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

package/dist/cjs/Plan.d.ts

@@ -0,0 +1,489 @@
+/**
+ * The plan: a node graph with every step key computed, inert until run.
+ *
+ * The way a plan is produced is a law: **planning performs no I/O**.
+ * Everything in this module is therefore a pure function of declarations plus
+ * the injected `Crypto` service: no filesystem, no clock, no network. A node's
+ * key is a function of what it consumes, so an edited declaration re-keys that
+ * node and everything downstream of it, and nothing else. That is the entire
+ * invalidation mechanism. Invalidation is re-keying, which **rejects**
+ * Skyframe's reverse-dependency index and invalidating node visitor outright
+ * because content addressing subsumes them. Key invalidation never retains a
+ * reverse-dependency index; annotation uses only a temporary reachability cache.
+ *
+ * Growth is append-only: {@link append} adds a pre-keyed subgraph to the same
+ * plan and never rewrites a node already in it.
+ *
+ * @since 0.1.0
+ */
+import type * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as KeyMaterial from "./KeyMaterial.ts";
+import * as StepKey from "./StepKey.ts";
+/**
+ * What a node does to the world, declared. Paths only — measuring them is
+ * run-time work, so a digest here would break the no-I/O law.
+ *
+ * Decoding fails with a `SchemaError` when a path is not workspace-relative.
+ * {@link compile} also refuses a node whose `removes` overlaps its `writes`
+ * with an `invalid_effects` {@link PlanError}.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const NodeEffects: Schema.Struct<{
+    /** Paths the node reads. A read orders the node after every writer of an overlapping path. */
+    readonly reads: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+        readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+        readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    }>]>, Schema.TaggedStruct<"Filegroup", {
+        readonly name: Schema.NonEmptyString;
+        readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+            readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+        }>]>>;
+    }>]>>;
+    /** Paths the node writes. Two writers of an overlapping path form a conflict. */
+    readonly writes: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+        readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+        readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    }>, Schema.TaggedStruct<"TreeArtifact", {
+        readonly path: Schema.NonEmptyString;
+    }>]>, Schema.TaggedStruct<"Filegroup", {
+        readonly name: Schema.NonEmptyString;
+        readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+            readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+        }>, Schema.TaggedStruct<"TreeArtifact", {
+            readonly path: Schema.NonEmptyString;
+        }>]>>;
+    }>]>>;
+    /**
+     * Paths the node declares it will DELETE. A removal mutates the world exactly
+     * as a write does, so {@link produces} folds the two together and both the
+     * conflict pass and the reader-after-writer pass see them as one set.
+     */
+    readonly removes: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    /** How strictly the sandbox enforces these declarations. */
+    readonly boundaryMode: Schema.Literals<readonly ["hard", "expected"]>;
+}>;
+/**
+ * The value form of {@link NodeEffects}.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type NodeEffects = typeof NodeEffects.Type;
+/**
+ * The plan-time verdict for two writers of an overlapping path:
+ * `serialize` gives the later writer an ordering edge, `lane` records a lane
+ * annotation on both writers and adds no edge, and `fail` refuses the plan
+ * with `overlap_forbidden`. For a pair, `fail` dominates `lane`, which
+ * dominates `serialize`. The same schema as `Effects.ConflictStrategy`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const PairStrategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+/**
+ * The value form of {@link PairStrategy}.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type PairStrategy = typeof PairStrategy.Type;
+/**
+ * The runtime half of a conflict annotation: what the scheduler
+ * does when the overlap the plan predicted actually bites, or when a
+ * scheduled node's inputs are invalidated under it. For a pair,
+ * `stop-merge` dominates `delay-rebase`.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const RuntimeStrategy: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+/**
+ * The value form of {@link RuntimeStrategy}.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type RuntimeStrategy = typeof RuntimeStrategy.Type;
+/**
+ * One resolved overlap between two writers that no dependency path already
+ * orders. Conflict is a property of the PAIR, not of one declaration.
+ *
+ * `with` names the other node, `paths` lists the overlapping declarations,
+ * and `strategy` and `runtime` are the verdicts resolved for the pair.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const ConflictAnnotation: Schema.Struct<{
+    readonly with: Schema.NonEmptyString;
+    readonly paths: Schema.$Array<Schema.String>;
+    readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+    readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+}>;
+/**
+ * The value form of {@link ConflictAnnotation}.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type ConflictAnnotation = typeof ConflictAnnotation.Type;
+/**
+ * A keyed node of the plan.
+ *
+ * `dependsOn` is the *edge* set: material references, any ordering edge a
+ * `serialize` verdict added, and the reader-after-writer edges that put a
+ * node behind whoever produces the paths it reads. Ordering edges are
+ * deliberately NOT part of the key — a node ordered behind another still
+ * computes the same result, so re-keying it would throw away a legitimate
+ * cache hit.
+ *
+ * `strategy` and `runtime` are this declaration's own preferences, recorded so
+ * a later elaboration can resolve a pair against them without re-reading the
+ * flow source.
+ *
+ * `generation` is 0 for nodes from {@link compile} and grows by one with each
+ * {@link append}.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const PlanNode: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly kind: Schema.Literals<readonly ["step", "agent", "merge"]>;
+    readonly key: Schema.brand<Schema.String, "@smthrs/keys/Key">;
+    readonly material: Schema.Struct<{
+        readonly version: Schema.Literal<"flows/key-material/v2">;
+        readonly kind: Schema.Literals<readonly ["sealed", "compensable", "irreversible"]>;
+        readonly nondeterministic: Schema.optional<Schema.Literal<true>>;
+        readonly body: Schema.Unknown;
+        readonly inputs: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"Literal", {
+            readonly value: Schema.Unknown;
+        }>, Schema.TaggedStruct<"Ref", {
+            readonly from: Schema.NonEmptyString;
+            readonly path: Schema.$Array<Schema.String>;
+        }>, Schema.TaggedStruct<"Pending", {
+            readonly from: Schema.NonEmptyString;
+        }>]>>;
+        readonly layers: Schema.$Array<Schema.String>;
+        readonly capabilities: Schema.$Array<Schema.String>;
+        readonly effects: Schema.optional<Schema.Unknown>;
+        readonly placement: Schema.optional<Schema.Unknown>;
+    }>;
+    readonly effects: Schema.Struct<{
+        /** Paths the node reads. A read orders the node after every writer of an overlapping path. */
+        readonly reads: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+            readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+        }>]>, Schema.TaggedStruct<"Filegroup", {
+            readonly name: Schema.NonEmptyString;
+            readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+            }>]>>;
+        }>]>>;
+        /** Paths the node writes. Two writers of an overlapping path form a conflict. */
+        readonly writes: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+            readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+        }>, Schema.TaggedStruct<"TreeArtifact", {
+            readonly path: Schema.NonEmptyString;
+        }>]>, Schema.TaggedStruct<"Filegroup", {
+            readonly name: Schema.NonEmptyString;
+            readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+            }>, Schema.TaggedStruct<"TreeArtifact", {
+                readonly path: Schema.NonEmptyString;
+            }>]>>;
+        }>]>>;
+        /**
+         * Paths the node declares it will DELETE. A removal mutates the world exactly
+         * as a write does, so {@link produces} folds the two together and both the
+         * conflict pass and the reader-after-writer pass see them as one set.
+         */
+        readonly removes: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+        /** How strictly the sandbox enforces these declarations. */
+        readonly boundaryMode: Schema.Literals<readonly ["hard", "expected"]>;
+    }>;
+    readonly dependsOn: Schema.$Array<Schema.NonEmptyString>;
+    readonly conflicts: Schema.$Array<Schema.Struct<{
+        readonly with: Schema.NonEmptyString;
+        readonly paths: Schema.$Array<Schema.String>;
+        readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+        readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+    }>>;
+    readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+    readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+    readonly priority: Schema.Int;
+    readonly generation: Schema.Int;
+}>;
+/**
+ * The value form of {@link PlanNode}.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type PlanNode = typeof PlanNode.Type;
+/**
+ * A plan: the whole keyed graph plus the digest an approval binds to.
+ *
+ * `nodes` follows material-dependency order within each generation. Inferred
+ * edges can point to later entries; schedule from the complete `dependsOn`
+ * graph, never by iterating the array alone.
+ *
+ * `baseDigest` is the digest at generation 0: what a human approved and what
+ * a `RUNNING` run pins. `digest` advances with every appended elaboration.
+ *
+ * Decoding checks only the shape. Use {@link verify} to check that keys,
+ * edges, and digests match the declarations.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const Plan: Schema.Struct<{
+    readonly planId: Schema.NonEmptyString;
+    readonly flow: Schema.NonEmptyString;
+    readonly generation: Schema.Int;
+    readonly baseDigest: Schema.brand<Schema.String, "@smthrs/keys/Key">;
+    readonly digest: Schema.brand<Schema.String, "@smthrs/keys/Key">;
+    readonly nodes: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly kind: Schema.Literals<readonly ["step", "agent", "merge"]>;
+        readonly key: Schema.brand<Schema.String, "@smthrs/keys/Key">;
+        readonly material: Schema.Struct<{
+            readonly version: Schema.Literal<"flows/key-material/v2">;
+            readonly kind: Schema.Literals<readonly ["sealed", "compensable", "irreversible"]>;
+            readonly nondeterministic: Schema.optional<Schema.Literal<true>>;
+            readonly body: Schema.Unknown;
+            readonly inputs: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"Literal", {
+                readonly value: Schema.Unknown;
+            }>, Schema.TaggedStruct<"Ref", {
+                readonly from: Schema.NonEmptyString;
+                readonly path: Schema.$Array<Schema.String>;
+            }>, Schema.TaggedStruct<"Pending", {
+                readonly from: Schema.NonEmptyString;
+            }>]>>;
+            readonly layers: Schema.$Array<Schema.String>;
+            readonly capabilities: Schema.$Array<Schema.String>;
+            readonly effects: Schema.optional<Schema.Unknown>;
+            readonly placement: Schema.optional<Schema.Unknown>;
+        }>;
+        readonly effects: Schema.Struct<{
+            /** Paths the node reads. A read orders the node after every writer of an overlapping path. */
+            readonly reads: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+            }>]>, Schema.TaggedStruct<"Filegroup", {
+                readonly name: Schema.NonEmptyString;
+                readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                    readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                }>]>>;
+            }>]>>;
+            /** Paths the node writes. Two writers of an overlapping path form a conflict. */
+            readonly writes: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+            }>, Schema.TaggedStruct<"TreeArtifact", {
+                readonly path: Schema.NonEmptyString;
+            }>]>, Schema.TaggedStruct<"Filegroup", {
+                readonly name: Schema.NonEmptyString;
+                readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                    readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                }>, Schema.TaggedStruct<"TreeArtifact", {
+                    readonly path: Schema.NonEmptyString;
+                }>]>>;
+            }>]>>;
+            /**
+             * Paths the node declares it will DELETE. A removal mutates the world exactly
+             * as a write does, so {@link produces} folds the two together and both the
+             * conflict pass and the reader-after-writer pass see them as one set.
+             */
+            readonly removes: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+            /** How strictly the sandbox enforces these declarations. */
+            readonly boundaryMode: Schema.Literals<readonly ["hard", "expected"]>;
+        }>;
+        readonly dependsOn: Schema.$Array<Schema.NonEmptyString>;
+        readonly conflicts: Schema.$Array<Schema.Struct<{
+            readonly with: Schema.NonEmptyString;
+            readonly paths: Schema.$Array<Schema.String>;
+            readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+            readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+        }>>;
+        readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+        readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+        readonly priority: Schema.Int;
+        readonly generation: Schema.Int;
+    }>>;
+}>;
+/**
+ * The value form of {@link Plan}.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Plan = typeof Plan.Type;
+/**
+ * What a planner hands {@link compile}: a node without its key.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface NodeDraft {
+    /** A non-empty id, unique within the plan. */
+    readonly id: string;
+    /** The key inputs. Its `Ref` inputs name the node's material dependencies. */
+    readonly material: KeyMaterial.KeyMaterial;
+    /** The declared reads, writes, and removals. They replace `material.effects`. */
+    readonly effects: NodeEffects;
+    /** `step`, `agent`, or `merge`. Defaults to `step`. */
+    readonly kind?: PlanNode["kind"] | undefined;
+    /** A safe integer scheduling priority. Defaults to 0. */
+    readonly priority?: number | undefined;
+    /** This declaration's preferred plan-time verdict for a detected overlap. */
+    readonly conflictStrategy?: PairStrategy | undefined;
+    /** This declaration's preferred runtime response. */
+    readonly runtimeStrategy?: RuntimeStrategy | undefined;
+}
+declare const PlanError_base: Schema.Class<PlanError, Schema.TaggedStruct<"@smthrs/plan/PlanError", {
+    readonly code: Schema.Literals<readonly ["cycle", "unknown_dependency", "duplicate_node", "overlap_forbidden", "invalid_effects", "invalid_node", "invalid_plan", "graph_too_large"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A graph the compiler refuses. `code` names the rule:
+ *
+ * - `cycle`: material or inferred edges form a cycle.
+ * - `unknown_dependency`: a `Ref` names a node that is not in the plan.
+ * - `duplicate_node`: two nodes share an id.
+ * - `overlap_forbidden`: two unordered writers overlap and the pair's
+ *   strategy is `fail`.
+ * - `invalid_effects`: a node both writes and removes one path.
+ * - `invalid_node`: a draft field, the plan id, or the flow name is malformed.
+ * - `invalid_plan`: {@link verify} found a plan that does not match its
+ *   declarations.
+ * - `graph_too_large`: the plan exceeds {@link maximumPlanNodes} or the
+ *   effect-analysis work budget.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class PlanError extends PlanError_base {
+}
+/**
+ * Maximum number of nodes retained by one compiled plan.
+ *
+ * Effect analysis also has a yielding work budget, since a node ceiling alone
+ * does not bound dense conflicts to practical work.
+ *
+ * @since 1.0.0
+ * @category limits
+ */
+export declare const maximumPlanNodes = 10000;
+/**
+ * Compiles drafts into a plan: material-dependency order, dependency-digest
+ * substitution, overlap annotation, and the plan digest. No I/O.
+ * Inferred edges extend `dependsOn` without reordering the node array.
+ *
+ * Traversal uses explicit stacks. Because the conflict and reader/writer
+ * passes consider a quadratic number of node pairs, plans are bounded by
+ * {@link maximumPlanNodes} and fail with `graph_too_large` above that limit
+ * or the effect-analysis work budget. Analysis yields periodically.
+ *
+ * The options and drafts are copied when `compile` is called, so later
+ * caller mutation does not reach the plan. The result is deeply frozen.
+ *
+ * @param options - `planId` and `flow` name the plan; `nodes` are the drafts.
+ * @returns The generation-0 plan, whose `baseDigest` equals its `digest`.
+ * Fails with {@link PlanError} for a refused graph, `KeyMaterialError` or
+ * `SchemaError` when a key cannot be derived.
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const compile: (options: {
+    readonly planId: string;
+    readonly flow: string;
+    readonly nodes: ReadonlyArray<NodeDraft>;
+}) => Effect.Effect<Plan, PlanError | StepKey.KeyMaterialError | Schema.SchemaError, Crypto.Crypto>;
+/**
+ * Appends an elaborated subgraph to an existing plan.
+ *
+ * The plan GROWS; it is never invalidated. Nodes already in it keep their id,
+ * key, edges, and generation byte for byte, and the new nodes arrive pre-keyed
+ * against them, so a `hit` shows instantly. New nodes retain their material
+ * dependency order; scheduling must honor their complete `dependsOn` graph.
+ * Re-ordering after a reconciliation happens by re-keying *future* steps,
+ * never by rewriting history.
+ *
+ * A plan not produced by this module is checked with {@link verify} first.
+ *
+ * @param plan - The plan to grow.
+ * @param drafts - At least one new node. Ids must not repeat existing ones;
+ *   `Ref` inputs may name existing nodes.
+ * @returns The plan with one more generation and a new `digest`. Fails with
+ * {@link PlanError} (`invalid_node` for an empty `drafts`, `invalid_plan` for a
+ * plan that fails verification), `KeyMaterialError`, or `SchemaError`.
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const append: (plan: Plan, drafts: ReadonlyArray<NodeDraft>) => Effect.Effect<Plan, PlanError | StepKey.KeyMaterialError | Schema.SchemaError, Crypto.Crypto>;
+/**
+ * Verifies an imported plan against the same key and topology rules as the
+ * compiler. Valid compiler-owned immutable values need no second compilation.
+ *
+ * Generation boundaries are replayed when reconstructing conflict annotations:
+ * an append may annotate new nodes, but cannot rewrite an earlier generation.
+ * Recorded material-dependency order is verified without sorting inferred edges.
+ * Keys and approval digests retain their existing format. The returned snapshot
+ * is immutable; later caller mutation cannot change the verified value.
+ *
+ * @since 1.0.0
+ * @category validation
+ */
+export declare const verify: (input: unknown) => Effect.Effect<Plan, PlanError | StepKey.KeyMaterialError | Schema.SchemaError, Crypto.Crypto>;
+/**
+ * The nodes added by the newest generation: what {@link module:PlanStore}
+ * appends and what the `subgraph-appended` journal record names.
+ *
+ * @param plan - A plan.
+ * @returns The nodes whose generation equals `plan.generation`, in order.
+ * @since 0.1.0
+ * @category accessors
+ */
+export declare const generationNodes: (plan: Plan) => ReadonlyArray<PlanNode>;
+/**
+ * Whether `input` is a compiler-owned immutable snapshot that already passed
+ * {@link verify}: such values take verify's trusted fast path and need no
+ * second schema validation.
+ *
+ * @param input - Any value.
+ * @returns `true` only for a plan returned by {@link compile},
+ * {@link append}, or {@link verify}; a structurally equal copy returns `false`.
+ * @since 1.0.0
+ * @category guards
+ */
+export declare const isVerified: (input: unknown) => input is Plan;
+/**
+ * The approval digest of every generation before the newest: the digest this
+ * plan carried before its last append. {@link module:PlanStore}'s append
+ * matches it against the stored envelope, so an append proves the recorded
+ * plan's integrity from the already-verified prefix instead of decoding and
+ * re-verifying every stored row.
+ *
+ * For a generation-0 plan no generation precedes the newest, so this is the
+ * digest of an empty node list.
+ *
+ * @param plan - A plan.
+ * @returns The approval digest of the nodes older than `plan.generation`.
+ * @since 1.0.0
+ * @category accessors
+ */
+export declare const prefixDigest: (plan: Plan) => Effect.Effect<StepKey.StepKey, StepKey.KeyMaterialError | Schema.SchemaError, Crypto.Crypto>;
+export {};
+//# sourceMappingURL=Plan.d.ts.map

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

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