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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/RuntimeGraph.ts"],
+  "sourcesContent": ["/**\n * Rebuildable scheduler indexes. Only verified, append-only plan nodes enter\n * here; durable plans, observations and attempts remain authoritative.\n *\n * @since 1.0.0\n */\n\nimport type { Plan, Scheduling } from \"@smthrs/plan\"\nimport type { Outcome } from \"../PlanScheduler.ts\"\n\n/** Mutable coordinator state; dispatch fibers own only attempt-local progress.\n * @since 1.0.0\n * @category models\n */\nexport interface NodeState {\n  status: \"pending\" | \"running\" | \"settled\"\n  outcome: Outcome\n  attempts: number\n  rebases: number\n  waited: number\n  dispatchKey: string\n}\n\n/** Counts explicit graph work, not host time or VM-internal allocations.\n * `allocations` counts new containers and records, including frontier copies\n * and candidate records. Collection backing storage and sort internals are\n * not observable here. Admission policy work is owned by Scheduling.\n * @since 1.0.0\n * @category diagnostics\n */\nexport interface Work {\n  nodes: number\n  edges: number\n  allocations: number\n  membership: number\n}\n\ninterface Vertex {\n  readonly node: Plan.PlanNode\n  readonly index: number\n  readonly state: NodeState\n  readonly dependencies: Set<Vertex>\n  readonly dependents: Set<Vertex>\n  unresolved: number\n  blocked: number\n  propagated: Outcome | undefined\n}\n\nconst work = (): Work => ({ nodes: 0, edges: 0, allocations: 0, membership: 0 })\nconst blocks = (outcome: Outcome): boolean => outcome !== \"built\" && outcome !== \"clean\"\n\n/** Run-local adjacency, readiness, membership and work counters.\n *\n * A provisional outcome is staged while reconciliation reads the journal.\n * Only `reconcile` publishes it to dependents. A later verdict can change an\n * outcome's blocking contribution, but never decrement indegree twice.\n *\n * @since 1.0.0\n * @category models\n */\nexport interface RuntimeGraph {\n  readonly states: ReadonlyMap<string, NodeState>\n  readonly remaining: number\n  readonly cost: {\n    readonly update: Work\n    readonly settlement: Work\n    readonly frontier: Work\n    readonly admission: Work\n    readonly reachability: Work\n  }\n  /** Adds only the newly admitted suffix, synchronously after its durable commit. */\n  readonly append: (nodes: ReadonlyArray<Plan.PlanNode>) => void\n  readonly stage: (nodeId: string, outcome: Outcome) => void\n  readonly reconcile: () => void\n  /** Declaration-ordered snapshots preserve passive-settlement wave ordering. */\n  readonly blocked: () => ReadonlyArray<Plan.PlanNode>\n  readonly ready: () => ReadonlyArray<Plan.PlanNode>\n  readonly candidates: (ready: ReadonlyArray<Plan.PlanNode>) => ReadonlyArray<Scheduling.Candidate>\n  readonly start: (nodeId: string) => void\n  /** Discovered edges affect readiness only, never declared file versions. */\n  readonly reorder: (nodeId: string, owners: ReadonlyArray<string>) => void\n  /** Visits declared ancestors once per query, including a not-yet-admitted suffix node. */\n  readonly visitAncestors: (node: Plan.PlanNode, visit: (node: Plan.PlanNode) => void) => void\n}\n\n/** Builds one private graph per run/resume. Recovery stages durable settlements\n * before the first admission; ordinary attempt replay still verifies content.\n * @since 1.0.0\n * @category constructors\n */\nexport const make = (nodes: ReadonlyArray<Plan.PlanNode>): RuntimeGraph => {\n  const vertices = new Map<string, Vertex>()\n  const states = new Map<string, NodeState>()\n  const ready = new Set<Vertex>()\n  const blocked = new Set<Vertex>()\n  const staged = new Set<Vertex>()\n  const cost = { update: work(), settlement: work(), frontier: work(), admission: work(), reachability: work() }\n  // The graph object, cost records, maps, sets and method closures have a\n  // constant per-run footprint. Count the explicit containers/records.\n  cost.update.allocations = 12\n  let remaining = 0\n\n  const refresh = (vertex: Vertex): void => {\n    ready.delete(vertex)\n    blocked.delete(vertex)\n    if (vertex.state.status === \"pending\" && vertex.unresolved === 0) {\n      if (vertex.blocked > 0) blocked.add(vertex)\n      else ready.add(vertex)\n    }\n  }\n\n  const edge = (target: Vertex, dependency: Vertex, count: Work): void => {\n    count.edges++\n    count.membership++\n    if (target.dependencies.has(dependency)) return\n    target.dependencies.add(dependency)\n    dependency.dependents.add(target)\n    if (dependency.propagated === undefined) target.unresolved++\n    else if (blocks(dependency.propagated)) target.blocked++\n  }\n\n  const append = (suffix: ReadonlyArray<Plan.PlanNode>): void => {\n    // Register the whole suffix first: declaration order need not be a\n    // topological order. Verified generations never rewrite old vertices.\n    for (const node of suffix) {\n      const state: NodeState = {\n        status: \"pending\",\n        outcome: \"skipped\",\n        attempts: 0,\n        rebases: 0,\n        waited: 0,\n        dispatchKey: \"\"\n      }\n      const vertex: Vertex = {\n        node,\n        index: vertices.size,\n        state,\n        dependencies: new Set(),\n        dependents: new Set(),\n        unresolved: 0,\n        blocked: 0,\n        propagated: undefined\n      }\n      vertices.set(node.id, vertex)\n      states.set(node.id, state)\n      remaining++\n      cost.update.nodes++\n      cost.update.allocations += 4\n    }\n    for (const node of suffix) {\n      const vertex = vertices.get(node.id)!\n      cost.update.nodes++\n      cost.update.membership++\n      for (const dependency of node.dependsOn) {\n        cost.update.membership++\n        edge(vertex, vertices.get(dependency)!, cost.update)\n      }\n      refresh(vertex)\n    }\n  }\n\n  const snapshot = (frontier: ReadonlySet<Vertex>): ReadonlyArray<Plan.PlanNode> => {\n    cost.frontier.nodes += frontier.size\n    cost.frontier.allocations += 2\n    return [...frontier].sort((left, right) => left.index - right.index).map((vertex) => vertex.node)\n  }\n\n  append(nodes)\n  return {\n    states,\n    get remaining() {\n      return remaining\n    },\n    cost,\n    append,\n    stage: (nodeId, outcome) => {\n      cost.settlement.nodes++\n      cost.settlement.membership++\n      const vertex = vertices.get(nodeId)!\n      vertex.state.status = \"settled\"\n      vertex.state.outcome = outcome\n      staged.add(vertex)\n    },\n    reconcile: () => {\n      for (const vertex of staged) {\n        cost.settlement.nodes++\n        const previous = vertex.propagated\n        const outcome = vertex.state.outcome\n        if (previous === outcome) continue\n        if (previous === undefined) remaining--\n        const delta = Number(blocks(outcome)) - Number(previous !== undefined && blocks(previous))\n        vertex.propagated = outcome\n        refresh(vertex)\n        for (const dependent of vertex.dependents) {\n          cost.settlement.edges++\n          cost.settlement.nodes++\n          if (previous === undefined) dependent.unresolved--\n          dependent.blocked += delta\n          refresh(dependent)\n        }\n      }\n      staged.clear()\n    },\n    blocked: () => snapshot(blocked),\n    ready: () => snapshot(ready),\n    candidates: (frontier) => {\n      cost.admission.allocations += 1 + frontier.length\n      return frontier.map((node) => {\n        cost.admission.nodes++\n        cost.admission.membership++\n        const vertex = vertices.get(node.id)!\n        return { node, order: vertex.index, waited: vertex.state.waited }\n      })\n    },\n    start: (nodeId) => {\n      cost.admission.nodes++\n      cost.admission.membership++\n      const vertex = vertices.get(nodeId)!\n      vertex.state.status = \"running\"\n      ready.delete(vertex)\n    },\n    reorder: (nodeId, owners) => {\n      const dependency = vertices.get(nodeId)!\n      cost.update.membership++\n      for (const owner of owners) {\n        cost.update.nodes++\n        cost.update.membership++\n        const target = vertices.get(owner)\n        if (target?.state.status !== \"pending\") continue\n        edge(target, dependency, cost.update)\n        refresh(target)\n      }\n    },\n    visitAncestors: (node, visit) => {\n      const seen = new Set<string>([node.id])\n      const stack = [...node.dependsOn]\n      cost.reachability.allocations += 2\n      cost.reachability.edges += stack.length\n      while (stack.length > 0) {\n        const id = stack.pop()!\n        cost.reachability.membership++\n        if (seen.has(id)) continue\n        seen.add(id)\n        const predecessor = vertices.get(id)!.node\n        cost.reachability.membership++\n        cost.reachability.nodes++\n        visit(predecessor)\n        cost.reachability.edges += predecessor.dependsOn.length\n        stack.push(...predecessor.dependsOn)\n      }\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,80 @@
+/**
+ * The isolated half of an attempt: run the body in a workspace transaction,
+ * copy its diff bundle back, and rebase a bounded number of times when the
+ * host moved underneath it.
+ *
+ * Copy-back has no human review gate.
+ *
+ * @since 0.1.0
+ */
+import type { FileBoundary } from "@smthrs/flow/FileBoundary";
+import type * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import * as WorkspaceSandbox from "../WorkspaceSandbox.ts";
+/**
+ * An isolated execution whose diff bundle is now on the host.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Settlement {
+    readonly result: unknown;
+    /**
+     * The content address of the applied bundle: a digest over every
+     * `(path, beforeDigest, afterDigest)` triple. It is the journal's handle on
+     * the copy-back, and the `diffIdentity` a deviation carries.
+     */
+    readonly bundleIdentity: string;
+    readonly files: ReadonlyArray<WorkspaceSandbox.FileChange>;
+    readonly effects: ReadonlyArray<WorkspaceSandbox.QueuedEffect>;
+    /**
+     * Paths the body wrote outside its declared write set. Non-empty only in
+     * expected mode — hard mode fails instead — and the whole tree is in view,
+     * not just the declared read set `StepBoundary` can re-measure.
+     */
+    readonly deviations: ReadonlyArray<string>;
+    /** How many times copy-back lost a race and the attempt re-ran from a fresh base. */
+    readonly rebases: number;
+}
+/**
+ * How many times a losing copy-back re-runs the body from a fresh base.
+ *
+ * Bounded on purpose: an unbounded rebase against a workspace under sustained
+ * concurrent modification never converges. This retry budget does not
+ * recreate the removed worktree-lane surface.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const defaultMaxRebases = 3;
+/**
+ * Runs one action body inside a workspace transaction and copies its result
+ * back.
+ *
+ * The host is untouched until copy-back, so every refusal below leaves the
+ * tree exactly as it found it:
+ *
+ * - a body failure propagates unchanged, because it is the action's own
+ *   declared error and the retry policy must still match on it;
+ * - an execution the declaration did not predict fails with the boundary's own
+ *   {@link StepBoundary.UndeclaredWrite}, which routes it through the caller's
+ *   existing hard-violation classification instead of inventing a second one;
+ * - a lost copy-back race re-runs the body from a fresh base up to
+ *   `maxRebases` times before surfacing the conflict.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const execute: (options: {
+    readonly sandbox: WorkspaceSandbox.Service;
+    readonly descriptor: FileBoundary;
+    /**
+     * The action body. The engine's encoded effect erases its requirements, so
+     * the sandbox's own surfaces are named here: they are what `execute` seeds,
+     * and naming them keeps a caller from having to launder the type.
+     */
+    readonly workflow: Effect.Effect<unknown, unknown, WorkspaceSandbox.Workspace | FileSystem.FileSystem>;
+    readonly maxRebases?: number | undefined;
+}) => Effect.Effect<Settlement, unknown, Crypto.Crypto>;
+//# sourceMappingURL=SandboxedExecution.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SandboxedExecution.d.ts","sourceRoot":"","sources":["../../../src/internal/SandboxedExecution.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAG7D,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAIpD,OAAO,KAAK,gBAAgB,MAAM,wBAAwB,CAAA;AAE1D;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB;;;;OAIG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAA;IAC1D,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAA;IAC9D;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC1C,qFAAqF;IACrF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAqBlC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,OAAO,GAAI,SAAS;IAC/B,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC,OAAO,CAAA;IAC1C,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAA;IACjC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,gBAAgB,CAAC,SAAS,GAAG,UAAU,CAAC,UAAU,CAAC,CAAA;IACtG,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACzC,KAAG,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,CAyDnD,CAAA"}

package/dist/cjs/internal/SandboxedExecution.js

@@ -0,0 +1,104 @@
+"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 SandboxedExecution_exports = {};
+__export(SandboxedExecution_exports, {
+  defaultMaxRebases: () => defaultMaxRebases,
+  execute: () => execute
+});
+module.exports = __toCommonJS(SandboxedExecution_exports);
+var import_keys = require("@smthrs/keys");
+var Cause = __toESM(require("effect/Cause"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Exit = __toESM(require("effect/Exit"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var StepBoundary = __toESM(require("../StepBoundary.js"), 1);
+var StepSandbox = __toESM(require("../StepSandbox.js"), 1);
+var WorkspaceSandbox = __toESM(require("../WorkspaceSandbox.js"), 1);
+const defaultMaxRebases = 3;
+const bundleIdentity = (entries) => Schema.decodeUnknownEffect(import_keys.DerivedKey)({
+  kind: "bundle-identity",
+  // Canonicalization substitutes undefined array slots with null. Name and
+  // normalize each member first so absence is explicit in this durable key.
+  entries: entries.map(([path, before, after]) => ({
+    path,
+    before: before ?? null,
+    after: after ?? null
+  }))
+}).pipe(Effect.orDie);
+const conflicted = (cause) => cause.reasons.some(
+  (reason) => Cause.isFailReason(reason) && reason.error instanceof WorkspaceSandbox.MaterializationConflict
+);
+const execute = (options) => {
+  const maxRebases = options.maxRebases ?? defaultMaxRebases;
+  const attempt = (rebases) => Effect.gen(function* () {
+    const executed = yield* options.sandbox.execute({
+      descriptor: options.descriptor,
+      workflow: options.workflow
+    });
+    if (executed._tag === "Invalidated") {
+      const paths = executed.violations.map((violation) => violation.resource.id);
+      const identity2 = yield* bundleIdentity(
+        executed.provenance.outputs.map((output) => [output.resource.id, void 0, output.digest])
+      );
+      if (executed.violations.some((violation) => violation.kind === "undeclared-read")) {
+        return yield* Effect.fail(
+          new StepSandbox.UndeclaredRead({
+            code: "undeclared_read",
+            paths: executed.violations.filter((violation) => violation.kind === "undeclared-read").map((violation) => violation.resource.id),
+            diffIdentity: identity2
+          })
+        );
+      }
+      return yield* Effect.fail(
+        new StepBoundary.UndeclaredWrite({
+          code: "undeclared_write",
+          paths,
+          diffIdentity: identity2
+        })
+      );
+    }
+    const identity = yield* bundleIdentity(
+      executed.result.files.map((change) => [change.path, change.beforeDigest, change.afterDigest])
+    );
+    const applied = yield* options.sandbox.materialize(executed).pipe(Effect.exit);
+    if (Exit.isFailure(applied)) {
+      return conflicted(applied.cause) && rebases < maxRebases ? yield* attempt(rebases + 1) : yield* Effect.failCause(applied.cause);
+    }
+    return {
+      result: executed.result.output,
+      bundleIdentity: identity,
+      files: executed.result.files,
+      effects: executed.result.effects,
+      deviations: executed.violations.map((violation) => violation.resource.id),
+      rebases
+    };
+  });
+  return attempt(0);
+};
+//# sourceMappingURL=SandboxedExecution.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/SandboxedExecution.ts"],
+  "sourcesContent": ["/**\n * The isolated half of an attempt: run the body in a workspace transaction,\n * copy its diff bundle back, and rebase a bounded number of times when the\n * host moved underneath it.\n *\n * Copy-back has no human review gate.\n *\n * @since 0.1.0\n */\n\nimport type { FileBoundary } from \"@smthrs/flow/FileBoundary\"\nimport { DerivedKey } from \"@smthrs/keys\"\nimport * as Cause from \"effect/Cause\"\nimport type * as Crypto from \"effect/Crypto\"\nimport * as Effect from \"effect/Effect\"\nimport * as Exit from \"effect/Exit\"\nimport type * as FileSystem from \"effect/FileSystem\"\nimport * as Schema from \"effect/Schema\"\nimport * as StepBoundary from \"../StepBoundary.ts\"\nimport * as StepSandbox from \"../StepSandbox.ts\"\nimport * as WorkspaceSandbox from \"../WorkspaceSandbox.ts\"\n\n/**\n * An isolated execution whose diff bundle is now on the host.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Settlement {\n  readonly result: unknown\n  /**\n   * The content address of the applied bundle: a digest over every\n   * `(path, beforeDigest, afterDigest)` triple. It is the journal's handle on\n   * the copy-back, and the `diffIdentity` a deviation carries.\n   */\n  readonly bundleIdentity: string\n  readonly files: ReadonlyArray<WorkspaceSandbox.FileChange>\n  readonly effects: ReadonlyArray<WorkspaceSandbox.QueuedEffect>\n  /**\n   * Paths the body wrote outside its declared write set. Non-empty only in\n   * expected mode \u2014 hard mode fails instead \u2014 and the whole tree is in view,\n   * not just the declared read set `StepBoundary` can re-measure.\n   */\n  readonly deviations: ReadonlyArray<string>\n  /** How many times copy-back lost a race and the attempt re-ran from a fresh base. */\n  readonly rebases: number\n}\n\n/**\n * How many times a losing copy-back re-runs the body from a fresh base.\n *\n * Bounded on purpose: an unbounded rebase against a workspace under sustained\n * concurrent modification never converges. This retry budget does not\n * recreate the removed worktree-lane surface.\n *\n * @since 0.1.0\n * @category models\n */\nexport const defaultMaxRebases = 3\n\nconst bundleIdentity = (\n  entries: ReadonlyArray<readonly [string, string | undefined, string | undefined]>\n): Effect.Effect<string, never, Crypto.Crypto> =>\n  Schema.decodeUnknownEffect(DerivedKey)({\n    kind: \"bundle-identity\",\n    // Canonicalization substitutes undefined array slots with null. Name and\n    // normalize each member first so absence is explicit in this durable key.\n    entries: entries.map(([path, before, after]) => ({\n      path,\n      before: before ?? null,\n      after: after ?? null\n    }))\n  }).pipe(Effect.orDie)\n\nconst conflicted = (cause: Cause.Cause<unknown>): boolean =>\n  cause.reasons.some((reason) =>\n    Cause.isFailReason(reason) && reason.error instanceof WorkspaceSandbox.MaterializationConflict\n  )\n\n/**\n * Runs one action body inside a workspace transaction and copies its result\n * back.\n *\n * The host is untouched until copy-back, so every refusal below leaves the\n * tree exactly as it found it:\n *\n * - a body failure propagates unchanged, because it is the action's own\n *   declared error and the retry policy must still match on it;\n * - an execution the declaration did not predict fails with the boundary's own\n *   {@link StepBoundary.UndeclaredWrite}, which routes it through the caller's\n *   existing hard-violation classification instead of inventing a second one;\n * - a lost copy-back race re-runs the body from a fresh base up to\n *   `maxRebases` times before surfacing the conflict.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const execute = (options: {\n  readonly sandbox: WorkspaceSandbox.Service\n  readonly descriptor: FileBoundary\n  /**\n   * The action body. The engine's encoded effect erases its requirements, so\n   * the sandbox's own surfaces are named here: they are what `execute` seeds,\n   * and naming them keeps a caller from having to launder the type.\n   */\n  readonly workflow: Effect.Effect<unknown, unknown, WorkspaceSandbox.Workspace | FileSystem.FileSystem>\n  readonly maxRebases?: number | undefined\n}): Effect.Effect<Settlement, unknown, Crypto.Crypto> => {\n  const maxRebases = options.maxRebases ?? defaultMaxRebases\n  const attempt = (rebases: number): Effect.Effect<Settlement, unknown, Crypto.Crypto> =>\n    Effect.gen(function*() {\n      const executed = yield* options.sandbox.execute({\n        descriptor: options.descriptor,\n        workflow: options.workflow\n      })\n      if (executed._tag === \"Invalidated\") {\n        // NOTHING IS RETURNED FROM AN INVALIDATED EXECUTION. The candidate\n        // output, its files, and its queued effects are not on the shape at\n        // all; only the violations and the provenance identifying them are.\n        const paths = executed.violations.map((violation) => violation.resource.id)\n        const identity = yield* bundleIdentity(\n          executed.provenance.outputs.map((output) => [output.resource.id, undefined, output.digest])\n        )\n        if (executed.violations.some((violation) => violation.kind === \"undeclared-read\")) {\n          return yield* Effect.fail(\n            new StepSandbox.UndeclaredRead({\n              code: \"undeclared_read\",\n              paths: executed.violations\n                .filter((violation) => violation.kind === \"undeclared-read\")\n                .map((violation) => violation.resource.id),\n              diffIdentity: identity\n            })\n          )\n        }\n        return yield* Effect.fail(\n          new StepBoundary.UndeclaredWrite({\n            code: \"undeclared_write\",\n            paths,\n            diffIdentity: identity\n          })\n        )\n      }\n      const identity = yield* bundleIdentity(\n        executed.result.files.map((change) => [change.path, change.beforeDigest, change.afterDigest])\n      )\n      const applied = yield* options.sandbox.materialize(executed).pipe(Effect.exit)\n      if (Exit.isFailure(applied)) {\n        // Only a conflict is rebaseable: it says the base moved, which a fresh\n        // execution answers. A host or artifact refusal says the copy-back\n        // itself cannot be performed, and re-running the body would not help.\n        return conflicted(applied.cause) && rebases < maxRebases\n          ? yield* attempt(rebases + 1)\n          : yield* Effect.failCause(applied.cause)\n      }\n      return {\n        result: executed.result.output,\n        bundleIdentity: identity,\n        files: executed.result.files,\n        effects: executed.result.effects,\n        deviations: executed.violations.map((violation) => violation.resource.id),\n        rebases\n      }\n    })\n  return attempt(0)\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,kBAA2B;AAC3B,YAAuB;AAEvB,aAAwB;AACxB,WAAsB;AAEtB,aAAwB;AACxB,mBAA8B;AAC9B,kBAA6B;AAC7B,uBAAkC;AAsC3B,MAAM,oBAAoB;AAEjC,MAAM,iBAAiB,CACrB,YAEA,OAAO,oBAAoB,sBAAU,EAAE;AAAA,EACrC,MAAM;AAAA;AAAA;AAAA,EAGN,SAAS,QAAQ,IAAI,CAAC,CAAC,MAAM,QAAQ,KAAK,OAAO;AAAA,IAC/C;AAAA,IACA,QAAQ,UAAU;AAAA,IAClB,OAAO,SAAS;AAAA,EAClB,EAAE;AACJ,CAAC,EAAE,KAAK,OAAO,KAAK;AAEtB,MAAM,aAAa,CAAC,UAClB,MAAM,QAAQ;AAAA,EAAK,CAAC,WAClB,MAAM,aAAa,MAAM,KAAK,OAAO,iBAAiB,iBAAiB;AACzE;AAoBK,MAAM,UAAU,CAAC,YAUiC;AACvD,QAAM,aAAa,QAAQ,cAAc;AACzC,QAAM,UAAU,CAAC,YACf,OAAO,IAAI,aAAY;AACrB,UAAM,WAAW,OAAO,QAAQ,QAAQ,QAAQ;AAAA,MAC9C,YAAY,QAAQ;AAAA,MACpB,UAAU,QAAQ;AAAA,IACpB,CAAC;AACD,QAAI,SAAS,SAAS,eAAe;AAInC,YAAM,QAAQ,SAAS,WAAW,IAAI,CAAC,cAAc,UAAU,SAAS,EAAE;AAC1E,YAAMA,YAAW,OAAO;AAAA,QACtB,SAAS,WAAW,QAAQ,IAAI,CAAC,WAAW,CAAC,OAAO,SAAS,IAAI,QAAW,OAAO,MAAM,CAAC;AAAA,MAC5F;AACA,UAAI,SAAS,WAAW,KAAK,CAAC,cAAc,UAAU,SAAS,iBAAiB,GAAG;AACjF,eAAO,OAAO,OAAO;AAAA,UACnB,IAAI,YAAY,eAAe;AAAA,YAC7B,MAAM;AAAA,YACN,OAAO,SAAS,WACb,OAAO,CAAC,cAAc,UAAU,SAAS,iBAAiB,EAC1D,IAAI,CAAC,cAAc,UAAU,SAAS,EAAE;AAAA,YAC3C,cAAcA;AAAA,UAChB,CAAC;AAAA,QACH;AAAA,MACF;AACA,aAAO,OAAO,OAAO;AAAA,QACnB,IAAI,aAAa,gBAAgB;AAAA,UAC/B,MAAM;AAAA,UACN;AAAA,UACA,cAAcA;AAAA,QAChB,CAAC;AAAA,MACH;AAAA,IACF;AACA,UAAM,WAAW,OAAO;AAAA,MACtB,SAAS,OAAO,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,MAAM,OAAO,cAAc,OAAO,WAAW,CAAC;AAAA,IAC9F;AACA,UAAM,UAAU,OAAO,QAAQ,QAAQ,YAAY,QAAQ,EAAE,KAAK,OAAO,IAAI;AAC7E,QAAI,KAAK,UAAU,OAAO,GAAG;AAI3B,aAAO,WAAW,QAAQ,KAAK,KAAK,UAAU,aAC1C,OAAO,QAAQ,UAAU,CAAC,IAC1B,OAAO,OAAO,UAAU,QAAQ,KAAK;AAAA,IAC3C;AACA,WAAO;AAAA,MACL,QAAQ,SAAS,OAAO;AAAA,MACxB,gBAAgB;AAAA,MAChB,OAAO,SAAS,OAAO;AAAA,MACvB,SAAS,SAAS,OAAO;AAAA,MACzB,YAAY,SAAS,WAAW,IAAI,CAAC,cAAc,UAAU,SAAS,EAAE;AAAA,MACxE;AAAA,IACF;AAAA,EACF,CAAC;AACH,SAAO,QAAQ,CAAC;AAClB;",
+  "names": ["identity"]
+}

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

@@ -0,0 +1,44 @@
+/**
+ * The engine store's one lock order for engine state and the journal.
+ *
+ * @since 0.1.0
+ */
+import type { DatabaseError } from "@smthrs/database/DurableWriter";
+import type { Journal } from "@smthrs/journal";
+import * as Effect from "effect/Effect";
+import type * as DurableEngineState from "../DurableEngineState.ts";
+/**
+ * Binds one ordered transaction boundary to a pair of stores.
+ *
+ * **The order is part of the package's contract.** Every fiber that needs
+ * both boundaries takes `DurableEngineState.transaction` FIRST and opens the
+ * journal's write transaction inside it. Never the other way around. The SQL
+ * engine state cannot tell the difference, because its transaction and the
+ * journal's are the same `DurableWriter` transaction and one of them nests as
+ * a savepoint of the other either way. The memory engine state has a gate of
+ * its own, and the contract requires the two implementations to be
+ * semantically equal. Taking the journal transaction first leaves a fiber
+ * holding the writer while it waits for that gate, which deadlocks against
+ * any fiber holding the gate while it waits for the writer. Both waits keep the
+ * caller's interruptibility: the state gate is taken first, then DurableWriter
+ * queues for its own permit before entering Effect SQL's masked connection
+ * acquisition. A journal-only writer never takes the state gate, so the
+ * writer's permit is what keeps a caller waiting behind it cancellable.
+ *
+ * Within that order the boundary is atomic in both directions: a failure
+ * before COMMIT rolls the SQL transaction back AND restores the memory
+ * snapshot, and the memory snapshot is accepted exactly at SQL COMMIT,
+ * through the `onCommit` callback registered before the body can queue any
+ * publication. The gate is therefore already released when the journal runs
+ * its post-commit work: compaction capture runs in a CHILD fiber and must see
+ * a released gate, just as it sees a committed SQL transaction. Publication
+ * failures happen after both commits and cannot undo either.
+ *
+ * `transact` defaults to the journal's own transaction. A caller passes its
+ * own only to change how the writer's Exit is read, never to change the order.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: (state: Pick<DurableEngineState.Service, "transaction">, journal: Journal.Service) => <A, E, R>(effect: Effect.Effect<A, E, R>, transact?: <B, F, S>(write: Effect.Effect<B, F, S>) => Effect.Effect<B, F | Journal.JournalError | DatabaseError, S>) => Effect.Effect<A, E | Journal.JournalError | DatabaseError, R>;
+//# sourceMappingURL=StateTransaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransaction.d.ts","sourceRoot":"","sources":["../../../src/internal/StateTransaction.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAA;AACnE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,kBAAkB,MAAM,0BAA0B,CAAA;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,IAAI,GACf,OAAO,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,aAAa,CAAC,EACtD,SAAS,OAAO,CAAC,OAAO,MAEzB,CAAC,EAAE,CAAC,EAAE,CAAC,EACN,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAC9B,WAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAC1B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,YAAY,GAAG,aAAa,EAAE,CAAC,CAAoB,KACpF,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,YAAY,GAAG,aAAa,EAAE,CAAC,CAiB3D,CAAA"}

package/dist/cjs/internal/StateTransaction.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 StateTransaction_exports = {};
+__export(StateTransaction_exports, {
+  make: () => make
+});
+module.exports = __toCommonJS(StateTransaction_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+const make = (state, journal) => (effect, transact = journal.transact) => Effect.suspend(() => {
+  let commit = Effect.void;
+  let bodyCompleted = false;
+  return state.transaction(
+    transact(Effect.gen(function* () {
+      yield* journal.whenCommitted(Effect.suspend(() => bodyCompleted ? commit : Effect.void));
+      const value = yield* effect;
+      bodyCompleted = true;
+      return value;
+    })),
+    {
+      onCommit: (accept) => {
+        commit = accept;
+      }
+    }
+  );
+});
+//# sourceMappingURL=StateTransaction.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/StateTransaction.ts"],
+  "sourcesContent": ["/**\n * The engine store's one lock order for engine state and the journal.\n *\n * @since 0.1.0\n */\n\nimport type { DatabaseError } from \"@smthrs/database/DurableWriter\"\nimport type { Journal } from \"@smthrs/journal\"\nimport * as Effect from \"effect/Effect\"\nimport type * as DurableEngineState from \"../DurableEngineState.ts\"\n\n/**\n * Binds one ordered transaction boundary to a pair of stores.\n *\n * **The order is part of the package's contract.** Every fiber that needs\n * both boundaries takes `DurableEngineState.transaction` FIRST and opens the\n * journal's write transaction inside it. Never the other way around. The SQL\n * engine state cannot tell the difference, because its transaction and the\n * journal's are the same `DurableWriter` transaction and one of them nests as\n * a savepoint of the other either way. The memory engine state has a gate of\n * its own, and the contract requires the two implementations to be\n * semantically equal. Taking the journal transaction first leaves a fiber\n * holding the writer while it waits for that gate, which deadlocks against\n * any fiber holding the gate while it waits for the writer. Both waits keep the\n * caller's interruptibility: the state gate is taken first, then DurableWriter\n * queues for its own permit before entering Effect SQL's masked connection\n * acquisition. A journal-only writer never takes the state gate, so the\n * writer's permit is what keeps a caller waiting behind it cancellable.\n *\n * Within that order the boundary is atomic in both directions: a failure\n * before COMMIT rolls the SQL transaction back AND restores the memory\n * snapshot, and the memory snapshot is accepted exactly at SQL COMMIT,\n * through the `onCommit` callback registered before the body can queue any\n * publication. The gate is therefore already released when the journal runs\n * its post-commit work: compaction capture runs in a CHILD fiber and must see\n * a released gate, just as it sees a committed SQL transaction. Publication\n * failures happen after both commits and cannot undo either.\n *\n * `transact` defaults to the journal's own transaction. A caller passes its\n * own only to change how the writer's Exit is read, never to change the order.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = (\n  state: Pick<DurableEngineState.Service, \"transaction\">,\n  journal: Journal.Service\n) =>\n<A, E, R>(\n  effect: Effect.Effect<A, E, R>,\n  transact: <B, F, S>(\n    write: Effect.Effect<B, F, S>\n  ) => Effect.Effect<B, F | Journal.JournalError | DatabaseError, S> = journal.transact\n): Effect.Effect<A, E | Journal.JournalError | DatabaseError, R> =>\n  Effect.suspend(() => {\n    let commit = Effect.void\n    let bodyCompleted = false\n    return state.transaction(\n      transact(Effect.gen(function*() {\n        yield* journal.whenCommitted(Effect.suspend(() => bodyCompleted ? commit : Effect.void))\n        const value = yield* effect\n        bodyCompleted = true\n        return value\n      })),\n      {\n        onCommit: (accept) => {\n          commit = accept\n        }\n      }\n    )\n  })\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,aAAwB;AAoCjB,MAAM,OAAO,CAClB,OACA,YAEF,CACE,QACA,WAEqE,QAAQ,aAE7E,OAAO,QAAQ,MAAM;AACnB,MAAI,SAAS,OAAO;AACpB,MAAI,gBAAgB;AACpB,SAAO,MAAM;AAAA,IACX,SAAS,OAAO,IAAI,aAAY;AAC9B,aAAO,QAAQ,cAAc,OAAO,QAAQ,MAAM,gBAAgB,SAAS,OAAO,IAAI,CAAC;AACvF,YAAM,QAAQ,OAAO;AACrB,sBAAgB;AAChB,aAAO;AAAA,IACT,CAAC,CAAC;AAAA,IACF;AAAA,MACE,UAAU,CAAC,WAAW;AACpB,iBAAS;AAAA,MACX;AAAA,IACF;AAAA,EACF;AACF,CAAC;",
+  "names": []
+}

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

@@ -0,0 +1,14 @@
+/** Projects only the saved outcome of an annotated trace checkpoint.
+ * @since 1.0.0
+ */
+import { JournalEvent } from "@smthrs/journal";
+import * as Effect from "effect/Effect";
+/** Builds the storage-only projector for one action.
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const make: (action: unknown, runId: string) => {
+    annotated: boolean;
+    settled: (outcome: unknown) => Effect.Effect<JournalEvent.Input | undefined, never, never>;
+};
+//# sourceMappingURL=StepFacts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StepFacts.d.ts","sourceRoot":"","sources":["../../../src/internal/StepFacts.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAY,MAAM,iBAAiB,CAAA;AAExD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC;;;GAGG;AACH,eAAO,MAAM,IAAI,GAAI,QAAQ,OAAO,EAAE,OAAO,MAAM;;uBAO5B,OAAO;CAc7B,CAAA"}

package/dist/cjs/internal/StepFacts.js

@@ -0,0 +1,58 @@
+"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 StepFacts_exports = {};
+__export(StepFacts_exports, {
+  make: () => make
+});
+module.exports = __toCommonJS(StepFacts_exports);
+var import_journal = require("@smthrs/journal");
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+const make = (action, runId) => {
+  const annotations = typeof action === "object" && action !== null && "annotations" in action ? action.annotations : void 0;
+  const annotated = annotations !== void 0 && Option.isSome(Context.getOption(annotations, import_journal.StepFact.Annotation));
+  return {
+    annotated,
+    settled: (outcome) => Effect.gen(function* () {
+      if (!annotated) return void 0;
+      const fact = yield* Schema.decodeUnknownEffect(import_journal.StepFact.Fact)(outcome).pipe(Effect.orDie);
+      const step = fact.step;
+      return new import_journal.JournalEvent.Input({
+        runId: import_journal.JournalEvent.RunId.make(runId),
+        sourceId: import_journal.JournalEvent.SourceId.make(`step-fact-v1:${step.stepId}:${step.attempt}:${step.ask}:${step.retry}`),
+        sourceSeq: import_journal.JournalEvent.SourceSeq.make(fact.sourceSequence),
+        eventType: import_journal.StepFact.eventType,
+        payload: fact
+      });
+    })
+  };
+};
+//# sourceMappingURL=StepFacts.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/StepFacts.ts"],
+  "sourcesContent": ["/** Projects only the saved outcome of an annotated trace checkpoint.\n * @since 1.0.0\n */\n\nimport { JournalEvent, StepFact } from \"@smthrs/journal\"\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Option from \"effect/Option\"\nimport * as Schema from \"effect/Schema\"\n\n/** Builds the storage-only projector for one action.\n * @category constructors\n * @since 1.0.0\n */\nexport const make = (action: unknown, runId: string) => {\n  const annotations = typeof action === \"object\" && action !== null && \"annotations\" in action\n    ? action.annotations as Context.Context<never>\n    : undefined\n  const annotated = annotations !== undefined && Option.isSome(Context.getOption(annotations, StepFact.Annotation))\n  return {\n    annotated,\n    settled: (outcome: unknown) =>\n      Effect.gen(function*() {\n        if (!annotated) return undefined\n        const fact = yield* Schema.decodeUnknownEffect(StepFact.Fact)(outcome).pipe(Effect.orDie)\n        const step = fact.step\n        return new JournalEvent.Input({\n          runId: JournalEvent.RunId.make(runId),\n          sourceId: JournalEvent.SourceId.make(`step-fact-v1:${step.stepId}:${step.attempt}:${step.ask}:${step.retry}`),\n          sourceSeq: JournalEvent.SourceSeq.make(fact.sourceSequence),\n          eventType: StepFact.eventType,\n          payload: fact\n        })\n      })\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,qBAAuC;AACvC,cAAyB;AACzB,aAAwB;AACxB,aAAwB;AACxB,aAAwB;AAMjB,MAAM,OAAO,CAAC,QAAiB,UAAkB;AACtD,QAAM,cAAc,OAAO,WAAW,YAAY,WAAW,QAAQ,iBAAiB,SAClF,OAAO,cACP;AACJ,QAAM,YAAY,gBAAgB,UAAa,OAAO,OAAO,QAAQ,UAAU,aAAa,wBAAS,UAAU,CAAC;AAChH,SAAO;AAAA,IACL;AAAA,IACA,SAAS,CAAC,YACR,OAAO,IAAI,aAAY;AACrB,UAAI,CAAC,UAAW,QAAO;AACvB,YAAM,OAAO,OAAO,OAAO,oBAAoB,wBAAS,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,KAAK;AACxF,YAAM,OAAO,KAAK;AAClB,aAAO,IAAI,4BAAa,MAAM;AAAA,QAC5B,OAAO,4BAAa,MAAM,KAAK,KAAK;AAAA,QACpC,UAAU,4BAAa,SAAS,KAAK,gBAAgB,KAAK,MAAM,IAAI,KAAK,OAAO,IAAI,KAAK,GAAG,IAAI,KAAK,KAAK,EAAE;AAAA,QAC5G,WAAW,4BAAa,UAAU,KAAK,KAAK,cAAc;AAAA,QAC1D,WAAW,wBAAS;AAAA,QACpB,SAAS;AAAA,MACX,CAAC;AAAA,IACH,CAAC;AAAA,EACL;AACF;",
+  "names": []
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Additive v2 constructors. Existing JournalRecords writers retain their bytes
+ * until a versioned writer cutover can supply complete lifecycle evidence.
+ *
+ * @since 1.0.0
+ */
+/**
+ * Additive typed engine event constructors and decoders.
+ *
+ * @category events
+ * @since 1.0.0
+ */
+export { attempt, attemptEventType, AttemptPayload, type Consumer, CurrentAttempt, decodeCurrentAttempt, decodeEntry, EventError, ExecutionLifecycle, Lineage, stateEvent, stateEventType, StatePayload, Wait } from "@smthrs/journal/EngineEvent";
+//# sourceMappingURL=TypedEvents.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TypedEvents.d.ts","sourceRoot":"","sources":["../../../src/internal/TypedEvents.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;GAKG;AACH,OAAO,EACL,OAAO,EACP,gBAAgB,EAChB,cAAc,EACd,KAAK,QAAQ,EACb,cAAc,EACd,oBAAoB,EACpB,WAAW,EACX,UAAU,EACV,kBAAkB,EAClB,OAAO,EACP,UAAU,EACV,cAAc,EACd,YAAY,EACZ,IAAI,EACL,MAAM,6BAA6B,CAAA"}

package/dist/cjs/internal/TypedEvents.js

@@ -0,0 +1,37 @@
+"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 TypedEvents_exports = {};
+__export(TypedEvents_exports, {
+  AttemptPayload: () => import_EngineEvent.AttemptPayload,
+  CurrentAttempt: () => import_EngineEvent.CurrentAttempt,
+  EventError: () => import_EngineEvent.EventError,
+  ExecutionLifecycle: () => import_EngineEvent.ExecutionLifecycle,
+  Lineage: () => import_EngineEvent.Lineage,
+  StatePayload: () => import_EngineEvent.StatePayload,
+  Wait: () => import_EngineEvent.Wait,
+  attempt: () => import_EngineEvent.attempt,
+  attemptEventType: () => import_EngineEvent.attemptEventType,
+  decodeCurrentAttempt: () => import_EngineEvent.decodeCurrentAttempt,
+  decodeEntry: () => import_EngineEvent.decodeEntry,
+  stateEvent: () => import_EngineEvent.stateEvent,
+  stateEventType: () => import_EngineEvent.stateEventType
+});
+module.exports = __toCommonJS(TypedEvents_exports);
+var import_EngineEvent = require("@smthrs/journal/EngineEvent");
+//# sourceMappingURL=TypedEvents.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/TypedEvents.ts"],
+  "sourcesContent": ["/**\n * Additive v2 constructors. Existing JournalRecords writers retain their bytes\n * until a versioned writer cutover can supply complete lifecycle evidence.\n *\n * @since 1.0.0\n */\n\n/**\n * Additive typed engine event constructors and decoders.\n *\n * @category events\n * @since 1.0.0\n */\nexport {\n  attempt,\n  attemptEventType,\n  AttemptPayload,\n  type Consumer,\n  CurrentAttempt,\n  decodeCurrentAttempt,\n  decodeEntry,\n  EventError,\n  ExecutionLifecycle,\n  Lineage,\n  stateEvent,\n  stateEventType,\n  StatePayload,\n  Wait\n} from \"@smthrs/journal/EngineEvent\"\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAaA,yBAeO;",
+  "names": []
+}

package/dist/cjs/migrations/0001_initial.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Initial durable deferred-completion and clock-deadline schema.
+ *
+ * Schema boundary: `packages/smithers/flows/engine-store/docs/concepts/durable-waits.md`.
+ *
+ * @since 0.1.0
+ */
+import * as Effect from "effect/Effect";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+/**
+ * Creates the `flows_deferred_completions` and `flows_clock_deadlines` tables.
+ *
+ * @category migrations
+ * @since 0.1.0
+ */
+export declare const initial: Effect.Effect<void, unknown, SqlClient.SqlClient>;
+//# sourceMappingURL=0001_initial.d.ts.map

package/dist/cjs/migrations/0001_initial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"0001_initial.d.ts","sourceRoot":"","sources":["../../../src/migrations/0001_initial.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,SAAS,MAAM,+BAA+B,CAAA;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,SAAS,CAgCpE,CAAA"}

package/dist/cjs/migrations/0001_initial.js

@@ -0,0 +1,61 @@
+"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 initial_exports = {};
+__export(initial_exports, {
+  initial: () => initial
+});
+module.exports = __toCommonJS(initial_exports);
+var Dialect = __toESM(require("@smthrs/database/Dialect"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var SqlClient = __toESM(require("effect/unstable/sql/SqlClient"), 1);
+const initial = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  yield* sql`CREATE TABLE flows_deferred_completions (
+    flow_name TEXT NOT NULL CHECK (length(flow_name) > 0),
+    execution_id TEXT NOT NULL CHECK (length(execution_id) > 0),
+    deferred_name TEXT NOT NULL CHECK (length(deferred_name) > 0),
+    exit_json TEXT NOT NULL CHECK (${Dialect.jsonValid(sql, sql`exit_json`)}),
+    metadata_json TEXT CHECK (metadata_json IS NULL OR ${Dialect.jsonValid(sql, sql`metadata_json`)}),
+    completed_at_ms ${Dialect.integer(sql)} NOT NULL CHECK (${Dialect.isInteger(sql, sql`completed_at_ms`)} AND completed_at_ms >= 0 AND completed_at_ms <= 9007199254740991),
+    PRIMARY KEY (flow_name, execution_id, deferred_name),
+    FOREIGN KEY (execution_id) REFERENCES flows_runs (run_id)
+  )`;
+  yield* sql`CREATE TABLE flows_clock_deadlines (
+    flow_name TEXT NOT NULL CHECK (length(flow_name) > 0),
+    execution_id TEXT NOT NULL CHECK (length(execution_id) > 0),
+    clock_name TEXT NOT NULL CHECK (length(clock_name) > 0),
+    deferred_name TEXT NOT NULL CHECK (length(deferred_name) > 0),
+    due_at_ms ${Dialect.integer(sql)} NOT NULL CHECK (${Dialect.isInteger(sql, sql`due_at_ms`)} AND due_at_ms >= 0 AND due_at_ms <= 9007199254740991),
+    completed_at_ms ${Dialect.integer(sql)} CHECK (completed_at_ms IS NULL OR (${Dialect.isInteger(sql, sql`completed_at_ms`)} AND completed_at_ms >= 0 AND completed_at_ms <= 9007199254740991)),
+    PRIMARY KEY (flow_name, execution_id, clock_name),
+    FOREIGN KEY (execution_id) REFERENCES flows_runs (run_id)
+  )`;
+  yield* sql`CREATE INDEX flows_clock_deadlines_pending_idx ON flows_clock_deadlines (completed_at_ms, due_at_ms)`;
+});
+//# sourceMappingURL=0001_initial.js.map

package/dist/cjs/migrations/0001_initial.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/migrations/0001_initial.ts"],
+  "sourcesContent": ["/**\n * Initial durable deferred-completion and clock-deadline schema.\n *\n * Schema boundary: `packages/smithers/flows/engine-store/docs/concepts/durable-waits.md`.\n *\n * @since 0.1.0\n */\n\nimport * as Dialect from \"@smthrs/database/Dialect\"\nimport * as Effect from \"effect/Effect\"\nimport * as SqlClient from \"effect/unstable/sql/SqlClient\"\n\n/**\n * Creates the `flows_deferred_completions` and `flows_clock_deadlines` tables.\n *\n * @category migrations\n * @since 0.1.0\n */\nexport const initial: Effect.Effect<void, unknown, SqlClient.SqlClient> = Effect.gen(function*() {\n  const sql = yield* SqlClient.SqlClient\n\n  yield* sql`CREATE TABLE flows_deferred_completions (\n    flow_name TEXT NOT NULL CHECK (length(flow_name) > 0),\n    execution_id TEXT NOT NULL CHECK (length(execution_id) > 0),\n    deferred_name TEXT NOT NULL CHECK (length(deferred_name) > 0),\n    exit_json TEXT NOT NULL CHECK (${Dialect.jsonValid(sql, sql`exit_json`)}),\n    metadata_json TEXT CHECK (metadata_json IS NULL OR ${Dialect.jsonValid(sql, sql`metadata_json`)}),\n    completed_at_ms ${Dialect.integer(sql)} NOT NULL CHECK (${\n    Dialect.isInteger(sql, sql`completed_at_ms`)\n  } AND completed_at_ms >= 0 AND completed_at_ms <= 9007199254740991),\n    PRIMARY KEY (flow_name, execution_id, deferred_name),\n    FOREIGN KEY (execution_id) REFERENCES flows_runs (run_id)\n  )`\n\n  yield* sql`CREATE TABLE flows_clock_deadlines (\n    flow_name TEXT NOT NULL CHECK (length(flow_name) > 0),\n    execution_id TEXT NOT NULL CHECK (length(execution_id) > 0),\n    clock_name TEXT NOT NULL CHECK (length(clock_name) > 0),\n    deferred_name TEXT NOT NULL CHECK (length(deferred_name) > 0),\n    due_at_ms ${Dialect.integer(sql)} NOT NULL CHECK (${\n    Dialect.isInteger(sql, sql`due_at_ms`)\n  } AND due_at_ms >= 0 AND due_at_ms <= 9007199254740991),\n    completed_at_ms ${Dialect.integer(sql)} CHECK (completed_at_ms IS NULL OR (${\n    Dialect.isInteger(sql, sql`completed_at_ms`)\n  } AND completed_at_ms >= 0 AND completed_at_ms <= 9007199254740991)),\n    PRIMARY KEY (flow_name, execution_id, clock_name),\n    FOREIGN KEY (execution_id) REFERENCES flows_runs (run_id)\n  )`\n\n  yield* sql`CREATE INDEX flows_clock_deadlines_pending_idx ON flows_clock_deadlines (completed_at_ms, due_at_ms)`\n})\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,cAAyB;AACzB,aAAwB;AACxB,gBAA2B;AAQpB,MAAM,UAA6D,OAAO,IAAI,aAAY;AAC/F,QAAM,MAAM,OAAO,UAAU;AAE7B,SAAO;AAAA;AAAA;AAAA;AAAA,qCAI4B,QAAQ,UAAU,KAAK,cAAc,CAAC;AAAA,yDAClB,QAAQ,UAAU,KAAK,kBAAkB,CAAC;AAAA,sBAC7E,QAAQ,QAAQ,GAAG,CAAC,oBACtC,QAAQ,UAAU,KAAK,oBAAoB,CAC7C;AAAA;AAAA;AAAA;AAKA,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA,gBAKO,QAAQ,QAAQ,GAAG,CAAC,oBAChC,QAAQ,UAAU,KAAK,cAAc,CACvC;AAAA,sBACoB,QAAQ,QAAQ,GAAG,CAAC,uCACtC,QAAQ,UAAU,KAAK,oBAAoB,CAC7C;AAAA;AAAA;AAAA;AAKA,SAAO;AACT,CAAC;",
+  "names": []
+}