@smthrs/plan 1.0.0-rc.5 → 1.0.0-rc.6

package/CHANGELOG.md

@@ -4,6 +4,8 @@
 
 ### Fixed
 
+- `Node.representationIdentity` writes the representation a sealed action's step key hashes as `effect@4.0.0-rc.115` wrote it, with the six built-in check ids `effect@4.0.4` renamed written back. A schema with `Schema.brand` re-keys once, because the brand is no longer part of the AST. ([#3839](https://github.com/smithersai/smithers/issues/3839)).
+- A schema's identity no longer depends on the installed `effect` release. `Node.schemaIdentity` prints the document a call or a `catch` filter contributes to a step key, as `effect@4.0.0-rc.115` printed it, so moving to `effect@4.0.4` or later does not re-key recorded steps. A declaration that uses one identified or recursive schema both with and without `Schema.brand` re-keys once. ([#3839](https://github.com/smithersai/smithers/issues/3839)).
 - Keep live executable bindings and planned-reference ownership across compatible package copies; serialized ASTs remain inert. ([#1991](https://github.com/smithersai/smithers/issues/1991)).
 
 ## [Unreleased]

package/README.md

@@ -2,9 +2,9 @@
 
 Release candidate scope, host requirements and compatibility review are defined in the [library support policy](https://github.com/smithersai/smithers/blob/main/RELEASE_SUPPORT.md).
 
-This package declares `effect` as an exact
-`4.0.0-rc.115` peer dependency. Keep the application on that version so
-all Smithers packages share one Effect runtime.
+This package declares `effect` as a `^4.0.4` peer dependency. Install one
+`effect` release in that range so all Smithers packages share one Effect
+runtime.
 
 **Documentation:** https://plan.smithers.sh
 
@@ -31,10 +31,10 @@ Compiling asks Effect for its `Crypto` service, which a platform package
 supplies:
 
 ```bash
-pnpm add @effect/platform-node@4.0.0-rc.115 @effect/platform-node-shared@4.0.0-rc.115
+pnpm add @effect/platform-node @effect/platform-node-shared
 ```
 
-Node.js 26.4.0 or later, and `effect` 4.0.0-rc.115 as a peer. Recording a plan
+Node.js 26.4.0 or later, and `effect` `^4.0.4` as a peer. Recording a plan
 is [`@smthrs/plan-store`](https://plan-store.smithers.sh), which owns the SQL
 and brings [`@smthrs/database`](https://database.smithers.sh) with it.
 

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,48 @@
+# Third-party notices
+
+This distribution contains third-party software. The notice below is
+reproduced to satisfy the terms of the license that component is distributed
+under. It is in addition to, and does not replace, the project's own `LICENSE`.
+
+## Effect (`Effect-TS/effect`)
+
+`@smthrs/plan` prints a schema's identity with an adapted copy of the JSON
+Schema emitter of one Effect release, so that the identity does not change
+with the Effect release an application installs. `src/internal/SchemaIdentity.ts`
+contains substantial portions of that source and records how it was changed:
+
+- Upstream repository: `Effect-TS/effect`
+- Upstream package: `effect@4.0.0-rc.115`
+- Upstream sources: `src/internal/schema/toJsonSchemaDocument.ts`,
+  `src/JsonSchema.ts` (`rewriteRefs`), `src/JsonPointer.ts`, and
+  `src/SchemaAST.ts` (`isJson`)
+
+Effect is distributed under the MIT License. Its copyright and permission
+notice is reproduced here verbatim:
+
+```
+MIT License
+
+Copyright (c) 2023 Effectful Technologies Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+`@smthrs/plan` also depends on Effect at runtime, so the notice above applies
+to that dependency as well as to the adapted source.

package/dist/cjs/KeyMaterial.d.ts

@@ -7,7 +7,7 @@
  * lives here, above `@smthrs/keys`, so the key package stays a leaf.
  *
  * Governing contract: the step-key rules at
- * https://smithers.sh/docs/concepts/content-addressing. Material is computed with no I/O,
+ * https://github.com/smithersai/smithers/blob/main/packages/smithers/flows/plan/docs/concepts/step-keys.md. Material is computed with no I/O,
  * and two hardening rules shape it: the nominal, never shape-sniffed
  * `InputRef` and the hashed `version`.
  *

package/dist/cjs/KeyMaterial.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/KeyMaterial.ts"],
-  "sourcesContent": ["/**\n * The key-material contract: what a planner hands the step-key compiler.\n *\n * Revived from the deleted `packages/smithers/flows/keys/src/KeyMaterial.ts`.\n * It does NOT return to `@smthrs/keys`: that package owns generic derivation\n * and stored-key validation, while material is a *plan-shaped* concept. It\n * lives here, above `@smthrs/keys`, so the key package stays a leaf.\n *\n * Governing contract: the step-key rules at\n * https://smithers.sh/docs/concepts/content-addressing. Material is computed with no I/O,\n * and two hardening rules shape it: the nominal, never shape-sniffed\n * `InputRef` and the hashed `version`.\n *\n * @since 0.1.0\n */\n\nimport * as Schema from \"effect/Schema\"\nimport * as Effects from \"./Effects.ts\"\n\n/**\n * A reference to one declared input of a node: a value hashed inline, or the\n * key of an upstream node whose result this node consumes.\n *\n * The three variants are tagged, and the tag is hashed, so `Pending{from}` and\n * `Ref{from, path: []}` \u2014 which resolve to the same dependency digest \u2014 can\n * never collide.\n *\n * @since 0.1.0\n * @category schemas\n * @slop\n */\nexport const InputRef = Schema.Union([\n  Schema.TaggedStruct(\"Literal\", { value: Schema.Unknown }),\n  Schema.TaggedStruct(\"Ref\", { from: Schema.NonEmptyString, path: Schema.Array(Schema.String) }),\n  Schema.TaggedStruct(\"Pending\", { from: Schema.NonEmptyString })\n])\n\n/**\n * A reference to one declared input of a node.\n *\n * @since 0.1.0\n * @category models\n * @slop\n */\nexport type InputRef = typeof InputRef.Type\n\n/**\n * The material version. Folded into every hashed body so a bump re-keys every\n * node derived from it \u2014 the original's second collision fix, kept.\n *\n * @since 0.1.0\n * @category constants\n * @slop\n */\nexport const version = \"flows/key-material/v2\"\n\n/**\n * Everything that can change a node's result, handed to the digest.\n *\n * `effects` and `placement` are opaque: canonically serialized, never\n * interpreted, which is what keeps the compiler independent of whatever the\n * flow builder decides an effect declaration looks like.\n *\n * @since 0.1.0\n * @category schemas\n * @slop\n */\nexport const KeyMaterial = Schema.Struct({\n  version: Schema.Literal(version),\n  kind: Effects.Tier,\n  // Absence claims determinism; only the explicit declaration changes identity.\n  nondeterministic: Schema.optional(Schema.Literal(true)),\n  body: Schema.Unknown,\n  inputs: Schema.Array(InputRef),\n  layers: Schema.Array(Schema.String),\n  capabilities: Schema.Array(Schema.String),\n  effects: Schema.optional(Schema.Unknown),\n  placement: Schema.optional(Schema.Unknown)\n})\n\n/**\n * Everything that can change a node's result, handed to the digest.\n *\n * @since 0.1.0\n * @category models\n * @slop\n */\nexport type KeyMaterial = typeof KeyMaterial.Type\n\n/**\n * The graph-local dependencies a material names, in declaration order and\n * without duplicates. The compiler resolves exactly these before hashing, and\n * {@link module:Plan} uses them as the edge set \u2014 one derivation, so an edge\n * and a hashed reference can never disagree.\n *\n * @since 0.1.0\n * @category accessors\n * @slop\n */\nexport const dependencies = (material: KeyMaterial): ReadonlyArray<string> => {\n  const seen = new Set<string>()\n  for (const input of material.inputs) {\n    if (input._tag !== \"Literal\") seen.add(input.from)\n  }\n  return [...seen]\n}\n"],
+  "sourcesContent": ["/**\n * The key-material contract: what a planner hands the step-key compiler.\n *\n * Revived from the deleted `packages/smithers/flows/keys/src/KeyMaterial.ts`.\n * It does NOT return to `@smthrs/keys`: that package owns generic derivation\n * and stored-key validation, while material is a *plan-shaped* concept. It\n * lives here, above `@smthrs/keys`, so the key package stays a leaf.\n *\n * Governing contract: the step-key rules at\n * https://github.com/smithersai/smithers/blob/main/packages/smithers/flows/plan/docs/concepts/step-keys.md. Material is computed with no I/O,\n * and two hardening rules shape it: the nominal, never shape-sniffed\n * `InputRef` and the hashed `version`.\n *\n * @since 0.1.0\n */\n\nimport * as Schema from \"effect/Schema\"\nimport * as Effects from \"./Effects.ts\"\n\n/**\n * A reference to one declared input of a node: a value hashed inline, or the\n * key of an upstream node whose result this node consumes.\n *\n * The three variants are tagged, and the tag is hashed, so `Pending{from}` and\n * `Ref{from, path: []}` \u2014 which resolve to the same dependency digest \u2014 can\n * never collide.\n *\n * @since 0.1.0\n * @category schemas\n * @slop\n */\nexport const InputRef = Schema.Union([\n  Schema.TaggedStruct(\"Literal\", { value: Schema.Unknown }),\n  Schema.TaggedStruct(\"Ref\", { from: Schema.NonEmptyString, path: Schema.Array(Schema.String) }),\n  Schema.TaggedStruct(\"Pending\", { from: Schema.NonEmptyString })\n])\n\n/**\n * A reference to one declared input of a node.\n *\n * @since 0.1.0\n * @category models\n * @slop\n */\nexport type InputRef = typeof InputRef.Type\n\n/**\n * The material version. Folded into every hashed body so a bump re-keys every\n * node derived from it \u2014 the original's second collision fix, kept.\n *\n * @since 0.1.0\n * @category constants\n * @slop\n */\nexport const version = \"flows/key-material/v2\"\n\n/**\n * Everything that can change a node's result, handed to the digest.\n *\n * `effects` and `placement` are opaque: canonically serialized, never\n * interpreted, which is what keeps the compiler independent of whatever the\n * flow builder decides an effect declaration looks like.\n *\n * @since 0.1.0\n * @category schemas\n * @slop\n */\nexport const KeyMaterial = Schema.Struct({\n  version: Schema.Literal(version),\n  kind: Effects.Tier,\n  // Absence claims determinism; only the explicit declaration changes identity.\n  nondeterministic: Schema.optional(Schema.Literal(true)),\n  body: Schema.Unknown,\n  inputs: Schema.Array(InputRef),\n  layers: Schema.Array(Schema.String),\n  capabilities: Schema.Array(Schema.String),\n  effects: Schema.optional(Schema.Unknown),\n  placement: Schema.optional(Schema.Unknown)\n})\n\n/**\n * Everything that can change a node's result, handed to the digest.\n *\n * @since 0.1.0\n * @category models\n * @slop\n */\nexport type KeyMaterial = typeof KeyMaterial.Type\n\n/**\n * The graph-local dependencies a material names, in declaration order and\n * without duplicates. The compiler resolves exactly these before hashing, and\n * {@link module:Plan} uses them as the edge set \u2014 one derivation, so an edge\n * and a hashed reference can never disagree.\n *\n * @since 0.1.0\n * @category accessors\n * @slop\n */\nexport const dependencies = (material: KeyMaterial): ReadonlyArray<string> => {\n  const seen = new Set<string>()\n  for (const input of material.inputs) {\n    if (input._tag !== \"Literal\") seen.add(input.from)\n  }\n  return [...seen]\n}\n"],
   "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,aAAwB;AACxB,cAAyB;AAclB,MAAM,WAAW,OAAO,MAAM;AAAA,EACnC,OAAO,aAAa,WAAW,EAAE,OAAO,OAAO,QAAQ,CAAC;AAAA,EACxD,OAAO,aAAa,OAAO,EAAE,MAAM,OAAO,gBAAgB,MAAM,OAAO,MAAM,OAAO,MAAM,EAAE,CAAC;AAAA,EAC7F,OAAO,aAAa,WAAW,EAAE,MAAM,OAAO,eAAe,CAAC;AAChE,CAAC;AAmBM,MAAM,UAAU;AAahB,MAAM,cAAc,OAAO,OAAO;AAAA,EACvC,SAAS,OAAO,QAAQ,OAAO;AAAA,EAC/B,MAAM,QAAQ;AAAA;AAAA,EAEd,kBAAkB,OAAO,SAAS,OAAO,QAAQ,IAAI,CAAC;AAAA,EACtD,MAAM,OAAO;AAAA,EACb,QAAQ,OAAO,MAAM,QAAQ;AAAA,EAC7B,QAAQ,OAAO,MAAM,OAAO,MAAM;AAAA,EAClC,cAAc,OAAO,MAAM,OAAO,MAAM;AAAA,EACxC,SAAS,OAAO,SAAS,OAAO,OAAO;AAAA,EACvC,WAAW,OAAO,SAAS,OAAO,OAAO;AAC3C,CAAC;AAqBM,MAAM,eAAe,CAAC,aAAiD;AAC5E,QAAM,OAAO,oBAAI,IAAY;AAC7B,aAAW,SAAS,SAAS,QAAQ;AACnC,QAAI,MAAM,SAAS,UAAW,MAAK,IAAI,MAAM,IAAI;AAAA,EACnD;AACA,SAAO,CAAC,GAAG,IAAI;AACjB;",
   "names": []
 }

package/dist/cjs/Node.d.ts

@@ -29,8 +29,10 @@
  */
 import type * as Pipeable from "effect/Pipeable";
 import type * as Schema from "effect/Schema";
+import type * as SchemaAST from "effect/SchemaAST";
 import type * as Types from "effect/Types";
 import * as internal from "./internal/node.ts";
+import * as internalSchemaIdentity from "./internal/SchemaIdentity.ts";
 import * as Planned from "./Planned.ts";
 /**
  * The runtime type identifier carried by every node.
@@ -580,6 +582,75 @@ export declare const catchFilter: (ast: Ast) => Schema.Top | undefined;
  * @slop
  */
 export declare const functionIdentity: (operation: unknown) => FunctionIdentity;
+/**
+ * The document a schema's identity is: JSON-Schema-shaped, and the same bytes
+ * under every `effect` release this package supports.
+ *
+ * @since 1.0.0
+ * @category engine
+ */
+export type SchemaIdentity = internalSchemaIdentity.Document;
+/**
+ * The one option a schema's identity is taken under: whether an object closes
+ * over the keys it declares (`"error"`) or leaves others open (`"ignore"`,
+ * the default). It has the meaning it has in `Schema.toJsonSchemaDocument`.
+ *
+ * @since 1.0.0
+ * @category engine
+ */
+export type SchemaIdentityOptions = internalSchemaIdentity.Options;
+/**
+ * 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 declare const SchemaIdentityError: typeof internalSchemaIdentity.SchemaIdentityError;
+/**
+ * The type of {@link SchemaIdentityError}.
+ *
+ * @since 1.0.0
+ * @category errors
+ */
+export type 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 declare const schemaIdentity: (schema: Schema.Top, options?: SchemaIdentityOptions) => SchemaIdentity;
+/**
+ * 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 declare const representationIdentity: (ast: SchemaAST.AST) => Schema.Json;
 /**
  * Binds a frozen plain copy of inert captures as the callback's this receiver.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"Node.d.ts","sourceRoot":"","sources":["../../src/Node.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Node.d.ts","sourceRoot":"","sources":["../../src/Node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,KAAK,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAChD,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,KAAK,SAAS,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAE1C,OAAO,KAAK,QAAQ,MAAM,oBAAoB,CAAA;AAC9C,OAAO,KAAK,sBAAsB,MAAM,8BAA8B,CAAA;AACtE,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,EAAE,MAAwB,CAAA;AAE7C;;;;;;GAMG;AACH,MAAM,MAAM,MAAM,GAAG,oBAAoB,CAAA;AAEzC;;;;;;;GAOG;AACH,MAAM,MAAM,GAAG,GAAG,QAAQ,CAAC,OAAO,CAAA;AAElC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,6DAAoB,CAAA;AAEzC;;;;;;GAMG;AACH,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAA;AAExC;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC,CAAC,QAAQ,CAAC,CAAA;AAE/E;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,2DAA4B,CAAA;AAEzD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,KAAK,EAAE,GAAG,CAAC,CAAC,GAAG,KAAK,CAAE,SAAQ,QAAQ,CAAC,QAAQ;IAClF,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE;QACjB,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;QAC/B,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;QAC/B,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;KAChC,CAAA;IACD,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;CAClB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,CAAA;AAE7C;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAEhF;;;;;;GAMG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAE9E;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAEjF;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,mBAAmB,CAAA;AAO7C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,kBAAkB,CAAA;AAE3C;;;;;;;;;;GAUG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE;IACtD,QAAQ,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAA;IAClC,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAA;IAC9D,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAA;CAC/D;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,GAAG,KAAK,EAAE,OAAO,GAAG,CAAC;IAC7D,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,SAAS,CAAA;IACnD,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAA;CACzE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,GAA6B,CAAA;AAE9E;;;;;;;;GAQG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,GAAG,KAAK,GACnE,CAAC,SAAS,IAAI,GAAG,MAAM,GAAG,IAAI,GAC9B,CAAC,SAAS;IAAE,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,MAAM,KAAK,CAAA;CAAE,GAAG,OAAO,CAAC,KAAK,CAAC,GACpE,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,GAAG,SAAS,GAC3C,CAAC,SAAS,MAAM,GAAG,SAAS,GAC5B,CAAC,SAAS,aAAa,CAAC,OAAO,CAAC,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,GAC/E,CAAC,SAAS,MAAM,GAAG;KAChB,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,KAAK,GAAG,CAAC,GAAG,KAAK,GAAG,OAAO,CAC5G,CAAC,CAAC,CAAC,CAAC,CACL;CACF,GACD,CAAC,CAAA;AAEL,eAAe;AACf,KAAK,kBAAkB,CAAC,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,GAAG,KAAK,GACvE,CAAC,SAAS,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,SAAS,MAAM,KAAK,GAAG,KAAK,SAAS,SAAS,GAAG,IAAI,GAAG,KAAK,GACzF,KAAK,GACP,KAAK,CAAA;AAET;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAA2D,CAAA;AAEhH;;;;;;;GAOG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,CAAA;AAEhC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,CAA4D,CAAA;AAElH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,GAAG,GAAI,KAAK,CAAC,KAAK,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,EACnE,OAAO,KAAK,KACX,IAAI,CACL,KAAK,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAE,CAAC,EAClE,KAAK,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,EACzB,QAAQ,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CACsD,CAAA;AAsDpF;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAA;AAEnD;;;;;;;;GAQG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,CAAC,KAAK,SAAS,OAAO,EAC9C,OAAO,KAAK,KACX,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CACjD,CAAA;AAE3C;;;;;;;;;GASG;AACH,eAAO,MAAM,GAAG,GAAI,KAAK,CAAC,KAAK,SAAS,OAAO,EAC7C,OAAO,KAAK,KACX,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CAClD,CAAA;AAE1C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,MAAM,GAAI,KAAK,CAAC,KAAK,SAAS,OAAO,EAChD,OAAO,MAAM,EACb,OAAO,KAAK,KACX,IAAI,CACL,KAAK,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,CAAC,IAAI,MAAM,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAE,CAAC,EACnE,KAAK,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,EACzB,QAAQ,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAAC,CACsB,CAAA;AAEpD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,GAAG,EAAE;IAChB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;IACpE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CAKjE,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;IAC7F,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CAkB1F,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW,EAAE;IACxB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACX,KAAK,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GACxD,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;IACzD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACjB,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACnB,KAAK,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GACxD,IAAI,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CAU3B,CAAA;AAwBD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,MAAM,EAAE;IACnB,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EACxB,OAAO,EAAE,aAAa,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,GAChD,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAA;IACzE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAC9B,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACnB,OAAO,EAAE,aAAa,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,GAChD,IAAI,CAAC,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAA;CAqB3C,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAA,MAAM,MAAM,EAAE;IACZ,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACjB,OAAO,EAAE,YAAY,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,OAAO,CAAC,GAAG;QACnD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;KACvC,GACA,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;IAChE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACX,OAAO,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG;QACpC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAA;KAC3B,GACA,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;IACzD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAC1B,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACnB,OAAO,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,OAAO,CAAC,GAAG;QAC7C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;KACvC,GACA,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;IAC9B,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACjB,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACnB,OAAO,EAAE,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG;QACpC,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAA;KAC3B,GACA,IAAI,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAA;CAmB3B,CAAA;AAED,OAAO,EAAE,MAAM,IAAI,KAAK,EAAE,CAAA;AAE1B;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,EAAE;IACrB,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;IAChE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;CAc7D,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAAI,KAAK,GAAG,KAAG,MAAM,GAAG,SAAyB,CAAA;AAE9E;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,EACxD,aAAa,OAAO,EACpB,MAAM,MAAM,EACZ,MAAM,QAAQ,EACd,SAAS,OAAO,KACf,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAoF,CAAA;AAEnG;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,EAC1D,aAAa,OAAO,EACpB,QAAQ,MAAM,EACd,SAAS,OAAO,KACf,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAkF,CAAA;AAEjG;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GACtB,KAAK,OAAO,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,UAAU,CAAA;CAAE,CAAC,KAC9D,OAAoC,CAAA;AAEvC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,GACvB,KAAK,OAAO,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CAAE,CAAC,KAC9C,CAAC,CAAC,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,GAAG,SAAoC,CAAA;AAExF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM,GAAI,KAAK,GAAG,KAAG,CAAC,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,GAAG,SACR,CAAA;AAE1D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,GAAG,KAAG,CAAC,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,GAAG,SACR,CAAA;AAE7D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,GAAI,KAAK,GAAG,KAAG,MAAM,CAAC,GAAG,GAAG,SAAoE,CAAA;AAExH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB,GAAI,WAAW,OAAO,KAAG,gBAAwD,CAAA;AAE9G;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,sBAAsB,CAAC,QAAQ,CAAA;AAE5D;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,sBAAsB,CAAC,OAAO,CAAA;AAElE;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,mDAA6C,CAAA;AAE7E;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,sBAAsB,CAAC,mBAAmB,CAAA;AAE5E;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,MAAM,CAAC,GAAG,EAAE,UAAU,qBAAqB,KAAG,cAC7B,CAAA;AAExD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,sBAAsB,GAAI,KAAK,SAAS,CAAC,GAAG,KAAG,MAAM,CAAC,IACf,CAAA;AAEpD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,IAAI,SAAS,aAAa,CAAC,OAAO,CAAC,EAAE,CAAC,EACzG,UAAU,CAAC,EACX,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,IAAI,KAAK,CAAC,KACjD,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,CAA0C,CAAA"}

package/dist/cjs/Node.js

@@ -29,6 +29,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var Node_exports = {};
 __export(Node_exports, {
   CallMode: () => CallMode,
+  SchemaIdentityError: () => SchemaIdentityError,
   TypeId: () => TypeId,
   actionCall: () => actionCall,
   all: () => all,
@@ -55,12 +56,15 @@ __export(Node_exports, {
   priority: () => priority,
   quorum: () => quorum,
   race: () => race,
+  representationIdentity: () => representationIdentity,
+  schemaIdentity: () => schemaIdentity,
   succeed: () => succeed
 });
 module.exports = __toCommonJS(Node_exports);
 var import_Function = require("effect/Function");
 var import_GraphBuildError = require("./GraphBuildError.js");
 var internal = __toESM(require("./internal/node.js"), 1);
+var internalSchemaIdentity = __toESM(require("./internal/SchemaIdentity.js"), 1);
 var Planned = __toESM(require("./Planned.js"), 1);
 const TypeId = internal.TypeId;
 const CallMode = internal.CallMode;
@@ -203,5 +207,8 @@ const mapper = (ast) => ast._tag === "Map" ? internal.operation(ast) : void 0;
 const predicate = (ast) => ast._tag === "Branch" ? internal.predicate(ast) : void 0;
 const catchFilter = (ast) => ast._tag === "Catch" ? internal.filter(ast) : void 0;
 const functionIdentity = (operation) => internal.functionIdentity(operation);
+const SchemaIdentityError = internalSchemaIdentity.SchemaIdentityError;
+const schemaIdentity = (schema, options) => internalSchemaIdentity.schemaIdentity(schema, options);
+const representationIdentity = (ast) => internalSchemaIdentity.representationIdentity(ast);
 const capture = (captures, operation) => internal.capture(captures, operation);
 //# sourceMappingURL=Node.js.map

package/dist/cjs/Node.js.map

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

package/dist/cjs/StepKey.d.ts

@@ -22,7 +22,7 @@
  * resolved references, and the hashed `version`.
  *
  * Governing contract: the step-key rules at
- * https://smithers.sh/docs/concepts/content-addressing.
+ * https://github.com/smithersai/smithers/blob/main/packages/smithers/flows/plan/docs/concepts/step-keys.md.
  *
  * @since 0.1.0
  */