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

package/types/frames/serializer.d.ts

@@ -1,182 +1,94 @@
-// Serialization surface (published as `@solidjs/web/serialization`): the
-// runtime's Seroval machinery, exposed for the runtime's own entries and
-// for integrations building transports on the same codec. This is
-// INTEGRATION-FACING plumbing, not application API — it is exempt from the
-// 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 type { Serializer } from "seroval";
-import {
-  JSONCodecOptions,
-  PluginInfo,
-  SerializerPlugin,
-  SerovalNode
-} from "./serializer-decode.js";
-
-// 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.js";
-
-// ---- Plugin authoring ----
-//
-// Unlike the rest of this entry, plugin authoring is APPLICATION-FACING —
-// 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 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
- * plugin authors stay on the exact seroval instance/version the runtime
- * serializes with. Import it from HERE, not from your own `seroval`
- * dependency: a plugin built against a different copy/version would not
- * fail the build — it would emit nodes the other peer can't interpret.
- *
- * Application-facing (see the plugin-authoring banner above).
- */
-export function createPlugin<Value, Info extends PluginInfo>(
-  plugin: SerializerPlugin<Value, Info>
-): SerializerPlugin<Value, Info>;
-
-/**
- * Seroval's `OpaqueReference`, re-exported from the runtime's own instance
- * (an `OpaqueReference` from another seroval copy fails the serializer's
- * instanceof check and serializes as a plain value): wraps a value so it
- * crosses the wire as its `replacement` (default `undefined`) while
- * staying readable in-process through `.value`.
- *
- * Application-facing (see the plugin-authoring banner above).
- */
-export class OpaqueReference<V, R = undefined> {
-  readonly value: V;
-  readonly replacement?: R;
-  constructor(value: V, replacement?: R);
-}
-
+import { Serializer } from "seroval";
+import type { JSONCodecOptions, PluginInfo, SerializerPlugin, SerovalNode } from "./serializer-decode.js";
+export { DEFAULT_WEB_PLUGINS, createJSONDataTable, createJSONDeserializer, resolveSerializerPlugins } from "./serializer-decode.js";
+export type * from "./serializer-decode.js";
 /**
  * Options for `createSerializer`.
  *
  * Integration-facing; may change (see the entry banner).
  */
 export interface WebSerializerOptions {
-  /** Name of the global object the emitted scripts write resolved values into. */
-  globalIdentifier: string;
-  /** Cross-reference scope id, for isolating multiple streams on one page. */
-  scopeId?: string;
-  /**
-   * Seroval feature bitflags to exclude from output. Defaults to disabling
-   * post-ES2017 features (AggregateError, BigInt typed arrays). Outside
-   * development, `Error.prototype.stack` is additionally stripped on top of
-   * any override — serialized stacks leak server paths to the client.
-   */
-  disabledFeatures?: number;
-  /** Extra plugins, composed ahead of `DEFAULT_WEB_PLUGINS`. */
-  plugins?: SerializerPlugin[];
-  /** Receives each emitted script chunk. */
-  onData: (result: string) => void;
-  onError?: (error: unknown) => void;
-  /** Fires once all async values have settled. */
-  onDone?: () => void;
+    /** Name of the global object the emitted scripts write resolved values into. */
+    globalIdentifier: string;
+    /** Cross-reference scope id, for isolating multiple streams on one page. */
+    scopeId?: string;
+    /**
+     * Seroval feature bitflags to exclude from output. Defaults to disabling
+     * post-ES2017 features (AggregateError, BigInt typed arrays). Outside
+     * development, `Error.prototype.stack` is additionally stripped on top of
+     * any override — serialized stacks leak server paths to the client.
+     */
+    disabledFeatures?: number;
+    /** Extra plugins, composed ahead of `DEFAULT_WEB_PLUGINS`. */
+    plugins?: SerializerPlugin[];
+    /** Receives each emitted script chunk. */
+    onData: (result: string) => void;
+    onError?: (error: unknown) => void;
+    /** Fires once all async values have settled. */
+    onDone?: () => void;
 }
-
-/**
- * Creates a streaming Seroval serializer preconfigured with the web plugin
- * set and the default feature policy. Emits JavaScript chunks (through
- * `onData`) that reconstruct the values under `globalIdentifier` when
- * evaluated — the script-injection form of serialization renderers build
- * on. For a JSON-based wire codec (no eval on the receiving side), use
- * `serializeJSON` / `createJSONDeserializer` instead.
- *
- * Integration-facing; may change (see the entry banner).
- */
-export function createSerializer(options: WebSerializerOptions): Serializer;
-
 /**
  * Options for `createHydrationSerializer` — `WebSerializerOptions` minus
  * the knobs hydration pins (`globalIdentifier`, `disabledFeatures`).
  * @internal
  */
-export type HydrationSerializerOptions = Omit<
-  WebSerializerOptions,
-  "globalIdentifier" | "disabledFeatures"
->;
-
-/**
- * Renderer primitive — the serializer SSR uses for hydration output. Pins
- * the hydration global (`_$HY.r`) and feature policy; only the wiring
- * options (callbacks, scope, extra plugins) are configurable. Not meant
- * for hand-written code — custom serialization should use
- * `createSerializer` or the JSON codec.
- * @internal
- */
-export function createHydrationSerializer(options: HydrationSerializerOptions): Serializer;
-
-/**
- * Renderer primitive — returns the cross-reference bootstrap script SSR
- * emits ahead of hydration data for a render scope. Not meant for
- * hand-written code.
- * @internal
- */
-export function getLocalHeaderScript(id?: string): string;
-
-// ---- JSON codec (server function transports) ----
-// (`JSONCodecOptions` and the decode half are declared in
-// serializer-decode.d.ts and re-exported above.)
-
+export type HydrationSerializerOptions = Omit<WebSerializerOptions, "globalIdentifier" | "disabledFeatures">;
 /**
  * Options for `serializeJSON`.
  *
  * Integration-facing; may change (see the entry banner).
  */
 export interface JSONSerializeOptions extends JSONCodecOptions {
-  /**
-   * Receives each serialized node; `initial` is true for the first chunk
-   * (the source value itself). Async values produce additional chunks as
-   * they resolve.
-   */
-  onParse: (node: SerovalNode, initial: boolean) => void;
-  onError?: (error: unknown) => void;
-  /** Fires once all async values have settled. */
-  onDone?: () => void;
+    /**
+     * Receives each serialized node; `initial` is true for the first chunk
+     * (the source value itself). Async values produce additional chunks as
+     * they resolve.
+     */
+    onParse: (node: SerovalNode, initial: boolean) => void;
+    onError?: (error: unknown) => void;
+    /** Fires once all async values have settled. */
+    onDone?: () => void;
 }
-
-/**
- * Serializes `value` as SerovalNode chunks delivered through `onParse` —
- * the encoding half of the eval-free JSON codec (RPC-style transports;
- * the deserializing peer needs no script evaluation, so CSP-safe). Wire
- * framing of the nodes is the transport's concern. Returns a cancel
- * function that aborts pending async serialization.
- *
- * Integration-facing; may change (see the entry banner).
- */
-export function serializeJSON(value: unknown, options: JSONSerializeOptions): () => void;
-
 /** Options for `createJSONSerializer`. */
 export interface JSONSerializerOptions extends JSONCodecOptions {
-  /**
-   * Receives each keyed record — `initial` is true for a key's first node
-   * (the written value itself); async values patch through later records
-   * under the same key. The decoding peer is `createJSONDataTable`.
-   */
-  onData: (record: { key: string; node: SerovalNode; initial: boolean }) => void;
-  onError?: (error: unknown) => void;
-  /** Fires once `flush()` has been called and every pending value settled. */
-  onDone?: () => void;
+    /**
+     * Receives each keyed record — `initial` is true for a key's first node
+     * (the written value itself); async values patch through later records
+     * under the same key. The decoding peer is `createJSONDataTable`.
+     */
+    onData: (record: {
+        key: string;
+        node: SerovalNode;
+        initial: boolean;
+    }) => void;
+    onError?: (error: unknown) => void;
+    /** Fires once `flush()` has been called and every pending value settled. */
+    onDone?: () => void;
+}
+export declare const createPlugin: <Value, Info extends PluginInfo>(plugin: SerializerPlugin<Value, Info>) => SerializerPlugin<Value, Info>;
+export interface OpaqueReference<V = unknown, R = undefined> {
+    readonly value: V;
+    readonly replacement?: R;
 }
-
+export declare const OpaqueReference: {
+    new <V, R = undefined>(value: V, replacement?: R): OpaqueReference<V, R>;
+};
 /**
- * The keyed, streaming encoder of the eval-free JSON codec — the render
- * stream's data serializer (frames default to it). Each `write(key, value)`
- * shares one reference space, so cross-record identity holds; `flush()`
- * marks the write set complete (writes after it are dropped, mirroring the
- * hydration serializer); `close()` aborts pending async serialization.
+ * Creates a streaming Seroval serializer preconfigured with the web plugin
+ * set and the default feature policy. Emits JavaScript chunks (through
+ * `onData`) that reconstruct the values under `globalIdentifier` when
+ * evaluated — the script-injection form of serialization renderers build
+ * on. For a JSON-based wire codec (no eval on the receiving side), use
+ * `serializeJSON` / `createJSONDeserializer` instead.
+ *
+ * Integration-facing; may change (see the entry banner).
  */
-export function createJSONSerializer(options: JSONSerializerOptions): {
-  write(key: string, value: unknown): void;
-  flush(): void;
-  close(): void;
+export declare function createSerializer(options: WebSerializerOptions): Serializer;
+export declare function createHydrationSerializer(options: HydrationSerializerOptions): Serializer;
+export declare function getLocalHeaderScript(id?: string): string;
+export declare function serializeJSON(value: unknown, options: JSONSerializeOptions): () => void;
+export declare function createJSONSerializer(options: JSONSerializerOptions): {
+    write(key: string, value: unknown): void;
+    flush(): void;
+    close(): void;
 };

package/types/head.d.ts

@@ -0,0 +1,16 @@
+export declare const HEAD_ELIGIBLE_TAGS: Set<string>;
+export declare const HEAD_ATTR_NAME: RegExp;
+export declare const RESOURCE_LINK_RELS: Set<string>;
+export declare const STYLESHEET_FETCH_META: Set<string>;
+export declare function evalHeadValue(v: any): any;
+export declare function evalHeadProps(props: any, presets: any): {};
+export declare function classifyHeadTag(desc: any): {
+    resource: boolean;
+    rel: any;
+} | {
+    resource: boolean;
+    rel?: undefined;
+};
+export declare function resourceIdentity(tag: any, props: any): string;
+export declare function replaceableIdentity(tag: any, props: any, key: any, unique: any): any;
+export declare function resolveHead(groups: any): Map<any, any>;

package/types/index.d.ts

@@ -1,4 +1,3 @@
-import { hydrate as hydrateCore } from "./client.js";
 import { Component } from "solid-js";
 import type { JSX } from "./jsx.js";
 export * from "./client.js";
@@ -6,16 +5,6 @@ export * from "./server-mock.js";
 export * from "./response.js";
 export type { JSX } from "./jsx.js";
 export { For, Show, Switch, Match, Errored, Loading, Repeat, Reveal, NoHydration, Hydration } from "solid-js";
-import { merge } from "solid-js";
-/**
- * Compiler-emitted prop-spread helper. The JSX transform (in
- * `dom-expressions`) emits `mergeProps(...)` calls when compiling prop
- * spreads on components — it is *not* a user-facing API. Application code
- * should import `merge` from `solid-js` directly.
- *
- * @internal
- */
-export declare const mergeProps: typeof merge;
 /**
  * Build-time constant indicating whether code is running on the server. This
  * client entry sets it to `false`; the matching server entry (`@solidjs/web`
@@ -54,7 +43,6 @@ export declare const isServer: boolean;
  * ```
  */
 export declare const isDev: boolean;
-type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;
 export type IntrinsicElement = Extract<keyof JSX.IntrinsicElements, string>;
 export type ValidComponent = IntrinsicElement | Component<any> | (string & {});
 export type ComponentProps<T extends ValidComponent> = T extends Component<infer P> ? P : T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : Record<string, unknown>;
@@ -63,59 +51,6 @@ export type DynamicProps<T extends ValidComponent, P = ComponentProps<T>> = {
 } & {
     component: T | null | undefined | false;
 };
-/**
- * Renders a component tree into a DOM element. Returns a dispose function
- * that tears the tree down and cleans up reactive scopes when called.
- *
- * @example
- * ```tsx
- * import { render } from "@solidjs/web";
- *
- * const dispose = render(() => <App />, document.getElementById("root")!);
- *
- * // Later, to unmount:
- * dispose();
- * ```
- *
- * @remarks
- * The top-level insert is queued via `insertOptions: { schedule: true }` so
- * its initial DOM attach goes through the effect queue rather than executing
- * inline. This lets the mount participate in transitions: if an uncaught
- * async read surfaces during the initial render (no `Loading` ancestor
- * absorbs it), the mount is held by the transition and attaches atomically
- * once all pending settles. On the no-async happy path the tail `flush()`
- * drains the queued callback so the attach is synchronous by the time
- * `render()` returns. The dev enforcement window scopes
- * `ASYNC_OUTSIDE_LOADING_BOUNDARY` to the initial mount only.
- */
-export declare function render(code: () => JSX.Element, element: MountableElement, init?: unknown, options?: {
-    renderId?: string;
-}): () => void;
-/**
- * Resumes a server-rendered tree on the client, attaching event listeners
- * and reactive bindings without reconstructing the DOM. Returns a `dispose`
- * function that tears down reactive scopes (DOM nodes are left in place).
- *
- * Use this when the page HTML was produced by `renderToString` or
- * `renderToStream`. For client-only apps, use `render` instead.
- *
- * Pass `options.renderId` to hydrate one of multiple roots emitted by a
- * server render that used the same id.
- *
- * When the server renders a full document but the client hydrates only the
- * app subtree, the server must give that subtree its own id namespace: wrap
- * the document shell in `<NoHydration>` and re-enter with `<Hydration>`
- * around the app. Otherwise the app's hydration ids are allocated under the
- * document component's owner tree and this walk can never claim them.
- *
- * @example
- * ```tsx
- * import { hydrate } from "@solidjs/web";
- *
- * hydrate(() => <App />, document.getElementById("root")!);
- * ```
- */
-export declare const hydrate: typeof hydrateCore;
 /**
  * Renders its children into a different part of the DOM (modal roots,
  * tooltips, layers that need to escape an `overflow: hidden` ancestor).

package/types/index.server.d.ts

@@ -0,0 +1,125 @@
+import { type Component } from "solid-js";
+import type { JSX } from "./jsx.js";
+export * from "./server.js";
+export * from "./response.js";
+export type { JSX } from "./jsx.js";
+export { For, Show, Loading, Reveal, Switch, Match, Repeat, Errored, NoHydration, Hydration } from "solid-js";
+/**
+ * Build-time constant indicating whether code is running on the server. This
+ * is the server entry; the value is `true`. The client entry of `@solidjs/web`
+ * sets it to `false`. See the client-entry JSDoc for the canonical guard
+ * pattern.
+ */
+export declare const isServer: boolean;
+/**
+ * Build-time constant indicating whether code is running in a dev build.
+ * The server entry hard-codes `false` (SSR builds are production by
+ * convention); the client entry's value is set by `_SOLID_DEV_` substitution.
+ */
+export declare const isDev: boolean;
+export type IntrinsicElement = Extract<keyof JSX.IntrinsicElements, string>;
+export type ValidComponent = IntrinsicElement | Component<any> | (string & {});
+export type ComponentProps<T extends ValidComponent> = T extends Component<infer P> ? P : T extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[T] : Record<string, unknown>;
+export declare function dynamic<T extends ValidComponent>(source: () => T | Promise<T> | null | undefined | false): Component<ComponentProps<T>>;
+export type DynamicProps<T extends ValidComponent, P = ComponentProps<T>> = {
+    [K in keyof P]: P[K];
+} & {
+    component: T | null | undefined | false;
+};
+export declare function Dynamic<T extends ValidComponent>(props: DynamicProps<T>): JSX.Element;
+/**
+ * Portals are client-only islands: the server renders nothing for them —
+ * `props.children` is never evaluated, no async is started, and nothing is
+ * serialized. The client renders the content fresh once hydration settles.
+ * Throwing here instead (as earlier betas did) is strictly worse: an ancestor
+ * `Errored` catches it and bakes the error fallback into the streamed HTML
+ * for a tree that renders fine client-side (#2876).
+ *
+ * The one thing both sides must still agree on is the parent's child-id
+ * counter: the client Portal scopes its internals under one owner (one slot),
+ * so consume the matching slot here or every hydration id after the portal
+ * drifts.
+ */
+export declare function Portal(props: {
+    mount?: Element;
+    children: JSX.Element;
+}): JSX.Element;
+/**
+ * Server half of `clientOnly`: the wrapped component never renders on the
+ * server — the import is never even started — only `props.fallback` is
+ * SSR'd. The client build swaps the real component in after load + mount.
+ * See the client entry's JSDoc for the full contract.
+ *
+ * `moduleUrl` is injected by the bundler's module-URL pass (the same one
+ * that annotates `lazy()`, padding the options slot when a call site omits
+ * it); when present and an asset manifest is set, the render emits early
+ * preload hints for the module — see `registerClientOnlyPreload` for why
+ * they stay out of the hydration asset map. Without it (untransformed code)
+ * or without a manifest, behavior is unchanged.
+ */
+export declare function clientOnly<M extends Record<string, any>, K extends keyof M & string>(fn: () => Promise<M>, options: {
+    lazy?: boolean;
+    export: K;
+}, moduleUrl?: string): Component<ComponentProps<M[K]> & {
+    fallback?: JSX.Element;
+}>;
+export declare function clientOnly<T extends Component<any>>(fn: () => Promise<{
+    default: T;
+}>, options?: {
+    lazy?: boolean;
+    export?: string;
+}, moduleUrl?: string): Component<ComponentProps<T> & {
+    fallback?: JSX.Element;
+}>;
+/**
+ * Declares the HTTP response status (and optional status text) for the
+ * lifetime of the current reactive scope during SSR, writing to the request
+ * event's `response` head (core's `ResponseStub`, exposed by the
+ * integration).
+ *
+ * Naming note — this is a scope-tied *declaration*, not a mutation: "while
+ * this reactive scope is live, the response has this status." Solid reserves
+ * `set*` verbs for event-time mutation; `httpStatus` is called bare in a
+ * component or reactive-scope body (like `createSignal`/`onCleanup`) and
+ * un-declares on scope disposal.
+ *
+ * Retraction semantics: disposal retracts only this scope's declaration —
+ * the response falls back to the latest still-live declaration, or to the
+ * base status the integration had set before the first declaration. A
+ * boundary that errored, declared a status, and then recovered retracts its
+ * write without stomping a status a surviving part of the tree legitimately
+ * set (e.g. a 404 page whose inner boundary recovers stays a 404), and
+ * sibling scopes may dispose in any order (#2984). Both the write and the
+ * cleanup are no-ops once the integration marks the response head
+ * `committed` (head derived/sent — status can no longer change). On the
+ * client this is a no-op.
+ */
+export declare function httpStatus(code: number, text?: string): void;
+/**
+ * Declares an HTTP response header (or with `append`, appends to one) for
+ * the lifetime of the current reactive scope during SSR, writing to the
+ * request event's `response` head (core's `ResponseStub`, exposed by the
+ * integration).
+ *
+ * Naming note — this is a scope-tied *declaration*, not a mutation: "while
+ * this reactive scope is live, the response has this header." Solid reserves
+ * `set*` verbs for event-time mutation; `httpHeader` is called bare in a
+ * component or reactive-scope body (like `createSignal`/`onCleanup`) and
+ * un-declares on scope disposal.
+ *
+ * Retraction semantics: disposal retracts only this scope's declaration —
+ * the header is recomputed by replaying the still-live declarations, in
+ * their original write order, over the base value the integration had set
+ * before the first declaration (deleted when there is neither). Sibling
+ * scopes may therefore dispose in any order without disturbing each
+ * other's contributions (#2984). For `set-cookie` — the one header whose
+ * multiple values must survive as separate entries — the base is captured
+ * and replayed entry-exact (`getSetCookie()` + re-append; `get()`/`set()`
+ * would comma-join the entries and then collapse them into one corrupt
+ * header). Both the write and the cleanup are no-ops once the integration
+ * marks the response head `committed` (head derived/sent — headers can no
+ * longer change). On the client this is a no-op.
+ */
+export declare function httpHeader(name: string, value: string, options?: {
+    append?: boolean;
+}): void;

package/types/jsx.d.ts

@@ -1,14 +1,15 @@
 /**
-	THIS FILE IS GENERATED BY `./jsx-update.mjs`.
-	PLEASE UPDATE `jsx-h.d.ts` INSTEAD AND RUN `pnpm jsx-sync-types`.
-*/
+ * THIS FILE IS GENERATED by `scripts/jsx-sync.mjs`.
+ * Edit `jsx-h.d.ts` and run `pnpm --filter @solidjs/web jsx-sync`
+ * (also runs as part of `pnpm types`).
+ */
 
 import * as csstype from "csstype";
 import type { PropKey, WidenPropValue } from "./jsx-properties.js";
 import type { Element as SolidElement } from "solid-js";
 
 /**
- * Originally based on JSX types for Surplus and Inferno and adapted for `dom-expressions`.
+ * Originally based on JSX types for Surplus and Inferno and adapted for Solid.
  *
  * - https://github.com/adamhaile/surplus/blob/master/index.d.ts
  * - https://github.com/infernojs/inferno/blob/master/packages/inferno/src/core/types.ts
@@ -249,15 +250,6 @@ export namespace JSX {
     ref?: Ref<T>;
     children?: Element | undefined;
     $ServerOnly?: boolean | undefined;
-    /**
-     * Entity identity for server markup (SSR-only): compiles to the `_key`
-     * attribute the frame morph matches keyed elements by, so live element
-     * state (form values, `open`, focus) follows the entity across
-     * reordering morphs. Sibling-scoped, like client keyed rendering.
-     * Stripped from DOM compiles; on components, `$key` is slot occurrence
-     * identity instead.
-     */
-    $key?: string | number | undefined;
   }
   interface ExplicitProperties {}
   type PropAttributes = {

package/types/reconcile.d.ts

@@ -0,0 +1 @@
+export default function reconcileArrays(parentNode: Node, a: Node[], b: Node[], marker?: Node | null): void;

package/types/render.d.ts

@@ -0,0 +1,4 @@
+export declare function effect<T>(fn: (prev?: T) => T, effectFn: (value: T, prev?: T) => void, options?: {
+    scope?: boolean;
+}): void;
+export declare function memo<T>(fn: () => T): () => T;