stitchkit 0.77.0 → 0.78.0

package/dist/index-n1g2xm6a.js

@@ -0,0 +1,203 @@
+// 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();
+
+export { createBoundedChannel };

package/dist/{index-t8qyvrvg.js → index-n7apa6sy.js}

@@ -8,6 +8,12 @@ import {
   guardSignalCallback,
   reportSignalError
 } from "./index-vbf2p6me.js";
+import {
+  ShutdownOptionsSchema,
+  isStreamCancellation,
+  ownHttpStream,
+  settleStreamCleanup
+} from "./index-1ckavx4h.js";
 import {
   extractIp,
   getClientInfo,
@@ -18,13 +24,7 @@ import {
   runWithRequestContext,
   setRequestEndpoint,
   setRequestError
-} from "./index-nemjkxjp.js";
-import {
-  ShutdownOptionsSchema,
-  isStreamCancellation,
-  ownHttpStream,
-  settleStreamCleanup
-} from "./index-3z73fh2c.js";
+} from "./index-s5tn4kdv.js";
 import {
   errorCode,
   normalizeError,
@@ -32,7 +32,7 @@ import {
   resolveTraceContext,
   validateDeclaredOutput,
   zodIssues
-} from "./index-nt1mp8km.js";
+} from "./index-efm026pw.js";
 import {
   DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
   isUnsafeKey,
@@ -40,14 +40,14 @@ import {
   parseTrailingWildcard,
   safeJsonParse
 } from "./index-vj3vvpaa.js";
-import {
-  AppError,
-  badRequest
-} from "./index-0w9abg87.js";
 import {
   isRecord,
   transportResult
 } from "./index-qyrqwr4c.js";
+import {
+  AppError,
+  badRequest
+} from "./index-0w9abg87.js";
 
 // src/server/multipart.ts
 var DEFAULT_MAX_REQUEST_BYTES = 25 * 1024 * 1024;

package/dist/{index-s4c8wy8m.js → index-qaajjfp6.js}

@@ -1,27 +1,27 @@
-import {
-  getRequestContext,
-  runWithRequestContext
-} from "./index-nemjkxjp.js";
 import {
   objectShapeKeys
 } from "./index-22by16v6.js";
+import {
+  getRequestContext,
+  runWithRequestContext
+} from "./index-s5tn4kdv.js";
 import {
   formatZodError,
   normalizeError,
   validateDeclaredOutput
-} from "./index-nt1mp8km.js";
+} from "./index-efm026pw.js";
 import {
   isUnsafeKey,
   safeJsonParse
 } from "./index-vj3vvpaa.js";
+import {
+  isRecord
+} from "./index-qyrqwr4c.js";
 import {
   AppError,
   STITCH_ERROR_STATUS,
   isStitchErrorCode
 } from "./index-0w9abg87.js";
-import {
-  isRecord
-} from "./index-qyrqwr4c.js";
 
 // src/tools/coerce.ts
 import { z } from "zod";

package/dist/{index-nemjkxjp.js → index-s5tn4kdv.js}

@@ -1,6 +1,6 @@
 import {
   resolveTraceContext
-} from "./index-nt1mp8km.js";
+} from "./index-efm026pw.js";
 import {
   isUnsafeKey
 } from "./index-vj3vvpaa.js";
@@ -179,38 +179,42 @@ function isPublicIp(value) {
 
 // src/observability/context.ts
 import { AsyncLocalStorage } from "node:async_hooks";
-var storage = new AsyncLocalStorage;
+var storage;
+var requestStorage = () => {
+  storage ??= new AsyncLocalStorage;
+  return storage;
+};
 function runWithRequestContext(ctx, fn) {
-  return storage.run(ctx, fn);
+  return requestStorage().run(ctx, fn);
 }
 function getRequestContext() {
-  return storage.getStore();
+  return requestStorage().getStore();
 }
 function getTraceId() {
-  return storage.getStore()?.trace.traceId;
+  return requestStorage().getStore()?.trace.traceId;
 }
 function getUserId() {
-  return storage.getStore()?.userId;
+  return requestStorage().getStore()?.userId;
 }
 function setRequestUser(userId) {
-  const ctx = storage.getStore();
+  const ctx = requestStorage().getStore();
   if (ctx)
     ctx.userId = userId;
 }
 function setRequestEndpoint(serviceName, action) {
-  const ctx = storage.getStore();
+  const ctx = requestStorage().getStore();
   if (ctx) {
     ctx.serviceName = serviceName;
     ctx.action = action;
   }
 }
 function setRequestDimensions(dimensions) {
-  const ctx = storage.getStore();
+  const ctx = requestStorage().getStore();
   if (ctx)
     ctx.dimensions = { ...ctx.dimensions, ...dimensions };
 }
 function setRequestError(error) {
-  const ctx = storage.getStore();
+  const ctx = requestStorage().getStore();
   if (ctx)
     ctx.error = error;
 }

package/dist/index-wfq8zerm.js

@@ -0,0 +1,92 @@
+import {
+  LiveStatePhaseSchema,
+  LiveStateStopReasonSchema
+} from "./index-dmfn9m4x.js";
+
+// src/live/watch-contract.ts
+import { z } from "zod";
+var WatchKeySchema = z.object({
+  service: z.string().min(1),
+  action: z.string().min(1),
+  digest: z.string().min(1)
+}).strict().readonly();
+var WatchOpenSchema = z.object({ key: WatchKeySchema, args: z.unknown() }).readonly();
+var WatchAcceptedSchema = z.object({
+  accepted: z.boolean(),
+  reason: z.string().optional()
+}).strict().readonly();
+var WatchValueSchema = z.object({
+  key: WatchKeySchema,
+  revision: z.number().int().nonnegative(),
+  value: z.unknown()
+}).readonly();
+var WatchStateSchema = z.object({
+  key: WatchKeySchema,
+  phase: LiveStatePhaseSchema,
+  reason: LiveStateStopReasonSchema.optional(),
+  code: z.string().optional(),
+  message: z.string().optional()
+}).readonly();
+var WATCH_OPEN = "stitchkit.watch.open";
+var WATCH_CLOSE = "stitchkit.watch.close";
+var WATCH_VALUE = "stitchkit.watch.value";
+var WATCH_STATE = "stitchkit.watch.state";
+var watchContract = {
+  serverToClient: {
+    [WATCH_VALUE]: { args: z.tuple([WatchValueSchema]) },
+    [WATCH_STATE]: { args: z.tuple([WatchStateSchema]) }
+  },
+  clientToServer: {
+    [WATCH_OPEN]: { args: z.tuple([WatchOpenSchema]), ack: WatchAcceptedSchema },
+    [WATCH_CLOSE]: { args: z.tuple([z.object({ key: WatchKeySchema }).readonly()]) }
+  }
+};
+function watchKeyString(key) {
+  return `${key.service}/${key.action}/${key.digest}`;
+}
+
+// src/internal/stable-digest.ts
+function stableValue(value) {
+  if (Array.isArray(value))
+    return value.map(stableValue);
+  if (value === null || typeof value !== "object")
+    return value;
+  const result = {};
+  for (const key of Object.keys(value).sort()) {
+    result[key] = stableValue(Reflect.get(value, key));
+  }
+  return result;
+}
+function mix128(input) {
+  let a = 2654435769;
+  let b = 2246822507;
+  let c = 3266489909;
+  let d = 668265263;
+  for (let index = 0;index < input.length; index += 1) {
+    const code = input.charCodeAt(index);
+    a = Math.imul(a ^ code, 2246822519);
+    b = Math.imul(b ^ code, 3266489917);
+    c = Math.imul(c ^ code, 668265263);
+    d = Math.imul(d ^ code, 374761393);
+    a = a << 13 | a >>> 19;
+    b = b << 17 | b >>> 15;
+    c = c << 7 | c >>> 25;
+    d = d << 11 | d >>> 21;
+  }
+  a ^= b >>> 15;
+  b ^= c >>> 13;
+  c ^= d >>> 11;
+  d ^= a >>> 9;
+  return [
+    Math.imul(a ^ a >>> 16, 575075507) >>> 0,
+    Math.imul(b ^ b >>> 13, 2654435761) >>> 0,
+    Math.imul(c ^ c >>> 16, 2246822507) >>> 0,
+    Math.imul(d ^ d >>> 15, 3266489909) >>> 0
+  ];
+}
+function argumentsDigest(args) {
+  const lanes = mix128(JSON.stringify(stableValue(args)) ?? "undefined");
+  return lanes.map((lane) => lane.toString(16).padStart(8, "0")).join("");
+}
+
+export { stableValue, argumentsDigest, WatchKeySchema, WatchValueSchema, WatchStateSchema, WATCH_OPEN, WATCH_CLOSE, WATCH_VALUE, WATCH_STATE, watchContract, watchKeyString };