stitchkit 0.94.0 → 0.94.1

package/dist/entrypoints/application.js

@@ -13,7 +13,7 @@ import {
   createActivityProjection,
   createApplicationSnapshotSink,
   createManagedSchedule
-} from "../index-sees8yf8.js";
+} from "../index-ensd0r74.js";
 import {
   DiagnosticJournalCloseResultSchema,
   DiagnosticJournalFailurePhaseSchema,
@@ -36,7 +36,7 @@ import {
   ApplicationShutdownBudgetSchema,
   ApplicationShutdownOptionsSchema,
   createApplication
-} from "../index-fdp6hdxn.js";
+} from "../index-w906953s.js";
 import {
   ApplicationAdmissionSnapshotSchema,
   ApplicationHealthSchema,
@@ -69,8 +69,8 @@ import {
   deltaWins,
   diff,
   watchKeyString
-} from "../index-mdzh02yc.js";
-import"../index-mkm15s49.js";
+} from "../index-wdkt63w3.js";
+import"../index-1j8pm5t0.js";
 import {
   BoundedChannelPolicySchema,
   BoundedChannelReaderError,
@@ -94,6 +94,85 @@ import"../index-kzfs85xp.js";
 import"../index-hffjpmq9.js";
 // src/application/admission.ts
 import { z } from "zod";
+
+// src/application/admission-rate.ts
+function pruneRate(samples, intervalMs, at) {
+  let expired = 0;
+  while (expired < samples.length && at - (samples[expired]?.at ?? at) >= intervalMs) {
+    expired += 1;
+  }
+  if (expired > 0)
+    samples.splice(0, expired);
+}
+function pruneExpired(policy, globalRate, keys, at) {
+  if (policy.global.rate)
+    pruneRate(globalRate, policy.global.rate.intervalMs, at);
+  for (const [key, record] of keys) {
+    if (record.limits?.rate)
+      pruneRate(record.rate, record.limits.rate.intervalMs, at);
+    if (record.active === 0 && record.rate.length === 0)
+      keys.delete(key);
+  }
+}
+function retryAfter(samples, budget, at) {
+  return Math.max(1, Math.ceil(budget.intervalMs - (at - (samples[0]?.at ?? at))));
+}
+function removeSample(samples, sample) {
+  if (!sample)
+    return;
+  const index = samples.indexOf(sample);
+  if (index >= 0)
+    samples.splice(index, 1);
+}
+
+// src/application/admission-run.ts
+async function runAdmitted(acquire, key, work, options) {
+  if (options.timeoutMs !== undefined) {
+    if (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 0) {
+      throw new TypeError("run timeoutMs must be a non-negative safe integer");
+    }
+  }
+  if (options.signal?.aborted)
+    throw new BoundedOperationWaitError("cancelled");
+  const admission = acquire(key);
+  if (admission.outcome === "refused") {
+    throw new BoundedAdmissionRefusalError(admission.reason, admission.retryAfterMs);
+  }
+  const workAbort = new AbortController;
+  const abortWork = () => workAbort.abort(options.signal?.reason);
+  options.signal?.addEventListener("abort", abortWork, { once: true });
+  let timer;
+  let timedOut = false;
+  if (options.timeoutMs !== undefined) {
+    timer = setTimeout(() => {
+      timedOut = true;
+      workAbort.abort(new DOMException("Operation wait timed out", "TimeoutError"));
+    }, options.timeoutMs);
+  }
+  const outcome = Promise.resolve().then(() => work({ signal: workAbort.signal })).then((value) => ({ kind: "value", value }), (error) => ({ kind: "error", error })).finally(() => admission.lease.release());
+  const callerDone = new Promise((resolve) => {
+    const settle = () => resolve({ kind: "caller" });
+    if (workAbort.signal.aborted)
+      settle();
+    else
+      workAbort.signal.addEventListener("abort", settle, { once: true });
+  });
+  try {
+    const settled = await Promise.race([outcome, callerDone]);
+    if (settled.kind === "caller") {
+      throw new BoundedOperationWaitError(timedOut ? "timed-out" : "cancelled");
+    }
+    if (settled.kind === "error")
+      throw settled.error;
+    return settled.value;
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+    options.signal?.removeEventListener("abort", abortWork);
+  }
+}
+
+// src/application/admission.ts
 var PositiveSafeIntegerSchema = z.number().int().positive().safe();
 var BoundedRateBudgetSchema = z.object({
   limit: PositiveSafeIntegerSchema,
@@ -176,22 +255,59 @@ class BoundedOperationWaitError extends Error {
     this.name = "BoundedOperationWaitError";
   }
 }
+var NO_REFUSALS = {
+  "not-accepting": 0,
+  "global-concurrency": 0,
+  "key-required": 0,
+  "key-capacity": 0,
+  "key-concurrency": 0,
+  "global-rate": 0,
+  "key-rate": 0,
+  upstream: 0
+};
+async function waitForDrain(drainWaiters, options) {
+  const controller = new AbortController;
+  let timer;
+  const abort = () => controller.abort();
+  if (options.signal?.aborted)
+    abort();
+  else
+    options.signal?.addEventListener("abort", abort, { once: true });
+  if (options.timeoutMs !== undefined) {
+    if (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 0) {
+      throw new TypeError("drain timeoutMs must be a non-negative safe integer");
+    }
+    timer = setTimeout(abort, options.timeoutMs);
+  }
+  let resolveDrained;
+  try {
+    await Promise.race([
+      new Promise((resolve) => {
+        resolveDrained = resolve;
+        drainWaiters.add(resolve);
+      }),
+      new Promise((resolve) => {
+        if (controller.signal.aborted)
+          resolve();
+        else
+          controller.signal.addEventListener("abort", () => resolve(), { once: true });
+      })
+    ]);
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+    options.signal?.removeEventListener("abort", abort);
+    if (resolveDrained)
+      drainWaiters.delete(resolveDrained);
+  }
+}
 function createBoundedAdmission(config) {
   const policy = BoundedAdmissionPolicySchema.parse(config.policy);
   const clock = config.clock ?? { now: () => performance.now() };
   const keys = new Map;
   const globalRate = [];
   const drainWaiters = new Set;
-  const refusals = {
-    "not-accepting": 0,
-    "global-concurrency": 0,
-    "key-required": 0,
-    "key-capacity": 0,
-    "key-concurrency": 0,
-    "global-rate": 0,
-    "key-rate": 0,
-    upstream: 0
-  };
+  const refusals = { ...NO_REFUSALS };
   let state = "accepting";
   let active = 0;
   let accepted = 0;
@@ -219,26 +335,7 @@ function createBoundedAdmission(config) {
       ...perKey.rate && { rate: perKey.rate }
     });
   };
-  const pruneRate = (samples, intervalMs, at) => {
-    let expired = 0;
-    while (expired < samples.length && at - (samples[expired]?.at ?? at) >= intervalMs) {
-      expired += 1;
-    }
-    if (expired > 0)
-      samples.splice(0, expired);
-  };
-  const prune = (at) => {
-    if (policy.global.rate)
-      pruneRate(globalRate, policy.global.rate.intervalMs, at);
-    for (const [key, record] of keys) {
-      if (record.limits?.rate) {
-        pruneRate(record.rate, record.limits.rate.intervalMs, at);
-      }
-      if (record.active === 0 && record.rate.length === 0)
-        keys.delete(key);
-    }
-  };
-  const retryAfter = (samples, budget, at) => Math.max(1, Math.ceil(budget.intervalMs - (at - (samples[0]?.at ?? at))));
+  const prune = (at) => pruneExpired(policy, globalRate, keys, at);
   const refuse = (reason, retryAfterMs) => {
     refused += 1;
     refusals[reason] += 1;
@@ -260,16 +357,9 @@ function createBoundedAdmission(config) {
     active -= 1;
     if (keyRecord)
       keyRecord.active -= 1;
-    if (globalSample) {
-      const index = globalRate.indexOf(globalSample);
-      if (index >= 0)
-        globalRate.splice(index, 1);
-    }
-    if (keySample && keyRecord) {
-      const index = keyRecord.rate.indexOf(keySample);
-      if (index >= 0)
-        keyRecord.rate.splice(index, 1);
-    }
+    removeSample(globalRate, globalSample);
+    if (keyRecord)
+      removeSample(keyRecord.rate, keySample);
     if (key !== undefined && keyRecord?.active === 0 && keyRecord.rate.length === 0) {
       keys.delete(key);
     }
@@ -368,87 +458,10 @@ function createBoundedAdmission(config) {
     stopAdmission();
     if (active === 0)
       return { drained: true, remaining: 0 };
-    const controller = new AbortController;
-    let timer;
-    const abort = () => controller.abort();
-    if (options.signal?.aborted)
-      abort();
-    else
-      options.signal?.addEventListener("abort", abort, { once: true });
-    if (options.timeoutMs !== undefined) {
-      if (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 0) {
-        throw new TypeError("drain timeoutMs must be a non-negative safe integer");
-      }
-      timer = setTimeout(abort, options.timeoutMs);
-    }
-    let resolveDrained;
-    try {
-      await Promise.race([
-        new Promise((resolve) => {
-          resolveDrained = resolve;
-          drainWaiters.add(resolve);
-        }),
-        new Promise((resolve) => {
-          if (controller.signal.aborted)
-            resolve();
-          else
-            controller.signal.addEventListener("abort", () => resolve(), { once: true });
-        })
-      ]);
-    } finally {
-      if (timer !== undefined)
-        clearTimeout(timer);
-      options.signal?.removeEventListener("abort", abort);
-      if (resolveDrained)
-        drainWaiters.delete(resolveDrained);
-    }
+    await waitForDrain(drainWaiters, options);
     return { drained: active === 0, remaining: active };
   };
-  const run = async (key, work, options = {}) => {
-    if (options.timeoutMs !== undefined) {
-      if (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 0) {
-        throw new TypeError("run timeoutMs must be a non-negative safe integer");
-      }
-    }
-    if (options.signal?.aborted)
-      throw new BoundedOperationWaitError("cancelled");
-    const admission = acquire(key);
-    if (admission.outcome === "refused") {
-      throw new BoundedAdmissionRefusalError(admission.reason, admission.retryAfterMs);
-    }
-    const workAbort = new AbortController;
-    const abortWork = () => workAbort.abort(options.signal?.reason);
-    options.signal?.addEventListener("abort", abortWork, { once: true });
-    let timer;
-    let timedOut = false;
-    if (options.timeoutMs !== undefined) {
-      timer = setTimeout(() => {
-        timedOut = true;
-        workAbort.abort(new DOMException("Operation wait timed out", "TimeoutError"));
-      }, options.timeoutMs);
-    }
-    const outcome = Promise.resolve().then(() => work({ signal: workAbort.signal })).then((value) => ({ kind: "value", value }), (error) => ({ kind: "error", error })).finally(() => admission.lease.release());
-    const callerDone = new Promise((resolve) => {
-      const settle = () => resolve({ kind: "caller" });
-      if (workAbort.signal.aborted)
-        settle();
-      else
-        workAbort.signal.addEventListener("abort", settle, { once: true });
-    });
-    try {
-      const settled = await Promise.race([outcome, callerDone]);
-      if (settled.kind === "caller") {
-        throw new BoundedOperationWaitError(timedOut ? "timed-out" : "cancelled");
-      }
-      if (settled.kind === "error")
-        throw settled.error;
-      return settled.value;
-    } finally {
-      if (timer !== undefined)
-        clearTimeout(timer);
-      options.signal?.removeEventListener("abort", abortWork);
-    }
-  };
+  const run = (key, work, options = {}) => runAdmitted(acquire, key, work, options);
   return {
     acquire,
     run,
@@ -815,37 +828,67 @@ var emptyOutboxState = () => ({
 });
 var sizeOf = (value) => measureSize(value).responseBytes;
 var DEFAULT_OUTBOX_BACKOFF = { minDelayMs: 1000, maxDelayMs: 60000, jitter: 0 };
-function createNotificationOutbox(config) {
-  const schema = notificationOutboxStateSchema(config.payloadSchema);
-  const clock = config.clock ?? (() => new Date);
-  const ownerId = config.ownerId ?? crypto.randomUUID();
+function resolveOutboxLimits(config) {
   const pollIntervalMs = z5.number().int().min(10).parse(config.pollIntervalMs ?? 1000);
   const leaseMs = z5.number().int().min(100).parse(config.leaseMs ?? 30000);
   const maxAttempts = z5.number().int().min(1).max(1e4).parse(config.maxAttempts ?? 100);
   const maxQueue = z5.number().int().min(1).max(1e5).parse(config.maxQueue ?? 1000);
   const maxStateBytes = z5.number().int().min(1024).parse(config.maxStateBytes ?? 1024 * 1024);
   const retainReceipts = z5.number().int().min(0).max(1e5).parse(config.retainReceipts ?? 1000);
+  return { pollIntervalMs, leaseMs, maxAttempts, maxQueue, maxStateBytes, retainReceipts };
+}
+function boundedOutboxState(parsed, maxQueue, retainReceipts, maxStateBytes) {
+  if (parsed.queue.length > maxQueue) {
+    throw new Error(`[stitchkit] notification outbox queue limit (${maxQueue}) exceeded`);
+  }
+  let receipts = parsed.receipts.slice(0, retainReceipts);
+  let next = { ...parsed, receipts };
+  while (sizeOf(next) > maxStateBytes && receipts.length > 0) {
+    receipts = receipts.slice(0, -1);
+    next = { ...parsed, receipts };
+  }
+  if (sizeOf(next) > maxStateBytes) {
+    throw new Error(`[stitchkit] notification outbox state limit (${maxStateBytes} bytes) exceeded`);
+  }
+  return next;
+}
+function dropReason(classification, attempts, maxAttempts) {
+  if (classification.recipientUnreachable === true)
+    return "recipient-unreachable";
+  if (!classification.retryable)
+    return "terminal";
+  return attempts >= maxAttempts ? "attempt-limit" : null;
+}
+var RetryDelaySchema = z5.number().nonnegative().max(24 * 60 * 60 * 1000);
+var NO_LEASE = { leaseOwner: null, leaseId: null, leaseUntil: null };
+function claimDue(queue, now, ownerId, leaseMs) {
+  const candidate = [...queue].sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt)).find((item) => Date.parse(item.nextAttemptAt) <= now.getTime() && (item.leaseUntil === null || Date.parse(item.leaseUntil) <= now.getTime()));
+  if (!candidate)
+    return null;
+  return {
+    ...candidate,
+    attempts: candidate.attempts + 1,
+    leaseOwner: ownerId,
+    leaseId: crypto.randomUUID(),
+    leaseUntil: new Date(now.getTime() + leaseMs).toISOString()
+  };
+}
+async function reportOutboxError(config, error) {
+  try {
+    await config.onError?.(error);
+  } catch {}
+}
+function createNotificationOutbox(config) {
+  const schema = notificationOutboxStateSchema(config.payloadSchema);
+  const clock = config.clock ?? (() => new Date);
+  const ownerId = config.ownerId ?? crypto.randomUUID();
+  const { pollIntervalMs, leaseMs, maxAttempts, maxQueue, maxStateBytes, retainReceipts } = resolveOutboxLimits(config);
   const backoffMs = config.backoffMs ?? ((attempt) => backoffDelay(DEFAULT_OUTBOX_BACKOFF, attempt));
   let timer;
   let running = false;
   let interrupted = false;
   let flushTail = Promise.resolve();
-  const bounded = (input) => {
-    const parsed = schema.parse(input);
-    if (parsed.queue.length > maxQueue) {
-      throw new Error(`[stitchkit] notification outbox queue limit (${maxQueue}) exceeded`);
-    }
-    let receipts = parsed.receipts.slice(0, retainReceipts);
-    let next = { ...parsed, receipts };
-    while (sizeOf(next) > maxStateBytes && receipts.length > 0) {
-      receipts = receipts.slice(0, -1);
-      next = { ...parsed, receipts };
-    }
-    if (sizeOf(next) > maxStateBytes) {
-      throw new Error(`[stitchkit] notification outbox state limit (${maxStateBytes} bytes) exceeded`);
-    }
-    return next;
-  };
+  const bounded = (input) => boundedOutboxState(schema.parse(input), maxQueue, retainReceipts, maxStateBytes);
   const parse = (state) => schema.parse(state ?? emptyOutboxState());
   const enqueue = async (input) => {
     const key = z5.string().min(1).max(512).parse(input.key);
@@ -857,18 +900,10 @@ function createNotificationOutbox(config) {
         return { state, result: false };
       }
       const now = clock().toISOString();
+      const fresh = { key, payload, createdAt: now, attempts: 0, nextAttemptAt: now };
       const queue = [
         ...state.queue.filter((item) => !supersedes.has(item.key)),
-        {
-          key,
-          payload,
-          createdAt: now,
-          attempts: 0,
-          nextAttemptAt: now,
-          leaseOwner: null,
-          leaseId: null,
-          leaseUntil: null
-        }
+        { ...fresh, ...NO_LEASE }
       ];
       const next = bounded({ ...state, queue });
       return { state: next, result: true };
@@ -878,21 +913,13 @@ function createNotificationOutbox(config) {
     const now = clock();
     return config.store.update((current) => {
       const state = parse(current);
-      const candidate = [...state.queue].sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt)).find((item) => Date.parse(item.nextAttemptAt) <= now.getTime() && (item.leaseUntil === null || Date.parse(item.leaseUntil) <= now.getTime()));
-      if (!candidate)
+      const claimed = claimDue(state.queue, now, ownerId, leaseMs);
+      if (!claimed)
         return { state, result: null };
-      const leaseId = crypto.randomUUID();
-      const claimed = {
-        ...candidate,
-        attempts: candidate.attempts + 1,
-        leaseOwner: ownerId,
-        leaseId,
-        leaseUntil: new Date(now.getTime() + leaseMs).toISOString()
-      };
       return {
         state: bounded({
           ...state,
-          queue: state.queue.map((item) => item.key === candidate.key ? claimed : item)
+          queue: state.queue.map((item) => item.key === claimed.key ? claimed : item)
         }),
         result: claimed
       };
@@ -926,7 +953,7 @@ function createNotificationOutbox(config) {
       if (!live)
         return { state, result: null };
       const attempts = live.attempts;
-      const reason = classification.recipientUnreachable === true ? "recipient-unreachable" : !classification.retryable ? "terminal" : attempts >= maxAttempts ? "attempt-limit" : null;
+      const reason = dropReason(classification, attempts, maxAttempts);
       if (reason) {
         return {
           state: bounded({
@@ -936,15 +963,11 @@ function createNotificationOutbox(config) {
           result: { item: { ...live, attempts }, error, reason }
         };
       }
-      const rawDelay = backoffMs(attempts);
-      const wait = z5.number().finite().nonnegative().max(24 * 60 * 60 * 1000).parse(rawDelay);
+      const wait = RetryDelaySchema.parse(backoffMs(attempts));
       const retry = {
         ...live,
-        attempts,
         nextAttemptAt: new Date(clock().getTime() + wait).toISOString(),
-        leaseOwner: null,
-        leaseId: null,
-        leaseUntil: null
+        ...NO_LEASE
       };
       return {
         state: bounded({
@@ -990,9 +1013,7 @@ function createNotificationOutbox(config) {
     try {
       await flush();
     } catch (error) {
-      try {
-        await config.onError?.(error);
-      } catch {}
+      await reportOutboxError(config, error);
     } finally {
       schedule();
     }
@@ -1552,59 +1573,60 @@ function managedServerResource(config) {
     }
   });
 }
-// src/application/watch-hub.ts
+// src/application/watch-hub-core.ts
 var DEFAULT_BACKOFF = { minDelayMs: 250, maxDelayMs: 30000, jitter: 0.2 };
-function watchKey(operation, args) {
-  const record = typeof args === "object" && args !== null && !Array.isArray(args) ? args : { value: args };
-  return {
-    service: operation.service,
-    action: operation.action,
-    digest: argumentsDigest(record)
-  };
-}
-function createWatchHub(config) {
-  const sources = new Map;
-  const held = new Map;
-  const maxWatches = config.maxWatchesPerSubscriber ?? 64;
-  const holdMs = config.holdMs ?? 0;
-  const deltaMemoryBytes = config.deltaMemoryBytes ?? 262144;
-  const same = config.same ?? ((previous, next) => serializeCanonicalJson(previous) === serializeCanonicalJson(next));
-  let reads = 0;
-  let closed = false;
-  function tell(key, deliver2) {
+
+class WatchHubCore {
+  config;
+  sources = new Map;
+  held = new Map;
+  maxWatches;
+  holdMs;
+  deltaMemoryBytes;
+  same;
+  reads = 0;
+  closed = false;
+  constructor(config) {
+    this.config = config;
+    this.maxWatches = config.maxWatchesPerSubscriber ?? 64;
+    this.holdMs = config.holdMs ?? 0;
+    this.deltaMemoryBytes = config.deltaMemoryBytes ?? 262144;
+    this.same = config.same ?? ((previous, next) => serializeCanonicalJson(previous) === serializeCanonicalJson(next));
+  }
+  tell(key, send) {
     try {
-      deliver2();
+      send();
       return true;
     } catch (error) {
-      config.logger?.warn?.("[stitchkit] watch subscriber threw", {
+      this.config.logger?.warn?.("[stitchkit] watch subscriber threw", {
         key: watchKeyString(key),
         error: error instanceof Error ? error.message : String(error)
       });
       return false;
     }
   }
-  function announceState(source, state) {
+  announceState(source, state) {
     source.state = state;
     for (const subscriber of source.subscribers) {
-      tell(source.key, () => subscriber.state(state));
+      this.tell(source.key, () => subscriber.state(state));
     }
   }
-  function remember(source, revision, value, fingerprint) {
-    if (deltaMemoryBytes === 0)
+  remember(source, revision, value, fingerprint) {
+    if (this.deltaMemoryBytes === 0)
       return;
     const bytes = (JSON.stringify(value) ?? "null").length;
-    if (bytes > deltaMemoryBytes)
+    if (bytes > this.deltaMemoryBytes)
       return;
     source.history.set(revision, { value, fingerprint, bytes });
     source.historyBytes += bytes;
     for (const [oldest, entry] of source.history) {
-      if (source.historyBytes <= deltaMemoryBytes)
+      if (source.historyBytes <= this.deltaMemoryBytes)
         break;
       source.history.delete(oldest);
       source.historyBytes -= entry.bytes;
     }
   }
-  function frameFor(source, subscriber) {
+  frameFor(source, subscriber) {
     const value = source.value;
     const fingerprint = source.fingerprint ?? valueFingerprint(value);
     const full = {
@@ -1620,10 +1642,10 @@ function createWatchHub(config) {
     if (base === source.revision) {
       return { kind: "unchanged", key: source.key, revision: source.revision, fingerprint };
     }
-    const held2 = source.history.get(base);
-    if (!held2)
+    const held = source.history.get(base);
+    if (!held)
       return full;
-    const delta = diff(held2.value, value);
+    const delta = diff(held.value, value);
     if (delta === undefined || !deltaWins(delta, value))
       return full;
     return {
@@ -1635,7 +1657,7 @@ function createWatchHub(config) {
       delta
     };
   }
-  function adoptBaseline(source, subscriber, have) {
+  adoptBaseline(source, subscriber, have) {
     if (source.fingerprint === have.fingerprint) {
       source.baselines.set(subscriber, source.revision);
       return;
@@ -1652,56 +1674,56 @@ function createWatchHub(config) {
       return;
     }
   }
-  function deliver(source, subscriber) {
-    const frame = frameFor(source, subscriber);
-    const delivered = tell(source.key, () => subscriber.value(frame));
+  deliver(source, subscriber) {
+    const frame = this.frameFor(source, subscriber);
+    const delivered = this.tell(source.key, () => subscriber.value(frame));
     if (delivered)
       source.baselines.set(subscriber, source.revision);
     return delivered;
   }
-  function publish(source, value, fingerprint) {
+  publish(source, value, fingerprint) {
     if (source.fingerprint !== undefined) {
-      remember(source, source.revision, source.value, source.fingerprint);
+      this.remember(source, source.revision, source.value, source.fingerprint);
     }
     source.revision += 1;
     source.value = value;
     source.fingerprint = fingerprint;
     for (const subscriber of source.subscribers)
-      deliver(source, subscriber);
+      this.deliver(source, subscriber);
   }
-  async function pump(source) {
-    if (source.reading || closed)
+  async pump(source) {
+    if (source.reading || this.closed)
       return;
     source.reading = true;
     try {
-      while (source.dirty && !closed) {
+      while (source.dirty && !this.closed) {
         source.dirty = false;
-        reads += 1;
+        this.reads += 1;
         try {
-          const value = await config.read(source.operation, source.args);
+          const value = await this.config.read(source.operation, source.args);
           source.backoff.reset();
           const signature = serializeCanonicalJson(value);
-          const unchanged = source.signature !== undefined && same(source.value, value);
+          const unchanged = source.signature !== undefined && this.same(source.value, value);
           source.signature = signature;
           if (!unchanged)
-            publish(source, value, valueFingerprint(value));
+            this.publish(source, value, valueFingerprint(value));
           if (source.state.phase !== "live") {
-            announceState(source, { key: source.key, phase: "live" });
+            this.announceState(source, { key: source.key, phase: "live" });
           }
         } catch (error) {
           const code = readErrorCode(error);
-          announceState(source, {
+          this.announceState(source, {
             key: source.key,
             phase: "unavailable",
             reason: "source-error",
             ...code !== undefined && { code },
             message: error instanceof Error ? error.message : String(error)
           });
-          config.logger?.warn?.("[stitchkit] watched read failed", {
+          this.config.logger?.warn?.("[stitchkit] watched read failed", {
             key: watchKeyString(source.key),
             error
           });
-          scheduleRetry(source);
+          this.scheduleRetry(source);
           return;
         }
       }
@@ -1709,19 +1731,19 @@ function createWatchHub(config) {
       source.reading = false;
     }
   }
-  function scheduleRetry(source) {
-    if (closed || source.subscribers.size === 0)
+  scheduleRetry(source) {
+    if (this.closed || source.subscribers.size === 0)
       return;
     clearTimeout(source.retry);
     source.retry = setTimeout(() => {
       source.dirty = true;
-      pump(source);
+      this.pump(source);
     }, source.backoff.next());
     source.retry.unref?.();
   }
-  function acquire(operation, key, args) {
+  acquire(operation, key, args) {
     const id = watchKeyString(key);
-    const existing = sources.get(id);
+    const existing = this.sources.get(id);
     if (existing) {
       clearTimeout(existing.release);
       existing.release = undefined;
@@ -1740,18 +1762,18 @@ function createWatchHub(config) {
       reading: false,
       dirty: true,
       state: { key, phase: "opening" },
-      backoff: createBackoff(config.backoff ?? DEFAULT_BACKOFF)
+      backoff: createBackoff(this.config.backoff ?? DEFAULT_BACKOFF)
     };
-    for (const topic of config.invalidatedBy(operation, args)) {
-      source.unsubscribes.push(config.subscribe(topic, () => {
+    for (const topic of this.config.invalidatedBy(operation, args)) {
+      source.unsubscribes.push(this.config.subscribe(topic, () => {
         source.dirty = true;
-        pump(source);
+        this.pump(source);
       }));
     }
-    sources.set(id, source);
+    this.sources.set(id, source);
     return source;
   }
-  function release(source) {
+  release(source) {
     if (source.subscribers.size > 0)
       return;
     clearTimeout(source.retry);
@@ -1764,109 +1786,105 @@ function createWatchHub(config) {
       }
       for (const unsubscribe of source.unsubscribes)
         unsubscribe();
-      sources.delete(watchKeyString(source.key));
+      this.sources.delete(watchKeyString(source.key));
     };
-    if (holdMs === 0) {
+    if (this.holdMs === 0) {
       drop();
       return;
     }
-    source.release = setTimeout(drop, holdMs);
+    source.release = setTimeout(drop, this.holdMs);
     source.release.unref?.();
   }
-  return {
-    attach(subscriber) {
-      const keys = new Set;
-      held.set(subscriber, keys);
-      return {
-        open(key, args, have) {
-          if (closed)
-            return { accepted: false, reason: "the watch hub is closed" };
-          const operation = { service: key.service, action: key.action };
-          if (!config.watchable(operation)) {
-            return {
-              accepted: false,
-              reason: `${key.service}.${key.action} is not watchable`
-            };
-          }
-          const id = watchKeyString(key);
-          if (keys.has(id))
-            return { accepted: true };
-          if (keys.size >= maxWatches) {
-            return {
-              accepted: false,
-              reason: `this connection is already watching ${keys.size} reads (limit ${maxWatches})`
-            };
-          }
-          const source = acquire(operation, key, args);
-          source.subscribers.add(subscriber);
-          keys.add(id);
-          if (have)
-            adoptBaseline(source, subscriber, have);
-          try {
-            if (source.signature !== undefined) {
-              const frame = frameFor(source, subscriber);
-              subscriber.value(frame);
-              source.baselines.set(subscriber, source.revision);
-            }
-            subscriber.state(source.state);
-          } catch (error) {
-            source.subscribers.delete(subscriber);
-            source.baselines.delete(subscriber);
-            keys.delete(id);
-            release(source);
-            return {
-              accepted: false,
-              reason: error instanceof Error ? error.message : String(error)
-            };
-          }
-          pump(source);
+  attach(subscriber) {
+    const keys = new Set;
+    this.held.set(subscriber, keys);
+    return {
+      open: (key, args, have) => {
+        if (this.closed)
+          return { accepted: false, reason: "the watch hub is closed" };
+        const operation = { service: key.service, action: key.action };
+        if (!this.config.watchable(operation)) {
+          return {
+            accepted: false,
+            reason: `${key.service}.${key.action} is not watchable`
+          };
+        }
+        const id = watchKeyString(key);
+        if (keys.has(id))
           return { accepted: true };
-        },
-        close(key) {
-          const id = watchKeyString(key);
-          if (!keys.delete(id))
-            return;
-          const source = sources.get(id);
+        if (keys.size >= this.maxWatches) {
+          return {
+            accepted: false,
+            reason: `this connection is already watching ${keys.size} reads (limit ${this.maxWatches})`
+          };
+        }
+        const source = this.acquire(operation, key, args);
+        source.subscribers.add(subscriber);
+        keys.add(id);
+        if (have)
+          this.adoptBaseline(source, subscriber, have);
+        try {
+          if (source.signature !== undefined) {
+            const frame = this.frameFor(source, subscriber);
+            subscriber.value(frame);
+            source.baselines.set(subscriber, source.revision);
+          }
+          subscriber.state(source.state);
+        } catch (error) {
+          source.subscribers.delete(subscriber);
+          source.baselines.delete(subscriber);
+          keys.delete(id);
+          this.release(source);
+          return {
+            accepted: false,
+            reason: error instanceof Error ? error.message : String(error)
+          };
+        }
+        this.pump(source);
+        return { accepted: true };
+      },
+      close: (key) => {
+        const id = watchKeyString(key);
+        if (!keys.delete(id))
+          return;
+        const source = this.sources.get(id);
+        if (!source)
+          return;
+        source.subscribers.delete(subscriber);
+        source.baselines.delete(subscriber);
+        this.release(source);
+      },
+      detach: () => {
+        for (const id of keys) {
+          const source = this.sources.get(id);
           if (!source)
-            return;
+            continue;
           source.subscribers.delete(subscriber);
           source.baselines.delete(subscriber);
-          release(source);
-        },
-        detach() {
-          for (const id of keys) {
-            const source = sources.get(id);
-            if (!source)
-              continue;
-            source.subscribers.delete(subscriber);
-            source.baselines.delete(subscriber);
-            release(source);
-          }
-          keys.clear();
-          held.delete(subscriber);
+          this.release(source);
         }
-      };
-    },
-    readCount: () => reads,
-    size: () => sources.size,
-    close() {
-      closed = true;
-      const teardown = [...sources.values()];
-      sources.clear();
-      held.clear();
-      for (const source of teardown) {
-        clearTimeout(source.retry);
-        clearTimeout(source.release);
-        announceState(source, {
-          key: source.key,
-          phase: "unavailable",
-          reason: "source-unavailable"
-        });
-        for (const unsubscribe of source.unsubscribes)
-          unsubscribe();
+        keys.clear();
+        this.held.delete(subscriber);
       }
+    };
+  }
+  close() {
+    this.closed = true;
+    const teardown = [...this.sources.values()];
+    this.sources.clear();
+    this.held.clear();
+    for (const source of teardown) {
+      clearTimeout(source.retry);
+      clearTimeout(source.release);
+      this.announceState(source, {
+        key: source.key,
+        phase: "unavailable",
+        reason: "source-unavailable"
+      });
+      for (const unsubscribe of source.unsubscribes)
+        unsubscribe();
     }
-  };
+  }
 }
 function valueFingerprint(value) {
   return argumentsDigest({ value });
@@ -1877,6 +1895,25 @@ function readErrorCode(error) {
   const code = Reflect.get(error, "code");
   return typeof code === "string" ? code : undefined;
 }
+
+// src/application/watch-hub.ts
+function watchKey(operation, args) {
+  const record = typeof args === "object" && args !== null && !Array.isArray(args) ? args : { value: args };
+  return {
+    service: operation.service,
+    action: operation.action,
+    digest: argumentsDigest(record)
+  };
+}
+function createWatchHub(config) {
+  const hub = new WatchHubCore(config);
+  return {
+    attach: (subscriber) => hub.attach(subscriber),
+    readCount: () => hub.reads,
+    size: () => hub.sources.size,
+    close: () => hub.close()
+  };
+}
 export {
   watchKey,
   transitionProcessStart,