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

package/types/server.d.ts

@@ -79,19 +79,6 @@ export function renderToString<T>(
     onHead?: (head: string) => void;
   }
 ): string;
-/** @deprecated use renderToStream which also returns a promise */
-export function renderToStringAsync<T>(
-  fn: () => T,
-  options?: {
-    timeoutMs?: number;
-    nonce?: string;
-    renderId?: string;
-    noScripts?: boolean;
-    plugins?: SerializerPlugin[];
-    manifest?: AssetManifest | AssetResolver | AssetResolverFn;
-    onError?: (err: any) => void;
-  }
-): Promise<string>;
 export function renderToStream<T>(
   fn: () => T,
   options?: {
@@ -116,7 +103,17 @@ export function renderToStream<T>(
     onHead?: (head: string) => void;
   }
 ): {
-  then: (fn: (html: string) => void) => void;
+  /**
+   * Awaiting the stream resolves with the complete HTML once every boundary
+   * settles — the fully-settled-string form of the render (`const html =
+   * await renderToStream(...)`). Render errors route through `onError` and
+   * the promise resolves with whatever HTML the render produced; it never
+   * rejects.
+   */
+  then<TResult1 = string, TResult2 = never>(
+    onfulfilled?: ((html: string) => TResult1 | PromiseLike<TResult1>) | null,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
+  ): Promise<TResult1 | TResult2>;
   pipe: (writable: { write: (v: string) => void; end: () => void }) => void;
   pipeTo: (writable: WritableStream) => Promise<void>;
   /**
@@ -153,21 +150,20 @@ export function applyRef(
   r: ((element: any) => void) | ((element: any) => void)[],
   element: any
 ): void;
-/** @deprecated Use `useHead` — removed before `0.50.0` stable. */
-export function useAssets(fn: () => JSX.Element): void;
-/**
- * @deprecated Use the `onHead` render option — removed before `0.50.0`
- * stable. Reads ambient render state, so it is unsafe across concurrent
- * renders; `onHead` is closure-bound to its render and also carries
- * `useHead` output, which this does not.
- */
-export function getAssets(): string;
 /**
  * A head tag descriptor. Props values may be getters (evaluated lazily on
  * the server — at the owning flush boundary — and reactively on the client);
  * `children` is the text body (title text, inline style/script content).
  * `key` overrides the built-in dedupe identity (`title` is a hard singleton
  * that `key` cannot fork).
+ *
+ * Getters must be plain reads: they evaluate at flush time here (under no
+ * component owner) and inside registry-owned computations on the client, so
+ * a getter that allocates a reactive owner (`createMemo`, a `children()`
+ * helper) consumes a hydration id slot on one side only and desyncs every
+ * id allocated after the `useHead` call. Create such helpers eagerly at
+ * component position and read them from the getter. See
+ * docs/head-management-rfc.md.
  */
 export type HeadTag = {
   tag: "title" | "meta" | "link" | "style" | "script" | "base";
@@ -212,32 +208,62 @@ export declare const RequestContext: unique symbol;
  * `response` property on `RequestEvent` itself: integrations that provide
  * one declare it through module augmentation (as `@solidjs/router` does),
  * and this type names the shape they agree on. Core's server-function
- * handler reads its `Set-Cookie` headers when folding single-flight
- * cookies but never requires it.
+ * handler folds it onto the outgoing response when present — its
+ * `Set-Cookie` values (cookies appended during the call via
+ * `serializeCookie`) append cookie-by-cookie, other headers fill gaps —
+ * and reads it when folding single-flight cookies, but never requires it.
  */
 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 and headers can no longer change. Consumers
-   * that write response metadata during render (e.g. JSX response
-   * components) must treat later status/header writes and cleanup-time
-   * retractions as no-ops.
+   * Set once the response head has been derived/sent from this stub —
+   * status and headers can no longer change. Flip it through
+   * `commitResponseStub`, which also instruments the stub's `headers` so
+   * a post-commit write fails loudly (dev build throws, production
+   * reports + no-ops) instead of silently missing the wire. `status`/
+   * `statusText` stay plain fields: consumers that write response
+   * metadata during render (e.g. JSX response components) must still
+   * treat later status writes and cleanup-time retractions as no-ops.
    */
   committed?: boolean;
 }
 
+/**
+ * The type of `RequestEvent.locals` — a module-augmentable interface so
+ * applications can type the state their middleware hangs on the event.
+ * Augment it through the package that re-exports the event (interface
+ * identity flows through the re-export chain):
+ *
+ * ```ts
+ * declare module "@solidjs/web" {
+ *   interface RequestEventLocals {
+ *     user: User;
+ *   }
+ * }
+ * ```
+ *
+ * The index signature keeps un-augmented usage permissive — `locals` is a
+ * free-form bag by default — so augmentation adds precision for the keys
+ * it names without gating existing code. The flip side: unaugmented keys
+ * read as `any` rather than erroring, a deliberate trade (a strict-only
+ * `locals` would break every untyped write that works today).
+ */
+export interface RequestEventLocals {
+  [key: string | number | symbol]: any;
+}
+
 /**
  * The per-request context available on the server: the incoming `Request`
- * and a `locals` bag integrations and middleware can hang state on.
- * Frameworks typically extend this shape with richer fields (e.g. a
- * `response` head — see `ResponseStub`).
+ * and a `locals` bag integrations and middleware can hang state on (typed
+ * through the augmentable `RequestEventLocals`). Frameworks typically
+ * extend this shape with richer fields (e.g. a `response` head — see
+ * `ResponseStub`).
  */
 export interface RequestEvent {
   request: Request;
-  locals: Record<string | number | symbol, any>;
+  locals: RequestEventLocals;
 }
 /**
  * The current request event, when called on the server inside a request
@@ -247,7 +273,129 @@ export interface RequestEvent {
  */
 export function getRequestEvent(): RequestEvent | undefined;
 
-export function Assets(props: { children?: JSX.Element }): JSX.Element;
+/** A fresh, uncommitted response head. */
+export function createResponseStub(): ResponseStub;
+
+/**
+ * The canonical request event for HTTP handlers: the incoming `Request`, a
+ * `locals` bag, and a `response` head stub the render writes to. `init`
+ * spreads over the defaults so frameworks can extend the shape.
+ */
+export function createRequestEvent<T extends object = {}>(
+  request: Request,
+  init?: T
+): RequestEvent & { response: ResponseStub } & T;
+
+/**
+ * The status an outgoing redirect should use for a response head carrying
+ * a `Location`: the stub's own status when it is a redirect status, 302
+ * otherwise.
+ */
+export function getExpectedRedirectStatus(response: ResponseStub): number;
+
+/**
+ * Flips a response stub to `committed` — the moment its head freezes on
+ * the wire — and instruments the stub's `headers` mutating methods
+ * (`set`/`append`/`delete`, patched in place; the `Headers` identity and
+ * reads are untouched) so a post-commit write fails loudly instead of
+ * silently missing the wire: it throws in the dev build and reports +
+ * no-ops otherwise. Every head materialization path commits through here
+ * (`createSSRResponse`, the server-function handler's commit seam);
+ * integrations deriving their own heads should too.
+ *
+ * `allowLateLocation` is the stream path's documented exception: a
+ * `Location` set after the shell flushed is still honored client-side
+ * (stream completion appends a `window.location` script), so that one
+ * write stays permitted there.
+ */
+export function commitResponseStub(
+  stub: ResponseStub,
+  options?: { allowLateLocation?: boolean }
+): ResponseStub;
+
+/**
+ * Handler-lifecycle plumbing — a response's exit through the request
+ * event's response-stub lifecycle: page results leave through
+ * `createSSRResponse`, any other `Response` (a middleware early return, an
+ * API result) leaves through `commitEventResponse`; application middleware
+ * never calls this. Folds the event's stub onto the outgoing response —
+ * `Set-Cookie` appends entry-by-entry alongside the response's own, other
+ * stub headers fill gaps only (never the wire-protocol family the handlers
+ * own, never `Content-Type`/`Content-Length` on a bodiless response), the
+ * status is never taken from the stub — then commits the stub
+ * (`commitResponseStub`: post-commit writes fail loudly). Responses with
+ * immutable headers are rebuilt around merged copies.
+ *
+ * Idempotent at handler edges: an already-committed stub passes the
+ * response through untouched, so a handler may apply this unconditionally
+ * after its middleware chain unwinds — page responses from
+ * `createSSRResponse` come back committed and do not double-fold.
+ *
+ * `event` defaults to the ambient `getRequestEvent()`.
+ */
+export function commitEventResponse(response: Response, event?: RequestEvent): Response;
+
+/**
+ * The cookie codec (the platform-gap primitives — see cookies.d.ts): ALL
+ * of core's cookie surface. The blessed patterns are
+ * `parseCookieHeader(event.request.headers.get("cookie"))` for reads and
+ * `event.response.headers.append("set-cookie", serializeCookie(name,
+ * value, options))` for writes.
+ */
+export { parseCookieHeader, serializeCookie } from "./cookies.js";
+export type { CookieOptions } from "./cookies.js";
+
+export interface SSRResponseOptions {
+  /** Base head; the stub's status/headers win over it. */
+  responseInit?: ResponseInit;
+  /** Nonce carried by the post-flush `<script>` redirect fallback. */
+  nonce?: string;
+  /** Rewrites each outgoing HTML chunk (entry script injection, ...). */
+  transformChunk?: (chunk: string) => string;
+}
+
+/**
+ * Derives the outgoing `Response` for an SSR render result, running the
+ * response-head lifecycle against `event.response`: commit at shell flush,
+ * pre-flush `Location` becomes a real redirect, post-flush `Location`
+ * appends a client-side script redirect before the stream closes.
+ * Synchronous for string results; resolves at shell flush for stream
+ * results.
+ */
+export function createSSRResponse(
+  result: string,
+  event: RequestEvent | undefined,
+  options?: SSRResponseOptions
+): Response;
+export function createSSRResponse(
+  result: { pipe(writable: { write: (v: string) => void; end: () => void }): void },
+  event: RequestEvent | undefined,
+  options?: SSRResponseOptions
+): Promise<Response>;
+
+/**
+ * Fetch-style middleware: return a `Response` to answer the request, or
+ * call `next()` (optionally with a substitute `Request`) to advance the
+ * chain and observe/replace the eventual response.
+ */
+export type FetchMiddleware = (
+  request: Request,
+  next: (request?: Request) => Promise<Response>
+) => Response | Promise<Response>;
+
+/**
+ * Composes fetch-style middleware into one function of the same shape;
+ * the terminal `next` dispatches to the actual handler. Runs in whatever
+ * scope the caller established (`provideRequestEvent`), so
+ * `getRequestEvent()` works exactly as in application code.
+ */
+export function composeMiddleware(
+  middlewares: FetchMiddleware[]
+): (
+  request: Request,
+  next: (request?: Request) => Response | Promise<Response>
+) => Promise<Response>;
+
 export function untrack<T>(fn: () => T): T;
 
 // client-only APIs
@@ -347,5 +495,9 @@ export function ref(
 ): void;
 /** @deprecated not supported on the server side */
 export function setStyleProperty(node: Element, name: string, value: any): void;
-/** @deprecated not supported on the server side — register assets through the render context instead */
+/**
+ * @internal See client.d.ts — head-management RFC policy: ambient CSS is
+ * unmanaged; the head registry owns directly-mounted stylesheet lifecycle.
+ * @deprecated not supported on the server side — register assets through the render context instead
+ */
 export function acquireAsset(descriptor: unknown): () => void;

package/types-cjs/client.d.cts

@@ -1,12 +1,24 @@
 import { JSX } from "./jsx.cjs";
+import type { RequestEventLocals } from "./server.cjs";
+// Element/property classification tables consumed by the JSX compiler and
+// custom renderers. Compiler/tooling surface; not for hand-written code.
+/** Compiler/tooling table; not for hand-written code. @internal */
 export const DOMWithState: Record<string, Record<string, 1 | 2>>;
+/** Compiler/tooling table; not for hand-written code. @internal */
 export const ChildProperties: Set<string>;
+/** Compiler/tooling table; not for hand-written code. @internal */
 export const DelegatedEvents: Set<string>;
+/** Compiler/tooling table; not for hand-written code. @internal */
 export const DOMElements: Set<string>;
+/** Compiler/tooling table; not for hand-written code. @internal */
 export const SVGElements: Set<string>;
+/** Compiler/tooling table; not for hand-written code. @internal */
 export const MathMLElements: Set<string>;
+/** Compiler/tooling table; not for hand-written code. @internal */
 export const VoidElements: Set<string>;
+/** Compiler/tooling table; not for hand-written code. @internal */
 export const RawTextElements: Set<string>;
+/** Compiler/tooling table; not for hand-written code. @internal */
 export const Namespaces: Record<string, string>;
 
 type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;
@@ -17,16 +29,30 @@ export function render(
   options?: { owner?: unknown }
 ): () => void;
 /**
+ * Compiler-emitted primitive; not for hand-written code.
  * @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.
+ * @internal
  */
 export function template(html: string, flag?: 1 | 2): () => Element;
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export function scope<T extends () => any>(fn: T): T;
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export function effect<T>(fn: (prev?: T) => T, effect: (value: T, prev?: T) => void): void;
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export function memo<T>(fn: () => T, equal: boolean): () => T;
+/**
+ * Compiler-emitted primitive; not for hand-written code — import `untrack`
+ * from `solid-js` instead.
+ * @internal
+ */
 export function untrack<T>(fn: () => T): T;
+/**
+ * Compiler-emitted primitive; not for hand-written code.
+ * @internal
+ */
 export function insert<T>(
   parent: MountableElement,
   accessor: (() => T) | T,
@@ -43,20 +69,29 @@ export function insert<T>(
     schedule?: boolean;
   }
 ): JSX.Element;
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export function delegateEvents(eventNames: string[]): void;
+/** Event-delegation plumbing (Portal/custom-root wiring). Integration plumbing. @internal */
 export function registerDelegatedRoot(root: MountableElement): void;
+/** Event-delegation plumbing (Portal/custom-root wiring). Integration plumbing. @internal */
 export function unregisterDelegatedRoot(root: MountableElement): void;
+/** Event-delegation plumbing (Portal/custom-root wiring). Integration plumbing. @internal */
 export function registerDelegatedContainer(
   container: MountableElement,
   owner?: MountableElement
 ): void;
+/** Event-delegation plumbing (Portal/custom-root wiring). Integration plumbing. @internal */
 export function unregisterDelegatedContainer(
   container: MountableElement,
   owner?: MountableElement
 ): void;
+/** Event-delegation plumbing (Portal/custom-root wiring). Integration plumbing. @internal */
 export function getDelegatedRoot(node: MountableElement): MountableElement | undefined;
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export function spread<T>(node: Element, accessor: T, skipChildren?: Boolean): void;
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export function assign(
   node: Element,
   props: any,
@@ -64,7 +99,9 @@ export function assign(
   prevProps?: any,
   skipRef?: Boolean
 ): void;
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export function setAttribute(node: Element, name: string, value: string): void;
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export function setAttributeNS(node: Element, namespace: string, name: string, value: string): void;
 /**
  * Register a consumer for compiler-emitted element claims. Compiled DOM
@@ -77,11 +114,16 @@ export function setAttributeNS(node: Element, namespace: string, name: string, v
  * cleanup through your own reactive system. Dormant until registered —
  * without a handler the emitted claims are null checks. Returns an
  * unregister function.
+ *
+ * Integration plumbing (routers register the consumer); not meant for
+ * application code.
+ * @internal
  */
 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.
+ * @internal
  */
 export function claimElement<T extends Element>(node: T): T;
 /**
@@ -90,29 +132,50 @@ export function claimElement<T extends Element>(node: T): T;
  * compiled output emits, for content that becomes live DOM without compiled
  * creation code (frame streams, adopted SSR ranges). Dormant without a
  * registered consumer.
+ *
+ * Integration plumbing; not meant for application code.
+ * @internal
  */
 export function claimElementTree<T extends Node>(root: T): T;
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export function className(node: Element, value: JSX.ClassValue, prev?: JSX.ClassValue): void;
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export function setProperty(node: Element, name: string, value: any): void;
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export function setStyleProperty(node: Element, name: string, value: any): void;
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export function addEvent(
   node: Element,
   name: string,
   handler: EventListener | EventListenerObject | (EventListenerObject & AddEventListenerOptions),
   delegate: boolean
 ): void;
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export function style(
   node: Element,
   value: { [k: string]: string },
   prev?: { [k: string]: string }
 ): void;
+/**
+ * Compiler-emitted primitive; not for hand-written code — import `getOwner`
+ * from `solid-js` instead.
+ * @internal
+ */
 export function getOwner(): unknown;
+/**
+ * Compiler-emitted prop-spread helper; not for hand-written code — import
+ * `merge` from `solid-js` instead.
+ * @internal
+ */
 export function mergeProps(...sources: unknown[]): unknown;
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export function dynamicProperty(props: unknown, key: string): unknown;
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export function applyRef<T extends Element = Element>(
   r: ((element: NoInfer<T>) => void) | ((element: NoInfer<T>) => void)[],
   element: T
 ): void;
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export function ref(
   fn: () => ((element: Element) => void) | ((element: Element) => void)[],
   element: Element
@@ -123,18 +186,25 @@ export function hydrate(
   node: MountableElement,
   options?: { renderId?: string; owner?: unknown }
 ): () => void;
+/** Hydration-walk primitive; not for hand-written code. @internal */
 export function getHydrationKey(): string | undefined;
+/** Hydration-walk primitive; not for hand-written code. @internal */
 export function getNextElement(template?: () => Element): Element;
+/** Hydration-walk primitive; not for hand-written code. @internal */
 export function getNextMatch(start: Node, elementName: string): Element;
+/** Hydration-walk primitive; not for hand-written code. @internal */
 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).
+ *
+ * Getters must be plain reads: they evaluate inside registry-owned
+ * computations here and at flush time on the server, so a getter that
+ * allocates a reactive owner (`createMemo`, a `children()` helper) consumes
+ * a hydration id slot on one side only and desyncs every id allocated after
+ * the `useHead` call. Create such helpers eagerly at component position and
+ * read them from the getter. See docs/head-management-rfc.md.
  */
 export type HeadTag = {
   tag: "title" | "meta" | "link" | "style" | "script" | "base";
@@ -163,13 +233,41 @@ export interface ExclusiveAssetDescriptor<T> {
   get(): T;
   set(value: T): void;
 }
+/**
+ * @internal Ref-counted client asset ownership: acquire adopts or mounts the
+ * asset, the returned release follows the owner (with a grace period for
+ * back-and-forth navigation). Internal machinery, not a public CSS-lifecycle
+ * API — per the head-management RFC (docs/head-management-rfc.md), ambient
+ * bundler-injected CSS is never lifecycle-managed, and the head registry
+ * owns the lifecycle of directly-mounted stylesheets outright. This keeps
+ * its non-head roles (exclusive slots, owner-following DOM ownership).
+ */
 export function acquireAsset(descriptor: AssetDescriptor): () => void;
+/**
+ * Registry entry returned by `warmAsset`. Stylesheet entries carry load
+ * tracking for the client reveal gate (docs/client-css-reveal-gating.md):
+ * `loadPromise` resolves on load OR error (never rejects) — an errored
+ * sheet releases the gate, parity with the server gate.
+ */
+export interface AssetEntry {
+  loadState?: "pending" | "loaded" | "errored";
+  loadPromise?: Promise<void>;
+}
+/**
+ * @internal Warm half of `acquireAsset`: idempotent and refcount-free,
+ * callable from a compute phase so the fetch starts at discovery and
+ * overlaps a transition's data wait. Stylesheets warm as
+ * `rel="preload" as="style"` and are flipped live by `acquireAsset` at
+ * commit — a branch superseded before it commits leaks only an inert
+ * preload, never an applied sheet. Only link-backed descriptors warm;
+ * inline styles and exclusive slots return `undefined`.
+ */
+export function warmAsset(descriptor: AssetDescriptor): AssetEntry | undefined;
 export function HydrationScript(props?: { nonce?: string; eventNames?: string[] }): JSX.Element;
 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.
@@ -185,10 +283,33 @@ export interface ResponseStub {
    */
   committed?: boolean;
 }
+/**
+ * See the server entry's `RequestEventLocals` — the augmentable type of
+ * `RequestEvent.locals`. Re-exported (not re-declared) so both entries
+ * share ONE interface identity and a single augmentation reaches every
+ * `locals`, whichever entry typed the event.
+ */
+export type { RequestEventLocals } from "./server.cjs";
 export interface RequestEvent {
   request: Request;
-  locals: Record<string | number | symbol, any>;
+  locals: RequestEventLocals;
 }
+/**
+ * Registered symbol (`Symbol.for("solid.RequestContext")`) naming the global
+ * slot where `provideRequestEvent` parks the AsyncLocalStorage scoping
+ * request events. Integration plumbing — read the event through
+ * `getRequestEvent()` instead.
+ * @internal
+ */
 export declare const RequestContext: unique symbol;
 export function getRequestEvent(): RequestEvent | undefined;
+/**
+ * The cookie codec (the platform-gap primitives — see cookies.d.ts for the
+ * blessed patterns): the real implementation on both entries, never a
+ * stub — a pure value transformer has legitimate browser uses
+ * (`document.cookie`). Tree-shakes away when unused.
+ */
+export { parseCookieHeader, serializeCookie } from "./cookies.cjs";
+export type { CookieOptions } from "./cookies.cjs";
+/** Hydration-walk primitive; not for hand-written code. @internal */
 export function runHydrationEvents(): void;

package/types-cjs/core.d.cts

@@ -1,4 +1,6 @@
 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 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;
+export declare const ssrAsyncValue: (value: any) => import("solid-js").SourceAccessor<any>;
+export declare const waitAsset: (promise: any) => void;

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

@@ -1,7 +1,20 @@
 export { createFrame, createFrameHost, createFrameElement, FRAME_APPLIED_EVENT } from "./frame-client.cjs";
 export { FRAME_STREAM_HEADER, applyFrameResponse, isFrameStreamResponse, createServerComponentHandler } from "./frame-transport.cjs";
-export { createJSONDataTable } from "./serializer.cjs";
 export type { Slot } from "./server.cjs";
+/**
+ * Client-condition twin of the server face's `asyncArg` (DR-2 value tier):
+ * the identity that types an async value crossing the slot border as its
+ * settled value. Server component modules are authored in universal code and
+ * may resolve under the browser condition at typecheck/bundle time — the
+ * call never runs here (the `"use server"` body executes server-side), but
+ * the symbol must exist.
+ */
+export declare function asyncArg<T>(value: PromiseLike<T> | AsyncIterable<T>): T;
+/**
+ * The app-wide shared frame host (created lazily): one chunk router with
+ * per-response codec data tables.
+ * @experimental
+ */
 export declare function getFrameHost(): any;
 /**
  * Installs the server-component transport policy on the server-function
@@ -18,5 +31,6 @@ export declare function getFrameHost(): any;
  * 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.
+ * @experimental
  */
 export declare function installServerComponents(host?: any): void;