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

package/dist/esm/Node.d.ts.map

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

package/dist/esm/Node.js

@@ -0,0 +1,591 @@
+/**
+ * Pure, pipeable nodes: the shape a flow body describes and nothing more.
+ *
+ * Building a node records an inspectable AST and executes nothing — the same
+ * split as Bazel's `ctx.actions.run`, which declares an action rather than
+ * running one. A plan is
+ * always a DAG, so there is no loop node here and never will be: repetition
+ * lives one level up, in what a flow settles with.
+ *
+ * A node also carries Effect's requirement channel, `R`, and carries it as a
+ * PHANTOM: building a plan demands nothing, and every combinator here unions
+ * `R` without ever reading it. What fills the channel is a call to something
+ * whose code lives elsewhere — an action — so the type of a plan states which
+ * implementations executing it will need, and the place that executes it is
+ * where the compiler asks for them.
+ *
+ * Control flow is structure. {@link branch} takes both arms and evaluates each
+ * ONCE, symbolically, so the exit condition and the handoff site are visible
+ * topology before anything runs; its predicate is digested and runs later on
+ * the real value. {@link map} is transformation only. The rule the authoring
+ * note states, and this module encodes: **map transforms; branch decides.**
+ *
+ * Adapted from `@smthrs/core` (`packages/smithers/flows/core`) `Node.ts`.
+ * `Dynamic` is gone — a model call is an ordinary action, and nothing
+ * model-shaped belongs in this package — and node annotations are gone with
+ * it, because the AST has to stay JSON serializable.
+ *
+ * @since 0.1.0
+ */
+import { dual } from "effect/Function";
+import { GraphBuildError } from "./GraphBuildError.js";
+import * as internal from "./internal/node.js";
+import * as internalSchemaIdentity from "./internal/SchemaIdentity.js";
+import * as Planned from "./Planned.js";
+/**
+ * The runtime type identifier carried by every node.
+ *
+ * @since 0.1.0
+ * @category type ids
+ * @slop
+ */
+export const TypeId = internal.TypeId;
+/**
+ * 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.
+ *
+ * This is the ONE call-mode vocabulary. {@link flowCall} takes it and
+ * `@smthrs/flow`'s graph builder switches on it, so a second spelling in
+ * either package would fork the moment one gained a mode.
+ *
+ * @since 0.1.0
+ * @category models
+ * @slop
+ */
+export const CallMode = internal.CallMode;
+/**
+ * Reads the inert AST reference created for a planned value.
+ *
+ * Structural lookalikes remain ordinary payload data. This accessor is the
+ * only recognition path because the marker itself is deliberately private to
+ * the AST cloner.
+ *
+ * @since 1.0.0
+ * @category accessors
+ */
+export const plannedReference = internal.plannedReference;
+/**
+ * The node reference a branch arm's symbolic subject carries. Arms are built
+ * before the graph assigns ids, so every reference an arm records names this
+ * placeholder, and graph building rewrites it to the branch's own upstream
+ * node — which is `first`, structurally, and therefore not a guess.
+ *
+ * @since 0.1.0
+ * @category constants
+ * @slop
+ */
+export const branchSubject = "branch/subject";
+/** @private */
+const subjectsKey = Symbol.for("@smthrs/plan/Node/subjects/v1");
+const globals = globalThis;
+const subjects = globals[subjectsKey] ??= { branch: 0, catch: 0 };
+/**
+ * The prefix of the node reference a catch failure arm's symbolic error
+ * carries. Each {@link catch_} mints its own token under this prefix, so an
+ * outer error captured inside a nested failure arm keeps naming the outer
+ * catch, and graph building rewrites each token to the node that catch
+ * protects.
+ *
+ * @since 0.1.0
+ * @category constants
+ * @slop
+ */
+export const catchSubject = "catch/subject";
+/**
+ * Checks whether a value is a node.
+ *
+ * A node this package built is recognized by registration at construction. A
+ * node that crossed a serialization boundary, an object sharing the node
+ * prototype whose own `ast` is a well-formed AST, is recognized by that shape,
+ * because `@smthrs/flow` hands a rehydrated AST back as a node and its side
+ * tables are all a round trip loses. The {@link TypeId} marker is a public
+ * string any object can carry, so it counts for nothing on its own: every
+ * combinator that admits a node reads its `ast` as trusted topology, and an
+ * object carrying the marker on any other prototype, one inheriting it from a
+ * node, and one whose `ast` is missing, malformed, cyclic, or an accessor are
+ * all refused with the same `GraphBuildError` as any other non-node. A proxy
+ * is judged by the shape it forwards: one that forwards a node unchanged
+ * passes, and one that diverges from it does not.
+ *
+ * @since 0.1.0
+ * @category guards
+ * @slop
+ */
+export const isNode = (value) => internal.isNode(value);
+/**
+ * A node that succeeds with the constant's inert JSON projection.
+ *
+ * Dates produce strings (or null for invalid dates), URLs produce strings,
+ * and callable object members are omitted. Use {@link map} to reconstruct a
+ * domain value explicitly after this serialization boundary.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export const succeed = (value) => internal.makeNode(internal.succeed(value));
+/**
+ * A node that fails with the constant's inert JSON projection, in the typed
+ * error channel.
+ *
+ * It is how a plan states a refusal it already knows about — an unsupported
+ * input, an exhausted budget, a compensation that has nothing left to undo —
+ * without an action that exists only to fail. {@link catch} recovers it exactly
+ * as it recovers an action's failure, and an uncaught one is the flow's typed
+ * failure.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export const fail = (error) => internal.makeNode(internal.fail(error));
+/**
+ * Combines independent children into one node, keyed by name.
+ *
+ * Width is fixed here, at plan time. Fanning out over something a step
+ * discovered is not this: end the round and carry the list in the next flow's
+ * payload, where it is real data.
+ *
+ * @since 0.1.0
+ * @category constructors
+ * @slop
+ */
+export const all = (nodes) => internal.makeNode(internal.all(memberAsts(nodes, "all", "invalid_all_member")));
+/**
+ * The member ASTs of a combination, keyed by name, refusing a non-node member.
+ *
+ * @private
+ */
+const memberAsts = (nodes, combinator, code) => {
+    const asts = Object.create(null);
+    for (const [member, node] of Object.entries(nodes)) {
+        if (!isNode(node)) {
+            throw new GraphBuildError({
+                code,
+                node: member,
+                path: [],
+                message: `Node.${combinator} expected a Node at member "${member}"`
+            });
+        }
+        Object.defineProperty(asts, member, {
+            configurable: true,
+            enumerable: true,
+            value: node.ast,
+            writable: true
+        });
+    }
+    return asts;
+};
+/**
+ * Builds a join that settles early, refusing a member set it could never
+ * decide on.
+ *
+ * @private
+ */
+const join = (mode, count, nodes) => {
+    const asts = memberAsts(nodes, mode, "invalid_join");
+    const width = Object.keys(asts).length;
+    if (!internal.isRaceCount(mode, count, width)) {
+        throw new GraphBuildError({
+            code: "invalid_join",
+            node: mode,
+            path: [],
+            message: mode === "quorum"
+                ? `Node.quorum needs a whole number of successes between 1 and its ${width} members, got ${String(count)}`
+                : `Node.${mode} needs at least one member`
+        });
+    }
+    return internal.race(mode, count, asts);
+};
+/**
+ * Settles with the first member to settle, success or typed failure.
+ *
+ * The other members are interrupted. The winner is journaled, so a resumed run
+ * settles the same member and never starts the others again.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export const race = (nodes) => internal.makeNode(join("race", 1, nodes));
+/**
+ * Settles with the first member to succeed, ignoring typed failures while a
+ * member is still running.
+ *
+ * It fails with the last failure when every member fails. The other members
+ * are interrupted, and the winner is journaled as {@link race} journals it.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export const any = (nodes) => internal.makeNode(join("any", 1, nodes));
+/**
+ * Succeeds once `count` members succeed, with exactly those members' values
+ * keyed by name.
+ *
+ * It fails with the failure that leaves fewer than `count` members able to
+ * succeed. Either way the members still running are interrupted, and the
+ * members that decided are journaled as {@link race} journals its winner.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export const quorum = (count, nodes) => internal.makeNode(join("quorum", count, nodes));
+/**
+ * Transforms an eventual success value with a deferred pure function.
+ *
+ * The function is digested, not run: it executes later, on the real value.
+ * This is where computation on a step result belongs — and only computation. A
+ * `map` that decides what happens next is a `branch` written wrongly.
+ *
+ * @since 0.1.0
+ * @category mapping
+ * @slop
+ */
+export const map = dual(2, (self, f) => internal.makeNode(internal.map(self.ast, (value) => f(value), f)));
+/**
+ * Starts the entire next subtree only after this node succeeds, without
+ * consuming its result. Failure or interruption prevents that subtree from
+ * starting, including actions nested inside combinations or inline flows.
+ *
+ * Use {@link bindPlanned} to build a dependency from a symbolic result, or
+ * {@link map} to compute on the eventual value.
+ *
+ * @since 0.1.0
+ * @category sequencing
+ * @slop
+ */
+export const andThen = dual(2, (self, next) => {
+    if (!isNode(next)) {
+        throw new GraphBuildError({
+            code: "invalid_continuation",
+            node: "andThen/next",
+            path: [],
+            message: "Node.andThen expects a Node; use Node.bindPlanned for a symbolic builder or Node.map for value computation"
+        });
+    }
+    return internal.makeNode(internal.andThenNode(self.ast, next.ast));
+});
+/**
+ * Builds a dependency using a symbolic reference to this node's future result.
+ *
+ * The builder runs during planning. Its argument is a {@link module:Planned.Planned}
+ * reference, not the value the node will eventually produce. Pass references
+ * into action payloads; use {@link branch} for decisions and {@link map} for
+ * computation on real results. JavaScript truthiness and reference equality
+ * cannot inspect a planned result. Enable type-aware ESLint's
+ * `@typescript-eslint/strict-boolean-expressions` to reject planned conditions.
+ * Independent descendants of the built subtree can start while this producer
+ * is running; consumers of its reference wait for its value. Use
+ * {@link andThen} when the whole next subtree must wait for success.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export const bindPlanned = dual(2, (self, build) => internal.makeNode(internal.andThen(self.ast, (value) => build(value), build)));
+/**
+ * Maximum eagerly nested branch arms. Arm construction precedes graph walking;
+ * this bound leaves native stack headroom for a typed refusal.
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export const maximumArmDepth = 512;
+let armDepth = 0;
+/**
+ * Builds one arm, once, against the symbolic subject.
+ *
+ * @private
+ */
+const arm = (build, subject, side) => {
+    if (armDepth >= maximumArmDepth) {
+        throw new GraphBuildError({
+            code: "graph_too_deep",
+            node: `${branchSubject}/${side}`,
+            path: [],
+            message: "Node.branch recursion needs a plan-time bound, such as a payload-derived round count. " +
+                "Both arms are built before the run-time predicate is evaluated."
+        });
+    }
+    armDepth++;
+    try {
+        const node = build(subject);
+        if (!isNode(node)) {
+            throw new GraphBuildError({
+                code: "invalid_continuation",
+                node: `${branchSubject}/${side}`,
+                path: [],
+                message: `Node.branch expected its "${side}" arm to return a Node`
+            });
+        }
+        return node.ast;
+    }
+    finally {
+        armDepth--;
+    }
+};
+/**
+ * Decides between two arms, both of them static topology.
+ *
+ * Each arm builder is evaluated exactly once, here, against a
+ * {@link module:Planned.Planned} placeholder, and the resulting ASTs are what
+ * the node stores — so a plan shows the exit condition and both continuations
+ * before it runs. The predicate is digested and evaluated at run time on the
+ * real value, which is why none of the plan-time placeholder machinery leaks
+ * into control flow.
+ *
+ * Both arms contribute their requirements, because both arms are topology the
+ * plan carries. A run takes one of them, but which one is not known until the
+ * predicate sees the real value, so an execution has to be able to take either.
+ *
+ * @since 0.1.0
+ * @category sequencing
+ * @slop
+ */
+export const branch = dual(2, (self, options) => {
+    const predicate = options.if;
+    const subjectToken = `${branchSubject}/${subjects.branch++}`;
+    const subject = Planned.make(subjectToken);
+    return internal.makeNode(internal.branch(subjectToken, self.ast, (value) => predicate(value), predicate, arm(options.then, subject, "then"), arm(options.else, subject, "else")));
+});
+/**
+ * Recovers from matching typed failures with static failure topology.
+ *
+ * The protected graph and failure arm are both stored in the AST. The arm is
+ * built once at plan time against a strict planned error placeholder. With no
+ * schema the whole typed error channel is handled. A schema handles only the
+ * values it accepts, so its overloads retain E: a refinement can reject values
+ * without narrowing its TypeScript type. Runtime schema callbacks enter the
+ * filter identity along with its JSON Schema. Uncaptured callbacks are local
+ * to this process, just like uncaptured mappers.
+ *
+ * The failure arm contributes its requirements to the node's, for the same
+ * reason a branch's arms do: it is topology the plan carries, and a run reaches
+ * it whenever the protected graph fails.
+ *
+ * @since 0.1.0
+ * @category sequencing
+ * @slop
+ */
+const catch_ = dual(2, (self, options) => {
+    const subjectToken = `${catchSubject}/${subjects.catch++}`;
+    const failure = options.onFailure(Planned.make(subjectToken));
+    if (!isNode(failure)) {
+        throw new GraphBuildError({
+            code: "invalid_continuation",
+            node: catchSubject,
+            path: [],
+            message: "Node.catch expected its failure arm to return a Node"
+        });
+    }
+    return internal.makeNode(internal.catch_(subjectToken, self.ast, failure.ast, options.error));
+});
+export { catch_ as catch };
+/**
+ * Attaches a scheduling priority to a node, leaving the original unchanged.
+ *
+ * The scheduler runs ready work with a higher number first, so a priority
+ * changes LATENCY and nothing else. It never enters key material: a node
+ * ordered ahead of another still computes the same result, so re-keying it
+ * would throw away a legitimate cache hit. Children inherit the value
+ * lexically when the graph is built, and a child that states its own keeps it.
+ *
+ * @since 0.1.0
+ * @category annotations
+ * @slop
+ */
+export const priority = dual(2, (self, value) => {
+    if (!Number.isSafeInteger(value)) {
+        throw new GraphBuildError({
+            code: "invalid_priority",
+            node: self.ast._tag,
+            path: [],
+            message: `Node.priority expects a safe integer, received ${value}`
+        });
+    }
+    return internal.makeNode(internal.withPriority(self.ast, value));
+});
+/**
+ * Reads the scheduling priority a node carries, or `undefined` when it states
+ * none and inherits from whatever encloses it.
+ *
+ * @since 0.1.0
+ * @category accessors
+ * @slop
+ */
+export const declaredPriority = (ast) => ast.priority;
+/**
+ * Constructs the flow-call node used by `@smthrs/flow` without making flow
+ * calls part of the public authoring surface of this package.
+ *
+ * Reserved for `@smthrs/flow`, which owns flow authoring. It is not part
+ * of this package's authoring surface, and it validates nothing: an unknown
+ * flow tag becomes a call node the graph keeps as a leaf.
+ *
+ * @since 0.1.0
+ * @category engine
+ * @slop
+ */
+export const flowCall = (declaration, flow, mode, payload) => internal.makeNode(internal.flowCall(declaration, flow, mode, payload));
+/**
+ * Constructs the action-call node used by `@smthrs/flow` without making
+ * action calls part of the public authoring surface of this package.
+ *
+ * Reserved for `@smthrs/flow`, which owns action authoring. It is not part
+ * of this package's authoring surface, and an unknown action tag becomes a
+ * call node the graph keeps as a leaf.
+ *
+ * @since 0.1.0
+ * @category engine
+ * @slop
+ */
+export const actionCall = (declaration, action, payload) => internal.makeNode(internal.actionCall(declaration, action, payload));
+/**
+ * Reads the flow or action declaration a call node names, so `@smthrs/flow`
+ * can expand a call it recorded. It is `undefined` for an AST that was
+ * rehydrated from JSON, because the declaration lives beside the AST rather
+ * than inside it — a graph built from such an AST keeps the call as a leaf.
+ *
+ * Reserved for `@smthrs/flow`, which files the declaration when it builds
+ * the call. Authors never call it.
+ *
+ * @since 0.1.0
+ * @category engine
+ * @slop
+ */
+export const declaration = (ast) => internal.declaration(ast);
+/**
+ * Reads the continuation builder of a sequenced node, which graph building
+ * evaluates once against a placeholder. It is `undefined` when the author
+ * supplied a node directly — the topology is already in `next` — and for a
+ * rehydrated AST, whose side table did not survive serialization.
+ *
+ * Reserved for `@smthrs/flow`'s graph walk. Authors never call it.
+ *
+ * @since 0.1.0
+ * @category engine
+ * @slop
+ */
+export const continuation = (ast) => internal.operation(ast);
+/**
+ * Reads the deferred mapper of a {@link map} node, which a driver applies to
+ * the real upstream value once it has one. It is `undefined` for every other
+ * variant, and for a rehydrated AST whose side table did not survive
+ * serialization.
+ *
+ * Reserved for `@smthrs/flow`'s interpreter. Authors never call it.
+ *
+ * @since 0.1.0
+ * @category engine
+ * @slop
+ */
+export const mapper = (ast) => ast._tag === "Map" ? internal.operation(ast) : undefined;
+/**
+ * Reads the run-time predicate of a {@link branch} node, which a driver
+ * evaluates on the real subject value to choose an arm. It is `undefined` for
+ * every other variant, and for a rehydrated AST whose side table did not
+ * survive serialization.
+ *
+ * Reserved for `@smthrs/flow`'s interpreter. Authors never call it.
+ *
+ * @since 0.1.0
+ * @category engine
+ * @slop
+ */
+export const predicate = (ast) => ast._tag === "Branch" ? internal.predicate(ast) : undefined;
+/**
+ * Reads the optional schema selecting failures handled by a {@link catch_}.
+ *
+ * Reserved for `@smthrs/flow`'s interpreter. It is `undefined` for every
+ * variant but `catch_`, and for a rehydrated AST whose side table did not
+ * survive serialization.
+ *
+ * @since 0.1.0
+ * @category engine
+ * @slop
+ */
+export const catchFilter = (ast) => ast._tag === "Catch" ? internal.filter(ast) : undefined;
+/**
+ * Identifies a plan-time function the AST does NOT store, a flow's `body`,
+ * exactly as the AST identifies the mapper and continuation it does store.
+ * A call that keeps its callee as a leaf still has to re-key when that
+ * callee's body is edited, and this is the identity it folds in. Unannotated
+ * functions fail closed with process-local identity; use {@link capture} to
+ * declare inert captures and obtain deterministic identity.
+ *
+ * Reserved for `@smthrs/flow`, which folds a callee body's identity into a
+ * call it keeps as a leaf. Authors never call it; it throws a `TypeError`
+ * when handed anything but a function.
+ *
+ * @since 0.1.0
+ * @category engine
+ * @slop
+ */
+export const functionIdentity = (operation) => internal.functionIdentity(operation);
+/**
+ * The refusal `schemaIdentity` and `representationIdentity` raise for a schema
+ * a step key cannot be derived from. Its message is the one
+ * `effect@4.0.0-rc.115` gave for the same schema, where it gave one.
+ *
+ * @since 1.0.0
+ * @category errors
+ */
+export const SchemaIdentityError = internalSchemaIdentity.SchemaIdentityError;
+/**
+ * Identifies a schema by the constraints it documents, so a call re-keys when
+ * what its callee accepts or produces changes, and a catch re-keys when its
+ * filter does.
+ *
+ * The document is what `Schema.toJsonSchemaDocument(schema, options)`
+ * returned under `effect@4.0.0-rc.115`. It is printed by this package, not by
+ * the installed `effect`, because a later release prints a different document
+ * for the same schema and a moved identity re-keys every recorded step. Use
+ * it wherever the document is hashed, compared or pinned; a JSON Schema shown
+ * to a model or a person comes from `Schema.toJsonSchemaDocument`.
+ *
+ * Reserved for the packages that derive identities. Authors never call it; it
+ * throws for a schema that has no JSON Schema form.
+ *
+ * @since 1.0.0
+ * @category engine
+ */
+export const schemaIdentity = (schema, options) => internalSchemaIdentity.schemaIdentity(schema, options);
+/**
+ * Identifies a schema AST by its encoded representation, the material a
+ * sealed action's step key folds in for its success and error schemas.
+ *
+ * The value is what `SchemaRepresentation.toJson(SchemaRepresentation.toRepresentation(ast))`
+ * returned under `effect@4.0.0-rc.115`, so a later `effect` release does not
+ * re-key recorded steps. The one exception is `Schema.brand`: from
+ * `effect@4.0.4` on a brand is not part of the AST, so a declaration with a
+ * brand re-keys once.
+ *
+ * Reserved for the packages that derive step keys. Authors never call it; it
+ * throws for an AST that has no representation.
+ *
+ * @since 1.0.0
+ * @category engine
+ */
+export const representationIdentity = (ast) => internalSchemaIdentity.representationIdentity(ast);
+/**
+ * Binds a frozen plain copy of inert captures as the callback's this receiver.
+ *
+ * Use a function expression to read the snapshot while keeping the ordinary
+ * callback arguments: Node.capture({ factor: 3 }, function(value: number) {
+ *   return value * this.factor
+ * }). Caller objects remain unchanged; lexical aliases still name originals
+ * and must not be used as mutable semantic inputs. Nested captures retain the
+ * inner callback's snapshot and compose the two identities.
+ *
+ * Admission walks original descriptors once, rejects built-in brands and
+ * non-plain prototypes without evaluating getters, then uses structuredClone
+ * to refuse Proxies. Hosts without that API refuse object capture. Only the
+ * owned frozen copy enters identity and the wrapper. Sealed, non-extensible,
+ * frozen and Immer ordinary data are supported equally. Unsupported values
+ * raise a TypeError naming the path. See core docs/api.md#nodecapture for the
+ * complete algorithm and the migration from original-object locking.
+ *
+ * @category constructors
+ * @since 0.1.0
+ * @slop
+ */
+export const capture = (captures, operation) => internal.capture(captures, operation);
+//# sourceMappingURL=Node.js.map