npm - @solidjs/web - Versions diffs - 2.0.0-beta.31 → 2.0.0-beta.32 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (64) hide show

package/README.md +1 -6
package/dist/dev.cjs +234 -45
package/dist/dev.js +221 -42
package/dist/server.cjs +456 -123
package/dist/server.js +445 -120
package/dist/web.cjs +234 -45
package/dist/web.js +221 -42
package/frames/dist/client.cjs +217 -112
package/frames/dist/client.dev.cjs +217 -112
package/frames/dist/client.dev.js +218 -113
package/frames/dist/client.js +218 -113
package/frames/dist/server.cjs +488 -177
package/frames/dist/server.js +489 -179
package/package.json +55 -4
package/serialization/dist/serialization.cjs +8 -0
package/serialization/dist/serialization.js +1 -0
package/serialization/types/index.d.ts +173 -6
package/serialization/types-cjs/index.d.cts +173 -6
package/server-functions/dist/client.cjs +46 -9
package/server-functions/dist/client.js +47 -11
package/server-functions/dist/rich-args.cjs +11 -0
package/server-functions/dist/rich-args.js +9 -0
package/server-functions/dist/server.cjs +275 -126
package/server-functions/dist/server.dev.cjs +1053 -0
package/server-functions/dist/server.dev.js +1021 -0
package/server-functions/dist/server.js +273 -127
package/server-functions/package.json +10 -0
package/server-functions/rich-args/package.json +20 -0
package/storage/types/index.d.ts +1 -1
package/storage/types-cjs/index.d.cts +1 -1
package/types/client.d.ts +127 -6
package/types/core.d.ts +3 -1
package/types/frames/client.d.ts +15 -1
package/types/frames/frame-client.d.ts +37 -7
package/types/frames/frame-sink.d.ts +26 -3
package/types/frames/frame-transport.d.ts +39 -7
package/types/frames/serializer.d.ts +173 -6
package/types/frames/server.d.ts +22 -0
package/types/index.d.ts +2 -3
package/types/response.d.ts +45 -0
package/types/serializer.d.ts +173 -6
package/types/server-functions/client.d.ts +1 -0
package/types/server-functions/rich-args.d.ts +10 -0
package/types/server-functions/server.d.ts +98 -0
package/types/server-functions/shared.d.ts +22 -0
package/types/server-mock.d.ts +171 -59
package/types/server.d.ts +188 -36
package/types-cjs/client.d.cts +127 -6
package/types-cjs/core.d.cts +3 -1
package/types-cjs/frames/client.d.cts +15 -1
package/types-cjs/frames/frame-client.d.cts +37 -7
package/types-cjs/frames/frame-sink.d.cts +26 -3
package/types-cjs/frames/frame-transport.d.cts +39 -7
package/types-cjs/frames/serializer.d.cts +173 -6
package/types-cjs/frames/server.d.cts +22 -0
package/types-cjs/index.d.cts +2 -3
package/types-cjs/response.d.cts +45 -0
package/types-cjs/serializer.d.cts +173 -6
package/types-cjs/server-functions/client.d.cts +1 -0
package/types-cjs/server-functions/rich-args.d.cts +10 -0
package/types-cjs/server-functions/server.d.cts +98 -0
package/types-cjs/server-functions/shared.d.cts +22 -0
package/types-cjs/server-mock.d.cts +171 -59
package/types-cjs/server.d.cts +188 -36

package/types-cjs/server-mock.d.cts CHANGED Viewed

@@ -1,7 +1,48 @@
+import type { RequestEvent, RequestEventLocals, ResponseStub } from "./client.cjs";
+/** 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[];
+}> & {
+    _base?: string;
+};
+/** Inline style content, e.g. dev CSS collected from a bundler's module graph. */
+export type InlineStyleAsset = {
+    id: string;
+    content: string;
+    attrs?: Record<string, string>;
+};
+export type ResolvedAssets = {
+    js: string[];
+    css: (string | InlineStyleAsset)[];
+};
+/**
+ * Resolver form of the manifest option — the primitive a dev server
+ * implements against its live module graph (a static manifest object is
+ * 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 }`.
+ */
+export type AssetResolver = {
+    resolve(key: string): ResolvedAssets | null | undefined | Promise<ResolvedAssets | null | undefined>;
+    /**
+     * Synchronous fast path answering with whatever is knowable without async
+     * work (typically js URLs, omitting css). Sync consumers — e.g. a lazy
+     * component's `moduleUrl` getter used by islands — use this when `resolve`
+     * would return a promise, so adapters should provide it whenever possible.
+     */
+    resolveSync?(key: string): ResolvedAssets | null | undefined;
+};
+/** Bare-function shorthand for `AssetResolver` (no sync fast path). */
+export type AssetResolverFn = (key: string) => ResolvedAssets | null | undefined | Promise<ResolvedAssets | null | undefined>;
 /**
  * Renders a component tree synchronously to an HTML string. Async reads inside
  * `<Loading>` boundaries emit their `fallback` content; for full-graph
- * resolution use `renderToStringAsync` instead.
+ * resolution await `renderToStream` instead.
  *
  * Pair the returned HTML with `hydrate()` on the client.
  *
@@ -18,45 +59,20 @@ export declare function renderToString<T>(fn: () => T, options?: {
     renderId?: string;
     noScripts?: boolean;
     plugins?: any[];
-    manifest?: Record<string, {
-        file: string;
-        css?: string[];
-        isEntry?: boolean;
-        isDynamicEntry?: boolean;
-        imports?: string[];
-    }>;
+    manifest?: AssetManifest | AssetResolver | AssetResolverFn;
     onError?: (err: any) => void;
+    /**
+     * Embedded-render contract for hosts that own the document. When the
+     * render output contains no `</head>`, everything head-bound (resolved
+     * `useHead` winners, eager resources, tracked asset links, inline
+     * styles) is delivered here as one HTML string — prelude (charset/base)
+     * first — for the host to splice into its own `<head>` template, instead
+     * of being dropped. Called synchronously before `renderToString`
+     * returns; not called when the output has a `</head>` (splicing is
+     * automatic then).
+     */
+    onHead?: (head: string) => void;
 }): string;
-/**
- * Renders a component tree to an HTML string and awaits all async reads in the
- * subtree before resolving. The returned HTML reflects the fully-settled state
- * — no `<Loading>` fallbacks appear in the output.
- *
- * Use this when you want a complete page in one round-trip. For incremental
- * streaming with progressive boundary resolution, use `renderToStream`.
- *
- * @example
- * ```tsx
- * import { renderToStringAsync } from "@solidjs/web";
- *
- * const html = await renderToStringAsync(() => <App />);
- * ```
- */
-export declare function renderToStringAsync<T>(fn: () => T, options?: {
-    timeoutMs?: number;
-    nonce?: string;
-    renderId?: string;
-    noScripts?: boolean;
-    plugins?: any[];
-    manifest?: Record<string, {
-        file: string;
-        css?: string[];
-        isEntry?: boolean;
-        isDynamicEntry?: boolean;
-        imports?: string[];
-    }>;
-    onError?: (err: any) => void;
-}): Promise<string>;
 /**
  * Streams an HTML response, flushing the synchronous shell first and then
  * progressively emitting async-resolved fragments as their `<Loading>`
@@ -64,9 +80,10 @@ export declare function renderToStringAsync<T>(fn: () => T, options?: {
  *
  * Returns an object with `pipe`/`pipeTo` for piping to a Node `Writable` or
  * a Web `WritableStream`, a lazy `readable` byte-stream view for
- * `new Response(stream.readable)`, plus a `then` for awaiting full
- * completion. `pipe`, `pipeTo`, and `readable` each consume the render —
- * use exactly one of the three.
+ * `new Response(stream.readable)`, plus a thenable for awaiting full
+ * completion — `await renderToStream(...)` resolves with the settled HTML
+ * (the fully-resolved-string form of the render). `pipe`, `pipeTo`, and
+ * `readable` each consume the render — use exactly one of the three.
  *
  * @example
  * ```tsx
@@ -77,6 +94,9 @@ export declare function renderToStringAsync<T>(fn: () => T, options?: {
  *
  * // Web (Workers / Deno):
  * return new Response(renderToStream(() => <App />).readable);
+ *
+ * // Fully settled string:
+ * const html = await renderToStream(() => <App />);
  * ```
  */
 export declare function renderToStream<T>(fn: () => T, options?: {
@@ -84,13 +104,7 @@ export declare function renderToStream<T>(fn: () => T, options?: {
     renderId?: string;
     noScripts?: boolean;
     plugins?: any[];
-    manifest?: Record<string, {
-        file: string;
-        css?: string[];
-        isEntry?: boolean;
-        isDynamicEntry?: boolean;
-        imports?: string[];
-    }>;
+    manifest?: AssetManifest | AssetResolver | AssetResolverFn;
     onCompleteShell?: (info: {
         write: (v: string) => void;
     }) => void;
@@ -98,8 +112,25 @@ export declare function renderToStream<T>(fn: () => T, options?: {
         write: (v: string) => void;
     }) => void;
     onError?: (err: any) => void;
+    /**
+     * Embedded-render contract for hosts that own the document. When the
+     * shell contains no `</head>`, everything head-bound at first flush
+     * (resolved `useHead` winners, eager resources, tracked asset links,
+     * inline styles) is delivered here as one HTML string — prelude first —
+     * before the shell chunk is emitted, so the host can write its own
+     * `<head>` ahead of piping the stream. Post-shell head updates flow
+     * through the stream itself and apply in the browser. Not called when
+     * the shell has a `</head>` (splicing is automatic then).
+     */
+    onHead?: (head: string) => void;
 }): {
-    then: (fn: (html: string) => void) => void;
+    /**
+     * Awaiting the stream resolves with the complete HTML once every boundary
+     * settles — the fully-settled-string form of the render. Render errors
+     * route through `onError` and the promise resolves with whatever HTML the
+     * render produced; it never rejects.
+     */
+    then<TResult1 = string, TResult2 = never>(onfulfilled?: ((html: string) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
     pipe: (writable: {
         write: (v: string) => void;
         end: () => void;
@@ -107,6 +138,75 @@ export declare function renderToStream<T>(fn: () => T, options?: {
     pipeTo: (writable: WritableStream) => Promise<void>;
     readonly readable: ReadableStream<Uint8Array>;
 };
+/**
+ * Fetch-style middleware: receives the `Request` and a `next` continuation
+ * (pass a `Request` to substitute it downstream) and returns the `Response`.
+ * Composed with `composeMiddleware`; runs inside the request-event scope, so
+ * `getRequestEvent()` works exactly as in application code.
+ */
+export type FetchMiddleware = (request: Request, next: (request?: Request) => Promise<Response>) => Response | Promise<Response>;
+/**
+ * Creates a fresh, uncommitted {@link ResponseStub}. Server-only.
+ */
+export declare function createResponseStub(): ResponseStub;
+/**
+ * Builds the canonical request event — a web-standard `Request`, a `locals`
+ * bag, and a stub-backed `response` head — for `provideRequestEvent`.
+ * Server-only: on the client the request event belongs to the server that
+ * rendered the page.
+ */
+export declare function createRequestEvent<T extends object = {}>(request: Request, init?: T): {
+    request: Request;
+    locals: RequestEventLocals;
+    response: ResponseStub;
+} & T;
+/**
+ * The HTTP status a redirect should use: the stub's own status when it is a
+ * redirect status (301/302/303/307/308), 302 otherwise. Server-only.
+ */
+export declare function getExpectedRedirectStatus(response: ResponseStub): number;
+/**
+ * Derives the outgoing `Response` for an SSR render result, running the
+ * response-head lifecycle against `event.response`: the stub commits at
+ * shell flush, a pre-flush `Location` becomes a real redirect
+ * (`getExpectedRedirectStatus`), and a post-flush one appends the
+ * nonce-aware `<script>window.location=...</script>` fallback. String
+ * results return a `Response` synchronously; stream results resolve at
+ * shell flush. Server-only.
+ */
+export declare function createSSRResponse(result: string, event: RequestEvent | undefined, options?: {
+    responseInit?: ResponseInit;
+    nonce?: string;
+    transformChunk?: (chunk: string) => string;
+}): Response;
+export declare function createSSRResponse(result: {
+    pipe(writable: {
+        write: (v: string) => void;
+        end: () => void;
+    }): void;
+}, event: RequestEvent | undefined, options?: {
+    responseInit?: ResponseInit;
+    nonce?: string;
+    transformChunk?: (chunk: string) => string;
+}): Promise<Response>;
+/**
+ * Handler-lifecycle plumbing — the exit for a `Response` that did not go
+ * through `createSSRResponse` (a middleware early return, an API result):
+ * folds the request event's response stub onto it (cookies append
+ * entry-by-entry, other headers gap-fill, status never) and commits the
+ * stub. Already-committed stubs pass the response through untouched, so
+ * handlers apply it unconditionally after their middleware chain unwinds.
+ * `event` defaults to the ambient `getRequestEvent()`. Application
+ * middleware never calls this. Server-only.
+ */
+export declare function commitEventResponse(response: Response, event?: RequestEvent): Response;
+/**
+ * Composes fetch-style middleware — `(request, next) => Response` — into a
+ * single function of the same shape. Nothing reaches the wire until the
+ * outermost middleware returns, so headers on the returned `Response` stay
+ * mutable through the whole unwind, streamed bodies included. Server-only.
+ */
+export declare function composeMiddleware(middlewares: FetchMiddleware[]): (request: Request, next: (request?: Request) => Response | Promise<Response>) => Promise<Response>;
 /**
  * Compiler primitive — emitted by JSX-DOM-Expressions for tagged-template
  * SSR output. Not meant for hand-written code.
@@ -124,27 +224,39 @@ export declare function ssrElement(name: string, props: any, children: any, need
     t: string;
 };
 /**
- * Compiler primitive — serializes a classList object for SSR output. Not
- * meant for hand-written code.
+ * Compiler primitive — serializes a class value (string, object map, or
+ * array) for SSR output. Not meant for hand-written code.
  * @internal
  */
-export declare function ssrClassList(value: {
+export declare function ssrClassName(value: string | {
     [k: string]: boolean;
-}): string;
+} | Array<any>): string;
 /**
- * Compiler primitive — serializes a style object for SSR output. Not meant
+ * Compiler primitive — serializes a style value for SSR output. Not meant
  * for hand-written code.
  * @internal
  */
-export declare function ssrStyle(value: {
+export declare function ssrStyle(value: string | {
     [k: string]: string;
 }): string;
 /**
- * Compiler primitive — serializes a boolean attribute for SSR output. Not
+ * Compiler primitive — serializes one style property for SSR output. Not
+ * meant for hand-written code.
+ * @internal
+ */
+export declare function ssrStyleProperty(name: string, value: any): string;
+/**
+ * Compiler primitive — serializes an attribute for SSR output. Not meant
+ * for hand-written code.
+ * @internal
+ */
+export declare function ssrAttribute(key: string, value: any): string;
+/**
+ * Compiler primitive — wraps a template-group closure for SSR output. Not
  * meant for hand-written code.
  * @internal
  */
-export declare function ssrAttribute(key: string, value: boolean): string;
+export declare function ssrGroup<T extends () => any[]>(fn: T, n: number): T;
 /**
  * Compiler primitive — generates the hydration-key attribute for SSR
  * output. Not meant for hand-written code.
@@ -156,10 +268,10 @@ export declare function ssrHydrationKey(): string;
  * Not meant for hand-written code.
  * @internal
  */
-export declare function resolveSSRNode(node: any): string;
+export declare function resolveSSRNode(node: any, result?: any, top?: boolean): any;
 /**
  * Escapes a string for safe inclusion in HTML output. Used by the SSR
  * runtime; not generally part of user code.
  * @internal
  */
-export declare function escape(html: string): string;
+export declare function escape(s: any, attr?: boolean): any;

package/types-cjs/server.d.cts CHANGED Viewed

@@ -79,19 +79,6 @@ export function renderToString<T>(
     onHead?: (head: string) => void;
   }
 ): string;
-/** @deprecated use renderToStream which also returns a promise */
-export function renderToStringAsync<T>(
-  fn: () => T,
-  options?: {
-    timeoutMs?: number;
-    nonce?: string;
-    renderId?: string;
-    noScripts?: boolean;
-    plugins?: SerializerPlugin[];
-    manifest?: AssetManifest | AssetResolver | AssetResolverFn;
-    onError?: (err: any) => void;
-  }
-): Promise<string>;
 export function renderToStream<T>(
   fn: () => T,
   options?: {
@@ -116,7 +103,17 @@ export function renderToStream<T>(
     onHead?: (head: string) => void;
   }
 ): {
-  then: (fn: (html: string) => void) => void;
+  /**
+   * Awaiting the stream resolves with the complete HTML once every boundary
+   * settles — the fully-settled-string form of the render (`const html =
+   * await renderToStream(...)`). Render errors route through `onError` and
+   * the promise resolves with whatever HTML the render produced; it never
+   * rejects.
+   */
+  then<TResult1 = string, TResult2 = never>(
+    onfulfilled?: ((html: string) => TResult1 | PromiseLike<TResult1>) | null,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
+  ): Promise<TResult1 | TResult2>;
   pipe: (writable: { write: (v: string) => void; end: () => void }) => void;
   pipeTo: (writable: WritableStream) => Promise<void>;
   /**
@@ -153,21 +150,20 @@ export function applyRef(
   r: ((element: any) => void) | ((element: any) => void)[],
   element: any
 ): void;
-/** @deprecated Use `useHead` — removed before `0.50.0` stable. */
-export function useAssets(fn: () => JSX.Element): void;
-/**
- * @deprecated Use the `onHead` render option — removed before `0.50.0`
- * stable. Reads ambient render state, so it is unsafe across concurrent
- * renders; `onHead` is closure-bound to its render and also carries
- * `useHead` output, which this does not.
- */
-export function getAssets(): string;
 /**
  * A head tag descriptor. Props values may be getters (evaluated lazily on
  * the server — at the owning flush boundary — and reactively on the client);
  * `children` is the text body (title text, inline style/script content).
  * `key` overrides the built-in dedupe identity (`title` is a hard singleton
  * that `key` cannot fork).
+ *
+ * Getters must be plain reads: they evaluate at flush time here (under no
+ * component owner) and inside registry-owned computations on the client, so
+ * a getter that allocates a reactive owner (`createMemo`, a `children()`
+ * helper) consumes a hydration id slot on one side only and desyncs every
+ * id allocated after the `useHead` call. Create such helpers eagerly at
+ * component position and read them from the getter. See
+ * docs/head-management-rfc.md.
  */
 export type HeadTag = {
   tag: "title" | "meta" | "link" | "style" | "script" | "base";
@@ -212,32 +208,62 @@ export declare const RequestContext: unique symbol;
  * `response` property on `RequestEvent` itself: integrations that provide
  * one declare it through module augmentation (as `@solidjs/router` does),
  * and this type names the shape they agree on. Core's server-function
- * handler reads its `Set-Cookie` headers when folding single-flight
- * cookies but never requires it.
+ * handler folds it onto the outgoing response when present — its
+ * `Set-Cookie` values (cookies appended during the call via
+ * `serializeCookie`) append cookie-by-cookie, other headers fill gaps —
+ * and reads it when folding single-flight cookies, but never requires it.
  */
 export interface ResponseStub {
   status?: number;
   statusText?: string;
   headers: Headers;
   /**
-   * Set by the integration once the response head has been derived/sent
-   * from this stub — status and headers can no longer change. Consumers
-   * that write response metadata during render (e.g. JSX response
-   * components) must treat later status/header writes and cleanup-time
-   * retractions as no-ops.
+   * Set once the response head has been derived/sent from this stub —
+   * status and headers can no longer change. Flip it through
+   * `commitResponseStub`, which also instruments the stub's `headers` so
+   * a post-commit write fails loudly (dev build throws, production
+   * reports + no-ops) instead of silently missing the wire. `status`/
+   * `statusText` stay plain fields: consumers that write response
+   * metadata during render (e.g. JSX response components) must still
+   * treat later status writes and cleanup-time retractions as no-ops.
    */
   committed?: boolean;
 }
+/**
+ * The type of `RequestEvent.locals` — a module-augmentable interface so
+ * applications can type the state their middleware hangs on the event.
+ * Augment it through the package that re-exports the event (interface
+ * identity flows through the re-export chain):
+ *
+ * ```ts
+ * declare module "@solidjs/web" {
+ *   interface RequestEventLocals {
+ *     user: User;
+ *   }
+ * }
+ * ```
+ *
+ * The index signature keeps un-augmented usage permissive — `locals` is a
+ * free-form bag by default — so augmentation adds precision for the keys
+ * it names without gating existing code. The flip side: unaugmented keys
+ * read as `any` rather than erroring, a deliberate trade (a strict-only
+ * `locals` would break every untyped write that works today).
+ */
+export interface RequestEventLocals {
+  [key: string | number | symbol]: any;
+}
 /**
  * The per-request context available on the server: the incoming `Request`
- * and a `locals` bag integrations and middleware can hang state on.
- * Frameworks typically extend this shape with richer fields (e.g. a
- * `response` head — see `ResponseStub`).
+ * and a `locals` bag integrations and middleware can hang state on (typed
+ * through the augmentable `RequestEventLocals`). Frameworks typically
+ * extend this shape with richer fields (e.g. a `response` head — see
+ * `ResponseStub`).
  */
 export interface RequestEvent {
   request: Request;
-  locals: Record<string | number | symbol, any>;
+  locals: RequestEventLocals;
 }
 /**
  * The current request event, when called on the server inside a request
@@ -247,7 +273,129 @@ export interface RequestEvent {
  */
 export function getRequestEvent(): RequestEvent | undefined;
-export function Assets(props: { children?: JSX.Element }): JSX.Element;
+/** A fresh, uncommitted response head. */
+export function createResponseStub(): ResponseStub;
+/**
+ * The canonical request event for HTTP handlers: the incoming `Request`, a
+ * `locals` bag, and a `response` head stub the render writes to. `init`
+ * spreads over the defaults so frameworks can extend the shape.
+ */
+export function createRequestEvent<T extends object = {}>(
+  request: Request,
+  init?: T
+): RequestEvent & { response: ResponseStub } & T;
+/**
+ * The status an outgoing redirect should use for a response head carrying
+ * a `Location`: the stub's own status when it is a redirect status, 302
+ * otherwise.
+ */
+export function getExpectedRedirectStatus(response: ResponseStub): number;
+/**
+ * Flips a response stub to `committed` — the moment its head freezes on
+ * the wire — and instruments the stub's `headers` mutating methods
+ * (`set`/`append`/`delete`, patched in place; the `Headers` identity and
+ * reads are untouched) so a post-commit write fails loudly instead of
+ * silently missing the wire: it throws in the dev build and reports +
+ * no-ops otherwise. Every head materialization path commits through here
+ * (`createSSRResponse`, the server-function handler's commit seam);
+ * integrations deriving their own heads should too.
+ *
+ * `allowLateLocation` is the stream path's documented exception: a
+ * `Location` set after the shell flushed is still honored client-side
+ * (stream completion appends a `window.location` script), so that one
+ * write stays permitted there.
+ */
+export function commitResponseStub(
+  stub: ResponseStub,
+  options?: { allowLateLocation?: boolean }
+): ResponseStub;
+/**
+ * Handler-lifecycle plumbing — a response's exit through the request
+ * event's response-stub lifecycle: page results leave through
+ * `createSSRResponse`, any other `Response` (a middleware early return, an
+ * API result) leaves through `commitEventResponse`; application middleware
+ * never calls this. Folds the event's stub onto the outgoing response —
+ * `Set-Cookie` appends entry-by-entry alongside the response's own, other
+ * stub headers fill gaps only (never the wire-protocol family the handlers
+ * own, never `Content-Type`/`Content-Length` on a bodiless response), the
+ * status is never taken from the stub — then commits the stub
+ * (`commitResponseStub`: post-commit writes fail loudly). Responses with
+ * immutable headers are rebuilt around merged copies.
+ *
+ * Idempotent at handler edges: an already-committed stub passes the
+ * response through untouched, so a handler may apply this unconditionally
+ * after its middleware chain unwinds — page responses from
+ * `createSSRResponse` come back committed and do not double-fold.
+ *
+ * `event` defaults to the ambient `getRequestEvent()`.
+ */
+export function commitEventResponse(response: Response, event?: RequestEvent): Response;
+/**
+ * The cookie codec (the platform-gap primitives — see cookies.d.ts): ALL
+ * of core's cookie surface. The blessed patterns are
+ * `parseCookieHeader(event.request.headers.get("cookie"))` for reads and
+ * `event.response.headers.append("set-cookie", serializeCookie(name,
+ * value, options))` for writes.
+ */
+export { parseCookieHeader, serializeCookie } from "./cookies.cjs";
+export type { CookieOptions } from "./cookies.cjs";
+export interface SSRResponseOptions {
+  /** Base head; the stub's status/headers win over it. */
+  responseInit?: ResponseInit;
+  /** Nonce carried by the post-flush `<script>` redirect fallback. */
+  nonce?: string;
+  /** Rewrites each outgoing HTML chunk (entry script injection, ...). */
+  transformChunk?: (chunk: string) => string;
+}
+/**
+ * Derives the outgoing `Response` for an SSR render result, running the
+ * response-head lifecycle against `event.response`: commit at shell flush,
+ * pre-flush `Location` becomes a real redirect, post-flush `Location`
+ * appends a client-side script redirect before the stream closes.
+ * Synchronous for string results; resolves at shell flush for stream
+ * results.
+ */
+export function createSSRResponse(
+  result: string,
+  event: RequestEvent | undefined,
+  options?: SSRResponseOptions
+): Response;
+export function createSSRResponse(
+  result: { pipe(writable: { write: (v: string) => void; end: () => void }): void },
+  event: RequestEvent | undefined,
+  options?: SSRResponseOptions
+): Promise<Response>;
+/**
+ * Fetch-style middleware: return a `Response` to answer the request, or
+ * call `next()` (optionally with a substitute `Request`) to advance the
+ * chain and observe/replace the eventual response.
+ */
+export type FetchMiddleware = (
+  request: Request,
+  next: (request?: Request) => Promise<Response>
+) => Response | Promise<Response>;
+/**
+ * Composes fetch-style middleware into one function of the same shape;
+ * the terminal `next` dispatches to the actual handler. Runs in whatever
+ * scope the caller established (`provideRequestEvent`), so
+ * `getRequestEvent()` works exactly as in application code.
+ */
+export function composeMiddleware(
+  middlewares: FetchMiddleware[]
+): (
+  request: Request,
+  next: (request?: Request) => Response | Promise<Response>
+) => Promise<Response>;
 export function untrack<T>(fn: () => T): T;
 // client-only APIs
@@ -347,5 +495,9 @@ export function ref(
 ): void;
 /** @deprecated not supported on the server side */
 export function setStyleProperty(node: Element, name: string, value: any): void;
-/** @deprecated not supported on the server side — register assets through the render context instead */
+/**
+ * @internal See client.d.ts — head-management RFC policy: ambient CSS is
+ * unmanaged; the head registry owns directly-mounted stylesheet lifecycle.
+ * @deprecated not supported on the server side — register assets through the render context instead
+ */
 export function acquireAsset(descriptor: unknown): () => void;