stitchkit 0.0.1 → 0.1.0

package/dist/index-809wc1tt.js

@@ -0,0 +1,18 @@
+// 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-gfzn1n4n.js

@@ -0,0 +1,29 @@
+import {
+  AppError
+} from "./index-7wfkbvss.js";
+
+// src/internal/errors.ts
+import { z } from "zod";
+function formatZodError(error) {
+  const issues = error.issues.slice(0, 5);
+  const lines = issues.map((issue) => {
+    const path = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+    return `${path}: ${issue.message}`;
+  });
+  const suffix = error.issues.length > 5 ? `
+...and ${error.issues.length - 5} more issues` : "";
+  return lines.join(`
+`) + suffix;
+}
+function normalizeError(err) {
+  if (AppError.is(err))
+    return err;
+  if (err instanceof z.ZodError) {
+    return new AppError("VALIDATION_ERROR", formatZodError(err), 400);
+  }
+  const msg = err instanceof Error ? err.message : String(err);
+  const safeMessage = msg.length > 200 ? `${msg.slice(0, 200)}...` : msg;
+  return new AppError("INTERNAL_SERVER_ERROR", safeMessage, 500);
+}
+
+export { formatZodError, normalizeError };

package/dist/index-ke4mx4ea.js

@@ -0,0 +1,38 @@
+// src/server/request.ts
+function generateTraceId() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 8);
+}
+function resolveTraceId(req) {
+  const header = req.headers.get("x-request-id") ?? req.headers.get("x-trace-id");
+  const trimmed = header?.trim();
+  if (trimmed && trimmed.length <= 128 && /^[\w.-]+$/.test(trimmed)) {
+    return trimmed;
+  }
+  return generateTraceId();
+}
+function extractIp(req) {
+  const forwarded = req.headers.get("x-forwarded-for");
+  if (forwarded)
+    return (forwarded.split(",")[0] ?? "").trim().replace("::ffff:", "");
+  const realIp = req.headers.get("x-real-ip");
+  if (realIp)
+    return realIp.trim().replace("::ffff:", "");
+  return "";
+}
+function getClientInfo(req) {
+  return {
+    ipAddress: extractIp(req) || undefined,
+    userAgent: req.headers.get("user-agent") ?? undefined
+  };
+}
+function parseQueryParams(url) {
+  const query = {};
+  for (const key of new Set(url.searchParams.keys())) {
+    const values = url.searchParams.getAll(key);
+    const [first] = values;
+    query[key] = values.length === 1 && first !== undefined ? first : values;
+  }
+  return query;
+}
+
+export { generateTraceId, resolveTraceId, extractIp, getClientInfo, parseQueryParams };

package/dist/index-n7bmdwmz.js

@@ -0,0 +1,68 @@
+// 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 msg = err instanceof Error ? err.message : String(err);
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ error: msg })}
+
+`));
+        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(6);
+        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 };

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { createClient, createClients } from './browser/client';
+export { ApiError, type ApiEvent, type ApiEventListener, createHttpClient, type HeaderProvider, type HttpClient, type HttpClientConfig, type RequestOptions, } from './browser/http';
+export type { SocketEventMap, SocketIOClient, SocketIOClientConfig, } from './browser/socket-io';
+export { createSocketIOClient } from './browser/socket-io';
+export { type ParseSSEOptions, parseSSE } from './browser/stream';
+export * from './contract';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EACL,QAAQ,EACR,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,cAAc,GACpB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,cAAc,EACd,cAAc,EACd,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,KAAK,eAAe,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAClE,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,111 @@
+import {
+  ApiError,
+  createClient,
+  createClients,
+  createHttpClient
+} from "./index-5sxnvwb1.js";
+import {
+  parseSSE
+} from "./index-n7bmdwmz.js";
+import {
+  ALL_TRANSPORTS,
+  AppError,
+  appError,
+  badRequest,
+  conflict,
+  defineContract,
+  forbidden,
+  notFound,
+  paginatedSchema,
+  rateLimited,
+  unauthorized
+} from "./index-7wfkbvss.js";
+import"./index-809wc1tt.js";
+// src/browser/socket-io.ts
+import { io } from "socket.io-client";
+function createSocketIOClient(config) {
+  let socket = null;
+  const connectionListeners = new Set;
+  const subscriptions = new Set;
+  function notifyConnection(connected) {
+    for (const listener of connectionListeners)
+      listener(connected);
+  }
+  return {
+    get connected() {
+      return socket?.connected ?? false;
+    },
+    connect() {
+      if (socket)
+        return;
+      socket = io(config.url, {
+        path: config.path ?? "/socket.io/",
+        withCredentials: config.withCredentials ?? true,
+        transports: config.transports ?? ["websocket", "polling"],
+        autoConnect: false,
+        reconnection: true,
+        reconnectionAttempts: config.reconnectionAttempts ?? Infinity,
+        reconnectionDelay: config.reconnectionDelay ?? 1000,
+        reconnectionDelayMax: config.reconnectionDelayMax ?? 5000,
+        timeout: config.timeout ?? 20000
+      });
+      socket.on("connect", () => notifyConnection(true));
+      socket.on("disconnect", () => notifyConnection(false));
+      for (const attach of subscriptions)
+        attach(socket);
+      socket.connect();
+    },
+    disconnect() {
+      if (!socket)
+        return;
+      const wasConnected = socket.connected;
+      socket.removeAllListeners();
+      socket.disconnect();
+      socket = null;
+      if (wasConnected)
+        notifyConnection(false);
+    },
+    on(event, handler) {
+      const name = event;
+      const attach = (s) => {
+        s.on(name, handler);
+      };
+      subscriptions.add(attach);
+      if (socket)
+        attach(socket);
+      return () => {
+        subscriptions.delete(attach);
+        socket?.off(name, handler);
+      };
+    },
+    emit(event, ...args) {
+      if (!socket?.connected)
+        return;
+      const name = event;
+      socket.emit(name, ...args);
+    },
+    onConnectionChange(listener) {
+      connectionListeners.add(listener);
+      return () => connectionListeners.delete(listener);
+    }
+  };
+}
+export {
+  unauthorized,
+  rateLimited,
+  parseSSE,
+  paginatedSchema,
+  notFound,
+  forbidden,
+  defineContract,
+  createSocketIOClient,
+  createHttpClient,
+  createClients,
+  createClient,
+  conflict,
+  badRequest,
+  appError,
+  AppError,
+  ApiError,
+  ALL_TRANSPORTS
+};

package/dist/internal/errors.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import { AppError } from '../contract';
+export declare function formatZodError(error: z.ZodError): string;
+export declare function normalizeError(err: unknown): AppError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/internal/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/internal/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,wBAAgB,cAAc,CAAC,KAAK,EAAE,CAAC,CAAC,QAAQ,GAAG,MAAM,CASxD;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,QAAQ,CAWrD"}

package/dist/internal/typed.d.ts

@@ -0,0 +1,9 @@
+export declare function typedEntries<T extends object>(value: T): Array<{
+    [K in keyof T]: [K, T[K]];
+}[keyof T]>;
+/** Narrow an unknown value to a plain object — not `null`, not an array. */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function mapObject<TSource extends object, TResult extends {
+    [K in keyof TSource]?: unknown;
+}>(source: TSource, mapper: <K extends keyof TSource>(key: K, value: TSource[K]) => TResult[K] | undefined): TResult;
+//# sourceMappingURL=typed.d.ts.map

package/dist/internal/typed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed.d.ts","sourceRoot":"","sources":["../../src/internal/typed.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,EAC3C,KAAK,EAAE,CAAC,GACP,KAAK,CAAC;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAE/C;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,wBAAgB,SAAS,CACvB,OAAO,SAAS,MAAM,EACtB,OAAO,SAAS;KAAG,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,EAAE,OAAO;CAAE,EAElD,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,CAAC,CAAC,SAAS,MAAM,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,GACrF,OAAO,CAOT"}

package/dist/observability/audit.d.ts

@@ -0,0 +1,32 @@
+import type { ToolCallHooks } from '../tools/execute';
+import type { RequestEvent } from './event';
+import { type SanitizeOptions } from './sanitize';
+/** Config for `createAuditHook`. */
+export interface AuditConfig {
+    /**
+     * The sink — persists one audit event. It runs fire-and-forget and its own
+     * errors are swallowed, so a slow or failing write never blocks or breaks the
+     * request it observes. Keep it asynchronous and self-contained.
+     */
+    write: (event: RequestEvent) => void | Promise<void>;
+    /** Keep only events for which this returns `true`. Default: keep every event. */
+    filter?: (event: RequestEvent) => boolean;
+    /** Payload sanitisation tuning — passed through to `sanitizePayload`. */
+    sanitize?: SanitizeOptions;
+}
+/** What `createAuditHook` returns — one wiring point per surface. */
+export interface AuditHook {
+    /**
+     * Wrap the HTTP fetch handler — audits every request from its final
+     * response (success and error alike). Compose it INSIDE `wrapInRequestContext`
+     * (it reads that context for trace ids, timing and identity).
+     */
+    http: <S>(handler: (req: Request, server: S) => Promise<Response>) => (req: Request, server: S) => Promise<Response>;
+    /**
+     * Tool-call hooks — audits every MCP / agent tool call. Pass as `hooks` to
+     * `createMcpHandler`, `createStdioMcpServer` or `mountAgent`.
+     */
+    toolCall: ToolCallHooks;
+}
+export declare function createAuditHook(config: AuditConfig): AuditHook;
+//# sourceMappingURL=audit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"audit.d.ts","sourceRoot":"","sources":["../../src/observability/audit.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,aAAa,EAAc,MAAM,kBAAkB,CAAC;AAElE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAe,KAAK,eAAe,EAAmB,MAAM,YAAY,CAAC;AAGhF,oCAAoC;AACpC,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,KAAK,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,iFAAiF;IACjF,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,OAAO,CAAC;IAC1C,yEAAyE;IACzE,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC5B;AAED,qEAAqE;AACrE,MAAM,WAAW,SAAS;IACxB;;;;OAIG;IACH,IAAI,EAAE,CAAC,CAAC,EACN,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,KACpD,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IACpD;;;OAGG;IACH,QAAQ,EAAE,aAAa,CAAC;CACzB;AAmBD,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,SAAS,CA6F9D"}

package/dist/observability/context.d.ts

@@ -0,0 +1,60 @@
+import type { TransportSource } from '../contract';
+import { type TraceContext } from './trace';
+/** Everything known about the request in flight. */
+export interface RequestContext {
+    /** W3C trace ids for this request. */
+    trace: TraceContext;
+    /** Which surface the request arrived on. */
+    source: TransportSource;
+    /** HTTP verb. */
+    method: string;
+    /** Request path. */
+    path: string;
+    /** Monotonic start, for duration — `process.hrtime.bigint()`. */
+    startedAt: bigint;
+    /** Client IP, when resolvable. */
+    ipAddress?: string;
+    /** Client user-agent, when present. */
+    userAgent?: string;
+    /** Resolved user id — set late, once auth has run. */
+    userId?: string;
+    /** Error outcome — set late, by the error handler. */
+    error?: {
+        code?: string;
+        message?: string;
+    };
+}
+/** Run `fn` with `ctx` as the active request context. */
+export declare function runWithRequestContext<T>(ctx: RequestContext, fn: () => T): T;
+/** The active request context, or `undefined` outside any request. */
+export declare function getRequestContext(): RequestContext | undefined;
+/** The active trace id — the one id to stamp on every log line. */
+export declare function getTraceId(): string | undefined;
+/** The active user id, once auth has resolved it. */
+export declare function getUserId(): string | undefined;
+/**
+ * Attach the resolved user to the active context. The ALS record is mutable —
+ * the update is visible to everything already holding the context. Call this
+ * from the auth hook.
+ */
+export declare function setRequestUser(userId: string): void;
+/**
+ * Record the error outcome on the active context. Call this from the error
+ * handler — the audit hook reads it when the request completes.
+ */
+export declare function setRequestError(error: {
+    code?: string;
+    message?: string;
+}): void;
+/**
+ * Wrap a fetch handler so it runs inside a fresh `RequestContext` — trace ids
+ * (the inbound `traceparent` continued, or freshly minted), timing and client
+ * info.
+ *
+ * Compose it as the OUTERMOST wrapper of the server's fetch handler. To make
+ * the framework router reuse this trace id (so request logs and application
+ * logs share one id), pass `traceId: getTraceId` to `createServer` /
+ * `createHandler`.
+ */
+export declare function wrapInRequestContext<S>(handler: (req: Request, server: S) => Promise<Response>): (req: Request, server: S) => Promise<Response>;
+//# sourceMappingURL=context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/observability/context.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAEjE,oDAAoD;AACpD,MAAM,WAAW,cAAc;IAC7B,sCAAsC;IACtC,KAAK,EAAE,YAAY,CAAC;IACpB,4CAA4C;IAC5C,MAAM,EAAE,eAAe,CAAC;IACxB,iBAAiB;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,iEAAiE;IACjE,SAAS,EAAE,MAAM,CAAC;IAClB,kCAAkC;IAClC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uCAAuC;IACvC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sDAAsD;IACtD,KAAK,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC7C;AAID,yDAAyD;AACzD,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,GAAG,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAE5E;AAED,sEAAsE;AACtE,wBAAgB,iBAAiB,IAAI,cAAc,GAAG,SAAS,CAE9D;AAED,mEAAmE;AACnE,wBAAgB,UAAU,IAAI,MAAM,GAAG,SAAS,CAE/C;AAED,qDAAqD;AACrD,wBAAgB,SAAS,IAAI,MAAM,GAAG,SAAS,CAE9C;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAGnD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAGhF;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EACpC,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,GACtD,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,CAYhD"}

package/dist/observability/event.d.ts

@@ -0,0 +1,49 @@
+import type { TransportSource } from '../contract';
+import type { JsonValue } from './sanitize';
+/**
+ * A normalised audit event — one shape for a completed call on any surface
+ * (an HTTP request, an MCP tool call, an agent tool call). `createAuditHook`
+ * produces it and hands it to the project's `write` sink. The project maps it
+ * onto its own audit table; stitchkit owns the normalisation.
+ */
+export interface RequestEvent {
+    /** Surface the call arrived on. */
+    source: TransportSource;
+    /** HTTP verb, or `TOOL` for a tool call. */
+    method: string;
+    /** Request path — `/api/...` for HTTP, `/{source}/{tool}` for a tool call. */
+    path: string;
+    /** Tool name — tool calls only. */
+    toolName?: string;
+    /** W3C trace id — correlates every span of one logical request. */
+    traceId: string;
+    /** W3C span id — unique to this call. */
+    spanId: string;
+    /** Parent span id, when this call is nested under another. */
+    parentSpanId?: string;
+    /** Whether the call succeeded. */
+    ok: boolean;
+    /** HTTP status — the real status for HTTP, `200` / `400` for a tool call. */
+    statusCode: number;
+    /** Wall-clock duration. */
+    durationMs: number;
+    /** Error code — failures only. */
+    errorCode?: string;
+    /** Error message — failures only. */
+    errorMessage?: string;
+    /** Sanitised request payload — the HTTP body or the tool arguments. */
+    payload: JsonValue | null;
+    /** Item count of the result, when it is a list. */
+    resultSize: number | null;
+    /** Serialised byte length of the result. */
+    responseBytes: number;
+    /** Resolved user id, when authenticated. */
+    userId?: string;
+    /** Client IP. */
+    ipAddress?: string;
+    /** Client user-agent. */
+    userAgent?: string;
+    /** When the call started. */
+    startedAt: Date;
+}
+//# sourceMappingURL=event.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../src/observability/event.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,mCAAmC;IACnC,MAAM,EAAE,eAAe,CAAC;IACxB,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,OAAO,EAAE,MAAM,CAAC;IAChB,yCAAyC;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,8DAA8D;IAC9D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kCAAkC;IAClC,EAAE,EAAE,OAAO,CAAC;IACZ,6EAA6E;IAC7E,UAAU,EAAE,MAAM,CAAC;IACnB,2BAA2B;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,kCAAkC;IAClC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qCAAqC;IACrC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uEAAuE;IACvE,OAAO,EAAE,SAAS,GAAG,IAAI,CAAC;IAC1B,mDAAmD;IACnD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,4CAA4C;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iBAAiB;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yBAAyB;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6BAA6B;IAC7B,SAAS,EAAE,IAAI,CAAC;CACjB"}

package/dist/observability/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `stitchkit/observability` — the audit layer one level above the raw hooks.
+ *
+ * W3C trace context, an `AsyncLocalStorage` request context, payload
+ * sanitisation, a normalised `RequestEvent`, and `createAuditHook` to wire it
+ * all into one sink. A project's logging becomes a table plus a `write`
+ * function — nothing else.
+ */
+export { type AuditConfig, type AuditHook, createAuditHook } from './audit';
+export { getRequestContext, getTraceId, getUserId, type RequestContext, runWithRequestContext, setRequestError, setRequestUser, wrapInRequestContext, } from './context';
+export type { RequestEvent } from './event';
+export { type JsonValue, measureSize, redact, type SanitizeOptions, type SizeMeasure, sanitizePayload, truncatePreview, } from './sanitize';
+export { childSpan, createTraceContext, formatTraceparent, parseTraceparent, resolveTraceContext, type TraceContext, } from './trace';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/observability/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,SAAS,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC5E,OAAO,EACL,iBAAiB,EACjB,UAAU,EACV,SAAS,EACT,KAAK,cAAc,EACnB,qBAAqB,EACrB,eAAe,EACf,cAAc,EACd,oBAAoB,GACrB,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EACL,KAAK,SAAS,EACd,WAAW,EACX,MAAM,EACN,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,eAAe,EACf,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,SAAS,EACT,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,KAAK,YAAY,GAClB,MAAM,SAAS,CAAC"}