typesea 0.1.0 → 0.3.0

package/dist/optimize/peephole.js

@@ -0,0 +1,254 @@
+/**
+ * @file peephole.ts
+ * @brief Local graph rewrites that remove dead dispatch arms.
+ * @details Optimizer helpers preserve graph equivalence while shrinking redundant nodes
+ * before code generation consumes the graph.
+ */
+import { NodeTag } from "../kind/index.js";
+import { ensureConst, keep, replace } from "./fold-common.js";
+import { resolveAlias, rewriteNodeDeps } from "./rewrite.js";
+/**
+ * @brief Run local dispatch compaction over one graph.
+ * @details This pass removes child arms that already fold to false and rewrites
+ * aliases after each replacement so later nodes see the simplified ids.
+ * @param graph Graph to optimize.
+ * @returns Graph with compacted dispatch nodes and resolved aliases.
+ */
+export function peepholeGraph(graph) {
+    const originalLength = graph.nodes.length;
+    const nodes = graph.nodes.slice();
+    const aliases = new Array(nodes.length);
+    for (let index = 0; index < aliases.length; index += 1) {
+        aliases[index] = index;
+    }
+    for (let index = 0; index < originalLength; index += 1) {
+        const node = nodes[index];
+        if (node === undefined) {
+            continue;
+        }
+        /*
+         * Each node is rewritten through aliases before the peephole rule runs.
+         * That lets a removal near the front of the graph feed later dispatch
+         * compaction in the same pass.
+         */
+        const rewritten = rewriteNodeDeps(node, aliases);
+        const result = peepholeNode(rewritten, nodes, aliases);
+        nodes[index] = result.node;
+        if (result.replacement !== undefined) {
+            aliases[index] = result.replacement;
+        }
+    }
+    for (let index = 0; index < aliases.length; index += 1) {
+        /*
+         * Aliases may point through other aliases. Resolve the chain once before
+         * rebuilding the graph so every dependency points at the final target.
+         */
+        aliases[index] = resolveAlias(index, aliases);
+    }
+    const rewritten = new Array(nodes.length);
+    for (let index = 0; index < nodes.length; index += 1) {
+        const node = nodes[index];
+        if (node !== undefined) {
+            rewritten[index] = rewriteNodeDeps(node, aliases);
+        }
+    }
+    return {
+        nodes: rewritten,
+        entry: resolveAlias(graph.entry, aliases),
+        result: resolveAlias(graph.result, aliases)
+    };
+}
+/**
+ * @brief Apply the local peephole rule for one node.
+ * @details Optimizer helpers preserve graph equivalence while shrinking redundant nodes
+ * before code generation consumes the graph.
+ * @param node Node with dependencies already alias-rewritten.
+ * @param nodes Mutable graph node table.
+ * @param aliases Alias table updated by replacements.
+ * @returns Fold decision for the node.
+ */
+function peepholeNode(node, nodes, aliases) {
+    switch (node.tag) {
+        case NodeTag.DiscriminantDispatch:
+            return compactDiscriminantDispatch(node, nodes, aliases);
+        case NodeTag.UnionDispatch:
+            return compactUnionDispatch(node, nodes, aliases);
+        case NodeTag.PrimitiveUnion:
+            return compactPrimitiveUnion(node, nodes, aliases);
+        default:
+            return keep(node);
+    }
+}
+/**
+ * @brief Remove impossible discriminant dispatch arms.
+ * @details Optimizer helpers preserve graph equivalence while shrinking redundant nodes
+ * before code generation consumes the graph.
+ * @param node Discriminant dispatch node to compact.
+ * @param nodes Mutable graph node table used for replacement constants.
+ * @param aliases Alias table updated by replacements.
+ * @returns Compacted dispatch node or constant false when no arm remains.
+ */
+function compactDiscriminantDispatch(node, nodes, aliases) {
+    const literals = [];
+    const schemas = [];
+    const graphs = [];
+    let changed = false;
+    for (let index = 0; index < node.graphs.length; index += 1) {
+        const graph = node.graphs[index];
+        const literal = node.literals[index];
+        const schema = node.schemas[index];
+        if (graph === undefined || literal === undefined || schema === undefined ||
+            readGraphResultBoolean(graph) === false) {
+            /*
+             * A dispatch arm whose child graph is already false can never accept
+             * input for that discriminant literal, so it is removed from lookup.
+             */
+            changed = true;
+            continue;
+        }
+        literals.push(literal);
+        schemas.push(schema);
+        graphs.push(graph);
+        changed = changed || literals.length - 1 !== index;
+    }
+    if (graphs.length === 0) {
+        return replace(node, ensureConst(nodes, aliases, false));
+    }
+    if (!changed) {
+        return keep(node);
+    }
+    return keep({
+        id: node.id,
+        tag: node.tag,
+        deps: node.deps,
+        value: node.value,
+        key: node.key,
+        literals,
+        schemas,
+        graphs,
+        lookup: makeDiscriminantLookup(literals)
+    });
+}
+/**
+ * @brief Remove impossible general union dispatch arms.
+ * @details Optimizer helpers preserve graph equivalence while shrinking redundant nodes
+ * before code generation consumes the graph.
+ * @param node Union dispatch node to compact.
+ * @param nodes Mutable graph node table used for replacement constants.
+ * @param aliases Alias table updated by replacements.
+ * @returns Compacted dispatch node or constant false when no arm remains.
+ */
+function compactUnionDispatch(node, nodes, aliases) {
+    const options = [];
+    const graphs = [];
+    const masks = [];
+    let changed = false;
+    for (let index = 0; index < node.graphs.length; index += 1) {
+        const graph = node.graphs[index];
+        const option = node.options[index];
+        const mask = node.masks[index];
+        if (graph === undefined || option === undefined || mask === undefined ||
+            mask === 0 || readGraphResultBoolean(graph) === false) {
+            /*
+             * A zero mask or false child graph means the arm has no reachable
+             * runtime domain after earlier folds.
+             */
+            changed = true;
+            continue;
+        }
+        options.push(option);
+        graphs.push(graph);
+        masks.push(mask);
+        changed = changed || graphs.length - 1 !== index;
+    }
+    if (graphs.length === 0) {
+        return replace(node, ensureConst(nodes, aliases, false));
+    }
+    if (!changed) {
+        return keep(node);
+    }
+    return keep({
+        id: node.id,
+        tag: node.tag,
+        deps: node.deps,
+        value: node.value,
+        options,
+        graphs,
+        masks
+    });
+}
+/**
+ * @brief Remove impossible primitive-union dispatch arms.
+ * @details Optimizer helpers preserve graph equivalence while shrinking redundant nodes
+ * before code generation consumes the graph.
+ * @param node Primitive union dispatch node to compact.
+ * @param nodes Mutable graph node table used for replacement constants.
+ * @param aliases Alias table updated by replacements.
+ * @returns Compacted dispatch node or constant false when no arm remains.
+ */
+function compactPrimitiveUnion(node, nodes, aliases) {
+    const graphs = [];
+    const masks = [];
+    let changed = false;
+    for (let index = 0; index < node.graphs.length; index += 1) {
+        const graph = node.graphs[index];
+        const mask = node.masks[index];
+        if (graph === undefined || mask === undefined ||
+            mask === 0 || readGraphResultBoolean(graph) === false) {
+            changed = true;
+            continue;
+        }
+        graphs.push(graph);
+        masks.push(mask);
+        changed = changed || graphs.length - 1 !== index;
+    }
+    if (graphs.length === 0) {
+        return replace(node, ensureConst(nodes, aliases, false));
+    }
+    if (!changed) {
+        return keep(node);
+    }
+    return keep({
+        id: node.id,
+        tag: node.tag,
+        deps: node.deps,
+        value: node.value,
+        graphs,
+        masks
+    });
+}
+/**
+ * @brief Read whether a graph's result is a constant boolean.
+ * @details Optimizer helpers preserve graph equivalence while shrinking redundant nodes
+ * before code generation consumes the graph.
+ * @param graph Child graph to inspect.
+ * @returns Constant boolean result, or undefined for non-constant graphs.
+ */
+function readGraphResultBoolean(graph) {
+    const result = graph.nodes[graph.result];
+    if (result?.tag !== NodeTag.Return) {
+        return undefined;
+    }
+    const value = graph.nodes[result.value];
+    if (value?.tag === NodeTag.Const && typeof value.value === "boolean") {
+        return value.value;
+    }
+    return undefined;
+}
+/**
+ * @brief Build a literal-to-arm lookup for discriminant dispatch.
+ * @details Optimizer helpers preserve graph equivalence while shrinking redundant nodes
+ * before code generation consumes the graph.
+ * @param literals Remaining discriminant literals in arm order.
+ * @returns Frozen null-prototype lookup from literal to compacted arm index.
+ */
+function makeDiscriminantLookup(literals) {
+    const lookup = Object.create(null);
+    for (let index = 0; index < literals.length; index += 1) {
+        const literal = literals[index];
+        if (literal !== undefined) {
+            lookup[literal] = index;
+        }
+    }
+    return Object.freeze(lookup);
+}

package/dist/optimize/remap.d.ts

@@ -1,6 +1,8 @@
 /**
  * @file optimize-remap.ts
  * @brief Dense node-id remapping helpers for graph compaction.
+ * @details Optimizer helpers preserve graph equivalence while shrinking redundant nodes
+ * before code generation consumes the graph.
  */
 import type { GraphNode, NodeId } from "../ir/index.js";
 /**

package/dist/optimize/remap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remap.d.ts","sourceRoot":"","sources":["../../src/optimize/remap.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,MAAM,EACP,MAAM,gBAAgB,CAAC;AAGxB;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,SAAS,CAMX;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAMvE;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAStF"}
+{"version":3,"file":"remap.d.ts","sourceRoot":"","sources":["../../src/optimize/remap.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACR,SAAS,EACT,MAAM,EACT,MAAM,gBAAgB,CAAC;AAGxB;;;;;;GAMG;AACH,wBAAgB,SAAS,CACrB,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,SAAS,MAAM,EAAE,GACzB,SAAS,CAMX;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAMvE;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAStF"}

package/dist/optimize/remap.js

@@ -1,6 +1,8 @@
 /**
  * @file optimize-remap.ts
  * @brief Dense node-id remapping helpers for graph compaction.
+ * @details Optimizer helpers preserve graph equivalence while shrinking redundant nodes
+ * before code generation consumes the graph.
  */
 import { mapNodeIds } from "./map-node.js";
 /**

package/dist/optimize/rewrite.d.ts

@@ -1,21 +1,26 @@
 /**
  * @file rewrite.ts
  * @brief Node dependency rewrite utilities.
+ * @details Optimizer helpers preserve graph equivalence while shrinking redundant nodes
+ * before code generation consumes the graph.
  */
 import type { GraphNode, NodeId } from "../ir/index.js";
 /**
- * @brief rewrite node deps.
- * @details Resolves dependency aliases while preserving the node's own id.
- * @param node Borrowed graph node to rewrite.
- * @param aliases Borrowed alias table produced by the folding pass.
+ * @brief Rewrite dependency ids through the current folding alias table.
+ * @details The node keeps its original id so the folding pass can continue a
+ * stable arena scan while all dependency edges point at canonical replacements.
+ * @param node Graph node to rewrite.
+ * @param aliases Alias table produced by the folding pass.
  * @returns Graph node with dependency ids rewritten through the alias table.
  */
 export declare function rewriteNodeDeps(node: GraphNode, aliases: readonly NodeId[]): GraphNode;
 /**
- * @brief resolve alias.
- * @details Follows an alias chain until it reaches a stable node id.
- * @param value Borrowed node id to resolve.
- * @param aliases Borrowed alias table.
+ * @brief Resolve one node id through a chain of folding aliases.
+ * @details Alias chains appear when a node folds to another node that later
+ * folds again. Resolving to the final stable id keeps dependency rewrites
+ * single-valued before compaction.
+ * @param value Node id to resolve.
+ * @param aliases Alias table produced by the folding pass.
  * @returns Canonical node id for the current folding pass.
  */
 export declare function resolveAlias(value: NodeId, aliases: readonly NodeId[]): NodeId;

package/dist/optimize/rewrite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rewrite.d.ts","sourceRoot":"","sources":["../../src/optimize/rewrite.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,MAAM,EACP,MAAM,gBAAgB,CAAC;AAGxB;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,SAAS,CAMX;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAW9E"}
+{"version":3,"file":"rewrite.d.ts","sourceRoot":"","sources":["../../src/optimize/rewrite.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACR,SAAS,EACT,MAAM,EACT,MAAM,gBAAgB,CAAC;AAGxB;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC3B,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,SAAS,MAAM,EAAE,GAC3B,SAAS,CAMX;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAW9E"}

package/dist/optimize/rewrite.js

@@ -1,23 +1,28 @@
 /**
  * @file rewrite.ts
  * @brief Node dependency rewrite utilities.
+ * @details Optimizer helpers preserve graph equivalence while shrinking redundant nodes
+ * before code generation consumes the graph.
  */
 import { mapNodeIds } from "./map-node.js";
 /**
- * @brief rewrite node deps.
- * @details Resolves dependency aliases while preserving the node's own id.
- * @param node Borrowed graph node to rewrite.
- * @param aliases Borrowed alias table produced by the folding pass.
+ * @brief Rewrite dependency ids through the current folding alias table.
+ * @details The node keeps its original id so the folding pass can continue a
+ * stable arena scan while all dependency edges point at canonical replacements.
+ * @param node Graph node to rewrite.
+ * @param aliases Alias table produced by the folding pass.
  * @returns Graph node with dependency ids rewritten through the alias table.
  */
 export function rewriteNodeDeps(node, aliases) {
     return mapNodeIds(node, (value) => resolveAlias(value, aliases), node.id);
 }
 /**
- * @brief resolve alias.
- * @details Follows an alias chain until it reaches a stable node id.
- * @param value Borrowed node id to resolve.
- * @param aliases Borrowed alias table.
+ * @brief Resolve one node id through a chain of folding aliases.
+ * @details Alias chains appear when a node folds to another node that later
+ * folds again. Resolving to the final stable id keeps dependency rewrites
+ * single-valued before compaction.
+ * @param value Node id to resolve.
+ * @param aliases Alias table produced by the folding pass.
  * @returns Canonical node id for the current folding pass.
  */
 export function resolveAlias(value, aliases) {

package/dist/plan/cache.d.ts

@@ -1,19 +1,25 @@
 /**
  * @file cache.ts
  * @brief Validation plan cache.
+ * @details Plan helpers keep schema-specialized execution aligned with optimized IR while
+ * preserving interpreter parity.
  */
 import type { Schema } from "../schema/index.js";
 import type { ValidationPlan } from "./types.js";
 /**
- * @brief make validation plan.
+ * @brief Build or reuse the optimized validation plan for a schema identity.
  * @details Lowers a schema into Sea-of-Nodes IR, runs the optimizer, and caches
- * the resulting graph for all runtime users of the schema.
+ * the resulting graph for all runtime users of the schema. Schema objects are
+ * immutable after construction, so identity is a stable cache key.
+ * @param schema Schema whose execution plan is requested.
  * @returns Cached or freshly built validation plan for the schema identity.
  */
 export declare function makeValidationPlan(schema: Schema): ValidationPlan;
 /**
- * @brief schema requires tracking.
+ * @brief Decide whether validation needs active schema/value pair tracking.
  * @details Returns true only for schemas that can recurse through `lazy`.
+ * Non-recursive schemas can skip the WeakMap bookkeeping on the hot path.
+ * @param schema Schema being analyzed.
  * @returns True when active schema/value pair tracking is required.
  */
 export declare function schemaRequiresTracking(schema: Schema): boolean;

package/dist/plan/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/plan/cache.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAgBjD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAYjE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAQ9D"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/plan/cache.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAgBjD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAYjE;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAQ9D"}

package/dist/plan/cache.js

@@ -1,6 +1,8 @@
 /**
  * @file cache.ts
  * @brief Validation plan cache.
+ * @details Plan helpers keep schema-specialized execution aligned with optimized IR while
+ * preserving interpreter parity.
  */
 import { lowerSchema } from "../lower/index.js";
 import { SchemaTag } from "../kind/index.js";
@@ -18,9 +20,11 @@ const planCache = new WeakMap();
  */
 const trackingCache = new WeakMap();
 /**
- * @brief make validation plan.
+ * @brief Build or reuse the optimized validation plan for a schema identity.
  * @details Lowers a schema into Sea-of-Nodes IR, runs the optimizer, and caches
- * the resulting graph for all runtime users of the schema.
+ * the resulting graph for all runtime users of the schema. Schema objects are
+ * immutable after construction, so identity is a stable cache key.
+ * @param schema Schema whose execution plan is requested.
  * @returns Cached or freshly built validation plan for the schema identity.
  */
 export function makeValidationPlan(schema) {
@@ -37,8 +41,10 @@ export function makeValidationPlan(schema) {
     return plan;
 }
 /**
- * @brief schema requires tracking.
+ * @brief Decide whether validation needs active schema/value pair tracking.
  * @details Returns true only for schemas that can recurse through `lazy`.
+ * Non-recursive schemas can skip the WeakMap bookkeeping on the hot path.
+ * @param schema Schema being analyzed.
  * @returns True when active schema/value pair tracking is required.
  */
 export function schemaRequiresTracking(schema) {
@@ -51,7 +57,12 @@ export function schemaRequiresTracking(schema) {
     return result;
 }
 /**
- * @brief schema requires tracking inner.
+ * @brief Walk a schema tree looking for lazy recursion boundaries.
+ * @details Plan helpers keep schema-specialized execution aligned with optimized IR while
+ * preserving interpreter parity.
+ * @param schema Current schema node.
+ * @param seen Schema identities already visited in this walk.
+ * @returns True when a reachable node can re-enter validation recursively.
  */
 function schemaRequiresTrackingInner(schema, seen) {
     if (seen.has(schema)) {
@@ -64,9 +75,19 @@ function schemaRequiresTrackingInner(schema, seen) {
         case SchemaTag.Array:
             return schemaRequiresTrackingInner(schema.item, seen);
         case SchemaTag.Tuple:
-            return schemaArrayRequiresTracking(schema.items, seen);
+            return schemaArrayRequiresTracking(schema.items, seen) ||
+                (schema.rest !== undefined &&
+                    schemaRequiresTrackingInner(schema.rest, seen));
         case SchemaTag.Record:
             return schemaRequiresTrackingInner(schema.value, seen);
+        case SchemaTag.Map:
+            return schemaRequiresTrackingInner(schema.key, seen) ||
+                schemaRequiresTrackingInner(schema.value, seen);
+        case SchemaTag.Set:
+            return schemaRequiresTrackingInner(schema.item, seen);
+        case SchemaTag.Property:
+            return schemaRequiresTrackingInner(schema.base, seen) ||
+                schemaRequiresTrackingInner(schema.value, seen);
         case SchemaTag.Object:
             for (let index = 0; index < schema.entries.length; index += 1) {
                 const entry = schema.entries[index];
@@ -101,6 +122,8 @@ function schemaRequiresTrackingInner(schema, seen) {
         case SchemaTag.Never:
         case SchemaTag.String:
         case SchemaTag.Number:
+        case SchemaTag.Date:
+        case SchemaTag.InstanceOf:
         case SchemaTag.BigInt:
         case SchemaTag.Symbol:
         case SchemaTag.Boolean:
@@ -109,7 +132,12 @@ function schemaRequiresTrackingInner(schema, seen) {
     }
 }
 /**
- * @brief schema array requires tracking.
+ * @brief Scan a vector of child schemas for recursion tracking needs.
+ * @details Plan helpers keep schema-specialized execution aligned with optimized IR while
+ * preserving interpreter parity.
+ * @param schemas Child schema vector.
+ * @param seen Schema identities already visited in this walk.
+ * @returns True when at least one child requires active-pair tracking.
  */
 function schemaArrayRequiresTracking(schemas, seen) {
     for (let index = 0; index < schemas.length; index += 1) {

package/dist/plan/index.d.ts

@@ -1,6 +1,8 @@
 /**
  * @file index.ts
  * @brief Validation plan module aggregation.
+ * @details This barrel keeps public import paths stable while implementation files remain
+ * split by responsibility.
  */
 export { makeValidationPlan, schemaRequiresTracking } from "./cache.js";
 export { executeGraphPredicate, executeSchemaPredicate, executeSchemaPredicateWithState } from "./predicate.js";

package/dist/plan/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plan/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACxE,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,+BAA+B,EAChC,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plan/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACxE,OAAO,EACH,qBAAqB,EACrB,sBAAsB,EACtB,+BAA+B,EAClC,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}

package/dist/plan/index.js

@@ -1,6 +1,8 @@
 /**
  * @file index.ts
  * @brief Validation plan module aggregation.
+ * @details This barrel keeps public import paths stable while implementation files remain
+ * split by responsibility.
  */
 export { makeValidationPlan, schemaRequiresTracking } from "./cache.js";
 export { executeGraphPredicate, executeSchemaPredicate, executeSchemaPredicateWithState } from "./predicate.js";

package/dist/plan/predicate.d.ts

@@ -1,6 +1,8 @@
 /**
  * @file predicate.ts
  * @brief Sea-of-Nodes predicate executor.
+ * @details Plan helpers keep schema-specialized execution aligned with optimized IR while
+ * preserving interpreter parity.
  */
 import type { Graph } from "../ir/index.js";
 import { type Schema } from "../schema/index.js";

package/dist/plan/predicate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"predicate.d.ts","sourceRoot":"","sources":["../../src/plan/predicate.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EACV,KAAK,EAGN,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAEL,KAAK,MAAM,EACZ,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAKL,KAAK,eAAe,EACrB,MAAM,sBAAsB,CAAC;AAI9B;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,GACb,OAAO,CAET;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,eAAe,GACrB,OAAO,CAcT;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,eAAe,GACrB,OAAO,CAaT"}
+{"version":3,"file":"predicate.d.ts","sourceRoot":"","sources":["../../src/plan/predicate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH,OAAO,KAAK,EACR,KAAK,EAIR,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAIH,KAAK,MAAM,EACd,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAKH,KAAK,eAAe,EACvB,MAAM,sBAAsB,CAAC;AAI9B;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAClC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,GACf,OAAO,CAET;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC3C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,eAAe,GACvB,OAAO,CAcT;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACjC,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,eAAe,GACvB,OAAO,CAaT"}