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

package/serialization/types-cjs/serializer-decode.d.cts

@@ -0,0 +1,182 @@
+// The DECODE half of the serialization surface (published as
+// `@solidjs/web/serialization/decode`): what reading a serialized payload
+// needs — `fromCrossJSON`-backed deserializers and the shared plugin set —
+// with none of the encode machinery. Lazy client consumers (the frames
+// data tables, `deserializeStream`) load this module so the encode half
+// never ships to a browser that only reads. The full serializer.d.ts
+// re-exports everything here; see its banner for the stability contract
+// (integration-facing, exempt from the 2.0 stability guarantee).
+// ---- Plugin types ----
+//
+// Declared here by hand (seroval's published d.ts use extensionless
+// ESM-relative imports that `moduleResolution: "nodenext"` cannot follow —
+// a bare type re-export would silently degrade the surface to `any` under
+// skipLibCheck, and an import would make every entry whose types reach
+// this module — the MAIN client entry included, via the server-function
+// seam's `JSONCodecOptions` — unimportable from a strict Node16 CJS
+// consumer). The declarations mirror seroval ~1.5 exactly; the `~` pin is
+// what makes mirroring safe. Plugin AUTHORING (`createPlugin`,
+// `OpaqueReference`) lives on the full serialization entry.
+
+/**
+ * Seroval's node shape — the intermediate representation `serializeJSON`
+ * emits and `createJSONDeserializer` consumes. Safe to `JSON.stringify`.
+ * Declared by hand like the plugin types below (same rationale): the
+ * observable envelope — a numeric type tag, an optional reference id —
+ * with the rest owned by the codec. Real seroval nodes satisfy it; treat
+ * it as an opaque token.
+ *
+ * Integration-facing; may change (see the entry banner).
+ */
+export interface SerovalNode {
+  /** Node type tag (seroval-internal enum). */
+  t: number;
+  /** Reference id, when the node participates in cross-referencing. */
+  i?: number | undefined;
+  [key: string]: unknown;
+}
+
+/** 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;
+}
+
+/**
+ * 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 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;
+}
+
+/**
+ * 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;
+
+/**
+ * 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;

package/server-functions/dist/client.cjs

@@ -1,55 +1,35 @@
 'use strict';
 
-var seroval = require('seroval');
-var web = require('seroval-plugins/web');
-
 const REVALIDATE_HEADER = "X-Revalidate";
 
-seroval.Feature.AggregateError | seroval.Feature.BigIntTypedArray;
-const serializeOnlyDisabledFeatures = () => process.env.NODE_ENV === "development" ? 0 : seroval.Feature.ErrorPrototypeStack;
-const DEFAULT_WEB_PLUGINS = Object.freeze([web.AbortSignalPlugin,
-web.CustomEventPlugin, web.DOMExceptionPlugin, web.EventPlugin,
-web.FormDataPlugin, web.HeadersPlugin, web.ReadableStreamPlugin, web.RequestPlugin, web.ResponsePlugin, web.URLSearchParamsPlugin, web.URLPlugin]);
-function resolveSerializerPlugins(customPlugins) {
-  return customPlugins ? [...customPlugins, ...DEFAULT_WEB_PLUGINS] : [...DEFAULT_WEB_PLUGINS];
-}
-const JSON_CODEC_DISABLED_FEATURES = seroval.Feature.RegExp;
-const JSON_CODEC_DEPTH_LIMIT = 64;
-function resolveCodecOptions({
-  plugins,
-  disabledFeatures,
-  depthLimit
-} = {}) {
-  return {
-    plugins: resolveSerializerPlugins(plugins),
-    disabledFeatures: disabledFeatures === undefined ? JSON_CODEC_DISABLED_FEATURES : disabledFeatures,
-    depthLimit: depthLimit === undefined ? JSON_CODEC_DEPTH_LIMIT : depthLimit
-  };
+const SERVER_FUNCTION_METADATA = Symbol.for("solid.ServerFunctionMetadata");
+function getServerFunctionMetadata(fn) {
+  if (typeof fn !== "function") return undefined;
+  return fn[SERVER_FUNCTION_METADATA] || undefined;
 }
-function serializeJSON(value, {
-  onParse,
-  onDone,
-  onError,
-  ...codecOptions
-}) {
-  const resolved = resolveCodecOptions(codecOptions);
-  return seroval.toCrossJSONStream(value, {
-    onParse,
-    onDone,
-    onError,
-    ...resolved,
-    disabledFeatures: resolved.disabledFeatures | serializeOnlyDisabledFeatures()
-  });
+function isServerFunction(fn) {
+  return typeof fn === "function" && !!fn[SERVER_FUNCTION_METADATA];
 }
-function createJSONDeserializer(options) {
-  const refs = new Map();
-  const resolved = resolveCodecOptions(options);
-  return function deserializeJSONChunk(node) {
-    return seroval.fromCrossJSON(node, {
-      refs,
-      ...resolved
-    });
-  };
+function withMeta(fn, meta) {
+  const metadata = getServerFunctionMetadata(fn);
+  if (!metadata) {
+    throw new Error("withMeta expects a server function reference");
+  }
+  Object.assign(metadata, meta);
+  return fn;
+}
+const SERVER_FUNCTION_RPC = Symbol.for("solid.ServerFunctionRPC");
+function provideServerFunctionRPC(rpc) {
+  globalThis[SERVER_FUNCTION_RPC] || (globalThis[SERVER_FUNCTION_RPC] = rpc);
+}
+
+const FLASH_COOKIE = "flash";
+const FLASH_MATCHER = new RegExp(`(?:^|;\\s*)${FLASH_COOKIE}=([^;]+)`);
+function hasFlashCookie(cookieHeader) {
+  return !!cookieHeader && FLASH_MATCHER.test(cookieHeader);
+}
+function clearFlashCookie() {
+  return `${FLASH_COOKIE}=; Max-Age=0; Path=/`;
 }
 
 const codecConfig = {
@@ -117,22 +97,6 @@ function stableString(value, seen) {
   }
   return out + "}";
 }
-const SERVER_FUNCTION_METADATA = Symbol.for("solid.ServerFunctionMetadata");
-function getServerFunctionMetadata(fn) {
-  if (typeof fn !== "function") return undefined;
-  return fn[SERVER_FUNCTION_METADATA] || undefined;
-}
-function isServerFunction(fn) {
-  return typeof fn === "function" && !!fn[SERVER_FUNCTION_METADATA];
-}
-function withMeta(fn, meta) {
-  const metadata = getServerFunctionMetadata(fn);
-  if (!metadata) {
-    throw new Error("withMeta expects a server function reference");
-  }
-  Object.assign(metadata, meta);
-  return fn;
-}
 const FUNCTION_HEADER = "X-Server-Function-Id";
 const ERROR_HEADER = "X-Server-Function-Error";
 const ERROR_HEADER_MARKER = "=?1?";
@@ -163,14 +127,6 @@ const INSTANCE_HEADER = "X-Server-Function-Instance";
 const BODY_FORMAT_HEADER = "X-Server-Function-Format";
 const SINGLE_FLIGHT_HEADER = "X-Single-Flight";
 const FILE_FORM_KEY = "__server_function_file__";
-const FLASH_COOKIE = "flash";
-const FLASH_MATCHER = new RegExp(`(?:^|;\\s*)${FLASH_COOKIE}=([^;]+)`);
-function hasFlashCookie(cookieHeader) {
-  return !!cookieHeader && FLASH_MATCHER.test(cookieHeader);
-}
-function clearFlashCookie() {
-  return `${FLASH_COOKIE}=; Max-Age=0; Path=/`;
-}
 const BodyFormat = {
   Serialized: "0",
   String: "1",
@@ -182,6 +138,38 @@ const BodyFormat = {
   Uint8Array: "7",
   Json: "8"
 };
+const JSON_SAFE_DEPTH_LIMIT = 10000;
+const EXIT = {};
+function isJSONSafe(value) {
+  const stack = [value];
+  const ancestors = new Set();
+  while (stack.length) {
+    const v = stack.pop();
+    if (v === EXIT) {
+      ancestors.delete(stack.pop());
+      continue;
+    }
+    if (v === null) continue;
+    const t = typeof v;
+    if (t === "string" || t === "boolean") continue;
+    if (t === "number") {
+      if (!Number.isFinite(v)) return false;
+      continue;
+    }
+    if (t !== "object") return false;
+    if (ancestors.has(v) || ancestors.size >= JSON_SAFE_DEPTH_LIMIT) return false;
+    ancestors.add(v);
+    stack.push(v, EXIT);
+    if (Array.isArray(v)) {
+      for (let i = 0; i < v.length; i++) stack.push(v[i]);
+    } else {
+      const proto = Object.getPrototypeOf(v);
+      if (proto !== Object.prototype && proto !== null) return false;
+      for (const k in v) stack.push(v[k]);
+    }
+  }
+  return true;
+}
 function getHeadersAndBody(body) {
   switch (true) {
     case typeof body === "string":
@@ -341,7 +329,10 @@ class ChunkReader {
 }
 function serializeStream(value, codecOptions) {
   return new ReadableStream({
-    start(controller) {
+    async start(controller) {
+      const {
+        serializeJSON
+      } = await import('@solidjs/web/serialization');
       serializeJSON(value, {
         ...codecOptions,
         onParse(node) {
@@ -368,6 +359,9 @@ async function deserializeStream(source, codecOptions) {
   const reader = new ChunkReader(source.body);
   const result = await reader.next();
   if (!result.done) {
+    const {
+      createJSONDeserializer
+    } = await import('@solidjs/web/serialization/decode');
     const deserializeChunk = createJSONDeserializer(codecOptions);
     function interpretChunk(chunk) {
       return deserializeChunk(JSON.parse(chunk));
@@ -400,21 +394,6 @@ const config = {
   responseHandler: undefined,
   serializeArgs: undefined
 };
-function isJSONSafe(value) {
-  if (value === null) return true;
-  const t = typeof value;
-  if (t === "string" || t === "boolean") return true;
-  if (t === "number") return Number.isFinite(value);
-  if (t !== "object") return false;
-  if (Array.isArray(value)) {
-    for (const v of value) if (!isJSONSafe(v)) return false;
-    return true;
-  }
-  const proto = Object.getPrototypeOf(value);
-  if (proto !== Object.prototype && proto !== null) return false;
-  for (const k in value) if (!isJSONSafe(value[k])) return false;
-  return true;
-}
 function serializeArguments(args) {
   if (!config.serializeArgs) {
     throw new Error("Server function arguments are sent as JSON by default and these " + "arguments are not JSON-serializable. Call enableRichArguments() " + '(from "@solidjs/web/server-functions/rich-args") once at startup ' + "to send Dates, Maps, Sets, typed arrays, etc. through the codec — " + "or pass a single Blob/FormData/File argument, which has a native " + "HTTP encoding.");
@@ -435,6 +414,15 @@ function configureServerFunctionsClient({
   if (serializeArgs !== undefined) config.serializeArgs = serializeArgs;
 }
 let INSTANCE = 0;
+let rpcProvided = false;
+function provideRPC() {
+  if (rpcProvided) return;
+  rpcProvided = true;
+  provideServerFunctionRPC({
+    GET,
+    decodeResponse
+  });
+}
 async function createRequest(base, id, instance, options, meta) {
   const headers = {
     ...options.headers,
@@ -474,31 +462,37 @@ async function initializeResponse(base, id, instance, options, args, meta) {
       }, meta);
     }
   }
-  if (isJSONSafe(args)) {
-    return createRequest(base, id, instance, {
-      ...options,
-      body: JSON.stringify(args),
-      headers: {
-        ...options.headers,
-        "Content-Type": "application/json",
-        [BODY_FORMAT_HEADER]: BodyFormat.Json
-      }
-    }, meta);
-  }
-  if (args.length > 1) {
-    const trailing = getHeadersAndBody(args[args.length - 1]);
-    const leading = args.slice(0, -1).map(arg => arg === undefined ? null : arg);
-    if (trailing && isJSONSafe(leading)) {
-      const target = base + (base.includes("?") ? "&" : "?") + "args=" + encodeURIComponent(JSON.stringify(leading));
-      return createRequest(target, id, instance, {
+  try {
+    if (isJSONSafe(args)) {
+      return createRequest(base, id, instance, {
         ...options,
-        body: trailing.body,
+        body: JSON.stringify(args),
         headers: {
           ...options.headers,
-          ...trailing.headers
+          "Content-Type": "application/json",
+          [BODY_FORMAT_HEADER]: BodyFormat.Json
         }
       }, meta);
     }
+  } catch {
+  }
+  if (args.length > 1) {
+    try {
+      const trailing = getHeadersAndBody(args[args.length - 1]);
+      const leading = args.slice(0, -1).map(arg => arg === undefined ? null : arg);
+      if (trailing && isJSONSafe(leading)) {
+        const target = base + (base.includes("?") ? "&" : "?") + "args=" + encodeURIComponent(JSON.stringify(leading));
+        return createRequest(target, id, instance, {
+          ...options,
+          body: trailing.body,
+          headers: {
+            ...options.headers,
+            ...trailing.headers
+          }
+        }, meta);
+      }
+    } catch {
+    }
   }
   return createRequest(base, id, instance, {
     ...options,
@@ -550,6 +544,7 @@ async function fetchServerFunction(base, id, options, args, meta, callArgs = arg
   return result;
 }
 function createServerReference(id, name, base) {
+  provideRPC();
   const metadata = name === undefined ? {} : {
     name
   };
@@ -580,6 +575,7 @@ function GET(fn) {
   if (!isServerFunction(fn)) {
     throw new Error("GET expects a server function reference");
   }
+  provideRPC();
   const id = fn.id;
   const metadata = {
     ...getServerFunctionMetadata(fn)