@solidjs/web 2.0.0-experimental.9 → 2.0.0-rc.0

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

@@ -0,0 +1,222 @@
+// EXPERIMENTAL — the frames/server-components surface ships as an
+// experimental preview, excluded from the 2.0 stability guarantee: API
+// shapes and the wire format may change between prereleases (RFC 11).
+// Every export in this module is @experimental.
+import { FrameChunk, FrameHost } from "./frame-client.cjs";
+import { JSONCodecOptions } from "./serializer-decode.cjs";
+
+// Structural mirror of server-functions/shared.js's FlightDataConsumer:
+// this file may only reference siblings that ship with it when integrations
+// copy the frames declaration set (solid-web's types build), and the
+// server-functions declarations are copied to a different root.
+type FlightConsumer = (data: unknown, context: { response: Response }) => void | Promise<void>;
+
+/**
+ * Header tagging a Response as a frame stream; its value is the producing
+ * frame's id. Frame-owned wire contract — deliberately not a server-function
+ * `BodyFormat` entry, since the body is frame chunks, not a serialized value.
+ * @experimental
+ */
+export const FRAME_STREAM_HEADER: "X-Frame-Stream";
+
+/**
+ * Whether a fetch Response carries a frame stream.
+ * @experimental
+ */
+export function isFrameStreamResponse(response: Response): boolean;
+
+/**
+ * Options for `applyFrameResponse`.
+ * @experimental
+ */
+export interface ApplyFrameResponseOptions {
+  /**
+   * Remap the producer's root frame id onto a local one — the id your
+   * insertable/frame registered under — so navigations to the same boundary
+   * reuse the same frame regardless of what the server called it. Boundary
+   * identity belongs to the client.
+   */
+  as?: string;
+  /**
+   * Restamp every chunk of the response with this version (one response IS
+   * one version). Versions belong to the client too: the producer cannot
+   * know how many streams a boundary has consumed, so pass the Nth-response
+   * counter to make policy A's stale-guard real across navigations. A
+   * single-flight response addresses several boundaries, each with its own
+   * history — pass a function and it is called once per frame in the
+   * response.
+   */
+  version?: number | ((frameId: string) => number);
+  /**
+   * Receives the payload text of each `outcome` chunk — the response-scoped
+   * single-flight envelope, the caller's result rather than anything the
+   * host renders.
+   */
+  onOutcome?(payload: string): void;
+}
+
+/**
+ * Reads a frame-stream Response to completion, applying every chunk to
+ * `host`. Chunks are length-prefixed JSON over the server-function wire
+ * framing. Resolves with the id the chunks were applied under once the
+ * stream ends; rejects on a malformed or errored stream.
+ *
+ * @example
+ * ```ts
+ * const response = await getStory(id); // frame-tagged server function result
+ * if (isFrameStreamResponse(response)) {
+ *   await applyFrameResponse(response, host, { as: "story-pane" });
+ * }
+ * ```
+ * @experimental
+ */
+export function applyFrameResponse(
+  response: Response,
+  host: FrameHost,
+  options?: ApplyFrameResponseOptions
+): Promise<string>;
+
+/**
+ * Brands an inline-rendered server component with its function id.
+ * @experimental
+ */
+export const SERVER_COMPONENT: unique symbol;
+
+/**
+ * The unwrapped server component behind an inline-render wrap.
+ * @experimental
+ */
+export const SERVER_COMPONENT_SOURCE: unique symbol;
+
+/**
+ * The call's wire address (`frameAddress`), for regions to be emitted under.
+ * @experimental
+ */
+export const SERVER_COMPONENT_ADDRESS: unique symbol;
+
+/**
+ * The binding brand on values the transport resolves: `{ component, address }`
+ * — the identity split (DR-1). `component` is the mount identity, one per
+ * server function; `address` names the call's content store. An equals-gated
+ * reader compares `component` across resolutions: same function means "same
+ * instance, new binding" — keep the mounted instance and deliver the new
+ * address into it; a different function swaps normally. `Symbol.for`, so
+ * frameworks can honor it without importing this module.
+ * @experimental
+ */
+export const COMPONENT_BINDING: unique symbol;
+
+/**
+ * The value under `COMPONENT_BINDING` on a transport-resolved binding.
+ * @experimental
+ */
+export interface ComponentBinding<C = unknown> {
+  /** The per-function mount component (the equals-gate identity). */
+  component: C;
+  /** The call's intrinsic (function, arguments) address — its store's key. */
+  address: string;
+}
+
+/**
+ * Seroval plugin for a server component crossing a serialization boundary:
+ * a branded component serializes as a REFERENCE — a per-function document
+ * placeholder in the hydration serializer, a live-registry lookup by call
+ * address in the JSON codec (single-flight envelopes) — its markup never
+ * rides as data.
+ * @experimental
+ */
+export const ServerComponentPlugin: unknown;
+
+/**
+ * Installs the hydration-serializer registry prefix: given the emitted
+ * script's serializer context, returns the expression the next serialized
+ * reference reads the `_$SC` registry through (the self-bootstrapping form
+ * on a script's first reference, a bare read after). Loaded document-SSR
+ * modules install this (see frame-sink); client bundles never carry the
+ * bootstrap text.
+ * @experimental
+ */
+export function setServerComponentBootstrap(resolve: (ctx: unknown) => string): void;
+
+/**
+ * The codec options for a single-flight envelope: `codec` plus
+ * `ServerComponentPlugin` (deduped by tag). Injected by the protocol on both
+ * legs; exported for integrations composing their own flight carriers.
+ * @experimental
+ */
+export function flightCodec(codec?: JSONCodecOptions): JSONCodecOptions;
+
+/**
+ * Options for `createServerComponentHandler`.
+ * @experimental
+ */
+export interface ServerComponentHandlerOptions<C = unknown> {
+  host: FrameHost;
+  /**
+   * Builds the framework's mount component for a server FUNCTION. Invoked
+   * once per function and cached — this is the equals-gate identity every
+   * call of the function resolves through. The component is CALLED (by the
+   * binding wrapper or a gated reader), receiving its current address as a
+   * second argument (`() => string`); it should (re-)bind its frame's pull
+   * to that address's store. Multi-mount fans out per site.
+   */
+  component(fnId: string): C;
+  /**
+   * A new response is about to stream into an address: rotate
+   * response-scoped state (codec data tables) here. `version` is the
+   * client-owned stream counter the chunks will be stamped with.
+   */
+  onStream?(address: string, version: number, response: Response): void;
+  /**
+   * Answer a call SYNCHRONOUSLY before any request is made (t = 0 local
+   * answers — e.g. a boundary the document already carries). Returning a
+   * non-undefined value resolves the call with it; a hydrating consumer
+   * never observes a pending beat.
+   */
+  intercept?(info: { id: string; meta: unknown; args: unknown[] }): C | undefined;
+  /**
+   * Reads the registered single-flight consumer at delivery time. The
+   * consumer is module state in the server-function client's SHARED
+   * instance; pass a getter reading that instance when your bundling gives
+   * this module a private copy. Defaults to the local copy's reader.
+   */
+  consumer?(): FlightConsumer | undefined;
+  /**
+   * Reads the configured codec options at decode time — same instance-
+   * identity contract as `consumer`. Defaults to the local copy's reader.
+   */
+  codec?(): JSONCodecOptions | undefined;
+}
+
+/**
+ * The client mirror of `frameTransformResult`, shaped for the server-function
+ * client's `responseHandler` seam: frame-stream responses resolve the call
+ * with a **binding** — a callable wrapper branded `COMPONENT_BINDING` — so
+ * an equals-gated consumer (Solid's `dynamic`) never remounts across
+ * refetches or argument changes; the response streams into the address's
+ * resident store as the only observable effect.
+ *
+ * The identity split (DR-1): stores are keyed per-ADDRESS — the call's
+ * intrinsic (function, arguments) name, one-to-one with a query cache's
+ * per-args entries — while mounts are per-SITE, rendering the per-function
+ * component and following delivered addresses. An address nothing is bound
+ * to warms its store (preload isolation is the default, not a rule).
+ * @experimental
+ */
+export function createServerComponentHandler<C>(options: ServerComponentHandlerOptions<C>): {
+  intercept?(info: { id: string; meta: unknown; args: unknown[] }): unknown;
+  handle(
+    response: Response,
+    ctx: { id: string; meta: unknown; args: unknown[]; context: unknown }
+  ): unknown;
+  /**
+   * Declares that the document is showing a call: hydration-data references
+   * carry their call's address (`_$SC.r(id, address)`) but never travel
+   * through the transport, so the integration forwards those records here.
+   * Mints the call's binding (a post-load refetch then resolves a value
+   * whose component matches what the document mounted) and brands the
+   * per-function component so cache-seeded readers deliver instead of
+   * remounting when their site later switches calls.
+   */
+  showing(address: string, functionId: string): void;
+};

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

@@ -0,0 +1,182 @@
+// 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.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 ----
+//
+// 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);
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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.)
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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.
+ */
+export function createJSONSerializer(options: JSONSerializerOptions): {
+  write(key: string, value: unknown): void;
+  flush(): void;
+  close(): void;
+};

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

@@ -0,0 +1,52 @@
+import type { Element as SolidElement } from "solid-js";
+/**
+ * A client position in a server component: a prop the server renders (as JSX
+ * or by calling it) where client-owned markup belongs. `P` is the client
+ * component's own props, so a server component can reference the client
+ * component's type directly instead of restating it.
+ *
+ * Arguments are classified by VALUE, not by name — any prop may carry any of
+ * these:
+ *
+ * - primitives ride the chunk;
+ * - server JSX streams as a nested region (html once, never data);
+ * - anything else serializes as a data record.
+ *
+ * Async server JSX in an argument needs its own boundary: the region is
+ * emitted as one finished string, so a bare async read has no fallback to
+ * show and no fragment to reveal into.
+ *
+ * `$key` names the occurrence so client state follows an entity across
+ * responses rather than being positional — the slot-level analogue of `For`'s
+ * `keyed`, for when references can't carry identity because every response
+ * re-creates everything. It is occurrence identity, not client data: it is
+ * stripped before the client component sees its props. Positional identity is
+ * the right default; `$key` matters when a live list reorders.
+ * @experimental
+ */
+export type Slot<P = {}> = (props: P & {
+    $key?: string | number;
+}) => SolidElement;
+/**
+ * Types an async value crossing the slot border (DR-2, value tier). What you
+ * pass is what ships — the promise / async iterable itself rides the data
+ * channel — but the client's prop READ settles: it suspends into the covering
+ * boundary until first arrival (a promise's resolution, an iterable's first
+ * yield), then reads as the settled value, updating per yield for iterables.
+ *
+ * `asyncArg` is the type-level statement of that contract: identity at
+ * runtime, settled type at the border, so `Slot<P>` keeps the fill's props
+ * truthful to what its reads actually return.
+ *
+ * Slots render as JSX — the compiler wraps each prop in a getter so the read
+ * defers to the slot border, where the runtime owns it. A call form
+ * (`props.status({ … })`) evaluates its args eagerly in the component body —
+ * a top-level read, an error in most cases.
+ *
+ * ```tsx
+ * <props.status progress={asyncArg(gen.progress)} stats={asyncArg(gen.stats)} />
+ * ```
+ */
+export declare function asyncArg<T>(value: PromiseLike<T> | AsyncIterable<T>): T;
+export { renderToFrameStream, renderServerComponent, serverComponentResponse, frameTransformResult, frameTransformFlightResult, createFrameSink, frameTransformDirectResult, ServerComponentPlugin, SERVER_COMPONENT_BOOTSTRAP } from "./frame-sink.cjs";
+export { FRAME_STREAM_HEADER, isFrameStreamResponse } from "./frame-transport.cjs";

package/types-cjs/index.d.cts

@@ -0,0 +1,230 @@
+import { hydrate as hydrateCore } from "./client.cjs";
+import { Component } from "solid-js";
+import type { JSX } from "./jsx.cjs";
+export * from "./client.cjs";
+export * from "./server-mock.cjs";
+export * from "./response.cjs";
+export type { JSX } from "./jsx.cjs";
+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`
+ * resolved through the `solid` server export condition) sets it to `true`.
+ *
+ * Bundlers can dead-code-eliminate branches gated on `isServer`, so guarding
+ * browser-only code with `if (!isServer) {…}` keeps it out of the SSR bundle
+ * entirely.
+ *
+ * @example
+ * ```ts
+ * import { isServer } from "@solidjs/web";
+ *
+ * if (!isServer) {
+ *   // Browser-only: tree-shaken out of the SSR bundle.
+ *   window.addEventListener("resize", onResize);
+ * }
+ * ```
+ */
+export declare const isServer: boolean;
+/**
+ * Build-time constant indicating whether code is running in a dev build.
+ * Replaced statically (`_SOLID_DEV_`) by the bundler integration, so guards
+ * like `if (isDev) {…}` are stripped from production builds.
+ *
+ * Use this to gate dev-only diagnostics, warnings, or expensive invariants
+ * that should never ship to production.
+ *
+ * @example
+ * ```ts
+ * import { isDev } from "@solidjs/web";
+ *
+ * if (isDev) {
+ *   console.warn("debug-only path");
+ * }
+ * ```
+ */
+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>;
+export type DynamicProps<T extends ValidComponent, P = ComponentProps<T>> = {
+    [K in keyof P]: P[K];
+} & {
+    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.
+ *
+ * @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).
+ *
+ * If `mount` is omitted, the portal attaches to `document.body`. The portal
+ * still participates in the parent's reactive scope and disposes when the
+ * parent does.
+ *
+ * Portals are client-only islands: the server renders nothing for them, and
+ * under hydration the children render fresh once hydration settles. Async
+ * read inside a portal therefore starts on the client — data that should be
+ * fetched on the server belongs above the portal (hoist the read, not the
+ * render), and async UI inside one wants its own `<Loading>` boundary.
+ *
+ * @example
+ * ```tsx
+ * <Portal mount={document.getElementById("modal-root")!}>
+ *   <Dialog />
+ * </Portal>
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/components/portal
+ */
+export declare function Portal(props: {
+    mount?: Element;
+    children: JSX.Element;
+}): JSX.Element;
+export declare function dynamic<T extends ValidComponent>(source: () => T | Promise<T> | null | undefined | false): Component<ComponentProps<T>>;
+/**
+ * Renders an arbitrary custom or native component and forwards the other
+ * props. JSX form of `dynamic()` — same primitive, picked at the JSX site.
+ *
+ * @example
+ * ```tsx
+ * <Dynamic
+ *   component={multiline() ? RichTextEditor : "input"}
+ *   value={value()}
+ *   onInput={onInput}
+ * />
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/components/dynamic
+ */
+export declare function Dynamic<T extends ValidComponent>(props: DynamicProps<T>): JSX.Element;
+/**
+ * Wraps a dynamically imported component so it renders only in the browser.
+ * The server renders `props.fallback` (and nothing else); the client shows
+ * the fallback until the import resolves and the tree has mounted, then
+ * swaps the real component in.
+ *
+ * Unlike `lazy()`, this avoids Suspense entirely and never server-renders
+ * the wrapped component — only the fallback — so the component participates
+ * in no hydration asset manifest and its code is guaranteed to never run on
+ * the server (safe for browser-only libraries touching `window`, DOM
+ * measurement, etc.). The mount gate keeps hydration safe: during hydration
+ * the fallback is rendered exactly as the server did, and the swap happens
+ * only after settle, so there is no mismatch.
+ *
+ * By default the import starts as soon as `clientOnly` is called (module
+ * load); pass `{ lazy: true }` to defer the import to the component's first
+ * render.
+ *
+ * @example
+ * ```tsx
+ * const Chart = clientOnly(() => import("./Chart.jsx"));
+ * // <Chart fallback={<div>Loading chart…</div>} data={data()} />
+ * ```
+ */
+export declare function clientOnly<T extends Component<any>>(fn: () => Promise<{
+    default: T;
+}>, options?: {
+    lazy?: boolean;
+}, _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 — call it bare in a
+ * component or reactive-scope body where the status is decided (a 404
+ * route, an error fallback). Client build: a no-op — the response head was
+ * sent long ago.
+ *
+ * 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; like
+ * `createSignal`/`onCleanup` this is called in scope bodies and un-declares
+ * on scope disposal.
+ *
+ * Retraction semantics (server): the write snapshots the previous
+ * `event.response` status at write time and restores it when the owning
+ * scope is disposed — so a boundary that errored, declared a status, and
+ * then recovered retracts its write instead of stomping a status a
+ * surviving part of the tree legitimately set. Once the integration marks
+ * the response head `committed` (head derived/sent), writes and
+ * retractions are no-ops.
+ */
+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 — call it bare in a
+ * component or reactive-scope body. Client build: a no-op — the response
+ * head was sent long ago.
+ *
+ * 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; like
+ * `createSignal`/`onCleanup` this is called in scope bodies and un-declares
+ * on scope disposal.
+ *
+ * Retraction semantics (server): the header's prior value is snapshotted at
+ * write time and restored when the owning scope is disposed (deleted if
+ * there was none) — a boundary that errors or recovers retracts its writes.
+ * Once the integration marks the response head `committed` (head
+ * derived/sent), writes and retractions are no-ops.
+ */
+export declare function httpHeader(_name: string, _value: string, _options?: {
+    append?: boolean;
+}): void;