stitchkit 0.99.0 → 0.100.1

package/dist/entrypoints/application.js

@@ -58,9 +58,6 @@ import {
   defineManagedResource,
   managedResourceDependencyId
 } from "../index-2k4yrqkc.js";
-import {
-  withDeadline
-} from "../index-b9aefrqd.js";
 import"../index-3z73fh2c.js";
 import {
   createBoundedSinkManager
@@ -69,11 +66,14 @@ import {
   backoffDelay,
   createBackoff
 } from "../index-ngfhvfpd.js";
+import {
+  withDeadline
+} from "../index-b9aefrqd.js";
 import {
   deltaWins,
   diff,
   watchKeyString
-} from "../index-wt743f7f.js";
+} from "../index-k6gpggb9.js";
 import"../index-1j8pm5t0.js";
 import {
   BoundedChannelPolicySchema,
@@ -90,7 +90,9 @@ import {
 import {
   argumentsDigest
 } from "../index-0b1ess5e.js";
-import"../index-2vtcmrj9.js";
+import {
+  AppError
+} from "../index-2vtcmrj9.js";
 import {
   serializeCanonicalJson
 } from "../index-k5hsfc3j.js";
@@ -483,12 +485,319 @@ function createBoundedAdmission(config) {
     getSnapshot
   };
 }
-// src/internal/decision.ts
+// src/application/change-subscription.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()
+
+// src/internal/coalesced-task.ts
+function createCoalescedTask(config) {
+  const backoff = createBackoff(config.backoff);
+  let running = false;
+  let dirty = false;
+  let closed = false;
+  let retry;
+  const pauseRetry = () => {
+    clearTimeout(retry);
+    retry = undefined;
+  };
+  const pump = async () => {
+    if (running || closed || !config.active() || retry)
+      return;
+    running = true;
+    try {
+      while (dirty && !closed && config.active()) {
+        dirty = false;
+        try {
+          await config.run();
+          backoff.reset();
+        } catch (error) {
+          dirty = true;
+          if (!closed && config.active()) {
+            retry = setTimeout(() => {
+              retry = undefined;
+              pump();
+            }, backoff.next());
+            retry.unref?.();
+            config.onError(error);
+          }
+          return;
+        }
+      }
+    } finally {
+      running = false;
+    }
+  };
+  return {
+    get running() {
+      return running;
+    },
+    get pending() {
+      return dirty;
+    },
+    trigger() {
+      if (closed)
+        return;
+      dirty = true;
+      pump();
+    },
+    pauseRetry,
+    close() {
+      closed = true;
+      dirty = false;
+      pauseRetry();
+    }
+  };
+}
+
+// src/application/change-subscription.ts
+class ChangeSubscription {
+  config;
+  keys;
+  interval;
+  timeout;
+  backoff;
+  tasks;
+  failedKeys = new Set;
+  lifetime;
+  attempt;
+  connection;
+  opening;
+  closing;
+  retry;
+  periodic;
+  context;
+  removeAbort;
+  constructor(config) {
+    this.config = config;
+    this.keys = z2.array(z2.string().min(1).max(256)).min(1).max(128).parse(config.keys);
+    if (new Set(this.keys).size !== this.keys.length)
+      throw new Error("Subscription keys must be unique");
+    this.interval = z2.number().int().min(10).max(3600000).parse(config.reconcileIntervalMs);
+    this.timeout = z2.number().int().min(1).max(3600000).parse(config.timeoutMs ?? 30000);
+    const policy = config.backoff ?? { minDelayMs: 250, maxDelayMs: 30000, jitter: 0.2 };
+    this.backoff = createBackoff(policy);
+    this.tasks = new Map(this.keys.map((key) => [
+      key,
+      createCoalescedTask({
+        active: () => this.connection !== undefined && this.attempt?.signal.aborted === false,
+        run: () => this.read(key),
+        onError: (error) => {
+          this.failedKeys.add(key);
+          this.report(error);
+        },
+        backoff: policy
+      })
+    ]));
+  }
+  report(error) {
+    this.context?.reportHealth("degraded");
+    try {
+      this.config.onError(error);
+    } catch {}
+  }
+  async read(key) {
+    const connection = this.connection;
+    const attempt = this.attempt;
+    if (!connection || !attempt)
+      return;
+    const readAbort = new AbortController;
+    const signal = AbortSignal.any([attempt.signal, readAbort.signal]);
+    const work = this.config.reconcile(key, {
+      signal,
+      commit: (publish) => {
+        if (signal.aborted || this.connection !== connection)
+          return false;
+        publish();
+        return true;
+      }
+    });
+    const outcome = await withDeadline(work, this.timeout);
+    if (!outcome.settled) {
+      readAbort.abort();
+      this.report(new Error("Reconciliation deadline exceeded"));
+      await work;
+      throw new Error("Reconciliation deadline exceeded");
+    }
+    if (!signal.aborted && this.connection === connection) {
+      this.failedKeys.delete(key);
+      if (this.failedKeys.size === 0)
+        this.context?.reportHealth("healthy");
+    }
+  }
+  reconcile() {
+    for (const task of this.tasks.values())
+      task.trigger();
+  }
+  schedule() {
+    if (!this.lifetime || this.lifetime.signal.aborted || this.retry)
+      return;
+    this.retry = setTimeout(() => {
+      this.retry = undefined;
+      this.open();
+    }, this.backoff.next());
+    this.retry.unref?.();
+  }
+  async release(handle) {
+    const work = Promise.resolve().then(() => handle.close());
+    this.closing = work;
+    try {
+      const outcome = await withDeadline(work, this.timeout);
+      if (!outcome.settled) {
+        this.report(new Error("Subscription close deadline exceeded"));
+        await work;
+      }
+    } finally {
+      if (this.closing === work)
+        this.closing = undefined;
+    }
+  }
+  lost(handle, error) {
+    if (this.connection !== handle)
+      return;
+    this.connection = undefined;
+    this.attempt?.abort();
+    this.report(error);
+    this.release(handle).catch((cause) => this.report(cause)).then(() => this.schedule());
+  }
+  open() {
+    if (this.opening)
+      return this.opening;
+    const lifetime = this.lifetime;
+    if (!lifetime || lifetime.signal.aborted || this.closing)
+      return Promise.resolve();
+    this.opening = this.connect(lifetime).finally(() => {
+      this.opening = undefined;
+    });
+    return this.opening;
+  }
+  async connect(lifetime) {
+    const attempt = new AbortController;
+    this.attempt = attempt;
+    const onAbort = () => attempt.abort();
+    lifetime.signal.addEventListener("abort", onAbort, { once: true });
+    let handle;
+    let lost = false;
+    const work = (async () => {
+      handle = await this.config.connect(attempt.signal);
+      if (attempt.signal.aborted)
+        return;
+      const owned = handle;
+      await owned.subscribe({
+        signal: attempt.signal,
+        hint: (key) => {
+          if (attempt.signal.aborted || lost)
+            return;
+          const task = this.tasks.get(key);
+          if (task)
+            task.trigger();
+          else
+            this.report(new Error("Unknown subscription key"));
+        },
+        disconnected: (error) => {
+          if (attempt.signal.aborted || this.lifetime !== lifetime)
+            return;
+          lost = true;
+          if (this.connection === owned)
+            this.lost(owned, error);
+          else
+            this.report(error);
+        }
+      });
+    })();
+    try {
+      const outcome = await withDeadline(work, this.timeout);
+      if (!outcome.settled) {
+        attempt.abort();
+        this.report(new Error("Subscription connect deadline exceeded"));
+        await work;
+      }
+      if (attempt.signal.aborted || lifetime !== this.lifetime || lost) {
+        if (handle)
+          await this.release(handle);
+        this.schedule();
+        return;
+      }
+      this.connection = handle;
+      this.backoff.reset();
+      this.context?.reportHealth("healthy");
+      this.reconcile();
+    } catch (error) {
+      attempt.abort();
+      if (handle) {
+        try {
+          await this.release(handle);
+        } catch (cause) {
+          this.report(cause);
+        }
+      }
+      if (!lifetime.signal.aborted) {
+        this.report(error);
+        this.schedule();
+      }
+    } finally {
+      lifetime.signal.removeEventListener("abort", onAbort);
+    }
+  }
+  start(context) {
+    if (this.lifetime && !this.lifetime.signal.aborted)
+      throw new Error("Subscription already started");
+    if (this.opening || this.closing || [...this.tasks.values()].some((task) => task.running))
+      throw new Error("Previous subscription work has not settled");
+    this.context = context;
+    this.lifetime = new AbortController;
+    const abort = () => {
+      this.close();
+    };
+    context.signal.addEventListener("abort", abort, { once: true });
+    this.removeAbort = () => context.signal.removeEventListener("abort", abort);
+    if (context.signal.aborted) {
+      this.close();
+      return {};
+    }
+    this.periodic = setInterval(() => this.reconcile(), this.interval);
+    this.periodic.unref?.();
+    const ready = (async () => {
+      const outcome = await withDeadline(this.open(), this.timeout);
+      if (!outcome.settled || !this.connection) {
+        this.close().catch((error) => this.report(error));
+        throw new Error("Subscription did not become ready before its deadline");
+      }
+    })();
+    return { ready };
+  }
+  async close() {
+    this.lifetime?.abort();
+    this.attempt?.abort();
+    this.removeAbort?.();
+    clearTimeout(this.retry);
+    this.retry = undefined;
+    clearInterval(this.periodic);
+    this.periodic = undefined;
+    for (const task of this.tasks.values())
+      task.pauseRetry();
+    const handle = this.connection;
+    this.connection = undefined;
+    if (handle) {
+      const outcome = await withDeadline(this.release(handle), this.timeout);
+      if (!outcome.settled)
+        this.report(new Error("Subscription shutdown deadline exceeded"));
+    }
+  }
+}
+function changeSubscriptionResource(config) {
+  const subscription = new ChangeSubscription(config);
+  return defineManagedResource({
+    id: config.id,
+    start: (context) => subscription.start(context),
+    close: () => subscription.close(),
+    force: () => subscription.close()
+  });
+}
+// src/internal/decision.ts
+import { z as z3 } from "zod";
+var PolicyDecisionSchema = z3.discriminatedUnion("outcome", [
+  z3.object({ outcome: z3.literal("allow") }).strict(),
+  z3.object({ outcome: z3.literal("deny"), reason: z3.string().min(1) }).strict(),
+  z3.object({ outcome: z3.literal("defer") }).strict()
 ]);
 
 // src/application/decisions.ts
@@ -562,17 +871,17 @@ function createDecisionPipeline(policies, config) {
   };
 }
 // src/application/events.ts
-import { z as z3 } from "zod";
-var ApplicationLifecycleEventSchema = z3.object({
-  type: z3.literal("application-state"),
+import { z as z4 } from "zod";
+var ApplicationLifecycleEventSchema = z4.object({
+  type: z4.literal("application-state"),
   applicationId: ApplicationIdSchema,
-  epoch: z3.string().uuid(),
-  revision: z3.number().int().nonnegative(),
+  epoch: z4.string().uuid(),
+  revision: z4.number().int().nonnegative(),
   lifecycle: ApplicationLifecycleSchema,
   health: ApplicationHealthSchema,
-  ready: z3.boolean(),
-  capturedAt: z3.string().datetime({ offset: true }),
-  resources: z3.array(ManagedResourceSnapshotSchema).readonly()
+  ready: z4.boolean(),
+  capturedAt: z4.string().datetime({ offset: true }),
+  resources: z4.array(ManagedResourceSnapshotSchema).readonly()
 }).strict().readonly();
 function applicationLifecycleEvent(snapshot) {
   return ApplicationLifecycleEventSchema.parse({
@@ -603,13 +912,13 @@ function createApplicationEventSink(config) {
   };
 }
 // src/application/health.ts
-import { z as z4 } from "zod";
-var ApplicationHealthHandlerOptionsSchema = z4.object({
-  kind: z4.enum(["liveness", "readiness"]),
-  retryAfterSeconds: z4.number().int().nonnegative().default(5)
+import { z as z5 } from "zod";
+var ApplicationHealthHandlerOptionsSchema = z5.object({
+  kind: z5.enum(["liveness", "readiness"]),
+  retryAfterSeconds: z5.number().int().nonnegative().default(5)
 });
-var ApplicationOperationalHandlersOptionsSchema = z4.object({
-  retryAfterSeconds: z4.number().int().nonnegative().default(5)
+var ApplicationOperationalHandlersOptionsSchema = z5.object({
+  retryAfterSeconds: z5.number().int().nonnegative().default(5)
 });
 function createApplicationHealthHandler(application, options) {
   const parsed = ApplicationHealthHandlerOptionsSchema.parse(options);
@@ -804,43 +1113,33 @@ function sqliteKeyspaceBackend(declaration, config) {
     }
   };
 }
-// src/application/notification-outbox.ts
-import { z as z5 } from "zod";
-function notificationOutboxStateSchema(payload) {
-  return z5.object({
-    schemaVersion: z5.literal(1),
-    queue: z5.array(z5.object({
-      key: z5.string().min(1).max(512),
-      payload,
-      createdAt: z5.string().datetime({ offset: true }),
-      attempts: z5.number().int().nonnegative(),
-      nextAttemptAt: z5.string().datetime({ offset: true }),
-      leaseOwner: z5.string().min(1).max(128).nullable(),
-      leaseId: z5.string().min(1).max(128).nullable(),
-      leaseUntil: z5.string().datetime({ offset: true }).nullable()
-    }).strict()),
-    receipts: z5.array(z5.object({
-      key: z5.string().min(1).max(512),
-      completedAt: z5.string().datetime({ offset: true })
-    }).strict())
-  }).strict();
-}
-var emptyOutboxState = () => ({
-  schemaVersion: 1,
-  queue: [],
-  receipts: []
-});
+// src/application/notification-delivery.ts
+import { z as z7 } from "zod";
+
+// src/application/notification-outbox-state.ts
+import { z as z6 } from "zod";
 var sizeOf = (value) => measureSize(value).responseBytes;
-var DEFAULT_OUTBOX_BACKOFF = { minDelayMs: 1000, maxDelayMs: 60000, jitter: 0 };
+var DEFAULT_OUTBOX_BACKOFF = {
+  minDelayMs: 1000,
+  maxDelayMs: 60000,
+  jitter: 0
+};
 function resolveOutboxLimits(config) {
-  const pollIntervalMs = z5.number().int().min(10).parse(config.pollIntervalMs ?? 1000);
-  const leaseMs = z5.number().int().min(100).parse(config.leaseMs ?? 30000);
-  const maxAttempts = z5.number().int().min(1).max(1e4).parse(config.maxAttempts ?? 100);
-  const maxQueue = z5.number().int().min(1).max(1e5).parse(config.maxQueue ?? 1000);
-  const maxStateBytes = z5.number().int().min(1024).parse(config.maxStateBytes ?? 1024 * 1024);
-  const retainReceipts = z5.number().int().min(0).max(1e5).parse(config.retainReceipts ?? 1000);
+  const pollIntervalMs = z6.number().int().min(10).parse(config.pollIntervalMs ?? 1000);
+  const leaseMs = z6.number().int().min(100).parse(config.leaseMs ?? 30000);
+  const maxAttempts = z6.number().int().min(1).max(1e4).parse(config.maxAttempts ?? 100);
+  const maxQueue = z6.number().int().min(1).max(1e5).parse(config.maxQueue ?? 1000);
+  const maxStateBytes = z6.number().int().min(1024).parse(config.maxStateBytes ?? 1024 * 1024);
+  const retainReceipts = z6.number().int().min(0).max(1e5).parse(config.retainReceipts ?? 1000);
   return { pollIntervalMs, leaseMs, maxAttempts, maxQueue, maxStateBytes, retainReceipts };
 }
+
+class OutboxStateLimitError extends Error {
+  constructor(maxStateBytes) {
+    super(`[stitchkit] notification outbox state limit (${maxStateBytes} bytes) exceeded`);
+    this.name = "OutboxStateLimitError";
+  }
+}
 function boundedOutboxState(parsed, maxQueue, retainReceipts, maxStateBytes) {
   if (parsed.queue.length > maxQueue) {
     throw new Error(`[stitchkit] notification outbox queue limit (${maxQueue}) exceeded`);
@@ -851,9 +1150,8 @@ function boundedOutboxState(parsed, maxQueue, retainReceipts, maxStateBytes) {
     receipts = receipts.slice(0, -1);
     next = { ...parsed, receipts };
   }
-  if (sizeOf(next) > maxStateBytes) {
-    throw new Error(`[stitchkit] notification outbox state limit (${maxStateBytes} bytes) exceeded`);
-  }
+  if (sizeOf(next) > maxStateBytes)
+    throw new OutboxStateLimitError(maxStateBytes);
   return next;
 }
 function dropReason(classification, attempts, maxAttempts) {
@@ -863,7 +1161,7 @@ function dropReason(classification, attempts, maxAttempts) {
     return "terminal";
   return attempts >= maxAttempts ? "attempt-limit" : null;
 }
-var RetryDelaySchema = z5.number().nonnegative().max(24 * 60 * 60 * 1000);
+var RetryDelaySchema = z6.number().nonnegative().max(24 * 60 * 60 * 1000);
 var NO_LEASE = { leaseOwner: null, leaseId: null, leaseUntil: null };
 function claimDue(queue, now, ownerId, leaseMs) {
   const candidate = [...queue].sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt)).find((item) => Date.parse(item.nextAttemptAt) <= now.getTime() && (item.leaseUntil === null || Date.parse(item.leaseUntil) <= now.getTime()));
@@ -877,16 +1175,196 @@ function claimDue(queue, now, ownerId, leaseMs) {
     leaseUntil: new Date(now.getTime() + leaseMs).toISOString()
   };
 }
+
+// src/application/notification-delivery.ts
+var NotificationDeliveryStateSchema = z7.object({
+  version: z7.string().min(1).max(128),
+  actions: z7.array(z7.string().min(1).max(128)).min(1).max(128),
+  receipts: z7.array(z7.object({
+    action: z7.string(),
+    receipt: z7.json(),
+    unrecorded: z7.enum(["not-json", "too-large"]).optional()
+  }).strict()).max(128),
+  projectedAt: z7.string().datetime({ offset: true }).optional()
+}).strict().refine((value) => new Set(value.actions).size === value.actions.length && new Set(value.receipts.map((receipt) => receipt.action)).size === value.receipts.length && value.receipts.every((receipt) => value.actions.includes(receipt.action)), "Invalid action plan or receipts");
+
+class NotificationPlanVersionError extends Error {
+  version;
+  constructor(version) {
+    super(`Notification action plan version "${version}" has no executor`);
+    this.name = "NotificationPlanVersionError";
+    this.version = version;
+  }
+}
+function projectionFor(config, version) {
+  if (version === config.version)
+    return config.project;
+  return config.retiredVersions && Object.hasOwn(config.retiredVersions, version) ? config.retiredVersions[version] : undefined;
+}
+function recordable(result) {
+  const parsed = z7.json().safeParse(result ?? null);
+  return parsed.success ? { receipt: parsed.data } : { receipt: null, unrecorded: "not-json" };
+}
+function notificationDeliveryPlan(config, payload) {
+  return NotificationDeliveryStateSchema.parse({
+    version: config.version,
+    actions: [...config.actions(payload)],
+    receipts: []
+  });
+}
+async function deliverNotification(input) {
+  const { item, config } = input;
+  const plan = item.delivery;
+  if (!plan)
+    throw new Error("Notification has no action plan");
+  const project = projectionFor(config, plan.version);
+  if (!project)
+    throw new NotificationPlanVersionError(plan.version);
+  const owns = (current2) => current2.key === item.key && current2.leaseId === item.leaseId;
+  const checkpoint = async (change) => input.store.update((state) => {
+    if (!state)
+      throw new Error("Outbox state disappeared");
+    const live2 = state.queue.find(owns);
+    if (!live2?.delivery)
+      return { state, result: false };
+    const delivery = NotificationDeliveryStateSchema.parse(change(live2.delivery));
+    return {
+      state: input.bounded({
+        ...state,
+        queue: state.queue.map((row) => row === live2 ? {
+          ...row,
+          delivery,
+          leaseUntil: new Date(input.clock().getTime() + input.leaseMs).toISOString()
+        } : row)
+      }),
+      result: true
+    };
+  });
+  const notification = { key: item.key, payload: item.payload, attempt: item.attempts };
+  for (const action of plan.actions) {
+    if (!input.active())
+      return false;
+    if (plan.receipts.some((receipt) => receipt.action === action))
+      continue;
+    if (!await checkpoint((value) => value))
+      return false;
+    const result = await input.send({
+      ...notification,
+      action,
+      idempotencyKey: JSON.stringify([item.key, plan.version, action])
+    });
+    const entry = recordable(result);
+    const confirm = (receipt) => checkpoint((value) => ({ ...value, receipts: [...value.receipts, receipt] }));
+    let confirmed;
+    let dropped;
+    try {
+      confirmed = await confirm({ action, ...entry });
+    } catch (error) {
+      if (entry.unrecorded || !(error instanceof OutboxStateLimitError))
+        throw error;
+      dropped = error;
+      confirmed = await confirm({ action, receipt: null, unrecorded: "too-large" });
+    }
+    if (dropped)
+      await input.report(dropped);
+    if (entry.unrecorded) {
+      await input.report(new Error(`Notification action "${action}" returned a receipt that is not JSON`));
+    }
+    if (!confirmed)
+      return false;
+  }
+  if (!input.active())
+    return false;
+  const current = await input.store.read();
+  const live = current?.queue.find(owns);
+  if (!live?.delivery)
+    return false;
+  if (live.delivery.projectedAt === undefined) {
+    await project(notification, live.delivery.receipts);
+    if (!await checkpoint((value) => ({ ...value, projectedAt: input.clock().toISOString() })))
+      return false;
+  }
+  return true;
+}
+// src/application/notification-outbox.ts
+import { z as z8 } from "zod";
+function notificationOutboxStateSchema(payload) {
+  return z8.object({
+    schemaVersion: z8.literal(1),
+    queue: z8.array(z8.object({
+      key: z8.string().min(1).max(512),
+      payload,
+      delivery: NotificationDeliveryStateSchema.optional(),
+      createdAt: z8.string().datetime({ offset: true }),
+      attempts: z8.number().int().nonnegative(),
+      nextAttemptAt: z8.string().datetime({ offset: true }),
+      leaseOwner: z8.string().min(1).max(128).nullable(),
+      leaseId: z8.string().min(1).max(128).nullable(),
+      leaseUntil: z8.string().datetime({ offset: true }).nullable()
+    }).strict()),
+    receipts: z8.array(z8.object({
+      key: z8.string().min(1).max(512),
+      completedAt: z8.string().datetime({ offset: true }),
+      delivery: NotificationDeliveryStateSchema.optional()
+    }).strict())
+  }).strict();
+}
+var emptyOutboxState = () => ({
+  schemaVersion: 1,
+  queue: [],
+  receipts: []
+});
 async function reportOutboxError(config, error) {
   try {
     await config.onError?.(error);
   } catch {}
 }
+function notificationRejection(config, parse, bounded, clock, backoffMs, pollIntervalMs) {
+  const maxAttempts = config.maxAttempts ?? 100;
+  return async (claimed, error) => {
+    const unknownPlan = error instanceof NotificationPlanVersionError;
+    if (unknownPlan)
+      await reportOutboxError(config, error);
+    const classification = unknownPlan ? { retryable: true } : await config.classify(error);
+    return config.store.update((current) => {
+      const state = parse(current);
+      const live = state.queue.find((item) => item.key === claimed.key && item.leaseId === claimed.leaseId);
+      if (!live)
+        return { state, result: null };
+      const attempts = unknownPlan ? Math.max(0, live.attempts - 1) : live.attempts;
+      const reason = dropReason(classification, attempts, maxAttempts);
+      if (reason) {
+        return {
+          state: bounded({
+            ...state,
+            queue: state.queue.filter((item) => item.key !== live.key)
+          }),
+          result: { item: { ...live, attempts }, error, reason }
+        };
+      }
+      const backoff = RetryDelaySchema.parse(backoffMs(Math.max(1, attempts)));
+      const wait = unknownPlan ? Math.max(backoff, pollIntervalMs) : backoff;
+      const retry = {
+        ...live,
+        attempts,
+        nextAttemptAt: new Date(clock().getTime() + wait).toISOString(),
+        ...NO_LEASE
+      };
+      return {
+        state: bounded({
+          ...state,
+          queue: state.queue.map((item) => item.key === live.key ? retry : item)
+        }),
+        result: null
+      };
+    });
+  };
+}
 function createNotificationOutbox(config) {
   const schema = notificationOutboxStateSchema(config.payloadSchema);
   const clock = config.clock ?? (() => new Date);
   const ownerId = config.ownerId ?? crypto.randomUUID();
-  const { pollIntervalMs, leaseMs, maxAttempts, maxQueue, maxStateBytes, retainReceipts } = resolveOutboxLimits(config);
+  const { pollIntervalMs, leaseMs, maxQueue, maxStateBytes, retainReceipts } = resolveOutboxLimits(config);
   const backoffMs = config.backoffMs ?? ((attempt) => backoffDelay(DEFAULT_OUTBOX_BACKOFF, attempt));
   let timer;
   let running = false;
@@ -895,7 +1373,7 @@ function createNotificationOutbox(config) {
   const bounded = (input) => boundedOutboxState(schema.parse(input), maxQueue, retainReceipts, maxStateBytes);
   const parse = (state) => schema.parse(state ?? emptyOutboxState());
   const enqueue = async (input) => {
-    const key = z5.string().min(1).max(512).parse(input.key);
+    const key = z8.string().min(1).max(512).parse(input.key);
     const payload = config.payloadSchema.parse(input.payload);
     const supersedes = new Set(input.supersedes ?? []);
     return config.store.update((current) => {
@@ -904,7 +1382,16 @@ function createNotificationOutbox(config) {
         return { state, result: false };
       }
       const now = clock().toISOString();
-      const fresh = { key, payload, createdAt: now, attempts: 0, nextAttemptAt: now };
+      const fresh = {
+        key,
+        payload,
+        createdAt: now,
+        attempts: 0,
+        nextAttemptAt: now,
+        ...config.delivery && {
+          delivery: notificationDeliveryPlan(config.delivery, payload)
+        }
+      };
       const queue = [
         ...state.queue.filter((item) => !supersedes.has(item.key)),
         { ...fresh, ...NO_LEASE }
@@ -932,11 +1419,15 @@ function createNotificationOutbox(config) {
   const acknowledge = async (claimed) => {
     await config.store.update((current) => {
       const state = parse(current);
-      const owns = state.queue.some((item) => item.key === claimed.key && item.leaseId === claimed.leaseId);
-      if (!owns)
+      const live = state.queue.find((item) => item.key === claimed.key && item.leaseId === claimed.leaseId);
+      if (!live)
         return { state, result: undefined };
       const receipts = [
-        { key: claimed.key, completedAt: clock().toISOString() },
+        {
+          key: claimed.key,
+          completedAt: clock().toISOString(),
+          ...live.delivery && { delivery: live.delivery }
+        },
         ...state.receipts.filter((receipt) => receipt.key !== claimed.key)
       ].slice(0, retainReceipts);
       return {
@@ -949,39 +1440,7 @@ function createNotificationOutbox(config) {
       };
     });
   };
-  const reject = async (claimed, error) => {
-    const classification = await config.classify(error);
-    return config.store.update((current) => {
-      const state = parse(current);
-      const live = state.queue.find((item) => item.key === claimed.key && item.leaseId === claimed.leaseId);
-      if (!live)
-        return { state, result: null };
-      const attempts = live.attempts;
-      const reason = dropReason(classification, attempts, maxAttempts);
-      if (reason) {
-        return {
-          state: bounded({
-            ...state,
-            queue: state.queue.filter((item) => item.key !== live.key)
-          }),
-          result: { item: { ...live, attempts }, error, reason }
-        };
-      }
-      const wait = RetryDelaySchema.parse(backoffMs(attempts));
-      const retry = {
-        ...live,
-        nextAttemptAt: new Date(clock().getTime() + wait).toISOString(),
-        ...NO_LEASE
-      };
-      return {
-        state: bounded({
-          ...state,
-          queue: state.queue.map((item) => item.key === live.key ? retry : item)
-        }),
-        result: null
-      };
-    });
-  };
+  const reject = notificationRejection(config, parse, bounded, clock, backoffMs, pollIntervalMs);
   const flushPass = async () => {
     let delivered = 0;
     while (!interrupted) {
@@ -989,11 +1448,29 @@ function createNotificationOutbox(config) {
       if (!claimed)
         return delivered;
       try {
-        await config.send({
-          key: claimed.key,
-          payload: claimed.payload,
-          attempt: claimed.attempts
-        });
+        if (config.delivery) {
+          const finished = await deliverNotification({
+            item: claimed,
+            store: config.store,
+            config: config.delivery,
+            send: config.send,
+            clock,
+            bounded,
+            leaseMs,
+            active: () => !interrupted,
+            report: (error) => reportOutboxError(config, error)
+          });
+          if (!finished)
+            return delivered;
+        } else {
+          if (claimed.delivery)
+            throw new Error("An action-plan notification requires its delivery executor");
+          await config.send({
+            key: claimed.key,
+            payload: claimed.payload,
+            attempt: claimed.attempts
+          });
+        }
         await acknowledge(claimed);
         delivered += 1;
       } catch (error) {
@@ -1072,11 +1549,11 @@ function notificationOutboxResource(outbox, config = {}) {
   });
 }
 // src/application/process-lifecycle.ts
-import { z as z7 } from "zod";
+import { z as z10 } from "zod";
 
 // src/application/process-lifecycle-transitions.ts
-import { z as z6 } from "zod";
-var LifecycleTerminationSchema = z6.enum([
+import { z as z9 } from "zod";
+var LifecycleTerminationSchema = z9.enum([
   "active",
   "draining",
   "clean",
@@ -1085,22 +1562,22 @@ var LifecycleTerminationSchema = z6.enum([
   "hot-reload",
   "abnormal"
 ]);
-var timestamp = z6.string().datetime({ offset: true });
-var LifecycleRunSchema = z6.object({
-  runId: z6.string().min(1).max(128),
-  pid: z6.number().int().positive(),
-  version: z6.string().min(1).max(256),
+var timestamp = z9.string().datetime({ offset: true });
+var LifecycleRunSchema = z9.object({
+  runId: z9.string().min(1).max(128),
+  pid: z9.number().int().positive(),
+  version: z9.string().min(1).max(256),
   startedAt: timestamp,
   readyAt: timestamp.nullable(),
   unavailableAt: timestamp.nullable().default(null),
   stoppedAt: timestamp.nullable(),
   termination: LifecycleTerminationSchema
 }).strict();
-var LifecycleStateSchema = z6.object({
-  schemaVersion: z6.literal(1),
-  runs: z6.array(LifecycleRunSchema)
+var LifecycleStateSchema = z9.object({
+  schemaVersion: z9.literal(1),
+  runs: z9.array(LifecycleRunSchema)
 }).strict();
-var PreviousExitSchema = z6.enum([
+var PreviousExitSchema = z9.enum([
   "first-boot",
   "hot-reload",
   "clean",
@@ -1127,7 +1604,7 @@ var UNKNOWN_VERSION = "unknown";
 function isVersionChange(previous, next) {
   return previous !== UNKNOWN_VERSION && next !== UNKNOWN_VERSION && previous !== next;
 }
-var RetainSchema = z6.number().int().min(1).max(1000);
+var RetainSchema = z9.number().int().min(1).max(1000);
 function previousExitOf(previous, run, overlap) {
   if (!previous)
     return "first-boot";
@@ -1315,8 +1792,8 @@ function transitionProcessShutdown(source, input) {
 // src/application/process-lifecycle.ts
 function createProcessLifecycleLedger(config) {
   const clock = config.clock ?? (() => new Date);
-  const pid = z7.number().int().positive().parse(config.pid ?? process.pid);
-  const retain = z7.number().int().min(1).max(1000).parse(config.retain ?? 20);
+  const pid = z10.number().int().positive().parse(config.pid ?? process.pid);
+  const retain = z10.number().int().min(1).max(1000).parse(config.retain ?? 20);
   const configuredRunId = config.runId;
   const nextRunId = typeof configuredRunId === "function" ? configuredRunId : configuredRunId === undefined ? () => crypto.randomUUID() : () => configuredRunId;
   let runId = nextRunId();
@@ -1441,27 +1918,27 @@ function lifecycleLedgerResource(ledger, config) {
   });
 }
 // src/application/revision-signal.ts
-import { z as z8 } from "zod";
-var NonNegativeSafeIntegerSchema = z8.number().int().nonnegative().safe();
-var PositiveSafeIntegerSchema2 = z8.number().int().positive().safe();
-var TimerDelaySchema = z8.number().int().positive().max(2147483647);
-var RevisionSignalStateSchema = z8.enum(["open", "closed"]);
-var RevisionSignalWaitOutcomeSchema = z8.enum([
+import { z as z11 } from "zod";
+var NonNegativeSafeIntegerSchema = z11.number().int().nonnegative().safe();
+var PositiveSafeIntegerSchema2 = z11.number().int().positive().safe();
+var TimerDelaySchema = z11.number().int().positive().max(2147483647);
+var RevisionSignalStateSchema = z11.enum(["open", "closed"]);
+var RevisionSignalWaitOutcomeSchema = z11.enum([
   "changed",
   "timed-out",
   "aborted",
   "closed",
   "capacity"
 ]);
-var RevisionSignalWaitResultSchema = z8.object({
+var RevisionSignalWaitResultSchema = z11.object({
   outcome: RevisionSignalWaitOutcomeSchema,
   revision: NonNegativeSafeIntegerSchema
 }).strict().readonly();
-var RevisionSignalAdvanceResultSchema = z8.object({
-  outcome: z8.enum(["advanced", "closed"]),
+var RevisionSignalAdvanceResultSchema = z11.object({
+  outcome: z11.enum(["advanced", "closed"]),
   revision: NonNegativeSafeIntegerSchema
 }).strict().readonly();
-var RevisionSignalSnapshotSchema = z8.object({
+var RevisionSignalSnapshotSchema = z11.object({
   state: RevisionSignalStateSchema,
   revision: NonNegativeSafeIntegerSchema,
   pending: NonNegativeSafeIntegerSchema,
@@ -1665,6 +2142,78 @@ function managedServerResource(config) {
     }
   });
 }
+// src/application/watch-hub-source.ts
+function remember(source, deltaMemoryBytes, revision, value, fingerprint) {
+  if (deltaMemoryBytes === 0)
+    return;
+  const bytes = (JSON.stringify(value) ?? "null").length;
+  if (bytes > deltaMemoryBytes)
+    return;
+  source.history.set(revision, { value, fingerprint, bytes });
+  source.historyBytes += bytes;
+  for (const [oldest, entry] of source.history) {
+    if (source.historyBytes <= deltaMemoryBytes)
+      break;
+    source.history.delete(oldest);
+    source.historyBytes -= entry.bytes;
+  }
+}
+function fullFrame(source) {
+  const value = source.value;
+  return {
+    kind: "full",
+    key: source.key,
+    revision: source.revision,
+    fingerprint: source.fingerprint ?? valueFingerprint(value),
+    value
+  };
+}
+function frameFor(source, subscriber) {
+  const value = source.value;
+  const full = fullFrame(source);
+  const fingerprint = full.fingerprint;
+  const base = source.baselines.get(subscriber);
+  if (base === undefined)
+    return full;
+  if (base === source.revision) {
+    return { kind: "unchanged", key: source.key, revision: source.revision, fingerprint };
+  }
+  const held = source.history.get(base);
+  if (!held)
+    return full;
+  const delta = diff(held.value, value);
+  if (delta === undefined || !deltaWins(delta, value))
+    return full;
+  return {
+    kind: "delta",
+    key: source.key,
+    revision: source.revision,
+    fingerprint,
+    base,
+    delta
+  };
+}
+function adoptBaseline(source, subscriber, have) {
+  if (source.fingerprint === have.fingerprint) {
+    source.baselines.set(subscriber, source.revision);
+    return;
+  }
+  const named = source.history.get(have.revision);
+  if (named?.fingerprint === have.fingerprint) {
+    source.baselines.set(subscriber, have.revision);
+    return;
+  }
+  for (const [revision, entry] of source.history) {
+    if (entry.fingerprint !== have.fingerprint)
+      continue;
+    source.baselines.set(subscriber, revision);
+    return;
+  }
+}
+function valueFingerprint(value) {
+  return argumentsDigest({ value });
+}
+
 // src/application/watch-hub-core.ts
 var DEFAULT_BACKOFF = { minDelayMs: 250, maxDelayMs: 30000, jitter: 0.2 };
 
@@ -1678,9 +2227,23 @@ class WatchHubCore {
   same;
   reads = 0;
   closed = false;
+  periodic;
   constructor(config) {
     this.config = config;
     this.maxWatches = config.maxWatchesPerSubscriber ?? 64;
+    for (const bound of [config.maxSources ?? 1024, config.maxSubscribers ?? 1024]) {
+      if (!Number.isInteger(bound) || bound < 1)
+        throw new RangeError("Watch capacity must be positive");
+    }
+    if (config.reconcileIntervalMs !== undefined) {
+      if (!Number.isInteger(config.reconcileIntervalMs) || config.reconcileIntervalMs < 10 || config.reconcileIntervalMs > 3600000)
+        throw new RangeError("Invalid reconciliation interval");
+      this.periodic = setInterval(() => {
+        for (const source of this.sources.values())
+          source.task.trigger();
+      }, config.reconcileIntervalMs);
+      this.periodic.unref?.();
+    }
     this.holdMs = config.holdMs ?? 0;
     this.deltaMemoryBytes = config.deltaMemoryBytes ?? 262144;
     this.same = config.same ?? ((previous, next) => serializeCanonicalJson(previous) === serializeCanonicalJson(next));
@@ -1700,82 +2263,24 @@ class WatchHubCore {
   announceState(source, state) {
     source.state = state;
     for (const subscriber of source.subscribers) {
-      this.tell(source.key, () => subscriber.state(state));
-    }
-  }
-  remember(source, revision, value, fingerprint) {
-    if (this.deltaMemoryBytes === 0)
-      return;
-    const bytes = (JSON.stringify(value) ?? "null").length;
-    if (bytes > this.deltaMemoryBytes)
-      return;
-    source.history.set(revision, { value, fingerprint, bytes });
-    source.historyBytes += bytes;
-    for (const [oldest, entry] of source.history) {
-      if (source.historyBytes <= this.deltaMemoryBytes)
-        break;
-      source.history.delete(oldest);
-      source.historyBytes -= entry.bytes;
-    }
-  }
-  frameFor(source, subscriber) {
-    const value = source.value;
-    const fingerprint = source.fingerprint ?? valueFingerprint(value);
-    const full = {
-      kind: "full",
-      key: source.key,
-      revision: source.revision,
-      fingerprint,
-      value
-    };
-    const base = source.baselines.get(subscriber);
-    if (base === undefined)
-      return full;
-    if (base === source.revision) {
-      return { kind: "unchanged", key: source.key, revision: source.revision, fingerprint };
-    }
-    const held = source.history.get(base);
-    if (!held)
-      return full;
-    const delta = diff(held.value, value);
-    if (delta === undefined || !deltaWins(delta, value))
-      return full;
-    return {
-      kind: "delta",
-      key: source.key,
-      revision: source.revision,
-      fingerprint,
-      base,
-      delta
-    };
-  }
-  adoptBaseline(source, subscriber, have) {
-    if (source.fingerprint === have.fingerprint) {
-      source.baselines.set(subscriber, source.revision);
-      return;
-    }
-    const named = source.history.get(have.revision);
-    if (named?.fingerprint === have.fingerprint) {
-      source.baselines.set(subscriber, have.revision);
-      return;
-    }
-    for (const [revision, entry] of source.history) {
-      if (entry.fingerprint !== have.fingerprint)
-        continue;
-      source.baselines.set(subscriber, revision);
-      return;
+      for (const key of source.routes.get(subscriber)?.values() ?? []) {
+        this.tell(key, () => subscriber.state({ ...state, key }));
+      }
     }
   }
   deliver(source, subscriber) {
-    const frame = this.frameFor(source, subscriber);
-    const delivered = this.tell(source.key, () => subscriber.value(frame));
+    const frame = frameFor(source, subscriber);
+    let delivered = true;
+    for (const key of source.routes.get(subscriber)?.values() ?? []) {
+      delivered = this.tell(key, () => subscriber.value({ ...frame, key })) && delivered;
+    }
     if (delivered)
       source.baselines.set(subscriber, source.revision);
     return delivered;
   }
   publish(source, value, fingerprint) {
     if (source.fingerprint !== undefined) {
-      this.remember(source, source.revision, source.value, source.fingerprint);
+      remember(source, this.deltaMemoryBytes, source.revision, source.value, source.fingerprint);
     }
     source.revision += 1;
     source.value = value;
@@ -1783,58 +2288,34 @@ class WatchHubCore {
     for (const subscriber of source.subscribers)
       this.deliver(source, subscriber);
   }
-  async pump(source) {
-    if (source.reading || this.closed)
+  async readSource(source) {
+    this.reads += 1;
+    const value = await this.config.read(source.operation, source.args, source.scope);
+    if (this.closed || this.sources.get(source.id) !== source)
       return;
-    source.reading = true;
-    try {
-      while (source.dirty && !this.closed) {
-        source.dirty = false;
-        this.reads += 1;
-        try {
-          const value = await this.config.read(source.operation, source.args);
-          source.backoff.reset();
-          const signature = serializeCanonicalJson(value);
-          const unchanged = source.signature !== undefined && this.same(source.value, value);
-          source.signature = signature;
-          if (!unchanged)
-            this.publish(source, value, valueFingerprint(value));
-          if (source.state.phase !== "live") {
-            this.announceState(source, { key: source.key, phase: "live" });
-          }
-        } catch (error) {
-          const code = readErrorCode(error);
-          this.announceState(source, {
-            key: source.key,
-            phase: "unavailable",
-            reason: "source-error",
-            ...code !== undefined && { code },
-            message: error instanceof Error ? error.message : String(error)
-          });
-          this.config.logger?.warn?.("[stitchkit] watched read failed", {
-            key: watchKeyString(source.key),
-            error
-          });
-          this.scheduleRetry(source);
-          return;
-        }
-      }
-    } finally {
-      source.reading = false;
-    }
+    const signature = serializeCanonicalJson(value);
+    const unchanged = source.signature !== undefined && this.same(source.value, value);
+    source.signature = signature;
+    if (!unchanged)
+      this.publish(source, value, valueFingerprint(value));
+    if (source.state.phase !== "live")
+      this.announceState(source, { key: source.key, phase: "live" });
   }
-  scheduleRetry(source) {
-    if (this.closed || source.subscribers.size === 0)
-      return;
-    clearTimeout(source.retry);
-    source.retry = setTimeout(() => {
-      source.dirty = true;
-      this.pump(source);
-    }, source.backoff.next());
-    source.retry.unref?.();
+  readFailed(source, error) {
+    this.announceState(source, {
+      key: source.key,
+      phase: "unavailable",
+      reason: "source-error",
+      ...AppError.is(error) ? { code: error.code, message: error.message } : { message: "The watched read failed" }
+    });
+    this.config.logger?.warn?.("[stitchkit] watched read failed", {
+      key: watchKeyString(source.key),
+      error
+    });
   }
-  acquire(operation, key, args) {
-    const id = watchKeyString(key);
+  acquire(operation, routed, args, scope) {
+    const id = sourceId(scope, routed);
+    const key = sharedKey(routed);
     const existing = this.sources.get(id);
     if (existing) {
       clearTimeout(existing.release);
@@ -1842,24 +2323,29 @@ class WatchHubCore {
       return existing;
     }
     const source = {
+      id,
+      scope,
       key,
       operation,
       args,
       subscribers: new Set,
+      routes: new Map,
       unsubscribes: [],
       revision: 0,
       history: new Map,
       historyBytes: 0,
       baselines: new Map,
-      reading: false,
-      dirty: true,
-      state: { key, phase: "opening" },
-      backoff: createBackoff(this.config.backoff ?? DEFAULT_BACKOFF)
+      task: createCoalescedTask({
+        run: () => this.readSource(source),
+        active: () => !this.closed && source.subscribers.size > 0,
+        onError: (error) => this.readFailed(source, error),
+        backoff: this.config.backoff ?? DEFAULT_BACKOFF
+      }),
+      state: { key, phase: "opening" }
     };
     for (const topic of this.config.invalidatedBy(operation, args)) {
       source.unsubscribes.push(this.config.subscribe(topic, () => {
-        source.dirty = true;
-        this.pump(source);
+        source.task.trigger();
       }));
     }
     this.sources.set(id, source);
@@ -1868,17 +2354,17 @@ class WatchHubCore {
   release(source) {
     if (source.subscribers.size > 0)
       return;
-    clearTimeout(source.retry);
-    source.retry = undefined;
+    source.task.pauseRetry();
     const drop = () => {
-      if (source.reading) {
+      if (source.task.running) {
         source.release = setTimeout(drop, 10);
         source.release.unref?.();
         return;
       }
+      source.task.close();
       for (const unsubscribe of source.unsubscribes)
         unsubscribe();
-      this.sources.delete(watchKeyString(source.key));
+      this.sources.delete(source.id);
     };
     if (this.holdMs === 0) {
       drop();
@@ -1887,11 +2373,38 @@ class WatchHubCore {
     source.release = setTimeout(drop, this.holdMs);
     source.release.unref?.();
   }
-  attach(subscriber) {
-    const keys = new Set;
+  unroute(source, subscriber, route) {
+    const routes = source.routes.get(subscriber);
+    routes?.delete(route);
+    if (routes && routes.size > 0)
+      return;
+    source.routes.delete(subscriber);
+    source.subscribers.delete(subscriber);
+    source.baselines.delete(subscriber);
+    this.release(source);
+  }
+  attach(subscriber, scope) {
+    if (this.held.size >= (this.config.maxSubscribers ?? 1024)) {
+      const refused = {
+        open: () => ({ accepted: false, reason: "Watch subscriber capacity exceeded" }),
+        close: () => {
+          return;
+        },
+        detach: () => {
+          return;
+        }
+      };
+      return refused;
+    }
+    if (scope && (!scope.key || scope.key.length > 512))
+      throw new Error("Invalid watch admission scope");
+    const keys = new Map;
     this.held.set(subscriber, keys);
-    return {
+    let detached = false;
+    const attached = {
       open: (key, args, have) => {
+        if (detached || scope?.signal.aborted)
+          return { accepted: false, reason: "Watch scope ended" };
         if (this.closed)
           return { accepted: false, reason: "the watch hub is closed" };
         const operation = { service: key.service, action: key.action };
@@ -1901,8 +2414,9 @@ class WatchHubCore {
             reason: `${key.service}.${key.action} is not watchable`
           };
         }
-        const id = watchKeyString(key);
-        if (keys.has(id))
+        const route = watchKeyString(key);
+        const id = sourceId(scope?.key, key);
+        if (keys.has(route))
           return { accepted: true };
         if (keys.size >= this.maxWatches) {
           return {
@@ -1910,82 +2424,91 @@ class WatchHubCore {
             reason: `this connection is already watching ${keys.size} reads (limit ${this.maxWatches})`
           };
         }
-        const source = this.acquire(operation, key, args);
+        if (!this.sources.has(id) && this.sources.size >= (this.config.maxSources ?? 1024))
+          return { accepted: false, reason: "Watch source capacity exceeded" };
+        const source = this.acquire(operation, key, args, scope?.key);
+        const alreadyRouted = source.routes.has(subscriber);
         source.subscribers.add(subscriber);
-        keys.add(id);
+        const routes = source.routes.get(subscriber) ?? new Map;
+        routes.set(route, key);
+        source.routes.set(subscriber, routes);
+        keys.set(route, id);
         if (have)
-          this.adoptBaseline(source, subscriber, have);
+          adoptBaseline(source, subscriber, have);
         try {
           if (source.signature !== undefined) {
-            const frame = this.frameFor(source, subscriber);
-            subscriber.value(frame);
+            const frame = alreadyRouted && !have ? fullFrame(source) : frameFor(source, subscriber);
+            subscriber.value({ ...frame, key });
             source.baselines.set(subscriber, source.revision);
           }
-          subscriber.state(source.state);
+          subscriber.state({ ...source.state, key });
         } catch (error) {
-          source.subscribers.delete(subscriber);
-          source.baselines.delete(subscriber);
-          keys.delete(id);
-          this.release(source);
+          keys.delete(route);
+          this.unroute(source, subscriber, route);
           return {
             accepted: false,
             reason: error instanceof Error ? error.message : String(error)
           };
         }
-        this.pump(source);
+        if (!source.task.running && (source.signature === undefined || source.state.phase !== "live" || source.task.pending))
+          source.task.trigger();
         return { accepted: true };
       },
       close: (key) => {
-        const id = watchKeyString(key);
-        if (!keys.delete(id))
+        const route = watchKeyString(key);
+        const id = keys.get(route);
+        if (id === undefined)
           return;
+        keys.delete(route);
         const source = this.sources.get(id);
-        if (!source)
-          return;
-        source.subscribers.delete(subscriber);
-        source.baselines.delete(subscriber);
-        this.release(source);
+        if (source)
+          this.unroute(source, subscriber, route);
       },
       detach: () => {
-        for (const id of keys) {
+        detached = true;
+        scope?.signal.removeEventListener("abort", onAbort);
+        for (const [route, id] of keys) {
           const source = this.sources.get(id);
-          if (!source)
-            continue;
-          source.subscribers.delete(subscriber);
-          source.baselines.delete(subscriber);
-          this.release(source);
+          if (source)
+            this.unroute(source, subscriber, route);
         }
         keys.clear();
         this.held.delete(subscriber);
       }
     };
+    const onAbort = () => attached.detach();
+    if (scope?.signal.aborted)
+      attached.detach();
+    else
+      scope?.signal.addEventListener("abort", onAbort, { once: true });
+    return attached;
   }
   close() {
     this.closed = true;
+    clearInterval(this.periodic);
     const teardown = [...this.sources.values()];
     this.sources.clear();
     this.held.clear();
     for (const source of teardown) {
-      clearTimeout(source.retry);
+      source.task.close();
       clearTimeout(source.release);
       this.announceState(source, {
         key: source.key,
         phase: "unavailable",
         reason: "source-unavailable"
       });
+      source.task.close();
       for (const unsubscribe of source.unsubscribes)
         unsubscribe();
     }
   }
 }
-function valueFingerprint(value) {
-  return argumentsDigest({ value });
+function sharedKey(key) {
+  const { instance: _routing, ...shared } = key;
+  return shared;
 }
-function readErrorCode(error) {
-  if (typeof error !== "object" || error === null)
-    return;
-  const code = Reflect.get(error, "code");
-  return typeof code === "string" ? code : undefined;
+function sourceId(scope, key) {
+  return JSON.stringify([scope ?? null, watchKeyString(sharedKey(key))]);
 }
 
 // src/application/watch-hub.ts
@@ -2000,7 +2523,7 @@ function watchKey(operation, args) {
 function createWatchHub(config) {
   const hub = new WatchHubCore(config);
   return {
-    attach: (subscriber) => hub.attach(subscriber),
+    attach: (subscriber, scope) => hub.attach(subscriber, scope),
     readCount: () => hub.reads,
     size: () => hub.sources.size,
     close: () => hub.close()
@@ -2040,6 +2563,7 @@ export {
   createApplicationEventSink,
   createApplication,
   createActivityProjection,
+  changeSubscriptionResource,
   applicationLifecycleEvent,
   RevisionSignalWaitResultSchema,
   RevisionSignalWaitOutcomeSchema,
@@ -2048,6 +2572,8 @@ export {
   RevisionSignalAdvanceResultSchema,
   PreviousExitSchema,
   PolicyDecisionSchema,
+  NotificationPlanVersionError,
+  NotificationDeliveryStateSchema,
   ManagedScheduleStatusSchema,
   ManagedScheduleOverlapSchema,
   ManagedScheduleErrorPolicySchema,