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

package/dist/cjs/ReplayOnly.d.ts

@@ -0,0 +1,91 @@
+/**
+ * An engine that replays recorded work and executes none.
+ *
+ * `smthrs runs verify` asks what a resume under the current code would do
+ * before anything runs: which recorded steps it would serve from their
+ * durable records, and which step it would execute again because its key no
+ * longer matches one. The engine is the only thing that can answer, because a
+ * step key is derived at dispatch from the running flow's own declaration,
+ * ordinal and scope. This service turns a durable engine into that question:
+ * a dispatch served from a durable record reports `replayed`, and the first
+ * dispatch that would run an action body dies with {@link WouldExecute} before
+ * any attempt row, snapshot, boundary or body. It reports `resumes` when it
+ * would re-enter a recorded attempt that never finished (a step parked inside
+ * its body), and `would-execute` when no record matches its key at all.
+ *
+ * The death is a defect on purpose. A typed failure would enter the action's
+ * retry policy, and the default policy never gives up; a defect is never
+ * retried, so the run settles with the verdict instead of spinning on it.
+ *
+ * Run it against a copy of the store. A replay still converges the journal
+ * rows a resume would write, and the run settles `failed` on the copy.
+ *
+ * @since 1.0.0
+ */
+import * as Context from "effect/Context";
+import type * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+/**
+ * One dispatch a replay-only engine saw.
+ *
+ * `stepKeyDigest` is the identity `flows_attempts` rows are keyed on, so a
+ * reader joins it to the recorded attempts directly. `action` is the declared
+ * action name. `outcome` is `replayed` for a dispatch served from a durable
+ * record (a recorded failure included), `resumes` for one that would re-enter
+ * a recorded attempt that never finished, and `would-execute` for one no
+ * record matches.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Dispatch {
+    readonly runId: string;
+    readonly stepKeyDigest: string;
+    readonly attempt: number;
+    readonly action: string;
+    readonly tier: "sealed" | "compensable" | "irreversible";
+    readonly outcome: "replayed" | "resumes" | "would-execute";
+}
+/**
+ * Receives every dispatch a replay-only engine settles, in settlement order.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Service {
+    readonly observe: (dispatch: Dispatch) => Effect.Effect<void>;
+}
+declare const ReplayOnly_base: Context.ServiceClass<ReplayOnly, "@smthrs/engine-store/ReplayOnly", Service>;
+/**
+ * Service tag. An engine composed with it in context executes no action body.
+ *
+ * @since 1.0.0
+ * @category services
+ */
+export declare class ReplayOnly extends ReplayOnly_base {
+}
+declare const WouldExecute_base: Schema.Class<WouldExecute, Schema.TaggedStruct<"@smthrs/engine-store/WouldExecute", {
+    readonly runId: Schema.String;
+    readonly stepKeyDigest: Schema.String;
+    readonly attempt: Schema.Number;
+    readonly action: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The defect a replay-only dispatch dies with instead of executing.
+ *
+ * @since 1.0.0
+ * @category errors
+ */
+export declare class WouldExecute extends WouldExecute_base {
+    get message(): string;
+}
+/**
+ * Provides a replay-only engine context that reports to `observe`.
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layer: (observe: Service["observe"]) => Layer.Layer<ReplayOnly>;
+export {};
+//# sourceMappingURL=ReplayOnly.d.ts.map

package/dist/cjs/ReplayOnly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReplayOnly.d.ts","sourceRoot":"","sources":["../../src/ReplayOnly.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,aAAa,GAAG,cAAc,CAAA;IACxD,QAAQ,CAAC,OAAO,EAAE,UAAU,GAAG,SAAS,GAAG,eAAe,CAAA;CAC3D;AAED;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CAC9D;;AAED;;;;;GAKG;AACH,qBAAa,UAAW,SAAQ,eAAyE;CAAG;;;;;;;AAE5G;;;;;GAKG;AACH,qBAAa,YAAa,SAAQ,iBAKhC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;AAED;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,SAAS,OAAO,CAAC,SAAS,CAAC,KAAG,KAAK,CAAC,KAAK,CAAC,UAAU,CACnB,CAAA"}

package/dist/cjs/ReplayOnly.js

@@ -0,0 +1,52 @@
+"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 ReplayOnly_exports = {};
+__export(ReplayOnly_exports, {
+  ReplayOnly: () => ReplayOnly,
+  WouldExecute: () => WouldExecute,
+  layer: () => layer
+});
+module.exports = __toCommonJS(ReplayOnly_exports);
+var Context = __toESM(require("effect/Context"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+class ReplayOnly extends Context.Service()("@smthrs/engine-store/ReplayOnly") {
+}
+class WouldExecute extends Schema.TaggedError()("@smthrs/engine-store/WouldExecute", {
+  runId: Schema.String,
+  stepKeyDigest: Schema.String,
+  attempt: Schema.Number,
+  action: Schema.String
+}) {
+  get message() {
+    return `Action ${this.action} (step ${this.stepKeyDigest}, attempt ${this.attempt}) would execute`;
+  }
+}
+const layer = (observe) => Layer.succeed(ReplayOnly, ReplayOnly.of({ observe }));
+//# sourceMappingURL=ReplayOnly.js.map

package/dist/cjs/ReplayOnly.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/ReplayOnly.ts"],
+  "sourcesContent": ["/**\n * An engine that replays recorded work and executes none.\n *\n * `smthrs runs verify` asks what a resume under the current code would do\n * before anything runs: which recorded steps it would serve from their\n * durable records, and which step it would execute again because its key no\n * longer matches one. The engine is the only thing that can answer, because a\n * step key is derived at dispatch from the running flow's own declaration,\n * ordinal and scope. This service turns a durable engine into that question:\n * a dispatch served from a durable record reports `replayed`, and the first\n * dispatch that would run an action body dies with {@link WouldExecute} before\n * any attempt row, snapshot, boundary or body. It reports `resumes` when it\n * would re-enter a recorded attempt that never finished (a step parked inside\n * its body), and `would-execute` when no record matches its key at all.\n *\n * The death is a defect on purpose. A typed failure would enter the action's\n * retry policy, and the default policy never gives up; a defect is never\n * retried, so the run settles with the verdict instead of spinning on it.\n *\n * Run it against a copy of the store. A replay still converges the journal\n * rows a resume would write, and the run settles `failed` on the copy.\n *\n * @since 1.0.0\n */\n\nimport * as Context from \"effect/Context\"\nimport type * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport * as Schema from \"effect/Schema\"\n\n/**\n * One dispatch a replay-only engine saw.\n *\n * `stepKeyDigest` is the identity `flows_attempts` rows are keyed on, so a\n * reader joins it to the recorded attempts directly. `action` is the declared\n * action name. `outcome` is `replayed` for a dispatch served from a durable\n * record (a recorded failure included), `resumes` for one that would re-enter\n * a recorded attempt that never finished, and `would-execute` for one no\n * record matches.\n *\n * @since 1.0.0\n * @category models\n */\nexport interface Dispatch {\n  readonly runId: string\n  readonly stepKeyDigest: string\n  readonly attempt: number\n  readonly action: string\n  readonly tier: \"sealed\" | \"compensable\" | \"irreversible\"\n  readonly outcome: \"replayed\" | \"resumes\" | \"would-execute\"\n}\n\n/**\n * Receives every dispatch a replay-only engine settles, in settlement order.\n *\n * @since 1.0.0\n * @category models\n */\nexport interface Service {\n  readonly observe: (dispatch: Dispatch) => Effect.Effect<void>\n}\n\n/**\n * Service tag. An engine composed with it in context executes no action body.\n *\n * @since 1.0.0\n * @category services\n */\nexport class ReplayOnly extends Context.Service<ReplayOnly, Service>()(\"@smthrs/engine-store/ReplayOnly\") {}\n\n/**\n * The defect a replay-only dispatch dies with instead of executing.\n *\n * @since 1.0.0\n * @category errors\n */\nexport class WouldExecute extends Schema.TaggedError<WouldExecute>()(\"@smthrs/engine-store/WouldExecute\", {\n  runId: Schema.String,\n  stepKeyDigest: Schema.String,\n  attempt: Schema.Number,\n  action: Schema.String\n}) {\n  override get message(): string {\n    return `Action ${this.action} (step ${this.stepKeyDigest}, attempt ${this.attempt}) would execute`\n  }\n}\n\n/**\n * Provides a replay-only engine context that reports to `observe`.\n *\n * @since 1.0.0\n * @category layers\n */\nexport const layer = (observe: Service[\"observe\"]): Layer.Layer<ReplayOnly> =>\n  Layer.succeed(ReplayOnly, ReplayOnly.of({ observe }))\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAyBA,cAAyB;AAEzB,YAAuB;AACvB,aAAwB;AAwCjB,MAAM,mBAAmB,QAAQ,QAA6B,EAAE,iCAAiC,EAAE;AAAC;AAQpG,MAAM,qBAAqB,OAAO,YAA0B,EAAE,qCAAqC;AAAA,EACxG,OAAO,OAAO;AAAA,EACd,eAAe,OAAO;AAAA,EACtB,SAAS,OAAO;AAAA,EAChB,QAAQ,OAAO;AACjB,CAAC,EAAE;AAAA,EACD,IAAa,UAAkB;AAC7B,WAAO,UAAU,KAAK,MAAM,UAAU,KAAK,aAAa,aAAa,KAAK,OAAO;AAAA,EACnF;AACF;AAQO,MAAM,QAAQ,CAAC,YACpB,MAAM,QAAQ,YAAY,WAAW,GAAG,EAAE,QAAQ,CAAC,CAAC;",
+  "names": []
+}

package/dist/cjs/Retention.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Deleting run history that has outlived its usefulness.
+ *
+ * Nothing in the durable stores forgets on its own: a finished run keeps its
+ * row, every attempt, every journal event, and every archived frame forever.
+ * That is the right default — a run's history is the only account of what an
+ * agent did to a repository — and it is why `smithers gc` exists rather than a
+ * background sweeper. Retention is an operator decision, taken explicitly,
+ * with a dry run available before anything is deleted.
+ *
+ * This module is the public surface. The operation lives in
+ * `internal/RetentionOps.ts` beside the other modules that read this package's
+ * own tables, so `internal/` is never imported by a consumer — the same split
+ * `Errors.ts` uses. {@link retain} and {@link layer} are that operation: one
+ * bounded pass over the engine ladder, inside one `journal.transact`.
+ *
+ * {@link collect} is the host-facing pass `smithers gc` runs, and it is a
+ * facade over the same guard. A project keeps its history in two files — the
+ * control plane's database and the engine's — and a sweep of one without the
+ * other leaves half of a deleted run behind, so the pass takes the database as
+ * a service and runs once per file. Which runs it may delete is
+ * {@link RetentionOps.lineagePrelude}'s answer, not a second guard written
+ * here: a run stays whenever a live run stands above or below it, over BOTH
+ * relations that make one run the parent of another — the `flows_run_parents`
+ * edge a spawned child records, and the `parent_run_id` column a trampoline
+ * lineage is chained through.
+ *
+ * Only terminal runs are ever considered. A `pending`, `running`, or
+ * `suspended` row belongs to work that can still resume.
+ *
+ * @since 1.0.0
+ */
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+import * as RetentionOps from "./internal/RetentionOps.ts";
+export { defaultLimit, layer, make, type RetainOptions, type RetainReport, Retention, RetentionError, RetentionErrorCode, type RunScopedTable, 
+/**
+ * Every table a deleted run leaves rows in. One inventory serves this pass
+ * and {@link Service.retain}, so neither can leak what the other deletes.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+runScopedTables, type Service, terminalStatuses } from "./internal/RetentionOps.ts";
+/**
+ * What one retention pass would delete, or did.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Report {
+    readonly database: string;
+    /** The threshold, as an epoch millisecond value. */
+    readonly olderThanMs: number;
+    readonly runs: ReadonlyArray<string>;
+    /** Rows deleted per table; empty under a dry run. */
+    readonly deleted: Readonly<Record<string, number>>;
+    readonly dryRun: boolean;
+}
+/**
+ * Arguments accepted by {@link collect}.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Options {
+    /** Delete terminal runs that finished strictly before this epoch millisecond. */
+    readonly olderThanMs: number;
+    readonly dryRun?: boolean | undefined;
+    /** A label for the report; the host's database path. */
+    readonly database?: string | undefined;
+    /** Largest number of runs considered by this pass. Defaults to 1,000. */
+    readonly limit?: number | undefined;
+    /** Runs retained by a host's cross-store ancestry, in addition to local live roots. */
+    readonly pins?: ReadonlyArray<string> | undefined;
+}
+/**
+ * The terminal runs one pass would delete, oldest first.
+ *
+ * @category getters
+ * @since 1.0.0
+ */
+export declare const eligible: (olderThanMs: number, limit?: number) => Effect.Effect<ReadonlyArray<string>, SqlError, SqlClient.SqlClient>;
+/**
+ * Runs one retention pass.
+ *
+ * The deletion itself is {@link RetentionOps.deleteRuns}, the same one
+ * {@link Service.retain} runs, so this pass cannot hold a shorter table list
+ * than that one and cannot delete run rows in an order the self-referential
+ * `parent_run_id` foreign key refuses. A handoff parent always sorts before
+ * its successor, so deleting in age order broke as soon as one lineage
+ * straddled a chunk boundary, and it broke AFTER the dependent rows of every
+ * eligible run were already gone. `assumeLadder: false` because this pass also
+ * runs against the control plane's database, which composed fewer stores.
+ *
+ * Eligibility and deletion share one retryable transaction: another writer
+ * cannot attach a live parent between the lineage scan and deletion. A busy
+ * retry recomputes eligibility rather than replaying an old candidate list.
+ * One transaction, for the reason `retain` opens one: a pass that removed a
+ * run's history and then refused on its row would have destroyed what it could
+ * not put back, and a workspace whose next pass refuses the same way can never
+ * be collected again.
+ *
+ * Under `dryRun` nothing is written and `deleted` is empty: the report names
+ * exactly the runs a real pass would remove, which is what makes
+ * `smithers gc --dry-run` worth trusting.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const collect: (options: Options) => Effect.Effect<Report, SqlError | RetentionOps.RetentionError, SqlClient.SqlClient>;
+//# sourceMappingURL=Retention.d.ts.map

package/dist/cjs/Retention.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Retention.d.ts","sourceRoot":"","sources":["../../src/Retention.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAIH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAA;AAC5D,OAAO,KAAK,YAAY,MAAM,4BAA4B,CAAA;AAE1D,OAAO,EACL,YAAY,EACZ,KAAK,EACL,IAAI,EACJ,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,SAAS,EACT,cAAc,EACd,kBAAkB,EAClB,KAAK,cAAc;AACnB;;;;;;GAMG;AACH,eAAe,EACf,KAAK,OAAO,EACZ,gBAAgB,EACjB,MAAM,4BAA4B,CAAA;AAEnC;;;;;GAKG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,oDAAoD;IACpD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACpC,qDAAqD;IACrD,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAClD,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CACzB;AAED;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,iFAAiF;IACjF,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IACrC,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,yEAAyE;IACzE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,uFAAuF;IACvF,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,SAAS,CAAA;CAClD;AA4CD;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GACnB,aAAa,MAAM,EACnB,cAAiC,KAChC,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,SAAS,CAIlE,CAAA;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,OAAO,GAClB,SAAS,OAAO,KACf,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,GAAG,YAAY,CAAC,cAAc,EAAE,SAAS,CAAC,SAAS,CA+BhF,CAAA"}

package/dist/cjs/Retention.js

@@ -0,0 +1,99 @@
+"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 Retention_exports = {};
+__export(Retention_exports, {
+  Retention: () => import_RetentionOps.Retention,
+  RetentionError: () => import_RetentionOps.RetentionError,
+  RetentionErrorCode: () => import_RetentionOps.RetentionErrorCode,
+  collect: () => collect,
+  defaultLimit: () => import_RetentionOps.defaultLimit,
+  eligible: () => eligible,
+  layer: () => import_RetentionOps.layer,
+  make: () => import_RetentionOps.make,
+  runScopedTables: () => import_RetentionOps.runScopedTables,
+  terminalStatuses: () => import_RetentionOps.terminalStatuses
+});
+module.exports = __toCommonJS(Retention_exports);
+var Dialect = __toESM(require("@smthrs/database/Dialect"), 1);
+var DurableWriter = __toESM(require("@smthrs/database/DurableWriter"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var SqlClient = __toESM(require("effect/unstable/sql/SqlClient"), 1);
+var RetentionOps = __toESM(require("./internal/RetentionOps.js"), 1);
+var import_RetentionOps = require("./internal/RetentionOps.js");
+const hasTable = (table) => Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  const rows = yield* Dialect.tables(sql).pipe(Effect.map((rows2) => rows2.filter((row) => row.name === table)));
+  return rows.length > 0;
+});
+const eligibleCandidates = (olderThanMs, limit, pins) => Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  if (!(yield* hasTable("flows_runs"))) return [];
+  return yield* RetentionOps.candidatesOf(sql, {
+    cutoffMs: olderThanMs,
+    inclusive: false,
+    parentEdges: yield* hasTable("flows_run_parents"),
+    pins,
+    limit: RetentionOps.normalizeLimit(limit)
+  });
+});
+const eligible = (olderThanMs, limit = RetentionOps.defaultLimit) => Effect.map(
+  eligibleCandidates(olderThanMs, limit),
+  (candidates) => candidates.map((candidate) => candidate.runId)
+);
+const collect = (options) => Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  const dryRun = options.dryRun === true;
+  const pass = Effect.gen(function* () {
+    const candidates = yield* eligibleCandidates(options.olderThanMs, options.limit, options.pins);
+    return yield* RetentionOps.deleteRuns(sql, candidates, {
+      dryRun,
+      assumeLadder: false
+    });
+  });
+  const removed = yield* dryRun ? sql.withTransaction(pass) : DurableWriter.make(sql).write(pass).pipe(
+    Effect.catchIf(
+      (cause) => cause instanceof DurableWriter.DatabaseError,
+      (cause) => Effect.fail(
+        new RetentionOps.RetentionError({
+          code: "delete_failed",
+          message: "retention transaction failed; no history was deleted",
+          cause
+        })
+      )
+    )
+  );
+  return {
+    database: options.database ?? "",
+    olderThanMs: options.olderThanMs,
+    runs: removed.runIds,
+    deleted: dryRun ? {} : removed.deleted,
+    dryRun
+  };
+});
+//# sourceMappingURL=Retention.js.map

package/dist/cjs/Retention.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Retention.ts"],
+  "sourcesContent": ["/**\n * Deleting run history that has outlived its usefulness.\n *\n * Nothing in the durable stores forgets on its own: a finished run keeps its\n * row, every attempt, every journal event, and every archived frame forever.\n * That is the right default \u2014 a run's history is the only account of what an\n * agent did to a repository \u2014 and it is why `smithers gc` exists rather than a\n * background sweeper. Retention is an operator decision, taken explicitly,\n * with a dry run available before anything is deleted.\n *\n * This module is the public surface. The operation lives in\n * `internal/RetentionOps.ts` beside the other modules that read this package's\n * own tables, so `internal/` is never imported by a consumer \u2014 the same split\n * `Errors.ts` uses. {@link retain} and {@link layer} are that operation: one\n * bounded pass over the engine ladder, inside one `journal.transact`.\n *\n * {@link collect} is the host-facing pass `smithers gc` runs, and it is a\n * facade over the same guard. A project keeps its history in two files \u2014 the\n * control plane's database and the engine's \u2014 and a sweep of one without the\n * other leaves half of a deleted run behind, so the pass takes the database as\n * a service and runs once per file. Which runs it may delete is\n * {@link RetentionOps.lineagePrelude}'s answer, not a second guard written\n * here: a run stays whenever a live run stands above or below it, over BOTH\n * relations that make one run the parent of another \u2014 the `flows_run_parents`\n * edge a spawned child records, and the `parent_run_id` column a trampoline\n * lineage is chained through.\n *\n * Only terminal runs are ever considered. A `pending`, `running`, or\n * `suspended` row belongs to work that can still resume.\n *\n * @since 1.0.0\n */\n\nimport * as Dialect from \"@smthrs/database/Dialect\"\nimport * as DurableWriter from \"@smthrs/database/DurableWriter\"\nimport * as Effect from \"effect/Effect\"\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\"\nimport type { SqlError } from \"effect/unstable/sql/SqlError\"\nimport * as RetentionOps from \"./internal/RetentionOps.ts\"\n\nexport {\n  defaultLimit,\n  layer,\n  make,\n  type RetainOptions,\n  type RetainReport,\n  Retention,\n  RetentionError,\n  RetentionErrorCode,\n  type RunScopedTable,\n  /**\n   * Every table a deleted run leaves rows in. One inventory serves this pass\n   * and {@link Service.retain}, so neither can leak what the other deletes.\n   *\n   * @category constants\n   * @since 1.0.0\n   */\n  runScopedTables,\n  type Service,\n  terminalStatuses\n} from \"./internal/RetentionOps.ts\"\n\n/**\n * What one retention pass would delete, or did.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Report {\n  readonly database: string\n  /** The threshold, as an epoch millisecond value. */\n  readonly olderThanMs: number\n  readonly runs: ReadonlyArray<string>\n  /** Rows deleted per table; empty under a dry run. */\n  readonly deleted: Readonly<Record<string, number>>\n  readonly dryRun: boolean\n}\n\n/**\n * Arguments accepted by {@link collect}.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Options {\n  /** Delete terminal runs that finished strictly before this epoch millisecond. */\n  readonly olderThanMs: number\n  readonly dryRun?: boolean | undefined\n  /** A label for the report; the host's database path. */\n  readonly database?: string | undefined\n  /** Largest number of runs considered by this pass. Defaults to 1,000. */\n  readonly limit?: number | undefined\n  /** Runs retained by a host's cross-store ancestry, in addition to local live roots. */\n  readonly pins?: ReadonlyArray<string> | undefined\n}\n\n/** Whether a table exists in the connected database. */\nconst hasTable = (table: string): Effect.Effect<boolean, SqlError, SqlClient.SqlClient> =>\n  Effect.gen(function*() {\n    const sql = yield* SqlClient.SqlClient\n    const rows = yield* Dialect.tables(sql).pipe(Effect.map((rows) => rows.filter((row) => row.name === table)))\n    return rows.length > 0\n  })\n\n/**\n * The runs one pass would delete, oldest first, each with the run it names as\n * its parent.\n *\n * The same candidate query `retain` runs: children before parents, so a\n * trampoline lineage longer than the bound still loses a run every pass, and\n * a run is excluded whenever a live run stands above or below it. Downward,\n * deleting a parent whose child is still running would break the\n * `parent_run_id` foreign key and drop the live child's edges with the\n * `flows_run_parents_gc` trigger. Upward, a parked parent still reads a\n * settled child's result out of its run row through `agent/await`, and it can\n * be parked for longer than the threshold before it ever asks.\n */\nconst eligibleCandidates = (\n  olderThanMs: number,\n  limit: number | undefined,\n  pins?: ReadonlyArray<string>\n): Effect.Effect<ReadonlyArray<RetentionOps.Candidate>, SqlError, SqlClient.SqlClient> =>\n  Effect.gen(function*() {\n    const sql = yield* SqlClient.SqlClient\n    if (!(yield* hasTable(\"flows_runs\"))) return []\n    // The engine's edge table is absent from the control-plane database, which\n    // migrates the run store and the journal and nothing else. The prelude\n    // drops that half of the walk there and keeps the `parent_run_id` half, so\n    // one guard covers both files.\n    return yield* RetentionOps.candidatesOf(sql, {\n      cutoffMs: olderThanMs,\n      inclusive: false,\n      parentEdges: yield* hasTable(\"flows_run_parents\"),\n      pins,\n      limit: RetentionOps.normalizeLimit(limit)\n    })\n  })\n\n/**\n * The terminal runs one pass would delete, oldest first.\n *\n * @category getters\n * @since 1.0.0\n */\nexport const eligible = (\n  olderThanMs: number,\n  limit = RetentionOps.defaultLimit\n): Effect.Effect<ReadonlyArray<string>, SqlError, SqlClient.SqlClient> =>\n  Effect.map(\n    eligibleCandidates(olderThanMs, limit),\n    (candidates) => candidates.map((candidate) => candidate.runId)\n  )\n\n/**\n * Runs one retention pass.\n *\n * The deletion itself is {@link RetentionOps.deleteRuns}, the same one\n * {@link Service.retain} runs, so this pass cannot hold a shorter table list\n * than that one and cannot delete run rows in an order the self-referential\n * `parent_run_id` foreign key refuses. A handoff parent always sorts before\n * its successor, so deleting in age order broke as soon as one lineage\n * straddled a chunk boundary, and it broke AFTER the dependent rows of every\n * eligible run were already gone. `assumeLadder: false` because this pass also\n * runs against the control plane's database, which composed fewer stores.\n *\n * Eligibility and deletion share one retryable transaction: another writer\n * cannot attach a live parent between the lineage scan and deletion. A busy\n * retry recomputes eligibility rather than replaying an old candidate list.\n * One transaction, for the reason `retain` opens one: a pass that removed a\n * run's history and then refused on its row would have destroyed what it could\n * not put back, and a workspace whose next pass refuses the same way can never\n * be collected again.\n *\n * Under `dryRun` nothing is written and `deleted` is empty: the report names\n * exactly the runs a real pass would remove, which is what makes\n * `smithers gc --dry-run` worth trusting.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const collect = (\n  options: Options\n): Effect.Effect<Report, SqlError | RetentionOps.RetentionError, SqlClient.SqlClient> =>\n  Effect.gen(function*() {\n    const sql = yield* SqlClient.SqlClient\n    const dryRun = options.dryRun === true\n    const pass = Effect.gen(function*() {\n      const candidates = yield* eligibleCandidates(options.olderThanMs, options.limit, options.pins)\n      return yield* RetentionOps.deleteRuns(sql, candidates, {\n        dryRun,\n        assumeLadder: false\n      })\n    })\n    const removed = yield* (dryRun ? sql.withTransaction(pass) : DurableWriter.make(sql).write(pass).pipe(\n      Effect.catchIf(\n        (cause): cause is DurableWriter.DatabaseError => cause instanceof DurableWriter.DatabaseError,\n        (cause) =>\n          Effect.fail(\n            new RetentionOps.RetentionError({\n              code: \"delete_failed\",\n              message: \"retention transaction failed; no history was deleted\",\n              cause\n            })\n          )\n      )\n    ))\n    return {\n      database: options.database ?? \"\",\n      olderThanMs: options.olderThanMs,\n      runs: removed.runIds,\n      deleted: dryRun ? {} : removed.deleted,\n      dryRun\n    }\n  })\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiCA,cAAyB;AACzB,oBAA+B;AAC/B,aAAwB;AACxB,gBAA2B;AAE3B,mBAA8B;AAE9B,0BAoBO;AAqCP,MAAM,WAAW,CAAC,UAChB,OAAO,IAAI,aAAY;AACrB,QAAM,MAAM,OAAO,UAAU;AAC7B,QAAM,OAAO,OAAO,QAAQ,OAAO,GAAG,EAAE,KAAK,OAAO,IAAI,CAACA,UAASA,MAAK,OAAO,CAAC,QAAQ,IAAI,SAAS,KAAK,CAAC,CAAC;AAC3G,SAAO,KAAK,SAAS;AACvB,CAAC;AAeH,MAAM,qBAAqB,CACzB,aACA,OACA,SAEA,OAAO,IAAI,aAAY;AACrB,QAAM,MAAM,OAAO,UAAU;AAC7B,MAAI,EAAE,OAAO,SAAS,YAAY,GAAI,QAAO,CAAC;AAK9C,SAAO,OAAO,aAAa,aAAa,KAAK;AAAA,IAC3C,UAAU;AAAA,IACV,WAAW;AAAA,IACX,aAAa,OAAO,SAAS,mBAAmB;AAAA,IAChD;AAAA,IACA,OAAO,aAAa,eAAe,KAAK;AAAA,EAC1C,CAAC;AACH,CAAC;AAQI,MAAM,WAAW,CACtB,aACA,QAAQ,aAAa,iBAErB,OAAO;AAAA,EACL,mBAAmB,aAAa,KAAK;AAAA,EACrC,CAAC,eAAe,WAAW,IAAI,CAAC,cAAc,UAAU,KAAK;AAC/D;AA6BK,MAAM,UAAU,CACrB,YAEA,OAAO,IAAI,aAAY;AACrB,QAAM,MAAM,OAAO,UAAU;AAC7B,QAAM,SAAS,QAAQ,WAAW;AAClC,QAAM,OAAO,OAAO,IAAI,aAAY;AAClC,UAAM,aAAa,OAAO,mBAAmB,QAAQ,aAAa,QAAQ,OAAO,QAAQ,IAAI;AAC7F,WAAO,OAAO,aAAa,WAAW,KAAK,YAAY;AAAA,MACrD;AAAA,MACA,cAAc;AAAA,IAChB,CAAC;AAAA,EACH,CAAC;AACD,QAAM,UAAU,OAAQ,SAAS,IAAI,gBAAgB,IAAI,IAAI,cAAc,KAAK,GAAG,EAAE,MAAM,IAAI,EAAE;AAAA,IAC/F,OAAO;AAAA,MACL,CAAC,UAAgD,iBAAiB,cAAc;AAAA,MAChF,CAAC,UACC,OAAO;AAAA,QACL,IAAI,aAAa,eAAe;AAAA,UAC9B,MAAM;AAAA,UACN,SAAS;AAAA,UACT;AAAA,QACF,CAAC;AAAA,MACH;AAAA,IACJ;AAAA,EACF;AACA,SAAO;AAAA,IACL,UAAU,QAAQ,YAAY;AAAA,IAC9B,aAAa,QAAQ;AAAA,IACrB,MAAM,QAAQ;AAAA,IACd,SAAS,SAAS,CAAC,IAAI,QAAQ;AAAA,IAC/B;AAAA,EACF;AACF,CAAC;",
+  "names": ["rows"]
+}

package/dist/cjs/RunCatalogRead.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The workspace run catalog read.
+ *
+ * `@smthrs/sync` serves a workspace subscription over a `RunCatalog`, and its
+ * own implementations are static or in-process. This is the durable source a
+ * `RunCatalog.makePolling` catalog reads, so a follower learns of a run
+ * another engine created.
+ *
+ * The operation lives in `internal/RunCatalogOps.ts`, beside the other
+ * modules that read this package's own tables; this module is the public
+ * surface, so `internal/` is never imported by a consumer.
+ *
+ * @since 0.1.0
+ */
+export { defaultLimit, layer, type ListOptions, make, RunCatalogError, RunCatalogErrorCode, RunCatalogRead, type Service } from "./internal/RunCatalogOps.ts";
+export { Filters, type ListRunsOptions, maximumPageSize, type RunPage } from "./internal/RunListing.ts";
+//# sourceMappingURL=RunCatalogRead.d.ts.map

package/dist/cjs/RunCatalogRead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunCatalogRead.d.ts","sourceRoot":"","sources":["../../src/RunCatalogRead.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EACL,YAAY,EACZ,KAAK,EACL,KAAK,WAAW,EAChB,IAAI,EACJ,eAAe,EACf,mBAAmB,EACnB,cAAc,EACd,KAAK,OAAO,EACb,MAAM,6BAA6B,CAAA;AAEpC,OAAO,EAAE,OAAO,EAAE,KAAK,eAAe,EAAE,eAAe,EAAE,KAAK,OAAO,EAAE,MAAM,0BAA0B,CAAA"}

package/dist/cjs/RunCatalogRead.js

@@ -0,0 +1,33 @@
+"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 RunCatalogRead_exports = {};
+__export(RunCatalogRead_exports, {
+  Filters: () => import_RunListing.Filters,
+  RunCatalogError: () => import_RunCatalogOps.RunCatalogError,
+  RunCatalogErrorCode: () => import_RunCatalogOps.RunCatalogErrorCode,
+  RunCatalogRead: () => import_RunCatalogOps.RunCatalogRead,
+  defaultLimit: () => import_RunCatalogOps.defaultLimit,
+  layer: () => import_RunCatalogOps.layer,
+  make: () => import_RunCatalogOps.make,
+  maximumPageSize: () => import_RunListing.maximumPageSize
+});
+module.exports = __toCommonJS(RunCatalogRead_exports);
+var import_RunCatalogOps = require("./internal/RunCatalogOps.js");
+var import_RunListing = require("./internal/RunListing.js");
+//# sourceMappingURL=RunCatalogRead.js.map

package/dist/cjs/RunCatalogRead.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/RunCatalogRead.ts"],
+  "sourcesContent": ["/**\n * The workspace run catalog read.\n *\n * `@smthrs/sync` serves a workspace subscription over a `RunCatalog`, and its\n * own implementations are static or in-process. This is the durable source a\n * `RunCatalog.makePolling` catalog reads, so a follower learns of a run\n * another engine created.\n *\n * The operation lives in `internal/RunCatalogOps.ts`, beside the other\n * modules that read this package's own tables; this module is the public\n * surface, so `internal/` is never imported by a consumer.\n *\n * @since 0.1.0\n */\n\nexport {\n  defaultLimit,\n  layer,\n  type ListOptions,\n  make,\n  RunCatalogError,\n  RunCatalogErrorCode,\n  RunCatalogRead,\n  type Service\n} from \"./internal/RunCatalogOps.ts\"\n\nexport { Filters, type ListRunsOptions, maximumPageSize, type RunPage } from \"./internal/RunListing.ts\"\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAeA,2BASO;AAEP,wBAA6E;",
+  "names": []
+}

package/dist/cjs/RunChangeFeed.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Coalesced execution catch-up with permanent deletion evidence.
+ *
+ * @since 1.0.0
+ */
+import { RunStoreError } from "@smthrs/run-store/RunStore";
+import { Context, Effect, Layer } from "effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import type { Position } from "./ExecutionSnapshot.ts";
+/**
+ * A live-row change or retained tombstone.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Change extends Position {
+    readonly runId: string;
+    readonly deleted: boolean;
+}
+/**
+ * One catch-up page at an engine watermark.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Page extends Position {
+    readonly changes: ReadonlyArray<Change>;
+    /** Resume here, including across gaps from coalesced changes. */
+    readonly nextRevision: number;
+    readonly hasMore: boolean;
+}
+/**
+ * Bounded state-feed operations.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Service {
+    readonly current: Effect.Effect<Position, RunStoreError>;
+    readonly changesSince: (options: Position & {
+        readonly limit: number;
+    }) => Effect.Effect<Page, RunStoreError>;
+}
+declare const RunChangeFeed_base: Context.ServiceClass<RunChangeFeed, "@smthrs/engine-store/RunChangeFeed", Service>;
+/**
+ * Durable change-feed service.
+ *
+ * @category services
+ * @since 1.0.0
+ */
+export declare class RunChangeFeed extends RunChangeFeed_base {
+}
+/**
+ * Maximum change-feed page size.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const maximumPageSize = 1000;
+/**
+ * Constructs the feed without polling or retention timers.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const make: () => Effect.Effect<Service, never, SqlClient.SqlClient>;
+/**
+ * Provides the SQL feed.
+ *
+ * @category layers
+ * @since 1.0.0
+ */
+export declare const layer: Layer.Layer<RunChangeFeed, never, SqlClient.SqlClient>;
+export {};
+//# sourceMappingURL=RunChangeFeed.d.ts.map

package/dist/cjs/RunChangeFeed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RunChangeFeed.d.ts","sourceRoot":"","sources":["../../src/RunChangeFeed.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAU,MAAM,QAAQ,CAAA;AACvD,OAAO,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AAGtD;;;;;GAKG;AACH,MAAM,WAAW,MAAO,SAAQ,QAAQ;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B;AACD;;;;;GAKG;AACH,MAAM,WAAW,IAAK,SAAQ,QAAQ;IACpC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IACvC,iEAAiE;IACjE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B;AACD;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAA;IACxD,QAAQ,CAAC,YAAY,EAAE,CAAC,OAAO,EAAE,QAAQ,GAAG;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,aAAa,CAAC,CAAA;CAC9G;;AACD;;;;;GAKG;AACH,qBAAa,aAAc,SAAQ,kBAA+E;CAAG;AACrH;;;;;GAKG;AACH,eAAO,MAAM,eAAe,OAAO,CAAA;AAQnC;;;;;GAKG;AACH,eAAO,MAAM,IAAI,QAAO,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,SAAS,CAAC,SAAS,CA8CrE,CAAA;AACJ;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,aAAa,EAAE,KAAK,EAAE,SAAS,CAAC,SAAS,CAAuC,CAAA"}

package/dist/cjs/RunChangeFeed.js

@@ -0,0 +1,96 @@
+"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 RunChangeFeed_exports = {};
+__export(RunChangeFeed_exports, {
+  RunChangeFeed: () => RunChangeFeed,
+  layer: () => layer,
+  make: () => make,
+  maximumPageSize: () => maximumPageSize
+});
+module.exports = __toCommonJS(RunChangeFeed_exports);
+var import_RunStore = require("@smthrs/run-store/RunStore");
+var import_effect = require("effect");
+var SqlClient = __toESM(require("effect/unstable/sql/SqlClient"), 1);
+var Read = __toESM(require("./internal/ExecutionSnapshotRead.js"), 1);
+class RunChangeFeed extends import_effect.Context.Service()("@smthrs/engine-store/RunChangeFeed") {
+}
+const maximumPageSize = 1e3;
+const Options = import_effect.Schema.Struct({
+  source: Read.Source,
+  revision: Read.Natural,
+  limit: import_effect.Schema.Int.check(import_effect.Schema.isBetween({ minimum: 1, maximum: maximumPageSize }))
+});
+const ChangeRow = import_effect.Schema.Struct({ run_id: Read.Identifier, revision: Read.Natural, deleted: import_effect.Schema.Literals([0, 1]) });
+const make = () => import_effect.Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  return {
+    current: Read.boundary("RunChangeFeed.current", Read.position(sql)),
+    changesSince: (options) => Read.boundary(
+      "RunChangeFeed.changesSince",
+      import_effect.Effect.gen(function* () {
+        const input = yield* Read.decode(Options, options);
+        return yield* Read.transaction(
+          sql,
+          import_effect.Effect.gen(function* () {
+            const at = yield* Read.position(sql);
+            if (input.source !== at.source || input.revision > at.revision) {
+              return yield* import_effect.Effect.fail(
+                new import_RunStore.RunStoreError({
+                  method: "RunChangeFeed.changesSince",
+                  code: "invalid_run",
+                  message: "change cursor requires an explicit source rebuild",
+                  cause: { requested: input, observed: at }
+                })
+              );
+            }
+            const rows = yield* sql`SELECT run_id, revision, deleted FROM flows_run_changes
+          WHERE revision > ${input.revision} AND revision <= ${at.revision}
+          ORDER BY revision LIMIT ${input.limit + 1}`;
+            const decoded = yield* import_effect.Effect.forEach(rows, (row) => Read.decode(ChangeRow, row));
+            const changes = decoded.slice(0, input.limit).map((row) => ({
+              runId: row.run_id,
+              source: at.source,
+              revision: row.revision,
+              deleted: row.deleted === 1
+            }));
+            const hasMore = decoded.length > input.limit;
+            return {
+              ...at,
+              changes,
+              hasMore,
+              nextRevision: hasMore ? changes[changes.length - 1].revision : at.revision
+            };
+          })
+        );
+      })
+    )
+  };
+});
+const layer = import_effect.Layer.effect(RunChangeFeed)(make());
+//# sourceMappingURL=RunChangeFeed.js.map