@carlos-tzin/tzin 0.1.0

package/dist/hub.js

@@ -0,0 +1,130 @@
+/**
+ * In-process pub/sub hub — the local delivery point of a realtime node.
+ * Standalone by default; pass `bus` to join a multi-node deployment.
+ */
+export class Hub {
+    #topics = new Map();
+    #bus;
+    #prefix;
+    #id = Math.random().toString(36).slice(2);
+    #busOffs = new Map();
+    #remoteListeners = new Set();
+    #infraChannel;
+    #infraOff;
+    constructor(options = {}) {
+        this.#bus = options.bus;
+        this.#prefix = options.channelPrefix ?? 'tzin:ch:';
+        this.#infraChannel = `${this.#prefix}__infra__`;
+    }
+    /**
+     * Infrastructure hook: invoked for every frame arriving from OTHER nodes
+     * over the dedicated infra channel, even when the topic has no local
+     * subscribers (e.g. presence replication). Returns an unsubscribe function.
+     */
+    onRemote(fn) {
+        this.#remoteListeners.add(fn);
+        if (this.#bus && !this.#infraOff) {
+            this.#infraOff = this.#bus.subscribe(this.#infraChannel, (m) => this.#deliverInfra(m));
+        }
+        return () => {
+            this.#remoteListeners.delete(fn);
+            if (this.#remoteListeners.size === 0 && this.#infraOff) {
+                this.#infraOff();
+                this.#infraOff = undefined;
+            }
+        };
+    }
+    /** Broadcast an infrastructure event to every other node's onRemote listeners. */
+    emitRemote(e) {
+        if (!this.#bus || this.#remoteListeners.size === 0)
+            return;
+        this.#bus.publish(this.#infraChannel, JSON.stringify({ topic: e.topic, event: e.event, data: e.data, from: this.#id }));
+    }
+    #deliverInfra(message) {
+        let frame;
+        try {
+            frame = JSON.parse(message);
+        }
+        catch {
+            return;
+        }
+        if (frame.from === this.#id)
+            return; // own echo
+        const e = { topic: frame.topic, event: frame.event, data: frame.data };
+        for (const fn of [...this.#remoteListeners]) {
+            try {
+                fn(e);
+            }
+            catch { }
+        }
+    }
+    subscribe(topic, fn) {
+        let set = this.#topics.get(topic);
+        if (!set) {
+            set = new Set();
+            this.#topics.set(topic, set);
+        }
+        set.add(fn);
+        // First local subscriber on the topic pulls remote frames for it.
+        const channel = this.#prefix + topic;
+        if (this.#bus && !this.#busOffs.has(channel)) {
+            this.#busOffs.set(channel, this.#bus.subscribe(channel, (message) => this.#deliverRemote(topic, message)));
+        }
+        return () => {
+            set.delete(fn);
+            if (set.size === 0) {
+                this.#topics.delete(topic);
+                // Last one out releases the bus subscription.
+                this.#busOffs.get(channel)?.();
+                this.#busOffs.delete(channel);
+            }
+        };
+    }
+    /** Deliver locally and, when clustered, broadcast to every other node. */
+    publish(topic, event, data) {
+        if (this.#bus) {
+            this.#bus.publish(this.#prefix + topic, JSON.stringify({ topic, event, data, from: this.#id }));
+        }
+        const set = this.#topics.get(topic);
+        if (!set)
+            return 0;
+        const e = { topic, event, data };
+        for (const fn of [...set]) {
+            try {
+                fn(e);
+            }
+            catch { }
+        }
+        return set.size;
+    }
+    subscriberCount(topic) {
+        return this.#topics.get(topic)?.size ?? 0;
+    }
+    #deliverRemote(topic, message) {
+        let frame;
+        try {
+            frame = JSON.parse(message);
+        }
+        catch {
+            return;
+        }
+        if (frame.from === this.#id)
+            return; // own echo
+        const e = { topic: frame.topic, event: frame.event, data: frame.data };
+        for (const fn of [...this.#remoteListeners]) {
+            try {
+                fn(e);
+            }
+            catch { }
+        }
+        const set = this.#topics.get(frame.topic);
+        if (!set)
+            return;
+        for (const fn of [...set]) {
+            try {
+                fn(e);
+            }
+            catch { }
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export { contract, impl, HttpError, type HttpMethod, type ContractDef, type AnyContract, type PathParamNames, type HandlerInput, type SectionsOf, type ResponseOf, type Handler, type RouteImpl, } from './contract.js';
+export { createApp, type App } from './server.js';
+export { client, type ClientOf, type ClientResult, type CallerFn } from './client.js';
+export { generateOpenApi } from './openapi.js';
+export { listen } from './node.js';
+export { t, Value } from './schema.js';
+export { defineContext, Ctx, type ContextKey } from './context.js';
+export { middleware, compose, type MiddlewareInput, type Middleware, type Next, type Dispatch } from './middleware.js';
+export { raw, isRawResult, type RawResult } from './contract.js';
+export { provide, type ProvidedEntry } from './provide.js';
+export { handleMcpMessage, listTools, toTool, type RpcRequest, } from './mcp.js';
+export { startStdioMcp, startStdioMcpFromStreams } from './mcp_stdio.js';
+export { Hub, type ChannelEvent, type Subscriber } from './hub.js';
+export { Presence, type MemberInfo } from './presence.js';
+export { channelRoutes, type ChannelOptions } from './channels.js';
+export { sse, type SseSender } from './sse.js';
+export { serve as serveBun } from './bun.js';
+export { toWorker, toDurableWorker, TzinChannels, DEFAULT_DO_BINDING, DEFAULT_DO_CLASS, type WorkerOptions, type DurableWorkerOptions, } from './workers.js';
+export { wsChannels, type WsRoute, type WsSend, type WsChannelOptions } from './ws.js';
+export { attachChannels } from './ws-node.js';
+export { LocalBus, clusterHubs, type MessageBus } from './bus.js';
+export { cors, type CorsOptions } from './cors.js';

package/dist/index.js

@@ -0,0 +1,22 @@
+export { contract, impl, HttpError, } from './contract.js';
+export { createApp } from './server.js';
+export { client } from './client.js';
+export { generateOpenApi } from './openapi.js';
+export { listen } from './node.js';
+export { t, Value } from './schema.js';
+export { defineContext, Ctx } from './context.js';
+export { middleware, compose } from './middleware.js';
+export { raw, isRawResult } from './contract.js';
+export { provide } from './provide.js';
+export { handleMcpMessage, listTools, toTool, } from './mcp.js';
+export { startStdioMcp, startStdioMcpFromStreams } from './mcp_stdio.js';
+export { Hub } from './hub.js';
+export { Presence } from './presence.js';
+export { channelRoutes } from './channels.js';
+export { sse } from './sse.js';
+export { serve as serveBun } from './bun.js';
+export { toWorker, toDurableWorker, TzinChannels, DEFAULT_DO_BINDING, DEFAULT_DO_CLASS, } from './workers.js';
+export { wsChannels } from './ws.js';
+export { attachChannels } from './ws-node.js';
+export { LocalBus, clusterHubs } from './bus.js';
+export { cors } from './cors.js';

package/dist/llms.d.ts

@@ -0,0 +1,10 @@
+import type { RouteImpl } from './contract.js';
+export interface ApiMeta {
+    title?: string;
+    description?: string;
+    version?: string;
+}
+/** llms.txt: the discoverable, human-readable index of the API. */
+export declare function renderLlmsTxt(routes: RouteImpl<any>[], meta?: ApiMeta): string;
+/** llms-full.txt: same index plus each endpoint's declared JSON Schemas. */
+export declare function renderLlmsFullTxt(routes: RouteImpl<any>[], meta?: ApiMeta): string;

package/dist/llms.js

@@ -0,0 +1,45 @@
+function endpointLines(routes) {
+    return routes.map(({ contract: c }) => {
+        const name = c.name ?? c.path.replace(/[^A-Za-z0-9]+/g, '_');
+        const label = `${c.method} ${c.path}`;
+        const desc = c.description ? `: ${c.description}` : '';
+        return `- [\`${label}\`](${name})${desc}`;
+    });
+}
+/** llms.txt: the discoverable, human-readable index of the API. */
+export function renderLlmsTxt(routes, meta = {}) {
+    const title = meta.title ?? 'API';
+    const summary = meta.description ?? `${routes.length} typed endpoints over a shared contract layer.`;
+    return [
+        `# ${title}`,
+        '',
+        `> ${summary}`,
+        '',
+        '## Endpoints',
+        '',
+        ...endpointLines(routes),
+        '',
+    ].join('\n');
+}
+/** llms-full.txt: same index plus each endpoint's declared JSON Schemas. */
+export function renderLlmsFullTxt(routes, meta = {}) {
+    const head = renderLlmsTxt(routes, meta);
+    const blocks = routes.map(({ contract: c }) => {
+        const name = c.name ?? c.path.replace(/[^A-Za-z0-9]+/g, '_');
+        const lines = [
+            `### ${c.method} ${c.path} (${name})`,
+            '',
+            ...(c.description ? [`${c.description}`, ''] : []),
+        ];
+        for (const section of ['params', 'query', 'headers', 'cookies', 'body']) {
+            if (section in c && c[section]) {
+                lines.push(`\`${section}\` schema:`, '', '```json', JSON.stringify(c[section]), '```', '');
+            }
+        }
+        for (const [status, schema] of Object.entries(c.responses)) {
+            lines.push(`response ${status} schema:`, '', '```json', JSON.stringify(schema), '```', '');
+        }
+        return lines.join('\n');
+    });
+    return `${head}\n## Endpoint details\n\n${blocks.join('\n')}`;
+}

package/dist/mcp.d.ts

@@ -0,0 +1,17 @@
+import type { App } from './server.js';
+import type { RouteImpl } from './contract.js';
+/**
+ * One endpoint = one MCP tool.
+ * The inputSchema is assembled from the contract's declared sections —
+ * TypeBox schemas are already JSON Schema, so there is no conversion layer.
+ */
+export declare function toTool(route: RouteImpl<any>): Record<string, unknown>;
+export declare function listTools(routes: RouteImpl<any>[]): Record<string, unknown>[];
+export interface RpcRequest {
+    jsonrpc?: string;
+    id?: string | number | null;
+    method?: string;
+    params?: Record<string, unknown>;
+}
+/** Handle one MCP JSON-RPC message; returns null for notifications. */
+export declare function handleMcpMessage(app: App, msg: RpcRequest): Promise<Record<string, unknown> | null>;

package/dist/mcp.js

@@ -0,0 +1,166 @@
+const PROTOCOL_VERSION = '2025-06-18';
+const SERVER_INFO = { name: 'tzin', version: '0.1.0' };
+/** '/users/:id' -> 'get_users_id' fallback tool name. */
+function defaultToolName(c) {
+    return `${c.method.toLowerCase()}_${c.path.replace(/[^A-Za-z0-9]+/g, '_').replace(/^_|_$/g, '')}`;
+}
+/**
+ * One endpoint = one MCP tool.
+ * The inputSchema is assembled from the contract's declared sections —
+ * TypeBox schemas are already JSON Schema, so there is no conversion layer.
+ */
+export function toTool(route) {
+    const c = route.contract;
+    const properties = {};
+    const required = [];
+    for (const section of ['params', 'query', 'body']) {
+        if (section in c && c[section]) {
+            properties[section] = c[section];
+            if (section !== 'query')
+                required.push(section);
+        }
+    }
+    // Path placeholders without a declared params schema still surface in the
+    // tool schema (as strings) so clients know to send them.
+    if (!('params' in c && c.params)) {
+        const placeholders = [...c.path.matchAll(/:([A-Za-z0-9_]+)/g)].map((m) => m[1]);
+        if (placeholders.length) {
+            properties.params = {
+                type: 'object',
+                properties: Object.fromEntries(placeholders.map((p) => [p, { type: 'string' }])),
+                required: placeholders,
+            };
+            required.push('params');
+        }
+    }
+    const responseLines = Object.entries(c.responses)
+        .map(([status, schema]) => {
+        const desc = schema.description ?? '';
+        return `- ${status}${desc ? `: ${desc}` : ''}`;
+    })
+        .join('\n');
+    return {
+        name: c.name ?? defaultToolName(c),
+        ...(c.description ? { description: c.description } : {}),
+        inputSchema: { type: 'object', properties, ...(required.length ? { required } : {}) },
+        annotations: {
+            'x-tzin-method': c.method,
+            'x-tzin-path': c.path,
+            'x-tzin-responses': responseLines,
+        },
+    };
+}
+export function listTools(routes) {
+    return routes.map(toTool);
+}
+function sectionProperties(schema) {
+    const props = schema.properties;
+    return props ? Object.keys(props) : [];
+}
+/**
+ * Tool arguments arrive nested ({params:{id}}) or flattened at the top level
+ * ({id}) — the common MCP client convention. Resolve either shape against the
+ * section's declared property names.
+ */
+function resolveSection(args, section, schema) {
+    const nested = args[section];
+    if (nested !== undefined) {
+        return typeof nested === 'object' && nested !== null ? nested : undefined;
+    }
+    const flat = {};
+    let found = false;
+    for (const key of sectionProperties(schema)) {
+        if (key in args) {
+            flat[key] = args[key];
+            found = true;
+        }
+    }
+    return found ? flat : undefined;
+}
+async function callTool(app, name, args) {
+    const routes = app.routes;
+    const route = routes.find((r) => (r.contract.name ?? defaultToolName(r.contract)) === name);
+    if (!route) {
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ error: `Unknown tool '${name}'` }) }],
+            isError: true,
+        };
+    }
+    const c = route.contract;
+    const rawArgs = (args ?? {});
+    const paramsSchema = 'params' in c ? c.params : undefined;
+    const querySchema = 'query' in c ? c.query : undefined;
+    const bodySchema = 'body' in c ? c.body : undefined;
+    // Path params may arrive even without a declared params schema — resolve
+    // them against the route's own :placeholders so the tool stays callable.
+    const requiredParams = [...c.path.matchAll(/:([A-Za-z0-9_]+)/g)].map((m) => m[1]);
+    const params = paramsSchema
+        ? resolveSection(rawArgs, 'params', paramsSchema)
+        : requiredParams.some((k) => k in rawArgs)
+            ? Object.fromEntries(requiredParams.filter((k) => k in rawArgs).map((k) => [k, rawArgs[k]]))
+            : undefined;
+    const missing = requiredParams.filter((k) => params?.[k] === undefined);
+    if (missing.length) {
+        return {
+            content: [
+                { type: 'text', text: `Missing argument(s): ${missing.map((k) => `params.${k}`).join(', ')}` },
+            ],
+            isError: true,
+        };
+    }
+    const path = c.path.replace(/:([A-Za-z0-9_]+)/g, (_m, key) => encodeURIComponent(String(params[key])));
+    const query = querySchema ? resolveSection(rawArgs, 'query', querySchema) : undefined;
+    const qs = query
+        ? new URLSearchParams(Object.entries(query).map(([k, v]) => [k, String(v)])).toString()
+        : '';
+    const fullPath = qs ? `${path}?${qs}` : path;
+    const body = bodySchema ? resolveSection(rawArgs, 'body', bodySchema) : undefined;
+    const init = { method: c.method };
+    if (body !== undefined)
+        init.body = JSON.stringify(body);
+    // In-process dispatch: validation, middleware and DI all apply.
+    const res = await app.fetch(new Request(`http://mcp.local${fullPath}`, init));
+    const text = await res.text();
+    if (!res.ok) {
+        return {
+            content: [{ type: 'text', text: `HTTP ${res.status}: ${text}` }],
+            isError: true,
+        };
+    }
+    return { content: [{ type: 'text', text }] };
+}
+/** Handle one MCP JSON-RPC message; returns null for notifications. */
+export async function handleMcpMessage(app, msg) {
+    const reply = (result) => ({
+        jsonrpc: '2.0',
+        id: msg.id ?? null,
+        result,
+    });
+    const error = (code, message) => ({
+        jsonrpc: '2.0',
+        id: msg.id ?? null,
+        error: { code, message },
+    });
+    switch (msg.method) {
+        case 'initialize':
+            return reply({
+                protocolVersion: PROTOCOL_VERSION,
+                capabilities: { tools: {} },
+                serverInfo: SERVER_INFO,
+            });
+        case 'tools/list':
+            return reply({ tools: listTools(app.routes) });
+        case 'tools/call': {
+            const name = String(msg.params?.name ?? '');
+            const result = await callTool(app, name, msg.params?.arguments);
+            return reply(result);
+        }
+        case 'notifications/initialized':
+            return null;
+        case undefined:
+        default:
+            if (msg.method?.startsWith('notifications/'))
+                return null;
+            return error(-32601, `Method not found: ${String(msg.method)}`);
+    }
+}

package/dist/mcp_stdio.d.ts

@@ -0,0 +1,10 @@
+import type { Readable, Writable } from 'node:stream';
+import type { App } from './server.js';
+/**
+ * Minimal MCP stdio transport: newline-delimited JSON-RPC on an input stream,
+ * responses written as newline-delimited JSON-RPC on an output stream.
+ * Streams are injectable for tests; startStdioMcp wires the real ones.
+ */
+export declare function startStdioMcpFromStreams(app: App, input: Readable, out: Writable): void;
+/** Point an MCP client at a small entryfile that builds the app and calls this. */
+export declare function startStdioMcp(app: App): void;

package/dist/mcp_stdio.js

@@ -0,0 +1,33 @@
+import { createInterface } from 'node:readline';
+import { handleMcpMessage } from './mcp.js';
+/**
+ * Minimal MCP stdio transport: newline-delimited JSON-RPC on an input stream,
+ * responses written as newline-delimited JSON-RPC on an output stream.
+ * Streams are injectable for tests; startStdioMcp wires the real ones.
+ */
+export function startStdioMcpFromStreams(app, input, out) {
+    const rl = createInterface({ input });
+    rl.on('line', async (line) => {
+        if (!line.trim())
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            out.write(JSON.stringify({
+                jsonrpc: '2.0',
+                id: null,
+                error: { code: -32700, message: 'Parse error' },
+            }) + '\n');
+            return;
+        }
+        const res = await handleMcpMessage(app, msg);
+        if (res)
+            out.write(JSON.stringify(res) + '\n');
+    });
+}
+/** Point an MCP client at a small entryfile that builds the app and calls this. */
+export function startStdioMcp(app) {
+    startStdioMcpFromStreams(app, process.stdin, process.stdout);
+}

package/dist/middleware.d.ts

@@ -0,0 +1,18 @@
+import type { Ctx } from './context.js';
+export interface Next {
+    (): Promise<Response>;
+}
+export interface MiddlewareInput {
+    req: Request;
+    ctx: Ctx;
+    next: Next;
+}
+export type Middleware = (input: MiddlewareInput) => Promise<Response>;
+export declare function middleware(fn: Middleware): Middleware;
+export type Dispatch = (req: Request, ctx: Ctx) => Promise<Response>;
+/**
+ * Onion composition: first middleware = outermost layer.
+ * Each middleware may run code before/after next(), short-circuit by not
+ * calling it, or replace the response entirely. `tail` is the innermost layer.
+ */
+export declare function compose(mws: Middleware[], tail: Dispatch): Dispatch;

package/dist/middleware.js

@@ -0,0 +1,22 @@
+export function middleware(fn) {
+    return fn;
+}
+/**
+ * Onion composition: first middleware = outermost layer.
+ * Each middleware may run code before/after next(), short-circuit by not
+ * calling it, or replace the response entirely. `tail` is the innermost layer.
+ */
+export function compose(mws, tail) {
+    return async (req, ctx) => {
+        let index = -1;
+        const run = (i) => {
+            if (i <= index)
+                return Promise.reject(new Error('next() called multiple times'));
+            index = i;
+            if (i === mws.length)
+                return tail(req, ctx);
+            return mws[i]({ req, ctx, next: () => run(i + 1) });
+        };
+        return run(0);
+    };
+}

package/dist/node.d.ts

@@ -0,0 +1,18 @@
+import { type Server } from 'node:http';
+import type { App } from './server.js';
+/**
+ * Minimal Node adapter. Production version: streaming, WebSockets, graceful shutdown.
+ *
+ * Hot-path notes (measured with autocannon layer isolation):
+ * - Requests are duck-typed instead of constructed via `new Request()` — the
+ *   undici constructor costs ~13µs/request under load.
+ * - Replies come from app.dispatchRaw(): tzin-built responses never allocate
+ *   an undici Response (~19µs/request under load). raw()/SSE still arrive as
+ *   a Response and take the streaming branch below.
+ * - `headers` on the duck request is a lazy getter: undici Headers allocation
+ *   is wasted work for contracts without a headers/cookies section.
+ * - The abort signal is lazy too: AbortController + close listener are only
+ *   wired when ctx.signal is actually read (SSE, channels), never on the
+ *   JSON hot path.
+ */
+export declare function listen(app: App, port?: number): Promise<Server>;

package/dist/node.js

@@ -0,0 +1,126 @@
+import { createServer } from 'node:http';
+/**
+ * Minimal Node adapter. Production version: streaming, WebSockets, graceful shutdown.
+ *
+ * Hot-path notes (measured with autocannon layer isolation):
+ * - Requests are duck-typed instead of constructed via `new Request()` — the
+ *   undici constructor costs ~13µs/request under load.
+ * - Replies come from app.dispatchRaw(): tzin-built responses never allocate
+ *   an undici Response (~19µs/request under load). raw()/SSE still arrive as
+ *   a Response and take the streaming branch below.
+ * - `headers` on the duck request is a lazy getter: undici Headers allocation
+ *   is wasted work for contracts without a headers/cookies section.
+ * - The abort signal is lazy too: AbortController + close listener are only
+ *   wired when ctx.signal is actually read (SSE, channels), never on the
+ *   JSON hot path.
+ */
+export function listen(app, port = 3000) {
+    const dispatch = app.dispatchRaw?.bind(app) ?? defaultDispatch(app);
+    const server = createServer(async (nodeReq, nodeRes) => {
+        try {
+            // Only drain the request stream when a body can actually be present.
+            let bodyBuf;
+            if (Number(nodeReq.headers['content-length'] ?? 0) > 0 ||
+                nodeReq.headers['transfer-encoding'] !== undefined) {
+                const chunks = [];
+                for await (const chunk of nodeReq)
+                    chunks.push(chunk);
+                bodyBuf = Buffer.concat(chunks);
+            }
+            // Signal wiring is deferred: the AbortController + close-listener only
+            // materialize if something reads ctx.signal (SSE, channels). JSON
+            // requests never pay for it.
+            let cachedSignal;
+            const signalFactory = () => {
+                if (cachedSignal === undefined) {
+                    const ac = new AbortController();
+                    nodeRes.on('close', () => {
+                        if (!nodeRes.writableEnded)
+                            ac.abort();
+                    });
+                    cachedSignal = ac.signal;
+                }
+                return cachedSignal;
+            };
+            let headers;
+            const req = {
+                url: `http://${nodeReq.headers.host}${nodeReq.url}`,
+                method: nodeReq.method,
+                get headers() {
+                    return (headers ??= new Headers(nodeReq.headers));
+                },
+                get signal() {
+                    return signalFactory();
+                },
+                __tzin_signal_factory: signalFactory,
+                body: null,
+                json: async () => {
+                    if (bodyBuf === undefined)
+                        throw new SyntaxError('Unexpected end of JSON input');
+                    return JSON.parse(bodyBuf.toString('utf8'));
+                },
+                text: async () => (bodyBuf ?? Buffer.alloc(0)).toString('utf8'),
+                arrayBuffer: async () => (bodyBuf ?? Buffer.alloc(0)).buffer,
+            };
+            const reply = await dispatch(req);
+            if (reply.response) {
+                const res = reply.response;
+                nodeRes.writeHead(res.status, resHeadersSlow(res));
+                // Streaming response (SSE, raw()): pump with backpressure instead of
+                // buffering — text()/arrayBuffer() would wait for the stream to close,
+                // which for event streams is never.
+                if (!res.body) {
+                    nodeRes.end();
+                    return;
+                }
+                const reader = res.body.getReader();
+                try {
+                    for (;;) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        if (!nodeRes.write(value)) {
+                            await new Promise((resolve) => nodeRes.once('drain', resolve));
+                        }
+                    }
+                    nodeRes.end();
+                }
+                catch {
+                    nodeRes.destroy();
+                }
+                return;
+            }
+            nodeRes.writeHead(reply.status, reply.headers);
+            nodeRes.end(reply.text);
+        }
+        catch (err) {
+            if (!nodeRes.headersSent) {
+                nodeRes.statusCode = 500;
+                nodeRes.end('Internal Server Error');
+            }
+            else {
+                nodeRes.end();
+            }
+            console.error(err);
+        }
+    });
+    // Nagle off once per socket, not per request.
+    server.on('connection', (socket) => socket.setNoDelay(true));
+    return new Promise((resolve) => {
+        server.listen(port, () => resolve(server));
+    });
+}
+function resHeadersSlow(res) {
+    const headers = {};
+    res.headers.forEach((value, key) => {
+        headers[key] = key === 'set-cookie' ? res.headers.getSetCookie() : value;
+    });
+    return headers;
+}
+/** Fallback for App implementations without dispatchRaw (e.g. wrappers). */
+function defaultDispatch(app) {
+    return async (req) => {
+        const res = await app.fetch(req);
+        return { status: res.status, response: res };
+    };
+}

package/dist/openapi.d.ts

@@ -0,0 +1,9 @@
+import type { RouteImpl } from './contract.js';
+/**
+ * OpenAPI 3.1 document generated from contracts.
+ * Zero conversion layer: TypeBox == JSON Schema == OpenAPI component vocabulary.
+ */
+export declare function generateOpenApi(routes: RouteImpl<any>[], info?: {
+    title: string;
+    version: string;
+}): Record<string, unknown>;