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

package/dist/cjs/Plan.d.ts

@@ -0,0 +1,440 @@
+/**
+ * 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.
+ *
+ * @since 0.1.0
+ * @category schemas
+ * @slop
+ */
+export declare const NodeEffects: Schema.Struct<{
+    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>>;
+        }>]>>;
+    }>]>>;
+    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>>;
+    readonly boundaryMode: Schema.Literals<readonly ["hard", "expected"]>;
+}>;
+/**
+ * The value form of {@link NodeEffects}.
+ *
+ * @since 0.1.0
+ * @category models
+ * @slop
+ */
+export type NodeEffects = typeof NodeEffects.Type;
+/**
+ * The plan-time write-conflict strategies of the effect taxonomy.
+ *
+ * @since 0.1.0
+ * @category schemas
+ * @slop
+ */
+export declare const PairStrategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+/**
+ * The value form of {@link PairStrategy}.
+ *
+ * @since 0.1.0
+ * @category models
+ * @slop
+ */
+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.
+ *
+ * @since 0.1.0
+ * @category schemas
+ * @slop
+ */
+export declare const RuntimeStrategy: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+/**
+ * The value form of {@link RuntimeStrategy}.
+ *
+ * @since 0.1.0
+ * @category models
+ * @slop
+ */
+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.
+ *
+ * @since 0.1.0
+ * @category schemas
+ * @slop
+ */
+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
+ * @slop
+ */
+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.
+ *
+ * @since 0.1.0
+ * @category schemas
+ * @slop
+ */
+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<{
+        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>>;
+            }>]>>;
+        }>]>>;
+        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>>;
+        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
+ * @slop
+ */
+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.
+ *
+ * @since 0.1.0
+ * @category schemas
+ * @slop
+ */
+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<{
+            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>>;
+                }>]>>;
+            }>]>>;
+            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>>;
+            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
+ * @slop
+ */
+export type Plan = typeof Plan.Type;
+/**
+ * What a planner hands {@link compile}: a node without its key.
+ *
+ * @since 0.1.0
+ * @category models
+ * @slop
+ */
+export interface NodeDraft {
+    readonly id: string;
+    readonly material: KeyMaterial.KeyMaterial;
+    readonly effects: NodeEffects;
+    readonly kind?: PlanNode["kind"] | undefined;
+    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.
+ *
+ * @since 0.1.0
+ * @category errors
+ * @slop
+ */
+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
+ * @slop
+ */
+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.
+ *
+ * @since 0.1.0
+ * @category constructors
+ * @slop
+ */
+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.
+ *
+ * @since 0.1.0
+ * @category constructors
+ * @slop
+ */
+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.
+ *
+ * @since 0.1.0
+ * @category accessors
+ * @slop
+ */
+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.
+ *
+ * @since 1.0.0
+ * @category guards
+ * @slop
+ */
+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.
+ *
+ * @since 1.0.0
+ * @category accessors
+ * @slop
+ */
+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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"}