@solidjs/web 2.0.0-rc.3 → 2.0.0-rc.5

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

@@ -1,4 +1,4 @@
-export { LIVE_SOURCE, SERVER_FUNCTION_METADATA, getServerFunctionMetadata, getServerFunctionRPC, isServerFunction, provideServerFunctionRPC, withMeta } from "./registry.js";
+export { LIVE_SOURCE, SERVER_FUNCTION_INVOKE, SERVER_FUNCTION_METADATA, getServerFunctionMetadata, getServerFunctionRPC, invoke, isServerFunction, provideServerFunctionRPC, withMeta } from "./registry.js";
 export { FLASH_COOKIE, clearFlashCookie, hasFlashCookie, matchFlashCookie } from "../cookies.js";
 import { JSONCodecOptions } from "../serializer-decode.js";
 /**
@@ -8,19 +8,22 @@ import { JSONCodecOptions } from "../serializer-decode.js";
  * HTTP handler. Integrations decoding passthrough responses themselves (no
  * registered consumer) see this shape from `decodeResponse`. The top level
  * is reserved for the protocol — integration payload lives entirely under
- * `data`, which can be any codec-serializable value.
+ * `data`, the envelope keyed by source id (the unnamed registration's
+ * slice rides under the reserved id "true"); each slice can be any
+ * codec-serializable value.
  */
 export interface SingleFlightPayload<T = unknown, D = unknown> {
     /** The server function's return (or thrown) value. */
     value: T;
-    /** The integration-produced data payload. */
+    /** The integration-produced data payload, keyed by source id. */
     data: D;
 }
 /**
  * Envelope context delivered alongside single-flight data: the transport
- * response, whose headers carry the integration metadata (`Location` for
- * redirect-with-data, `X-Revalidate` keys) and status. The body is already
- * consumed — read `data` and `value` from the delivery, not from here.
+ * response, whose headers carry the integration metadata (the redirect
+ * carrier for redirect-with-data, `X-Revalidate` keys) and status. The
+ * body is already consumed — read `data` and `value` from the delivery,
+ * not from here.
  */
 export interface FlightDataContext {
     /** The HTTP response the data arrived on (metadata only). */
@@ -45,6 +48,42 @@ export interface ServerFunction<A extends readonly any[] = any[], T = any> {
     /** URL invoking this function directly over HTTP (form `action`s, raw fetches). */
     readonly url: string;
 }
+/**
+ * Per-call, invocation-scoped options for `invoke` — things that vary
+ * between calls of the SAME function and cannot be declared (`GET`,
+ * `withMeta`) or configured (`prepareRequest`). On the server the call is
+ * in-process: `signal` still rejects the caller, the transport hints are
+ * no-ops (they describe a wire that does not exist).
+ */
+export interface InvokeOptions {
+    /**
+     * The call's lifecycle. Aborting rejects the call with the signal's
+     * reason and cancels the request (firing `request.signal` server-side);
+     * a live source's iteration ends across reconnects. When provided, the
+     * signal owns the wire — timeouts compose through it
+     * (`AbortSignal.timeout`, `AbortSignal.any`).
+     */
+    signal?: AbortSignal;
+    /**
+     * Lets the request outlive the page — fire-and-forget calls during
+     * unload (`pagehide`). Maps to fetch's `keepalive`, body-size caps
+     * included.
+     */
+    keepalive?: boolean;
+    /** Fetch priority hint — speculative prefetch vs. interaction fetch. */
+    priority?: "high" | "low" | "auto";
+}
+/**
+ * A reference's invocation channel, carried under `SERVER_FUNCTION_INVOKE`:
+ * applies one call with per-call options. Declaration wrappers (`GET`,
+ * `live`) forward it mechanically — they keep the call mapping 1:1. A
+ * wrapper that shares calls (a deduping cache, a multicast channel) opts
+ * in deliberately, deciding first what a caller's abort means for shared
+ * work — or declines, leaving `invoke` to answer with a directed error.
+ * Options arrive already validated — `invoke` admits only
+ * invocation-scoped keys.
+ */
+export type ServerFunctionInvoker<A extends readonly any[] = any[], R = any> = (args: A, options?: InvokeOptions) => R;
 /**
  * Declaration-static metadata attached to a server function reference
  * through declaration wrappers (`GET`, `withMeta`). Read it with
@@ -95,11 +134,27 @@ export interface ServerFunctionRPC {
 export type BodyFormatValue = (typeof BodyFormat)[keyof typeof BodyFormat];
 export declare function configureServerFunctionsCodec(codec: JSONCodecOptions | undefined): void;
 export declare function getServerFunctionsCodec(): JSONCodecOptions | undefined;
+/**
+ * Validates a flight data source id (both registration halves share the
+ * rule): ids travel the `SINGLE_FLIGHT_HEADER` as a comma-separated list,
+ * so they cannot be empty or contain commas, and "true" is reserved for
+ * the unnamed registration.
+ *
+ * Transport building block; not meant for hand-written code.
+ * @internal
+ */
+export declare function assertFlightSource(source: string): void;
 export declare function subscribeFlightData<D = unknown>(consumer: FlightDataConsumer<D>): () => void;
-export declare function getFlightDataConsumer(): FlightDataConsumer | undefined;
+export declare function subscribeFlightData<D = unknown>(source: string, consumer: FlightDataConsumer<D>): () => void;
+export declare function getFlightDataConsumer(source?: string): FlightDataConsumer | undefined;
+export declare function getFlightDataSourceIds(): string[];
 export declare function frameAddress(id: string, args?: readonly unknown[]): string;
-/** Header carrying the server function id. */
-export declare const FUNCTION_HEADER = "X-Server-Function-Id";
+export declare function serverFunctionAddress(endpoint: string, id: string): string;
+export declare function serverFunctionDataAddress(endpoint: string, id: string): string;
+export declare function parseServerFunctionAddress(pathname: string, endpoint: string): {
+    id: string;
+    data: boolean;
+} | null;
 /**
  * Response header marking a thrown server-function error. The value is the
  * error's message (the structured error itself travels in the body); `"true"`
@@ -115,6 +170,51 @@ export declare function decodeErrorHeaderValue(value: string): string;
 export declare const INSTANCE_HEADER = "X-Server-Function-Instance";
 /** Header carrying the body format tag (a `BodyFormat` value). */
 export declare const BODY_FORMAT_HEADER = "X-Server-Function-Format";
+/**
+ * Header labelling the unknown-id 404: the address was well-formed but its
+ * id is not registered in the deployment that answered (#3110). This is the
+ * ordinary shape of version skew — a tab holding the previous build's ids
+ * across a deploy — and the label is what lets an integration recover
+ * (e.g. reload the document) instead of surfacing a generic failed call.
+ * Nothing distinguishes it otherwise: a CDN 404 and a skew 404 look alike.
+ */
+export declare const UNKNOWN_HEADER = "X-Server-Function-Unknown";
+/**
+ * Header carrying a redirect to scripted callers. fetch FOLLOWS redirect
+ * statuses before the transport can read them, so a scripted answer masks
+ * the 3xx to 200 and this header carries what the mask erases: the author's
+ * status and the target RESOLVED against the request url — exactly the
+ * meaning HTTP assigns the `Location` a form post would have received.
+ * Value: `<status> <absolute-url>`, decode with `decodeRedirectHeaderValue`.
+ *
+ * Carrying the resolved absolute form is the point (#3102, #3107): the
+ * reader never guesses navigation strategy from how the author spelled the
+ * target — `redirect("/")` and `redirect(new URL("/", url).href)` arrive
+ * identical by construction, and same-origin vs cross-origin is a real URL
+ * comparison, not a `startsWith("http")` coin toss. `Location` itself never
+ * rides a masked answer: on a 200 it has no HTTP meaning, and it collided
+ * with authored Locations on statuses that forward (a 201's created-at is
+ * data, not navigation).
+ */
+export declare const REDIRECT_HEADER = "X-Server-Function-Redirect";
+/**
+ * Decodes a `REDIRECT_HEADER` value into the author's status and the
+ * resolved absolute target. Integration plumbing for readers of the header
+ * (routers); the wire format is the runtime's own, not a contract to parse
+ * by hand.
+ *
+ * The documented output — a resolved ABSOLUTE http(s) target and a redirect
+ * status — is enforced, not assumed (#3175): the absoluteness used to be a
+ * property of the server having resolved it, and a hostile or buggy peer
+ * could ride a `javascript:` target straight into the `location.href =
+ * decoded.url` an integration reasonably writes. A value that does not
+ * parse as an absolute http(s) url, or whose status is not one the runtime
+ * masks, decodes to `undefined` — the same answer a missing header gives.
+ */
+export declare function decodeRedirectHeaderValue(value: string | null | undefined): {
+    status: number;
+    url: string;
+} | undefined;
 /**
  * Header driving the single-flight protocol on both legs: on the request it
  * opts the call into flight-data collection (the integration sends it on
@@ -141,6 +241,13 @@ export declare const BodyFormat: {
      * included) on the response.
      */
     Json: string;
+    /**
+     * No body at all — a function that returned nothing. It marks the response
+     * as one the runtime encoded, which separates a void result with a status
+     * on it from a refusal answered by something else. Decoding falls through
+     * to `undefined`, which is what a peer predating the tag reads too.
+     */
+    Void: string;
 };
 export declare function isJSONSafe(value: unknown): boolean;
 export declare function getHeadersAndBody(body: unknown): {
@@ -157,15 +264,14 @@ export declare class ChunkReader {
         value: string;
     }>;
     drain(interpret: any): Promise<void>;
-} /**
- * Serializes a value as a stream of length-prefixed SerovalNode chunks.
- * Async values (promises, streams) keep the stream open until they settle,
- * so one connection carries incremental results. Codec options must match
- * the deserializing peer.
- *
- * Transport building block; not meant for hand-written code.
+}
+/**
+ * Encodes a terminal error-trailer frame payload. The value is expected to
+ * be already sanitized by the caller; only `name` and `message` travel.
+ * Transport wire detail; not meant for hand-written code.
  * @internal
  */
+export declare function encodeErrorTrailer(error: unknown): string;
 export declare function serializeStream(value: unknown, codecOptions?: JSONCodecOptions): ReadableStream<Uint8Array>;
 export declare function serializeString(value: unknown, codecOptions?: JSONCodecOptions): Promise<string>;
 export declare function deserializeStream<T = unknown>(source: Request | Response, codecOptions?: JSONCodecOptions): Promise<T>;

package/types/server-mock.d.ts

@@ -1,10 +1,23 @@
 import type { RequestEvent, RequestEventLocals, ResponseStub } from "./client.js";
+import type { JSX } from "./jsx.js";
+/** An explicit `<link rel="preload">` emitted by the SSR asset pipeline. */
+export type PreloadLink = {
+    href: string;
+    as: JSX.HTMLPreloadAs;
+    type?: string;
+    crossorigin?: JSX.HTMLCrossorigin;
+    integrity?: string;
+    referrerpolicy?: JSX.HTMLReferrerPolicy;
+    fetchpriority?: JSX.HTMLFetchPriority;
+    media?: string;
+};
 /** Static asset manifest produced by a build (e.g. parsed Vite manifest.json). */
 export type AssetManifest = Record<string, {
     file: string;
     css?: string[];
     isEntry?: boolean;
     imports?: string[];
+    preloads?: PreloadLink[];
 }> & {
     _base?: string;
 };
@@ -17,6 +30,7 @@ export type InlineStyleAsset = {
 export type ResolvedAssets = {
     js: string[];
     css: (string | InlineStyleAsset)[];
+    preloads?: PreloadLink[];
 };
 /**
  * Resolver form of the manifest option — the primitive a dev server
@@ -24,8 +38,9 @@ export type ResolvedAssets = {
  * normalized into a sync resolver internally). `resolve` may return a
  * promise (async resolvers require streaming rendering); CSS entries may be
  * URL strings (emitted as load-gated `<link>` tags) or inline-style
- * descriptors (emitted as `<style>` tags). A bare `resolve`-shaped function
- * is accepted as shorthand for `{ resolve }`.
+ * descriptors (emitted as `<style>` tags), and `preloads` carries explicit
+ * preload links selected by the integration. A bare `resolve`-shaped
+ * function is accepted as shorthand for `{ resolve }`.
  */
 export type AssetResolver = {
     resolve(key: string): ResolvedAssets | null | undefined | Promise<ResolvedAssets | null | undefined>;

package/types/server.d.ts

@@ -5,12 +5,24 @@ export { clearFlashCookie, hasFlashCookie } from "./cookies.js";
 export { getServerFunctionMetadata, getServerFunctionRPC, isServerFunction } from "./server-functions/registry.js";
 import { JSX } from "./jsx.js";
 import { SerializerPlugin } from "./serializer-decode.js";
+/** An explicit `<link rel="preload">` emitted by the SSR asset pipeline. */
+export type PreloadLink = {
+    href: string;
+    as: JSX.HTMLPreloadAs;
+    type?: string;
+    crossorigin?: JSX.HTMLCrossorigin;
+    integrity?: string;
+    referrerpolicy?: JSX.HTMLReferrerPolicy;
+    fetchpriority?: JSX.HTMLFetchPriority;
+    media?: string;
+};
 /** Static asset manifest produced by a build (e.g. parsed Vite manifest.json). */
 export type AssetManifest = Record<string, {
     file: string;
     css?: string[];
     isEntry?: boolean;
     imports?: string[];
+    preloads?: PreloadLink[];
 }> & {
     _base?: string;
 };
@@ -23,6 +35,7 @@ export type InlineStyleAsset = {
 export type ResolvedAssets = {
     js: string[];
     css: (string | InlineStyleAsset)[];
+    preloads?: PreloadLink[];
 };
 /**
  * Resolver form of the manifest option — the primitive a dev server
@@ -30,8 +43,9 @@ export type ResolvedAssets = {
  * normalized into a sync resolver internally). `resolve` may return a
  * promise (async resolvers require streaming rendering); CSS entries may be
  * URL strings (emitted as load-gated `<link>` tags) or inline-style
- * descriptors (emitted as `<style>` tags). A bare `resolve`-shaped function
- * is accepted as shorthand for `{ resolve }`.
+ * descriptors (emitted as `<style>` tags), and `preloads` carries explicit
+ * preload links selected by the integration. A bare `resolve`-shaped
+ * function is accepted as shorthand for `{ resolve }`.
  */
 export type AssetResolver = {
     resolve(key: string): ResolvedAssets | null | undefined | Promise<ResolvedAssets | null | undefined>;

package/types-cjs/client.d.cts

@@ -79,6 +79,8 @@ export interface RequestEvent {
 export type { CookieOptions } from "./cookies.cjs";
 export type { ServerFunction, ServerFunctionMetadata, ServerFunctionRPC } from "./server-functions/shared.cjs";
 export declare const waitAsset: (promise: Promise<unknown>) => void;
+export declare let listDriver: ((parent: Node, listFn: any, marker?: Node, lateClassic?: () => void) => boolean) | undefined;
+export declare function installListDriver(driver: typeof listDriver): void;
 export { DOMWithState, ChildProperties, DOMElements, SVGElements, MathMLElements, VoidElements, RawTextElements, Namespaces, DelegatedEvents } from "./constants.cjs";
 /** Client stub — hydration bootstrap is a server-only emit. */
 export declare function generateHydrationScript(_options?: {
@@ -145,10 +147,10 @@ export declare function spread<T>(node: Element, accessor: T, skipChildren?: Boo
 export declare function dynamicProperty(props: unknown, key: string): unknown;
 export declare function applyRef<T extends Element = Element>(r: ((element: NoInfer<T>) => void) | ((element: NoInfer<T>) => void)[], element: T): void;
 export declare function ref(fn: () => ((element: Element) => void) | ((element: Element) => void)[], element: Element): void;
-export declare function rowProof(fn: any): any; /** Compiler-emitted primitive; not for hand-written code. @internal */
+/** Compiler-emitted primitive; not for hand-written code. @internal */
 export declare function scope<T extends () => any>(fn: T): T;
 export declare function installHydrationRuntime(): void;
-export declare function patchDriver(subject: any, body: any): void; /**
+/**
  * Compiler-emitted primitive; not for hand-written code.
  * @internal
  */

package/types-cjs/cookies.d.cts

@@ -13,6 +13,12 @@ export interface CookieOptions {
     secure?: boolean;
     /** Cookie `SameSite` attribute, any case. */
     sameSite?: "lax" | "strict" | "none" | "Lax" | "Strict" | "None";
+    /**
+     * Emit the `Partitioned` attribute (CHIPS): a third-party cookie keyed to
+     * the top-level site it was set under — the only third-party cookie that
+     * keeps working as browsers finish removing the rest. Requires `secure`.
+     */
+    partitioned?: boolean;
 }
 /**
  * Parses a `Cookie` request header into a name → value map. Names and
@@ -25,20 +31,6 @@ export interface CookieOptions {
  * `parseCookieHeader(event.request.headers.get("cookie"))`.
  */
 export declare 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 `/` — the only defaulted attribute — and every other
- * attribute is emitted exactly when the caller asked for it: `domain`,
- * `maxAge` (seconds, truncated to an integer), `expires` (a `Date`),
- * `httpOnly`, `secure`, `sameSite` (`"lax" | "strict" | "none"`, any
- * case).
- *
- * 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 declare function serializeCookie(name: string, value: string, options?: CookieOptions): string;
 export declare const FLASH_COOKIE = "flash";
 /** Whether a Cookie header carries a flash cookie (readable or not). */

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

@@ -59,6 +59,10 @@ export type FrameChunk = {
         content?: string;
         attrs?: Record<string, string>;
     }[];
+    preloads?: {
+        href: string;
+        attrs: Record<string, string>;
+    }[];
 } | {
     type: "slot";
     id: string;

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

@@ -105,6 +105,18 @@ export interface JSONCodecOptions {
     disabledFeatures?: number;
     /** Maximum parse/deserialize depth. Defaults to 64. Must match on both peers. */
     depthLimit?: number;
+    /**
+     * Whether serialized `Error`s carry their `.stack` — server file paths,
+     * internal function names, the shape of the deployment — to the peer.
+     * Defaults to `NODE_ENV === "development"`, but that signal describes the
+     * PROCESS, not the artifact: a production build running with
+     * `NODE_ENV=development` (a base image, a stray dotenv) ships stacks to
+     * the wire — including for errors marked safe with `markSafeError`, whose
+     * stacks traverse application code (#3152). Set `false` to pin production
+     * disclosure regardless of the ambient variable. Encode-side only; the
+     * decode side is always permissive, so it need not match peers.
+     */
+    serializeErrorStacks?: boolean;
 }
 /**
  * A resident, response-scoped decode table over the keyed JSON codec: apply
@@ -142,10 +154,11 @@ export declare const DEFAULT_WEB_PLUGINS: any; /**
  * Integration-facing; may change (see the entry banner).
  */
 export declare function resolveSerializerPlugins(customPlugins?: SerializerPlugin[]): SerializerPlugin[];
-export declare function resolveCodecOptions({ plugins, disabledFeatures, depthLimit }?: JSONCodecOptions): {
+export declare function resolveCodecOptions({ plugins, disabledFeatures, depthLimit, serializeErrorStacks }?: JSONCodecOptions): {
     plugins: SerializerPlugin<any, any>[];
     disabledFeatures: any;
     depthLimit: number;
+    serializeErrorStacks: boolean;
 }; /**
  * Creates the decoding counterpart of `serializeJSON`. Cross-references
  * between chunks resolve through state shared across calls, so all chunks

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

@@ -19,6 +19,13 @@ export interface WebSerializerOptions {
      * any override — serialized stacks leak server paths to the client.
      */
     disabledFeatures?: number;
+    /**
+     * Whether serialized `Error`s carry their `.stack`. Defaults to
+     * `NODE_ENV === "development"`; set `false` to pin production disclosure
+     * to the deployment rather than the ambient variable (#3152 — see
+     * `JSONCodecOptions.serializeErrorStacks`).
+     */
+    serializeErrorStacks?: boolean;
     /** Extra plugins, composed ahead of `DEFAULT_WEB_PLUGINS`. */
     plugins?: SerializerPlugin[];
     /** Receives each emitted script chunk. */

package/types-cjs/index.d.cts

@@ -1,6 +1,7 @@
 import { Component } from "solid-js";
 import type { JSX } from "./jsx.cjs";
 export * from "./client.cjs";
+export { patchDriver, rowProof, driveList } from "./patch-driver.cjs";
 export * from "./server-mock.cjs";
 export * from "./response.cjs";
 export type { JSX } from "./jsx.cjs";

package/types-cjs/jsx.d.cts

@@ -1080,6 +1080,7 @@ export namespace JSX {
   type HTMLFormEncType = "application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain";
   type HTMLFormMethod = "post" | "get" | "dialog";
   type HTMLCrossorigin = "anonymous" | "use-credentials" | EnumeratedAcceptsEmpty;
+  type HTMLFetchPriority = "high" | "low" | "auto";
   type HTMLReferrerPolicy =
     | "no-referrer"
     | "no-referrer-when-downgrade"
@@ -1105,19 +1106,8 @@ export namespace JSX {
     | "allow-top-navigation"
     | "allow-top-navigation-by-user-activation"
     | "allow-top-navigation-to-custom-protocols";
-  type HTMLLinkAs =
-    | "audio"
-    | "document"
-    | "embed"
-    | "fetch"
-    | "font"
-    | "image"
-    | "object"
-    | "script"
-    | "style"
-    | "track"
-    | "video"
-    | "worker";
+  type HTMLPreloadAs = "fetch" | "font" | "image" | "script" | "style" | "track";
+  type HTMLLinkAs = HTMLPreloadAs | "audio" | "document" | "embed" | "object" | "video" | "worker";
 
   interface AnchorHTMLAttributes<T> extends HTMLAttributes<T> {
     download?: string | EnumeratedAcceptsEmpty | RemoveAttribute;
@@ -1367,7 +1357,7 @@ export namespace JSX {
     browsingtopics?: string | RemoveAttribute;
     crossorigin?: HTMLCrossorigin | RemoveAttribute;
     decoding?: "sync" | "async" | "auto" | RemoveAttribute;
-    fetchpriority?: "high" | "low" | "auto" | RemoveAttribute;
+    fetchpriority?: HTMLFetchPriority | RemoveAttribute;
     height?: number | string | RemoveAttribute;
     ismap?: BooleanAttribute | RemoveAttribute;
     loading?: "eager" | "lazy" | RemoveAttribute;
@@ -1522,7 +1512,7 @@ export namespace JSX {
     color?: string | RemoveAttribute;
     crossorigin?: HTMLCrossorigin | RemoveAttribute;
     disabled?: BooleanAttribute | RemoveAttribute;
-    fetchpriority?: "high" | "low" | "auto" | RemoveAttribute;
+    fetchpriority?: HTMLFetchPriority | RemoveAttribute;
     href?: string | RemoveAttribute;
     hreflang?: string | RemoveAttribute;
     imagesizes?: string | RemoveAttribute;
@@ -1713,7 +1703,7 @@ export namespace JSX {
     blocking?: "render" | RemoveAttribute;
     crossorigin?: HTMLCrossorigin | RemoveAttribute;
     defer?: BooleanAttribute | RemoveAttribute;
-    fetchpriority?: "high" | "low" | "auto" | RemoveAttribute;
+    fetchpriority?: HTMLFetchPriority | RemoveAttribute;
     for?: string | RemoveAttribute;
     integrity?: string | RemoveAttribute;
     nomodule?: BooleanAttribute | RemoveAttribute;
@@ -3500,6 +3490,11 @@ export namespace JSX {
      * @url https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectElement
      */
     select: SelectHTMLAttributes<HTMLSelectElement> & Properties<HTMLSelectElement>;
+    /**
+     * @url https://developer.mozilla.org/en-US/docs/Web/HTML/Element/selectedcontent
+     * @url https://developer.mozilla.org/en-US/docs/Web/API/HTMLSelectedContentElement
+     */
+    selectedcontent: HTMLAttributes<HTMLElement> & Properties<HTMLElement>;
     /**
      * @url https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot
      * @url https://developer.mozilla.org/en-US/docs/Web/API/HTMLSlotElement

package/types-cjs/patch-driver.d.cts

@@ -0,0 +1,3 @@
+export declare function rowProof<T extends Function>(fn: T): T;
+export declare const driveList: (parent: Node, listFn: any, marker?: Node, lateClassic?: () => void) => boolean;
+export declare const patchDriver: (subject: any, body: any) => void;

package/types-cjs/response.d.cts

@@ -16,7 +16,15 @@ export declare const ResponseEnvelope: {
 export declare function isResponseEnvelope(value: unknown): value is ResponseEnvelope;
 export declare const HREF: unique symbol;
 export interface Href {
-    [HREF]: true;
+    /**
+     * The brand doubles as a channel: when the slot holds a string it is the
+     * value's *logical* path — the routable pathname before an integration's
+     * display rendering (eg. a hash router's `#` prefix). `redirect()` prefers
+     * it over coercion so Location headers carry routable paths; `toString()`
+     * remains the display href for the DOM. `true` brands a value whose
+     * string form is already logical.
+     */
+    [HREF]: true | string;
     toString(): string;
 }
 /** Whether `value` is an `Href`-branded URL-bearing value. */
@@ -42,6 +50,8 @@ export declare const REVALIDATE_HEADER = "X-Revalidate";
 export interface ResponseHelperInit extends ResponseInit {
     revalidate?: string | string[];
 }
+/** @internal */
+export declare const RESPONSE_HEADER_VALUE_LIMIT = 4096;
 /**
  * Response redirecting to `url` (default 302). `revalidate` names the
  * cache keys the mutation invalidated.
@@ -52,6 +62,15 @@ export declare function redirect(url: string | Href, init?: number | ResponseHel
  * them when omitted).
  */
 export declare function reload(init?: ResponseHelperInit): Response;
+/**
+ * Statuses HTTP forbids a body on — the `Response` constructor enforces it
+ * by throwing on ANY body, `JSON.stringify(undefined)`'s `"undefined"`
+ * included. Shared with the server-function encoder, which answers void
+ * results on these statuses with a real null-body response and reports
+ * value-carrying ones as authoring errors (#3095).
+ * @internal
+ */
+export declare const NULL_BODY_STATUSES: ReadonlySet<number>;
 /**
  * A value paired with response metadata (status, headers, `revalidate`) —
  * for the things a naked return can't express. Progressive enhancement

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

@@ -105,6 +105,18 @@ export interface JSONCodecOptions {
     disabledFeatures?: number;
     /** Maximum parse/deserialize depth. Defaults to 64. Must match on both peers. */
     depthLimit?: number;
+    /**
+     * Whether serialized `Error`s carry their `.stack` — server file paths,
+     * internal function names, the shape of the deployment — to the peer.
+     * Defaults to `NODE_ENV === "development"`, but that signal describes the
+     * PROCESS, not the artifact: a production build running with
+     * `NODE_ENV=development` (a base image, a stray dotenv) ships stacks to
+     * the wire — including for errors marked safe with `markSafeError`, whose
+     * stacks traverse application code (#3152). Set `false` to pin production
+     * disclosure regardless of the ambient variable. Encode-side only; the
+     * decode side is always permissive, so it need not match peers.
+     */
+    serializeErrorStacks?: boolean;
 }
 /**
  * A resident, response-scoped decode table over the keyed JSON codec: apply
@@ -142,10 +154,11 @@ export declare const DEFAULT_WEB_PLUGINS: any; /**
  * Integration-facing; may change (see the entry banner).
  */
 export declare function resolveSerializerPlugins(customPlugins?: SerializerPlugin[]): SerializerPlugin[];
-export declare function resolveCodecOptions({ plugins, disabledFeatures, depthLimit }?: JSONCodecOptions): {
+export declare function resolveCodecOptions({ plugins, disabledFeatures, depthLimit, serializeErrorStacks }?: JSONCodecOptions): {
     plugins: SerializerPlugin<any, any>[];
     disabledFeatures: any;
     depthLimit: number;
+    serializeErrorStacks: boolean;
 }; /**
  * Creates the decoding counterpart of `serializeJSON`. Cross-references
  * between chunks resolve through state shared across calls, so all chunks

package/types-cjs/serializer.d.cts

@@ -19,6 +19,13 @@ export interface WebSerializerOptions {
      * any override — serialized stacks leak server paths to the client.
      */
     disabledFeatures?: number;
+    /**
+     * Whether serialized `Error`s carry their `.stack`. Defaults to
+     * `NODE_ENV === "development"`; set `false` to pin production disclosure
+     * to the deployment rather than the ambient variable (#3152 — see
+     * `JSONCodecOptions.serializeErrorStacks`).
+     */
+    serializeErrorStacks?: boolean;
     /** Extra plugins, composed ahead of `DEFAULT_WEB_PLUGINS`. */
     plugins?: SerializerPlugin[];
     /** Receives each emitted script chunk. */