stitchkit 0.93.0 → 0.94.1

package/dist/index-xw3s75nj.js

@@ -0,0 +1,100 @@
+import {
+  projectRuntimeTool
+} from "./index-np4m8hd3.js";
+
+// src/tools/runtime-tool.ts
+function defineRuntimeTool(definition) {
+  if (definition.transports?.length === 0) {
+    throw new Error(`Runtime tool "${definition.name}" must expose at least one transport`);
+  }
+  return definition;
+}
+function createRuntimeToolFactory(config) {
+  function parseContext(context) {
+    const parsed = config.context.parse(context);
+    return {
+      ...context,
+      ...parsed,
+      params: undefined,
+      input: context.input,
+      ...context.mcp !== undefined && { mcp: context.mcp }
+    };
+  }
+  function define(definition) {
+    if (definition.output !== undefined) {
+      const { action: action2, method: method2, meta: meta2, handler: handler2, ...tool2 } = definition;
+      const identity2 = {
+        serviceName: config.serviceName,
+        action: action2,
+        method: method2,
+        ...config.scope !== undefined && { scope: config.scope },
+        ...(meta2 ?? config.meta) !== undefined && { meta: meta2 ?? config.meta }
+      };
+      return defineRuntimeTool({
+        ...tool2,
+        identity: identity2,
+        handler: (context) => handler2(parseContext(context))
+      });
+    }
+    const { action, method, meta, handler, ...tool } = definition;
+    const identity = {
+      serviceName: config.serviceName,
+      action,
+      method,
+      ...config.scope !== undefined && { scope: config.scope },
+      ...(meta ?? config.meta) !== undefined && { meta: meta ?? config.meta }
+    };
+    return defineRuntimeTool({
+      ...tool,
+      identity,
+      handler: (context) => handler(parseContext(context))
+    });
+  }
+  return { define };
+}
+function runtimeToolIdentity(definition) {
+  return {
+    method: definition.identity.method,
+    desc: definition.description,
+    serviceName: definition.identity.serviceName,
+    key: definition.identity.action,
+    toolName: definition.name,
+    scope: definition.identity.scope,
+    meta: definition.identity.meta,
+    annotations: definition.annotations,
+    ui: definition.ui,
+    mcp: definition.mcp
+  };
+}
+function runtimeToolMountable(definition, assertName = true) {
+  const projected = projectRuntimeTool(definition, assertName);
+  const method = {
+    ...runtimeToolIdentity(definition),
+    inputSchema: definition.input,
+    outputSchema: definition.output,
+    handler: definition.handler
+  };
+  return {
+    method,
+    name: projected.name,
+    argumentSchema: definition.input,
+    presentationSchema: projected.presentationSchema,
+    shouldExtend: false
+  };
+}
+function executableAgentRuntimeTools(tools) {
+  for (const tool of tools) {
+    if (typeof tool.handler !== "function") {
+      throw new TypeError(`Runtime tool "${tool.name}" must provide a handler`);
+    }
+    if (tool.present?.agent !== undefined && typeof tool.present.agent !== "function") {
+      throw new TypeError(`Runtime tool "${tool.name}" Agent presenter must be a function`);
+    }
+    if (tool.present?.agent !== undefined && tool.output === undefined) {
+      throw new TypeError(`Runtime tool "${tool.name}" Agent presenter requires an output schema`);
+    }
+  }
+  return tools;
+}
+
+export { defineRuntimeTool, createRuntimeToolFactory, runtimeToolMountable, executableAgentRuntimeTools };

package/dist/index-yw4fzmdz.js

@@ -0,0 +1,268 @@
+import {
+  isUnsafeKey
+} from "./index-kzfs85xp.js";
+import {
+  isRecord
+} from "./index-hffjpmq9.js";
+
+// src/observability/sanitize.ts
+var SENSITIVE_WORDS = new Set([
+  "password",
+  "passwords",
+  "passwd",
+  "pwd",
+  "secret",
+  "secrets",
+  "token",
+  "tokens",
+  "apikey",
+  "auth",
+  "authorization",
+  "bearer",
+  "cookie",
+  "cookies",
+  "credential",
+  "credentials"
+]);
+var SENSITIVE_WORD_PAIRS = new Set([
+  "apikey",
+  "privatekey",
+  "initdata",
+  "sessionid",
+  "sessionkey"
+]);
+var SENSITIVE_EXACT = new Set(["session"]);
+function splitKeyWords(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter((word) => word.length > 0);
+}
+function isSensitiveKeyDefault(key) {
+  const words = splitKeyWords(key);
+  if (words.length === 1 && SENSITIVE_EXACT.has(words[0] ?? ""))
+    return true;
+  for (let index = 0;index < words.length; index += 1) {
+    const word = words[index] ?? "";
+    if (SENSITIVE_WORDS.has(word))
+      return true;
+    const next = words[index + 1];
+    if (next !== undefined && SENSITIVE_WORD_PAIRS.has(word + next))
+      return true;
+  }
+  return false;
+}
+var DEFAULT_MAX_BYTES = 16000;
+var DEFAULT_MAX_DEPTH = 20;
+var DEFAULT_MAX_NODES = 20000;
+var MASK = "[redacted]";
+function redact(value, options = {}) {
+  const custom = options.sensitiveKeys;
+  const isSensitive = custom === undefined ? isSensitiveKeyDefault : (key) => {
+    custom.lastIndex = 0;
+    return custom.test(key) || options.includeDefaultSensitiveKeys === true && isSensitiveKeyDefault(key);
+  };
+  const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const maxStringLength = options.maxStringLength ?? Number.POSITIVE_INFINITY;
+  const maxCollectionLength = options.maxCollectionLength ?? Number.POSITIVE_INFINITY;
+  const pathMatchers = (options.sensitivePaths ?? []).map((pattern) => pattern.split("."));
+  const matchesPath = (matcher, path, patternIndex = 0, pathIndex = 0) => {
+    if (patternIndex === matcher.length)
+      return pathIndex === path.length;
+    const segment = matcher[patternIndex];
+    if (segment === "**") {
+      if (patternIndex + 1 === matcher.length)
+        return true;
+      for (let next = pathIndex;next <= path.length; next += 1) {
+        if (matchesPath(matcher, path, patternIndex + 1, next))
+          return true;
+      }
+      return false;
+    }
+    if (pathIndex === path.length || segment !== "*" && segment !== path[pathIndex])
+      return false;
+    return matchesPath(matcher, path, patternIndex + 1, pathIndex + 1);
+  };
+  const isSensitivePath = (path) => pathMatchers.some((matcher) => matchesPath(matcher, path));
+  const stringBoundFor = (key) => {
+    const byKey = key === undefined ? undefined : options.maxStringLengthByKey?.[key];
+    return byKey ?? maxStringLength;
+  };
+  const safeString = (input, key) => {
+    const bound = stringBoundFor(key);
+    let output = input;
+    for (const pattern of options.sensitiveUrlPatterns ?? []) {
+      try {
+        const global = new RegExp(pattern.source, `${pattern.flags.replace(/[gy]/g, "")}g`);
+        output = output.replace(global, MASK);
+      } catch {}
+    }
+    if (output.length <= bound)
+      return output;
+    return `${output.slice(0, Math.max(0, bound))}…[truncated]`;
+  };
+  const ancestors = new Set;
+  const maxNodes = options.maxNodes ?? DEFAULT_MAX_NODES;
+  let visited = 0;
+  const walk = (input, depth, path = []) => {
+    if (depth > maxDepth)
+      return "[max depth]";
+    visited += 1;
+    if (visited > maxNodes)
+      return "[node budget]";
+    if (input === null || input === undefined)
+      return null;
+    if (typeof input === "string")
+      return safeString(input, path[path.length - 1]);
+    if (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 (input instanceof Map) {
+      if (ancestors.has(input))
+        return "[circular]";
+      ancestors.add(input);
+      const entries = [...input.entries()];
+      const result = entries.slice(0, maxCollectionLength).map(([key, value2]) => {
+        const segment = typeof key === "string" ? key : String(key);
+        const childPath = [...path, segment];
+        return [
+          walk(key, depth + 1, [...path, "[key]"]),
+          typeof key === "string" && isSensitive(key) || isSensitivePath(childPath) ? MASK : walk(value2, depth + 1, childPath)
+        ];
+      });
+      if (entries.length > maxCollectionLength)
+        result.push(["[truncated]", entries.length - maxCollectionLength]);
+      ancestors.delete(input);
+      return { _type: "map", entries: result };
+    }
+    if (input instanceof Set) {
+      if (ancestors.has(input))
+        return "[circular]";
+      ancestors.add(input);
+      const entries = [...input];
+      const values = entries.slice(0, maxCollectionLength).map((item, index) => walk(item, depth + 1, [...path, String(index)]));
+      if (entries.length > maxCollectionLength)
+        values.push(`[truncated ${entries.length - maxCollectionLength} items]`);
+      ancestors.delete(input);
+      return { _type: "set", values };
+    }
+    if (input instanceof Date) {
+      return Number.isNaN(input.getTime()) ? "[invalid date]" : input.toISOString();
+    }
+    if (input instanceof URL)
+      return safeString(input.href);
+    if (input instanceof Error) {
+      const property = (name) => {
+        try {
+          return Reflect.get(input, name);
+        } catch {
+          return "[unreadable]";
+        }
+      };
+      const stack = property("stack");
+      const cause = property("cause");
+      return {
+        _type: "error",
+        name: safeString(String(property("name")), "name"),
+        message: safeString(String(property("message")), "message"),
+        ...stack !== undefined && { stack: safeString(String(stack), "stack") },
+        ...cause !== undefined && { cause: walk(cause, depth + 1, [...path, "cause"]) }
+      };
+    }
+    if (Array.isArray(input)) {
+      if (ancestors.has(input))
+        return "[circular]";
+      ancestors.add(input);
+      const result = [];
+      const count = Math.min(input.length, maxCollectionLength);
+      for (let index = 0;index < count; index += 1) {
+        try {
+          result.push(walk(Reflect.get(input, index), depth + 1, [...path, String(index)]));
+        } catch {
+          result.push("[unreadable]");
+        }
+      }
+      if (input.length > maxCollectionLength)
+        result.push(`[truncated ${input.length - maxCollectionLength} items]`);
+      ancestors.delete(input);
+      return result;
+    }
+    if (isRecord(input)) {
+      if (ancestors.has(input))
+        return "[circular]";
+      ancestors.add(input);
+      const out = {};
+      const keys = Object.keys(input);
+      for (const key of keys.slice(0, maxCollectionLength)) {
+        if (isUnsafeKey(key))
+          continue;
+        const childPath = [...path, key];
+        if (isSensitive(key) || isSensitivePath(childPath)) {
+          out[key] = MASK;
+          continue;
+        }
+        try {
+          out[key] = walk(Reflect.get(input, key), depth + 1, childPath);
+        } catch {
+          out[key] = "[unreadable]";
+        }
+      }
+      if (keys.length > maxCollectionLength)
+        out["[truncated]"] = keys.length - maxCollectionLength;
+      ancestors.delete(input);
+      return out;
+    }
+    return String(input);
+  };
+  return walk(value, 0);
+}
+function truncatePreview(value, maxBytes = DEFAULT_MAX_BYTES) {
+  const json = JSON.stringify(value);
+  const bytes = new TextEncoder().encode(json);
+  if (bytes.byteLength <= maxBytes)
+    return value;
+  let end = Math.max(0, maxBytes);
+  while (end > 0 && ((bytes[end] ?? 0) & 192) === 128)
+    end -= 1;
+  const preview = new TextDecoder().decode(bytes.subarray(0, end));
+  return {
+    _truncated: true,
+    _originalBytes: bytes.byteLength,
+    preview: `${preview}…`
+  };
+}
+function sanitizePayload(value, options = {}) {
+  if (value === undefined || value === null)
+    return null;
+  try {
+    return truncatePreview(redact(value, options), options.maxBytes ?? DEFAULT_MAX_BYTES);
+  } catch {
+    return "[unserializable]";
+  }
+}
+function measureSize(value) {
+  if (value === undefined || value === null) {
+    return { resultSize: null, responseBytes: 0 };
+  }
+  let responseBytes = 0;
+  try {
+    responseBytes = new TextEncoder().encode(JSON.stringify(value)).byteLength;
+  } catch {
+    return { resultSize: null, responseBytes: 0, unserializable: true };
+  }
+  if (Array.isArray(value)) {
+    return { resultSize: value.length, responseBytes };
+  }
+  if (isRecord(value) && Array.isArray(value.items) && "nextCursor" in value) {
+    return { resultSize: value.items.length, responseBytes };
+  }
+  return { resultSize: null, responseBytes };
+}
+
+export { redact, truncatePreview, sanitizePayload, measureSize };

package/dist/index-zfrhfn82.js

@@ -0,0 +1,85 @@
+import {
+  getClientInfo,
+  resolveSocketIp
+} from "./index-35mh5bhj.js";
+import {
+  resolveTraceContext
+} from "./index-zcgf3gqf.js";
+import {
+  isUnsafeKey
+} from "./index-kzfs85xp.js";
+
+// src/observability/context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var storage;
+var requestStorage = () => {
+  storage ??= new AsyncLocalStorage;
+  return storage;
+};
+function runWithRequestContext(ctx, fn) {
+  return requestStorage().run(ctx, fn);
+}
+function getRequestContext() {
+  return requestStorage().getStore();
+}
+function getTraceId() {
+  return requestStorage().getStore()?.trace.traceId;
+}
+function getUserId() {
+  return requestStorage().getStore()?.userId;
+}
+function setRequestUser(userId) {
+  const ctx = requestStorage().getStore();
+  if (ctx)
+    ctx.userId = userId;
+}
+function setRequestEndpoint(serviceName, action) {
+  const ctx = requestStorage().getStore();
+  if (ctx) {
+    ctx.serviceName = serviceName;
+    if (action !== undefined)
+      ctx.action = action;
+  }
+}
+function setRequestDimensions(dimensions, options = {}) {
+  const ctx = requestStorage().getStore();
+  if (!ctx)
+    return;
+  const next = { ...ctx.dimensions };
+  for (const [key, value] of Object.entries(dimensions)) {
+    if (isUnsafeKey(key))
+      throw new Error('Request dimension name cannot be "__proto__"');
+    const exists = Object.hasOwn(next, key);
+    if (exists && options.collision === "preserve")
+      continue;
+    if (exists && options.collision === "error") {
+      throw new Error(`Request dimension "${key}" is already set`);
+    }
+    next[key] = value;
+  }
+  ctx.dimensions = next;
+}
+function setRequestError(error) {
+  const ctx = requestStorage().getStore();
+  if (ctx)
+    ctx.error = error;
+}
+function wrapInRequestContext(handler, options = {}) {
+  return (req, server) => {
+    const ctx = {
+      trace: resolveTraceContext(req),
+      source: "http",
+      kind: "request",
+      method: req.method,
+      path: new URL(req.url, "http://localhost").pathname,
+      startedAt: process.hrtime.bigint(),
+      ...getClientInfo(req, {
+        trustProxy: options.trustProxy,
+        socketIp: resolveSocketIp(req, server)
+      })
+    };
+    return runWithRequestContext(ctx, () => handler(req, server));
+  };
+}
+
+export { runWithRequestContext, getRequestContext, getTraceId, getUserId, setRequestUser, setRequestEndpoint, setRequestDimensions, setRequestError, wrapInRequestContext };

package/dist/index-znfs20ss.js

@@ -0,0 +1,98 @@
+import {
+  formatZodError,
+  zodIssues
+} from "./index-p5r7qpdd.js";
+import {
+  AppError
+} from "./index-2vtcmrj9.js";
+import {
+  isRecord
+} from "./index-hffjpmq9.js";
+
+// src/contract/normalize.ts
+import { z } from "zod";
+var MAX_DETAIL_ISSUES = 20;
+function errorCode(err) {
+  if (AppError.is(err))
+    return err.code;
+  if (err instanceof z.ZodError)
+    return "VALIDATION_ERROR";
+  return;
+}
+function recordedErrorMessage(code, envelopeMessage, thrown) {
+  if ((code === "INTERNAL_SERVER_ERROR" || code === "REALTIME_CONTRACT_VIOLATION") && thrown !== undefined) {
+    if (thrown instanceof Error)
+      return thrown.message;
+    if (typeof thrown === "string")
+      return thrown;
+  }
+  return envelopeMessage;
+}
+function normalizeError(err) {
+  if (AppError.is(err)) {
+    if (err.code === "REALTIME_CONTRACT_VIOLATION") {
+      return new AppError("REALTIME_CONTRACT_VIOLATION", "Realtime contract violation", 500);
+    }
+    return err;
+  }
+  if (err instanceof z.ZodError) {
+    return new AppError("VALIDATION_ERROR", formatZodError(err), 400, {
+      issues: zodIssues(err).slice(0, MAX_DETAIL_ISSUES)
+    });
+  }
+  console.error("[stitchkit] unhandled error:", err);
+  return new AppError("INTERNAL_SERVER_ERROR", "Internal server error", 500);
+}
+function strippedPaths(before, after, prefix) {
+  if (Array.isArray(before)) {
+    if (!Array.isArray(after))
+      return [];
+    return before.flatMap((item, i) => strippedPaths(item, after[i], `${prefix}[${i}]`));
+  }
+  if (!isRecord(before) || !isRecord(after))
+    return [];
+  const paths = [];
+  for (const [key, value] of Object.entries(before)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (!(key in after)) {
+      paths.push(path);
+      continue;
+    }
+    paths.push(...strippedPaths(value, after[key], path));
+  }
+  return paths;
+}
+function validateHandlerOutput(schema, data, onStripped) {
+  const parsed = schema.safeParse(data);
+  if (parsed.success) {
+    if (onStripped) {
+      const paths = strippedPaths(data, parsed.data, "");
+      if (paths.length > 0)
+        onStripped(paths);
+    }
+    return { ok: true, data: parsed.data };
+  }
+  return {
+    ok: false,
+    message: `Handler output does not match the contract: ${formatZodError(parsed.error)}`
+  };
+}
+function validateDeclaredOutput(schema, data, onStripped) {
+  if (!schema) {
+    if (data === undefined || data === null)
+      return { ok: true, data };
+    return {
+      ok: false,
+      message: "Handler returned data but the contract declares no output"
+    };
+  }
+  if (data === undefined) {
+    return {
+      ok: false,
+      message: "Handler returned undefined but the contract declares an output"
+    };
+  }
+  return validateHandlerOutput(schema, data, onStripped);
+}
+
+export { errorCode, recordedErrorMessage, normalizeError, validateDeclaredOutput };

package/dist/internal/atomic-file.d.ts

@@ -15,7 +15,28 @@
  * the target 0o755 and then renames the link itself into place, so every later
  * write goes there too. `wx` refuses to open anything that already exists,
  * link or file, which closes it.
+ *
+ * Two forms with one order of guarantees. The asynchronous one exists because a
+ * synchronous `rename` on a loaded machine was measured holding a consumer's
+ * main thread for ~15 s — every timer and request of a daemon stood still.
+ */
+/** Options of {@link writeFileAtomic} and {@link writeFileAtomicSync}. */
+export interface WriteFileAtomicOptions {
+    /**
+     * Permission bits of the written file, applied on the open descriptor before
+     * the file becomes visible — not masked by the process umask. Defaults to
+     * `0o600`: a file readable by other users of the machine is a decision the
+     * caller states, never one a default makes for them.
+     */
+    mode?: number;
+}
+/**
+ * Write `data` to `target` atomically: a reader sees the old contents or the
+ * new ones, never part of either, and the new file has `mode` from its first
+ * visible moment. A failed write leaves the target untouched and no staging
+ * file behind.
  */
-/** Write `bytes` to `target` atomically, with an explicit mode. */
-export declare function writeFileAtomic(target: string, bytes: Uint8Array, mode: number): void;
+export declare function writeFileAtomic(target: string, data: Uint8Array | string, options?: WriteFileAtomicOptions): Promise<void>;
+/** The synchronous form of {@link writeFileAtomic}, with the same guarantees in the same order. */
+export declare function writeFileAtomicSync(target: string, data: Uint8Array | string, options?: WriteFileAtomicOptions): void;
 //# sourceMappingURL=atomic-file.d.ts.map

package/dist/internal/atomic-file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atomic-file.d.ts","sourceRoot":"","sources":["../../src/internal/atomic-file.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAMH,mEAAmE;AACnE,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAmBrF"}
+{"version":3,"file":"atomic-file.d.ts","sourceRoot":"","sources":["../../src/internal/atomic-file.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAeH,0EAA0E;AAC1E,MAAM,WAAW,sBAAsB;IACrC;;;;;OAKG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAYD;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,UAAU,GAAG,MAAM,EACzB,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,IAAI,CAAC,CAmBf;AAED,mGAAmG;AACnG,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,UAAU,GAAG,MAAM,EACzB,OAAO,GAAE,sBAA2B,GACnC,IAAI,CA6BN"}

package/dist/internal/backoff.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const BackoffPolicySchema: z.ZodReadonly<z.ZodObject<{
+    minDelayMs: z.ZodNumber;
+    maxDelayMs: z.ZodNumber;
+    jitter: z.ZodNumber;
+}, z.core.$strict>>;
+export type BackoffPolicy = z.infer<typeof BackoffPolicySchema>;
+/**
+ * The delay before retry number `attempt` (1-based) under `policy`: doubling
+ * from `minDelayMs`, capped at `maxDelayMs`, with `jitter` subtracted. The one
+ * formula behind `createBackoff` and every attempt-numbered retry schedule.
+ */
+export declare function backoffDelay(policy: BackoffPolicy, attempt: number, random?: () => number): number;
+export interface Backoff {
+    /** The next delay in milliseconds, doubling from `minDelayMs` and jittered. */
+    next(): number;
+    reset(): void;
+}
+/**
+ * Exponential backoff with jitter, as a value.
+ *
+ * Jitter is the part that is easy to leave out and expensive to leave out: without it every
+ * consumer that lost the same server retries at the same instant, and the recovering server is
+ * hit by the whole fleet at once instead of a spread. The randomisation is subtractive — a delay
+ * is never longer than the ceiling the caller declared, only shorter — so `maxDelayMs` remains a
+ * real bound rather than an average.
+ */
+export declare function createBackoff(policy: BackoffPolicy, random?: () => number): Backoff;
+//# sourceMappingURL=backoff.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"backoff.d.ts","sourceRoot":"","sources":["../../src/internal/backoff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,mBAAmB;;;;mBAW5B,CAAC;AACL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,MAAM,EACf,MAAM,GAAE,MAAM,MAAoB,GACjC,MAAM,CAOR;AAED,MAAM,WAAW,OAAO;IACtB,+EAA+E;IAC/E,IAAI,IAAI,MAAM,CAAC;IACf,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,aAAa,EACrB,MAAM,GAAE,MAAM,MAAoB,GACjC,OAAO,CAYT"}

package/dist/internal/canonical-json.d.ts

@@ -1,20 +1,30 @@
 /**
- * Codepoint order, not locale order.
+ * UTF-16 code-unit order — the order `Array.prototype.sort` uses without a
+ * comparator, and deliberately not code-point or locale order.
  *
- * `Array.prototype.sort` without a comparator is codepoint order already, but
- * `localeCompare` is what a reader reaches for — and it would make a digest
- * depend on the machine's locale, which is the one input a fingerprint must
- * never have.
+ * Locale order would make a digest depend on the machine it ran on. Code-point
+ * order would be defensible, but every digest this package has ever written —
+ * CLI manifest signatures, agent-store event and checkpoint hashes, archives,
+ * committed surface snapshots — was taken in code-unit order, and the two
+ * disagree on keys outside the Basic Multilingual Plane. Changing it would
+ * report drift in data that never changed.
  */
-export declare function compareCodepoints(left: string, right: string): number;
+export declare function compareCodeUnits(left: string, right: string): number;
 /**
  * Canonical bytes for a JSON value — object keys sorted, array order kept.
  *
- * The single serialisation behind every digest this repository takes of a
- * declared surface: the committed manifest snapshot and the live MCP catalog
- * stamp. Two implementations of "the same bytes" would eventually disagree,
- * and a fingerprint that disagrees with itself reports drift that never
- * happened.
+ * The one serialisation behind every digest and identity in the package: the
+ * surface snapshot and the MCP catalog stamp, CLI manifest signatures, the
+ * agent store's hashes and archives, watched-read and MCP-round argument keys,
+ * and schema comparison in union flattening. Two implementations of "the same
+ * bytes" would eventually disagree, and a fingerprint that disagrees with
+ * itself reports drift that never happened.
+ *
+ * What `JSON.stringify` drops or transforms is dropped or transformed here too:
+ * an `undefined` member disappears, a `Date` becomes `{}` (its own keys, none). A caller that must
+ * refuse such values validates before calling (the agent store parses with
+ * `z.json()` first). A top-level `undefined` answers `'undefined'`, so the
+ * result is always a string.
  */
 export declare function serializeCanonicalJson(value: unknown): string;
 //# sourceMappingURL=canonical-json.d.ts.map

package/dist/internal/canonical-json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canonical-json.d.ts","sourceRoot":"","sources":["../../src/internal/canonical-json.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAIrE;AAYD;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE7D"}
+{"version":3,"file":"canonical-json.d.ts","sourceRoot":"","sources":["../../src/internal/canonical-json.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAIpE;AAyBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE7D"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../src/internal/channel.ts"],"names":[],"mappings":"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"}