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

package/dist/cjs/PlanInputStore.js

@@ -0,0 +1,224 @@
+"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 PlanInputStore_exports = {};
+__export(PlanInputStore_exports, {
+  Address: () => Address,
+  PlanInputError: () => PlanInputError,
+  PlanInputStore: () => PlanInputStore,
+  Snapshot: () => Snapshot,
+  layer: () => layer,
+  make: () => make,
+  maximumSnapshotCharacters: () => maximumSnapshotCharacters
+});
+module.exports = __toCommonJS(PlanInputStore_exports);
+var import_crypto = require("@smthrs/crypto");
+var import_DurableWriter = require("@smthrs/database/DurableWriter");
+var import_plan = require("@smthrs/plan");
+var import_Ownership = require("@smthrs/run-store/Ownership");
+var import_effect = require("effect");
+var SqlClient = __toESM(require("effect/unstable/sql/SqlClient"), 1);
+const Natural = import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0));
+const Address = import_effect.Schema.Struct({
+  runId: import_effect.Schema.NonEmptyString,
+  planId: import_effect.Schema.NonEmptyString,
+  baseDigest: import_effect.Schema.NonEmptyString,
+  environmentDigest: import_effect.Schema.NonEmptyString,
+  generation: Natural
+});
+const maximumSnapshotCharacters = 16 * 1024 * 1024;
+const Snapshot = import_effect.Schema.Struct({
+  version: import_effect.Schema.Literal(1),
+  generation: Natural,
+  nodes: import_effect.Schema.Array(import_effect.Schema.Struct({
+    id: import_effect.Schema.NonEmptyString,
+    key: import_effect.Schema.NonEmptyString,
+    reads: import_effect.Schema.Array(import_effect.Schema.Struct({
+      entry: import_plan.FileSet.ReadEntry,
+      sourcePaths: import_effect.Schema.Array(import_plan.FileSet.Pattern)
+    }))
+  })).check(import_effect.Schema.isMaxLength(import_plan.Plan.maximumPlanNodes)),
+  pins: import_effect.Schema.Array(import_effect.Schema.Struct({ path: import_plan.FileSet.Pattern, digest: import_effect.Schema.NonEmptyString }))
+});
+class PlanInputError extends import_effect.Schema.TaggedError()("@smthrs/engine-store/PlanInputError", {
+  code: import_effect.Schema.Literals([
+    "invalid_input",
+    "corrupt_state",
+    "incompatible_state",
+    "fence_lost",
+    "transaction_open",
+    "persistence_failed"
+  ]),
+  message: import_effect.Schema.String,
+  cause: import_effect.Schema.optional(import_effect.Schema.Unknown)
+}) {
+}
+class PlanInputStore extends import_effect.Context.Service()("@smthrs/engine-store/PlanInputStore") {
+}
+const failure = (code, message, cause) => new PlanInputError({ code, message, ...cause === void 0 ? {} : { cause } });
+const persistError = (cause) => cause instanceof PlanInputError ? cause : failure("persistence_failed", "could not access durable plan inputs", cause);
+const decode = (schema, value, code) => import_effect.Effect.try({
+  try: () => import_effect.Schema.decodeUnknownSync(schema)(value, { onExcessProperty: "error" }),
+  catch: (cause) => failure(code, "invalid plan input observation", cause)
+});
+const validateSnapshot = (snapshot, generation, code) => {
+  if (snapshot.generation !== generation || new Set(snapshot.nodes.map((node) => node.id)).size !== snapshot.nodes.length || new Set(snapshot.pins.map((pin) => pin.path)).size !== snapshot.pins.length || snapshot.nodes.some(
+    (node) => node.reads.some(
+      (read) => new Set(read.sourcePaths).size !== read.sourcePaths.length || read.sourcePaths.some(
+        (path) => typeof read.entry === "string" ? path !== read.entry : !import_plan.FileSet.matchesGlob(read.entry, path)
+      )
+    )
+  )) {
+    return import_effect.Effect.fail(failure(code, "plan input observation has inconsistent membership or generation"));
+  }
+  return import_effect.Effect.void;
+};
+const make = import_effect.Effect.gen(
+  function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const writer = yield* import_DurableWriter.DurableWriter;
+    const crypto = yield* import_effect.Effect.context();
+    const checksum = (value) => import_effect.Schema.decodeUnknownEffect(import_crypto.Sha256)(value).pipe(import_effect.Effect.provide(crypto));
+    const fence = (address, owner) => import_effect.Effect.gen(function* () {
+      const owned = yield* sql`SELECT run_id FROM flows_runs WHERE run_id = ${address.runId}
+      AND status = 'running' AND cancel_requested_at_ms IS NULL
+      AND owner_host_id = ${owner.hostId} AND owner_pid = ${owner.pid} AND owner_nonce = ${owner.nonce}`;
+      if (owned.length !== 1) {
+        return yield* import_effect.Effect.fail(failure("fence_lost", "plan input owner no longer owns the run"));
+      }
+      const legacy = yield* sql`SELECT run_id FROM flows_plan_input_legacy_runs WHERE run_id = ${address.runId}`;
+      if (legacy.length > 0) {
+        return yield* import_effect.Effect.fail(
+          failure(
+            "incompatible_state",
+            "this run executed before durable plan inputs were recorded; its original sources cannot be reconstructed"
+          )
+        );
+      }
+    });
+    const load = (address) => import_effect.Effect.gen(function* () {
+      const heads = yield* sql`SELECT plan_id AS "planId", base_digest AS "baseDigest", environment_digest AS "environmentDigest", generation
+      FROM flows_plan_input_heads WHERE run_id = ${address.runId}`;
+      const head = heads[0];
+      if (head === void 0) {
+        const orphan = yield* sql`SELECT 1 FROM flows_plan_input_generations
+        WHERE run_id = ${address.runId} AND plan_id = ${address.planId} LIMIT 1`;
+        if (address.generation !== 0 || orphan.length > 0) {
+          return yield* import_effect.Effect.fail(failure("corrupt_state", "plan input history has no initial generation"));
+        }
+        return import_effect.Option.none();
+      }
+      yield* decode(
+        import_effect.Schema.Struct({
+          planId: import_effect.Schema.NonEmptyString,
+          baseDigest: import_effect.Schema.NonEmptyString,
+          environmentDigest: import_effect.Schema.NullOr(import_effect.Schema.NonEmptyString),
+          generation: Natural
+        }),
+        head,
+        "corrupt_state"
+      );
+      if (head.planId !== address.planId || head.baseDigest !== address.baseDigest) {
+        return yield* import_effect.Effect.fail(
+          failure("incompatible_state", "this run already observed a different approved plan")
+        );
+      }
+      if (head.environmentDigest === null || head.environmentDigest !== address.environmentDigest) {
+        return yield* import_effect.Effect.fail(failure(
+          "incompatible_state",
+          "this run has a different or unrecorded execution environment; recover with its original runtime or explicitly reconcile before starting a new run"
+        ));
+      }
+      const counts = yield* sql`SELECT COUNT(*) AS count,
+      MIN(generation) AS first, MAX(generation) AS last FROM flows_plan_input_generations
+      WHERE run_id = ${address.runId} AND plan_id = ${address.planId}`;
+      if (counts[0].count !== head.generation + 1 || counts[0].first !== 0 || counts[0].last !== head.generation || address.generation > head.generation + 1) {
+        return yield* import_effect.Effect.fail(failure("corrupt_state", "plan input history has a missing generation"));
+      }
+      if (address.generation > head.generation) return import_effect.Option.none();
+      const rows = yield* sql`SELECT snapshot_json AS "snapshotJson", checksum
+      FROM flows_plan_input_generations WHERE run_id = ${address.runId} AND plan_id = ${address.planId}
+      AND generation = ${address.generation}`;
+      const row = rows[0];
+      if (row.snapshotJson.length > maximumSnapshotCharacters || (yield* checksum(row.snapshotJson)) !== row.checksum) {
+        return yield* import_effect.Effect.fail(failure("corrupt_state", "plan input snapshot failed its size or integrity check"));
+      }
+      const snapshot = yield* decode(import_effect.Schema.fromJsonString(Snapshot), row.snapshotJson, "corrupt_state");
+      yield* validateSnapshot(snapshot, address.generation, "corrupt_state");
+      return import_effect.Option.some(snapshot);
+    });
+    const get = import_effect.Effect.fn("PlanInputStore.get")(
+      (input, ownerInput) => import_effect.Effect.gen(function* () {
+        const address = yield* decode(Address, input, "invalid_input");
+        const owner = yield* decode(import_Ownership.OwnerId, ownerInput, "invalid_input");
+        if (import_effect.Option.isSome(yield* import_effect.Effect.serviceOption(sql.transactionService))) {
+          return yield* import_effect.Effect.fail(
+            failure("transaction_open", "plan execution requires committed source observations")
+          );
+        }
+        return yield* writer.write(import_effect.Effect.gen(function* () {
+          yield* fence(address, owner);
+          return yield* load(address);
+        }));
+      }).pipe(import_effect.Effect.mapError(persistError))
+    );
+    const record = import_effect.Effect.fn("PlanInputStore.record")(
+      (input, value, ownerInput) => import_effect.Effect.gen(function* () {
+        const address = yield* decode(Address, input, "invalid_input");
+        const owner = yield* decode(import_Ownership.OwnerId, ownerInput, "invalid_input");
+        const snapshot = yield* decode(Snapshot, value, "invalid_input");
+        yield* validateSnapshot(snapshot, address.generation, "invalid_input");
+        const encoded = JSON.stringify(snapshot);
+        if (encoded.length > maximumSnapshotCharacters) {
+          return yield* import_effect.Effect.fail(failure("invalid_input", "plan input snapshot exceeds the durable size limit"));
+        }
+        const hash = yield* checksum(encoded);
+        return yield* writer.write(import_effect.Effect.gen(function* () {
+          yield* fence(address, owner);
+          const existing = yield* load(address);
+          if (import_effect.Option.isSome(existing)) return existing.value;
+          if (address.generation === 0) {
+            yield* sql`INSERT INTO flows_plan_input_heads (run_id, plan_id, base_digest, environment_digest, merge_state_version, generation)
+          VALUES (${address.runId}, ${address.planId}, ${address.baseDigest}, ${address.environmentDigest}, 1, 0)`;
+          } else {
+            yield* sql`UPDATE flows_plan_input_heads SET generation = ${address.generation}
+          WHERE run_id = ${address.runId} AND plan_id = ${address.planId}`;
+          }
+          yield* sql`INSERT INTO flows_plan_input_generations (run_id, plan_id, generation, snapshot_json, checksum)
+        VALUES (${address.runId}, ${address.planId}, ${address.generation}, ${encoded}, ${hash})`;
+          return snapshot;
+        }));
+      }).pipe(import_effect.Effect.mapError(persistError))
+    );
+    return { get, record };
+  }
+);
+const layer = import_effect.Layer.effect(
+  PlanInputStore
+)(make);
+//# sourceMappingURL=PlanInputStore.js.map

package/dist/cjs/PlanInputStore.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/PlanInputStore.ts"],
+  "sourcesContent": ["/**\n * Authoritative source observations for one durable plan execution. These are\n * replay state, not approval data, journal projections, or evictable cache rows.\n * @since 1.0.0\n */\n\nimport { Sha256 } from \"@smthrs/crypto\"\nimport { DurableWriter } from \"@smthrs/database/DurableWriter\"\nimport { FileSet, Plan } from \"@smthrs/plan\"\nimport { OwnerId } from \"@smthrs/run-store/Ownership\"\nimport { Context, Effect, Layer, Option, Schema } from \"effect\"\nimport type * as Crypto from \"effect/Crypto\"\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\"\n\nconst Natural = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))\n\n/**\n * Address of an append-only observation generation. `environmentDigest` comes\n * from `StepKey.environmentIdentity` and binds every generation of the run.\n * @since 1.0.0\n * @category schemas\n */\nexport const Address = Schema.Struct({\n  runId: Schema.NonEmptyString,\n  planId: Schema.NonEmptyString,\n  baseDigest: Schema.NonEmptyString,\n  environmentDigest: Schema.NonEmptyString,\n  generation: Natural\n})\n/**\n * Address of an append-only observation generation.\n * @since 1.0.0\n * @category models\n */\nexport type Address = typeof Address.Type\n\n/**\n * Maximum encoded snapshot size, in JavaScript string code units.\n * @since 1.0.0\n * @category constants\n */\nexport const maximumSnapshotCharacters = 16 * 1024 * 1024\n\n/**\n * Frozen membership and newly pinned source digests for one generation.\n * @since 1.0.0\n * @category schemas\n */\nexport const Snapshot = Schema.Struct({\n  version: Schema.Literal(1),\n  generation: Natural,\n  nodes: Schema.Array(Schema.Struct({\n    id: Schema.NonEmptyString,\n    key: Schema.NonEmptyString,\n    reads: Schema.Array(Schema.Struct({\n      entry: FileSet.ReadEntry,\n      sourcePaths: Schema.Array(FileSet.Pattern)\n    }))\n  })).check(Schema.isMaxLength(Plan.maximumPlanNodes)),\n  pins: Schema.Array(Schema.Struct({ path: FileSet.Pattern, digest: Schema.NonEmptyString }))\n})\n/**\n * Frozen membership and newly pinned source digests for one generation.\n * @since 1.0.0\n * @category models\n */\nexport type Snapshot = typeof Snapshot.Type\n\n/**\n * A durable observation cannot be read or safely admitted.\n * @since 1.0.0\n * @category errors\n */\nexport class PlanInputError extends Schema.TaggedError<PlanInputError>()(\"@smthrs/engine-store/PlanInputError\", {\n  code: Schema.Literals([\n    \"invalid_input\",\n    \"corrupt_state\",\n    \"incompatible_state\",\n    \"fence_lost\",\n    \"transaction_open\",\n    \"persistence_failed\"\n  ]),\n  message: Schema.String,\n  cause: Schema.optional(Schema.Unknown)\n}) {}\n\n/**\n * `get` is a committed-state admission gate and refuses an enclosing SQL\n * transaction. `record` is first-writer-wins and may join a write transaction;\n * callers must wait for its outer commit before executing affected actions.\n * @since 1.0.0\n * @category models\n */\nexport interface Service {\n  readonly get: (address: Address, owner: OwnerId) => Effect.Effect<Option.Option<Snapshot>, PlanInputError>\n  readonly record: (address: Address, snapshot: Snapshot, owner: OwnerId) => Effect.Effect<Snapshot, PlanInputError>\n}\n\n/**\n * Durable plan-input service.\n * @since 1.0.0\n * @category services\n */\nexport class PlanInputStore extends Context.Service<PlanInputStore, Service>()(\"@smthrs/engine-store/PlanInputStore\") {}\n\nconst failure = (code: PlanInputError[\"code\"], message: string, cause?: unknown) =>\n  new PlanInputError({ code, message, ...(cause === undefined ? {} : { cause }) })\nconst persistError = (cause: unknown) =>\n  cause instanceof PlanInputError ?\n    cause :\n    failure(\"persistence_failed\", \"could not access durable plan inputs\", cause)\n\nconst decode = <S extends Schema.Top & { readonly DecodingServices: never }>(\n  schema: S,\n  value: unknown,\n  code: \"invalid_input\" | \"corrupt_state\"\n) =>\n  Effect.try({\n    try: () => Schema.decodeUnknownSync(schema)(value, { onExcessProperty: \"error\" }),\n    catch: (cause) => failure(code, \"invalid plan input observation\", cause)\n  })\n\nconst validateSnapshot = (snapshot: Snapshot, generation: number, code: \"invalid_input\" | \"corrupt_state\") => {\n  if (\n    snapshot.generation !== generation ||\n    new Set(snapshot.nodes.map((node) => node.id)).size !== snapshot.nodes.length ||\n    new Set(snapshot.pins.map((pin) => pin.path)).size !== snapshot.pins.length ||\n    snapshot.nodes.some((node) =>\n      node.reads.some((read) =>\n        new Set(read.sourcePaths).size !== read.sourcePaths.length ||\n        read.sourcePaths.some((path) =>\n          typeof read.entry === \"string\" ? path !== read.entry : !FileSet.matchesGlob(read.entry, path)\n        )\n      )\n    )\n  ) {\n    return Effect.fail(failure(code, \"plan input observation has inconsistent membership or generation\"))\n  }\n  return Effect.void\n}\n\n/**\n * Builds the SQL-backed, owner-fenced store.\n * @since 1.0.0\n * @category constructors\n */\nexport const make: Effect.Effect<Service, never, SqlClient.SqlClient | DurableWriter | Crypto.Crypto> = Effect.gen(\n  function*() {\n    const sql = yield* SqlClient.SqlClient\n    const writer = yield* DurableWriter\n    const crypto = yield* Effect.context<Crypto.Crypto>()\n    const checksum = (value: string) => Schema.decodeUnknownEffect(Sha256)(value).pipe(Effect.provide(crypto))\n\n    const fence = (address: Address, owner: OwnerId) =>\n      Effect.gen(function*() {\n        const owned = yield* sql`SELECT run_id FROM flows_runs WHERE run_id = ${address.runId}\n      AND status = 'running' AND cancel_requested_at_ms IS NULL\n      AND owner_host_id = ${owner.hostId} AND owner_pid = ${owner.pid} AND owner_nonce = ${owner.nonce}`\n        if (owned.length !== 1) {\n          return yield* Effect.fail(failure(\"fence_lost\", \"plan input owner no longer owns the run\"))\n        }\n        const legacy = yield* sql`SELECT run_id FROM flows_plan_input_legacy_runs WHERE run_id = ${address.runId}`\n        if (legacy.length > 0) {\n          return yield* Effect.fail(\n            failure(\n              \"incompatible_state\",\n              \"this run executed before durable plan inputs were recorded; its original sources cannot be reconstructed\"\n            )\n          )\n        }\n      })\n\n    const load = (address: Address) =>\n      Effect.gen(function*() {\n        const heads = yield* sql<\n          { planId: string; baseDigest: string; environmentDigest: string | null; generation: number }\n        >`SELECT plan_id AS \"planId\", base_digest AS \"baseDigest\", environment_digest AS \"environmentDigest\", generation\n      FROM flows_plan_input_heads WHERE run_id = ${address.runId}`\n        const head = heads[0]\n        if (head === undefined) {\n          const orphan = yield* sql`SELECT 1 FROM flows_plan_input_generations\n        WHERE run_id = ${address.runId} AND plan_id = ${address.planId} LIMIT 1`\n          if (address.generation !== 0 || orphan.length > 0) {\n            return yield* Effect.fail(failure(\"corrupt_state\", \"plan input history has no initial generation\"))\n          }\n          return Option.none<Snapshot>()\n        }\n        yield* decode(\n          Schema.Struct({\n            planId: Schema.NonEmptyString,\n            baseDigest: Schema.NonEmptyString,\n            environmentDigest: Schema.NullOr(Schema.NonEmptyString),\n            generation: Natural\n          }),\n          head,\n          \"corrupt_state\"\n        )\n        if (head.planId !== address.planId || head.baseDigest !== address.baseDigest) {\n          return yield* Effect.fail(\n            failure(\"incompatible_state\", \"this run already observed a different approved plan\")\n          )\n        }\n        if (head.environmentDigest === null || head.environmentDigest !== address.environmentDigest) {\n          return yield* Effect.fail(failure(\n            \"incompatible_state\",\n            \"this run has a different or unrecorded execution environment; recover with its original runtime or explicitly reconcile before starting a new run\"\n          ))\n        }\n        const counts = yield* sql<{ count: number; first: number; last: number }>`SELECT COUNT(*) AS count,\n      MIN(generation) AS first, MAX(generation) AS last FROM flows_plan_input_generations\n      WHERE run_id = ${address.runId} AND plan_id = ${address.planId}`\n        if (\n          counts[0]!.count !== head.generation + 1 || counts[0]!.first !== 0 || counts[0]!.last !== head.generation ||\n          address.generation > head.generation + 1\n        ) {\n          return yield* Effect.fail(failure(\"corrupt_state\", \"plan input history has a missing generation\"))\n        }\n        if (address.generation > head.generation) return Option.none<Snapshot>()\n        const rows = yield* sql<\n          { snapshotJson: string; checksum: string }\n        >`SELECT snapshot_json AS \"snapshotJson\", checksum\n      FROM flows_plan_input_generations WHERE run_id = ${address.runId} AND plan_id = ${address.planId}\n      AND generation = ${address.generation}`\n        const row = rows[0]!\n        if (\n          row.snapshotJson.length > maximumSnapshotCharacters || (yield* checksum(row.snapshotJson)) !== row.checksum\n        ) {\n          return yield* Effect.fail(failure(\"corrupt_state\", \"plan input snapshot failed its size or integrity check\"))\n        }\n        const snapshot = yield* decode(Schema.fromJsonString(Snapshot), row.snapshotJson, \"corrupt_state\")\n        yield* validateSnapshot(snapshot, address.generation, \"corrupt_state\")\n        return Option.some(snapshot)\n      })\n\n    const get: Service[\"get\"] = Effect.fn(\"PlanInputStore.get\")((input, ownerInput) =>\n      Effect.gen(function*() {\n        const address = yield* decode(Address, input, \"invalid_input\")\n        const owner = yield* decode(OwnerId, ownerInput, \"invalid_input\")\n        if (Option.isSome(yield* Effect.serviceOption(sql.transactionService))) {\n          return yield* Effect.fail(\n            failure(\"transaction_open\", \"plan execution requires committed source observations\")\n          )\n        }\n        return yield* writer.write(Effect.gen(function*() {\n          yield* fence(address, owner)\n          return yield* load(address)\n        }))\n      }).pipe(Effect.mapError(persistError))\n    )\n\n    const record: Service[\"record\"] = Effect.fn(\"PlanInputStore.record\")((input, value, ownerInput) =>\n      Effect.gen(function*() {\n        const address = yield* decode(Address, input, \"invalid_input\")\n        const owner = yield* decode(OwnerId, ownerInput, \"invalid_input\")\n        const snapshot = yield* decode(Snapshot, value, \"invalid_input\")\n        yield* validateSnapshot(snapshot, address.generation, \"invalid_input\")\n        const encoded = JSON.stringify(snapshot)\n        if (encoded.length > maximumSnapshotCharacters) {\n          return yield* Effect.fail(failure(\"invalid_input\", \"plan input snapshot exceeds the durable size limit\"))\n        }\n        const hash = yield* checksum(encoded)\n        return yield* writer.write(Effect.gen(function*() {\n          yield* fence(address, owner)\n          const existing = yield* load(address)\n          if (Option.isSome(existing)) return existing.value\n          if (address.generation === 0) {\n            yield* sql`INSERT INTO flows_plan_input_heads (run_id, plan_id, base_digest, environment_digest, merge_state_version, generation)\n          VALUES (${address.runId}, ${address.planId}, ${address.baseDigest}, ${address.environmentDigest}, 1, 0)`\n          } else {\n            yield* sql`UPDATE flows_plan_input_heads SET generation = ${address.generation}\n          WHERE run_id = ${address.runId} AND plan_id = ${address.planId}`\n          }\n          yield* sql`INSERT INTO flows_plan_input_generations (run_id, plan_id, generation, snapshot_json, checksum)\n        VALUES (${address.runId}, ${address.planId}, ${address.generation}, ${encoded}, ${hash})`\n          return snapshot\n        }))\n      }).pipe(Effect.mapError(persistError))\n    )\n\n    return { get, record }\n  }\n)\n\n/**\n * Provides the SQL-backed input store over the same database as the run/attempt stores.\n * @since 1.0.0\n * @category layers\n */\nexport const layer: Layer.Layer<PlanInputStore, never, SqlClient.SqlClient | DurableWriter | Crypto.Crypto> = Layer\n  .effect(\n    PlanInputStore\n  )(make)\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/PlanMergeStore.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Owner-fenced scheduler decisions, distinct from action failure evidence and
+ * redacted journal projections. Intent survives before a merge is appended.
+ * @since 1.0.0
+ */
+import { DurableWriter } from "@smthrs/database/DurableWriter";
+import { OwnerId } from "@smthrs/run-store/Ownership";
+import { Context, Effect, Layer, Schema } from "effect";
+import type * as Crypto from "effect/Crypto";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+/** Execution binding shared by every decision of one plan run.
+ * @since 1.0.0
+ * @category schemas
+ */
+export declare const Identity: Schema.Struct<{
+    readonly runId: Schema.NonEmptyString;
+    readonly planId: Schema.NonEmptyString;
+    readonly baseDigest: Schema.NonEmptyString;
+    readonly environmentDigest: Schema.NonEmptyString;
+}>;
+/** Execution binding.
+ * @since 1.0.0
+ * @category models
+ */
+export type Identity = typeof Identity.Type;
+/** A stopped attempt and the exact cohort eligible to supply merge winners.
+ * @since 1.0.0
+ * @category schemas
+ */
+export declare const Intent: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly nodeId: Schema.NonEmptyString;
+    readonly nodeKey: Schema.NonEmptyString;
+    readonly dispatchKey: Schema.NonEmptyString;
+    readonly attempts: Schema.Int;
+    readonly rebases: Schema.Int;
+    readonly peers: Schema.$Array<Schema.NonEmptyString>;
+}>;
+/** Durable stopped-attempt decision.
+ * @since 1.0.0
+ * @category models
+ */
+export type Intent = typeof Intent.Type;
+/** The plan extension committed for an intent.
+ * @since 1.0.0
+ * @category schemas
+ */
+export declare const Completion: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly generation: Schema.Int;
+    readonly parentDigest: Schema.NonEmptyString;
+    readonly planDigest: Schema.NonEmptyString;
+    readonly mergeId: Schema.NonEmptyString;
+    readonly mergeKey: Schema.NonEmptyString;
+    readonly winners: Schema.$Array<Schema.NonEmptyString>;
+}>;
+/** Committed merge extension.
+ * @since 1.0.0
+ * @category models
+ */
+export type Completion = typeof Completion.Type;
+/** Intent with its optional committed extension.
+ * @since 1.0.0
+ * @category models
+ */
+export interface Decision {
+    readonly intent: Intent;
+    readonly completion?: Completion;
+}
+declare const PlanMergeError_base: Schema.Class<PlanMergeError, Schema.TaggedStruct<"@smthrs/engine-store/PlanMergeError", {
+    readonly code: Schema.Literals<readonly ["invalid_input", "corrupt_state", "incompatible_state", "fence_lost", "transaction_open", "transaction_required", "persistence_failed"]>;
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/** Typed admission/storage refusal.
+ * @since 1.0.0
+ * @category errors
+ */
+export declare class PlanMergeError extends PlanMergeError_base {
+}
+/** Store operations; writes may join the owning transaction, reads require committed state.
+ * @since 1.0.0
+ * @category models
+ */
+export interface Service {
+    readonly list: (identity: Identity, owner: OwnerId) => Effect.Effect<ReadonlyArray<Decision>, PlanMergeError>;
+    readonly intend: (identity: Identity, intent: Intent, owner: OwnerId) => Effect.Effect<Intent, PlanMergeError>;
+    readonly complete: (identity: Identity, nodeId: string, completion: Completion, owner: OwnerId) => Effect.Effect<Completion, PlanMergeError>;
+}
+declare const PlanMergeStore_base: Context.ServiceClass<PlanMergeStore, "@smthrs/engine-store/PlanMergeStore", Service>;
+/** Durable merge decision service.
+ * @since 1.0.0
+ * @category services
+ */
+export declare class PlanMergeStore extends PlanMergeStore_base {
+}
+/** Encoded decision limit, in JavaScript code units.
+ * @since 1.0.0
+ * @category constants
+ */
+export declare const maximumDecisionCharacters: number;
+/** SQL constructor; all collaborating stores must use the same database/writer.
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const make: Effect.Effect<Service, never, SqlClient.SqlClient | DurableWriter | Crypto.Crypto>;
+/** SQL-backed merge decisions; migrations must run first.
+ * @since 1.0.0
+ * @category layers
+ */
+export declare const layer: Layer.Layer<PlanMergeStore, never, SqlClient.SqlClient | DurableWriter | Crypto.Crypto>;
+export {};
+//# sourceMappingURL=PlanMergeStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PlanMergeStore.d.ts","sourceRoot":"","sources":["../../src/PlanMergeStore.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAA;AAE9D,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAA;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/D,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAM1D;;;GAGG;AACH,eAAO,MAAM,QAAQ;;;;;EAKnB,CAAA;AACF;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAC3C;;;GAGG;AACH,eAAO,MAAM,MAAM;;;;;;;;EAQjB,CAAA;AACF;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AACvC;;;GAGG;AACH,eAAO,MAAM,UAAU;;;;;;;;EAQrB,CAAA;AACF;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA;AAC/C;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAA;CACjC;;;;;;AACD;;;GAGG;AACH,qBAAa,cAAe,SAAQ,mBAYlC;CAAG;AACL;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC,CAAA;IAC7G,QAAQ,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;IAC9G,QAAQ,CAAC,QAAQ,EAAE,CACjB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,OAAO,KACX,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,cAAc,CAAC,CAAA;CAC/C;;AACD;;;GAGG;AACH,qBAAa,cAAe,SAAQ,mBAAiF;CAAG;AACxH;;;GAGG;AACH,eAAO,MAAM,yBAAyB,QAAmB,CAAA;AAiBzD;;;GAGG;AACH,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,SAAS,CAAC,SAAS,GAAG,aAAa,GAAG,MAAM,CAAC,MAAM,CAyLnG,CAAA;AACD;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,cAAc,EAAE,KAAK,EAAE,SAAS,CAAC,SAAS,GAAG,aAAa,GAAG,MAAM,CAAC,MAAM,CAC3E,CAAA"}

package/dist/cjs/PlanMergeStore.js

@@ -0,0 +1,255 @@
+"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 PlanMergeStore_exports = {};
+__export(PlanMergeStore_exports, {
+  Completion: () => Completion,
+  Identity: () => Identity,
+  Intent: () => Intent,
+  PlanMergeError: () => PlanMergeError,
+  PlanMergeStore: () => PlanMergeStore,
+  layer: () => layer,
+  make: () => make,
+  maximumDecisionCharacters: () => maximumDecisionCharacters
+});
+module.exports = __toCommonJS(PlanMergeStore_exports);
+var import_crypto = require("@smthrs/crypto");
+var import_DurableWriter = require("@smthrs/database/DurableWriter");
+var import_plan = require("@smthrs/plan");
+var import_Ownership = require("@smthrs/run-store/Ownership");
+var import_effect = require("effect");
+var SqlClient = __toESM(require("effect/unstable/sql/SqlClient"), 1);
+const Natural = import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0));
+const Positive = import_effect.Schema.Int.check(import_effect.Schema.isGreaterThan(0));
+const Names = import_effect.Schema.Array(import_effect.Schema.NonEmptyString).check(import_effect.Schema.isMaxLength(import_plan.Plan.maximumPlanNodes));
+const Identity = import_effect.Schema.Struct({
+  runId: import_effect.Schema.NonEmptyString,
+  planId: import_effect.Schema.NonEmptyString,
+  baseDigest: import_effect.Schema.NonEmptyString,
+  environmentDigest: import_effect.Schema.NonEmptyString
+});
+const Intent = import_effect.Schema.Struct({
+  version: import_effect.Schema.Literal(1),
+  nodeId: import_effect.Schema.NonEmptyString,
+  nodeKey: import_effect.Schema.NonEmptyString,
+  dispatchKey: import_effect.Schema.NonEmptyString,
+  attempts: Positive,
+  rebases: Natural,
+  peers: Names
+});
+const Completion = import_effect.Schema.Struct({
+  version: import_effect.Schema.Literal(1),
+  generation: Positive,
+  parentDigest: import_effect.Schema.NonEmptyString,
+  planDigest: import_effect.Schema.NonEmptyString,
+  mergeId: import_effect.Schema.NonEmptyString,
+  mergeKey: import_effect.Schema.NonEmptyString,
+  winners: Names
+});
+class PlanMergeError extends import_effect.Schema.TaggedError()("@smthrs/engine-store/PlanMergeError", {
+  code: import_effect.Schema.Literals([
+    "invalid_input",
+    "corrupt_state",
+    "incompatible_state",
+    "fence_lost",
+    "transaction_open",
+    "transaction_required",
+    "persistence_failed"
+  ]),
+  message: import_effect.Schema.String,
+  cause: import_effect.Schema.optional(import_effect.Schema.Unknown)
+}) {
+}
+class PlanMergeStore extends import_effect.Context.Service()("@smthrs/engine-store/PlanMergeStore") {
+}
+const maximumDecisionCharacters = 16 * 1024 * 1024;
+const error = (code, message, cause) => new PlanMergeError({ code, message, ...cause === void 0 ? {} : { cause } });
+const storageError = (cause) => cause instanceof PlanMergeError ? cause : error("persistence_failed", "could not access plan merge decisions", cause);
+const decode = (schema, value, code) => import_effect.Effect.try({
+  try: () => import_effect.Schema.decodeUnknownSync(schema)(value, { onExcessProperty: "error" }),
+  catch: (cause) => error(code, "invalid plan merge decision", cause)
+});
+const unique = (names, code) => new Set(names).size === names.length ? import_effect.Effect.void : import_effect.Effect.fail(error(code, "duplicate merge peer identity"));
+const make = import_effect.Effect.gen(
+  function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const writer = yield* import_DurableWriter.DurableWriter;
+    const crypto = yield* import_effect.Effect.context();
+    const hash = (value) => import_effect.Schema.decodeUnknownEffect(import_crypto.Sha256)(value).pipe(import_effect.Effect.provide(crypto));
+    const fence = (identity, owner, requireHead) => import_effect.Effect.gen(function* () {
+      const owned = yield* sql`SELECT run_id FROM flows_runs WHERE run_id = ${identity.runId}
+      AND status = 'running' AND cancel_requested_at_ms IS NULL
+      AND owner_host_id = ${owner.hostId} AND owner_pid = ${owner.pid} AND owner_nonce = ${owner.nonce}`;
+      if (owned.length !== 1) {
+        return yield* import_effect.Effect.fail(error("fence_lost", "merge decision owner no longer owns the run"));
+      }
+      const heads = yield* sql`SELECT
+      plan_id AS "planId", base_digest AS "baseDigest", environment_digest AS "environmentDigest", merge_state_version AS version
+      FROM flows_plan_input_heads WHERE run_id = ${identity.runId}`;
+      const head = heads[0];
+      if (head === void 0) {
+        const orphan = yield* sql`SELECT 1 FROM flows_plan_merge_intents WHERE run_id = ${identity.runId} LIMIT 1`;
+        if (requireHead || orphan.length > 0) {
+          return yield* import_effect.Effect.fail(error("corrupt_state", "merge intent has no admitted input generation"));
+        }
+        return;
+      }
+      if (head.version !== 1 || head.planId !== identity.planId || head.baseDigest !== identity.baseDigest || head.environmentDigest !== identity.environmentDigest) {
+        return yield* import_effect.Effect.fail(
+          error(
+            "incompatible_state",
+            "this run has different or unrecorded merge execution state; recover with its original runtime or reconcile before starting a new run"
+          )
+        );
+      }
+    });
+    const encoded = (value) => import_effect.Effect.gen(function* () {
+      const json = JSON.stringify(value);
+      if (json.length > maximumDecisionCharacters) {
+        return yield* import_effect.Effect.fail(error("invalid_input", "merge decision exceeds its durable size limit"));
+      }
+      return { json, checksum: yield* hash(json) };
+    });
+    const stored = (schema, row) => import_effect.Effect.gen(function* () {
+      if (row.json.length > maximumDecisionCharacters || (yield* hash(row.json)) !== row.checksum) {
+        return yield* import_effect.Effect.fail(error("corrupt_state", "merge decision failed its size or integrity check"));
+      }
+      return yield* decode(import_effect.Schema.fromJsonString(schema), row.json, "corrupt_state");
+    });
+    const load = (identity, nodeId) => import_effect.Effect.gen(function* () {
+      const rows = yield* sql`SELECT i.stopped_node_id AS "nodeId", i.intent_json AS json, i.checksum,
+        c.generation, c.merge_node_id AS "mergeId", c.completion_json AS "completionJson",
+        c.checksum AS "completionChecksum"
+      FROM flows_plan_merge_intents i LEFT JOIN flows_plan_merge_completions c
+        ON c.run_id = i.run_id AND c.stopped_node_id = i.stopped_node_id
+      WHERE i.run_id = ${identity.runId} ${nodeId === void 0 ? sql`` : sql`AND i.stopped_node_id = ${nodeId}`}
+      ORDER BY i.stopped_node_id LIMIT ${import_plan.Plan.maximumPlanNodes + 1}`;
+      if (rows.length > import_plan.Plan.maximumPlanNodes) {
+        return yield* import_effect.Effect.fail(error("corrupt_state", "too many merge decisions for one plan"));
+      }
+      return yield* import_effect.Effect.forEach(rows, (row) => import_effect.Effect.gen(function* () {
+        const intent = yield* stored(Intent, row);
+        yield* unique(intent.peers, "corrupt_state");
+        if (intent.nodeId !== row.nodeId || intent.peers.includes(intent.nodeId)) {
+          return yield* import_effect.Effect.fail(error("corrupt_state", "merge intent identity is inconsistent"));
+        }
+        if (row.completionJson === null) return { intent };
+        const completion = yield* stored(Completion, {
+          json: row.completionJson,
+          checksum: row.completionChecksum
+        });
+        yield* unique(completion.winners, "corrupt_state");
+        if (completion.generation !== row.generation || completion.mergeId !== row.mergeId || completion.winners.some((id) => !intent.peers.includes(id))) {
+          return yield* import_effect.Effect.fail(error("corrupt_state", "merge completion does not match its intent"));
+        }
+        return { intent, completion };
+      }));
+    });
+    const list = (input, ownerInput) => import_effect.Effect.gen(function* () {
+      const identity = yield* decode(Identity, input, "invalid_input");
+      const owner = yield* decode(import_Ownership.OwnerId, ownerInput, "invalid_input");
+      if (import_effect.Option.isSome(yield* import_effect.Effect.serviceOption(sql.transactionService))) {
+        return yield* import_effect.Effect.fail(error("transaction_open", "merge recovery requires committed decisions"));
+      }
+      return yield* writer.write(import_effect.Effect.gen(function* () {
+        yield* fence(identity, owner, false);
+        return yield* load(identity);
+      }));
+    }).pipe(import_effect.Effect.mapError(storageError));
+    const intend = (input, value, ownerInput) => import_effect.Effect.gen(function* () {
+      const identity = yield* decode(Identity, input, "invalid_input");
+      const owner = yield* decode(import_Ownership.OwnerId, ownerInput, "invalid_input");
+      const intent = yield* decode(Intent, value, "invalid_input");
+      yield* unique(intent.peers, "invalid_input");
+      if (intent.peers.includes(intent.nodeId)) {
+        return yield* import_effect.Effect.fail(error("invalid_input", "a merge cannot stop its own peer"));
+      }
+      const data = yield* encoded(intent);
+      return yield* writer.write(import_effect.Effect.gen(function* () {
+        yield* fence(identity, owner, true);
+        const [existing] = yield* load(identity, intent.nodeId);
+        if (existing !== void 0) return existing.intent;
+        const [count] = yield* sql`SELECT count(*) AS count
+        FROM flows_plan_merge_intents WHERE run_id = ${identity.runId}`;
+        if (count.count >= import_plan.Plan.maximumPlanNodes) {
+          return yield* import_effect.Effect.fail(error("invalid_input", "too many merge intents for one plan"));
+        }
+        yield* sql`INSERT INTO flows_plan_merge_intents (run_id, stopped_node_id, intent_json, checksum)
+        VALUES (${identity.runId}, ${intent.nodeId}, ${data.json}, ${data.checksum})`;
+        return intent;
+      }));
+    }).pipe(import_effect.Effect.mapError(storageError));
+    const complete = (input, nodeIdInput, value, ownerInput) => import_effect.Effect.gen(function* () {
+      if (import_effect.Option.isNone(yield* import_effect.Effect.serviceOption(sql.transactionService))) {
+        return yield* import_effect.Effect.fail(
+          error("transaction_required", "merge completion must join the plan/input append transaction")
+        );
+      }
+      const identity = yield* decode(Identity, input, "invalid_input");
+      const owner = yield* decode(import_Ownership.OwnerId, ownerInput, "invalid_input");
+      const nodeId = yield* decode(import_effect.Schema.NonEmptyString, nodeIdInput, "invalid_input");
+      const completion = yield* decode(Completion, value, "invalid_input");
+      yield* unique(completion.winners, "invalid_input");
+      const data = yield* encoded(completion);
+      return yield* writer.write(import_effect.Effect.gen(function* () {
+        yield* fence(identity, owner, true);
+        const [decision] = yield* load(identity, nodeId);
+        if (decision === void 0) {
+          return yield* import_effect.Effect.fail(error("corrupt_state", "merge completion has no intent"));
+        }
+        if (decision.completion !== void 0) {
+          if (JSON.stringify(decision.completion) !== JSON.stringify(completion)) {
+            return yield* import_effect.Effect.fail(
+              error("incompatible_state", "a merge intent already committed a different extension")
+            );
+          }
+          return decision.completion;
+        }
+        if (completion.winners.some((id) => !decision.intent.peers.includes(id))) {
+          return yield* import_effect.Effect.fail(error("invalid_input", "merge winner was not an admitted peer"));
+        }
+        const appended = yield* sql`SELECT p.plan_id FROM flows_plans p JOIN flows_plan_input_generations i ON i.plan_id = p.plan_id
+        JOIN flows_plan_nodes n ON n.plan_id = p.plan_id AND n.generation = p.generation
+        WHERE p.plan_id = ${identity.planId} AND p.digest = ${completion.planDigest} AND p.generation = ${completion.generation}
+        AND i.run_id = ${identity.runId} AND i.generation = ${completion.generation}
+        AND n.node_id = ${completion.mergeId} AND n.key_digest = ${completion.mergeKey} AND n.kind = 'merge'`;
+        if (appended.length !== 1) {
+          return yield* import_effect.Effect.fail(
+            error("corrupt_state", "merge completion requires its plan and input generation in the same transaction")
+          );
+        }
+        yield* sql`INSERT INTO flows_plan_merge_completions (run_id, stopped_node_id, generation, merge_node_id, completion_json, checksum)
+        VALUES (${identity.runId}, ${nodeId}, ${completion.generation}, ${completion.mergeId}, ${data.json}, ${data.checksum})`;
+        return completion;
+      }));
+    }).pipe(import_effect.Effect.mapError(storageError));
+    return { list, intend, complete };
+  }
+);
+const layer = import_effect.Layer.effect(PlanMergeStore)(make);
+//# sourceMappingURL=PlanMergeStore.js.map