stitchkit 0.93.0 → 0.94.1

package/dist/entrypoints/application.js

@@ -0,0 +1,2016 @@
+import {
+  ActivityIdSchema,
+  ActivityLiveStateSchema,
+  ActivitySnapshotSchema,
+  ActivityStageIdSchema,
+  ActivityStageSnapshotSchema,
+  ActivityTokenBrand,
+  ApplicationSnapshotSinkStatusSchema,
+  ManagedScheduleDescriptorSchema,
+  ManagedScheduleErrorPolicySchema,
+  ManagedScheduleOverlapSchema,
+  ManagedScheduleStatusSchema,
+  createActivityProjection,
+  createApplicationSnapshotSink,
+  createManagedSchedule
+} from "../index-ensd0r74.js";
+import {
+  DiagnosticJournalCloseResultSchema,
+  DiagnosticJournalFailurePhaseSchema,
+  DiagnosticJournalFrameSchema,
+  DiagnosticJournalLimitsSchema,
+  DiagnosticJournalLockPolicySchema,
+  DiagnosticJournalRefusalReasonSchema,
+  DiagnosticJournalStateSchema,
+  DiagnosticJournalStatusSchema,
+  DiagnosticJournalSubmitResultSchema,
+  DiagnosticJournalWaitResultSchema,
+  readDiagnosticJournalLockDiagnosis
+} from "../index-qwhynv6x.js";
+import"../index-5jm36zv1.js";
+import {
+  ApplicationAdmissionError,
+  ApplicationRestartInputSchema,
+  ApplicationRestartOutcomeSchema,
+  ApplicationRestartResultSchema,
+  ApplicationShutdownBudgetSchema,
+  ApplicationShutdownOptionsSchema,
+  createApplication
+} from "../index-w906953s.js";
+import {
+  ApplicationAdmissionSnapshotSchema,
+  ApplicationHealthSchema,
+  ApplicationIdSchema,
+  ApplicationLifecycleSchema,
+  ApplicationResourceShutdownSchema,
+  ApplicationShutdownResultSchema,
+  ApplicationSnapshotSchema,
+  ApplicationStatusProjectionSchema,
+  ManagedResourceSnapshotSchema,
+  ManagedResourceStateSchema,
+  projectApplicationStatus
+} from "../index-3gye9wzb.js";
+import {
+  defineManagedResource,
+  managedResourceDependencyId
+} from "../index-2k4yrqkc.js";
+import {
+  withDeadline
+} from "../index-b9aefrqd.js";
+import"../index-3z73fh2c.js";
+import {
+  createBoundedSinkManager
+} from "../index-h6eeys1v.js";
+import {
+  backoffDelay,
+  createBackoff
+} from "../index-ngfhvfpd.js";
+import {
+  deltaWins,
+  diff,
+  watchKeyString
+} from "../index-wdkt63w3.js";
+import"../index-1j8pm5t0.js";
+import {
+  BoundedChannelPolicySchema,
+  BoundedChannelReaderError,
+  BoundedChannelSnapshotSchema,
+  BoundedChannelStateSchema,
+  CreditWindowSnapshotSchema,
+  createBoundedChannel,
+  createCreditWindow
+} from "../index-d9pk3td4.js";
+import {
+  measureSize
+} from "../index-yw4fzmdz.js";
+import {
+  argumentsDigest
+} from "../index-0b1ess5e.js";
+import"../index-2vtcmrj9.js";
+import {
+  serializeCanonicalJson
+} from "../index-k5hsfc3j.js";
+import"../index-kzfs85xp.js";
+import"../index-hffjpmq9.js";
+// src/application/admission.ts
+import { z } from "zod";
+
+// src/application/admission-rate.ts
+function pruneRate(samples, intervalMs, at) {
+  let expired = 0;
+  while (expired < samples.length && at - (samples[expired]?.at ?? at) >= intervalMs) {
+    expired += 1;
+  }
+  if (expired > 0)
+    samples.splice(0, expired);
+}
+function pruneExpired(policy, globalRate, keys, at) {
+  if (policy.global.rate)
+    pruneRate(globalRate, policy.global.rate.intervalMs, at);
+  for (const [key, record] of keys) {
+    if (record.limits?.rate)
+      pruneRate(record.rate, record.limits.rate.intervalMs, at);
+    if (record.active === 0 && record.rate.length === 0)
+      keys.delete(key);
+  }
+}
+function retryAfter(samples, budget, at) {
+  return Math.max(1, Math.ceil(budget.intervalMs - (at - (samples[0]?.at ?? at))));
+}
+function removeSample(samples, sample) {
+  if (!sample)
+    return;
+  const index = samples.indexOf(sample);
+  if (index >= 0)
+    samples.splice(index, 1);
+}
+
+// src/application/admission-run.ts
+async function runAdmitted(acquire, key, work, options) {
+  if (options.timeoutMs !== undefined) {
+    if (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 0) {
+      throw new TypeError("run timeoutMs must be a non-negative safe integer");
+    }
+  }
+  if (options.signal?.aborted)
+    throw new BoundedOperationWaitError("cancelled");
+  const admission = acquire(key);
+  if (admission.outcome === "refused") {
+    throw new BoundedAdmissionRefusalError(admission.reason, admission.retryAfterMs);
+  }
+  const workAbort = new AbortController;
+  const abortWork = () => workAbort.abort(options.signal?.reason);
+  options.signal?.addEventListener("abort", abortWork, { once: true });
+  let timer;
+  let timedOut = false;
+  if (options.timeoutMs !== undefined) {
+    timer = setTimeout(() => {
+      timedOut = true;
+      workAbort.abort(new DOMException("Operation wait timed out", "TimeoutError"));
+    }, options.timeoutMs);
+  }
+  const outcome = Promise.resolve().then(() => work({ signal: workAbort.signal })).then((value) => ({ kind: "value", value }), (error) => ({ kind: "error", error })).finally(() => admission.lease.release());
+  const callerDone = new Promise((resolve) => {
+    const settle = () => resolve({ kind: "caller" });
+    if (workAbort.signal.aborted)
+      settle();
+    else
+      workAbort.signal.addEventListener("abort", settle, { once: true });
+  });
+  try {
+    const settled = await Promise.race([outcome, callerDone]);
+    if (settled.kind === "caller") {
+      throw new BoundedOperationWaitError(timedOut ? "timed-out" : "cancelled");
+    }
+    if (settled.kind === "error")
+      throw settled.error;
+    return settled.value;
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+    options.signal?.removeEventListener("abort", abortWork);
+  }
+}
+
+// src/application/admission.ts
+var PositiveSafeIntegerSchema = z.number().int().positive().safe();
+var BoundedRateBudgetSchema = z.object({
+  limit: PositiveSafeIntegerSchema,
+  intervalMs: PositiveSafeIntegerSchema
+}).strict().readonly();
+var BoundedAdmissionPerKeyLimitsSchema = z.object({
+  maxConcurrent: PositiveSafeIntegerSchema,
+  rate: BoundedRateBudgetSchema.optional()
+}).strict().readonly();
+var PerKeyLimitResolverSchema = z.custom((value) => typeof value === "function", { message: "perKey.limits must be a function of the key" });
+var BoundedAdmissionPolicySchema = z.object({
+  global: z.object({
+    maxConcurrent: PositiveSafeIntegerSchema,
+    rate: BoundedRateBudgetSchema.optional()
+  }).strict(),
+  perKey: z.union([
+    z.object({
+      maxConcurrent: PositiveSafeIntegerSchema,
+      maxKeys: PositiveSafeIntegerSchema,
+      rate: BoundedRateBudgetSchema.optional(),
+      limits: z.never().optional()
+    }).strict(),
+    z.object({
+      maxKeys: PositiveSafeIntegerSchema,
+      limits: PerKeyLimitResolverSchema,
+      maxConcurrent: z.never().optional(),
+      rate: z.never().optional()
+    }).strict()
+  ]).optional()
+}).strict().readonly();
+var BoundedAdmissionStateSchema = z.enum(["accepting", "draining", "closed"]);
+var BoundedAdmissionRefusalReasonSchema = z.enum([
+  "not-accepting",
+  "global-concurrency",
+  "key-required",
+  "key-capacity",
+  "key-concurrency",
+  "global-rate",
+  "key-rate",
+  "upstream"
+]);
+var RefusalCountersSchema = z.object({
+  "not-accepting": z.number().int().nonnegative(),
+  "global-concurrency": z.number().int().nonnegative(),
+  "key-required": z.number().int().nonnegative(),
+  "key-capacity": z.number().int().nonnegative(),
+  "key-concurrency": z.number().int().nonnegative(),
+  "global-rate": z.number().int().nonnegative(),
+  "key-rate": z.number().int().nonnegative(),
+  upstream: z.number().int().nonnegative()
+}).strict().readonly();
+var BoundedAdmissionSnapshotSchema = z.object({
+  state: BoundedAdmissionStateSchema,
+  active: z.number().int().nonnegative(),
+  accepted: z.number().int().nonnegative(),
+  released: z.number().int().nonnegative(),
+  refused: z.number().int().nonnegative(),
+  keys: z.number().int().nonnegative(),
+  globalRateSamples: z.number().int().nonnegative(),
+  keyRateSamples: z.number().int().nonnegative(),
+  refusals: RefusalCountersSchema
+}).strict().readonly();
+
+class BoundedAdmissionRefusalError extends Error {
+  reason;
+  retryAfterMs;
+  constructor(reason, retryAfterMs) {
+    super(`Bounded admission refused: ${reason}`);
+    this.reason = reason;
+    this.retryAfterMs = retryAfterMs;
+    this.name = "BoundedAdmissionRefusalError";
+  }
+}
+
+class BoundedOperationWaitError extends Error {
+  reason;
+  constructor(reason) {
+    super(reason === "cancelled" ? "Operation wait was cancelled" : "Operation wait timed out");
+    this.reason = reason;
+    this.name = "BoundedOperationWaitError";
+  }
+}
+var NO_REFUSALS = {
+  "not-accepting": 0,
+  "global-concurrency": 0,
+  "key-required": 0,
+  "key-capacity": 0,
+  "key-concurrency": 0,
+  "global-rate": 0,
+  "key-rate": 0,
+  upstream: 0
+};
+async function waitForDrain(drainWaiters, options) {
+  const controller = new AbortController;
+  let timer;
+  const abort = () => controller.abort();
+  if (options.signal?.aborted)
+    abort();
+  else
+    options.signal?.addEventListener("abort", abort, { once: true });
+  if (options.timeoutMs !== undefined) {
+    if (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 0) {
+      throw new TypeError("drain timeoutMs must be a non-negative safe integer");
+    }
+    timer = setTimeout(abort, options.timeoutMs);
+  }
+  let resolveDrained;
+  try {
+    await Promise.race([
+      new Promise((resolve) => {
+        resolveDrained = resolve;
+        drainWaiters.add(resolve);
+      }),
+      new Promise((resolve) => {
+        if (controller.signal.aborted)
+          resolve();
+        else
+          controller.signal.addEventListener("abort", () => resolve(), { once: true });
+      })
+    ]);
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+    options.signal?.removeEventListener("abort", abort);
+    if (resolveDrained)
+      drainWaiters.delete(resolveDrained);
+  }
+}
+function createBoundedAdmission(config) {
+  const policy = BoundedAdmissionPolicySchema.parse(config.policy);
+  const clock = config.clock ?? { now: () => performance.now() };
+  const keys = new Map;
+  const globalRate = [];
+  const drainWaiters = new Set;
+  const refusals = { ...NO_REFUSALS };
+  let state = "accepting";
+  let active = 0;
+  let accepted = 0;
+  let released = 0;
+  let refused = 0;
+  let lastNow = Number.NEGATIVE_INFINITY;
+  const now = () => {
+    const value = clock.now();
+    if (!Number.isFinite(value))
+      throw new TypeError("Bounded admission clock must be finite");
+    if (value < lastNow)
+      throw new Error("Bounded admission clock moved backwards");
+    lastNow = value;
+    return value;
+  };
+  const resolveKeyLimits = (key) => {
+    const perKey = policy.perKey;
+    if (!perKey)
+      return;
+    const resolver = perKey.limits;
+    if (resolver)
+      return BoundedAdmissionPerKeyLimitsSchema.parse(resolver(key));
+    return BoundedAdmissionPerKeyLimitsSchema.parse({
+      maxConcurrent: perKey.maxConcurrent,
+      ...perKey.rate && { rate: perKey.rate }
+    });
+  };
+  const prune = (at) => pruneExpired(policy, globalRate, keys, at);
+  const refuse = (reason, retryAfterMs) => {
+    refused += 1;
+    refusals[reason] += 1;
+    return {
+      outcome: "refused",
+      reason,
+      ...retryAfterMs !== undefined && { retryAfterMs }
+    };
+  };
+  const closeIfDrained = () => {
+    if (state !== "draining" || active !== 0)
+      return;
+    state = "closed";
+    for (const resolve of drainWaiters)
+      resolve();
+    drainWaiters.clear();
+  };
+  const rollbackReservation = (key, keyRecord, globalSample, keySample) => {
+    active -= 1;
+    if (keyRecord)
+      keyRecord.active -= 1;
+    removeSample(globalRate, globalSample);
+    if (keyRecord)
+      removeSample(keyRecord.rate, keySample);
+    if (key !== undefined && keyRecord?.active === 0 && keyRecord.rate.length === 0) {
+      keys.delete(key);
+    }
+  };
+  const acquire = (key) => {
+    const at = now();
+    prune(at);
+    if (state !== "accepting")
+      return refuse("not-accepting");
+    if (active >= policy.global.maxConcurrent)
+      return refuse("global-concurrency");
+    if (policy.perKey && key === undefined)
+      return refuse("key-required");
+    let keyRecord = key === undefined ? undefined : keys.get(key);
+    if (policy.perKey && key !== undefined) {
+      if (!keyRecord && keys.size >= policy.perKey.maxKeys)
+        return refuse("key-capacity");
+      if (keyRecord?.limits && keyRecord.active >= keyRecord.limits.maxConcurrent) {
+        return refuse("key-concurrency");
+      }
+    }
+    if (policy.global.rate && globalRate.length >= policy.global.rate.limit) {
+      return refuse("global-rate", retryAfter(globalRate, policy.global.rate, at));
+    }
+    const keyRate = keyRecord?.limits?.rate;
+    if (keyRate && keyRecord && keyRecord.rate.length >= keyRate.limit) {
+      return refuse("key-rate", retryAfter(keyRecord.rate, keyRate, at));
+    }
+    if (key !== undefined && !keyRecord) {
+      keyRecord = { active: 0, rate: [], limits: resolveKeyLimits(key) };
+      keys.set(key, keyRecord);
+    }
+    const globalSample = policy.global.rate ? { at } : undefined;
+    const keySample = keyRecord?.limits?.rate ? { at } : undefined;
+    active += 1;
+    if (keyRecord)
+      keyRecord.active += 1;
+    if (globalSample)
+      globalRate.push(globalSample);
+    if (keySample && keyRecord)
+      keyRecord.rate.push(keySample);
+    const upstreamLease = config.upstream?.acquire();
+    if (config.upstream && !upstreamLease) {
+      rollbackReservation(key, keyRecord, globalSample, keySample);
+      return refuse("upstream");
+    }
+    accepted += 1;
+    let leaseReleased = false;
+    const lease = {
+      ...key !== undefined && { key },
+      get released() {
+        return leaseReleased;
+      },
+      release() {
+        if (leaseReleased)
+          return;
+        leaseReleased = true;
+        active -= 1;
+        if (keyRecord)
+          keyRecord.active -= 1;
+        released += 1;
+        if (key !== undefined && keyRecord?.active === 0 && keyRecord.rate.length === 0) {
+          keys.delete(key);
+        }
+        upstreamLease?.release();
+        closeIfDrained();
+      }
+    };
+    return { outcome: "leased", lease };
+  };
+  const getSnapshot = () => {
+    const at = now();
+    prune(at);
+    let keyRateSamples = 0;
+    for (const record of keys.values())
+      keyRateSamples += record.rate.length;
+    return BoundedAdmissionSnapshotSchema.parse({
+      state,
+      active,
+      accepted,
+      released,
+      refused,
+      keys: keys.size,
+      globalRateSamples: globalRate.length,
+      keyRateSamples,
+      refusals
+    });
+  };
+  const stopAdmission = () => {
+    if (state === "accepting")
+      state = "draining";
+    closeIfDrained();
+    return getSnapshot();
+  };
+  const drain = async (options = {}) => {
+    stopAdmission();
+    if (active === 0)
+      return { drained: true, remaining: 0 };
+    await waitForDrain(drainWaiters, options);
+    return { drained: active === 0, remaining: active };
+  };
+  const run = (key, work, options = {}) => runAdmitted(acquire, key, work, options);
+  return {
+    acquire,
+    run,
+    stopAdmission,
+    drain,
+    force() {
+      if (state === "accepting")
+        state = "draining";
+      state = "closed";
+      for (const resolve of drainWaiters)
+        resolve();
+      drainWaiters.clear();
+      return { remaining: active };
+    },
+    getSnapshot
+  };
+}
+// src/internal/decision.ts
+import { z as z2 } from "zod";
+var PolicyDecisionSchema = z2.discriminatedUnion("outcome", [
+  z2.object({ outcome: z2.literal("allow") }).strict(),
+  z2.object({ outcome: z2.literal("deny"), reason: z2.string().min(1) }).strict(),
+  z2.object({ outcome: z2.literal("defer") }).strict()
+]);
+
+// src/application/decisions.ts
+class DecisionUndecidedError extends Error {
+  trace;
+  constructor(trace) {
+    const ran = trace.length === 0 ? "no policy ran" : trace.map((e) => e.id).join(" → ");
+    super(`Decision pipeline reached its end with no terminal verdict (${ran}). A pipeline needs a policy that answers allow or deny.`);
+    this.name = "DecisionUndecidedError";
+    this.trace = trace;
+  }
+}
+
+class DecisionPolicyError extends Error {
+  policyId;
+  trace;
+  constructor(policyId, detail, trace = []) {
+    super(`Policy "${policyId}" did not answer (${detail}). A policy returns { outcome: "allow" | "deny" | "defer" } within its deadline, and a deny carries a reason.`);
+    this.name = "DecisionPolicyError";
+    this.policyId = policyId;
+    this.trace = trace;
+  }
+}
+function createDecisionPipeline(policies, config) {
+  const { policyTimeoutMs } = config;
+  if (!Number.isInteger(policyTimeoutMs) || policyTimeoutMs <= 0) {
+    throw new Error("[stitchkit] decision pipeline: policyTimeoutMs must be a positive integer number of milliseconds.");
+  }
+  const seen = new Set;
+  for (const policy of policies) {
+    if (policy.id.trim() === "") {
+      throw new Error("[stitchkit] decision pipeline: a policy needs a non-empty id.");
+    }
+    if (seen.has(policy.id)) {
+      throw new Error(`[stitchkit] decision pipeline: two policies share the id "${policy.id}". The trace names policies by id, and a duplicate makes it ambiguous exactly when it is read to explain a refusal.`);
+    }
+    seen.add(policy.id);
+  }
+  return {
+    policyIds: policies.map((policy) => policy.id),
+    async decide(input) {
+      const trace = [];
+      for (const policy of policies) {
+        let answer;
+        try {
+          const outcome = await withDeadline(policy.decide(input), policyTimeoutMs);
+          if (!outcome.settled) {
+            throw new DecisionPolicyError(policy.id, `did not answer within ${policyTimeoutMs}ms`, trace);
+          }
+          answer = outcome.value;
+        } catch (error) {
+          if (error instanceof DecisionPolicyError)
+            throw error;
+          throw new DecisionPolicyError(policy.id, error instanceof Error ? `threw: ${error.message}` : "threw", trace);
+        }
+        const parsed = PolicyDecisionSchema.safeParse(answer);
+        if (!parsed.success) {
+          throw new DecisionPolicyError(policy.id, parsed.error.issues[0]?.message ?? "invalid", trace);
+        }
+        const decision = parsed.data;
+        trace.push(decision.outcome === "deny" ? { id: policy.id, outcome: "deny", reason: decision.reason } : { id: policy.id, outcome: decision.outcome });
+        if (decision.outcome === "deny") {
+          return { outcome: "deny", reason: decision.reason, trace };
+        }
+        if (decision.outcome === "allow") {
+          return { outcome: "allow", trace };
+        }
+      }
+      throw new DecisionUndecidedError(trace);
+    }
+  };
+}
+// src/application/events.ts
+import { z as z3 } from "zod";
+var ApplicationLifecycleEventSchema = z3.object({
+  type: z3.literal("application-state"),
+  applicationId: ApplicationIdSchema,
+  epoch: z3.string().uuid(),
+  revision: z3.number().int().nonnegative(),
+  lifecycle: ApplicationLifecycleSchema,
+  health: ApplicationHealthSchema,
+  ready: z3.boolean(),
+  capturedAt: z3.string().datetime({ offset: true }),
+  resources: z3.array(ManagedResourceSnapshotSchema).readonly()
+}).strict().readonly();
+function applicationLifecycleEvent(snapshot) {
+  return ApplicationLifecycleEventSchema.parse({
+    type: "application-state",
+    applicationId: snapshot.id,
+    epoch: snapshot.epoch,
+    revision: snapshot.revision,
+    lifecycle: snapshot.lifecycle,
+    health: snapshot.health,
+    ready: snapshot.ready,
+    capturedAt: snapshot.capturedAt,
+    resources: snapshot.resources
+  });
+}
+function createApplicationEventSink(config) {
+  const manager = createBoundedSinkManager({
+    write: config.write,
+    ...config.maxPending !== undefined && { maxPending: config.maxPending },
+    ...config.onSinkError && { onSinkError: config.onSinkError }
+  });
+  return {
+    publish(snapshot) {
+      manager.submit(() => applicationLifecycleEvent(snapshot));
+    },
+    flush: (bound) => manager.flush(bound),
+    getStatus: () => manager.getStatus(),
+    close: (bound) => manager.close(bound)
+  };
+}
+// 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)
+});
+var ApplicationOperationalHandlersOptionsSchema = z4.object({
+  retryAfterSeconds: z4.number().int().nonnegative().default(5)
+});
+function createApplicationHealthHandler(application, options) {
+  const parsed = ApplicationHealthHandlerOptionsSchema.parse(options);
+  return () => {
+    const snapshot = application.getSnapshot();
+    const healthy = parsed.kind === "readiness" ? snapshot.ready : snapshot.lifecycle !== "failed" && snapshot.lifecycle !== "stopped";
+    return Response.json(projectApplicationStatus(snapshot), {
+      status: healthy ? 200 : 503,
+      ...healthy ? {} : { headers: { "Retry-After": String(parsed.retryAfterSeconds) } }
+    });
+  };
+}
+function createApplicationOperationalHandlers(application, options = {}) {
+  const parsed = ApplicationOperationalHandlersOptionsSchema.parse(options);
+  return {
+    status: () => Response.json(projectApplicationStatus(application.getSnapshot())),
+    readiness: createApplicationHealthHandler(application, {
+      kind: "readiness",
+      retryAfterSeconds: parsed.retryAfterSeconds
+    }),
+    liveness: createApplicationHealthHandler(application, {
+      kind: "liveness",
+      retryAfterSeconds: parsed.retryAfterSeconds
+    })
+  };
+}
+// src/application/keyspace.ts
+function defineKeyspace(name, declaration) {
+  if (name.trim() === "") {
+    throw new Error("[stitchkit] defineKeyspace: a keyspace needs a name.");
+  }
+  return { name, schema: declaration.schema, key: declaration.key };
+}
+async function openKeyspace(declaration, config) {
+  const machine = keyspaceMachine(declaration, config);
+  await machine.load();
+  return {
+    keyspace: machine.keyspace,
+    stopAdmission: machine.stopAdmission,
+    drain: machine.drain,
+    close: machine.close
+  };
+}
+function keyspaceResource(declaration, config) {
+  const machine = keyspaceMachine(declaration, config);
+  return {
+    id: config.id ?? `keyspace:${declaration.name}`,
+    ...config.dependsOn && { dependsOn: config.dependsOn },
+    async start(_context) {
+      await machine.open();
+      return { value: machine.keyspace };
+    },
+    stopAdmission: machine.stopAdmission,
+    drain: machine.drain,
+    close: machine.close,
+    force: machine.force
+  };
+}
+function keyspaceMachine(declaration, config) {
+  const maxPending = config.maxPendingWrites ?? 1024;
+  const records = new Map;
+  let admitting = true;
+  let backend;
+  const currentBackend = () => {
+    backend ??= typeof config.backend === "function" ? config.backend() : config.backend;
+    return backend;
+  };
+  let pending = 0;
+  let chain = Promise.resolve();
+  function run(work) {
+    if (!admitting) {
+      return Promise.reject(new Error(`[stitchkit] keyspace "${declaration.name}" is shutting down and is not accepting writes.`));
+    }
+    if (pending >= maxPending) {
+      return Promise.reject(new Error(`[stitchkit] keyspace "${declaration.name}": ${pending} writes are already waiting for the backend (limit ${maxPending}). The backend is not keeping up; queueing this one would trade a visible refusal for an invisible leak.`));
+    }
+    pending += 1;
+    const queued = chain.then(work, work);
+    chain = queued.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return queued.finally(() => {
+      pending -= 1;
+    });
+  }
+  const keyspace = {
+    get: (key) => records.get(key),
+    list: () => [...records.values()],
+    get size() {
+      return records.size;
+    },
+    put(value) {
+      const parsed = declaration.schema.parse(value);
+      const key = declaration.key(parsed);
+      return run(async () => {
+        await currentBackend().put(key, parsed);
+        records.set(key, parsed);
+        config.onChanged?.({
+          keyspace: declaration.name,
+          key,
+          value: parsed,
+          change: "put"
+        });
+      });
+    },
+    delete(key) {
+      return run(async () => {
+        await currentBackend().delete(key);
+        records.delete(key);
+        config.onChanged?.({ keyspace: declaration.name, key, change: "delete" });
+      });
+    },
+    pendingWrites: () => pending
+  };
+  function reportUnwritten() {
+    if (pending > 0)
+      config.onUnwritten?.(pending);
+  }
+  return {
+    keyspace,
+    async load() {
+      for (const stored of await currentBackend().load()) {
+        const value = declaration.schema.parse(stored);
+        records.set(declaration.key(value), value);
+      }
+    },
+    async open() {
+      backend = undefined;
+      records.clear();
+      chain = Promise.resolve();
+      pending = 0;
+      admitting = true;
+      await this.load();
+    },
+    stopAdmission() {
+      admitting = false;
+    },
+    async drain() {
+      await chain;
+    },
+    async close() {
+      reportUnwritten();
+      await backend?.close?.();
+    },
+    force() {
+      reportUnwritten();
+    }
+  };
+}
+function memoryKeyspaceBackend() {
+  const stored = new Map;
+  return {
+    load: async () => [...stored.values()],
+    put: async (key, value) => {
+      stored.set(key, value);
+    },
+    delete: async (key) => {
+      stored.delete(key);
+    }
+  };
+}
+// src/application/keyspace-sqlite.ts
+var IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function sqliteKeyspaceBackend(declaration, config) {
+  const table = config.table ?? `stitchkit_keyspace_${declaration.name}`;
+  if (!IDENTIFIER.test(table)) {
+    throw new Error(`[stitchkit] sqliteKeyspaceBackend: "${table}" is not a bare SQL identifier. A table name cannot be a bound parameter, so it is checked here rather than interpolated on trust. Pass \`table\` explicitly when the keyspace name is not identifier-shaped.`);
+  }
+  const database = config.database;
+  if (config.initialize !== false) {
+    database.exec(`CREATE TABLE IF NOT EXISTS ${table} (key TEXT PRIMARY KEY, payload TEXT NOT NULL)`);
+  }
+  return {
+    async load() {
+      const rows = database.prepare(`SELECT payload FROM ${table}`).all();
+      return rows.map((row) => {
+        const payload = Reflect.get(Object(row), "payload");
+        if (typeof payload !== "string") {
+          throw new Error(`[stitchkit] keyspace "${declaration.name}": a row in ${table} has no text payload.`);
+        }
+        return JSON.parse(payload);
+      });
+    },
+    async put(key, value) {
+      database.prepare(`INSERT INTO ${table} (key, payload) VALUES (?, ?)
+             ON CONFLICT(key) DO UPDATE SET payload = excluded.payload`).run(key, JSON.stringify(value));
+    },
+    async delete(key) {
+      database.prepare(`DELETE FROM ${table} WHERE key = ?`).run(key);
+    }
+  };
+}
+// 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: []
+});
+var sizeOf = (value) => measureSize(value).responseBytes;
+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);
+  return { pollIntervalMs, leaseMs, maxAttempts, maxQueue, maxStateBytes, retainReceipts };
+}
+function boundedOutboxState(parsed, maxQueue, retainReceipts, maxStateBytes) {
+  if (parsed.queue.length > maxQueue) {
+    throw new Error(`[stitchkit] notification outbox queue limit (${maxQueue}) exceeded`);
+  }
+  let receipts = parsed.receipts.slice(0, retainReceipts);
+  let next = { ...parsed, receipts };
+  while (sizeOf(next) > maxStateBytes && receipts.length > 0) {
+    receipts = receipts.slice(0, -1);
+    next = { ...parsed, receipts };
+  }
+  if (sizeOf(next) > maxStateBytes) {
+    throw new Error(`[stitchkit] notification outbox state limit (${maxStateBytes} bytes) exceeded`);
+  }
+  return next;
+}
+function dropReason(classification, attempts, maxAttempts) {
+  if (classification.recipientUnreachable === true)
+    return "recipient-unreachable";
+  if (!classification.retryable)
+    return "terminal";
+  return attempts >= maxAttempts ? "attempt-limit" : null;
+}
+var RetryDelaySchema = z5.number().nonnegative().max(24 * 60 * 60 * 1000);
+var NO_LEASE = { leaseOwner: null, leaseId: null, leaseUntil: null };
+function claimDue(queue, now, ownerId, leaseMs) {
+  const candidate = [...queue].sort((left, right) => Date.parse(left.createdAt) - Date.parse(right.createdAt)).find((item) => Date.parse(item.nextAttemptAt) <= now.getTime() && (item.leaseUntil === null || Date.parse(item.leaseUntil) <= now.getTime()));
+  if (!candidate)
+    return null;
+  return {
+    ...candidate,
+    attempts: candidate.attempts + 1,
+    leaseOwner: ownerId,
+    leaseId: crypto.randomUUID(),
+    leaseUntil: new Date(now.getTime() + leaseMs).toISOString()
+  };
+}
+async function reportOutboxError(config, error) {
+  try {
+    await config.onError?.(error);
+  } catch {}
+}
+function createNotificationOutbox(config) {
+  const schema = notificationOutboxStateSchema(config.payloadSchema);
+  const clock = config.clock ?? (() => new Date);
+  const ownerId = config.ownerId ?? crypto.randomUUID();
+  const { pollIntervalMs, leaseMs, maxAttempts, maxQueue, maxStateBytes, retainReceipts } = resolveOutboxLimits(config);
+  const backoffMs = config.backoffMs ?? ((attempt) => backoffDelay(DEFAULT_OUTBOX_BACKOFF, attempt));
+  let timer;
+  let running = false;
+  let interrupted = false;
+  let flushTail = Promise.resolve();
+  const bounded = (input) => 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 payload = config.payloadSchema.parse(input.payload);
+    const supersedes = new Set(input.supersedes ?? []);
+    return config.store.update((current) => {
+      const state = parse(current);
+      if (state.queue.some((item) => item.key === key) || state.receipts.some((receipt) => receipt.key === key)) {
+        return { state, result: false };
+      }
+      const now = clock().toISOString();
+      const fresh = { key, payload, createdAt: now, attempts: 0, nextAttemptAt: now };
+      const queue = [
+        ...state.queue.filter((item) => !supersedes.has(item.key)),
+        { ...fresh, ...NO_LEASE }
+      ];
+      const next = bounded({ ...state, queue });
+      return { state: next, result: true };
+    });
+  };
+  const claimNext = async () => {
+    const now = clock();
+    return config.store.update((current) => {
+      const state = parse(current);
+      const claimed = claimDue(state.queue, now, ownerId, leaseMs);
+      if (!claimed)
+        return { state, result: null };
+      return {
+        state: bounded({
+          ...state,
+          queue: state.queue.map((item) => item.key === claimed.key ? claimed : item)
+        }),
+        result: claimed
+      };
+    });
+  };
+  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)
+        return { state, result: undefined };
+      const receipts = [
+        { key: claimed.key, completedAt: clock().toISOString() },
+        ...state.receipts.filter((receipt) => receipt.key !== claimed.key)
+      ].slice(0, retainReceipts);
+      return {
+        state: bounded({
+          ...state,
+          queue: state.queue.filter((item) => item.key !== claimed.key),
+          receipts
+        }),
+        result: undefined
+      };
+    });
+  };
+  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 flushPass = async () => {
+    let delivered = 0;
+    while (!interrupted) {
+      const claimed = await claimNext();
+      if (!claimed)
+        return delivered;
+      try {
+        await config.send({
+          key: claimed.key,
+          payload: claimed.payload,
+          attempt: claimed.attempts
+        });
+        await acknowledge(claimed);
+        delivered += 1;
+      } catch (error) {
+        const dropped = await reject(claimed, error);
+        if (dropped)
+          await config.onDropped?.(dropped);
+      }
+    }
+    return delivered;
+  };
+  const flush = () => {
+    const result = flushTail.then(flushPass, flushPass);
+    flushTail = result.then(() => {
+      return;
+    }, () => {
+      return;
+    });
+    return result;
+  };
+  const runScheduled = async () => {
+    try {
+      await flush();
+    } catch (error) {
+      await reportOutboxError(config, error);
+    } finally {
+      schedule();
+    }
+  };
+  const schedule = () => {
+    if (!running)
+      return;
+    timer = setTimeout(() => {
+      runScheduled();
+    }, pollIntervalMs);
+  };
+  return {
+    enqueue,
+    flush,
+    start() {
+      if (running)
+        return;
+      running = true;
+      interrupted = false;
+      runScheduled();
+    },
+    async stop() {
+      running = false;
+      interrupted = true;
+      if (timer)
+        clearTimeout(timer);
+      timer = undefined;
+      try {
+        await flushTail;
+      } finally {
+        interrupted = false;
+      }
+    },
+    async state() {
+      return parse(await config.store.read());
+    }
+  };
+}
+function notificationOutboxResource(outbox, config = {}) {
+  return defineManagedResource({
+    id: config.id ?? "notification-outbox",
+    start() {
+      outbox.start();
+      return { value: outbox };
+    },
+    async close() {
+      await outbox.stop();
+    },
+    async force() {
+      await outbox.stop();
+    }
+  });
+}
+// src/application/process-lifecycle.ts
+import { z as z6 } from "zod";
+var LifecycleTerminationSchema = z6.enum([
+  "active",
+  "clean",
+  "forced",
+  "hot-reload",
+  "abnormal"
+]);
+var LifecycleRunSchema = z6.object({
+  runId: z6.string().min(1).max(128),
+  pid: z6.number().int().positive(),
+  version: z6.string().min(1).max(256),
+  startedAt: z6.string().datetime({ offset: true }),
+  readyAt: z6.string().datetime({ offset: true }).nullable(),
+  stoppedAt: z6.string().datetime({ offset: true }).nullable(),
+  termination: LifecycleTerminationSchema
+}).strict();
+var LifecycleStateSchema = z6.object({
+  schemaVersion: z6.literal(1),
+  runs: z6.array(LifecycleRunSchema)
+}).strict();
+var PreviousExitSchema = z6.enum([
+  "first-boot",
+  "hot-reload",
+  "clean",
+  "forced",
+  "handoff",
+  "abnormal"
+]);
+var emptyState = () => ({ schemaVersion: 1, runs: [] });
+var epoch = (value) => Date.parse(value);
+var elapsed = (later, earlier) => Math.max(0, epoch(later) - epoch(earlier));
+function normalize(state, retain) {
+  const parsed = LifecycleStateSchema.parse(state ?? emptyState());
+  const runs = [...parsed.runs];
+  for (let index = runs.length - 1;runs.length > retain && index >= 0; index -= 1) {
+    if (runs[index]?.termination !== "active")
+      runs.splice(index, 1);
+  }
+  return { schemaVersion: 1, runs: runs.slice(0, retain) };
+}
+var UNKNOWN_VERSION = "unknown";
+function isVersionChange(previous, next) {
+  return previous !== UNKNOWN_VERSION && next !== UNKNOWN_VERSION && previous !== next;
+}
+function transitionProcessStart(source, input) {
+  const retain = z6.number().int().min(1).max(1000).parse(input.retain ?? 20);
+  const state = normalize(source, 1000);
+  const run = LifecycleRunSchema.parse({
+    runId: input.runId,
+    pid: input.pid,
+    version: input.version,
+    startedAt: input.now,
+    readyAt: null,
+    stoppedAt: null,
+    termination: "active"
+  });
+  if (state.runs.some((candidate) => candidate.runId === run.runId)) {
+    throw new Error(`[stitchkit] lifecycle run id already exists: ${run.runId}`);
+  }
+  const previous = state.runs[0] ?? null;
+  let previousExit = "first-boot";
+  let downtimeMs = null;
+  if (previous?.stoppedAt) {
+    previousExit = previous.termination === "forced" || previous.termination === "abnormal" || previous.termination === "hot-reload" ? previous.termination : "clean";
+    downtimeMs = elapsed(run.startedAt, previous.stoppedAt);
+  } else if (previous) {
+    if (previous.pid === run.pid)
+      previousExit = "hot-reload";
+    else if (isVersionChange(previous.version, run.version))
+      previousExit = "handoff";
+    else
+      previousExit = input.sameVersionOverlap ?? "abnormal";
+  }
+  const runs = state.runs.map((candidate) => {
+    if (candidate.runId !== previous?.runId || candidate.termination !== "active")
+      return candidate;
+    if (previousExit === "hot-reload") {
+      return { ...candidate, stoppedAt: run.startedAt, termination: "hot-reload" };
+    }
+    if (previousExit === "abnormal") {
+      return { ...candidate, stoppedAt: run.startedAt, termination: "abnormal" };
+    }
+    return candidate;
+  });
+  const next = normalize({ schemaVersion: 1, runs: [run, ...runs] }, retain);
+  return {
+    state: next,
+    fact: {
+      type: "started",
+      runId: run.runId,
+      pid: run.pid,
+      version: run.version,
+      startedAt: run.startedAt,
+      previousExit,
+      previousRunId: previous?.runId ?? null,
+      previousPid: previous?.pid ?? null,
+      previousVersion: previous?.version ?? null,
+      versionChanged: previous !== null && isVersionChange(previous.version, run.version),
+      downtimeMs
+    }
+  };
+}
+function transitionProcessReady(source, input) {
+  const retain = input.retain ?? 20;
+  const state = normalize(source, retain);
+  const target = state.runs.find((run) => run.runId === input.runId && run.pid === input.pid && run.termination === "active");
+  if (!target) {
+    return {
+      state,
+      fact: {
+        type: "ready",
+        runId: input.runId,
+        pid: input.pid,
+        readyAt: input.now,
+        startupMs: 0,
+        recorded: false
+      }
+    };
+  }
+  const readyAt = target.readyAt ?? input.now;
+  return {
+    state: {
+      schemaVersion: 1,
+      runs: state.runs.map((run) => run.runId === target.runId && run.readyAt === null ? { ...run, readyAt } : run)
+    },
+    fact: {
+      type: "ready",
+      runId: target.runId,
+      pid: target.pid,
+      readyAt,
+      startupMs: elapsed(readyAt, target.startedAt),
+      recorded: target.readyAt === null
+    }
+  };
+}
+function transitionProcessShutdown(source, input) {
+  const state = normalize(source, input.retain ?? 20);
+  const target = state.runs.find((run) => run.runId === input.runId && run.pid === input.pid && run.termination === "active");
+  const termination = input.forced ? "forced" : "clean";
+  if (!target) {
+    return {
+      state,
+      fact: {
+        type: "stopped",
+        runId: input.runId,
+        pid: input.pid,
+        stoppedAt: input.now,
+        uptimeMs: null,
+        termination,
+        recorded: false
+      }
+    };
+  }
+  return {
+    state: {
+      schemaVersion: 1,
+      runs: state.runs.map((run) => run.runId === target.runId ? { ...run, stoppedAt: input.now, termination } : run)
+    },
+    fact: {
+      type: "stopped",
+      runId: target.runId,
+      pid: target.pid,
+      stoppedAt: input.now,
+      uptimeMs: elapsed(input.now, target.startedAt),
+      termination,
+      recorded: true
+    }
+  };
+}
+function createProcessLifecycleLedger(config) {
+  const clock = config.clock ?? (() => new Date);
+  const pid = z6.number().int().positive().parse(config.pid ?? process.pid);
+  const retain = z6.number().int().min(1).max(1000).parse(config.retain ?? 20);
+  const configuredRunId = config.runId;
+  const nextRunId = typeof configuredRunId === "function" ? configuredRunId : configuredRunId === undefined ? () => crypto.randomUUID() : () => configuredRunId;
+  let runId = nextRunId();
+  let started = false;
+  const listeners = new Set;
+  const publish = (fact) => {
+    for (const listener of listeners) {
+      Promise.resolve().then(() => listener(fact)).catch((error) => config.onSubscriberError?.(error, fact));
+    }
+  };
+  return {
+    async recordStart({ version }) {
+      if (started)
+        runId = nextRunId();
+      const fact = await config.store.update((state) => {
+        const transition = transitionProcessStart(state, {
+          runId,
+          pid,
+          version,
+          now: clock().toISOString(),
+          retain,
+          sameVersionOverlap: config.sameVersionOverlap
+        });
+        return { state: transition.state, result: transition.fact };
+      });
+      started = true;
+      publish(fact);
+      return fact;
+    },
+    async recordReady() {
+      const fact = await config.store.update((state) => {
+        const transition = transitionProcessReady(state, {
+          runId,
+          pid,
+          now: clock().toISOString(),
+          retain
+        });
+        return { state: transition.state, result: transition.fact };
+      });
+      if (fact.recorded)
+        publish(fact);
+      return fact;
+    },
+    async recordShutdown(input) {
+      const fact = await config.store.update((state) => {
+        const transition = transitionProcessShutdown(state, {
+          runId,
+          pid,
+          now: clock().toISOString(),
+          forced: input?.forced,
+          retain
+        });
+        return { state: transition.state, result: transition.fact };
+      });
+      if (fact.recorded)
+        publish(fact);
+      return fact;
+    },
+    async current() {
+      const state = normalize(await config.store.read(), retain);
+      return state.runs.find((run) => run.runId === runId && run.pid === pid) ?? null;
+    },
+    async runs() {
+      return normalize(await config.store.read(), retain).runs;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    }
+  };
+}
+function lifecycleLedgerResource(ledger, config) {
+  let stopped = false;
+  let shutdown;
+  const stop = async (forced) => {
+    if (stopped)
+      return;
+    if (!shutdown)
+      shutdown = ledger.recordShutdown({ forced });
+    try {
+      await shutdown;
+      stopped = true;
+    } finally {
+      if (!stopped)
+        shutdown = undefined;
+    }
+  };
+  return defineManagedResource({
+    id: config.id ?? "lifecycle",
+    async start() {
+      stopped = false;
+      shutdown = undefined;
+      await ledger.recordStart({ version: config.version });
+      return { value: ledger };
+    },
+    async activate() {
+      await ledger.recordReady();
+    },
+    async close() {
+      await stop(false);
+    },
+    async force() {
+      await stop(true);
+    }
+  });
+}
+// src/application/revision-signal.ts
+import { z as z7 } from "zod";
+var NonNegativeSafeIntegerSchema = z7.number().int().nonnegative().safe();
+var PositiveSafeIntegerSchema2 = z7.number().int().positive().safe();
+var TimerDelaySchema = z7.number().int().positive().max(2147483647);
+var RevisionSignalStateSchema = z7.enum(["open", "closed"]);
+var RevisionSignalWaitOutcomeSchema = z7.enum([
+  "changed",
+  "timed-out",
+  "aborted",
+  "closed",
+  "capacity"
+]);
+var RevisionSignalWaitResultSchema = z7.object({
+  outcome: RevisionSignalWaitOutcomeSchema,
+  revision: NonNegativeSafeIntegerSchema
+}).strict().readonly();
+var RevisionSignalAdvanceResultSchema = z7.object({
+  outcome: z7.enum(["advanced", "closed"]),
+  revision: NonNegativeSafeIntegerSchema
+}).strict().readonly();
+var RevisionSignalSnapshotSchema = z7.object({
+  state: RevisionSignalStateSchema,
+  revision: NonNegativeSafeIntegerSchema,
+  pending: NonNegativeSafeIntegerSchema,
+  maxWaiters: PositiveSafeIntegerSchema2,
+  advances: NonNegativeSafeIntegerSchema,
+  refusedAdvances: NonNegativeSafeIntegerSchema,
+  waits: NonNegativeSafeIntegerSchema,
+  changed: NonNegativeSafeIntegerSchema,
+  timedOut: NonNegativeSafeIntegerSchema,
+  aborted: NonNegativeSafeIntegerSchema,
+  closedWaits: NonNegativeSafeIntegerSchema,
+  capacityRefusals: NonNegativeSafeIntegerSchema,
+  clockFailures: NonNegativeSafeIntegerSchema
+}).strict().readonly();
+var systemClock = {
+  schedule(callback, delayMs) {
+    const timer = setTimeout(callback, delayMs);
+    return { cancel: () => clearTimeout(timer) };
+  }
+};
+function createRevisionSignal(config) {
+  const maxWaiters = PositiveSafeIntegerSchema2.parse(config.maxWaiters);
+  const clock = config.clock ?? systemClock;
+  const waiters = new Set;
+  let state = "open";
+  let revision = 0;
+  let advances = 0;
+  let refusedAdvances = 0;
+  let waits = 0;
+  let changed = 0;
+  let timedOut = 0;
+  let aborted = 0;
+  let closedWaits = 0;
+  let capacityRefusals = 0;
+  let clockFailures = 0;
+  const result = (outcome) => {
+    if (outcome === "changed")
+      changed += 1;
+    else if (outcome === "timed-out")
+      timedOut += 1;
+    else if (outcome === "aborted")
+      aborted += 1;
+    else if (outcome === "closed")
+      closedWaits += 1;
+    else
+      capacityRefusals += 1;
+    return RevisionSignalWaitResultSchema.parse({ outcome, revision });
+  };
+  const snapshot = () => RevisionSignalSnapshotSchema.parse({
+    state,
+    revision,
+    pending: waiters.size,
+    maxWaiters,
+    advances,
+    refusedAdvances,
+    waits,
+    changed,
+    timedOut,
+    aborted,
+    closedWaits,
+    capacityRefusals,
+    clockFailures
+  });
+  return {
+    advance() {
+      if (state === "closed") {
+        refusedAdvances += 1;
+        return RevisionSignalAdvanceResultSchema.parse({ outcome: "closed", revision });
+      }
+      if (revision === Number.MAX_SAFE_INTEGER) {
+        throw new RangeError("Revision signal exhausted the safe-integer revision range");
+      }
+      revision += 1;
+      advances += 1;
+      for (const waiter of [...waiters])
+        waiter.settle("changed");
+      return RevisionSignalAdvanceResultSchema.parse({ outcome: "advanced", revision });
+    },
+    wait(after, options = {}) {
+      const parsedAfter = NonNegativeSafeIntegerSchema.parse(after);
+      const timeoutMs = options.timeoutMs === undefined ? undefined : TimerDelaySchema.parse(options.timeoutMs);
+      if (parsedAfter > revision) {
+        throw new RangeError(`Revision signal cannot wait after future revision ${parsedAfter}; current revision is ${revision}`);
+      }
+      waits += 1;
+      if (state === "closed")
+        return Promise.resolve(result("closed"));
+      if (parsedAfter < revision)
+        return Promise.resolve(result("changed"));
+      if (options.signal?.aborted)
+        return Promise.resolve(result("aborted"));
+      if (waiters.size >= maxWaiters)
+        return Promise.resolve(result("capacity"));
+      return new Promise((resolve) => {
+        let settled = false;
+        let timer;
+        const waiter = {
+          settle(outcome) {
+            if (settled)
+              return;
+            settled = true;
+            timer?.cancel();
+            options.signal?.removeEventListener("abort", onAbort);
+            waiters.delete(waiter);
+            resolve(result(outcome));
+          }
+        };
+        function onAbort() {
+          waiter.settle("aborted");
+        }
+        waiters.add(waiter);
+        options.signal?.addEventListener("abort", onAbort, { once: true });
+        if (timeoutMs !== undefined) {
+          try {
+            const scheduled = clock.schedule(() => waiter.settle("timed-out"), timeoutMs);
+            timer = scheduled;
+            if (settled)
+              scheduled.cancel();
+          } catch (error) {
+            settled = true;
+            options.signal?.removeEventListener("abort", onAbort);
+            waiters.delete(waiter);
+            clockFailures += 1;
+            throw error;
+          }
+        }
+      });
+    },
+    close() {
+      if (state === "closed")
+        return snapshot();
+      state = "closed";
+      for (const waiter of [...waiters])
+        waiter.settle("closed");
+      return snapshot();
+    },
+    getSnapshot: snapshot
+  };
+}
+// src/application/server-resource.ts
+function managedServerResource(config) {
+  let shutdownPromise;
+  let started;
+  let startAttempted = false;
+  const resolveServer = (context) => typeof config.server === "function" ? config.server(context) : config.server;
+  const isHandle = (value) => ("shutdown" in value);
+  const whole = (milliseconds, round) => Number.isFinite(milliseconds) ? Math.max(0, round(milliseconds)) : milliseconds;
+  const grace = (milliseconds) => whole(milliseconds, Math.floor);
+  const force = (milliseconds) => whole(milliseconds, Math.ceil);
+  const ensureShutdown = (context, phase = "graceful") => {
+    if (shutdownPromise)
+      return shutdownPromise;
+    const now = context.now();
+    const gracePeriodMs = phase === "force" ? 0 : context.deadlineAt === undefined ? undefined : grace(context.deadlineAt - now);
+    const forceTimeoutMs = context.forceDeadlineAt === undefined ? undefined : phase === "force" ? force(context.forceDeadlineAt - now) : force(context.forceDeadlineAt - (context.deadlineAt ?? now));
+    const server = started ?? (startAttempted ? undefined : resolveServer(context));
+    if (server === undefined) {
+      shutdownPromise = Promise.resolve(undefined);
+      return shutdownPromise;
+    }
+    const options = {
+      ...gracePeriodMs !== undefined && { gracePeriodMs },
+      ...forceTimeoutMs !== undefined && { forceTimeoutMs },
+      retryAfterSeconds: grace(config.retryAfterSeconds ?? 5),
+      ...config.realtimeCloseTimeoutMs !== undefined && {
+        realtimeCloseTimeoutMs: grace(config.realtimeCloseTimeoutMs)
+      },
+      signal: context.signal
+    };
+    shutdownPromise = isHandle(server) ? server.shutdown(options) : server.then((handle) => handle.shutdown(options));
+    shutdownPromise.catch(() => {
+      return;
+    });
+    return shutdownPromise;
+  };
+  return defineManagedResource({
+    id: config.id,
+    ...config.dependsOn && { dependsOn: config.dependsOn },
+    ...config.required !== undefined && { required: config.required },
+    async start(context) {
+      if (startAttempted && typeof config.server !== "function") {
+        throw new Error(`[stitchkit] managed server "${config.id}" cannot be restarted: it was given a server instance, and that one has been shut down. Pass a factory — \`server: (context) => …\` — so each generation gets its own.`);
+      }
+      shutdownPromise = undefined;
+      started = undefined;
+      startAttempted = true;
+      started = await resolveServer(context);
+      return { value: started };
+    },
+    stopAdmission(context) {
+      ensureShutdown(context);
+    },
+    async drain() {
+      await shutdownPromise;
+    },
+    async close(context) {
+      await ensureShutdown(context);
+    },
+    async force(context) {
+      await ensureShutdown(context, "force");
+    }
+  });
+}
+// src/application/watch-hub-core.ts
+var DEFAULT_BACKOFF = { minDelayMs: 250, maxDelayMs: 30000, jitter: 0.2 };
+
+class WatchHubCore {
+  config;
+  sources = new Map;
+  held = new Map;
+  maxWatches;
+  holdMs;
+  deltaMemoryBytes;
+  same;
+  reads = 0;
+  closed = false;
+  constructor(config) {
+    this.config = config;
+    this.maxWatches = config.maxWatchesPerSubscriber ?? 64;
+    this.holdMs = config.holdMs ?? 0;
+    this.deltaMemoryBytes = config.deltaMemoryBytes ?? 262144;
+    this.same = config.same ?? ((previous, next) => serializeCanonicalJson(previous) === serializeCanonicalJson(next));
+  }
+  tell(key, send) {
+    try {
+      send();
+      return true;
+    } catch (error) {
+      this.config.logger?.warn?.("[stitchkit] watch subscriber threw", {
+        key: watchKeyString(key),
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return false;
+    }
+  }
+  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;
+    }
+  }
+  deliver(source, subscriber) {
+    const frame = this.frameFor(source, subscriber);
+    const delivered = this.tell(source.key, () => subscriber.value(frame));
+    if (delivered)
+      source.baselines.set(subscriber, source.revision);
+    return delivered;
+  }
+  publish(source, value, fingerprint) {
+    if (source.fingerprint !== undefined) {
+      this.remember(source, source.revision, source.value, source.fingerprint);
+    }
+    source.revision += 1;
+    source.value = value;
+    source.fingerprint = fingerprint;
+    for (const subscriber of source.subscribers)
+      this.deliver(source, subscriber);
+  }
+  async pump(source) {
+    if (source.reading || this.closed)
+      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;
+    }
+  }
+  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?.();
+  }
+  acquire(operation, key, args) {
+    const id = watchKeyString(key);
+    const existing = this.sources.get(id);
+    if (existing) {
+      clearTimeout(existing.release);
+      existing.release = undefined;
+      return existing;
+    }
+    const source = {
+      key,
+      operation,
+      args,
+      subscribers: new Set,
+      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)
+    };
+    for (const topic of this.config.invalidatedBy(operation, args)) {
+      source.unsubscribes.push(this.config.subscribe(topic, () => {
+        source.dirty = true;
+        this.pump(source);
+      }));
+    }
+    this.sources.set(id, source);
+    return source;
+  }
+  release(source) {
+    if (source.subscribers.size > 0)
+      return;
+    clearTimeout(source.retry);
+    source.retry = undefined;
+    const drop = () => {
+      if (source.reading) {
+        source.release = setTimeout(drop, 10);
+        source.release.unref?.();
+        return;
+      }
+      for (const unsubscribe of source.unsubscribes)
+        unsubscribe();
+      this.sources.delete(watchKeyString(source.key));
+    };
+    if (this.holdMs === 0) {
+      drop();
+      return;
+    }
+    source.release = setTimeout(drop, this.holdMs);
+    source.release.unref?.();
+  }
+  attach(subscriber) {
+    const keys = new Set;
+    this.held.set(subscriber, keys);
+    return {
+      open: (key, args, have) => {
+        if (this.closed)
+          return { accepted: false, reason: "the watch hub is closed" };
+        const operation = { service: key.service, action: key.action };
+        if (!this.config.watchable(operation)) {
+          return {
+            accepted: false,
+            reason: `${key.service}.${key.action} is not watchable`
+          };
+        }
+        const id = watchKeyString(key);
+        if (keys.has(id))
+          return { accepted: true };
+        if (keys.size >= this.maxWatches) {
+          return {
+            accepted: false,
+            reason: `this connection is already watching ${keys.size} reads (limit ${this.maxWatches})`
+          };
+        }
+        const source = this.acquire(operation, key, args);
+        source.subscribers.add(subscriber);
+        keys.add(id);
+        if (have)
+          this.adoptBaseline(source, subscriber, have);
+        try {
+          if (source.signature !== undefined) {
+            const frame = this.frameFor(source, subscriber);
+            subscriber.value(frame);
+            source.baselines.set(subscriber, source.revision);
+          }
+          subscriber.state(source.state);
+        } catch (error) {
+          source.subscribers.delete(subscriber);
+          source.baselines.delete(subscriber);
+          keys.delete(id);
+          this.release(source);
+          return {
+            accepted: false,
+            reason: error instanceof Error ? error.message : String(error)
+          };
+        }
+        this.pump(source);
+        return { accepted: true };
+      },
+      close: (key) => {
+        const id = watchKeyString(key);
+        if (!keys.delete(id))
+          return;
+        const source = this.sources.get(id);
+        if (!source)
+          return;
+        source.subscribers.delete(subscriber);
+        source.baselines.delete(subscriber);
+        this.release(source);
+      },
+      detach: () => {
+        for (const id of keys) {
+          const source = this.sources.get(id);
+          if (!source)
+            continue;
+          source.subscribers.delete(subscriber);
+          source.baselines.delete(subscriber);
+          this.release(source);
+        }
+        keys.clear();
+        this.held.delete(subscriber);
+      }
+    };
+  }
+  close() {
+    this.closed = true;
+    const teardown = [...this.sources.values()];
+    this.sources.clear();
+    this.held.clear();
+    for (const source of teardown) {
+      clearTimeout(source.retry);
+      clearTimeout(source.release);
+      this.announceState(source, {
+        key: source.key,
+        phase: "unavailable",
+        reason: "source-unavailable"
+      });
+      for (const unsubscribe of source.unsubscribes)
+        unsubscribe();
+    }
+  }
+}
+function valueFingerprint(value) {
+  return argumentsDigest({ value });
+}
+function readErrorCode(error) {
+  if (typeof error !== "object" || error === null)
+    return;
+  const code = Reflect.get(error, "code");
+  return typeof code === "string" ? code : undefined;
+}
+
+// src/application/watch-hub.ts
+function watchKey(operation, args) {
+  const record = typeof args === "object" && args !== null && !Array.isArray(args) ? args : { value: args };
+  return {
+    service: operation.service,
+    action: operation.action,
+    digest: argumentsDigest(record)
+  };
+}
+function createWatchHub(config) {
+  const hub = new WatchHubCore(config);
+  return {
+    attach: (subscriber) => hub.attach(subscriber),
+    readCount: () => hub.reads,
+    size: () => hub.sources.size,
+    close: () => hub.close()
+  };
+}
+export {
+  watchKey,
+  transitionProcessStart,
+  transitionProcessShutdown,
+  transitionProcessReady,
+  sqliteKeyspaceBackend,
+  readDiagnosticJournalLockDiagnosis,
+  projectApplicationStatus,
+  openKeyspace,
+  notificationOutboxStateSchema,
+  notificationOutboxResource,
+  memoryKeyspaceBackend,
+  managedServerResource,
+  managedResourceDependencyId,
+  lifecycleLedgerResource,
+  keyspaceResource,
+  defineManagedResource,
+  defineKeyspace,
+  createWatchHub,
+  createRevisionSignal,
+  createProcessLifecycleLedger,
+  createNotificationOutbox,
+  createManagedSchedule,
+  createDecisionPipeline,
+  createCreditWindow,
+  createBoundedChannel,
+  createBoundedAdmission,
+  createApplicationSnapshotSink,
+  createApplicationOperationalHandlers,
+  createApplicationHealthHandler,
+  createApplicationEventSink,
+  createApplication,
+  createActivityProjection,
+  applicationLifecycleEvent,
+  RevisionSignalWaitResultSchema,
+  RevisionSignalWaitOutcomeSchema,
+  RevisionSignalStateSchema,
+  RevisionSignalSnapshotSchema,
+  RevisionSignalAdvanceResultSchema,
+  PreviousExitSchema,
+  PolicyDecisionSchema,
+  ManagedScheduleStatusSchema,
+  ManagedScheduleOverlapSchema,
+  ManagedScheduleErrorPolicySchema,
+  ManagedScheduleDescriptorSchema,
+  ManagedResourceStateSchema,
+  ManagedResourceSnapshotSchema,
+  LifecycleTerminationSchema,
+  LifecycleStateSchema,
+  LifecycleRunSchema,
+  DiagnosticJournalWaitResultSchema,
+  DiagnosticJournalSubmitResultSchema,
+  DiagnosticJournalStatusSchema,
+  DiagnosticJournalStateSchema,
+  DiagnosticJournalRefusalReasonSchema,
+  DiagnosticJournalLockPolicySchema,
+  DiagnosticJournalLimitsSchema,
+  DiagnosticJournalFrameSchema,
+  DiagnosticJournalFailurePhaseSchema,
+  DiagnosticJournalCloseResultSchema,
+  DecisionUndecidedError,
+  DecisionPolicyError,
+  CreditWindowSnapshotSchema,
+  BoundedRateBudgetSchema,
+  BoundedOperationWaitError,
+  BoundedChannelStateSchema,
+  BoundedChannelSnapshotSchema,
+  BoundedChannelReaderError,
+  BoundedChannelPolicySchema,
+  BoundedAdmissionStateSchema,
+  BoundedAdmissionSnapshotSchema,
+  BoundedAdmissionRefusalReasonSchema,
+  BoundedAdmissionRefusalError,
+  BoundedAdmissionPolicySchema,
+  BoundedAdmissionPerKeyLimitsSchema,
+  ApplicationStatusProjectionSchema,
+  ApplicationSnapshotSinkStatusSchema,
+  ApplicationSnapshotSchema,
+  ApplicationShutdownResultSchema,
+  ApplicationShutdownOptionsSchema,
+  ApplicationShutdownBudgetSchema,
+  ApplicationRestartResultSchema,
+  ApplicationRestartOutcomeSchema,
+  ApplicationRestartInputSchema,
+  ApplicationResourceShutdownSchema,
+  ApplicationOperationalHandlersOptionsSchema,
+  ApplicationLifecycleSchema,
+  ApplicationLifecycleEventSchema,
+  ApplicationIdSchema,
+  ApplicationHealthSchema,
+  ApplicationHealthHandlerOptionsSchema,
+  ApplicationAdmissionSnapshotSchema,
+  ApplicationAdmissionError,
+  ActivityTokenBrand,
+  ActivityStageSnapshotSchema,
+  ActivityStageIdSchema,
+  ActivitySnapshotSchema,
+  ActivityLiveStateSchema,
+  ActivityIdSchema
+};