stitchkit 0.8.0 → 0.9.0

package/dist/tools.js

@@ -1,39 +1,32 @@
 import {
-  ApiError,
-  createClient
-} from "./index-kdkvp26v.js";
+  inputIsQuery,
+  signJwt,
+  verifyPkce
+} from "./index-9zrq8x5z.js";
 import {
   coerceJsonArgs,
   collectTools,
   createCli,
   createToolRunner,
+  executeToolMethod,
   fetchGuarded,
   flattenDiscriminatedUnion,
   formatToolError,
   pollUntil,
   readCapped,
   toolResultFromError
-} from "./index-tr7r1530.js";
-import {
-  signJwt,
-  verifyPkce
-} from "./index-5qe31283.js";
-import"./index-48ffdxgk.js";
+} from "./index-13psnhhe.js";
 import {
   toJsonSchema
 } from "./index-0ed3bx43.js";
 import {
+  AppError,
   isWithinDir
-} from "./index-x3fcszf8.js";
-import"./index-wjwj5bz2.js";
+} from "./index-jgpsd7dy.js";
 import {
-  AppError
-} from "./index-eq29zkrx.js";
-import"./index-kzfs85xp.js";
-import {
-  isRecord
-} from "./index-809wc1tt.js";
-import"./index-37x76zdn.js";
+  isRecord,
+  typedEntries
+} from "./index-tm7dqzxc.js";
 
 // src/tools/agent.ts
 import { tool, zodSchema } from "ai";
@@ -76,6 +69,30 @@ function mountAgent(services, config = {}) {
   }
   return tools;
 }
+// src/tools/dispatch.ts
+function createContractDispatcher(services, config) {
+  const list = Array.isArray(services) ? services : [services];
+  const index = new Map;
+  for (const service of list) {
+    for (const [name, method] of Object.entries(service.methods)) {
+      if (index.has(name)) {
+        throw new Error(`createContractDispatcher: duplicate method "${name}" across services`);
+      }
+      index.set(name, method);
+    }
+  }
+  return {
+    methods: [...index.keys()],
+    dispatch(method, args, context) {
+      const target = index.get(method);
+      if (!target) {
+        return Promise.resolve(toolResultFromError(new AppError("NOT_FOUND", `Unknown method: ${method}`, 404)));
+      }
+      const ctx = { ...config.context, ...context, source: config.source };
+      return executeToolMethod(target, method, args, ctx, config.hooks, config.lifecycle, config.coerceJsonArgs ?? false);
+    }
+  };
+}
 // src/tools/manifest.ts
 function buildToolManifest(tools) {
   return tools.map((t) => {
@@ -94,16 +111,15 @@ import { z } from "zod";
 
 // src/tools/mcp-app.ts
 import { readFileSync } from "node:fs";
-import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
 var RESOURCE_MIME_TYPE = "text/html;profile=mcp-app";
 var EXT_APPS_BUNDLE_PLACEHOLDER = "/*__EXT_APPS_BUNDLE__*/";
-var require2 = createRequire(import.meta.url);
 function inlineMcpAppBundle(html) {
   if (!html.includes(EXT_APPS_BUNDLE_PLACEHOLDER))
     return html;
   let bundlePath;
   try {
-    bundlePath = require2.resolve("@modelcontextprotocol/ext-apps/app-with-deps");
+    bundlePath = fileURLToPath(import.meta.resolve("@modelcontextprotocol/ext-apps/app-with-deps"));
   } catch {
     throw new Error("[stitchkit] inlineMcpAppBundle: '@modelcontextprotocol/ext-apps' is not installed. " + "Add it as a dependency to serve MCP App widgets.");
   }
@@ -836,6 +852,257 @@ function mountOAuthProvider(config) {
   };
   return [metadataRoute, registerRoute, authorizeRoute, tokenRoute];
 }
+// src/browser/http.ts
+import ky, { isHTTPError } from "ky";
+class ApiError extends Error {
+  code;
+  status;
+  details;
+  hint;
+  constructor(code, status = 0, details, message, hint) {
+    super(message ?? `API Error: ${code}`);
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.hint = hint;
+    this.name = "ApiError";
+  }
+  static is(error) {
+    return error instanceof ApiError;
+  }
+}
+function parseApiErrorBody(body) {
+  if (!isRecord(body) || !isRecord(body.error))
+    return null;
+  const error = body.error;
+  if (typeof error.code !== "string")
+    return null;
+  return {
+    code: error.code,
+    message: typeof error.message === "string" ? error.message : undefined,
+    details: error.details,
+    hint: typeof error.hint === "string" ? error.hint : undefined
+  };
+}
+
+// src/browser/client.ts
+function withTimeout(options, timeout) {
+  if (timeout === undefined)
+    return options;
+  return { ...options, timeout };
+}
+function isParamArray(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string" || typeof v === "number");
+}
+function collectQueryParams(args, skipKeys) {
+  const params = {};
+  let hasParams = false;
+  for (const [key, value] of Object.entries(args)) {
+    if (skipKeys.has(key) || value === undefined || value === null)
+      continue;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || isParamArray(value)) {
+      params[key] = value;
+      hasParams = true;
+    }
+  }
+  return hasParams ? params : undefined;
+}
+function createClient(contract, configOrClient, contractConfig) {
+  const client = {};
+  const makeMethod = isHttpAdapter(configOrClient) ? (endpoint) => createHttpMethod(endpoint, contract.meta.prefix, configOrClient, contractConfig) : (endpoint) => createFetchMethod(endpoint, contract.meta.prefix, configOrClient, contractConfig);
+  for (const [key, endpoint] of typedEntries(contract.endpoints)) {
+    if (endpoint.expose && !endpoint.expose.includes("HTTP"))
+      continue;
+    setClientMethod(client, key, makeMethod(endpoint));
+  }
+  return client;
+}
+function isHttpAdapter(value) {
+  return typeof value === "object" && "get" in value && typeof value.get === "function";
+}
+function setClientMethod(target, key, method) {
+  target[key] = method;
+}
+function createHttpMethod(endpoint, prefix, client, config) {
+  const httpMethod = endpoint.method.toLowerCase();
+  const isGet = httpMethod === "get";
+  const paramNames = extractParamNames(endpoint.path);
+  const prefixKeys = new Set([...config?.stripPrefixKeys ?? [], ...paramNames]);
+  return (...args) => {
+    const firstArg = args[0] ?? {};
+    let pathPrefixStr = "";
+    if (config?.pathPrefix) {
+      pathPrefixStr = typeof config.pathPrefix === "function" ? config.pathPrefix(firstArg) : config.pathPrefix;
+      if (pathPrefixStr && !pathPrefixStr.endsWith("/"))
+        pathPrefixStr += "/";
+    }
+    let url = `${pathPrefixStr}${prefix}${endpoint.path}`;
+    for (const name of paramNames) {
+      const value = firstArg[name];
+      if (value === undefined || value === null) {
+        throw new Error(`Missing path param: ${name}`);
+      }
+      url = url.replace(`:${name}`, encodeURIComponent(String(value)));
+    }
+    if (url.endsWith("/"))
+      url = url.slice(0, -1);
+    if (endpoint.multipart) {
+      const file = firstArg[endpoint.multipart];
+      if (!isMultipartFile(file)) {
+        throw new Error(`Missing multipart file field: ${endpoint.multipart}`);
+      }
+      const formData = new FormData;
+      appendMultipartFile(formData, endpoint.multipart, file);
+      appendFormFields(formData, firstArg, new Set([...prefixKeys, endpoint.multipart]));
+      return client.post(url, formData, withTimeout(undefined, endpoint.timeout));
+    }
+    if (isGet) {
+      const params = collectQueryParams(firstArg, prefixKeys);
+      return client.get(url, withTimeout(params ? { params } : undefined, endpoint.timeout));
+    }
+    if (httpMethod === "delete") {
+      const params = collectQueryParams(firstArg, prefixKeys);
+      return client.delete(url, withTimeout(params ? { params } : undefined, endpoint.timeout));
+    }
+    const payload = {};
+    for (const [key, value] of Object.entries(firstArg)) {
+      if (!prefixKeys.has(key) && value !== undefined) {
+        payload[key] = value;
+      }
+    }
+    return client[httpMethod](url, Object.keys(payload).length > 0 ? payload : undefined, withTimeout(undefined, endpoint.timeout));
+  };
+}
+function createFetchMethod(endpoint, prefix, config, contractConfig) {
+  const prefixKeys = new Set(contractConfig?.stripPrefixKeys ?? []);
+  return async (args) => {
+    let pathPrefixStr = "";
+    if (contractConfig?.pathPrefix) {
+      pathPrefixStr = typeof contractConfig.pathPrefix === "function" ? contractConfig.pathPrefix(args ?? {}) : contractConfig.pathPrefix;
+      if (pathPrefixStr && !pathPrefixStr.endsWith("/"))
+        pathPrefixStr += "/";
+    }
+    let url = buildFetchUrl(config.baseUrl, prefix, endpoint.path, args, pathPrefixStr);
+    const headers = {
+      Accept: "application/json",
+      ...typeof config.headers === "function" ? config.headers() : config.headers
+    };
+    const isQuery = inputIsQuery(endpoint.method);
+    const hasBody = !isQuery && !endpoint.multipart && endpoint.input && args;
+    if (isQuery && args) {
+      const remaining = stripParams(args, endpoint.path, prefixKeys);
+      const searchParams = new URLSearchParams;
+      for (const [k, v] of Object.entries(remaining)) {
+        if (v === undefined || v === null)
+          continue;
+        if (isParamArray(v)) {
+          for (const item of v)
+            searchParams.append(k, String(item));
+        } else if (typeof v !== "object") {
+          searchParams.set(k, String(v));
+        }
+      }
+      if (searchParams.size > 0)
+        url += `?${searchParams}`;
+    }
+    if (hasBody)
+      headers["Content-Type"] = "application/json";
+    if (endpoint.multipart && args) {
+      const file = args[endpoint.multipart];
+      if (!isMultipartFile(file)) {
+        throw new Error(`Missing multipart file field: ${endpoint.multipart}`);
+      }
+      const formData = new FormData;
+      appendMultipartFile(formData, endpoint.multipart, file);
+      appendFormFields(formData, stripParams(args, endpoint.path, prefixKeys), new Set([endpoint.multipart]));
+      const res2 = await fetch(url, {
+        method: endpoint.method,
+        headers,
+        credentials: config.credentials,
+        body: formData
+      });
+      if (!res2.ok) {
+        await throwForErrorResponse(res2, config, null);
+      }
+      if (res2.status === 204)
+        return;
+      const json3 = await res2.json();
+      return endpoint.output ? endpoint.output.parse(json3) : json3;
+    }
+    const res = await fetch(url, {
+      method: endpoint.method,
+      headers,
+      credentials: config.credentials,
+      ...hasBody && {
+        body: JSON.stringify(stripParams(hasBody, endpoint.path, prefixKeys))
+      }
+    });
+    if (!res.ok) {
+      await throwForErrorResponse(res, config, { error: res.statusText });
+    }
+    if (res.status === 204)
+      return;
+    const json2 = await res.json();
+    return endpoint.output ? endpoint.output.parse(json2) : json2;
+  };
+}
+function isFileDescriptor(value) {
+  return typeof value === "object" && value !== null && !(value instanceof Blob) && "uri" in value && typeof value.uri === "string" && "name" in value && typeof value.name === "string" && "type" in value && typeof value.type === "string";
+}
+function isMultipartFile(value) {
+  return value instanceof Blob || isFileDescriptor(value);
+}
+function appendMultipartFile(form, field, file) {
+  const sink = form;
+  sink.append(field, file);
+}
+function appendFormFields(formData, values, skipKeys) {
+  for (const [key, value] of Object.entries(values)) {
+    if (skipKeys.has(key) || value === undefined || value === null)
+      continue;
+    formData.append(key, typeof value === "string" ? value : JSON.stringify(value));
+  }
+}
+async function throwForErrorResponse(res, config, fallbackBody) {
+  const body = await res.json().catch(() => fallbackBody);
+  config.onError?.(res.status, body);
+  const parsed = parseApiErrorBody(body);
+  if (parsed) {
+    throw new ApiError(parsed.code, res.status, parsed.details, parsed.message, parsed.hint);
+  }
+  throw new ApiError("HTTP_ERROR", res.status, { body });
+}
+function extractParamNames(path) {
+  const matches = path.match(/:(\w+)/g);
+  return matches ? matches.map((m) => m.slice(1)) : [];
+}
+function buildFetchUrl(baseUrl, prefix, path, args, pathPrefix = "") {
+  let fullPath = `/${pathPrefix}${prefix}${path === "/" ? "" : path}`;
+  if (args) {
+    fullPath = fullPath.replace(/:(\w+)/g, (_, key) => {
+      const val = args[key];
+      if (val === undefined || val === null) {
+        throw new Error(`Missing path param: ${key}`);
+      }
+      return encodeURIComponent(String(val));
+    });
+  }
+  return `${baseUrl}${fullPath}`;
+}
+function stripParams(args, path, extra) {
+  const skip = new Set(extra);
+  for (const match of path.matchAll(/:(\w+)/g)) {
+    if (match[1])
+      skip.add(match[1]);
+  }
+  const result = {};
+  for (const [k, v] of Object.entries(args)) {
+    if (!skip.has(k))
+      result[k] = v;
+  }
+  return result;
+}
+
 // src/tools/remote.ts
 function toArgs(ctx) {
   const { params, input } = ctx;
@@ -865,6 +1132,7 @@ function implementRemote(contract, http, options) {
       inputSchema: endpoint.input,
       outputSchema: endpoint.output,
       multipart: endpoint.multipart,
+      idempotent: endpoint.idempotent,
       handler: async (ctx) => {
         const call = client[key];
         if (!call) {
@@ -1043,6 +1311,7 @@ export {
   createToolkit,
   createStdioMcpServer,
   createMcpHandler,
+  createContractDispatcher,
   createCli,
   collectTools,
   coerceJsonArgs,

package/llms-full.txt

@@ -236,6 +236,7 @@ export const users = defineContract({ prefix: 'users' }, {
 | `toolName` | no | explicit MCP / agent tool name (defaults to `prefix_key`) |
 | `multipart` | no | field name of a file upload — see [below](#file-uploads) |
 | `timeout` | no | per-endpoint client timeout in ms, for slow endpoints |
+| `idempotent` | no | safe to call twice with the same input (like `PUT`/`DELETE`); a retrying transport reads it — see [Realtime](./realtime.md#bring-your-own-transport) |
 | `meta` | no | opaque app metadata — read in hooks / on tool mounts, never in OpenAPI ([below](#endpoint-metadata-meta)) |
 
 ## `params` vs `input` vs `output`
@@ -861,7 +862,10 @@ contract:
 - for `GET` / `DELETE`, the remaining fields become the **query string**
   (arrays become repeated keys),
 - for `POST` / `PUT` / `PATCH`, they become the **JSON body**,
-- a `multipart` field must be a `Blob` and is sent as `form-data`.
+- a `multipart` field is a `Blob` (web / Bun) or a platform `FileDescriptor`
+  (`{ uri, name, type }`, for React Native / Expo) and is sent as `form-data`.
+  The exported `MultipartFile` / `FileDescriptor` types let you annotate your own
+  upload helpers.
 
 ### Many contracts at once
 
@@ -1668,7 +1672,41 @@ subscribe once; reconnection is the wrapper's problem, not yours.
 
 `SocketIOClientConfig` takes `url`, `path`, `withCredentials` (cookies on the
 handshake — default `true`), `auth`, `query`, `extraHeaders`, `transports`,
-`reconnectionAttempts` and `reconnectionDelay`.
+`reconnectionAttempts`, `reconnectionDelay` and `retain` (below).
+
+### Sticky events
+
+A handler that subscribes **after** an event was emitted misses it — the UI stays
+on stale state until the next emission. List those events in **`retain`** and the
+client keeps each one's last payload and replays it to a handler the moment it
+subscribes (and on the next subscribe after a re-render). It is the pub/sub
+analogue of an MQTT *retained* message or an RxJS `BehaviorSubject`.
+
+```ts
+const client = createSocketIOClient<ServerEvents, ClientEvents>({
+  url,
+  retain: ['presence:changed', 'job:state'],   // events to keep the last value of
+})
+client.connect()
+
+// Later — even after the event already fired — this handler fires at once with
+// the last value, then on every future change:
+client.on('job:state', (s) => render(s))
+```
+
+The retained value survives a `disconnect()` / `connect()` cycle (the store lives
+outside the socket). Only an event's **first** argument is retained.
+
+For a pub/sub channel that is **not** Socket.IO (your own transport — see
+[below](#bring-your-own-transport)), use the same memory directly:
+
+```ts
+import { createRetainedTopics } from 'stitchkit'
+
+const topics = createRetainedTopics<{ 'job:state': JobState }>()
+topics.record('job:state', state)                 // on every publish
+topics.replay('job:state', (s) => render(s))      // for a late subscriber
+```
 
 ### Handshake auth — cookie or token
 
@@ -1834,6 +1872,69 @@ Notes:
 - For high throughput, handle backpressure in the raw lane: `ws.send()` returns
   `-1` under pressure; resume on the `drain` callback.
 
+## Bring-your-own transport
+
+Sometimes the transport is neither HTTP nor Socket.IO — a desktop app whose UI
+webview talks to its own local Bun sidecar over a raw WebSocket, an IPC channel,
+a queue worker. You still want one contract: a `defineContract` with typed
+client/server, Zod validation and a typed error envelope, not a hand-rolled
+method registry alongside it.
+
+stitchkit ships the **executor**, not the transport. `createContractDispatcher`
+runs a contract method by its key through the *same* core as the MCP / agent
+mounts — same validation, the same `{ ok, data } | { ok: false, code, … }`
+envelope, the same hooks and `beforeHandle` scope gate. You own the wire (framing,
+handshake, reconnect) and call `dispatch` per inbound frame.
+
+```ts
+import { createContractDispatcher } from 'stitchkit/tools'
+import { implement } from 'stitchkit/server'
+
+const service = implement(runtimeContract, { 'tasks.setDone': (ctx) => doIt(ctx.input), … })
+
+const dispatcher = createContractDispatcher(service, { source: 'local-ws' })
+
+// In your raw-WebSocket server, per `{ id, method, params }` frame:
+ws.onmessage = async (frame) => {
+  const { id, method, params } = JSON.parse(frame.data)
+  const result = await dispatcher.dispatch(method, params)   // validates + runs
+  ws.send(JSON.stringify({ id, ...result }))                 // { ok, data } | { ok:false, code, … }
+}
+```
+
+`dispatch` never throws for a normal call — a handler error becomes a failed
+result, and an unknown method is a `NOT_FOUND` result. Pass `hooks`
+(`beforeToolCall` / `afterToolCall`) and `lifecycle.beforeHandle` to audit and
+scope-guard exactly like the other transports. Tag calls with your own
+`source` — `TransportSource` is an open union.
+
+### Durability — `idempotent` + replay
+
+If the sidecar can restart mid-call, the client decides what to do with an
+in-flight request on reconnect from the operation's **idempotency**, declared on
+the contract:
+
+```ts
+export const runtimeContract = defineContract({ prefix: 'runtime' }, {
+  'tasks.setDone': { method: 'POST', path: '/done', desc: '…',
+    idempotent: true, input: taskDone, output: ok },     // re-send after reconnect — same result
+  'capture.start': { method: 'POST', path: '/start', desc: '…',
+    output: snapshot },                                   // unset → one-shot, do not re-send
+})
+```
+
+`idempotent` rides through to `MethodDef.idempotent`; the core attaches no
+behaviour. Your reconnect logic reads it: replay an idempotent call (the
+durability guarantee — the user's action is not lost), reject a non-idempotent
+one rather than fire a second side effect. Pair it with
+[sticky events](#sticky-events) (`createRetainedTopics`) so a reconnected client
+also catches up on the latest pushed state.
+
+This is deliberately *not* a reliable-RPC engine — that would be a competing
+WebSocket transport ([ADR 0008](../decisions/0008-thin-wrappers.md)). stitchkit
+gives you the executor and the metadata; the wire stays yours. See
+[ADR 0027](../decisions/0027-transport-neutral-contract-execution.md).
+
 
 ==============================================================================
 # Guide: Auth & errors  (docs/guide/auth-and-errors.md)
@@ -2718,10 +2819,12 @@ The browser-and-server entrypoint. Re-exports everything from
 | Export | Kind | Summary |
 |--------|------|---------|
 | `createSocketIOClient` | function | the typed Socket.IO client — [guide](../guide/realtime.md#client--createsocketioclient) |
+| `createRetainedTopics` | function | retained last-value store for sticky events — [guide](../guide/realtime.md#sticky-events) |
 | `parseSSE` | function | parse an SSE `Response` into an async generator — [guide](../guide/client.md#sse) |
 | `SocketIOClient` | _type_ | the client handle |
-| `SocketIOClientConfig` | _type_ | config for `createSocketIOClient` |
+| `SocketIOClientConfig` | _type_ | config for `createSocketIOClient` (incl. `retain`) |
 | `SocketEventMap` | _type_ | the shape of an event map |
+| `RetainedTopics` | _type_ | the `createRetainedTopics` handle |
 | `ParseSSEOptions` | _type_ | options for `parseSSE` |
 
 ---
@@ -2750,6 +2853,8 @@ from the root `stitchkit`.
 | `TypedHttpClient` | _type_ | the typed client, HTTP endpoints only (`= ScopedHttpClient<C, unknown>`) |
 | `ScopedHttpClient` | _type_ | a client whose `stripPrefixKeys` become required args ([guide](../guide/multi-tenant.md)) |
 | `ScopedEndpointFn` | _type_ | one method's signature with the consumed keys folded in |
+| `MultipartFile` | _type_ | a `multipart` file field — `Blob \| FileDescriptor` |
+| `FileDescriptor` | _type_ | a React Native / Expo file — `{ uri, name, type }` |
 
 ### Errors
 
@@ -2953,6 +3058,7 @@ Server-only. Turns contracts into MCP and AI-agent tools. Needs the
 | `mountMcp` | function | add contract tools to an existing `McpServer` — [guide](../guide/mcp-and-agents.md#mountmcp) |
 | `implementRemote` | function | bind a contract to a remote HTTP API — [guide](../guide/mcp-and-agents.md#proxying-a-remote-api--implementremote) |
 | `mountAgent` | function | a Vercel AI SDK `ToolSet` from a service — [guide](../guide/mcp-and-agents.md#ai-agents--mountagent) |
+| `createContractDispatcher` | function | run a contract over a bring-your-own transport — [guide](../guide/realtime.md#bring-your-own-transport) |
 | `createCli` | function | a command-line program from contracts — [guide](../guide/cli.md) (also on `stitchkit/cli`) |
 | `createToolkit` | function | context-typed tool mounts — [guide](../guide/cli.md#typed-context) |
 | `mountViewFile` | function | a native multimodal "view file" MCP tool |
@@ -2964,6 +3070,8 @@ Server-only. Turns contracts into MCP and AI-agent tools. Needs the
 | `ImplementRemoteOptions` | _type_ | options for `implementRemote` |
 | `McpMountConfig` | _type_ | config for `mountMcp` |
 | `AgentMountConfig` | _type_ | config for `mountAgent` |
+| `ContractDispatcher` | _type_ | the `createContractDispatcher` handle |
+| `ContractDispatcherConfig` | _type_ | config for `createContractDispatcher` |
 | `AgentContext` | _type_ | the context merged into agent tool handlers |
 | `CliConfig` | _type_ | config for `createCli` |
 | `CliWaitConfig` | _type_ | `--wait` polling config |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stitchkit",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Contract-first backend framework — one defineContract() into an HTTP API, MCP tools, AI-agent tools and a typed client. Bun and Node.",
   "keywords": [
     "bun",
@@ -82,9 +82,11 @@
   },
   "scripts": {
     "check": "bun x tsc --noEmit",
-    "build:js": "bun build src/index.ts src/react.ts src/tools.ts src/cli.ts src/contract/index.ts src/server/index.ts src/observability/index.ts src/node.ts --outdir dist --target node --packages external --splitting --root src",
+    "build:browser": "bun build src/index.ts src/react.ts src/contract/index.ts --outdir dist --target node --packages external --splitting --root src",
+    "build:server": "bun build src/server/index.ts src/node.ts src/tools.ts src/cli.ts src/observability/index.ts --outdir dist --target node --packages external --splitting --root src",
+    "build:js": "bun run build:browser && bun run build:server",
     "build:types": "bun x tsc -p tsconfig.build.json --emitDeclarationOnly",
-    "build": "rm -rf dist && bun run build:js && bun run build:types",
+    "build": "rm -rf dist && bun run build:js && bun run build:types && bun scripts/check-browser-clean.mjs",
     "dev": "bun run build:js -- --watch",
     "prepublishOnly": "cp ../../README.md ./README.md && bun ../../scripts/gen-llms.ts && bun run build",
     "test": "bun test",

package/dist/index-37x76zdn.js

@@ -1,4 +0,0 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-export { __require };

package/dist/index-48ffdxgk.js

@@ -1,6 +0,0 @@
-// src/internal/http-input.ts
-function inputIsQuery(method) {
-  return method === "GET" || method === "DELETE";
-}
-
-export { inputIsQuery };

package/dist/index-809wc1tt.js

@@ -1,18 +0,0 @@
-// src/internal/typed.ts
-function typedEntries(value) {
-  return Object.entries(value);
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function mapObject(source, mapper) {
-  const result = {};
-  for (const [key, value] of typedEntries(source)) {
-    const mapped = mapper(key, value);
-    if (mapped !== undefined)
-      result[key] = mapped;
-  }
-  return result;
-}
-
-export { typedEntries, isRecord, mapObject };

package/dist/index-a1702zj4.js

@@ -1,72 +0,0 @@
-import {
-  normalizeError
-} from "./index-wjwj5bz2.js";
-
-// src/server/stream.ts
-function streamSSE(generator) {
-  const encoder = new TextEncoder;
-  const stream = new ReadableStream({
-    async start(controller) {
-      try {
-        for await (const chunk of generator) {
-          const data = JSON.stringify(chunk);
-          controller.enqueue(encoder.encode(`data: ${data}
-
-`));
-        }
-        controller.enqueue(encoder.encode(`data: [DONE]
-
-`));
-        controller.close();
-      } catch (err) {
-        const envelope = normalizeError(err).toJSON();
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify(envelope)}
-
-`));
-        controller.close();
-      }
-    }
-  });
-  return new Response(stream, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive"
-    }
-  });
-}
-async function* parseSSE(response, options) {
-  const reader = response.body?.getReader();
-  if (!reader)
-    return;
-  const decoder = new TextDecoder;
-  let buffer = "";
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split(`
-`);
-      buffer = lines.pop() ?? "";
-      for (const rawLine of lines) {
-        const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
-        if (!line.startsWith("data:"))
-          continue;
-        const data = line.slice(5).replace(/^ /, "");
-        if (data === "[DONE]")
-          return;
-        try {
-          yield JSON.parse(data);
-        } catch (err) {
-          options?.onParseError?.(data, err instanceof Error ? err : new Error(String(err)));
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-
-export { streamSSE, parseSSE };