stitchkit 0.77.0 → 0.78.0

package/dist/application.js

@@ -1,46 +1,26 @@
 import {
-  ActivityIdSchema,
-  ActivityLiveStateSchema,
-  ActivitySnapshotSchema,
-  ActivityStageIdSchema,
-  ActivityStageSnapshotSchema,
-  ActivityTokenBrand,
-  ApplicationSnapshotSinkStatusSchema,
+  createBackoff
+} from "./index-h4pj6fta.js";
+import {
+  argumentsDigest,
+  stableValue,
+  watchKeyString
+} from "./index-wfq8zerm.js";
+import {
   BoundedChannelPolicySchema,
   BoundedChannelReaderError,
   BoundedChannelSnapshotSchema,
   BoundedChannelStateSchema,
   CreditWindowSnapshotSchema,
-  ManagedScheduleDescriptorSchema,
-  ManagedScheduleErrorPolicySchema,
-  ManagedScheduleOverlapSchema,
-  ManagedScheduleStatusSchema,
-  createActivityProjection,
-  createApplicationSnapshotSink,
   createBoundedChannel,
-  createCreditWindow,
-  createManagedSchedule
-} from "./index-3cwck0rm.js";
+  createCreditWindow
+} from "./index-dmfn9m4x.js";
 import {
-  createBoundedSinkManager
-} from "./index-a59da114.js";
+  AppError
+} from "./index-0w9abg87.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";
+  isRecord
+} from "./index-ksp6e2ye.js";
 import {
   ApplicationAdmissionSnapshotSchema,
   ApplicationHealthSchema,
@@ -53,46 +33,315 @@ import {
   ManagedResourceSnapshotSchema,
   ManagedResourceStateSchema,
   projectApplicationStatus
-} from "./index-8eywc9zv.js";
-import"./index-3z73fh2c.js";
-import"./index-0w9abg87.js";
-import {
-  isRecord
-} from "./index-qyrqwr4c.js";
-// src/application/admission.ts
+} from "./index-kw12fsbc.js";
+
+// src/application/activity.ts
+import { z as z2 } from "zod";
+
+// src/application/latest-sink.ts
 import { z } from "zod";
-var PositiveSafeIntegerSchema = z.number().int().positive().safe();
-var BoundedRateBudgetSchema = z.object({
+var SnapshotRevisionSchema = z.number().int().nonnegative();
+var ApplicationSnapshotSinkStatusSchema = z.object({
+  accepting: z.boolean(),
+  received: z.number().int().nonnegative(),
+  accepted: z.number().int().nonnegative(),
+  rejected: z.number().int().nonnegative(),
+  delivered: z.number().int().nonnegative(),
+  coalesced: z.number().int().nonnegative(),
+  failed: z.number().int().nonnegative(),
+  inFlight: z.boolean(),
+  pending: z.boolean(),
+  lastAcceptedRevision: SnapshotRevisionSchema.optional(),
+  lastDeliveredRevision: SnapshotRevisionSchema.optional()
+}).strict().readonly();
+function createApplicationSnapshotSink(config) {
+  let accepting = true;
+  let received = 0;
+  let accepted = 0;
+  let rejected = 0;
+  let delivered = 0;
+  let coalesced = 0;
+  let failed = 0;
+  let lastAcceptedRevision;
+  let lastDeliveredRevision;
+  let inFlight;
+  let closePromise;
+  let resolveClose;
+  const pending = createBoundedChannel({
+    policy: "latest",
+    maxItems: 1,
+    maxBytes: 1,
+    sizeOf: () => 1
+  });
+  const getStatus = () => ApplicationSnapshotSinkStatusSchema.parse({
+    accepting,
+    received,
+    accepted,
+    rejected,
+    delivered,
+    coalesced,
+    failed,
+    inFlight: inFlight !== undefined,
+    pending: pending.getSnapshot().queuedItems > 0,
+    ...lastAcceptedRevision !== undefined && { lastAcceptedRevision },
+    ...lastDeliveredRevision !== undefined && { lastDeliveredRevision }
+  });
+  const reportFailure = (error, snapshot) => {
+    if (!config.onSinkError)
+      return;
+    Promise.resolve().then(() => config.onSinkError?.({ error, snapshot })).catch(() => {
+      return;
+    });
+  };
+  const settleCloseIfIdle = () => {
+    if (accepting || inFlight || pending.getSnapshot().queuedItems > 0 || !resolveClose)
+      return;
+    const resolve = resolveClose;
+    resolveClose = undefined;
+    resolve(getStatus());
+  };
+  const startWrite = (snapshot) => {
+    const write = Promise.resolve().then(() => config.write(snapshot)).then(() => {
+      delivered += 1;
+      lastDeliveredRevision = snapshot.revision;
+    }).catch((error) => {
+      failed += 1;
+      reportFailure(error, snapshot);
+    }).finally(() => {
+      if (pending.getSnapshot().queuedItems > 0) {
+        pending.next().then((next) => {
+          if (next.done) {
+            inFlight = undefined;
+            settleCloseIfIdle();
+          } else {
+            startWrite(next.value);
+          }
+        });
+      } else {
+        inFlight = undefined;
+        settleCloseIfIdle();
+      }
+    });
+    inFlight = write;
+  };
+  return {
+    publish(snapshot) {
+      received += 1;
+      const revision = SnapshotRevisionSchema.parse(snapshot.revision);
+      if (!accepting || lastAcceptedRevision !== undefined && revision <= lastAcceptedRevision) {
+        rejected += 1;
+        return false;
+      }
+      accepted += 1;
+      lastAcceptedRevision = revision;
+      if (!inFlight) {
+        startWrite(snapshot);
+      } else {
+        const offered = pending.offer(snapshot);
+        if (offered.outcome === "coalesced")
+          coalesced += offered.replaced;
+      }
+      return true;
+    },
+    getStatus,
+    close() {
+      if (closePromise)
+        return closePromise;
+      accepting = false;
+      pending.close({ mode: "drain" });
+      closePromise = new Promise((resolve) => {
+        resolveClose = resolve;
+        settleCloseIfIdle();
+      });
+      return closePromise;
+    }
+  };
+}
+
+// src/application/activity.ts
+var BoundedOperationalIdSchema = z2.string().min(1).max(64).regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]*$/);
+var NonNegativeIntegerSchema = z2.number().int().nonnegative();
+var ActivityIdSchema = BoundedOperationalIdSchema;
+var ActivityStageIdSchema = BoundedOperationalIdSchema;
+var ActivityStageSnapshotSchema = z2.object({
+  id: ActivityStageIdSchema,
+  active: NonNegativeIntegerSchema,
+  queued: NonNegativeIntegerSchema,
+  completed: NonNegativeIntegerSchema,
+  failed: NonNegativeIntegerSchema
+}).strict().readonly();
+var ActivityTotalsSchema = z2.object({
+  active: NonNegativeIntegerSchema,
+  queued: NonNegativeIntegerSchema,
+  completed: NonNegativeIntegerSchema,
+  failed: NonNegativeIntegerSchema
+}).strict().readonly();
+var ActivitySnapshotSchema = z2.object({
+  id: ActivityIdSchema,
+  epoch: z2.string().uuid(),
+  revision: NonNegativeIntegerSchema,
+  capturedAt: z2.string().datetime({ offset: true }),
+  changedAt: z2.string().datetime({ offset: true }),
+  stages: z2.array(ActivityStageSnapshotSchema).min(1).max(64).readonly(),
+  totals: ActivityTotalsSchema
+}).strict().readonly();
+var ActivityLiveStateSchema = z2.enum(["active", "queued"]);
+var ActivityTokenBrand = Symbol("stitchkit.application.activity");
+function emptyCounters() {
+  return { active: 0, queued: 0, completed: 0, failed: 0 };
+}
+function totalsOf(stages) {
+  return stages.reduce((totals, stage) => ({
+    active: totals.active + stage.active,
+    queued: totals.queued + stage.queued,
+    completed: totals.completed + stage.completed,
+    failed: totals.failed + stage.failed
+  }), emptyCounters());
+}
+function createActivityProjection(config) {
+  const id = ActivityIdSchema.parse(config.id);
+  const declaredStages = z2.array(ActivityStageIdSchema).min(1).max(64).parse(config.stages);
+  const uniqueStages = new Set(declaredStages);
+  if (uniqueStages.size !== declaredStages.length) {
+    throw new Error("[stitchkit] createActivityProjection: stage ids must be unique");
+  }
+  const epoch = z2.string().uuid().parse(config.epoch ?? crypto.randomUUID());
+  const now = config.now ?? (() => new Date);
+  const counters = new Map(declaredStages.map((stage) => [stage, emptyCounters()]));
+  const activities = new WeakMap;
+  const subscribers = new Set;
+  let revision = 0;
+  let changedAt = now().toISOString();
+  const countersFor = (stage) => {
+    const value = counters.get(stage);
+    if (!value) {
+      throw new Error(`[stitchkit] createActivityProjection: undeclared stage "${stage}"`);
+    }
+    return value;
+  };
+  const getSnapshot = () => {
+    const stages = declaredStages.map((stage) => ({ id: stage, ...countersFor(stage) }));
+    return ActivitySnapshotSchema.parse({
+      id,
+      epoch,
+      revision,
+      capturedAt: now().toISOString(),
+      changedAt,
+      stages,
+      totals: totalsOf(stages)
+    });
+  };
+  const publishChange = () => {
+    revision += 1;
+    changedAt = now().toISOString();
+    const snapshot = getSnapshot();
+    for (const subscriber of subscribers)
+      subscriber.publish(snapshot);
+  };
+  const requireActivity = (token) => {
+    const activity = activities.get(token);
+    if (!activity) {
+      throw new Error("[stitchkit] activity token belongs to another projection");
+    }
+    return activity;
+  };
+  const leaveLiveState = (activity) => {
+    if (activity.state === "active" || activity.state === "queued") {
+      countersFor(activity.stage)[activity.state] -= 1;
+    }
+  };
+  const settle = (token, terminal) => {
+    const activity = requireActivity(token);
+    if (activity.state === "completed" || activity.state === "failed")
+      return false;
+    leaveLiveState(activity);
+    countersFor(activity.stage)[terminal] += 1;
+    activity.state = terminal;
+    publishChange();
+    return true;
+  };
+  return {
+    open(stage, rawState = "active") {
+      const parsedStage = ActivityStageIdSchema.parse(stage);
+      const state = ActivityLiveStateSchema.parse(rawState);
+      countersFor(parsedStage)[state] += 1;
+      const token = Object.freeze({
+        get [ActivityTokenBrand]() {
+          return true;
+        }
+      });
+      activities.set(token, { stage: parsedStage, state });
+      publishChange();
+      return token;
+    },
+    transition(token, input) {
+      const activity = requireActivity(token);
+      if (activity.state === "completed" || activity.state === "failed") {
+        throw new Error("[stitchkit] cannot transition a terminal activity");
+      }
+      const stage = ActivityStageIdSchema.parse(input.stage);
+      const state = ActivityLiveStateSchema.parse(input.state);
+      countersFor(stage);
+      if (activity.stage === stage && activity.state === state)
+        return false;
+      leaveLiveState(activity);
+      countersFor(stage)[state] += 1;
+      activity.stage = stage;
+      activity.state = state;
+      publishChange();
+      return true;
+    },
+    complete: (token) => settle(token, "completed"),
+    fail: (token) => settle(token, "failed"),
+    getSnapshot,
+    subscribe(listener) {
+      const sink = createApplicationSnapshotSink({
+        write: listener,
+        ...config.onSubscriberError && { onSinkError: config.onSubscriberError }
+      });
+      subscribers.add(sink);
+      sink.publish(getSnapshot());
+      return () => {
+        subscribers.delete(sink);
+        sink.close();
+      };
+    }
+  };
+}
+// src/application/admission.ts
+import { z as z3 } from "zod";
+var PositiveSafeIntegerSchema = z3.number().int().positive().safe();
+var BoundedRateBudgetSchema = z3.object({
   limit: PositiveSafeIntegerSchema,
   intervalMs: PositiveSafeIntegerSchema
 }).strict().readonly();
-var BoundedAdmissionPerKeyLimitsSchema = z.object({
+var BoundedAdmissionPerKeyLimitsSchema = z3.object({
   maxConcurrent: PositiveSafeIntegerSchema,
   rate: BoundedRateBudgetSchema.optional()
 }).strict().readonly();
-var PerKeyLimitResolverSchema = z.custom((value) => typeof value === "function", { message: "perKey.limits must be a function of the key" });
-var BoundedAdmissionPolicySchema = z.object({
-  global: z.object({
+var PerKeyLimitResolverSchema = z3.custom((value) => typeof value === "function", { message: "perKey.limits must be a function of the key" });
+var BoundedAdmissionPolicySchema = z3.object({
+  global: z3.object({
     maxConcurrent: PositiveSafeIntegerSchema,
     rate: BoundedRateBudgetSchema.optional()
   }).strict(),
-  perKey: z.union([
-    z.object({
+  perKey: z3.union([
+    z3.object({
       maxConcurrent: PositiveSafeIntegerSchema,
       maxKeys: PositiveSafeIntegerSchema,
       rate: BoundedRateBudgetSchema.optional(),
-      limits: z.never().optional()
+      limits: z3.never().optional()
     }).strict(),
-    z.object({
+    z3.object({
       maxKeys: PositiveSafeIntegerSchema,
       limits: PerKeyLimitResolverSchema,
-      maxConcurrent: z.never().optional(),
-      rate: z.never().optional()
+      maxConcurrent: z3.never().optional(),
+      rate: z3.never().optional()
     }).strict()
   ]).optional()
 }).strict().readonly();
-var BoundedAdmissionStateSchema = z.enum(["accepting", "draining", "closed"]);
-var BoundedAdmissionRefusalReasonSchema = z.enum([
+var BoundedAdmissionStateSchema = z3.enum(["accepting", "draining", "closed"]);
+var BoundedAdmissionRefusalReasonSchema = z3.enum([
   "not-accepting",
   "global-concurrency",
   "key-required",
@@ -102,25 +351,25 @@ var BoundedAdmissionRefusalReasonSchema = z.enum([
   "key-rate",
   "upstream"
 ]);
-var RefusalCountersSchema = z.object({
-  "not-accepting": z.number().int().nonnegative(),
-  "global-concurrency": z.number().int().nonnegative(),
-  "key-required": z.number().int().nonnegative(),
-  "key-capacity": z.number().int().nonnegative(),
-  "key-concurrency": z.number().int().nonnegative(),
-  "global-rate": z.number().int().nonnegative(),
-  "key-rate": z.number().int().nonnegative(),
-  upstream: z.number().int().nonnegative()
+var RefusalCountersSchema = z3.object({
+  "not-accepting": z3.number().int().nonnegative(),
+  "global-concurrency": z3.number().int().nonnegative(),
+  "key-required": z3.number().int().nonnegative(),
+  "key-capacity": z3.number().int().nonnegative(),
+  "key-concurrency": z3.number().int().nonnegative(),
+  "global-rate": z3.number().int().nonnegative(),
+  "key-rate": z3.number().int().nonnegative(),
+  upstream: z3.number().int().nonnegative()
 }).strict().readonly();
-var BoundedAdmissionSnapshotSchema = z.object({
+var BoundedAdmissionSnapshotSchema = z3.object({
   state: BoundedAdmissionStateSchema,
-  active: z.number().int().nonnegative(),
-  accepted: z.number().int().nonnegative(),
-  released: z.number().int().nonnegative(),
-  refused: z.number().int().nonnegative(),
-  keys: z.number().int().nonnegative(),
-  globalRateSamples: z.number().int().nonnegative(),
-  keyRateSamples: z.number().int().nonnegative(),
+  active: z3.number().int().nonnegative(),
+  accepted: z3.number().int().nonnegative(),
+  released: z3.number().int().nonnegative(),
+  refused: z3.number().int().nonnegative(),
+  keys: z3.number().int().nonnegative(),
+  globalRateSamples: z3.number().int().nonnegative(),
+  keyRateSamples: z3.number().int().nonnegative(),
   refusals: RefusalCountersSchema
 }).strict().readonly();
 
@@ -433,12 +682,31 @@ function createBoundedAdmission(config) {
     getSnapshot
   };
 }
+// src/internal/deadline.ts
+async function withDeadline(value, timeoutMs) {
+  if (!(value instanceof Promise))
+    return { settled: true, value };
+  let timer;
+  const expiry = new Promise((resolve) => {
+    timer = setTimeout(() => resolve({ settled: false }), timeoutMs);
+  });
+  try {
+    return await Promise.race([
+      value.then((settledValue) => ({ settled: true, value: settledValue })),
+      expiry
+    ]);
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+  }
+}
+
 // src/internal/decision.ts
-import { z as z2 } from "zod";
-var PolicyDecisionSchema = z2.discriminatedUnion("outcome", [
-  z2.object({ outcome: z2.literal("allow") }).strict(),
-  z2.object({ outcome: z2.literal("deny"), reason: z2.string().min(1) }).strict(),
-  z2.object({ outcome: z2.literal("defer") }).strict()
+import { z as z4 } from "zod";
+var PolicyDecisionSchema = z4.discriminatedUnion("outcome", [
+  z4.object({ outcome: z4.literal("allow") }).strict(),
+  z4.object({ outcome: z4.literal("deny"), reason: z4.string().min(1) }).strict(),
+  z4.object({ outcome: z4.literal("defer") }).strict()
 ]);
 
 // src/application/decisions.ts
@@ -454,13 +722,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 +750,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,23 +779,20 @@ 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({
+import { z as z5 } from "zod";
+var PositiveSafeIntegerSchema2 = z5.number().int().positive().safe();
+var FileModeSchema = z5.number().int().min(0).max(511);
+var DiagnosticJournalLimitsSchema = z5.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([
+var DiagnosticJournalLockPolicySchema = z5.enum(["refuse", "reclaim-stale"]);
+var DiagnosticJournalStateSchema = z5.enum(["open", "draining", "closed", "failed"]);
+var DiagnosticJournalRefusalReasonSchema = z5.enum([
   "closed",
   "failed",
   "invalid",
@@ -518,704 +800,228 @@ var DiagnosticJournalRefusalReasonSchema = z3.enum([
   "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()
+var DiagnosticJournalRefusalCountersSchema = z5.object({
+  closed: z5.number().int().nonnegative(),
+  failed: z5.number().int().nonnegative(),
+  invalid: z5.number().int().nonnegative(),
+  oversized: z5.number().int().nonnegative(),
+  "item-capacity": z5.number().int().nonnegative(),
+  "byte-capacity": z5.number().int().nonnegative()
 }).strict().readonly();
-var DiagnosticJournalFailurePhaseSchema = z3.enum(["write", "rotation", "close"]);
-var DiagnosticJournalStatusSchema = z3.object({
+var DiagnosticJournalFailurePhaseSchema = z5.enum(["write", "rotation", "close"]);
+var DiagnosticJournalStatusSchema = z5.object({
   state: DiagnosticJournalStateSchema,
-  epoch: z3.uuid(),
+  epoch: z5.uuid(),
   limits: DiagnosticJournalLimitsSchema,
-  lock: z3.object({
+  lock: z5.object({
     policy: DiagnosticJournalLockPolicySchema,
-    reclaimedStale: z3.boolean()
+    reclaimedStale: z5.boolean()
   }).strict().readonly(),
-  received: z3.number().int().nonnegative(),
-  accepted: z3.number().int().nonnegative(),
-  refused: z3.number().int().nonnegative(),
+  received: z5.number().int().nonnegative(),
+  accepted: z5.number().int().nonnegative(),
+  refused: z5.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({
+  written: z5.number().int().nonnegative(),
+  failedRecords: z5.number().int().nonnegative(),
+  pendingItems: z5.number().int().nonnegative(),
+  pendingBytes: z5.number().int().nonnegative(),
+  inFlight: z5.boolean(),
+  rotations: z5.number().int().nonnegative(),
+  rotationFailures: z5.number().int().nonnegative(),
+  partialTails: z5.number().int().nonnegative(),
+  currentFileBytes: z5.number().int().nonnegative(),
+  retainedFiles: z5.number().int().nonnegative(),
+  lastAcceptedSequence: z5.number().int().positive().optional(),
+  lastWrittenSequence: z5.number().int().positive().optional(),
+  lastSettledSequence: z5.number().int().positive().optional(),
+  lastFailure: z5.object({
     phase: DiagnosticJournalFailurePhaseSchema,
-    sequence: z3.number().int().positive().optional()
+    sequence: z5.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()
+var DiagnosticJournalSubmitResultSchema = z5.discriminatedUnion("outcome", [
+  z5.object({
+    outcome: z5.literal("accepted"),
+    epoch: z5.uuid(),
+    sequence: z5.number().int().positive()
   }).strict().readonly(),
-  z3.object({
-    outcome: z3.literal("refused"),
+  z5.object({
+    outcome: z5.literal("refused"),
     reason: DiagnosticJournalRefusalReasonSchema
   }).strict().readonly()
 ]);
-var DiagnosticJournalWaitResultSchema = z3.object({
-  outcome: z3.enum(["settled", "timed-out", "cancelled"]),
+var DiagnosticJournalWaitResultSchema = z5.object({
+  outcome: z5.enum(["settled", "timed-out", "cancelled"]),
   state: DiagnosticJournalStateSchema,
-  throughSequence: z3.number().int().nonnegative(),
-  settledSequence: z3.number().int().nonnegative()
+  throughSequence: z5.number().int().nonnegative(),
+  settledSequence: z5.number().int().nonnegative()
 }).strict().readonly();
-var DiagnosticJournalCloseResultSchema = z3.object({
-  outcome: z3.enum(["closed", "timed-out", "cancelled"]),
+var DiagnosticJournalCloseResultSchema = z5.object({
+  outcome: z5.enum(["closed", "timed-out", "cancelled"]),
   state: DiagnosticJournalStateSchema,
-  pendingItems: z3.number().int().nonnegative()
+  pendingItems: z5.number().int().nonnegative()
 }).strict().readonly();
-var DiagnosticJournalFrameSchema = z3.object({
-  schemaVersion: z3.literal(1),
-  epoch: z3.uuid(),
-  sequence: z3.number().int().positive(),
-  event: z3.json()
+var DiagnosticJournalFrameSchema = z5.object({
+  schemaVersion: z5.literal(1),
+  epoch: z5.uuid(),
+  sequence: z5.number().int().positive(),
+  event: z5.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/events.ts
+import { z as z7 } from "zod";
 
-// 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/observability/status.ts
+import { z as z6 } from "zod";
+var NonNegativeIntegerSchema2 = z6.number().int().nonnegative();
+var ObservabilitySinkStatusSchema = z6.object({
+  capacity: NonNegativeIntegerSchema2,
+  received: NonNegativeIntegerSchema2,
+  accepted: NonNegativeIntegerSchema2,
+  filtered: NonNegativeIntegerSchema2,
+  completed: NonNegativeIntegerSchema2,
+  dropped: NonNegativeIntegerSchema2,
+  failed: NonNegativeIntegerSchema2,
+  preparationFailed: NonNegativeIntegerSchema2,
+  preparing: NonNegativeIntegerSchema2,
+  pending: NonNegativeIntegerSchema2,
+  closed: z6.boolean()
+}).readonly();
+var ObservabilityStatusObjectSchema = z6.object({
+  request: ObservabilitySinkStatusSchema.optional(),
+  tools: ObservabilitySinkStatusSchema.optional(),
+  total: ObservabilitySinkStatusSchema
+});
+var ObservabilityStatusSchema = ObservabilityStatusObjectSchema.readonly();
+var ObservabilityDrainReportSchema = ObservabilityStatusObjectSchema.extend({
+  durationMs: z6.number().nonnegative()
+}).readonly();
 
-// 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))
+// src/internal/observability-sink.ts
+var DEFAULT_MAX_PENDING = 1000;
+function invokeIsolated(callback) {
+  if (!callback)
     return;
-  const suffix = name.slice(prefix.length);
-  if (!/^\d+$/.test(suffix))
-    return;
-  const value = Number(suffix);
-  return Number.isSafeInteger(value) && value > 0 ? value : undefined;
+  Promise.resolve().then(callback).catch(() => {});
 }
-async function createRotatingDiagnosticJournalStorage(config) {
-  if (!isAbsolute(config.path) || resolve(config.path) !== config.path) {
-    throw new TypeError("Diagnostic journal path must be normalized and absolute");
+function createBoundedSinkManager(config) {
+  const maxPending = config.maxPending ?? DEFAULT_MAX_PENDING;
+  if (!Number.isSafeInteger(maxPending) || maxPending <= 0) {
+    throw new TypeError("Observability maxPending must be a positive safe integer");
   }
-  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 sequence = 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);
+  let received = 0;
+  let accepted = 0;
+  let filtered = 0;
+  let completed = 0;
+  let dropped = 0;
+  let failed = 0;
+  let preparationFailed = 0;
+  let closePromise;
+  const preparing = new Map;
+  const writes = new Map;
+  const reportError = (error, event) => {
+    invokeIsolated(config.onSinkError ? () => config.onSinkError?.({ error, ...event !== undefined && { event } }) : undefined);
   };
-  const rotate = async () => {
+  const reportDrop = (reason, event) => {
+    invokeIsolated(config.onDrop ? () => config.onDrop?.({ reason, event, pending: writes.size }) : undefined);
+  };
+  const admit = (id, event) => {
     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));
+      if (config.filter && !config.filter(event)) {
+        filtered += 1;
+        return;
       }
-      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(() => {
+      preparationFailed += 1;
+      reportError(error, event);
       return;
-    });
-    await unlink2(lockPath).catch(() => {
+    }
+    if (writes.size >= maxPending) {
+      dropped += 1;
+      reportDrop("capacity", event);
       return;
-    });
-    throw error;
-  }
-  const snapshot = () => ({
-    currentFileBytes,
-    retainedFiles,
-    rotations,
-    partialTails
-  });
+    }
+    accepted += 1;
+    const write = Promise.resolve().then(() => config.write(event)).then(() => {
+      completed += 1;
+    }).catch((error) => {
+      failed += 1;
+      reportError(error, event);
+    }).finally(() => writes.delete(id));
+    writes.set(id, write);
+  };
+  const awaitGeneration = async (boundary) => {
+    const through = (values) => [...values].filter(([id]) => id <= boundary).map(([, value]) => value);
+    await Promise.allSettled(through(preparing));
+    await Promise.allSettled(through(writes));
+  };
   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
+    submit(produce) {
+      received += 1;
+      const id = ++sequence;
+      if (closed) {
+        Promise.resolve().then(produce).then((event) => {
+          dropped += 1;
+          reportDrop("closed", event);
+        }).catch((error) => {
+          preparationFailed += 1;
+          reportError(error);
         });
+        return;
       }
+      const preparation = Promise.resolve().then(produce).then((event) => admit(id, event)).catch((error) => {
+        preparationFailed += 1;
+        reportError(error);
+      }).finally(() => preparing.delete(id));
+      preparing.set(id, preparation);
     },
-    snapshot,
-    async close() {
-      if (closed)
-        return;
+    flush() {
+      return awaitGeneration(sequence);
+    },
+    getStatus,
+    close() {
+      if (closePromise)
+        return closePromise;
       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
-        });
-      }
+      closePromise = awaitGeneration(sequence).then(getStatus);
+      return closePromise;
     }
   };
-}
-
-// 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");
+  function getStatus() {
+    return ObservabilitySinkStatusSchema.parse({
+      capacity: maxPending,
+      received,
+      accepted,
+      filtered,
+      completed,
+      dropped,
+      failed,
+      preparationFailed,
+      preparing: preparing.size,
+      pending: writes.size,
+      closed
+    });
   }
-  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"),
+var ApplicationLifecycleEventSchema = z7.object({
+  type: z7.literal("application-state"),
   applicationId: ApplicationIdSchema,
-  epoch: z5.string().uuid(),
-  revision: z5.number().int().nonnegative(),
+  epoch: z7.string().uuid(),
+  revision: z7.number().int().nonnegative(),
   lifecycle: ApplicationLifecycleSchema,
   health: ApplicationHealthSchema,
-  ready: z5.boolean(),
-  capturedAt: z5.string().datetime({ offset: true }),
-  resources: z5.array(ManagedResourceSnapshotSchema).readonly()
+  ready: z7.boolean(),
+  capturedAt: z7.string().datetime({ offset: true }),
+  resources: z7.array(ManagedResourceSnapshotSchema).readonly()
 }).strict().readonly();
 function applicationLifecycleEvent(snapshot) {
   return ApplicationLifecycleEventSchema.parse({
@@ -1246,13 +1052,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 z8 } from "zod";
+var ApplicationHealthHandlerOptionsSchema = z8.object({
+  kind: z8.enum(["liveness", "readiness"]),
+  retryAfterSeconds: z8.number().int().nonnegative().default(5)
 });
-var ApplicationOperationalHandlersOptionsSchema = z6.object({
-  retryAfterSeconds: z6.number().int().nonnegative().default(5)
+var ApplicationOperationalHandlersOptionsSchema = z8.object({
+  retryAfterSeconds: z8.number().int().nonnegative().default(5)
 });
 function createApplicationHealthHandler(application, options) {
   const parsed = ApplicationHealthHandlerOptionsSchema.parse(options);
@@ -1279,6 +1085,901 @@ function createApplicationOperationalHandlers(application, options = {}) {
     })
   };
 }
+// src/application/kernel.ts
+import { z as z10 } from "zod";
+
+// src/server/shutdown.ts
+import { z as z9 } from "zod";
+
+// src/server/http-stream-lifetime.ts
+var requests = new WeakMap;
+
+// src/server/shutdown.ts
+var ShutdownStateSchema = z9.enum([
+  "running",
+  "draining-http",
+  "closing-realtime",
+  "stopping-runtime",
+  "clean",
+  "forced"
+]);
+var ShutdownOptionsSchema = z9.object({
+  gracePeriodMs: z9.number().int().nonnegative().default(30000),
+  realtimeCloseTimeoutMs: z9.number().int().nonnegative().default(1000),
+  forceTimeoutMs: z9.number().int().nonnegative().default(5000),
+  retryAfterSeconds: z9.number().int().nonnegative().default(5),
+  signal: z9.custom((value) => typeof value === "object" && value !== null && ("aborted" in value) && ("addEventListener" in value), "Expected an AbortSignal").optional()
+});
+var ShutdownStatusSchema = z9.object({
+  state: ShutdownStateSchema,
+  acceptedRequests: z9.number().int().nonnegative(),
+  completedRequests: z9.number().int().nonnegative(),
+  pendingRequests: z9.number().int().nonnegative(),
+  pendingWebSockets: z9.number().int().nonnegative()
+});
+var ShutdownResultSchema = z9.object({
+  outcome: z9.enum(["clean", "forced"]),
+  reason: z9.enum(["deadline", "signal"]).optional(),
+  acceptedRequests: z9.number().int().nonnegative(),
+  completedRequests: z9.number().int().nonnegative(),
+  pendingRequests: z9.number().int().nonnegative(),
+  pendingWebSockets: z9.number().int().nonnegative(),
+  pendingRequestsAtForce: z9.number().int().nonnegative(),
+  pendingWebSocketsAtForce: z9.number().int().nonnegative(),
+  abortedRequests: z9.number().int().nonnegative(),
+  forcedWebSockets: z9.number().int().nonnegative(),
+  durationMs: z9.number().nonnegative()
+});
+
+// src/application/resource.ts
+function managedResourceDependencyId(dependency) {
+  return typeof dependency === "string" ? dependency : dependency.id;
+}
+function defineManagedResource(resource) {
+  return resource;
+}
+
+// src/application/graph.ts
+function resolveResourceGraph(resources) {
+  const entries = resources.map((resource, declarationIndex) => ({
+    resource,
+    id: ApplicationIdSchema.parse(resource.id),
+    dependsOn: [...resource.dependsOn ?? []].map((dependency) => ApplicationIdSchema.parse(managedResourceDependencyId(dependency))),
+    required: resource.required ?? true,
+    declarationIndex
+  }));
+  const byId = new Map;
+  for (const entry of entries) {
+    if (byId.has(entry.id)) {
+      throw new Error(`[stitchkit] createApplication: duplicate resource id "${entry.id}"`);
+    }
+    byId.set(entry.id, entry);
+  }
+  for (const entry of entries) {
+    for (const dependencyId of entry.dependsOn) {
+      const dependency = byId.get(dependencyId);
+      if (!dependency) {
+        throw new Error(`[stitchkit] createApplication: resource "${entry.id}" depends on missing resource "${dependencyId}"`);
+      }
+      if (entry.required && !dependency.required) {
+        throw new Error(`[stitchkit] createApplication: required resource "${entry.id}" cannot depend on optional resource "${dependencyId}"`);
+      }
+    }
+  }
+  const pending = new Map(entries.map((entry) => [entry.id, entry]));
+  const resolved = new Set;
+  const ordered = [];
+  while (pending.size > 0) {
+    const ready = [...pending.values()].filter((entry) => entry.dependsOn.every((id) => resolved.has(id))).sort((left, right) => left.declarationIndex - right.declarationIndex);
+    if (ready.length === 0) {
+      throw new Error(`[stitchkit] createApplication: resource dependency cycle: ${[...pending.keys()].join(", ")}`);
+    }
+    for (const entry of ready) {
+      pending.delete(entry.id);
+      resolved.add(entry.id);
+      ordered.push(entry);
+    }
+  }
+  return ordered;
+}
+
+// src/application/kernel.ts
+class ResourceCompletionBeforeReadyError extends Error {
+  constructor(resourceId, cause) {
+    super(`[stitchkit] resource "${resourceId}" completed before reaching readiness`, {
+      ...cause !== undefined && { cause }
+    });
+    this.name = "ResourceCompletionBeforeReadyError";
+  }
+}
+
+class ApplicationStartupInterruptedError extends Error {
+  constructor() {
+    super("[stitchkit] application startup interrupted by shutdown");
+    this.name = "ApplicationStartupInterruptedError";
+  }
+}
+var ApplicationShutdownOptionsSchema = ShutdownOptionsSchema.pick({
+  gracePeriodMs: true,
+  forceTimeoutMs: true,
+  signal: true
+});
+var ApplicationShutdownBudgetSchema = ShutdownOptionsSchema.pick({
+  gracePeriodMs: true,
+  forceTimeoutMs: true
+});
+var ApplicationRestartInputSchema = z10.object({
+  resourceId: z10.string().min(1),
+  gracePeriodMs: z10.number().int().nonnegative().optional(),
+  forceTimeoutMs: z10.number().int().nonnegative().optional()
+}).strict().readonly();
+var ApplicationRestartOutcomeSchema = z10.enum(["restarted", "failed", "refused"]);
+var ApplicationRestartResultSchema = z10.object({
+  resourceId: z10.string(),
+  affected: z10.array(z10.string()).readonly(),
+  outcome: ApplicationRestartOutcomeSchema,
+  reason: z10.string().optional(),
+  durationMs: z10.number().int().nonnegative()
+}).strict().readonly();
+
+class ApplicationAdmissionError extends AppError {
+  constructor() {
+    super("APPLICATION_NOT_ACCEPTING", "Application is not accepting new operations", 503);
+    this.name = "ApplicationAdmissionError";
+  }
+}
+function isStartResult(value) {
+  return typeof value === "object" && value !== null;
+}
+function waitForAbort(signal) {
+  if (signal.aborted)
+    return Promise.resolve();
+  return new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
+}
+async function untilDeadline(work, signal) {
+  const result = await Promise.race([
+    work.then((value) => ({ settled: true, value }), (error) => ({ settled: true, error })),
+    waitForAbort(signal).then(() => ({ settled: false }))
+  ]);
+  return result;
+}
+function createApplication(config) {
+  const id = ApplicationIdSchema.parse(config.id);
+  const ordered = resolveResourceGraph(config.resources ?? []);
+  const shutdownBudget = ApplicationShutdownBudgetSchema.parse(config.shutdown ?? {});
+  const reverse = [...ordered].reverse();
+  const reportFailure = (resourceId, phase, error) => {
+    if (!config.onResourceFailure)
+      return;
+    try {
+      Promise.resolve(config.onResourceFailure({ resourceId, phase, error })).catch(() => {
+        return;
+      });
+    } catch {}
+  };
+  const published = new Map;
+  const records = new Map;
+  for (const entry of ordered) {
+    records.set(entry.id, {
+      entry,
+      state: "registered",
+      health: "unknown",
+      healthReported: false,
+      everHealthy: false,
+      attempted: false,
+      activated: false,
+      closeInvoked: false,
+      closed: false,
+      failures: []
+    });
+  }
+  const epoch = crypto.randomUUID();
+  const listeners = new Set;
+  const lifetimeAbort = new AbortController;
+  const startupAbort = new AbortController;
+  let lifecycle = "created";
+  let revision = 0;
+  let changedAt = new Date().toISOString();
+  let accepting = false;
+  let accepted = 0;
+  let completed = 0;
+  let pending = 0;
+  let startPromise;
+  let shutdownPromise;
+  let shutdownRequested = false;
+  let activationComplete = false;
+  const pendingWaiters = new Set;
+  const aggregateHealth = () => {
+    if (lifecycle === "created" || lifecycle === "starting")
+      return "unknown";
+    let optionalUnhealthy = false;
+    for (const record of records.values()) {
+      if (record.entry.required && (record.state !== "ready" || record.health !== "healthy")) {
+        return "unhealthy";
+      }
+      if (!record.entry.required && (record.state !== "ready" || record.health !== "healthy")) {
+        optionalUnhealthy = true;
+      }
+    }
+    return optionalUnhealthy ? "degraded" : "healthy";
+  };
+  const isReady = () => lifecycle === "ready" && [...records.values()].every((record) => !record.entry.required || record.state === "ready" && record.health === "healthy");
+  const snapshot = () => ApplicationSnapshotSchema.parse({
+    id,
+    epoch,
+    revision,
+    lifecycle,
+    health: aggregateHealth(),
+    ready: isReady(),
+    capturedAt: new Date().toISOString(),
+    changedAt,
+    admission: { accepting, accepted, completed, pending },
+    resources: ordered.map((entry) => {
+      const record = records.get(entry.id);
+      if (!record)
+        throw new Error("Managed resource record disappeared");
+      return {
+        id: entry.id,
+        required: entry.required,
+        dependsOn: entry.dependsOn,
+        state: record.state,
+        health: record.health,
+        ready: record.state === "ready" && record.health === "healthy"
+      };
+    })
+  });
+  const publish = () => {
+    revision += 1;
+    changedAt = new Date().toISOString();
+    const value = snapshot();
+    for (const listener of listeners) {
+      try {
+        listener(value);
+      } catch {}
+    }
+    if (config.onSnapshot) {
+      Promise.resolve().then(() => config.onSnapshot?.(value)).catch(() => {});
+    }
+  };
+  const contextFor = (record, options = {}) => ({
+    applicationId: id,
+    signal: options.signal ?? lifetimeAbort.signal,
+    ...options.deadlineAt !== undefined && { deadlineAt: options.deadlineAt },
+    ...options.forceDeadlineAt !== undefined && {
+      forceDeadlineAt: options.forceDeadlineAt
+    },
+    now: () => performance.now(),
+    use(resource) {
+      const dependencyId = resource?.id;
+      if (typeof dependencyId !== "string" || dependencyId.length === 0) {
+        throw new Error(`[stitchkit] resource "${record.entry.id}": use() takes a managed resource, and this one has no id`);
+      }
+      if (!record.entry.dependsOn.includes(dependencyId)) {
+        throw new Error(`[stitchkit] resource "${record.entry.id}" used "${dependencyId}" without declaring it in dependsOn`);
+      }
+      if (!published.has(dependencyId)) {
+        throw new Error(`[stitchkit] resource "${record.entry.id}" used "${dependencyId}", which published no value from start()`);
+      }
+      return published.get(dependencyId);
+    },
+    reportHealth(health) {
+      if (record.state === "stopped")
+        return;
+      record.health = health;
+      record.healthReported = true;
+      if (health === "healthy")
+        record.everHealthy = true;
+      accepting = activationComplete && !shutdownRequested && isReady();
+      publish();
+    }
+  });
+  const markLateCompletion = (record, failure) => {
+    if (shutdownRequested || record.state === "stopping" || record.state === "stopped")
+      return;
+    if (failure) {
+      record.failures.push("completion");
+      reportFailure(record.entry.id, "completion", failure.error);
+    }
+    record.state = "failed";
+    record.health = "unhealthy";
+    accepting = activationComplete && isReady();
+    publish();
+  };
+  const closeAttempted = async () => {
+    const errors = [];
+    const rollbackStartedAt = performance.now();
+    const rollbackDeadlineAt = rollbackStartedAt + shutdownBudget.gracePeriodMs;
+    const rollbackForceDeadlineAt = rollbackDeadlineAt + shutdownBudget.forceTimeoutMs;
+    const rollbackAbort = new AbortController;
+    const rollbackTimer = setTimeout(() => rollbackAbort.abort(), Math.max(0, rollbackForceDeadlineAt - performance.now()));
+    try {
+      await closeEachAttempted(rollbackAbort.signal, errors, {
+        deadlineAt: rollbackDeadlineAt,
+        forceDeadlineAt: rollbackForceDeadlineAt
+      });
+    } finally {
+      clearTimeout(rollbackTimer);
+    }
+    return errors;
+  };
+  const closeEachAttempted = async (bound, errors, deadlines) => {
+    for (const entry of reverse) {
+      const record = records.get(entry.id);
+      if (!record?.attempted || record.closed)
+        continue;
+      record.state = "stopping";
+      try {
+        record.closeInvoked = true;
+        const settled = await untilDeadline(Promise.resolve(entry.resource.close?.(contextFor(record, { signal: startupAbort.signal, ...deadlines }))), bound);
+        if (!settled.settled) {
+          record.failures.push("close");
+          record.state = "failed";
+          const timedOut = new Error(`[stitchkit] resource "${entry.id}" did not finish closing during rollback`);
+          reportFailure(entry.id, "close", timedOut);
+          errors.push(timedOut);
+          publish();
+          break;
+        }
+        if (settled.error !== undefined)
+          throw settled.error;
+        record.closed = true;
+        record.state = "stopped";
+      } catch (error) {
+        record.failures.push("close");
+        record.state = "failed";
+        reportFailure(entry.id, "close", error);
+        errors.push(error);
+      }
+      publish();
+    }
+  };
+  const startEach = async (entries, signal) => {
+    for (const entry of entries) {
+      if (shutdownRequested || signal.aborted) {
+        throw new ApplicationStartupInterruptedError;
+      }
+      const record = records.get(entry.id);
+      if (!record)
+        throw new Error("Managed resource record disappeared");
+      const dependencyFailed = entry.dependsOn.some((dependencyId) => records.get(dependencyId)?.state !== "ready");
+      if (dependencyFailed) {
+        record.state = "failed";
+        record.health = "unhealthy";
+        record.failures.push("start");
+        publish();
+        if (entry.required) {
+          throw new Error(`[stitchkit] required resource "${entry.id}" has an unavailable dependency`);
+        }
+        continue;
+      }
+      record.attempted = true;
+      record.state = "starting";
+      publish();
+      try {
+        const started = await entry.resource.start(contextFor(record, { signal }));
+        if (shutdownRequested || signal.aborted) {
+          throw new ApplicationStartupInterruptedError;
+        }
+        if (isStartResult(started)) {
+          record.runtime = started;
+          if (started.value !== undefined)
+            published.set(entry.id, started.value);
+          let resourceReady = started.ready === undefined;
+          let completionSettled = false;
+          let completionFailure;
+          const completion = started.completion?.then(() => {
+            completionSettled = true;
+            if (resourceReady)
+              markLateCompletion(record);
+          }, (error) => {
+            completionSettled = true;
+            completionFailure = error;
+            if (resourceReady)
+              markLateCompletion(record, { error });
+          });
+          if (started.ready && completion) {
+            const readiness = started.ready.then(() => "ready");
+            const completionBeforeReady = completion.then(() => "completion");
+            const first = await Promise.race([readiness, completionBeforeReady]);
+            if (first === "completion") {
+              throw new ResourceCompletionBeforeReadyError(entry.id, completionFailure);
+            }
+            resourceReady = true;
+            if (completionSettled) {
+              throw new ResourceCompletionBeforeReadyError(entry.id, completionFailure);
+            }
+          } else if (started.ready) {
+            await started.ready;
+            resourceReady = true;
+          } else if (completion) {}
+        }
+        if (shutdownRequested || signal.aborted) {
+          throw new ApplicationStartupInterruptedError;
+        }
+        record.state = "ready";
+        if (!record.healthReported) {
+          record.health = "healthy";
+          record.everHealthy = true;
+        }
+        publish();
+      } catch (error) {
+        const interrupted = shutdownRequested || signal.aborted;
+        if (!(error instanceof ApplicationStartupInterruptedError)) {
+          record.failures.push(error instanceof ResourceCompletionBeforeReadyError ? "completion" : record.runtime?.ready ? "ready" : "start");
+          record.state = "failed";
+          record.health = "unhealthy";
+          reportFailure(entry.id, record.failures[record.failures.length - 1] ?? "start", error);
+          publish();
+        }
+        if (interrupted || entry.required)
+          throw error;
+      }
+    }
+  };
+  const activateEach = async (entries, signal) => {
+    for (const entry of entries) {
+      if (shutdownRequested || signal.aborted) {
+        throw new ApplicationStartupInterruptedError;
+      }
+      const record = records.get(entry.id);
+      if (record?.state !== "ready")
+        continue;
+      const dependencyUnavailable = entry.dependsOn.some((dependencyId) => {
+        const dependency = records.get(dependencyId);
+        return dependency?.state !== "ready" || !dependency.activated;
+      });
+      if (dependencyUnavailable) {
+        record.failures.push("start");
+        record.state = "failed";
+        record.health = "unhealthy";
+        publish();
+        if (entry.required) {
+          throw new Error(`[stitchkit] required resource "${entry.id}" has an unavailable activation dependency`);
+        }
+        continue;
+      }
+      try {
+        await entry.resource.activate?.(contextFor(record));
+        if (shutdownRequested || signal.aborted) {
+          throw new ApplicationStartupInterruptedError;
+        }
+        record.activated = true;
+        if (entry.required && (record.state !== "ready" || record.health !== "healthy")) {
+          const observed = `${record.state}/${record.health}`;
+          throw new Error(record.everHealthy ? `[stitchkit] required resource "${entry.id}" lost readiness during activation (${observed})` : `[stitchkit] required resource "${entry.id}" is not healthy (${observed}). A required resource must be healthy for the application to be ready; a resource that is expected to start degraded belongs behind \`required: false\`.`);
+        }
+      } catch (error) {
+        const interrupted = shutdownRequested || signal.aborted;
+        if (!(error instanceof ApplicationStartupInterruptedError)) {
+          record.failures.push("start");
+          record.state = "failed";
+          record.health = "unhealthy";
+          reportFailure(entry.id, "start", error);
+          publish();
+        }
+        if (interrupted || entry.required)
+          throw error;
+      }
+    }
+  };
+  const subtreeOf = (resourceId) => {
+    const affected = new Set([resourceId]);
+    for (const entry of ordered) {
+      if (entry.dependsOn.some((dependencyId) => affected.has(dependencyId))) {
+        affected.add(entry.id);
+      }
+    }
+    return ordered.filter((entry) => affected.has(entry.id));
+  };
+  const closeOne = async (entry, record, signal, deadlines) => {
+    const context = () => contextFor(record, { ...deadlines, signal });
+    if (record.attempted && !record.closed) {
+      const phase = async (work, what) => {
+        const settled = await untilDeadline(Promise.resolve(work), signal);
+        if (!settled.settled) {
+          throw new Error(`[stitchkit] resource "${entry.id}" did not ${what} within the restart budget`);
+        }
+        if (settled.error !== undefined)
+          throw settled.error;
+      };
+      await phase(entry.resource.stopAdmission?.(context()), "stop admitting");
+      await phase(entry.resource.drain?.(context()), "drain");
+      record.closeInvoked = true;
+      await phase(entry.resource.close?.(context()), "close");
+    }
+    record.closed = false;
+    record.closeInvoked = false;
+    record.attempted = false;
+    record.activated = false;
+    record.state = "registered";
+    record.health = "unknown";
+    record.healthReported = false;
+    record.runtime = undefined;
+    published.delete(entry.id);
+  };
+  let restarting = Promise.resolve();
+  const runRestart = async (input) => {
+    const startedAt = Date.now();
+    const parsed = ApplicationRestartInputSchema.parse(input);
+    const affected = subtreeOf(parsed.resourceId);
+    const affectedIds = affected.map((entry) => entry.id);
+    const refuse = (reason) => ({
+      resourceId: parsed.resourceId,
+      affected: affectedIds,
+      outcome: "refused",
+      reason,
+      durationMs: Date.now() - startedAt
+    });
+    if (!records.has(parsed.resourceId)) {
+      return refuse(`no resource is registered as "${parsed.resourceId}"`);
+    }
+    if (shutdownRequested) {
+      return refuse("the application is shutting down");
+    }
+    if (lifecycle !== "ready") {
+      return refuse(`the application is ${lifecycle}, not ready`);
+    }
+    const budget = {
+      gracePeriodMs: parsed.gracePeriodMs ?? shutdownBudget.gracePeriodMs,
+      forceTimeoutMs: parsed.forceTimeoutMs ?? shutdownBudget.forceTimeoutMs
+    };
+    const closeDeadlineAt = performance.now() + budget.gracePeriodMs;
+    const deadlines = {
+      deadlineAt: closeDeadlineAt,
+      forceDeadlineAt: closeDeadlineAt + budget.forceTimeoutMs
+    };
+    const restartAbort = new AbortController;
+    const closeTimer = setTimeout(() => restartAbort.abort(), Math.max(0, deadlines.forceDeadlineAt - performance.now()));
+    const stillFailed = () => affectedIds.filter((id2) => records.get(id2)?.state === "failed");
+    try {
+      for (const entry of [...affected].reverse()) {
+        const record = records.get(entry.id);
+        if (record)
+          await closeOne(entry, record, restartAbort.signal, deadlines);
+      }
+      publish();
+      await startEach(affected, restartAbort.signal);
+      await activateEach(affected, restartAbort.signal);
+      publish();
+      const failed = stillFailed();
+      if (failed.length > 0) {
+        return {
+          resourceId: parsed.resourceId,
+          affected: affectedIds,
+          outcome: "failed",
+          reason: `did not come back: ${failed.join(", ")}`,
+          durationMs: Date.now() - startedAt
+        };
+      }
+      return {
+        resourceId: parsed.resourceId,
+        affected: affectedIds,
+        outcome: "restarted",
+        durationMs: Date.now() - startedAt
+      };
+    } catch (error) {
+      restartAbort.abort();
+      publish();
+      return {
+        resourceId: parsed.resourceId,
+        affected: affectedIds,
+        outcome: "failed",
+        reason: error instanceof Error ? error.message : String(error),
+        durationMs: Date.now() - startedAt
+      };
+    } finally {
+      clearTimeout(closeTimer);
+    }
+  };
+  const runStart = async () => {
+    lifecycle = "starting";
+    publish();
+    let startFailure;
+    try {
+      await startEach(ordered, startupAbort.signal);
+      lifecycle = "ready";
+      publish();
+      await activateEach(ordered, startupAbort.signal);
+      if (shutdownRequested) {
+        throw new ApplicationStartupInterruptedError;
+      }
+      if (!isReady()) {
+        const blocking = [...records.values()].filter((record) => record.entry.required && (record.state !== "ready" || record.health !== "healthy")).map((record) => `${record.entry.id} (${record.state}/${record.health})`);
+        if (blocking.length === 0)
+          blocking.push("(none identified)");
+        const chosen = [...records.values()].some((record) => record.entry.required && record.health !== "healthy" && !record.everHealthy);
+        throw new Error(`[stitchkit] the application is not ready after startup — required ${blocking.length === 1 ? "resource" : "resources"} ${blocking.join(", ")}. A required resource must be healthy for the application to be ready; ${chosen ? "a resource that is expected to start degraded belongs behind `required: false`." : "this one was healthy and stopped being so — read `onResourceFailure` for the cause."}`);
+      }
+      activationComplete = true;
+      accepting = isReady();
+      publish();
+      return snapshot();
+    } catch (error) {
+      startFailure = error;
+    }
+    if (!shutdownRequested) {
+      const rollbackErrors = await closeAttempted();
+      lifecycle = "failed";
+      accepting = false;
+      publish();
+      if (rollbackErrors.length > 0) {
+        throw new AggregateError([startFailure, ...rollbackErrors], "[stitchkit] application startup and rollback failed", { cause: startFailure });
+      }
+    }
+    throw startFailure;
+  };
+  const start = () => {
+    if (startPromise)
+      return startPromise;
+    if (lifecycle !== "created") {
+      return Promise.reject(new Error(`[stitchkit] application cannot start from lifecycle "${lifecycle}"`));
+    }
+    startPromise = runStart();
+    startPromise.catch(() => {
+      return;
+    });
+    return startPromise;
+  };
+  const acquire = () => {
+    if (!accepting || !isReady())
+      return null;
+    accepted += 1;
+    pending += 1;
+    publish();
+    let released = false;
+    return {
+      get released() {
+        return released;
+      },
+      release() {
+        if (released)
+          return;
+        released = true;
+        pending -= 1;
+        completed += 1;
+        if (pending === 0) {
+          for (const waiter of pendingWaiters)
+            waiter();
+          pendingWaiters.clear();
+        }
+        publish();
+      }
+    };
+  };
+  const run = async (work) => {
+    const lease = acquire();
+    if (!lease)
+      throw new ApplicationAdmissionError;
+    try {
+      return await work();
+    } finally {
+      lease.release();
+    }
+  };
+  const waitForPending = () => {
+    if (pending === 0)
+      return Promise.resolve();
+    return new Promise((resolve) => pendingWaiters.add(resolve));
+  };
+  const shutdown = (options) => {
+    if (shutdownPromise)
+      return shutdownPromise;
+    const requested = options ?? {};
+    const parsed = ApplicationShutdownOptionsSchema.parse({
+      gracePeriodMs: requested.gracePeriodMs ?? shutdownBudget.gracePeriodMs,
+      forceTimeoutMs: requested.forceTimeoutMs ?? shutdownBudget.forceTimeoutMs,
+      ...requested.signal !== undefined && { signal: requested.signal }
+    });
+    const startedAt = performance.now();
+    const graceDeadlineAt = startedAt + parsed.gracePeriodMs;
+    const forceDeadlineAt = graceDeadlineAt + parsed.forceTimeoutMs;
+    shutdownRequested = true;
+    accepting = false;
+    startupAbort.abort();
+    lifecycle = lifecycle === "created" ? "stopping" : "draining";
+    publish();
+    shutdownPromise = (async () => {
+      const gracefulAbort = new AbortController;
+      let forcedReason;
+      let gracefulFailed = [...records.values()].some((record) => record.attempted && record.closeInvoked && !record.closed);
+      const force = (reason) => {
+        if (forcedReason)
+          return;
+        forcedReason = reason;
+        gracefulAbort.abort();
+        lifetimeAbort.abort();
+      };
+      const graceTimer = setTimeout(() => force("deadline"), Math.max(0, graceDeadlineAt - performance.now()));
+      const onExternalAbort = () => force("signal");
+      parsed.signal?.addEventListener("abort", onExternalAbort, { once: true });
+      if (parsed.signal?.aborted)
+        force("signal");
+      if (startPromise) {
+        await untilDeadline(startPromise.catch(() => {
+          return;
+        }), gracefulAbort.signal);
+      }
+      const gracefulContext = (record) => contextFor(record, {
+        signal: gracefulAbort.signal,
+        deadlineAt: graceDeadlineAt,
+        forceDeadlineAt
+      });
+      for (const entry of reverse) {
+        if (gracefulAbort.signal.aborted)
+          break;
+        const record = records.get(entry.id);
+        if (!record?.attempted || record.closed)
+          continue;
+        try {
+          const result = await untilDeadline(Promise.resolve(entry.resource.stopAdmission?.(gracefulContext(record))), gracefulAbort.signal);
+          if (!result.settled)
+            break;
+          if (result.error !== undefined)
+            throw result.error;
+        } catch (error) {
+          record.failures.push("admission");
+          reportFailure(entry.id, "admission", error);
+          gracefulFailed = true;
+          lifetimeAbort.abort();
+        }
+      }
+      if (!gracefulAbort.signal.aborted && !gracefulFailed) {
+        const result = await untilDeadline(waitForPending(), gracefulAbort.signal);
+        if (!result.settled)
+          force("deadline");
+      }
+      for (const entry of reverse) {
+        if (gracefulAbort.signal.aborted || gracefulFailed)
+          break;
+        const record = records.get(entry.id);
+        if (!record?.attempted || record.closed)
+          continue;
+        record.state = "stopping";
+        publish();
+        try {
+          const drained = await untilDeadline(Promise.resolve(entry.resource.drain?.(gracefulContext(record))), gracefulAbort.signal);
+          if (!drained.settled) {
+            force("deadline");
+            break;
+          }
+          if (drained.error !== undefined)
+            throw drained.error;
+        } catch (error) {
+          record.failures.push("drain");
+          reportFailure(entry.id, "drain", error);
+          gracefulFailed = true;
+          lifetimeAbort.abort();
+          break;
+        }
+      }
+      lifecycle = "stopping";
+      publish();
+      for (const entry of reverse) {
+        if (gracefulAbort.signal.aborted || gracefulFailed)
+          break;
+        const record = records.get(entry.id);
+        if (!record?.attempted || record.closed || record.closeInvoked)
+          continue;
+        try {
+          record.closeInvoked = true;
+          const closed = await untilDeadline(Promise.resolve(entry.resource.close?.(gracefulContext(record))), gracefulAbort.signal);
+          if (!closed.settled) {
+            force("deadline");
+            break;
+          }
+          if (closed.error !== undefined)
+            throw closed.error;
+          record.closed = true;
+          record.state = "stopped";
+          publish();
+        } catch (error) {
+          record.failures.push("close");
+          reportFailure(entry.id, "close", error);
+          record.state = "failed";
+          gracefulFailed = true;
+          lifetimeAbort.abort();
+          publish();
+          break;
+        }
+      }
+      clearTimeout(graceTimer);
+      parsed.signal?.removeEventListener("abort", onExternalAbort);
+      const mustForce = forcedReason !== undefined || gracefulFailed;
+      const pendingOperationsAtForce = mustForce ? pending : 0;
+      if (mustForce) {
+        lifetimeAbort.abort();
+        const forceAbort = new AbortController;
+        const forceTimer = setTimeout(() => forceAbort.abort(), Math.max(0, forceDeadlineAt - performance.now()));
+        await Promise.all(reverse.map(async (entry) => {
+          const record = records.get(entry.id);
+          if (!record?.attempted || record.closed)
+            return;
+          try {
+            let cleanup;
+            if (entry.resource.force) {
+              cleanup = Promise.resolve(entry.resource.force(contextFor(record, {
+                signal: forceAbort.signal,
+                deadlineAt: graceDeadlineAt,
+                forceDeadlineAt
+              })));
+            } else if (entry.resource.close && !record.closeInvoked) {
+              record.closeInvoked = true;
+              cleanup = Promise.resolve(entry.resource.close(contextFor(record, {
+                signal: forceAbort.signal,
+                deadlineAt: graceDeadlineAt,
+                forceDeadlineAt
+              })));
+            } else if (entry.resource.close) {
+              record.failures.push("force");
+              reportFailure(entry.id, "force", new Error(`[stitchkit] resource "${entry.id}" was already closing and did not settle before the force deadline`));
+              return;
+            }
+            const forced = await untilDeadline(cleanup ?? Promise.resolve(), forceAbort.signal);
+            if (!forced.settled || forced.error !== undefined) {
+              record.failures.push("force");
+              reportFailure(entry.id, "force", forced.settled ? forced.error : new Error("[stitchkit] forced cleanup did not settle in time"));
+              return;
+            }
+            record.closed = true;
+            record.state = "stopped";
+          } catch (error) {
+            record.failures.push("force");
+            reportFailure(entry.id, "force", error);
+          }
+        }));
+        clearTimeout(forceTimer);
+      }
+      const cleanupComplete = [...records.values()].every((record) => !record.attempted || record.closed);
+      lifecycle = cleanupComplete ? "stopped" : "failed";
+      publish();
+      return ApplicationShutdownResultSchema.parse({
+        outcome: mustForce ? "forced" : "clean",
+        ...forcedReason && { reason: forcedReason },
+        cleanupComplete,
+        acceptedOperations: accepted,
+        completedOperations: completed,
+        pendingOperations: pending,
+        pendingOperationsAtForce,
+        resources: ordered.map((entry) => {
+          const record = records.get(entry.id);
+          if (!record)
+            throw new Error("Managed resource record disappeared");
+          return {
+            id: entry.id,
+            state: !record.attempted ? "not-started" : record.closed ? "closed" : "force-failed",
+            failures: record.failures
+          };
+        }),
+        durationMs: performance.now() - startedAt
+      });
+    })();
+    shutdownPromise.catch(() => {
+      return;
+    });
+    return shutdownPromise;
+  };
+  return {
+    id,
+    admission: { acquire, run },
+    start,
+    getSnapshot: snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      listener(snapshot());
+      return () => listeners.delete(listener);
+    },
+    shutdown,
+    restart(input) {
+      const queued = restarting.then(() => runRestart(input));
+      restarting = queued.then(() => {
+        return;
+      }, () => {
+        return;
+      });
+      return queued;
+    }
+  };
+}
 // src/application/keyspace.ts
 function defineKeyspace(name, declaration) {
   if (name.trim() === "") {
@@ -1302,7 +2003,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 +2016,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 +2050,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 +2062,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 +2077,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 +2098,7 @@ function keyspaceMachine(declaration, config) {
     },
     async close() {
       reportUnwritten();
-      await config.backend.close?.();
+      await backend?.close?.();
     },
     force() {
       reportUnwritten();
@@ -1434,6 +2148,308 @@ function sqliteKeyspaceBackend(declaration, config) {
     }
   };
 }
+// src/application/schedule.ts
+import { z as z11 } from "zod";
+var NonNegativeSafeIntegerSchema = z11.number().int().nonnegative().refine(Number.isSafeInteger, "Expected a safe integer");
+var PositiveSafeIntegerSchema3 = NonNegativeSafeIntegerSchema.refine((value) => value > 0, "Expected a positive integer");
+var ManagedScheduleOverlapSchema = z11.discriminatedUnion("mode", [
+  z11.object({ mode: z11.literal("skip") }).readonly(),
+  z11.object({ mode: z11.literal("queue-one") }).readonly(),
+  z11.object({
+    mode: z11.literal("parallel"),
+    maxConcurrent: PositiveSafeIntegerSchema3
+  }).readonly()
+]);
+var ManagedScheduleErrorPolicySchema = z11.enum(["continue", "stop-schedule"]);
+var ManagedScheduleDescriptorSchema = z11.object({
+  id: ApplicationIdSchema,
+  everyMs: PositiveSafeIntegerSchema3,
+  startAfterMs: NonNegativeSafeIntegerSchema,
+  overlap: ManagedScheduleOverlapSchema,
+  errorPolicy: ManagedScheduleErrorPolicySchema
+}).readonly();
+var ManagedScheduleStatusSchema = z11.object({
+  descriptor: ManagedScheduleDescriptorSchema,
+  state: z11.enum(["inactive", "scheduled", "running", "draining", "stopped"]),
+  revision: NonNegativeSafeIntegerSchema,
+  capturedAt: z11.string().datetime({ offset: true }),
+  changedAt: z11.string().datetime({ offset: true }),
+  accepting: z11.boolean(),
+  active: NonNegativeSafeIntegerSchema,
+  queued: z11.boolean(),
+  runsStarted: NonNegativeSafeIntegerSchema,
+  runsCompleted: NonNegativeSafeIntegerSchema,
+  runsFailed: NonNegativeSafeIntegerSchema,
+  ticksSkipped: NonNegativeSafeIntegerSchema,
+  nextRunAt: z11.string().datetime({ offset: true }).nullable(),
+  lastScheduledAt: z11.string().datetime({ offset: true }).nullable(),
+  lastStartedAt: z11.string().datetime({ offset: true }).nullable(),
+  lastFinishedAt: z11.string().datetime({ offset: true }).nullable()
+}).readonly();
+var systemClock = {
+  now: () => performance.now(),
+  wallNow: () => new Date,
+  schedule(callback, delayMs) {
+    const timer = setTimeout(callback, delayMs);
+    return { cancel: () => clearTimeout(timer) };
+  }
+};
+var DEFAULT_OVERLAP = { mode: "skip" };
+function createManagedSchedule(config) {
+  const descriptor = ManagedScheduleDescriptorSchema.parse({
+    id: config.id,
+    everyMs: config.everyMs,
+    startAfterMs: config.startAfterMs ?? config.everyMs,
+    overlap: config.overlap ?? DEFAULT_OVERLAP,
+    errorPolicy: config.errorPolicy ?? "continue"
+  });
+  const dependsOn = config.dependsOn?.map((id) => ApplicationIdSchema.parse(id));
+  const clock = config.clock ?? systemClock;
+  let revision = 0;
+  let accepting = false;
+  let activated = false;
+  let stopped = false;
+  let timer = null;
+  let activationContext = null;
+  let nextRunAt = null;
+  let queuedAt = null;
+  let runsStarted = 0;
+  let runsCompleted = 0;
+  let runsFailed = 0;
+  let ticksSkipped = 0;
+  let lastScheduledAt = null;
+  let lastStartedAt = null;
+  let lastFinishedAt = null;
+  let changedAt = clock.wallNow().toISOString();
+  const active = new Set;
+  const changed = () => {
+    revision += 1;
+    changedAt = clock.wallNow().toISOString();
+  };
+  const cancelFuture = () => {
+    timer?.cancel();
+    timer = null;
+    nextRunAt = null;
+    queuedAt = null;
+  };
+  const stopAdmission = () => {
+    if (!accepting && stopped)
+      return;
+    accepting = false;
+    stopped = true;
+    cancelFuture();
+    changed();
+  };
+  const reportError = (error, context) => {
+    if (!config.onError)
+      return;
+    Promise.resolve().then(() => config.onError?.(error, context)).catch(() => {});
+  };
+  const state = () => {
+    if (!activated)
+      return stopped ? "stopped" : "inactive";
+    if (!accepting)
+      return active.size > 0 ? "draining" : "stopped";
+    return active.size > 0 ? "running" : "scheduled";
+  };
+  const wallAt = (monotonicAt, anchor) => {
+    if (monotonicAt === null)
+      return null;
+    return new Date(anchor.wallNow + monotonicAt - anchor.monotonicNow).toISOString();
+  };
+  const status = () => {
+    const captured = clock.wallNow();
+    const anchor = { monotonicNow: clock.now(), wallNow: captured.getTime() };
+    return ManagedScheduleStatusSchema.parse({
+      descriptor,
+      state: state(),
+      revision,
+      capturedAt: captured.toISOString(),
+      changedAt,
+      accepting,
+      active: active.size,
+      queued: queuedAt !== null,
+      runsStarted,
+      runsCompleted,
+      runsFailed,
+      ticksSkipped,
+      nextRunAt: wallAt(nextRunAt, anchor),
+      lastScheduledAt,
+      lastStartedAt,
+      lastFinishedAt
+    });
+  };
+  let startExecution = () => {
+    return;
+  };
+  const settleExecution = () => {
+    if (!accepting || queuedAt === null || active.size !== 0)
+      return;
+    const successorAt = queuedAt;
+    queuedAt = null;
+    changed();
+    startExecution(successorAt);
+  };
+  startExecution = (scheduledAt) => {
+    const resourceContext = activationContext;
+    if (!accepting || !resourceContext)
+      return;
+    const startedAt = clock.now();
+    const wallStartedAt = clock.wallNow().getTime();
+    const runContext = {
+      applicationId: resourceContext.applicationId,
+      signal: resourceContext.signal,
+      scheduledAt,
+      startedAt,
+      now: () => clock.now()
+    };
+    runsStarted += 1;
+    lastScheduledAt = new Date(wallStartedAt + scheduledAt - startedAt).toISOString();
+    lastStartedAt = new Date(wallStartedAt).toISOString();
+    changed();
+    let tracked;
+    tracked = Promise.resolve().then(() => config.run(runContext)).then(() => {
+      runsCompleted += 1;
+      lastFinishedAt = clock.wallNow().toISOString();
+      if (descriptor.errorPolicy === "continue" && accepting) {
+        resourceContext.reportHealth("healthy");
+      }
+    }, (error) => {
+      runsFailed += 1;
+      lastFinishedAt = clock.wallNow().toISOString();
+      reportError(error, runContext);
+      if (descriptor.errorPolicy === "stop-schedule") {
+        resourceContext.reportHealth("unhealthy");
+        stopAdmission();
+      } else {
+        resourceContext.reportHealth("degraded");
+      }
+    }).finally(() => {
+      active.delete(tracked);
+      changed();
+      settleExecution();
+    });
+    active.add(tracked);
+  };
+  const dispatchTick = (scheduledAt) => {
+    if (!accepting)
+      return;
+    if (descriptor.overlap.mode === "skip") {
+      if (active.size > 0) {
+        ticksSkipped += 1;
+        changed();
+        return;
+      }
+      startExecution(scheduledAt);
+      return;
+    }
+    if (descriptor.overlap.mode === "queue-one") {
+      if (active.size > 0) {
+        queuedAt = scheduledAt;
+        changed();
+        return;
+      }
+      startExecution(scheduledAt);
+      return;
+    }
+    if (active.size >= descriptor.overlap.maxConcurrent) {
+      ticksSkipped += 1;
+      changed();
+      return;
+    }
+    startExecution(scheduledAt);
+  };
+  const arm = () => {
+    if (!accepting || nextRunAt === null)
+      return;
+    const delayMs = Math.max(0, nextRunAt - clock.now());
+    timer = clock.schedule(() => {
+      timer = null;
+      if (!accepting || nextRunAt === null)
+        return;
+      const scheduledAt = nextRunAt;
+      const observedAt = clock.now();
+      const elapsedIntervals = Math.max(1, Math.floor((observedAt - scheduledAt) / descriptor.everyMs) + 1);
+      if (elapsedIntervals > 1) {
+        ticksSkipped += elapsedIntervals - 1;
+        changed();
+      }
+      nextRunAt = scheduledAt + elapsedIntervals * descriptor.everyMs;
+      arm();
+      dispatchTick(scheduledAt);
+    }, delayMs);
+  };
+  const waitForActive = async (context, deadlineAt) => {
+    if (active.size === 0 || context.signal.aborted)
+      return;
+    await new Promise((resolve) => {
+      let settled = false;
+      let deadlineTimer = null;
+      const finish = () => {
+        if (settled)
+          return;
+        settled = true;
+        deadlineTimer?.cancel();
+        context.signal.removeEventListener("abort", finish);
+        resolve();
+      };
+      context.signal.addEventListener("abort", finish, { once: true });
+      if (deadlineAt !== undefined) {
+        deadlineTimer = clock.schedule(finish, Math.max(0, deadlineAt - context.now()));
+      }
+      Promise.allSettled([...active]).then(finish);
+    });
+  };
+  const drain = async (context) => {
+    stopAdmission();
+    await waitForActive(context, context.deadlineAt);
+  };
+  return {
+    id: descriptor.id,
+    ...dependsOn && { dependsOn },
+    ...config.required !== undefined && { required: config.required },
+    get status() {
+      return status();
+    },
+    start() {
+      if (active.size > 0) {
+        throw new Error(`[stitchkit] schedule "${descriptor.id}" still has executions from its previous generation`);
+      }
+      cancelFuture();
+      stopped = false;
+      accepting = false;
+      activated = false;
+      activationContext = null;
+      queuedAt = null;
+      changed();
+    },
+    activate(context) {
+      if (activated || stopped)
+        return;
+      activated = true;
+      accepting = true;
+      activationContext = context;
+      nextRunAt = clock.now() + descriptor.startAfterMs;
+      context.reportHealth("healthy");
+      changed();
+      arm();
+    },
+    stopAdmission() {
+      stopAdmission();
+    },
+    drain,
+    close() {
+      stopAdmission();
+    },
+    async force(context) {
+      stopAdmission();
+      await waitForActive(context, context.forceDeadlineAt);
+      if (active.size > 0) {
+        throw new Error(`[stitchkit] schedule "${descriptor.id}" still has active executions`);
+      }
+    }
+  };
+}
 // src/application/server-resource.ts
 function managedServerResource(config) {
   let shutdownPromise;
@@ -1475,6 +2491,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 +2514,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) {
@@ -1819,7 +2737,6 @@ export {
   defineKeyspace,
   createWatchHub,
   createManagedSchedule,
-  createDiagnosticJournal,
   createDecisionPipeline,
   createCreditWindow,
   createBoundedChannel,