stitchkit 0.0.1 → 0.1.0

package/dist/observability/index.js

@@ -0,0 +1,266 @@
+import {
+  isRecord
+} from "../index-809wc1tt.js";
+import {
+  getClientInfo
+} from "../index-ke4mx4ea.js";
+
+// src/observability/context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+
+// src/observability/trace.ts
+var TRACEPARENT_RE = /^00-([0-9a-f]{32})-([0-9a-f]{16})-[0-9a-f]{2}$/i;
+function randomHex(bytes) {
+  const arr = new Uint8Array(bytes);
+  crypto.getRandomValues(arr);
+  let hex = "";
+  for (const byte of arr)
+    hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+function createTraceContext() {
+  return { traceId: randomHex(16), spanId: randomHex(8) };
+}
+function parseTraceparent(header) {
+  if (!header)
+    return null;
+  const match = TRACEPARENT_RE.exec(header.trim());
+  if (!match?.[1] || !match[2])
+    return null;
+  return {
+    traceId: match[1].toLowerCase(),
+    spanId: randomHex(8),
+    parentSpanId: match[2].toLowerCase()
+  };
+}
+function formatTraceparent(ctx) {
+  return `00-${ctx.traceId}-${ctx.spanId}-01`;
+}
+function resolveTraceContext(req) {
+  return parseTraceparent(req.headers.get("traceparent")) ?? createTraceContext();
+}
+function childSpan(parent) {
+  return {
+    traceId: parent.traceId,
+    spanId: randomHex(8),
+    parentSpanId: parent.spanId
+  };
+}
+
+// src/observability/context.ts
+var storage = new AsyncLocalStorage;
+function runWithRequestContext(ctx, fn) {
+  return storage.run(ctx, fn);
+}
+function getRequestContext() {
+  return storage.getStore();
+}
+function getTraceId() {
+  return storage.getStore()?.trace.traceId;
+}
+function getUserId() {
+  return storage.getStore()?.userId;
+}
+function setRequestUser(userId) {
+  const ctx = storage.getStore();
+  if (ctx)
+    ctx.userId = userId;
+}
+function setRequestError(error) {
+  const ctx = storage.getStore();
+  if (ctx)
+    ctx.error = error;
+}
+function wrapInRequestContext(handler) {
+  return (req, server) => {
+    const ctx = {
+      trace: resolveTraceContext(req),
+      source: "http",
+      method: req.method,
+      path: new URL(req.url).pathname,
+      startedAt: process.hrtime.bigint(),
+      ...getClientInfo(req)
+    };
+    return runWithRequestContext(ctx, () => handler(req, server));
+  };
+}
+
+// src/observability/sanitize.ts
+var DEFAULT_SENSITIVE_KEYS = /(password|passwd|pwd|secret|token|apikey|api[-_ ]?key|auth|authorization|bearer|session|cookie|init[-_ ]?data|credential|private[-_ ]?key)/i;
+var DEFAULT_MAX_BYTES = 16000;
+var DEFAULT_MAX_DEPTH = 20;
+var MASK = "[redacted]";
+function redact(value, options = {}) {
+  const sensitive = options.sensitiveKeys ?? DEFAULT_SENSITIVE_KEYS;
+  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const walk = (input, depth) => {
+    if (depth > maxDepth)
+      return "[max depth]";
+    if (input === null || input === undefined)
+      return null;
+    if (typeof input === "string" || typeof input === "number" || typeof input === "boolean") {
+      return input;
+    }
+    if (input instanceof Uint8Array || input instanceof ArrayBuffer) {
+      return { _type: "binary", size: input.byteLength };
+    }
+    if (input instanceof Blob) {
+      return { _type: "blob", size: input.size, mime: input.type };
+    }
+    if (typeof FormData !== "undefined" && input instanceof FormData) {
+      return { _type: "formdata", keys: [...input.keys()] };
+    }
+    if (Array.isArray(input)) {
+      return input.map((item) => walk(item, depth + 1));
+    }
+    if (isRecord(input)) {
+      const out = {};
+      for (const [key, val] of Object.entries(input)) {
+        out[key] = sensitive.test(key) ? MASK : walk(val, depth + 1);
+      }
+      return out;
+    }
+    return String(input);
+  };
+  return walk(value, 0);
+}
+function truncatePreview(value, maxBytes = DEFAULT_MAX_BYTES) {
+  const json = JSON.stringify(value);
+  if (json.length <= maxBytes)
+    return value;
+  return {
+    _truncated: true,
+    _originalBytes: json.length,
+    preview: `${json.slice(0, maxBytes)}…`
+  };
+}
+function sanitizePayload(value, options = {}) {
+  if (value === undefined || value === null)
+    return null;
+  return truncatePreview(redact(value, options), options.maxBytes ?? DEFAULT_MAX_BYTES);
+}
+function measureSize(value) {
+  if (value === undefined || value === null) {
+    return { resultSize: null, responseBytes: 0 };
+  }
+  const responseBytes = Buffer.byteLength(JSON.stringify(value), "utf8");
+  if (Array.isArray(value)) {
+    return { resultSize: value.length, responseBytes };
+  }
+  if (typeof value === "object" && "items" in value && Array.isArray(value.items)) {
+    return { resultSize: value.items.length, responseBytes };
+  }
+  return { resultSize: null, responseBytes };
+}
+
+// src/observability/audit.ts
+var BODY_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+function toolErrorMessage(result) {
+  const { details, hint } = result;
+  if (isRecord(details) && typeof details.message === "string") {
+    return details.message;
+  }
+  return hint;
+}
+function readString(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function createAuditHook(config) {
+  const { write, filter, sanitize } = config;
+  const emit = async (event) => {
+    try {
+      if (filter && !filter(event))
+        return;
+      await write(event);
+    } catch {}
+  };
+  const http = (handler) => {
+    return async (req, server) => {
+      const bodyClone = BODY_METHODS.has(req.method) ? req.clone() : null;
+      const res = await handler(req, server);
+      const ctx = getRequestContext();
+      if (ctx) {
+        const durationMs = Math.round(Number(process.hrtime.bigint() - ctx.startedAt) / 1e6);
+        (async () => {
+          let body;
+          if (bodyClone) {
+            try {
+              body = await bodyClone.json();
+            } catch {
+              body = undefined;
+            }
+          }
+          await emit({
+            source: ctx.source,
+            method: ctx.method,
+            path: ctx.path,
+            traceId: ctx.trace.traceId,
+            spanId: ctx.trace.spanId,
+            parentSpanId: ctx.trace.parentSpanId,
+            ok: res.status < 400,
+            statusCode: res.status,
+            durationMs,
+            errorCode: ctx.error?.code,
+            errorMessage: ctx.error?.message,
+            payload: sanitizePayload(body, sanitize),
+            resultSize: null,
+            responseBytes: 0,
+            userId: ctx.userId,
+            ipAddress: ctx.ipAddress,
+            userAgent: ctx.userAgent,
+            startedAt: new Date(Date.now() - durationMs)
+          });
+        })();
+      }
+      return res;
+    };
+  };
+  const toolCall = {
+    afterToolCall: (toolName, args, result, durationMs, context) => {
+      const parent = getRequestContext()?.trace;
+      const span = parent ? childSpan(parent) : createTraceContext();
+      const measure = result.ok ? measureSize(result.data) : { resultSize: null, responseBytes: 0 };
+      emit({
+        source: context.source,
+        method: "TOOL",
+        path: `/${context.source}/${toolName}`,
+        toolName,
+        traceId: span.traceId,
+        spanId: span.spanId,
+        parentSpanId: span.parentSpanId,
+        ok: result.ok,
+        statusCode: result.ok ? 200 : 400,
+        durationMs,
+        errorCode: result.ok ? undefined : result.code,
+        errorMessage: result.ok ? undefined : toolErrorMessage(result),
+        payload: sanitizePayload(args, sanitize),
+        resultSize: measure.resultSize,
+        responseBytes: measure.responseBytes,
+        userId: readString(context.userId),
+        ipAddress: readString(context.ipAddress),
+        userAgent: readString(context.userAgent),
+        startedAt: new Date(Date.now() - durationMs)
+      });
+    }
+  };
+  return { http, toolCall };
+}
+export {
+  wrapInRequestContext,
+  truncatePreview,
+  setRequestUser,
+  setRequestError,
+  sanitizePayload,
+  runWithRequestContext,
+  resolveTraceContext,
+  redact,
+  parseTraceparent,
+  measureSize,
+  getUserId,
+  getTraceId,
+  getRequestContext,
+  formatTraceparent,
+  createTraceContext,
+  createAuditHook,
+  childSpan
+};

package/dist/observability/sanitize.d.ts

@@ -0,0 +1,42 @@
+/** A JSON-serialisable value — what a sanitised payload always reduces to. */
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** Tuning for `redact` / `sanitizePayload`. */
+export interface SanitizeOptions {
+    /** Keys whose VALUE is masked. Default covers passwords, tokens, secrets… */
+    sensitiveKeys?: RegExp;
+    /** Cap on the serialised payload — anything larger collapses to a preview. Default 16 KB. */
+    maxBytes?: number;
+    /** Recursion limit — deeper nesting collapses to a marker. Default 20. */
+    maxDepth?: number;
+}
+/** The result of `measureSize`. */
+export interface SizeMeasure {
+    /** Item count, when the value is a list (or a `{ items: [] }` page). */
+    resultSize: number | null;
+    /** Serialised byte length. */
+    responseBytes: number;
+}
+/**
+ * Deep-copy `value` into a JSON-safe shape: secret-named keys masked, binary
+ * blobs reduced to `{ _type, size }` metadata, branches past `maxDepth`
+ * truncated. Always returns a `JsonValue` — safe to store directly.
+ */
+export declare function redact(value: unknown, options?: SanitizeOptions): JsonValue;
+/**
+ * Cap a `JsonValue` by serialised size — anything over `maxBytes` collapses to
+ * a `{ _truncated, _originalBytes, preview }` marker.
+ */
+export declare function truncatePreview(value: JsonValue, maxBytes?: number): JsonValue;
+/**
+ * Sanitise an arbitrary payload for an audit row — `redact` then
+ * `truncatePreview`. `null` / `undefined` reduce to `null`.
+ */
+export declare function sanitizePayload(value: unknown, options?: SanitizeOptions): JsonValue | null;
+/**
+ * Measure a result for the audit row — item count when it is a list (a bare
+ * array or a `{ items: [] }` page), and the serialised byte length.
+ */
+export declare function measureSize(value: unknown): SizeMeasure;
+//# sourceMappingURL=sanitize.d.ts.map

package/dist/observability/sanitize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/observability/sanitize.ts"],"names":[],"mappings":"AAMA,8EAA8E;AAC9E,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,EAAE,GACX;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAEjC,+CAA+C;AAC/C,MAAM,WAAW,eAAe;IAC9B,6EAA6E;IAC7E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,mCAAmC;AACnC,MAAM,WAAW,WAAW;IAC1B,wEAAwE;IACxE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,8BAA8B;IAC9B,aAAa,EAAE,MAAM,CAAC;CACvB;AASD;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE,eAAoB,GAAG,SAAS,CAsC/E;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,SAAoB,GAAG,SAAS,CAQzF;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,eAAoB,GAC5B,SAAS,GAAG,IAAI,CAGlB;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAYvD"}

package/dist/observability/trace.d.ts

@@ -0,0 +1,42 @@
+/**
+ * W3C Trace Context — `traceparent` parsing, formatting and span chaining.
+ *
+ * `traceparent` format: `00-{traceId:32hex}-{spanId:16hex}-{flags:2hex}`.
+ * Spec: https://www.w3.org/TR/trace-context/
+ *
+ * A trace id is stable across every span of one logical request — it ties the
+ * front-end call, the HTTP handler and each nested tool call into one timeline.
+ * A span id is unique to a single operation within that trace.
+ */
+/** A point in a distributed trace — one trace, one span, an optional parent. */
+export interface TraceContext {
+    /** 32-hex trace id — stable across every span of one logical request. */
+    traceId: string;
+    /** 16-hex span id — unique to this operation. */
+    spanId: string;
+    /** 16-hex id of the span that caused this one, when there is one. */
+    parentSpanId?: string;
+}
+/** A fresh root trace — a new trace id, a new span id, no parent. */
+export declare function createTraceContext(): TraceContext;
+/**
+ * Parse a `traceparent` header into a `TraceContext`. The inbound span id
+ * becomes THIS context's `parentSpanId` and a fresh span id is minted — the
+ * receiver opens a new span under the caller's trace. Returns `null` for a
+ * missing or malformed header.
+ */
+export declare function parseTraceparent(header: string | null | undefined): TraceContext | null;
+/** Render a `TraceContext` as a `traceparent` header value (sampled flag `01`). */
+export declare function formatTraceparent(ctx: TraceContext): string;
+/**
+ * The trace for an incoming request — the caller's `traceparent` continued
+ * when present and valid, else a fresh root trace.
+ */
+export declare function resolveTraceContext(req: Request): TraceContext;
+/**
+ * A child span of `parent` — the same trace id, a fresh span id, `parentSpanId`
+ * set to the parent's span. Open one per nested operation (e.g. each tool call
+ * inside an HTTP request).
+ */
+export declare function childSpan(parent: TraceContext): TraceContext;
+//# sourceMappingURL=trace.d.ts.map

package/dist/observability/trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../src/observability/trace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,gFAAgF;AAChF,MAAM,WAAW,YAAY;IAC3B,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,qEAAqE;IACrE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAaD,qEAAqE;AACrE,wBAAgB,kBAAkB,IAAI,YAAY,CAEjD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,YAAY,GAAG,IAAI,CASvF;AAED,mFAAmF;AACnF,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,YAAY,GAAG,MAAM,CAE3D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,YAAY,CAE9D;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CAM5D"}

package/dist/react/cache-bridge.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Cache bridge — wire socket events into the TanStack Query cache.
+ *
+ * Transport-agnostic: works with ANY emitter exposing `on(event, handler) =>
+ * unsubscribe` — socket.io, stitchkit's `SocketClient`, an `EventTarget`
+ * wrapper. `TEvents` is a socket.io-style event map (`{ event: (payload) =>
+ * void }`, i.e. `ServerToClientEvents`) — so the whole family (all on
+ * socket.io) shares one cache-sync helper.
+ *
+ * Each handler updates `queryClient` in response to a typed server event.
+ * `markFresh(key)` (called from a mutation's onSuccess) records a key as
+ * just-mutated; a handler calls `ctx.isFresh(key)` to skip a stale socket echo
+ * and avoid a double update (mutation result + socket event).
+ */
+import type { QueryClient, QueryKey } from '@tanstack/react-query';
+/** Minimal emitter — subscribe to an event, get an unsubscribe back. */
+export interface CacheBridgeSocket<TEvents> {
+    on<K extends keyof TEvents & string>(event: K, handler: TEvents[K]): () => void;
+}
+export interface CacheBridgeContext {
+    queryClient: QueryClient;
+    /** True if `markFresh(key)` was called for this key within `freshWindow` ms. */
+    isFresh(key: QueryKey): boolean;
+}
+/** Payload of a socket.io-style event entry `(payload) => void`. */
+type EventPayload<T> = T extends (payload: infer P) => unknown ? P : never;
+export type CacheBridgeHandler<TPayload> = (data: TPayload, ctx: CacheBridgeContext) => void;
+export type CacheBridgeHandlers<TEvents> = {
+    [K in keyof TEvents & string]?: CacheBridgeHandler<EventPayload<TEvents[K]>>;
+};
+export interface CacheBridgeConfig<TEvents> {
+    socket: CacheBridgeSocket<TEvents>;
+    /**
+     * The TanStack Query client, or a thunk returning it. A thunk is resolved
+     * lazily at `connect()` time — keeps the bridge SSR-safe when it lives in a
+     * module-level `const` (client components are still evaluated on the server,
+     * where a browser-only `QueryClient` does not exist yet).
+     */
+    queryClient: QueryClient | (() => QueryClient);
+    handlers: CacheBridgeHandlers<TEvents>;
+    /** Window (ms) after `markFresh()` during which `isFresh()` returns true. Default 500. */
+    freshWindow?: number;
+}
+export interface CacheBridge {
+    connect(): void;
+    disconnect(): void;
+    /** Mark a query key as just-mutated. Call from a mutation's onSuccess so
+     *  handlers can skip a stale socket echo via `ctx.isFresh()`. */
+    markFresh(key: QueryKey): void;
+}
+export declare function createCacheBridge<TEvents>(config: CacheBridgeConfig<TEvents>): CacheBridge;
+export {};
+//# sourceMappingURL=cache-bridge.d.ts.map

package/dist/react/cache-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-bridge.d.ts","sourceRoot":"","sources":["../../src/react/cache-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEnE,wEAAwE;AACxE,MAAM,WAAW,iBAAiB,CAAC,OAAO;IACxC,EAAE,CAAC,CAAC,SAAS,MAAM,OAAO,GAAG,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,CAAC;CACjF;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,WAAW,CAAC;IACzB,gFAAgF;IAChF,OAAO,CAAC,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC;CACjC;AAED,oEAAoE;AACpE,KAAK,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC,KAAK,OAAO,GAAG,CAAC,GAAG,KAAK,CAAC;AAE3E,MAAM,MAAM,kBAAkB,CAAC,QAAQ,IAAI,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,kBAAkB,KAAK,IAAI,CAAC;AAE7F,MAAM,MAAM,mBAAmB,CAAC,OAAO,IAAI;KACxC,CAAC,IAAI,MAAM,OAAO,GAAG,MAAM,CAAC,CAAC,EAAE,kBAAkB,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;CAC7E,CAAC;AAEF,MAAM,WAAW,iBAAiB,CAAC,OAAO;IACxC,MAAM,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC;IACnC;;;;;OAKG;IACH,WAAW,EAAE,WAAW,GAAG,CAAC,MAAM,WAAW,CAAC,CAAC;IAC/C,QAAQ,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACvC,0FAA0F;IAC1F,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,IAAI,IAAI,CAAC;IAChB,UAAU,IAAI,IAAI,CAAC;IACnB;qEACiE;IACjE,SAAS,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAAC;CAChC;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,iBAAiB,CAAC,OAAO,CAAC,GAAG,WAAW,CA8C1F"}

package/dist/react/cursor-query.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Cursor-paginated infinite query — the family's canonical pagination hook.
+ *
+ * Built on `react-query-kit`'s `createInfiniteQuery` (the family's hook layer),
+ * so the result keeps the full rqk surface: `.getKey()`, `.fetcher`,
+ * `useSuspenseInfiniteQuery`, every option. Cursor pagination is immune to
+ * concurrent inserts — offset paging drops or duplicates rows when a new row
+ * lands on top of the list.
+ *
+ * Pass the typed contract method as `endpoint` (e.g. `apiClient.media.list`).
+ * The helper injects `cursor` from the page param and bakes in
+ * `getNextPageParam` / `initialPageParam`. An infinite hook is therefore just
+ * `queryKey + endpoint` — no per-hook fetcher, no pagination plumbing. Every
+ * other rqk option (`staleTime`, `gcTime`, `refetch*`, …) passes through.
+ *
+ * Page size is NOT a client concern: the helper never sends `limit`, so the
+ * server applies the contract's `limit` default (`z.coerce.number().default(N)`).
+ * That default is the single source of truth — the client cannot diverge.
+ */
+import { type CompatibleError, type CreateInfiniteQueryOptions } from 'react-query-kit';
+/** The cursor field the helper owns — the caller never passes it. */
+interface CursorParam {
+    cursor?: string;
+}
+/** Options the helper computes itself; the caller cannot override them. */
+type ControlledKeys = 'fetcher' | 'initialPageParam' | 'getNextPageParam';
+export type CursorQueryConfig<TVars, TPage extends {
+    nextCursor: string | null;
+}, TError> = Omit<CreateInfiniteQueryOptions<TPage, TVars, TError, string | null>, ControlledKeys> & {
+    /** Contract method, e.g. `apiClient.media.list`. */
+    endpoint: (args: TVars & CursorParam) => Promise<TPage>;
+};
+export declare function createCursorQuery<TVars, TPage extends {
+    nextCursor: string | null;
+}, TError = CompatibleError>(config: CursorQueryConfig<TVars, TPage, TError>): import("react-query-kit").InfiniteQueryHook<TPage, TVars, TError, string | null>;
+export {};
+//# sourceMappingURL=cursor-query.d.ts.map

package/dist/react/cursor-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor-query.d.ts","sourceRoot":"","sources":["../../src/react/cursor-query.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,0BAA0B,EAEhC,MAAM,iBAAiB,CAAC;AAEzB,qEAAqE;AACrE,UAAU,WAAW;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,2EAA2E;AAC3E,KAAK,cAAc,GAAG,SAAS,GAAG,kBAAkB,GAAG,kBAAkB,CAAC;AAE1E,MAAM,MAAM,iBAAiB,CAC3B,KAAK,EACL,KAAK,SAAS;IAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EAC3C,MAAM,IACJ,IAAI,CAAC,0BAA0B,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,EAAE,cAAc,CAAC,GAAG;IAC1F,oDAAoD;IACpD,QAAQ,EAAE,CAAC,IAAI,EAAE,KAAK,GAAG,WAAW,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC;CACzD,CAAC;AAEF,wBAAgB,iBAAiB,CAC/B,KAAK,EACL,KAAK,SAAS;IAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EAC3C,MAAM,GAAG,eAAe,EACxB,MAAM,EAAE,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,oFAYhD"}

package/dist/react.d.ts

@@ -0,0 +1,3 @@
+export { type CacheBridge, type CacheBridgeConfig, type CacheBridgeContext, type CacheBridgeHandler, type CacheBridgeHandlers, type CacheBridgeSocket, createCacheBridge, } from './react/cache-bridge';
+export { type CursorQueryConfig, createCursorQuery } from './react/cursor-query';
+//# sourceMappingURL=react.d.ts.map

package/dist/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../src/react.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,KAAK,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/react.js

@@ -0,0 +1,52 @@
+// src/react/cache-bridge.ts
+function createCacheBridge(config) {
+  const freshWindow = config.freshWindow ?? 500;
+  const freshAt = new Map;
+  let unsubscribers = [];
+  const isFresh = (key) => {
+    const ts = freshAt.get(JSON.stringify(key));
+    return ts !== undefined && Date.now() - ts < freshWindow;
+  };
+  return {
+    connect() {
+      if (unsubscribers.length > 0)
+        return;
+      const queryClient = typeof config.queryClient === "function" ? config.queryClient() : config.queryClient;
+      const ctx = { queryClient, isFresh };
+      const handlers = config.handlers;
+      const socket = config.socket;
+      for (const event of Object.keys(handlers)) {
+        const handler = handlers[event];
+        if (!handler)
+          continue;
+        const off = socket.on(event, (data) => handler(data, ctx));
+        unsubscribers.push(off);
+      }
+    },
+    disconnect() {
+      for (const off of unsubscribers)
+        off();
+      unsubscribers = [];
+    },
+    markFresh(key) {
+      freshAt.set(JSON.stringify(key), Date.now());
+    }
+  };
+}
+// src/react/cursor-query.ts
+import {
+  createInfiniteQuery
+} from "react-query-kit";
+function createCursorQuery(config) {
+  const { endpoint, ...rest } = config;
+  return createInfiniteQuery({
+    ...rest,
+    fetcher: (variables, { pageParam }) => endpoint({ ...variables, cursor: pageParam ?? undefined }),
+    initialPageParam: null,
+    getNextPageParam: (lastPage) => lastPage.nextCursor
+  });
+}
+export {
+  createCursorQuery,
+  createCacheBridge
+};

package/dist/server/cache.d.ts

@@ -0,0 +1,15 @@
+/**
+ * In-memory key/value cache with a per-entry TTL. Expired entries are swept on
+ * a 30-second timer; `destroy()` stops it. For response `Cache-Control`
+ * headers use `cacheHeaders()` instead.
+ */
+export declare function createCache(): {
+    destroy: () => void;
+    get(key: string): unknown | null;
+    set(key: string, data: unknown, maxAgeSeconds: number): void;
+    invalidate(prefix: string): void;
+    clear(): void;
+};
+/** Build a `Cache-Control` header capping freshness at `maxAge` seconds. */
+export declare function cacheHeaders(maxAge: number, scope?: 'public' | 'private'): Record<string, string>;
+//# sourceMappingURL=cache.d.ts.map

package/dist/server/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/server/cache.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,wBAAgB,WAAW;;aAQd,MAAM,GAAG,OAAO,GAAG,IAAI;aAUvB,MAAM,QAAQ,OAAO,iBAAiB,MAAM;uBAIlC,MAAM;;EAU5B;AAED,4EAA4E;AAC5E,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,KAAK,GAAE,QAAQ,GAAG,SAAoB,GACrC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAIxB"}

package/dist/server/context.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `RuntimeContext` assembly — parses params / body / multipart against the
+ * endpoint schemas and gathers request metadata (trace id, client info).
+ */
+import { type RuntimeContext } from '../contract';
+import type { MethodDef } from './types';
+export declare function buildContext(req: Request, url: URL, method: MethodDef, pathParams: Record<string, string>, traceId: string): Promise<RuntimeContext>;
+export declare function buildErrorContext(req: Request, url: URL, traceId: string): RuntimeContext;
+//# sourceMappingURL=context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/server/context.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAc,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAG9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AA2BzC,wBAAsB,YAAY,CAChC,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAClC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,cAAc,CAAC,CAyCzB;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,GAAG,cAAc,CAWzF"}

package/dist/server/create.d.ts

@@ -0,0 +1,4 @@
+import type { ServerConfig } from './types';
+export declare function createHandler(config: ServerConfig): (req: Request) => Promise<Response>;
+export declare function createServer(config: ServerConfig): Bun.Server<unknown>;
+//# sourceMappingURL=create.d.ts.map

package/dist/server/create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/server/create.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAwB,YAAY,EAAgB,MAAM,SAAS,CAAC;AAEhF,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CA+KvF;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,uBAsBhD"}

package/dist/server/event-bus.d.ts

@@ -0,0 +1,24 @@
+type EventHandler<T = unknown> = (data: T) => void | Promise<void>;
+/** Default event map — untyped string-keyed events (ad-hoc buses). */
+export type DefaultEventMap = Record<string, unknown>;
+/**
+ * In-process pub/sub bus.
+ *
+ * Pass an event map for full type safety — `emit`/`on`/`once`/`off` are then
+ * typed per event:
+ *
+ * ```ts
+ * const bus = createEventBus<{ 'user:created': { id: string } }>();
+ * bus.emit('user:created', { id: '1' }); // typed
+ * ```
+ */
+export interface EventBus<M extends Record<string, unknown> = DefaultEventMap> {
+    emit<K extends keyof M & string>(event: K, data: M[K]): void;
+    on<K extends keyof M & string>(event: K, handler: EventHandler<M[K]>): () => void;
+    once<K extends keyof M & string>(event: K, handler: EventHandler<M[K]>): () => void;
+    off<K extends keyof M & string>(event: K, handler: EventHandler<M[K]>): void;
+    clear(): void;
+}
+export declare function createEventBus<M extends Record<string, unknown> = DefaultEventMap>(): EventBus<M>;
+export {};
+//# sourceMappingURL=event-bus.d.ts.map

package/dist/server/event-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-bus.d.ts","sourceRoot":"","sources":["../../src/server/event-bus.ts"],"names":[],"mappings":"AAAA,KAAK,YAAY,CAAC,CAAC,GAAG,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnE,sEAAsE;AACtE,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEtD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe;IAC3E,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAC7D,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,CAAC;IAClF,IAAI,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI,CAAC;IACpF,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAC7E,KAAK,IAAI,IAAI,CAAC;CACf;AAYD,wBAAgB,cAAc,CAC5B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe,KAChD,QAAQ,CAAC,CAAC,CAAC,CAuDf"}

package/dist/server/implement.d.ts

@@ -0,0 +1,16 @@
+import type { ContractDef, EndpointDef, RuntimeContext } from '../contract';
+import type { Handlers, ServiceDef } from './types';
+/**
+ * Bind a contract to its typed `handlers`, producing a `ServiceDef` to mount on
+ * `createServer`. Every handler is type-checked against its endpoint's schemas.
+ * Pass `TCtx` for a typed handler context — or use `createImplement` to fix it
+ * once.
+ */
+export declare function implement<T extends Record<string, EndpointDef>, TCtx extends RuntimeContext = RuntimeContext>(contract: ContractDef<T, string>, handlers: Handlers<T, TCtx>): ServiceDef;
+/**
+ * Fix the handler context type once — `const implement =
+ * createImplement<MyContext>()` — so each `implement()` call site stays free of
+ * the generic. The application declares its context shape in a single place.
+ */
+export declare function createImplement<TCtx extends RuntimeContext>(): <T extends Record<string, EndpointDef>>(contract: ContractDef<T, string>, handlers: Handlers<T, TCtx>) => ServiceDef;
+//# sourceMappingURL=implement.d.ts.map

package/dist/server/implement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"implement.d.ts","sourceRoot":"","sources":["../../src/server/implement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC5E,OAAO,KAAK,EAAE,QAAQ,EAAa,UAAU,EAAE,MAAM,SAAS,CAAC;AAE/D;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EACrC,IAAI,SAAS,cAAc,GAAG,cAAc,EAC5C,QAAQ,EAAE,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,UAAU,CAoC3E;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,SAAS,cAAc,MACjD,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EAC3C,UAAU,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,EAChC,UAAU,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC,KAC1B,UAAU,CACd"}

package/dist/server/index.d.ts

@@ -0,0 +1,17 @@
+export { AppError, appError, badRequest, conflict, forbidden, notFound, rateLimited, unauthorized, } from '../contract';
+export { cacheHeaders, createCache } from './cache';
+export { createHandler, createServer } from './create';
+export { createEventBus, type EventBus } from './event-bus';
+export { createImplement, implement } from './implement';
+export { type AuthHook, type AuthHookConfig, type AuthRule, type BearerResolverConfig, createAuthHook, createBearerResolver, extractToken, type JwtPayload, verifyJwt, } from './middleware/auth';
+export { type CookieDef, type CookieOptions, defineCookie, parseCookies, serializeCookie, } from './middleware/cookies';
+export { type CorsConfig, corsHeaders, corsPreflightResponse, } from './middleware/cors';
+export { parseMultipart } from './multipart';
+export { createRateLimiter, type RateLimitConfig } from './rate-limit';
+export { extractIp, generateTraceId, getClientInfo, resolveTraceId, } from './request';
+export { staticRoute } from './router';
+export type { SocketIOServerConfig, SocketIOServerHandle } from './socket-io';
+export { createSocketIOServer } from './socket-io';
+export { type ParseSSEOptions, parseSSE, streamSSE } from './stream';
+export type { BunServer, Handlers, LifecycleHooks, MethodDef, RawRoute, RawRouteContext, RouteGroup, ServerConfig, ServerPassthrough, ServiceDef, StitchLogger, } from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,WAAW,EACX,YAAY,GACb,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,QAAQ,EACb,KAAK,oBAAoB,EACzB,cAAc,EACd,oBAAoB,EACpB,YAAY,EACZ,KAAK,UAAU,EACf,SAAS,GACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,YAAY,EACZ,YAAY,EACZ,eAAe,GAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,KAAK,UAAU,EACf,WAAW,EACX,qBAAqB,GACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AACvE,OAAO,EACL,SAAS,EACT,eAAe,EACf,aAAa,EACb,cAAc,GACf,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC,YAAY,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,KAAK,eAAe,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrE,YAAY,EACV,SAAS,EACT,QAAQ,EACR,cAAc,EACd,SAAS,EACT,QAAQ,EACR,eAAe,EACf,UAAU,EACV,YAAY,EACZ,iBAAiB,EACjB,UAAU,EACV,YAAY,GACb,MAAM,SAAS,CAAC"}