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

package/dist/cjs/Interpreter.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Interpreter.ts"],
+  "sourcesContent": ["/**\n * The body interpreter: what a flow does when it runs.\n *\n * A `Flow` has no handler to register \u2014 its `body` IS the behavior, per\n * `docs/concepts/flows-and-actions.md` \u2014 so something has to turn\n * the graph that body describes into execution. That is this\n * module. {@link layer} registers a flow with the runtime, and the\n * handler it installs builds the graph with {@link module:Graph.build} and\n * walks it: each node settles once, in dependency order, and the root's value\n * is the flow's result.\n *\n * What each variant does is the run-time half of what the AST recorded. An\n * `ActionCall` runs its declaration's implementation \u2014 looked up by tag in\n * {@link module:Implementations.Implementations} before the walk starts \u2014 as\n * the ordinary durable action `toLayer` built, so a node driven here takes\n * the same attempt journal, retry policy, and tier as the same action called\n * from a handler. Its invocation identity additionally folds this node's\n * structural address, keeping concurrent graph sites replay-stable. A `Map`\n * applies its deferred function to the real upstream value. A `Branch`\n * evaluates its digested predicate on the real\n * subject and settles ONLY the arm it took: the other arm is topology the plan\n * shows and the run skipped, and it is reported as such rather than silently\n * absent. An `All` joins its members by name, a `Succeed` yields its value, and\n * an inline `FlowCall` was already flattened by graph building, so it settles\n * with the body spliced beneath it. A `FlowCall` the author wrote as\n * `.child(payload)` is the one node that is NOT flattened: it opens a real child\n * execution under a deterministically derived id\n * ({@link childExecutionId}), which is what gives it its own journal lineage and\n * makes the parent's interruption and the child's suspension travel between\n * them.\n *\n * Planned references are resolved the way the plan names them: a payload\n * placeholder carries the `Ref` `{from, path}` its key material recorded, so\n * `result.files` reads `files` off the settled value of the node that produced\n * it.\n *\n * The walk is demand-driven from the root rather than a sweep over the node\n * list, because dependency order puts BOTH branch arms before the branch that\n * chooses between them, and executing an arm to discover it was not taken is\n * exactly what static topology exists to avoid.\n *\n * @since 0.1.0\n */\n\nimport { isRecord } from \"@smthrs/canonical/Record\"\nimport * as CapabilitySet from \"@smthrs/capability/CapabilitySet\"\nimport { DerivedKey, digest } from \"@smthrs/keys\"\nimport { isFatalDiagnostic } from \"@smthrs/plan/GraphBuildError\"\nimport * as KeyMaterial from \"@smthrs/plan/KeyMaterial\"\nimport * as Node from \"@smthrs/plan/Node\"\nimport * as Planned from \"@smthrs/plan/Planned\"\nimport * as StepKey from \"@smthrs/plan/StepKey\"\nimport * as Cause from \"effect/Cause\"\nimport * as Context from \"effect/Context\"\nimport type * as Crypto from \"effect/Crypto\"\nimport * as Deferred from \"effect/Deferred\"\nimport * as Effect from \"effect/Effect\"\nimport * as Exit from \"effect/Exit\"\nimport type * as Fiber from \"effect/Fiber\"\nimport * as Layer from \"effect/Layer\"\nimport * as Option from \"effect/Option\"\nimport * as Predicate from \"effect/Predicate\"\nimport * as Schema from \"effect/Schema\"\nimport * as Scope from \"effect/Scope\"\nimport { type Implementation, Implementations, layerImplementations } from \"./Action/Implementations.ts\"\nimport { DispatchReport, DispatchSite } from \"./Action/StepIdentity.ts\"\nimport * as DurableDeferred from \"./DurableDeferred.ts\"\nimport { attenuateCapabilities } from \"./Flow/CapabilityCeiling.ts\"\nimport type { Any as AnyFlow, AnyStructSchema, AnyWithProps, Flow } from \"./Flow/Flow.ts\"\nimport * as Outcome from \"./Flow/Outcome.ts\"\nimport { Handoff } from \"./Flow/Result.ts\"\nimport { suspend } from \"./Flow/Runtime.ts\"\nimport { TypeId as FlowTypeId } from \"./Flow/TypeId.ts\"\nimport { FlowInstance } from \"./FlowRuntime/FlowInstance.ts\"\nimport { FlowRuntime } from \"./FlowRuntime/FlowRuntime.ts\"\nimport type * as NodeRecord from \"./FlowRuntime/NodeRecord.ts\"\nimport { annotateWaiting } from \"./FlowRuntime/WaitingAnnotation.ts\"\nimport * as Graph from \"./Graph.ts\"\nimport * as BoundedJson from \"./internal/BoundedJson.ts\"\nimport { ExecutionMiddleware } from \"./internal/ExecutionMiddleware.ts\"\nimport { OutcomeValueTypeId } from \"./internal/OutcomeMarker.ts\"\n\n/**\n * A graph the interpreter will not drive.\n *\n * Every code names something the run cannot recover from on its own: a graph\n * whose topology is incomplete, an action with no implementation wired up, a\n * call the interpreter does not execute, and a deferred function that did not\n * survive serialization beside its AST. `missing_implementation_version`\n * names a content-reusable action that lacks the canonical version contract;\n * `implementation_version_mismatch` names a declaration and registry that\n * disagree. Both are preflight failures, before action dispatch.\n * `join_mismatch` names a race, any, or quorum whose journaled decision this\n * plan's members can no longer reproduce.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class InterpreterError extends Schema.TaggedError<InterpreterError>()(\n  \"@smthrs/flow/InterpreterError\",\n  {\n    code: Schema.Literals([\n      \"incomplete_graph\",\n      \"duplicate_node_id\",\n      \"unresolved_action\",\n      \"implementation_version_mismatch\",\n      \"missing_implementation_version\",\n      \"unresolved_reference\",\n      \"unsupported_call\",\n      \"missing_operation\",\n      \"node_record_too_large\",\n      \"join_mismatch\"\n    ]),\n    flow: Schema.String,\n    node: Schema.String,\n    message: Schema.String\n  }\n) {}\n\n/**\n * What one interpretation produced: the root's value, every node that settled\n * with the value it settled with, and the nodes the run never reached because\n * a branch went the other way.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Interpretation {\n  readonly value: unknown\n  readonly settled: ReadonlyMap<string, unknown>\n  /** Typed failures observed before a catch recovered them. */\n  readonly failed: ReadonlyMap<string, unknown>\n  readonly skipped: ReadonlyArray<string>\n}\n\n/**\n * The services a driven node needs: the runtime that executes an action, and\n * the execution it is part of.\n *\n * @private\n */\ntype Services = Crypto.Crypto | FlowRuntime | FlowInstance | Implementations\n\n/** Reads one own data property without invoking an accessor or letting a proxy trap escape. */\nconst ownDataProperty = (value: unknown, key: PropertyKey): unknown => {\n  if (Object(value) !== value) return undefined\n  try {\n    const descriptor = Object.getOwnPropertyDescriptor(value, key)\n    return descriptor !== undefined && \"value\" in descriptor ? descriptor.value : undefined\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * The execution id a `.child()` boundary runs its child under.\n *\n * DECIDED: the id is DERIVED from the parent\n * execution and the child node's structural address, not minted. That is what\n * makes a boundary at-most-once under replay, exactly as\n * `docs/concepts/trampoline-rounds.md` requires of a round handoff: a\n * parent that is re-driven re-derives the same id, so the engine lands on the\n * child execution that already exists instead of starting a second copy of it.\n * The canonical tuple includes the callee and a canonical payload digest, so\n * delimiter splicing and a changed invocation cannot alias an earlier child.\n * SHA-256 uses the same injected derivation services as the repository's\n * other durable identities. The versioned key prefix is dropped because the\n * child-id wire format is the bare digest. `digest` owns the\n * prefix knowledge, so this package never guesses at a stored-key format.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const childExecutionId = (\n  parentExecutionId: string,\n  nodeId: string,\n  calleeTag: string,\n  payload: unknown\n): Effect.Effect<string, never, Crypto.Crypto> =>\n  Effect.gen(function*() {\n    const payloadDigest = yield* Schema.decodeUnknownEffect(DerivedKey)(payload).pipe(Effect.orDie)\n    const tupleDigest = yield* Schema.decodeUnknownEffect(DerivedKey)([\n      parentExecutionId,\n      nodeId,\n      calleeTag,\n      payloadDigest\n    ]).pipe(Effect.orDie)\n    return digest(tupleDigest)\n  })\n\n/**\n * The largest encoded page of a recorded plan.\n *\n * A journal entry has a byte bound and a projection clips an oversized one, so\n * a graph is PAGED rather than truncated: whatever does not fit in the plan\n * record follows as appended subgraph pages. The budget is deliberately well\n * under the 16 KiB gateway limit on graph events. The runtime measures the\n * encoded journal envelope; absent that hook, the complete node record is\n * measured in UTF-8. A node too large for one page is a typed preflight refusal.\n *\n * @since 1.0.0\n * @category constants\n */\nexport const maximumPageBytes = 12_000\n\n/**\n * How many distinct step key digests one node's settlement names.\n *\n * A journal entry has a byte bound and a digest is 64 characters, so the list\n * is capped rather than left to grow with whatever a node dispatched. The\n * cap is far above what any node reaches today \u2014 an action node drives one\n * dispatch and keeps one step key however many times it is retried \u2014 and a\n * node past it names the dispatches it started with rather than none.\n *\n * @since 1.0.0\n * @category constants\n */\nexport const maximumDispatchDigests = 16\n\n/** The declared tag a node dispatches, if it dispatches one. @private */\nconst actionTag = (ast: Node.Ast): string | undefined =>\n  ast._tag === \"ActionCall\" ? ast.action : ast._tag === \"FlowCall\" ? ast.flow : undefined\n\n/** What one node of a driven graph tells a monitor about itself. @private */\nconst summarize = (node: Graph.GraphNode): NodeRecord.NodeSummary => {\n  const action = actionTag(node.ast)\n  return {\n    id: node.id,\n    kind: node.kind,\n    dependsOn: KeyMaterial.dependencies(node.draft.material),\n    tier: node.draft.material.kind,\n    effects: node.draft.effects,\n    ...(action === undefined ? {} : { action }),\n    ...(node.declaredAt === undefined ? {} : { declaredAt: node.declaredAt })\n  }\n}\n\n/**\n * The graph, as the pages a journal can hold.\n *\n * Nothing about one node has to fit one page. A node's summary is seated on a\n * page with no dependencies on it, and then its dependency list and the edges\n * that END on it are spread over as many following pages as they need: a\n * continuation page re-seats the same summary and carries the next disjoint\n * slice of `dependsOn`, so a reader that unions `dependsOn` per node id and\n * concatenates edges reassembles exactly the graph that was built. That is\n * what lets an input-driven fan-in \u2014 `Node.all` over a caller-sized list \u2014 be\n * recorded at any width instead of refused.\n *\n * A node's summary is seated no later than the first page naming one of its\n * dependencies or one of its incoming edges, so an assembled PREFIX of pages\n * never names an edge whose destination is unknown.\n *\n * The typed refusal is left for the one thing paging cannot divide: a node\n * whose summary with NO dependencies on it still exceeds the budget.\n *\n * @private\n */\nconst planPages = (\n  flow: string,\n  graph: Graph.Graph,\n  measure: (record: NodeRecord.NodeRecord) => Effect.Effect<number, never, FlowInstance>\n): Effect.Effect<\n  ReadonlyArray<NodeRecord.PlanRecorded | NodeRecord.SubgraphAppended>,\n  InterpreterError,\n  FlowInstance\n> =>\n  Effect.gen(function*() {\n    const incoming = new Map<string, Array<NodeRecord.EdgeSummary>>()\n    let edgeCount = 0\n    for (const edge of Graph.edges(graph)) {\n      edgeCount += 1\n      const summary = { from: edge.from, to: edge.to, reason: edge.reason }\n      const existing = incoming.get(edge.to)\n      if (existing === undefined) incoming.set(edge.to, [summary])\n      else existing.push(summary)\n    }\n    type Page = { nodes: Array<NodeRecord.NodeSummary>; edges: Array<NodeRecord.EdgeSummary> }\n    const graphNodes = Graph.nodes(graph)\n    const pages: Array<Page> = []\n    let current: Page = { nodes: [], edges: [] }\n    const record = (\n      page: Page,\n      index: number,\n      count: number\n    ): NodeRecord.PlanRecorded | NodeRecord.SubgraphAppended => ({\n      ...(index === 0\n        ? { _tag: \"PlanRecorded\" as const, nodeCount: graphNodes.length }\n        : { _tag: \"SubgraphAppended\" as const }),\n      sourceId: `plan/0/${index}`,\n      flow,\n      generation: 0,\n      page: index,\n      pages: count,\n      ...page\n    })\n    // Every page is started by a node seat or by an edge, and a node is seated\n    // once plus at most once per dependency that starts a continuation page,\n    // so the page count is at most nodes + dependencies + edges. Reserving\n    // that many digits is what makes replacing the reservation with the final\n    // count shrink an encoded envelope or leave it alone, never grow it.\n    const reserved = graphNodes.reduce(\n      (total, node) => total + KeyMaterial.dependencies(node.draft.material).length,\n      graphNodes.length + edgeCount\n    )\n    const fits = (page: Page) =>\n      Effect.map(measure(record(page, pages.length, reserved)), (bytes) => bytes <= maximumPageBytes)\n    const flush = () => {\n      pages.push(current)\n      current = { nodes: [], edges: [] }\n    }\n    /**\n     * How many of the remaining items the page still holds.\n     *\n     * A page only grows as items are added to it, so the boundary is found by\n     * bisection: a thousand-way fan-in costs a logarithmic number of\n     * measurements per page rather than one per item. Taking none is the page\n     * as it stands, which was measured before anything was offered to it.\n     */\n    const admits = <T>(rest: ReadonlyArray<T>, grow: (take: number) => Page) =>\n      Effect.gen(function*() {\n        if (yield* fits(grow(rest.length))) return rest.length\n        let low = 0\n        let high = rest.length - 1\n        while (low < high) {\n          const mid = low + Math.ceil((high - low) / 2)\n          if (yield* fits(grow(mid))) low = mid\n          else high = mid - 1\n        }\n        return low\n      })\n    /**\n     * Puts every item somewhere, starting a page whenever the current one is\n     * full. `resume` prepares a freshly started page so what follows still\n     * says which node it belongs to, and a page that was just started and\n     * admits nothing is the end of what paging can do.\n     */\n    const spread = <T>(\n      items: ReadonlyArray<T>,\n      onto: (page: Page, taken: ReadonlyArray<T>) => Page,\n      resume: (page: Page) => Page,\n      refusal: () => InterpreterError\n    ): Effect.Effect<void, InterpreterError, FlowInstance> =>\n      Effect.gen(function*() {\n        let rest = items\n        let started = false\n        while (rest.length > 0) {\n          const take = yield* admits(rest, (count) => onto(current, rest.slice(0, count)))\n          if (take > 0) {\n            current = onto(current, rest.slice(0, take))\n            rest = rest.slice(take)\n            started = false\n            continue\n          }\n          if (started) return yield* refusal()\n          flush()\n          current = resume(current)\n          started = true\n        }\n      })\n    for (const node of graphNodes) {\n      const summary = summarize(node)\n      const arriving = incoming.get(node.id) ?? []\n      // The summary alone first. What a page must hold whole is the node\n      // itself, and that is the only thing left to refuse.\n      const bare: NodeRecord.NodeSummary = { ...summary, dependsOn: [] }\n      const seat = (page: Page): Page => ({ nodes: [...page.nodes, bare], edges: page.edges })\n      const tooLarge = () =>\n        new InterpreterError({\n          code: \"node_record_too_large\",\n          flow,\n          node: node.id,\n          message:\n            `Node \"${node.id}\" and its encoded envelope exceed ${maximumPageBytes} bytes with no dependencies on it`\n        })\n      if (!(yield* fits(seat(current)))) {\n        if (current.nodes.length > 0 || current.edges.length > 0) flush()\n        if (!(yield* fits(seat(current)))) return yield* tooLarge()\n      }\n      current = seat(current)\n      // Then its dependencies, onto the summary the page just seated, and then\n      // the edges that end on it. Either may run past this page onto the next.\n      yield* spread(\n        summary.dependsOn,\n        (page, taken) => {\n          const seated = page.nodes[page.nodes.length - 1]!\n          return {\n            nodes: [...page.nodes.slice(0, -1), { ...seated, dependsOn: [...seated.dependsOn, ...taken] }],\n            edges: page.edges\n          }\n        },\n        seat,\n        tooLarge\n      )\n      yield* spread(\n        arriving,\n        (page, taken) => ({ nodes: page.nodes, edges: [...page.edges, ...taken] }),\n        (page) => page,\n        tooLarge\n      )\n    }\n    pages.push(current)\n    return pages.map((page, index) => record(page, index, pages.length))\n  })\n\n/**\n * Interprets a flow body, or a bare node, against real values.\n *\n * The graph is built first and in full \u2014 planning is a pure function of the\n * declarations and the payload, so the whole shape of the round is known before\n * the first action runs \u2014 and then driven. The low-level default permits\n * process-local callbacks; pass `callbackIdentity: \"stable\"` for reproducible\n * callback identity. {@link layerWithImplementations} selects that policy by\n * default.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const interpret = (\n  flowOrNode: Parameters<typeof Graph.build>[0],\n  payload?: unknown,\n  options: Graph.BuildOptions = {}\n): Effect.Effect<Interpretation, unknown, Services> => interpretWithPolicy(flowOrNode, payload, options, false)\n\n/** The canonical composition requires versions before permitting content-key reuse. @private */\nconst interpretWithPolicy = (\n  flowOrNode: Parameters<typeof Graph.build>[0],\n  payload: unknown,\n  options: Graph.BuildOptions,\n  requireReusableVersions: boolean,\n  registerReachable?: (flow: AnyWithProps) => Effect.Effect<void>\n): Effect.Effect<Interpretation, unknown, Services> =>\n  Effect.gen(function*() {\n    const table = yield* Implementations\n    const name = \"_tag\" in flowOrNode ? flowOrNode._tag : \"node\"\n    const refuse = (\n      code: InterpreterError[\"code\"],\n      node: string,\n      message: string\n    ): Effect.Effect<never, InterpreterError> => Effect.fail(new InterpreterError({ code, flow: name, node, message }))\n\n    const graph = yield* Effect.try({\n      try: () => Graph.build(flowOrNode, payload, options),\n      catch: (cause) => {\n        // Graph.build normalizes its own refusals to GraphBuildError, but the\n        // flow body runs inside this boundary and a body throws whatever it\n        // throws. Reading `node` and `message` off the value without checking\n        // built an InterpreterError its own schema rejects, and the\n        // constructor's \"Schema validation failed\" then replaced the reason\n        // the author needed. All three fields are read through own data\n        // descriptors and narrowed here so a plain Error from a body arrives\n        // as a typed failure that still says why. A body that threw produced no\n        // topology, so it reports `incomplete_graph`.\n        const refusalNode = ownDataProperty(cause, \"node\")\n        const refusalCode = ownDataProperty(cause, \"code\")\n        const refusalMessage = ownDataProperty(cause, \"message\")\n        const node = typeof refusalNode === \"string\" ? refusalNode : \"\"\n        const reported = typeof refusalMessage === \"string\" ? refusalMessage : \"\"\n        return new InterpreterError({\n          code: refusalCode === \"duplicate_node\" ? \"duplicate_node_id\" : \"incomplete_graph\",\n          flow: name,\n          node,\n          message: reported === \"\"\n            ? `building the graph of flow ${name} threw ${\n              typeof cause === \"string\" ? cause : BoundedJson.render(cause, 512)\n            }`\n            : reported\n        })\n      }\n    })\n\n    const graphNodes = Graph.nodes(graph)\n    const byId = new Map(graphNodes.map((node) => [node.id, node]))\n\n    // Advisory diagnostics describe a graph that is exactly what will run, so\n    // they are reported by `Graph.diagnostics` and do not stop a run. A fatal\n    // one means the topology is not what the author wrote.\n    const fatal = graph.diagnostics.find(isFatalDiagnostic)\n    if (fatal !== undefined) {\n      return yield* refuse(\n        \"incomplete_graph\",\n        fatal.node,\n        `Graph of \"${name}\" is missing topology and cannot be driven: ${fatal.message}`\n      )\n    }\n\n    /**\n     * The node records this walk writes, if the runtime keeps any.\n     *\n     * A runtime without the seam costs a comparison per node and nothing else:\n     * the record is built by the thunk only when something will hold it.\n     */\n    const runtime = yield* FlowRuntime\n    const recordNode = runtime.recordNode\n    const record = recordNode === undefined\n      ? (_: () => NodeRecord.NodeRecord) => Effect.void as Effect.Effect<void, never, FlowInstance>\n      : (make: () => NodeRecord.NodeRecord) => recordNode(make())\n    // The whole graph, before the first node runs. Planning is pure, so this\n    // is the complete declared ceiling of the round rather than a prefix of\n    // what happened to run, and a monitor can draw the round it is watching\n    // from the first record it receives.\n    if (recordNode !== undefined) {\n      const measure = runtime.nodeRecordBytes ??\n        ((record: NodeRecord.NodeRecord) => Effect.succeed(new TextEncoder().encode(JSON.stringify(record)).byteLength))\n      // Validate every page before writing the first or dispatching any action.\n      const pages = yield* planPages(name, graph, measure)\n      yield* Effect.forEach(pages, (page) => recordNode(page), { discard: true })\n    }\n\n    // Everything the walk needs that the built graph can be asked for before it\n    // runs, is asked for here \u2014 so no such refusal can surface halfway through a\n    // body with the actions ahead of it already committed.\n    //\n    // A reference out of the graph is the first: a round may be PLANNED against\n    // a node an earlier generation settled \u2014 `Plan.append` exists for exactly\n    // that \u2014 but one interpretation settles one graph, so there is nothing to\n    // read it from. A missing implementation is the second, and it is a wiring\n    // error rather than a run-time contingency: every action the graph names\n    // is resolved up front, including the ones only an untaken branch arm would\n    // have reached, because the plan is the declared ceiling of what may run.\n    // Deferred operations must likewise survive beside every AST, even when\n    // the walk would skip their branch or catch arm.\n    const implementations = new Map<string, Implementation>()\n    const handoffDeclarations = new Map<string, AnyFlow>()\n    const childDeclarations = new Map<string, AnyWithProps>()\n    for (const node of graphNodes) {\n      const ast = node.ast\n      if (ast._tag === \"Map\" && Node.mapper(ast) === undefined) {\n        return yield* refuse(\"missing_operation\", node.id, `Map at \"${node.id}\" lost its mapper.`)\n      }\n      if (ast._tag === \"Branch\" && Node.predicate(ast) === undefined) {\n        return yield* refuse(\"missing_operation\", node.id, `Branch at \"${node.id}\" lost its predicate.`)\n      }\n      if (ast._tag === \"Catch\" && ast.filter !== undefined && Node.catchFilter(ast) === undefined) {\n        return yield* refuse(\"missing_operation\", node.id, `Catch at \"${node.id}\" lost its schema filter.`)\n      }\n      for (const dependency of KeyMaterial.dependencies(node.draft.material)) {\n        if (byId.has(dependency)) continue\n        return yield* refuse(\n          \"unresolved_reference\",\n          node.id,\n          `Node \"${node.id}\" reads \"${dependency}\", which this graph does not hold.`\n        )\n      }\n      if (node.ast._tag === \"FlowCall\" && node.ast.mode === \"handoff\") {\n        const declaration = Node.declaration(node.ast)\n        if (!Predicate.hasProperty(declaration, FlowTypeId)) {\n          return yield* refuse(\n            \"unsupported_call\",\n            node.id,\n            `Handoff to flow \"${node.ast.flow}\" at \"${node.id}\" lost its declaration. ` +\n              \"Build and interpret the authored node in the same process so its payload can be encoded.\"\n          )\n        }\n        handoffDeclarations.set(node.id, declaration as unknown as AnyFlow)\n        if (registerReachable !== undefined) yield* registerReachable(declaration as unknown as AnyWithProps)\n        continue\n      }\n      if (node.ast._tag === \"FlowCall\" && node.ast.mode === \"boundary\") {\n        // A boundary is one node here and a real execution underneath, so what\n        // it needs resolved up front is the callee itself: the declaration is\n        // what `execute` is called on, and losing it is a wiring error rather\n        // than a run-time contingency, exactly like an unimplemented action.\n        const declaration = Node.declaration(node.ast)\n        if (!Predicate.hasProperty(declaration, FlowTypeId)) {\n          return yield* refuse(\n            \"unsupported_call\",\n            node.id,\n            `Child boundary to flow \"${node.ast.flow}\" at \"${node.id}\" lost its declaration. ` +\n              \"Build and interpret the authored node in the same process so the child can be executed.\"\n          )\n        }\n        childDeclarations.set(node.id, declaration as unknown as AnyWithProps)\n        if (registerReachable !== undefined) yield* registerReachable(declaration as unknown as AnyWithProps)\n        continue\n      }\n      if (node.ast._tag !== \"ActionCall\") continue\n      const implementation = yield* table.get(node.ast.action)\n      if (Option.isNone(implementation)) {\n        return yield* refuse(\n          \"unresolved_action\",\n          node.id,\n          `Action \"${node.ast.action}\" has no implementation. ` +\n            `Provide ONE Action.layerImplementations under both ${node.ast.action}.toLayer(execute) and ` +\n            \"this interpreter layer: an implementation files itself with the table that is in scope \" +\n            \"while IT is built, so a table merged beside it, or a second one built above it, is not the \" +\n            \"table this driver reads.\"\n        )\n      }\n      const declaration = Node.declaration(node.ast)\n      const declaredVersion = ownDataProperty(declaration, \"implementationVersion\")\n      if (requireReusableVersions) {\n        const tier = ownDataProperty(declaration, \"tier\")\n        if (tier === undefined) {\n          return yield* refuse(\n            \"incomplete_graph\",\n            node.id,\n            `Action \"${node.ast.action}\" lost its declaration, so its implementation identity cannot be checked. ` +\n              \"Build the canonical composition from the authored action nodes.\"\n          )\n        }\n        if (\n          tier === \"sealed\" && ownDataProperty(declaration, \"idempotencyKey\") !== undefined &&\n          declaredVersion === undefined\n        ) {\n          return yield* refuse(\n            \"missing_implementation_version\",\n            node.id,\n            `Sealed action \"${node.ast.action}\" declares an idempotency key and can reuse recorded content. ` +\n              \"Declare implementationVersion on Action.make and attest the same version in toLayer.\"\n          )\n        }\n      }\n      if (declaredVersion !== implementation.value.implementationVersion) {\n        return yield* refuse(\n          \"implementation_version_mismatch\",\n          node.id,\n          `Action \"${node.ast.action}\" does not match its registered implementationVersion. ` +\n            \"Register the declared version and start a newly planned execution when its semantics change.\"\n        )\n      }\n      implementations.set(node.ast.action, implementation.value)\n    }\n\n    // Graph.build also accepts authored references. Unlike Plan.compile, this\n    // entry point has not yet checked them for cycles: a self-reference would\n    // join its own in-flight deferred forever. Validate the entire dependency\n    // graph before dispatch, including branch arms the execution might skip.\n    const remaining = new Map<string, number>()\n    const dependents = new Map<string, Array<string>>()\n    const ready: Array<string> = []\n    for (const node of graphNodes) {\n      const dependencies = KeyMaterial.dependencies(node.draft.material)\n      remaining.set(node.id, dependencies.length)\n      if (dependencies.length === 0) ready.push(node.id)\n      for (const dependency of dependencies) {\n        const consumers = dependents.get(dependency)\n        if (consumers === undefined) dependents.set(dependency, [node.id])\n        else consumers.push(node.id)\n      }\n    }\n    for (let index = 0; index < ready.length; index++) {\n      for (const consumer of dependents.get(ready[index]!) ?? []) {\n        const count = remaining.get(consumer)! - 1\n        remaining.set(consumer, count)\n        if (count === 0) ready.push(consumer)\n      }\n    }\n    if (ready.length !== graphNodes.length) {\n      const blocked = graphNodes.find((node) => remaining.get(node.id)! > 0)!\n      return yield* refuse(\n        \"incomplete_graph\",\n        blocked.id,\n        `Graph of \"${name}\" contains a dependency cycle blocking \"${blocked.id}\". ` +\n          \"Use an acyclic reference, a child boundary, or a trampoline handoff.\"\n      )\n    }\n    // The children a node settles with, in the order graph building recorded\n    // them: `first` then the arms of a branch, `first` then the continuation of\n    // a sequence, the members of a combination, the spliced body of an inline\n    // call. Payload references are NOT here \u2014 they are named by the key\n    // material, and settled from it.\n    const sources = new Map<string, Array<string>>()\n    for (const edge of Graph.edges(graph)) {\n      if (edge.reason !== \"value\") continue\n      sources.set(edge.to, [...sources.get(edge.to) ?? [], edge.from])\n    }\n\n    const settled = new Map<string, unknown>()\n    const failed = new Map<string, unknown>()\n\n    /**\n     * Projects a settled value along the property path a `Ref` recorded \u2014\n     * through `StepKey.project`, the one projection semantics for the value\n     * channel. The scheduler digests exactly what this returns; resolving a\n     * `Ref` any other way here would let two executions that key identically\n     * consume different values.\n     */\n    const project = StepKey.project\n\n    /**\n     * Replaces every placeholder in a hydrated payload with what it stands for.\n     *\n     * The record is rebuilt with a null prototype and `defineProperty`, for the\n     * reason {@link module:Graph.build}'s cloners are: `output[key] = \u2026` on an\n     * object literal routes `__proto__` through `Object.prototype`'s accessor,\n     * which drops an own `__proto__` field carrying a primitive and reparents\n     * the clone when it carries an object. A graph hydrates that field as data,\n     * so the value handed to an action has to keep it as data too.\n     */\n    const resolve = (value: unknown): unknown => {\n      const reference = Planned.reference(value)\n      if (reference !== undefined) {\n        return project(\n          settled.has(reference.node) ? settled.get(reference.node) : failed.get(reference.node),\n          reference.path\n        )\n      }\n      if (Array.isArray(value)) return value.map((item) => resolve(item))\n      if (!isRecord(value)) return value\n      const output: Record<string, unknown> = Object.create(null) as Record<string, unknown>\n      for (const key of Object.keys(value)) {\n        Object.defineProperty(output, key, {\n          configurable: true,\n          enumerable: true,\n          value: resolve(value[key]),\n          writable: true\n        })\n      }\n      const outcome = Object.getOwnPropertyDescriptor(value, OutcomeValueTypeId)\n      if (outcome !== undefined && \"value\" in outcome) {\n        Object.defineProperty(output, OutcomeValueTypeId, {\n          configurable: false,\n          enumerable: false,\n          value: outcome.value,\n          writable: false\n        })\n      }\n      return output\n    }\n\n    /**\n     * The settlement currently in flight for a node, for as long as it is.\n     *\n     * `settled.has(id)` alone is not a memo once the walk runs concurrently: it\n     * answers \"has this node FINISHED\", and two demands that arrive while the\n     * node is still running both see `false` and both execute it. A diamond\n     * would then run its shared node twice, which for an action with effects is\n     * a correctness bug rather than a wasted cycle.\n     *\n     * The check-and-register below is the whole reason this is a `suspend` and\n     * not a generator: the callback runs synchronously, so no other fiber can\n     * observe the gap between the lookup and the insert.\n     *\n     * Every computation runs on a fiber forked into `nodes`, the\n     * interpretation's own scope, and every demand \u2014 the first included \u2014 is a\n     * join on the node's deferred. Ownership by the interpretation rather than\n     * by whichever demand arrived first is what makes a ref-diamond sound: a\n     * failing `All` interrupts its member JOINS, never a shared node's\n     * execution, so recovery arms above can still join the shared work; and\n     * when the walk itself ends, closing the scope interrupts whatever is\n     * still running, so an orphaned execution cannot outlive the\n     * interpretation or write a phantom success into `settled` afterwards\n     * (Skyframe's and `MemoMap`'s ownership model).\n     */\n    const inFlight = new Map<string, Deferred.Deferred<unknown, unknown>>()\n    const nodes = yield* Scope.make()\n    /**\n     * The execution fiber of every node still running, so a join that settled\n     * early can interrupt the work of the members it no longer waits for.\n     */\n    const executions = new Map<string, Fiber.Fiber<unknown, unknown>>()\n    /**\n     * The child execution id each `.child()` node opened. Interrupting the\n     * node's fiber only stops its join: a losing child is cancelled through\n     * the runtime, the same request a caller's cancellation makes.\n     */\n    const childExecutions = new Map<string, string>()\n\n    /**\n     * The nodes this walk has already settled a record for.\n     *\n     * Everything else is what the walk never reached, which is exactly the\n     * `skipped` set reported below \u2014 an untaken branch arm, or a dependent of\n     * something that failed.\n     */\n    const reported = new Set<string>()\n\n    const settleNode = (id: string): Effect.Effect<unknown, unknown, Services> =>\n      Effect.suspend(() => {\n        if (settled.has(id)) return Effect.succeed(settled.get(id))\n        const waiting = inFlight.get(id)\n        // A later demand joins the execution rather than starting one.\n        if (waiting !== undefined) return Deferred.await(waiting)\n        const deferred = Deferred.makeUnsafe<unknown, unknown>()\n        inFlight.set(id, deferred)\n        const node = byId.get(id)!\n        const action = actionTag(node.ast)\n        // What this node's dispatches did, reported by the engine underneath\n        // it: a node whose dispatches were ALL served from durable records\n        // rebuilt nothing, and says so. The digests name those dispatches, so\n        // the attempt rows the engine wrote under them belong to THIS node,\n        // and the highest attempt reported is the node's real attempt count.\n        // A `Set` keeps the digests unrepeated in report order: one dispatch\n        // retried three times keeps one step key and reports it three times.\n        const dispatches = { executed: 0, replayed: 0, attempts: 1, digests: new Set<string>() }\n        const settleRecord =\n          (outcome: NodeRecord.NodeOutcome, settlement: { readonly value: unknown }) => (): NodeRecord.NodeRecord => ({\n            _tag: \"NodeSettled\",\n            sourceId: `node/${id}/1/settled`,\n            nodeId: id,\n            outcome,\n            attempts: dispatches.attempts,\n            stepKeyDigests: [...dispatches.digests],\n            value: settlement.value,\n            ...(action === undefined ? {} : { action })\n          })\n        const execution = record(() => ({\n          _tag: \"NodeScheduled\",\n          sourceId: `node/${id}/1`,\n          nodeId: id,\n          kind: node.kind,\n          attempt: 1,\n          ...(action === undefined ? {} : { action })\n        })).pipe(\n          Effect.andThen(\n            compute(node).pipe(\n              Effect.provideService(\n                DispatchReport,\n                DispatchReport.of({\n                  dispatched: (dispatch) =>\n                    Effect.sync(() => {\n                      if (dispatch.outcome === \"executed\") dispatches.executed = dispatches.executed + 1\n                      else dispatches.replayed = dispatches.replayed + 1\n                      // Bounded where it is COLLECTED, not where it is\n                      // written: a cap applied at the end still holds every\n                      // digest in memory until then, and the point of the cap\n                      // is that one node cannot grow without bound.\n                      if (\n                        dispatch.stepKeyDigest !== undefined &&\n                        dispatches.digests.size < maximumDispatchDigests\n                      ) {\n                        dispatches.digests.add(dispatch.stepKeyDigest)\n                      }\n                      if (dispatch.attempt !== undefined && dispatch.attempt > dispatches.attempts) {\n                        dispatches.attempts = dispatch.attempt\n                      }\n                    })\n                })\n              )\n            )\n          ),\n          Effect.tap((value) =>\n            Effect.sync(() => {\n              settled.set(id, value)\n              reported.add(id)\n            }).pipe(\n              Effect.andThen(record(\n                settleRecord(dispatches.executed === 0 && dispatches.replayed > 0 ? \"clean\" : \"built\", { value })\n              ))\n            )\n          ),\n          Effect.tapError((error) =>\n            Effect.sync(() => {\n              failed.set(id, error)\n              reported.add(id)\n            }).pipe(Effect.andThen(record(settleRecord(\"failed\", { value: error }))))\n          ),\n          Effect.onExit((exit) => {\n            // An interrupted execution is evicted, not memoized: current\n            // joiners observe the interruption, but a LATER demand \u2014 a\n            // recovery arm, a re-driven walk \u2014 re-executes the node instead\n            // of replaying an interrupt that says nothing about it.\n            if (Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)) inFlight.delete(id)\n            executions.delete(id)\n            return Deferred.done(deferred, exit)\n          })\n        )\n        // `startImmediately` keeps the first demand's latency identical to the\n        // old inline execution: the node runs synchronously until its first\n        // real suspension, so a body that parks does so before the driver's\n        // next tick \u2014 the same observable cadence a sequential walk had.\n        return Effect.forkIn(\n          Effect.withFiber((fiber) => {\n            executions.set(id, fiber)\n            return execution\n          }),\n          nodes,\n          { startImmediately: true }\n        ).pipe(Effect.andThen(Deferred.await(deferred)))\n      })\n\n    /**\n     * The nodes that read each node's value through their key material: the\n     * payload references and barriers a structural subtree does not show.\n     */\n    const readers = new Map<string, Array<string>>()\n    for (const node of graphNodes) {\n      for (const dependency of KeyMaterial.dependencies(node.draft.material)) {\n        readers.set(dependency, [...readers.get(dependency) ?? [], node.id])\n      }\n    }\n\n    /**\n     * The work of the members a join no longer waits for: their running node\n     * fibers and the child executions those nodes opened.\n     *\n     * A member's structural subtree is its own, so its running executions are\n     * interrupted; nothing else demands them again. A node something outside that\n     * subtree also reads is shared work the interpretation owns \u2014 the same\n     * ownership an `All` failure respects \u2014 and keeps running, together with\n     * everything inside the subtree it depends on.\n     */\n    // Graph building gives every node exactly one structural parent and reads\n    // each child through that parent's key material, so the walk below never\n    // reaches a node twice and every node in a subtree has a reader.\n    const losingWork = (joinId: string, roots: ReadonlyArray<string>) => {\n      const subtree = new Set<string>()\n      const pending = [...roots]\n      while (pending.length > 0) {\n        const id = pending.pop()!\n        subtree.add(id)\n        pending.push(...sources.get(id) ?? [])\n      }\n      const kept = new Set<string>()\n      const shared = [...subtree].filter((id) =>\n        readers.get(id)!.some((reader) => reader !== joinId && !subtree.has(reader))\n      )\n      while (shared.length > 0) {\n        const id = shared.pop()!\n        if (kept.has(id) || !subtree.has(id)) continue\n        kept.add(id)\n        shared.push(...sources.get(id) ?? [], ...KeyMaterial.dependencies(byId.get(id)!.draft.material))\n      }\n      const fibers: Array<Fiber.Fiber<unknown, unknown>> = []\n      const childRuns: Array<JoinChild> = []\n      for (const id of subtree) {\n        if (kept.has(id)) continue\n        const fiber = executions.get(id)\n        if (fiber === undefined) continue\n        fibers.push(fiber)\n        const executionId = childExecutions.get(id)\n        if (executionId !== undefined) childRuns.push({ node: id, executionId })\n      }\n      return { fibers, childRuns }\n    }\n\n    /**\n     * Cancels the child executions a join's losers opened, through the\n     * runtime: interrupting a node's fiber only stops its join, so a losing\n     * child is cancelled with the same request a caller's cancellation makes.\n     */\n    const cancelChildren = (childRuns: ReadonlyArray<JoinChild>): Effect.Effect<void, never, Services> =>\n      Effect.forEach(\n        childRuns,\n        ({ executionId, node }) =>\n          Effect.orDie(runtime.interrupt(childDeclarations.get(node)! as AnyFlow, executionId)),\n        { discard: true }\n      )\n\n    /**\n     * Settles a `Race` node: `race`, `any`, or `quorum`.\n     *\n     * The members that decided are journaled, in the order they decided,\n     * under a durable deferred named for the node before any loser is\n     * interrupted. A resumed walk that finds the record settles exactly those\n     * members \u2014 whose own dispatches replay from their durable records \u2014 and\n     * never demands the others, so it reaches the same verdict without\n     * running a loser again. A defect or an interpreter refusal in a member is\n     * not a decision: it propagates unjournaled, as it would from an `All`.\n     *\n     * The same record names the child executions the losers had opened, so a\n     * process that dies between the journal write and their cancellation does\n     * not orphan them: the resumed walk never demands a loser, and it cancels\n     * those children from the record instead (#2892). Cancellation is a\n     * first-writer-wins request, so repeating it on every replay is harmless.\n     */\n    const join = (\n      node: Graph.GraphNode,\n      ast: Extract<Node.Ast, { readonly _tag: \"Race\" }>,\n      children: ReadonlyArray<string>\n    ): Effect.Effect<unknown, unknown, Services> =>\n      Effect.gen(function*() {\n        const members = Object.keys(ast.nodes)\n        const journal = DurableDeferred.make(`join/${node.id}`, { success: JoinDecision })\n        const instance = yield* FlowInstance\n        // A join is not a wait: reading its record must not consume the\n        // waiting classification a parked sibling declared.\n        const waiting = instance.waiting\n        const recorded = yield* runtime.deferredResult(journal)\n        instance.waiting = waiting\n        if (Option.isSome(recorded) && Exit.isSuccess(recorded.value)) {\n          const record = recorded.value.value\n          const decided = \"members\" in record ? record.members : record\n          const opened = \"members\" in record ? record.children : []\n          const indices = decided.map((member) => members.indexOf(member))\n          if (indices.some((index) => index < 0) || new Set(indices).size !== indices.length) {\n            return yield* refuse(\n              \"join_mismatch\",\n              node.id,\n              `Join at \"${node.id}\" journaled members ${JSON.stringify(decided)}, which it no longer holds.`\n            )\n          }\n          const lost = opened.find((child) => !childDeclarations.has(child.node))\n          if (lost !== undefined) {\n            return yield* refuse(\n              \"join_mismatch\",\n              node.id,\n              `Join at \"${node.id}\" journaled a losing child at \"${lost.node}\", which the plan no longer holds.`\n            )\n          }\n          yield* cancelChildren(opened)\n          // The losers are never demanded, so nothing of theirs starts again.\n          const exits = yield* Effect.forEach(indices, (index) => Effect.exit(settleNode(children[index]!)), {\n            concurrency: \"unbounded\"\n          })\n          // The verdict must close on the LAST journaled member, exactly as it\n          // did live: one that closes earlier, or never, is a different join.\n          const outcomes: Array<Decision> = []\n          for (let position = 0; position < exits.length; position++) {\n            const exit = exits[position]!\n            if (classify(exit) !== \"decisive\") return yield* exit\n            outcomes.push({ member: members[indices[position]!]!, exit })\n            const verdict = decide(ast, members.length, outcomes)\n            if (verdict !== undefined && position === exits.length - 1) return yield* verdict\n            if (verdict !== undefined) break\n          }\n          return yield* refuse(\n            \"join_mismatch\",\n            node.id,\n            `Join at \"${node.id}\" replayed members ${JSON.stringify(decided)} without reaching its verdict.`\n          )\n        }\n\n        const outcomes: Array<Decision> = []\n        let verdict: Exit.Exit<unknown, unknown> | undefined\n        let journaled = false\n        const over = Deferred.makeUnsafe<void>()\n        const watch = (index: number) =>\n          Effect.exit(settleNode(children[index]!)).pipe(\n            Effect.flatMap((exit) =>\n              Effect.sync(() => {\n                if (verdict !== undefined) return\n                const kind = classify(exit)\n                // An interrupted member is still undecided: it parked, or a\n                // join elsewhere cancelled shared work. The others may still\n                // decide without it.\n                if (kind === \"pending\") return\n                if (kind === \"fatal\") {\n                  verdict = exit\n                } else {\n                  outcomes.push({ member: members[index]!, exit })\n                  verdict = decide(ast, members.length, outcomes)\n                  journaled = verdict !== undefined\n                }\n                if (verdict !== undefined) Deferred.doneUnsafe(over, Exit.void)\n              })\n            )\n          )\n        yield* Effect.raceFirst(\n          Effect.forEach(children, (_, index) => watch(index), { concurrency: \"unbounded\", discard: true }),\n          Deferred.await(over)\n        )\n        // Every member ended interrupted: the join cannot decide in this\n        // round, and the walk parks or ends with it.\n        if (verdict === undefined) return yield* Effect.interrupt\n        const decidedMembers = outcomes.map((outcome) => outcome.member)\n        yield* Effect.uninterruptible(\n          Effect.gen(function*() {\n            const { childRuns, fibers } = losingWork(\n              node.id,\n              children.filter((_, index) => !decidedMembers.includes(members[index]!))\n            )\n            if (journaled) {\n              yield* runtime.deferredDone(journal, {\n                flowName: instance.flow._tag,\n                executionId: instance.executionId,\n                deferredName: journal.name,\n                exit: Exit.succeed({ members: decidedMembers, children: childRuns })\n              })\n            }\n            // The interruption is requested, not awaited: a loser's finalizers\n            // may wait on work that only settles after the join returns, and\n            // the node scope awaits every fiber when the walk ends anyway.\n            yield* Effect.withFiber((current) =>\n              Effect.sync(() => {\n                for (const fiber of fibers) fiber.interruptUnsafe(current.id)\n              })\n            )\n            yield* cancelChildren(childRuns)\n          })\n        )\n        return yield* verdict\n      })\n\n    const compute: (node: Graph.GraphNode) => Effect.Effect<unknown, unknown, Services> = Effect.fnUntraced(\n      function*(node: Graph.GraphNode) {\n        const children = sources.get(node.id) ?? []\n        const ast = node.ast\n        if (ast._tag === \"AndThen\" && ast.next !== undefined) {\n          // An explicit sequence is a success boundary for the WHOLE next\n          // subtree. Joining first and then concurrently lets a nested All,\n          // Map, or inline call start effects before its prerequisite settles.\n          // bindPlanned is distinct: it declares data dependencies and can\n          // expose independent work while the producer is still running.\n          yield* settleNode(children[0]!)\n          return yield* settleNode(children[1]!)\n        }\n        if (ast._tag === \"Branch\") {\n          // The predicate decides on the REAL value, and only the arm it chose\n          // is settled. Both arms are still in the plan; the untaken one is\n          // reported as skipped.\n          const decide = Node.predicate(ast)!\n          const subject = yield* settleNode(children[0]!)\n          return yield* settleNode(decide(subject) ? children[1]! : children[2]!)\n        }\n        if (ast._tag === \"Catch\") {\n          // DECIDED: catch observes only typed\n          // failures from ordinary protected execution. Interpreter refusals\n          // propagate unchanged. Effect defects and\n          // compensation failures remain outside this interpreter's error\n          // channel, so recovery cannot conceal a broken invariant or weaken\n          // withRollback's compensation guarantees.\n          const protectedId = children[0]!\n          return yield* Effect.matchEffect(settleNode(protectedId), {\n            onFailure: (error) => {\n              if (Schema.is(InterpreterError)(error)) return Effect.fail(error)\n              const filter = Node.catchFilter(ast)\n              if (filter !== undefined && !Schema.is(filter)(error)) {\n                return Effect.fail(error)\n              }\n              // The failure arm's planned subject resolves through the\n              // protected node id. Filing the typed failure as that settlement\n              // also prevents its static failure edge from re-running the\n              // protected graph while the recovery arm is driven.\n              failed.set(protectedId, error)\n              return settleNode(children[1]!)\n            },\n            onSuccess: Effect.succeed\n          })\n        }\n        if (ast._tag === \"Race\") {\n          // A join must not wait for every member, so its members are left\n          // out of the dependency barrier below; its other dependencies \u2014 the\n          // references and barriers it reads \u2014 still settle first.\n          const members = new Set(children)\n          yield* Effect.forEach(\n            KeyMaterial.dependencies(node.draft.material).filter((dependency) =>\n              !members.has(dependency) && !failed.has(dependency)\n            ),\n            settleNode,\n            { concurrency: \"unbounded\", discard: true }\n          )\n          return yield* join(node, ast, children)\n        }\n        // Dependency order, from the key material: the same `Ref` and `Pending`\n        // inputs the plan turns into edges, settled before the node that reads\n        // them \u2014 and settled CONCURRENTLY, because independent dependencies are\n        // exactly what the scheduler admits under separate permits. Two\n        // execution surfaces disagreeing about concurrency is a correctness\n        // hazard, not just a latency one.\n        yield* Effect.forEach(\n          KeyMaterial.dependencies(node.draft.material).filter((dependency) => !failed.has(dependency)),\n          settleNode,\n          { concurrency: \"unbounded\", discard: true }\n        )\n        switch (ast._tag) {\n          case \"ActionCall\":\n            // Resolved by the pre-pass above, which refuses the whole graph\n            // when an action it names has no implementation. The structural\n            // node address is durable dispatch identity, scoped to this one\n            // implementation call; it never comes from fiber arrival order.\n            return yield* implementations.get(ast.action)!.action(resolve(node.payload)).pipe(\n              Effect.provideService(DispatchSite, node.id),\n              attenuateCapabilities(node.capabilityCeilings)\n            )\n          case \"Succeed\":\n            return resolve(node.payload)\n          case \"Fail\":\n            // The typed error channel, from a constant the plan already holds.\n            // An enclosing catch observes it exactly as it observes an action's\n            // failure, and an uncaught one is the body's typed failure.\n            return yield* Effect.fail(resolve(node.payload))\n          case \"Map\": {\n            const transform = Node.mapper(ast)!\n            return transform(yield* settleNode(children[0]!))\n          }\n          case \"All\": {\n            // `All` is a combination, so its members settle concurrently \u2014 the\n            // same semantics `PlanScheduler` gives the same graph. Fail-fast\n            // matches `Effect.forEach`'s default and the scheduler's halt\n            // rule \u2014 with the ownership caveat: what a failure interrupts is\n            // each sibling's JOIN, not the node execution itself, which the\n            // interpretation owns and interrupts when the walk ends. A node\n            // whose execution was interrupted is evicted from the memo and\n            // records nothing, so it reports as skipped rather than as a\n            // phantom success.\n            const members = Object.keys(ast.nodes)\n            const values = yield* Effect.forEach(members, (_, index) => settleNode(children[index]!), {\n              concurrency: \"unbounded\"\n            })\n            const joined: Record<string, unknown> = Object.create(null) as Record<string, unknown>\n            for (let index = 0; index < members.length; index++) {\n              Object.defineProperty(joined, members[index]!, {\n                configurable: true,\n                enumerable: true,\n                value: values[index],\n                writable: true\n              })\n            }\n            return joined\n          }\n          case \"AndThen\":\n            return yield* settleNode(children[1]!)\n          case \"FlowCall\": {\n            if (ast.mode === \"handoff\") {\n              const declaration = handoffDeclarations.get(node.id)!\n              // DECIDED: a handoff target's schema\n              // services come from the context registration captured. A\n              // body's type cannot enumerate declarations hidden in its\n              // topology, so erase only that dynamic service parameter after\n              // resolving the concrete declaration here.\n              const payload = yield* Effect.flatMap(\n                Effect.orDie(declaration.payloadSchema.makeEffect(resolve(node.payload) as never)),\n                (decoded) =>\n                  Effect.orDie(\n                    Schema.encodeEffect(Schema.toCodecJson(declaration.payloadSchema))(decoded)\n                  )\n              ) as unknown as Effect.Effect<unknown, never, Services>\n              const ceiling = (yield* attenuateCapabilities(node.capabilityCeilings)(CapabilitySet.current)).groups\n              const outcome = {\n                _tag: \"To\",\n                flow: ast.flow,\n                payload,\n                ...(ceiling.length === 0 ? {} : { capabilityCeilings: ceiling })\n              } satisfies Outcome.To<unknown>\n              Object.defineProperty(outcome, OutcomeValueTypeId, {\n                configurable: false,\n                enumerable: false,\n                value: \"To\",\n                writable: false\n              })\n              return outcome\n            }\n            if (ast.mode === \"boundary\") {\n              // The real boundary of `docs/guides/run-a-child-flow.md`: an\n              // ordinary child execution, opened through the same `execute` a\n              // handler would call. The parent's `FlowInstance` is in scope, so\n              // the engine records the lineage edge, interrupts the child with\n              // the parent, and turns a suspended child into a suspended\n              // parent \u2014 genuine nesting, not a spliced imitation of it. It is\n              // deliberately NOT `Effect.scoped`: the interrupt link the engine\n              // installs is a finalizer of the PARENT's scope, and closing a\n              // scope of our own here would run it the moment the child\n              // settled. The same dynamic schema-service erasure the handoff\n              // above records applies to the cast: a body's type cannot\n              // enumerate the declarations hidden in its topology.\n              const declaration = childDeclarations.get(node.id)!\n              const instance = yield* FlowInstance\n              const childPayload = resolve(node.payload)\n              const executionId = yield* (childExecutionId(\n                instance.executionId,\n                node.id,\n                declaration._tag,\n                childPayload\n              ) as unknown as Effect.Effect<string, never, Services>)\n              childExecutions.set(node.id, executionId)\n              return yield* (declaration.execute(childPayload, {\n                executionId\n              }) as Effect.Effect<unknown, unknown, Services>).pipe(attenuateCapabilities(node.capabilityCeilings))\n            }\n            const spliced = children[0]\n            if (spliced === undefined) {\n              return yield* refuse(\n                \"unsupported_call\",\n                node.id,\n                `Flow \"${ast.flow}\" is called at \"${node.id}\" as a leaf, which this interpreter does not drive. ` +\n                  \"An inline .call() is spliced into the graph with the callee's body and driven with it, and \" +\n                  \"only a call that lost its declaration has no body to splice. Build and interpret the authored \" +\n                  `node in the same process, or call it as ${ast.flow}.child(payload) to run it as its own execution.`\n              )\n            }\n            return yield* settleNode(spliced)\n          }\n        }\n      }\n    )\n\n    // Closing the node scope on every exit \u2014 value, failure, or the\n    // interpretation's own interruption \u2014 is the fail-fast half of the\n    // ownership model: whatever is still running when the walk ends is\n    // interrupted before the interpretation reports, so no execution\n    // outlives it.\n    /**\n     * Everything the walk never reached, recorded once the walk is over.\n     *\n     * Only a walk that ENDED reports this. An interrupted one is a run that\n     * parked or was cancelled, and its nodes are not skipped \u2014 the resumed\n     * walk settles them, and recording them as skipped first would leave the\n     * journal claiming a node never ran that later did. A typed failure is\n     * terminal for the round, so its stranded nodes are skipped exactly as a\n     * completed walk's untaken branch arm is.\n     */\n    const recordSkipped = (exit: Exit.Exit<unknown, unknown>) =>\n      Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause) ? Effect.void : Effect.forEach(\n        graphNodes.filter((node) => !reported.has(node.id)),\n        (node) => {\n          const action = actionTag(node.ast)\n          return record(() => ({\n            _tag: \"NodeSettled\",\n            sourceId: `node/${node.id}/1/settled`,\n            nodeId: node.id,\n            outcome: \"skipped\",\n            attempts: 0,\n            // A node the walk never reached dispatched nothing, so it claims\n            // no step key and there is no value it settled with.\n            stepKeyDigests: [],\n            ...(action === undefined ? {} : { action })\n          }))\n        },\n        { discard: true }\n      )\n\n    const value = yield* settleNode(options.root ?? \"root\").pipe(\n      Effect.onExit((exit) => Scope.close(nodes, exit)),\n      Effect.onExit(recordSkipped)\n    )\n    return {\n      value,\n      settled,\n      failed,\n      skipped: Graph.nodes(graph).filter((node) => !settled.has(node.id) && !failed.has(node.id)).map((node) => node.id)\n    }\n  })\n\n/** A child execution a losing join member opened. @private */\nconst JoinChild = Schema.Struct({ node: Schema.String, executionId: Schema.String })\ntype JoinChild = typeof JoinChild.Type\n\n/**\n * The members a join decided on, in the order they decided, and the child\n * executions its losers had opened. A bare member list is the record written\n * before losing children were journaled; it names none, and still replays.\n *\n * @private\n */\nconst JoinDecision = Schema.Union([\n  Schema.Struct({ members: Schema.Array(Schema.String), children: Schema.Array(JoinChild) }),\n  Schema.Array(Schema.String)\n])\n\n/** One member's decisive settlement. @private */\ninterface Decision {\n  readonly member: string\n  readonly exit: Exit.Exit<unknown, unknown>\n}\n\n/**\n * How a member's settlement counts toward a join: a value or a typed failure\n * decides, an interruption is still undecided, and a defect or interpreter\n * refusal is fatal to the join.\n *\n * @private\n */\nconst classify = (exit: Exit.Exit<unknown, unknown>): \"decisive\" | \"pending\" | \"fatal\" => {\n  if (Exit.isSuccess(exit)) return \"decisive\"\n  if (Cause.hasInterruptsOnly(exit.cause)) return \"pending\"\n  const reasons = exit.cause.reasons\n  const typed = reasons.every((reason) => reason._tag !== \"Die\") &&\n    reasons.some((reason) => reason._tag === \"Fail\") &&\n    !reasons.some((reason) => reason._tag === \"Fail\" && Schema.is(InterpreterError)(reason.error))\n  return typed ? \"decisive\" : \"fatal\"\n}\n\n/**\n * A join's verdict over the members that decided, in the order they decided,\n * or `undefined` while it is still open.\n *\n * `race` takes the first settlement. `any` and `quorum` succeed once `count`\n * members succeed, and fail with the failure that leaves too few members able\n * to: for `any`, that is the last one.\n *\n * @private\n */\nconst decide = (\n  ast: Extract<Node.Ast, { readonly _tag: \"Race\" }>,\n  width: number,\n  outcomes: ReadonlyArray<Decision>\n): Exit.Exit<unknown, unknown> | undefined => {\n  if (ast.mode === \"race\") return outcomes[0]?.exit\n  const successes = outcomes.filter((outcome) => Exit.isSuccess(outcome.exit))\n  if (successes.length >= ast.count) {\n    if (ast.mode === \"any\") return successes[0]!.exit\n    const joined: Record<string, unknown> = Object.create(null) as Record<string, unknown>\n    for (const success of successes) {\n      Object.defineProperty(joined, success.member, {\n        configurable: true,\n        enumerable: true,\n        value: (success.exit as Exit.Success<unknown>).value,\n        writable: true\n      })\n    }\n    return Exit.succeed(joined)\n  }\n  if (outcomes.length - successes.length > width - ast.count) return outcomes[outcomes.length - 1]!.exit\n  return undefined\n}\n\n/**\n * Turns a body's root value into the settlement the engine acts on.\n *\n * Three of them exist, and only three\n * (`docs/concepts/trampoline-rounds.md`): `done(value)` is the answer, so the\n * value passes straight through; `Next.to(payload)` is the next round, recorded in the instance's\n * handoff slot so `Flow.intoResult` answers `Flow.Handoff`; and `park(reason)`\n * is a durable suspension, declared through the ordinary waiting vocabulary so\n * a durable driver parks the run under the flow's own reason and wake token\n * rather than the derived `timer`/`event` default. Anything else is an ordinary\n * value and is the answer as it stands, which is what keeps a body that never\n * heard of the trampoline working unchanged.\n *\n * @private\n */\nconst settleOutcome = (value: unknown): Effect.Effect<unknown, never, FlowInstance> => {\n  if (!Outcome.isOutcome(value)) return Effect.succeed(value)\n  switch (value._tag) {\n    case \"Done\":\n      return Effect.succeed(value.value)\n    case \"To\":\n      return Effect.gen(function*() {\n        const instance = yield* FlowInstance\n        const current = yield* CapabilitySet.current\n        instance.handoff = new Handoff({\n          flow: value.flow,\n          payload: value.payload,\n          capabilityCeilings: [...current.groups, ...(value.capabilityCeilings ?? [])]\n        })\n      })\n    case \"Park\":\n      return Effect.andThen(\n        annotateWaiting(value.reason),\n        Effect.flatMap(FlowInstance, suspend)\n      )\n  }\n}\n\n/**\n * Registers a flow with the runtime, driven by its body.\n *\n * This is the only way a flow's behavior reaches the runtime, and the reason a\n * flow has no `toLayer`: a flow has one behavior and it is the body, so there\n * is no second, opaque one to attach. An Action is what carries an\n * implementation, and it attaches that implementation with its own `toLayer`.\n * Compose this beside the action implementation layers the body calls, over the\n * {@link module:Implementations.layerImplementations} table they file\n * themselves in \u2014 the table goes UNDER them, because filing happens while an\n * implementation layer is built:\n *\n * ```ts\n * Layer.mergeAll(Read.toLayer(read), Write.toLayer(write), Interpreter.layer(Pipeline)).pipe(\n *   Layer.provideMerge(Action.layerImplementations)\n * )\n * ```\n *\n * It accepts a flow whatever its requirement channel says, and requires only\n * the table. Registering a body is not running one: the handler installed here\n * resolves each call by tag when the run reaches it, which is the same thing a\n * driver does for a plan read back out of a journal. `Flow.execute` is where\n * the requirements are asked for.\n *\n * This low-level registration keeps the `process-local` callback policy for\n * compatibility. Select `callbackIdentity: \"stable\"`, or use\n * {@link layerWithImplementations}, to refuse unstable callbacks before\n * dispatch. Without that selection it makes no reproducible-plan guarantee.\n *\n * @since 0.1.0\n * @category layers\n */\nexport const layer = <\n  Tag extends string,\n  Payload extends AnyStructSchema,\n  Success extends Schema.Top,\n  Error extends Schema.Top\n>(\n  flow: Flow<Tag, Payload, Success, Error, any>,\n  options: Graph.BuildOptions = {}\n) => makeLayer(flow, options, false)\n\n/** Registers one interpreter policy without changing the low-level compatibility surface. @private */\nconst makeLayer = <\n  Tag extends string,\n  Payload extends AnyStructSchema,\n  Success extends Schema.Top,\n  Error extends Schema.Top\n>(\n  flow: Flow<Tag, Payload, Success, Error, any>,\n  options: Graph.BuildOptions,\n  requireReusableVersions: boolean,\n  reachable?: Set<AnyWithProps>,\n  ifAbsent = false\n): Layer.Layer<\n  never,\n  never,\n  | FlowRuntime\n  | Implementations\n  | Payload[\"DecodingServices\"]\n  | Payload[\"EncodingServices\"]\n  | Success[\"DecodingServices\"]\n  | Success[\"EncodingServices\"]\n  | Error[\"DecodingServices\"]\n  | Error[\"EncodingServices\"]\n> =>\n  Layer.effectDiscard(Effect.gen(function*() {\n    const runtime = yield* FlowRuntime\n    const registered = reachable ?? new Set<AnyWithProps>()\n    if (registered.has(flow)) return\n    // Lazy registration can be skipped by an independent live owner. Recheck\n    // on later executions so releasing that owner permits fresh admission.\n    if (!ifAbsent) registered.add(flow)\n    const scope = yield* Effect.scope\n    const context = yield* Effect.context<Services | Scope.Scope>()\n    const implementations = Context.get(context, Implementations)\n    // Keep discovered declarations in the host registration scope, rather\n    // than the executing parent's scope: handoffs outlive that parent.\n    // Dynamic declarations erase their codec services, just like execute;\n    // those services still come from the registering host's context.\n    const registerReachable = (declaration: AnyWithProps): Effect.Effect<void> =>\n      Layer.buildWithScope(\n        makeLayer(\n          declaration as Flow<string, AnyStructSchema, Schema.Top, Schema.Top, any>,\n          options,\n          requireReusableVersions,\n          registered,\n          true\n        ),\n        scope\n      ).pipe(\n        Effect.provide(context),\n        Effect.asVoid\n      ) as Effect.Effect<void>\n    const middleware = Context.get(flow.annotations, ExecutionMiddleware)\n    yield* runtime.register(\n      flow,\n      ((payload: Payload[\"Type\"]) => {\n        const body = Effect.flatMap(\n          interpretWithPolicy(flow, payload, options, requireReusableVersions, registerReachable),\n          (interpretation) => settleOutcome(interpretation.value)\n        )\n        // Registration owns action resolution. A caller may supply a different\n        // table when entering this flow as a child; retain dynamic execution\n        // services while restoring this flow's registered implementations.\n        return (middleware === undefined ? body : middleware.wrap(payload, body)).pipe(\n          Effect.provideService(Implementations, implementations)\n        )\n      }) as (payload: Payload[\"Type\"], executionId: string) => Effect.Effect<\n        Success[\"Type\"],\n        Error[\"Type\"],\n        Crypto.Crypto | Implementations\n      >,\n      { ifAbsent }\n    )\n  }))\n\n/**\n * Composes one flow and its implementation layers around one isolated registry.\n *\n * The implementation layer must provide every action requirement carried by the\n * flow. Callback identity defaults to `stable`: raw callbacks are refused before\n * dispatch, with a diagnostic naming the callback and `Node.capture`. Captures\n * must cover semantic configuration and implementation versions, including\n * behavior reached through imports. Explicit `callbackIdentity: \"process-local\"`\n * is available for local experimentation, without a reproducible-plan claim.\n * Sealed actions with an idempotency key must declare `implementationVersion`\n * and register that exact version. This rule is independent of callback policy:\n * those declarations can reuse recorded content even if their code changes.\n * Keyless sealed actions use invocation identity; compensable and irreversible\n * actions do not use content-key caching. Their versions remain optional.\n * Versions must cover semantic handler and service changes; callback stability\n * cannot establish that declaration's completeness.\n *\n * The interpreter validates all named graph actions before dispatching any\n * of them. Conflicting registrations fail while the layer builds; use an explicit\n * `toLayer(handler, { override: true })` only for intentional scoped substitution.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerWithImplementations = <\n  Tag extends string,\n  Payload extends AnyStructSchema,\n  Success extends Schema.Top,\n  Error extends Schema.Top,\n  Requires,\n  Provided,\n  E,\n  R\n>(\n  flow: Flow<Tag, Payload, Success, Error, Requires>,\n  implementations:\n    & Layer.Layer<Provided, E, R>\n    & (\n      [NoInfer<Requires>] extends [Provided] ? unknown\n        : { readonly missingActionImplementations: Exclude<Requires, Provided> }\n    ),\n  options: Graph.BuildOptions = {}\n) =>\n  Layer.merge(\n    implementations,\n    makeLayer(flow, { ...options, callbackIdentity: options.callbackIdentity ?? \"stable\" }, true)\n  )\n    .pipe(\n      Layer.provide(Layer.fresh(layerImplementations))\n    )\n"],
+  "mappings": "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",
+  "names": ["reported", "record", "declaration", "FlowTypeId", "value", "outcomes", "verdict", "decide", "payload"]
+}

package/dist/cjs/Poll.d.ts

@@ -0,0 +1,238 @@
+/**
+ * Polling as a durable lineage: one attempt per round, a durable wait between
+ * attempts, and a bound the lineage settles on.
+ *
+ * Smithers 0.x had a `Poller` component — a check, an interval, a backoff, an
+ * attempt bound, and what to do at that bound. The pieces it was built from
+ * already exist here: {@link module:Sleep.action} is the durable wait, and
+ * `Flow.to` opens the next round. What was missing is the shape that puts them
+ * together, and that is this module.
+ *
+ * A poll is a flow whose body is ONE attempt. It runs the check, and branches:
+ * a satisfied check settles the lineage with the check's own output, an
+ * unsatisfied one sleeps for this attempt's delay and hands off to the next
+ * round with the attempt counter raised. The last attempt has no sleep and no
+ * handoff — it either answers with the output it just read (`return-last`) or
+ * fails {@link PollExhausted} (`fail`).
+ *
+ * Everything durable about it is durable for the ordinary reason. Each attempt
+ * is a round with its own keyed plan nodes, so a check that already ran replays
+ * from its recorded outcome instead of running again; the wait between attempts
+ * is a durable timer, so a process that dies during it resumes on the round it
+ * left rather than starting the poll over; and the attempt counter travels in
+ * the payload, so nothing about "which attempt is this" lives in memory.
+ *
+ * The bound is stated twice on purpose. The body ends the lineage on the last
+ * attempt, and `maxAttempts` is also the flow's `maxRounds` budget, so a
+ * lineage that somehow opened another round is refused by the engine rather
+ * than polling forever.
+ *
+ * @since 0.1.0
+ */
+import * as Node from "@smthrs/plan/Node";
+import type * as Repetition from "@smthrs/plan/Repetition";
+import type * as Crypto from "effect/Crypto";
+import type * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as Action from "./Action/index.ts";
+import * as Flow from "./Flow/index.ts";
+import type { FlowRuntime } from "./FlowRuntime/FlowRuntime.ts";
+import * as Sleep from "./Sleep.ts";
+/**
+ * How the wait between attempts grows.
+ *
+ * `fixed` waits the interval every time, `linear` waits the interval times the
+ * attempt, and `exponential` doubles the interval on every attempt.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Backoff = "fixed" | "linear" | "exponential";
+/**
+ * What a check reports: whether the poll is over, and the value this attempt
+ * read.
+ *
+ * The output travels on every attempt, satisfied or not, because it is also
+ * the answer a `return-last` poll settles with when it runs out of attempts.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Check<out Result> {
+    readonly satisfied: boolean;
+    readonly output: Result;
+}
+/**
+ * The success schema a check action declares.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const CheckResult: <Result extends Schema.Top>(result: Result) => Schema.Struct<{
+    readonly satisfied: typeof Schema.Boolean;
+    readonly output: Result;
+}>;
+declare const PollExhausted_base: Schema.Class<PollExhausted, Schema.TaggedStruct<"@smthrs/flow/PollExhausted", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"poll_exhausted">>;
+    readonly poll: Schema.String;
+    readonly attempts: Schema.Number;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A poll that used its last attempt without a satisfied check.
+ *
+ * It is a typed failure rather than a defect: running out of attempts is an
+ * expected outcome of polling something that may never become ready, so a
+ * caller recovers from it through `Node.catch` like any other declared failure.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class PollExhausted extends PollExhausted_base {
+}
+/**
+ * The tag the exhaustion step is catalogued and resolved under.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const exhaustedTag = "system/poll-exhausted";
+/**
+ * The declared step a poll takes when its last attempt was not satisfied.
+ *
+ * Running out of attempts is a step rather than a bare `Effect.fail` so the
+ * exhaustion is in the plan and in the journal: the round that gave up shows
+ * which poll gave up and after how many attempts, exactly like every other node
+ * a body drove.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const exhausted: Action.Declared<typeof exhaustedTag, Schema.Struct<{
+    readonly poll: typeof Schema.String;
+    readonly attempts: typeof Schema.Number;
+}>, typeof Schema.Never, typeof PollExhausted, never>;
+/**
+ * The wait before the attempt after this one, in milliseconds.
+ *
+ * @category combinators
+ * @since 0.1.0
+ */
+export declare const delayMillis: (options: {
+    readonly intervalMs: number;
+    readonly backoff: Backoff;
+    readonly attempt: number;
+}) => number;
+/**
+ * What a poll round can fail with.
+ *
+ * {@link PollExhausted} is the poll's own failure. `SleepRequestInvalid` is the
+ * wait node's, declared because the wait between attempts is an ordinary
+ * {@link module:Sleep.action} node and its typed refusal is part of the
+ * topology a poll carries. Its codes cover a payload that names no deadline,
+ * names two deadlines, or names a value that is not a deadline. {@link make}
+ * refuses invalid author schedules at construction. A caller-visible round
+ * payload can still carry an invalid attempt that produces an invalid derived
+ * wait, so `Sleep` refuses that wait before the round parks.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Failure: Schema.Union<readonly [typeof PollExhausted, typeof Sleep.SleepRequestInvalid]>;
+/**
+ * The payload schema {@link make} derives from an author's input fields: the
+ * author's own fields, plus the attempt this round is.
+ *
+ * `attempt` is optional so a caller starts a poll with its own fields alone;
+ * the first round reads it as one.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type PayloadSchema<Input extends Schema.Struct.Fields> = Schema.Struct<Input & {
+    readonly attempt: Schema.optional<typeof Schema.Number>;
+}>;
+/**
+ * Declares a durable poller.
+ *
+ * **When to use**
+ *
+ * Use it wherever a run has to keep asking until something is ready — a build
+ * that finishes, a deployment that goes live, a review that lands — and the
+ * waiting has to survive a restart. `check` is the one thing an author writes:
+ * a body fragment that reads whatever it polls and reports a {@link Check}.
+ * Everything else is schedule. Under stable callback admission (the default of
+ * `Interpreter.layerWithImplementations`), wrap `check` in `Node.capture` with
+ * every semantic capture, including a version for imported behavior. An
+ * uncaptured check keeps the poll process-local. The helper captures its own
+ * callbacks using the schedule and the check's identity.
+ *
+ * ```ts
+ * const Deployment = Poll.make("deploy/wait", {
+ *   input: { id: Schema.String },
+ *   result: Schema.String,
+ *   intervalMs: 5_000,
+ *   backoff: "exponential",
+ *   maxAttempts: 8,
+ *   onTimeout: "fail",
+ *   check: Node.capture(
+ *     { action: Status.name, implementationVersion: "deploy/status-check/v1" },
+ *     ({ attempt, id }) => Status.call({ attempt, id })
+ *   )
+ * })
+ * ```
+ *
+ * The check may not fail. A check that can fail states what a failure means for
+ * the poll — give up, or treat it as "not ready yet" — with `Node.catch` inside
+ * the fragment, rather than leaving the poll to guess.
+ *
+ * A per-attempt time limit on the check itself is NOT a poll option. A plan
+ * node's duration is not something the body around it can bound; that bound
+ * belongs in the check's own implementation, where `DurableDeferred.raceAll`
+ * races the work against a durable clock and stays replayable.
+ *
+ * A schedule no clock can be armed with is refused here, with a `RangeError`
+ * naming the option that is wrong. `intervalMs` becomes the `millis` of a
+ * {@link module:Sleep.action} node, and a wait of `Infinity`, `NaN`, or a
+ * negative length arms a timer that never fires — a poll that hangs forever
+ * with a plan that looks correct. The check is on the schedule, not only on the
+ * interval: `{ intervalMs: 1000, maxAttempts: 2000, backoff: "exponential" }`
+ * states three finite options and asks for an infinite wait, so the LAST wait
+ * the poll can arm has to be a length too. `maxAttempts` is the lineage's round
+ * budget, and a budget below one attempt reaches `Flow.make` as a `maxRounds`
+ * complaint about an option the author never wrote.
+ *
+ * @throws A `RangeError` when `intervalMs` is not a duration a clock accepts,
+ * when `maxAttempts` is not a whole number of attempts of at least one, or when
+ * the interval under the declared backoff reaches a wait no clock can be armed
+ * with before the budget is spent.
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: <const Tag extends string, Input extends Schema.Struct.Fields, Result extends Schema.Top, R = never>(tag: Tag, options: {
+    readonly input: Input;
+    readonly result: Result;
+    readonly check: (payload: Schema.Struct.Type<Input> & {
+        readonly attempt: number;
+    }) => Node.Node<Check<Result["Type"]>, never, R>;
+    readonly intervalMs: number;
+    readonly maxAttempts: number;
+    readonly backoff?: Backoff | undefined;
+    readonly onTimeout?: Repetition.AtCeiling | undefined;
+}) => Flow.Flow<Tag, PayloadSchema<Input>, Result, typeof Failure, R>;
+/**
+ * The exhaustion implementation, provided beside the other action layers a
+ * poll's rounds call.
+ *
+ * ```ts
+ * Layer.mergeAll(Poll.layer, Sleep.layer, Interpreter.layer(Deployment)).pipe(
+ *   Layer.provideMerge(Action.layerImplementations)
+ * )
+ * ```
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: Layer.Layer<never, never, Crypto.Crypto | FlowRuntime>;
+export {};
+//# sourceMappingURL=Poll.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Poll.d.ts","sourceRoot":"","sources":["../../src/Poll.ts"],"names":[],"mappings":"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"}

package/dist/cjs/Poll.js

@@ -0,0 +1,150 @@
+"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 Poll_exports = {};
+__export(Poll_exports, {
+  CheckResult: () => CheckResult,
+  Failure: () => Failure,
+  PollExhausted: () => PollExhausted,
+  delayMillis: () => delayMillis,
+  exhausted: () => exhausted,
+  exhaustedTag: () => exhaustedTag,
+  layer: () => layer,
+  make: () => make
+});
+module.exports = __toCommonJS(Poll_exports);
+var Node = __toESM(require("@smthrs/plan/Node"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var Action = __toESM(require("./Action/index.js"), 1);
+var Flow = __toESM(require("./Flow/index.js"), 1);
+var Sleep = __toESM(require("./Sleep.js"), 1);
+const CheckResult = (result) => Schema.Struct({ satisfied: Schema.Boolean, output: result });
+class PollExhausted extends Schema.TaggedError()(
+  "@smthrs/flow/PollExhausted",
+  {
+    // This wire shape freezes at 1.0.0-rc.0.
+    code: Schema.Literal("poll_exhausted").pipe(
+      Schema.withConstructorDefault(Effect.succeed("poll_exhausted"))
+    ),
+    poll: Schema.String,
+    attempts: Schema.Number,
+    message: Schema.String
+  }
+) {
+}
+const exhaustedTag = "system/poll-exhausted";
+const exhausted = Action.makeSystem(exhaustedTag, {
+  payload: { poll: Schema.String, attempts: Schema.Number },
+  success: Schema.Never,
+  error: PollExhausted,
+  tier: "sealed"
+});
+const delayMillis = (options) => options.intervalMs * (options.backoff === "fixed" ? 1 : options.backoff === "linear" ? options.attempt : 2 ** (options.attempt - 1));
+const Failure = Schema.Union([PollExhausted, Sleep.SleepRequestInvalid]);
+const payloadSchema = (input, maxAttempts) => Schema.Struct({
+  ...input,
+  attempt: Schema.optional(
+    Schema.Int.check(
+      Schema.isGreaterThanOrEqualTo(1),
+      Schema.isLessThanOrEqualTo(maxAttempts)
+    )
+  )
+});
+const attemptOf = (payload) => {
+  const attempt = payload.attempt;
+  return typeof attempt === "number" ? attempt : 1;
+};
+const withAttempt = (payload, attempt) => ({ ...payload, attempt });
+const make = (tag, options) => {
+  if (Object.prototype.hasOwnProperty.call(options.input, "attempt")) {
+    throw new TypeError(
+      `Poll.make: "${tag}" input cannot declare the reserved "attempt" field. Poll owns that counter across durable rounds.`
+    );
+  }
+  const input = Object.freeze({ ...options.input });
+  const result = options.result;
+  const check = options.check;
+  const intervalMs = options.intervalMs;
+  const maxAttempts = options.maxAttempts;
+  if (!Number.isFinite(intervalMs) || intervalMs < 0) {
+    throw new RangeError(
+      `Poll.make: "${tag}" intervalMs must be a finite number of milliseconds that is not negative, and was ${intervalMs}. The interval is the length of a durable wait, and a wait of that length never ends.`
+    );
+  }
+  if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {
+    throw new RangeError(
+      `Poll.make: "${tag}" maxAttempts must be a whole number of attempts of at least one, and was ${maxAttempts}. A poll checks at least once.`
+    );
+  }
+  const backoff = options.backoff ?? "fixed";
+  const longestWaitMs = maxAttempts > 1 ? delayMillis({ intervalMs, backoff, attempt: maxAttempts - 1 }) : 0;
+  if (!Number.isFinite(longestWaitMs)) {
+    throw new RangeError(
+      `Poll.make: "${tag}" asks for a wait of ${longestWaitMs} ms before its last attempt. An intervalMs of ${intervalMs} under the "${backoff}" backoff reaches a length no clock can be armed with by attempt ${maxAttempts - 1} of ${maxAttempts}. Lower maxAttempts, shorten the interval, or slow the backoff.`
+    );
+  }
+  const onTimeout = options.onTimeout ?? "fail";
+  const captures = { tag, intervalMs, backoff, maxAttempts, onTimeout, check: Node.functionIdentity(check) };
+  const body = (payload) => {
+    const attempt = attemptOf(payload);
+    const last = attempt >= maxAttempts;
+    return check(withAttempt(payload, attempt)).pipe(
+      Node.branch({
+        if: Node.capture(captures, (checked) => checked.satisfied),
+        then: (checked) => Flow.done(checked.output),
+        else: (checked) => last ? onTimeout === "return-last" ? Flow.done(checked.output) : exhausted.call({ poll: tag, attempts: attempt }) : Sleep.action.call({
+          millis: delayMillis({ intervalMs, backoff, attempt })
+        }).pipe(
+          Node.andThen(
+            self.to(withAttempt(payload, attempt + 1))
+          )
+        )
+      })
+    );
+  };
+  const self = Flow.make(tag, {
+    payload: payloadSchema(input, maxAttempts),
+    success: result,
+    error: Failure,
+    maxRounds: maxAttempts,
+    // A captured wrapper must not admit a process-local check as stable.
+    body: captures.check.algorithm === "sha256-source-ephemeral/v4" ? body : Node.capture(captures, body)
+  });
+  return self;
+};
+const layer = exhausted.toLayer(
+  ({ attempts, poll }) => Effect.fail(
+    new PollExhausted({
+      poll,
+      attempts,
+      message: `Poll "${poll}" used all ${attempts} attempts without a satisfied check.`
+    })
+  )
+);
+//# sourceMappingURL=Poll.js.map