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

package/types/server-functions/shared.d.ts

@@ -1,4 +1,4 @@
-import { JSONCodecOptions } from "../serializer.js";
+import { JSONCodecOptions } from "../serializer-decode.js";
 
 export type { JSONCodecOptions };
 
@@ -283,6 +283,46 @@ export function withMeta<F extends (...args: any[]) => any>(fn: F, meta: ServerF
  */
 export const SERVER_FUNCTION_METADATA: unique symbol;
 
+/**
+ * The transport surface integrations consume through the late-bound RPC
+ * seam (server-functions/registry.js) — filled by the transport halves when
+ * the first server function reference is created (code that only exists in
+ * a bundle when a `"use server"` function was actually compiled in), read
+ * by routers so they never import the transport/codec statically.
+ */
+export interface ServerFunctionRPC {
+  /**
+   * The build's `GET` declaration wrapper (client fetch transport or
+   * server in-process dispatch — see the respective entries).
+   */
+  GET<A extends readonly any[], R>(fn: (...args: A) => R): ServerFunction<A, Awaited<R>>;
+  /**
+   * `decodeResponse` bound to the configured codec: decodes a server
+   * function response body the transport handed over whole (redirects,
+   * revalidation). Resolves undefined for empty bodies and bodies without
+   * a recognized encoding (e.g. a raw user Response).
+   */
+  decodeResponse<T = unknown>(response: Response): Promise<T | undefined>;
+}
+
+/**
+ * Fills the RPC seam. Called by the transport halves when the first server
+ * function reference is created; first write wins.
+ * @internal
+ */
+export function provideServerFunctionRPC(rpc: ServerFunctionRPC): void;
+
+/**
+ * The registered RPC surface, or undefined when no server function exists
+ * in this build's graph. Integration plumbing (routers): gate every use of
+ * the transport/codec behind this read instead of importing it — an app
+ * with no server functions then ships none of it, while a reference in the
+ * bundle guarantees the seam is filled before integration code can hold
+ * that reference (compiled output creates references at module scope).
+ * @internal
+ */
+export function getServerFunctionRPC(): ServerFunctionRPC | undefined;
+
 /**
  * Header carrying the body format tag (a `BodyFormat` value) —
  * `"X-Server-Function-Format"`.
@@ -316,6 +356,11 @@ export const BodyFormat: {
   readonly File: "5";
   readonly ArrayBuffer: "6";
   readonly Uint8Array: "7";
+  /**
+   * Plain `JSON.stringify` — the fast path for JSON-safe payloads on both
+   * legs: argument lists on the request, results on the response.
+   */
+  readonly Json: "8";
 };
 
 /**
@@ -324,6 +369,17 @@ export const BodyFormat: {
  */
 export type BodyFormatValue = (typeof BodyFormat)[keyof typeof BodyFormat];
 
+/**
+ * Whether a value survives a `JSON.stringify` round trip faithfully: JSON
+ * primitives (finite numbers only), arrays, and plain objects. Anything
+ * else — Dates, Maps, typed arrays, undefined (bare or as a property),
+ * NaN, class instances, cyclic structures — needs the codec. Never throws:
+ * cycles and pathological depth answer `false`. Both peers negotiate the
+ * wire format with this guard: the client for argument lists, the server
+ * for results.
+ */
+export function isJSONSafe(value: unknown): boolean;
+
 /**
  * Picks a direct HTTP encoding (headers + BodyInit) for values that have
  * one — strings, FormData, URLSearchParams, File, Blob, ArrayBuffer,

package/types/server.d.ts

@@ -1,5 +1,5 @@
 import { JSX } from "./jsx.js";
-import { SerializerPlugin } from "./serializer.js";
+import { SerializerPlugin } from "./serializer-decode.js";
 export const DOMWithState: Record<string, Record<string, 1 | 2>>;
 export const ChildProperties: Set<string>;
 export const DelegatedEvents: Set<string>;
@@ -345,6 +345,26 @@ export function commitEventResponse(response: Response, event?: RequestEvent): R
 export { parseCookieHeader, serializeCookie } from "./cookies.js";
 export type { CookieOptions } from "./cookies.js";
 
+/**
+ * The flash cookie's isomorphic half and the codec-free server-function
+ * layer (reference detection + the late-bound RPC seam) — mirrors of the
+ * client entry's exports, so integration code reading them stays
+ * universal. Declared through server-functions/shared.d.ts, the
+ * declaration home published-types layouts ship.
+ */
+export {
+  clearFlashCookie,
+  getServerFunctionMetadata,
+  getServerFunctionRPC,
+  hasFlashCookie,
+  isServerFunction
+} from "./server-functions/shared.js";
+export type {
+  ServerFunction,
+  ServerFunctionMetadata,
+  ServerFunctionRPC
+} from "./server-functions/shared.js";
+
 export interface SSRResponseOptions {
   /** Base head; the stub's status/headers win over it. */
   responseInit?: ResponseInit;

package/types-cjs/client.d.cts

@@ -289,7 +289,7 @@ export interface ResponseStub {
  * share ONE interface identity and a single augmentation reaches every
  * `locals`, whichever entry typed the event.
  */
-export type { RequestEventLocals } from "./server.cjs";
+export { RequestEventLocals } from "./server.cjs";
 export interface RequestEvent {
   request: Request;
   locals: RequestEventLocals;
@@ -311,5 +311,27 @@ export function getRequestEvent(): RequestEvent | undefined;
  */
 export { parseCookieHeader, serializeCookie } from "./cookies.cjs";
 export type { CookieOptions } from "./cookies.cjs";
+/**
+ * The flash cookie's isomorphic half (name/detection/clearing — cookie
+ * utilities living beside the cookie codec) and the codec-free
+ * server-function layer (reference detection + the late-bound RPC seam).
+ * On the core entries so integrations consuming them eagerly (routers)
+ * never import the server-functions entry — whose client half is the
+ * transport + codec — from their eager graph. Declared through
+ * server-functions/shared.d.ts, the declaration home published-types
+ * layouts ship.
+ */
+export {
+  clearFlashCookie,
+  getServerFunctionMetadata,
+  getServerFunctionRPC,
+  hasFlashCookie,
+  isServerFunction
+} from "./server-functions/shared.cjs";
+export type {
+  ServerFunction,
+  ServerFunctionMetadata,
+  ServerFunctionRPC
+} from "./server-functions/shared.cjs";
 /** Hydration-walk primitive; not for hand-written code. @internal */
 export function runHydrationEvents(): void;

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,4 @@
-export { getOwner, runWithOwner, createComponent, createRoot as root, sharedConfig, untrack, merge as mergeProps, flatten, ssrHandleError, ssrScope, NoHydration, Hydration, runInServerComponentScope } from "solid-js";
+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;

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

@@ -186,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;
 }
 
 /**
@@ -219,6 +223,28 @@ 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 */

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

@@ -3,7 +3,7 @@
 // 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

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

@@ -5,15 +5,20 @@
 // 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 };
+import type { Serializer } from "seroval";
+import {
+  JSONCodecOptions,
+  PluginInfo,
+  SerializerPlugin,
+  SerovalNode
+} from "./serializer-decode.cjs";
+
+// The decode half — `SerovalNode`, the plugin TYPES, `DEFAULT_WEB_PLUGINS`,
+// `resolveSerializerPlugins`, `JSONCodecOptions`, `createJSONDeserializer`,
+// `createJSONDataTable` — is declared in serializer-decode.d.ts (published
+// as `@solidjs/web/serialization/decode`, the module lazy client consumers
+// load) and re-exported here so this remains the full surface.
+export * from "./serializer-decode.cjs";
 
 // ---- Plugin authoring ----
 //
@@ -21,86 +26,8 @@ export type { SerovalNode };
 // 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 (`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 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;
-}
+// the plugin TYPES live in serializer-decode.d.ts (hand-declared there —
+// see its banner for why).
 
 /**
  * Builds a `SerializerPlugin` — seroval's `createPlugin`, re-exported so
@@ -130,26 +57,6 @@ export class OpaqueReference<V, R = undefined> {
   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[];
-
-/**
- * Composes custom plugins with `DEFAULT_WEB_PLUGINS`. Custom plugins come
- * 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`.
  *
@@ -217,30 +124,8 @@ export function createHydrationSerializer(options: HydrationSerializerOptions):
 export function getLocalHeaderScript(id?: string): string;
 
 // ---- JSON codec (server function transports) ----
-
-/**
- * Options shared by both halves of the JSON codec. All of them must match
- * 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. */
-  plugins?: SerializerPlugin[];
-  /**
-   * Seroval feature bitflags to exclude. Defaults to disabling `RegExp`
-   * (payloads may come from an untrusted peer). Must match on both peers.
-   * Outside development, the encoding side additionally strips
-   * `Error.prototype.stack` on top of any override — serialized stacks leak
-   * server paths to the client. Decoding stays permissive, so payloads from
-   * a development peer still round-trip.
-   */
-  disabledFeatures?: number;
-  /** Maximum parse/deserialize depth. Defaults to 64. Must match on both peers. */
-  depthLimit?: number;
-}
+// (`JSONCodecOptions` and the decode half are declared in
+// serializer-decode.d.ts and re-exported above.)
 
 /**
  * Options for `serializeJSON`.
@@ -270,17 +155,6 @@ export interface JSONSerializeOptions extends JSONCodecOptions {
  */
 export function serializeJSON(value: unknown, options: JSONSerializeOptions): () => void;
 
-/**
- * Creates the decoding counterpart of `serializeJSON`. Cross-references
- * between chunks resolve through state shared across calls, so all chunks
- * 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 {
   /**
@@ -306,19 +180,3 @@ export function createJSONSerializer(options: JSONSerializerOptions): {
   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;
-  resolve<T = unknown>(ref: { $ref: string }): T;
-}
-export function createJSONDataTable(options?: JSONCodecOptions): JSONDataTable;