toiljs 0.0.115 → 0.0.117

package/src/client/search/search.ts

@@ -1,189 +0,0 @@
-/**
- * Site-wide page search over route {@link Metadata}. The compiler bakes a static index of every
- * page's title/description/keywords/OpenGraph (extracted from each route's `export const metadata`)
- * into the generated bundle and registers it with {@link registerPages} at startup. User code then
- * queries it with {@link searchPages} (pure, framework-agnostic) or the {@link usePageSearch} hook,
- * getting back ranked pages with their `path` ready to feed to `Link` / `navigate`.
- *
- * Only statically-analyzable metadata is indexed: a route's `generateMetadata` (dynamic, per-request)
- * and computed values can't be known at build time. A dynamic route can still be made discoverable
- * by exporting static {@link SearchHints} (`export const searchHints = { title, keywords, … }`),
- * which the compiler merges over the route's static `metadata` when building the index.
- */
-import type { Metadata } from '../head/metadata.js';
-
-/**
- * Static search hints a route can `export const searchHints` to seed the search index, useful when
- * the route's real `<head>` is produced by a dynamic `generateMetadata` (so nothing else is
- * statically indexable). Merged over the route's static `metadata`, winning ties.
- */
-export interface SearchHints {
-    /** Indexed as the page title (highest-weighted field). */
-    readonly title?: string;
-    /** Indexed as the page description. */
-    readonly description?: string;
-    /** Indexed keywords (string or array). */
-    readonly keywords?: string | readonly string[];
-}
-
-/** A searchable page: its route pattern plus the statically-known metadata baked at build time. */
-export interface PageMeta {
-    /** Route URL pattern, e.g. `'/'`, `'/about'`, `'/blog/:id'`. */
-    readonly path: string;
-    /** Whether `path` has dynamic (`:param` / `*catch-all`) segments, not navigable without params. */
-    readonly dynamic: boolean;
-    /** The page's statically-extracted metadata (empty object when the route declares none). */
-    readonly metadata: Metadata;
-}
-
-/** A metadata field that {@link searchPages} can match against. */
-export type SearchField = 'title' | 'description' | 'keywords' | 'path' | 'openGraph';
-
-/** Options for {@link searchPages}. */
-export interface PageSearchOptions {
-    /** Cap the number of results returned (after ranking). Default: no cap. */
-    readonly limit?: number;
-    /** Include dynamic (`:param` / `*`) routes, which can't be navigated to as-is. Default: `false`. */
-    readonly includeDynamic?: boolean;
-    /** Restrict matching to these fields. Default: every searchable field. */
-    readonly fields?: readonly SearchField[];
-}
-
-/** A page that matched a query, with its relevance {@link score} and the fields that matched. */
-export interface PageSearchResult {
-    readonly page: PageMeta;
-    /** Relevance score (higher = better); always `> 0` for a returned result. */
-    readonly score: number;
-    /** The metadata fields that contributed to the match, e.g. `['title', 'keywords']`. */
-    readonly matches: readonly SearchField[];
-}
-
-/** Relative weight of each field, title is the strongest signal, OpenGraph the weakest. */
-const FIELD_WEIGHT: Record<SearchField, number> = {
-    title: 10,
-    path: 6,
-    keywords: 5,
-    description: 3,
-    openGraph: 2,
-};
-
-const ALL_FIELDS: readonly SearchField[] = [
-    'title',
-    'description',
-    'keywords',
-    'path',
-    'openGraph',
-];
-
-/** The live page index, populated by {@link registerPages} from the compiler-generated bundle. */
-let registry: readonly PageMeta[] = [];
-
-/**
- * Registers the project's page index. Called once at startup by the generated `globals` module
- * (`Toil.registerPages(pages)`); replaces any previous registration. Rarely called by user code,
- * but exposed for tests and advanced setups that build their own index.
- */
-export function registerPages(pages: readonly PageMeta[]): void {
-    registry = pages;
-}
-
-/** The registered page index (every page, including dynamic ones). Empty before registration. */
-export function getPages(): readonly PageMeta[] {
-    return registry;
-}
-
-/** Normalizes a search target (a result, a page, or a raw path) to its route path string. */
-export function pagePath(target: string | PageMeta | PageSearchResult): string {
-    if (typeof target === 'string') return target;
-    return 'page' in target ? target.page.path : target.path;
-}
-
-/** Joins a page's keyword list (string or array) into one searchable string. */
-function keywordsText(keywords: Metadata['keywords']): string {
-    if (keywords === undefined) return '';
-    return typeof keywords === 'string' ? keywords : keywords.join(' ');
-}
-
-/** The searchable text for one field of a page (empty string when the field is unset). */
-function fieldText(page: PageMeta, field: SearchField): string {
-    const m = page.metadata;
-    switch (field) {
-        case 'title':
-            return m.title ?? '';
-        case 'description':
-            return m.description ?? '';
-        case 'keywords':
-            return keywordsText(m.keywords);
-        case 'path':
-            // Make slugs word-searchable: '/get-started' → 'get started', '/blog/:id' → 'blog id'.
-            return page.path.replace(/[/:*\-_]+/g, ' ').trim();
-        case 'openGraph': {
-            const og = m.openGraph;
-            if (!og) return '';
-            return [og.title, og.description, og.siteName, og.type].filter(Boolean).join(' ');
-        }
-    }
-}
-
-/** Whether the character before `index` is a word boundary (start of string or non-alphanumeric). */
-function isWordStart(text: string, index: number): boolean {
-    return index === 0 || !/[a-z0-9]/i.test(text[index - 1]);
-}
-
-/**
- * Scores a single field against one query term, returning `0` for no match. Substring matches count;
- * a whole-field exact match, a prefix match, and a word-boundary match each rank progressively higher.
- */
-function scoreTerm(text: string, term: string, weight: number): number {
-    const index = text.indexOf(term);
-    if (index === -1) return 0;
-    if (text === term) return weight * 3; // the field IS the term
-    if (index === 0) return weight * 1.6; // prefix of the field
-    if (isWordStart(text, index)) return weight * 1.2; // start of a word within the field
-    return weight; // mid-word substring
-}
-
-/**
- * Searches the registered page index for `query`, returning pages ranked by relevance (best first).
- * Matching is case-insensitive; the query is split on whitespace and every term must match somewhere
- * (AND semantics) for a page to be included. An empty query returns no results. Dynamic routes are
- * excluded unless {@link PageSearchOptions.includeDynamic} is set, since they need params to navigate.
- */
-export function searchPages(query: string, options: PageSearchOptions = {}): PageSearchResult[] {
-    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
-    if (terms.length === 0) return [];
-    const fields = options.fields ?? ALL_FIELDS;
-
-    const results: PageSearchResult[] = [];
-    for (const page of registry) {
-        if (page.dynamic && !options.includeDynamic) continue;
-
-        const texts = fields.map((field) => ({
-            field,
-            text: fieldText(page, field).toLowerCase(),
-        }));
-        const matched = new Set<SearchField>();
-        let score = 0;
-        // AND semantics: every term must hit at least one field, or the page is dropped.
-        const allTermsMatch = terms.every((term) => {
-            let termScore = 0;
-            for (const { field, text } of texts) {
-                if (!text) continue;
-                const s = scoreTerm(text, term, FIELD_WEIGHT[field]);
-                if (s > 0) {
-                    termScore += s;
-                    matched.add(field);
-                }
-            }
-            score += termScore;
-            return termScore > 0;
-        });
-        if (allTermsMatch && score > 0) {
-            results.push({ page, score, matches: [...matched] });
-        }
-    }
-
-    // Best score first; ties broken by path for a stable, deterministic order.
-    results.sort((a, b) => b.score - a.score || a.page.path.localeCompare(b.page.path));
-    return options.limit !== undefined ? results.slice(0, options.limit) : results;
-}

package/src/client/search/use-page-search.ts

@@ -1,73 +0,0 @@
-/**
- * React binding for the page-metadata {@link searchPages search}. Gives a route component reactive,
- * memoized search results plus a `goTo` helper that navigates straight to a matched page, a drop-in
- * for a site-wide "jump to page" / command-palette style search box.
- */
-import { useMemo } from 'react';
-
-import { navigate, type NavigateOptions } from '../navigation/navigation.js';
-import type { Href } from '../types.js';
-import {
-    getPages,
-    type PageMeta,
-    pagePath,
-    type PageSearchOptions,
-    type PageSearchResult,
-    searchPages,
-} from './search.js';
-
-/** What {@link usePageSearch} returns. */
-export interface PageSearch {
-    /** Ranked matches for the current query (best first); empty when the query is blank. */
-    readonly results: readonly PageSearchResult[];
-    /** The full registered page index (handy for rendering an "all pages" listing). */
-    readonly pages: readonly PageMeta[];
-    /**
-     * Navigates to a result / page / raw path. A dynamic (`:param`) page can't be navigated to
-     * as-is, so passing one (or its result) is a no-op unless you pass a concrete path string with
-     * the params already filled in. A stable reference, safe to destructure.
-     */
-    readonly goTo: (
-        target: string | PageMeta | PageSearchResult,
-        options?: NavigateOptions,
-    ) => void;
-}
-
-/** Whether a path can be navigated to directly (no unfilled dynamic segments). */
-function isNavigable(path: string): boolean {
-    return !/[:*]/.test(path);
-}
-
-/**
- * Searches the project's pages by `query` and returns ranked {@link PageSearchResult}s, recomputed
- * only when the query or options change. Use the returned `goTo` to redirect to a match:
- *
- * ```tsx
- * const { results, goTo } = usePageSearch(query);
- * return results.map((r) => (
- *   <button key={r.page.path} onClick={() => { goTo(r); }}>{r.page.metadata.title ?? r.page.path}</button>
- * ));
- * ```
- */
-export function usePageSearch(query: string, options: PageSearchOptions = {}): PageSearch {
-    const { limit, includeDynamic, fields } = options;
-    const fieldsKey = fields?.join(',');
-    const results = useMemo(
-        () => searchPages(query, { limit, includeDynamic, fields }),
-        // `fields` is compared by content (fieldsKey) so a fresh array literal each render is fine.
-        [query, limit, includeDynamic, fieldsKey],
-    );
-
-    return useMemo<PageSearch>(
-        () => ({
-            results,
-            pages: getPages(),
-            goTo(target, navOptions) {
-                const path = pagePath(target);
-                if (typeof target !== 'string' && !isNavigable(path)) return;
-                navigate(path as Href, navOptions);
-            },
-        }),
-        [results],
-    );
-}

package/src/client/ssr/markers.tsx

@@ -1,172 +0,0 @@
-/**
- * Edge-SSR hole markers. A route opts into server rendering by wrapping its
- * dynamic bits in these components; the compiler's template extractor finds
- * them deterministically (rather than guessing which `{expr}` is dynamic).
- *
- * The markers are TRANSPARENT at runtime: in the browser `<Hole>` renders its
- * children, `<Repeat>` renders `each.map(...)`, `<RawHtml>` renders a
- * `dangerouslySetInnerHTML` wrapper, `<Island>` renders its children. So the
- * client's React tree is exactly the normal app.
- *
- * Under the BUILD extractor (which calls {@link __setSsrBuild}(true) before
- * `renderToStaticMarkup`), each marker instead emits a unique PUA sentinel
- * token marking an insertion point. The extractor strips the tokens, records
- * their byte offsets, and emits the `.tmpl` + `.slots`. PUA codepoints
- * (U+E000..) never occur in real HTML and React serialises them verbatim, so
- * the tokens are collision-proof and strip to zero bytes.
- *
- * Because the static scaffold around every hole is React's OWN
- * `renderToStaticMarkup` output, the browser's `hydrateRoot` sees byte-
- * identical markup as long as the guest escapes hole values the same way React
- * does (it does: see `server/runtime/ssr/escape.ts`).
- */
-
-import { createElement, Fragment, type ReactNode, useEffect, useState } from 'react';
-
-/** Token framing codepoints (Unicode Private Use Area). */
-export const SENTINEL_START = String.fromCharCode(0xe000);
-export const SENTINEL_SEP = String.fromCharCode(0xe001);
-export const SENTINEL_END = String.fromCharCode(0xe002);
-
-/** Kind chars embedded in a sentinel token. Lowercase letters; `R`/`r` open and
- * close a repeat region. */
-export const enum HoleKindChar {
-    Text = 't',
-    Raw = 'h',
-    Attr = 'a',
-    RepeatOpen = 'R',
-    RepeatClose = 'r',
-}
-
-let ssrBuild = false;
-
-/** Build-extractor switch. Flipped on around a `renderToStaticMarkup` pass so
- * the markers emit sentinels; left `false` in the browser bundle so they are
- * transparent. */
-export function __setSsrBuild(on: boolean): void {
-    ssrBuild = on;
-}
-
-/** `true` while the extractor is rendering (test/diagnostic use). */
-export function __isSsrBuild(): boolean {
-    return ssrBuild;
-}
-
-/** A self-closing insertion-point token, e.g. `␀t<id>␂`. */
-function token(kind: HoleKindChar, id: string): string {
-    return SENTINEL_START + kind + id + SENTINEL_END;
-}
-
-/** Wrap a string so a component always returns a `ReactElement` (a Fragment
- * with one text child renders the string verbatim). */
-function textNode(s: string): ReactNode {
-    return createElement(Fragment, null, s);
-}
-
-export interface HoleProps {
-    /** Stable hole name; the extractor maps it to a numeric slot id. */
-    id: string;
-    children?: ReactNode;
-}
-
-/** A scalar text hole. Client: renders `children`. Build: a text insertion
- * point the guest fills with the React-escaped value. */
-export function Hole(props: HoleProps): ReactNode {
-    if (ssrBuild) return textNode(token(HoleKindChar.Text, props.id));
-    return createElement(Fragment, null, props.children);
-}
-
-/**
- * An attribute-value hole. Unlike the child markers, an attribute is not a child
- * node, so this is a *function* used in attribute position rather than a JSX
- * element:
- *
- * ```tsx
- * <a href={attr('profileUrl', d.url)} class={attr('cls', d.cls)}>…</a>
- * ```
- *
- * Browser: returns `value` unchanged, so the attribute renders normally. Build:
- * returns a PUA sentinel token, so the extractor records an `attr` slot at the
- * attribute's byte offset (the token sits between the quotes and strips to zero
- * bytes). The guest fills it per request with the React-escaped value (kind
- * `attr`), which the host splices at that offset — exactly like a text hole, but
- * inside an attribute. It composes with surrounding literal text
- * (`` `btn ${attr('x', v)}` ``), and `setAttr`/`HtmlBuilder.attr` produce the
- * value on the server side.
- */
-export function attr(id: string, value: string): string {
-    return ssrBuild ? token(HoleKindChar.Attr, id) : value;
-}
-
-export interface RawHtmlProps {
-    id: string;
-    /** Raw HTML string. The author owns sanitisation (same as React
-     * `dangerouslySetInnerHTML`). */
-    html: string;
-    /** Wrapper element tag (raw HTML needs a host element to live in so server
-     * and client DOM match). Defaults to `div`. */
-    as?: keyof React.JSX.IntrinsicElements;
-}
-
-/** A raw-HTML block hole. Client: `<as dangerouslySetInnerHTML>`. Build:
- * `<as>SENTINEL</as>` so the `.tmpl` carries the wrapper and the guest fills
- * its inner HTML. */
-export function RawHtml(props: RawHtmlProps): ReactNode {
-    const tag = props.as ?? 'div';
-    if (ssrBuild) {
-        return createElement(tag, null, token(HoleKindChar.Raw, props.id));
-    }
-    return createElement(tag, { dangerouslySetInnerHTML: { __html: props.html } });
-}
-
-export interface RepeatProps<T> {
-    id: string;
-    /** The data rows. The build extractor requires a representative sample with
-     * at least one row to capture the row sub-template. */
-    each: readonly T[];
-    children: (item: T, index: number) => ReactNode;
-}
-
-/** A repeat region. Client: `each.map(children)`. Build: a region wrapping
- * exactly ONE representative row (so the extractor captures the row sub-
- * template + its nested holes); the host inserts the guest's pre-stamped,
- * concatenated rows at the region offset. */
-export function Repeat<T>(props: RepeatProps<T>): ReactNode {
-    if (ssrBuild) {
-        const sample = props.each.length > 0 ? props.each[0] : undefined;
-        return createElement(
-            Fragment,
-            null,
-            token(HoleKindChar.RepeatOpen, props.id),
-            sample !== undefined ? props.children(sample, 0) : null,
-            token(HoleKindChar.RepeatClose, props.id),
-        );
-    }
-    return createElement(
-        Fragment,
-        null,
-        // Each row is wrapped in a keyed Fragment so React has a stable list key (the
-        // row markup itself need not carry one). Index keys are fine here: an SSR'd
-        // region hydrates 1:1 against the host's pre-stamped rows and does not reorder.
-        props.each.map((item, i) => createElement(Fragment, { key: i }, props.children(item, i))),
-    );
-}
-
-export interface IslandProps {
-    children?: ReactNode;
-}
-
-/** A client-only escape hatch for content outside the server-template subset.
- * Build: renders nothing (empty in the server HTML). Client: ALSO renders nothing
- * on the first (hydration) render, so it matches the empty server markup, then a
- * mount effect reveals `children` on the next commit. Rendering the children
- * during hydration instead would diverge from the server's empty markup and trip
- * a hydration mismatch. So an island gets no first-paint / SEO, by design. */
-export function Island(props: IslandProps): ReactNode {
-    const [hydrated, setHydrated] = useState(false);
-    useEffect(() => {
-        setHydrated(true);
-    }, []);
-    if (ssrBuild || !hydrated) return null;
-    return createElement(Fragment, null, props.children);
-}

package/src/client/stream/client.ts

@@ -1,237 +0,0 @@
-/**
- * Client runtime for the typed `@stream` channel (doc 08 section 8.2). `Server.Stream.<Class>.connect(path?)`
- * opens a browser `WebTransport` session to the class's `route` on the production edge (an `https://`
- * stream-tier origin), or a `WebSocket` against the dev server (a `ws(s)://` origin), and returns a channel:
- * `onMessage` / `send` / `onClose` / `close`. A raw `@stream` channel sends `Uint8Array`; a typed
- * `@stream({ message: T })` channel sends the `@data` class and encodes it on send (the per-class
- * encoder the generated module passes). The inbound reply is always raw bytes. The generated
- * `shared/server.ts` (toilscript hot pass) attaches `makeStreamClient(routes, undefined, encoders)` to
- * `globalThis.__toilStream`, and `Server.Stream`
- * (`rpc.ts`) surfaces it - the same wiring the REST client uses via `globalThis.__toilRest`.
- */
-
-/** A live `@stream` connection. `TSend` is the outbound message type: `Uint8Array` for a raw `@stream`,
- *  or the `@data` class for a typed `@stream({ message: T })` (the channel encodes it before sending).
- *  The inbound reply is ALWAYS raw bytes - the server's `StreamOutbound` is raw (doc 03 2.5). */
-export interface StreamChannel<TSend = Uint8Array> {
-    /** Register the inbound-frame handler (one call per server reply frame). */
-    onMessage(cb: (data: Uint8Array) => void): void;
-    /** Send one outbound message (one `@message` on the server); a typed channel encodes it first. */
-    send(data: TSend): void;
-    /** Register the close handler (`code` is the `0x02xx` stream close code, or the WS code). */
-    onClose(cb: (code: number) => void): void;
-    /** Close the connection. */
-    close(): void;
-}
-
-/** The connect factory for one `@stream` class. `path` is the `@connect` path (default `''`). */
-export interface StreamConnectable<TSend = Uint8Array> {
-    connect(path?: string): Promise<StreamChannel<TSend>>;
-}
-
-/** `Server.Stream`: one `connect()` factory per `@stream` class name. */
-export type StreamClient = Record<string, StreamConnectable>;
-
-/** Open a WebSocket to `url` and resolve a channel once the upgrade completes; reject if the socket
- *  closes/errors BEFORE it opens (a 421 redirect / wrong-node / unreachable). A server close AFTER
- *  open (e.g. a `@connect` reject or a guest reject) surfaces through `onClose(code)`. */
-function connectStream<TSend = Uint8Array>(
-    url: string,
-    encode?: (msg: never) => Uint8Array,
-): Promise<StreamChannel<TSend>> {
-    return new Promise((resolve, reject) => {
-        const ws = new WebSocket(url);
-        ws.binaryType = 'arraybuffer';
-        let opened = false;
-        let messageCb: ((data: Uint8Array) => void) | undefined;
-        let closeCb: ((code: number) => void) | undefined;
-        const pending: Uint8Array[] = [];
-
-        const channel: StreamChannel<TSend> = {
-            onMessage: (cb): void => {
-                messageCb = cb;
-                for (const m of pending) cb(m);
-                pending.length = 0;
-            },
-            onClose: (cb): void => {
-                closeCb = cb;
-            },
-            send: (data): void => {
-                if (ws.readyState !== WebSocket.OPEN) return;
-                // A typed channel encodes the @data message; a raw channel sends the bytes as-is.
-                const bytes = encode ? encode(data as never) : (data as unknown as Uint8Array);
-                try {
-                    ws.send(bytes as BufferSource);
-                } catch {
-                    /* socket transitioned OPEN -> CLOSING between the readyState check and send */
-                }
-            },
-            close: (): void => {
-                ws.close();
-            },
-        };
-
-        ws.addEventListener('open', () => {
-            opened = true;
-            resolve(channel);
-        });
-        ws.addEventListener('message', (event: MessageEvent) => {
-            if (!(event.data instanceof ArrayBuffer)) return;
-            const bytes = new Uint8Array(event.data);
-            // Buffer a reply that arrives before onMessage() registers (mirror the WebTransport path),
-            // so an eager server reply is not silently dropped.
-            if (messageCb) messageCb(bytes);
-            else pending.push(bytes);
-        });
-        ws.addEventListener('close', (event: CloseEvent) => {
-            if (!opened) reject(new Error(`stream connect failed (closed ${String(event.code)})`));
-            else closeCb?.(event.code);
-        });
-        ws.addEventListener('error', () => {
-            if (!opened) reject(new Error('stream connect error'));
-        });
-    });
-}
-
-/** Open a browser `WebTransport` session to `url` (an `https://` stream-tier origin) and resolve a
- *  channel once the session is ready. The browser drives the QUIC handshake, H3 Extended-CONNECT, and
- *  the RFC 9297 Quarter-Stream-ID datagram framing, so `send`/`onMessage` deal in raw bytes (no manual
- *  prefix). Rejects if the session fails to open (wrong node / unreachable / cert); a server close AFTER
- *  open surfaces via `onClose(code)`. This is the PRODUCTION transport - the L2/L3 edge is
- *  WebTransport-only; the dev server uses the `connectStream` WebSocket above. */
-function connectStreamWT<TSend = Uint8Array>(
-    url: string,
-    encode?: (msg: never) => Uint8Array,
-): Promise<StreamChannel<TSend>> {
-    return new Promise((resolve, reject) => {
-        if (!('WebTransport' in globalThis)) {
-            reject(new Error('WebTransport is not available in this browser'));
-            return;
-        }
-        let transport: WebTransport;
-        try {
-            transport = new WebTransport(url);
-        } catch (e) {
-            reject(e instanceof Error ? e : new Error(String(e)));
-            return;
-        }
-        let messageCb: ((data: Uint8Array) => void) | undefined;
-        let closeCb: ((code: number) => void) | undefined;
-        let writer: WritableStreamDefaultWriter<Uint8Array> | undefined;
-        let opened = false;
-        const pending: Uint8Array[] = [];
-
-        const channel: StreamChannel<TSend> = {
-            onMessage: (cb): void => {
-                messageCb = cb;
-                for (const m of pending) cb(m);
-                pending.length = 0;
-            },
-            onClose: (cb): void => {
-                closeCb = cb;
-            },
-            send: (data): void => {
-                if (!writer) return;
-                const bytes = encode ? encode(data as never) : (data as unknown as Uint8Array);
-                // Fire-and-forget; a write that rejects (transport closing / backpressure) is surfaced
-                // via onClose, so swallow it here to avoid an unhandled promise rejection.
-                void writer.write(bytes).catch(() => {});
-            },
-            close: (): void => {
-                try {
-                    transport.close();
-                } catch {
-                    /* already closing */
-                }
-            },
-        };
-
-        // A close AFTER open (guest reject, idle sweep, server shutdown) reports through onClose; a
-        // failure BEFORE open rejects the connect() promise via the `ready` catch below.
-        transport.closed
-            .then((info) => {
-                if (opened) closeCb?.(info?.closeCode ?? 0);
-            })
-            .catch(() => {
-                if (opened) closeCb?.(1);
-            });
-
-        transport.ready
-            .then(() => {
-                opened = true;
-                writer = transport.datagrams.writable.getWriter();
-                const reader = transport.datagrams.readable.getReader();
-                void (async (): Promise<void> => {
-                    try {
-                        for (;;) {
-                            const { value, done } = await reader.read();
-                            if (done) break;
-                            const bytes =
-                                value instanceof Uint8Array
-                                    ? value
-                                    : new Uint8Array(value as ArrayBufferLike);
-                            if (messageCb) messageCb(bytes);
-                            else pending.push(bytes);
-                        }
-                    } catch {
-                        /* read loop ended on session close */
-                    }
-                })();
-                resolve(channel);
-            })
-            .catch((e) => reject(e instanceof Error ? e : new Error(String(e))));
-    });
-}
-
-/** Pick the transport by origin scheme: `https://` -> WebTransport (the production L2/L3 edge),
- *  `ws(s)://` -> WebSocket (the dev server). The generated `shared/server.ts` sets the scheme per build
- *  (edge: `https://wt.<tenant>`; dev: same-origin `wss://`). */
-function openChannel<TSend = Uint8Array>(
-    url: string,
-    encode?: (msg: never) => Uint8Array,
-): Promise<StreamChannel<TSend>> {
-    return url.startsWith('https://')
-        ? connectStreamWT<TSend>(url, encode)
-        : connectStream<TSend>(url, encode);
-}
-
-/** The same-origin WebSocket base (`ws://` / `wss://` per the page protocol). */
-function defaultOrigin(): string {
-    const loc = globalThis.location;
-    return `${loc.protocol === 'https:' ? 'wss:' : 'ws:'}//${loc.host}`;
-}
-
-/** Resolve the stream-tier origin when the generated client passes none. A deploy/runtime override -
- *  `globalThis.__TOIL_STREAM_ORIGIN__` (e.g. `"https://wt.dacely.com"`, the production L2/L3 edge) -
- *  wins; otherwise fall back to the same-origin WebSocket base (the dev server). The edge override is
- *  `https://` so `openChannel` selects WebTransport; the dev fallback is `ws(s)://` so it selects
- *  WebSocket. This is how a deployed app points at its `wt.<tenant>` tier without the build knowing it. */
-function resolveStreamOrigin(): string {
-    const override = (globalThis as { __TOIL_STREAM_ORIGIN__?: unknown }).__TOIL_STREAM_ORIGIN__;
-    if (typeof override === 'string' && override.length > 0) return override;
-    return defaultOrigin();
-}
-
-/**
- * Build the `Server.Stream` client from the generated route map (`{ ClassName: route }`). `origin`
- * defaults to the page origin. `encoders` carries one `@data` encoder per typed `@stream({ message: T })`
- * class (the generated `(m) => m.encode()`); a class with no entry is a raw byte channel. The generated
- * `shared/server.ts` calls this and assigns the result to `globalThis.__toilStream`.
- */
-export function makeStreamClient(
-    routes: Record<string, string>,
-    origin?: string,
-    encoders?: Record<string, (msg: never) => Uint8Array>,
-): StreamClient {
-    const client: StreamClient = {};
-    for (const [name, route] of Object.entries(routes)) {
-        const encode = encoders?.[name];
-        client[name] = {
-            // Resolve the origin LAZILY, per connect() - so a deploy/app that sets
-            // `__TOIL_STREAM_ORIGIN__` after this module loads is still honoured.
-            connect: (path = ''): Promise<StreamChannel> =>
-                openChannel(`${origin ?? resolveStreamOrigin()}${route}${path}`, encode),
-        };
-    }
-    return client;
-}