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

package/types-cjs/cookies.d.cts

@@ -0,0 +1,93 @@
+// Cookie wire format: the platform-gap primitives, and ALL of core's
+// cookie surface — core owns the exchange (the request's headers in, the
+// response stub's headers out) and the codec, nothing ambient. Blessed
+// patterns:
+//
+//   parseCookieHeader(event.request.headers.get("cookie"))
+//   event.response.headers.append("set-cookie", serializeCookie(name, value, options))
+//
+// Dependency-free and isomorphic (exported from both entries — real
+// implementation, never a stub); integrity/confidentiality layers
+// (sessions) belong to the caller, on top of these primitives.
+
+/**
+ * Attributes for a `Set-Cookie` header, mirroring RFC 6265. `path`
+ * defaults to `/`; nothing else is defaulted.
+ */
+export interface CookieOptions {
+  /** Cookie `Path` attribute. Defaults to `/`. */
+  path?: string;
+  /** Cookie `Domain` attribute. Emitted only when provided. */
+  domain?: string;
+  /** Cookie `Max-Age` attribute, in seconds (truncated to an integer). */
+  maxAge?: number;
+  /** Cookie `Expires` attribute. */
+  expires?: Date;
+  /** Emit the `HttpOnly` attribute. */
+  httpOnly?: boolean;
+  /** Emit the `Secure` attribute. */
+  secure?: boolean;
+  /** Cookie `SameSite` attribute, any case. */
+  sameSite?: "lax" | "strict" | "none" | "Lax" | "Strict" | "None";
+}
+
+/**
+ * Parses a `Cookie` request header into a name → value map. Names and
+ * values are `decodeURIComponent`-decoded (falling back to the raw text
+ * when decoding throws); a quoted value keeps its content. `null`/empty
+ * input parses to an empty map.
+ *
+ * The read half of the platform gap — the blessed request-cookie read is
+ * `parseCookieHeader(event.request.headers.get("cookie"))`.
+ */
+export function parseCookieHeader(header: string | null | undefined): Record<string, string>;
+
+/**
+ * Serializes a cookie to a `Set-Cookie` header value. The name and value
+ * are `encodeURIComponent`-encoded (the parser decodes symmetrically);
+ * `path` defaults to `/` and every other attribute is emitted exactly
+ * when the caller asked for it.
+ *
+ * The write half of the platform gap — the blessed response-cookie write
+ * is `event.response.headers.append("set-cookie", serializeCookie(name,
+ * value, options))`, which every head materialization path carries to the
+ * wire entry-by-entry.
+ */
+export function serializeCookie(name: string, value: string, options?: CookieOptions): string;
+
+/**
+ * Name of the cookie carrying the outcome of a server function call made
+ * without the client runtime (`"flash"`). A no-JS form post has no way to
+ * receive a value — the browser follows the redirect and renders the next
+ * page — so the handler stashes the outcome here for the render after it
+ * to pick up, which is how a form submitted without JavaScript still shows
+ * its result.
+ *
+ * The name, detection and clearing are cookie utilities and isomorphic
+ * (integrations read the cookie from code that also ships to the browser);
+ * the codec that fills and decodes it is server-only and lives behind the
+ * server-functions server entry.
+ */
+export const FLASH_COOKIE: string;
+
+/**
+ * Whether a Cookie header carries a flash cookie, readable or not. Cheap
+ * enough to call on every render so the clear can be queued before the
+ * response headers flush.
+ */
+export function hasFlashCookie(cookieHeader: string | null): boolean;
+
+/**
+ * The `Set-Cookie` value clearing the flash cookie. The outcome is
+ * one-shot: append this as soon as the cookie is detected, whether or not
+ * it decodes, so a stale outcome cannot resurface on a later request.
+ */
+export function clearFlashCookie(): string;
+
+/**
+ * The raw encoded flash payload out of a Cookie header, if present — the
+ * codec's own accessor.
+ *
+ * @internal
+ */
+export function matchFlashCookie(cookieHeader: string | null): string | undefined;

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 { getOwner, runWithOwner, createComponent, createRoot as root, sharedConfig, untrack, merge as mergeProps, flatten, ssrHandleError, ssrScope, NoHydration, Hydration, runInServerComponentScope, creationStamp, inServerComponentScope } 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;
+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;

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;
@@ -170,6 +186,10 @@ export interface FrameHost {
   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;
+  /** See FrameHostOptions.revive. */
+  revive?(value: unknown): unknown;
+  /** See FrameHostOptions.isContainer. */
+  isContainer?(value: unknown): boolean;
 }
 
 /**
@@ -180,10 +200,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`).
@@ -199,11 +223,37 @@ export interface FrameHostOptions {
    * `applyData: c => table.apply(c)` (see `createJSONDataTable`).
    */
   applyData?(chunk: Extract<FrameChunk, { type: "data" }>): void;
+  /**
+   * A lazily-loaded deserializer's load, awaited by the transport before it
+   * delivers a `data` chunk — `applyData`/`resolve` can assume the codec is
+   * resident once data has arrived. Keeps codec weight out of the eager
+   * client graph for responses that never carry serialized data.
+   */
+  prepareData?(): Promise<unknown>;
+  /**
+   * Revive protocol markers inside LITERAL slot args (values that are
+   * neither `{$ref}` nor `{$frame}`) at arg-resolution time. Document-face
+   * container traces ride this way — inline in the record, revived by the
+   * integration (`reviveContainerTraces`) into live local containers.
+   */
+  revive?(value: unknown): unknown;
+  /**
+   * Whether a resolved arg value is a LIVE CONTAINER (a materialized trace —
+   * see `isMaterializedContainer`). The record-dedupe compare must know: a
+   * pending container's property reads throw not-ready, so async probes and
+   * serialization compares would detonate it. Containers compare by
+   * identity only.
+   */
+  isContainer?(value: unknown): boolean;
 }
 
+/** @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 +267,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 +309,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 +329,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,5 +1,9 @@
+// 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";
+import { JSONCodecOptions } from "./serializer-decode.cjs";
 
 // Structural mirror of server-functions/shared.js's FlightDataConsumer:
 // this file may only reference siblings that ship with it when integrations
@@ -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;