stitchkit 0.94.0 → 0.95.0

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();
     }
@@ -1047,21 +1068,28 @@ function notificationOutboxResource(outbox, config = {}) {
   });
 }
 // src/application/process-lifecycle.ts
+import { z as z7 } from "zod";
+
+// src/application/process-lifecycle-transitions.ts
 import { z as z6 } from "zod";
 var LifecycleTerminationSchema = z6.enum([
   "active",
+  "draining",
   "clean",
   "forced",
+  "startup-failed",
   "hot-reload",
   "abnormal"
 ]);
+var timestamp = z6.string().datetime({ offset: true });
 var LifecycleRunSchema = z6.object({
   runId: z6.string().min(1).max(128),
   pid: z6.number().int().positive(),
   version: z6.string().min(1).max(256),
-  startedAt: z6.string().datetime({ offset: true }),
-  readyAt: z6.string().datetime({ offset: true }).nullable(),
-  stoppedAt: z6.string().datetime({ offset: true }).nullable(),
+  startedAt: timestamp,
+  readyAt: timestamp.nullable(),
+  unavailableAt: timestamp.nullable().default(null),
+  stoppedAt: timestamp.nullable(),
   termination: LifecycleTerminationSchema
 }).strict();
 var LifecycleStateSchema = z6.object({
@@ -1073,17 +1101,20 @@ var PreviousExitSchema = z6.enum([
   "hot-reload",
   "clean",
   "forced",
+  "startup-failed",
   "handoff",
   "abnormal"
 ]);
 var emptyState = () => ({ schemaVersion: 1, runs: [] });
 var epoch = (value) => Date.parse(value);
 var elapsed = (later, earlier) => Math.max(0, epoch(later) - epoch(earlier));
-function normalize(state, retain) {
+var isOpenRun = (run) => run.termination === "active" || run.termination === "draining";
+function normalizeLifecycleState(state, retain) {
   const parsed = LifecycleStateSchema.parse(state ?? emptyState());
   const runs = [...parsed.runs];
   for (let index = runs.length - 1;runs.length > retain && index >= 0; index -= 1) {
-    if (runs[index]?.termination !== "active")
+    const run = runs[index];
+    if (run && !isOpenRun(run))
       runs.splice(index, 1);
   }
   return { schemaVersion: 1, runs: runs.slice(0, retain) };
@@ -1092,15 +1123,45 @@ var UNKNOWN_VERSION = "unknown";
 function isVersionChange(previous, next) {
   return previous !== UNKNOWN_VERSION && next !== UNKNOWN_VERSION && previous !== next;
 }
+var RetainSchema = z6.number().int().min(1).max(1000);
+function previousExitOf(previous, run, overlap) {
+  if (!previous)
+    return "first-boot";
+  const ended = previous.termination;
+  if (ended !== "active" && ended !== "draining")
+    return ended;
+  if (previous.pid === run.pid)
+    return "hot-reload";
+  if (isVersionChange(previous.version, run.version) || overlap === "handoff")
+    return "handoff";
+  return previous.readyAt === null ? "startup-failed" : "abnormal";
+}
+function closeAbandoned(candidate, previous, previousExit, run, overlap) {
+  if (!isOpenRun(candidate))
+    return candidate;
+  const closed = { ...candidate, stoppedAt: run.startedAt };
+  if (candidate.pid === run.pid)
+    return { ...closed, termination: "hot-reload" };
+  if (overlap === "handoff")
+    return candidate;
+  if (candidate.runId === previous?.runId && previousExit === "handoff")
+    return candidate;
+  return {
+    ...closed,
+    termination: candidate.readyAt === null ? "startup-failed" : "abnormal"
+  };
+}
 function transitionProcessStart(source, input) {
-  const retain = z6.number().int().min(1).max(1000).parse(input.retain ?? 20);
-  const state = normalize(source, 1000);
+  const retain = RetainSchema.parse(input.retain ?? 20);
+  const overlap = input.sameVersionOverlap ?? "abnormal";
+  const state = normalizeLifecycleState(source, 1000);
   const run = LifecycleRunSchema.parse({
     runId: input.runId,
     pid: input.pid,
     version: input.version,
     startedAt: input.now,
     readyAt: null,
+    unavailableAt: null,
     stoppedAt: null,
     termination: "active"
   });
@@ -1108,31 +1169,10 @@ function transitionProcessStart(source, input) {
     throw new Error(`[stitchkit] lifecycle run id already exists: ${run.runId}`);
   }
   const previous = state.runs[0] ?? null;
-  let previousExit = "first-boot";
-  let downtimeMs = null;
-  if (previous?.stoppedAt) {
-    previousExit = previous.termination === "forced" || previous.termination === "abnormal" || previous.termination === "hot-reload" ? previous.termination : "clean";
-    downtimeMs = elapsed(run.startedAt, previous.stoppedAt);
-  } else if (previous) {
-    if (previous.pid === run.pid)
-      previousExit = "hot-reload";
-    else if (isVersionChange(previous.version, run.version))
-      previousExit = "handoff";
-    else
-      previousExit = input.sameVersionOverlap ?? "abnormal";
-  }
-  const runs = state.runs.map((candidate) => {
-    if (candidate.runId !== previous?.runId || candidate.termination !== "active")
-      return candidate;
-    if (previousExit === "hot-reload") {
-      return { ...candidate, stoppedAt: run.startedAt, termination: "hot-reload" };
-    }
-    if (previousExit === "abnormal") {
-      return { ...candidate, stoppedAt: run.startedAt, termination: "abnormal" };
-    }
-    return candidate;
-  });
-  const next = normalize({ schemaVersion: 1, runs: [run, ...runs] }, retain);
+  const previousExit = previousExitOf(previous, run, overlap);
+  const processGapMs = previous && !isOpenRun(previous) && previous.stoppedAt ? elapsed(run.startedAt, previous.stoppedAt) : null;
+  const runs = state.runs.map((candidate) => closeAbandoned(candidate, previous, previousExit, run, overlap));
+  const next = normalizeLifecycleState({ schemaVersion: 1, runs: [run, ...runs] }, retain);
   return {
     state: next,
     fact: {
@@ -1146,15 +1186,30 @@ function transitionProcessStart(source, input) {
       previousPid: previous?.pid ?? null,
       previousVersion: previous?.version ?? null,
       versionChanged: previous !== null && isVersionChange(previous.version, run.version),
-      downtimeMs
+      processGapMs
     }
   };
 }
+function findOpen(state, input) {
+  return state.runs.find((run) => run.runId === input.runId && run.pid === input.pid && isOpenRun(run));
+}
+function unavailability(state, target, readyAt) {
+  const older = state.runs.slice(state.runs.indexOf(target) + 1);
+  const served = older.find((run) => run.readyAt !== null);
+  if (!served)
+    return { downtimeMs: null, unavailableSince: null };
+  if (served.unavailableAt !== null) {
+    return {
+      downtimeMs: elapsed(readyAt, served.unavailableAt),
+      unavailableSince: served.unavailableAt
+    };
+  }
+  return isOpenRun(served) ? { downtimeMs: 0, unavailableSince: null } : { downtimeMs: null, unavailableSince: null };
+}
 function transitionProcessReady(source, input) {
-  const retain = input.retain ?? 20;
-  const state = normalize(source, retain);
-  const target = state.runs.find((run) => run.runId === input.runId && run.pid === input.pid && run.termination === "active");
-  if (!target) {
+  const state = normalizeLifecycleState(source, input.retain ?? 20);
+  const target = findOpen(state, input);
+  if (target?.termination !== "active") {
     return {
       state,
       fact: {
@@ -1163,6 +1218,8 @@ function transitionProcessReady(source, input) {
         pid: input.pid,
         readyAt: input.now,
         startupMs: 0,
+        downtimeMs: null,
+        unavailableSince: null,
         recorded: false
       }
     };
@@ -1179,14 +1236,45 @@ function transitionProcessReady(source, input) {
       pid: target.pid,
       readyAt,
       startupMs: elapsed(readyAt, target.startedAt),
+      ...unavailability(state, target, readyAt),
       recorded: target.readyAt === null
     }
   };
 }
+function transitionProcessDraining(source, input) {
+  const state = normalizeLifecycleState(source, input.retain ?? 20);
+  const target = findOpen(state, input);
+  if (target?.termination !== "active") {
+    return {
+      state,
+      fact: {
+        type: "draining",
+        runId: input.runId,
+        pid: input.pid,
+        unavailableAt: target ? target.unavailableAt : null,
+        recorded: false
+      }
+    };
+  }
+  const unavailableAt = target.readyAt === null ? null : input.now;
+  return {
+    state: {
+      schemaVersion: 1,
+      runs: state.runs.map((run) => run.runId === target.runId ? { ...run, termination: "draining", unavailableAt } : run)
+    },
+    fact: {
+      type: "draining",
+      runId: target.runId,
+      pid: target.pid,
+      unavailableAt,
+      recorded: true
+    }
+  };
+}
 function transitionProcessShutdown(source, input) {
-  const state = normalize(source, input.retain ?? 20);
-  const target = state.runs.find((run) => run.runId === input.runId && run.pid === input.pid && run.termination === "active");
-  const termination = input.forced ? "forced" : "clean";
+  const state = normalizeLifecycleState(source, input.retain ?? 20);
+  const target = findOpen(state, input);
+  const requested = input.forced ? "forced" : "clean";
   if (!target) {
     return {
       state,
@@ -1196,15 +1284,17 @@ function transitionProcessShutdown(source, input) {
         pid: input.pid,
         stoppedAt: input.now,
         uptimeMs: null,
-        termination,
+        termination: requested,
         recorded: false
       }
     };
   }
+  const termination = target.readyAt === null ? "startup-failed" : requested;
+  const unavailableAt = target.unavailableAt ?? (target.readyAt === null ? null : input.now);
   return {
     state: {
       schemaVersion: 1,
-      runs: state.runs.map((run) => run.runId === target.runId ? { ...run, stoppedAt: input.now, termination } : run)
+      runs: state.runs.map((run) => run.runId === target.runId ? { ...run, unavailableAt, stoppedAt: input.now, termination } : run)
     },
     fact: {
       type: "stopped",
@@ -1217,10 +1307,12 @@ function transitionProcessShutdown(source, input) {
     }
   };
 }
+
+// src/application/process-lifecycle.ts
 function createProcessLifecycleLedger(config) {
   const clock = config.clock ?? (() => new Date);
-  const pid = z6.number().int().positive().parse(config.pid ?? process.pid);
-  const retain = z6.number().int().min(1).max(1000).parse(config.retain ?? 20);
+  const pid = z7.number().int().positive().parse(config.pid ?? process.pid);
+  const retain = z7.number().int().min(1).max(1000).parse(config.retain ?? 20);
   const configuredRunId = config.runId;
   const nextRunId = typeof configuredRunId === "function" ? configuredRunId : configuredRunId === undefined ? () => crypto.randomUUID() : () => configuredRunId;
   let runId = nextRunId();
@@ -1264,6 +1356,20 @@ function createProcessLifecycleLedger(config) {
         publish(fact);
       return fact;
     },
+    async recordDraining() {
+      const fact = await config.store.update((state) => {
+        const transition = transitionProcessDraining(state, {
+          runId,
+          pid,
+          now: clock().toISOString(),
+          retain
+        });
+        return { state: transition.state, result: transition.fact };
+      });
+      if (fact.recorded)
+        publish(fact);
+      return fact;
+    },
     async recordShutdown(input) {
       const fact = await config.store.update((state) => {
         const transition = transitionProcessShutdown(state, {
@@ -1280,11 +1386,11 @@ function createProcessLifecycleLedger(config) {
       return fact;
     },
     async current() {
-      const state = normalize(await config.store.read(), retain);
+      const state = normalizeLifecycleState(await config.store.read(), retain);
       return state.runs.find((run) => run.runId === runId && run.pid === pid) ?? null;
     },
     async runs() {
-      return normalize(await config.store.read(), retain).runs;
+      return normalizeLifecycleState(await config.store.read(), retain).runs;
     },
     subscribe(listener) {
       listeners.add(listener);
@@ -1319,6 +1425,9 @@ function lifecycleLedgerResource(ledger, config) {
     async activate() {
       await ledger.recordReady();
     },
+    async stopAdmission() {
+      await ledger.recordDraining();
+    },
     async close() {
       await stop(false);
     },
@@ -1328,27 +1437,27 @@ function lifecycleLedgerResource(ledger, config) {
   });
 }
 // src/application/revision-signal.ts
-import { z as z7 } from "zod";
-var NonNegativeSafeIntegerSchema = z7.number().int().nonnegative().safe();
-var PositiveSafeIntegerSchema2 = z7.number().int().positive().safe();
-var TimerDelaySchema = z7.number().int().positive().max(2147483647);
-var RevisionSignalStateSchema = z7.enum(["open", "closed"]);
-var RevisionSignalWaitOutcomeSchema = z7.enum([
+import { z as z8 } from "zod";
+var NonNegativeSafeIntegerSchema = z8.number().int().nonnegative().safe();
+var PositiveSafeIntegerSchema2 = z8.number().int().positive().safe();
+var TimerDelaySchema = z8.number().int().positive().max(2147483647);
+var RevisionSignalStateSchema = z8.enum(["open", "closed"]);
+var RevisionSignalWaitOutcomeSchema = z8.enum([
   "changed",
   "timed-out",
   "aborted",
   "closed",
   "capacity"
 ]);
-var RevisionSignalWaitResultSchema = z7.object({
+var RevisionSignalWaitResultSchema = z8.object({
   outcome: RevisionSignalWaitOutcomeSchema,
   revision: NonNegativeSafeIntegerSchema
 }).strict().readonly();
-var RevisionSignalAdvanceResultSchema = z7.object({
-  outcome: z7.enum(["advanced", "closed"]),
+var RevisionSignalAdvanceResultSchema = z8.object({
+  outcome: z8.enum(["advanced", "closed"]),
   revision: NonNegativeSafeIntegerSchema
 }).strict().readonly();
-var RevisionSignalSnapshotSchema = z7.object({
+var RevisionSignalSnapshotSchema = z8.object({
   state: RevisionSignalStateSchema,
   revision: NonNegativeSafeIntegerSchema,
   pending: NonNegativeSafeIntegerSchema,
@@ -1552,59 +1661,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 +1730,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 +1745,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 +1762,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 +1819,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 +1850,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 +1874,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,11 +1983,31 @@ 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,
   transitionProcessShutdown,
   transitionProcessReady,
+  transitionProcessDraining,
   sqliteKeyspaceBackend,
   readDiagnosticJournalLockDiagnosis,
   projectApplicationStatus,