stitchkit 0.93.0 → 0.94.1

package/dist/files/boundary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"boundary.d.ts","sourceRoot":"","sources":["../../src/files/boundary.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,KAAK,cAAc,EAEpB,MAAM,sBAAsB,CAAC;AAqB9B,MAAM,MAAM,oBAAoB,GAC5B,mBAAmB,GACnB,gBAAgB,GAChB,kBAAkB,GAClB,mBAAmB,GACnB,gBAAgB,GAChB,aAAa,GACb,0BAA0B,GAC1B,eAAe,CAAC;AAEpB,qBAAa,gBAAiB,SAAQ,KAAK;aAEvB,IAAI,EAAE,oBAAoB;IAD5C,YACkB,IAAI,EAAE,oBAAoB,EAC1C,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,YAAY,EAIvB;CACF;AAED,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,UAAU,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,cAAc,EAAE,WAAW,GAAG,MAAM,CAAC,CAAC;AAE/E,MAAM,MAAM,oBAAoB,GAAG,CACjC,KAAK,EAAE,0BAA0B,KAC9B,qBAAqB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC;AAE5D,MAAM,WAAW,yBAAyB;IACxC,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAC;IACb,uFAAuF;IACvF,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,wEAAwE;IACxE,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAC/B,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC3C;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,cAAc,CAAC;IACpB,KAAK,EAAE,UAAU,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACjF,KAAK,CACH,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,UAAU,GAAG,cAAc,CAAC,UAAU,CAAC,EAC/C,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,cAAc,CAAC,CAAC;CAC5B;AAmRD;;;;GAIG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAAC,mBAAmB,CAAC,CAyJ9B"}
+{"version":3,"file":"boundary.d.ts","sourceRoot":"","sources":["../../src/files/boundary.ts"],"names":[],"mappings":"AAIA,OAAO,EAAyB,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAkBlF,MAAM,MAAM,oBAAoB,GAC5B,mBAAmB,GACnB,gBAAgB,GAChB,kBAAkB,GAClB,mBAAmB,GACnB,gBAAgB,GAChB,aAAa,GACb,0BAA0B,GAC1B,eAAe,CAAC;AAEpB,qBAAa,gBAAiB,SAAQ,KAAK;aAEvB,IAAI,EAAE,oBAAoB;IAD5C,YACkB,IAAI,EAAE,oBAAoB,EAC1C,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,YAAY,EAIvB;CACF;AAED,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,UAAU,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,cAAc,EAAE,WAAW,GAAG,MAAM,CAAC,CAAC;AAE/E,MAAM,MAAM,oBAAoB,GAAG,CACjC,KAAK,EAAE,0BAA0B,KAC9B,qBAAqB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC;AAE5D,MAAM,WAAW,yBAAyB;IACxC,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAC;IACb,uFAAuF;IACvF,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,wEAAwE;IACxE,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAC/B,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC3C;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,cAAc,CAAC;IACpB,KAAK,EAAE,UAAU,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACjF,KAAK,CACH,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,UAAU,GAAG,cAAc,CAAC,UAAU,CAAC,EAC/C,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,cAAc,CAAC,CAAC;CAC5B;AA2GD;;;;GAIG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAAC,mBAAmB,CAAC,CAyJ9B"}

package/dist/files/file-io.d.ts

@@ -0,0 +1,14 @@
+import type { open } from 'node:fs/promises';
+import { type ManagedFileRef } from '../contract/file-ref.js';
+import { type ManagedFileInspection, type ManagedFileInspectionInput, type ManagedFileInspector } from './boundary.js';
+export declare function inspectFile(inspector: ManagedFileInspector | undefined, input: Omit<ManagedFileInspectionInput, 'signal'>, timeoutMs: number, outerSignal?: AbortSignal): Promise<ManagedFileInspection>;
+export declare function inspectedRef(path: string, size: number, inspection: ManagedFileInspection, fallback?: {
+    mediaType?: string;
+    name?: string;
+}): ManagedFileRef;
+export declare function readHandle(handle: Awaited<ReturnType<typeof open>>, maxBytes: number, signal?: AbortSignal): Promise<Uint8Array>;
+export declare function writeSource(handle: Awaited<ReturnType<typeof open>>, source: Uint8Array | ReadableStream<Uint8Array>, maxBytes: number, inspectionBytes: number, signal?: AbortSignal): Promise<{
+    size: number;
+    prefix: Uint8Array;
+}>;
+//# sourceMappingURL=file-io.d.ts.map

package/dist/files/file-io.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-io.d.ts","sourceRoot":"","sources":["../../src/files/file-io.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,sBAAsB,CAAC;AACjF,OAAO,EAEL,KAAK,qBAAqB,EAC1B,KAAK,0BAA0B,EAC/B,KAAK,oBAAoB,EAC1B,MAAM,YAAY,CAAC;AA+BpB,wBAAsB,WAAW,CAC/B,SAAS,EAAE,oBAAoB,GAAG,SAAS,EAC3C,KAAK,EAAE,IAAI,CAAC,0BAA0B,EAAE,QAAQ,CAAC,EACjD,SAAS,EAAE,MAAM,EACjB,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,qBAAqB,CAAC,CAmBhC;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,qBAAqB,EACjC,QAAQ,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GACnD,cAAc,CAiBhB;AAED,wBAAsB,UAAU,CAC9B,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,CAAC,EACxC,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,UAAU,CAAC,CAyBrB;AAcD,wBAAsB,WAAW,CAC/B,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,CAAC,EACxC,MAAM,EAAE,UAAU,GAAG,cAAc,CAAC,UAAU,CAAC,EAC/C,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,MAAM,EACvB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,CAAC,CA2C/C"}

package/dist/google/google.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../src/google/google.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,mBAAmB,GAC3B,eAAe,GACf,oBAAoB,GACpB,sBAAsB,CAAC;AAQ3B,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAE5B,YAAY,IAAI,EAAE,mBAAmB,EAAE,OAAO,CAAC,EAAE,YAAY,EAK5D;CACF;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,MAAM,wBAAwB,GAAG,CACrC,KAAK,EAAE,uBAAuB,KAC3B,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAElC,MAAM,MAAM,yBAAyB,GAAG,CAAC,KAAK,EAAE;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;AAEhC,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IACjF,cAAc,CAAC,EAAE,wBAAwB,CAAC;IAC1C,eAAe,CAAC,EAAE,yBAAyB,CAAC;CAC7C;AAED,MAAM,WAAW,oCAAoC;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,yBAAyB,CACvB,KAAK,EAAE,oCAAoC,GAC1C,OAAO,CAAC,kBAAkB,CAAC,CAAC;CAChC;AAqGD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,sBAAsB,GAAG,gBAAgB,CAmFvF"}

package/dist/index-0b1ess5e.js

@@ -0,0 +1,38 @@
+import {
+  serializeCanonicalJson
+} from "./index-k5hsfc3j.js";
+
+// src/internal/stable-digest.ts
+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(serializeCanonicalJson(args));
+  return lanes.map((lane) => lane.toString(16).padStart(8, "0")).join("");
+}
+
+export { argumentsDigest };

package/dist/index-1j8pm5t0.js

@@ -0,0 +1,412 @@
+import {
+  createBoundedChannel
+} from "./index-d9pk3td4.js";
+
+// src/browser/live-state.ts
+import { z as z2 } from "zod";
+
+// src/browser/live-state-core.ts
+import { z } from "zod";
+var PositiveSafeIntegerSchema = z.number().int().positive().safe();
+function isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+}
+
+class LiveStateCore {
+  config;
+  maxBufferedEvents;
+  maxBufferedBytes;
+  subscribers = new Set;
+  phase = "idle";
+  reason;
+  generation = 0;
+  stored = { hasValue: false };
+  receivedEvents = 0;
+  appliedEvents = 0;
+  duplicateEvents = 0;
+  gapEvents = 0;
+  refusedEvents = 0;
+  current;
+  opening;
+  unsettledSourceOpens = 0;
+  unsettledSourceCloses = 0;
+  publishDepth = 0;
+  controllerErrorObserverEnabled = true;
+  subscriberErrorObserverEnabled = true;
+  published;
+  abortFromConfig = () => {
+    this.close();
+  };
+  constructor(config) {
+    this.config = config;
+    this.maxBufferedEvents = PositiveSafeIntegerSchema.parse(config.maxBufferedEvents);
+    this.maxBufferedBytes = PositiveSafeIntegerSchema.parse(config.maxBufferedBytes);
+    if (config.signal?.aborted)
+      this.phase = "closed";
+    else
+      config.signal?.addEventListener("abort", this.abortFromConfig, { once: true });
+    this.published = this.buildSnapshot();
+  }
+  start() {
+    if (this.phase === "idle")
+      return this.begin(false);
+    return this.opening ?? Promise.resolve(this.published);
+  }
+  resync() {
+    if (this.phase === "closed")
+      return Promise.resolve(this.published);
+    const active = this.current;
+    if (active?.startedByResync && !active.sourceOpenStarted && this.phase === "opening" && this.publishDepth > 0) {
+      return this.opening ?? Promise.resolve(this.published);
+    }
+    if (active) {
+      this.retire(active);
+      if (this.unsettledSourceOpens + this.unsettledSourceCloses >= 2) {
+        this.phase = "unavailable";
+        this.reason = "controller-capacity";
+        return Promise.resolve(this.publish());
+      }
+    }
+    return this.begin(true);
+  }
+  status() {
+    const buffered = this.current?.buffer.getSnapshot();
+    return LiveStateControllerStatusSchema.parse({
+      phase: this.phase,
+      generation: this.generation,
+      hasValue: this.stored.hasValue,
+      bufferedEvents: buffered?.queuedItems ?? 0,
+      bufferedBytes: buffered?.queuedBytes ?? 0,
+      receivedEvents: this.receivedEvents,
+      appliedEvents: this.appliedEvents,
+      duplicateEvents: this.duplicateEvents,
+      gapEvents: this.gapEvents,
+      refusedEvents: this.refusedEvents,
+      ...this.reason && { reason: this.reason }
+    });
+  }
+  buildSnapshot() {
+    const metadata = this.status();
+    return this.stored.hasValue ? Object.freeze({ ...metadata, value: this.stored.value }) : metadata;
+  }
+  reportControllerError(error, at, atGeneration) {
+    if (!this.config.onControllerError || !this.controllerErrorObserverEnabled)
+      return;
+    try {
+      const returned = this.config.onControllerError({
+        error,
+        generation: atGeneration,
+        phase: at
+      });
+      if (isPromiseLike(returned)) {
+        this.controllerErrorObserverEnabled = false;
+        Promise.resolve(returned).catch(() => {
+          return;
+        });
+      }
+    } catch {}
+  }
+  reportSubscriberError(error, snapshot) {
+    if (!this.config.onSubscriberError || !this.subscriberErrorObserverEnabled)
+      return;
+    try {
+      const returned = this.config.onSubscriberError({ error, snapshot });
+      if (isPromiseLike(returned)) {
+        this.subscriberErrorObserverEnabled = false;
+        Promise.resolve(returned).catch(() => {
+          return;
+        });
+      }
+    } catch {}
+  }
+  publish() {
+    const snapshot = this.buildSnapshot();
+    this.published = snapshot;
+    this.publishDepth += 1;
+    try {
+      for (const listener of this.subscribers) {
+        try {
+          const returned = listener(snapshot);
+          if (isPromiseLike(returned)) {
+            this.subscribers.delete(listener);
+            this.reportSubscriberError(new TypeError("Live-state subscribers must settle synchronously"), snapshot);
+            Promise.resolve(returned).catch(() => {
+              return;
+            });
+          }
+        } catch (error) {
+          this.reportSubscriberError(error, snapshot);
+        }
+      }
+    } finally {
+      this.publishDepth -= 1;
+    }
+    return this.published;
+  }
+  publishAvailableCapacity() {
+    if (this.phase !== "unavailable" || this.reason !== "controller-capacity" || this.unsettledSourceOpens + this.unsettledSourceCloses >= 2)
+      return;
+    this.phase = "resync-required";
+    this.publish();
+  }
+  closeSource(active) {
+    if (active.closePromise)
+      return active.closePromise;
+    if (!active.closeSource)
+      return Promise.resolve();
+    const at = this.phase;
+    this.unsettledSourceCloses += 1;
+    active.closePromise = Promise.resolve().then(() => active.closeSource?.()).then(() => {
+      return;
+    }).catch((error) => {
+      this.reportControllerError(error, at, active.id);
+    }).finally(() => {
+      this.unsettledSourceCloses -= 1;
+      this.publishAvailableCapacity();
+    });
+    return active.closePromise;
+  }
+  retire(active) {
+    if (!active.retired) {
+      active.retired = true;
+      active.settleRetired();
+      active.abort.abort();
+      active.buffer.close({ mode: "discard" });
+    }
+    return this.closeSource(active);
+  }
+  stopGeneration(active, nextPhase, nextReason) {
+    if (this.current !== active || active.retired || this.phase === "closed")
+      return;
+    this.phase = nextPhase;
+    this.reason = nextReason;
+    this.retire(active);
+    this.publish();
+  }
+  apply(active, event) {
+    if (this.current !== active || active.retired || !this.stored.hasValue || this.phase !== "opening" && this.phase !== "live")
+      return;
+    let decision;
+    try {
+      decision = this.config.applyEvent(this.stored.value, event);
+    } catch (error) {
+      this.reportControllerError(error, this.phase, active.id);
+      this.stopGeneration(active, "unavailable", "controller-error");
+      return;
+    }
+    if (this.current !== active || active.retired || this.phase !== "opening" && this.phase !== "live")
+      return;
+    if (!decision || !["applied", "duplicate", "gap"].includes(decision.outcome) || decision.outcome === "applied" && !("state" in decision)) {
+      this.reportControllerError(new Error("applyEvent returned an invalid decision"), this.phase, active.id);
+      this.stopGeneration(active, "unavailable", "controller-error");
+      return;
+    }
+    if (decision.outcome === "duplicate") {
+      this.duplicateEvents += 1;
+      this.publish();
+      return;
+    }
+    if (decision.outcome === "gap") {
+      this.gapEvents += 1;
+      this.stopGeneration(active, "resync-required", "gap");
+      return;
+    }
+    this.stored = { hasValue: true, value: decision.state };
+    this.appliedEvents += 1;
+    this.publish();
+  }
+  onEvent(active, event) {
+    if (this.current !== active || active.retired || this.phase === "closed")
+      return;
+    this.receivedEvents += 1;
+    if (this.phase === "opening") {
+      try {
+        const offered = active.buffer.offer(event);
+        if (offered.outcome === "refused") {
+          this.refusedEvents += 1;
+          this.stopGeneration(active, "resync-required", "buffer-overflow");
+        } else {
+          this.publish();
+        }
+      } catch (error) {
+        this.refusedEvents += 1;
+        this.reportControllerError(error, this.phase, active.id);
+        this.stopGeneration(active, "unavailable", "controller-error");
+      }
+      return;
+    }
+    if (this.phase === "live")
+      this.apply(active, event);
+  }
+  async openGeneration(active) {
+    try {
+      if (active.retired || this.current !== active || this.phase === "closed")
+        return this.published;
+      this.unsettledSourceOpens += 1;
+      let sourceOpening;
+      try {
+        sourceOpening = this.config.source.open({
+          signal: active.abort.signal,
+          onEvent: (event) => this.onEvent(active, event),
+          onUnavailable: () => this.stopGeneration(active, "unavailable", "source-unavailable")
+        });
+      } catch (error) {
+        this.unsettledSourceOpens -= 1;
+        this.publishAvailableCapacity();
+        throw error;
+      }
+      sourceOpening = sourceOpening.then((opened2) => {
+        active.closeSource = () => opened2.close();
+        this.unsettledSourceOpens -= 1;
+        if (active.retired || this.current !== active || this.phase === "closed") {
+          this.closeSource(active);
+        }
+        this.publishAvailableCapacity();
+        return opened2;
+      }, (error) => {
+        this.unsettledSourceOpens -= 1;
+        this.publishAvailableCapacity();
+        throw error;
+      });
+      const outcome = await Promise.race([
+        sourceOpening.then((opened2) => ({ outcome: "opened", opened: opened2 })),
+        active.retiredPromise.then(() => ({ outcome: "retired" }))
+      ]);
+      if (outcome.outcome === "retired") {
+        return this.published;
+      }
+      const { opened } = outcome;
+      if (this.current !== active || active.retired || this.phase !== "opening") {
+        this.closeSource(active);
+        return this.published;
+      }
+      this.stored = { hasValue: true, value: opened.snapshot };
+      this.publish();
+      while (this.current === active && !active.retired && this.phase === "opening") {
+        if (active.buffer.getSnapshot().queuedItems === 0) {
+          active.buffer.close({ mode: "discard" });
+          this.phase = "live";
+          this.reason = undefined;
+          return this.publish();
+        }
+        const next = await active.buffer.next();
+        if (next.done)
+          break;
+        this.apply(active, next.value);
+      }
+      if (this.current && this.current !== active && this.opening)
+        return this.opening;
+      return this.published;
+    } catch (error) {
+      if (this.current === active && !active.retired && this.phase !== "closed") {
+        this.reportControllerError(error, this.phase, active.id);
+        this.stopGeneration(active, "unavailable", "source-error");
+      }
+      this.publishAvailableCapacity();
+      return this.published;
+    }
+  }
+  begin(startedByResync) {
+    this.generation += 1;
+    this.phase = "opening";
+    this.reason = undefined;
+    let settleRetired = () => {
+      return;
+    };
+    const retiredPromise = new Promise((resolve) => {
+      settleRetired = resolve;
+    });
+    const active = {
+      id: this.generation,
+      startedByResync,
+      abort: new AbortController,
+      buffer: createBoundedChannel({
+        policy: "ordered",
+        maxItems: this.maxBufferedEvents,
+        maxBytes: this.maxBufferedBytes,
+        sizeOf: this.config.sizeOfEvent
+      }),
+      retiredPromise,
+      settleRetired,
+      retired: false,
+      sourceOpenStarted: false
+    };
+    this.current = active;
+    this.publish();
+    if (this.current !== active || active.retired || this.phase !== "opening") {
+      return this.opening ?? Promise.resolve(this.published);
+    }
+    active.sourceOpenStarted = true;
+    const operation = this.openGeneration(active);
+    this.opening = operation;
+    operation.finally(() => {
+      if (this.opening === operation)
+        this.opening = undefined;
+    });
+    return operation;
+  }
+  close() {
+    if (this.phase === "closed")
+      return Promise.resolve(this.published);
+    const active = this.current;
+    this.current = undefined;
+    this.phase = "closed";
+    this.reason = undefined;
+    const snapshot = this.publish();
+    if (active)
+      this.retire(active);
+    this.config.signal?.removeEventListener("abort", this.abortFromConfig);
+    this.subscribers.clear();
+    return Promise.resolve(snapshot);
+  }
+}
+
+// src/browser/live-state.ts
+var LiveStatePhaseSchema = z2.enum([
+  "idle",
+  "opening",
+  "live",
+  "resync-required",
+  "unavailable",
+  "closed"
+]);
+var LiveStateStopReasonSchema = z2.enum([
+  "gap",
+  "buffer-overflow",
+  "source-unavailable",
+  "source-error",
+  "controller-error",
+  "controller-capacity"
+]);
+var LiveStateControllerStatusSchema = z2.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(),
+  reason: LiveStateStopReasonSchema.optional()
+}).strict().readonly();
+function createLiveStateController(config) {
+  const core = new LiveStateCore(config);
+  return {
+    start: () => core.start(),
+    resync: () => core.resync(),
+    getSnapshot: () => core.published,
+    subscribe(listener) {
+      if (core.phase === "closed")
+        return () => {
+          return;
+        };
+      core.subscribers.add(listener);
+      return () => core.subscribers.delete(listener);
+    },
+    close: () => core.close()
+  };
+}
+
+export { LiveStatePhaseSchema, LiveStateStopReasonSchema, LiveStateControllerStatusSchema, createLiveStateController };

package/dist/index-1zbbzgfh.js

@@ -0,0 +1,89 @@
+import {
+  safeJsonParse
+} from "./index-kzfs85xp.js";
+import {
+  isRecord
+} from "./index-hffjpmq9.js";
+
+// src/tools/schema/coerce.ts
+import { z } from "zod";
+function needsJsonCoercion(schema) {
+  if (schema instanceof z.ZodArray || schema instanceof z.ZodObject || schema instanceof z.ZodRecord || schema instanceof z.ZodTuple || schema instanceof z.ZodUnion) {
+    return true;
+  }
+  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable || schema instanceof z.ZodDefault) {
+    return needsJsonCoercion(schema.unwrap());
+  }
+  return false;
+}
+function acceptsRawString(schema) {
+  const type = schema._zod.def.type;
+  if (type === "string" || type === "template_literal")
+    return true;
+  if (schema instanceof z.ZodLiteral) {
+    return schema.def.values.some((value) => typeof value === "string");
+  }
+  if (schema instanceof z.ZodEnum) {
+    return schema.options.some((value) => typeof value === "string");
+  }
+  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable || schema instanceof z.ZodDefault) {
+    return acceptsRawString(schema.unwrap());
+  }
+  if (schema instanceof z.ZodUnion) {
+    return schema.def.options.some((option) => acceptsRawString(option));
+  }
+  return false;
+}
+function matchingVariant(union, value) {
+  const disc = union.def.discriminator;
+  const tag = value[disc];
+  for (const option of union.def.options) {
+    if (!(option instanceof z.ZodObject))
+      continue;
+    const field = option.shape[disc];
+    if (field instanceof z.ZodLiteral && field.def.values.some((v) => v === tag))
+      return option;
+    if (field instanceof z.ZodEnum && field.options.some((v) => v === tag))
+      return option;
+  }
+  return;
+}
+function coerceValue(value, schema) {
+  if (!schema)
+    return value;
+  if (schema instanceof z.ZodOptional || schema instanceof z.ZodNullable || schema instanceof z.ZodDefault) {
+    return coerceValue(value, schema.unwrap());
+  }
+  let current = value;
+  if (typeof current === "string" && needsJsonCoercion(schema)) {
+    if (acceptsRawString(schema))
+      return current;
+    try {
+      current = safeJsonParse(current);
+    } catch {
+      return value;
+    }
+  }
+  if (schema instanceof z.ZodObject && isRecord(current)) {
+    const shape = schema.shape;
+    const out = {};
+    for (const [key, item] of Object.entries(current)) {
+      out[key] = coerceValue(item, shape[key]);
+    }
+    return out;
+  }
+  if (schema instanceof z.ZodArray && Array.isArray(current)) {
+    return current.map((item) => coerceValue(item, schema.element));
+  }
+  if (schema instanceof z.ZodDiscriminatedUnion && isRecord(current)) {
+    const variant = matchingVariant(schema, current);
+    return variant ? coerceValue(current, variant) : current;
+  }
+  return current;
+}
+function coerceJsonArgs(args, schema) {
+  const coerced = coerceValue(args, schema);
+  return isRecord(coerced) ? coerced : args;
+}
+
+export { coerceJsonArgs };

package/dist/index-2bxbyab0.js

@@ -0,0 +1,47 @@
+import {
+  resolveRouteParamsSchema
+} from "./index-4gcnakhx.js";
+
+// src/contract/runtime-context.ts
+function mergeMeta(contractMeta, endpointMeta) {
+  if (!contractMeta)
+    return endpointMeta;
+  if (!endpointMeta)
+    return { ...contractMeta };
+  return { ...contractMeta, ...endpointMeta };
+}
+
+// src/server/contract-method.ts
+var HTTP_ONLY = Object.freeze(["HTTP"]);
+function contractMethodFields(contract, key, endpoint) {
+  const groupScope = contract.meta.scope ?? "public";
+  return {
+    method: endpoint.method,
+    path: endpoint.path,
+    desc: endpoint.desc,
+    serviceName: contract.meta.prefix,
+    key,
+    toolName: endpoint.tool?.name,
+    expose: endpoint.rawResponse || endpoint.rawBody || endpoint.responseMeta || "stream" in endpoint && endpoint.stream ? HTTP_ONLY : endpoint.expose,
+    scope: endpoint.scope ?? groupScope,
+    paramsSchema: resolveRouteParamsSchema(endpoint.path, endpoint.params),
+    inputSchema: endpoint.input,
+    outputSchema: endpoint.output,
+    toolView: endpoint.tool?.view,
+    stream: "stream" in endpoint ? endpoint.stream : undefined,
+    multipart: endpoint.multipart,
+    maxJsonBodyBytes: endpoint.maxJsonBodyBytes,
+    idempotent: endpoint.idempotent,
+    ui: endpoint.tool?.ui,
+    annotations: endpoint.tool?.annotations,
+    mcp: endpoint.tool?.mcp,
+    meta: mergeMeta(contract.meta.meta, endpoint.meta),
+    rawResponse: endpoint.rawResponse,
+    rawBody: endpoint.rawBody,
+    safelistedBody: endpoint.safelistedBody,
+    responseMeta: endpoint.responseMeta,
+    contentType: "contentType" in endpoint ? endpoint.contentType : undefined
+  };
+}
+
+export { contractMethodFields };