@smthrs/flow 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/Interpreter.js

@@ -0,0 +1,888 @@
+"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 Interpreter_exports = {};
+__export(Interpreter_exports, {
+  InterpreterError: () => InterpreterError,
+  childExecutionId: () => childExecutionId,
+  interpret: () => interpret,
+  layer: () => layer,
+  layerWithImplementations: () => layerWithImplementations,
+  maximumDispatchDigests: () => maximumDispatchDigests,
+  maximumPageBytes: () => maximumPageBytes
+});
+module.exports = __toCommonJS(Interpreter_exports);
+var import_Record = require("@smthrs/canonical/Record");
+var CapabilitySet = __toESM(require("@smthrs/capability/CapabilitySet"), 1);
+var import_keys = require("@smthrs/keys");
+var import_GraphBuildError = require("@smthrs/plan/GraphBuildError");
+var KeyMaterial = __toESM(require("@smthrs/plan/KeyMaterial"), 1);
+var Node = __toESM(require("@smthrs/plan/Node"), 1);
+var Planned = __toESM(require("@smthrs/plan/Planned"), 1);
+var StepKey = __toESM(require("@smthrs/plan/StepKey"), 1);
+var Cause = __toESM(require("effect/Cause"), 1);
+var Context = __toESM(require("effect/Context"), 1);
+var Deferred = __toESM(require("effect/Deferred"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Exit = __toESM(require("effect/Exit"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var Predicate = __toESM(require("effect/Predicate"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var Scope = __toESM(require("effect/Scope"), 1);
+var import_Implementations = require("./Action/Implementations.js");
+var import_StepIdentity = require("./Action/StepIdentity.js");
+var DurableDeferred = __toESM(require("./DurableDeferred.js"), 1);
+var import_CapabilityCeiling = require("./Flow/CapabilityCeiling.js");
+var Outcome = __toESM(require("./Flow/Outcome.js"), 1);
+var import_Result = require("./Flow/Result.js");
+var import_Runtime = require("./Flow/Runtime.js");
+var import_TypeId = require("./Flow/TypeId.js");
+var import_FlowInstance = require("./FlowRuntime/FlowInstance.js");
+var import_FlowRuntime = require("./FlowRuntime/FlowRuntime.js");
+var import_WaitingAnnotation = require("./FlowRuntime/WaitingAnnotation.js");
+var Graph = __toESM(require("./Graph.js"), 1);
+var BoundedJson = __toESM(require("./internal/BoundedJson.js"), 1);
+var import_ExecutionMiddleware = require("./internal/ExecutionMiddleware.js");
+var import_OutcomeMarker = require("./internal/OutcomeMarker.js");
+class InterpreterError extends Schema.TaggedError()(
+  "@smthrs/flow/InterpreterError",
+  {
+    code: Schema.Literals([
+      "incomplete_graph",
+      "duplicate_node_id",
+      "unresolved_action",
+      "implementation_version_mismatch",
+      "missing_implementation_version",
+      "unresolved_reference",
+      "unsupported_call",
+      "missing_operation",
+      "node_record_too_large",
+      "join_mismatch"
+    ]),
+    flow: Schema.String,
+    node: Schema.String,
+    message: Schema.String
+  }
+) {
+}
+const ownDataProperty = (value, key) => {
+  if (Object(value) !== value) return void 0;
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor !== void 0 && "value" in descriptor ? descriptor.value : void 0;
+  } catch {
+    return void 0;
+  }
+};
+const childExecutionId = (parentExecutionId, nodeId, calleeTag, payload) => Effect.gen(function* () {
+  const payloadDigest = yield* Schema.decodeUnknownEffect(import_keys.DerivedKey)(payload).pipe(Effect.orDie);
+  const tupleDigest = yield* Schema.decodeUnknownEffect(import_keys.DerivedKey)([
+    parentExecutionId,
+    nodeId,
+    calleeTag,
+    payloadDigest
+  ]).pipe(Effect.orDie);
+  return (0, import_keys.digest)(tupleDigest);
+});
+const maximumPageBytes = 12e3;
+const maximumDispatchDigests = 16;
+const actionTag = (ast) => ast._tag === "ActionCall" ? ast.action : ast._tag === "FlowCall" ? ast.flow : void 0;
+const summarize = (node) => {
+  const action = actionTag(node.ast);
+  return {
+    id: node.id,
+    kind: node.kind,
+    dependsOn: KeyMaterial.dependencies(node.draft.material),
+    tier: node.draft.material.kind,
+    effects: node.draft.effects,
+    ...action === void 0 ? {} : { action },
+    ...node.declaredAt === void 0 ? {} : { declaredAt: node.declaredAt }
+  };
+};
+const planPages = (flow, graph, measure) => Effect.gen(function* () {
+  const incoming = /* @__PURE__ */ new Map();
+  let edgeCount = 0;
+  for (const edge of Graph.edges(graph)) {
+    edgeCount += 1;
+    const summary = { from: edge.from, to: edge.to, reason: edge.reason };
+    const existing = incoming.get(edge.to);
+    if (existing === void 0) incoming.set(edge.to, [summary]);
+    else existing.push(summary);
+  }
+  const graphNodes = Graph.nodes(graph);
+  const pages = [];
+  let current = { nodes: [], edges: [] };
+  const record = (page, index, count) => ({
+    ...index === 0 ? { _tag: "PlanRecorded", nodeCount: graphNodes.length } : { _tag: "SubgraphAppended" },
+    sourceId: `plan/0/${index}`,
+    flow,
+    generation: 0,
+    page: index,
+    pages: count,
+    ...page
+  });
+  const reserved = graphNodes.reduce(
+    (total, node) => total + KeyMaterial.dependencies(node.draft.material).length,
+    graphNodes.length + edgeCount
+  );
+  const fits = (page) => Effect.map(measure(record(page, pages.length, reserved)), (bytes) => bytes <= maximumPageBytes);
+  const flush = () => {
+    pages.push(current);
+    current = { nodes: [], edges: [] };
+  };
+  const admits = (rest, grow) => Effect.gen(function* () {
+    if (yield* fits(grow(rest.length))) return rest.length;
+    let low = 0;
+    let high = rest.length - 1;
+    while (low < high) {
+      const mid = low + Math.ceil((high - low) / 2);
+      if (yield* fits(grow(mid))) low = mid;
+      else high = mid - 1;
+    }
+    return low;
+  });
+  const spread = (items, onto, resume, refusal) => Effect.gen(function* () {
+    let rest = items;
+    let started = false;
+    while (rest.length > 0) {
+      const take = yield* admits(rest, (count) => onto(current, rest.slice(0, count)));
+      if (take > 0) {
+        current = onto(current, rest.slice(0, take));
+        rest = rest.slice(take);
+        started = false;
+        continue;
+      }
+      if (started) return yield* refusal();
+      flush();
+      current = resume(current);
+      started = true;
+    }
+  });
+  for (const node of graphNodes) {
+    const summary = summarize(node);
+    const arriving = incoming.get(node.id) ?? [];
+    const bare = { ...summary, dependsOn: [] };
+    const seat = (page) => ({ nodes: [...page.nodes, bare], edges: page.edges });
+    const tooLarge = () => new InterpreterError({
+      code: "node_record_too_large",
+      flow,
+      node: node.id,
+      message: `Node "${node.id}" and its encoded envelope exceed ${maximumPageBytes} bytes with no dependencies on it`
+    });
+    if (!(yield* fits(seat(current)))) {
+      if (current.nodes.length > 0 || current.edges.length > 0) flush();
+      if (!(yield* fits(seat(current)))) return yield* tooLarge();
+    }
+    current = seat(current);
+    yield* spread(
+      summary.dependsOn,
+      (page, taken) => {
+        const seated = page.nodes[page.nodes.length - 1];
+        return {
+          nodes: [...page.nodes.slice(0, -1), { ...seated, dependsOn: [...seated.dependsOn, ...taken] }],
+          edges: page.edges
+        };
+      },
+      seat,
+      tooLarge
+    );
+    yield* spread(
+      arriving,
+      (page, taken) => ({ nodes: page.nodes, edges: [...page.edges, ...taken] }),
+      (page) => page,
+      tooLarge
+    );
+  }
+  pages.push(current);
+  return pages.map((page, index) => record(page, index, pages.length));
+});
+const interpret = (flowOrNode, payload, options = {}) => interpretWithPolicy(flowOrNode, payload, options, false);
+const interpretWithPolicy = (flowOrNode, payload, options, requireReusableVersions, registerReachable) => Effect.gen(function* () {
+  const table = yield* import_Implementations.Implementations;
+  const name = "_tag" in flowOrNode ? flowOrNode._tag : "node";
+  const refuse = (code, node, message) => Effect.fail(new InterpreterError({ code, flow: name, node, message }));
+  const graph = yield* Effect.try({
+    try: () => Graph.build(flowOrNode, payload, options),
+    catch: (cause) => {
+      const refusalNode = ownDataProperty(cause, "node");
+      const refusalCode = ownDataProperty(cause, "code");
+      const refusalMessage = ownDataProperty(cause, "message");
+      const node = typeof refusalNode === "string" ? refusalNode : "";
+      const reported2 = typeof refusalMessage === "string" ? refusalMessage : "";
+      return new InterpreterError({
+        code: refusalCode === "duplicate_node" ? "duplicate_node_id" : "incomplete_graph",
+        flow: name,
+        node,
+        message: reported2 === "" ? `building the graph of flow ${name} threw ${typeof cause === "string" ? cause : BoundedJson.render(cause, 512)}` : reported2
+      });
+    }
+  });
+  const graphNodes = Graph.nodes(graph);
+  const byId = new Map(graphNodes.map((node) => [node.id, node]));
+  const fatal = graph.diagnostics.find(import_GraphBuildError.isFatalDiagnostic);
+  if (fatal !== void 0) {
+    return yield* refuse(
+      "incomplete_graph",
+      fatal.node,
+      `Graph of "${name}" is missing topology and cannot be driven: ${fatal.message}`
+    );
+  }
+  const runtime = yield* import_FlowRuntime.FlowRuntime;
+  const recordNode = runtime.recordNode;
+  const record = recordNode === void 0 ? (_) => Effect.void : (make) => recordNode(make());
+  if (recordNode !== void 0) {
+    const measure = runtime.nodeRecordBytes ?? ((record2) => Effect.succeed(new TextEncoder().encode(JSON.stringify(record2)).byteLength));
+    const pages = yield* planPages(name, graph, measure);
+    yield* Effect.forEach(pages, (page) => recordNode(page), { discard: true });
+  }
+  const implementations = /* @__PURE__ */ new Map();
+  const handoffDeclarations = /* @__PURE__ */ new Map();
+  const childDeclarations = /* @__PURE__ */ new Map();
+  for (const node of graphNodes) {
+    const ast = node.ast;
+    if (ast._tag === "Map" && Node.mapper(ast) === void 0) {
+      return yield* refuse("missing_operation", node.id, `Map at "${node.id}" lost its mapper.`);
+    }
+    if (ast._tag === "Branch" && Node.predicate(ast) === void 0) {
+      return yield* refuse("missing_operation", node.id, `Branch at "${node.id}" lost its predicate.`);
+    }
+    if (ast._tag === "Catch" && ast.filter !== void 0 && Node.catchFilter(ast) === void 0) {
+      return yield* refuse("missing_operation", node.id, `Catch at "${node.id}" lost its schema filter.`);
+    }
+    for (const dependency of KeyMaterial.dependencies(node.draft.material)) {
+      if (byId.has(dependency)) continue;
+      return yield* refuse(
+        "unresolved_reference",
+        node.id,
+        `Node "${node.id}" reads "${dependency}", which this graph does not hold.`
+      );
+    }
+    if (node.ast._tag === "FlowCall" && node.ast.mode === "handoff") {
+      const declaration2 = Node.declaration(node.ast);
+      if (!Predicate.hasProperty(declaration2, import_TypeId.TypeId)) {
+        return yield* refuse(
+          "unsupported_call",
+          node.id,
+          `Handoff to flow "${node.ast.flow}" at "${node.id}" lost its declaration. Build and interpret the authored node in the same process so its payload can be encoded.`
+        );
+      }
+      handoffDeclarations.set(node.id, declaration2);
+      if (registerReachable !== void 0) yield* registerReachable(declaration2);
+      continue;
+    }
+    if (node.ast._tag === "FlowCall" && node.ast.mode === "boundary") {
+      const declaration2 = Node.declaration(node.ast);
+      if (!Predicate.hasProperty(declaration2, import_TypeId.TypeId)) {
+        return yield* refuse(
+          "unsupported_call",
+          node.id,
+          `Child boundary to flow "${node.ast.flow}" at "${node.id}" lost its declaration. Build and interpret the authored node in the same process so the child can be executed.`
+        );
+      }
+      childDeclarations.set(node.id, declaration2);
+      if (registerReachable !== void 0) yield* registerReachable(declaration2);
+      continue;
+    }
+    if (node.ast._tag !== "ActionCall") continue;
+    const implementation = yield* table.get(node.ast.action);
+    if (Option.isNone(implementation)) {
+      return yield* refuse(
+        "unresolved_action",
+        node.id,
+        `Action "${node.ast.action}" has no implementation. Provide ONE Action.layerImplementations under both ${node.ast.action}.toLayer(execute) and this interpreter layer: an implementation files itself with the table that is in scope while IT is built, so a table merged beside it, or a second one built above it, is not the table this driver reads.`
+      );
+    }
+    const declaration = Node.declaration(node.ast);
+    const declaredVersion = ownDataProperty(declaration, "implementationVersion");
+    if (requireReusableVersions) {
+      const tier = ownDataProperty(declaration, "tier");
+      if (tier === void 0) {
+        return yield* refuse(
+          "incomplete_graph",
+          node.id,
+          `Action "${node.ast.action}" lost its declaration, so its implementation identity cannot be checked. Build the canonical composition from the authored action nodes.`
+        );
+      }
+      if (tier === "sealed" && ownDataProperty(declaration, "idempotencyKey") !== void 0 && declaredVersion === void 0) {
+        return yield* refuse(
+          "missing_implementation_version",
+          node.id,
+          `Sealed action "${node.ast.action}" declares an idempotency key and can reuse recorded content. Declare implementationVersion on Action.make and attest the same version in toLayer.`
+        );
+      }
+    }
+    if (declaredVersion !== implementation.value.implementationVersion) {
+      return yield* refuse(
+        "implementation_version_mismatch",
+        node.id,
+        `Action "${node.ast.action}" does not match its registered implementationVersion. Register the declared version and start a newly planned execution when its semantics change.`
+      );
+    }
+    implementations.set(node.ast.action, implementation.value);
+  }
+  const remaining = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  const ready = [];
+  for (const node of graphNodes) {
+    const dependencies = KeyMaterial.dependencies(node.draft.material);
+    remaining.set(node.id, dependencies.length);
+    if (dependencies.length === 0) ready.push(node.id);
+    for (const dependency of dependencies) {
+      const consumers = dependents.get(dependency);
+      if (consumers === void 0) dependents.set(dependency, [node.id]);
+      else consumers.push(node.id);
+    }
+  }
+  for (let index = 0; index < ready.length; index++) {
+    for (const consumer of dependents.get(ready[index]) ?? []) {
+      const count = remaining.get(consumer) - 1;
+      remaining.set(consumer, count);
+      if (count === 0) ready.push(consumer);
+    }
+  }
+  if (ready.length !== graphNodes.length) {
+    const blocked = graphNodes.find((node) => remaining.get(node.id) > 0);
+    return yield* refuse(
+      "incomplete_graph",
+      blocked.id,
+      `Graph of "${name}" contains a dependency cycle blocking "${blocked.id}". Use an acyclic reference, a child boundary, or a trampoline handoff.`
+    );
+  }
+  const sources = /* @__PURE__ */ new Map();
+  for (const edge of Graph.edges(graph)) {
+    if (edge.reason !== "value") continue;
+    sources.set(edge.to, [...sources.get(edge.to) ?? [], edge.from]);
+  }
+  const settled = /* @__PURE__ */ new Map();
+  const failed = /* @__PURE__ */ new Map();
+  const project = StepKey.project;
+  const resolve = (value2) => {
+    const reference = Planned.reference(value2);
+    if (reference !== void 0) {
+      return project(
+        settled.has(reference.node) ? settled.get(reference.node) : failed.get(reference.node),
+        reference.path
+      );
+    }
+    if (Array.isArray(value2)) return value2.map((item) => resolve(item));
+    if (!(0, import_Record.isRecord)(value2)) return value2;
+    const output = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(value2)) {
+      Object.defineProperty(output, key, {
+        configurable: true,
+        enumerable: true,
+        value: resolve(value2[key]),
+        writable: true
+      });
+    }
+    const outcome = Object.getOwnPropertyDescriptor(value2, import_OutcomeMarker.OutcomeValueTypeId);
+    if (outcome !== void 0 && "value" in outcome) {
+      Object.defineProperty(output, import_OutcomeMarker.OutcomeValueTypeId, {
+        configurable: false,
+        enumerable: false,
+        value: outcome.value,
+        writable: false
+      });
+    }
+    return output;
+  };
+  const inFlight = /* @__PURE__ */ new Map();
+  const nodes = yield* Scope.make();
+  const executions = /* @__PURE__ */ new Map();
+  const childExecutions = /* @__PURE__ */ new Map();
+  const reported = /* @__PURE__ */ new Set();
+  const settleNode = (id) => Effect.suspend(() => {
+    if (settled.has(id)) return Effect.succeed(settled.get(id));
+    const waiting = inFlight.get(id);
+    if (waiting !== void 0) return Deferred.await(waiting);
+    const deferred = Deferred.makeUnsafe();
+    inFlight.set(id, deferred);
+    const node = byId.get(id);
+    const action = actionTag(node.ast);
+    const dispatches = { executed: 0, replayed: 0, attempts: 1, digests: /* @__PURE__ */ new Set() };
+    const settleRecord = (outcome, settlement) => () => ({
+      _tag: "NodeSettled",
+      sourceId: `node/${id}/1/settled`,
+      nodeId: id,
+      outcome,
+      attempts: dispatches.attempts,
+      stepKeyDigests: [...dispatches.digests],
+      value: settlement.value,
+      ...action === void 0 ? {} : { action }
+    });
+    const execution = record(() => ({
+      _tag: "NodeScheduled",
+      sourceId: `node/${id}/1`,
+      nodeId: id,
+      kind: node.kind,
+      attempt: 1,
+      ...action === void 0 ? {} : { action }
+    })).pipe(
+      Effect.andThen(
+        compute(node).pipe(
+          Effect.provideService(
+            import_StepIdentity.DispatchReport,
+            import_StepIdentity.DispatchReport.of({
+              dispatched: (dispatch) => Effect.sync(() => {
+                if (dispatch.outcome === "executed") dispatches.executed = dispatches.executed + 1;
+                else dispatches.replayed = dispatches.replayed + 1;
+                if (dispatch.stepKeyDigest !== void 0 && dispatches.digests.size < maximumDispatchDigests) {
+                  dispatches.digests.add(dispatch.stepKeyDigest);
+                }
+                if (dispatch.attempt !== void 0 && dispatch.attempt > dispatches.attempts) {
+                  dispatches.attempts = dispatch.attempt;
+                }
+              })
+            })
+          )
+        )
+      ),
+      Effect.tap(
+        (value2) => Effect.sync(() => {
+          settled.set(id, value2);
+          reported.add(id);
+        }).pipe(
+          Effect.andThen(record(
+            settleRecord(dispatches.executed === 0 && dispatches.replayed > 0 ? "clean" : "built", { value: value2 })
+          ))
+        )
+      ),
+      Effect.tapError(
+        (error) => Effect.sync(() => {
+          failed.set(id, error);
+          reported.add(id);
+        }).pipe(Effect.andThen(record(settleRecord("failed", { value: error }))))
+      ),
+      Effect.onExit((exit) => {
+        if (Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)) inFlight.delete(id);
+        executions.delete(id);
+        return Deferred.done(deferred, exit);
+      })
+    );
+    return Effect.forkIn(
+      Effect.withFiber((fiber) => {
+        executions.set(id, fiber);
+        return execution;
+      }),
+      nodes,
+      { startImmediately: true }
+    ).pipe(Effect.andThen(Deferred.await(deferred)));
+  });
+  const readers = /* @__PURE__ */ new Map();
+  for (const node of graphNodes) {
+    for (const dependency of KeyMaterial.dependencies(node.draft.material)) {
+      readers.set(dependency, [...readers.get(dependency) ?? [], node.id]);
+    }
+  }
+  const losingWork = (joinId, roots) => {
+    const subtree = /* @__PURE__ */ new Set();
+    const pending = [...roots];
+    while (pending.length > 0) {
+      const id = pending.pop();
+      subtree.add(id);
+      pending.push(...sources.get(id) ?? []);
+    }
+    const kept = /* @__PURE__ */ new Set();
+    const shared = [...subtree].filter(
+      (id) => readers.get(id).some((reader) => reader !== joinId && !subtree.has(reader))
+    );
+    while (shared.length > 0) {
+      const id = shared.pop();
+      if (kept.has(id) || !subtree.has(id)) continue;
+      kept.add(id);
+      shared.push(...sources.get(id) ?? [], ...KeyMaterial.dependencies(byId.get(id).draft.material));
+    }
+    const fibers = [];
+    const childRuns = [];
+    for (const id of subtree) {
+      if (kept.has(id)) continue;
+      const fiber = executions.get(id);
+      if (fiber === void 0) continue;
+      fibers.push(fiber);
+      const executionId = childExecutions.get(id);
+      if (executionId !== void 0) childRuns.push({ node: id, executionId });
+    }
+    return { fibers, childRuns };
+  };
+  const cancelChildren = (childRuns) => Effect.forEach(
+    childRuns,
+    ({ executionId, node }) => Effect.orDie(runtime.interrupt(childDeclarations.get(node), executionId)),
+    { discard: true }
+  );
+  const join = (node, ast, children) => Effect.gen(function* () {
+    const members = Object.keys(ast.nodes);
+    const journal = DurableDeferred.make(`join/${node.id}`, { success: JoinDecision });
+    const instance = yield* import_FlowInstance.FlowInstance;
+    const waiting = instance.waiting;
+    const recorded = yield* runtime.deferredResult(journal);
+    instance.waiting = waiting;
+    if (Option.isSome(recorded) && Exit.isSuccess(recorded.value)) {
+      const record2 = recorded.value.value;
+      const decided = "members" in record2 ? record2.members : record2;
+      const opened = "members" in record2 ? record2.children : [];
+      const indices = decided.map((member) => members.indexOf(member));
+      if (indices.some((index) => index < 0) || new Set(indices).size !== indices.length) {
+        return yield* refuse(
+          "join_mismatch",
+          node.id,
+          `Join at "${node.id}" journaled members ${JSON.stringify(decided)}, which it no longer holds.`
+        );
+      }
+      const lost = opened.find((child) => !childDeclarations.has(child.node));
+      if (lost !== void 0) {
+        return yield* refuse(
+          "join_mismatch",
+          node.id,
+          `Join at "${node.id}" journaled a losing child at "${lost.node}", which the plan no longer holds.`
+        );
+      }
+      yield* cancelChildren(opened);
+      const exits = yield* Effect.forEach(indices, (index) => Effect.exit(settleNode(children[index])), {
+        concurrency: "unbounded"
+      });
+      const outcomes2 = [];
+      for (let position = 0; position < exits.length; position++) {
+        const exit = exits[position];
+        if (classify(exit) !== "decisive") return yield* exit;
+        outcomes2.push({ member: members[indices[position]], exit });
+        const verdict2 = decide(ast, members.length, outcomes2);
+        if (verdict2 !== void 0 && position === exits.length - 1) return yield* verdict2;
+        if (verdict2 !== void 0) break;
+      }
+      return yield* refuse(
+        "join_mismatch",
+        node.id,
+        `Join at "${node.id}" replayed members ${JSON.stringify(decided)} without reaching its verdict.`
+      );
+    }
+    const outcomes = [];
+    let verdict;
+    let journaled = false;
+    const over = Deferred.makeUnsafe();
+    const watch = (index) => Effect.exit(settleNode(children[index])).pipe(
+      Effect.flatMap(
+        (exit) => Effect.sync(() => {
+          if (verdict !== void 0) return;
+          const kind = classify(exit);
+          if (kind === "pending") return;
+          if (kind === "fatal") {
+            verdict = exit;
+          } else {
+            outcomes.push({ member: members[index], exit });
+            verdict = decide(ast, members.length, outcomes);
+            journaled = verdict !== void 0;
+          }
+          if (verdict !== void 0) Deferred.doneUnsafe(over, Exit.void);
+        })
+      )
+    );
+    yield* Effect.raceFirst(
+      Effect.forEach(children, (_, index) => watch(index), { concurrency: "unbounded", discard: true }),
+      Deferred.await(over)
+    );
+    if (verdict === void 0) return yield* Effect.interrupt;
+    const decidedMembers = outcomes.map((outcome) => outcome.member);
+    yield* Effect.uninterruptible(
+      Effect.gen(function* () {
+        const { childRuns, fibers } = losingWork(
+          node.id,
+          children.filter((_, index) => !decidedMembers.includes(members[index]))
+        );
+        if (journaled) {
+          yield* runtime.deferredDone(journal, {
+            flowName: instance.flow._tag,
+            executionId: instance.executionId,
+            deferredName: journal.name,
+            exit: Exit.succeed({ members: decidedMembers, children: childRuns })
+          });
+        }
+        yield* Effect.withFiber(
+          (current) => Effect.sync(() => {
+            for (const fiber of fibers) fiber.interruptUnsafe(current.id);
+          })
+        );
+        yield* cancelChildren(childRuns);
+      })
+    );
+    return yield* verdict;
+  });
+  const compute = Effect.fnUntraced(
+    function* (node) {
+      const children = sources.get(node.id) ?? [];
+      const ast = node.ast;
+      if (ast._tag === "AndThen" && ast.next !== void 0) {
+        yield* settleNode(children[0]);
+        return yield* settleNode(children[1]);
+      }
+      if (ast._tag === "Branch") {
+        const decide2 = Node.predicate(ast);
+        const subject = yield* settleNode(children[0]);
+        return yield* settleNode(decide2(subject) ? children[1] : children[2]);
+      }
+      if (ast._tag === "Catch") {
+        const protectedId = children[0];
+        return yield* Effect.matchEffect(settleNode(protectedId), {
+          onFailure: (error) => {
+            if (Schema.is(InterpreterError)(error)) return Effect.fail(error);
+            const filter = Node.catchFilter(ast);
+            if (filter !== void 0 && !Schema.is(filter)(error)) {
+              return Effect.fail(error);
+            }
+            failed.set(protectedId, error);
+            return settleNode(children[1]);
+          },
+          onSuccess: Effect.succeed
+        });
+      }
+      if (ast._tag === "Race") {
+        const members = new Set(children);
+        yield* Effect.forEach(
+          KeyMaterial.dependencies(node.draft.material).filter(
+            (dependency) => !members.has(dependency) && !failed.has(dependency)
+          ),
+          settleNode,
+          { concurrency: "unbounded", discard: true }
+        );
+        return yield* join(node, ast, children);
+      }
+      yield* Effect.forEach(
+        KeyMaterial.dependencies(node.draft.material).filter((dependency) => !failed.has(dependency)),
+        settleNode,
+        { concurrency: "unbounded", discard: true }
+      );
+      switch (ast._tag) {
+        case "ActionCall":
+          return yield* implementations.get(ast.action).action(resolve(node.payload)).pipe(
+            Effect.provideService(import_StepIdentity.DispatchSite, node.id),
+            (0, import_CapabilityCeiling.attenuateCapabilities)(node.capabilityCeilings)
+          );
+        case "Succeed":
+          return resolve(node.payload);
+        case "Fail":
+          return yield* Effect.fail(resolve(node.payload));
+        case "Map": {
+          const transform = Node.mapper(ast);
+          return transform(yield* settleNode(children[0]));
+        }
+        case "All": {
+          const members = Object.keys(ast.nodes);
+          const values = yield* Effect.forEach(members, (_, index) => settleNode(children[index]), {
+            concurrency: "unbounded"
+          });
+          const joined = /* @__PURE__ */ Object.create(null);
+          for (let index = 0; index < members.length; index++) {
+            Object.defineProperty(joined, members[index], {
+              configurable: true,
+              enumerable: true,
+              value: values[index],
+              writable: true
+            });
+          }
+          return joined;
+        }
+        case "AndThen":
+          return yield* settleNode(children[1]);
+        case "FlowCall": {
+          if (ast.mode === "handoff") {
+            const declaration = handoffDeclarations.get(node.id);
+            const payload2 = yield* Effect.flatMap(
+              Effect.orDie(declaration.payloadSchema.makeEffect(resolve(node.payload))),
+              (decoded) => Effect.orDie(
+                Schema.encodeEffect(Schema.toCodecJson(declaration.payloadSchema))(decoded)
+              )
+            );
+            const ceiling = (yield* (0, import_CapabilityCeiling.attenuateCapabilities)(node.capabilityCeilings)(CapabilitySet.current)).groups;
+            const outcome = {
+              _tag: "To",
+              flow: ast.flow,
+              payload: payload2,
+              ...ceiling.length === 0 ? {} : { capabilityCeilings: ceiling }
+            };
+            Object.defineProperty(outcome, import_OutcomeMarker.OutcomeValueTypeId, {
+              configurable: false,
+              enumerable: false,
+              value: "To",
+              writable: false
+            });
+            return outcome;
+          }
+          if (ast.mode === "boundary") {
+            const declaration = childDeclarations.get(node.id);
+            const instance = yield* import_FlowInstance.FlowInstance;
+            const childPayload = resolve(node.payload);
+            const executionId = yield* childExecutionId(
+              instance.executionId,
+              node.id,
+              declaration._tag,
+              childPayload
+            );
+            childExecutions.set(node.id, executionId);
+            return yield* declaration.execute(childPayload, {
+              executionId
+            }).pipe((0, import_CapabilityCeiling.attenuateCapabilities)(node.capabilityCeilings));
+          }
+          const spliced = children[0];
+          if (spliced === void 0) {
+            return yield* refuse(
+              "unsupported_call",
+              node.id,
+              `Flow "${ast.flow}" is called at "${node.id}" as a leaf, which this interpreter does not drive. An inline .call() is spliced into the graph with the callee's body and driven with it, and only a call that lost its declaration has no body to splice. Build and interpret the authored node in the same process, or call it as ${ast.flow}.child(payload) to run it as its own execution.`
+            );
+          }
+          return yield* settleNode(spliced);
+        }
+      }
+    }
+  );
+  const recordSkipped = (exit) => Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause) ? Effect.void : Effect.forEach(
+    graphNodes.filter((node) => !reported.has(node.id)),
+    (node) => {
+      const action = actionTag(node.ast);
+      return record(() => ({
+        _tag: "NodeSettled",
+        sourceId: `node/${node.id}/1/settled`,
+        nodeId: node.id,
+        outcome: "skipped",
+        attempts: 0,
+        // A node the walk never reached dispatched nothing, so it claims
+        // no step key and there is no value it settled with.
+        stepKeyDigests: [],
+        ...action === void 0 ? {} : { action }
+      }));
+    },
+    { discard: true }
+  );
+  const value = yield* settleNode(options.root ?? "root").pipe(
+    Effect.onExit((exit) => Scope.close(nodes, exit)),
+    Effect.onExit(recordSkipped)
+  );
+  return {
+    value,
+    settled,
+    failed,
+    skipped: Graph.nodes(graph).filter((node) => !settled.has(node.id) && !failed.has(node.id)).map((node) => node.id)
+  };
+});
+const JoinChild = Schema.Struct({ node: Schema.String, executionId: Schema.String });
+const JoinDecision = Schema.Union([
+  Schema.Struct({ members: Schema.Array(Schema.String), children: Schema.Array(JoinChild) }),
+  Schema.Array(Schema.String)
+]);
+const classify = (exit) => {
+  if (Exit.isSuccess(exit)) return "decisive";
+  if (Cause.hasInterruptsOnly(exit.cause)) return "pending";
+  const reasons = exit.cause.reasons;
+  const typed = reasons.every((reason) => reason._tag !== "Die") && reasons.some((reason) => reason._tag === "Fail") && !reasons.some((reason) => reason._tag === "Fail" && Schema.is(InterpreterError)(reason.error));
+  return typed ? "decisive" : "fatal";
+};
+const decide = (ast, width, outcomes) => {
+  if (ast.mode === "race") return outcomes[0]?.exit;
+  const successes = outcomes.filter((outcome) => Exit.isSuccess(outcome.exit));
+  if (successes.length >= ast.count) {
+    if (ast.mode === "any") return successes[0].exit;
+    const joined = /* @__PURE__ */ Object.create(null);
+    for (const success of successes) {
+      Object.defineProperty(joined, success.member, {
+        configurable: true,
+        enumerable: true,
+        value: success.exit.value,
+        writable: true
+      });
+    }
+    return Exit.succeed(joined);
+  }
+  if (outcomes.length - successes.length > width - ast.count) return outcomes[outcomes.length - 1].exit;
+  return void 0;
+};
+const settleOutcome = (value) => {
+  if (!Outcome.isOutcome(value)) return Effect.succeed(value);
+  switch (value._tag) {
+    case "Done":
+      return Effect.succeed(value.value);
+    case "To":
+      return Effect.gen(function* () {
+        const instance = yield* import_FlowInstance.FlowInstance;
+        const current = yield* CapabilitySet.current;
+        instance.handoff = new import_Result.Handoff({
+          flow: value.flow,
+          payload: value.payload,
+          capabilityCeilings: [...current.groups, ...value.capabilityCeilings ?? []]
+        });
+      });
+    case "Park":
+      return Effect.andThen(
+        (0, import_WaitingAnnotation.annotateWaiting)(value.reason),
+        Effect.flatMap(import_FlowInstance.FlowInstance, import_Runtime.suspend)
+      );
+  }
+};
+const layer = (flow, options = {}) => makeLayer(flow, options, false);
+const makeLayer = (flow, options, requireReusableVersions, reachable, ifAbsent = false) => Layer.effectDiscard(Effect.gen(function* () {
+  const runtime = yield* import_FlowRuntime.FlowRuntime;
+  const registered = reachable ?? /* @__PURE__ */ new Set();
+  if (registered.has(flow)) return;
+  if (!ifAbsent) registered.add(flow);
+  const scope = yield* Effect.scope;
+  const context = yield* Effect.context();
+  const implementations = Context.get(context, import_Implementations.Implementations);
+  const registerReachable = (declaration) => Layer.buildWithScope(
+    makeLayer(
+      declaration,
+      options,
+      requireReusableVersions,
+      registered,
+      true
+    ),
+    scope
+  ).pipe(
+    Effect.provide(context),
+    Effect.asVoid
+  );
+  const middleware = Context.get(flow.annotations, import_ExecutionMiddleware.ExecutionMiddleware);
+  yield* runtime.register(
+    flow,
+    ((payload) => {
+      const body = Effect.flatMap(
+        interpretWithPolicy(flow, payload, options, requireReusableVersions, registerReachable),
+        (interpretation) => settleOutcome(interpretation.value)
+      );
+      return (middleware === void 0 ? body : middleware.wrap(payload, body)).pipe(
+        Effect.provideService(import_Implementations.Implementations, implementations)
+      );
+    }),
+    { ifAbsent }
+  );
+}));
+const layerWithImplementations = (flow, implementations, options = {}) => Layer.merge(
+  implementations,
+  makeLayer(flow, { ...options, callbackIdentity: options.callbackIdentity ?? "stable" }, true)
+).pipe(
+  Layer.provide(Layer.fresh(import_Implementations.layerImplementations))
+);
+//# sourceMappingURL=Interpreter.js.map