stitchkit 0.80.0 → 0.81.0

package/dist/application.js

@@ -62,8 +62,9 @@ import {
   createBoundedSinkManager
 } from "./index-a59da114.js";
 import {
+  backoffDelay,
   createBackoff
-} from "./index-h4pj6fta.js";
+} from "./index-s8cnx02s.js";
 import {
   watchKeyString
 } from "./index-dre2ywck.js";
@@ -77,11 +78,15 @@ import {
   createBoundedChannel,
   createCreditWindow
 } from "./index-7gnkny4z.js";
+import {
+  measureSize
+} from "./index-xbppf54a.js";
 import {
   argumentsDigest,
   stableValue
 } from "./index-a916km3r.js";
 import"./index-0w9abg87.js";
+import"./index-kzfs85xp.js";
 import"./index-77fekveh.js";
 // src/application/admission.ts
 import { z } from "zod";
@@ -778,6 +783,707 @@ function sqliteKeyspaceBackend(declaration, config) {
     }
   };
 }
+// src/application/notification-outbox.ts
+import { z as z5 } from "zod";
+function notificationOutboxStateSchema(payload) {
+  return z5.object({
+    schemaVersion: z5.literal(1),
+    queue: z5.array(z5.object({
+      key: z5.string().min(1).max(512),
+      payload,
+      createdAt: z5.string().datetime({ offset: true }),
+      attempts: z5.number().int().nonnegative(),
+      nextAttemptAt: z5.string().datetime({ offset: true }),
+      leaseOwner: z5.string().min(1).max(128).nullable(),
+      leaseId: z5.string().min(1).max(128).nullable(),
+      leaseUntil: z5.string().datetime({ offset: true }).nullable()
+    }).strict()),
+    receipts: z5.array(z5.object({
+      key: z5.string().min(1).max(512),
+      completedAt: z5.string().datetime({ offset: true })
+    }).strict())
+  }).strict();
+}
+var emptyOutboxState = () => ({
+  schemaVersion: 1,
+  queue: [],
+  receipts: []
+});
+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;
@@ -1081,17 +1787,26 @@ function readErrorCode(error) {
 }
 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,
@@ -1104,6 +1819,12 @@ export {
   createApplication,
   createActivityProjection,
   applicationLifecycleEvent,
+  RevisionSignalWaitResultSchema,
+  RevisionSignalWaitOutcomeSchema,
+  RevisionSignalStateSchema,
+  RevisionSignalSnapshotSchema,
+  RevisionSignalAdvanceResultSchema,
+  PreviousExitSchema,
   PolicyDecisionSchema,
   ManagedScheduleStatusSchema,
   ManagedScheduleOverlapSchema,
@@ -1111,6 +1832,9 @@ export {
   ManagedScheduleDescriptorSchema,
   ManagedResourceStateSchema,
   ManagedResourceSnapshotSchema,
+  LifecycleTerminationSchema,
+  LifecycleStateSchema,
+  LifecycleRunSchema,
   DiagnosticJournalWaitResultSchema,
   DiagnosticJournalSubmitResultSchema,
   DiagnosticJournalStatusSchema,