stitchkit 0.100.2 → 0.101.0

package/dist/{index-yw4fzmdz.js → index-e6c2spsd.js}

@@ -1,9 +1,12 @@
+import {
+  maskSecretShapes
+} from "./index-sznqf8fx.js";
 import {
   isUnsafeKey
-} from "./index-kzfs85xp.js";
+} from "./index-zsarb5xp.js";
 import {
   isRecord
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/observability/sanitize.ts
 var SENSITIVE_WORDS = new Set([
@@ -53,17 +56,40 @@ 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);
+function secretMasker(options, isSecretName) {
+  const values = [...options.sensitiveValues ?? []].filter((value) => value !== "").sort((left, right) => right.length - left.length);
+  const patterns = options.sensitiveUrlPatterns ?? [];
+  return (input) => {
+    let output = input;
+    for (const value of values)
+      output = output.replaceAll(value, MASK);
+    for (const pattern of patterns) {
+      try {
+        const global = new RegExp(pattern.source, `${pattern.flags.replace(/[gy]/g, "")}g`);
+        output = output.replace(global, MASK);
+      } catch {}
+    }
+    return maskSecretShapes(output, MASK, isSecretName);
   };
-  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) => {
+}
+var ERROR_CORE = new Set(["_type", "name", "message", "stack", "cause"]);
+function isErrorFact(value) {
+  if (value === null || typeof value !== "object")
+    return typeof value !== "function";
+  if (Array.isArray(value) || value instanceof Error || value instanceof Date)
+    return true;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function kindOf(value) {
+  if (typeof value === "function")
+    return "function";
+  const maker = isRecord(value) ? value.constructor : undefined;
+  return typeof maker === "function" && maker.name !== "" ? maker.name : "object";
+}
+function pathMatcher(patterns) {
+  const matchers = patterns.map((pattern) => pattern.split("."));
+  const matches = (matcher, path, patternIndex = 0, pathIndex = 0) => {
     if (patternIndex === matcher.length)
       return pathIndex === path.length;
     const segment = matcher[patternIndex];
@@ -71,29 +97,35 @@ function redact(value, options = {}) {
       if (patternIndex + 1 === matcher.length)
         return true;
       for (let next = pathIndex;next <= path.length; next += 1) {
-        if (matchesPath(matcher, path, patternIndex + 1, next))
+        if (matches(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);
+    return matches(matcher, path, patternIndex + 1, pathIndex + 1);
   };
-  const isSensitivePath = (path) => pathMatchers.some((matcher) => matchesPath(matcher, path));
+  return (path) => matchers.some((matcher) => matches(matcher, path));
+}
+function redact2(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 isSensitivePath = pathMatcher(options.sensitivePaths ?? []);
   const stringBoundFor = (key) => {
     const byKey = key === undefined ? undefined : options.maxStringLengthByKey?.[key];
     return byKey ?? maxStringLength;
   };
+  const mask = secretMasker(options, isSensitive);
   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 {}
-    }
+    const output = mask(input);
     if (output.length <= bound)
       return output;
     return `${output.slice(0, Math.max(0, bound))}…[truncated]`;
@@ -128,12 +160,12 @@ function redact(value, options = {}) {
         return "[circular]";
       ancestors.add(input);
       const entries = [...input.entries()];
-      const result = entries.slice(0, maxCollectionLength).map(([key, value2]) => {
+      const result = entries.slice(0, maxCollectionLength).map(([key, value]) => {
         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)
+          typeof key === "string" && isSensitive(key) || isSensitivePath(childPath) ? MASK : walk(value, depth + 1, childPath)
         ];
       });
       if (entries.length > maxCollectionLength)
@@ -165,14 +197,31 @@ function redact(value, options = {}) {
           return "[unreadable]";
         }
       };
+      if (ancestors.has(input))
+        return "[circular]";
+      ancestors.add(input);
       const stack = property("stack");
       const cause = property("cause");
+      const own = {};
+      for (const key of Object.keys(input)) {
+        if (isUnsafeKey(key) || ERROR_CORE.has(key))
+          continue;
+        const childPath = [...path, key];
+        try {
+          const field = Reflect.get(input, key);
+          own[key] = isSensitive(key) || isSensitivePath(childPath) ? MASK : isErrorFact(field) ? walk(field, depth + 1, childPath) : `[${kindOf(field)}]`;
+        } catch {
+          own[key] = "[unreadable]";
+        }
+      }
+      ancestors.delete(input);
       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"]) }
+        ...cause !== undefined && { cause: walk(cause, depth + 1, [...path, "cause"]) },
+        ...own
       };
     }
     if (Array.isArray(input)) {
@@ -222,7 +271,7 @@ function redact(value, options = {}) {
   };
   return walk(value, 0);
 }
-function truncatePreview(value, maxBytes = DEFAULT_MAX_BYTES) {
+function truncatePreview2(value, maxBytes = DEFAULT_MAX_BYTES) {
   const json = JSON.stringify(value);
   const bytes = new TextEncoder().encode(json);
   if (bytes.byteLength <= maxBytes)
@@ -237,16 +286,16 @@ function truncatePreview(value, maxBytes = DEFAULT_MAX_BYTES) {
     preview: `${preview}…`
   };
 }
-function sanitizePayload(value, options = {}) {
+function sanitizePayload2(value, options = {}) {
   if (value === undefined || value === null)
     return null;
   try {
-    return truncatePreview(redact(value, options), options.maxBytes ?? DEFAULT_MAX_BYTES);
+    return truncatePreview2(redact2(value, options), options.maxBytes ?? DEFAULT_MAX_BYTES);
   } catch {
     return "[unserializable]";
   }
 }
-function measureSize(value) {
+function measureSize2(value) {
   if (value === undefined || value === null) {
     return { resultSize: null, responseBytes: 0 };
   }
@@ -265,4 +314,4 @@ function measureSize(value) {
   return { resultSize: null, responseBytes };
 }
 
-export { redact, truncatePreview, sanitizePayload, measureSize };
+export { redact2, truncatePreview2, sanitizePayload2, measureSize2 };

package/dist/{index-fhwqwxe0.js → index-ej331hah.js}

@@ -1,6 +1,6 @@
 import {
   loadDarwinBinding
-} from "./index-zjjyynm3.js";
+} from "./index-d4pa2bgs.js";
 
 // src/agent-runtime/contained-scan.ts
 import path2 from "node:path";

package/dist/{index-9t3dffv2.js → index-ewbaywk5.js}

@@ -1,12 +1,12 @@
+import {
+  projectToolSurface
+} from "./index-7z9ym7t8.js";
 import {
   contractToolMountable
-} from "./index-bm5rx7n6.js";
+} from "./index-n9tyz8z3.js";
 import {
   runtimeToolMountable
-} from "./index-d8m8zpd8.js";
-import {
-  projectToolSurface
-} from "./index-0r0fbk7z.js";
+} from "./index-jzczzcsb.js";
 
 // src/tools/surface.ts
 function collectToolSurface({

package/dist/{index-7p1f0vp2.js → index-fyphpknh.js}

@@ -1,20 +1,20 @@
 import {
-  base64UrlToBytes,
-  bytesToBase64Url
-} from "./index-rxfy4cq7.js";
+  defineContract2
+} from "./index-ck71tbcf.js";
 import {
-  defineContract
-} from "./index-k30h66yd.js";
+  AppError2,
+  STITCH_ERROR_STATUS2,
+  isStitchErrorCode2
+} from "./index-n53mswt3.js";
 import {
-  AppError,
-  STITCH_ERROR_STATUS,
-  isStitchErrorCode
-} from "./index-2vtcmrj9.js";
+  bytesToBase64Url,
+  base64UrlToBytes
+} from "./index-dwfv9a85.js";
 import {
-  mapObjectTypeBoundary,
+  typedEntries,
   transportResult,
-  typedEntries
-} from "./index-hffjpmq9.js";
+  mapObjectTypeBoundary
+} from "./index-9jfdm5tg.js";
 // src/contract/errors-factory.ts
 import { z } from "zod";
 function isErrorDetailsSchema(value) {
@@ -31,7 +31,7 @@ function validateDefinition(code, definition) {
     throw new Error(`[stitchkit] Error "${code}" message must be a non-empty string`);
   }
 }
-function defineErrors(source, mapping) {
+function defineErrors2(source, mapping) {
   const definitions = mapObjectTypeBoundary(source, (code, definition) => {
     const name = String(code);
     validateDefinition(name, definition);
@@ -46,10 +46,10 @@ function defineErrors(source, mapping) {
         if ("details" in options) {
           throw new Error(`[stitchkit] Error "${name}" does not declare details`);
         }
-        return new AppError(name, message, definition.status, undefined, options.hint, undefined, definition.retryable);
+        return new AppError2(name, message, definition.status, undefined, options.hint, undefined, definition.retryable);
       }
       const details = definition.details.parse(options.details);
-      return new AppError(name, message, definition.status, details, options.hint, undefined, definition.retryable);
+      return new AppError2(name, message, definition.status, details, options.hint, undefined, definition.retryable);
     };
   });
   Object.freeze(errors);
@@ -57,13 +57,13 @@ function defineErrors(source, mapping) {
   Object.freeze(codes);
   const known = new Set(Object.keys(definitions));
   for (const [code, target] of Object.entries(mapping?.map ?? {})) {
-    if (!isStitchErrorCode(code)) {
+    if (!isStitchErrorCode2(code)) {
       throw new Error(`[stitchkit] Error vocabulary contains unknown framework code "${code}"`);
     }
     if (typeof target !== "string" || !known.has(target)) {
       throw new Error(`[stitchkit] Error vocabulary maps "${code}" to undeclared code "${String(target)}"`);
     }
-    const status = STITCH_ERROR_STATUS[code];
+    const status = STITCH_ERROR_STATUS2[code];
     if (definitions[target]?.status !== status) {
       throw new Error(`[stitchkit] Error vocabulary maps "${code}" (${status}) to "${target}", declared with status ${String(definitions[target]?.status)}`);
     }
@@ -81,14 +81,14 @@ function defineErrors(source, mapping) {
     }
   }
   if (mapping?.exhaustive === true) {
-    for (const code of Object.keys(STITCH_ERROR_STATUS)) {
+    for (const code of Object.keys(STITCH_ERROR_STATUS2)) {
       if (!Object.hasOwn(mapping.map, code)) {
         throw new Error(`[stitchkit] Exhaustive error vocabulary is missing "${code}"`);
       }
     }
   }
   const codeMap = {};
-  for (const [stitchCode, status] of typedEntries(STITCH_ERROR_STATUS)) {
+  for (const [stitchCode, status] of typedEntries(STITCH_ERROR_STATUS2)) {
     const code = mapping?.map?.[stitchCode] ?? mapping?.fallback?.[status];
     if (code === undefined)
       continue;
@@ -108,9 +108,9 @@ function defineErrors(source, mapping) {
   });
 }
 // src/contract/factory.ts
-function createContractFactory(config) {
+function createContractFactory2(config) {
   const scoped = (meta, endpoints) => {
-    const validated = defineContract({ prefix: meta.prefix }, endpoints);
+    const validated = defineContract2({ prefix: meta.prefix }, endpoints);
     return {
       endpoints: validated.endpoints,
       meta: { ...meta, prefix: meta.prefix, scope: meta.scope }
@@ -126,7 +126,7 @@ function createContractFactory(config) {
 }
 // src/contract/pagination.ts
 import { z as z2 } from "zod";
-function paginatedSchema(itemSchema) {
+function paginatedSchema2(itemSchema) {
   return z2.object({
     items: z2.array(itemSchema),
     nextCursor: z2.string().nullable()
@@ -138,10 +138,10 @@ function toBase64Url(str) {
 function fromBase64Url(value) {
   return new TextDecoder().decode(base64UrlToBytes(value));
 }
-function encodeCursor(value) {
+function encodeCursor2(value) {
   return toBase64Url(JSON.stringify(value));
 }
-function decodeCursor(cursor, schema) {
+function decodeCursor2(cursor, schema) {
   if (!cursor)
     return null;
   try {
@@ -151,4 +151,4 @@ function decodeCursor(cursor, schema) {
     return null;
   }
 }
-export { defineErrors, createContractFactory, paginatedSchema, encodeCursor, decodeCursor };
+export { defineErrors2, createContractFactory2, paginatedSchema2, encodeCursor2, decodeCursor2 };

package/dist/{index-83bdg97s.js → index-g149e9pk.js}

@@ -1,6 +1,6 @@
 import {
   isRecord
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/internal/error-message.ts
 function messageOf(value) {

package/dist/{index-ngfhvfpd.js → index-g6a3na27.js}

@@ -1,7 +1,7 @@
 // src/internal/backoff.ts
 import { z } from "zod";
 var PositiveSafeIntegerSchema = z.number().int().positive().safe();
-var BackoffPolicySchema = z.object({
+var BackoffPolicySchema2 = z.object({
   minDelayMs: PositiveSafeIntegerSchema,
   maxDelayMs: PositiveSafeIntegerSchema,
   jitter: z.number().min(0).max(1)
@@ -13,8 +13,8 @@ function backoffDelay(policy, attempt, random = Math.random) {
   const spread = exponential * policy.jitter * random();
   return Math.max(1, Math.round(exponential - spread));
 }
-function createBackoff(policy, random = Math.random) {
-  const parsed = BackoffPolicySchema.parse(policy);
+function createBackoff2(policy, random = Math.random) {
+  const parsed = BackoffPolicySchema2.parse(policy);
   let attempt = 0;
   return {
     next() {
@@ -27,4 +27,4 @@ function createBackoff(policy, random = Math.random) {
   };
 }
 
-export { BackoffPolicySchema, backoffDelay, createBackoff };
+export { BackoffPolicySchema2, backoffDelay, createBackoff2 };

package/dist/{index-qwhynv6x.js → index-h124epcf.js}

@@ -1,21 +1,21 @@
 import {
   isRecord
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/application/diagnostic-journal-contract.ts
 import { z } from "zod";
 var PositiveSafeIntegerSchema = z.number().int().positive().safe();
 var FileModeSchema = z.number().int().min(0).max(511);
-var DiagnosticJournalLimitsSchema = z.object({
+var DiagnosticJournalLimitsSchema2 = z.object({
   maxEventBytes: PositiveSafeIntegerSchema,
   maxPendingItems: PositiveSafeIntegerSchema,
   maxPendingBytes: PositiveSafeIntegerSchema,
   maxFileBytes: PositiveSafeIntegerSchema,
   maxFiles: PositiveSafeIntegerSchema
 }).strict().readonly();
-var DiagnosticJournalLockPolicySchema = z.enum(["refuse", "reclaim-stale"]);
-var DiagnosticJournalStateSchema = z.enum(["open", "draining", "closed", "failed"]);
-var DiagnosticJournalRefusalReasonSchema = z.enum([
+var DiagnosticJournalLockPolicySchema2 = z.enum(["refuse", "reclaim-stale"]);
+var DiagnosticJournalStateSchema2 = z.enum(["open", "draining", "closed", "failed"]);
+var DiagnosticJournalRefusalReasonSchema2 = z.enum([
   "closed",
   "failed",
   "invalid",
@@ -31,13 +31,13 @@ var DiagnosticJournalRefusalCountersSchema = z.object({
   "item-capacity": z.number().int().nonnegative(),
   "byte-capacity": z.number().int().nonnegative()
 }).strict().readonly();
-var DiagnosticJournalFailurePhaseSchema = z.enum(["write", "rotation", "close"]);
-var DiagnosticJournalStatusSchema = z.object({
-  state: DiagnosticJournalStateSchema,
+var DiagnosticJournalFailurePhaseSchema2 = z.enum(["write", "rotation", "close"]);
+var DiagnosticJournalStatusSchema2 = z.object({
+  state: DiagnosticJournalStateSchema2,
   epoch: z.uuid(),
-  limits: DiagnosticJournalLimitsSchema,
+  limits: DiagnosticJournalLimitsSchema2,
   lock: z.object({
-    policy: DiagnosticJournalLockPolicySchema,
+    policy: DiagnosticJournalLockPolicySchema2,
     reclaimedStale: z.boolean()
   }).strict().readonly(),
   received: z.number().int().nonnegative(),
@@ -58,11 +58,11 @@ var DiagnosticJournalStatusSchema = z.object({
   lastWrittenSequence: z.number().int().positive().optional(),
   lastSettledSequence: z.number().int().positive().optional(),
   lastFailure: z.object({
-    phase: DiagnosticJournalFailurePhaseSchema,
+    phase: DiagnosticJournalFailurePhaseSchema2,
     sequence: z.number().int().positive().optional()
   }).strict().readonly().optional()
 }).strict().readonly();
-var DiagnosticJournalSubmitResultSchema = z.discriminatedUnion("outcome", [
+var DiagnosticJournalSubmitResultSchema2 = z.discriminatedUnion("outcome", [
   z.object({
     outcome: z.literal("accepted"),
     epoch: z.uuid(),
@@ -70,21 +70,21 @@ var DiagnosticJournalSubmitResultSchema = z.discriminatedUnion("outcome", [
   }).strict().readonly(),
   z.object({
     outcome: z.literal("refused"),
-    reason: DiagnosticJournalRefusalReasonSchema
+    reason: DiagnosticJournalRefusalReasonSchema2
   }).strict().readonly()
 ]);
-var DiagnosticJournalWaitResultSchema = z.object({
+var DiagnosticJournalWaitResultSchema2 = z.object({
   outcome: z.enum(["settled", "timed-out", "cancelled"]),
-  state: DiagnosticJournalStateSchema,
+  state: DiagnosticJournalStateSchema2,
   throughSequence: z.number().int().nonnegative(),
   settledSequence: z.number().int().nonnegative()
 }).strict().readonly();
-var DiagnosticJournalCloseResultSchema = z.object({
+var DiagnosticJournalCloseResultSchema2 = z.object({
   outcome: z.enum(["closed", "timed-out", "cancelled"]),
-  state: DiagnosticJournalStateSchema,
+  state: DiagnosticJournalStateSchema2,
   pendingItems: z.number().int().nonnegative()
 }).strict().readonly();
-var DiagnosticJournalFrameSchema = z.object({
+var DiagnosticJournalFrameSchema2 = z.object({
   schemaVersion: z.literal(1),
   epoch: z.uuid(),
   sequence: z.number().int().positive(),
@@ -93,11 +93,11 @@ var DiagnosticJournalFrameSchema = z.object({
 function parseDiagnosticJournalMode(mode) {
   return FileModeSchema.parse(mode ?? 384);
 }
-function readDiagnosticJournalLockDiagnosis(error) {
+function readDiagnosticJournalLockDiagnosis2(error) {
   if (!isRecord(error))
     return;
   const diagnosis = error.journalLock;
   return isRecord(diagnosis) ? diagnosis : undefined;
 }
 
-export { DiagnosticJournalLimitsSchema, DiagnosticJournalLockPolicySchema, DiagnosticJournalStateSchema, DiagnosticJournalRefusalReasonSchema, DiagnosticJournalFailurePhaseSchema, DiagnosticJournalStatusSchema, DiagnosticJournalSubmitResultSchema, DiagnosticJournalWaitResultSchema, DiagnosticJournalCloseResultSchema, DiagnosticJournalFrameSchema, parseDiagnosticJournalMode, readDiagnosticJournalLockDiagnosis };
+export { DiagnosticJournalLimitsSchema2, DiagnosticJournalLockPolicySchema2, DiagnosticJournalStateSchema2, DiagnosticJournalRefusalReasonSchema2, DiagnosticJournalFailurePhaseSchema2, DiagnosticJournalStatusSchema2, DiagnosticJournalSubmitResultSchema2, DiagnosticJournalWaitResultSchema2, DiagnosticJournalCloseResultSchema2, DiagnosticJournalFrameSchema2, parseDiagnosticJournalMode, readDiagnosticJournalLockDiagnosis2 };

package/dist/{index-h6eeys1v.js → index-h97tqqp1.js}

@@ -1,7 +1,7 @@
 // src/observability/status.ts
 import { z } from "zod";
 var NonNegativeIntegerSchema = z.number().int().nonnegative();
-var ObservabilitySinkStatusSchema = z.object({
+var ObservabilitySinkStatusSchema2 = z.object({
   capacity: NonNegativeIntegerSchema,
   received: NonNegativeIntegerSchema,
   accepted: NonNegativeIntegerSchema,
@@ -15,12 +15,12 @@ var ObservabilitySinkStatusSchema = z.object({
   closed: z.boolean()
 }).readonly();
 var ObservabilityStatusObjectSchema = z.object({
-  request: ObservabilitySinkStatusSchema.optional(),
-  tools: ObservabilitySinkStatusSchema.optional(),
-  total: ObservabilitySinkStatusSchema
+  request: ObservabilitySinkStatusSchema2.optional(),
+  tools: ObservabilitySinkStatusSchema2.optional(),
+  total: ObservabilitySinkStatusSchema2
 });
-var ObservabilityStatusSchema = ObservabilityStatusObjectSchema.readonly();
-var ObservabilityDrainReportSchema = ObservabilityStatusObjectSchema.extend({
+var ObservabilityStatusSchema2 = ObservabilityStatusObjectSchema.readonly();
+var ObservabilityDrainReportSchema2 = ObservabilityStatusObjectSchema.extend({
   durationMs: z.number().nonnegative(),
   drained: z.boolean()
 }).readonly();
@@ -53,7 +53,7 @@ function aggregateObservabilityStatus(surfaces, closed) {
     for (const key of SUMMED_STATUS_KEYS)
       totals[key] += surface[key];
   }
-  return ObservabilitySinkStatusSchema.parse({ ...totals, closed });
+  return ObservabilitySinkStatusSchema2.parse({ ...totals, closed });
 }
 
 // src/observability/bounded-sink.ts
@@ -192,7 +192,7 @@ function createBoundedSinkManager(config) {
     }
   };
   function getStatus() {
-    return ObservabilitySinkStatusSchema.parse({
+    return ObservabilitySinkStatusSchema2.parse({
       capacity: maxPending,
       received,
       accepted,
@@ -208,4 +208,4 @@ function createBoundedSinkManager(config) {
   }
 }
 
-export { ObservabilitySinkStatusSchema, ObservabilityStatusSchema, ObservabilityDrainReportSchema, aggregateObservabilityStatus, assertDrainBound, withinBound, createBoundedSinkManager };
+export { ObservabilitySinkStatusSchema2, ObservabilityStatusSchema2, ObservabilityDrainReportSchema2, aggregateObservabilityStatus, assertDrainBound, withinBound, createBoundedSinkManager };

package/dist/{index-zcgf3gqf.js → index-hby4qhax.js}

@@ -10,10 +10,10 @@ function randomHex(bytes) {
 
 // src/observability/trace.ts
 var TRACEPARENT_RE = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})(.*)$/i;
-function createTraceContext() {
+function createTraceContext2() {
   return { traceId: randomHex(16), spanId: randomHex(8) };
 }
-function parseTraceparent(header) {
+function parseTraceparent2(header) {
   if (!header)
     return null;
   const match = TRACEPARENT_RE.exec(header.trim());
@@ -33,13 +33,13 @@ function parseTraceparent(header) {
     return null;
   return { traceId, spanId: randomHex(8), parentSpanId, traceFlags };
 }
-function formatTraceparent(ctx) {
+function formatTraceparent2(ctx) {
   return `00-${ctx.traceId}-${ctx.spanId}-${ctx.traceFlags ?? "01"}`;
 }
-function resolveTraceContext(req) {
-  return parseTraceparent(req.headers.get("traceparent")) ?? createTraceContext();
+function resolveTraceContext2(req) {
+  return parseTraceparent2(req.headers.get("traceparent")) ?? createTraceContext2();
 }
-function childSpan(parent) {
+function childSpan2(parent) {
   return {
     traceId: parent.traceId,
     spanId: randomHex(8),
@@ -67,10 +67,10 @@ function boundedPropagationValue(value, maxBytes, maxMembers) {
   }
   return trimmed;
 }
-function resolvePropagationContext(metadata, fallback) {
+function resolvePropagationContext2(metadata, fallback) {
   const traceparent = metadata?.traceparent;
-  const parsed = typeof traceparent === "string" ? parseTraceparent(traceparent) : null;
-  const trace = traceparent === undefined ? fallback ?? createTraceContext() : parsed ?? createTraceContext();
+  const parsed = typeof traceparent === "string" ? parseTraceparent2(traceparent) : null;
+  const trace = traceparent === undefined ? fallback ?? createTraceContext2() : parsed ?? createTraceContext2();
   const tracestate = parsed ? boundedPropagationValue(metadata?.tracestate, 512, 32) : undefined;
   const baggage = boundedPropagationValue(metadata?.baggage, 8192, 180);
   return {
@@ -80,4 +80,4 @@ function resolvePropagationContext(metadata, fallback) {
   };
 }
 
-export { randomHex, createTraceContext, parseTraceparent, formatTraceparent, resolveTraceContext, childSpan, resolvePropagationContext };
+export { randomHex, createTraceContext2, parseTraceparent2, formatTraceparent2, resolveTraceContext2, childSpan2, resolvePropagationContext2 };

package/dist/{index-5jrd0yng.js → index-j8aw2c0e.js}

@@ -2,12 +2,12 @@
 import { z } from "zod";
 var timestamp = z.string().datetime({ offset: true });
 var key = z.string().min(1).max(255);
-var DirectoryInboxRejectionReasonSchema = z.enum([
+var DirectoryInboxRejectionReasonSchema2 = z.enum([
   "invalid",
   "too-large",
   "attempt-limit"
 ]);
-var DirectoryInboxStateSchema = z.object({
+var DirectoryInboxStateSchema2 = z.object({
   schemaVersion: z.literal(1),
   claims: z.array(z.object({
     key,
@@ -19,7 +19,7 @@ var DirectoryInboxStateSchema = z.object({
   receipts: z.array(z.object({ key, completedAt: timestamp }).strict()),
   rejected: z.array(z.object({
     key,
-    reason: DirectoryInboxRejectionReasonSchema,
+    reason: DirectoryInboxRejectionReasonSchema2,
     detail: z.string().max(1000),
     rejectedAt: timestamp
   }).strict())
@@ -111,4 +111,4 @@ function forgetMissing(state, present, now) {
   };
 }
 
-export { DirectoryInboxRejectionReasonSchema, DirectoryInboxStateSchema, emptyDirectoryInboxState, withRejection, claimEntry, completeEntry, releaseEntry, forgetMissing };
+export { DirectoryInboxRejectionReasonSchema2, DirectoryInboxStateSchema2, emptyDirectoryInboxState, withRejection, claimEntry, completeEntry, releaseEntry, forgetMissing };