API Reference

Build an OpenElement application through the supported adapter boundary.

Build the headExtras string from FrameworkOptions.inject.

One loaded collection entry: slug, validated frontmatter and rendered HTML.

Declarative definition of one frontmatter field (type, required, default).

Primitive frontmatter field types supported by content collections.

Configuration of one content collection (directory, base path, schema).

Declarative fields keep generated modules typed. `transform` covers values derived from filenames (for example a site's locale suffix) without making that convention part of the framework.

Context handed to a collection schema's `transform` hook.

The slug/frontmatter result a collection schema `transform` returns.

Create the Vite plugin that loads one content collection into a generated data module.

Low-level Vite plugin pipeline: SSR dev server, SSG and islands without the content/i18n conveniences of `openElement()`.

Generate sitemap.xml and optionally robots.txt from dist/ output.

Result of building head extras from FrameworkOptions.

Load a content collection from disk: parse frontmatter, validate the schema and render Markdown.

Vite plugin compiling `.mdx` route files into compiled page modules.

Create the full OpenElement Vite plugin set: pipeline, content collections, nav, i18n and sitemap.

Blog options stored in the adapter build context.

Minimal build-context contract available to adapter sub-plugins.

One header navigation link (href + label) in the generated site nav.

Locale options carried through the build context to the i18n integration.

Navigation section produced by the adapter content pipeline.

Options for the openElement() unified Vite entry.

Options for the `.mdx` route plugin ({@linkcode mdxPlugin}).

Low-level Vite plugin pipeline: SSR dev server, SSG and islands without the content/i18n conveniences of `openElement()`.

Options for the low-level {@linkcode openPipeline} Vite plugin pipeline.

Serialize loaded collection entries into the generated typed data module source.

Mounts an OpenElement request handler on a Nitro v3 route. Near pass-through: the event's standard `req` goes in, the handler's Response comes out — h3 v2 serves a returned Response as-is.

Minimal Nitro v3 route event shape (#857). Nitro v3 is fetch-native: its h3 v2 event carries `req`, a srvx ServerRequest that already IS a standard Request, so the pre-v3 method/path/headers/body translation layer is gone. The mount only wires the OpenElement runtime context around the standard Request → Response seam.

Options for mounting an OpenElement request handler under a Nitro/Node server.

Generate sitemap.xml and optionally robots.txt from dist/ output.

Sitemap module configuration

Route action: handles form submissions for a page route.

Request header selecting the action response channel (ADR-0121, amends ADR-0120): `true` marks a programmatic caller and selects the serialized ActionResult union; `enhance` marks the built-in morph enhancement and selects the same full-HTML responses the no-JS path receives.

Context passed to a route action function (extends loader context).

Wire shape returned to the JavaScript form-enhancement path (0.42.0-alpha.2, ADR-0120). The no-JS path never sees this: it gets the equivalent semantics as plain HTTP (303 on success, 422 with the re-rendered form on validation failure, redirect/error as status codes).

Build the canonical OpenElement request context from a platform request event.

Inputs for building an {@linkcode OpenElementRequestContext} from a platform request event.

Define a client-side SPA application: route table, router mode and mount/dispose lifecycle.

Validate and register an island delivery descriptor; returns the normalized config.

Attach a page descriptor to a compiled page element class.

Return a structured action failure with an HTTP status and typed data payload.

Type guard for {@linkcode OpenElementActionFailure}, including its duck-typed cross-realm shape.

Per-island delivery configuration (SSR/DSD participation and hydration strategy).

Delivery strategy for an island: a hydration trigger or media-gated loading.

Type guard for {@linkcode OpenElementNotFound}, including its duck-typed cross-realm shape.

Type guard for {@linkcode OpenElementRedirect}, including its duck-typed cross-realm shape.

Route loader: fetches data for a page route.

Context passed to a request-time ('dynamic') route loader.

Throw an {@linkcode OpenElementNotFound} to render the 404 path.

Expected-failure channel for actions (0.42.0-alpha.2, ADR-0120): validation failures RETURN `fail(status, data)` — never throw — so the server can answer 422 with the form re-rendered and the submitted values echoed back. Thrown values keep the exception channel (redirect/notFound/error page).

Not-found signal thrown from a loader to render the route's 404 path.

The page descriptor the pipeline reads (`module.default.openElementPage`). Attached to the compiled page class by definePage(); the class owns the render program, so the descriptor carries metadata and projectors only.

Redirect signal thrown from a loader/action to short-circuit rendering with an HTTP redirect.

Host-agnostic request context shared by App request adapters.

A compiled element class carrying the page descriptor static.

Maps a caught render/loader/action failure onto the error variant of the page's compiled properties. Its presence declares that the page's compiled markup carries an error variant (the generated entry renders the page with these props and status 500 — the POST/GET error-boundary channel of ADR-0121 §7); without it the generic status page answers.

The request-scoped context handed to a page's props projector. Everything a compiled page can render must pass through here: the compiled render() only reads `this.<property>`, so the projector is the single deterministic seam that maps loader data, action data, params and request onto the page's compiled properties (v0.44, ADR-0143).

Maps the request-scoped context onto the page's compiled properties. Declared as part of the page descriptor; the generated server entry and the SPA bootstrap call it per render and feed the result to renderDsd() props (server) or pre-connect property sets (SPA).

Media type of the RFC 9457 action error channel (#863).

RFC 9457 Problem Details document (0.42.0-alpha.13, #863, ADR-0123 addendum item 13): the action error channel answers `application/problem+json` instead of the bespoke `{ type: 'error', error: { message } }` JSON, so HTTP tooling recognizes failures natively. With `type: 'about:blank'`, `title` is the HTTP reason phrase and `detail` carries the specific explanation. The wire shape is alpha-unfrozen; ADR-0122 acceptance freezes it in this problem+json form.

Throw an {@linkcode OpenElementRedirect} for `location` (status must be a real 3xx).

Canonical request-time/SSG server route context.

Context passed to a request-time ('dynamic') route loader. This is the server contract: the loader runs on the server with the Web-standard request, matched route params, the host environment and the platform object, and signals validation failure via fail()/redirect() (ADR-0120).

SPA route action: client-side submit handler; signal failure by throwing.

Context passed to an SPA-mode route action (client-side).

A mounted SPA: idempotent mount/dispose plus the client-side router instance.

SPA route loader: client-side data fetch receiving route params only.

Context passed to an SPA-mode route loader (#570). The SPA chain runs client-side and supplies only the matched route params — no request, env or platform — and signals failure by throwing (a throw is normalized to action data by the SPA submit handler). These semantics are frozen under ADR-0119; this type names the existing narrowing without changing any runtime behavior.

Build the canonical OpenElement request context from a platform request event.

Inputs for building an {@linkcode OpenElementRequestContext} from a platform request event.

Host-agnostic request context shared by App request adapters.

Define a Preact component as a custom-element island with attribute-to-props bridging.

A Preact island constructor plus its server-render seam.

Options for {@linkcode definePreactIsland} (base props, SSR participation).

Define a client-side SPA application: route table, router mode and mount/dispose lifecycle.

A mounted SPA: idempotent mount/dispose plus the client-side router instance.

Route action: handles form submissions for a page route.

Request header selecting the action response channel (ADR-0121, amends ADR-0120): `true` marks a programmatic caller and selects the serialized ActionResult union; `enhance` marks the built-in morph enhancement and selects the same full-HTML responses the no-JS path receives.

Context passed to a route action function (extends loader context).

Wire shape returned to the JavaScript form-enhancement path (0.42.0-alpha.2, ADR-0120). The no-JS path never sees this: it gets the equivalent semantics as plain HTTP (303 on success, 422 with the re-rendered form on validation failure, redirect/error as status codes).

Create a derived read-only signal recomputed from its dependencies.

Consumer-local reactive projection of a protocol context value.

A typed context token: protocol identity (`key`) plus its default value.

Create a typed context token shared between provider and consumer elements.

Object prototype keys that must never be injected from untrusted props.

Run a side effect that re-subscribes whenever its signal dependencies change.

Compiler-recognized element decorator; inert no-op at runtime.

Error message prefix for all openElement errors.

Base class for elements that catch descendant render/hydration errors and apply a retry policy.

Callback receiving every reported {@linkcode OpenElementError} for telemetry.

Escape an HTML attribute value.

Escape the five HTML-significant characters in text content.

Runtime list of supported hydration strategies; the single source of truth for the `HydrationStrategy` union. Consumed by island/registry validation and re-exported from the element root for app and build adapters.

Island hydration trigger: 'load' | 'idle' | 'visible' | 'only'.

Safely assign caller-supplied props onto a target object, skipping keys that could enable prototype pollution and tolerating read-only properties.

Shared dangerous-key predicate (#903, #1214). Prototype-internal keys must never be injected from untrusted props on ANY path: host prop collection (collectPublicProps / normalizePublicProps in props-utils.ts), guarded assignment (injectPropsSafe below — the SPA bootstrap page-projection write boundary in

Per-island delivery options (hydration strategy, SSR/DSD participation).

Shared safe-attribute-name predicate (#1033). Attribute *names* are not escaped on any render path, so a name must be a valid HTML attribute name (blocks quote/space injection, #602) and must not be an event handler (`on*`, case-insensitive). render-ir.ts (silent skip) and adapter-vite head-injection.ts (throw) enforce the same rule with different failure strategies; both delegate here so the boundary cannot diverge.

Route loader: fetches data for a page route.

Context passed to a request-time ('dynamic') route loader.

Locale-aware resolved path contract.

Fetch middleware contract (ADR-0123 item 2, #858): WinterCG shape, dialect-free — no Hono/h3 context object. Composed at the handler boundary in onion order (`use[0]` is outermost: it sees the request first and the response last), so it runs with identical semantics in the dev server, the `start` CLI, the e2e fixture server, and the Nitro production entry.

Custom Element base class for the compiled Part Program architecture.

One documented attribute of a custom element declaration.

One documented CSS part of a custom element declaration.

One custom element declaration in a package manifest: tag, members and delivery metadata.

Framework error carrying a stable code, severity, phase and recoverability contract.

One documented custom event of a custom element declaration.

Package manifest of component declarations (not CEM-compatible; see packages/ui README).

Host-agnostic route and asset contracts shared by app and build drivers.

One documented slot of a custom element declaration.

Media type of the RFC 9457 action error channel (#863).

RFC 9457 Problem Details document (0.42.0-alpha.13, #863, ADR-0123 addendum item 13): the action error channel answers `application/problem+json` instead of the bespoke `{ type: 'error', error: { message } }` JSON, so HTTP tooling recognizes failures natively. With `type: 'about:blank'`, `title` is the HTTP reason phrase and `detail` carries the specific explanation. The wire shape is alpha-unfrozen; ADR-0122 acceptance freezes it in this problem+json form.

Compiler-recognized property decorator; inert no-op at runtime.

Provide a plain protocol value; the provider Signal remains OE-private.

Recoverable render-phase error carrying the failing component path and tag.

Report an {@linkcode OpenElementError} to the telemetry hook, or console.error when none is installed.

Canonical request-time/SSG server route context.

Context passed to a request-time ('dynamic') route loader. This is the server contract: the loader runs on the server with the Web-standard request, matched route params, the host environment and the platform object, and signals validation failure via fail()/redirect() (ADR-0120).

Install the process-wide error telemetry hook (replaceable for tests/HMR/multi-app pages).

Create a writable signal through the selected signal engine.

Alias for APIs that accept either writable or read-only signals.

SPA route action: client-side submit handler; signal failure by throwing.

Context passed to an SPA-mode route action (client-side).

SPA route loader: client-side data fetch receiving route params only.

Context passed to an SPA-mode route loader (#570). The SPA chain runs client-side and supplies only the matched route params — no request, env or platform — and signals failure by throwing (a throw is normalized to action data by the SPA submit handler). These semantics are frozen under ADR-0119; this type names the existing narrowing without changing any runtime behavior.

Cross-realm StyleSheet constructor: the native CSSStyleSheet or the internal shim.

Minimal stylesheet contract (replaceSync + cssRules) satisfied by native and shim sheets.

Mark an HTML string as trusted for explicit `innerHTML` sinks (the trust does not serialize).

Opaque capability marking HTML the application has explicitly vetted as trusted.

Typechecking-only fragment marker; fails closed when executed at runtime.

JSX type interface consumed by TypeScript's automatic JSX transform.

Typechecking-only factory; fails closed when executed at runtime.

Typechecking-only fragment marker; fails closed when executed at runtime.

Typechecking-only factory; fails closed when executed at runtime.

JSX type interface consumed by TypeScript's automatic JSX transform.

Typechecking-only factory; fails closed when executed at runtime.

URL scheme policy (ADR-0126): reject anything that could become an executable scheme after browser-side parsing.

Sanitize untrusted HTML against the allow-list (ADR-0126).

Per-tag attribute allow-list; '*' applies to every tag.

The build-time generated package manifest (declarations for every UI component).

Compact status badge backed by Open Props semantic tokens.

Minimal button component following Swiss International Style.

Callout/notice box for inline documentation alerts.

Minimal card container with optional header and footer.

Code block with copy button AND syntax highlighting via Prism.

Dialog component using native <dialog> element + popover API.

Popover-API dropdown with CSS Anchor Positioning placement.

Minimal input field following Swiss International Style.

Pre-built stylesheet exposing the Open Props tokens on `:root` (document-level adoption).

Pre-built stylesheet carrying the full Open Props token set (adopt into a shadow root).

WAI-ARIA tabs pattern. The slotted [slot="tab"] and [slot="panel"] elements

Theme toggle Reactive DSD component for Dark/Light mode switching.

Explicitly register every first-party UI element. Safe to call repeatedly.

Compact status badge backed by Open Props semantic tokens.

Minimal button component following Swiss International Style.

Callout/notice box for inline documentation alerts.

Minimal card container with optional header and footer.

Code block with copy button AND syntax highlighting via Prism.

Dialog component using native <dialog> element + popover API.

Popover-API dropdown with CSS Anchor Positioning placement.

Minimal input field following Swiss International Style.

Pre-built stylesheet exposing the Open Props tokens on `:root` (document-level adoption).

Pre-built stylesheet carrying the full Open Props token set (adopt into a shadow root).

WAI-ARIA tabs pattern. The slotted [slot="tab"] and [slot="panel"] elements

Theme toggle Reactive DSD component for Dark/Light mode switching.