@cosmicdrift/kumiko-dev-server 0.387.0 → 0.389.0

package/dist/build-server-bundle.d.ts

@@ -1,7 +1,7 @@
 export type BuildServerBundleOptions = {
     /** App-Root. Default: process.cwd(). */
     readonly cwd?: string;
-    /** Output-Folder relativ zu cwd. Default: "dist-server". */
+    /** Output folder relative to cwd. Default: "dist-server". */
     readonly outDir?: string;
     /** Additional packages that must be installed at runtime
      *  (beyond RUNTIME_EXTERNALS). App-specific; defaults to empty. */

package/dist/build-server-bundle.js

@@ -125,12 +125,12 @@ export async function buildServerBundle(options = {}) {
     const outDir = resolve(cwd, options.outDir ?? "dist-server");
     const serverEntry = discoverServerEntry(cwd);
     if (!serverEntry) {
-        throw new Error(`[buildServerBundle] Kein bin/main.ts in ${cwd}.\n  Convention: bin/main.ts ist der Server-Bootstrap.`);
+        throw new Error(`[buildServerBundle] No bin/main.ts in ${cwd}.\n  Convention: bin/main.ts is the server bootstrap.`);
     }
     const repoRoot = findRepoRoot(cwd);
     const kumikoCli = repoRoot ? join(repoRoot, "bin/kumiko.ts") : undefined;
     if (kumikoCli && !existsSync(kumikoCli)) {
-        throw new Error(`[buildServerBundle] Repo-Root erkannt (${repoRoot}), aber bin/kumiko.ts fehlt — kann Migrate-CLI nicht bündeln.`);
+        throw new Error(`[buildServerBundle] Found the repo root (${repoRoot}), but bin/kumiko.ts is missing, so the migrate CLI cannot be bundled.`);
     }
     const extraEntryPaths = resolveExtraEntries(cwd, options.extraEntries ?? []);
     const externals = [

package/dist/create-kumiko-server-client-bundles.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="bun-types" preserve="true" />
+import type { CreateKumikoServerOptions } from "./create-kumiko-server.ts";
+export declare const PROD_BUNDLES_ENV = "KUMIKO_DEV_PROD_BUNDLES";
+export type ClientBundle = {
+    readonly js: string;
+    readonly map: string;
+    readonly chunks?: ReadonlyMap<string, string>;
+};
+export type ClientBundleBuilder = (sourceFile: string) => Promise<ClientBundle>;
+export declare function buildClient(entry: string): Promise<ClientBundle>;
+/** @internal — normalized client-entry form shared by single-entry
+ *  (`clientEntry`) and multi-entry (`clientEntries`) modes. */
+export type NormalizedEntry = {
+    readonly name: string;
+    readonly sourceFile: string;
+    readonly htmlPath: string | undefined;
+};
+export declare function normalizeEntries(options: CreateKumikoServerOptions): readonly NormalizedEntry[];
+export declare function indexBundlesByAssetPath(entries: readonly NormalizedEntry[]): ReadonlyMap<string, string>;
+export declare function buildClientBundles(entries: readonly NormalizedEntry[], buildBundle: ClientBundleBuilder): Promise<Map<string, ClientBundle>>;
+export declare function rebuildClientBundles(entries: readonly NormalizedEntry[], buildBundle: ClientBundleBuilder, clientBundles: Map<string, ClientBundle>): Promise<void>;

package/dist/create-kumiko-server-client-bundles.js

@@ -0,0 +1,97 @@
+/// <reference types="bun-types" preserve="true" />
+import { resolve } from "node:path";
+import { hasBun, logError, logInfo } from "./dev-server-runtime.js";
+// Duplicated in packages/testing/src/e2e/constants.ts: the Playwright config
+// runs under Node and cannot import this module.
+export const PROD_BUNDLES_ENV = "KUMIKO_DEV_PROD_BUNDLES";
+export async function buildClient(entry) {
+    if (!hasBun) {
+        throw new Error("[kumiko-server] clientEntry is only supported under Bun — Bun.build is unavailable in this runtime.");
+    }
+    const unminified = process.env["KUMIKO_DEV_UNMINIFIED"] === "1";
+    // Same splitting/sourcemap/NODE_ENV as build-prod-bundle.ts, opt-in via
+    // env so `bun dev` stays unchanged.
+    const prodShaped = process.env[PROD_BUNDLES_ENV] === "1";
+    const built = await Bun.build({
+        entrypoints: [entry],
+        target: "browser",
+        minify: !unminified,
+        sourcemap: prodShaped ? "none" : "linked",
+        splitting: prodShaped,
+        ...(prodShaped ? { define: { "process.env.NODE_ENV": JSON.stringify("production") } } : {}),
+    });
+    if (!built.success) {
+        logError("[kumiko-server] client bundle failed:");
+        for (const log of built.logs)
+            logError(log);
+        throw new Error("client bundle failed");
+    }
+    const jsOutput = built.outputs.find((o) => o.kind === "entry-point");
+    const mapOutput = built.outputs.find((o) => o.path.endsWith(".js.map"));
+    if (!jsOutput)
+        throw new Error("[kumiko-server] client bundle produced no .js output");
+    const chunks = new Map();
+    for (const output of built.outputs) {
+        if (output.kind !== "chunk")
+            continue;
+        const chunkPath = `/${output.path.replace(/^\.\//, "")}`;
+        chunks.set(chunkPath, await output.text());
+    }
+    return {
+        js: await jsOutput.text(),
+        map: mapOutput ? await mapOutput.text() : "",
+        chunks,
+    };
+}
+/** URL path used to serve an entry: `"client"` → `/client.js`
+ *  (the single-entry default), otherwise `/client-<name>.js`. Keeping
+ *  this in one place ensures routing and logging use the same convention. */
+function assetPathFor(entryName) {
+    return entryName === "client" ? "/client.js" : `/client-${entryName}.js`;
+}
+export function normalizeEntries(options) {
+    if (options.clientEntries !== undefined && options.clientEntry !== undefined) {
+        throw new Error("[kumiko-server] clientEntry und clientEntries sind mutually exclusive — wähle eins");
+    }
+    if (options.clientEntries !== undefined && options.clientEntries.length > 0) {
+        if (options.hostDispatch === undefined) {
+            throw new Error("[kumiko-server] clientEntries braucht hostDispatch — sonst weiß der Server nicht welches Template er liefern soll");
+        }
+        return options.clientEntries.map((e) => ({
+            name: e.name,
+            sourceFile: resolve(e.sourceFile),
+            htmlPath: e.htmlPath,
+        }));
+    }
+    if (options.clientEntry !== undefined) {
+        return [{ name: "client", sourceFile: resolve(options.clientEntry), htmlPath: undefined }];
+    }
+    return [];
+}
+// Each entry is served at GET /client[-name].js and its sourcemap at
+// GET /client[-name].js.map.
+export function indexBundlesByAssetPath(entries) {
+    const bundleByAssetPath = new Map();
+    for (const e of entries)
+        bundleByAssetPath.set(assetPathFor(e.name), e.name);
+    return bundleByAssetPath;
+}
+export async function buildClientBundles(entries, buildBundle) {
+    const clientBundles = new Map();
+    for (const e of entries) {
+        const bundle = await buildBundle(e.sourceFile);
+        clientBundles.set(e.name, bundle);
+        logInfo(`[kumiko-server] client bundle ${e.name}: ${bundle.js.length.toLocaleString()} bytes` +
+            (bundle.map ? ` (+ ${bundle.map.length.toLocaleString()} bytes sourcemap)` : ""));
+    }
+    return clientBundles;
+}
+// Rebuilds every entry even when only one file changed, because we do not
+// know which entries import it. A failing build throws and leaves the
+// bundles replaced so far in place.
+export async function rebuildClientBundles(entries, buildBundle, clientBundles) {
+    for (const e of entries) {
+        const rebuilt = await buildBundle(e.sourceFile);
+        clientBundles.set(e.name, rebuilt);
+    }
+}

package/dist/create-kumiko-server-html.d.ts

@@ -0,0 +1,21 @@
+import { type PageHeadResolver, type PageHeadSystemQuery } from "@cosmicdrift/kumiko-renderer/headless/apex";
+import type { TestStack } from "@cosmicdrift/kumiko-testing/stack";
+import type { NormalizedEntry } from "./create-kumiko-server-client-bundles.ts";
+export declare const DEFAULT_HTML = "<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"utf-8\" />\n    <meta name=\"viewport\" content=\"width=device-width,initial-scale=1,interactive-widget=resizes-content\" />\n    <title>Kumiko</title>\n  </head>\n  <body>\n    <div id=\"root\"></div>\n    <script type=\"module\" src=\"/client.js\"></script>\n  </body>\n</html>\n";
+export type DevHtmlTemplates = {
+    readonly defaultTemplate: string;
+    readonly byEntry: ReadonlyMap<string, string>;
+};
+export declare function loadHtmlTemplates(entries: readonly NormalizedEntry[], htmlPath: string | undefined): Promise<DevHtmlTemplates>;
+export type DevSystemQueryBuilder = (req: Request, socketAddress?: string) => PageHeadSystemQuery;
+export declare function createDevSystemQueryBuilder(dispatcher: TestStack["dispatcher"], trustedProxyHops: number | undefined): DevSystemQueryBuilder;
+export type DevHtmlDeps = {
+    readonly templates: DevHtmlTemplates;
+    readonly jwt: TestStack["jwt"];
+    readonly autoMintJwt: boolean;
+    readonly stylesheetPath: string | undefined;
+    readonly resolvePageHead: PageHeadResolver | undefined;
+    readonly buildSystemQuery: DevSystemQueryBuilder;
+};
+export declare function respondWithHtmlShell(deps: DevHtmlDeps, entryName: string, req: Request, socketAddress?: string, status?: number): Promise<Response>;
+export declare function respondWithStaticHtmlFile(file: string, status: number): Promise<Response>;

package/dist/create-kumiko-server-html.js

@@ -0,0 +1,132 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { AUTH_COOKIE_BASE, CSRF_COOKIE_BASE, createClientIpResolver, generateToken, sessionCookieName, } from "@cosmicdrift/kumiko-framework/api";
+import { rankPreferredLocales } from "@cosmicdrift/kumiko-framework/i18n";
+import { TestUsers } from "@cosmicdrift/kumiko-framework/seeding";
+import { resolveAndInjectPageHead, } from "@cosmicdrift/kumiko-renderer/headless/apex";
+import { buildRequestBoundSystemQuery } from "@cosmicdrift/kumiko-server-runtime/request-bound-system-query";
+import { errorCodeOf } from "@cosmicdrift/kumiko-types/type-guards";
+import { injectReload } from "./create-kumiko-server-reload.js";
+// The dev server speaks plain http, so its minted cookies are never Secure and keep the unprefixed names.
+const CSRF_COOKIE = sessionCookieName(CSRF_COOKIE_BASE, { secure: false });
+const AUTH_COOKIE = sessionCookieName(AUTH_COOKIE_BASE, { secure: false });
+// Minimal HTML when the caller didn't hand one in. `#root` is the
+// default mount target for `createKumikoApp`, so the one-line client
+// can attach without the sample having to ship its own template.
+//
+// `type="module"` is load-bearing: a classic script turns the bundle's
+// top-level declarations into window properties, so a dependency exporting
+// `function history()` (prosemirror-history, pulled in by tiptap) silently
+// replaces `window.history` and every pushState afterwards throws. Prod
+// (build-prod-bundle) has always emitted the module form.
+//
+// `interactive-widget=resizes-content`: without it, a mobile
+// keyboard shrinks only the visual viewport, not the layout viewport that
+// `position: fixed` anchors to — a fixed bottom action bar would stay
+// pinned behind the keyboard instead of above it. iOS Safari ignores the
+// key; renderer/web's useKeyboardInset covers it via window.visualViewport.
+export const DEFAULT_HTML = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1,interactive-widget=resizes-content" />
+    <title>Kumiko</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/client.js"></script>
+  </body>
+</html>
+`;
+// Injects <link rel="stylesheet" href="/styles.css"> into <head> if it
+// is not already present. Called only when the stylesheet option is used;
+// otherwise no CSS route is provided.
+function injectStylesheet(html) {
+    if (html.includes('href="/styles.css"'))
+        return html;
+    const link = '<link rel="stylesheet" href="/styles.css" />';
+    return html.includes("</head>")
+        ? html.replace("</head>", `  ${link}\n</head>`)
+        : `${link}${html}`;
+}
+// Single-entry uses one template (`htmlPath` or DEFAULT_HTML). Multi-entry
+// uses one per entry (`entry.htmlPath ?? options.htmlPath ?? DEFAULT_HTML`);
+// hostDispatch selects it per request.
+export async function loadHtmlTemplates(entries, htmlPath) {
+    const defaultTemplate = htmlPath !== undefined ? await readFile(resolve(htmlPath), "utf-8") : DEFAULT_HTML;
+    const byEntry = new Map();
+    for (const e of entries) {
+        byEntry.set(e.name, e.htmlPath !== undefined ? await readFile(resolve(e.htmlPath), "utf-8") : defaultTemplate);
+    }
+    return { defaultTemplate, byEntry };
+}
+// Anonymous-role systemQuery, shared by resolvePageHead and hostDispatch —
+// mirrors runProdApp's HostDispatchFn deps so dev/prod stay symmetric.
+// Own resolver with the same effective hops as setupTestStack's internal
+// buildServer: this path runs ahead of requestIdMiddleware's /api/* mount,
+// so it can't reuse that instance. Two independent warn-once flags in dev
+// is an accepted, low-risk gap (dev normally runs unproxied).
+export function createDevSystemQueryBuilder(dispatcher, trustedProxyHops) {
+    const pageHeadClientIpResolver = createClientIpResolver(trustedProxyHops ?? 0, "createKumikoServer(pageHead)");
+    return (req, socketAddress) => buildRequestBoundSystemQuery({
+        req,
+        dispatcher,
+        resolver: pageHeadClientIpResolver,
+        socketAddress,
+    });
+}
+// Dev user = TestUsers.admin: demo features are openToAll, but the auth
+// middleware still requires a valid JWT.
+async function appendDevSessionCookies(headers, jwt) {
+    const token = await jwt.sign(TestUsers.admin);
+    const csrf = generateToken();
+    headers.append("Set-Cookie", `${AUTH_COOKIE}=${token}; Path=/; HttpOnly; SameSite=Lax`);
+    headers.append("Set-Cookie", `${CSRF_COOKIE}=${csrf}; Path=/; SameSite=Lax`);
+}
+// resolvePageHead goes through the same headless resolveAndInjectPageHead
+// that runProdApp uses, so dev and e2e exercise the one timeout and
+// fallback path instead of a second copy of it.
+async function injectDevPageHead(html, resolvePageHead, req, socketAddress, buildSystemQuery) {
+    const url = new URL(req.url);
+    const host = req.headers.get("host") ?? url.host;
+    return resolveAndInjectPageHead(html, resolvePageHead, {
+        path: url.pathname,
+        host,
+        preferredLocales: rankPreferredLocales({
+            queryLang: url.searchParams.get("lang"),
+            acceptLanguage: req.headers.get("accept-language"),
+        }),
+        systemQuery: buildSystemQuery(req, socketAddress),
+        requestSignal: req.signal,
+    });
+}
+export async function respondWithHtmlShell(deps, entryName, req, socketAddress, status = 200) {
+    const template = deps.templates.byEntry.get(entryName) ?? deps.templates.defaultTemplate;
+    const headers = new Headers();
+    headers.set("Content-Type", "text/html; charset=utf-8");
+    if (deps.autoMintJwt)
+        await appendDevSessionCookies(headers, deps.jwt);
+    let html = injectReload(template);
+    if (deps.stylesheetPath !== undefined)
+        html = injectStylesheet(html);
+    if (deps.resolvePageHead !== undefined) {
+        html = await injectDevPageHead(html, deps.resolvePageHead, req, socketAddress, deps.buildSystemQuery);
+    }
+    return new Response(html, { status, headers });
+}
+// Raw file serve, no bundle injection — mirrors prod's `{ kind: "html", file }`.
+export async function respondWithStaticHtmlFile(file, status) {
+    let content;
+    try {
+        content = await readFile(file, "utf-8");
+    }
+    catch (error) {
+        if (errorCodeOf(error) !== "ENOENT")
+            throw error;
+        return new Response(`hostDispatch: file not found: ${file}`, { status: 500 });
+    }
+    return new Response(content, {
+        status,
+        headers: { "Content-Type": "text/html; charset=utf-8" },
+    });
+}

package/dist/create-kumiko-server-public-files.d.ts

@@ -0,0 +1,6 @@
+export declare function isRoutableGetOrHead(req: Request, pathname: string): boolean;
+export declare function servePublicFile(pathname: string, publicDir: string): Promise<{
+    readonly bytes: Uint8Array;
+    readonly mime: string;
+} | undefined>;
+export declare function resolveDevPublicDir(): string;

package/dist/create-kumiko-server-public-files.js

@@ -0,0 +1,96 @@
+import { existsSync, realpathSync } from "node:fs";
+import { readFile, realpath } from "node:fs/promises";
+import { resolve, sep } from "node:path";
+import { errorCodeOf } from "@cosmicdrift/kumiko-types/type-guards";
+// GET/HEAD to a non-API, non-SSE path — the dispatch-worthy set shared by
+// the SPA catch-all and the public/-file lookup (they split on whether the
+// path has a dot).
+export function isRoutableGetOrHead(req, pathname) {
+    return ((req.method === "GET" || req.method === "HEAD") &&
+        !pathname.startsWith("/api/") &&
+        !pathname.startsWith("/sse"));
+}
+// Resolves a request pathname to a file inside publicDir, or undefined if
+// it isn't one. Two traversal vectors, both must be blocked:
+//   - literal ".." segments (new URL() already collapses these in
+//     `pathname`, but resolve()+containment is checked regardless — no
+//     path-safety may depend on caller behavior upstream).
+//   - percent-encoded slashes (e.g. "%2e%2e%2f"): WHATWG URL parsing only
+//     normalizes dot-segments that are delimited by a literal "/", so an
+//     encoded slash survives into `pathname` untouched. decodeURIComponent
+//     resolves it to "../" before the containment check runs.
+function resolvePublicFilePath(pathname, publicDir) {
+    let decoded;
+    try {
+        decoded = decodeURIComponent(pathname);
+    }
+    catch {
+        return undefined;
+    }
+    // A NUL byte makes readFile throw ERR_INVALID_ARG_VALUE (not ENOENT), which
+    // would surface as a 500 instead of a router miss.
+    if (decoded.includes("\0"))
+        return undefined;
+    const resolved = resolve(publicDir, `.${decoded}`);
+    return resolved === publicDir || resolved.startsWith(publicDir + sep) ? resolved : undefined;
+}
+// Same extension → content-type mapping as prod's
+// run-prod-app-static-files.ts#mimeTypeFor — that function isn't part of
+// server-runtime's public exports (its own package.json "exports" map),
+// so this is a small self-contained copy rather than a new cross-package
+// export for one call site.
+const PUBLIC_FILE_MIME_TYPES = new Map([
+    ["html", "text/html; charset=utf-8"],
+    ["js", "text/javascript; charset=utf-8"],
+    ["mjs", "text/javascript; charset=utf-8"],
+    ["css", "text/css; charset=utf-8"],
+    ["json", "application/json; charset=utf-8"],
+    ["svg", "image/svg+xml"],
+    ["png", "image/png"],
+    ["jpg", "image/jpeg"],
+    ["jpeg", "image/jpeg"],
+    ["ico", "image/x-icon"],
+    ["txt", "text/plain; charset=utf-8"],
+    ["xml", "application/xml; charset=utf-8"],
+    ["webmanifest", "application/manifest+json"],
+    ["woff2", "font/woff2"],
+]);
+function publicFileMimeType(filePath) {
+    const ext = filePath.toLowerCase().split(".").pop() ?? "";
+    return PUBLIC_FILE_MIME_TYPES.get(ext) ?? "application/octet-stream";
+}
+// Reads a file under publicDir for the dev-server's static-asset fallback
+// (dev-parity with prod's disk lookup in buildStaticFallback). undefined
+// means "not a servable file here" — caller treats that as a router miss,
+// same as ENOENT/EISDIR/ENOTDIR further down.
+export async function servePublicFile(pathname, publicDir) {
+    const filePath = resolvePublicFilePath(pathname, publicDir);
+    if (filePath === undefined)
+        return undefined;
+    try {
+        // Lexical containment (above) only catches "..", not a symlink inside
+        // publicDir that points outside it on disk — realpath resolves the
+        // actual target and the same containment check runs against it. Read
+        // from the resolved path so the checked target is the one read.
+        const real = await realpath(filePath);
+        if (real !== publicDir && !real.startsWith(publicDir + sep))
+            return undefined;
+        const bytes = await readFile(real);
+        return { bytes, mime: publicFileMimeType(filePath) };
+    }
+    catch (err) {
+        const code = errorCodeOf(err);
+        if (code === "ENOENT" || code === "EISDIR" || code === "ENOTDIR" || code === "ENAMETOOLONG") {
+            return undefined;
+        }
+        throw err;
+    }
+}
+// App-root convention (same as the watchDirs patterns and resolveStylesheet):
+// process.cwd() is the app workspace, so public/ is its static asset dir.
+// Symlink-resolved once: servePublicFile compares realpath()s against it, so
+// a symlinked public/ would otherwise 404 every file.
+export function resolveDevPublicDir() {
+    const lexicalPublicDir = resolve(process.cwd(), "public");
+    return existsSync(lexicalPublicDir) ? realpathSync(lexicalPublicDir) : lexicalPublicDir;
+}

package/dist/create-kumiko-server-reload.d.ts

@@ -0,0 +1,14 @@
+export declare function injectReload(html: string): string;
+type ReloadClient = {
+    readonly controller: ReadableStreamDefaultController<Uint8Array>;
+    readonly encoder: TextEncoder;
+    closed: boolean;
+};
+export type DevReloadHub = {
+    readonly bootId: string;
+    readonly clients: Set<ReloadClient>;
+};
+export declare function createReloadHub(): DevReloadHub;
+export declare function broadcastReload(hub: DevReloadHub, changedFile: string): void;
+export declare function openReloadStream(hub: DevReloadHub): Response;
+export {};

package/dist/create-kumiko-server-reload.js

@@ -0,0 +1,73 @@
+// Reload snippet injected into every page-load so the browser
+// subscribes to /_reload without the HTML needing to hard-code it.
+//
+// Two reload triggers:
+//   - explicit `reload` event from the server after hot reload (rebuild + send)
+//   - implicit `boot` event on every SSE connection, containing the current
+//     server process's bootId. The snippet remembers the first bootId; if a
+//     reconnect receives a different one, it refreshes. Otherwise the
+//     browser could remain on a stale bundle after a server restart.
+const RELOAD_SNIPPET = `
+<script>
+  (() => {
+    const es = new EventSource("/_reload");
+    let firstBootId = null;
+    es.addEventListener("boot", (e) => {
+      if (firstBootId === null) {
+        firstBootId = e.data;
+      } else if (firstBootId !== e.data) {
+        location.reload();
+      }
+    });
+    es.addEventListener("reload", () => location.reload());
+  })();
+</script>
+`;
+export function injectReload(html) {
+    if (html.includes("/_reload"))
+        return html;
+    return html.includes("</body>")
+        ? html.replace("</body>", `${RELOAD_SNIPPET}</body>`)
+        : html + RELOAD_SNIPPET;
+}
+export function createReloadHub() {
+    return { bootId: String(Date.now()), clients: new Set() };
+}
+// JSON-encoded so a filename can never break the SSE framing.
+export function broadcastReload(hub, changedFile) {
+    const payload = `event: reload\ndata: ${JSON.stringify(changedFile)}\n\n`;
+    for (const client of hub.clients) {
+        if (client.closed)
+            continue;
+        try {
+            client.controller.enqueue(client.encoder.encode(payload));
+        }
+        catch {
+            client.closed = true;
+        }
+    }
+}
+export function openReloadStream(hub) {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        start(controller) {
+            const entry = { controller, encoder, closed: false };
+            hub.clients.add(entry);
+            controller.enqueue(encoder.encode(": connected\n\n"));
+            controller.enqueue(encoder.encode(`event: boot\ndata: ${hub.bootId}\n\n`));
+        },
+        cancel() {
+            for (const c of hub.clients) {
+                if (c.closed)
+                    hub.clients.delete(c);
+            }
+        },
+    });
+    return new Response(stream, {
+        headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        },
+    });
+}

package/dist/create-kumiko-server-routes.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="bun-types" preserve="true" />
+import type { TestStack } from "@cosmicdrift/kumiko-testing/stack";
+import type { CreateKumikoServerOptions } from "./create-kumiko-server.ts";
+import { type ClientBundle, type NormalizedEntry } from "./create-kumiko-server-client-bundles.ts";
+import { type DevHtmlTemplates } from "./create-kumiko-server-html.ts";
+import { type DevReloadHub } from "./create-kumiko-server-reload.ts";
+export type DevFetchHandler = (req: Request, socketAddress?: string) => Promise<Response>;
+export declare function createDevFetchHandler(input: {
+    readonly options: CreateKumikoServerOptions;
+    readonly stack: TestStack;
+    readonly entries: readonly NormalizedEntry[];
+    readonly clientBundles: ReadonlyMap<string, ClientBundle>;
+    readonly templates: DevHtmlTemplates;
+    readonly stylesheetPath: string | undefined;
+    readonly reloadHub: DevReloadHub;
+}): DevFetchHandler;