stitchkit 0.77.0 → 0.79.0

package/dist/application.js

@@ -1,3 +1,16 @@
+import {
+  ApplicationAdmissionError,
+  ApplicationRestartInputSchema,
+  ApplicationRestartOutcomeSchema,
+  ApplicationRestartResultSchema,
+  ApplicationShutdownBudgetSchema,
+  ApplicationShutdownOptionsSchema,
+  createApplication
+} from "./index-evcnmsc3.js";
+import {
+  defineManagedResource,
+  managedResourceDependencyId
+} from "./index-2k4yrqkc.js";
 import {
   ActivityIdSchema,
   ActivityLiveStateSchema,
@@ -6,41 +19,28 @@ import {
   ActivityStageSnapshotSchema,
   ActivityTokenBrand,
   ApplicationSnapshotSinkStatusSchema,
-  BoundedChannelPolicySchema,
-  BoundedChannelReaderError,
-  BoundedChannelSnapshotSchema,
-  BoundedChannelStateSchema,
-  CreditWindowSnapshotSchema,
   ManagedScheduleDescriptorSchema,
   ManagedScheduleErrorPolicySchema,
   ManagedScheduleOverlapSchema,
   ManagedScheduleStatusSchema,
   createActivityProjection,
   createApplicationSnapshotSink,
-  createBoundedChannel,
-  createCreditWindow,
   createManagedSchedule
-} from "./index-3cwck0rm.js";
+} from "./index-6s7n2v50.js";
 import {
-  createBoundedSinkManager
-} from "./index-a59da114.js";
-import {
-  argumentsDigest,
-  stableValue
-} from "./index-a916km3r.js";
-import {
-  ApplicationAdmissionError,
-  ApplicationRestartInputSchema,
-  ApplicationRestartOutcomeSchema,
-  ApplicationRestartResultSchema,
-  ApplicationShutdownBudgetSchema,
-  ApplicationShutdownOptionsSchema,
-  createApplication
-} from "./index-vc1b0b1b.js";
-import {
-  defineManagedResource,
-  managedResourceDependencyId
-} from "./index-2k4yrqkc.js";
+  DiagnosticJournalCloseResultSchema,
+  DiagnosticJournalFailurePhaseSchema,
+  DiagnosticJournalFrameSchema,
+  DiagnosticJournalLimitsSchema,
+  DiagnosticJournalLockPolicySchema,
+  DiagnosticJournalRefusalReasonSchema,
+  DiagnosticJournalStateSchema,
+  DiagnosticJournalStatusSchema,
+  DiagnosticJournalSubmitResultSchema,
+  DiagnosticJournalWaitResultSchema,
+  readDiagnosticJournalLockDiagnosis
+} from "./index-wc4x00bn.js";
+import"./index-pq95qkbf.js";
 import {
   ApplicationAdmissionSnapshotSchema,
   ApplicationHealthSchema,
@@ -53,12 +53,36 @@ import {
   ManagedResourceSnapshotSchema,
   ManagedResourceStateSchema,
   projectApplicationStatus
-} from "./index-8eywc9zv.js";
+} from "./index-3gye9wzb.js";
+import {
+  withDeadline
+} from "./index-b9aefrqd.js";
 import"./index-3z73fh2c.js";
-import"./index-0w9abg87.js";
 import {
-  isRecord
-} from "./index-qyrqwr4c.js";
+  createBoundedSinkManager
+} from "./index-a59da114.js";
+import {
+  createBackoff
+} from "./index-h4pj6fta.js";
+import {
+  watchKeyString
+} from "./index-dre2ywck.js";
+import"./index-ywd0y6m1.js";
+import {
+  BoundedChannelPolicySchema,
+  BoundedChannelReaderError,
+  BoundedChannelSnapshotSchema,
+  BoundedChannelStateSchema,
+  CreditWindowSnapshotSchema,
+  createBoundedChannel,
+  createCreditWindow
+} from "./index-7gnkny4z.js";
+import {
+  argumentsDigest,
+  stableValue
+} from "./index-a916km3r.js";
+import"./index-0w9abg87.js";
+import"./index-77fekveh.js";
 // src/application/admission.ts
 import { z } from "zod";
 var PositiveSafeIntegerSchema = z.number().int().positive().safe();
@@ -454,13 +478,19 @@ class DecisionUndecidedError extends Error {
 
 class DecisionPolicyError extends Error {
   policyId;
-  constructor(policyId, detail) {
-    super(`Policy "${policyId}" did not return a decision (${detail}). A policy returns { outcome: "allow" | "deny" | "defer" }, and a deny carries a reason.`);
+  trace;
+  constructor(policyId, detail, trace = []) {
+    super(`Policy "${policyId}" did not answer (${detail}). A policy returns { outcome: "allow" | "deny" | "defer" } within its deadline, and a deny carries a reason.`);
     this.name = "DecisionPolicyError";
     this.policyId = policyId;
+    this.trace = trace;
   }
 }
-function createDecisionPipeline(policies) {
+function createDecisionPipeline(policies, config) {
+  const { policyTimeoutMs } = config;
+  if (!Number.isInteger(policyTimeoutMs) || policyTimeoutMs <= 0) {
+    throw new Error("[stitchkit] decision pipeline: policyTimeoutMs must be a positive integer number of milliseconds.");
+  }
   const seen = new Set;
   for (const policy of policies) {
     if (policy.id.trim() === "") {
@@ -476,10 +506,21 @@ function createDecisionPipeline(policies) {
     async decide(input) {
       const trace = [];
       for (const policy of policies) {
-        const answer = await policy.decide(input);
+        let answer;
+        try {
+          const outcome = await withDeadline(policy.decide(input), policyTimeoutMs);
+          if (!outcome.settled) {
+            throw new DecisionPolicyError(policy.id, `did not answer within ${policyTimeoutMs}ms`, trace);
+          }
+          answer = outcome.value;
+        } catch (error) {
+          if (error instanceof DecisionPolicyError)
+            throw error;
+          throw new DecisionPolicyError(policy.id, error instanceof Error ? `threw: ${error.message}` : "threw", trace);
+        }
         const parsed = PolicyDecisionSchema.safeParse(answer);
         if (!parsed.success) {
-          throw new DecisionPolicyError(policy.id, parsed.error.issues[0]?.message ?? "invalid");
+          throw new DecisionPolicyError(policy.id, parsed.error.issues[0]?.message ?? "invalid", trace);
         }
         const decision = parsed.data;
         trace.push(decision.outcome === "deny" ? { id: policy.id, outcome: "deny", reason: decision.reason } : { id: policy.id, outcome: decision.outcome });
@@ -494,728 +535,18 @@ function createDecisionPipeline(policies) {
     }
   };
 }
-// src/application/diagnostic-journal.ts
-import { randomUUID } from "node:crypto";
-
-// src/application/diagnostic-journal-contract.ts
-import { z as z3 } from "zod";
-var PositiveSafeIntegerSchema2 = z3.number().int().positive().safe();
-var FileModeSchema = z3.number().int().min(0).max(511);
-var DiagnosticJournalLimitsSchema = z3.object({
-  maxEventBytes: PositiveSafeIntegerSchema2,
-  maxPendingItems: PositiveSafeIntegerSchema2,
-  maxPendingBytes: PositiveSafeIntegerSchema2,
-  maxFileBytes: PositiveSafeIntegerSchema2,
-  maxFiles: PositiveSafeIntegerSchema2
-}).strict().readonly();
-var DiagnosticJournalLockPolicySchema = z3.enum(["refuse", "reclaim-stale"]);
-var DiagnosticJournalStateSchema = z3.enum(["open", "draining", "closed", "failed"]);
-var DiagnosticJournalRefusalReasonSchema = z3.enum([
-  "closed",
-  "failed",
-  "invalid",
-  "oversized",
-  "item-capacity",
-  "byte-capacity"
-]);
-var DiagnosticJournalRefusalCountersSchema = z3.object({
-  closed: z3.number().int().nonnegative(),
-  failed: z3.number().int().nonnegative(),
-  invalid: z3.number().int().nonnegative(),
-  oversized: z3.number().int().nonnegative(),
-  "item-capacity": z3.number().int().nonnegative(),
-  "byte-capacity": z3.number().int().nonnegative()
-}).strict().readonly();
-var DiagnosticJournalFailurePhaseSchema = z3.enum(["write", "rotation", "close"]);
-var DiagnosticJournalStatusSchema = z3.object({
-  state: DiagnosticJournalStateSchema,
-  epoch: z3.uuid(),
-  limits: DiagnosticJournalLimitsSchema,
-  lock: z3.object({
-    policy: DiagnosticJournalLockPolicySchema,
-    reclaimedStale: z3.boolean()
-  }).strict().readonly(),
-  received: z3.number().int().nonnegative(),
-  accepted: z3.number().int().nonnegative(),
-  refused: z3.number().int().nonnegative(),
-  refusals: DiagnosticJournalRefusalCountersSchema,
-  written: z3.number().int().nonnegative(),
-  failedRecords: z3.number().int().nonnegative(),
-  pendingItems: z3.number().int().nonnegative(),
-  pendingBytes: z3.number().int().nonnegative(),
-  inFlight: z3.boolean(),
-  rotations: z3.number().int().nonnegative(),
-  rotationFailures: z3.number().int().nonnegative(),
-  partialTails: z3.number().int().nonnegative(),
-  currentFileBytes: z3.number().int().nonnegative(),
-  retainedFiles: z3.number().int().nonnegative(),
-  lastAcceptedSequence: z3.number().int().positive().optional(),
-  lastWrittenSequence: z3.number().int().positive().optional(),
-  lastSettledSequence: z3.number().int().positive().optional(),
-  lastFailure: z3.object({
-    phase: DiagnosticJournalFailurePhaseSchema,
-    sequence: z3.number().int().positive().optional()
-  }).strict().readonly().optional()
-}).strict().readonly();
-var DiagnosticJournalSubmitResultSchema = z3.discriminatedUnion("outcome", [
-  z3.object({
-    outcome: z3.literal("accepted"),
-    epoch: z3.uuid(),
-    sequence: z3.number().int().positive()
-  }).strict().readonly(),
-  z3.object({
-    outcome: z3.literal("refused"),
-    reason: DiagnosticJournalRefusalReasonSchema
-  }).strict().readonly()
-]);
-var DiagnosticJournalWaitResultSchema = z3.object({
-  outcome: z3.enum(["settled", "timed-out", "cancelled"]),
-  state: DiagnosticJournalStateSchema,
-  throughSequence: z3.number().int().nonnegative(),
-  settledSequence: z3.number().int().nonnegative()
-}).strict().readonly();
-var DiagnosticJournalCloseResultSchema = z3.object({
-  outcome: z3.enum(["closed", "timed-out", "cancelled"]),
-  state: DiagnosticJournalStateSchema,
-  pendingItems: z3.number().int().nonnegative()
-}).strict().readonly();
-var DiagnosticJournalFrameSchema = z3.object({
-  schemaVersion: z3.literal(1),
-  epoch: z3.uuid(),
-  sequence: z3.number().int().positive(),
-  event: z3.json()
-}).strict().readonly();
-function parseDiagnosticJournalMode(mode) {
-  return FileModeSchema.parse(mode ?? 384);
-}
-function readDiagnosticJournalLockDiagnosis(error) {
-  if (!isRecord(error))
-    return;
-  const diagnosis = error.journalLock;
-  return isRecord(diagnosis) ? diagnosis : undefined;
-}
-
-// src/application/diagnostic-journal-manager.ts
-import { z as z4 } from "zod";
-
-// src/application/diagnostic-journal-storage.ts
-import { constants as constants2 } from "node:fs";
-import { lstat, open as open2, readdir, realpath, rename, unlink as unlink2 } from "node:fs/promises";
-import { basename, dirname, isAbsolute, resolve } from "node:path";
-
-// src/application/diagnostic-journal-lock.ts
-import { execFile } from "node:child_process";
-import { constants } from "node:fs";
-import { open, readFile, unlink } from "node:fs/promises";
-import { hostname, platform } from "node:os";
-import { promisify } from "node:util";
-function isExisting(error) {
-  return isRecord(error) && error.code === "EEXIST";
-}
-function readOwner(text) {
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    return;
-  }
-  if (!isRecord(parsed))
-    return;
-  const { pid, host, acquiredAt, machine } = parsed;
-  if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0)
-    return;
-  if (typeof host !== "string" || host.length === 0)
-    return;
-  if (typeof acquiredAt !== "string")
-    return;
-  const identified = typeof machine === "string" && machine.length > 0 ? { machine } : {};
-  return { pid, host, acquiredAt, ...identified };
-}
-var detectedIdentity;
-async function firstReadableLine(paths) {
-  for (const path of paths) {
-    try {
-      const text = (await readFile(path, "utf8")).trim();
-      if (text.length > 0)
-        return text;
-    } catch {}
-  }
-  return null;
-}
-var run = promisify(execFile);
-function parsePlatformUuid(dump) {
-  return /"IOPlatformUUID"\s*=\s*"([^"]+)"/.exec(dump)?.[1] ?? null;
-}
-async function readDarwinPlatformUuid(command = "ioreg") {
-  try {
-    const { stdout } = await run(command, ["-rd1", "-c", "IOPlatformExpertDevice"], {
-      timeout: 2000,
-      maxBuffer: 1 << 20,
-      encoding: "utf8"
-    });
-    return parsePlatformUuid(stdout);
-  } catch {
-    return null;
-  }
-}
-async function machineIdentity(declared) {
-  if (declared !== undefined)
-    return declared;
-  if (detectedIdentity !== undefined)
-    return detectedIdentity;
-  detectedIdentity = platform() === "darwin" ? await readDarwinPlatformUuid() : await firstReadableLine(["/etc/machine-id", "/var/lib/dbus/machine-id"]);
-  return detectedIdentity;
-}
-function attribute(owner, identity) {
-  if (identity !== null && owner.machine !== undefined) {
-    return owner.machine === identity ? "this-machine" : "another-machine";
-  }
-  return owner.host === hostname() ? "this-machine" : "unattributable";
-}
-async function probeLiveness(owner) {
-  try {
-    process.kill(owner.pid, 0);
-  } catch (error) {
-    return isRecord(error) && error.code === "ESRCH" ? "gone" : "alive";
-  }
-  return await isZombieProcess(owner.pid) ? "gone" : "alive";
-}
-async function isZombieProcess(pid, seam = {}) {
-  const { procRoot = "/proc", psCommand = "ps" } = seam;
-  try {
-    const stat = await readFile(`${procRoot}/${pid}/stat`, "utf8");
-    return stat.slice(stat.lastIndexOf(")") + 1).trimStart().startsWith("Z");
-  } catch {}
-  try {
-    const { stdout } = await run(psCommand, ["-o", "state=", "-p", String(pid)], {
-      timeout: 2000,
-      maxBuffer: 1 << 16,
-      encoding: "utf8"
-    });
-    return stdout.trim().startsWith("Z");
-  } catch {
-    return false;
-  }
-}
-async function diagnose(owner, declaredIdentity) {
-  if (!owner)
-    return { attribution: "unattributable", liveness: "not-probed", owner: null };
-  const attribution = attribute(owner, await machineIdentity(declaredIdentity));
-  const record = {
-    pid: owner.pid,
-    host: owner.host,
-    acquiredAt: owner.acquiredAt,
-    ...owner.machine !== undefined && { machine: owner.machine }
-  };
-  if (attribution !== "this-machine")
-    return { attribution, liveness: "not-probed", owner: record };
-  return { attribution, liveness: await probeLiveness(owner), owner: record };
-}
-async function readLockOwner(lockPath) {
-  let handle;
-  try {
-    handle = await open(lockPath, constants.O_RDONLY | constants.O_NOFOLLOW);
-    return readOwner(await handle.readFile("utf8"));
-  } catch {
-    return;
-  } finally {
-    await handle?.close().catch(() => {
-      return;
-    });
-  }
-}
-async function createExclusive(lockPath, mode, declaredIdentity) {
-  const handle = await open(lockPath, "wx", mode);
-  const identity = await machineIdentity(declaredIdentity);
-  const owner = {
-    pid: process.pid,
-    host: hostname(),
-    acquiredAt: new Date().toISOString(),
-    ...identity !== null && { machine: identity }
-  };
-  await handle.writeFile(`${JSON.stringify(owner)}
-`, "utf8");
-  return handle;
-}
-async function acquireDiagnosticJournalLock(lockPath, mode, policy, declaredIdentity) {
-  try {
-    return {
-      handle: await createExclusive(lockPath, mode, declaredIdentity),
-      reclaimedStale: false
-    };
-  } catch (error) {
-    if (policy !== "reclaim-stale" || !isExisting(error))
-      throw error;
-    const owner = await readLockOwner(lockPath);
-    const diagnosis = await diagnose(owner, declaredIdentity);
-    if (!owner || diagnosis.liveness !== "gone") {
-      if (isRecord(error))
-        Object.assign(error, { journalLock: diagnosis });
-      throw error;
-    }
-    await unlink(lockPath).catch(() => {
-      return;
-    });
-    return {
-      handle: await createExclusive(lockPath, mode, declaredIdentity),
-      reclaimedStale: true
-    };
-  }
-}
-
-// src/application/diagnostic-journal-storage.ts
-class DiagnosticJournalStorageError extends Error {
-  phase;
-  constructor(phase, message, options) {
-    super(message, options);
-    this.phase = phase;
-    this.name = "DiagnosticJournalStorageError";
-  }
-}
-function isMissing(error) {
-  return isRecord(error) && error.code === "ENOENT";
-}
-async function removeIfPresent(path) {
-  try {
-    const info = await lstat(path);
-    if (info.isSymbolicLink() || !info.isFile()) {
-      throw new Error("Diagnostic journal generations must be regular files");
-    }
-    await unlink2(path);
-  } catch (error) {
-    if (!isMissing(error))
-      throw error;
-  }
-}
-async function moveIfPresent(from, to) {
-  try {
-    const info = await lstat(from);
-    if (info.isSymbolicLink() || !info.isFile()) {
-      throw new Error("Diagnostic journal generations must be regular files");
-    }
-    await rename(from, to);
-    return true;
-  } catch (error) {
-    if (isMissing(error))
-      return false;
-    throw error;
-  }
-}
-function generation(path, index) {
-  return `${path}.${index}`;
-}
-function generationIndex(name, prefix) {
-  if (!name.startsWith(prefix))
-    return;
-  const suffix = name.slice(prefix.length);
-  if (!/^\d+$/.test(suffix))
-    return;
-  const value = Number(suffix);
-  return Number.isSafeInteger(value) && value > 0 ? value : undefined;
-}
-async function createRotatingDiagnosticJournalStorage(config) {
-  if (!isAbsolute(config.path) || resolve(config.path) !== config.path) {
-    throw new TypeError("Diagnostic journal path must be normalized and absolute");
-  }
-  const parent = await realpath(dirname(config.path));
-  const journalPath = resolve(parent, basename(config.path));
-  const lockPath = `${journalPath}.lock`;
-  const { handle: lock, reclaimedStale } = await acquireDiagnosticJournalLock(lockPath, config.mode, config.lock, config.machineIdentity);
-  let handle;
-  let currentFileBytes = 0;
-  let retainedFiles = 1;
-  let rotations = 0;
-  let partialTails = 0;
-  let closed = false;
-  const openCurrent = async () => {
-    handle = await open2(journalPath, constants2.O_APPEND | constants2.O_CREAT | constants2.O_RDWR | constants2.O_NOFOLLOW, config.mode);
-    const info = await handle.stat();
-    if (!info.isFile()) {
-      await handle.close();
-      handle = undefined;
-      throw new Error("Diagnostic journal path must be a regular file");
-    }
-    currentFileBytes = Number(info.size);
-  };
-  const rotate = async () => {
-    try {
-      await handle?.close();
-      handle = undefined;
-      if (config.maxFiles === 1) {
-        await removeIfPresent(journalPath);
-      } else {
-        await removeIfPresent(generation(journalPath, config.maxFiles - 1));
-        for (let index = config.maxFiles - 2;index >= 1; index -= 1) {
-          await moveIfPresent(generation(journalPath, index), generation(journalPath, index + 1));
-        }
-        await moveIfPresent(journalPath, generation(journalPath, 1));
-      }
-      retainedFiles = Math.min(config.maxFiles, retainedFiles + 1);
-      rotations += 1;
-      await openCurrent();
-    } catch (error) {
-      throw new DiagnosticJournalStorageError("rotation", "Diagnostic journal rotation failed", { cause: error });
-    }
-  };
-  try {
-    const names = await readdir(parent);
-    const prefix = `${basename(journalPath)}.`;
-    let existingGenerations = 0;
-    for (const name of names) {
-      const index = generationIndex(name, prefix);
-      if (index === undefined)
-        continue;
-      if (index >= config.maxFiles) {
-        await removeIfPresent(resolve(parent, name));
-      } else {
-        const info = await lstat(resolve(parent, name));
-        if (info.isSymbolicLink() || !info.isFile()) {
-          throw new Error("Diagnostic journal generations must be regular files");
-        }
-        existingGenerations += 1;
-      }
-    }
-    retainedFiles = Math.min(config.maxFiles, existingGenerations + 1);
-    await openCurrent();
-    if (currentFileBytes > 0) {
-      const tail = new Uint8Array(1);
-      const read = await handle?.read(tail, 0, 1, currentFileBytes - 1);
-      if (read?.bytesRead === 1 && tail[0] !== 10) {
-        partialTails += 1;
-        await rotate();
-      }
-    }
-  } catch (error) {
-    await handle?.close().catch(() => {
-      return;
-    });
-    await lock.close().catch(() => {
-      return;
-    });
-    await unlink2(lockPath).catch(() => {
-      return;
-    });
-    throw error;
-  }
-  const snapshot = () => ({
-    currentFileBytes,
-    retainedFiles,
-    rotations,
-    partialTails
-  });
-  return {
-    reclaimedStale,
-    async append(bytes) {
-      if (closed || !handle) {
-        throw new DiagnosticJournalStorageError("write", "Diagnostic journal storage is closed");
-      }
-      let rotated = false;
-      if (currentFileBytes > 0 && currentFileBytes + bytes.byteLength > config.maxFileBytes) {
-        await rotate();
-        rotated = true;
-      }
-      try {
-        await handle.writeFile(bytes);
-        currentFileBytes += bytes.byteLength;
-        return { ...snapshot(), rotated };
-      } catch (error) {
-        throw new DiagnosticJournalStorageError("write", "Diagnostic journal write failed", {
-          cause: error
-        });
-      }
-    },
-    snapshot,
-    async close() {
-      if (closed)
-        return;
-      closed = true;
-      let failure;
-      try {
-        await handle?.close();
-      } catch (error) {
-        failure = error;
-      }
-      try {
-        await lock.close();
-        await unlink2(lockPath);
-      } catch (error) {
-        failure ??= error;
-      }
-      if (failure !== undefined) {
-        throw new DiagnosticJournalStorageError("close", "Diagnostic journal close failed", {
-          cause: failure
-        });
-      }
-    }
-  };
-}
-
-// src/application/diagnostic-journal-manager.ts
-function waitBudget(options) {
-  if (options.timeoutMs === undefined)
-    return;
-  if (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs <= 0) {
-    throw new TypeError("Diagnostic journal timeoutMs must be a positive safe integer");
-  }
-  return options.timeoutMs;
-}
-function createDiagnosticJournalManager(config, storage) {
-  const limits = DiagnosticJournalLimitsSchema.parse(config.limits);
-  const encoder = new TextEncoder;
-  const channel = createBoundedChannel({
-    policy: "ordered",
-    maxItems: limits.maxPendingItems,
-    maxBytes: limits.maxPendingBytes,
-    sizeOf: (frame) => frame.bytes.byteLength
-  });
-  const refusals = {
-    closed: 0,
-    failed: 0,
-    invalid: 0,
-    oversized: 0,
-    "item-capacity": 0,
-    "byte-capacity": 0
-  };
-  const progressWaiters = new Set;
-  let state = "open";
-  let received = 0;
-  let accepted = 0;
-  let refused = 0;
-  let written = 0;
-  let failedRecords = 0;
-  let pendingItems = 0;
-  let pendingBytes = 0;
-  let inFlight = false;
-  let rotationFailures = 0;
-  let lastAcceptedSequence = 0;
-  let lastWrittenSequence = 0;
-  let lastSettledSequence = 0;
-  let lastFailure;
-  let physicalClosed = false;
-  const isFailed = () => state === "failed";
-  const notifyProgress = () => {
-    for (const waiter of progressWaiters)
-      waiter();
-  };
-  const reportFailure = (failure) => {
-    if (!config.onFailure)
-      return;
-    Promise.resolve().then(() => config.onFailure?.(failure)).catch(() => {
-      return;
-    });
-  };
-  const markFailure = (error, fallbackPhase, sequence) => {
-    const phase = error instanceof DiagnosticJournalStorageError ? error.phase : fallbackPhase;
-    if (phase === "rotation")
-      rotationFailures += 1;
-    lastFailure = { phase, ...sequence !== undefined && { sequence } };
-    state = "failed";
-    channel.close({ mode: "drain" });
-    reportFailure({ phase, error, ...sequence !== undefined && { sequence } });
-  };
-  const worker = (async () => {
-    for await (const frame of channel) {
-      inFlight = true;
-      if (isFailed()) {
-        failedRecords += 1;
-      } else {
-        try {
-          await storage.append(frame.bytes);
-          written += 1;
-          lastWrittenSequence = frame.sequence;
-        } catch (error) {
-          failedRecords += 1;
-          markFailure(error, "write", frame.sequence);
-        }
-      }
-      pendingItems -= 1;
-      pendingBytes -= frame.bytes.byteLength;
-      lastSettledSequence = frame.sequence;
-      inFlight = false;
-      notifyProgress();
-    }
-    try {
-      await storage.close();
-    } catch (error) {
-      markFailure(error, "close");
-    }
-    physicalClosed = true;
-    if (!isFailed())
-      state = "closed";
-    notifyProgress();
-  })();
-  worker.catch((error) => {
-    markFailure(error, "close");
-    physicalClosed = true;
-    notifyProgress();
-  });
-  const refuse = (reason) => {
-    refused += 1;
-    refusals[reason] += 1;
-    return DiagnosticJournalSubmitResultSchema.parse({ outcome: "refused", reason });
-  };
-  const waitUntil = (predicate, options) => {
-    const timeoutMs = waitBudget(options);
-    if (predicate())
-      return Promise.resolve("settled");
-    if (options.signal?.aborted)
-      return Promise.resolve("cancelled");
-    return new Promise((resolve2) => {
-      let settled = false;
-      let timer;
-      const finish = (outcome) => {
-        if (settled)
-          return;
-        settled = true;
-        progressWaiters.delete(onProgress);
-        options.signal?.removeEventListener("abort", onAbort);
-        if (timer)
-          clearTimeout(timer);
-        resolve2(outcome);
-      };
-      const onProgress = () => {
-        if (predicate())
-          finish("settled");
-      };
-      const onAbort = () => finish("cancelled");
-      progressWaiters.add(onProgress);
-      options.signal?.addEventListener("abort", onAbort, { once: true });
-      if (timeoutMs !== undefined)
-        timer = setTimeout(() => finish("timed-out"), timeoutMs);
-      onProgress();
-    });
-  };
-  const getStatus = () => {
-    const file = storage.snapshot();
-    return DiagnosticJournalStatusSchema.parse({
-      state,
-      epoch: config.epoch,
-      limits,
-      lock: config.lock,
-      received,
-      accepted,
-      refused,
-      refusals,
-      written,
-      failedRecords,
-      pendingItems,
-      pendingBytes,
-      inFlight,
-      rotations: file.rotations,
-      rotationFailures,
-      partialTails: file.partialTails,
-      currentFileBytes: file.currentFileBytes,
-      retainedFiles: file.retainedFiles,
-      ...lastAcceptedSequence > 0 && { lastAcceptedSequence },
-      ...lastWrittenSequence > 0 && { lastWrittenSequence },
-      ...lastSettledSequence > 0 && { lastSettledSequence },
-      ...lastFailure && { lastFailure }
-    });
-  };
-  return {
-    submit(event) {
-      received += 1;
-      if (state === "failed")
-        return refuse("failed");
-      if (state !== "open")
-        return refuse("closed");
-      const parsed = config.eventSchema.safeParse(event);
-      if (!parsed.success)
-        return refuse("invalid");
-      const json = z4.json().safeParse(parsed.data);
-      if (!json.success)
-        return refuse("invalid");
-      const payload = encoder.encode(JSON.stringify(json.data));
-      if (payload.byteLength > limits.maxEventBytes)
-        return refuse("oversized");
-      if (pendingItems >= limits.maxPendingItems)
-        return refuse("item-capacity");
-      const sequence = lastAcceptedSequence + 1;
-      const frame = DiagnosticJournalFrameSchema.parse({
-        schemaVersion: 1,
-        epoch: config.epoch,
-        sequence,
-        event: json.data
-      });
-      const bytes = encoder.encode(`${JSON.stringify(frame)}
-`);
-      if (bytes.byteLength > limits.maxFileBytes)
-        return refuse("oversized");
-      if (pendingBytes + bytes.byteLength > limits.maxPendingBytes) {
-        return refuse("byte-capacity");
-      }
-      const offered = channel.offer({ sequence, bytes });
-      if (offered.outcome === "refused") {
-        return refuse(offered.reason === "not-open" ? "closed" : "item-capacity");
-      }
-      accepted += 1;
-      pendingItems += 1;
-      pendingBytes += bytes.byteLength;
-      lastAcceptedSequence = sequence;
-      return DiagnosticJournalSubmitResultSchema.parse({
-        outcome: "accepted",
-        epoch: config.epoch,
-        sequence
-      });
-    },
-    async flush(options = {}) {
-      const throughSequence = lastAcceptedSequence;
-      const outcome = await waitUntil(() => lastSettledSequence >= throughSequence, options);
-      return DiagnosticJournalWaitResultSchema.parse({
-        outcome,
-        state,
-        throughSequence,
-        settledSequence: lastSettledSequence
-      });
-    },
-    getStatus,
-    async close(options = {}) {
-      if (state === "open") {
-        state = "draining";
-        channel.close({ mode: "drain" });
-      }
-      const wait = await waitUntil(() => physicalClosed, options);
-      return DiagnosticJournalCloseResultSchema.parse({
-        outcome: wait === "settled" ? "closed" : wait,
-        state,
-        pendingItems
-      });
-    }
-  };
-}
-
-// src/application/diagnostic-journal.ts
-async function createDiagnosticJournal(config) {
-  const limits = DiagnosticJournalLimitsSchema.parse(config.limits);
-  const lock = DiagnosticJournalLockPolicySchema.parse(config.lock ?? "refuse");
-  const storage = await createRotatingDiagnosticJournalStorage({
-    path: config.path,
-    maxFileBytes: limits.maxFileBytes,
-    maxFiles: limits.maxFiles,
-    mode: parseDiagnosticJournalMode(config.mode),
-    lock,
-    ...config.machineIdentity !== undefined && { machineIdentity: config.machineIdentity }
-  });
-  return createDiagnosticJournalManager({
-    eventSchema: config.eventSchema,
-    epoch: randomUUID(),
-    limits,
-    lock: { policy: lock, reclaimedStale: storage.reclaimedStale },
-    ...config.onFailure && { onFailure: config.onFailure }
-  }, storage);
-}
 // src/application/events.ts
-import { z as z5 } from "zod";
-var ApplicationLifecycleEventSchema = z5.object({
-  type: z5.literal("application-state"),
+import { z as z3 } from "zod";
+var ApplicationLifecycleEventSchema = z3.object({
+  type: z3.literal("application-state"),
   applicationId: ApplicationIdSchema,
-  epoch: z5.string().uuid(),
-  revision: z5.number().int().nonnegative(),
+  epoch: z3.string().uuid(),
+  revision: z3.number().int().nonnegative(),
   lifecycle: ApplicationLifecycleSchema,
   health: ApplicationHealthSchema,
-  ready: z5.boolean(),
-  capturedAt: z5.string().datetime({ offset: true }),
-  resources: z5.array(ManagedResourceSnapshotSchema).readonly()
+  ready: z3.boolean(),
+  capturedAt: z3.string().datetime({ offset: true }),
+  resources: z3.array(ManagedResourceSnapshotSchema).readonly()
 }).strict().readonly();
 function applicationLifecycleEvent(snapshot) {
   return ApplicationLifecycleEventSchema.parse({
@@ -1246,13 +577,13 @@ function createApplicationEventSink(config) {
   };
 }
 // src/application/health.ts
-import { z as z6 } from "zod";
-var ApplicationHealthHandlerOptionsSchema = z6.object({
-  kind: z6.enum(["liveness", "readiness"]),
-  retryAfterSeconds: z6.number().int().nonnegative().default(5)
+import { z as z4 } from "zod";
+var ApplicationHealthHandlerOptionsSchema = z4.object({
+  kind: z4.enum(["liveness", "readiness"]),
+  retryAfterSeconds: z4.number().int().nonnegative().default(5)
 });
-var ApplicationOperationalHandlersOptionsSchema = z6.object({
-  retryAfterSeconds: z6.number().int().nonnegative().default(5)
+var ApplicationOperationalHandlersOptionsSchema = z4.object({
+  retryAfterSeconds: z4.number().int().nonnegative().default(5)
 });
 function createApplicationHealthHandler(application, options) {
   const parsed = ApplicationHealthHandlerOptionsSchema.parse(options);
@@ -1302,7 +633,7 @@ function keyspaceResource(declaration, config) {
     id: config.id ?? `keyspace:${declaration.name}`,
     ...config.dependsOn && { dependsOn: config.dependsOn },
     async start(_context) {
-      await machine.load();
+      await machine.open();
       return { value: machine.keyspace };
     },
     stopAdmission: machine.stopAdmission,
@@ -1315,9 +646,14 @@ function keyspaceMachine(declaration, config) {
   const maxPending = config.maxPendingWrites ?? 1024;
   const records = new Map;
   let admitting = true;
+  let backend;
+  const currentBackend = () => {
+    backend ??= typeof config.backend === "function" ? config.backend() : config.backend;
+    return backend;
+  };
   let pending = 0;
   let chain = Promise.resolve();
-  function run2(work) {
+  function run(work) {
     if (!admitting) {
       return Promise.reject(new Error(`[stitchkit] keyspace "${declaration.name}" is shutting down and is not accepting writes.`));
     }
@@ -1344,8 +680,8 @@ function keyspaceMachine(declaration, config) {
     put(value) {
       const parsed = declaration.schema.parse(value);
       const key = declaration.key(parsed);
-      return run2(async () => {
-        await config.backend.put(key, parsed);
+      return run(async () => {
+        await currentBackend().put(key, parsed);
         records.set(key, parsed);
         config.onChanged?.({
           keyspace: declaration.name,
@@ -1356,8 +692,8 @@ function keyspaceMachine(declaration, config) {
       });
     },
     delete(key) {
-      return run2(async () => {
-        await config.backend.delete(key);
+      return run(async () => {
+        await currentBackend().delete(key);
         records.delete(key);
         config.onChanged?.({ keyspace: declaration.name, key, change: "delete" });
       });
@@ -1371,11 +707,19 @@ function keyspaceMachine(declaration, config) {
   return {
     keyspace,
     async load() {
-      for (const stored of await config.backend.load()) {
+      for (const stored of await currentBackend().load()) {
         const value = declaration.schema.parse(stored);
         records.set(declaration.key(value), value);
       }
     },
+    async open() {
+      backend = undefined;
+      records.clear();
+      chain = Promise.resolve();
+      pending = 0;
+      admitting = true;
+      await this.load();
+    },
     stopAdmission() {
       admitting = false;
     },
@@ -1384,7 +728,7 @@ function keyspaceMachine(declaration, config) {
     },
     async close() {
       reportUnwritten();
-      await config.backend.close?.();
+      await backend?.close?.();
     },
     force() {
       reportUnwritten();
@@ -1475,6 +819,11 @@ function managedServerResource(config) {
     ...config.dependsOn && { dependsOn: config.dependsOn },
     ...config.required !== undefined && { required: config.required },
     async start(context) {
+      if (startAttempted && typeof config.server !== "function") {
+        throw new Error(`[stitchkit] managed server "${config.id}" cannot be restarted: it was given a server instance, and that one has been shut down. Pass a factory — \`server: (context) => …\` — so each generation gets its own.`);
+      }
+      shutdownPromise = undefined;
+      started = undefined;
       startAttempted = true;
       started = await resolveServer(context);
       return { value: started };
@@ -1493,109 +842,6 @@ function managedServerResource(config) {
     }
   });
 }
-// src/browser/resumable.ts
-import { z as z7 } from "zod";
-var PositiveSafeIntegerSchema3 = z7.number().int().positive().safe();
-var BackoffPolicySchema = z7.object({
-  minDelayMs: PositiveSafeIntegerSchema3,
-  maxDelayMs: PositiveSafeIntegerSchema3,
-  jitter: z7.number().min(0).max(1)
-}).strict().readonly().refine((policy) => policy.maxDelayMs >= policy.minDelayMs, {
-  message: "maxDelayMs must be at least minDelayMs"
-});
-function createBackoff(policy, random = Math.random) {
-  const { minDelayMs, maxDelayMs, jitter } = BackoffPolicySchema.parse(policy);
-  let attempt = 0;
-  return {
-    next() {
-      const exponential = Math.min(maxDelayMs, minDelayMs * 2 ** attempt);
-      attempt += 1;
-      const spread = exponential * jitter * random();
-      return Math.max(1, Math.round(exponential - spread));
-    },
-    reset() {
-      attempt = 0;
-    }
-  };
-}
-
-// src/live/watch-contract.ts
-import { z as z9 } from "zod";
-
-// src/browser/live-state.ts
-import { z as z8 } from "zod";
-var PositiveSafeIntegerSchema4 = z8.number().int().positive().safe();
-var LiveStatePhaseSchema = z8.enum([
-  "idle",
-  "opening",
-  "live",
-  "resync-required",
-  "unavailable",
-  "closed"
-]);
-var LiveStateStopReasonSchema = z8.enum([
-  "gap",
-  "buffer-overflow",
-  "source-unavailable",
-  "source-error",
-  "controller-error",
-  "controller-capacity"
-]);
-var LiveStateControllerStatusSchema = z8.object({
-  phase: LiveStatePhaseSchema,
-  generation: z8.number().int().nonnegative(),
-  hasValue: z8.boolean(),
-  bufferedEvents: z8.number().int().nonnegative(),
-  bufferedBytes: z8.number().int().nonnegative(),
-  receivedEvents: z8.number().int().nonnegative(),
-  appliedEvents: z8.number().int().nonnegative(),
-  duplicateEvents: z8.number().int().nonnegative(),
-  gapEvents: z8.number().int().nonnegative(),
-  refusedEvents: z8.number().int().nonnegative(),
-  reason: LiveStateStopReasonSchema.optional()
-}).strict().readonly();
-
-// src/live/watch-contract.ts
-var WatchKeySchema = z9.object({
-  service: z9.string().min(1),
-  action: z9.string().min(1),
-  digest: z9.string().min(1)
-}).strict().readonly();
-var WatchOpenSchema = z9.object({ key: WatchKeySchema, args: z9.unknown() }).readonly();
-var WatchAcceptedSchema = z9.object({
-  accepted: z9.boolean(),
-  reason: z9.string().optional()
-}).strict().readonly();
-var WatchValueSchema = z9.object({
-  key: WatchKeySchema,
-  revision: z9.number().int().nonnegative(),
-  value: z9.unknown()
-}).readonly();
-var WatchStateSchema = z9.object({
-  key: WatchKeySchema,
-  phase: LiveStatePhaseSchema,
-  reason: LiveStateStopReasonSchema.optional(),
-  code: z9.string().optional(),
-  message: z9.string().optional()
-}).readonly();
-var WATCH_OPEN = "stitchkit.watch.open";
-var WATCH_CLOSE = "stitchkit.watch.close";
-var WATCH_VALUE = "stitchkit.watch.value";
-var WATCH_STATE = "stitchkit.watch.state";
-var watchContract = {
-  serverToClient: {
-    [WATCH_VALUE]: { args: z9.tuple([WatchValueSchema]) },
-    [WATCH_STATE]: { args: z9.tuple([WatchStateSchema]) }
-  },
-  clientToServer: {
-    [WATCH_OPEN]: { args: z9.tuple([WatchOpenSchema]), ack: WatchAcceptedSchema },
-    [WATCH_CLOSE]: { args: z9.tuple([z9.object({ key: WatchKeySchema }).readonly()]) }
-  }
-};
-function watchKeyString(key) {
-  return `${key.service}/${key.action}/${key.digest}`;
-}
-
 // src/application/watch-hub.ts
 var DEFAULT_BACKOFF = { minDelayMs: 250, maxDelayMs: 30000, jitter: 0.2 };
 function watchKey(operation, args) {
@@ -1614,17 +860,29 @@ function createWatchHub(config) {
   const same = config.same ?? ((previous, next) => JSON.stringify(stableValue(previous)) === JSON.stringify(stableValue(next)));
   let reads = 0;
   let closed = false;
+  function tell(key, deliver) {
+    try {
+      deliver();
+    } catch (error) {
+      config.logger?.warn?.("[stitchkit] watch subscriber threw", {
+        key: watchKeyString(key),
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   function announceState(source, state) {
     source.state = state;
-    for (const subscriber of source.subscribers)
-      subscriber.state(state);
+    for (const subscriber of source.subscribers) {
+      tell(source.key, () => subscriber.state(state));
+    }
   }
   function publish(source, value) {
     source.revision += 1;
     source.value = value;
     const frame = { key: source.key, revision: source.revision, value };
-    for (const subscriber of source.subscribers)
-      subscriber.value(frame);
+    for (const subscriber of source.subscribers) {
+      tell(source.key, () => subscriber.value(frame));
+    }
   }
   async function pump(source) {
     if (source.reading || closed)
@@ -1754,10 +1012,20 @@ function createWatchHub(config) {
           const source = acquire(operation, key, args);
           source.subscribers.add(subscriber);
           keys.add(id);
-          if (source.signature !== undefined) {
-            subscriber.value({ key, revision: source.revision, value: source.value });
+          try {
+            if (source.signature !== undefined) {
+              subscriber.value({ key, revision: source.revision, value: source.value });
+            }
+            subscriber.state(source.state);
+          } catch (error) {
+            source.subscribers.delete(subscriber);
+            keys.delete(id);
+            release(source);
+            return {
+              accepted: false,
+              reason: error instanceof Error ? error.message : String(error)
+            };
           }
-          subscriber.state(source.state);
           pump(source);
           return { accepted: true };
         },
@@ -1788,14 +1056,20 @@ function createWatchHub(config) {
     size: () => sources.size,
     close() {
       closed = true;
-      for (const source of sources.values()) {
+      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();
       }
-      sources.clear();
-      held.clear();
     }
   };
 }
@@ -1819,7 +1093,6 @@ export {
   defineKeyspace,
   createWatchHub,
   createManagedSchedule,
-  createDiagnosticJournal,
   createDecisionPipeline,
   createCreditWindow,
   createBoundedChannel,