stitchkit 0.95.0 → 0.95.1

package/CHANGELOG.md

@@ -15,6 +15,23 @@ additive**; the first breaking change landed in 0.10.0. Grep the file for
 
 ## [Unreleased]
 
+## [0.95.1] — 2026-09-23
+
+### Added
+
+- `stitchkit/application/directory-inbox` (new, server, evolving) —
+  **`createDirectoryInbox({ id, directory, schema, handle })`**, with its
+  contract (`DirectoryInboxConfig`, `DirectoryInboxStateSchema`, …) in
+  `stitchkit/application`: a managed resource that delivers each `<name>.json` entry
+  another program drops into a directory to the application at least once,
+  after readiness. Taken and done are separate durable records — a claim with a
+  lease before `handle`, a receipt after it and only then the file removed — so
+  a restart neither loses an entry nor repeats a finished one. A throwing
+  handler is retried with a backoff; an entry that fails its schema, is too
+  large or used up `maxAttempts` is moved to `rejected/` with its reason and
+  the queue keeps flowing. `stopAdmission` stops taking entries, `force` aborts
+  the delivery in flight. A consuming project wrote this receiver by hand.
+
 ## [0.95.0] — 2026-09-23
 
 ### ⚠️ Breaking changes

package/dist/application/directory-inbox-contract.d.ts

@@ -0,0 +1,129 @@
+import { z } from 'zod';
+import type { ManagedResource, ManagedResourceDependency } from './resource.js';
+import type { StateStore } from './state-store.js';
+export declare const DirectoryInboxRejectionReasonSchema: z.ZodEnum<{
+    "attempt-limit": "attempt-limit";
+    invalid: "invalid";
+    "too-large": "too-large";
+}>;
+export type DirectoryInboxRejectionReason = z.infer<typeof DirectoryInboxRejectionReasonSchema>;
+export declare const DirectoryInboxStateSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    claims: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        attempts: z.ZodNumber;
+        nextAttemptAt: z.ZodString;
+        leaseId: z.ZodNullable<z.ZodString>;
+        leaseUntil: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    receipts: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        completedAt: z.ZodString;
+    }, z.core.$strict>>;
+    rejected: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        reason: z.ZodEnum<{
+            "attempt-limit": "attempt-limit";
+            invalid: "invalid";
+            "too-large": "too-large";
+        }>;
+        detail: z.ZodString;
+        rejectedAt: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type DirectoryInboxState = z.infer<typeof DirectoryInboxStateSchema>;
+export type DirectoryInboxClaim = DirectoryInboxState['claims'][number];
+export type DirectoryInboxRejection = DirectoryInboxState['rejected'][number];
+export declare const emptyDirectoryInboxState: () => DirectoryInboxState;
+/**
+ * A directory another program drops entries into, handed to the application
+ * at least once each. The producer writes each entry atomically as a
+ * `<name>.json` file (a temporary name, then a rename); names starting with a
+ * dot are never read, which is where the inbox keeps its own state.
+ */
+export interface DirectoryInboxDelivery<TEntry> {
+    /** The entry's file name — stable across retries and restarts. */
+    readonly key: string;
+    readonly entry: TEntry;
+    /** 1 on the first delivery of this entry. */
+    readonly attempt: number;
+    /** Aborted when the application is forced down mid-delivery. */
+    readonly signal: AbortSignal;
+}
+export interface DirectoryInboxConfig<TEntry> {
+    readonly id: string;
+    readonly directory: string;
+    readonly schema: z.ZodType<TEntry>;
+    /** Throwing leaves the entry for a later attempt. */
+    readonly handle: (delivery: DirectoryInboxDelivery<TEntry>) => void | Promise<void>;
+    readonly dependsOn?: readonly ManagedResourceDependency[];
+    /** Default: `<directory>/.inbox-state.json`, locked across processes. */
+    readonly store?: StateStore<DirectoryInboxState>;
+    readonly clock?: () => Date;
+    /** How often the directory is read while the application runs. Default 1 s. */
+    readonly pollIntervalMs?: number;
+    /** How long a taken entry is someone's before it may be taken again. Default 5 min. */
+    readonly leaseMs?: number;
+    /** Deliveries of one entry before it is set aside. Default 20. */
+    readonly maxAttempts?: number;
+    /** Larger entries are set aside unread. Default 1 MiB. */
+    readonly maxEntryBytes?: number;
+    /** Receipts and rejections kept. Default 1 000. */
+    readonly retain?: number;
+    /** An entry was set aside into `<directory>/rejected/`, with the reason. */
+    readonly onRejected?: (rejection: DirectoryInboxRejection) => void | Promise<void>;
+    /**
+     * A delivery failed (the entry is retried after a backoff) or a whole pass
+     * did (storage, the directory; the next poll tries again).
+     */
+    readonly onError?: (error: unknown) => void | Promise<void>;
+}
+export interface DirectoryInbox {
+    /** Deliver every entry due now; resolves with how many were handled. */
+    flush(): Promise<number>;
+    state(): Promise<DirectoryInboxState>;
+}
+export interface DirectoryInboxResource extends ManagedResource {
+    start(): Promise<{
+        readonly value: DirectoryInbox;
+    }>;
+}
+/** What the next step does with one entry of the directory. */
+export type InboxStep = {
+    readonly kind: 'skip';
+} | {
+    readonly kind: 'remove';
+} | {
+    readonly kind: 'set-aside';
+} | {
+    readonly kind: 'reject';
+    readonly rejection: DirectoryInboxRejection;
+} | {
+    readonly kind: 'deliver';
+    readonly claim: DirectoryInboxClaim;
+};
+interface StepInput {
+    readonly key: string;
+    readonly now: Date;
+    readonly leaseMs: number;
+    readonly maxAttempts: number;
+    readonly retain: number;
+}
+export declare function withRejection(state: DirectoryInboxState, rejection: DirectoryInboxRejection, retain: number): DirectoryInboxState;
+/**
+ * Decide one entry, and take it when it is due. A claim whose attempts are
+ * spent is not taken again: an entry whose handling kills the process would
+ * otherwise be retried on every restart, forever.
+ */
+export declare function claimEntry(state: DirectoryInboxState, input: StepInput): {
+    readonly state: DirectoryInboxState;
+    readonly step: InboxStep;
+};
+/** The entry was handled: its receipt replaces its claim. */
+export declare function completeEntry(state: DirectoryInboxState, entryKey: string, now: Date, retain: number): DirectoryInboxState;
+/** The handler refused: wait, then take it again — unless it is no longer ours. */
+export declare function releaseEntry(state: DirectoryInboxState, claim: DirectoryInboxClaim, retryAt: Date): DirectoryInboxState;
+/** Records about entries that are gone from the directory, except a live lease. */
+export declare function forgetMissing(state: DirectoryInboxState, present: ReadonlySet<string>, now: Date): DirectoryInboxState;
+export {};
+//# sourceMappingURL=directory-inbox-contract.d.ts.map

package/dist/application/directory-inbox-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directory-inbox-contract.d.ts","sourceRoot":"","sources":["../../src/application/directory-inbox-contract.ts"],"names":[],"mappings":"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"}

package/dist/application/directory-inbox.d.ts

@@ -0,0 +1,3 @@
+import { type DirectoryInboxConfig, type DirectoryInboxResource } from './directory-inbox-contract.js';
+export declare function createDirectoryInbox<TEntry>(config: DirectoryInboxConfig<TEntry>): DirectoryInboxResource;
+//# sourceMappingURL=directory-inbox.d.ts.map

package/dist/application/directory-inbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directory-inbox.d.ts","sourceRoot":"","sources":["../../src/application/directory-inbox.ts"],"names":[],"mappings":"AAIA,OAAO,EAKL,KAAK,oBAAoB,EAEzB,KAAK,sBAAsB,EAO5B,MAAM,4BAA4B,CAAC;AAyEpC,wBAAgB,oBAAoB,CAAC,MAAM,EACzC,MAAM,EAAE,oBAAoB,CAAC,MAAM,CAAC,GACnC,sBAAsB,CAiKxB"}

package/dist/entrypoints/application/directory-inbox.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The directory inbox — delivers each entry another program drops into a
+ * directory to the application at least once.
+ *
+ * Its own entrypoint because it reads, renames and removes files (`node:fs`),
+ * and `stitchkit/application` must stay importable in a browser. Its contract —
+ * the configuration, the delivery, the state and rejection schemas — stays in
+ * `stitchkit/application`, as the diagnostic journal's does. → ADR 0156.
+ */
+export { createDirectoryInbox } from '../../application/directory-inbox.js';
+//# sourceMappingURL=directory-inbox.d.ts.map

package/dist/entrypoints/application/directory-inbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directory-inbox.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/application/directory-inbox.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC"}

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

@@ -0,0 +1,221 @@
+import {
+  DirectoryInboxStateSchema,
+  claimEntry,
+  completeEntry,
+  emptyDirectoryInboxState,
+  forgetMissing,
+  releaseEntry,
+  withRejection
+} from "../../index-5jrd0yng.js";
+import {
+  defineManagedResource
+} from "../../index-2k4yrqkc.js";
+import {
+  createFileStateStore
+} from "../../index-tm88avnj.js";
+import {
+  backoffDelay
+} from "../../index-ngfhvfpd.js";
+import"../../index-hffjpmq9.js";
+
+// src/application/directory-inbox.ts
+import { mkdir, readdir, readFile, rename, stat, 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;
+  }
+}
+function resolveLimits(config) {
+  const integer = z.number().int();
+  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 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();
+}
+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` };
+    }
+    const text = await readFile(path, "utf8");
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch (error) {
+      return { reason: "invalid", detail: String(error).slice(0, 1000) };
+    }
+    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;
+  }
+}
+function createDirectoryInbox(config) {
+  const limits = resolveLimits(config);
+  const clock = config.clock ?? (() => new Date);
+  const store = config.store ?? createFileStateStore(join(config.directory, ".inbox-state.json"), {
+    schema: DirectoryInboxStateSchema
+  });
+  const parse = (state) => DirectoryInboxStateSchema.parse(state ?? emptyDirectoryInboxState());
+  const update = (transition) => store.update((current) => transition(parse(current)));
+  let running = false;
+  let admitting = false;
+  let timer;
+  let forced = new AbortController;
+  let tail = Promise.resolve();
+  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 pass = async () => {
+    const names = await entryNames(config.directory);
+    await update((state) => ({
+      state: forgetMissing(state, new Set(names), clock()),
+      result: undefined
+    }));
+    let handled = 0;
+    for (const key of names) {
+      if (!admitting && running)
+        break;
+      const { step } = await update((state) => {
+        const next = claimEntry(state, { key, now: clock(), ...limits });
+        return { state: next.state, result: next };
+      });
+      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;
+    }
+    return handled;
+  };
+  const flush = () => {
+    const result = tail.then(pass, pass);
+    tail = result.catch(() => {
+      return;
+    });
+    return result;
+  };
+  const poll = async () => {
+    try {
+      await flush();
+    } catch (error) {
+      await report(error);
+    }
+    if (admitting)
+      timer = setTimeout(() => void poll(), limits.pollIntervalMs);
+  };
+  const stopAdmitting = () => {
+    admitting = false;
+    if (timer)
+      clearTimeout(timer);
+    timer = undefined;
+  };
+  const inbox = {
+    flush,
+    async state() {
+      return parse(await store.read());
+    }
+  };
+  return defineManagedResource({
+    id: config.id,
+    ...config.dependsOn && { dependsOn: config.dependsOn },
+    async start() {
+      await mkdir(config.directory, { recursive: true });
+      forced = new AbortController;
+      return { value: inbox };
+    },
+    activate() {
+      running = true;
+      admitting = true;
+      poll();
+    },
+    stopAdmission() {
+      stopAdmitting();
+    },
+    async drain() {
+      await tail;
+    },
+    async close() {
+      stopAdmitting();
+      await tail;
+    },
+    async force() {
+      stopAdmitting();
+      forced.abort();
+      await tail;
+    }
+  });
+}
+export {
+  createDirectoryInbox
+};

package/dist/entrypoints/application.d.ts

@@ -2,6 +2,7 @@ export { type ActivityId, ActivityIdSchema, type ActivityLiveState, ActivityLive
 export { type BoundedAdmission, type BoundedAdmissionClock, type BoundedAdmissionConfig, type BoundedAdmissionDrainOptions, type BoundedAdmissionDrainResult, type BoundedAdmissionForceResult, type BoundedAdmissionLeaseResult, type BoundedAdmissionPerKeyLimitResolver, type BoundedAdmissionPerKeyLimits, BoundedAdmissionPerKeyLimitsSchema, type BoundedAdmissionPolicy, BoundedAdmissionPolicySchema, BoundedAdmissionRefusalError, type BoundedAdmissionRefusalReason, BoundedAdmissionRefusalReasonSchema, type BoundedAdmissionRefusedResult, type BoundedAdmissionResult, type BoundedAdmissionSnapshot, BoundedAdmissionSnapshotSchema, type BoundedAdmissionState, BoundedAdmissionStateSchema, type BoundedOperationLease, type BoundedOperationRunContext, type BoundedOperationRunOptions, BoundedOperationWaitError, type BoundedRateBudget, BoundedRateBudgetSchema, createBoundedAdmission, } from '../application/admission.js';
 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 { type DirectoryInbox, type DirectoryInboxConfig, type DirectoryInboxDelivery, 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';

package/dist/entrypoints/application.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"application.d.ts","sourceRoot":"","sources":["../../src/entrypoints/application.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"application.d.ts","sourceRoot":"","sources":["../../src/entrypoints/application.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,gBAAgB,EAChB,KAAK,iBAAiB,EACtB,uBAAuB,EACvB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,iCAAiC,EACtC,KAAK,gBAAgB,EACrB,sBAAsB,EACtB,KAAK,eAAe,EACpB,qBAAqB,EACrB,KAAK,qBAAqB,EAC1B,2BAA2B,EAC3B,KAAK,aAAa,EAClB,kBAAkB,EAClB,KAAK,kBAAkB,EACvB,wBAAwB,GACzB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC3B,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EAChC,KAAK,2BAA2B,EAChC,KAAK,2BAA2B,EAChC,KAAK,mCAAmC,EACxC,KAAK,4BAA4B,EACjC,kCAAkC,EAClC,KAAK,sBAAsB,EAC3B,4BAA4B,EAC5B,4BAA4B,EAC5B,KAAK,6BAA6B,EAClC,mCAAmC,EACnC,KAAK,6BAA6B,EAClC,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,8BAA8B,EAC9B,KAAK,qBAAqB,EAC1B,2BAA2B,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,0BAA0B,EAC/B,KAAK,0BAA0B,EAC/B,yBAAyB,EACzB,KAAK,iBAAiB,EACtB,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,sBAAsB,EACtB,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,mBAAmB,EACnB,KAAK,cAAc,EACnB,KAAK,kBAAkB,EACvB,sBAAsB,EACtB,KAAK,cAAc,EACnB,oBAAoB,GACrB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,4BAA4B,EACjC,kCAAkC,EAClC,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,6BAA6B,EAClC,mCAAmC,EACnC,KAAK,sBAAsB,EAC3B,4BAA4B,EAC5B,KAAK,uBAAuB,EAC5B,6BAA6B,EAC7B,KAAK,8BAA8B,EACnC,KAAK,2BAA2B,EAChC,iCAAiC,EACjC,KAAK,8BAA8B,EACnC,oCAAoC,EACpC,KAAK,sBAAsB,EAC3B,4BAA4B,EAC5B,KAAK,uBAAuB,EAC5B,6BAA6B,EAC7B,KAAK,6BAA6B,EAClC,mCAAmC,EACnC,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EAChC,iCAAiC,EACjC,kCAAkC,GACnC,MAAM,4CAA4C,CAAC;AACpD,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAC5B,KAAK,6BAA6B,EAClC,mCAAmC,EACnC,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACxB,yBAAyB,GAC1B,MAAM,yCAAyC,CAAC;AACjD,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,EAC9B,+BAA+B,EAC/B,yBAAyB,EACzB,0BAA0B,GAC3B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,KAAK,+BAA+B,EACpC,qCAAqC,EACrC,KAAK,8BAA8B,EACnC,KAAK,qCAAqC,EAC1C,2CAA2C,EAC3C,8BAA8B,EAC9B,oCAAoC,GACrC,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EACL,KAAK,oBAAoB,EACzB,yBAAyB,EACzB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,6BAA6B,EAC7B,KAAK,yBAAyB,EAC9B,+BAA+B,EAC/B,KAAK,wBAAwB,EAC7B,8BAA8B,EAC9B,KAAK,yBAAyB,EAC9B,+BAA+B,EAC/B,KAAK,0BAA0B,EAC/B,gCAAgC,GACjC,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,gBAAgB,EAChB,qBAAqB,EACrB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,YAAY,GACb,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,KAAK,2BAA2B,EAChC,qBAAqB,GACtB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,6BAA6B,EAClC,KAAK,4BAA4B,EACjC,KAAK,6BAA6B,EAClC,mCAAmC,EACnC,6BAA6B,EAC7B,KAAK,6BAA6B,GACnC,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,wBAAwB,EACxB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,KAAK,iCAAiC,EACtC,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAC/B,KAAK,gCAAgC,EACrC,KAAK,uBAAuB,EAC5B,KAAK,gBAAgB,EACrB,0BAA0B,EAC1B,6BAA6B,GAC9B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EACL,4BAA4B,EAC5B,KAAK,uBAAuB,EAC5B,KAAK,6BAA6B,EAClC,uBAAuB,EACvB,KAAK,sBAAsB,EAC3B,KAAK,4BAA4B,GAClC,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,kBAAkB,EAClB,KAAK,cAAc,EACnB,oBAAoB,EACpB,KAAK,oBAAoB,EACzB,0BAA0B,EAC1B,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,kBAAkB,EAClB,KAAK,oBAAoB,EACzB,KAAK,SAAS,EACd,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,kBAAkB,EACvB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,yBAAyB,EACzB,sBAAsB,EACtB,yBAAyB,EACzB,sBAAsB,GACvB,MAAM,8CAA8C,CAAC;AACtD,OAAO,EACL,qBAAqB,EACrB,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC7B,KAAK,+BAA+B,EACpC,KAAK,0BAA0B,EAC/B,2BAA2B,GAC5B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,oBAAoB,EACpB,KAAK,cAAc,EACnB,KAAK,2BAA2B,EAChC,iCAAiC,EACjC,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,EAC3B,4BAA4B,EAC5B,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,yBAAyB,EAC9B,+BAA+B,EAC/B,KAAK,wBAAwB,EAC7B,8BAA8B,GAC/B,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,qBAAqB,EACrB,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,+BAA+B,EAC/B,KAAK,0BAA0B,EAC/B,gCAAgC,EAChC,KAAK,sBAAsB,EAC3B,4BAA4B,EAC5B,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAC1B,2BAA2B,EAC3B,KAAK,oBAAoB,GAC1B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,qBAAqB,GACtB,MAAM,gCAAgC,CAAC;AACxC,YAAY,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC/E,OAAO,EACL,KAAK,eAAe,EACpB,cAAc,EACd,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,QAAQ,GACT,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,0BAA0B,EAC/B,KAAK,oBAAoB,EACzB,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,EACzB,0BAA0B,EAC1B,yBAAyB,EACzB,KAAK,sBAAsB,EAC3B,4BAA4B,EAC5B,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,WAAW,EAChB,KAAK,uBAAuB,EAC5B,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,0BAA0B,EAC1B,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACvF,cAAc,uBAAuB,CAAC"}

package/dist/entrypoints/application.js

@@ -14,6 +14,10 @@ import {
   createApplicationSnapshotSink,
   createManagedSchedule
 } from "../index-ensd0r74.js";
+import {
+  DirectoryInboxRejectionReasonSchema,
+  DirectoryInboxStateSchema
+} from "../index-5jrd0yng.js";
 import {
   DiagnosticJournalCloseResultSchema,
   DiagnosticJournalFailurePhaseSchema,
@@ -2053,6 +2057,8 @@ export {
   LifecycleTerminationSchema,
   LifecycleStateSchema,
   LifecycleRunSchema,
+  DirectoryInboxStateSchema,
+  DirectoryInboxRejectionReasonSchema,
   DiagnosticJournalWaitResultSchema,
   DiagnosticJournalSubmitResultSchema,
   DiagnosticJournalStatusSchema,

package/dist/entrypoints/server.js

@@ -21,6 +21,9 @@ import {
   webSocketLane
 } from "../index-p3vsv1fb.js";
 import"../index-y91ry9h2.js";
+import {
+  createFileStateStore
+} from "../index-tm88avnj.js";
 import {
   withDeadline
 } from "../index-b9aefrqd.js";
@@ -113,222 +116,6 @@ import {
 import {
   isRecord
 } from "../index-hffjpmq9.js";
-
-// src/application/file-state-store.ts
-import { mkdir, open, readdir, readFile, rename, stat, unlink } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
-var ABANDONED_LOCK_MULTIPLIER = 10;
-var ABANDONED_HEARTBEATS = 30;
-var MIN_HEARTBEAT_MS = 10;
-var delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
-async function missing(error) {
-  return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-function existing(error) {
-  return error instanceof Error && "code" in error && error.code === "EEXIST";
-}
-async function ownerState(lockPath) {
-  let owner;
-  try {
-    owner = JSON.parse(await readFile(lockPath, "utf8"));
-  } catch {
-    return "unknown";
-  }
-  if (typeof owner !== "object" || owner === null || !("pid" in owner) || typeof owner.pid !== "number" || !Number.isSafeInteger(owner.pid) || owner.pid <= 0) {
-    return "unknown";
-  }
-  try {
-    process.kill(owner.pid, 0);
-    return "alive";
-  } catch (error) {
-    return error instanceof Error && "code" in error && error.code === "ESRCH" ? "gone" : "unknown";
-  }
-}
-async function sweepTemporaries(path, staleLockMs) {
-  const prefix = `${basename(path)}.tmp.`;
-  const directory = dirname(path);
-  let entries;
-  try {
-    entries = await readdir(directory);
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (!entry.startsWith(prefix))
-      continue;
-    const candidate = join(directory, entry);
-    const info = await stat(candidate).catch(() => null);
-    if (info && Date.now() - info.mtimeMs > staleLockMs) {
-      await unlink(candidate).catch(() => {
-        return;
-      });
-    }
-  }
-}
-async function reclaim(lockPath, observed, staleLockMs, abandonedAfterMs) {
-  const guardPath = `${lockPath}.reclaim`;
-  let guard;
-  try {
-    guard = await open(guardPath, "wx");
-  } catch (error) {
-    if (!existing(error))
-      throw error;
-    const orphan = await stat(guardPath).catch(() => null);
-    if (orphan && Date.now() - orphan.mtimeMs > staleLockMs) {
-      await unlink(guardPath).catch(() => {
-        return;
-      });
-    }
-    return false;
-  }
-  try {
-    const current = await stat(lockPath).catch(() => null);
-    if (!current || current.dev !== observed.dev || current.ino !== observed.ino || current.mtimeMs !== observed.mtimeMs) {
-      return false;
-    }
-    const owner = await ownerState(lockPath);
-    const age = Date.now() - current.mtimeMs;
-    if (owner !== "gone" && age < abandonedAfterMs)
-      return false;
-    await unlink(lockPath);
-    return true;
-  } finally {
-    await guard.close().catch(() => {
-      return;
-    });
-    await unlink(guardPath).catch(() => {
-      return;
-    });
-  }
-}
-function createFileStateStore(path, options) {
-  const lockPath = `${path}.lock`;
-  const lockTimeoutMs = options.lockTimeoutMs ?? 1e4;
-  const staleLockMs = options.staleLockMs ?? 3000;
-  const retryMs = options.retryMs ?? 10;
-  const heartbeatMs = Math.max(MIN_HEARTBEAT_MS, Math.floor(staleLockMs / 3));
-  const abandonedAfterMs = Math.max(staleLockMs * ABANDONED_LOCK_MULTIPLIER, heartbeatMs * ABANDONED_HEARTBEATS);
-  if (staleLockMs >= lockTimeoutMs) {
-    throw new Error(`[stitchkit] createFileStateStore: staleLockMs (${staleLockMs}) must be below lockTimeoutMs (${lockTimeoutMs}), or a crashed holder blocks every update until the timeout`);
-  }
-  let sweptTemporaries = false;
-  const parseFile = async () => {
-    let source;
-    try {
-      source = await readFile(path, "utf8");
-    } catch (error) {
-      if (await missing(error))
-        return null;
-      throw error;
-    }
-    try {
-      return options.schema.parse(JSON.parse(source));
-    } catch (error) {
-      await options.onCorrupt?.({ path, error });
-      if ((options.corrupt ?? "throw") === "empty")
-        return null;
-      throw error;
-    }
-  };
-  const acquire = async () => {
-    await mkdir(dirname(path), { recursive: true });
-    if (!sweptTemporaries) {
-      sweptTemporaries = true;
-      await sweepTemporaries(path, staleLockMs);
-    }
-    const deadline = Date.now() + lockTimeoutMs;
-    while (true) {
-      try {
-        const handle = await open(lockPath, "wx");
-        const token = crypto.randomUUID();
-        try {
-          await handle.writeFile(JSON.stringify({ token, pid: process.pid, acquiredAt: Date.now() }));
-          await handle.sync();
-        } catch (error) {
-          await handle.close().catch(() => {
-            return;
-          });
-          await unlink(lockPath).catch(() => {
-            return;
-          });
-          throw error;
-        }
-        return {
-          refresh: async () => {
-            const now = new Date;
-            await handle.utimes(now, now);
-          },
-          release: async () => {
-            await handle.close();
-            try {
-              const owner = JSON.parse(await readFile(lockPath, "utf8"));
-              if (isRecord(owner) && owner.token === token)
-                await unlink(lockPath);
-            } catch (error) {
-              if (!await missing(error))
-                throw error;
-            }
-          }
-        };
-      } catch (error) {
-        if (!existing(error))
-          throw error;
-        try {
-          const lock = await stat(lockPath);
-          if (Date.now() - lock.mtimeMs > staleLockMs) {
-            if (await reclaim(lockPath, lock, staleLockMs, abandonedAfterMs))
-              continue;
-          }
-        } catch (statError) {
-          if (await missing(statError))
-            continue;
-          throw statError;
-        }
-        if (Date.now() >= deadline) {
-          throw new Error(`[stitchkit] timed out acquiring state lock for ${path}`);
-        }
-        await delay(retryMs);
-      }
-    }
-  };
-  const write = async (state) => {
-    const validated = options.schema.parse(state);
-    const temporary = `${path}.tmp.${process.pid}.${crypto.randomUUID()}`;
-    const handle = await open(temporary, "wx");
-    try {
-      try {
-        await handle.writeFile(`${JSON.stringify(validated)}
-`);
-        await handle.sync();
-      } finally {
-        await handle.close();
-      }
-      await rename(temporary, path);
-    } catch (error) {
-      await unlink(temporary).catch(() => {
-        return;
-      });
-      throw error;
-    }
-  };
-  return {
-    read: parseFile,
-    async update(transition) {
-      const lock = await acquire();
-      const heartbeat = setInterval(() => void lock.refresh().catch(() => {
-        return;
-      }), heartbeatMs);
-      try {
-        const next = await transition(await parseFile());
-        await write(next.state);
-        return next.result;
-      } finally {
-        clearInterval(heartbeat);
-        await lock.release();
-      }
-    }
-  };
-}
 // src/realtime/registry.ts
 var authorizedRoom = Symbol("stitchkit.authorized-room");
 function freezeRoom(name) {
@@ -1001,7 +788,7 @@ function createEventBus(options = {}) {
   };
 }
 // src/server/file.ts
-import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { readFile, stat } from "node:fs/promises";
 import { resolve } from "node:path";
 
 // src/server/mime.ts
@@ -1061,10 +848,10 @@ function staticRoute(prefix, dir) {
       const realTarget = await realPathWithinDir(root, target);
       if (realTarget === null)
         return new Response("Not found", { status: 404 });
-      const info = await stat2(realTarget).catch(() => null);
+      const info = await stat(realTarget).catch(() => null);
       if (!info?.isFile())
         return new Response("Not found", { status: 404 });
-      return new Response(await readFile2(realTarget), {
+      return new Response(await readFile(realTarget), {
         headers: {
           "Content-Type": mimeForPath(realTarget),
           "X-Content-Type-Options": "nosniff"

package/dist/index-5jrd0yng.js

@@ -0,0 +1,114 @@
+// src/application/directory-inbox-contract.ts
+import { z } from "zod";
+var timestamp = z.string().datetime({ offset: true });
+var key = z.string().min(1).max(255);
+var DirectoryInboxRejectionReasonSchema = z.enum([
+  "invalid",
+  "too-large",
+  "attempt-limit"
+]);
+var DirectoryInboxStateSchema = z.object({
+  schemaVersion: z.literal(1),
+  claims: z.array(z.object({
+    key,
+    attempts: z.number().int().positive(),
+    nextAttemptAt: timestamp,
+    leaseId: z.string().min(1).max(128).nullable(),
+    leaseUntil: timestamp.nullable()
+  }).strict()),
+  receipts: z.array(z.object({ key, completedAt: timestamp }).strict()),
+  rejected: z.array(z.object({
+    key,
+    reason: DirectoryInboxRejectionReasonSchema,
+    detail: z.string().max(1000),
+    rejectedAt: timestamp
+  }).strict())
+}).strict();
+var emptyDirectoryInboxState = () => ({
+  schemaVersion: 1,
+  claims: [],
+  receipts: [],
+  rejected: []
+});
+var iso = (milliseconds) => new Date(milliseconds).toISOString();
+function withRejection(state, rejection, retain) {
+  return {
+    ...state,
+    claims: state.claims.filter((claim) => claim.key !== rejection.key),
+    rejected: [
+      rejection,
+      ...state.rejected.filter((item) => item.key !== rejection.key)
+    ].slice(0, retain)
+  };
+}
+function claimEntry(state, input) {
+  if (state.receipts.some((receipt) => receipt.key === input.key)) {
+    return { state, step: { kind: "remove" } };
+  }
+  if (state.rejected.some((rejection) => rejection.key === input.key)) {
+    return { state, step: { kind: "set-aside" } };
+  }
+  const now = input.now.getTime();
+  const claim = state.claims.find((candidate) => candidate.key === input.key);
+  if (claim) {
+    const leased = claim.leaseUntil !== null && Date.parse(claim.leaseUntil) > now;
+    if (leased || Date.parse(claim.nextAttemptAt) > now)
+      return { state, step: { kind: "skip" } };
+    if (claim.attempts >= input.maxAttempts) {
+      const rejection = {
+        key: input.key,
+        reason: "attempt-limit",
+        detail: `taken ${claim.attempts} times without completing`,
+        rejectedAt: iso(now)
+      };
+      return {
+        state: withRejection(state, rejection, input.retain),
+        step: { kind: "reject", rejection }
+      };
+    }
+  }
+  const taken = {
+    key: input.key,
+    attempts: (claim?.attempts ?? 0) + 1,
+    nextAttemptAt: iso(now),
+    leaseId: crypto.randomUUID(),
+    leaseUntil: iso(now + input.leaseMs)
+  };
+  return {
+    state: {
+      ...state,
+      claims: [...state.claims.filter((candidate) => candidate.key !== input.key), taken]
+    },
+    step: { kind: "deliver", claim: taken }
+  };
+}
+function completeEntry(state, entryKey, now, retain) {
+  return {
+    ...state,
+    claims: state.claims.filter((claim) => claim.key !== entryKey),
+    receipts: [
+      { key: entryKey, completedAt: now.toISOString() },
+      ...state.receipts.filter((receipt) => receipt.key !== entryKey)
+    ].slice(0, retain)
+  };
+}
+function releaseEntry(state, claim, retryAt) {
+  return {
+    ...state,
+    claims: state.claims.map((candidate) => candidate.key === claim.key && candidate.leaseId === claim.leaseId ? {
+      ...candidate,
+      nextAttemptAt: retryAt.toISOString(),
+      leaseId: null,
+      leaseUntil: null
+    } : candidate)
+  };
+}
+function forgetMissing(state, present, now) {
+  const live = (claim) => claim.leaseUntil !== null && Date.parse(claim.leaseUntil) > now.getTime();
+  return {
+    ...state,
+    claims: state.claims.filter((claim) => present.has(claim.key) || live(claim))
+  };
+}
+
+export { DirectoryInboxRejectionReasonSchema, DirectoryInboxStateSchema, emptyDirectoryInboxState, withRejection, claimEntry, completeEntry, releaseEntry, forgetMissing };

package/dist/index-tm88avnj.js

@@ -0,0 +1,221 @@
+import {
+  isRecord
+} from "./index-hffjpmq9.js";
+
+// src/application/file-state-store.ts
+import { mkdir, open, readdir, readFile, rename, stat, unlink } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+var ABANDONED_LOCK_MULTIPLIER = 10;
+var ABANDONED_HEARTBEATS = 30;
+var MIN_HEARTBEAT_MS = 10;
+var delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+async function missing(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function existing(error) {
+  return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
+async function ownerState(lockPath) {
+  let owner;
+  try {
+    owner = JSON.parse(await readFile(lockPath, "utf8"));
+  } catch {
+    return "unknown";
+  }
+  if (typeof owner !== "object" || owner === null || !("pid" in owner) || typeof owner.pid !== "number" || !Number.isSafeInteger(owner.pid) || owner.pid <= 0) {
+    return "unknown";
+  }
+  try {
+    process.kill(owner.pid, 0);
+    return "alive";
+  } catch (error) {
+    return error instanceof Error && "code" in error && error.code === "ESRCH" ? "gone" : "unknown";
+  }
+}
+async function sweepTemporaries(path, staleLockMs) {
+  const prefix = `${basename(path)}.tmp.`;
+  const directory = dirname(path);
+  let entries;
+  try {
+    entries = await readdir(directory);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.startsWith(prefix))
+      continue;
+    const candidate = join(directory, entry);
+    const info = await stat(candidate).catch(() => null);
+    if (info && Date.now() - info.mtimeMs > staleLockMs) {
+      await unlink(candidate).catch(() => {
+        return;
+      });
+    }
+  }
+}
+async function reclaim(lockPath, observed, staleLockMs, abandonedAfterMs) {
+  const guardPath = `${lockPath}.reclaim`;
+  let guard;
+  try {
+    guard = await open(guardPath, "wx");
+  } catch (error) {
+    if (!existing(error))
+      throw error;
+    const orphan = await stat(guardPath).catch(() => null);
+    if (orphan && Date.now() - orphan.mtimeMs > staleLockMs) {
+      await unlink(guardPath).catch(() => {
+        return;
+      });
+    }
+    return false;
+  }
+  try {
+    const current = await stat(lockPath).catch(() => null);
+    if (!current || current.dev !== observed.dev || current.ino !== observed.ino || current.mtimeMs !== observed.mtimeMs) {
+      return false;
+    }
+    const owner = await ownerState(lockPath);
+    const age = Date.now() - current.mtimeMs;
+    if (owner !== "gone" && age < abandonedAfterMs)
+      return false;
+    await unlink(lockPath);
+    return true;
+  } finally {
+    await guard.close().catch(() => {
+      return;
+    });
+    await unlink(guardPath).catch(() => {
+      return;
+    });
+  }
+}
+function createFileStateStore(path, options) {
+  const lockPath = `${path}.lock`;
+  const lockTimeoutMs = options.lockTimeoutMs ?? 1e4;
+  const staleLockMs = options.staleLockMs ?? 3000;
+  const retryMs = options.retryMs ?? 10;
+  const heartbeatMs = Math.max(MIN_HEARTBEAT_MS, Math.floor(staleLockMs / 3));
+  const abandonedAfterMs = Math.max(staleLockMs * ABANDONED_LOCK_MULTIPLIER, heartbeatMs * ABANDONED_HEARTBEATS);
+  if (staleLockMs >= lockTimeoutMs) {
+    throw new Error(`[stitchkit] createFileStateStore: staleLockMs (${staleLockMs}) must be below lockTimeoutMs (${lockTimeoutMs}), or a crashed holder blocks every update until the timeout`);
+  }
+  let sweptTemporaries = false;
+  const parseFile = async () => {
+    let source;
+    try {
+      source = await readFile(path, "utf8");
+    } catch (error) {
+      if (await missing(error))
+        return null;
+      throw error;
+    }
+    try {
+      return options.schema.parse(JSON.parse(source));
+    } catch (error) {
+      await options.onCorrupt?.({ path, error });
+      if ((options.corrupt ?? "throw") === "empty")
+        return null;
+      throw error;
+    }
+  };
+  const acquire = async () => {
+    await mkdir(dirname(path), { recursive: true });
+    if (!sweptTemporaries) {
+      sweptTemporaries = true;
+      await sweepTemporaries(path, staleLockMs);
+    }
+    const deadline = Date.now() + lockTimeoutMs;
+    while (true) {
+      try {
+        const handle = await open(lockPath, "wx");
+        const token = crypto.randomUUID();
+        try {
+          await handle.writeFile(JSON.stringify({ token, pid: process.pid, acquiredAt: Date.now() }));
+          await handle.sync();
+        } catch (error) {
+          await handle.close().catch(() => {
+            return;
+          });
+          await unlink(lockPath).catch(() => {
+            return;
+          });
+          throw error;
+        }
+        return {
+          refresh: async () => {
+            const now = new Date;
+            await handle.utimes(now, now);
+          },
+          release: async () => {
+            await handle.close();
+            try {
+              const owner = JSON.parse(await readFile(lockPath, "utf8"));
+              if (isRecord(owner) && owner.token === token)
+                await unlink(lockPath);
+            } catch (error) {
+              if (!await missing(error))
+                throw error;
+            }
+          }
+        };
+      } catch (error) {
+        if (!existing(error))
+          throw error;
+        try {
+          const lock = await stat(lockPath);
+          if (Date.now() - lock.mtimeMs > staleLockMs) {
+            if (await reclaim(lockPath, lock, staleLockMs, abandonedAfterMs))
+              continue;
+          }
+        } catch (statError) {
+          if (await missing(statError))
+            continue;
+          throw statError;
+        }
+        if (Date.now() >= deadline) {
+          throw new Error(`[stitchkit] timed out acquiring state lock for ${path}`);
+        }
+        await delay(retryMs);
+      }
+    }
+  };
+  const write = async (state) => {
+    const validated = options.schema.parse(state);
+    const temporary = `${path}.tmp.${process.pid}.${crypto.randomUUID()}`;
+    const handle = await open(temporary, "wx");
+    try {
+      try {
+        await handle.writeFile(`${JSON.stringify(validated)}
+`);
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      await rename(temporary, path);
+    } catch (error) {
+      await unlink(temporary).catch(() => {
+        return;
+      });
+      throw error;
+    }
+  };
+  return {
+    read: parseFile,
+    async update(transition) {
+      const lock = await acquire();
+      const heartbeat = setInterval(() => void lock.refresh().catch(() => {
+        return;
+      }), heartbeatMs);
+      try {
+        const next = await transition(await parseFile());
+        await write(next.state);
+        return next.result;
+      } finally {
+        clearInterval(heartbeat);
+        await lock.release();
+      }
+    }
+  };
+}
+
+export { createFileStateStore };

package/llms/application-directory-inbox.txt

@@ -0,0 +1,9 @@
+# stitchkit/application/directory-inbox — stitchkit docs slice
+
+> Generated from the `docs/` tree by `bun run gen:llms`. The index of all slices is
+> `llms.txt` in this package.
+
+Contains: pointers only
+
+Also read:
+- see `llms/application.txt` for the Managed application kernel guide

package/llms/application.2.txt

@@ -299,6 +299,8 @@ cutovers are covered by the executable
 | `NotificationOutboxItem` / `NotificationOutboxReceipt` / `NotificationOutboxState` / `NotificationSend` / `NotificationFailureClassification` / `DroppedNotification` / `EnqueueNotification` | _type_ | versioned queue records, stable send identity and delivery decisions |
 | `notificationOutboxStateSchema` | function | strict persisted-state schema over an application payload schema |
 | `notificationOutboxResource` / `NotificationOutboxResource` / `NotificationOutboxResourceConfig` | function / _type_ | thin managed-resource scheduler over an outbox handle |
+| `createDirectoryInbox` (from `stitchkit/application/directory-inbox`) / `DirectoryInbox` / `DirectoryInboxConfig` / `DirectoryInboxDelivery` / `DirectoryInboxResource` | function / _type_ | managed resource delivering each `<name>.json` entry another program drops into a directory to the application at least once, after readiness; separate durable taken/done records, leases, bounded retry |
+| `DirectoryInboxStateSchema` / `DirectoryInboxState` / `DirectoryInboxRejection` / `DirectoryInboxRejectionReasonSchema` / `DirectoryInboxRejectionReason` | schema / _type_ | the inbox's claims, receipts and rejections (`invalid`, `too-large`, `attempt-limit`) |
 | `ApplicationHandle.restart` | method | replace one resource and everything that depends on it, leaving the rest of the graph running and the process epoch unchanged |
 | `ApplicationRestartInputSchema` / `ApplicationRestartInput` | schema / _type_ | the resource to replace, by id, and optionally `gracePeriodMs` / `forceTimeoutMs` for this restart — the application's own shutdown budget otherwise |
 | `ApplicationRestartResultSchema` / `ApplicationRestartResult` | schema / _type_ | the subtree that was actually taken down and brought back, in start order, with the outcome, the reason on anything but success, and how long it took |

package/llms/application.txt

@@ -905,7 +905,36 @@ deadline holds `stop()` — and so the resource's `force()` — for that one cal
 so give the transport a timeout. Superseding a key that is being sent right now
 does not recall it: the send completes, and only its receipt is not written.
 
-Both primitives depend on the structural `StateStore`. On a server,
+`createDirectoryInbox` is the receiving side for another program on the same
+host: it drops entries — a release transition, say — into a directory, and
+the application takes each one at least once. It is a managed resource of its
+own (`createDirectoryInbox({ id, directory, schema, handle })`, imported from
+`stitchkit/application/directory-inbox` because it touches files; its types
+and schemas are in `stitchkit/application`) and publishes a handle with
+`flush()` and `state()`. The producer writes each entry
+atomically as `<name>.json` — a temporary name, then a rename; names that start
+with a dot are never read. Entries are delivered in name order, and only after
+`activate`: none reaches the application before it is ready. `stopAdmission`
+stops taking new ones, `drain` waits for the one in flight, and `force` aborts
+the `signal` its handler was given.
+
+Taken and done are separate durable records. Before `handle` runs, the entry
+is claimed with a lease (`leaseMs`, default five minutes); after it returns,
+a receipt replaces the claim and only then is the file removed. A process that
+died mid-delivery leaves a claim, and the entry is taken again once the lease
+runs out — at least once, not exactly once, so a handler that sends somewhere
+should carry the entry's `key` as its idempotency key. A process that died
+after the receipt leaves only the file, which the next pass removes without
+delivering it again. A handler that throws is retried after a backoff from one
+second doubling to five minutes; an entry that fails `schema`, is over
+`maxEntryBytes` or was taken `maxAttempts` times (default 20 — the count
+survives restarts, so an entry whose handling kills the process is not taken
+forever) is moved to `rejected/` with its reason and reported to `onRejected`,
+and the entries after it keep flowing. The state lives in
+`<directory>/.inbox-state.json` under `createFileStateStore`'s inter-process
+lock unless a `store` is supplied.
+
+These primitives depend on the structural `StateStore`. On a server,
 `createFileStateStore` supplies the shared Zod-validated JSON adapter with an
 inter-process lock, unique temporary file, fsync and atomic rename. The lock
 is a file with a heartbeat: the holder refreshes its mtime every third of

package/llms/stitchkit.txt

@@ -95,6 +95,7 @@ own, recorded as an ADR.
 | `stitchkit/application/opentelemetry` | server | evolving | maps application snapshots onto an injected OpenTelemetry `Meter` |
 | `stitchkit/application/schemas` | browser + server | evolving | the application's snapshot, health and shutdown schemas alone, without the kernel |
 | `stitchkit/application/diagnostic-journal` | server | evolving | the local diagnostic journal — the one part of the kernel that spawns, locks and writes files |
+| `stitchkit/application/directory-inbox` | server | evolving | the directory inbox — entries another program drops into a directory, delivered to the application at least once |
 
 Rule of thumb: browser code imports `stitchkit` and `stitchkit/react`; server
 code adds `stitchkit/server` (or `stitchkit/node` on Node) and opts into

package/llms-full.txt

@@ -86,6 +86,7 @@ own, recorded as an ADR.
 | `stitchkit/application/opentelemetry` | server | evolving | maps application snapshots onto an injected OpenTelemetry `Meter` |
 | `stitchkit/application/schemas` | browser + server | evolving | the application's snapshot, health and shutdown schemas alone, without the kernel |
 | `stitchkit/application/diagnostic-journal` | server | evolving | the local diagnostic journal — the one part of the kernel that spawns, locks and writes files |
+| `stitchkit/application/directory-inbox` | server | evolving | the directory inbox — entries another program drops into a directory, delivered to the application at least once |
 
 Rule of thumb: browser code imports `stitchkit` and `stitchkit/react`; server
 code adds `stitchkit/server` (or `stitchkit/node` on Node) and opts into
@@ -7151,7 +7152,36 @@ deadline holds `stop()` — and so the resource's `force()` — for that one cal
 so give the transport a timeout. Superseding a key that is being sent right now
 does not recall it: the send completes, and only its receipt is not written.
 
-Both primitives depend on the structural `StateStore`. On a server,
+`createDirectoryInbox` is the receiving side for another program on the same
+host: it drops entries — a release transition, say — into a directory, and
+the application takes each one at least once. It is a managed resource of its
+own (`createDirectoryInbox({ id, directory, schema, handle })`, imported from
+`stitchkit/application/directory-inbox` because it touches files; its types
+and schemas are in `stitchkit/application`) and publishes a handle with
+`flush()` and `state()`. The producer writes each entry
+atomically as `<name>.json` — a temporary name, then a rename; names that start
+with a dot are never read. Entries are delivered in name order, and only after
+`activate`: none reaches the application before it is ready. `stopAdmission`
+stops taking new ones, `drain` waits for the one in flight, and `force` aborts
+the `signal` its handler was given.
+
+Taken and done are separate durable records. Before `handle` runs, the entry
+is claimed with a lease (`leaseMs`, default five minutes); after it returns,
+a receipt replaces the claim and only then is the file removed. A process that
+died mid-delivery leaves a claim, and the entry is taken again once the lease
+runs out — at least once, not exactly once, so a handler that sends somewhere
+should carry the entry's `key` as its idempotency key. A process that died
+after the receipt leaves only the file, which the next pass removes without
+delivering it again. A handler that throws is retried after a backoff from one
+second doubling to five minutes; an entry that fails `schema`, is over
+`maxEntryBytes` or was taken `maxAttempts` times (default 20 — the count
+survives restarts, so an entry whose handling kills the process is not taken
+forever) is moved to `rejected/` with its reason and reported to `onRejected`,
+and the entries after it keep flowing. The state lives in
+`<directory>/.inbox-state.json` under `createFileStateStore`'s inter-process
+lock unless a `store` is supplied.
+
+These primitives depend on the structural `StateStore`. On a server,
 `createFileStateStore` supplies the shared Zod-validated JSON adapter with an
 inter-process lock, unique temporary file, fsync and atomic rename. The lock
 is a file with a heartbeat: the holder refreshes its mtime every third of
@@ -16978,6 +17008,8 @@ cutovers are covered by the executable
 | `NotificationOutboxItem` / `NotificationOutboxReceipt` / `NotificationOutboxState` / `NotificationSend` / `NotificationFailureClassification` / `DroppedNotification` / `EnqueueNotification` | _type_ | versioned queue records, stable send identity and delivery decisions |
 | `notificationOutboxStateSchema` | function | strict persisted-state schema over an application payload schema |
 | `notificationOutboxResource` / `NotificationOutboxResource` / `NotificationOutboxResourceConfig` | function / _type_ | thin managed-resource scheduler over an outbox handle |
+| `createDirectoryInbox` (from `stitchkit/application/directory-inbox`) / `DirectoryInbox` / `DirectoryInboxConfig` / `DirectoryInboxDelivery` / `DirectoryInboxResource` | function / _type_ | managed resource delivering each `<name>.json` entry another program drops into a directory to the application at least once, after readiness; separate durable taken/done records, leases, bounded retry |
+| `DirectoryInboxStateSchema` / `DirectoryInboxState` / `DirectoryInboxRejection` / `DirectoryInboxRejectionReasonSchema` / `DirectoryInboxRejectionReason` | schema / _type_ | the inbox's claims, receipts and rejections (`invalid`, `too-large`, `attempt-limit`) |
 | `ApplicationHandle.restart` | method | replace one resource and everything that depends on it, leaving the rest of the graph running and the process epoch unchanged |
 | `ApplicationRestartInputSchema` / `ApplicationRestartInput` | schema / _type_ | the resource to replace, by id, and optionally `gracePeriodMs` / `forceTimeoutMs` for this restart — the application's own shutdown budget otherwise |
 | `ApplicationRestartResultSchema` / `ApplicationRestartResult` | schema / _type_ | the subtree that was actually taken down and brought back, in start order, with the outcome, the reason on anything but success, and how long it took |

package/llms.txt

@@ -9,7 +9,7 @@ Build with stitchkit: define a contract once, then `implement` it and serve it (
 Load the slice for each entrypoint your code imports — `import … from 'stitchkit/server'` → `llms/server.txt`; the root `stitchkit` import → `llms/stitchkit.txt`. A slice holds that entrypoint's API reference section and the guide pages whose home it is; every guide lives in exactly one slice, and a slice that needs another's guide names it under "Also read". Each file is at most 50.0 KB; a longer one continues in numbered parts, each naming the next at its top. Moving across versions: load `llms/upgrading.txt` and the range slices it lists between your version and the target. `llms-full.txt` inlines everything; it is far larger than a context window, so do not read it whole.
 
 ## Entrypoint slices
-- **stitchkit**: [llms/stitchkit.txt](llms/stitchkit.txt) 15.1 KB → [llms/stitchkit.2.txt](llms/stitchkit.2.txt) 35.0 KB → [llms/stitchkit.3.txt](llms/stitchkit.3.txt) 14.2 KB
+- **stitchkit**: [llms/stitchkit.txt](llms/stitchkit.txt) 15.3 KB → [llms/stitchkit.2.txt](llms/stitchkit.2.txt) 35.0 KB → [llms/stitchkit.3.txt](llms/stitchkit.3.txt) 14.2 KB
 - **stitchkit/live**: [llms/live.txt](llms/live.txt) 21.2 KB
 - **stitchkit/react**: [llms/react.txt](llms/react.txt) 8.6 KB
 - **stitchkit/tools**: [llms/tools.txt](llms/tools.txt) 44.9 KB → [llms/tools.2.txt](llms/tools.2.txt) 26.3 KB → [llms/tools.3.txt](llms/tools.3.txt) 25.4 KB
@@ -30,9 +30,10 @@ Load the slice for each entrypoint your code imports — `import … from 'stitc
 - **stitchkit/agent-runtime/openrouter**: [llms/agent-runtime-openrouter.txt](llms/agent-runtime-openrouter.txt) 1.1 KB
 - **stitchkit/agent-runtime/sqlite/bun**: [llms/agent-runtime-sqlite-bun.txt](llms/agent-runtime-sqlite-bun.txt) 1.8 KB
 - **stitchkit/agent-runtime/sqlite/node**: [llms/agent-runtime-sqlite-node.txt](llms/agent-runtime-sqlite-node.txt) 1.7 KB
-- **stitchkit/application**: [llms/application.txt](llms/application.txt) 40.1 KB → [llms/application.2.txt](llms/application.2.txt) 31.9 KB
+- **stitchkit/application**: [llms/application.txt](llms/application.txt) 42.1 KB → [llms/application.2.txt](llms/application.2.txt) 32.6 KB
 - **stitchkit/application/grammy**: [llms/application-grammy.txt](llms/application-grammy.txt) 1.5 KB
 - **stitchkit/application/opentelemetry**: [llms/application-opentelemetry.txt](llms/application-opentelemetry.txt) 1.6 KB
+- **stitchkit/application/directory-inbox**: [llms/application-directory-inbox.txt](llms/application-directory-inbox.txt) 0.3 KB
 - **stitchkit/application/diagnostic-journal**: [llms/application-diagnostic-journal.txt](llms/application-diagnostic-journal.txt) 1.4 KB
 - **stitchkit/application/schemas**: [llms/application-schemas.txt](llms/application-schemas.txt) 1.8 KB
 - **stitchkit/testing**: [llms/testing.txt](llms/testing.txt) 30.8 KB

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stitchkit",
-  "version": "0.95.0",
+  "version": "0.95.1",
   "description": "Contract-first backend framework — one defineContract() into an HTTP API, MCP tools, AI-agent tools and a typed client. Bun and Node.",
   "keywords": [
     "bun",
@@ -146,6 +146,10 @@
       "types": "./dist/entrypoints/application/opentelemetry.d.ts",
       "import": "./dist/entrypoints/application/opentelemetry.js"
     },
+    "./application/directory-inbox": {
+      "types": "./dist/entrypoints/application/directory-inbox.d.ts",
+      "import": "./dist/entrypoints/application/directory-inbox.js"
+    },
     "./application/diagnostic-journal": {
       "types": "./dist/entrypoints/application/diagnostic-journal.d.ts",
       "import": "./dist/entrypoints/application/diagnostic-journal.js"