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

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

@@ -0,0 +1,78 @@
+/**
+ * Bounded, indexed run pages.
+ *
+ * @since 1.0.0
+ */
+import { Effect, Schema } from "effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import * as Read from "./ExecutionSnapshotRead.ts";
+import { RunCatalogError } from "./RunListingError.ts";
+/**
+ * Supported equality and inclusive creation-range filters.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export declare const Filters: Schema.Struct<{
+    readonly status: Schema.optionalKey<Schema.Literals<readonly ["pending", "running", "suspended", "completed", "failed", "cancelled"]>>;
+    readonly flowName: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly parentRunId: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+    readonly lineageId: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly waitingReason: Schema.optionalKey<Schema.NullOr<Schema.NonEmptyString>>;
+    readonly createdAfterMs: Schema.optionalKey<Schema.Int>;
+    readonly createdBeforeMs: Schema.optionalKey<Schema.Int>;
+}>;
+/**
+ * Supported filters; lineageId also selects its original root.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Filters = typeof Filters.Type;
+/**
+ * Options for a bounded run page. Numeric offsets are not cursors.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface ListRunsOptions {
+    readonly filters?: Filters;
+    readonly cursor?: string;
+    readonly limit?: number;
+}
+/**
+ * One transaction's page and watermark; no total count.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface RunPage extends Read.Position {
+    readonly runs: ReadonlyArray<Read.Observed>;
+    readonly cursor: string | null;
+}
+/**
+ * Bounded catalog operations.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Service {
+    readonly listRuns: (options?: ListRunsOptions) => Effect.Effect<RunPage, RunCatalogError>;
+}
+/**
+ * Maximum page size.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const maximumPageSize = 200;
+/**
+ * Builds the bounded read against the engine database.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const make: () => Effect.Effect<{
+    listRuns: (options?: ListRunsOptions) => Effect.Effect<RunPage, RunCatalogError>;
+}, never, SqlClient.SqlClient>;
+//# sourceMappingURL=RunListing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RunListing.d.ts","sourceRoot":"","sources":["../../../src/internal/RunListing.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAS,MAAM,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC9C,OAAO,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAC1D,OAAO,KAAK,IAAI,MAAM,4BAA4B,CAAA;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAEtD;;;;;GAKG;AACH,eAAO,MAAM,OAAO;;;;;;;;EAQlB,CAAA;AACF;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AACzC;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AACD;;;;;GAKG;AACH,MAAM,WAAW,OAAQ,SAAQ,IAAI,CAAC,QAAQ;IAC5C,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IAC3C,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B;AACD;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,eAAe,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,eAAe,CAAC,CAAA;CAC1F;AACD;;;;;GAKG;AACH,eAAO,MAAM,eAAe,MAAM,CAAA;AAiBlC;;;;;GAKG;AACH,eAAO,MAAM,IAAI;yBA/Be,eAAe,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,eAAe,CAAC;8BAkJvF,CAAA"}

package/dist/cjs/internal/RunListing.js

@@ -0,0 +1,171 @@
+"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 RunListing_exports = {};
+__export(RunListing_exports, {
+  Filters: () => Filters,
+  make: () => make,
+  maximumPageSize: () => maximumPageSize
+});
+module.exports = __toCommonJS(RunListing_exports);
+var Dialect = __toESM(require("@smthrs/database/Dialect"), 1);
+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("./ExecutionSnapshotRead.js"), 1);
+var import_RunListingError = require("./RunListingError.js");
+const Filters = import_effect.Schema.Struct({
+  status: import_effect.Schema.optionalKey(import_RunStore.RunStatus),
+  flowName: import_effect.Schema.optionalKey(Read.Identifier),
+  parentRunId: import_effect.Schema.optionalKey(import_effect.Schema.NullOr(Read.Identifier)),
+  lineageId: import_effect.Schema.optionalKey(Read.Identifier),
+  waitingReason: import_effect.Schema.optionalKey(import_effect.Schema.NullOr(Read.Identifier)),
+  createdAfterMs: import_effect.Schema.optionalKey(Read.Natural),
+  createdBeforeMs: import_effect.Schema.optionalKey(Read.Natural)
+});
+const maximumPageSize = 200;
+const Cursor = import_effect.Schema.fromJsonString(import_effect.Schema.Struct({
+  version: import_effect.Schema.Literal(1),
+  source: Read.Source,
+  filters: import_effect.Schema.String,
+  createdAtMs: Read.Natural,
+  runId: Read.Identifier
+}));
+const Options = import_effect.Schema.Struct({
+  filters: import_effect.Schema.optionalKey(Filters),
+  // Four 1,024-unit filter strings can expand sevenfold inside the JSON tuple
+  // string, plus a sixfold escaped 1,024-unit run ID and bounded scalar fields.
+  // 64 Ki UTF-16 units therefore admits every cursor this port can produce.
+  cursor: import_effect.Schema.optionalKey(import_effect.Schema.String.check(import_effect.Schema.isMaxLength(65536))),
+  limit: import_effect.Schema.optionalKey(import_effect.Schema.Int.check(import_effect.Schema.isBetween({ minimum: 1, maximum: maximumPageSize })))
+});
+const make = () => import_effect.Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  const listRuns = (options = {}) => import_effect.Effect.gen(function* () {
+    const admitted = yield* import_effect.Schema.decodeUnknownEffect(Options)(options, { onExcessProperty: "error" }).pipe(
+      import_effect.Effect.mapError(
+        (cause) => new import_RunListingError.RunCatalogError({ code: "invalid_options", message: "invalid run page options", cause })
+      )
+    );
+    const filters = admitted.filters ?? {};
+    const tuple = JSON.stringify([
+      filters.status ?? null,
+      filters.flowName ?? null,
+      filters.parentRunId === void 0 ? [] : [filters.parentRunId],
+      filters.lineageId ?? null,
+      filters.waitingReason === void 0 ? [] : [filters.waitingReason],
+      filters.createdAfterMs ?? null,
+      filters.createdBeforeMs ?? null
+    ]);
+    const cursor = admitted.cursor === void 0 ? null : yield* import_effect.Schema.decodeUnknownEffect(Cursor)(admitted.cursor).pipe(
+      import_effect.Effect.mapError(
+        (cause) => new import_RunListingError.RunCatalogError({ code: "invalid_cursor", message: "malformed run cursor", cause })
+      )
+    );
+    if (cursor !== null && cursor.filters !== tuple) {
+      return yield* import_effect.Effect.fail(
+        new import_RunListingError.RunCatalogError({ code: "invalid_cursor", message: "run cursor belongs to another query" })
+      );
+    }
+    const limit = admitted.limit ?? 100;
+    return yield* Read.transaction(
+      sql,
+      import_effect.Effect.gen(function* () {
+        const at = yield* Read.position(sql);
+        if (cursor !== null && cursor.source !== at.source) {
+          return yield* import_effect.Effect.fail(
+            new import_RunListingError.RunCatalogError({ code: "source_changed", message: "run cursor belongs to another engine source" })
+          );
+        }
+        const predicates = [];
+        const values = [];
+        let mask = 0;
+        const equalities = [
+          ["status", filters.status],
+          ["execution_flow", filters.flowName],
+          ["execution_parent_id", filters.parentRunId],
+          ["execution_lineage", filters.lineageId],
+          ["waiting_reason", filters.waitingReason]
+        ];
+        for (const [index, [column, value]] of equalities.entries()) {
+          if (value === void 0) continue;
+          mask |= 1 << index;
+          predicates.push(`r.${column} IS NOT DISTINCT FROM ?`);
+          values.push(value);
+        }
+        if (filters.createdAfterMs !== void 0) {
+          predicates.push("r.created_at_ms >= ?");
+          values.push(filters.createdAfterMs);
+        }
+        if (filters.createdBeforeMs !== void 0) {
+          predicates.push("r.created_at_ms <= ?");
+          values.push(filters.createdBeforeMs);
+        }
+        if (cursor !== null) {
+          predicates.push("(r.created_at_ms, r.run_id) > (?, ?)");
+          values.push(cursor.createdAtMs, cursor.runId);
+        }
+        values.push(limit + 1);
+        const rows = yield* Dialect.query(
+          sql,
+          `SELECT ${Read.selectColumns} FROM flows_runs r ${Dialect.isPostgres(sql) ? "" : `INDEXED BY flows_runs_listing_${mask}`}
+        LEFT JOIN flows_run_changes c ON c.run_id = r.run_id
+        ${predicates.length === 0 ? "" : `WHERE ${predicates.join(" AND ")}`}
+        ORDER BY r.created_at_ms, r.run_id LIMIT ?`,
+          values
+        );
+        const decoded = yield* import_effect.Effect.forEach(rows, (row) => Read.observed(row, at));
+        const runs = decoded.slice(0, limit);
+        const last = runs[runs.length - 1];
+        return {
+          ...at,
+          runs,
+          cursor: decoded.length > limit ? JSON.stringify({
+            version: 1,
+            source: at.source,
+            filters: tuple,
+            createdAtMs: last.createdAtMs,
+            runId: last.runId
+          }) : null
+        };
+      })
+    );
+  }).pipe(import_effect.Effect.catchCause((cause) => {
+    if (import_effect.Cause.hasInterruptsOnly(cause)) return import_effect.Effect.failCause(cause);
+    const original = import_effect.Cause.squash(cause);
+    return import_effect.Effect.fail(
+      original instanceof import_RunListingError.RunCatalogError ? original : new import_RunListingError.RunCatalogError({
+        code: "list_failed",
+        message: "the engine run page could not be read",
+        cause: original
+      })
+    );
+  }));
+  return { listRuns };
+});
+//# sourceMappingURL=RunListing.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/RunListing.ts"],
+  "sourcesContent": ["/**\n * Bounded, indexed run pages.\n *\n * @since 1.0.0\n */\n\nimport * as Dialect from \"@smthrs/database/Dialect\"\nimport { RunStatus } from \"@smthrs/run-store/RunStore\"\nimport { Cause, Effect, Schema } from \"effect\"\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\"\nimport * as Read from \"./ExecutionSnapshotRead.ts\"\nimport { RunCatalogError } from \"./RunListingError.ts\"\n\n/**\n * Supported equality and inclusive creation-range filters.\n *\n * @category models\n * @since 1.0.0\n */\nexport const Filters = Schema.Struct({\n  status: Schema.optionalKey(RunStatus),\n  flowName: Schema.optionalKey(Read.Identifier),\n  parentRunId: Schema.optionalKey(Schema.NullOr(Read.Identifier)),\n  lineageId: Schema.optionalKey(Read.Identifier),\n  waitingReason: Schema.optionalKey(Schema.NullOr(Read.Identifier)),\n  createdAfterMs: Schema.optionalKey(Read.Natural),\n  createdBeforeMs: Schema.optionalKey(Read.Natural)\n})\n/**\n * Supported filters; lineageId also selects its original root.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Filters = typeof Filters.Type\n/**\n * Options for a bounded run page. Numeric offsets are not cursors.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface ListRunsOptions {\n  readonly filters?: Filters\n  readonly cursor?: string\n  readonly limit?: number\n}\n/**\n * One transaction's page and watermark; no total count.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface RunPage extends Read.Position {\n  readonly runs: ReadonlyArray<Read.Observed>\n  readonly cursor: string | null\n}\n/**\n * Bounded catalog operations.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Service {\n  readonly listRuns: (options?: ListRunsOptions) => Effect.Effect<RunPage, RunCatalogError>\n}\n/**\n * Maximum page size.\n *\n * @category constants\n * @since 1.0.0\n */\nexport const maximumPageSize = 200\nconst Cursor = Schema.fromJsonString(Schema.Struct({\n  version: Schema.Literal(1),\n  source: Read.Source,\n  filters: Schema.String,\n  createdAtMs: Read.Natural,\n  runId: Read.Identifier\n}))\nconst Options = Schema.Struct({\n  filters: Schema.optionalKey(Filters),\n  // Four 1,024-unit filter strings can expand sevenfold inside the JSON tuple\n  // string, plus a sixfold escaped 1,024-unit run ID and bounded scalar fields.\n  // 64 Ki UTF-16 units therefore admits every cursor this port can produce.\n  cursor: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(65536))),\n  limit: Schema.optionalKey(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: maximumPageSize })))\n})\n\n/**\n * Builds the bounded read against the engine database.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const make = () =>\n  Effect.gen(function*() {\n    const sql = yield* SqlClient.SqlClient\n    const listRuns: Service[\"listRuns\"] = (options = {}) =>\n      Effect.gen(function*() {\n        const admitted = yield* Schema.decodeUnknownEffect(Options)(options, { onExcessProperty: \"error\" }).pipe(\n          Effect.mapError((cause) =>\n            new RunCatalogError({ code: \"invalid_options\", message: \"invalid run page options\", cause })\n          )\n        )\n        const filters = admitted.filters ?? {}\n        const tuple = JSON.stringify([\n          filters.status ?? null,\n          filters.flowName ?? null,\n          filters.parentRunId === undefined ? [] : [filters.parentRunId],\n          filters.lineageId ?? null,\n          filters.waitingReason === undefined ? [] : [filters.waitingReason],\n          filters.createdAfterMs ?? null,\n          filters.createdBeforeMs ?? null\n        ])\n        const cursor = admitted.cursor === undefined ?\n          null :\n          yield* Schema.decodeUnknownEffect(Cursor)(admitted.cursor).pipe(\n            Effect.mapError((cause) =>\n              new RunCatalogError({ code: \"invalid_cursor\", message: \"malformed run cursor\", cause })\n            )\n          )\n        if (cursor !== null && cursor.filters !== tuple) {\n          return yield* Effect.fail(\n            new RunCatalogError({ code: \"invalid_cursor\", message: \"run cursor belongs to another query\" })\n          )\n        }\n        const limit = admitted.limit ?? 100\n        return yield* Read.transaction(\n          sql,\n          Effect.gen(function*() {\n            const at = yield* Read.position(sql)\n            if (cursor !== null && cursor.source !== at.source) {\n              return yield* Effect.fail(\n                new RunCatalogError({ code: \"source_changed\", message: \"run cursor belongs to another engine source\" })\n              )\n            }\n            const predicates: Array<string> = []\n            const values: Array<string | number | null> = []\n            let mask = 0\n            const equalities = [\n              [\"status\", filters.status],\n              [\"execution_flow\", filters.flowName],\n              [\"execution_parent_id\", filters.parentRunId],\n              [\"execution_lineage\", filters.lineageId],\n              [\"waiting_reason\", filters.waitingReason]\n            ] as const\n            for (const [index, [column, value]] of equalities.entries()) {\n              if (value === undefined) continue\n              mask |= 1 << index\n              predicates.push(`r.${column} IS NOT DISTINCT FROM ?`)\n              values.push(value)\n            }\n            if (filters.createdAfterMs !== undefined) {\n              predicates.push(\"r.created_at_ms >= ?\")\n              values.push(filters.createdAfterMs)\n            }\n            if (filters.createdBeforeMs !== undefined) {\n              predicates.push(\"r.created_at_ms <= ?\")\n              values.push(filters.createdBeforeMs)\n            }\n            if (cursor !== null) {\n              predicates.push(\"(r.created_at_ms, r.run_id) > (?, ?)\")\n              values.push(cursor.createdAtMs, cursor.runId)\n            }\n            values.push(limit + 1)\n            const rows = yield* Dialect.query(\n              sql,\n              `SELECT ${Read.selectColumns} FROM flows_runs r ${\n                Dialect.isPostgres(sql) ? \"\" : `INDEXED BY flows_runs_listing_${mask}`\n              }\n        LEFT JOIN flows_run_changes c ON c.run_id = r.run_id\n        ${\n                predicates.length === 0\n                  ? \"\"\n                  : `WHERE ${predicates.join(\" AND \")}`\n              }\n        ORDER BY r.created_at_ms, r.run_id LIMIT ?`,\n              values\n            )\n            const decoded = yield* Effect.forEach(rows, (row) => Read.observed(row, at))\n            const runs = decoded.slice(0, limit)\n            const last = runs[runs.length - 1]\n            return {\n              ...at,\n              runs,\n              cursor: decoded.length > limit ?\n                JSON.stringify({\n                  version: 1,\n                  source: at.source,\n                  filters: tuple,\n                  createdAtMs: last!.createdAtMs,\n                  runId: last!.runId\n                }) :\n                null\n            }\n          })\n        )\n      }).pipe(Effect.catchCause((cause) => {\n        if (Cause.hasInterruptsOnly(cause)) return Effect.failCause(cause as Cause.Cause<never>)\n        const original = Cause.squash(cause)\n        return Effect.fail(\n          original instanceof RunCatalogError ? original : new RunCatalogError({\n            code: \"list_failed\",\n            message: \"the engine run page could not be read\",\n            cause: original\n          })\n        )\n      }))\n    return { listRuns }\n  })\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,35 @@
+/**
+ * Shared catalog failure vocabulary.
+ *
+ * @since 1.0.0
+ */
+import * as Schema from "effect/Schema";
+/**
+ * Catalog failure codes.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const RunCatalogErrorCode: Schema.Literals<readonly ["invalid_options", "list_failed", "invalid_cursor", "source_changed"]>;
+/**
+ * Catalog failure codes.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type RunCatalogErrorCode = typeof RunCatalogErrorCode.Type;
+declare const RunCatalogError_base: Schema.Class<RunCatalogError, Schema.TaggedStruct<"@smthrs/engine-store/RunCatalogError", {
+    readonly code: Schema.Literals<readonly ["invalid_options", "list_failed", "invalid_cursor", "source_changed"]>;
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Catalog read failure retaining its original cause.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class RunCatalogError extends RunCatalogError_base {
+}
+export {};
+//# sourceMappingURL=RunListingError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RunListingError.d.ts","sourceRoot":"","sources":["../../../src/internal/RunListingError.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,kGAK9B,CAAA;AACF;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAA;;;;;;AACjE;;;;;GAKG;AACH,qBAAa,eAAgB,SAAQ,oBAGpC;CAAG"}

package/dist/cjs/internal/RunListingError.js

@@ -0,0 +1,47 @@
+"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 RunListingError_exports = {};
+__export(RunListingError_exports, {
+  RunCatalogError: () => RunCatalogError,
+  RunCatalogErrorCode: () => RunCatalogErrorCode
+});
+module.exports = __toCommonJS(RunListingError_exports);
+var Schema = __toESM(require("effect/Schema"), 1);
+const RunCatalogErrorCode = Schema.Literals([
+  "invalid_options",
+  "list_failed",
+  "invalid_cursor",
+  "source_changed"
+]);
+class RunCatalogError extends Schema.TaggedError()(
+  "@smthrs/engine-store/RunCatalogError",
+  { code: RunCatalogErrorCode, message: Schema.String, cause: Schema.optional(Schema.Unknown) }
+) {
+}
+//# sourceMappingURL=RunListingError.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/RunListingError.ts"],
+  "sourcesContent": ["/**\n * Shared catalog failure vocabulary.\n *\n * @since 1.0.0\n */\n\nimport * as Schema from \"effect/Schema\"\n\n/**\n * Catalog failure codes.\n *\n * @category models\n * @since 0.1.0\n */\nexport const RunCatalogErrorCode = Schema.Literals([\n  \"invalid_options\",\n  \"list_failed\",\n  \"invalid_cursor\",\n  \"source_changed\"\n])\n/**\n * Catalog failure codes.\n *\n * @category models\n * @since 0.1.0\n */\nexport type RunCatalogErrorCode = typeof RunCatalogErrorCode.Type\n/**\n * Catalog read failure retaining its original cause.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class RunCatalogError extends Schema.TaggedError<RunCatalogError>()(\n  \"@smthrs/engine-store/RunCatalogError\",\n  { code: RunCatalogErrorCode, message: Schema.String, cause: Schema.optional(Schema.Unknown) }\n) {}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,aAAwB;AAQjB,MAAM,sBAAsB,OAAO,SAAS;AAAA,EACjD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAcM,MAAM,wBAAwB,OAAO,YAA6B;AAAA,EACvE;AAAA,EACA,EAAE,MAAM,qBAAqB,SAAS,OAAO,QAAQ,OAAO,OAAO,SAAS,OAAO,OAAO,EAAE;AAC9F,EAAE;AAAC;",
+  "names": []
+}

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

@@ -0,0 +1,73 @@
+/**
+ * Rebuildable scheduler indexes. Only verified, append-only plan nodes enter
+ * here; durable plans, observations and attempts remain authoritative.
+ *
+ * @since 1.0.0
+ */
+import type { Plan, Scheduling } from "@smthrs/plan";
+import type { Outcome } from "../PlanScheduler.ts";
+/** Mutable coordinator state; dispatch fibers own only attempt-local progress.
+ * @since 1.0.0
+ * @category models
+ */
+export interface NodeState {
+    status: "pending" | "running" | "settled";
+    outcome: Outcome;
+    attempts: number;
+    rebases: number;
+    waited: number;
+    dispatchKey: string;
+}
+/** Counts explicit graph work, not host time or VM-internal allocations.
+ * `allocations` counts new containers and records, including frontier copies
+ * and candidate records. Collection backing storage and sort internals are
+ * not observable here. Admission policy work is owned by Scheduling.
+ * @since 1.0.0
+ * @category diagnostics
+ */
+export interface Work {
+    nodes: number;
+    edges: number;
+    allocations: number;
+    membership: number;
+}
+/** Run-local adjacency, readiness, membership and work counters.
+ *
+ * A provisional outcome is staged while reconciliation reads the journal.
+ * Only `reconcile` publishes it to dependents. A later verdict can change an
+ * outcome's blocking contribution, but never decrement indegree twice.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface RuntimeGraph {
+    readonly states: ReadonlyMap<string, NodeState>;
+    readonly remaining: number;
+    readonly cost: {
+        readonly update: Work;
+        readonly settlement: Work;
+        readonly frontier: Work;
+        readonly admission: Work;
+        readonly reachability: Work;
+    };
+    /** Adds only the newly admitted suffix, synchronously after its durable commit. */
+    readonly append: (nodes: ReadonlyArray<Plan.PlanNode>) => void;
+    readonly stage: (nodeId: string, outcome: Outcome) => void;
+    readonly reconcile: () => void;
+    /** Declaration-ordered snapshots preserve passive-settlement wave ordering. */
+    readonly blocked: () => ReadonlyArray<Plan.PlanNode>;
+    readonly ready: () => ReadonlyArray<Plan.PlanNode>;
+    readonly candidates: (ready: ReadonlyArray<Plan.PlanNode>) => ReadonlyArray<Scheduling.Candidate>;
+    readonly start: (nodeId: string) => void;
+    /** Discovered edges affect readiness only, never declared file versions. */
+    readonly reorder: (nodeId: string, owners: ReadonlyArray<string>) => void;
+    /** Visits declared ancestors once per query, including a not-yet-admitted suffix node. */
+    readonly visitAncestors: (node: Plan.PlanNode, visit: (node: Plan.PlanNode) => void) => void;
+}
+/** Builds one private graph per run/resume. Recovery stages durable settlements
+ * before the first admission; ordinary attempt replay still verifies content.
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const make: (nodes: ReadonlyArray<Plan.PlanNode>) => RuntimeGraph;
+//# sourceMappingURL=RuntimeGraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeGraph.d.ts","sourceRoot":"","sources":["../../../src/internal/RuntimeGraph.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAElD;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAA;IACzC,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;CACpB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;CACnB;AAgBD;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;IAC/C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,IAAI,EAAE;QACb,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;QACrB,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAA;QACzB,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAA;QACvB,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAA;QACxB,QAAQ,CAAC,YAAY,EAAE,IAAI,CAAA;KAC5B,CAAA;IACD,mFAAmF;IACnF,QAAQ,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAA;IAC9D,QAAQ,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;IAC1D,QAAQ,CAAC,SAAS,EAAE,MAAM,IAAI,CAAA;IAC9B,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,EAAE,MAAM,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IACpD,QAAQ,CAAC,KAAK,EAAE,MAAM,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IAClD,QAAQ,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,aAAa,CAAC,UAAU,CAAC,SAAS,CAAC,CAAA;IACjG,QAAQ,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IACxC,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,KAAK,IAAI,CAAA;IACzE,0FAA0F;IAC1F,QAAQ,CAAC,cAAc,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,KAAK,IAAI,KAAK,IAAI,CAAA;CAC7F;AAED;;;;GAIG;AACH,eAAO,MAAM,IAAI,GAAI,OAAO,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAG,YAkK1D,CAAA"}

package/dist/cjs/internal/RuntimeGraph.js

@@ -0,0 +1,180 @@
+"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 RuntimeGraph_exports = {};
+__export(RuntimeGraph_exports, {
+  make: () => make
+});
+module.exports = __toCommonJS(RuntimeGraph_exports);
+const work = () => ({ nodes: 0, edges: 0, allocations: 0, membership: 0 });
+const blocks = (outcome) => outcome !== "built" && outcome !== "clean";
+const make = (nodes) => {
+  const vertices = /* @__PURE__ */ new Map();
+  const states = /* @__PURE__ */ new Map();
+  const ready = /* @__PURE__ */ new Set();
+  const blocked = /* @__PURE__ */ new Set();
+  const staged = /* @__PURE__ */ new Set();
+  const cost = { update: work(), settlement: work(), frontier: work(), admission: work(), reachability: work() };
+  cost.update.allocations = 12;
+  let remaining = 0;
+  const refresh = (vertex) => {
+    ready.delete(vertex);
+    blocked.delete(vertex);
+    if (vertex.state.status === "pending" && vertex.unresolved === 0) {
+      if (vertex.blocked > 0) blocked.add(vertex);
+      else ready.add(vertex);
+    }
+  };
+  const edge = (target, dependency, count) => {
+    count.edges++;
+    count.membership++;
+    if (target.dependencies.has(dependency)) return;
+    target.dependencies.add(dependency);
+    dependency.dependents.add(target);
+    if (dependency.propagated === void 0) target.unresolved++;
+    else if (blocks(dependency.propagated)) target.blocked++;
+  };
+  const append = (suffix) => {
+    for (const node of suffix) {
+      const state = {
+        status: "pending",
+        outcome: "skipped",
+        attempts: 0,
+        rebases: 0,
+        waited: 0,
+        dispatchKey: ""
+      };
+      const vertex = {
+        node,
+        index: vertices.size,
+        state,
+        dependencies: /* @__PURE__ */ new Set(),
+        dependents: /* @__PURE__ */ new Set(),
+        unresolved: 0,
+        blocked: 0,
+        propagated: void 0
+      };
+      vertices.set(node.id, vertex);
+      states.set(node.id, state);
+      remaining++;
+      cost.update.nodes++;
+      cost.update.allocations += 4;
+    }
+    for (const node of suffix) {
+      const vertex = vertices.get(node.id);
+      cost.update.nodes++;
+      cost.update.membership++;
+      for (const dependency of node.dependsOn) {
+        cost.update.membership++;
+        edge(vertex, vertices.get(dependency), cost.update);
+      }
+      refresh(vertex);
+    }
+  };
+  const snapshot = (frontier) => {
+    cost.frontier.nodes += frontier.size;
+    cost.frontier.allocations += 2;
+    return [...frontier].sort((left, right) => left.index - right.index).map((vertex) => vertex.node);
+  };
+  append(nodes);
+  return {
+    states,
+    get remaining() {
+      return remaining;
+    },
+    cost,
+    append,
+    stage: (nodeId, outcome) => {
+      cost.settlement.nodes++;
+      cost.settlement.membership++;
+      const vertex = vertices.get(nodeId);
+      vertex.state.status = "settled";
+      vertex.state.outcome = outcome;
+      staged.add(vertex);
+    },
+    reconcile: () => {
+      for (const vertex of staged) {
+        cost.settlement.nodes++;
+        const previous = vertex.propagated;
+        const outcome = vertex.state.outcome;
+        if (previous === outcome) continue;
+        if (previous === void 0) remaining--;
+        const delta = Number(blocks(outcome)) - Number(previous !== void 0 && blocks(previous));
+        vertex.propagated = outcome;
+        refresh(vertex);
+        for (const dependent of vertex.dependents) {
+          cost.settlement.edges++;
+          cost.settlement.nodes++;
+          if (previous === void 0) dependent.unresolved--;
+          dependent.blocked += delta;
+          refresh(dependent);
+        }
+      }
+      staged.clear();
+    },
+    blocked: () => snapshot(blocked),
+    ready: () => snapshot(ready),
+    candidates: (frontier) => {
+      cost.admission.allocations += 1 + frontier.length;
+      return frontier.map((node) => {
+        cost.admission.nodes++;
+        cost.admission.membership++;
+        const vertex = vertices.get(node.id);
+        return { node, order: vertex.index, waited: vertex.state.waited };
+      });
+    },
+    start: (nodeId) => {
+      cost.admission.nodes++;
+      cost.admission.membership++;
+      const vertex = vertices.get(nodeId);
+      vertex.state.status = "running";
+      ready.delete(vertex);
+    },
+    reorder: (nodeId, owners) => {
+      const dependency = vertices.get(nodeId);
+      cost.update.membership++;
+      for (const owner of owners) {
+        cost.update.nodes++;
+        cost.update.membership++;
+        const target = vertices.get(owner);
+        if (target?.state.status !== "pending") continue;
+        edge(target, dependency, cost.update);
+        refresh(target);
+      }
+    },
+    visitAncestors: (node, visit) => {
+      const seen = /* @__PURE__ */ new Set([node.id]);
+      const stack = [...node.dependsOn];
+      cost.reachability.allocations += 2;
+      cost.reachability.edges += stack.length;
+      while (stack.length > 0) {
+        const id = stack.pop();
+        cost.reachability.membership++;
+        if (seen.has(id)) continue;
+        seen.add(id);
+        const predecessor = vertices.get(id).node;
+        cost.reachability.membership++;
+        cost.reachability.nodes++;
+        visit(predecessor);
+        cost.reachability.edges += predecessor.dependsOn.length;
+        stack.push(...predecessor.dependsOn);
+      }
+    }
+  };
+};
+//# sourceMappingURL=RuntimeGraph.js.map