stitchkit 0.94.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/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-kvj7f4hq.js → index-2bxbyab0.js}

@@ -1,7 +1,15 @@
 import {
-  mergeMeta,
   resolveRouteParamsSchema
-} from "./index-gyr48nzg.js";
+} 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"]);

package/dist/{index-xnj9bgxe.js → index-2gxzjvyr.js}

@@ -1,16 +1,11 @@
 import {
   contractMethodFields
-} from "./index-kvj7f4hq.js";
+} from "./index-2bxbyab0.js";
 import {
   AppError
 } from "./index-2vtcmrj9.js";
-import {
-  isUnsafeKey
-} from "./index-kzfs85xp.js";
 import {
   callRuntimeHandler,
-  isRecord,
-  transportResult,
   typedEntries
 } from "./index-hffjpmq9.js";
 
@@ -233,161 +228,6 @@ function createScopedImplement() {
   const declare = (_contract) => (handlers) => handlers;
   return Object.assign(implementScoped, { stream, declare });
 }
-function createScopedImplementRegistry() {
-  return (contracts, handlers, options) => transportResult(bindRegistry(contracts, handlers, options));
-}
-function isImplementationContract(value) {
-  return isRecord(value) && isRecord(value.meta) && typeof value.meta.prefix === "string" && isRecord(value.endpoints);
-}
-function bindRegistry(contracts, handlers, options) {
-  const contractKeys = Object.keys(contracts);
-  const handlerKeys = Object.keys(handlers);
-  const missing = contractKeys.filter((key) => !Object.hasOwn(handlers, key));
-  const extra = handlerKeys.filter((key) => !Object.hasOwn(contracts, key));
-  if (missing.length > 0 || extra.length > 0) {
-    if (options?.onMissingHandler !== "stub") {
-      throw new Error(`[stitchkit] implementRegistry: registry mismatch (missing: ${missing.join(", ") || "none"}; extra: ${extra.join(", ") || "none"})`);
-    }
-    console.warn(`[stitchkit] implementRegistry: registry mismatch (missing: ${missing.join(", ") || "none"}; extra: ${extra.join(", ") || "none"}) — missing contracts are mounted as 501 stubs and extra handlers are ignored`);
-  }
-  const prefixes = new Map;
-  const services = [];
-  const byKey = {};
-  for (const [key, candidate] of Object.entries(contracts)) {
-    if (!isImplementationContract(candidate)) {
-      throw new TypeError(`[stitchkit] implementRegistry: registry entry "${key}" must be one contract; composed arrays and namespaces are not supported`);
-    }
-    const contract = candidate;
-    const groupScope = contract.meta.scope ?? "public";
-    const identity = `${groupScope}\x00${contract.meta.prefix}`;
-    const previousKey = prefixes.get(identity);
-    if (previousKey !== undefined) {
-      throw new Error(`[stitchkit] implementRegistry: duplicate contract prefix "${contract.meta.prefix}" in scope "${groupScope}" at "${previousKey}" and "${key}"`);
-    }
-    prefixes.set(identity, key);
-    const entryHandlers = handlers[key] === undefined && options?.onMissingHandler === "stub" ? {} : handlers[key];
-    if (!isRecord(entryHandlers)) {
-      throw new TypeError(`[stitchkit] implementRegistry: handlers for "${key}" must be an object`);
-    }
-    const endpointKeys = Object.keys(contract.endpoints);
-    const handlerEntryKeys = Object.keys(entryHandlers);
-    const missingEndpoints = endpointKeys.filter((endpointKey) => !Object.hasOwn(entryHandlers, endpointKey));
-    const extraEndpoints = handlerEntryKeys.filter((endpointKey) => !Object.hasOwn(contract.endpoints, endpointKey));
-    if (missingEndpoints.length > 0 || extraEndpoints.length > 0) {
-      const detail = `handlers for "${key}" mismatch (missing: ${missingEndpoints.join(", ") || "none"}; extra: ${extraEndpoints.join(", ") || "none"})`;
-      if (options?.onMissingHandler !== "stub") {
-        throw new Error(`[stitchkit] implementRegistry: ${detail}`);
-      }
-      console.warn(`[stitchkit] implementRegistry: ${detail} — missing endpoints are mounted as 501 stubs and extra handlers are ignored`);
-    }
-    const service = bindContract(contract, entryHandlers, options);
-    services.push(service);
-    byKey[key] = service;
-  }
-  Object.defineProperty(services, "byKey", { value: byKey, enumerable: false });
-  return transportResult(services);
-}
-function implementRegistry(contracts, handlers, options) {
-  return transportResult(bindRegistry(contracts, handlers, options));
-}
-function createImplementRegistry() {
-  return (contracts, handlers, options) => transportResult(bindRegistry(contracts, handlers, options));
-}
-
-// src/server/context-contribution.ts
-var RUNTIME_CONTEXT_RESERVED_KEYS = new Set([
-  "params",
-  "input",
-  "files",
-  "rawBody",
-  "source",
-  "req",
-  "url",
-  "headers",
-  "traceId",
-  "spanId",
-  "ipAddress",
-  "userAgent",
-  "signal",
-  "mcp",
-  "reportProgress"
-]);
-function contributionError(scope, reason) {
-  return new TypeError(`[stitchkit] auth: invalid context contribution for scope ${JSON.stringify(scope)}: ${reason}`);
-}
-function descriptorsEqual(left, right) {
-  if (!left || !right)
-    return left === right;
-  if (left.enumerable !== right.enumerable || left.configurable !== right.configurable || left.writable !== right.writable) {
-    return false;
-  }
-  if ("value" in left || "value" in right) {
-    return "value" in left && "value" in right && Object.is(left.value, right.value);
-  }
-  return left.get === right.get && left.set === right.set;
-}
-function contextContributionDelta(original, shadow, scope) {
-  if (Object.getPrototypeOf(shadow) !== Object.getPrototypeOf(original)) {
-    throw contributionError(scope, "context prototype changes are not supported");
-  }
-  const originalKeys = Reflect.ownKeys(original);
-  const shadowKeys = Reflect.ownKeys(shadow);
-  const shadowKeySet = new Set(shadowKeys);
-  for (const key of originalKeys) {
-    if (!shadowKeySet.has(key)) {
-      const printable = typeof key === "string" ? JSON.stringify(key) : "a symbol key";
-      throw contributionError(scope, `context key ${printable} may not be deleted`);
-    }
-  }
-  const contribution = Object.create(null);
-  for (const key of shadowKeys) {
-    const originalDescriptor = Object.getOwnPropertyDescriptor(original, key);
-    const shadowDescriptor = Object.getOwnPropertyDescriptor(shadow, key);
-    if (!shadowDescriptor || descriptorsEqual(originalDescriptor, shadowDescriptor))
-      continue;
-    Object.defineProperty(contribution, key, shadowDescriptor);
-  }
-  return contribution;
-}
-function prepareContextContribution(value, scope) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw contributionError(scope, "expected a plain record");
-  }
-  let prototype;
-  let descriptors;
-  let keys;
-  try {
-    prototype = Object.getPrototypeOf(value);
-    descriptors = Object.getOwnPropertyDescriptors(value);
-    keys = Reflect.ownKeys(value);
-  } catch {
-    throw contributionError(scope, "record inspection failed");
-  }
-  if (prototype !== Object.prototype && prototype !== null) {
-    throw contributionError(scope, "expected Object.prototype or null prototype");
-  }
-  const prepared = Object.create(null);
-  for (const key of keys) {
-    if (typeof key !== "string") {
-      throw contributionError(scope, "symbol keys are not supported");
-    }
-    if (isUnsafeKey(key)) {
-      throw contributionError(scope, `unsafe key ${JSON.stringify(key)}`);
-    }
-    if (RUNTIME_CONTEXT_RESERVED_KEYS.has(key)) {
-      throw contributionError(scope, `reserved key ${JSON.stringify(key)}`);
-    }
-    const descriptor = descriptors[key];
-    if (!descriptor?.enumerable || !("value" in descriptor)) {
-      throw contributionError(scope, `key ${JSON.stringify(key)} must be enumerable data`);
-    }
-    prepared[key] = descriptor.value;
-  }
-  return prepared;
-}
-function mergeContextContribution(ctx, value, scope) {
-  Object.assign(ctx, prepareContextContribution(value, scope));
-}
 
 // src/server/process-signal-common.ts
 var DEFAULT_PROCESS_SIGNALS = ["SIGINT", "SIGTERM"];
@@ -423,4 +263,4 @@ function mediaTypeEssence(contentType) {
   return (contentType ?? "").split(";", 1)[0]?.trim().toLowerCase() ?? "";
 }
 
-export { DEFAULT_CORS_ALLOW_HEADERS, DEFAULT_CORS_EXPOSE_HEADERS, assertCorsConfig, isOriginAllowed, corsHeaders, corsPreflightResponse, requestCorsHeaders, applyCors, RUNTIME_CONTEXT_RESERVED_KEYS, contextContributionDelta, prepareContextContribution, mergeContextContribution, defineMultipartStream, createMultipartStream, contractOnlyService, implement, createImplement, createScopedImplement, createScopedImplementRegistry, implementRegistry, createImplementRegistry, DEFAULT_PROCESS_SIGNALS, defaultSignalSource, reportSignalError, guardSignalCallback, mediaTypeEssence };
+export { DEFAULT_CORS_ALLOW_HEADERS, DEFAULT_CORS_EXPOSE_HEADERS, assertCorsConfig, isOriginAllowed, corsHeaders, corsPreflightResponse, requestCorsHeaders, applyCors, defineMultipartStream, createMultipartStream, contractOnlyService, bindContract, implement, createImplement, createScopedImplement, DEFAULT_PROCESS_SIGNALS, defaultSignalSource, reportSignalError, guardSignalCallback, mediaTypeEssence };