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

package/dist/esm/internal/RetentionOps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RetentionOps.js","sourceRoot":"","sources":["../../../src/internal/RetentionOps.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Retention: the one operation that deletes finished run state.\n *\n * Nothing in the composition removed a `flows_runs` row or anything that hangs\n * off one. Every run a workspace ever finished stayed in `.flows/engine.db`\n * with its attempts, its persisted deferred completions and clock deadlines,\n * its journal entries, and its checkpoints, and journal compaction is off by\n * default (`SqlJournal` `Options.compaction`), so the file only grew. This\n * module is the deletion side, and the whole of it: one operation, run\n * explicitly.\n *\n * Three properties make it safe to run against a live workspace.\n *\n * - **One transaction.** Every delete runs inside a single `journal.transact`,\n *   so a crash leaves either a run with all of its rows or none of them —\n *   never a run row whose history is gone, or history whose run row is gone.\n * - **Terminal and aged only.** A run is a candidate only when its status is\n *   `completed`, `failed`, or `cancelled` AND it finished before the cutoff.\n *   A running, pending, or suspended run is never a candidate at any age.\n * - **Nothing a live run still needs.** A candidate is retained when a live\n *   run stands on either side of it in the lineage, over BOTH relations that\n *   make one run the parent of another: the `flows_run_parents` edge a spawned\n *   child is recorded under, and the reserved `parent_run_id` column the\n *   rounds of one trampoline lineage are chained through. Upward: an aged\n *   terminal run with a live ancestor stays, because a parent reads a settled\n *   child's result out of its run row (`agent/await`) and a parent parked on\n *   an approval, a deferred, or a timer can be parked for longer than the\n *   threshold before it ever asks. Downward: an aged terminal run whose\n *   descendant is still live stays, because deleting it would leave that\n *   descendant's `parent_run_id` pointing at nothing and would drop the live\n *   descendant's lineage edges with the `flows_run_parents_gc` trigger.\n * - **Explicit.** Nothing schedules this. Automatic retention stays opt-in,\n *   for the reason `ArtifactGc` states: deletion is the irreversible\n *   direction, and a human approving a plan must be approving the deletions.\n *\n * Journal history is deleted outright rather than compacted to a checkpoint.\n * `Journal.checkpoint` and `Journal.compact` are owner-fenced — `SqlJournal`'s\n * `fenceGuard` requires a consensus lease held by the exact owner passed in —\n * so neither can be called for a finished, ownerless run at all. Deleting the run's entries and checkpoints is strictly stronger than\n * compacting them to a checkpoint, and it happens in the same transaction as\n * the run row, which is the property a compaction could not have given.\n *\n * The operation is idempotent. With a positive integer limit and a fixed,\n * finite, acyclic run lineage, each successful non-dry pass deletes at least\n * one collectable run until none remain. Continuation children are selected\n * before parents; parents pinned by excluded children do not consume the\n * bound. Runs protected by age or live lineage remain until eligible.\n *\n * @since 0.1.0\n */\n\nimport * as Dialect from \"@smthrs/database/Dialect\"\nimport * as Journal from \"@smthrs/journal/Journal\"\nimport * as JournalEvent from \"@smthrs/journal/JournalEvent\"\nimport * as RunStore from \"@smthrs/run-store/RunStore\"\nimport * as Clock from \"effect/Clock\"\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport * as Schema from \"effect/Schema\"\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\"\nimport type { SqlError } from \"effect/unstable/sql/SqlError\"\n\n/**\n * Stable error codes returned by retention.\n *\n * @category models\n * @since 0.1.0\n */\nexport const RetentionErrorCode = Schema.Literals([\"scan_failed\", \"delete_failed\"])\n\n/**\n * Stable error codes returned by retention.\n *\n * @category models\n * @since 0.1.0\n */\nexport type RetentionErrorCode = typeof RetentionErrorCode.Type\n\n/**\n * A retention pass that could not complete.\n *\n * `scan_failed` means the candidate set could not be computed and nothing was\n * deleted. `delete_failed` means the candidate set held but a delete refused;\n * the transaction rolled back, so nothing was deleted then either, and\n * re-running converges once the cause is fixed.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class RetentionError extends Schema.TaggedError<RetentionError>()(\n  \"@smthrs/engine-store/RetentionError\",\n  {\n    code: RetentionErrorCode,\n    message: Schema.String,\n    cause: Schema.optional(Schema.Unknown)\n  }\n) {}\n\n/**\n * Options for one retention pass.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface RetainOptions {\n  /**\n   * How long a run must have been finished to be collected, in milliseconds.\n   * A run's age is measured from `finished_at_ms`, or from `created_at_ms`\n   * for a terminal row that never recorded one. Zero collects every terminal\n   * run; a negative value is read as zero.\n   */\n  readonly olderThanMs: number\n  /**\n   * Largest number of runs one pass deletes. Defaults to\n   * {@link defaultLimit}. Retention is idempotent, so a workspace with more\n   * aged runs than the bound converges over repeated passes instead of\n   * holding one long write transaction open. A negative value is read as\n   * zero, so a pass under a mistyped bound deletes nothing.\n   */\n  readonly limit?: number | undefined\n  /** Compute and report the pass without deleting anything. */\n  readonly dryRun?: boolean | undefined\n}\n\n/**\n * What one retention pass did, or — under `dryRun` — would do.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface RetainReport {\n  /** Runs finished at or before this instant were candidates. */\n  readonly cutoffMs: number\n  /** The runs deleted, oldest first. */\n  readonly runIds: ReadonlyArray<string>\n  /**\n   * Aged terminal runs left in place because a descendant of theirs is not\n   * terminal, or is terminal and is not being deleted by this pass. They\n   * become collectable once that descendant is. At most `limit` of them are\n   * reported, the oldest first, so the report costs no more than the pass.\n   */\n  readonly retainedForLiveDescendants: ReadonlyArray<string>\n  /**\n   * Aged terminal runs left in place because an ancestor of theirs is not\n   * terminal. That ancestor can still read the run's settled result through\n   * `agent/await`, which answers out of the run row. They become collectable\n   * once every ancestor is terminal — a terminal ancestor holds nothing back,\n   * whatever its own age. A run retained for both reasons is reported under\n   * {@link retainedForLiveDescendants}, and at most `limit` runs are reported.\n   */\n  readonly retainedForLiveAncestors: ReadonlyArray<string>\n  readonly runs: number\n  readonly attempts: number\n  readonly clockDeadlines: number\n  readonly deferredCompletions: number\n  readonly journalEntries: number\n  readonly journalCheckpoints: number\n  /** Producer identities journal compaction kept after deleting event payloads. */\n  readonly journalIdentities: number\n  /** Time-travel archive rows; always zero where that table is not installed. */\n  readonly archiveEntries: number\n  /** Time-travel receipt rows reached through their audits. */\n  readonly timeTravelReceipts: number\n  readonly dryRun: boolean\n}\n\n/**\n * Explicit run retention.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Service {\n  /**\n   * Deletes up to `limit` aged terminal runs and their dependents atomically.\n   * With a positive integer limit and a fixed, finite, acyclic lineage, each\n   * successful non-dry pass makes progress until all collectable runs are gone,\n   * including continuation chains longer than the bound. Age and live-lineage\n   * protection still apply. Explicit only; nothing schedules this operation.\n   */\n  readonly retain: (\n    options: RetainOptions\n  ) => Effect.Effect<RetainReport, RetentionError | Journal.JournalError>\n}\n\n/**\n * Service tag for run retention.\n *\n * @category services\n * @since 0.1.0\n */\nexport class Retention extends Context.Service<Retention, Service>()(\"@smthrs/engine-store/Retention\") {}\n\n/**\n * Runs deleted by one pass when the caller names no bound. Large enough that\n * an ordinary workspace finishes in one pass, small enough that the write\n * transaction stays short on a workspace that has never been collected.\n *\n * @category constants\n * @since 0.1.0\n */\nexport const defaultLimit = 1000\n\n/**\n * Run ids per `IN (...)` list. SQLite's default host-parameter ceiling is 999.\n *\n * @category constants\n * @since 0.1.0\n */\nconst chunkSize = 500\n\n/**\n * One table a deleted run leaves rows in.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface RunScopedTable {\n  readonly table: string\n  /** The column naming the run. */\n  readonly column: string\n  /**\n   * Whether the migration ladder this package composes installs the table.\n   *\n   * A ladder table missing from an engine database is a broken schema, so\n   * {@link installedTables} can be asked to keep it and let the delete refuse.\n   * A table beyond the ladder belongs to a store the host may simply not have\n   * composed, and is skipped when the catalog does not list it.\n   */\n  readonly ladder: boolean\n  /**\n   * Whether the table also holds the runs' journal companion streams\n   * (`JournalEvent.companionRunId`), which name a run through a derived id\n   * rather than the run id itself. {@link companionStreams} lists them.\n   */\n  readonly companions?: boolean | undefined\n}\n\n/**\n * The journal companion streams a run owns beside its own stream. A deleted\n * run's companion streams go with it.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const companionStreams: ReadonlyArray<string> = [RunStore.companionStream]\n\n/**\n * Every table a deleted run leaves rows in, and the column naming the run.\n *\n * ONE inventory, because two passes read it: {@link Service.retain} over the\n * engine ladder, and `Retention.collect` over whatever a host's file holds. A\n * table listed by only one of them is a table the other leaks forever. Tables\n * are listed rather than discovered from foreign keys because the set spans\n * six packages that migrate into one database, and a silently missing entry is\n * exactly that leak.\n *\n * The run rows themselves are not here: they go last and in generation order,\n * which {@link deleteRuns} does after this list.\n * `flows_time_travel_receipts` is reached through its audit rather than listed\n * here because the upstream table has no run column: its `audit_id` points to\n * `flows_time_travel_audits.id`, whose row carries `run_id`.\n *\n * @category constants\n * @since 0.1.0\n */\nexport const runScopedTables: ReadonlyArray<RunScopedTable> = [\n  { table: \"flows_deferred_completions\", column: \"execution_id\", ladder: true },\n  { table: \"flows_clock_deadlines\", column: \"execution_id\", ladder: true },\n  { table: \"flows_attempts\", column: \"run_id\", ladder: true },\n  { table: \"flows_journal_events\", column: \"run_id\", ladder: true, companions: true },\n  { table: \"flows_journal_checkpoints\", column: \"run_id\", ladder: true, companions: true },\n  { table: \"flows_journal_dedup\", column: \"run_id\", ladder: true, companions: true },\n  { table: \"flows_consensus_leases\", column: \"run_id\", ladder: true },\n  { table: \"flows_step_cache_recorded\", column: \"recorded_run_id\", ladder: true },\n  { table: \"flows_time_travel_archive\", column: \"run_id\", ladder: false },\n  { table: \"flows_time_travel_snapshots\", column: \"run_id\", ladder: false },\n  { table: \"flows_time_travel_audits\", column: \"run_id\", ladder: false },\n  { table: \"flows_time_travel_edges\", column: \"child_run_id\", ladder: false },\n  { table: \"control_run_messages\", column: \"run_id\", ladder: false },\n  { table: \"control_runs\", column: \"run_id\", ladder: false }\n]\n\n/**\n * The statuses a run can never leave.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const terminalStatuses: ReadonlyArray<string> = [\"completed\", \"failed\", \"cancelled\"]\n\n/** `terminalStatuses` as a SQL list, for the lineage prelude below. */\nconst terminalList = terminalStatuses.map((status) => `'${status}'`).join(\", \")\n\n/**\n * The prelude every scan opens with: which runs a live run stands above, and\n * which it stands below.\n *\n * Two relations make one run the parent of another, and a walk over either one\n * alone misses half the lineage. A SPAWNED child records its parent as a\n * `flows_run_parents` edge, one row per parent so a diamond records both, and\n * leaves `parent_run_id` NULL: the engine reserves that column for the rounds\n * of one trampoline lineage (`RunDriver.continueLineage`). The edge is the\n * relation every `agent/await` depends on. `link` is both relations as one\n * edge list.\n *\n * `under_live` is every run reachable downward from a run that is not\n * terminal. Those runs have a live ancestor, which can still read a settled\n * result out of their run row. `over_live` is every run reachable upward from\n * one. Those runs have a live descendant, whose own lineage the\n * `flows_run_parents_gc` trigger would drop with them. An edge whose parent\n * row is gone is not reachable from `live` at all, so it holds nothing back,\n * and since only terminal runs are ever deleted it never can.\n *\n * The walks carry run ids and nothing else, so `UNION` makes them terminate on\n * their own: a corrupt edge that closed a cycle adds a row the set already\n * holds, and the walk stops. That matters because these reads run inside the\n * pass's write transaction. They are SQLite-specific, like the `sqlite_master`\n * probe below, and rc.0 is SQLite-only.\n *\n * `parentEdges: false` drops the `flows_run_parents` half of `link`. A\n * database that carries the run rows but not the engine's edge table — the\n * control plane's, which migrates the run store and the journal and nothing\n * else — has no edges to walk, and reading the missing table would fail the\n * whole scan. The `parent_run_id` half still runs, so the continuation\n * lineage is guarded there too. The retention pass itself always walks both.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const lineagePrelude = (\n  options: { readonly parentEdges: boolean }\n): string => `\n      WITH RECURSIVE\n        link(child_id, parent_id) AS (\n          ${\n  options.parentEdges\n    ? `SELECT child_id, parent_id FROM flows_run_parents\n          UNION\n          `\n    : ``\n}SELECT run_id, parent_run_id FROM flows_runs WHERE parent_run_id IS NOT NULL\n        ),\n        live(run_id) AS (\n          SELECT run_id FROM flows_runs WHERE status NOT IN (${terminalList})\n        ),\n        under_live(run_id) AS (\n          SELECT link.child_id FROM link JOIN live ON live.run_id = link.parent_id\n          UNION\n          SELECT link.child_id FROM link JOIN under_live ON under_live.run_id = link.parent_id\n        ),\n        over_live(run_id) AS (\n          SELECT link.parent_id FROM link JOIN live ON live.run_id = link.child_id\n          UNION\n          SELECT link.parent_id FROM link JOIN over_live ON over_live.run_id = link.child_id\n        )\n    `\n\n/**\n * The bound one pass may delete, as both passes read it.\n *\n * Clamped, not interpolated: SQLite reads a negative `LIMIT` as no limit at\n * all, which would make a mistyped bound a full sweep, and rejects `NaN` or a\n * fraction as a datatype mismatch. Anything that is not a non-negative safe\n * integer is read as zero, so the pass deletes nothing.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const normalizeLimit = (limit: number | undefined): number => {\n  const bound = limit ?? defaultLimit\n  return Number.isSafeInteger(bound) && bound >= 0 ? bound : 0\n}\n\n/**\n * Which runs a pass may delete, and which it must keep, as CTEs.\n *\n * `eligible` is every terminal run older than the cutoff that no live run\n * stands above or below. `blocked` is every other run plus every ancestor of\n * one over `parent_run_id`: a continuation parent must outlive every child\n * excluded by age or live lineage, and this propagates that exclusion before\n * any bound is applied. `inclusive` says whether a run finished exactly at\n * the cutoff is old enough.\n */\nconst scanPrelude = (\n  sql: SqlClient.SqlClient,\n  options: {\n    readonly cutoffMs: number\n    readonly inclusive: boolean\n    readonly parentEdges: boolean\n    readonly pins?: ReadonlyArray<string> | undefined\n  }\n) =>\n  sql`\n      ${sql.unsafe(lineagePrelude({ parentEdges: options.parentEdges }))},\n      eligible(run_id) AS (\n        SELECT run_id FROM flows_runs\n        WHERE ${sql.in(\"status\", terminalStatuses)}\n          AND ${\n    options.inclusive\n      ? sql`COALESCE(finished_at_ms, created_at_ms) <= ${options.cutoffMs}`\n      : sql`COALESCE(finished_at_ms, created_at_ms) < ${options.cutoffMs}`\n  }\n          AND run_id NOT IN (SELECT run_id FROM under_live)\n          AND run_id NOT IN (SELECT run_id FROM over_live)\n          AND ${\n    options.pins === undefined || options.pins.length === 0 ?\n      sql.literal(\"1 = 1\")\n      : sql`run_id NOT IN ${sql.in(options.pins)}`\n  }\n      ),\n      blocked(run_id) AS (\n        SELECT run_id FROM flows_runs WHERE run_id NOT IN (SELECT run_id FROM eligible)\n        UNION\n        SELECT runs.parent_run_id FROM flows_runs AS runs\n        JOIN blocked ON blocked.run_id = runs.run_id\n        WHERE runs.parent_run_id IS NOT NULL\n      )\n    `\n\n/**\n * The runs one pass deletes: at most `limit` of them, children before parents.\n *\n * The one candidate query, shared by {@link Service.retain} and\n * `Retention.collect`. A trampoline parent always finishes before its\n * successor, so an oldest-first window over a lineage longer than the bound\n * held only ancestors, each pinned by the round just outside the window, and\n * every later pass selected the same window and deleted nothing. Depth walks\n * from roots, visiting each continuation row once; corrupt cycles have no\n * root and cannot enter the deletion set. Excluded runs and their ancestors\n * are dropped before the bound, so pinned parents cannot consume it. The\n * result is presented oldest first.\n *\n * @category getters\n * @since 1.0.0\n */\nexport const candidatesOf = (\n  sql: SqlClient.SqlClient,\n  options: {\n    readonly cutoffMs: number\n    readonly inclusive: boolean\n    readonly parentEdges: boolean\n    readonly pins?: ReadonlyArray<string> | undefined\n    readonly limit: number\n  }\n): Effect.Effect<ReadonlyArray<Candidate>, SqlError> =>\n  sql<{ readonly run_id: string; readonly parent_run_id: string | null }>`\n    ${scanPrelude(sql, options)},\n    depths(run_id, depth) AS (\n      SELECT run_id, 0 FROM flows_runs WHERE parent_run_id IS NULL\n      UNION ALL\n      SELECT runs.run_id, depths.depth + 1 FROM flows_runs AS runs\n      JOIN depths ON runs.parent_run_id = depths.run_id\n    ),\n    selected AS (\n      SELECT runs.run_id, runs.parent_run_id,\n        COALESCE(runs.finished_at_ms, runs.created_at_ms) AS finished_at_ms\n      FROM flows_runs AS runs JOIN depths ON depths.run_id = runs.run_id\n      WHERE runs.run_id NOT IN (SELECT run_id FROM blocked)\n      ORDER BY depths.depth DESC, COALESCE(runs.finished_at_ms, runs.created_at_ms), runs.run_id\n      LIMIT ${normalizeLimit(options.limit)}\n    )\n    SELECT run_id, parent_run_id FROM selected ORDER BY finished_at_ms, run_id\n  `.pipe(\n    Effect.map((rows): ReadonlyArray<Candidate> =>\n      rows.map((row) => ({ runId: row.run_id, parentRunId: row.parent_run_id }))\n    )\n  )\n\n/** Classifies a read of the scan phase, where nothing has been deleted yet. */\nconst scanning = (what: string) => (cause: unknown): RetentionError =>\n  new RetentionError({ code: \"scan_failed\", message: `${what} could not be read`, cause })\n\n/** Classifies a statement of the delete phase, which rolls the pass back. */\nconst deleting = (what: string) => (cause: unknown): RetentionError =>\n  new RetentionError({ code: \"delete_failed\", message: `${what} could not be collected`, cause })\n\nconst chunksOf = (ids: ReadonlyArray<string>): ReadonlyArray<ReadonlyArray<string>> => {\n  const chunks: Array<ReadonlyArray<string>> = []\n  for (let offset = 0; offset < ids.length; offset += chunkSize) {\n    chunks.push(ids.slice(offset, offset + chunkSize))\n  }\n  return chunks\n}\n\n/**\n * A run a pass proposes to delete, and the run it names as its parent.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Candidate {\n  readonly runId: string\n  readonly parentRunId: string | null\n}\n\n/** A run and the candidate it names as its parent. */\ninterface ChildEdge {\n  readonly runId: string\n  readonly parentRunId: string\n}\n\n/**\n * What one deletion pass removed, or would remove under `dryRun`.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface DeletionReport {\n  /** The candidates deleted, in the order they were given. */\n  readonly runIds: ReadonlyArray<string>\n  /** Candidates kept because a run outside the pass still names them. */\n  readonly pinned: ReadonlyArray<string>\n  /**\n   * Rows counted per table, `flows_runs` included, zeroes omitted. Counted\n   * whether or not the pass deletes, so a dry run reports the same numbers.\n   */\n  readonly deleted: Readonly<Record<string, number>>\n}\n\n/** Reads the installed SQLite table names once for inventory decisions. */\nconst installedTableNames = (sql: SqlClient.SqlClient): Effect.Effect<ReadonlySet<string>, RetentionError> =>\n  Dialect.tables(sql).pipe(\n    Effect.map((rows) => new Set(rows.map((row) => row.name))),\n    Effect.mapError(scanning(\"the schema catalog\"))\n  )\n\n/**\n * The {@link runScopedTables} entries this database actually has.\n *\n * `assumeLadder` keeps every entry the ladder installs whether the catalog\n * lists it or not. {@link Service.retain} passes `true`: this package composes\n * the run-store, journal, step-cache and engine migrations, so a ladder table\n * missing from the file it is pointed at is a broken schema, and a delete that\n * refuses says so. `Retention.collect` passes `false`, because it also runs\n * against the control plane's database, which migrates the run store and the\n * journal and nothing else; there a missing ladder table is a host that\n * composed fewer stores, and the pass still owes it a complete sweep of what\n * it has.\n *\n * The catalog read is SQLite-specific, like the lineage prelude above and the\n * `flows_run_parents_gc` trigger this package ships. rc.0 is SQLite-only.\n *\n * @category getters\n * @since 0.1.0\n */\nexport const installedTables = (\n  sql: SqlClient.SqlClient,\n  options: { readonly assumeLadder: boolean }\n): Effect.Effect<ReadonlyArray<RunScopedTable>, RetentionError> =>\n  installedTableNames(sql).pipe(\n    Effect.map((present) =>\n      runScopedTables.filter((entry) => (options.assumeLadder && entry.ladder) || present.has(entry.table))\n    )\n  )\n\nconst countIn = (sql: SqlClient.SqlClient, table: string, column: string, ids: ReadonlyArray<string>) =>\n  Effect.reduce(chunksOf(ids), () => 0, (total, chunk) =>\n    sql<{ readonly total: number }>`\n      SELECT COUNT(*) AS total FROM ${sql.unsafe(table)} WHERE ${sql.in(column, chunk)}\n    `.pipe(\n      Effect.map((rows) => rows.reduce((sum, row) => sum + Number(row.total), total)),\n      Effect.mapError(deleting(table))\n    ))\n\nconst deleteIn = (sql: SqlClient.SqlClient, table: string, column: string, ids: ReadonlyArray<string>) =>\n  Effect.forEach(\n    chunksOf(ids),\n    (chunk) =>\n      sql`DELETE FROM ${sql.unsafe(table)} WHERE ${sql.in(column, chunk)}`.pipe(\n        Effect.mapError(deleting(table))\n      ),\n    { discard: true }\n  )\n\nconst countTimeTravelReceipts = (sql: SqlClient.SqlClient, ids: ReadonlyArray<string>) =>\n  Effect.reduce(chunksOf(ids), () => 0, (total, chunk) =>\n    sql<{ readonly total: number }>`\n      SELECT COUNT(*) AS total\n      FROM flows_time_travel_receipts\n      WHERE audit_id IN (\n        SELECT id FROM flows_time_travel_audits WHERE ${sql.in(\"run_id\", chunk)}\n      )\n    `.pipe(\n      Effect.map((rows) => rows.reduce((sum, row) => sum + Number(row.total), total)),\n      Effect.mapError(deleting(\"flows_time_travel_receipts\"))\n    ))\n\nconst deleteTimeTravelReceipts = (sql: SqlClient.SqlClient, ids: ReadonlyArray<string>) =>\n  Effect.forEach(\n    chunksOf(ids),\n    (chunk) =>\n      sql`\n        DELETE FROM flows_time_travel_receipts\n        WHERE audit_id IN (\n          SELECT id FROM flows_time_travel_audits WHERE ${sql.in(\"run_id\", chunk)}\n        )\n      `.pipe(Effect.mapError(deleting(\"flows_time_travel_receipts\"))),\n    { discard: true }\n  )\n\n/** Every run whose parent is a candidate, candidates included. */\nconst childrenOf = (sql: SqlClient.SqlClient, candidateIds: ReadonlyArray<string>) =>\n  Effect.reduce(\n    chunksOf(candidateIds),\n    (): Array<ChildEdge> => [],\n    (accumulated, chunk) =>\n      // `parent_run_id` is the match predicate, so every row this returns\n      // has one.\n      sql<{ readonly run_id: string; readonly parent_run_id: string }>`\n        SELECT run_id, parent_run_id FROM flows_runs WHERE ${sql.in(\"parent_run_id\", chunk)}\n      `.pipe(\n        Effect.map((rows) => {\n          for (const row of rows) {\n            accumulated.push({ runId: row.run_id, parentRunId: row.parent_run_id })\n          }\n          return accumulated\n        }),\n        Effect.mapError(scanning(\"the run lineage\"))\n      )\n  )\n\n/**\n * Drops from `doomed` every candidate that must outlive this pass, and\n * every ancestor of one.\n *\n * A candidate whose child is not being deleted has to stay: `flows_runs`\n * carries a self-referential foreign key on `parent_run_id`, so deleting\n * it would orphan a row that still exists. Retention is upward-closed for\n * the same reason — once a candidate is retained, the candidate it points\n * at is still referenced and is retained too.\n */\nconst pinAncestors = (\n  doomed: Set<string>,\n  retained: Set<string>,\n  parentOf: ReadonlyMap<string, string | null>,\n  from: string\n): void => {\n  let current: string | undefined = from\n  while (current !== undefined && doomed.has(current)) {\n    doomed.delete(current)\n    retained.add(current)\n    current = parentOf.get(current) ?? undefined\n  }\n}\n\n/**\n * Groups the doomed runs so that no group holds a run and one of its\n * doomed descendants. Deleting a parent while its child row still exists\n * violates the foreign key, and SQLite evaluates it per row rather than at\n * commit, so the delete runs deepest generation first.\n */\nconst generations = (\n  doomed: ReadonlySet<string>,\n  parentOf: ReadonlyMap<string, string | null>\n): ReadonlyArray<ReadonlyArray<string>> => {\n  const depths = new Map<string, number>()\n  const depthOf = (runId: string): number => {\n    const known = depths.get(runId)\n    if (known !== undefined) return known\n    const parent = parentOf.get(runId) ?? undefined\n    const depth = parent !== undefined && doomed.has(parent) ? depthOf(parent) + 1 : 0\n    depths.set(runId, depth)\n    return depth\n  }\n  const byDepth = new Map<number, Array<string>>()\n  for (const runId of doomed) {\n    const depth = depthOf(runId)\n    const bucket = byDepth.get(depth)\n    if (bucket === undefined) byDepth.set(depth, [runId])\n    else bucket.push(runId)\n  }\n  return Array.from(byDepth.keys())\n    .sort((left, right) => right - left)\n    .map((depth) => byDepth.get(depth)!)\n}\n\n/**\n * Deletes `candidates` and every row the inventory says names them.\n *\n * The one deletion in this package. Both passes call it, so neither can be\n * holding a shorter table list than the other, and neither can be deleting\n * run rows in an order the self-referential foreign key refuses: a handoff\n * parent always sorts before its successor, so a pass that deleted in age\n * order broke as soon as one lineage straddled a chunk boundary.\n *\n * The caller owns the transaction. Nothing here is atomic on its own, and a\n * pass that removed the dependents of every candidate and then refused on the\n * run rows would have destroyed history it could not put back.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const deleteRuns = (\n  sql: SqlClient.SqlClient,\n  candidates: ReadonlyArray<Candidate>,\n  options: { readonly dryRun: boolean; readonly assumeLadder: boolean }\n): Effect.Effect<DeletionReport, RetentionError> =>\n  Effect.gen(function*() {\n    const installed = yield* installedTableNames(sql)\n    const tables = runScopedTables.filter((entry) =>\n      (options.assumeLadder && entry.ladder) || installed.has(entry.table)\n    )\n    const hasTimeTravelReceipts = installed.has(\"flows_time_travel_receipts\") &&\n      installed.has(\"flows_time_travel_audits\")\n    const candidateIds = candidates.map((candidate) => candidate.runId)\n    const parentOf = new Map(candidates.map((candidate) => [candidate.runId, candidate.parentRunId]))\n    const doomed = new Set(candidateIds)\n    const pinned = new Set<string>()\n    const candidateSet = new Set(candidateIds)\n    // The foreign key, which no lineage filter covers: a child row that is\n    // terminal and simply outside this pass — younger than the cutoff, or past\n    // the bound — still points at its parent.\n    for (const child of yield* childrenOf(sql, candidateIds)) {\n      if (candidateSet.has(child.runId)) continue\n      pinAncestors(doomed, pinned, parentOf, child.parentRunId)\n    }\n    // `candidates` arrives oldest first, so this reads in the order the pass\n    // collected.\n    const runIds = candidateIds.filter((runId) => doomed.has(runId))\n\n    const companionIds = runIds.flatMap((runId) =>\n      companionStreams.map((stream) => JournalEvent.companionRunId(stream, runId))\n    )\n    const idsFor = (entry: RunScopedTable): ReadonlyArray<string> =>\n      entry.companions === true ? [...runIds, ...companionIds] : runIds\n\n    const deleted: Record<string, number> = {}\n    if (hasTimeTravelReceipts) {\n      const total = yield* countTimeTravelReceipts(sql, runIds)\n      if (total > 0) deleted[\"flows_time_travel_receipts\"] = total\n    }\n    for (const entry of tables) {\n      const total = yield* countIn(sql, entry.table, entry.column, idsFor(entry))\n      if (total > 0) deleted[entry.table] = total\n    }\n    if (runIds.length > 0) deleted[\"flows_runs\"] = runIds.length\n\n    if (!options.dryRun) {\n      // Receipts have no run column, so remove them through their audits\n      // before the ordinary inventory reaches and deletes those audit rows.\n      if (hasTimeTravelReceipts) yield* deleteTimeTravelReceipts(sql, runIds)\n      for (const entry of tables) yield* deleteIn(sql, entry.table, entry.column, idsFor(entry))\n      // Last, and deepest generation first. The `flows_run_parents_gc`\n      // trigger drops each run's DAG edges as its row goes.\n      for (const generation of generations(doomed, parentOf)) {\n        yield* deleteIn(sql, \"flows_runs\", \"run_id\", generation)\n      }\n    }\n\n    return { runIds, pinned: Array.from(pinned), deleted }\n  })\n\n/**\n * Builds the retention operation over the composition's own durable tables.\n *\n * The scan reads `flows_runs` directly, the way `DurableEngineState` and\n * `ArtifactGc` do: this package composes the run-store, journal, and engine\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 | Journal.Journal> =>\n  Effect.gen(function*() {\n    const sql = yield* Effect.service(SqlClient.SqlClient)\n    const journal = yield* Journal.Journal\n\n    /**\n     * Aged terminal runs held by live lineage or an excluded continuation\n     * descendant. An upward exclusion takes precedence over a live ancestor.\n     *\n     * These runs are never candidates — `candidatesOf` excludes them — so this\n     * read exists to say WHY a workspace with aged runs collected fewer than\n     * it holds. It carries the pass's own bound so the report costs no more\n     * than the pass does.\n     */\n    const retainedByLineage = (cutoffMs: number, limit: number) =>\n      sql<{ readonly run_id: string; readonly live_descendant: number }>`\n        ${scanPrelude(sql, { cutoffMs, inclusive: true, parentEdges: true })}\n        SELECT\n          run_id,\n          (run_id IN (SELECT run_id FROM over_live) OR EXISTS (\n            SELECT 1 FROM flows_runs AS child\n            WHERE child.parent_run_id = flows_runs.run_id\n              AND child.run_id IN (SELECT run_id FROM blocked)\n          )) AS live_descendant\n        FROM flows_runs\n        WHERE ${sql.in(\"status\", terminalStatuses)}\n          AND COALESCE(finished_at_ms, created_at_ms) <= ${cutoffMs}\n          AND run_id IN (SELECT run_id FROM blocked)\n        ORDER BY COALESCE(finished_at_ms, created_at_ms), run_id\n        LIMIT ${limit}\n      `.pipe(Effect.mapError(scanning(\"the run lineage\")))\n\n    const pass = (options: RetainOptions, cutoffMs: number) =>\n      Effect.gen(function*() {\n        const limit = normalizeLimit(options.limit)\n        const candidates = yield* candidatesOf(sql, { cutoffMs, inclusive: true, parentEdges: true, limit }).pipe(\n          Effect.mapError(scanning(\"the run table\"))\n        )\n        const retained = new Set<string>()\n        const retainedAbove = new Set<string>()\n        // Why the workspace kept aged runs this pass. These never entered the\n        // candidate set, so this only classifies them. It runs before the\n        // deletes so the report describes the file the pass was handed.\n        for (const held of yield* retainedByLineage(cutoffMs, limit)) {\n          if (Number(held.live_descendant) > 0) retained.add(held.run_id)\n          else retainedAbove.add(held.run_id)\n        }\n        // The whole deletion, shared with `Retention.collect` so the two\n        // passes cannot hold different table lists or different orders. This\n        // database is the engine's own ladder, so a table of it that the\n        // catalog does not list is a broken schema and the delete says so.\n        const removed = yield* deleteRuns(sql, candidates, {\n          dryRun: options.dryRun === true,\n          assumeLadder: true\n        })\n\n        return {\n          cutoffMs,\n          runIds: removed.runIds,\n          retainedForLiveDescendants: Array.from(retained).sort(),\n          retainedForLiveAncestors: Array.from(retainedAbove).sort(),\n          runs: removed.runIds.length,\n          attempts: removed.deleted[\"flows_attempts\"] ?? 0,\n          clockDeadlines: removed.deleted[\"flows_clock_deadlines\"] ?? 0,\n          deferredCompletions: removed.deleted[\"flows_deferred_completions\"] ?? 0,\n          journalEntries: removed.deleted[\"flows_journal_events\"] ?? 0,\n          journalCheckpoints: removed.deleted[\"flows_journal_checkpoints\"] ?? 0,\n          journalIdentities: removed.deleted[\"flows_journal_dedup\"] ?? 0,\n          archiveEntries: removed.deleted[\"flows_time_travel_archive\"] ?? 0,\n          timeTravelReceipts: removed.deleted[\"flows_time_travel_receipts\"] ?? 0,\n          dryRun: options.dryRun === true\n        } satisfies RetainReport\n      })\n\n    const retain: Service[\"retain\"] = Effect.fn(\"Retention.retain\")((options: RetainOptions) =>\n      Effect.gen(function*() {\n        const nowMs = yield* Clock.currentTimeMillis.pipe(Effect.map(Math.floor))\n        const cutoffMs = nowMs - Math.max(0, options.olderThanMs)\n        // One commit: `transact` joins the run-row deletes, the dependent\n        // deletes, and the journal truncation into a single write transaction,\n        // so a crash can never leave a run without its history or history\n        // without its run. A transaction that cannot commit fails as the\n        // `JournalError` it is rather than being laundered into a retention\n        // code that would claim to know why.\n        return yield* journal.transact(pass(options, cutoffMs))\n      })\n    )\n\n    return { retain }\n  })\n\n/**\n * Provides run retention. Nothing schedules `retain()`; invoking it stays an\n * explicit caller decision.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer: Layer.Layer<Retention, never, SqlClient.SqlClient | Journal.Journal> = Layer.effect(Retention)(\n  make()\n)\n"]}

package/dist/esm/internal/RunCatalogOps.d.ts

@@ -0,0 +1,118 @@
+/**
+ * The workspace run catalog read.
+ *
+ * `@smthrs/sync` serves a workspace subscription over a `RunCatalog`, and
+ * every implementation of that service was static (`layerStatic`,
+ * `layerNoop`) or in-process (`makeMemory`, which hears only about runs the
+ * same process registered). A follower composed against any of them saw the
+ * runs that existed when it started and never learned of another run, so a
+ * second engine writing to the same workspace was invisible to it. This
+ * module is the durable half of the fix: the read that says which runs the
+ * workspace has right now, taken from `flows_runs` itself.
+ *
+ * The read is a full set rather than a cursor tail, for one reason: retention
+ * deletes runs. A follower that only ever appended what appeared after a
+ * cursor would keep every collected run in its view forever and hold a
+ * journal stream open for each one. Reading the set makes both directions
+ * work, and the workspace's own bound keeps the cost of it flat.
+ *
+ * Nothing here polls. The interval belongs to the catalog that consumes this
+ * read (`RunCatalog.makePolling` in `@smthrs/sync`), so the durable side has
+ * no policy and no fiber of its own.
+ *
+ * @since 0.1.0
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import * as RunListing from "./RunListing.ts";
+import { RunCatalogError } from "./RunListingError.ts";
+/**
+ * Stable error codes returned by the catalog read.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export { RunCatalogErrorCode } from "./RunListingError.ts";
+/**
+ * A catalog read that could not complete.
+ *
+ * `list_failed` means the workspace's run set could not be read. The caller
+ * keeps whatever view it already had; the read is idempotent, so the next one
+ * converges once the cause is fixed.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export { RunCatalogError } from "./RunListingError.ts";
+/**
+ * Options for one catalog read.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface ListOptions {
+    /**
+     * Largest number of runs the read returns. Defaults to
+     * {@link defaultLimit}. A workspace with more runs than the bound is
+     * followed by its most recent ones; an older run stays readable through a
+     * run-scoped subscription, which names it directly.
+     */
+    readonly limit?: number | undefined;
+}
+/**
+ * The workspace's run set.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Service {
+    /** Revision-consistent, filtered keyset page of execution rows. */
+    readonly listRuns: RunListing.Service["listRuns"];
+    /**
+     * Every run the workspace has, oldest first, bounded by the read. "Oldest"
+     * is the run table's own row order, which is the order `RunStore.create`
+     * inserted them: SQLite hands a new row an identifier above every one in
+     * the table, and reuses one only after the highest is deleted, so deletion
+     * by retention does not reorder what is left.
+     */
+    readonly listRunIds: (options?: ListOptions) => Effect.Effect<ReadonlyArray<string>, RunCatalogError>;
+}
+declare const RunCatalogRead_base: Context.ServiceClass<RunCatalogRead, "@smthrs/engine-store/RunCatalogRead", Service>;
+/**
+ * Service tag for the workspace run catalog read.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export declare class RunCatalogRead extends RunCatalogRead_base {
+}
+/**
+ * Runs one read returns when the caller names no bound. Large enough that an
+ * ordinary workspace is returned whole, small enough that a workspace which
+ * has never been collected does not hand a follower an unbounded list.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const defaultLimit = 10000;
+/**
+ * Builds the catalog read over the composition's own run table.
+ *
+ * The read goes to `flows_runs` directly, the way `DurableEngineState`,
+ * `ArtifactGc`, and `RetentionOps` do: this package composes the run-store
+ * migrations, so the schema is its own.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: () => Effect.Effect<Service, never, SqlClient.SqlClient>;
+/**
+ * Provides the workspace run catalog read.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: Layer.Layer<RunCatalogRead, never, SqlClient.SqlClient>;
+//# sourceMappingURL=RunCatalogOps.d.ts.map

package/dist/esm/internal/RunCatalogOps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunCatalogOps.d.ts","sourceRoot":"","sources":["../../../src/internal/RunCatalogOps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAC1D,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAEtD;;;;;GAKG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAE1D;;;;;;;;;GASG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAEtD;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACpC;AAED;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,mEAAmE;IACnE,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;IACjD;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,WAAW,KAAK,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC,CAAA;CACtG;;AAED;;;;;GAKG;AACH,qBAAa,cAAe,SAAQ,mBAEnC;CAAG;AAEJ;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,QAAS,CAAA;AAElC;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI,QAAO,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,SAAS,CAAC,SAAS,CAgDrE,CAAA;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,cAAc,EAAE,KAAK,EAAE,SAAS,CAAC,SAAS,CAAwC,CAAA"}

package/dist/esm/internal/RunCatalogOps.js

@@ -0,0 +1,120 @@
+/**
+ * The workspace run catalog read.
+ *
+ * `@smthrs/sync` serves a workspace subscription over a `RunCatalog`, and
+ * every implementation of that service was static (`layerStatic`,
+ * `layerNoop`) or in-process (`makeMemory`, which hears only about runs the
+ * same process registered). A follower composed against any of them saw the
+ * runs that existed when it started and never learned of another run, so a
+ * second engine writing to the same workspace was invisible to it. This
+ * module is the durable half of the fix: the read that says which runs the
+ * workspace has right now, taken from `flows_runs` itself.
+ *
+ * The read is a full set rather than a cursor tail, for one reason: retention
+ * deletes runs. A follower that only ever appended what appeared after a
+ * cursor would keep every collected run in its view forever and hold a
+ * journal stream open for each one. Reading the set makes both directions
+ * work, and the workspace's own bound keeps the cost of it flat.
+ *
+ * Nothing here polls. The interval belongs to the catalog that consumes this
+ * read (`RunCatalog.makePolling` in `@smthrs/sync`), so the durable side has
+ * no policy and no fiber of its own.
+ *
+ * @since 0.1.0
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import * as RunListing from "./RunListing.js";
+import { RunCatalogError } from "./RunListingError.js";
+/**
+ * Stable error codes returned by the catalog read.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export { RunCatalogErrorCode } from "./RunListingError.js";
+/**
+ * A catalog read that could not complete.
+ *
+ * `list_failed` means the workspace's run set could not be read. The caller
+ * keeps whatever view it already had; the read is idempotent, so the next one
+ * converges once the cause is fixed.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export { RunCatalogError } from "./RunListingError.js";
+/**
+ * Service tag for the workspace run catalog read.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export class RunCatalogRead extends Context.Service()("@smthrs/engine-store/RunCatalogRead") {
+}
+/**
+ * Runs one read returns when the caller names no bound. Large enough that an
+ * ordinary workspace is returned whole, small enough that a workspace which
+ * has never been collected does not hand a follower an unbounded list.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export const defaultLimit = 10_000;
+/**
+ * Builds the catalog read over the composition's own run table.
+ *
+ * The read goes to `flows_runs` directly, the way `DurableEngineState`,
+ * `ArtifactGc`, and `RetentionOps` do: this package composes the run-store
+ * migrations, so the schema is its own.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export const make = () => Effect.gen(function* () {
+    const sql = yield* Effect.service(SqlClient.SqlClient);
+    const listing = yield* RunListing.make();
+    // Newest first by `rowid`, then reversed. `rowid` is the order the
+    // workspace gained its runs, and reading it backwards walks the table's
+    // own b-tree, so the bound costs one seek rather than a sort of every
+    // run: `flows_runs` carries no index on `created_at_ms`, and two runs
+    // created in the same millisecond do not order by it at all.
+    //
+    // `flows_runs` has a TEXT primary key, so its `rowid` is not an alias of
+    // a declared column and SQLite documents that a rebuild may reassign it.
+    // The order the rebuild leaves is what this read depends on, not the
+    // numbers, and `VACUUM INTO` — the hot backup this release ships, and the
+    // only rebuild in the supported path (the release policy) — preserves
+    // it. `RunCatalogCatchUp.test.ts` pins that across a real backup and
+    // reopen, including after retention has deleted rows out of the middle
+    // and the end.
+    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 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 RunCatalogError({
+            code: "list_failed",
+            message: "the workspace run set could not be read",
+            cause
+        })));
+    }));
+    return { listRunIds, ...listing };
+});
+/**
+ * Provides the workspace run catalog read.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export const layer = Layer.effect(RunCatalogRead)(make());
+//# sourceMappingURL=RunCatalogOps.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RunCatalogOps.js","sourceRoot":"","sources":["../../../src/internal/RunCatalogOps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAC1D,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAEtD;;;;;GAKG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAE1D;;;;;;;;;GASG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAqCtD;;;;;GAKG;AACH,MAAM,OAAO,cAAe,SAAQ,OAAO,CAAC,OAAO,EAA2B,CAC5E,qCAAqC,CACtC;CAAG;AAEJ;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,MAAM,CAAA;AAElC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,GAAuD,EAAE,CAC3E,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC,CAAA;IACtD,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,CAAA;IAExC,mEAAmE;IACnE,wEAAwE;IACxE,sEAAsE;IACtE,sEAAsE;IACtE,6DAA6D;IAC7D,EAAE;IACF,yEAAyE;IACzE,yEAAyE;IACzE,qEAAqE;IACrE,0EAA0E;IAC1E,sEAAsE;IACtE,qEAAqE;IACrE,uEAAuE;IACvE,eAAe;IACf,MAAM,UAAU,GAA0B,MAAM,CAAC,EAAE,CAAC,uBAAuB,CAAC,CAAC,CAAC,OAAqB,EAAE,EAAE,CACrG,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QAClB,MAAM,KAAK,GAAG,OAAO,EAAE,KAAK,IAAI,YAAY,CAAA;QAC5C,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YAC9C,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CACvB,IAAI,eAAe,CAAC;gBAClB,IAAI,EAAE,iBAAiB;gBACvB,OAAO,EAAE,2DAA2D;aACrE,CAAC,CACH,CAAA;QACH,CAAC;QACD,OAAO,KAAK,CAAC,CAAC,GAAG,CAA6B;;;kBAGpC,KAAK;SACd,CAAC,IAAI,CACJ,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,CAAC,EAC7D,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE,CACxB,IAAI,eAAe,CAAC;YAClB,IAAI,EAAE,aAAa;YACnB,OAAO,EAAE,yCAAyC;YAClD,KAAK;SACN,CAAC,CACH,CACF,CAAA;IACH,CAAC,CAAC,CACH,CAAA;IAED,OAAO,EAAE,UAAU,EAAE,GAAG,OAAO,EAAE,CAAA;AACnC,CAAC,CAAC,CAAA;AAEJ;;;;;GAKG;AACH,MAAM,CAAC,MAAM,KAAK,GAA4D,KAAK,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,IAAI,EAAE,CAAC,CAAA","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` — the hot backup this release ships, and the\n    // only rebuild in the supported path (the release policy) — 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"]}

package/dist/esm/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/esm/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/esm/internal/RunCoordinator.js

@@ -0,0 +1,115 @@
+/**
+ * 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 { Cause, Deferred, Effect, Exit, Fiber, FiberSet } from "effect";
+/**
+ * Creates a scoped coordinator for keyed drain effects.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export const make = (options) => Effect.gen(function* () {
+    const active = new Map();
+    const fork = yield* FiberSet.makeRuntime();
+    const makeEntry = () => ({
+        done: Deferred.makeUnsafe(),
+        pendingWake: false,
+        stopping: false
+    });
+    const start = (key, entry, successor = false, onlyIf = Effect.succeed(true)) => {
+        const ready = Deferred.makeUnsafe();
+        const owner = fork((successor ? Effect.yieldNow : Deferred.await(ready)).pipe(Effect.andThen(onlyIf), Effect.flatMap((ready) => ready ? Effect.suspend(() => options.drain(key)) : Effect.void), Effect.onError((cause) => Cause.hasInterruptsOnly(cause)
+            ? Effect.void
+            : Effect.logWarning(`engine-store: coordinated drain failed for ${String(key)}`, cause)), Effect.onExit((exit) => Effect.sync(() => settle(key, entry, exit))), Effect.exit, Effect.asVoid));
+        entry.owner = owner;
+        if (!successor)
+            Deferred.doneUnsafe(ready, Effect.void);
+    };
+    const settle = (key, entry, exit) => {
+        if (Exit.isSuccess(exit) && !entry.stopping && entry.pendingWake) {
+            entry.pendingWake = false;
+            start(key, entry, true);
+            return;
+        }
+        const successor = entry.pendingWake ? makeEntry() : undefined;
+        if (successor === undefined)
+            active.delete(key);
+        else {
+            active.set(key, successor);
+            start(key, successor, true);
+        }
+        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) => Effect.uninterruptibleMask((restore) => {
+        const entry = active.get(key);
+        if (entry !== undefined) {
+            /* v8 ignore next -- stopping is a cooperative-scheduler handoff covered by the cleanup race test */
+            if (entry.stopping)
+                return restore(Deferred.await(entry.done).pipe(Effect.andThen(run(key))));
+            return restore(Deferred.await(entry.done));
+        }
+        return restore(Deferred.await(startIdle(key).done));
+    });
+    const join = (key) => Effect.suspend(() => {
+        const entry = active.get(key);
+        return entry === undefined ? Effect.void : Deferred.await(entry.done);
+    });
+    const schedule = (key) => Effect.sync(() => {
+        if (!active.has(key))
+            startIdle(key);
+    });
+    const scheduleIf = (key, ready) => Effect.sync(() => {
+        if (!active.has(key))
+            startIdle(key, ready);
+    });
+    const wake = (key) => Effect.sync(() => {
+        const entry = active.get(key);
+        if (entry !== undefined) {
+            entry.pendingWake = true;
+            return;
+        }
+        startIdle(key);
+    });
+    const interrupt = (key) => Effect.suspend(() => {
+        const entry = active.get(key);
+        if (entry?.owner === undefined)
+            return Effect.void;
+        entry.stopping = true;
+        entry.pendingWake = false;
+        return Fiber.interrupt(entry.owner);
+    });
+    const requestInterrupt = (key) => Effect.withFiber((fiber) => Effect.sync(() => {
+        const entry = active.get(key);
+        if (entry?.owner === undefined)
+            return;
+        entry.stopping = true;
+        entry.pendingWake = false;
+        entry.owner.interruptUnsafe(fiber.id);
+    }));
+    return {
+        active: Effect.fn("RunCoordinator.active")(() => Effect.sync(() => new Set(active.keys())))(),
+        run: Effect.fn("RunCoordinator.run")(run),
+        join: Effect.fn("RunCoordinator.join")(join),
+        schedule: Effect.fn("RunCoordinator.schedule")(schedule),
+        scheduleIf: Effect.fn("RunCoordinator.scheduleIf")(scheduleIf),
+        wake: Effect.fn("RunCoordinator.wake")(wake),
+        interrupt: Effect.fn("RunCoordinator.interrupt")(interrupt),
+        requestInterrupt: Effect.fn("RunCoordinator.requestInterrupt")(requestInterrupt)
+    };
+});
+//# sourceMappingURL=RunCoordinator.js.map

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

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