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

package/dist/esm/internal/node.js

@@ -0,0 +1,564 @@
+/**
+ * The node AST, and the side tables the functions hang off.
+ *
+ * Two invariants shape every declaration here. The AST is **closure-free**
+ * and keeps payloads as inert JSON mirrors, so a valid plan can be shipped,
+ * stored, diffed, and rendered without the process that built it; control flow is
+ * **structure**, so a branch stores both arms as ASTs rather than a function
+ * that would have to be run to find out what comes next.
+ *
+ * The functions an author does write — a mapper, a continuation, a branch
+ * predicate — live in `WeakMap`s keyed by the AST node they belong to, and the
+ * AST keeps only a {@link FunctionIdentity} digest of their source. The digest
+ * is what enters content identity (https://smithers.sh/docs/concepts/content-addressing); the
+ * `WeakMap` is what the run reaches for when it has the real value in hand, and
+ * it drops with the AST it is keyed by.
+ *
+ * Adapted from `@smthrs/core` (`packages/smithers/flows/core`)
+ * `internal/node.ts`. `Dynamic` does not come across — a model call is an
+ * ordinary action here — and neither do annotations, which are `Context`
+ * values and would break serializability. Scheduling priority is the one thing that does cross, as
+ * the plain JSON field {@link Scheduled.priority} rather than as an
+ * annotation, because the scheduler has to read it out of a stored plan.
+ *
+ * @since 0.1.0
+ */
+import { isRecord } from "@smthrs/canonical/Record";
+import { digestSync } from "@smthrs/crypto";
+import * as Identity from "@smthrs/crypto/Identity";
+import { identity } from "effect/Function";
+import { pipeArguments } from "effect/Pipeable";
+import * as Schema from "effect/Schema";
+import { jsonMirror } from "./JsonMirror.js";
+/**
+ * The runtime type identifier every node carries.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const TypeId = "~@smthrs/plan/Node";
+/**
+ * How a flow call joins the caller's plan: `inline` splices the callee's body
+ * in, `boundary` makes it one child execution, and `handoff` names the next
+ * trampoline round. Why the child call is a mode rather than a second AST tag
+ * is in `docs/concepts/authoring-ast.md`.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const CallMode = Schema.Literals(["inline", "boundary", "handoff"]);
+/**
+ * The algorithms a {@link FunctionIdentity} may name. The tag is versioned so a
+ * change to identity semantics re-keys everything derived from one, rather than
+ * colliding with it.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const IdentityAlgorithm = Schema.Literals([
+    "sha256-source-ephemeral/v4",
+    "sha256-source-captures/v5",
+    "static-node/v1"
+]);
+/**
+ * Brands an operation with every inert value it closes over, so its identity
+ * covers what it computes with and not only its source.
+ *
+ * `@smthrs/crypto` owns the captures, nested metadata, and freezing contract.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export const capture = Identity.capture;
+// A bundled runtime and a dynamically loaded flow may contain separate
+// compatible package copies. Share only live object metadata: JSON round trips
+// still lose executable bindings, and structural lookalikes remain inert.
+const stateKey = Symbol.for("@smthrs/plan/Node/live/v1");
+const globals = globalThis;
+const liveState = globals[stateKey] ??= {
+    references: new WeakSet(),
+    nodes: new WeakSet(),
+    operations: new WeakMap(),
+    predicates: new WeakMap(),
+    filters: new WeakMap(),
+    declarations: new WeakMap()
+};
+/** The AST references minted by this module; structural lookalikes are data. */
+const plannedReferences = liveState.references;
+const makePlannedReference = (reference) => {
+    const value = Object.freeze({
+        _tag: "PlannedReference",
+        node: reference.node,
+        path: Object.freeze([...reference.path])
+    });
+    plannedReferences.add(value);
+    return value;
+};
+/**
+ * Reads an AST-owned planned reference without trusting its public data shape.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export const plannedReference = (value) => typeof value === "object" && value !== null && plannedReferences.has(value)
+    ? value
+    : undefined;
+const operations = liveState.operations;
+const predicates = liveState.predicates;
+const filters = liveState.filters;
+const declarations = liveState.declarations;
+/**
+ * The JSON mirror of an AST payload. A planned value becomes an AST-owned
+ * {@link PlannedReference}, so the AST stays inert JSON.
+ *
+ * @private
+ */
+const payloadMirror = (input) => jsonMirror(input, (_value, reference) => makePlannedReference(reference));
+/**
+ * Digests a function's exact source as UTF-8 with SHA-256. Exact source matters:
+ * whitespace inside a string literal is behavior, and normalizing it before
+ * hashing can make different functions share an identity. Unless its inert
+ * captures were declared with {@link capture}, the digest also includes
+ * process-local, per-function entropy: JavaScript cannot inspect a closure, so
+ * source-only identity would permit incorrect cache hits.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const functionIdentity = Identity.functionIdentity;
+/**
+ * The prototype every node shares, so `pipe` is one function rather than one
+ * closure per node.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const NodeProto = {
+    [TypeId]: {
+        _A: identity,
+        _E: identity,
+        _R: identity
+    },
+    pipe() {
+        // eslint-disable-next-line prefer-rest-params -- `pipeArguments` takes the arguments object itself.
+        return pipeArguments(this, arguments);
+    }
+};
+/**
+ * Every node {@link makeNode} built, so a node this module made is recognized
+ * in constant time without walking its AST again.
+ */
+const liveNodes = liveState.nodes;
+/** Recognizes the algorithms {@link IdentityAlgorithm} declares, and nothing else. */
+const isIdentityAlgorithm = Schema.is(IdentityAlgorithm);
+/** Recognizes the modes {@link CallMode} declares, and nothing else. */
+const isCallMode = Schema.is(CallMode);
+/** Recognizes the modes {@link RaceMode} names, and nothing else. @private */
+const isRaceMode = (value) => value === "race" || value === "any" || value === "quorum";
+/**
+ * Whether `count` is a successes target a {@link Race} of `members` can reach:
+ * a quorum needs between one and every member, and the other modes need one.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export const isRaceCount = (mode, count, members) => members > 0 && Number.isSafeInteger(count) &&
+    (mode === "quorum" ? count >= 1 && count <= members : count === 1);
+/** @private */
+const isFunctionIdentity = (value) => isRecord(value) && value._tag === "FunctionIdentity" && isIdentityAlgorithm(value.algorithm) &&
+    typeof value.digest === "string";
+/**
+ * Checks whether a value has the shape of a {@link NodeAst}: what a JSON round
+ * trip of a genuine AST produces, and nothing looser. Every variant's own
+ * fields are checked, and every child is walked. The walk is an explicit stack
+ * rather than recursion, so an arbitrarily deep AST cannot overflow the native
+ * stack, and it tracks the ancestors of the position it has reached, so a
+ * cyclic object is refused rather than walked forever while a shared sub-AST
+ * still passes.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export const isNodeAst = (value) => {
+    const ancestors = new Set();
+    const pending = [{ enter: value }];
+    while (pending.length > 0) {
+        const visit = pending.pop();
+        if ("exit" in visit) {
+            ancestors.delete(visit.exit);
+            continue;
+        }
+        const ast = visit.enter;
+        if (!isRecord(ast) || ancestors.has(ast))
+            return false;
+        if (ast.priority !== undefined && !Number.isSafeInteger(ast.priority))
+            return false;
+        const children = [];
+        switch (ast._tag) {
+            case "Succeed":
+            case "Fail":
+                break;
+            case "All": {
+                if (!isRecord(ast.nodes) || Array.isArray(ast.nodes))
+                    return false;
+                for (const child of Object.values(ast.nodes))
+                    children.push(child);
+                break;
+            }
+            case "Race": {
+                if (!isRecord(ast.nodes) || Array.isArray(ast.nodes))
+                    return false;
+                const members = Object.values(ast.nodes);
+                if (!isRaceMode(ast.mode) || !isRaceCount(ast.mode, ast.count, members.length))
+                    return false;
+                for (const child of members)
+                    children.push(child);
+                break;
+            }
+            case "Map": {
+                if (!isFunctionIdentity(ast.mapper))
+                    return false;
+                children.push(ast.first);
+                break;
+            }
+            case "AndThen": {
+                if (!isFunctionIdentity(ast.continuation))
+                    return false;
+                children.push(ast.first);
+                if (ast.next !== undefined)
+                    children.push(ast.next);
+                break;
+            }
+            case "Branch": {
+                if (typeof ast.subject !== "string" || !isFunctionIdentity(ast.predicate))
+                    return false;
+                children.push(ast.first, ast.then, ast.else);
+                break;
+            }
+            case "Catch": {
+                if (typeof ast.subject !== "string")
+                    return false;
+                if (ast.filterIdentity !== undefined && !isFunctionIdentity(ast.filterIdentity))
+                    return false;
+                children.push(ast.protected, ast.failure);
+                break;
+            }
+            case "FlowCall": {
+                if (typeof ast.flow !== "string" || !isCallMode(ast.mode))
+                    return false;
+                break;
+            }
+            case "ActionCall": {
+                if (typeof ast.action !== "string")
+                    return false;
+                break;
+            }
+            default:
+                return false;
+        }
+        if (children.length > 0) {
+            ancestors.add(ast);
+            pending.push({ exit: ast });
+            for (const child of children)
+                pending.push({ enter: child });
+        }
+    }
+    return true;
+};
+/**
+ * Checks whether a value is a node.
+ *
+ * A node this module built is recognized by registration. A node that crossed
+ * a serialization boundary, an object whose prototype is {@link NodeProto} and
+ * whose own `ast` data property passes {@link isNodeAst}, is recognized by that
+ * shape: `@smthrs/flow` hands a rehydrated AST back as a node, and the side
+ * tables are all a round trip loses. The {@link TypeId} marker is an exported
+ * string any object can carry, so it counts for nothing on its own, and an
+ * `ast` that is missing, malformed, cyclic, or an accessor is refused because
+ * every combinator reads it as trusted topology. A proxy is judged by the
+ * shape it forwards.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export const isNode = (value) => {
+    if (typeof value !== "object" || value === null)
+        return false;
+    if (liveNodes.has(value))
+        return true;
+    if (Object.getPrototypeOf(value) !== NodeProto)
+        return false;
+    const ast = Object.getOwnPropertyDescriptor(value, "ast");
+    return ast !== undefined && "value" in ast && isNodeAst(ast.value);
+};
+/**
+ * Wraps an AST as a node.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const makeNode = (ast) => {
+    const node = Object.assign(Object.create(NodeProto), { ast });
+    liveNodes.add(node);
+    return node;
+};
+/**
+ * Constructs a {@link Succeed}.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const succeed = (input) => ({ _tag: "Succeed", value: payloadMirror(input) });
+/**
+ * Constructs a {@link Fail}.
+ *
+ * @since 1.0.0
+ * @private
+ * @slop
+ */
+export const fail = (error) => ({ _tag: "Fail", error: payloadMirror(error) });
+/**
+ * Constructs an {@link All}.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const all = (nodes) => ({ _tag: "All", nodes });
+/**
+ * Constructs a {@link Race}.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export const race = (mode, count, nodes) => ({
+    _tag: "Race",
+    mode,
+    count,
+    nodes
+});
+/**
+ * Constructs a {@link Map}, filing the mapper under the AST it belongs to.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const map = (first, operation, source) => {
+    const ast = { _tag: "Map", first, mapper: functionIdentity(source) };
+    operations.set(ast, operation);
+    return ast;
+};
+/**
+ * Constructs an {@link AndThen} from a builder. The builder is evaluated once
+ * against a planned value when the graph is built, never here.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const andThen = (first, operation, source) => {
+    const ast = { _tag: "AndThen", first, continuation: functionIdentity(source) };
+    operations.set(ast, operation);
+    return ast;
+};
+/**
+ * Constructs an {@link AndThen} from a node the author supplied directly. There
+ * is no function to digest, so the continuation carries a fixed marker.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const andThenNode = (first, next) => ({
+    _tag: "AndThen",
+    first,
+    continuation: { _tag: "FunctionIdentity", algorithm: "static-node/v1", digest: digestSync("static-node") },
+    next
+});
+/**
+ * Constructs a {@link Branch}. Both arms arrive already evaluated, because a
+ * branch that had to be run to reveal its topology would not be a plan.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const branch = (subject, first, predicate, source, then, otherwise) => {
+    const ast = {
+        _tag: "Branch",
+        subject,
+        first,
+        predicate: functionIdentity(source),
+        then,
+        else: otherwise
+    };
+    predicates.set(ast, predicate);
+    return ast;
+};
+/**
+ * JSON Schema does not describe arbitrary checks, declaration parsers, or
+ * suspended schema factories. Include every function reachable from the
+ * schema AST, preserving declared captures and treating opaque wrappers as
+ * ephemeral. The iterative walk also covers nested checks and cyclic ASTs.
+ *
+ * @private
+ */
+const filterIdentity = (filter) => {
+    const identities = [];
+    const pending = [["$", filter.ast]];
+    const seen = new WeakSet();
+    while (pending.length > 0) {
+        const [path, current] = pending.pop();
+        if (typeof current === "function") {
+            identities.push([path, functionIdentity(current)]);
+        }
+        else if (typeof current === "object" && current !== null && !seen.has(current)) {
+            seen.add(current);
+            const descriptors = Object.getOwnPropertyDescriptors(current);
+            for (const key of Object.keys(descriptors).sort()) {
+                const descriptor = descriptors[key];
+                if ("value" in descriptor)
+                    pending.push([`${path}/${JSON.stringify(key)}`, descriptor.value]);
+                else {
+                    if (descriptor.get !== undefined)
+                        pending.push([`${path}/${JSON.stringify(key)}/get`, descriptor.get]);
+                    if (descriptor.set !== undefined)
+                        pending.push([`${path}/${JSON.stringify(key)}/set`, descriptor.set]);
+                }
+            }
+        }
+    }
+    return {
+        _tag: "FunctionIdentity",
+        algorithm: identities.some(([, identity]) => identity.algorithm === "sha256-source-ephemeral/v4")
+            ? "sha256-source-ephemeral/v4"
+            : "sha256-source-captures/v5",
+        digest: digestSync(JSON.stringify(identities))
+    };
+};
+/**
+ * Constructs a {@link Catch} whose failure topology is already evaluated.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const catch_ = (subject, protectedAst, failure, filter) => {
+    const ast = {
+        _tag: "Catch",
+        subject,
+        protected: protectedAst,
+        failure,
+        ...(filter === undefined
+            ? {}
+            : {
+                filter: Schema.toJsonSchemaDocument(filter, { onExcessProperty: "error" }),
+                filterIdentity: filterIdentity(filter)
+            })
+    };
+    if (filter !== undefined)
+        filters.set(ast, filter);
+    return ast;
+};
+/**
+ * Constructs a {@link FlowCall}, filing the flow declaration beside it.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const flowCall = (declaration, flow, mode, payload) => {
+    const ast = { _tag: "FlowCall", flow, mode, payload: payloadMirror(payload) };
+    declarations.set(ast, declaration);
+    return ast;
+};
+/**
+ * Constructs an {@link ActionCall}, filing the action declaration beside
+ * it.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const actionCall = (declaration, action, payload) => {
+    const ast = { _tag: "ActionCall", action, payload: payloadMirror(payload) };
+    declarations.set(ast, declaration);
+    return ast;
+};
+/**
+ * The deferred function of a map or a continuation.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const operation = (ast) => operations.get(ast);
+/**
+ * The run-time predicate of a branch.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const predicate = (ast) => predicates.get(ast);
+/**
+ * The optional error schema filter of a catch node.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const filter = (ast) => filters.get(ast);
+/**
+ * The flow or action declaration a call node names.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const declaration = (ast) => declarations.get(ast);
+/**
+ * Copies an AST with a scheduling priority attached.
+ *
+ * The copy is shallow and the side tables are re-filed against it, because a
+ * function, a predicate, a filter schema, and a declaration are keyed by the
+ * exact AST object they belong to: a copy that left them behind would silently
+ * lose the continuation the graph walk has to evaluate.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export const withPriority = (ast, priority) => {
+    const prioritized = { ...ast, priority };
+    if (ast._tag === "AndThen" || ast._tag === "Map") {
+        const deferred = operations.get(ast);
+        if (deferred !== undefined)
+            operations.set(prioritized, deferred);
+    }
+    if (ast._tag === "Branch") {
+        const decision = predicates.get(ast);
+        if (decision !== undefined)
+            predicates.set(prioritized, decision);
+    }
+    if (ast._tag === "Catch") {
+        const schema = filters.get(ast);
+        if (schema !== undefined)
+            filters.set(prioritized, schema);
+    }
+    if (ast._tag === "ActionCall" || ast._tag === "FlowCall") {
+        const target = declarations.get(ast);
+        if (target !== undefined)
+            declarations.set(prioritized, target);
+    }
+    return prioritized;
+};
+//# sourceMappingURL=node.js.map

package/dist/esm/internal/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","sourceRoot":"","sources":["../../../src/internal/node.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The node AST, and the side tables the functions hang off.\n *\n * Two invariants shape every declaration here. The AST is **closure-free**\n * and keeps payloads as inert JSON mirrors, so a valid plan can be shipped,\n * stored, diffed, and rendered without the process that built it; control flow is\n * **structure**, so a branch stores both arms as ASTs rather than a function\n * that would have to be run to find out what comes next.\n *\n * The functions an author does write — a mapper, a continuation, a branch\n * predicate — live in `WeakMap`s keyed by the AST node they belong to, and the\n * AST keeps only a {@link FunctionIdentity} digest of their source. The digest\n * is what enters content identity (https://smithers.sh/docs/concepts/content-addressing); the\n * `WeakMap` is what the run reaches for when it has the real value in hand, and\n * it drops with the AST it is keyed by.\n *\n * Adapted from `@smthrs/core` (`packages/smithers/flows/core`)\n * `internal/node.ts`. `Dynamic` does not come across — a model call is an\n * ordinary action here — and neither do annotations, which are `Context`\n * values and would break serializability. Scheduling priority is the one thing that does cross, as\n * the plain JSON field {@link Scheduled.priority} rather than as an\n * annotation, because the scheduler has to read it out of a stored plan.\n *\n * @since 0.1.0\n */\n\nimport { isRecord } from \"@smthrs/canonical/Record\"\nimport { digestSync } from \"@smthrs/crypto\"\nimport * as Identity from \"@smthrs/crypto/Identity\"\nimport { identity } from \"effect/Function\"\nimport { pipeArguments } from \"effect/Pipeable\"\nimport * as Schema from \"effect/Schema\"\nimport type { Node } from \"../Node.ts\"\nimport type * as Planned from \"../Planned.ts\"\nimport { jsonMirror } from \"./JsonMirror.ts\"\n\n/**\n * The runtime type identifier every node carries.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const TypeId = \"~@smthrs/plan/Node\" as const\n\n/**\n * The type-level form of {@link TypeId}.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport type TypeId = typeof TypeId\n\n/**\n * What every AST variant carries besides its own shape: an optional scheduling\n * priority.\n *\n * A priority is JSON, not a `Context` annotation, which is why it can live in\n * the AST at all: the whole point of dropping core's annotations was to keep a\n * plan shippable, storable, and diffable. It is a scheduling HINT — the plan\n * compiler copies it onto the node draft and the scheduler orders ready work by\n * it, while key material never reads it, so raising a priority reorders work\n * without re-keying a single step.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport interface Scheduled {\n  readonly priority?: number | undefined\n}\n\n/**\n * A constant, known before anything runs.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport interface Succeed extends Scheduled {\n  readonly _tag: \"Succeed\"\n  readonly value: unknown\n}\n\n/**\n * A constant typed failure, known before anything runs.\n *\n * The error is an inert JSON mirror for the same reason {@link Succeed.value}\n * is: a stored plan has to carry what the node produces without the process\n * that built it.\n *\n * @since 1.0.0\n * @private\n * @slop\n */\nexport interface Fail extends Scheduled {\n  readonly _tag: \"Fail\"\n  readonly error: unknown\n}\n\n/**\n * Independent children, combined by name. Width is fixed here, at plan time:\n * there is no dynamic fan-out.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport interface All extends Scheduled {\n  readonly _tag: \"All\"\n  readonly nodes: Readonly<Record<string, NodeAst>>\n}\n\n/**\n * How a {@link Race} settles: `race` on the first member to settle, `any` on\n * the first member to succeed, and `quorum` once `count` members succeed.\n *\n * @since 1.0.0\n * @private\n */\nexport type RaceMode = \"race\" | \"any\" | \"quorum\"\n\n/**\n * Independent children that settle early: the join decides as soon as its\n * {@link RaceMode} can, and the members it did not wait for are interrupted.\n * `count` is the successes a quorum needs, and 1 for `race` and `any`.\n *\n * @since 1.0.0\n * @private\n */\nexport interface Race extends Scheduled {\n  readonly _tag: \"Race\"\n  readonly mode: RaceMode\n  readonly count: number\n  readonly nodes: Readonly<Record<string, NodeAst>>\n}\n\n/**\n * A deferred pure transformation of an upstream result. `map` transforms; it\n * never decides.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport interface Map extends Scheduled {\n  readonly _tag: \"Map\"\n  readonly first: NodeAst\n  readonly mapper: FunctionIdentity\n}\n\n/**\n * A continuation after an upstream node. `next` is present when the author\n * supplied a node directly instead of a builder, in which case the topology is\n * already known and nothing has to be evaluated to reveal it.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport interface AndThen extends Scheduled {\n  readonly _tag: \"AndThen\"\n  readonly first: NodeAst\n  readonly continuation: FunctionIdentity\n  readonly next?: NodeAst | undefined\n}\n\n/**\n * A decision whose arms are static topology. The predicate runs at run time on\n * the real value; both arms are already ASTs, so the exit condition and the\n * handoff site are visible before anything runs.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport interface Branch extends Scheduled {\n  readonly _tag: \"Branch\"\n  readonly subject: string\n  readonly first: NodeAst\n  readonly predicate: FunctionIdentity\n  readonly then: NodeAst\n  readonly else: NodeAst\n}\n\n/**\n * A protected graph and its statically planned typed-failure continuation.\n *\n * The symbolic error `subject` is minted per catch node rather than shared,\n * mirroring {@link Branch}. Failure arms are built before the graph assigns\n * ids, so a nested arm that captured an outer error would resolve it to the\n * inner catch's protected node under one shared token.\n *\n * An absent filter catches the entire typed error channel, while a present\n * schema catches only values it accepts. This mirrors Effect's typed-error\n * boundary and keeps defects outside normal recovery. The serializable AST carries the schema identity; the live schema\n * remains in a side table beside the AST.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport interface Catch extends Scheduled {\n  readonly _tag: \"Catch\"\n  readonly subject: string\n  readonly protected: NodeAst\n  readonly failure: NodeAst\n  readonly filter?: unknown | undefined\n  readonly filterIdentity?: FunctionIdentity | undefined\n}\n\n/**\n * How a flow call joins the caller's plan: `inline` splices the callee's body\n * in, `boundary` makes it one child execution, and `handoff` names the next\n * trampoline round. Why the child call is a mode rather than a second AST tag\n * is in `docs/concepts/authoring-ast.md`.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const CallMode = Schema.Literals([\"inline\", \"boundary\", \"handoff\"])\n\n/**\n * How a flow call joins the caller's plan.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport type CallMode = typeof CallMode.Type\n\n/**\n * A call to another flow. The AST keeps the callee's tag and the payload;\n * the declaration itself is in the side table, because a flow value carries\n * schemas and a body and is not JSON.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport interface FlowCall extends Scheduled {\n  readonly _tag: \"FlowCall\"\n  readonly flow: string\n  readonly mode: CallMode\n  readonly payload: unknown\n}\n\n/**\n * A call to an action: the atom that does work. Same split as\n * {@link FlowCall}, and no mode — an action is always one node.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport interface ActionCall extends Scheduled {\n  readonly _tag: \"ActionCall\"\n  readonly action: string\n  readonly payload: unknown\n}\n\n/**\n * The algorithms a {@link FunctionIdentity} may name. The tag is versioned so a\n * change to identity semantics re-keys everything derived from one, rather than\n * colliding with it.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const IdentityAlgorithm = Schema.Literals([\n  \"sha256-source-ephemeral/v4\",\n  \"sha256-source-captures/v5\",\n  \"static-node/v1\"\n])\n\n/**\n * The algorithms a {@link FunctionIdentity} may name.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport type IdentityAlgorithm = typeof IdentityAlgorithm.Type\n\n/**\n * The serializable stand-in for a function. Captured functions digest their\n * exact source and declared inert captures. Unannotated functions additionally\n * carry process-local, per-object entropy so indistinguishable closure sources\n * fail closed instead of sharing a cache key. The tag it names is\n * {@link IdentityAlgorithm}.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport interface FunctionIdentity {\n  readonly _tag: \"FunctionIdentity\"\n  readonly algorithm: IdentityAlgorithm\n  readonly digest: string\n}\n\n/**\n * Brands an operation with every inert value it closes over, so its identity\n * covers what it computes with and not only its source.\n *\n * `@smthrs/crypto` owns the captures, nested metadata, and freezing contract.\n *\n * @since 0.1.0\n * @private\n */\nexport const capture = Identity.capture\n\n/**\n * The serializable form of a planned value embedded in an AST value or\n * payload. The strict proxy itself cannot enter the AST because serializing it\n * is deliberately a build error.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport interface PlannedReference {\n  readonly _tag: \"PlannedReference\"\n  readonly node: string\n  readonly path: ReadonlyArray<string>\n}\n\n// A bundled runtime and a dynamically loaded flow may contain separate\n// compatible package copies. Share only live object metadata: JSON round trips\n// still lose executable bindings, and structural lookalikes remain inert.\nconst stateKey = Symbol.for(\"@smthrs/plan/Node/live/v1\")\ninterface LiveState {\n  readonly references: WeakSet<object>\n  readonly nodes: WeakSet<object>\n  readonly operations: WeakMap<AndThen | Map, Operation>\n  readonly predicates: WeakMap<Branch, Predicate>\n  readonly filters: WeakMap<Catch, Schema.Top>\n  readonly declarations: WeakMap<ActionCall | FlowCall, unknown>\n}\nconst globals = globalThis as typeof globalThis & { [stateKey]?: LiveState }\nconst liveState = globals[stateKey] ??= {\n  references: new WeakSet(),\n  nodes: new WeakSet(),\n  operations: new WeakMap(),\n  predicates: new WeakMap(),\n  filters: new WeakMap(),\n  declarations: new WeakMap()\n}\n\n/** The AST references minted by this module; structural lookalikes are data. */\nconst plannedReferences = liveState.references\n\nconst makePlannedReference = (reference: Planned.Reference): PlannedReference => {\n  const value = Object.freeze({\n    _tag: \"PlannedReference\" as const,\n    node: reference.node,\n    path: Object.freeze([...reference.path])\n  })\n  plannedReferences.add(value)\n  return value\n}\n\n/**\n * Reads an AST-owned planned reference without trusting its public data shape.\n *\n * @since 1.0.0\n * @private\n */\nexport const plannedReference = (value: unknown): PlannedReference | undefined =>\n  typeof value === \"object\" && value !== null && plannedReferences.has(value)\n    ? value as PlannedReference\n    : undefined\n\n/**\n * Every AST variant.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport type NodeAst = Succeed | Fail | All | Race | Map | AndThen | Branch | Catch | FlowCall | ActionCall\n\ntype Operation = (value: unknown) => unknown\n\ntype Predicate = (value: unknown) => boolean\n\nconst operations = liveState.operations\nconst predicates = liveState.predicates\nconst filters = liveState.filters\nconst declarations = liveState.declarations\n\n/**\n * The JSON mirror of an AST payload. A planned value becomes an AST-owned\n * {@link PlannedReference}, so the AST stays inert JSON.\n *\n * @private\n */\nconst payloadMirror = (input: unknown): unknown =>\n  jsonMirror(input, (_value, reference) => makePlannedReference(reference))\n\n/**\n * Digests a function's exact source as UTF-8 with SHA-256. Exact source matters:\n * whitespace inside a string literal is behavior, and normalizing it before\n * hashing can make different functions share an identity. Unless its inert\n * captures were declared with {@link capture}, the digest also includes\n * process-local, per-function entropy: JavaScript cannot inspect a closure, so\n * source-only identity would permit incorrect cache hits.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const functionIdentity: (operation: unknown) => FunctionIdentity = Identity.functionIdentity\n\n/**\n * The prototype every node shares, so `pipe` is one function rather than one\n * closure per node.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const NodeProto = {\n  [TypeId]: {\n    _A: identity,\n    _E: identity,\n    _R: identity\n  },\n  pipe() {\n    // eslint-disable-next-line prefer-rest-params -- `pipeArguments` takes the arguments object itself.\n    return pipeArguments(this, arguments)\n  }\n}\n\n/**\n * Every node {@link makeNode} built, so a node this module made is recognized\n * in constant time without walking its AST again.\n */\nconst liveNodes = liveState.nodes\n\n/** Recognizes the algorithms {@link IdentityAlgorithm} declares, and nothing else. */\nconst isIdentityAlgorithm = Schema.is(IdentityAlgorithm)\n\n/** Recognizes the modes {@link CallMode} declares, and nothing else. */\nconst isCallMode = Schema.is(CallMode)\n\n/** Recognizes the modes {@link RaceMode} names, and nothing else. @private */\nconst isRaceMode = (value: unknown): value is RaceMode => value === \"race\" || value === \"any\" || value === \"quorum\"\n\n/**\n * Whether `count` is a successes target a {@link Race} of `members` can reach:\n * a quorum needs between one and every member, and the other modes need one.\n *\n * @since 1.0.0\n * @private\n */\nexport const isRaceCount = (mode: RaceMode, count: unknown, members: number): boolean =>\n  members > 0 && Number.isSafeInteger(count) &&\n  (mode === \"quorum\" ? (count as number) >= 1 && (count as number) <= members : count === 1)\n\n/** @private */\nconst isFunctionIdentity = (value: unknown): value is FunctionIdentity =>\n  isRecord(value) && value._tag === \"FunctionIdentity\" && isIdentityAlgorithm(value.algorithm) &&\n  typeof value.digest === \"string\"\n\n/** One position of the {@link isNodeAst} walk: an AST to check, or one whose children are all checked. @private */\ntype AstVisit = { readonly enter: unknown } | { readonly exit: object }\n\n/**\n * Checks whether a value has the shape of a {@link NodeAst}: what a JSON round\n * trip of a genuine AST produces, and nothing looser. Every variant's own\n * fields are checked, and every child is walked. The walk is an explicit stack\n * rather than recursion, so an arbitrarily deep AST cannot overflow the native\n * stack, and it tracks the ancestors of the position it has reached, so a\n * cyclic object is refused rather than walked forever while a shared sub-AST\n * still passes.\n *\n * @since 1.0.0\n * @private\n */\nexport const isNodeAst = (value: unknown): value is NodeAst => {\n  const ancestors = new Set<object>()\n  const pending: Array<AstVisit> = [{ enter: value }]\n  while (pending.length > 0) {\n    const visit = pending.pop()!\n    if (\"exit\" in visit) {\n      ancestors.delete(visit.exit)\n      continue\n    }\n    const ast = visit.enter\n    if (!isRecord(ast) || ancestors.has(ast)) return false\n    if (ast.priority !== undefined && !Number.isSafeInteger(ast.priority)) return false\n    const children: Array<unknown> = []\n    switch (ast._tag) {\n      case \"Succeed\":\n      case \"Fail\":\n        break\n      case \"All\": {\n        if (!isRecord(ast.nodes) || Array.isArray(ast.nodes)) return false\n        for (const child of Object.values(ast.nodes)) children.push(child)\n        break\n      }\n      case \"Race\": {\n        if (!isRecord(ast.nodes) || Array.isArray(ast.nodes)) return false\n        const members = Object.values(ast.nodes)\n        if (!isRaceMode(ast.mode) || !isRaceCount(ast.mode, ast.count, members.length)) return false\n        for (const child of members) children.push(child)\n        break\n      }\n      case \"Map\": {\n        if (!isFunctionIdentity(ast.mapper)) return false\n        children.push(ast.first)\n        break\n      }\n      case \"AndThen\": {\n        if (!isFunctionIdentity(ast.continuation)) return false\n        children.push(ast.first)\n        if (ast.next !== undefined) children.push(ast.next)\n        break\n      }\n      case \"Branch\": {\n        if (typeof ast.subject !== \"string\" || !isFunctionIdentity(ast.predicate)) return false\n        children.push(ast.first, ast.then, ast.else)\n        break\n      }\n      case \"Catch\": {\n        if (typeof ast.subject !== \"string\") return false\n        if (ast.filterIdentity !== undefined && !isFunctionIdentity(ast.filterIdentity)) return false\n        children.push(ast.protected, ast.failure)\n        break\n      }\n      case \"FlowCall\": {\n        if (typeof ast.flow !== \"string\" || !isCallMode(ast.mode)) return false\n        break\n      }\n      case \"ActionCall\": {\n        if (typeof ast.action !== \"string\") return false\n        break\n      }\n      default:\n        return false\n    }\n    if (children.length > 0) {\n      ancestors.add(ast)\n      pending.push({ exit: ast })\n      for (const child of children) pending.push({ enter: child })\n    }\n  }\n  return true\n}\n\n/**\n * Checks whether a value is a node.\n *\n * A node this module built is recognized by registration. A node that crossed\n * a serialization boundary, an object whose prototype is {@link NodeProto} and\n * whose own `ast` data property passes {@link isNodeAst}, is recognized by that\n * shape: `@smthrs/flow` hands a rehydrated AST back as a node, and the side\n * tables are all a round trip loses. The {@link TypeId} marker is an exported\n * string any object can carry, so it counts for nothing on its own, and an\n * `ast` that is missing, malformed, cyclic, or an accessor is refused because\n * every combinator reads it as trusted topology. A proxy is judged by the\n * shape it forwards.\n *\n * @since 1.0.0\n * @private\n */\nexport const isNode = (value: unknown): value is Node<unknown, unknown, any> => {\n  if (typeof value !== \"object\" || value === null) return false\n  if (liveNodes.has(value)) return true\n  if (Object.getPrototypeOf(value) !== NodeProto) return false\n  const ast = Object.getOwnPropertyDescriptor(value, \"ast\")\n  return ast !== undefined && \"value\" in ast && isNodeAst(ast.value)\n}\n\n/**\n * Wraps an AST as a node.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const makeNode = <A = unknown, E = never, R = never>(ast: NodeAst): Node<A, E, R> => {\n  const node: Node<A, E, R> = Object.assign(Object.create(NodeProto), { ast })\n  liveNodes.add(node)\n  return node\n}\n\n/**\n * Constructs a {@link Succeed}.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const succeed = (input: unknown): Succeed => ({ _tag: \"Succeed\", value: payloadMirror(input) })\n\n/**\n * Constructs a {@link Fail}.\n *\n * @since 1.0.0\n * @private\n * @slop\n */\nexport const fail = (error: unknown): Fail => ({ _tag: \"Fail\", error: payloadMirror(error) })\n\n/**\n * Constructs an {@link All}.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const all = (nodes: Readonly<Record<string, NodeAst>>): All => ({ _tag: \"All\", nodes })\n\n/**\n * Constructs a {@link Race}.\n *\n * @since 1.0.0\n * @private\n */\nexport const race = (mode: RaceMode, count: number, nodes: Readonly<Record<string, NodeAst>>): Race => ({\n  _tag: \"Race\",\n  mode,\n  count,\n  nodes\n})\n\n/**\n * Constructs a {@link Map}, filing the mapper under the AST it belongs to.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const map = (first: NodeAst, operation: Operation, source: unknown): Map => {\n  const ast: Map = { _tag: \"Map\", first, mapper: functionIdentity(source) }\n  operations.set(ast, operation)\n  return ast\n}\n\n/**\n * Constructs an {@link AndThen} from a builder. The builder is evaluated once\n * against a planned value when the graph is built, never here.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const andThen = (first: NodeAst, operation: Operation, source: unknown): AndThen => {\n  const ast: AndThen = { _tag: \"AndThen\", first, continuation: functionIdentity(source) }\n  operations.set(ast, operation)\n  return ast\n}\n\n/**\n * Constructs an {@link AndThen} from a node the author supplied directly. There\n * is no function to digest, so the continuation carries a fixed marker.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const andThenNode = (first: NodeAst, next: NodeAst): AndThen => ({\n  _tag: \"AndThen\",\n  first,\n  continuation: { _tag: \"FunctionIdentity\", algorithm: \"static-node/v1\", digest: digestSync(\"static-node\") },\n  next\n})\n\n/**\n * Constructs a {@link Branch}. Both arms arrive already evaluated, because a\n * branch that had to be run to reveal its topology would not be a plan.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const branch = (\n  subject: string,\n  first: NodeAst,\n  predicate: Predicate,\n  source: unknown,\n  then: NodeAst,\n  otherwise: NodeAst\n): Branch => {\n  const ast: Branch = {\n    _tag: \"Branch\",\n    subject,\n    first,\n    predicate: functionIdentity(source),\n    then,\n    else: otherwise\n  }\n  predicates.set(ast, predicate)\n  return ast\n}\n\n/**\n * JSON Schema does not describe arbitrary checks, declaration parsers, or\n * suspended schema factories. Include every function reachable from the\n * schema AST, preserving declared captures and treating opaque wrappers as\n * ephemeral. The iterative walk also covers nested checks and cyclic ASTs.\n *\n * @private\n */\nconst filterIdentity = (filter: Schema.Top): FunctionIdentity => {\n  const identities: Array<readonly [string, FunctionIdentity]> = []\n  const pending: Array<readonly [string, unknown]> = [[\"$\", filter.ast]]\n  const seen = new WeakSet<object>()\n  while (pending.length > 0) {\n    const [path, current] = pending.pop()!\n    if (typeof current === \"function\") {\n      identities.push([path, functionIdentity(current)])\n    } else if (typeof current === \"object\" && current !== null && !seen.has(current)) {\n      seen.add(current)\n      const descriptors = Object.getOwnPropertyDescriptors(current)\n      for (const key of Object.keys(descriptors).sort()) {\n        const descriptor = descriptors[key]!\n        if (\"value\" in descriptor) pending.push([`${path}/${JSON.stringify(key)}`, descriptor.value])\n        else {\n          if (descriptor.get !== undefined) pending.push([`${path}/${JSON.stringify(key)}/get`, descriptor.get])\n          if (descriptor.set !== undefined) pending.push([`${path}/${JSON.stringify(key)}/set`, descriptor.set])\n        }\n      }\n    }\n  }\n  return {\n    _tag: \"FunctionIdentity\",\n    algorithm: identities.some(([, identity]) => identity.algorithm === \"sha256-source-ephemeral/v4\")\n      ? \"sha256-source-ephemeral/v4\"\n      : \"sha256-source-captures/v5\",\n    digest: digestSync(JSON.stringify(identities))\n  }\n}\n\n/**\n * Constructs a {@link Catch} whose failure topology is already evaluated.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const catch_ = (subject: string, protectedAst: NodeAst, failure: NodeAst, filter?: Schema.Top): Catch => {\n  const ast: Catch = {\n    _tag: \"Catch\",\n    subject,\n    protected: protectedAst,\n    failure,\n    ...(filter === undefined\n      ? {}\n      : {\n        filter: Schema.toJsonSchemaDocument(filter, { onExcessProperty: \"error\" }),\n        filterIdentity: filterIdentity(filter)\n      })\n  }\n  if (filter !== undefined) filters.set(ast, filter)\n  return ast\n}\n\n/**\n * Constructs a {@link FlowCall}, filing the flow declaration beside it.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const flowCall = (declaration: unknown, flow: string, mode: CallMode, payload: unknown): FlowCall => {\n  const ast: FlowCall = { _tag: \"FlowCall\", flow, mode, payload: payloadMirror(payload) }\n  declarations.set(ast, declaration)\n  return ast\n}\n\n/**\n * Constructs an {@link ActionCall}, filing the action declaration beside\n * it.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const actionCall = (declaration: unknown, action: string, payload: unknown): ActionCall => {\n  const ast: ActionCall = { _tag: \"ActionCall\", action, payload: payloadMirror(payload) }\n  declarations.set(ast, declaration)\n  return ast\n}\n\n/**\n * The deferred function of a map or a continuation.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const operation = (ast: AndThen | Map): Operation | undefined => operations.get(ast)\n\n/**\n * The run-time predicate of a branch.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const predicate = (ast: Branch): Predicate | undefined => predicates.get(ast)\n\n/**\n * The optional error schema filter of a catch node.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const filter = (ast: Catch): Schema.Top | undefined => filters.get(ast)\n\n/**\n * The flow or action declaration a call node names.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const declaration = (ast: ActionCall | FlowCall): unknown => declarations.get(ast)\n\n/**\n * Copies an AST with a scheduling priority attached.\n *\n * The copy is shallow and the side tables are re-filed against it, because a\n * function, a predicate, a filter schema, and a declaration are keyed by the\n * exact AST object they belong to: a copy that left them behind would silently\n * lose the continuation the graph walk has to evaluate.\n *\n * @since 0.1.0\n * @private\n * @slop\n */\nexport const withPriority = (ast: NodeAst, priority: number): NodeAst => {\n  const prioritized = { ...ast, priority }\n  if (ast._tag === \"AndThen\" || ast._tag === \"Map\") {\n    const deferred = operations.get(ast)\n    if (deferred !== undefined) operations.set(prioritized as AndThen | Map, deferred)\n  }\n  if (ast._tag === \"Branch\") {\n    const decision = predicates.get(ast)\n    if (decision !== undefined) predicates.set(prioritized as Branch, decision)\n  }\n  if (ast._tag === \"Catch\") {\n    const schema = filters.get(ast)\n    if (schema !== undefined) filters.set(prioritized as Catch, schema)\n  }\n  if (ast._tag === \"ActionCall\" || ast._tag === \"FlowCall\") {\n    const target = declarations.get(ast)\n    if (target !== undefined) declarations.set(prioritized as ActionCall | FlowCall, target)\n  }\n  return prioritized\n}\n"]}