@bquery/bquery 1.10.0 → 1.11.0

package/dist/ssr/context.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Server-side rendering context.
+ *
+ * Encapsulates everything a render path may need to know about the incoming
+ * request and to produce response-side metadata (head tags, asset hints,
+ * nonces, etc.). The context is propagated explicitly through the public
+ * async APIs (`renderToStringAsync`, `renderToStream`, `renderToResponse`)
+ * and is available to template loaders.
+ *
+ * @module bquery/ssr
+ */
+import { type AssetManager, type HeadManager } from './head';
+/** Options for `createSSRContext()`. */
+export interface CreateSSRContextOptions {
+    /** Pre-built request to use as the source of URL/headers/cookies/etc. */
+    request?: Request;
+    /** Override the URL (defaults to `request.url` or `'http://localhost/'`). */
+    url?: string | URL;
+    /** Override the user agent string. */
+    userAgent?: string;
+    /** Override the request locale; defaults to `Accept-Language` parsing. */
+    locale?: string;
+    /** Provide an `AbortSignal` for cancellation. Default: `request.signal`. */
+    signal?: AbortSignal;
+    /** Pre-computed CSP nonce. If omitted and `crypto.getRandomValues` exists, a fresh nonce is generated. */
+    nonce?: string;
+    /** Render mode hint — used by streaming/string renderers for diagnostics. */
+    mode?: 'string' | 'stream';
+    /** Optional error sink invoked for non-fatal render errors. */
+    onError?: (error: unknown) => void;
+}
+/** Public SSR context shape. */
+export interface SSRContext {
+    /** The originating `Request` (may be a synthetic one if none was provided). */
+    request: Request;
+    /** Parsed URL of the request. */
+    url: URL;
+    /** Request headers (via `Request.headers`). */
+    headers: Headers;
+    /** Resolved cookie map from `Cookie` header. */
+    cookies: Record<string, string>;
+    /** Best-effort user agent string. */
+    userAgent: string;
+    /** Best-effort locale parsed from `Accept-Language`. */
+    locale: string;
+    /** Cancellation signal — render paths must respect it. */
+    signal: AbortSignal;
+    /** CSP nonce applied to all generated `<script>` tags. */
+    nonce: string;
+    /** Render mode hint. */
+    mode: 'string' | 'stream';
+    /** Head manager — call `head.add(...)`, `head.render()`, or read `head.state()`. */
+    head: HeadManager;
+    /** Asset manifest — call `assets.preload()`/`module()`/`style()`. */
+    assets: AssetManager;
+    /** Status code suggested by render paths (loaders, error boundaries). */
+    status: number;
+    /** Outgoing response headers (used by `renderToResponse()`). */
+    responseHeaders: Headers;
+    /** Reports a non-fatal error. */
+    reportError(error: unknown): void;
+}
+/**
+ * Creates a fully populated SSR context.
+ *
+ * @example
+ * ```ts
+ * const ctx = createSSRContext({ request });
+ * const { html } = await renderToStringAsync(template, data, { context: ctx });
+ * ```
+ */
+export declare const createSSRContext: (options?: CreateSSRContextOptions) => SSRContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/ssr/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/ssr/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,EAAyC,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,MAAM,QAAQ,CAAC;AAEpG,wCAAwC;AACxC,MAAM,WAAW,uBAAuB;IACtC,yEAAyE;IACzE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,6EAA6E;IAC7E,GAAG,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;IACnB,sCAAsC;IACtC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,0GAA0G;IAC1G,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,IAAI,CAAC,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC3B,+DAA+D;IAC/D,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACpC;AAED,gCAAgC;AAChC,MAAM,WAAW,UAAU;IACzB,+EAA+E;IAC/E,OAAO,EAAE,OAAO,CAAC;IACjB,iCAAiC;IACjC,GAAG,EAAE,GAAG,CAAC;IACT,+CAA+C;IAC/C,OAAO,EAAE,OAAO,CAAC;IACjB,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,qCAAqC;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,wDAAwD;IACxD,MAAM,EAAE,MAAM,CAAC;IACf,0DAA0D;IAC1D,MAAM,EAAE,WAAW,CAAC;IACpB,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAC;IACd,wBAAwB;IACxB,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC1B,oFAAoF;IACpF,IAAI,EAAE,WAAW,CAAC;IAClB,qEAAqE;IACrE,MAAM,EAAE,YAAY,CAAC;IACrB,yEAAyE;IACzE,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,eAAe,EAAE,OAAO,CAAC;IACzB,iCAAiC;IACjC,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;CACnC;AAoHD;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,GAAI,UAAS,uBAA4B,KAAG,UAqDxE,CAAC"}

package/dist/ssr/defer-brand.d.ts

@@ -0,0 +1,5 @@
+/** Shared internal brand for SSR deferred values and tagged loaders. */
+declare const _deferBrandSymbol: unique symbol;
+export declare const DEFER_BRAND: typeof _deferBrandSymbol;
+export {};
+//# sourceMappingURL=defer-brand.d.ts.map

package/dist/ssr/defer-brand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defer-brand.d.ts","sourceRoot":"","sources":["../../src/ssr/defer-brand.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,OAAO,CAAC,MAAM,iBAAiB,EAAE,OAAO,MAAM,CAAC;AAC/C,eAAO,MAAM,WAAW,EAAqC,OAAO,iBAAiB,CAAC"}

package/dist/ssr/escape.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared escaping helpers for SSR inline script payloads and HTML attributes.
+ *
+ * @module bquery/ssr
+ * @internal
+ */
+/**
+ * Escapes a string for safe embedding in an inline `<script>` body.
+ * @internal
+ */
+export declare const escapeForScript: (str: string) => string;
+/**
+ * Escapes a string for safe embedding in an HTML attribute value.
+ * @internal
+ */
+export declare const escapeForHtmlAttribute: (str: string) => string;
+//# sourceMappingURL=escape.d.ts.map

package/dist/ssr/escape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escape.d.ts","sourceRoot":"","sources":["../../src/ssr/escape.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,KAAG,MAMZ,CAAC;AAEnC;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,KAAK,MAAM,KAAG,MAC2C,CAAC"}

package/dist/ssr/expression.d.ts

@@ -0,0 +1,44 @@
+/**
+ * CSP-safe expression evaluator for SSR templates.
+ *
+ * Evaluates a tightly scoped subset of JavaScript expressions against a
+ * binding context without using `eval` or `new Function()`. Runs in any
+ * runtime (Bun, Deno, Node, browsers) and is safe under strict CSP without
+ * `'unsafe-eval'`.
+ *
+ * Supported grammar (operator-precedence Pratt parser):
+ *
+ * - Literals: numbers, single/double-quoted strings, `true`, `false`, `null`,
+ *   `undefined`.
+ * - Identifiers and member access (`a.b`, `a['b']`, `a[0]`).
+ * - Optional chaining (`a?.b`, `a?.[b]`).
+ * - Unary `!`, `+`, `-`, `typeof`.
+ * - Binary `+`, `-`, `*`, `/`, `%`, `==`, `===`, `!=`, `!==`, `<`, `<=`,
+ *   `>`, `>=`, `&&`, `||`, `??`.
+ * - Ternary `cond ? a : b`.
+ * - Parentheses for grouping.
+ * - Function calls `fn(arg1, arg2, ...)` (only on identifiers / member chains
+ *   resolved against the context — no arbitrary expression invocation).
+ *
+ * Anything outside this grammar throws a parse error which the caller
+ * converts into the standard SSR fallback (`undefined`).
+ *
+ * @module bquery/ssr
+ * @internal
+ */
+import type { BindingContext } from '../view/types';
+/**
+ * Evaluates a tightly scoped expression against a binding context.
+ *
+ * Returns `undefined` when the expression cannot be parsed or evaluated.
+ * This matches the behaviour of the previous `new Function()`-based fallback
+ * but never invokes dynamic code generation.
+ *
+ * @param expression - Expression source.
+ * @param context - Binding context whose top-level signal/computed values are
+ *   automatically unwrapped.
+ *
+ * @internal
+ */
+export declare const evaluateExpression: <T = unknown>(expression: string, context: BindingContext) => T;
+//# sourceMappingURL=expression.d.ts.map

package/dist/ssr/expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["../../src/ssr/expression.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAgmBpD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,GAAG,OAAO,EAAE,YAAY,MAAM,EAAE,SAAS,cAAc,KAAG,CAgB7F,CAAC"}

package/dist/ssr/hash.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Shared hashing helpers used by the SSR renderer and the client-side
+ * hydration mismatch verifier.
+ *
+ * The hash is intentionally cheap (DJB2 → base36) — its goal is to spot
+ * Server↔Client divergence in dev, not to provide cryptographic guarantees.
+ *
+ * @module bquery/ssr
+ */
+/**
+ * Computes a stable, very small hash for a string. Used to attach a hydration
+ * annotation that the client can compare against during dev-time hydration.
+ *
+ * Collisions are acceptable here: the goal is a mismatch *warning*, not
+ * security.
+ *
+ * @internal
+ */
+export declare const cheapHash: (input: string) => string;
+/**
+ * The attribute that holds the directive-signature hash on a server-rendered
+ * element. Public name so userland can read/write it deterministically.
+ */
+export declare const HYDRATION_HASH_ATTR = "data-bq-h";
+/**
+ * Collects the directive signature for a virtual element (used by the pure
+ * renderer).
+ *
+ * @internal
+ */
+export declare const collectDirectiveSignatureFromAttrs: (attributeOrder: readonly string[], attributes: Readonly<Record<string, string | undefined>>, prefix: string) => string;
+/**
+ * Collects the directive signature for a real DOM `Element`. Used by the
+ * client-side mismatch verifier and the DOM-backed renderer.
+ *
+ * @internal
+ */
+export declare const collectDirectiveSignatureFromElement: (el: Element, prefix: string) => string;
+//# sourceMappingURL=hash.d.ts.map

package/dist/ssr/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/ssr/hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,MAAM,KAAG,MAMzC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,cAAc,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,kCAAkC,GAC7C,gBAAgB,SAAS,MAAM,EAAE,EACjC,YAAY,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC,EACxD,QAAQ,MAAM,KACb,MASF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oCAAoC,GAAI,IAAI,OAAO,EAAE,QAAQ,MAAM,KAAG,MAUlF,CAAC"}

package/dist/ssr/head.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Head manager for SSR.
+ *
+ * Collects `<title>`, `<meta>`, `<link>` and inline `<script>` directives that
+ * a render path wants to inject into the document head, then serialises them
+ * as a single HTML string. The same descriptor shape is reused by the
+ * server-side head manager methods across SSR entry points.
+ *
+ * @module bquery/ssr
+ */
+/** A `<meta>` tag descriptor. */
+export interface SSRMeta {
+    name?: string;
+    property?: string;
+    httpEquiv?: string;
+    charset?: string;
+    content?: string;
+}
+/** A `<link>` tag descriptor. */
+export interface SSRLink {
+    rel: string;
+    href: string;
+    as?: string;
+    type?: string;
+    crossorigin?: string;
+    media?: string;
+    integrity?: string;
+    nonce?: string;
+}
+/** An inline or external `<script>` tag descriptor. */
+export interface SSRScript {
+    src?: string;
+    type?: string;
+    body?: string;
+    defer?: boolean;
+    async?: boolean;
+    nonce?: string;
+    crossorigin?: string;
+    integrity?: string;
+    module?: boolean;
+}
+/** Options accepted by `HeadManager.add()`. */
+export interface UseHeadOptions {
+    title?: string;
+    titleTemplate?: string;
+    meta?: SSRMeta[];
+    link?: SSRLink[];
+    script?: SSRScript[];
+}
+/** Aggregated head state collected during a render. */
+export interface SSRHeadState {
+    title: string | null;
+    titleTemplate: string | null;
+    meta: SSRMeta[];
+    link: SSRLink[];
+    script: SSRScript[];
+}
+/** Public head manager handle. */
+export interface HeadManager {
+    /** Add or replace head entries. */
+    add(options: UseHeadOptions): void;
+    /** Returns the current state snapshot. */
+    state(): SSRHeadState;
+    /** Renders the collected head into HTML. */
+    render(options?: {
+        nonce?: string;
+    }): string;
+    /** Resets the manager to an empty state. */
+    reset(): void;
+}
+/**
+ * Creates an isolated head manager. Each SSR context owns one instance.
+ */
+export declare const createHeadManager: () => HeadManager;
+/** Asset preload entry. */
+export interface SSRAsset {
+    href: string;
+    rel: 'preload' | 'modulepreload' | 'stylesheet';
+    as?: string;
+    type?: string;
+    crossorigin?: string;
+    integrity?: string;
+}
+/** Public asset manager handle. */
+export interface AssetManager {
+    /** Add a generic preload (`<link rel="preload">`). */
+    preload(href: string, opts?: Omit<SSRAsset, 'href' | 'rel'>): void;
+    /** Add a JS module preload (`<link rel="modulepreload">`). */
+    module(href: string, opts?: Omit<SSRAsset, 'href' | 'rel' | 'as'>): void;
+    /** Add a stylesheet link (`<link rel="stylesheet">`). */
+    style(href: string, opts?: Omit<SSRAsset, 'href' | 'rel' | 'as'>): void;
+    /** Returns the current asset list snapshot. */
+    list(): SSRAsset[];
+    /** Renders all assets to a series of `<link>` tags. */
+    render(options?: {
+        nonce?: string;
+    }): string;
+    /** Resets the manifest. */
+    reset(): void;
+}
+export declare const createAssetManager: () => AssetManager;
+//# sourceMappingURL=head.d.ts.map

package/dist/ssr/head.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"head.d.ts","sourceRoot":"","sources":["../../src/ssr/head.ts"],"names":[],"mappings":"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"}

package/dist/ssr/html-parser.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Minimal, runtime-agnostic HTML parser for the SSR renderer.
+ *
+ * This is intentionally a small, linear scanner rather than a full HTML5
+ * tokenizer. It is sufficient for templates authored against the `bQuery`
+ * directive vocabulary (HTML fragments, common void/raw elements, attributes)
+ * and lets the SSR pipeline run on Bun, Deno and Node without depending on a
+ * `DOMParser` polyfill.
+ *
+ * Output: a tiny virtual node tree (`SSRNode`) compatible with the pluggable
+ * DOM adapter API used by `renderer.ts`.
+ *
+ * @module bquery/ssr
+ * @internal
+ */
+/** A DOM-free node structure produced by `parseTemplate()`. */
+export type SSRNode = SSRElement | SSRText | SSRComment | SSRDocumentFragment;
+export interface SSRElement {
+    type: 'element';
+    tag: string;
+    attributes: Record<string, string>;
+    /** Order-preserving attribute list (so output is deterministic). */
+    attributeOrder: string[];
+    children: SSRNode[];
+    /** Whether this element should be serialised as a void element. */
+    void: boolean;
+    /** Whether the children are raw (e.g. `<script>` content). */
+    raw: boolean;
+}
+export interface SSRText {
+    type: 'text';
+    value: string;
+}
+export interface SSRComment {
+    type: 'comment';
+    value: string;
+}
+export interface SSRDocumentFragment {
+    type: 'fragment';
+    children: SSRNode[];
+}
+/**
+ * Decodes the named/numeric HTML entities the SSR parser actually needs.
+ * Anything else is preserved verbatim.
+ */
+export declare const decodeEntities: (input: string) => string;
+/**
+ * Parses an HTML template string into a virtual node tree without depending
+ * on a DOM implementation. The parser is intentionally permissive: it does
+ * not validate nesting, but it preserves attribute order and never throws on
+ * malformed input.
+ */
+export declare const parseTemplate: (template: string) => SSRDocumentFragment;
+/** Serialises a virtual node tree to an HTML string. */
+export declare const serializeTree: (node: SSRNode) => string;
+/** Recursively clones a virtual node (used by `bq-for`). */
+export declare const cloneNode: (node: SSRNode) => SSRNode;
+//# sourceMappingURL=html-parser.d.ts.map

package/dist/ssr/html-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-parser.d.ts","sourceRoot":"","sources":["../../src/ssr/html-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAqBH,+DAA+D;AAC/D,MAAM,MAAM,OAAO,GAAG,UAAU,GAAG,OAAO,GAAG,UAAU,GAAG,mBAAmB,CAAC;AAE9E,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,SAAS,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,oEAAoE;IACpE,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,mEAAmE;IACnE,IAAI,EAAE,OAAO,CAAC;IACd,8DAA8D;IAC9D,GAAG,EAAE,OAAO,CAAC;CACd;AAED,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB;AAWD;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,MAAM,KAAG,MAkB9C,CAAC;AAwHF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,UAAU,MAAM,KAAG,mBAuGhD,CAAC;AAQF,wDAAwD;AACxD,eAAO,MAAM,aAAa,GAAI,MAAM,OAAO,KAAG,MA+B7C,CAAC;AAEF,4DAA4D;AAC5D,eAAO,MAAM,SAAS,GAAI,MAAM,OAAO,KAAG,OAiBzC,CAAC"}

package/dist/ssr/index.d.ts

@@ -1,52 +1,31 @@
 /**
  * SSR / Pre-rendering module for bQuery.js.
  *
- * Provides server-side rendering, hydration, and store state serialization
- * utilities for bQuery applications. Enables rendering bQuery templates
- * to HTML strings on the server, serializing store state for client pickup,
- * and hydrating the pre-rendered DOM on the client.
+ * Server-side rendering, hydration, store-state serialization and runtime
+ * adapters for bQuery applications. The module is **runtime-agnostic** and
+ * runs on Bun, Deno and Node.js ≥ 24 without any external dependency.
  *
- * ## Features
+ * The synchronous `renderToString()` keeps its previous behaviour for
+ * backward compatibility but now automatically falls back to a fully
+ * DOM-free renderer when no `DOMParser` is available — that is what makes
+ * the same code path work on every server runtime.
  *
- * - **`renderToString(template, data)`** — Server-side render a bQuery
- *   template to an `SSRResult` containing an `html` string with directive evaluation.
- * - **`hydrateMount(selector, context, { hydrate: true })`** — Reuse
- *   existing server-rendered DOM and attach reactive bindings.
- * - **`serializeStoreState(options?)`** — Serialize store state into a
- *   `<script>` tag for client-side pickup.
- * - **`deserializeStoreState()`** — Read serialized state on the client.
- * - **`hydrateStore(id, state)` / `hydrateStores(stateMap)`** — Apply
- *   server state to client stores.
+ * ## Highlights
  *
- * ## Usage
- *
- * ### Server
- * ```ts
- * import { renderToString, serializeStoreState } from '@bquery/bquery/ssr';
- *
- * const { html } = renderToString(
- *   '<div id="app"><h1 bq-text="title"></h1></div>',
- *   { title: 'Welcome' }
- * );
- *
- * const { scriptTag } = serializeStoreState();
- *
- * // Send to client: html + scriptTag
- * ```
- *
- * ### Client
- * ```ts
- * import { hydrateMount, deserializeStoreState, hydrateStores } from '@bquery/bquery/ssr';
- * import { signal } from '@bquery/bquery/reactive';
- *
- * // Restore store state from SSR
- * const ssrState = deserializeStoreState();
- * hydrateStores(ssrState);
- *
- * // Hydrate the DOM with reactive bindings
- * const title = signal('Welcome');
- * hydrateMount('#app', { title }, { hydrate: true });
- * ```
+ * - **`renderToString(template, data)`** — synchronous render to HTML.
+ * - **`renderToStringAsync(template, data, ctx?)`** — awaits Promises and
+ *   `defer()` values in the binding context.
+ * - **`renderToStream(template, data, ctx?)`** — Web `ReadableStream<Uint8Array>`.
+ * - **`renderToResponse(template, data, ctx?)`** — high-level `Response`
+ *   wrapper with ETag, Cache-Control, head & store-state injection.
+ * - **`createSSRContext(...)`** — request/response context bag.
+ * - **`createHeadManager()`** — `<title>`, `<meta>`, `<link>` and
+ *   `<script>` collection.
+ * - **`hydrateMount` / `hydrateOnVisible` / `hydrateOnIdle` /
+ *   `hydrateOnInteraction` / `hydrateOnMedia` / `hydrateIsland`** — full
+ *   progressive-hydration toolkit.
+ * - **Runtime adapters** — `createWebHandler`, `createBunHandler`,
+ *   `createDenoHandler`, `createNodeHandler`, `createSSRHandler`.
  *
  * @module bquery/ssr
  */
@@ -56,4 +35,31 @@ export { renderToString } from './render';
 export { deserializeStoreState, hydrateStore, hydrateStores, serializeStoreState, } from './serialize';
 export type { SerializeResult } from './serialize';
 export type { DeserializedStoreState, HydrationOptions, RenderOptions, SSRResult, SerializeOptions, } from './types';
+export { detectRuntime, getSSRRuntimeFeatures, isBrowserRuntime, isServerRuntime } from './runtime';
+export type { SSRRuntime, SSRRuntimeFeatures } from './runtime';
+export { configureSSR, getSSRConfig } from './config';
+export type { SSRDocumentImpl, SSRRendererBackend } from './config';
+export { renderToResponse, renderToStream, renderToStringAsync } from './render-async';
+export type { AsyncRenderOptions, AsyncSSRResult, RenderToResponseOptions } from './render-async';
+export { createSSRContext } from './context';
+export type { CreateSSRContextOptions, SSRContext } from './context';
+export { createAssetManager, createHeadManager } from './head';
+export type { AssetManager, HeadManager, SSRAsset, SSRHeadState, SSRLink, SSRMeta, SSRScript, UseHeadOptions, } from './head';
+export { defer, defineLoader } from './async';
+export type { SSRLoader } from './async';
+export { hydrateIsland, hydrateOnIdle, hydrateOnInteraction, hydrateOnMedia, hydrateOnVisible, } from './strategies';
+export type { HydrationHandle } from './strategies';
+export { verifyHydration } from './mismatch';
+export type { HydrationMismatch, VerifyHydrationOptions } from './mismatch';
+export { HYDRATION_HASH_ATTR } from './hash';
+export { renderToStreamSuspense } from './suspense';
+export type { SuspenseStreamOptions } from './suspense';
+export { createSSRRouterContext, resolveSSRRoute, runRouteLoaders } from './router-bridge';
+export type { ResolvedSSRRoute, SSRRouteLoader } from './router-bridge';
+export { hydrateStoreSnapshot, readStoreSnapshot, serializeStoreSnapshot } from './store-snapshot';
+export type { HydrateSnapshotOptions, HydrateSnapshotResult, SerializeSnapshotOptions, SerializeSnapshotResult, SSRStoreSnapshot, } from './store-snapshot';
+export { createResumableState, resumeState } from './resumability';
+export type { CreateResumableStateOptions, ResumableState, ResumeReader } from './resumability';
+export { createBunHandler, createDenoHandler, createNodeHandler, createSSRHandler, createWebHandler, } from './adapters';
+export type { NodeHandlerOptions, NodeIncomingMessage, NodeServerResponse, SSRRequestHandler, } from './adapters';
 //# sourceMappingURL=index.d.ts.map

package/dist/ssr/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ssr/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACzC,YAAY,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EACL,qBAAqB,EACrB,YAAY,EACZ,aAAa,EACb,mBAAmB,GACpB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,YAAY,EACV,sBAAsB,EACtB,gBAAgB,EAChB,aAAa,EACb,SAAS,EACT,gBAAgB,GACjB,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ssr/index.ts"],"names":[],"mappings":"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"}

package/dist/ssr/mismatch.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Hydration mismatch detection.
+ *
+ * The DOM-free SSR renderer can annotate every element that carries a `bq-*`
+ * directive with a small `data-bq-h` hash (see `RenderOptions.annotateHydration`).
+ * On the client, `verifyHydration()` walks the live DOM, recomputes the same
+ * hash for each annotated element and reports any divergence.
+ *
+ * The check is intentionally cheap and safe: collisions only result in false
+ * negatives (a mismatch slips through), never in false positives (a stable
+ * tree never reports a mismatch).
+ *
+ * @module bquery/ssr
+ */
+/** A single hydration mismatch entry returned by `verifyHydration()`. */
+export interface HydrationMismatch {
+    /** The DOM element whose annotation diverged. */
+    element: Element;
+    /** The hash that the server emitted (`data-bq-h` value). */
+    expected: string;
+    /** The hash recomputed from the live element. */
+    actual: string;
+    /** The directive signature that was hashed (useful for diagnostics). */
+    signature: string;
+}
+/** Options for `verifyHydration`. */
+export interface VerifyHydrationOptions {
+    /** Directive prefix to match. Default: `'bq'`. */
+    prefix?: string;
+    /**
+     * Whether to log a `console.warn` for each mismatch. Defaults to `true` in
+     * non-production environments and `false` otherwise. Pass an explicit
+     * boolean to override.
+     */
+    warn?: boolean;
+    /** Optional callback invoked once per mismatch. */
+    onMismatch?: (mismatch: HydrationMismatch) => void;
+}
+/**
+ * Walks `[data-bq-h]` elements within `root`, recomputes the directive hash
+ * and reports mismatches. Returns the list of mismatches; callers can react
+ * however they want (throw in tests, log in dev, ignore in production).
+ *
+ * Safe to call in any environment. When the runtime has no DOM (server-side)
+ * or `root` has no `querySelectorAll`, the function returns an empty array
+ * without throwing.
+ *
+ * @example
+ * ```ts
+ * import { detectDevEnvironment } from '@bquery/bquery';
+ * import { hydrateMount, verifyHydration } from '@bquery/bquery/ssr';
+ *
+ * const view = hydrateMount('#app', context);
+ * if (detectDevEnvironment()) {
+ *   verifyHydration(document.getElementById('app')!);
+ * }
+ * ```
+ */
+export declare const verifyHydration: (root: Element | Document, options?: VerifyHydrationOptions) => HydrationMismatch[];
+//# sourceMappingURL=mismatch.d.ts.map

package/dist/ssr/mismatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mismatch.d.ts","sourceRoot":"","sources":["../../src/ssr/mismatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,yEAAyE;AACzE,MAAM,WAAW,iBAAiB;IAChC,iDAAiD;IACjD,OAAO,EAAE,OAAO,CAAC;IACjB,4DAA4D;IAC5D,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qCAAqC;AACrC,MAAM,WAAW,sBAAsB;IACrC,kDAAkD;IAClD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,mDAAmD;IACnD,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,iBAAiB,KAAK,IAAI,CAAC;CACpD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,eAAe,GAC1B,MAAM,OAAO,GAAG,QAAQ,EACxB,UAAS,sBAA2B,KACnC,iBAAiB,EA0CnB,CAAC"}

package/dist/ssr/render-async.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Async / streaming render entry points.
+ *
+ * Builds on top of the synchronous `renderToString()` and adds:
+ * - `renderToStringAsync()` — awaits Promise/`defer()` values in the context.
+ * - `renderToStream()` — emits the HTML as a Web `ReadableStream<Uint8Array>`.
+ * - `renderToResponse()` — wraps the stream in a `Response` with sensible
+ *   defaults (`Content-Type`, `Cache-Control`, ETag, head injection, store
+ *   state injection).
+ *
+ * All three run on Bun, Deno and Node ≥ 24 without external dependencies.
+ *
+ * @module bquery/ssr
+ */
+import type { BindingContext } from '../view/types';
+import { type SSRContext } from './context';
+import type { RenderOptions, SSRResult } from './types';
+/**
+ * Options accepted by the async render APIs. Extends the base `RenderOptions`
+ * with response-shaping switches.
+ */
+export interface AsyncRenderOptions extends RenderOptions {
+    /** Pre-built SSR context. Created automatically if omitted. */
+    context?: SSRContext;
+    /**
+     * Whether to inject the head manager output, asset manifest and store-state
+     * `<script>` tag into the output HTML when the template contains
+     * `</head>`/`</body>` markers. Default: `true`.
+     */
+    injectHead?: boolean;
+    /**
+     * Custom store-state script ID/global key forwarded to `serializeStoreState()`.
+     */
+    storeScriptId?: string;
+    storeGlobalKey?: string;
+}
+/** Result of an async render call. */
+export interface AsyncSSRResult extends SSRResult {
+    /** SSR context that produced this result. */
+    context: SSRContext;
+    /** Aggregated head HTML (already injected when `injectHead` is true). */
+    headHtml: string;
+    /** Aggregated asset preload HTML (already injected when `injectHead` is true). */
+    assetsHtml: string;
+    /** `<script>` tag with serialized store state, if any. */
+    storeScriptTag: string;
+}
+/**
+ * Async-aware render. Resolves all `Promise`/`defer()` values in the context,
+ * then delegates to `renderToString()` and applies head/asset/store-state
+ * injection based on the SSR context.
+ */
+export declare const renderToStringAsync: (template: string, data: BindingContext, options?: AsyncRenderOptions) => Promise<AsyncSSRResult>;
+/**
+ * Renders a template into a Web `ReadableStream<Uint8Array>`. The stream is
+ * single-chunk for now (the HTML is fully resolved before flushing) but is
+ * exposed as a stream so adapters can pipe it directly into Bun/Deno/Node
+ * responses without buffering into memory twice.
+ *
+ * Future Suspense-style streaming patches will reuse the same return type.
+ */
+export declare const renderToStream: (template: string, data: BindingContext, options?: AsyncRenderOptions) => ReadableStream<Uint8Array>;
+/** Options for `renderToResponse()`. */
+export interface RenderToResponseOptions extends AsyncRenderOptions {
+    /** Override the response status code. */
+    status?: number;
+    /** Override the `Content-Type` header. Default: `text/html; charset=utf-8`. */
+    contentType?: string;
+    /** Set a `Cache-Control` header value. */
+    cacheControl?: string;
+    /** Whether to compute a weak ETag from the rendered HTML. Default: `false`. */
+    etag?: boolean;
+    /** Extra headers merged into the response. */
+    headers?: HeadersInit;
+}
+/**
+ * Renders a template and returns a `Response` ready to be returned from a
+ * `fetch`-style handler (`Bun.serve`, `Deno.serve`, Hono, Elysia, etc.).
+ *
+ * Honours `SSRContext.signal` for cancellation and `SSRContext.responseHeaders`
+ * for headers added during the render path.
+ */
+export declare const renderToResponse: (template: string, data: BindingContext, options?: RenderToResponseOptions) => Promise<Response>;
+//# sourceMappingURL=render-async.d.ts.map

package/dist/ssr/render-async.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-async.d.ts","sourceRoot":"","sources":["../../src/ssr/render-async.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,WAAW,CAAC;AAG9D,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AA2BxD;;;GAGG;AACH,MAAM,WAAW,kBAAmB,SAAQ,aAAa;IACvD,+DAA+D;IAC/D,OAAO,CAAC,EAAE,UAAU,CAAC;IACrB;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,sCAAsC;AACtC,MAAM,WAAW,cAAe,SAAQ,SAAS;IAC/C,6CAA6C;IAC7C,OAAO,EAAE,UAAU,CAAC;IACpB,yEAAyE;IACzE,QAAQ,EAAE,MAAM,CAAC;IACjB,kFAAkF;IAClF,UAAU,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,cAAc,EAAE,MAAM,CAAC;CACxB;AAgBD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAC9B,UAAU,MAAM,EAChB,MAAM,cAAc,EACpB,UAAS,kBAAuB,KAC/B,OAAO,CAAC,cAAc,CAwDxB,CAAC;AASF;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GACzB,UAAU,MAAM,EAChB,MAAM,cAAc,EACpB,UAAS,kBAAuB,KAC/B,cAAc,CAAC,UAAU,CAwC3B,CAAC;AAgBF,wCAAwC;AACxC,MAAM,WAAW,uBAAwB,SAAQ,kBAAkB;IACjE,yCAAyC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0CAA0C;IAC1C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,+EAA+E;IAC/E,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,8CAA8C;IAC9C,OAAO,CAAC,EAAE,WAAW,CAAC;CACvB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAC3B,UAAU,MAAM,EAChB,MAAM,cAAc,EACpB,UAAS,uBAA4B,KACpC,OAAO,CAAC,QAAQ,CAyBlB,CAAC"}

package/dist/ssr/render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/ssr/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AA2YxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,cAAc,GACzB,UAAU,MAAM,EAChB,MAAM,cAAc,EACpB,UAAS,aAAkB,KAC1B,SA6CF,CAAC"}
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/ssr/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAIpD,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAobxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,cAAc,GACzB,UAAU,MAAM,EAChB,MAAM,cAAc,EACpB,UAAS,aAAkB,KAC1B,SAyEF,CAAC"}