@solidjs/web 2.0.0-beta.31 → 2.0.0-beta.32

package/types-cjs/frames/frame-client.d.cts

@@ -6,9 +6,17 @@
  * 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.
+ *
+ * EXPERIMENTAL — the frames/server-components surface ships as an
+ * experimental preview, excluded from the 2.0 stability guarantee: API
+ * shapes and the wire format may change between prereleases (RFC 11).
+ * Every export in this module is `@experimental`.
  */
 
-/** One transport chunk of a frame stream, addressed by frame `id`. */
+/**
+ * One transport chunk of a frame stream, addressed by frame `id`.
+ * @experimental
+ */
 export type FrameChunk =
   | { type: "start"; id: string; version: number }
   | { type: "html"; id: string; version: number; html: string }
@@ -48,6 +56,7 @@ export type FrameChunk =
  * 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.
+ * @experimental
  */
 export function chunkToRecords(chunk: FrameChunk): Record<string, unknown>;
 
@@ -55,13 +64,17 @@ 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.
+ * @experimental
  */
 export interface FrameWrite {
   version: number;
   r: Record<string, unknown>;
 }
 
-/** Context passed to a slot callback. */
+/**
+ * Context passed to a slot callback.
+ * @experimental
+ */
 export interface SlotContext {
   /**
    * True only for the hydration-attach invocation of an adopted
@@ -117,9 +130,11 @@ export interface SlotContext {
  * 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.
+ * @experimental
  */
 export type Slot = (props: Record<string, unknown>, ctx: SlotContext) => Node | Node[] | undefined;
 
+/** @experimental */
 export interface Frame {
   /** Merge a write into the store and flush (morph/reveal/slot sync). */
   apply(write: FrameWrite): void;
@@ -159,6 +174,7 @@ export interface Frame {
  * 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.
+ * @experimental
  */
 export interface FrameHost {
   register(id: string, frame: Frame): void;
@@ -180,10 +196,14 @@ export interface FrameHost {
  * 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.
+ * @experimental
  */
 export const FRAME_APPLIED_EVENT: "frame:applied";
 
-/** Options for `createFrameHost`. */
+/**
+ * Options for `createFrameHost`.
+ * @experimental
+ */
 export interface FrameHostOptions {
   /**
    * Backs `{$ref}` slot args (typically a codec data table's `resolve`).
@@ -201,9 +221,13 @@ export interface FrameHostOptions {
   applyData?(chunk: Extract<FrameChunk, { type: "data" }>): void;
 }
 
+/** @experimental */
 export function createFrameHost(options?: FrameHostOptions): FrameHost;
 
-/** Options for `createFrame` / `createFrameElement`. */
+/**
+ * Options for `createFrame` / `createFrameElement`.
+ * @experimental
+ */
 export interface FrameOptions {
   /** Register with this host under `id`, receiving routed/buffered chunks. */
   host?: FrameHost;
@@ -217,7 +241,7 @@ export interface FrameOptions {
    */
   adopt?: boolean;
   /** Called after each apply flush (tests/telemetry). */
-  onApply?(info: { version: number; reason: "materialize" | "morph" | "reveal" }): void;
+  onApply?(info: { version: number; reason: "materialize" | "morph" | "reveal" | "error" }): void;
   /**
    * Wraps element-claim sweeps (`a[href]`/`form[action]` in materialized
    * server content — and only those) so claim consumers register their
@@ -259,12 +283,17 @@ export interface FrameOptions {
  * so the first apply morphs against it and slots sync immediately (hydration
  * attach), claiming their server-rendered DOM — a document boot needs no
  * chunk.
+ * @experimental
  */
 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. */
+/**
+ * The default boundary/region element tag and its id attribute — the DOM
+ * contract the producer emits at t=0 and the consumer creates/adopts.
+ * @experimental
+ */
 export const FRAME_TAG: "dx-frame";
+/** @experimental */
 export const FRAME_ID_ATTR: "data-fid";
 
 /**
@@ -274,6 +303,7 @@ export const FRAME_ID_ATTR: "data-fid";
  * 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).
+ * @experimental
  */
 export function createFrameElement(options: FrameOptions): {
   readonly element: Element;

package/types-cjs/frames/frame-sink.d.cts

@@ -1,6 +1,13 @@
+// EXPERIMENTAL — the frames/server-components surface ships as an
+// experimental preview, excluded from the 2.0 stability guarantee: API
+// shapes and the wire format may change between prereleases (RFC 11).
+// Every export in this module is @experimental.
 import { FrameChunk } from "./frame-client.cjs";
 
-/** Addresses a frame stream: the boundary id and this response's version. */
+/**
+ * Addresses a frame stream: the boundary id and this response's version.
+ * @experimental
+ */
 export interface FrameAddress {
   id: string;
   version: number;
@@ -12,13 +19,17 @@ export interface FrameAddress {
  * method emits transport-agnostic chunks; `emit` is the envelope boundary.
  * @internal Compiler/renderer wiring — use `renderToFrameStream` or
  * `renderServerComponent` instead.
+ * @experimental
  */
 export function createFrameSink(
   emit: (chunk: FrameChunk) => void,
   frame: FrameAddress
 ): Record<string, (...args: any[]) => void>;
 
-/** Options shared by the frame producers. */
+/**
+ * Options shared by the frame producers.
+ * @experimental
+ */
 export interface FrameStreamOptions {
   /** Boundary address; defaults to `{ id: "", version: 1 }`. */
   frame?: { id?: string; version?: number };
@@ -26,7 +37,10 @@ export interface FrameStreamOptions {
   [key: string]: unknown;
 }
 
-/** A produced frame stream: pipe chunks, or await the collected array. */
+/**
+ * A produced frame stream: pipe chunks, or await the collected array.
+ * @experimental
+ */
 export interface FrameStream extends PromiseLike<FrameChunk[]> {
   pipe(writable: { write(chunk: FrameChunk): void; end?(): void }): void;
 }
@@ -37,6 +51,7 @@ export interface FrameStream extends PromiseLike<FrameChunk[]> {
  * by a chunk envelope (`start` up front, `complete` at stream end). Data
  * records default to the keyed JSON codec (decode with
  * `createJSONDataTable`).
+ * @experimental
  */
 export function renderToFrameStream(code: () => unknown, options?: FrameStreamOptions): FrameStream;
 
@@ -57,6 +72,7 @@ export function renderToFrameStream(code: () => unknown, options?: FrameStreamOp
  *
  * The props a *client* passes never reach the server — server inputs are the
  * function's arguments.
+ * @experimental
  */
 export function renderServerComponent(
   component: (props: Record<string, any>) => unknown,
@@ -70,6 +86,7 @@ export function renderServerComponent(
  * the live render context, so it must only be used during the frame's
  * render.
  * @internal Exposed for framework bindings composing their own producers.
+ * @experimental
  */
 export function createSlotProps(
   sink: ReturnType<typeof createFrameSink>,
@@ -82,6 +99,7 @@ export function createSlotProps(
  * the client and `X-Content-Raw` so the server-function handler forwards it
  * untouched. `init` (headers/status, e.g. from a `respond()` envelope)
  * merges in; the frame tags win on conflict.
+ * @experimental
  */
 export function serverComponentResponse(
   component: (props: Record<string, any>) => unknown,
@@ -103,6 +121,7 @@ export function serverComponentResponse(
  *   provideEvent
  * });
  * ```
+ * @experimental
  */
 export function frameTransformResult(event: unknown, result: unknown): unknown;
 
@@ -115,6 +134,7 @@ export function frameTransformResult(event: unknown, result: unknown): unknown;
  * positions (the one hydration-time exception), wrapped in the same marker
  * dialect the chunk producer emits so the adopting client binds slots and
  * regions onto the server-rendered ranges.
+ * @experimental
  */
 export function createDocumentSlotProps(
   clientProps: Record<string, unknown>,
@@ -128,6 +148,7 @@ export function createDocumentSlotProps(
  * as an inline-renderable server component (frame markers + document
  * slot props), branded with its function id and the call's wire address.
  * Non-function results pass through.
+ * @experimental
  */
 export function frameTransformDirectResult<T>(
   value: T,
@@ -143,6 +164,7 @@ export function frameTransformDirectResult<T>(
  * component entries serialized as flight references. Returns `undefined`
  * when nothing invalidated is markup (the response stays the plain
  * single-flight envelope).
+ * @experimental
  */
 export function frameTransformFlightResult(
   event: unknown,
@@ -167,5 +189,6 @@ export {
  * self-bootstraps the registry. Kept for integrations still installing it
  * document-wide; the client upgrades the registry via
  * `installServerComponents()`.
+ * @experimental
  */
 export const SERVER_COMPONENT_BOOTSTRAP: string;

package/types-cjs/frames/frame-transport.d.cts

@@ -1,3 +1,7 @@
+// EXPERIMENTAL — the frames/server-components surface ships as an
+// experimental preview, excluded from the 2.0 stability guarantee: API
+// shapes and the wire format may change between prereleases (RFC 11).
+// Every export in this module is @experimental.
 import { FrameChunk, FrameHost } from "./frame-client.cjs";
 import { JSONCodecOptions } from "./serializer.cjs";
 
@@ -11,13 +15,20 @@ type FlightConsumer = (data: unknown, context: { response: Response }) => void |
  * Header tagging a Response as a frame stream; its value is the producing
  * frame's id. Frame-owned wire contract — deliberately not a server-function
  * `BodyFormat` entry, since the body is frame chunks, not a serialized value.
+ * @experimental
  */
 export const FRAME_STREAM_HEADER: "X-Frame-Stream";
 
-/** Whether a fetch Response carries a frame stream. */
+/**
+ * Whether a fetch Response carries a frame stream.
+ * @experimental
+ */
 export function isFrameStreamResponse(response: Response): boolean;
 
-/** Options for `applyFrameResponse`. */
+/**
+ * Options for `applyFrameResponse`.
+ * @experimental
+ */
 export interface ApplyFrameResponseOptions {
   /**
    * Remap the producer's root frame id onto a local one — the id your
@@ -57,6 +68,7 @@ export interface ApplyFrameResponseOptions {
  *   await applyFrameResponse(response, host, { as: "story-pane" });
  * }
  * ```
+ * @experimental
  */
 export function applyFrameResponse(
   response: Response,
@@ -64,13 +76,22 @@ export function applyFrameResponse(
   options?: ApplyFrameResponseOptions
 ): Promise<string>;
 
-/** Brands an inline-rendered server component with its function id. */
+/**
+ * Brands an inline-rendered server component with its function id.
+ * @experimental
+ */
 export const SERVER_COMPONENT: unique symbol;
 
-/** The unwrapped server component behind an inline-render wrap. */
+/**
+ * The unwrapped server component behind an inline-render wrap.
+ * @experimental
+ */
 export const SERVER_COMPONENT_SOURCE: unique symbol;
 
-/** The call's wire address (`frameAddress`), for regions to be emitted under. */
+/**
+ * The call's wire address (`frameAddress`), for regions to be emitted under.
+ * @experimental
+ */
 export const SERVER_COMPONENT_ADDRESS: unique symbol;
 
 /**
@@ -81,10 +102,14 @@ export const SERVER_COMPONENT_ADDRESS: unique symbol;
  * instance, new binding" — keep the mounted instance and deliver the new
  * address into it; a different function swaps normally. `Symbol.for`, so
  * frameworks can honor it without importing this module.
+ * @experimental
  */
 export const COMPONENT_BINDING: unique symbol;
 
-/** The value under `COMPONENT_BINDING` on a transport-resolved binding. */
+/**
+ * The value under `COMPONENT_BINDING` on a transport-resolved binding.
+ * @experimental
+ */
 export interface ComponentBinding<C = unknown> {
   /** The per-function mount component (the equals-gate identity). */
   component: C;
@@ -98,6 +123,7 @@ export interface ComponentBinding<C = unknown> {
  * placeholder in the hydration serializer, a live-registry lookup by call
  * address in the JSON codec (single-flight envelopes) — its markup never
  * rides as data.
+ * @experimental
  */
 export const ServerComponentPlugin: unknown;
 
@@ -108,6 +134,7 @@ export const ServerComponentPlugin: unknown;
  * on a script's first reference, a bare read after). Loaded document-SSR
  * modules install this (see frame-sink); client bundles never carry the
  * bootstrap text.
+ * @experimental
  */
 export function setServerComponentBootstrap(resolve: (ctx: unknown) => string): void;
 
@@ -115,10 +142,14 @@ export function setServerComponentBootstrap(resolve: (ctx: unknown) => string):
  * The codec options for a single-flight envelope: `codec` plus
  * `ServerComponentPlugin` (deduped by tag). Injected by the protocol on both
  * legs; exported for integrations composing their own flight carriers.
+ * @experimental
  */
 export function flightCodec(codec?: JSONCodecOptions): JSONCodecOptions;
 
-/** Options for `createServerComponentHandler`. */
+/**
+ * Options for `createServerComponentHandler`.
+ * @experimental
+ */
 export interface ServerComponentHandlerOptions<C = unknown> {
   host: FrameHost;
   /**
@@ -170,6 +201,7 @@ export interface ServerComponentHandlerOptions<C = unknown> {
  * per-args entries — while mounts are per-SITE, rendering the per-function
  * component and following delivered addresses. An address nothing is bound
  * to warms its store (preload isolation is the default, not a rule).
+ * @experimental
  */
 export function createServerComponentHandler<C>(options: ServerComponentHandlerOptions<C>): {
   intercept?(info: { id: string; meta: unknown; args: unknown[] }): unknown;

package/types-cjs/frames/serializer.d.cts

@@ -1,23 +1,142 @@
-import { Plugin, Serializer, SerovalNode } from "seroval";
+// Serialization surface (published as `@solidjs/web/serialization`): the
+// runtime's Seroval machinery, exposed for the runtime's own entries and
+// for integrations building transports on the same codec. This is
+// INTEGRATION-FACING plumbing, not application API — it is exempt from the
+// 2.0 stability guarantee and may change between releases. Application and
+// router code should configure `codec` on the server-function entries
+// instead of importing from here.
+import { Serializer, SerovalNode } from "seroval";
 
 /**
  * Seroval's node shape — the intermediate representation `serializeJSON`
  * emits and `createJSONDeserializer` consumes. Safe to `JSON.stringify`.
+ *
+ * Integration-facing; may change (see the entry banner).
  */
 export type { SerovalNode };
 
+// ---- Plugin authoring ----
+//
+// Unlike the rest of this entry, plugin authoring is APPLICATION-FACING —
+// it is the supported way to feed the serializers' `plugins` options and
+// the server-function entries' `codec.plugins`. The values re-export
+// seroval's own (`createPlugin`, `OpaqueReference` — see serializer.js);
+// the TYPES are declared here by hand, like everything else in this file,
+// because seroval's published d.ts use extensionless ESM-relative imports
+// that `moduleResolution: "nodenext"` cannot follow — a bare type
+// re-export would silently degrade the whole authoring surface to `any`
+// under skipLibCheck. The declarations mirror seroval ~1.5 exactly; the
+// `~` pin is what makes mirroring safe.
+
+/** Per-plugin bookkeeping seroval hands each plugin callback. */
+export interface PluginData {
+  id: number;
+}
+
+/**
+ * The shape of a plugin's parsed payload: a map of `SerovalNode`s produced
+ * by the parse contexts, consumed by `serialize`/`deserialize`.
+ */
+export type PluginInfo = { [key: string]: SerovalNode };
+
+/** Parse context for `parse.sync`: turns child values into nodes. */
+export interface SyncParsePluginContext {
+  parse<T>(current: T): SerovalNode;
+}
+
+/** Parse context for `parse.async`: like sync, but child parses await. */
+export interface AsyncParsePluginContext {
+  parse<T>(current: T): Promise<SerovalNode>;
+}
+
+/**
+ * Parse context for `parse.stream`: sync parsing plus the streaming
+ * lifecycle (pending-state tracking, late node emission, cleanup).
+ */
+export interface StreamParsePluginContext {
+  parse<T>(current: T): SerovalNode;
+  parseWithError<T>(current: T): SerovalNode | undefined;
+  isAlive(): boolean;
+  pushPendingState(): void;
+  popPendingState(): void;
+  onParse(node: SerovalNode): void;
+  onError(error: unknown): void;
+  addCleanup(callback: () => void): void;
+}
+
+/** Serialize context: renders child nodes to JS source. */
+export interface SerializePluginContext {
+  serialize(node: SerovalNode): string;
+}
+
+/** Deserialize context: revives child nodes to runtime values. */
+export interface DeserializePluginContext {
+  deserialize<T>(node: SerovalNode): T;
+}
+
 /**
  * A Seroval plugin usable with the web serializers — teaches the codec how
- * to encode/decode a custom value type. Supply matching plugins on both
- * peers of a transport.
+ * to encode/decode a custom value type (`Value` is the value it matches,
+ * `Info` its parsed payload). Supply matching plugins on both peers of a
+ * transport. Bare `SerializerPlugin` (both parameters defaulted to `any`)
+ * is the list-element type every `plugins` option accepts.
+ *
+ * Integration-facing; may change (see the entry banner).
  */
-export type SerializerPlugin = Plugin<any, any>;
+export interface SerializerPlugin<Value = any, Info extends PluginInfo = any> {
+  /** A unique string identifying the plugin — namespace it (`"app/Thing"`). */
+  tag: string;
+  /** Dependency plugins, resolved ahead of this one. */
+  extends?: SerializerPlugin[];
+  /** Whether `value` is this plugin's to encode. */
+  test(value: unknown): boolean;
+  /** Parsing modes — provide the ones the transports you target use. */
+  parse: {
+    sync?: (value: Value, ctx: SyncParsePluginContext, data: PluginData) => Info;
+    async?: (value: Value, ctx: AsyncParsePluginContext, data: PluginData) => Promise<Info>;
+    stream?: (value: Value, ctx: StreamParsePluginContext, data: PluginData) => Info;
+  };
+  /** Renders the parsed payload as JS source (script-injection form). */
+  serialize(node: Info, ctx: SerializePluginContext, data: PluginData): string;
+  /** Revives the parsed payload back into the runtime value. */
+  deserialize(node: Info, ctx: DeserializePluginContext, data: PluginData): Value;
+}
+
+/**
+ * Builds a `SerializerPlugin` — seroval's `createPlugin`, re-exported so
+ * plugin authors stay on the exact seroval instance/version the runtime
+ * serializes with. Import it from HERE, not from your own `seroval`
+ * dependency: a plugin built against a different copy/version would not
+ * fail the build — it would emit nodes the other peer can't interpret.
+ *
+ * Application-facing (see the plugin-authoring banner above).
+ */
+export function createPlugin<Value, Info extends PluginInfo>(
+  plugin: SerializerPlugin<Value, Info>
+): SerializerPlugin<Value, Info>;
+
+/**
+ * Seroval's `OpaqueReference`, re-exported from the runtime's own instance
+ * (an `OpaqueReference` from another seroval copy fails the serializer's
+ * instanceof check and serializes as a plain value): wraps a value so it
+ * crosses the wire as its `replacement` (default `undefined`) while
+ * staying readable in-process through `.value`.
+ *
+ * Application-facing (see the plugin-authoring banner above).
+ */
+export class OpaqueReference<V, R = undefined> {
+  readonly value: V;
+  readonly replacement?: R;
+  constructor(value: V, replacement?: R);
+}
 
 /**
  * Baseline plugin set for serializing web-platform values (AbortSignal,
  * Event, FormData, Headers, ReadableStream, Request, Response, URL, ...).
  * Applied by every serializer in this module; custom plugins compose ahead
  * of it via `resolveSerializerPlugins`.
+ *
+ * Integration-facing; may change (see the entry banner).
  */
 export const DEFAULT_WEB_PLUGINS: readonly SerializerPlugin[];
 
@@ -26,10 +145,16 @@ export const DEFAULT_WEB_PLUGINS: readonly SerializerPlugin[];
  * first so they can shadow a default for values both would match. Returns a
  * fresh array; the defaults are never mutated. Useful when handing a full
  * plugin list to another serialization layer.
+ *
+ * Integration-facing; may change (see the entry banner).
  */
 export function resolveSerializerPlugins(customPlugins?: SerializerPlugin[]): SerializerPlugin[];
 
-/** Options for `createSerializer`. */
+/**
+ * Options for `createSerializer`.
+ *
+ * Integration-facing; may change (see the entry banner).
+ */
 export interface WebSerializerOptions {
   /** Name of the global object the emitted scripts write resolved values into. */
   globalIdentifier: string;
@@ -58,6 +183,8 @@ export interface WebSerializerOptions {
  * evaluated — the script-injection form of serialization renderers build
  * on. For a JSON-based wire codec (no eval on the receiving side), use
  * `serializeJSON` / `createJSONDeserializer` instead.
+ *
+ * Integration-facing; may change (see the entry banner).
  */
 export function createSerializer(options: WebSerializerOptions): Serializer;
 
@@ -96,6 +223,8 @@ export function getLocalHeaderScript(id?: string): string;
  * on the serializing and deserializing peer or payloads will not
  * round-trip — for server functions, set them once through the
  * client/server `codec` config option.
+ *
+ * Integration-facing; may change (see the entry banner).
  */
 export interface JSONCodecOptions {
   /** Extra plugins, composed ahead of `DEFAULT_WEB_PLUGINS`. Must match on both peers. */
@@ -113,7 +242,11 @@ export interface JSONCodecOptions {
   depthLimit?: number;
 }
 
-/** Options for `serializeJSON`. */
+/**
+ * Options for `serializeJSON`.
+ *
+ * Integration-facing; may change (see the entry banner).
+ */
 export interface JSONSerializeOptions extends JSONCodecOptions {
   /**
    * Receives each serialized node; `initial` is true for the first chunk
@@ -132,6 +265,8 @@ export interface JSONSerializeOptions extends JSONCodecOptions {
  * the deserializing peer needs no script evaluation, so CSP-safe). Wire
  * framing of the nodes is the transport's concern. Returns a cancel
  * function that aborts pending async serialization.
+ *
+ * Integration-facing; may change (see the entry banner).
  */
 export function serializeJSON(value: unknown, options: JSONSerializeOptions): () => void;
 
@@ -141,14 +276,46 @@ export function serializeJSON(value: unknown, options: JSONSerializeOptions): ()
  * from one stream must go through the same deserializer instance. The first
  * chunk's return value is the decoded source value; feeding later chunks
  * settles the async values referenced inside it.
+ *
+ * Integration-facing; may change (see the entry banner).
  */
 export function createJSONDeserializer(options?: JSONCodecOptions): <T>(node: SerovalNode) => T;
 
+/** Options for `createJSONSerializer`. */
+export interface JSONSerializerOptions extends JSONCodecOptions {
+  /**
+   * Receives each keyed record — `initial` is true for a key's first node
+   * (the written value itself); async values patch through later records
+   * under the same key. The decoding peer is `createJSONDataTable`.
+   */
+  onData: (record: { key: string; node: SerovalNode; initial: boolean }) => void;
+  onError?: (error: unknown) => void;
+  /** Fires once `flush()` has been called and every pending value settled. */
+  onDone?: () => void;
+}
+
+/**
+ * The keyed, streaming encoder of the eval-free JSON codec — the render
+ * stream's data serializer (frames default to it). Each `write(key, value)`
+ * shares one reference space, so cross-record identity holds; `flush()`
+ * marks the write set complete (writes after it are dropped, mirroring the
+ * hydration serializer); `close()` aborts pending async serialization.
+ */
+export function createJSONSerializer(options: JSONSerializerOptions): {
+  write(key: string, value: unknown): void;
+  flush(): void;
+  close(): void;
+};
+
 /**
  * A resident, response-scoped decode table over the keyed JSON codec: apply
  * each frame `data` chunk with `apply`, resolve `{ $ref }` slot args with
  * `resolve`. The frames client host wires one per response
  * (`applyData: c => table.apply(c)`).
+ *
+ * Integration-facing; may change (see the entry banner). This serialization
+ * entry is the single home of the data table — the frames client consumes
+ * it internally rather than re-exporting it.
  */
 export interface JSONDataTable {
   apply(chunk: { key?: string; node?: unknown; initial?: boolean }): void;

package/types-cjs/frames/server.d.cts

@@ -22,9 +22,31 @@ import type { Element as SolidElement } from "solid-js";
  * re-creates everything. It is occurrence identity, not client data: it is
  * stripped before the client component sees its props. Positional identity is
  * the right default; `$key` matters when a live list reorders.
+ * @experimental
  */
 export type Slot<P = {}> = (props: P & {
     $key?: string | number;
 }) => SolidElement;
+/**
+ * Types an async value crossing the slot border (DR-2, value tier). What you
+ * pass is what ships — the promise / async iterable itself rides the data
+ * channel — but the client's prop READ settles: it suspends into the covering
+ * boundary until first arrival (a promise's resolution, an iterable's first
+ * yield), then reads as the settled value, updating per yield for iterables.
+ *
+ * `asyncArg` is the type-level statement of that contract: identity at
+ * runtime, settled type at the border, so `Slot<P>` keeps the fill's props
+ * truthful to what its reads actually return.
+ *
+ * Slots render as JSX — the compiler wraps each prop in a getter so the read
+ * defers to the slot border, where the runtime owns it. A call form
+ * (`props.status({ … })`) evaluates its args eagerly in the component body —
+ * a top-level read, an error in most cases.
+ *
+ * ```tsx
+ * <props.status progress={asyncArg(gen.progress)} stats={asyncArg(gen.stats)} />
+ * ```
+ */
+export declare function asyncArg<T>(value: PromiseLike<T> | AsyncIterable<T>): T;
 export { renderToFrameStream, renderServerComponent, serverComponentResponse, frameTransformResult, frameTransformFlightResult, createFrameSink, frameTransformDirectResult, ServerComponentPlugin, SERVER_COMPONENT_BOOTSTRAP } from "./frame-sink.cjs";
 export { FRAME_STREAM_HEADER, isFrameStreamResponse } from "./frame-transport.cjs";

package/types-cjs/index.d.cts

@@ -96,9 +96,8 @@ export declare function render(code: () => JSX.Element, element: MountableElemen
  * and reactive bindings without reconstructing the DOM. Returns a `dispose`
  * function that tears down reactive scopes (DOM nodes are left in place).
  *
- * Use this when the page HTML was produced by `renderToString`,
- * `renderToStringAsync`, or `renderToStream`. For client-only apps, use
- * `render` instead.
+ * Use this when the page HTML was produced by `renderToString` or
+ * `renderToStream`. For client-only apps, use `render` instead.
  *
  * Pass `options.renderId` to hydrate one of multiple roots emitted by a
  * server render that used the same id.