stitchkit 0.77.0 → 0.79.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-da1aqnhb.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";
+  bytesToBase64Url
+} from "./index-y01f4223.js";
 import {
   forbidden,
   unauthorized
 } from "./index-0w9abg87.js";
+import {
+  isUnsafeKey,
+  safeJsonParse
+} from "./index-kzfs85xp.js";
 import {
   isRecord
-} from "./index-qyrqwr4c.js";
+} from "./index-77fekveh.js";
 
 // src/server/middleware/cookies.ts
 function parseCookies(header) {

package/dist/{index-f6n5n7nz.js → index-y01f4223.js}

@@ -1,12 +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;
@@ -47,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) {
@@ -259,92 +264,12 @@ function assertResponseMetaEndpoint(prefix, key, ep) {
     throw new Error(`${where} is HTTP-only — remove ${nonHttp.join(", ")} from expose`);
   }
 }
-// src/contract/errors.ts
-var APP_ERROR_BRAND = Symbol.for("stitchkit.AppError");
-
-class AppError extends Error {
-  code;
-  status;
-  details;
-  hint;
-  traceId;
-  constructor(code, message, status = 500, details, hint, traceId) {
-    super(message ?? code);
-    this.code = code;
-    this.status = status;
-    this.details = details;
-    this.hint = hint;
-    this.traceId = traceId;
-    this.name = "AppError";
-    Object.defineProperty(this, APP_ERROR_BRAND, { value: true });
-  }
-  static is(err) {
-    return typeof err === "object" && err !== null && APP_ERROR_BRAND in err;
-  }
-  toJSON() {
-    return {
-      error: {
-        code: this.code,
-        message: this.message,
-        ...this.details && { details: this.details },
-        ...this.hint && { hint: this.hint }
-      }
-    };
-  }
-}
-function notFound(message = "Not found") {
-  throw new AppError("NOT_FOUND", message, 404);
-}
-function badRequest(message, details) {
-  throw new AppError("BAD_REQUEST", message, 400, details);
-}
-function unauthorized(message = "Unauthorized") {
-  throw new AppError("UNAUTHORIZED", message, 401);
-}
-function forbidden(message = "Forbidden") {
-  throw new AppError("FORBIDDEN", message, 403);
-}
-function conflict(message = "Conflict", details) {
-  throw new AppError("CONFLICT", message, 409, details);
-}
-function rateLimited(message = "Too many requests") {
-  throw new AppError("RATE_LIMITED", message, 429);
-}
-var STITCH_ERROR_STATUS = {
-  BAD_REQUEST: 400,
-  UNAUTHORIZED: 401,
-  FORBIDDEN: 403,
-  NOT_FOUND: 404,
-  METHOD_NOT_ALLOWED: 405,
-  CONFLICT: 409,
-  RATE_LIMITED: 429,
-  VALIDATION_ERROR: 400,
-  FILE_INVALID_PATH: 400,
-  FILE_OUTSIDE_ROOT: 400,
-  FILE_NOT_FOUND: 404,
-  FILE_NOT_REGULAR: 422,
-  FILE_INSPECTION_REJECTED: 422,
-  FILE_TOO_LARGE: 413,
-  FILE_EXISTS: 409,
-  REALTIME_CONTRACT_VIOLATION: 500,
-  APPLICATION_NOT_ACCEPTING: 503,
-  GRAMMY_WEBHOOK_NOT_ACCEPTING: 503,
-  WAIT_TIMEOUT: 408,
-  WAIT_FAILED: 409,
-  DOWNLOAD_NOT_FOUND: 404,
-  VIEW_HTTP_ERROR: 502,
-  OPERATION_NOT_SUCCEEDED: 409,
-  STREAM_ITEM_INVALID: 500,
-  STREAM_FRAME_TOO_LARGE: 500,
-  STREAM_TERMINAL_MISSING: 500,
-  STREAM_LIFETIME_EXCEEDED: 408,
-  INTERNAL_SERVER_ERROR: 500
-};
-function isStitchErrorCode(code) {
-  return Object.hasOwn(STITCH_ERROR_STATUS, code);
-}
-function appError(code, message, details) {
-  throw new AppError(code, message, isStitchErrorCode(code) ? STITCH_ERROR_STATUS[code] : 500, details);
+function mergeMeta(contractMeta, endpointMeta) {
+  if (!contractMeta)
+    return endpointMeta;
+  if (!endpointMeta)
+    return { ...contractMeta };
+  return { ...contractMeta, ...endpointMeta };
 }
 // src/contract/errors-factory.ts
 import { z as z2 } from "zod";
@@ -411,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) {
@@ -450,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) {
@@ -475,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, AppError, notFound, badRequest, unauthorized, forbidden, conflict, rateLimited, STITCH_ERROR_STATUS, isStitchErrorCode, appError, 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-35z5h2ty.js → index-ywd0y6m1.js}

@@ -1,211 +1,11 @@
-// src/browser/live-state.ts
-import { z as z2 } from "zod";
+import {
+  createBoundedChannel
+} from "./index-7gnkny4z.js";
 
-// src/application/channel.ts
+// src/browser/live-state.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();
-
-// src/browser/live-state.ts
-var PositiveSafeIntegerSchema2 = z2.number().int().positive().safe();
-var LiveStatePhaseSchema = z2.enum([
+var LiveStatePhaseSchema = z.enum([
   "idle",
   "opening",
   "live",
@@ -213,7 +13,7 @@ var LiveStatePhaseSchema = z2.enum([
   "unavailable",
   "closed"
 ]);
-var LiveStateStopReasonSchema = z2.enum([
+var LiveStateStopReasonSchema = z.enum([
   "gap",
   "buffer-overflow",
   "source-unavailable",
@@ -221,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;