stitchkit 0.78.0 → 0.80.0

package/dist/application.js

@@ -1,26 +1,46 @@
 import {
-  createBackoff
-} from "./index-h4pj6fta.js";
-import {
-  argumentsDigest,
-  stableValue,
-  watchKeyString
-} from "./index-wfq8zerm.js";
+  ApplicationAdmissionError,
+  ApplicationRestartInputSchema,
+  ApplicationRestartOutcomeSchema,
+  ApplicationRestartResultSchema,
+  ApplicationShutdownBudgetSchema,
+  ApplicationShutdownOptionsSchema,
+  createApplication
+} from "./index-evcnmsc3.js";
 import {
-  BoundedChannelPolicySchema,
-  BoundedChannelReaderError,
-  BoundedChannelSnapshotSchema,
-  BoundedChannelStateSchema,
-  CreditWindowSnapshotSchema,
-  createBoundedChannel,
-  createCreditWindow
-} from "./index-dmfn9m4x.js";
+  defineManagedResource,
+  managedResourceDependencyId
+} from "./index-2k4yrqkc.js";
 import {
-  AppError
-} from "./index-0w9abg87.js";
+  ActivityIdSchema,
+  ActivityLiveStateSchema,
+  ActivitySnapshotSchema,
+  ActivityStageIdSchema,
+  ActivityStageSnapshotSchema,
+  ActivityTokenBrand,
+  ApplicationSnapshotSinkStatusSchema,
+  ManagedScheduleDescriptorSchema,
+  ManagedScheduleErrorPolicySchema,
+  ManagedScheduleOverlapSchema,
+  ManagedScheduleStatusSchema,
+  createActivityProjection,
+  createApplicationSnapshotSink,
+  createManagedSchedule
+} from "./index-6s7n2v50.js";
 import {
-  isRecord
-} from "./index-ksp6e2ye.js";
+  DiagnosticJournalCloseResultSchema,
+  DiagnosticJournalFailurePhaseSchema,
+  DiagnosticJournalFrameSchema,
+  DiagnosticJournalLimitsSchema,
+  DiagnosticJournalLockPolicySchema,
+  DiagnosticJournalRefusalReasonSchema,
+  DiagnosticJournalStateSchema,
+  DiagnosticJournalStatusSchema,
+  DiagnosticJournalSubmitResultSchema,
+  DiagnosticJournalWaitResultSchema,
+  readDiagnosticJournalLockDiagnosis
+} from "./index-wc4x00bn.js";
+import"./index-pq95qkbf.js";
 import {
   ApplicationAdmissionSnapshotSchema,
   ApplicationHealthSchema,
@@ -33,315 +53,70 @@ import {
   ManagedResourceSnapshotSchema,
   ManagedResourceStateSchema,
   projectApplicationStatus
-} from "./index-kw12fsbc.js";
-
-// src/application/activity.ts
-import { z as z2 } from "zod";
-
-// src/application/latest-sink.ts
-import { z } from "zod";
-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();
-      };
-    }
-  };
-}
+} from "./index-3gye9wzb.js";
+import {
+  withDeadline
+} from "./index-b9aefrqd.js";
+import"./index-3z73fh2c.js";
+import {
+  createBoundedSinkManager
+} from "./index-a59da114.js";
+import {
+  createBackoff
+} from "./index-h4pj6fta.js";
+import {
+  watchKeyString
+} from "./index-dre2ywck.js";
+import"./index-ywd0y6m1.js";
+import {
+  BoundedChannelPolicySchema,
+  BoundedChannelReaderError,
+  BoundedChannelSnapshotSchema,
+  BoundedChannelStateSchema,
+  CreditWindowSnapshotSchema,
+  createBoundedChannel,
+  createCreditWindow
+} from "./index-7gnkny4z.js";
+import {
+  argumentsDigest,
+  stableValue
+} from "./index-a916km3r.js";
+import"./index-0w9abg87.js";
+import"./index-77fekveh.js";
 // src/application/admission.ts
-import { z as z3 } from "zod";
-var PositiveSafeIntegerSchema = z3.number().int().positive().safe();
-var BoundedRateBudgetSchema = z3.object({
+import { z } from "zod";
+var PositiveSafeIntegerSchema = z.number().int().positive().safe();
+var BoundedRateBudgetSchema = z.object({
   limit: PositiveSafeIntegerSchema,
   intervalMs: PositiveSafeIntegerSchema
 }).strict().readonly();
-var BoundedAdmissionPerKeyLimitsSchema = z3.object({
+var BoundedAdmissionPerKeyLimitsSchema = z.object({
   maxConcurrent: PositiveSafeIntegerSchema,
   rate: BoundedRateBudgetSchema.optional()
 }).strict().readonly();
-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({
+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({
     maxConcurrent: PositiveSafeIntegerSchema,
     rate: BoundedRateBudgetSchema.optional()
   }).strict(),
-  perKey: z3.union([
-    z3.object({
+  perKey: z.union([
+    z.object({
       maxConcurrent: PositiveSafeIntegerSchema,
       maxKeys: PositiveSafeIntegerSchema,
       rate: BoundedRateBudgetSchema.optional(),
-      limits: z3.never().optional()
+      limits: z.never().optional()
     }).strict(),
-    z3.object({
+    z.object({
       maxKeys: PositiveSafeIntegerSchema,
       limits: PerKeyLimitResolverSchema,
-      maxConcurrent: z3.never().optional(),
-      rate: z3.never().optional()
+      maxConcurrent: z.never().optional(),
+      rate: z.never().optional()
     }).strict()
   ]).optional()
 }).strict().readonly();
-var BoundedAdmissionStateSchema = z3.enum(["accepting", "draining", "closed"]);
-var BoundedAdmissionRefusalReasonSchema = z3.enum([
+var BoundedAdmissionStateSchema = z.enum(["accepting", "draining", "closed"]);
+var BoundedAdmissionRefusalReasonSchema = z.enum([
   "not-accepting",
   "global-concurrency",
   "key-required",
@@ -351,25 +126,25 @@ var BoundedAdmissionRefusalReasonSchema = z3.enum([
   "key-rate",
   "upstream"
 ]);
-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()
+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()
 }).strict().readonly();
-var BoundedAdmissionSnapshotSchema = z3.object({
+var BoundedAdmissionSnapshotSchema = z.object({
   state: BoundedAdmissionStateSchema,
-  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(),
+  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(),
   refusals: RefusalCountersSchema
 }).strict().readonly();
 
@@ -682,31 +457,12 @@ 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 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()
+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()
 ]);
 
 // src/application/decisions.ts
@@ -779,249 +535,18 @@ function createDecisionPipeline(policies, config) {
     }
   };
 }
-// src/application/diagnostic-journal-contract.ts
-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 = z5.enum(["refuse", "reclaim-stale"]);
-var DiagnosticJournalStateSchema = z5.enum(["open", "draining", "closed", "failed"]);
-var DiagnosticJournalRefusalReasonSchema = z5.enum([
-  "closed",
-  "failed",
-  "invalid",
-  "oversized",
-  "item-capacity",
-  "byte-capacity"
-]);
-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 = z5.enum(["write", "rotation", "close"]);
-var DiagnosticJournalStatusSchema = z5.object({
-  state: DiagnosticJournalStateSchema,
-  epoch: z5.uuid(),
-  limits: DiagnosticJournalLimitsSchema,
-  lock: z5.object({
-    policy: DiagnosticJournalLockPolicySchema,
-    reclaimedStale: z5.boolean()
-  }).strict().readonly(),
-  received: z5.number().int().nonnegative(),
-  accepted: z5.number().int().nonnegative(),
-  refused: z5.number().int().nonnegative(),
-  refusals: DiagnosticJournalRefusalCountersSchema,
-  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: z5.number().int().positive().optional()
-  }).strict().readonly().optional()
-}).strict().readonly();
-var DiagnosticJournalSubmitResultSchema = z5.discriminatedUnion("outcome", [
-  z5.object({
-    outcome: z5.literal("accepted"),
-    epoch: z5.uuid(),
-    sequence: z5.number().int().positive()
-  }).strict().readonly(),
-  z5.object({
-    outcome: z5.literal("refused"),
-    reason: DiagnosticJournalRefusalReasonSchema
-  }).strict().readonly()
-]);
-var DiagnosticJournalWaitResultSchema = z5.object({
-  outcome: z5.enum(["settled", "timed-out", "cancelled"]),
-  state: DiagnosticJournalStateSchema,
-  throughSequence: z5.number().int().nonnegative(),
-  settledSequence: z5.number().int().nonnegative()
-}).strict().readonly();
-var DiagnosticJournalCloseResultSchema = z5.object({
-  outcome: z5.enum(["closed", "timed-out", "cancelled"]),
-  state: DiagnosticJournalStateSchema,
-  pendingItems: z5.number().int().nonnegative()
-}).strict().readonly();
-var DiagnosticJournalFrameSchema = z5.object({
-  schemaVersion: z5.literal(1),
-  epoch: z5.uuid(),
-  sequence: z5.number().int().positive(),
-  event: z5.json()
-}).strict().readonly();
-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/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/internal/observability-sink.ts
-var DEFAULT_MAX_PENDING = 1000;
-function invokeIsolated(callback) {
-  if (!callback)
-    return;
-  Promise.resolve().then(callback).catch(() => {});
-}
-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");
-  }
-  let sequence = 0;
-  let closed = false;
-  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 reportDrop = (reason, event) => {
-    invokeIsolated(config.onDrop ? () => config.onDrop?.({ reason, event, pending: writes.size }) : undefined);
-  };
-  const admit = (id, event) => {
-    try {
-      if (config.filter && !config.filter(event)) {
-        filtered += 1;
-        return;
-      }
-    } catch (error) {
-      preparationFailed += 1;
-      reportError(error, event);
-      return;
-    }
-    if (writes.size >= maxPending) {
-      dropped += 1;
-      reportDrop("capacity", event);
-      return;
-    }
-    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 {
-    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);
-    },
-    flush() {
-      return awaitGeneration(sequence);
-    },
-    getStatus,
-    close() {
-      if (closePromise)
-        return closePromise;
-      closed = true;
-      closePromise = awaitGeneration(sequence).then(getStatus);
-      return closePromise;
-    }
-  };
-  function getStatus() {
-    return ObservabilitySinkStatusSchema.parse({
-      capacity: maxPending,
-      received,
-      accepted,
-      filtered,
-      completed,
-      dropped,
-      failed,
-      preparationFailed,
-      preparing: preparing.size,
-      pending: writes.size,
-      closed
-    });
-  }
-}
-
-// src/application/events.ts
-var ApplicationLifecycleEventSchema = z7.object({
-  type: z7.literal("application-state"),
+import { z as z3 } from "zod";
+var ApplicationLifecycleEventSchema = z3.object({
+  type: z3.literal("application-state"),
   applicationId: ApplicationIdSchema,
-  epoch: z7.string().uuid(),
-  revision: z7.number().int().nonnegative(),
+  epoch: z3.string().uuid(),
+  revision: z3.number().int().nonnegative(),
   lifecycle: ApplicationLifecycleSchema,
   health: ApplicationHealthSchema,
-  ready: z7.boolean(),
-  capturedAt: z7.string().datetime({ offset: true }),
-  resources: z7.array(ManagedResourceSnapshotSchema).readonly()
+  ready: z3.boolean(),
+  capturedAt: z3.string().datetime({ offset: true }),
+  resources: z3.array(ManagedResourceSnapshotSchema).readonly()
 }).strict().readonly();
 function applicationLifecycleEvent(snapshot) {
   return ApplicationLifecycleEventSchema.parse({
@@ -1052,13 +577,13 @@ function createApplicationEventSink(config) {
   };
 }
 // src/application/health.ts
-import { z as z8 } from "zod";
-var ApplicationHealthHandlerOptionsSchema = z8.object({
-  kind: z8.enum(["liveness", "readiness"]),
-  retryAfterSeconds: z8.number().int().nonnegative().default(5)
+import { z as z4 } from "zod";
+var ApplicationHealthHandlerOptionsSchema = z4.object({
+  kind: z4.enum(["liveness", "readiness"]),
+  retryAfterSeconds: z4.number().int().nonnegative().default(5)
 });
-var ApplicationOperationalHandlersOptionsSchema = z8.object({
-  retryAfterSeconds: z8.number().int().nonnegative().default(5)
+var ApplicationOperationalHandlersOptionsSchema = z4.object({
+  retryAfterSeconds: z4.number().int().nonnegative().default(5)
 });
 function createApplicationHealthHandler(application, options) {
   const parsed = ApplicationHealthHandlerOptionsSchema.parse(options);
@@ -1085,901 +610,6 @@ 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() === "") {
@@ -2148,308 +778,6 @@ 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;
@@ -2532,17 +860,29 @@ function createWatchHub(config) {
   const same = config.same ?? ((previous, next) => JSON.stringify(stableValue(previous)) === JSON.stringify(stableValue(next)));
   let reads = 0;
   let closed = false;
+  function tell(key, deliver) {
+    try {
+      deliver();
+    } catch (error) {
+      config.logger?.warn?.("[stitchkit] watch subscriber threw", {
+        key: watchKeyString(key),
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   function announceState(source, state) {
     source.state = state;
-    for (const subscriber of source.subscribers)
-      subscriber.state(state);
+    for (const subscriber of source.subscribers) {
+      tell(source.key, () => subscriber.state(state));
+    }
   }
   function publish(source, value) {
     source.revision += 1;
     source.value = value;
     const frame = { key: source.key, revision: source.revision, value };
-    for (const subscriber of source.subscribers)
-      subscriber.value(frame);
+    for (const subscriber of source.subscribers) {
+      tell(source.key, () => subscriber.value(frame));
+    }
   }
   async function pump(source) {
     if (source.reading || closed)
@@ -2672,10 +1012,20 @@ function createWatchHub(config) {
           const source = acquire(operation, key, args);
           source.subscribers.add(subscriber);
           keys.add(id);
-          if (source.signature !== undefined) {
-            subscriber.value({ key, revision: source.revision, value: source.value });
+          try {
+            if (source.signature !== undefined) {
+              subscriber.value({ key, revision: source.revision, value: source.value });
+            }
+            subscriber.state(source.state);
+          } catch (error) {
+            source.subscribers.delete(subscriber);
+            keys.delete(id);
+            release(source);
+            return {
+              accepted: false,
+              reason: error instanceof Error ? error.message : String(error)
+            };
           }
-          subscriber.state(source.state);
           pump(source);
           return { accepted: true };
         },
@@ -2706,14 +1056,20 @@ function createWatchHub(config) {
     size: () => sources.size,
     close() {
       closed = true;
-      for (const source of sources.values()) {
+      const teardown = [...sources.values()];
+      sources.clear();
+      held.clear();
+      for (const source of teardown) {
         clearTimeout(source.retry);
         clearTimeout(source.release);
+        announceState(source, {
+          key: source.key,
+          phase: "unavailable",
+          reason: "source-unavailable"
+        });
         for (const unsubscribe of source.unsubscribes)
           unsubscribe();
       }
-      sources.clear();
-      held.clear();
     }
   };
 }