@solidjs/web 2.0.0-beta.3 → 2.0.0-beta.30

package/server-functions/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@solidjs/web/server-functions",
+  "main": "./dist/server.cjs",
+  "module": "./dist/server.js",
+  "types": "../types/server-functions/server.d.ts",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "browser": {
+        "import": {
+          "types": "../types/server-functions/client.d.ts",
+          "default": "./dist/client.js"
+        },
+        "require": {
+          "types": "../types-cjs/server-functions/client.d.cts",
+          "default": "./dist/client.cjs"
+        }
+      },
+      "import": {
+        "types": "../types/server-functions/server.d.ts",
+        "default": "./dist/server.js"
+      },
+      "require": {
+        "types": "../types-cjs/server-functions/server.d.cts",
+        "default": "./dist/server.cjs"
+      }
+    }
+  }
+}

package/storage/package.json

@@ -7,9 +7,14 @@
   "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./types/index.d.ts",
-      "import": "./dist/storage.js",
-      "require": "./dist/storage.cjs"
+      "import": {
+        "types": "./types/index.d.ts",
+        "default": "./dist/storage.js"
+      },
+      "require": {
+        "types": "./types-cjs/index.d.cts",
+        "default": "./dist/storage.cjs"
+      }
     }
   }
 }

package/storage/types/index.d.ts

@@ -1,2 +1,28 @@
 import type { RequestEvent } from "@solidjs/web";
+/**
+ * Establishes the request-event scope for a server request: everything
+ * `cb` runs (across `await`s, via AsyncLocalStorage) sees `init` from
+ * `getRequestEvent()`. Call it at the top of the server's request handling,
+ * wrapping SSR and server-function dispatch; the server-functions runtime
+ * also picks the scope up automatically as its default event provider.
+ *
+ * Lives on its own subpath because it imports `node:async_hooks` — keep it
+ * out of environments without that module.
+ *
+ * @example
+ * ```ts
+ * import { provideRequestEvent } from "@solidjs/web/storage";
+ *
+ * async function handler(request: Request) {
+ *   return provideRequestEvent({ request, locals: {} }, () =>
+ *     renderToStringAsync(() => <App />)
+ *   );
+ * }
+ * ```
+ *
+ * @param init the event for this request — frameworks pass their richer
+ * event shapes
+ * @param cb runs synchronously; its return value is passed through
+ * @throws on the client, where there is no request to scope
+ */
 export declare function provideRequestEvent<T extends RequestEvent, U>(init: T, cb: () => U): U;

package/storage/types-cjs/index.d.cts

@@ -0,0 +1,28 @@
+import type { RequestEvent } from "@solidjs/web";
+/**
+ * Establishes the request-event scope for a server request: everything
+ * `cb` runs (across `await`s, via AsyncLocalStorage) sees `init` from
+ * `getRequestEvent()`. Call it at the top of the server's request handling,
+ * wrapping SSR and server-function dispatch; the server-functions runtime
+ * also picks the scope up automatically as its default event provider.
+ *
+ * Lives on its own subpath because it imports `node:async_hooks` — keep it
+ * out of environments without that module.
+ *
+ * @example
+ * ```ts
+ * import { provideRequestEvent } from "@solidjs/web/storage";
+ *
+ * async function handler(request: Request) {
+ *   return provideRequestEvent({ request, locals: {} }, () =>
+ *     renderToStringAsync(() => <App />)
+ *   );
+ * }
+ * ```
+ *
+ * @param init the event for this request — frameworks pass their richer
+ * event shapes
+ * @param cb runs synchronously; its return value is passed through
+ * @throws on the client, where there is no request to scope
+ */
+export declare function provideRequestEvent<T extends RequestEvent, U>(init: T, cb: () => U): U;

package/storage/types-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/types/client.d.ts

@@ -1,10 +1,13 @@
 import { JSX } from "./jsx.js";
-export const Properties: Set<string>;
+export const DOMWithState: Record<string, Record<string, 1 | 2>>;
 export const ChildProperties: Set<string>;
 export const DelegatedEvents: Set<string>;
 export const DOMElements: Set<string>;
 export const SVGElements: Set<string>;
-export const SVGNamespace: Record<string, string>;
+export const MathMLElements: Set<string>;
+export const VoidElements: Set<string>;
+export const RawTextElements: Set<string>;
+export const Namespaces: Record<string, string>;
 
 type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;
 export function render(
@@ -13,42 +16,86 @@ export function render(
   init?: JSX.Element,
   options?: { owner?: unknown }
 ): () => void;
-export function template(html: string, isImportNode?: boolean, isSVG?: boolean, isMathML?: boolean): () => Element;
-export function effect<T>(fn: (prev?: T) => T, effect: (value: T, prev?: T) => void, init?: T): void;
+/**
+ * @param flag
+ * - `undefined` — clone the template as-is (uses `cloneNode`).
+ * - `1` — use `document.importNode` instead of `cloneNode`.
+ * - `2` — the template html is wrapped; the outer tag is stripped at clone time.
+ */
+export function template(html: string, flag?: 1 | 2): () => Element;
+export function scope<T extends () => any>(fn: T): T;
+export function effect<T>(fn: (prev?: T) => T, effect: (value: T, prev?: T) => void): void;
 export function memo<T>(fn: () => T, equal: boolean): () => T;
 export function untrack<T>(fn: () => T): T;
 export function insert<T>(
   parent: MountableElement,
   accessor: (() => T) | T,
   marker?: Node | null,
-  init?: JSX.Element
+  init?: JSX.Element,
+  options?: {
+    /**
+     * Live accessor for the slot's logical host in the source tree (portals).
+     * Each top-level node the slot manages is tagged with a `_$host` getter
+     * backed by this accessor so delegated events retarget correctly.
+     */
+    host?: () => Node | null;
+    /** Defer the insert effect to the queue instead of running it inline. */
+    schedule?: boolean;
+  }
 ): JSX.Element;
 export function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
-export function delegateEvents(eventNames: string[], d?: Document): void;
-export function clearDelegatedEvents(d?: Document): void;
-export function spread<T>(
-  node: Element,
-  accessor: T,
-  isSVG?: Boolean,
-  skipChildren?: Boolean
+export function delegateEvents(eventNames: string[]): void;
+export function registerDelegatedRoot(root: MountableElement): void;
+export function unregisterDelegatedRoot(root: MountableElement): void;
+export function registerDelegatedContainer(
+  container: MountableElement,
+  owner?: MountableElement
 ): void;
+export function unregisterDelegatedContainer(
+  container: MountableElement,
+  owner?: MountableElement
+): void;
+export function getDelegatedRoot(node: MountableElement): MountableElement | undefined;
+export function spread<T>(node: Element, accessor: T, skipChildren?: Boolean): void;
 export function assign(
   node: Element,
   props: any,
-  isSVG?: Boolean,
   skipChildren?: Boolean,
   prevProps?: any,
   skipRef?: Boolean
 ): void;
 export function setAttribute(node: Element, name: string, value: string): void;
 export function setAttributeNS(node: Element, namespace: string, name: string, value: string): void;
-type ClassList =
-  | Record<string, boolean>
-  | Array<string | number | boolean | null | undefined | Record<string, boolean>>;
-export function className(node: Element, value: string | ClassList, isSvg?: boolean, prev?: string | ClassList): void;
+/**
+ * Register a consumer for compiler-emitted element claims. Compiled DOM
+ * output claims navigation-relevant elements (`a[href]`, `form[action]`) at
+ * creation, and compiler-owned writes to `href`/`action` re-invoke the same
+ * handlers — so handlers must be idempotent and must check the element's
+ * relevance themselves (rechecks can fire for any element whose
+ * `href`/`action` is written, e.g. `<link href>`). Handlers run under the
+ * reactive owner current at element creation; scope per-element state and
+ * cleanup through your own reactive system. Dormant until registered —
+ * without a handler the emitted claims are null checks. Returns an
+ * unregister function.
+ */
+export function registerElementClaim(handler: (element: Element) => void): () => void;
+/**
+ * Claim `node` for registered consumers (see `registerElementClaim`).
+ * Emitted by the compiler at element creation; idempotent by contract.
+ */
+export function claimElement<T extends Element>(node: T): T;
+/**
+ * Sweep-claim every navigation-relevant element (`a[href]`, `form[action]`)
+ * in `root` — the subtree equivalent of the per-element `claimElement`
+ * compiled output emits, for content that becomes live DOM without compiled
+ * creation code (frame streams, adopted SSR ranges). Dormant without a
+ * registered consumer.
+ */
+export function claimElementTree<T extends Node>(root: T): T;
+export function className(node: Element, value: JSX.ClassValue, prev?: JSX.ClassValue): void;
 export function setProperty(node: Element, name: string, value: any): void;
 export function setStyleProperty(node: Element, name: string, value: any): void;
-export function addEventListener(
+export function addEvent(
   node: Element,
   name: string,
   handler: EventListener | EventListenerObject | (EventListenerObject & AddEventListenerOptions),
@@ -62,8 +109,14 @@ export function style(
 export function getOwner(): unknown;
 export function mergeProps(...sources: unknown[]): unknown;
 export function dynamicProperty(props: unknown, key: string): unknown;
-export function applyRef(r: ((element: Element) => void) | ((element: Element) => void)[], element: Element): void;
-export function ref(fn: () => ((element: Element) => void) | ((element: Element) => void)[], element: Element): void;
+export function applyRef<T extends Element = Element>(
+  r: ((element: NoInfer<T>) => void) | ((element: NoInfer<T>) => void)[],
+  element: T
+): void;
+export function ref(
+  fn: () => ((element: Element) => void) | ((element: Element) => void)[],
+  element: Element
+): void;
 
 export function hydrate(
   fn: () => JSX.Element,
@@ -74,11 +127,62 @@ export function getHydrationKey(): string | undefined;
 export function getNextElement(template?: () => Element): Element;
 export function getNextMatch(start: Node, elementName: string): Element;
 export function getNextMarker(start: Node): [Node, Array<Node>];
+/** @deprecated Use `useHead` — removed before `0.50.0` stable. */
 export function useAssets(fn: () => JSX.Element): void;
+/** @deprecated Use `useHead` — removed before `0.50.0` stable. */
 export function getAssets(): string;
+/**
+ * A head tag descriptor. Props values may be getters (reactive on the
+ * client); `children` is the text body. `key` overrides the built-in dedupe
+ * identity (`title` is a hard singleton that `key` cannot fork).
+ */
+export type HeadTag = {
+  tag: "title" | "meta" | "link" | "style" | "script" | "base";
+  props: Record<string, any>;
+  key?: string | (() => string);
+};
+/**
+ * Registers head tags with the ambient head registry under the current
+ * owner. An array is a group — one replacement set. Resolution is
+ * last-committed group per identity; disposal restores the previous winner.
+ * During hydration the server-flushed head state stays authoritative until
+ * hydration completes. See docs/head-management-rfc.md.
+ */
+export function useHead(tag: HeadTag | HeadTag[]): void;
+export type AssetDescriptor =
+  | { type: "style"; href: string; attrs?: Record<string, string> }
+  | { type: "inline-style"; id: string; content?: string; attrs?: Record<string, string> }
+  | { type: "module"; href: string }
+  | ExclusiveAssetDescriptor<any>;
+export interface ExclusiveAssetDescriptor<T> {
+  policy: "exclusive";
+  key: string;
+  value: T;
+  get(): T;
+  set(value: T): void;
+}
+export function acquireAsset(descriptor: AssetDescriptor): () => void;
 export function HydrationScript(props?: { nonce?: string; eventNames?: string[] }): JSX.Element;
-export function generateHydrationScript(options?: { nonce?: string; eventNames?: string[] }): string;
+export function generateHydrationScript(options?: {
+  nonce?: string;
+  eventNames?: string[];
+}): string;
 export function Assets(props: { children?: JSX.Element }): JSX.Element;
+/**
+ * See the server entry's `ResponseStub` — the shape of the mutable response
+ * head integrations expose as `event.response` via module augmentation.
+ */
+export interface ResponseStub {
+  status?: number;
+  statusText?: string;
+  headers: Headers;
+  /**
+   * Set by the integration once the response head has been derived/sent
+   * from this stub (status/headers can no longer change); consumers must
+   * treat later writes and cleanup-time retractions as no-ops.
+   */
+  committed?: boolean;
+}
 export interface RequestEvent {
   request: Request;
   locals: Record<string | number | symbol, any>;

package/types/core.d.ts

@@ -1,3 +1,4 @@
-export { getOwner, runWithOwner, createComponent, createRoot as root, sharedConfig, untrack, merge as mergeProps, flatten, ssrHandleError, ssrRunInScope } from "solid-js";
-export declare const effect: (fn: any, effectFn: any, initial: any) => void;
-export declare const memo: (fn: any, transparent: any) => any;
+export { getOwner, runWithOwner, createComponent, createRoot as root, sharedConfig, untrack, merge as mergeProps, flatten, ssrHandleError, ssrScope, NoHydration, Hydration, runInServerComponentScope } from "solid-js";
+export declare const effect: (fn: any, effectFn: any, options: any) => void;
+export declare const memo: (fn: any) => import("solid-js").SourceAccessor<any>;
+export declare const runWithHydrationScope: (id: any, fn: any) => unknown;

package/types/frames/client.d.ts

@@ -0,0 +1,20 @@
+export { createFrame, createFrameHost, createFrameElement, FRAME_APPLIED_EVENT } from "./frame-client.js";
+export { FRAME_STREAM_HEADER, applyFrameResponse, isFrameStreamResponse, createServerComponentHandler } from "./frame-transport.js";
+export { createJSONDataTable } from "./serializer.js";
+export type { Slot } from "./server.js";
+export declare function getFrameHost(): any;
+/**
+ * Installs the server-component transport policy on the server-function
+ * client: boundary identity is the call's intrinsic (function, arguments)
+ * address — per-args, exactly like the query cache, so a cached component
+ * always mounts the boundary showing the call it was cached for. Repeat
+ * calls for the same args resolve the identical component (refetches morph
+ * in place, cache hits pass `dynamic`'s equals-gate); a source switching
+ * args swaps boundaries, re-materialized instantly from the host's
+ * retained state.
+ *
+ * Call once in the client entry (an explicit call — the package is
+ * `sideEffects: false`, so a bare import would be tree-shaken away);
+ * call again to rebind to a custom host.
+ */
+export declare function installServerComponents(host?: any): void;

package/types/frames/frame-client.d.ts

@@ -0,0 +1,270 @@
+/**
+ * Client frame runtime — the consumer side of a frame stream. A frame
+ * renders server-owned content into a DOM boundary from a resident keyed
+ * record store: chunks are writes, not events, so application is
+ * prerequisite-driven and order-independent. Client-owned slot ranges
+ * inside the boundary are preserved across server updates — the
+ * version is a stale-guard only ("policy A"): newer content morphs in
+ * place, and teardown is `dispose()`, never a version bump.
+ */
+
+/** One transport chunk of a frame stream, addressed by frame `id`. */
+export type FrameChunk =
+  | { type: "start"; id: string; version: number }
+  | { type: "html"; id: string; version: number; html: string }
+  | { type: "fragment"; id: string; version: number; key: string; html: string }
+  | {
+      type: "reveal";
+      id: string;
+      version: number;
+      keys: string[];
+      waitForStyles?: boolean;
+      fallback?: boolean;
+    }
+  | {
+      type: "data";
+      id: string;
+      version: number;
+      key?: string;
+      node?: unknown;
+      initial?: boolean;
+      /** Eval-style hydration script — only when produced with the hydration serializer. */
+      payload?: string;
+    }
+  | {
+      type: "assets";
+      id: string;
+      version: number;
+      key: string;
+      modules?: string[];
+      styles?: string[];
+      inlineStyles?: { id: string; content?: string; attrs?: Record<string, string> }[];
+    }
+  | { type: "slot"; id: string; version: number; key: string; args: Record<string, unknown> }
+  | { type: "complete"; id: string; version: number }
+  | { type: "error"; id: string; version: number; key?: string; error: unknown };
+
+/**
+ * Maps a wire chunk onto resident-store record writes. `data` chunks map to
+ * no records — they are response-scoped and the host applies them through
+ * its data hook.
+ */
+export function chunkToRecords(chunk: FrameChunk): Record<string, unknown>;
+
+/**
+ * One store write applied to a frame: `r` maps record keys to values
+ * (`chunkToRecords` produces these from wire chunks) and `version` is the
+ * stream stamp — an older version than the frame's current one is ignored.
+ */
+export interface FrameWrite {
+  version: number;
+  r: Record<string, unknown>;
+}
+
+/** Context passed to a slot callback. */
+export interface SlotContext {
+  /**
+   * True only for the hydration-attach invocation of an adopted
+   * document-SSR range — the one call a consumer may answer with a claim
+   * (`existing` IS the server-rendered output for these args). Unset on
+   * stream-driven re-calls: those must render for real, or content the
+   * re-call displaced (e.g. `{$frame}` region ranges) is dropped.
+   */
+  adopted?: boolean;
+  /**
+   * Whether this occurrence is a render-prop CALL (the producer placed it
+   * with arguments — possibly empty — via a slot record) as opposed to a
+   * direct-insert position. Consumers cannot tell from the resolved props
+   * alone: an argless render prop and a direct insert both arrive as `{}`,
+   * but one is a function to invoke and the other a value to place.
+   */
+  invoked?: boolean;
+  /**
+   * Register cleanup for when this occurrence's range is removed from the
+   * server content, or the owning frame is disposed.
+   */
+  onCleanup(fn: () => void): void;
+  /**
+   * Live-props opt-in: a binding that registers here receives the
+   * re-resolved props when a re-sent record's args CHANGE in value, instead
+   * of the occurrence being re-called — the invocation's instance (and its
+   * client state) survives the change. Register synchronously during the
+   * invocation; one updater per occurrence (last registration wins). A
+   * genuine re-call or unmount clears it before/with the binding it served.
+   */
+  onUpdate(fn: (props: Record<string, unknown>) => void): void;
+  /**
+   * The range's current interior — server-rendered client content on an
+   * adopted document-SSR boot, or the previous output on a re-call. A
+   * framework binding hydrates onto it and returns `undefined` to claim it
+   * in place (zero DOM mutation).
+   */
+  existing: ChildNode[];
+  /**
+   * The range's own marker comments, when the occurrence has a placed range.
+   * A framework binding whose slot content is reactive at the top level (a
+   * boundary accessor, changing route children) owns the interior instead of
+   * returning nodes: bind before `end` with the framework's insert primitive
+   * and return `undefined` — the frame leaves the range alone (server morphs
+   * already protect slot ranges).
+   */
+  range?: { start: Comment; end: Comment };
+}
+
+/**
+ * Client content for a server-declared slot. Direct-insert occurrences
+ * call it with empty props; render-prop occurrences pass the occurrence's
+ * resolved args (primitives literal, `{$ref}` data resolved through the
+ * host, `{$frame}` regions as marker-range fragments). Return nodes to fill
+ * the range, or `undefined` to claim `ctx.existing` untouched.
+ */
+export type Slot = (props: Record<string, unknown>, ctx: SlotContext) => Node | Node[] | undefined;
+
+export interface Frame {
+  /** Merge a write into the store and flush (morph/reveal/slot sync). */
+  apply(write: FrameWrite): void;
+  /** The active version, or undefined before the first apply. */
+  readonly version: number | undefined;
+  /** Read-only view of the resident record store. */
+  readonly store: Readonly<Record<string, unknown>>;
+  /** The stream's error record, if an `error` chunk arrived. */
+  readonly error: unknown;
+  /** Whether the named fragment has been revealed into the boundary. */
+  isRevealed(segment: string): boolean;
+  /**
+   * Re-key this live frame to a different boundary id (the mount-preserving
+   * half of a call-site handoff): nothing tears down — the element, store,
+   * and slot state stay — while leaving the old id stashes a retention
+   * snapshot under it and joining the new id seeds/drains its retained
+   * store and buffered chunks. Version affinity resets: histories are per
+   * boundary id.
+   */
+  rebind(id: string): void;
+  /**
+   * Forget the version baseline without touching content — the next write
+   * is accepted whatever its number. Called by the host after seeding a
+   * registration from a retained snapshot, whose numbering belongs to a
+   * different stream space.
+   */
+  rebase(): void;
+  /** Tear down: slot cleanups cascade, later chunks are ignored. Idempotent. */
+  dispose(): void;
+}
+
+/**
+ * Routes a flat stream of addressed chunks to frames by id, buffering chunks
+ * for frames that have not registered yet (only the newest version's chunks
+ * are kept). `data` chunks are response-scoped and go to `applyData`.
+ *
+ * An id may have several frames (the same server component mounted more
+ * than once): chunks fan out to all of them, and a frame registering after
+ * delivery is seeded from a sibling's store.
+ */
+export interface FrameHost {
+  register(id: string, frame: Frame): void;
+  /** Remove one frame (or all frames of the id when `frame` is omitted). */
+  unregister(id: string, frame?: Frame): void;
+  apply(chunk: FrameChunk): void;
+  /** The first registered frame under the id, if any. */
+  get(id: string): Frame | undefined;
+  serialize(value: unknown): { $ref: string };
+  /** `frameId` is the resolving frame's id — route to its stream's table. */
+  resolve(ref: { $ref: string }, frameId?: string): unknown;
+}
+
+/**
+ * The bubbling DOM event (`"frame:applied"`) a frame dispatches from its
+ * parent element whenever server content lands in the document — root
+ * materialize/morph, segment reveal, fallback materialization — with
+ * `detail: { id, version, reason }`. One document-level listener sees every
+ * boundary (nested region frames dispatch too); use it to re-apply
+ * client-owned decorations on server-owned markup (router affordance
+ * reflection, e.g. `aria-current`) without a MutationObserver.
+ */
+export const FRAME_APPLIED_EVENT: "frame:applied";
+
+/** Options for `createFrameHost`. */
+export interface FrameHostOptions {
+  /**
+   * Backs `{$ref}` slot args (typically a codec data table's `resolve`).
+   * `frameId` identifies the resolving frame — data tables are
+   * response-scoped, so multi-stream hosts route by it (nested region ids
+   * prefix-match their root).
+   */
+  resolve?(ref: { $ref: string }, frameId?: string): unknown;
+  /** Test/host-side counterpart of `resolve`. */
+  serialize?(value: unknown): { $ref: string };
+  /**
+   * Receives each `data` chunk whole. Wire a codec table:
+   * `applyData: c => table.apply(c)` (see `createJSONDataTable`).
+   */
+  applyData?(chunk: Extract<FrameChunk, { type: "data" }>): void;
+}
+
+export function createFrameHost(options?: FrameHostOptions): FrameHost;
+
+/** Options for `createFrame` / `createFrameElement`. */
+export interface FrameOptions {
+  /** Register with this host under `id`, receiving routed/buffered chunks. */
+  host?: FrameHost;
+  id?: string;
+  /** Client content keyed by prop name (occurrences resolve by prop). */
+  slots?: Record<string, Slot>;
+  /**
+   * Adopt existing server-rendered DOM: the first apply morphs against it,
+   * and slots sync immediately (hydration attach) — a document-SSR boot
+   * needs no chunk.
+   */
+  adopt?: boolean;
+  /** Called after each apply flush (tests/telemetry). */
+  onApply?(info: { version: number; reason: "materialize" | "morph" | "reveal" }): void;
+  /**
+   * Wraps element-claim sweeps (`a[href]`/`form[action]` in materialized
+   * server content — and only those) so claim consumers register their
+   * per-element cleanup against the boundary's reactive owner, e.g.
+   * `fn => runWithOwner(owner, fn)`. Nested region frames inherit it.
+   * Without it, sweeps run under whatever owner is current (none, for
+   * streamed chunks).
+   */
+  ownerScope?<T>(fn: () => T): T;
+  /**
+   * Boundary-driven segment reveal. When present, `#revealSegment` hands the
+   * placeholder seam to this hook instead of swapping imperatively: the binding
+   * reconstructs a client `<Loading>` there — `fallback` is the placeholder's
+   * own template content (shown while holding), `content()` materializes the
+   * segment and renders its client fills INSIDE the boundary so their readiness
+   * gates the reveal — and inserts it before `before`. An unboundaried async
+   * fill suspends up to that boundary and is covered instead of orphaned; one
+   * boundary per revealed segment, i.e. per author-placed `<Loading>`. Omit it
+   * for the framework-agnostic imperative swap (no reactive reveal).
+   */
+  reveal?(seam: { before: Node; fallback: Node[]; content: () => Node | DocumentFragment }): void;
+}
+
+/**
+ * A frame rendering into an EXISTING element boundary. Pass `adopt: true` for
+ * the document-SSR path: the element already holds server-rendered content,
+ * so the first apply morphs against it and slots sync immediately (hydration
+ * attach), claiming their server-rendered DOM — a document boot needs no
+ * chunk.
+ */
+export function createFrame(boundary: Element, options?: FrameOptions): Frame;
+
+/** The default boundary/region element tag and its id attribute — the DOM
+ *  contract the producer emits at t=0 and the consumer creates/adopts. */
+export const FRAME_TAG: "dx-frame";
+export const FRAME_ID_ATTR: "data-fid";
+
+/**
+ * Create a boundary/region ELEMENT and bind a host-registered frame to it.
+ * The frame mounts INTO the element (server content is its children, morphed
+ * in place). Because the boundary is a real node, `insert` places the
+ * returned `element` in any position — single, array, or fragment — with no
+ * special-casing. One frame per element; lifecycle belongs to the creator via
+ * `dispose()` (register it with your owner's cleanup).
+ */
+export function createFrameElement(options: FrameOptions): {
+  readonly element: Element;
+  readonly frame: Frame;
+  dispose(): void;
+};