stitchkit 0.103.13 → 0.104.1

package/dist/entrypoints/application/directory-inbox.js

@@ -1,159 +1,448 @@
 import {
-  backoffDelay
-} from "../../index-g6a3na27.js";
-import {
+  DirectoryInboxIdentitySchema2,
   DirectoryInboxStateSchema2,
   emptyDirectoryInboxState,
   withRejection,
   claimEntry,
   completeEntry,
   releaseEntry,
+  ownsClaim,
+  renewEntry,
   forgetMissing
-} from "../../index-j8aw2c0e.js";
+} from "../../index-bakgedh8.js";
+import {
+  backoffDelay
+} from "../../index-g6a3na27.js";
+import"../../index-za6j7nwy.js";
+import"../../index-5csmzesf.js";
+import"../../index-v5ee8ath.js";
 import {
   defineManagedResource2
 } from "../../index-50ejfz75.js";
 import {
   createFileStateStore2
-} from "../../index-wykebpn9.js";
+} from "../../index-269zqj8m.js";
+import"../../index-g95fk660.js";
+import {
+  writeAtomicFileData
+} from "../../index-s4evrmp5.js";
+import {
+  BoundedFileReadError,
+  readBoundedFile
+} from "../../index-jd470k6q.js";
+import {
+  publishAtomicFile
+} from "../../index-8a9ksm91.js";
+import {
+  raceAbort
+} from "../../index-mbnnw3f2.js";
+import {
+  isJsonData
+} from "../../index-fm1c1a08.js";
 
 // src/application/directory-inbox.ts
-import { mkdir, readdir, readFile, rename, stat, unlink } from "node:fs/promises";
+import { mkdir as mkdir2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+import { z as z2 } from "zod";
+
+// src/application/directory-inbox-files.ts
+import { createHash } from "node:crypto";
+import { lstat, mkdir, open, opendir, unlink } from "node:fs/promises";
 import { join } from "node:path";
 import { z } from "zod";
-var REJECTED = "rejected";
 var ENTRY_NAME = /^[^.].*\.json$/;
-var RETRY_BACKOFF = { minDelayMs: 1000, maxDelayMs: 300000, jitter: 0 };
-var absent = (error) => error instanceof Error && ("code" in error) && error.code === "ENOENT";
-async function quietly(run) {
-  try {
-    await run();
-  } catch (error) {
-    if (!absent(error))
-      throw error;
-  }
+var ACCEPTED_NAME = /^intake-[0-9a-f]{64}\.json$/;
+var EnvelopeSchema = z.object({
+  schemaVersion: z.literal(1),
+  identity: DirectoryInboxIdentitySchema2,
+  entry: z.unknown()
+}).strict();
+var missingInboxFile = (error) => error instanceof Error && ("code" in error) && error.code === "ENOENT";
+function inboxFilename(identity) {
+  return "intake-" + createHash("sha256").update(JSON.stringify([identity.source, identity.key])).digest("hex") + ".json";
 }
-function resolveLimits(config) {
-  const integer = z.number().int();
+function sameInboxIdentity(a, b) {
+  return a?.source === b.source && a.key === b.key;
+}
+function encodeInboxEntry(identity, entry, schema, maxBytes) {
+  const envelope = { schemaVersion: 1, identity, entry: schema.parse(entry) };
+  const snapshot = {};
+  if (!isJsonData(envelope, { maxDepth: 100, maxNodes: maxBytes, maxBytes, omitObjectUndefined: false }, snapshot))
+    throw new TypeError("Inbox entry must be lossless JSON within maxEntryBytes");
+  const encoded = JSON.stringify(snapshot.value);
+  if (encoded === undefined || new TextEncoder().encode(encoded).byteLength > maxBytes)
+    throw new RangeError("Inbox entry exceeds maxEntryBytes");
+  return encoded;
+}
+async function createInboxFiles(directory, maxBytes) {
+  const read = (name) => readBoundedFile(join(directory, name), maxBytes, {
+    rejectSymlinks: true,
+    singleLink: true,
+    stable: true
+  });
+  const matches = async (key, observation) => {
+    if (!observation)
+      return true;
+    try {
+      const current = await lstat(join(directory, key));
+      return current.isFile() && current.nlink === 1 && current.dev === observation.dev && current.ino === observation.ino && current.size === observation.size && current.mtimeMs === observation.mtimeMs && current.ctimeMs === observation.ctimeMs;
+    } catch (error) {
+      if (missingInboxFile(error))
+        return false;
+      throw error;
+    }
+  };
   return {
-    pollIntervalMs: integer.min(10).parse(config.pollIntervalMs ?? 1000),
-    leaseMs: integer.min(100).parse(config.leaseMs ?? 300000),
-    maxAttempts: integer.min(1).max(1e4).parse(config.maxAttempts ?? 20),
-    maxEntryBytes: integer.min(1).parse(config.maxEntryBytes ?? 1024 * 1024),
-    retain: integer.min(1).max(1e5).parse(config.retain ?? 1000)
+    async names(limit) {
+      const names = [];
+      for await (const entry of await opendir(directory)) {
+        if (!entry.isFile() || !ENTRY_NAME.test(entry.name))
+          continue;
+        names.push(entry.name);
+        if (limit !== undefined && names.length >= limit)
+          break;
+      }
+      return names.sort();
+    },
+    async read(key, schema) {
+      try {
+        const source = await read(key);
+        if (!source.observation)
+          throw new Error("Inbox reader did not provide file observation");
+        let json;
+        try {
+          json = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(source.bytes));
+        } catch (error) {
+          return {
+            reason: "invalid",
+            detail: String(error).slice(0, 1000),
+            observation: source.observation
+          };
+        }
+        let identity;
+        if (ACCEPTED_NAME.test(key)) {
+          const envelope = EnvelopeSchema.safeParse(json);
+          if (!envelope.success || inboxFilename(envelope.data.identity) !== key)
+            return {
+              reason: "invalid",
+              detail: "Invalid programmatic inbox envelope",
+              observation: source.observation
+            };
+          identity = envelope.data.identity;
+          json = envelope.data.entry;
+        }
+        const parsed = schema.safeParse(json);
+        return parsed.success ? {
+          entry: parsed.data,
+          observation: source.observation,
+          ...identity && { identity }
+        } : {
+          reason: "invalid",
+          detail: z.prettifyError(parsed.error).slice(0, 1000),
+          observation: source.observation,
+          ...identity && { identity }
+        };
+      } catch (error) {
+        if (missingInboxFile(error))
+          return null;
+        if (error instanceof BoundedFileReadError && error.code === "FILE_TOO_LARGE" && error.observation)
+          return {
+            reason: "too-large",
+            detail: error.message.slice(0, 1000),
+            observation: error.observation
+          };
+        throw error;
+      }
+    },
+    async existingIdentity(key) {
+      for (const name of [key, `rejected/${key}`]) {
+        try {
+          const source = await read(name);
+          const envelope = EnvelopeSchema.parse(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(source.bytes)));
+          return envelope.identity;
+        } catch (error) {
+          if (!missingInboxFile(error))
+            throw error;
+        }
+      }
+      return;
+    },
+    async publish(key, bytes, context) {
+      await writeAtomicFileData(join(directory, key), bytes, { replace: false, durability: "directory" }, {
+        open,
+        unlink,
+        async publish(staged, target, replace, directorySync) {
+          await context.assertHeld();
+          await publishAtomicFile(staged, target, replace, directorySync);
+        }
+      });
+    },
+    async remove(key, context, observation) {
+      if (!await matches(key, observation))
+        return;
+      await context.assertHeld();
+      try {
+        await unlink(join(directory, key));
+      } catch (error) {
+        if (!missingInboxFile(error))
+          throw error;
+      }
+    },
+    async setAside(key, context, observation) {
+      if (!await matches(key, observation))
+        return;
+      await mkdir(join(directory, "rejected"), { recursive: true });
+      await context.assertHeld();
+      try {
+        await publishAtomicFile(join(directory, key), join(directory, "rejected", key), false, true);
+      } catch (error) {
+        if (!missingInboxFile(error))
+          throw error;
+      }
+    }
+  };
+}
+
+// src/application/directory-inbox-accept.ts
+function createInboxAccept(options) {
+  return async (input) => {
+    if (!options.accepting())
+      throw new Error("Directory inbox is not accepting entries");
+    const identity = DirectoryInboxIdentitySchema2.parse({
+      source: input.source,
+      key: input.key
+    });
+    const filename = inboxFilename(identity);
+    const bytes = encodeInboxEntry(identity, input.entry, options.schema, options.maxEntryBytes);
+    return options.access.update(async (state, context) => {
+      if (!options.accepting())
+        throw new Error("Directory inbox is not accepting entries");
+      await context.assertHeld();
+      const files = options.files();
+      const remembered = [...state.receipts, ...state.rejected, ...state.claims].find((item) => item.key === filename);
+      const existing = remembered?.identity ?? await files.existingIdentity(filename);
+      if (remembered || existing) {
+        if (!sameInboxIdentity(existing, identity))
+          throw new Error("Inbox filename belongs to a different producer identity");
+        return { state, result: { status: "duplicate", filename } };
+      }
+      if ((await files.names(options.maxPendingEntries)).length >= options.maxPendingEntries)
+        throw new RangeError("Directory inbox reached maxPendingEntries");
+      await context.assertHeld();
+      if (!options.accepting())
+        throw new Error("Directory inbox is not accepting entries");
+      await files.publish(filename, bytes, context);
+      return { state, result: { status: "accepted", filename } };
+    });
   };
 }
-async function entryNames(directory) {
-  const entries = await readdir(directory, { withFileTypes: true });
-  return entries.filter((entry) => entry.isFile() && ENTRY_NAME.test(entry.name)).map((entry) => entry.name).sort();
+
+// src/application/directory-inbox-state.ts
+function inboxStateAccess(store) {
+  const parse = (current) => DirectoryInboxStateSchema2.parse(current ?? emptyDirectoryInboxState());
+  return {
+    read: async () => parse(await store.read()),
+    update: (transition) => store.update((current, context) => transition(parse(current), context))
+  };
 }
-async function readEntry(path, schema, maxEntryBytes) {
-  try {
-    const { size } = await stat(path);
-    if (size > maxEntryBytes) {
-      return { reason: "too-large", detail: `${size} bytes over the ${maxEntryBytes} limit` };
+async function cleanupInboxEntry(access, files, key, settlement, observation) {
+  await access.update(async (state, context) => {
+    if (state.claims.some((claim) => claim.key === key))
+      return { state, result: undefined };
+    if ("completedAt" in settlement) {
+      if (state.receipts.some((receipt) => receipt.key === key && receipt.completedAt === settlement.completedAt))
+        await files.remove(key, context, observation);
+    } else if (state.rejected.some((rejection) => rejection.key === key && rejection.rejectedAt === settlement.rejectedAt && rejection.reason === settlement.reason)) {
+      await files.setAside(key, context, observation);
     }
-    const text = await readFile(path, "utf8");
-    let json;
+    return { state, result: undefined };
+  });
+}
+
+// src/application/directory-inbox-delivery.ts
+var RETRY_BACKOFF = { minDelayMs: 1000, maxDelayMs: 300000, jitter: 0 };
+function createInboxDelivery(options) {
+  const { access, clock, config } = options;
+  return async (taken) => {
+    const controller = new AbortController;
+    const signal = AbortSignal.any([controller.signal, options.forced()]);
+    let timer;
+    let renewing = Promise.resolve();
+    const renew = () => {
+      renewing = access.update((state) => {
+        const next = renewEntry(state, taken, clock(), options.leaseMs);
+        return { state: next, result: next !== state };
+      }).then((held) => {
+        if (!held)
+          controller.abort(new Error("Inbox delivery lease was lost"));
+        if (!signal.aborted)
+          timer = setTimeout(renew, Math.max(10, Math.floor(options.leaseMs / 4)));
+      }).catch(async (error) => {
+        controller.abort(error);
+        await options.report(error);
+      });
+    };
+    if (!signal.aborted)
+      timer = setTimeout(renew, Math.max(10, Math.floor(options.leaseMs / 4)));
     try {
-      json = JSON.parse(text);
-    } catch (error) {
-      return { reason: "invalid", detail: String(error).slice(0, 1000) };
+      const files = options.files();
+      const read = await files.read(taken.key, config.schema);
+      if (read === null || signal.aborted)
+        return false;
+      const claim = { ...taken, ...read.identity && { identity: read.identity } };
+      if ("reason" in read) {
+        const rejection = {
+          key: claim.key,
+          ...claim.identity && { identity: claim.identity },
+          reason: read.reason,
+          detail: read.detail,
+          rejectedAt: clock().toISOString()
+        };
+        const settled = await access.update((state) => {
+          if (signal.aborted || !ownsClaim(state, claim, clock()))
+            return { state, result: false };
+          return { state: withRejection(state, rejection, options.retain), result: true };
+        });
+        if (settled) {
+          await cleanupInboxEntry(access, files, claim.key, rejection, read.observation);
+          await config.onRejected?.(rejection);
+        }
+        return false;
+      }
+      const held = await access.update((state) => {
+        if (signal.aborted || !ownsClaim(state, claim, clock()))
+          return { state, result: false };
+        return {
+          state: {
+            ...state,
+            claims: state.claims.map((item) => item.key === claim.key ? { ...item, ...claim.identity && { identity: claim.identity } } : item)
+          },
+          result: true
+        };
+      });
+      if (!held || signal.aborted)
+        return false;
+      try {
+        await raceAbort(Promise.resolve().then(() => {
+          signal.throwIfAborted();
+          return config.handle({
+            key: claim.key,
+            ...claim.identity && { identity: claim.identity },
+            entry: read.entry,
+            attempt: claim.attempts,
+            signal
+          });
+        }), signal);
+      } catch (error) {
+        await options.report(error);
+        await access.update((state) => ({
+          state: signal.aborted ? state : releaseEntry(state, claim, clock(), new Date(clock().getTime() + backoffDelay(RETRY_BACKOFF, claim.attempts))),
+          result: undefined
+        }));
+        return false;
+      }
+      const completedAt = clock();
+      const completed = await access.update((state) => {
+        const next = signal.aborted ? state : completeEntry(state, claim, completedAt, options.retain);
+        return { state: next, result: next !== state };
+      });
+      if (!completed)
+        return false;
+      await cleanupInboxEntry(access, files, claim.key, { completedAt: completedAt.toISOString() }, read.observation);
+      return true;
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+      controller.abort(new Error("Inbox delivery ended"));
+      await renewing;
     }
-    const parsed = schema.safeParse(json);
-    return parsed.success ? { entry: parsed.data } : { reason: "invalid", detail: z.prettifyError(parsed.error).slice(0, 1000) };
-  } catch (error) {
-    if (absent(error))
-      return null;
-    throw error;
-  }
+  };
+}
+
+// src/application/directory-inbox.ts
+function resolveLimits(config) {
+  const integer = z2.int();
+  return {
+    pollIntervalMs: integer.min(10).max(2147483647).parse(config.pollIntervalMs ?? 1000),
+    leaseMs: integer.min(100).max(2147483647).parse(config.leaseMs ?? 300000),
+    maxAttempts: integer.min(1).max(1e4).parse(config.maxAttempts ?? 20),
+    maxEntryBytes: integer.min(1).parse(config.maxEntryBytes ?? 1024 * 1024),
+    maxPendingEntries: integer.min(1).max(1e5).parse(config.maxPendingEntries ?? 1000),
+    retain: integer.min(1).max(1e5).parse(config.retain ?? 1000)
+  };
 }
 function createDirectoryInbox(config) {
   const limits = resolveLimits(config);
   const clock = config.clock ?? (() => new Date);
-  const store = config.store ?? createFileStateStore2(join(config.directory, ".inbox-state.json"), {
+  const access = inboxStateAccess(config.store ?? createFileStateStore2(join2(config.directory, ".inbox-state.json"), {
     schema: DirectoryInboxStateSchema2
-  });
-  const parse = (state) => DirectoryInboxStateSchema2.parse(state ?? emptyDirectoryInboxState());
-  const update = (transition) => store.update((current) => transition(parse(current)));
+  }));
+  let files;
+  const filesFor = () => {
+    if (!files)
+      throw new Error("Directory inbox has not started");
+    return files;
+  };
   let running = false;
   let admitting = false;
+  let accepting = false;
   let timer;
   let forced = new AbortController;
   let tail = Promise.resolve();
+  const pendingAccepts = new Set;
   const report = async (error) => {
     try {
       await config.onError?.(error);
     } catch {}
   };
-  const setAside = async (key, rejection) => {
-    await mkdir(join(config.directory, REJECTED), { recursive: true });
-    await quietly(() => rename(join(config.directory, key), join(config.directory, REJECTED, key)));
-    if (rejection)
-      await config.onRejected?.(rejection);
-  };
-  const reject = async (key, reason, detail) => {
-    const rejection = { key, reason, detail, rejectedAt: clock().toISOString() };
-    await update((state) => ({
-      state: withRejection(state, rejection, limits.retain),
-      result: undefined
-    }));
-    await setAside(key, rejection);
-  };
-  const deliver = async (claim) => {
-    const path = join(config.directory, claim.key);
-    const read = await readEntry(path, config.schema, limits.maxEntryBytes);
-    if (read === null)
-      return false;
-    if ("reason" in read) {
-      await reject(claim.key, read.reason, read.detail);
-      return false;
-    }
-    try {
-      await config.handle({
-        key: claim.key,
-        entry: read.entry,
-        attempt: claim.attempts,
-        signal: forced.signal
-      });
-    } catch (error) {
-      await report(error);
-      const retryAt = new Date(clock().getTime() + backoffDelay(RETRY_BACKOFF, claim.attempts));
-      await update((state) => ({
-        state: releaseEntry(state, claim, retryAt),
-        result: undefined
-      }));
-      return false;
-    }
-    await update((state) => ({
-      state: completeEntry(state, claim.key, clock(), limits.retain),
-      result: undefined
-    }));
-    await quietly(() => unlink(path));
-    return true;
-  };
+  const deliver = createInboxDelivery({
+    config,
+    access,
+    files: filesFor,
+    clock,
+    forced: () => forced.signal,
+    leaseMs: limits.leaseMs,
+    retain: limits.retain,
+    report
+  });
   const pass = async () => {
-    const names = await entryNames(config.directory);
-    await update((state) => ({
+    if (!accepting || forced.signal.aborted)
+      return 0;
+    const currentFiles = filesFor();
+    const names = await currentFiles.names();
+    await access.update((state) => ({
       state: forgetMissing(state, new Set(names), clock()),
       result: undefined
     }));
     let handled = 0;
     for (const key of names) {
-      if (!admitting && running)
+      if (!accepting || forced.signal.aborted || running && !admitting)
         break;
-      const { step } = await update((state) => {
+      const step = await access.update((state) => {
         const next = claimEntry(state, { key, now: clock(), ...limits });
-        return { state: next.state, result: next };
+        return { state: next.state, result: next.step };
       });
-      if (step.kind === "remove")
-        await quietly(() => unlink(join(config.directory, key)));
-      else if (step.kind === "set-aside")
-        await setAside(key);
-      else if (step.kind === "reject")
-        await setAside(key, step.rejection);
-      else if (step.kind === "deliver" && await deliver(step.claim))
-        handled += 1;
+      if (step.kind === "deliver") {
+        if (await deliver(step.claim))
+          handled += 1;
+      } else if (step.kind === "reject") {
+        await cleanupInboxEntry(access, currentFiles, key, step.rejection);
+        await config.onRejected?.(step.rejection);
+      } else if (step.kind === "remove" || step.kind === "set-aside") {
+        await access.update(async (state, context) => {
+          if (state.claims.some((claim) => claim.key === key))
+            return { state, result: undefined };
+          const terminal = step.kind === "remove" ? state.receipts.some((receipt) => receipt.key === key) : state.rejected.some((rejection) => rejection.key === key);
+          if (terminal) {
+            await context.assertHeld();
+            if (step.kind === "remove")
+              await currentFiles.remove(key, context);
+            else
+              await currentFiles.setAside(key, context);
+          }
+          return { state, result: undefined };
+        });
+      }
     }
     return handled;
   };
@@ -175,22 +464,42 @@ function createDirectoryInbox(config) {
   };
   const stopAdmitting = () => {
     admitting = false;
+    accepting = false;
     if (timer)
       clearTimeout(timer);
     timer = undefined;
   };
+  const accept = createInboxAccept({
+    access,
+    files: filesFor,
+    accepting: () => accepting,
+    schema: config.schema,
+    maxEntryBytes: limits.maxEntryBytes,
+    maxPendingEntries: limits.maxPendingEntries
+  });
+  const drained = async () => {
+    await Promise.allSettled([...pendingAccepts]);
+    await tail;
+  };
   const inbox = {
+    accept(input) {
+      const result = accept(input);
+      pendingAccepts.add(result);
+      result.then(() => pendingAccepts.delete(result), () => pendingAccepts.delete(result));
+      return result;
+    },
     flush,
-    async state() {
-      return parse(await store.read());
-    }
+    state: access.read
   };
   return defineManagedResource2({
     id: config.id,
     ...config.dependsOn && { dependsOn: config.dependsOn },
     async start() {
-      await mkdir(config.directory, { recursive: true });
+      await mkdir2(config.directory, { recursive: true });
+      files = await createInboxFiles(config.directory, limits.maxEntryBytes);
       forced = new AbortController;
+      running = false;
+      accepting = true;
       return { value: inbox };
     },
     activate() {
@@ -198,20 +507,16 @@ function createDirectoryInbox(config) {
       admitting = true;
       poll();
     },
-    stopAdmission() {
-      stopAdmitting();
-    },
-    async drain() {
-      await tail;
-    },
+    stopAdmission: stopAdmitting,
+    drain: drained,
     async close() {
       stopAdmitting();
-      await tail;
+      await drained();
     },
     async force() {
       stopAdmitting();
-      forced.abort();
-      await tail;
+      forced.abort(new Error("Directory inbox was forced down"));
+      await drained();
     }
   });
 }

package/dist/entrypoints/application/grammy.js

@@ -1,6 +1,6 @@
 import {
   AppError2
-} from "../../index-n53mswt3.js";
+} from "../../index-x928baz2.js";
 import {
   defineManagedResource2
 } from "../../index-50ejfz75.js";

package/dist/entrypoints/application.d.ts

@@ -4,7 +4,7 @@ export { type ChangeConnection, type ChangeReconciliation, type ChangeSubscripti
 export { createDecisionPipeline, type DecisionPipeline, type DecisionPipelineConfig, type DecisionPolicy, DecisionPolicyError, type DecisionResult, type DecisionTraceEntry, DecisionUndecidedError, type PolicyDecision, PolicyDecisionSchema, } from '../application/decisions.js';
 export { type DiagnosticJournal, type DiagnosticJournalCloseResult, DiagnosticJournalCloseResultSchema, type DiagnosticJournalConfig, type DiagnosticJournalFailure, type DiagnosticJournalFailurePhase, DiagnosticJournalFailurePhaseSchema, type DiagnosticJournalFrame, DiagnosticJournalFrameSchema, type DiagnosticJournalLimits, DiagnosticJournalLimitsSchema, type DiagnosticJournalLockDiagnosis, type DiagnosticJournalLockPolicy, DiagnosticJournalLockPolicySchema, type DiagnosticJournalRefusalReason, DiagnosticJournalRefusalReasonSchema, type DiagnosticJournalState, DiagnosticJournalStateSchema, type DiagnosticJournalStatus, DiagnosticJournalStatusSchema, type DiagnosticJournalSubmitResult, DiagnosticJournalSubmitResultSchema, type DiagnosticJournalWaitOptions, type DiagnosticJournalWaitResult, DiagnosticJournalWaitResultSchema, readDiagnosticJournalLockDiagnosis, } from '../application/diagnostic-journal-contract.js';
 export { createDiagnosticJournalReadResultSchema, type DiagnosticJournalAnomaly, DiagnosticJournalAnomalySchema, type DiagnosticJournalReadResult, DiagnosticJournalRecoveryError, type DiagnosticJournalRecoveryStatus, DiagnosticJournalRecoveryStatusSchema, } from '../application/diagnostic-journal-read-contract.js';
-export { type DirectoryInbox, type DirectoryInboxConfig, type DirectoryInboxDelivery, type DirectoryInboxRejection, type DirectoryInboxRejectionReason, DirectoryInboxRejectionReasonSchema, type DirectoryInboxResource, type DirectoryInboxState, DirectoryInboxStateSchema, } from '../application/directory-inbox-contract.js';
+export { type DirectoryInbox, type DirectoryInboxAccept, type DirectoryInboxAcceptResult, DirectoryInboxAcceptResultSchema, type DirectoryInboxConfig, type DirectoryInboxDelivery, type DirectoryInboxIdentity, DirectoryInboxIdentitySchema, type DirectoryInboxRejection, type DirectoryInboxRejectionReason, DirectoryInboxRejectionReasonSchema, type DirectoryInboxResource, type DirectoryInboxState, DirectoryInboxStateSchema, } from '../application/directory-inbox-contract.js';
 export { type ApplicationEventSink, type ApplicationEventSinkConfig, type ApplicationLifecycleEvent, ApplicationLifecycleEventSchema, applicationLifecycleEvent, createApplicationEventSink, } from '../application/events.js';
 export { type ApplicationHealthHandlerOptions, ApplicationHealthHandlerOptionsSchema, type ApplicationOperationalHandlers, type ApplicationOperationalHandlersOptions, ApplicationOperationalHandlersOptionsSchema, createApplicationHealthHandler, createApplicationOperationalHandlers, } from '../application/health.js';
 export { createApplication } from '../application/kernel.js';
@@ -20,7 +20,7 @@ export { defineManagedResource, type ManagedResource, type ManagedResourceAdmiss
 export { createRevisionSignal, type RevisionSignal, type RevisionSignalAdvanceResult, RevisionSignalAdvanceResultSchema, type RevisionSignalClock, type RevisionSignalConfig, type RevisionSignalSnapshot, RevisionSignalSnapshotSchema, type RevisionSignalState, RevisionSignalStateSchema, type RevisionSignalTimer, type RevisionSignalWaitOptions, type RevisionSignalWaitOutcome, RevisionSignalWaitOutcomeSchema, type RevisionSignalWaitResult, RevisionSignalWaitResultSchema, } from '../application/revision-signal.js';
 export { createManagedSchedule, type ManagedSchedule, type ManagedScheduleClock, type ManagedScheduleConfig, type ManagedScheduleDescriptor, ManagedScheduleDescriptorSchema, type ManagedScheduleErrorPolicy, ManagedScheduleErrorPolicySchema, type ManagedScheduleOverlap, ManagedScheduleOverlapSchema, type ManagedScheduleRunContext, type ManagedScheduleStatus, ManagedScheduleStatusSchema, type ManagedScheduleTimer, } from '../application/schedule.js';
 export { type ManagedServerResource, type ManagedServerResourceConfig, managedServerResource, } from '../application/server-resource.js';
-export type { StateStore, StateStoreUpdate } from '../application/state-store.js';
+export type { StateStore, StateStoreUpdate, StateStoreUpdateContext, } from '../application/state-store.js';
 export { type AttachedWatcher, createWatchHub, type WatchAdmissionScope, type WatchHub, type WatchHubConfig, type WatchOperation, type WatchSubscriber, watchKey, } from '../application/watch-hub.js';
 export { type BoundedChannel, type BoundedChannelCloseOptions, type BoundedChannelConfig, type BoundedChannelOfferResult, type BoundedChannelPolicy, BoundedChannelPolicySchema, BoundedChannelReaderError, type BoundedChannelSnapshot, BoundedChannelSnapshotSchema, type BoundedChannelState, BoundedChannelStateSchema, type CreditAcquireResult, type CreditAcquireWaitOptions, type CreditLease, type CreditWaitRefusalReason, type CreditWaitResult, type CreditWindow, type CreditWindowSnapshot, CreditWindowSnapshotSchema, createBoundedChannel, createCreditWindow, } from '../internal/channel.js';
 export type { SqliteDatabase, SqliteStatement, SqliteValue } from '../internal/sqlite.js';