stitchkit 0.78.0 → 0.80.0

package/dist/index-wc4x00bn.js

@@ -0,0 +1,103 @@
+import {
+  isRecord
+} from "./index-77fekveh.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({
+  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([
+  "closed",
+  "failed",
+  "invalid",
+  "oversized",
+  "item-capacity",
+  "byte-capacity"
+]);
+var DiagnosticJournalRefusalCountersSchema = z.object({
+  closed: z.number().int().nonnegative(),
+  failed: z.number().int().nonnegative(),
+  invalid: z.number().int().nonnegative(),
+  oversized: z.number().int().nonnegative(),
+  "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,
+  epoch: z.uuid(),
+  limits: DiagnosticJournalLimitsSchema,
+  lock: z.object({
+    policy: DiagnosticJournalLockPolicySchema,
+    reclaimedStale: z.boolean()
+  }).strict().readonly(),
+  received: z.number().int().nonnegative(),
+  accepted: z.number().int().nonnegative(),
+  refused: z.number().int().nonnegative(),
+  refusals: DiagnosticJournalRefusalCountersSchema,
+  written: z.number().int().nonnegative(),
+  failedRecords: z.number().int().nonnegative(),
+  pendingItems: z.number().int().nonnegative(),
+  pendingBytes: z.number().int().nonnegative(),
+  inFlight: z.boolean(),
+  rotations: z.number().int().nonnegative(),
+  rotationFailures: z.number().int().nonnegative(),
+  partialTails: z.number().int().nonnegative(),
+  currentFileBytes: z.number().int().nonnegative(),
+  retainedFiles: z.number().int().nonnegative(),
+  lastAcceptedSequence: z.number().int().positive().optional(),
+  lastWrittenSequence: z.number().int().positive().optional(),
+  lastSettledSequence: z.number().int().positive().optional(),
+  lastFailure: z.object({
+    phase: DiagnosticJournalFailurePhaseSchema,
+    sequence: z.number().int().positive().optional()
+  }).strict().readonly().optional()
+}).strict().readonly();
+var DiagnosticJournalSubmitResultSchema = z.discriminatedUnion("outcome", [
+  z.object({
+    outcome: z.literal("accepted"),
+    epoch: z.uuid(),
+    sequence: z.number().int().positive()
+  }).strict().readonly(),
+  z.object({
+    outcome: z.literal("refused"),
+    reason: DiagnosticJournalRefusalReasonSchema
+  }).strict().readonly()
+]);
+var DiagnosticJournalWaitResultSchema = z.object({
+  outcome: z.enum(["settled", "timed-out", "cancelled"]),
+  state: DiagnosticJournalStateSchema,
+  throughSequence: z.number().int().nonnegative(),
+  settledSequence: z.number().int().nonnegative()
+}).strict().readonly();
+var DiagnosticJournalCloseResultSchema = z.object({
+  outcome: z.enum(["closed", "timed-out", "cancelled"]),
+  state: DiagnosticJournalStateSchema,
+  pendingItems: z.number().int().nonnegative()
+}).strict().readonly();
+var DiagnosticJournalFrameSchema = z.object({
+  schemaVersion: z.literal(1),
+  epoch: z.uuid(),
+  sequence: z.number().int().positive(),
+  event: z.json()
+}).strict().readonly();
+function parseDiagnosticJournalMode(mode) {
+  return FileModeSchema.parse(mode ?? 384);
+}
+function readDiagnosticJournalLockDiagnosis(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 };

package/dist/{index-aewy3x5j.js → index-xcetq6j3.js}

@@ -2,20 +2,22 @@ import {
   contextContributionDelta,
   mergeContextContribution,
   prepareContextContribution
-} from "./index-vbf2p6me.js";
+} from "./index-m9kzax52.js";
 import {
   base64UrlToBytes,
-  bytesToBase64Url,
-  isUnsafeKey,
-  safeJsonParse
-} from "./index-vj3vvpaa.js";
-import {
-  isRecord
-} from "./index-qyrqwr4c.js";
+  bytesToBase64Url
+} from "./index-y01f4223.js";
 import {
   forbidden,
   unauthorized
 } from "./index-0w9abg87.js";
+import {
+  isUnsafeKey,
+  safeJsonParse
+} from "./index-kzfs85xp.js";
+import {
+  isRecord
+} from "./index-77fekveh.js";
 
 // src/server/middleware/cookies.ts
 function parseCookies(header) {

package/dist/{index-7z69kyrh.js → index-y01f4223.js}

@@ -1,15 +1,22 @@
 import {
   AppError
 } from "./index-0w9abg87.js";
+import {
+  isUnsafeKey
+} from "./index-kzfs85xp.js";
 import {
   mapObjectTypeBoundary
-} from "./index-ksp6e2ye.js";
+} from "./index-77fekveh.js";
 
 // src/contract/define.ts
 import { z } from "zod";
 
 // src/internal/route-pattern.ts
 var PARAM_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function joinRoutePath(...parts) {
+  const joined = parts.filter((part) => Boolean(part)).map((part) => part.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
+  return `/${joined}`;
+}
 function parseTrailingWildcard(path) {
   const segments = path.split("/").filter(Boolean);
   const paramNames = new Set;
@@ -50,11 +57,6 @@ function parseTrailingWildcard(path) {
   return wildcard;
 }
 
-// src/internal/safe-json.ts
-function isUnsafeKey(key) {
-  return key === "__proto__";
-}
-
 // src/contract/define.ts
 var ALL_TRANSPORTS = ["HTTP", "MCP", "AGENT", "CLI"];
 function defineContract(meta, endpoints) {
@@ -334,26 +336,8 @@ function createContractFactory(config) {
   };
   return { defineContract: explicit };
 }
-// src/contract/file-ref.ts
-import { z as z3 } from "zod";
-function isManagedFilePath(value) {
-  if (value.length === 0 || value.includes("\x00") || value.includes("\\"))
-    return false;
-  if (value.startsWith("/") || value.startsWith("//") || /^[A-Za-z]:/.test(value)) {
-    return false;
-  }
-  const parts = value.split("/");
-  return parts.every((part) => part.length > 0 && part !== "." && part !== "..");
-}
-var ManagedFilePathSchema = z3.string().refine(isManagedFilePath, "expected a canonical relative managed-file path");
-var ManagedFileRefSchema = z3.object({
-  path: ManagedFilePathSchema,
-  size: z3.number().int().nonnegative(),
-  mediaType: z3.string().min(1).optional(),
-  name: z3.string().min(1).optional()
-});
 // src/contract/pagination.ts
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 
 // src/internal/base64url.ts
 function bytesToBase64Url(bytes) {
@@ -373,9 +357,9 @@ function base64UrlToBytes(segment) {
 
 // src/contract/pagination.ts
 function paginatedSchema(itemSchema) {
-  return z4.object({
-    items: z4.array(itemSchema),
-    nextCursor: z4.string().nullable()
+  return z3.object({
+    items: z3.array(itemSchema),
+    nextCursor: z3.string().nullable()
   });
 }
 function toBase64Url(str) {
@@ -398,19 +382,19 @@ function decodeCursor(cursor, schema) {
   }
 }
 // src/contract/stream.ts
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 var DEFAULT_CONTRACT_STREAM_FRAME_BYTES = 256 * 1024;
-var ContractStreamFrameSchema = z5.discriminatedUnion("type", [
-  z5.object({ type: z5.literal("data"), data: z5.unknown() }).strict(),
-  z5.object({
-    type: z5.literal("error"),
-    error: z5.object({
-      code: z5.string(),
-      message: z5.string().optional(),
-      details: z5.unknown().optional(),
-      hint: z5.string().optional()
+var ContractStreamFrameSchema = z4.discriminatedUnion("type", [
+  z4.object({ type: z4.literal("data"), data: z4.unknown() }).strict(),
+  z4.object({
+    type: z4.literal("error"),
+    error: z4.object({
+      code: z4.string(),
+      message: z4.string().optional(),
+      details: z4.unknown().optional(),
+      hint: z4.string().optional()
     }).strict()
   }).strict(),
-  z5.object({ type: z5.literal("end") }).strict()
+  z4.object({ type: z4.literal("end") }).strict()
 ]);
-export { parseTrailingWildcard, ALL_TRANSPORTS, defineContract, mergeMeta, defineErrors, createContractFactory, ManagedFilePathSchema, ManagedFileRefSchema, paginatedSchema, encodeCursor, decodeCursor, DEFAULT_CONTRACT_STREAM_FRAME_BYTES, ContractStreamFrameSchema };
+export { joinRoutePath, parseTrailingWildcard, ALL_TRANSPORTS, defineContract, mergeMeta, defineErrors, createContractFactory, bytesToBase64Url, base64UrlToBytes, paginatedSchema, encodeCursor, decodeCursor, DEFAULT_CONTRACT_STREAM_FRAME_BYTES, ContractStreamFrameSchema };

package/dist/{index-dmfn9m4x.js → index-ywd0y6m1.js}

@@ -1,332 +1,11 @@
-// src/application/channel.ts
-import { z } from "zod";
-var PositiveSafeIntegerSchema = z.number().int().positive().safe();
-var BoundedChannelPolicySchema = z.enum(["ordered", "latest"]);
-var BoundedChannelStateSchema = z.enum(["open", "draining", "closed", "failed"]);
-var BoundedChannelSnapshotSchema = z.object({
-  state: BoundedChannelStateSchema,
-  policy: BoundedChannelPolicySchema,
-  queuedItems: z.number().int().nonnegative(),
-  queuedBytes: z.number().int().nonnegative(),
-  waitingReader: z.boolean(),
-  offered: z.number().int().nonnegative(),
-  delivered: z.number().int().nonnegative(),
-  queued: z.number().int().nonnegative(),
-  coalesced: z.number().int().nonnegative(),
-  refused: z.number().int().nonnegative(),
-  discarded: z.number().int().nonnegative()
-}).strict().readonly();
-
-class BoundedChannelReaderError extends Error {
-  constructor() {
-    super("A bounded channel permits only one pending next() call");
-    this.name = "BoundedChannelReaderError";
-  }
-}
-function createBoundedChannel(config) {
-  const policy = BoundedChannelPolicySchema.parse(config.policy);
-  const maxItems = PositiveSafeIntegerSchema.parse(config.maxItems);
-  const maxBytes = PositiveSafeIntegerSchema.parse(config.maxBytes);
-  const queue = [];
-  let state = "open";
-  let queuedBytes = 0;
-  let waiting;
-  let failure;
-  let hasFailure = false;
-  let offered = 0;
-  let delivered = 0;
-  let queued = 0;
-  let coalesced = 0;
-  let refused = 0;
-  let discarded = 0;
-  const removeAbortListener = () => {
-    config.signal?.removeEventListener("abort", abortChannel);
-  };
-  const snapshot = () => BoundedChannelSnapshotSchema.parse({
-    state,
-    policy,
-    queuedItems: queue.length,
-    queuedBytes,
-    waitingReader: waiting !== undefined,
-    offered,
-    delivered,
-    queued,
-    coalesced,
-    refused,
-    discarded
-  });
-  const clearQueue = () => {
-    discarded += queue.length;
-    queue.length = 0;
-    queuedBytes = 0;
-  };
-  const settleClosed = () => {
-    if (state !== "draining" || queue.length > 0)
-      return;
-    state = "closed";
-    removeAbortListener();
-    const reader = waiting;
-    waiting = undefined;
-    reader?.resolve({ done: true, value: undefined });
-  };
-  const close = (options = {}) => {
-    if (state === "closed" || state === "failed")
-      return snapshot();
-    const mode = options.mode ?? "drain";
-    if (mode !== "drain" && mode !== "discard") {
-      throw new TypeError("Bounded channel close mode must be drain or discard");
-    }
-    if (mode === "discard") {
-      clearQueue();
-      state = "closed";
-      removeAbortListener();
-      const reader = waiting;
-      waiting = undefined;
-      reader?.resolve({ done: true, value: undefined });
-      return snapshot();
-    }
-    state = "draining";
-    settleClosed();
-    return snapshot();
-  };
-  function abortChannel() {
-    close({ mode: "discard" });
-  }
-  const channel = {
-    [Symbol.asyncIterator]() {
-      return channel;
-    },
-    offer(value) {
-      offered += 1;
-      if (state !== "open") {
-        refused += 1;
-        return { outcome: "refused", reason: "not-open" };
-      }
-      const bytes = config.sizeOf(value);
-      if (!Number.isSafeInteger(bytes) || bytes < 0) {
-        throw new TypeError("Bounded channel sizeOf() must return a non-negative safe integer");
-      }
-      if (bytes > maxBytes) {
-        refused += 1;
-        return { outcome: "refused", reason: "item-too-large" };
-      }
-      const reader = waiting;
-      if (reader) {
-        waiting = undefined;
-        delivered += 1;
-        reader.resolve({ done: false, value });
-        return { outcome: "delivered" };
-      }
-      if (policy === "latest" && queue.length > 0) {
-        const previous = queue[0];
-        if (!previous)
-          throw new Error("Bounded latest channel lost its pending value");
-        queue[0] = { value, bytes };
-        queuedBytes += bytes - previous.bytes;
-        coalesced += 1;
-        return { outcome: "coalesced", replaced: 1 };
-      }
-      if (queue.length >= maxItems) {
-        refused += 1;
-        return { outcome: "refused", reason: "item-capacity" };
-      }
-      if (queuedBytes + bytes > maxBytes) {
-        refused += 1;
-        return { outcome: "refused", reason: "byte-capacity" };
-      }
-      queue.push({ value, bytes });
-      queuedBytes += bytes;
-      queued += 1;
-      return { outcome: "queued" };
-    },
-    next() {
-      if (hasFailure)
-        return Promise.reject(failure);
-      const next = queue.shift();
-      if (next) {
-        queuedBytes -= next.bytes;
-        delivered += 1;
-        settleClosed();
-        return Promise.resolve({ done: false, value: next.value });
-      }
-      if (state === "closed" || state === "draining") {
-        settleClosed();
-        return Promise.resolve({ done: true, value: undefined });
-      }
-      if (waiting)
-        return Promise.reject(new BoundedChannelReaderError);
-      return new Promise((resolve, reject) => {
-        waiting = { resolve, reject };
-      });
-    },
-    return() {
-      close({ mode: "discard" });
-      return Promise.resolve({ done: true, value: undefined });
-    },
-    throw(error) {
-      channel.fail(error);
-      return Promise.reject(error);
-    },
-    close,
-    fail(error) {
-      if (state === "closed" || state === "failed")
-        return snapshot();
-      failure = error;
-      hasFailure = true;
-      state = "failed";
-      clearQueue();
-      removeAbortListener();
-      const reader = waiting;
-      waiting = undefined;
-      reader?.reject(error);
-      return snapshot();
-    },
-    getSnapshot: snapshot
-  };
-  if (config.signal?.aborted)
-    abortChannel();
-  else
-    config.signal?.addEventListener("abort", abortChannel, { once: true });
-  return channel;
-}
-var CreditWindowSnapshotSchema = z.object({
-  state: z.enum(["open", "closed"]),
-  capacityBytes: PositiveSafeIntegerSchema,
-  availableBytes: z.number().int().nonnegative(),
-  leasedBytes: z.number().int().nonnegative(),
-  acquired: z.number().int().nonnegative(),
-  refused: z.number().int().nonnegative(),
-  replenishedBytes: z.number().int().nonnegative(),
-  waiting: z.number().int().nonnegative()
-}).strict().readonly();
-function createCreditWindow(config) {
-  const capacityBytes = PositiveSafeIntegerSchema.parse(config.capacityBytes);
-  let availableBytes = capacityBytes;
-  let state = "open";
-  let acquired = 0;
-  let refused = 0;
-  let replenishedBytes = 0;
-  const waiters = new Set;
-  const snapshot = () => CreditWindowSnapshotSchema.parse({
-    state,
-    capacityBytes,
-    availableBytes,
-    leasedBytes: capacityBytes - availableBytes,
-    acquired,
-    refused,
-    replenishedBytes,
-    waiting: waiters.size
-  });
-  const serveWaiters = () => {
-    for (const waiter of waiters) {
-      if (waiter.bytes > availableBytes)
-        return;
-      waiter.settle({ outcome: "leased", lease: lease(waiter.bytes) });
-    }
-  };
-  const lease = (requested) => {
-    availableBytes -= requested;
-    acquired += 1;
-    let leaseReleased = false;
-    return {
-      bytes: requested,
-      get released() {
-        return leaseReleased;
-      },
-      release() {
-        if (leaseReleased)
-          return;
-        leaseReleased = true;
-        availableBytes += requested;
-        replenishedBytes += requested;
-        if (availableBytes > capacityBytes) {
-          throw new Error("Credit window accounting exceeded its capacity");
-        }
-        serveWaiters();
-      }
-    };
-  };
-  const tryLease = (requested) => {
-    if (state === "closed")
-      return { outcome: "refused", reason: "closed" };
-    if (requested > capacityBytes) {
-      return { outcome: "refused", reason: "larger-than-window" };
-    }
-    if (requested > availableBytes) {
-      return { outcome: "refused", reason: "insufficient-credit" };
-    }
-    return { outcome: "leased", lease: lease(requested) };
-  };
-  const acquireNow = (requested) => {
-    const result = tryLease(requested);
-    if (result.outcome === "refused")
-      refused += 1;
-    return result;
-  };
-  const acquireWaiting = (requested, options) => {
-    const timeoutMs = options.timeoutMs === undefined ? undefined : PositiveSafeIntegerSchema.parse(options.timeoutMs);
-    const immediate = tryLease(requested);
-    if (immediate.outcome === "leased")
-      return Promise.resolve(immediate);
-    if (immediate.reason !== "insufficient-credit") {
-      refused += 1;
-      return Promise.resolve({ outcome: "refused", reason: immediate.reason });
-    }
-    if (options.signal?.aborted) {
-      refused += 1;
-      return Promise.resolve({ outcome: "refused", reason: "aborted" });
-    }
-    return new Promise((resolve) => {
-      let settled = false;
-      let timer;
-      const waiter = {
-        bytes: requested,
-        settle(result) {
-          if (settled)
-            return;
-          settled = true;
-          if (timer !== undefined)
-            clearTimeout(timer);
-          options.signal?.removeEventListener("abort", onAbort);
-          waiters.delete(waiter);
-          if (result.outcome === "refused")
-            refused += 1;
-          resolve(result);
-        }
-      };
-      function onAbort() {
-        waiter.settle({ outcome: "refused", reason: "aborted" });
-      }
-      waiters.add(waiter);
-      options.signal?.addEventListener("abort", onAbort, { once: true });
-      if (timeoutMs !== undefined) {
-        timer = setTimeout(() => {
-          waiter.settle({ outcome: "refused", reason: "timed-out" });
-        }, timeoutMs);
-      }
-    });
-  };
-  function acquire(bytes, options) {
-    const requested = PositiveSafeIntegerSchema.parse(bytes);
-    return options === undefined ? acquireNow(requested) : acquireWaiting(requested, options);
-  }
-  return {
-    acquire,
-    close() {
-      state = "closed";
-      for (const waiter of [...waiters]) {
-        waiter.settle({ outcome: "refused", reason: "closed" });
-      }
-      return snapshot();
-    },
-    getSnapshot: snapshot
-  };
-}
+import {
+  createBoundedChannel
+} from "./index-7gnkny4z.js";
 
 // src/browser/live-state.ts
-import { z as z2 } from "zod";
-var PositiveSafeIntegerSchema2 = z2.number().int().positive().safe();
-var LiveStatePhaseSchema = z2.enum([
+import { z } from "zod";
+var PositiveSafeIntegerSchema = z.number().int().positive().safe();
+var LiveStatePhaseSchema = z.enum([
   "idle",
   "opening",
   "live",
@@ -334,7 +13,7 @@ var LiveStatePhaseSchema = z2.enum([
   "unavailable",
   "closed"
 ]);
-var LiveStateStopReasonSchema = z2.enum([
+var LiveStateStopReasonSchema = z.enum([
   "gap",
   "buffer-overflow",
   "source-unavailable",
@@ -342,22 +21,22 @@ var LiveStateStopReasonSchema = z2.enum([
   "controller-error",
   "controller-capacity"
 ]);
-var LiveStateControllerStatusSchema = z2.object({
+var LiveStateControllerStatusSchema = z.object({
   phase: LiveStatePhaseSchema,
-  generation: z2.number().int().nonnegative(),
-  hasValue: z2.boolean(),
-  bufferedEvents: z2.number().int().nonnegative(),
-  bufferedBytes: z2.number().int().nonnegative(),
-  receivedEvents: z2.number().int().nonnegative(),
-  appliedEvents: z2.number().int().nonnegative(),
-  duplicateEvents: z2.number().int().nonnegative(),
-  gapEvents: z2.number().int().nonnegative(),
-  refusedEvents: z2.number().int().nonnegative(),
+  generation: z.number().int().nonnegative(),
+  hasValue: z.boolean(),
+  bufferedEvents: z.number().int().nonnegative(),
+  bufferedBytes: z.number().int().nonnegative(),
+  receivedEvents: z.number().int().nonnegative(),
+  appliedEvents: z.number().int().nonnegative(),
+  duplicateEvents: z.number().int().nonnegative(),
+  gapEvents: z.number().int().nonnegative(),
+  refusedEvents: z.number().int().nonnegative(),
   reason: LiveStateStopReasonSchema.optional()
 }).strict().readonly();
 function createLiveStateController(config) {
-  const maxBufferedEvents = PositiveSafeIntegerSchema2.parse(config.maxBufferedEvents);
-  const maxBufferedBytes = PositiveSafeIntegerSchema2.parse(config.maxBufferedBytes);
+  const maxBufferedEvents = PositiveSafeIntegerSchema.parse(config.maxBufferedEvents);
+  const maxBufferedBytes = PositiveSafeIntegerSchema.parse(config.maxBufferedBytes);
   const subscribers = new Set;
   let phase = "idle";
   let reason;
@@ -712,4 +391,4 @@ function createLiveStateController(config) {
   };
 }
 
-export { BoundedChannelPolicySchema, BoundedChannelStateSchema, BoundedChannelSnapshotSchema, BoundedChannelReaderError, createBoundedChannel, CreditWindowSnapshotSchema, createCreditWindow, LiveStatePhaseSchema, LiveStateStopReasonSchema, LiveStateControllerStatusSchema, createLiveStateController };
+export { LiveStatePhaseSchema, LiveStateStopReasonSchema, LiveStateControllerStatusSchema, createLiveStateController };