stitchkit 0.93.0 → 0.94.1

package/dist/application.js

@@ -1,1977 +0,0 @@
-import {
-  ActivityIdSchema,
-  ActivityLiveStateSchema,
-  ActivitySnapshotSchema,
-  ActivityStageIdSchema,
-  ActivityStageSnapshotSchema,
-  ActivityTokenBrand,
-  ApplicationSnapshotSinkStatusSchema,
-  ManagedScheduleDescriptorSchema,
-  ManagedScheduleErrorPolicySchema,
-  ManagedScheduleOverlapSchema,
-  ManagedScheduleStatusSchema,
-  createActivityProjection,
-  createApplicationSnapshotSink,
-  createManagedSchedule
-} from "./index-9f8ztey6.js";
-import {
-  DiagnosticJournalCloseResultSchema,
-  DiagnosticJournalFailurePhaseSchema,
-  DiagnosticJournalFrameSchema,
-  DiagnosticJournalLimitsSchema,
-  DiagnosticJournalLockPolicySchema,
-  DiagnosticJournalRefusalReasonSchema,
-  DiagnosticJournalStateSchema,
-  DiagnosticJournalStatusSchema,
-  DiagnosticJournalSubmitResultSchema,
-  DiagnosticJournalWaitResultSchema,
-  readDiagnosticJournalLockDiagnosis
-} from "./index-wc4x00bn.js";
-import"./index-pq95qkbf.js";
-import {
-  ApplicationAdmissionError,
-  ApplicationRestartInputSchema,
-  ApplicationRestartOutcomeSchema,
-  ApplicationRestartResultSchema,
-  ApplicationShutdownBudgetSchema,
-  ApplicationShutdownOptionsSchema,
-  createApplication
-} from "./index-a11g2kry.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-wnfk50r0.js";
-import {
-  backoffDelay,
-  createBackoff
-} from "./index-s8cnx02s.js";
-import {
-  deltaWins,
-  diff,
-  watchKeyString
-} from "./index-2na0qrfn.js";
-import"./index-ywd0y6m1.js";
-import {
-  BoundedChannelPolicySchema,
-  BoundedChannelReaderError,
-  BoundedChannelSnapshotSchema,
-  BoundedChannelStateSchema,
-  CreditWindowSnapshotSchema,
-  createBoundedChannel,
-  createCreditWindow
-} from "./index-7gnkny4z.js";
-import {
-  measureSize
-} from "./index-6kyksz9y.js";
-import {
-  argumentsDigest,
-  stableValue
-} from "./index-a916km3r.js";
-import"./index-2vtcmrj9.js";
-import"./index-kzfs85xp.js";
-import"./index-77fekveh.js";
-// src/application/admission.ts
-import { z } from "zod";
-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";
-  }
-}
-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 = {
-    "not-accepting": 0,
-    "global-concurrency": 0,
-    "key-required": 0,
-    "key-capacity": 0,
-    "key-concurrency": 0,
-    "global-rate": 0,
-    "key-rate": 0,
-    upstream: 0
-  };
-  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 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);
-  };
-  const prune = (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);
-    }
-  };
-  const retryAfter = (samples, budget, at) => Math.max(1, Math.ceil(budget.intervalMs - (at - (samples[0]?.at ?? 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;
-    if (globalSample) {
-      const index = globalRate.indexOf(globalSample);
-      if (index >= 0)
-        globalRate.splice(index, 1);
-    }
-    if (keySample && keyRecord) {
-      const index = keyRecord.rate.indexOf(keySample);
-      if (index >= 0)
-        keyRecord.rate.splice(index, 1);
-    }
-    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 };
-    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);
-    }
-    return { drained: active === 0, remaining: active };
-  };
-  const run = async (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);
-    }
-  };
-  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 createNotificationOutbox(config) {
-  const schema = notificationOutboxStateSchema(config.payloadSchema);
-  const clock = config.clock ?? (() => new Date);
-  const ownerId = config.ownerId ?? crypto.randomUUID();
-  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 backoffMs = config.backoffMs ?? ((attempt) => backoffDelay(DEFAULT_OUTBOX_BACKOFF, attempt));
-  let timer;
-  let running = false;
-  let interrupted = false;
-  let flushTail = Promise.resolve();
-  const bounded = (input) => {
-    const parsed = schema.parse(input);
-    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;
-  };
-  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 queue = [
-        ...state.queue.filter((item) => !supersedes.has(item.key)),
-        {
-          key,
-          payload,
-          createdAt: now,
-          attempts: 0,
-          nextAttemptAt: now,
-          leaseOwner: null,
-          leaseId: null,
-          leaseUntil: null
-        }
-      ];
-      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 candidate = [...state.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 { state, result: null };
-      const leaseId = crypto.randomUUID();
-      const claimed = {
-        ...candidate,
-        attempts: candidate.attempts + 1,
-        leaseOwner: ownerId,
-        leaseId,
-        leaseUntil: new Date(now.getTime() + leaseMs).toISOString()
-      };
-      return {
-        state: bounded({
-          ...state,
-          queue: state.queue.map((item) => item.key === candidate.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 = classification.recipientUnreachable === true ? "recipient-unreachable" : !classification.retryable ? "terminal" : attempts >= maxAttempts ? "attempt-limit" : null;
-      if (reason) {
-        return {
-          state: bounded({
-            ...state,
-            queue: state.queue.filter((item) => item.key !== live.key)
-          }),
-          result: { item: { ...live, attempts }, error, reason }
-        };
-      }
-      const rawDelay = backoffMs(attempts);
-      const wait = z5.number().finite().nonnegative().max(24 * 60 * 60 * 1000).parse(rawDelay);
-      const retry = {
-        ...live,
-        attempts,
-        nextAttemptAt: new Date(clock().getTime() + wait).toISOString(),
-        leaseOwner: null,
-        leaseId: null,
-        leaseUntil: null
-      };
-      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) {
-      try {
-        await config.onError?.(error);
-      } catch {}
-    } 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.ts
-var DEFAULT_BACKOFF = { minDelayMs: 250, maxDelayMs: 30000, jitter: 0.2 };
-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 sources = new Map;
-  const held = new Map;
-  const maxWatches = config.maxWatchesPerSubscriber ?? 64;
-  const holdMs = config.holdMs ?? 0;
-  const deltaMemoryBytes = config.deltaMemoryBytes ?? 262144;
-  const same = config.same ?? ((previous, next) => JSON.stringify(stableValue(previous)) === JSON.stringify(stableValue(next)));
-  let reads = 0;
-  let closed = false;
-  function tell(key, deliver2) {
-    try {
-      deliver2();
-      return true;
-    } catch (error) {
-      config.logger?.warn?.("[stitchkit] watch subscriber threw", {
-        key: watchKeyString(key),
-        error: error instanceof Error ? error.message : String(error)
-      });
-      return false;
-    }
-  }
-  function announceState(source, state) {
-    source.state = state;
-    for (const subscriber of source.subscribers) {
-      tell(source.key, () => subscriber.state(state));
-    }
-  }
-  function remember(source, 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 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 held2 = source.history.get(base);
-    if (!held2)
-      return full;
-    const delta = diff(held2.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 deliver(source, subscriber) {
-    const frame = frameFor(source, subscriber);
-    const delivered = tell(source.key, () => subscriber.value(frame));
-    if (delivered)
-      source.baselines.set(subscriber, source.revision);
-    return delivered;
-  }
-  function publish(source, value, fingerprint) {
-    if (source.fingerprint !== undefined) {
-      remember(source, source.revision, source.value, source.fingerprint);
-    }
-    source.revision += 1;
-    source.value = value;
-    source.fingerprint = fingerprint;
-    for (const subscriber of source.subscribers)
-      deliver(source, subscriber);
-  }
-  async function pump(source) {
-    if (source.reading || closed)
-      return;
-    source.reading = true;
-    try {
-      while (source.dirty && !closed) {
-        source.dirty = false;
-        reads += 1;
-        try {
-          const value = await config.read(source.operation, source.args);
-          source.backoff.reset();
-          const signature = JSON.stringify(stableValue(value));
-          const unchanged = source.signature !== undefined && same(source.value, value);
-          source.signature = signature;
-          if (!unchanged)
-            publish(source, value, valueFingerprint(value));
-          if (source.state.phase !== "live") {
-            announceState(source, { key: source.key, phase: "live" });
-          }
-        } catch (error) {
-          const code = readErrorCode(error);
-          announceState(source, {
-            key: source.key,
-            phase: "unavailable",
-            reason: "source-error",
-            ...code !== undefined && { code },
-            message: error instanceof Error ? error.message : String(error)
-          });
-          config.logger?.warn?.("[stitchkit] watched read failed", {
-            key: watchKeyString(source.key),
-            error
-          });
-          scheduleRetry(source);
-          return;
-        }
-      }
-    } finally {
-      source.reading = false;
-    }
-  }
-  function scheduleRetry(source) {
-    if (closed || source.subscribers.size === 0)
-      return;
-    clearTimeout(source.retry);
-    source.retry = setTimeout(() => {
-      source.dirty = true;
-      pump(source);
-    }, source.backoff.next());
-    source.retry.unref?.();
-  }
-  function acquire(operation, key, args) {
-    const id = watchKeyString(key);
-    const existing = 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(config.backoff ?? DEFAULT_BACKOFF)
-    };
-    for (const topic of config.invalidatedBy(operation, args)) {
-      source.unsubscribes.push(config.subscribe(topic, () => {
-        source.dirty = true;
-        pump(source);
-      }));
-    }
-    sources.set(id, source);
-    return source;
-  }
-  function 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();
-      sources.delete(watchKeyString(source.key));
-    };
-    if (holdMs === 0) {
-      drop();
-      return;
-    }
-    source.release = setTimeout(drop, holdMs);
-    source.release.unref?.();
-  }
-  return {
-    attach(subscriber) {
-      const keys = new Set;
-      held.set(subscriber, keys);
-      return {
-        open(key, args, have) {
-          if (closed)
-            return { accepted: false, reason: "the watch hub is closed" };
-          const operation = { service: key.service, action: key.action };
-          if (!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 >= maxWatches) {
-            return {
-              accepted: false,
-              reason: `this connection is already watching ${keys.size} reads (limit ${maxWatches})`
-            };
-          }
-          const source = acquire(operation, key, args);
-          source.subscribers.add(subscriber);
-          keys.add(id);
-          if (have)
-            adoptBaseline(source, subscriber, have);
-          try {
-            if (source.signature !== undefined) {
-              const frame = 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);
-            release(source);
-            return {
-              accepted: false,
-              reason: error instanceof Error ? error.message : String(error)
-            };
-          }
-          pump(source);
-          return { accepted: true };
-        },
-        close(key) {
-          const id = watchKeyString(key);
-          if (!keys.delete(id))
-            return;
-          const source = sources.get(id);
-          if (!source)
-            return;
-          source.subscribers.delete(subscriber);
-          source.baselines.delete(subscriber);
-          release(source);
-        },
-        detach() {
-          for (const id of keys) {
-            const source = sources.get(id);
-            if (!source)
-              continue;
-            source.subscribers.delete(subscriber);
-            source.baselines.delete(subscriber);
-            release(source);
-          }
-          keys.clear();
-          held.delete(subscriber);
-        }
-      };
-    },
-    readCount: () => reads,
-    size: () => sources.size,
-    close() {
-      closed = true;
-      const teardown = [...sources.values()];
-      sources.clear();
-      held.clear();
-      for (const source of teardown) {
-        clearTimeout(source.retry);
-        clearTimeout(source.release);
-        announceState(source, {
-          key: source.key,
-          phase: "unavailable",
-          reason: "source-unavailable"
-        });
-        for (const unsubscribe of source.unsubscribes)
-          unsubscribe();
-      }
-    }
-  };
-}
-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;
-}
-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
-};