@fougere/workflow 0.11.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fougere contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/Later.d.ts

@@ -0,0 +1,24 @@
+declare const Later_base: import("@fougere/schema").SchemaConstructor<{
+    id: import("@fougere/schema").Field<string>;
+    /** The address, flat, so a due row is found without reading what it carries. */
+    entity: import("@fougere/schema").Field<string>;
+    operation: import("@fougere/schema").Field<string>;
+    /** What the caller supplied — params, query, input, identity. `runAt` is dropped on the way out. */
+    invocation: import("@fougere/schema").Field<unknown>;
+    runAt: import("@fougere/schema").Field<number>;
+    takenUntil: import("@fougere/schema").Field<number | null>;
+}>;
+/**
+ * A call that has not happened yet, and who is making it happen.
+ *
+ * Distinct from `Run`, which says a release BEGAN and can be redone: this one never began, so
+ * it goes out exactly once, and a taker holds it for a bounded time rather than locking it —
+ * the same answer `RunRepository` gives, for the same reason a process cannot tell a dead peer
+ * from a slow one.
+ *
+ * Documented: [entities](https://fougere.dev/docs/schema/entities).
+ */
+export default class Later extends Later_base {
+}
+export {};
+//# sourceMappingURL=Later.d.ts.map

package/dist/Later.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Later.d.ts","sourceRoot":"","sources":["../src/Later.ts"],"names":[],"mappings":";;IAcE,gFAAgF;;;IAGhF,oGAAoG;;;;;AAftG;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,KAAM,SAAQ,UASjC;CAAG"}

package/dist/Later.js

@@ -0,0 +1,23 @@
+import { entity, json, number, optional, primary, text } from '@fougere/schema';
+/**
+ * A call that has not happened yet, and who is making it happen.
+ *
+ * Distinct from `Run`, which says a release BEGAN and can be redone: this one never began, so
+ * it goes out exactly once, and a taker holds it for a bounded time rather than locking it —
+ * the same answer `RunRepository` gives, for the same reason a process cannot tell a dead peer
+ * from a slow one.
+ *
+ * Documented: [entities](https://fougere.dev/docs/schema/entities).
+ */
+export default class Later extends entity({
+    id: primary(text()),
+    /** The address, flat, so a due row is found without reading what it carries. */
+    entity: text(),
+    operation: text(),
+    /** What the caller supplied — params, query, input, identity. `runAt` is dropped on the way out. */
+    invocation: json(),
+    runAt: number({ integer: true }),
+    takenUntil: optional(number({ integer: true })),
+}) {
+}
+//# sourceMappingURL=Later.js.map

package/dist/Later.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Later.js","sourceRoot":"","sources":["../src/Later.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEhF;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,KAAM,SAAQ,MAAM,CAAC;IACxC,EAAE,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC;IACnB,gFAAgF;IAChF,MAAM,EAAE,IAAI,EAAE;IACd,SAAS,EAAE,IAAI,EAAE;IACjB,oGAAoG;IACpG,UAAU,EAAE,IAAI,EAAE;IAClB,KAAK,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAChC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;CAChD,CAAC;CAAG"}

package/dist/LaterRepository.d.ts

@@ -0,0 +1,29 @@
+import { Call, type Storage } from '@fougere/core';
+import Later from './Later.js';
+declare const LaterRepository_base: import("@fougere/core").RepositoryConstructor<Later>;
+/**
+ * The calls waiting for their hour, and the take that says one process is making them.
+ *
+ * The take is bounded like `RunRepository`'s lease and for the same reason, but it guards the
+ * opposite case: a release may be redone, a call may not, so what is bounded here is how long
+ * a taker is believed rather than how long a driver is assumed alive.
+ */
+export default class LaterRepository extends LaterRepository_base {
+    private now;
+    constructor(storage: Storage<Later>, now?: () => number);
+    keep(call: Call, runAt: number): Promise<void>;
+    /**
+     * The calls whose hour has passed and whom nobody is making right now.
+     *
+     * Read whole and filtered here, which bounds what this package holds: a source that answers
+     * `where` on two numbers would answer it at the rows, and that is the next thing to ask for.
+     */
+    due(): Promise<Later[]>;
+    /** Hold this one, or say another process already has it — the read and the write are two. */
+    take(id: string): Promise<'taken' | 'busy'>;
+    done(id: string): Promise<void>;
+    /** Rebuilds what was kept — the address flat, the invocation whole. */
+    callOf(row: Later): Call;
+}
+export {};
+//# sourceMappingURL=LaterRepository.d.ts.map

package/dist/LaterRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LaterRepository.d.ts","sourceRoot":"","sources":["../src/LaterRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAA4B,KAAK,OAAO,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,KAAK,MAAM,YAAY,CAAC;;AAK/B;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,oBAAiB;IACvB,OAAO,CAAC,GAAG;IAAhD,YAAY,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,EAAU,GAAG,GAAE,MAAM,MAAiB,EAExE;IAEK,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CASnD;IAED;;;;;OAKG;IACG,GAAG,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC,CAK5B;IAED,6FAA6F;IACvF,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,MAAM,CAAC,CAQhD;IAEK,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpC;IAED,uEAAuE;IACvE,MAAM,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,CAKvB;CACF"}

package/dist/LaterRepository.js

@@ -0,0 +1,57 @@
+import { Call, Repository, RouteAddress } from '@fougere/core';
+import Later from './Later.js';
+/** How long a taker holds a due call before anyone may take it over. */
+const TAKE_MS = 30_000;
+/**
+ * The calls waiting for their hour, and the take that says one process is making them.
+ *
+ * The take is bounded like `RunRepository`'s lease and for the same reason, but it guards the
+ * opposite case: a release may be redone, a call may not, so what is bounded here is how long
+ * a taker is believed rather than how long a driver is assumed alive.
+ */
+export default class LaterRepository extends Repository(Later) {
+    now;
+    constructor(storage, now = Date.now) {
+        super(storage);
+        this.now = now;
+    }
+    async keep(call, runAt) {
+        const { runAt: _dropped, ...invocation } = call.invocation;
+        await this.create({
+            id: crypto.randomUUID(),
+            entity: call.address.entity,
+            operation: call.address.operation,
+            invocation,
+            runAt,
+        });
+    }
+    /**
+     * The calls whose hour has passed and whom nobody is making right now.
+     *
+     * Read whole and filtered here, which bounds what this package holds: a source that answers
+     * `where` on two numbers would answer it at the rows, and that is the next thing to ask for.
+     */
+    async due() {
+        const rows = await this.list();
+        const now = this.now();
+        return rows.filter((row) => row.runAt <= now && (row.takenUntil ?? 0) <= now);
+    }
+    /** Hold this one, or say another process already has it — the read and the write are two. */
+    async take(id) {
+        const held = await this.findById(id);
+        if (!held)
+            return 'busy';
+        if ((held.takenUntil ?? 0) > this.now())
+            return 'busy';
+        await this.update(id, { takenUntil: this.now() + TAKE_MS });
+        return 'taken';
+    }
+    async done(id) {
+        await this.delete(id);
+    }
+    /** Rebuilds what was kept — the address flat, the invocation whole. */
+    callOf(row) {
+        return new Call(new RouteAddress({ entity: row.entity, operation: row.operation }), row.invocation);
+    }
+}
+//# sourceMappingURL=LaterRepository.js.map

package/dist/LaterRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LaterRepository.js","sourceRoot":"","sources":["../src/LaterRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,YAAY,EAAgB,MAAM,eAAe,CAAC;AAC7E,OAAO,KAAK,MAAM,YAAY,CAAC;AAE/B,wEAAwE;AACxE,MAAM,OAAO,GAAG,MAAM,CAAC;AAEvB;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,UAAU,CAAC,KAAK,CAAC;IACf,GAAG;IAAhD,YAAY,OAAuB,EAAU,GAAG,GAAiB,IAAI,CAAC,GAAG;QACvE,KAAK,CAAC,OAAO,CAAC,CAAC;mBAD4B,GAAG;IAEhD,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,IAAU,EAAE,KAAa;QAClC,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,UAAU,EAAE,GAAG,IAAI,CAAC,UAAU,CAAC;QAC3D,MAAM,IAAI,CAAC,MAAM,CAAC;YAChB,EAAE,EAAE,MAAM,CAAC,UAAU,EAAE;YACvB,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM;YAC3B,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS;YACjC,UAAU;YACV,KAAK;SACN,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,GAAG;QACP,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;QAC/B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAEvB,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,KAAK,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,IAAI,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC;IAChF,CAAC;IAED,6FAA6F;IAC7F,KAAK,CAAC,IAAI,CAAC,EAAU;QACnB,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QACrC,IAAI,CAAC,IAAI;YAAE,OAAO,MAAM,CAAC;QACzB,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE;YAAE,OAAO,MAAM,CAAC;QAEvD,MAAM,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;QAE5D,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,EAAU;QACnB,MAAM,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACxB,CAAC;IAED,uEAAuE;IACvE,MAAM,CAAC,GAAU;QACf,OAAO,IAAI,IAAI,CACb,IAAI,YAAY,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC,EAClE,GAAG,CAAC,UAAqC,CAC1C,CAAC;IACJ,CAAC;CACF"}

package/dist/Run.d.ts

@@ -0,0 +1,25 @@
+declare const Run_base: import("@fougere/schema").SchemaConstructor<{
+    /** `user:ada` — derived from what is released, so relaunching is the same run, not a second. */
+    id: import("@fougere/schema").Field<string>;
+    entity: import("@fougere/schema").Field<string>;
+    key: import("@fougere/schema").Field<string>;
+    status: import("@fougere/schema").Field<"done" | "running">;
+    /** Who is driving, and until when. An expired lease is what a sweep claims. */
+    leaseOwner: import("@fougere/schema").Field<string>;
+    leaseUntil: import("@fougere/schema").Field<number>;
+    finishedAt: import("@fougere/schema").Field<number | null>;
+}>;
+/**
+ * A release that is under way, and who is driving it.
+ *
+ * There is no plan here and no position, because a release needs neither: every hop it makes
+ * is already idempotent — a row taken out twice is taken out once, a field emptied twice is
+ * empty — so RESUMING is simply doing it again. What the row has to say is that somebody
+ * started and did not finish.
+ *
+ * Documented: [entities](https://fougere.dev/docs/schema/entities).
+ */
+export default class Run extends Run_base {
+}
+export {};
+//# sourceMappingURL=Run.d.ts.map

package/dist/Run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Run.d.ts","sourceRoot":"","sources":["../src/Run.ts"],"names":[],"mappings":";IAaE,gGAAgG;;;;;IAKhG,+EAA+E;;;;;AAhBjF;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,GAAI,SAAQ,QAU/B;CAAG"}

package/dist/Run.js

@@ -0,0 +1,24 @@
+import { entity, number, oneOf, optional, primary, text } from '@fougere/schema';
+/**
+ * A release that is under way, and who is driving it.
+ *
+ * There is no plan here and no position, because a release needs neither: every hop it makes
+ * is already idempotent — a row taken out twice is taken out once, a field emptied twice is
+ * empty — so RESUMING is simply doing it again. What the row has to say is that somebody
+ * started and did not finish.
+ *
+ * Documented: [entities](https://fougere.dev/docs/schema/entities).
+ */
+export default class Run extends entity({
+    /** `user:ada` — derived from what is released, so relaunching is the same run, not a second. */
+    id: primary(text()),
+    entity: text(),
+    key: text(),
+    status: oneOf('running', 'done', { default: 'running' }),
+    /** Who is driving, and until when. An expired lease is what a sweep claims. */
+    leaseOwner: text(),
+    leaseUntil: number({ integer: true }),
+    finishedAt: optional(number({ integer: true })),
+}) {
+}
+//# sourceMappingURL=Run.js.map

package/dist/Run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Run.js","sourceRoot":"","sources":["../src/Run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEjF;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,GAAI,SAAQ,MAAM,CAAC;IACtC,gGAAgG;IAChG,EAAE,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC;IACnB,MAAM,EAAE,IAAI,EAAE;IACd,GAAG,EAAE,IAAI,EAAE;IACX,MAAM,EAAE,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;IACxD,+EAA+E;IAC/E,UAAU,EAAE,IAAI,EAAE;IAClB,UAAU,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IACrC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;CAChD,CAAC;CAAG"}

package/dist/RunHandler.d.ts

@@ -0,0 +1,18 @@
+import { type Releasing } from '@fougere/core';
+import RunRepository from './RunRepository.js';
+/** Finish what a stopped process started. */
+export default class RunHandler {
+    private runs;
+    private releasing;
+    constructor(runs: RunRepository, releasing: Releasing);
+    /**
+     * Redo every release whose driver stopped saying it was alive.
+     *
+     * An operation, so the CLI, an HTTP route and a cron all reach it the same way — a durable
+     * engine ships one host adapter per platform to get this far.
+     */
+    sweep(): Promise<{
+        resumed: string[];
+    }>;
+}
+//# sourceMappingURL=RunHandler.d.ts.map

package/dist/RunHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunHandler.d.ts","sourceRoot":"","sources":["../src/RunHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,aAAa,MAAM,oBAAoB,CAAC;AAG/C,6CAA6C;AAC7C,MAAM,CAAC,OAAO,OAAO,UAAU;IACjB,OAAO,CAAC,IAAI;IAAiB,OAAO,CAAC,SAAS;IAA1D,YAAoB,IAAI,EAAE,aAAa,EAAU,SAAS,EAAE,SAAS,EAAI;IAEzE;;;;;OAKG;IACG,KAAK,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAY5C;CACF"}

package/dist/RunHandler.js

@@ -0,0 +1,30 @@
+import { release } from '@fougere/core';
+import { DRIVER } from './RunJournal.js';
+/** Finish what a stopped process started. */
+export default class RunHandler {
+    runs;
+    releasing;
+    constructor(runs, releasing) {
+        this.runs = runs;
+        this.releasing = releasing;
+    }
+    /**
+     * Redo every release whose driver stopped saying it was alive.
+     *
+     * An operation, so the CLI, an HTTP route and a cron all reach it the same way — a durable
+     * engine ships one host adapter per platform to get this far.
+     */
+    async sweep() {
+        const resumed = [];
+        for (const run of await this.runs.abandoned()) {
+            if (await this.runs.open(run.entity, run.key, DRIVER) === 'busy')
+                continue;
+            // The row too: a release interrupted before it reached the row is not finished.
+            await release(run.entity, run.key, this.releasing, [], async () => this.releasing.rowsOf(run.entity)?.delete(run.key));
+            await this.runs.close(run.entity, run.key);
+            resumed.push(run.id);
+        }
+        return { resumed };
+    }
+}
+//# sourceMappingURL=RunHandler.js.map

package/dist/RunHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunHandler.js","sourceRoot":"","sources":["../src/RunHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAkB,MAAM,eAAe,CAAC;AAExD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,6CAA6C;AAC7C,MAAM,CAAC,OAAO,OAAO,UAAU;IACT,IAAI;IAAyB,SAAS;IAA1D,YAAoB,IAAmB,EAAU,SAAoB;oBAAjD,IAAI;yBAAyB,SAAS;IAAc,CAAC;IAEzE;;;;;OAKG;IACH,KAAK,CAAC,KAAK;QACT,MAAM,OAAO,GAAa,EAAE,CAAC;QAC7B,KAAK,MAAM,GAAG,IAAI,MAAM,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YAC9C,IAAI,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,MAAM;gBAAE,SAAS;YAC3E,gFAAgF;YAChF,MAAM,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,EAAE,EAAE,EACnD,KAAK,IAAI,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;YAClE,MAAM,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;YAC3C,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACvB,CAAC;QAED,OAAO,EAAE,OAAO,EAAE,CAAC;IACrB,CAAC;CACF"}

package/dist/RunJournal.d.ts

@@ -0,0 +1,21 @@
+import { JOURNAL, type Call, type Journal } from '@fougere/core';
+import LaterRepository from './LaterRepository.js';
+import RunRepository from './RunRepository.js';
+export { JOURNAL };
+/**
+ * The journal core asks for, answered by a row.
+ *
+ * Registered under core's own key, which is how an optional package answers a reading core
+ * declares — the same shape a source takes when it says what it keeps at the rows.
+ */
+export default class RunJournal implements Journal {
+    private runs;
+    private later;
+    constructor(runs: RunRepository, later: LaterRepository);
+    keep(call: Call, runAt: number): Promise<void>;
+    open(entity: string, key: string): Promise<'taken' | 'busy'>;
+    close(entity: string, key: string): Promise<void>;
+}
+/** What this process calls itself while it drives a run — enough to tell it from another. */
+export declare const DRIVER: string;
+//# sourceMappingURL=RunJournal.d.ts.map

package/dist/RunJournal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunJournal.d.ts","sourceRoot":"","sources":["../src/RunJournal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,OAAO,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,eAAe,MAAM,sBAAsB,CAAC;AACnD,OAAO,aAAa,MAAM,oBAAoB,CAAC;AAE/C,OAAO,EAAE,OAAO,EAAE,CAAC;AAEnB;;;;;GAKG;AACH,MAAM,CAAC,OAAO,OAAO,UAAW,YAAW,OAAO;IACpC,OAAO,CAAC,IAAI;IAAiB,OAAO,CAAC,KAAK;IAAtD,YAAoB,IAAI,EAAE,aAAa,EAAU,KAAK,EAAE,eAAe,EAAI;IAE3E,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE7C;IAED,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,MAAM,CAAC,CAE3D;IAED,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEhD;CACF;AAED,6FAA6F;AAC7F,eAAO,MAAM,MAAM,QAAmB,CAAC"}

package/dist/RunJournal.js

@@ -0,0 +1,28 @@
+import { JOURNAL } from '@fougere/core';
+export { JOURNAL };
+/**
+ * The journal core asks for, answered by a row.
+ *
+ * Registered under core's own key, which is how an optional package answers a reading core
+ * declares — the same shape a source takes when it says what it keeps at the rows.
+ */
+export default class RunJournal {
+    runs;
+    later;
+    constructor(runs, later) {
+        this.runs = runs;
+        this.later = later;
+    }
+    keep(call, runAt) {
+        return this.later.keep(call, runAt);
+    }
+    open(entity, key) {
+        return this.runs.open(entity, key, DRIVER);
+    }
+    close(entity, key) {
+        return this.runs.close(entity, key);
+    }
+}
+/** What this process calls itself while it drives a run — enough to tell it from another. */
+export const DRIVER = `${process.pid}`;
+//# sourceMappingURL=RunJournal.js.map

package/dist/RunJournal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunJournal.js","sourceRoot":"","sources":["../src/RunJournal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAA2B,MAAM,eAAe,CAAC;AAIjE,OAAO,EAAE,OAAO,EAAE,CAAC;AAEnB;;;;;GAKG;AACH,MAAM,CAAC,OAAO,OAAO,UAAU;IACT,IAAI;IAAyB,KAAK;IAAtD,YAAoB,IAAmB,EAAU,KAAsB;oBAAnD,IAAI;qBAAyB,KAAK;IAAoB,CAAC;IAE3E,IAAI,CAAC,IAAU,EAAE,KAAa;QAC5B,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACtC,CAAC;IAED,IAAI,CAAC,MAAc,EAAE,GAAW;QAC9B,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;IAC7C,CAAC;IAED,KAAK,CAAC,MAAc,EAAE,GAAW;QAC/B,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACtC,CAAC;CACF;AAED,6FAA6F;AAC7F,MAAM,CAAC,MAAM,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC"}

package/dist/RunRepository.d.ts

@@ -0,0 +1,21 @@
+import { type Storage } from '@fougere/core';
+import Run from './Run.js';
+declare const RunRepository_base: import("@fougere/core").RepositoryConstructor<Run>;
+/**
+ * The runs, and the lease that says one process is driving.
+ *
+ * A lease is time-bounded on purpose: no process can tell whether another is dead or slow, so
+ * the question is never asked. What is bounded instead is how long an answer is assumed, and
+ * two drivers at once stay harmless because every hop can be done twice.
+ */
+export default class RunRepository extends RunRepository_base {
+    private now;
+    constructor(storage: Storage<Run>, now?: () => number);
+    /** Take this release on, or say it is already someone's — the same row either way. */
+    open(entity: string, key: string, owner: string): Promise<'taken' | 'busy'>;
+    close(entity: string, key: string): Promise<void>;
+    /** Runs whose driver stopped saying it was alive — what a sweep has to finish. */
+    abandoned(): Promise<Run[]>;
+}
+export {};
+//# sourceMappingURL=RunRepository.d.ts.map

package/dist/RunRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunRepository.d.ts","sourceRoot":"","sources":["../src/RunRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,OAAO,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,GAAG,MAAM,UAAU,CAAC;;AAK3B;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,kBAAe;IACrB,OAAO,CAAC,GAAG;IAA9C,YAAY,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,EAAU,GAAG,GAAE,MAAM,MAAiB,EAEtE;IAED,sFAAsF;IAChF,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,MAAM,CAAC,CAehF;IAEK,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAEtD;IAED,kFAAkF;IAC5E,SAAS,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC,CAIhC;CACF"}

package/dist/RunRepository.js

@@ -0,0 +1,41 @@
+import { Repository } from '@fougere/core';
+import Run from './Run.js';
+/** How long a driver holds a run before anyone may take it over. */
+const LEASE_MS = 30_000;
+/**
+ * The runs, and the lease that says one process is driving.
+ *
+ * A lease is time-bounded on purpose: no process can tell whether another is dead or slow, so
+ * the question is never asked. What is bounded instead is how long an answer is assumed, and
+ * two drivers at once stay harmless because every hop can be done twice.
+ */
+export default class RunRepository extends Repository(Run) {
+    now;
+    constructor(storage, now = Date.now) {
+        super(storage);
+        this.now = now;
+    }
+    /** Take this release on, or say it is already someone's — the same row either way. */
+    async open(entity, key, owner) {
+        const id = `${entity}:${String(key)}`;
+        const held = await this.findById(id);
+        const until = this.now() + LEASE_MS;
+        if (!held) {
+            await this.create({ id, entity, key: String(key), status: 'running', leaseOwner: owner, leaseUntil: until });
+            return 'taken';
+        }
+        if (held.status === 'running' && held.leaseUntil > this.now() && held.leaseOwner !== owner)
+            return 'busy';
+        await this.update(id, { status: 'running', leaseOwner: owner, leaseUntil: until, finishedAt: null });
+        return 'taken';
+    }
+    async close(entity, key) {
+        await this.update(`${entity}:${String(key)}`, { status: 'done', finishedAt: this.now() });
+    }
+    /** Runs whose driver stopped saying it was alive — what a sweep has to finish. */
+    async abandoned() {
+        const running = await this.findAllBy({ status: 'running' });
+        return running.filter((run) => run.leaseUntil <= this.now());
+    }
+}
+//# sourceMappingURL=RunRepository.js.map

package/dist/RunRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunRepository.js","sourceRoot":"","sources":["../src/RunRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAgB,MAAM,eAAe,CAAC;AACzD,OAAO,GAAG,MAAM,UAAU,CAAC;AAE3B,oEAAoE;AACpE,MAAM,QAAQ,GAAG,MAAM,CAAC;AAExB;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,UAAU,CAAC,GAAG,CAAC;IACb,GAAG;IAA9C,YAAY,OAAqB,EAAU,GAAG,GAAiB,IAAI,CAAC,GAAG;QACrE,KAAK,CAAC,OAAO,CAAC,CAAC;mBAD0B,GAAG;IAE9C,CAAC;IAED,sFAAsF;IACtF,KAAK,CAAC,IAAI,CAAC,MAAc,EAAE,GAAW,EAAE,KAAa;QACnD,MAAM,EAAE,GAAG,GAAG,MAAM,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QACrC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,QAAQ,CAAC;QAEpC,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,MAAM,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;YAE7G,OAAO,OAAO,CAAC;QACjB,CAAC;QACD,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,IAAI,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,UAAU,KAAK,KAAK;YAAE,OAAO,MAAM,CAAC;QAE1G,MAAM,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;QAErG,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,MAAc,EAAE,GAAW;QACrC,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,MAAM,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;IAC5F,CAAC;IAED,kFAAkF;IAClF,KAAK,CAAC,SAAS;QACb,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;QAE5D,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,UAAU,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IAC/D,CAAC;CACF"}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { releasing, type Extension } from '@fougere/core';
+export { default as Later } from './Later.js';
+export { default as LaterRepository } from './LaterRepository.js';
+export { default as Run } from './Run.js';
+export { default as RunRepository } from './RunRepository.js';
+export { default as RunJournal } from './RunJournal.js';
+export { default as RunHandler } from './RunHandler.js';
+export interface WorkflowOptions {
+    /** Milliseconds between sweeps. `0` never sweeps — a test drives `sweep()` itself. */
+    sweepMs?: number;
+}
+export declare function workflow({ sweepMs }?: WorkflowOptions): Extension;
+export { releasing };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAwB,SAAS,EAA0B,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAQxG,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,OAAO,IAAI,GAAG,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAKxD,MAAM,WAAW,eAAe;IAC9B,sFAAsF;IACtF,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,QAAQ,CAAC,EAAE,OAAkB,EAAE,GAAE,eAAoB,GAAG,SAAS,CAiDhF;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,66 @@
+import { Call, frond, JOURNAL, releasing, RouteAddress } from '@fougere/core';
+import Later from './Later.js';
+import LaterRepository from './LaterRepository.js';
+import Run from './Run.js';
+import RunRepository from './RunRepository.js';
+import RunJournal from './RunJournal.js';
+import RunHandler from './RunHandler.js';
+export { default as Later } from './Later.js';
+export { default as LaterRepository } from './LaterRepository.js';
+export { default as Run } from './Run.js';
+export { default as RunRepository } from './RunRepository.js';
+export { default as RunJournal } from './RunJournal.js';
+export { default as RunHandler } from './RunHandler.js';
+/** How often a process looks for a run somebody stopped driving. */
+const SWEEP_MS = 10_000;
+export function workflow({ sweepMs = SWEEP_MS } = {}) {
+    let beat;
+    return {
+        name: 'workflow',
+        fronds: [frond('workflow', {
+                entities: [Run, Later],
+                providers: [
+                    { ctor: RunRepository, deps: ['RunStorage'] },
+                    { ctor: LaterRepository, deps: ['LaterStorage'] },
+                    // Under core's own key, which is how an optional package answers a reading core declares.
+                    { ctor: RunJournal, deps: ['RunRepository', 'LaterRepository'], name: JOURNAL },
+                ],
+                // Stated, because a published package is not scanned: nothing reads this handler's
+                // source at boot, so what it answers is written here.
+                handlers: [{
+                        ctor: RunHandler,
+                        deps: ['RunRepository', 'Releasing'],
+                        operations: { sweep: { binding: [] } },
+                    }],
+                // `sweep` leads with no verb core knows, and it is the word the subject uses — so the
+                // kind is stated rather than the operation renamed.
+                operationsOverrides: { sweep: { kind: 'command', binding: [] } },
+            })],
+        up: (app) => {
+            if (sweepMs <= 0)
+                return;
+            const scope = app.container.resolve('frond:workflow');
+            const later = scope.resolve('LaterRepository');
+            /**
+             * A kept call goes out from HERE and not from an operation, because making it is a
+             * dispatch: an op that dispatched the due ones would answer for calls it only started.
+             */
+            const beatOnce = async () => {
+                await app.dispatch(new Call(new RouteAddress({ entity: 'run', operation: 'sweep' })))
+                    .catch(() => undefined);
+                for (const row of await later.due()) {
+                    if (await later.take(row.id) === 'busy')
+                        continue;
+                    // Taken and not yet done: a call that throws is left for the take to expire.
+                    await app.dispatch(later.callOf(row)).then(() => later.done(row.id), () => undefined);
+                }
+            };
+            beat = setInterval(() => { void beatOnce().catch(() => undefined); }, sweepMs);
+            beat.unref?.();
+        },
+        down: () => { if (beat)
+            clearInterval(beat); },
+    };
+}
+export { releasing };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,YAAY,EAA4B,MAAM,eAAe,CAAC;AACxG,OAAO,KAAK,MAAM,YAAY,CAAC;AAC/B,OAAO,eAAe,MAAM,sBAAsB,CAAC;AACnD,OAAO,GAAG,MAAM,UAAU,CAAC;AAC3B,OAAO,aAAa,MAAM,oBAAoB,CAAC;AAC/C,OAAO,UAAU,MAAM,iBAAiB,CAAC;AACzC,OAAO,UAAU,MAAM,iBAAiB,CAAC;AAEzC,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAClE,OAAO,EAAE,OAAO,IAAI,GAAG,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAExD,oEAAoE;AACpE,MAAM,QAAQ,GAAG,MAAM,CAAC;AAOxB,MAAM,UAAU,QAAQ,CAAC,EAAE,OAAO,GAAG,QAAQ,EAAE,GAAoB,EAAE;IACnE,IAAI,IAAgD,CAAC;IAErD,OAAO;QACL,IAAI,EAAE,UAAU;QAChB,MAAM,EAAE,CAAC,KAAK,CAAC,UAAU,EAAE;gBACzB,QAAQ,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC;gBACtB,SAAS,EAAE;oBACT,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,YAAY,CAAC,EAAE;oBAC7C,EAAE,IAAI,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,cAAc,CAAC,EAAE;oBACjD,0FAA0F;oBAC1F,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,eAAe,EAAE,iBAAiB,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE;iBAChF;gBACD,mFAAmF;gBACnF,sDAAsD;gBACtD,QAAQ,EAAE,CAAC;wBACT,IAAI,EAAE,UAAU;wBAChB,IAAI,EAAE,CAAC,eAAe,EAAE,WAAW,CAAC;wBACpC,UAAU,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE;qBACvC,CAAC;gBACF,sFAAsF;gBACtF,oDAAoD;gBACpD,mBAAmB,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE;aACjE,CAAC,CAAC;QACH,EAAE,EAAE,CAAC,GAAQ,EAAE,EAAE;YACf,IAAI,OAAO,IAAI,CAAC;gBAAE,OAAO;YACzB,MAAM,KAAK,GAAG,GAAG,CAAC,SAAS,CAAC,OAAO,CAAY,gBAAgB,CAAC,CAAC;YACjE,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAkB,iBAAiB,CAAC,CAAC;YAEhE;;;eAGG;YACH,MAAM,QAAQ,GAAG,KAAK,IAAI,EAAE;gBAC1B,MAAM,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,CAAC,IAAI,YAAY,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;qBAClF,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;gBAE1B,KAAK,MAAM,GAAG,IAAI,MAAM,KAAK,CAAC,GAAG,EAAE,EAAE,CAAC;oBACpC,IAAI,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,MAAM;wBAAE,SAAS;oBAClD,6EAA6E;oBAC7E,MAAM,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;gBACxF,CAAC;YACH,CAAC,CAAC;YAEF,IAAI,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,KAAK,QAAQ,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;YAC/E,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC;QACjB,CAAC;QACD,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,IAAI;YAAE,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;KAC/C,CAAC;AACJ,CAAC;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@fougere/workflow",
+  "version": "0.11.0-alpha.0",
+  "description": "A release that goes to the end: the journal is three entities, the sweep is an operation, and a shared journal is one line of remotes:.",
+  "keywords": [
+    "fougere",
+    "typescript",
+    "durable",
+    "workflow"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chok/fougere.git",
+    "directory": "packages/workflow"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "peerDependencies": {
+    "@fougere/core": "^0.11.0-alpha.0",
+    "@fougere/schema": "^0.11.0-alpha.0"
+  },
+  "devDependencies": {
+    "vitest": "^4.1.0",
+    "@fougere/core": "0.11.0-alpha.0",
+    "@fougere/adapter-sql": "0.11.0-alpha.0",
+    "@fougere/schema": "0.11.0-alpha.0",
+    "@fougere/defaults": "0.11.0-alpha.0",
+    "@fougere/container": "0.11.0-alpha.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit -p tsconfig.test.json"
+  }
+}

package/src/Later.ts

@@ -0,0 +1,22 @@
+import { entity, json, number, optional, primary, text } from '@fougere/schema';
+
+/**
+ * A call that has not happened yet, and who is making it happen.
+ *
+ * Distinct from `Run`, which says a release BEGAN and can be redone: this one never began, so
+ * it goes out exactly once, and a taker holds it for a bounded time rather than locking it —
+ * the same answer `RunRepository` gives, for the same reason a process cannot tell a dead peer
+ * from a slow one.
+ *
+ * Documented: [entities](https://fougere.dev/docs/schema/entities).
+ */
+export default class Later extends entity({
+  id: primary(text()),
+  /** The address, flat, so a due row is found without reading what it carries. */
+  entity: text(),
+  operation: text(),
+  /** What the caller supplied — params, query, input, identity. `runAt` is dropped on the way out. */
+  invocation: json(),
+  runAt: number({ integer: true }),
+  takenUntil: optional(number({ integer: true })),
+}) {}

package/src/LaterRepository.ts

@@ -0,0 +1,65 @@
+import { Call, Repository, RouteAddress, type Storage } from '@fougere/core';
+import Later from './Later.js';
+
+/** How long a taker holds a due call before anyone may take it over. */
+const TAKE_MS = 30_000;
+
+/**
+ * The calls waiting for their hour, and the take that says one process is making them.
+ *
+ * The take is bounded like `RunRepository`'s lease and for the same reason, but it guards the
+ * opposite case: a release may be redone, a call may not, so what is bounded here is how long
+ * a taker is believed rather than how long a driver is assumed alive.
+ */
+export default class LaterRepository extends Repository(Later) {
+  constructor(storage: Storage<Later>, private now: () => number = Date.now) {
+    super(storage);
+  }
+
+  async keep(call: Call, runAt: number): Promise<void> {
+    const { runAt: _dropped, ...invocation } = call.invocation;
+    await this.create({
+      id: crypto.randomUUID(),
+      entity: call.address.entity,
+      operation: call.address.operation,
+      invocation,
+      runAt,
+    });
+  }
+
+  /**
+   * The calls whose hour has passed and whom nobody is making right now.
+   *
+   * Read whole and filtered here, which bounds what this package holds: a source that answers
+   * `where` on two numbers would answer it at the rows, and that is the next thing to ask for.
+   */
+  async due(): Promise<Later[]> {
+    const rows = await this.list();
+    const now = this.now();
+
+    return rows.filter((row) => row.runAt <= now && (row.takenUntil ?? 0) <= now);
+  }
+
+  /** Hold this one, or say another process already has it — the read and the write are two. */
+  async take(id: string): Promise<'taken' | 'busy'> {
+    const held = await this.findById(id);
+    if (!held) return 'busy';
+    if ((held.takenUntil ?? 0) > this.now()) return 'busy';
+
+    await this.update(id, { takenUntil: this.now() + TAKE_MS });
+
+    return 'taken';
+  }
+
+  async done(id: string): Promise<void> {
+    await this.delete(id);
+  }
+
+  /** Rebuilds what was kept — the address flat, the invocation whole. */
+  callOf(row: Later): Call {
+    return new Call(
+      new RouteAddress({ entity: row.entity, operation: row.operation }),
+      row.invocation as Record<string, unknown>,
+    );
+  }
+}

package/src/Run.ts

@@ -0,0 +1,23 @@
+import { entity, number, oneOf, optional, primary, text } from '@fougere/schema';
+
+/**
+ * A release that is under way, and who is driving it.
+ *
+ * There is no plan here and no position, because a release needs neither: every hop it makes
+ * is already idempotent — a row taken out twice is taken out once, a field emptied twice is
+ * empty — so RESUMING is simply doing it again. What the row has to say is that somebody
+ * started and did not finish.
+ *
+ * Documented: [entities](https://fougere.dev/docs/schema/entities).
+ */
+export default class Run extends entity({
+  /** `user:ada` — derived from what is released, so relaunching is the same run, not a second. */
+  id: primary(text()),
+  entity: text(),
+  key: text(),
+  status: oneOf('running', 'done', { default: 'running' }),
+  /** Who is driving, and until when. An expired lease is what a sweep claims. */
+  leaseOwner: text(),
+  leaseUntil: number({ integer: true }),
+  finishedAt: optional(number({ integer: true })),
+}) {}

package/src/RunHandler.ts

@@ -0,0 +1,28 @@
+import { release, type Releasing } from '@fougere/core';
+import RunRepository from './RunRepository.js';
+import { DRIVER } from './RunJournal.js';
+
+/** Finish what a stopped process started. */
+export default class RunHandler {
+  constructor(private runs: RunRepository, private releasing: Releasing) {}
+
+  /**
+   * Redo every release whose driver stopped saying it was alive.
+   *
+   * An operation, so the CLI, an HTTP route and a cron all reach it the same way — a durable
+   * engine ships one host adapter per platform to get this far.
+   */
+  async sweep(): Promise<{ resumed: string[] }> {
+    const resumed: string[] = [];
+    for (const run of await this.runs.abandoned()) {
+      if (await this.runs.open(run.entity, run.key, DRIVER) === 'busy') continue;
+      // The row too: a release interrupted before it reached the row is not finished.
+      await release(run.entity, run.key, this.releasing, [],
+        async () => this.releasing.rowsOf(run.entity)?.delete(run.key));
+      await this.runs.close(run.entity, run.key);
+      resumed.push(run.id);
+    }
+
+    return { resumed };
+  }
+}

package/src/RunJournal.ts

@@ -0,0 +1,30 @@
+import { JOURNAL, type Call, type Journal } from '@fougere/core';
+import LaterRepository from './LaterRepository.js';
+import RunRepository from './RunRepository.js';
+
+export { JOURNAL };
+
+/**
+ * The journal core asks for, answered by a row.
+ *
+ * Registered under core's own key, which is how an optional package answers a reading core
+ * declares — the same shape a source takes when it says what it keeps at the rows.
+ */
+export default class RunJournal implements Journal {
+  constructor(private runs: RunRepository, private later: LaterRepository) {}
+
+  keep(call: Call, runAt: number): Promise<void> {
+    return this.later.keep(call, runAt);
+  }
+
+  open(entity: string, key: string): Promise<'taken' | 'busy'> {
+    return this.runs.open(entity, key, DRIVER);
+  }
+
+  close(entity: string, key: string): Promise<void> {
+    return this.runs.close(entity, key);
+  }
+}
+
+/** What this process calls itself while it drives a run — enough to tell it from another. */
+export const DRIVER = `${process.pid}`;

package/src/RunRepository.ts

@@ -0,0 +1,47 @@
+import { Repository, type Storage } from '@fougere/core';
+import Run from './Run.js';
+
+/** How long a driver holds a run before anyone may take it over. */
+const LEASE_MS = 30_000;
+
+/**
+ * The runs, and the lease that says one process is driving.
+ *
+ * A lease is time-bounded on purpose: no process can tell whether another is dead or slow, so
+ * the question is never asked. What is bounded instead is how long an answer is assumed, and
+ * two drivers at once stay harmless because every hop can be done twice.
+ */
+export default class RunRepository extends Repository(Run) {
+  constructor(storage: Storage<Run>, private now: () => number = Date.now) {
+    super(storage);
+  }
+
+  /** Take this release on, or say it is already someone's — the same row either way. */
+  async open(entity: string, key: string, owner: string): Promise<'taken' | 'busy'> {
+    const id = `${entity}:${String(key)}`;
+    const held = await this.findById(id);
+    const until = this.now() + LEASE_MS;
+
+    if (!held) {
+      await this.create({ id, entity, key: String(key), status: 'running', leaseOwner: owner, leaseUntil: until });
+
+      return 'taken';
+    }
+    if (held.status === 'running' && held.leaseUntil > this.now() && held.leaseOwner !== owner) return 'busy';
+
+    await this.update(id, { status: 'running', leaseOwner: owner, leaseUntil: until, finishedAt: null });
+
+    return 'taken';
+  }
+
+  async close(entity: string, key: string): Promise<void> {
+    await this.update(`${entity}:${String(key)}`, { status: 'done', finishedAt: this.now() });
+  }
+
+  /** Runs whose driver stopped saying it was alive — what a sweep has to finish. */
+  async abandoned(): Promise<Run[]> {
+    const running = await this.findAllBy({ status: 'running' });
+
+    return running.filter((run) => run.leaseUntil <= this.now());
+  }
+}

package/src/index.ts

@@ -0,0 +1,84 @@
+/**
+ * A release that goes to the end — the journal is one entity, and the sweep is an operation.
+ *
+ * Stated and not scanned: `frond()` is what a published package hands over, so a consumer
+ * needs no TypeScript loader and no scan of its `node_modules`. The frond is BROUGHT by the
+ * extension, which puts it in every process that installs it — and putting it behind
+ * `remotes:` is then how two processes come to share one journal.
+ */
+import type { Container } from '@fougere/container';
+import { Call, frond, JOURNAL, releasing, RouteAddress, type App, type Extension } from '@fougere/core';
+import Later from './Later.js';
+import LaterRepository from './LaterRepository.js';
+import Run from './Run.js';
+import RunRepository from './RunRepository.js';
+import RunJournal from './RunJournal.js';
+import RunHandler from './RunHandler.js';
+
+export { default as Later } from './Later.js';
+export { default as LaterRepository } from './LaterRepository.js';
+export { default as Run } from './Run.js';
+export { default as RunRepository } from './RunRepository.js';
+export { default as RunJournal } from './RunJournal.js';
+export { default as RunHandler } from './RunHandler.js';
+
+/** How often a process looks for a run somebody stopped driving. */
+const SWEEP_MS = 10_000;
+
+export interface WorkflowOptions {
+  /** Milliseconds between sweeps. `0` never sweeps — a test drives `sweep()` itself. */
+  sweepMs?: number;
+}
+
+export function workflow({ sweepMs = SWEEP_MS }: WorkflowOptions = {}): Extension {
+  let beat: ReturnType<typeof setInterval> | undefined;
+
+  return {
+    name: 'workflow',
+    fronds: [frond('workflow', {
+      entities: [Run, Later],
+      providers: [
+        { ctor: RunRepository, deps: ['RunStorage'] },
+        { ctor: LaterRepository, deps: ['LaterStorage'] },
+        // Under core's own key, which is how an optional package answers a reading core declares.
+        { ctor: RunJournal, deps: ['RunRepository', 'LaterRepository'], name: JOURNAL },
+      ],
+      // Stated, because a published package is not scanned: nothing reads this handler's
+      // source at boot, so what it answers is written here.
+      handlers: [{
+        ctor: RunHandler,
+        deps: ['RunRepository', 'Releasing'],
+        operations: { sweep: { binding: [] } },
+      }],
+      // `sweep` leads with no verb core knows, and it is the word the subject uses — so the
+      // kind is stated rather than the operation renamed.
+      operationsOverrides: { sweep: { kind: 'command', binding: [] } },
+    })],
+    up: (app: App) => {
+      if (sweepMs <= 0) return;
+      const scope = app.container.resolve<Container>('frond:workflow');
+      const later = scope.resolve<LaterRepository>('LaterRepository');
+
+      /**
+       * A kept call goes out from HERE and not from an operation, because making it is a
+       * dispatch: an op that dispatched the due ones would answer for calls it only started.
+       */
+      const beatOnce = async () => {
+        await app.dispatch(new Call(new RouteAddress({ entity: 'run', operation: 'sweep' })))
+          .catch(() => undefined);
+
+        for (const row of await later.due()) {
+          if (await later.take(row.id) === 'busy') continue;
+          // Taken and not yet done: a call that throws is left for the take to expire.
+          await app.dispatch(later.callOf(row)).then(() => later.done(row.id), () => undefined);
+        }
+      };
+
+      beat = setInterval(() => { void beatOnce().catch(() => undefined); }, sweepMs);
+      beat.unref?.();
+    },
+    down: () => { if (beat) clearInterval(beat); },
+  };
+}
+
+export { releasing };