@smthrs/engine-store 0.0.0-stage → 1.0.0-rc.3

package/dist/cjs/internal/RunCatalogOps.js

@@ -0,0 +1,85 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var RunCatalogOps_exports = {};
+__export(RunCatalogOps_exports, {
+  RunCatalogError: () => import_RunListingError3.RunCatalogError,
+  RunCatalogErrorCode: () => import_RunListingError2.RunCatalogErrorCode,
+  RunCatalogRead: () => RunCatalogRead,
+  defaultLimit: () => defaultLimit,
+  layer: () => layer,
+  make: () => make
+});
+module.exports = __toCommonJS(RunCatalogOps_exports);
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var SqlClient = __toESM(require("effect/unstable/sql/SqlClient"), 1);
+var RunListing = __toESM(require("./RunListing.js"), 1);
+var import_RunListingError = require("./RunListingError.js");
+var import_RunListingError2 = require("./RunListingError.js");
+var import_RunListingError3 = require("./RunListingError.js");
+class RunCatalogRead extends Context.Service()(
+  "@smthrs/engine-store/RunCatalogRead"
+) {
+}
+const defaultLimit = 1e4;
+const make = () => Effect.gen(function* () {
+  const sql = yield* Effect.service(SqlClient.SqlClient);
+  const listing = yield* RunListing.make();
+  const listRunIds = Effect.fn("RunCatalog.listRunIds")(
+    (options) => Effect.gen(function* () {
+      const limit = options?.limit ?? defaultLimit;
+      if (!Number.isSafeInteger(limit) || limit < 0) {
+        return yield* Effect.fail(
+          new import_RunListingError.RunCatalogError({
+            code: "invalid_options",
+            message: "the run catalog limit must be a non-negative safe integer"
+          })
+        );
+      }
+      return yield* sql`
+          SELECT run_id FROM flows_runs
+          ORDER BY rowid DESC
+          LIMIT ${limit}
+        `.pipe(
+        Effect.map((rows) => rows.map((row) => row.run_id).reverse()),
+        Effect.mapError(
+          (cause) => new import_RunListingError.RunCatalogError({
+            code: "list_failed",
+            message: "the workspace run set could not be read",
+            cause
+          })
+        )
+      );
+    })
+  );
+  return { listRunIds, ...listing };
+});
+const layer = Layer.effect(RunCatalogRead)(make());
+//# sourceMappingURL=RunCatalogOps.js.map

package/dist/cjs/internal/RunCatalogOps.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/RunCatalogOps.ts"],
+  "sourcesContent": ["/**\n * The workspace run catalog read.\n *\n * `@smthrs/sync` serves a workspace subscription over a `RunCatalog`, and\n * every implementation of that service was static (`layerStatic`,\n * `layerNoop`) or in-process (`makeMemory`, which hears only about runs the\n * same process registered). A follower composed against any of them saw the\n * runs that existed when it started and never learned of another run, so a\n * second engine writing to the same workspace was invisible to it. This\n * module is the durable half of the fix: the read that says which runs the\n * workspace has right now, taken from `flows_runs` itself.\n *\n * The read is a full set rather than a cursor tail, for one reason: retention\n * deletes runs. A follower that only ever appended what appeared after a\n * cursor would keep every collected run in its view forever and hold a\n * journal stream open for each one. Reading the set makes both directions\n * work, and the workspace's own bound keeps the cost of it flat.\n *\n * Nothing here polls. The interval belongs to the catalog that consumes this\n * read (`RunCatalog.makePolling` in `@smthrs/sync`), so the durable side has\n * no policy and no fiber of its own.\n *\n * @since 0.1.0\n */\n\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\"\nimport * as RunListing from \"./RunListing.ts\"\nimport { RunCatalogError } from \"./RunListingError.ts\"\n\n/**\n * Stable error codes returned by the catalog read.\n *\n * @category models\n * @since 0.1.0\n */\nexport { RunCatalogErrorCode } from \"./RunListingError.ts\"\n\n/**\n * A catalog read that could not complete.\n *\n * `list_failed` means the workspace's run set could not be read. The caller\n * keeps whatever view it already had; the read is idempotent, so the next one\n * converges once the cause is fixed.\n *\n * @category errors\n * @since 0.1.0\n */\nexport { RunCatalogError } from \"./RunListingError.ts\"\n\n/**\n * Options for one catalog read.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface ListOptions {\n  /**\n   * Largest number of runs the read returns. Defaults to\n   * {@link defaultLimit}. A workspace with more runs than the bound is\n   * followed by its most recent ones; an older run stays readable through a\n   * run-scoped subscription, which names it directly.\n   */\n  readonly limit?: number | undefined\n}\n\n/**\n * The workspace's run set.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Service {\n  /** Revision-consistent, filtered keyset page of execution rows. */\n  readonly listRuns: RunListing.Service[\"listRuns\"]\n  /**\n   * Every run the workspace has, oldest first, bounded by the read. \"Oldest\"\n   * is the run table's own row order, which is the order `RunStore.create`\n   * inserted them: SQLite hands a new row an identifier above every one in\n   * the table, and reuses one only after the highest is deleted, so deletion\n   * by retention does not reorder what is left.\n   */\n  readonly listRunIds: (options?: ListOptions) => Effect.Effect<ReadonlyArray<string>, RunCatalogError>\n}\n\n/**\n * Service tag for the workspace run catalog read.\n *\n * @category services\n * @since 0.1.0\n */\nexport class RunCatalogRead extends Context.Service<RunCatalogRead, Service>()(\n  \"@smthrs/engine-store/RunCatalogRead\"\n) {}\n\n/**\n * Runs one read returns when the caller names no bound. Large enough that an\n * ordinary workspace is returned whole, small enough that a workspace which\n * has never been collected does not hand a follower an unbounded list.\n *\n * @category constants\n * @since 0.1.0\n */\nexport const defaultLimit = 10_000\n\n/**\n * Builds the catalog read over the composition's own run table.\n *\n * The read goes to `flows_runs` directly, the way `DurableEngineState`,\n * `ArtifactGc`, and `RetentionOps` do: this package composes the run-store\n * migrations, so the schema is its own.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = (): Effect.Effect<Service, never, SqlClient.SqlClient> =>\n  Effect.gen(function*() {\n    const sql = yield* Effect.service(SqlClient.SqlClient)\n    const listing = yield* RunListing.make()\n\n    // Newest first by `rowid`, then reversed. `rowid` is the order the\n    // workspace gained its runs, and reading it backwards walks the table's\n    // own b-tree, so the bound costs one seek rather than a sort of every\n    // run: `flows_runs` carries no index on `created_at_ms`, and two runs\n    // created in the same millisecond do not order by it at all.\n    //\n    // `flows_runs` has a TEXT primary key, so its `rowid` is not an alias of\n    // a declared column and SQLite documents that a rebuild may reassign it.\n    // The order the rebuild leaves is what this read depends on, not the\n    // numbers, and `VACUUM INTO` \u2014 the hot backup this release ships, and the\n    // only rebuild in the supported path (the release policy) \u2014 preserves\n    // it. `RunCatalogCatchUp.test.ts` pins that across a real backup and\n    // reopen, including after retention has deleted rows out of the middle\n    // and the end.\n    const listRunIds: Service[\"listRunIds\"] = Effect.fn(\"RunCatalog.listRunIds\")((options?: ListOptions) =>\n      Effect.gen(function*() {\n        const limit = options?.limit ?? defaultLimit\n        if (!Number.isSafeInteger(limit) || limit < 0) {\n          return yield* Effect.fail(\n            new RunCatalogError({\n              code: \"invalid_options\",\n              message: \"the run catalog limit must be a non-negative safe integer\"\n            })\n          )\n        }\n        return yield* sql<{ readonly run_id: string }>`\n          SELECT run_id FROM flows_runs\n          ORDER BY rowid DESC\n          LIMIT ${limit}\n        `.pipe(\n          Effect.map((rows) => rows.map((row) => row.run_id).reverse()),\n          Effect.mapError((cause) =>\n            new RunCatalogError({\n              code: \"list_failed\",\n              message: \"the workspace run set could not be read\",\n              cause\n            })\n          )\n        )\n      })\n    )\n\n    return { listRunIds, ...listing }\n  })\n\n/**\n * Provides the workspace run catalog read.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer: Layer.Layer<RunCatalogRead, never, SqlClient.SqlClient> = Layer.effect(RunCatalogRead)(make())\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAyBA,cAAyB;AACzB,aAAwB;AACxB,YAAuB;AACvB,gBAA2B;AAC3B,iBAA4B;AAC5B,6BAAgC;AAQhC,IAAAA,0BAAoC;AAYpC,IAAAA,0BAAgC;AA2CzB,MAAM,uBAAuB,QAAQ,QAAiC;AAAA,EAC3E;AACF,EAAE;AAAC;AAUI,MAAM,eAAe;AAYrB,MAAM,OAAO,MAClB,OAAO,IAAI,aAAY;AACrB,QAAM,MAAM,OAAO,OAAO,QAAQ,UAAU,SAAS;AACrD,QAAM,UAAU,OAAO,WAAW,KAAK;AAgBvC,QAAM,aAAoC,OAAO,GAAG,uBAAuB;AAAA,IAAE,CAAC,YAC5E,OAAO,IAAI,aAAY;AACrB,YAAM,QAAQ,SAAS,SAAS;AAChC,UAAI,CAAC,OAAO,cAAc,KAAK,KAAK,QAAQ,GAAG;AAC7C,eAAO,OAAO,OAAO;AAAA,UACnB,IAAI,uCAAgB;AAAA,YAClB,MAAM;AAAA,YACN,SAAS;AAAA,UACX,CAAC;AAAA,QACH;AAAA,MACF;AACA,aAAO,OAAO;AAAA;AAAA;AAAA,kBAGJ,KAAK;AAAA,UACb;AAAA,QACA,OAAO,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,QAAQ,IAAI,MAAM,EAAE,QAAQ,CAAC;AAAA,QAC5D,OAAO;AAAA,UAAS,CAAC,UACf,IAAI,uCAAgB;AAAA,YAClB,MAAM;AAAA,YACN,SAAS;AAAA,YACT;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AAEA,SAAO,EAAE,YAAY,GAAG,QAAQ;AAClC,CAAC;AAQI,MAAM,QAAiE,MAAM,OAAO,cAAc,EAAE,KAAK,CAAC;",
+  "names": ["import_RunListingError"]
+}

package/dist/cjs/internal/RunCoordinator.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Coordinates keyed drain executions.
+ *
+ * Adapted nearly verbatim from
+ * `reference/opencode/packages/smithers/flows/core/src/session/run-coordinator.ts`:
+ * `Deferred` joins, `FiberSet` ownership, coalesced wakes, and
+ * `uninterruptibleMask` preserve its start-or-join semantics. This adaptation
+ * drops the source's `force` drain argument because no engine-store drain has
+ * a second execution mode; the successor flag carries coordinator scheduling.
+ *
+ * @since 0.1.0
+ */
+import { Effect, type Scope } from "effect";
+/**
+ * Serializes drain execution for each key while allowing distinct keys to run
+ * concurrently.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface RunCoordinator<Key, E> {
+    /**
+     * Snapshots keys with an execution owned by this coordinator.
+     *
+     * @since 0.1.0
+     * @category operations
+     */
+    readonly active: Effect.Effect<ReadonlySet<Key>>;
+    /**
+     * Starts a drain while idle or joins the active drain for the key.
+     *
+     * @since 0.1.0
+     * @category operations
+     */
+    readonly run: (key: Key) => Effect.Effect<void, E>;
+    /**
+     * Joins the active drain for the key, and starts none while idle.
+     *
+     * @since 1.0.0
+     * @category operations
+     */
+    readonly join: (key: Key) => Effect.Effect<void, E>;
+    /**
+     * Starts an idle key without joining or requesting another active drain.
+     *
+     * @since 1.0.0
+     * @category operations
+     */
+    readonly schedule: (key: Key) => Effect.Effect<void>;
+    /** Reserves an idle key, then starts its drain only while the supplied durable readiness holds. */
+    readonly scheduleIf: (key: Key, ready: Effect.Effect<boolean>) => Effect.Effect<void>;
+    /**
+     * Ensures one coalesced drain follows the active drain for the key.
+     *
+     * @since 0.1.0
+     * @category operations
+     */
+    readonly wake: (key: Key) => Effect.Effect<void>;
+    /**
+     * Interrupts the active drain for the key and waits for its cleanup.
+     *
+     * @since 0.1.0
+     * @category operations
+     */
+    readonly interrupt: (key: Key) => Effect.Effect<void>;
+    /** Sends interruption without awaiting cleanup; safe for a short commit publication. */
+    readonly requestInterrupt: (key: Key) => Effect.Effect<void>;
+}
+/**
+ * Creates a scoped coordinator for keyed drain effects.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const make: <Key, E, R>(options: {
+    readonly drain: (key: Key) => Effect.Effect<void, E, R>;
+}) => Effect.Effect<RunCoordinator<Key, E>, never, Scope.Scope | R>;
+//# sourceMappingURL=RunCoordinator.d.ts.map

package/dist/cjs/internal/RunCoordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunCoordinator.d.ts","sourceRoot":"","sources":["../../../src/internal/RunCoordinator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAmB,MAAM,EAAyB,KAAK,KAAK,EAAE,MAAM,QAAQ,CAAA;AAEnF;;;;;;GAMG;AACH,MAAM,WAAW,cAAc,CAAC,GAAG,EAAE,CAAC;IACpC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAA;IAChD;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;IAClD;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;IACnD;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACpD,mGAAmG;IACnG,QAAQ,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACrF;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAChD;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACrD,wFAAwF;IACxF,QAAQ,CAAC,gBAAgB,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CAC7D;AASD;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,SAAS;IACvC,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CACxD,KAAG,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,GAAG,CAAC,CAgI5D,CAAA"}

package/dist/cjs/internal/RunCoordinator.js

@@ -0,0 +1,123 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var RunCoordinator_exports = {};
+__export(RunCoordinator_exports, {
+  make: () => make
+});
+module.exports = __toCommonJS(RunCoordinator_exports);
+var import_effect = require("effect");
+const make = (options) => import_effect.Effect.gen(function* () {
+  const active = /* @__PURE__ */ new Map();
+  const fork = yield* import_effect.FiberSet.makeRuntime();
+  const makeEntry = () => ({
+    done: import_effect.Deferred.makeUnsafe(),
+    pendingWake: false,
+    stopping: false
+  });
+  const start = (key, entry, successor = false, onlyIf = import_effect.Effect.succeed(true)) => {
+    const ready = import_effect.Deferred.makeUnsafe();
+    const owner = fork(
+      (successor ? import_effect.Effect.yieldNow : import_effect.Deferred.await(ready)).pipe(
+        import_effect.Effect.andThen(onlyIf),
+        import_effect.Effect.flatMap((ready2) => ready2 ? import_effect.Effect.suspend(() => options.drain(key)) : import_effect.Effect.void),
+        import_effect.Effect.onError(
+          (cause) => import_effect.Cause.hasInterruptsOnly(cause) ? import_effect.Effect.void : import_effect.Effect.logWarning(`engine-store: coordinated drain failed for ${String(key)}`, cause)
+        ),
+        import_effect.Effect.onExit((exit) => import_effect.Effect.sync(() => settle(key, entry, exit))),
+        import_effect.Effect.exit,
+        import_effect.Effect.asVoid
+      )
+    );
+    entry.owner = owner;
+    if (!successor) import_effect.Deferred.doneUnsafe(ready, import_effect.Effect.void);
+  };
+  const settle = (key, entry, exit) => {
+    if (import_effect.Exit.isSuccess(exit) && !entry.stopping && entry.pendingWake) {
+      entry.pendingWake = false;
+      start(key, entry, true);
+      return;
+    }
+    const successor = entry.pendingWake ? makeEntry() : void 0;
+    if (successor === void 0) active.delete(key);
+    else {
+      active.set(key, successor);
+      start(key, successor, true);
+    }
+    import_effect.Deferred.doneUnsafe(entry.done, exit);
+  };
+  const startIdle = (key, onlyIf) => {
+    const next = makeEntry();
+    active.set(key, next);
+    start(key, next, false, onlyIf);
+    return next;
+  };
+  const run = (key) => import_effect.Effect.uninterruptibleMask((restore) => {
+    const entry = active.get(key);
+    if (entry !== void 0) {
+      if (entry.stopping) return restore(import_effect.Deferred.await(entry.done).pipe(import_effect.Effect.andThen(run(key))));
+      return restore(import_effect.Deferred.await(entry.done));
+    }
+    return restore(import_effect.Deferred.await(startIdle(key).done));
+  });
+  const join = (key) => import_effect.Effect.suspend(() => {
+    const entry = active.get(key);
+    return entry === void 0 ? import_effect.Effect.void : import_effect.Deferred.await(entry.done);
+  });
+  const schedule = (key) => import_effect.Effect.sync(() => {
+    if (!active.has(key)) startIdle(key);
+  });
+  const scheduleIf = (key, ready) => import_effect.Effect.sync(() => {
+    if (!active.has(key)) startIdle(key, ready);
+  });
+  const wake = (key) => import_effect.Effect.sync(() => {
+    const entry = active.get(key);
+    if (entry !== void 0) {
+      entry.pendingWake = true;
+      return;
+    }
+    startIdle(key);
+  });
+  const interrupt = (key) => import_effect.Effect.suspend(() => {
+    const entry = active.get(key);
+    if (entry?.owner === void 0) return import_effect.Effect.void;
+    entry.stopping = true;
+    entry.pendingWake = false;
+    return import_effect.Fiber.interrupt(entry.owner);
+  });
+  const requestInterrupt = (key) => import_effect.Effect.withFiber(
+    (fiber) => import_effect.Effect.sync(() => {
+      const entry = active.get(key);
+      if (entry?.owner === void 0) return;
+      entry.stopping = true;
+      entry.pendingWake = false;
+      entry.owner.interruptUnsafe(fiber.id);
+    })
+  );
+  return {
+    active: import_effect.Effect.fn("RunCoordinator.active")(() => import_effect.Effect.sync(() => new Set(active.keys())))(),
+    run: import_effect.Effect.fn("RunCoordinator.run")(run),
+    join: import_effect.Effect.fn("RunCoordinator.join")(join),
+    schedule: import_effect.Effect.fn("RunCoordinator.schedule")(schedule),
+    scheduleIf: import_effect.Effect.fn("RunCoordinator.scheduleIf")(scheduleIf),
+    wake: import_effect.Effect.fn("RunCoordinator.wake")(wake),
+    interrupt: import_effect.Effect.fn("RunCoordinator.interrupt")(interrupt),
+    requestInterrupt: import_effect.Effect.fn("RunCoordinator.requestInterrupt")(requestInterrupt)
+  };
+});
+//# sourceMappingURL=RunCoordinator.js.map

package/dist/cjs/internal/RunCoordinator.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/RunCoordinator.ts"],
+  "sourcesContent": ["/**\n * Coordinates keyed drain executions.\n *\n * Adapted nearly verbatim from\n * `reference/opencode/packages/smithers/flows/core/src/session/run-coordinator.ts`:\n * `Deferred` joins, `FiberSet` ownership, coalesced wakes, and\n * `uninterruptibleMask` preserve its start-or-join semantics. This adaptation\n * drops the source's `force` drain argument because no engine-store drain has\n * a second execution mode; the successor flag carries coordinator scheduling.\n *\n * @since 0.1.0\n */\n\nimport { Cause, Deferred, Effect, Exit, Fiber, FiberSet, type Scope } from \"effect\"\n\n/**\n * Serializes drain execution for each key while allowing distinct keys to run\n * concurrently.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface RunCoordinator<Key, E> {\n  /**\n   * Snapshots keys with an execution owned by this coordinator.\n   *\n   * @since 0.1.0\n   * @category operations\n   */\n  readonly active: Effect.Effect<ReadonlySet<Key>>\n  /**\n   * Starts a drain while idle or joins the active drain for the key.\n   *\n   * @since 0.1.0\n   * @category operations\n   */\n  readonly run: (key: Key) => Effect.Effect<void, E>\n  /**\n   * Joins the active drain for the key, and starts none while idle.\n   *\n   * @since 1.0.0\n   * @category operations\n   */\n  readonly join: (key: Key) => Effect.Effect<void, E>\n  /**\n   * Starts an idle key without joining or requesting another active drain.\n   *\n   * @since 1.0.0\n   * @category operations\n   */\n  readonly schedule: (key: Key) => Effect.Effect<void>\n  /** Reserves an idle key, then starts its drain only while the supplied durable readiness holds. */\n  readonly scheduleIf: (key: Key, ready: Effect.Effect<boolean>) => Effect.Effect<void>\n  /**\n   * Ensures one coalesced drain follows the active drain for the key.\n   *\n   * @since 0.1.0\n   * @category operations\n   */\n  readonly wake: (key: Key) => Effect.Effect<void>\n  /**\n   * Interrupts the active drain for the key and waits for its cleanup.\n   *\n   * @since 0.1.0\n   * @category operations\n   */\n  readonly interrupt: (key: Key) => Effect.Effect<void>\n  /** Sends interruption without awaiting cleanup; safe for a short commit publication. */\n  readonly requestInterrupt: (key: Key) => Effect.Effect<void>\n}\n\ntype Entry<E> = {\n  readonly done: Deferred.Deferred<void, E>\n  owner?: Fiber.Fiber<void, never>\n  pendingWake: boolean\n  stopping: boolean\n}\n\n/**\n * Creates a scoped coordinator for keyed drain effects.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const make = <Key, E, R>(options: {\n  readonly drain: (key: Key) => Effect.Effect<void, E, R>\n}): Effect.Effect<RunCoordinator<Key, E>, never, Scope.Scope | R> =>\n  Effect.gen(function*() {\n    const active = new Map<Key, Entry<E>>()\n    const fork = yield* FiberSet.makeRuntime<R, void, never>()\n\n    const makeEntry = (): Entry<E> => ({\n      done: Deferred.makeUnsafe<void, E>(),\n      pendingWake: false,\n      stopping: false\n    })\n\n    const start = (\n      key: Key,\n      entry: Entry<E>,\n      successor = false,\n      onlyIf: Effect.Effect<boolean> = Effect.succeed(true)\n    ): void => {\n      const ready = Deferred.makeUnsafe<void>()\n      const owner = fork(\n        (successor ? Effect.yieldNow : Deferred.await(ready)).pipe(\n          Effect.andThen(onlyIf),\n          Effect.flatMap((ready) => ready ? Effect.suspend(() => options.drain(key)) : Effect.void),\n          Effect.onError((cause) =>\n            Cause.hasInterruptsOnly(cause)\n              ? Effect.void\n              : Effect.logWarning(`engine-store: coordinated drain failed for ${String(key)}`, cause)\n          ),\n          Effect.onExit((exit) => Effect.sync(() => settle(key, entry, exit))),\n          Effect.exit,\n          Effect.asVoid\n        )\n      )\n      entry.owner = owner\n      if (!successor) Deferred.doneUnsafe(ready, Effect.void)\n    }\n\n    const settle = (key: Key, entry: Entry<E>, exit: Exit.Exit<void, E>): void => {\n      if (Exit.isSuccess(exit) && !entry.stopping && entry.pendingWake) {\n        entry.pendingWake = false\n        start(key, entry, true)\n        return\n      }\n\n      const successor = entry.pendingWake ? makeEntry() : undefined\n      if (successor === undefined) active.delete(key)\n      else {\n        active.set(key, successor)\n        start(key, successor, true)\n      }\n      Deferred.doneUnsafe(entry.done, exit)\n    }\n\n    const startIdle = (key: Key, onlyIf?: Effect.Effect<boolean>): Entry<E> => {\n      const next = makeEntry()\n      active.set(key, next)\n      start(key, next, false, onlyIf)\n      return next\n    }\n\n    const run = (key: Key): Effect.Effect<void, E> =>\n      Effect.uninterruptibleMask((restore) => {\n        const entry = active.get(key)\n        if (entry !== undefined) {\n          /* v8 ignore next -- stopping is a cooperative-scheduler handoff covered by the cleanup race test */\n          if (entry.stopping) return restore(Deferred.await(entry.done).pipe(Effect.andThen(run(key))))\n          return restore(Deferred.await(entry.done))\n        }\n\n        return restore(Deferred.await(startIdle(key).done))\n      })\n\n    const join = (key: Key): Effect.Effect<void, E> =>\n      Effect.suspend(() => {\n        const entry = active.get(key)\n        return entry === undefined ? Effect.void : Deferred.await(entry.done)\n      })\n\n    const schedule = (key: Key): Effect.Effect<void> =>\n      Effect.sync(() => {\n        if (!active.has(key)) startIdle(key)\n      })\n\n    const scheduleIf = (key: Key, ready: Effect.Effect<boolean>): Effect.Effect<void> =>\n      Effect.sync(() => {\n        if (!active.has(key)) startIdle(key, ready)\n      })\n\n    const wake = (key: Key): Effect.Effect<void> =>\n      Effect.sync(() => {\n        const entry = active.get(key)\n        if (entry !== undefined) {\n          entry.pendingWake = true\n          return\n        }\n\n        startIdle(key)\n      })\n\n    const interrupt = (key: Key): Effect.Effect<void> =>\n      Effect.suspend(() => {\n        const entry = active.get(key)\n        if (entry?.owner === undefined) return Effect.void\n        entry.stopping = true\n        entry.pendingWake = false\n        return Fiber.interrupt(entry.owner)\n      })\n\n    const requestInterrupt = (key: Key): Effect.Effect<void> =>\n      Effect.withFiber((fiber) =>\n        Effect.sync(() => {\n          const entry = active.get(key)\n          if (entry?.owner === undefined) return\n          entry.stopping = true\n          entry.pendingWake = false\n          entry.owner.interruptUnsafe(fiber.id)\n        })\n      )\n\n    return {\n      active: Effect.fn(\"RunCoordinator.active\")(() => Effect.sync(() => new Set(active.keys())))(),\n      run: Effect.fn(\"RunCoordinator.run\")(run),\n      join: Effect.fn(\"RunCoordinator.join\")(join),\n      schedule: Effect.fn(\"RunCoordinator.schedule\")(schedule),\n      scheduleIf: Effect.fn(\"RunCoordinator.scheduleIf\")(scheduleIf),\n      wake: Effect.fn(\"RunCoordinator.wake\")(wake),\n      interrupt: Effect.fn(\"RunCoordinator.interrupt\")(interrupt),\n      requestInterrupt: Effect.fn(\"RunCoordinator.requestInterrupt\")(requestInterrupt)\n    }\n  })\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAaA,oBAA2E;AAuEpE,MAAM,OAAO,CAAY,YAG9B,qBAAO,IAAI,aAAY;AACrB,QAAM,SAAS,oBAAI,IAAmB;AACtC,QAAM,OAAO,OAAO,uBAAS,YAA4B;AAEzD,QAAM,YAAY,OAAiB;AAAA,IACjC,MAAM,uBAAS,WAAoB;AAAA,IACnC,aAAa;AAAA,IACb,UAAU;AAAA,EACZ;AAEA,QAAM,QAAQ,CACZ,KACA,OACA,YAAY,OACZ,SAAiC,qBAAO,QAAQ,IAAI,MAC3C;AACT,UAAM,QAAQ,uBAAS,WAAiB;AACxC,UAAM,QAAQ;AAAA,OACX,YAAY,qBAAO,WAAW,uBAAS,MAAM,KAAK,GAAG;AAAA,QACpD,qBAAO,QAAQ,MAAM;AAAA,QACrB,qBAAO,QAAQ,CAACA,WAAUA,SAAQ,qBAAO,QAAQ,MAAM,QAAQ,MAAM,GAAG,CAAC,IAAI,qBAAO,IAAI;AAAA,QACxF,qBAAO;AAAA,UAAQ,CAAC,UACd,oBAAM,kBAAkB,KAAK,IACzB,qBAAO,OACP,qBAAO,WAAW,8CAA8C,OAAO,GAAG,CAAC,IAAI,KAAK;AAAA,QAC1F;AAAA,QACA,qBAAO,OAAO,CAAC,SAAS,qBAAO,KAAK,MAAM,OAAO,KAAK,OAAO,IAAI,CAAC,CAAC;AAAA,QACnE,qBAAO;AAAA,QACP,qBAAO;AAAA,MACT;AAAA,IACF;AACA,UAAM,QAAQ;AACd,QAAI,CAAC,UAAW,wBAAS,WAAW,OAAO,qBAAO,IAAI;AAAA,EACxD;AAEA,QAAM,SAAS,CAAC,KAAU,OAAiB,SAAmC;AAC5E,QAAI,mBAAK,UAAU,IAAI,KAAK,CAAC,MAAM,YAAY,MAAM,aAAa;AAChE,YAAM,cAAc;AACpB,YAAM,KAAK,OAAO,IAAI;AACtB;AAAA,IACF;AAEA,UAAM,YAAY,MAAM,cAAc,UAAU,IAAI;AACpD,QAAI,cAAc,OAAW,QAAO,OAAO,GAAG;AAAA,SACzC;AACH,aAAO,IAAI,KAAK,SAAS;AACzB,YAAM,KAAK,WAAW,IAAI;AAAA,IAC5B;AACA,2BAAS,WAAW,MAAM,MAAM,IAAI;AAAA,EACtC;AAEA,QAAM,YAAY,CAAC,KAAU,WAA8C;AACzE,UAAM,OAAO,UAAU;AACvB,WAAO,IAAI,KAAK,IAAI;AACpB,UAAM,KAAK,MAAM,OAAO,MAAM;AAC9B,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,CAAC,QACX,qBAAO,oBAAoB,CAAC,YAAY;AACtC,UAAM,QAAQ,OAAO,IAAI,GAAG;AAC5B,QAAI,UAAU,QAAW;AAEvB,UAAI,MAAM,SAAU,QAAO,QAAQ,uBAAS,MAAM,MAAM,IAAI,EAAE,KAAK,qBAAO,QAAQ,IAAI,GAAG,CAAC,CAAC,CAAC;AAC5F,aAAO,QAAQ,uBAAS,MAAM,MAAM,IAAI,CAAC;AAAA,IAC3C;AAEA,WAAO,QAAQ,uBAAS,MAAM,UAAU,GAAG,EAAE,IAAI,CAAC;AAAA,EACpD,CAAC;AAEH,QAAM,OAAO,CAAC,QACZ,qBAAO,QAAQ,MAAM;AACnB,UAAM,QAAQ,OAAO,IAAI,GAAG;AAC5B,WAAO,UAAU,SAAY,qBAAO,OAAO,uBAAS,MAAM,MAAM,IAAI;AAAA,EACtE,CAAC;AAEH,QAAM,WAAW,CAAC,QAChB,qBAAO,KAAK,MAAM;AAChB,QAAI,CAAC,OAAO,IAAI,GAAG,EAAG,WAAU,GAAG;AAAA,EACrC,CAAC;AAEH,QAAM,aAAa,CAAC,KAAU,UAC5B,qBAAO,KAAK,MAAM;AAChB,QAAI,CAAC,OAAO,IAAI,GAAG,EAAG,WAAU,KAAK,KAAK;AAAA,EAC5C,CAAC;AAEH,QAAM,OAAO,CAAC,QACZ,qBAAO,KAAK,MAAM;AAChB,UAAM,QAAQ,OAAO,IAAI,GAAG;AAC5B,QAAI,UAAU,QAAW;AACvB,YAAM,cAAc;AACpB;AAAA,IACF;AAEA,cAAU,GAAG;AAAA,EACf,CAAC;AAEH,QAAM,YAAY,CAAC,QACjB,qBAAO,QAAQ,MAAM;AACnB,UAAM,QAAQ,OAAO,IAAI,GAAG;AAC5B,QAAI,OAAO,UAAU,OAAW,QAAO,qBAAO;AAC9C,UAAM,WAAW;AACjB,UAAM,cAAc;AACpB,WAAO,oBAAM,UAAU,MAAM,KAAK;AAAA,EACpC,CAAC;AAEH,QAAM,mBAAmB,CAAC,QACxB,qBAAO;AAAA,IAAU,CAAC,UAChB,qBAAO,KAAK,MAAM;AAChB,YAAM,QAAQ,OAAO,IAAI,GAAG;AAC5B,UAAI,OAAO,UAAU,OAAW;AAChC,YAAM,WAAW;AACjB,YAAM,cAAc;AACpB,YAAM,MAAM,gBAAgB,MAAM,EAAE;AAAA,IACtC,CAAC;AAAA,EACH;AAEF,SAAO;AAAA,IACL,QAAQ,qBAAO,GAAG,uBAAuB,EAAE,MAAM,qBAAO,KAAK,MAAM,IAAI,IAAI,OAAO,KAAK,CAAC,CAAC,CAAC,EAAE;AAAA,IAC5F,KAAK,qBAAO,GAAG,oBAAoB,EAAE,GAAG;AAAA,IACxC,MAAM,qBAAO,GAAG,qBAAqB,EAAE,IAAI;AAAA,IAC3C,UAAU,qBAAO,GAAG,yBAAyB,EAAE,QAAQ;AAAA,IACvD,YAAY,qBAAO,GAAG,2BAA2B,EAAE,UAAU;AAAA,IAC7D,MAAM,qBAAO,GAAG,qBAAqB,EAAE,IAAI;AAAA,IAC3C,WAAW,qBAAO,GAAG,0BAA0B,EAAE,SAAS;AAAA,IAC1D,kBAAkB,qBAAO,GAAG,iCAAiC,EAAE,gBAAgB;AAAA,EACjF;AACF,CAAC;",
+  "names": ["ready"]
+}

package/dist/cjs/internal/RunDriver.d.ts

@@ -0,0 +1,192 @@
+/**
+ * Claim-gated durable flow run lifecycle.
+ *
+ * @since 0.1.0
+ */
+import { DurableWriter } from "@smthrs/database/DurableWriter";
+import { FlowEngine } from "@smthrs/engine";
+import { Flow, FlowRuntime } from "@smthrs/flow";
+import { Journal } from "@smthrs/journal";
+import { Ownership, RunStore } from "@smthrs/run-store";
+import type * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Scope from "effect/Scope";
+import * as DurableEngineState from "../DurableEngineState.ts";
+import * as WakeBus from "../WakeBus.ts";
+/**
+ * Raised when a flow (directly or through mutual ancestry) attempts to
+ * execute an execution id that already appears in its own persisted
+ * `parentExecutionId` chain.
+ *
+ * Detection walks the already-persisted parent chain from the requesting
+ * parent upward — an O(depth) check, not a dependency-graph DFS — because
+ * `parentExecutionId` is the only edge our runtime model can express.
+ *
+ * The class is declared by `@smthrs/flow` (it is part of the `execute`
+ * contract) and re-exported here for the detector's callers.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare const FlowCycleDetected: typeof FlowRuntime.FlowCycleDetected;
+/**
+ * The value form of {@link FlowCycleDetected}.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export type FlowCycleDetected = FlowRuntime.FlowCycleDetected;
+/**
+ * Why the engine itself asked a parked execution to resume.
+ *
+ * The operator's own resume is absent on purpose: it is the one wake a host
+ * has already claimed before the engine hears about it.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type RequestedResumeReason = "deferred" | "clock" | "parent";
+/**
+ * Why a wake is scheduled for an execution.
+ *
+ * Only `operator` is recovery consent for a quarantine park. `delegated` is a
+ * host taking up a control delegation it has already claimed, so, like
+ * `operator`, it is not recorded back to the host as a request.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type ScheduledResumeReason = RequestedResumeReason | "operator" | "delegated";
+/**
+ * Dependencies for the run driver.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Dependencies {
+    readonly owner: Ownership.OwnerId;
+    readonly journalSource: string;
+    /**
+     * Liveness arbitration before a steal, consulted only for a run whose lease
+     * has already expired. Optional: the default is
+     * `Ownership.leaseLiveness(Ownership.heartbeatStaleAfter)`, which has no
+     * evidence beyond the lease and therefore reports the owner gone, so a
+     * composition that supplies nothing still reclaims hard-killed runs.
+     */
+    readonly isAlive?: Ownership.LivenessCheck | undefined;
+    readonly canExecute?: ((row: RunStore.RunRow) => Effect.Effect<boolean>) | undefined;
+    readonly canActivate?: ((row: RunStore.RunRow) => Effect.Effect<boolean>) | undefined;
+    /**
+     * Records, for a host that keeps one, that this driver has asked a
+     * SUSPENDED execution to resume.
+     *
+     * Every wake the engine itself initiates passes through here: a durable
+     * clock firing, a durable deferred completing (a signal, a queue offer, a
+     * registration-time sweep of completions taken while the host was down),
+     * and a child settling under a parent that parked on it. A host that guards
+     * re-entry into a parked run — `AgentSession` refuses a round for a parked
+     * control row that nobody asked for — otherwise cannot tell those from its
+     * own heartbeat sweep, and a run that slept never settled.
+     *
+     * An operator resume is NOT recorded: `Control.resume` and
+     * `ControlLive.decide` claim the control row themselves, and recording a
+     * second request for the resume a host is already taking up would buy that
+     * park a second re-drive.
+     *
+     * Optional. A composition with no such host leaves it undefined and the
+     * wake is exactly what it was.
+     */
+    readonly requestResume?: ((executionId: string, reason: RequestedResumeReason) => Effect.Effect<void>) | undefined;
+    readonly engine: Effect.Effect<FlowRuntime.FlowRuntime["Service"]>;
+    /**
+     * In-process wake bus announced to whenever a durable write makes a run
+     * runnable — a scheduled resume (deferred, clock, operator) and a run
+     * settling terminally. Optional so a direct construction without one keeps
+     * the pre-existing polling-only behavior: the default drops every wake,
+     * which the engine's suspension polling schedule already covers.
+     */
+    readonly wakeBus?: WakeBus.Service | undefined;
+    /**
+     * Runs inside the uninterruptible finalizer that retains a suspended run's
+     * flow scope, immediately after the entry is inserted and before the round's
+     * settlement can start.
+     *
+     * Private to `packages/smithers/flows/engine-store/test`. That boundary is where a pending
+     * interruption first becomes observable again, and no public seam reaches
+     * it, so the regression proving the retention is released there — rather
+     * than stranded until the driver's own scope closes — raises the
+     * interruption from here. This module is not exported from the package
+     * (`"./internal/*": null`), and production compositions leave the hook
+     * undefined, which costs one `undefined` check per suspension.
+     */
+    readonly unsafeOnScopeRetained?: ((runId: string) => Effect.Effect<void>) | undefined;
+}
+/**
+ * Claim-gated operations composed into the encoded flow engine.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Service {
+    readonly register: FlowEngine.Encoded["register"];
+    /**
+     * The encoded `execute`, widened for direct driver callers: an absent
+     * `round` admits the execution as round zero of its own lineage. Nested
+     * direct callers observe its latest round; encoded callers read one round.
+     * To decode a terminal result, direct nested callers must register the
+     * terminal flow's codec in this driver, even if another worker ran it.
+     * A missing codec is a wiring defect, as with the typed Trampoline; it
+     * fails fast rather than suspending terminal work with no future wake.
+     */
+    readonly execute: <const Discard extends boolean>(flow: Flow.Any, options: {
+        readonly executionId: string;
+        readonly payload: object;
+        readonly discard: Discard;
+        readonly parent?: FlowRuntime.FlowInstance["Service"] | undefined;
+        readonly round?: Parameters<FlowEngine.Encoded["execute"]>[1]["round"] | undefined;
+        readonly follow?: boolean | undefined;
+    }) => Effect.Effect<Discard extends true ? void : Flow.Result<unknown, unknown>, FlowCycleDetected>;
+    readonly poll: FlowEngine.Encoded["poll"];
+    readonly interrupt: FlowEngine.Encoded["interrupt"];
+    readonly interruptUnsafe: FlowEngine.Encoded["interruptUnsafe"];
+    readonly resume: FlowEngine.Encoded["resume"];
+    readonly scheduleResume: (flowName: string, executionId: string, reason: ScheduledResumeReason, sourceId?: string | undefined) => Effect.Effect<void>;
+    readonly active: Effect.Effect<ReadonlySet<string>>;
+    /**
+     * The runs whose parked flow scope this driver still holds. Cancellation
+     * and re-drive both release; the set is the leak assertion's observation
+     * point.
+     */
+    readonly retainedRuns: Effect.Effect<ReadonlySet<string>>;
+}
+/**
+ * The effect kind a detached child spawn is journaled under, and therefore the
+ * kind an engine composition registers a spawn-compensation handler for.
+ *
+ * @since 0.1.0
+ * @category constants
+ */
+export declare const spawnEffectKind: "flows/engine-store/child-spawn";
+/**
+ * Compares encoded JSON payloads structurally. Object key order is not part
+ * of JSON identity, while array order and array length are.
+ *
+ * Values outside JSON compare unequal unless both arguments are the same
+ * reference.
+ *
+ * @since 1.0.0
+ * @category guards
+ * @private
+ */
+export declare const samePayload: (left: unknown, right: unknown) => boolean;
+/**
+ * Constructs a scoped run driver.
+ *
+ * Every start and wake enters the same keyed coordinator and then the same
+ * exact-snapshot claim/activation path.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const make: (dependencies: Dependencies) => Effect.Effect<Service, never, Crypto.Crypto | DurableEngineState.DurableEngineState | DurableWriter | Journal.Journal | RunStore.RunStore | Scope.Scope>;
+//# sourceMappingURL=RunDriver.d.ts.map

package/dist/cjs/internal/RunDriver.d.ts.map

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