typesea 0.1.0 → 0.2.0

package/dist/optimize/fold-constraints.js

@@ -0,0 +1,484 @@
+/**
+ * @file fold-constraints.ts
+ * @brief Boolean constraint canonicalization for pure predicate runs.
+ * @details Optimizer helpers preserve graph equivalence while shrinking redundant nodes
+ * before code generation consumes the graph.
+ */
+import { NodeTag } from "../kind/index.js";
+import { readConst } from "./fold-common.js";
+/**
+ * @brief Numeric tags for runtime type facts extracted from predicate nodes.
+ * @details Numeric tags keep fact comparisons cheap and avoid string switching
+ * in the tight canonicalization scan.
+ */
+const TypeFactTag = {
+    String: 1,
+    Number: 2,
+    Boolean: 3,
+    BigInt: 4,
+    Symbol: 5,
+    Object: 6,
+    Array: 7,
+    Undefined: 8,
+    Null: 9
+};
+/**
+ * @brief canonicalize and values.
+ * @details Removes duplicate predicates and dominated scalar bounds while keeping
+ * the first observable execution order intact. Only the pure prefix may collapse
+ * the whole conjunction to `false`.
+ * @returns Canonical node id vector or a contradiction marker.
+ */
+export function canonicalizeAndValues(values, nodes) {
+    const omitted = new Array(values.length).fill(false);
+    const seen = new Set();
+    const pureEnd = findPurePrefixEnd(values, nodes);
+    omitDuplicateIds(values, omitted, seen);
+    if (canonicalizeTypeFacts(values, nodes, omitted, pureEnd)) {
+        return {
+            contradiction: true,
+            values: []
+        };
+    }
+    if (canonicalizeStringBounds(values, nodes, omitted, pureEnd)) {
+        return {
+            contradiction: true,
+            values: []
+        };
+    }
+    if (canonicalizeNumericBounds(values, nodes, omitted, pureEnd)) {
+        return {
+            contradiction: true,
+            values: []
+        };
+    }
+    return {
+        contradiction: false,
+        values: collectKeptValues(values, omitted)
+    };
+}
+/**
+ * @brief canonicalize or values.
+ * @details Removes repeated node ids. Repeated ids are already memoized by graph
+ * execution, so this only shrinks emitted boolean expressions.
+ * @returns Canonical node id vector.
+ */
+export function canonicalizeOrValues(values) {
+    const kept = [];
+    const seen = new Set();
+    for (let index = 0; index < values.length; index += 1) {
+        const value = values[index];
+        if (value === undefined || seen.has(value)) {
+            continue;
+        }
+        seen.add(value);
+        kept.push(value);
+    }
+    return kept;
+}
+/**
+ * @brief Mark repeated node ids as omitted while preserving first occurrence.
+ * @details Graph execution memoizes node results, so repeated ids inside the
+ * same boolean fold only inflate generated expressions.
+ * @param values Original fold input node ids.
+ * @param omitted Mutable omission bitmap aligned with `values`.
+ * @param seen Mutable set used by the caller for duplicate tracking.
+ */
+function omitDuplicateIds(values, omitted, seen) {
+    for (let index = 0; index < values.length; index += 1) {
+        const value = values[index];
+        if (value === undefined) {
+            omitted[index] = true;
+            continue;
+        }
+        if (seen.has(value)) {
+            omitted[index] = true;
+            continue;
+        }
+        seen.add(value);
+    }
+}
+/**
+ * @brief Remove duplicate type predicates and detect impossible type pairs.
+ * @details The scan is limited to the pure prefix so dynamic schema checks and
+ * composite loops keep their original execution order. Conflicting facts turn
+ * the whole conjunction into a contradiction.
+ * @param values Original fold input node ids.
+ * @param nodes Graph node table.
+ * @param omitted Mutable omission bitmap aligned with `values`.
+ * @param end Exclusive end of the pure scalar prefix.
+ * @returns True when the facts prove the conjunction impossible.
+ */
+function canonicalizeTypeFacts(values, nodes, omitted, end) {
+    const facts = new Map();
+    for (let index = 0; index < end; index += 1) {
+        if (omitted[index] === true) {
+            continue;
+        }
+        const id = values[index];
+        const node = id === undefined ? undefined : nodes[id];
+        const fact = node === undefined ? undefined : readTypeFact(node, index);
+        if (id === undefined || fact === undefined) {
+            continue;
+        }
+        const previous = facts.get(fact.value);
+        if (previous === undefined) {
+            facts.set(fact.value, fact);
+            continue;
+        }
+        if (previous.tag !== fact.tag) {
+            return true;
+        }
+        if (previous.tag === TypeFactTag.Number && previous.integer !== fact.integer) {
+            if (previous.integer) {
+                omitted[index] = true;
+            }
+            else {
+                omitted[previous.index] = true;
+                facts.set(fact.value, fact);
+            }
+            continue;
+        }
+        omitted[index] = true;
+    }
+    return false;
+}
+/**
+ * @brief Keep only the strongest string-length bounds in the pure prefix.
+ * @details Weaker bounds are marked omitted, while crossing min/max bounds prove
+ * the conjunction false before runtime.
+ * @param values Original fold input node ids.
+ * @param nodes Graph node table.
+ * @param omitted Mutable omission bitmap aligned with `values`.
+ * @param end Exclusive end of the pure scalar prefix.
+ * @returns True when the bounds prove the conjunction impossible.
+ */
+function canonicalizeStringBounds(values, nodes, omitted, end) {
+    const bounds = new Map();
+    for (let index = 0; index < end; index += 1) {
+        if (omitted[index] === true) {
+            continue;
+        }
+        const id = values[index];
+        const node = id === undefined ? undefined : nodes[id];
+        if (node?.tag !== NodeTag.StringMin && node?.tag !== NodeTag.StringMax) {
+            continue;
+        }
+        const slot = readStringBounds(bounds, node.value);
+        if (node.tag === NodeTag.StringMin) {
+            keepStrongestMin(omitted, slot, index, node.bound);
+        }
+        else {
+            keepStrongestMax(omitted, slot, index, node.bound);
+        }
+        if (hasImpossibleBounds(slot)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * @brief Keep only the strongest finite numeric bounds in the pure prefix.
+ * @details The pass ignores non-constant and non-finite comparisons because
+ * those do not create stable static intervals.
+ * @param values Original fold input node ids.
+ * @param nodes Graph node table.
+ * @param omitted Mutable omission bitmap aligned with `values`.
+ * @param end Exclusive end of the pure scalar prefix.
+ * @returns True when the bounds prove the conjunction impossible.
+ */
+function canonicalizeNumericBounds(values, nodes, omitted, end) {
+    const bounds = new Map();
+    for (let index = 0; index < end; index += 1) {
+        if (omitted[index] === true) {
+            continue;
+        }
+        const id = values[index];
+        const node = id === undefined ? undefined : nodes[id];
+        if (node?.tag !== NodeTag.Gte && node?.tag !== NodeTag.Lte) {
+            continue;
+        }
+        const right = readConst(nodes, node.right);
+        if (!right.found || typeof right.value !== "number" ||
+            !Number.isFinite(right.value)) {
+            continue;
+        }
+        const slot = readNumericBounds(bounds, node.left);
+        if (node.tag === NodeTag.Gte) {
+            keepStrongestGte(omitted, slot, index, right.value);
+        }
+        else {
+            keepStrongestLte(omitted, slot, index, right.value);
+        }
+        if (hasImpossibleNumericBounds(slot)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * @brief Convert a primitive predicate node into a type fact.
+ * @details Constraint folding uses these facts to remove redundant checks and
+ * to detect impossible type intersections. Nodes without direct type meaning
+ * return undefined and remain under normal folding control.
+ * @param node Graph node to classify.
+ * @param index Node id currently being scanned.
+ * @returns Type fact for primitive predicate nodes, otherwise undefined.
+ */
+function readTypeFact(node, index) {
+    switch (node.tag) {
+        case NodeTag.IsString:
+            return makeTypeFact(TypeFactTag.String, node.value, false, index);
+        case NodeTag.IsNumber:
+            return makeTypeFact(TypeFactTag.Number, node.value, false, index);
+        case NodeTag.IsInteger:
+            return makeTypeFact(TypeFactTag.Number, node.value, true, index);
+        case NodeTag.IsBoolean:
+            return makeTypeFact(TypeFactTag.Boolean, node.value, false, index);
+        case NodeTag.IsBigInt:
+            return makeTypeFact(TypeFactTag.BigInt, node.value, false, index);
+        case NodeTag.IsSymbol:
+            return makeTypeFact(TypeFactTag.Symbol, node.value, false, index);
+        case NodeTag.IsObject:
+            return makeTypeFact(TypeFactTag.Object, node.value, false, index);
+        case NodeTag.IsArray:
+            return makeTypeFact(TypeFactTag.Array, node.value, false, index);
+        case NodeTag.IsUndefined:
+            return makeTypeFact(TypeFactTag.Undefined, node.value, false, index);
+        case NodeTag.IsNull:
+            return makeTypeFact(TypeFactTag.Null, node.value, false, index);
+        default:
+            return undefined;
+    }
+}
+/**
+ * @brief Pack the normalized type fact used by the constraint pass.
+ * @details The `integer` bit distinguishes `number` from `integer` predicates
+ * without introducing a separate domain family, which keeps conflict checks
+ * small and branch-free.
+ * @param tag Runtime domain proven by the predicate.
+ * @param value Node id whose type is constrained.
+ * @param integer True when the predicate is the integer subtype check.
+ * @param index Node id of the predicate that produced the fact.
+ * @returns Type fact record used by later scans.
+ */
+function makeTypeFact(tag, value, integer, index) {
+    return {
+        tag,
+        value,
+        integer,
+        index
+    };
+}
+/**
+ * @brief Get or create the accumulated string-length bounds for a value node.
+ * @details A mutable slot lets multiple `minLength` and `maxLength` predicates
+ * compete while the pass marks weaker predicates for omission.
+ * @param bounds Map from value node id to accumulated string bounds.
+ * @param value Node id whose string bounds are being tracked.
+ * @returns Mutable bounds slot for that value node.
+ */
+function readStringBounds(bounds, value) {
+    const cached = bounds.get(value);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const slot = {
+        min: undefined,
+        max: undefined
+    };
+    bounds.set(value, slot);
+    return slot;
+}
+/**
+ * @brief Get or create the accumulated numeric bounds for a value node.
+ * @details The pass stores lower and upper numeric limits separately so it can
+ * keep the strongest surviving predicate while also detecting impossible ranges.
+ * @param bounds Map from value node id to accumulated numeric bounds.
+ * @param value Node id whose numeric bounds are being tracked.
+ * @returns Mutable bounds slot for that value node.
+ */
+function readNumericBounds(bounds, value) {
+    const cached = bounds.get(value);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const slot = {
+        gte: undefined,
+        lte: undefined
+    };
+    bounds.set(value, slot);
+    return slot;
+}
+/**
+ * @brief Keep the strongest string lower bound in an accumulated slot.
+ * @details A larger minimum dominates a smaller one. The dominated predicate is
+ * marked in the original omission bitmap so final collection remains ordered.
+ * @param omitted Mutable omission bitmap aligned with the fold inputs.
+ * @param slot Accumulated bounds for one value node.
+ * @param index Position of the candidate predicate.
+ * @param bound Candidate minimum length.
+ */
+function keepStrongestMin(omitted, slot, index, bound) {
+    if (slot.min === undefined || bound >= slot.min.bound) {
+        if (slot.min !== undefined) {
+            omitted[slot.min.index] = true;
+        }
+        slot.min = {
+            index,
+            bound
+        };
+        return;
+    }
+    omitted[index] = true;
+}
+/**
+ * @brief Keep the strongest string upper bound in an accumulated slot.
+ * @details A smaller maximum dominates a larger one and preserves the same
+ * runtime acceptance set.
+ * @param omitted Mutable omission bitmap aligned with the fold inputs.
+ * @param slot Accumulated bounds for one value node.
+ * @param index Position of the candidate predicate.
+ * @param bound Candidate maximum length.
+ */
+function keepStrongestMax(omitted, slot, index, bound) {
+    if (slot.max === undefined || bound <= slot.max.bound) {
+        if (slot.max !== undefined) {
+            omitted[slot.max.index] = true;
+        }
+        slot.max = {
+            index,
+            bound
+        };
+        return;
+    }
+    omitted[index] = true;
+}
+/**
+ * @brief Keep the strongest numeric lower bound in an accumulated slot.
+ * @details A larger inclusive lower bound dominates a smaller one for the same
+ * numeric value node.
+ * @param omitted Mutable omission bitmap aligned with the fold inputs.
+ * @param slot Accumulated bounds for one value node.
+ * @param index Position of the candidate predicate.
+ * @param bound Candidate inclusive lower bound.
+ */
+function keepStrongestGte(omitted, slot, index, bound) {
+    if (slot.gte === undefined || bound >= slot.gte.bound) {
+        if (slot.gte !== undefined) {
+            omitted[slot.gte.index] = true;
+        }
+        slot.gte = {
+            index,
+            bound
+        };
+        return;
+    }
+    omitted[index] = true;
+}
+/**
+ * @brief Keep the strongest numeric upper bound in an accumulated slot.
+ * @details A smaller inclusive upper bound dominates a larger one for the same
+ * numeric value node.
+ * @param omitted Mutable omission bitmap aligned with the fold inputs.
+ * @param slot Accumulated bounds for one value node.
+ * @param index Position of the candidate predicate.
+ * @param bound Candidate inclusive upper bound.
+ */
+function keepStrongestLte(omitted, slot, index, bound) {
+    if (slot.lte === undefined || bound <= slot.lte.bound) {
+        if (slot.lte !== undefined) {
+            omitted[slot.lte.index] = true;
+        }
+        slot.lte = {
+            index,
+            bound
+        };
+        return;
+    }
+    omitted[index] = true;
+}
+/**
+ * @brief Detect a statically impossible string-length interval.
+ * @details Optimizer helpers preserve graph equivalence while shrinking redundant nodes
+ * before code generation consumes the graph.
+ * @param slot Accumulated string bounds for one value node.
+ * @returns True when minimum length exceeds maximum length.
+ */
+function hasImpossibleBounds(slot) {
+    return slot.min !== undefined &&
+        slot.max !== undefined &&
+        slot.min.bound > slot.max.bound;
+}
+/**
+ * @brief Detect a statically impossible numeric interval.
+ * @details Optimizer helpers preserve graph equivalence while shrinking redundant nodes
+ * before code generation consumes the graph.
+ * @param slot Accumulated numeric bounds for one value node.
+ * @returns True when lower bound exceeds upper bound.
+ */
+function hasImpossibleNumericBounds(slot) {
+    return slot.gte !== undefined &&
+        slot.lte !== undefined &&
+        slot.gte.bound > slot.lte.bound;
+}
+/**
+ * @brief Find the prefix of fold inputs that can be reordered semantically.
+ * @details Pure scalar checks have no callbacks, loops, or schema recursion.
+ * The pass stops before composite or dynamic nodes so optimization cannot hide
+ * observable validation behavior.
+ * @param values Original fold input node ids.
+ * @param nodes Graph node table.
+ * @returns Exclusive index where pure scalar processing must stop.
+ */
+function findPurePrefixEnd(values, nodes) {
+    for (let index = 0; index < values.length; index += 1) {
+        const id = values[index];
+        const node = id === undefined ? undefined : nodes[id];
+        if (node === undefined || !isPureScalarNode(node)) {
+            return index;
+        }
+    }
+    return values.length;
+}
+/**
+ * @brief Decide whether a graph node is safe for scalar constraint folding.
+ * @details Composite loops, union dispatch, and SchemaCheck may trigger dynamic
+ * behavior or nested validation, so they form a barrier for this pass.
+ * @param node Graph node to classify.
+ * @returns True for scalar predicate nodes handled by local constraint folding.
+ */
+function isPureScalarNode(node) {
+    switch (node.tag) {
+        case NodeTag.SchemaCheck:
+        case NodeTag.ArrayEvery:
+        case NodeTag.TupleItems:
+        case NodeTag.RecordEvery:
+        case NodeTag.DiscriminantDispatch:
+        case NodeTag.ObjectShape:
+        case NodeTag.UnionDispatch:
+        case NodeTag.And:
+        case NodeTag.Or:
+            return false;
+        default:
+            return true;
+    }
+}
+/**
+ * @brief Rebuild the fold input vector after omission marks are applied.
+ * @details Values are appended in their original order so generated code keeps
+ * the same left-to-right scalar check sequence after simplification.
+ * @param values Original fold input node ids.
+ * @param omitted Omission bitmap aligned with `values`.
+ * @returns Compact vector containing only surviving node ids.
+ */
+function collectKeptValues(values, omitted) {
+    const kept = [];
+    for (let index = 0; index < values.length; index += 1) {
+        const value = values[index];
+        if (value !== undefined && omitted[index] !== true) {
+            kept.push(value);
+        }
+    }
+    return kept;
+}

package/dist/optimize/fold-scalar.d.ts

@@ -1,59 +1,144 @@
 /**
  * @file fold-scalar.ts
  * @brief Constant folding for scalar graph nodes.
+ * @details Optimizer helpers preserve graph equivalence while shrinking redundant nodes
+ * before code generation consumes the graph.
  */
 import type { ArrayEveryNode, DiscriminantDispatchNode, EqualsNode, GetPropNode, GraphNode, HasOwnDataNode, HasOwnNode, NodeId, NumericCompareNode, RecordEveryNode, RegexNode, StrictKeysNode, StringBoundNode, TupleItemsNode, UnaryPredicateNode } from "../ir/index.js";
 import { type FoldResult } from "./fold-common.js";
 /**
- * @brief fold get prop.
+ * @brief Fold property reads whose receiver is already a literal constant.
+ * @details Lowered graphs never materialize object literals as safe Const data,
+ * so a constant receiver cannot provide a trustworthy property slot. The node
+ * folds to undefined instead of executing user accessors during optimization.
+ * @param node Property-read node to fold.
+ * @param nodes Mutable graph node table for constant interning.
+ * @param aliases Mutable alias table updated when a constant is inserted.
+ * @returns Fold result for the property read.
  */
 export declare function foldGetProp(node: GetPropNode, nodes: GraphNode[], aliases: NodeId[]): FoldResult;
 /**
- * @brief fold unary.
+ * @brief Fold unary predicate nodes when their subject is constant.
+ * @details Each predicate mirrors the runtime validator's exact primitive test,
+ * including finite-number and plain-record semantics, so compile-time folding
+ * cannot widen the accepted value set.
+ * @param node Unary predicate node to fold.
+ * @param nodes Mutable graph node table for constant interning.
+ * @param aliases Mutable alias table updated when a constant is inserted.
+ * @returns Fold result for the predicate.
  */
 export declare function foldUnary(node: UnaryPredicateNode, nodes: GraphNode[], aliases: NodeId[]): FoldResult;
 /**
- * @brief fold equals.
+ * @brief Fold literal equality when both operands are constants.
+ * @details `Object.is` is used so NaN and negative zero follow TypeSea literal
+ * equality semantics instead of JavaScript `===` corner cases.
+ * @param node Equality node to fold.
+ * @param nodes Mutable graph node table for constant interning.
+ * @param aliases Mutable alias table updated when a constant is inserted.
+ * @returns Fold result for the equality node.
  */
 export declare function foldEquals(node: EqualsNode, nodes: GraphNode[], aliases: NodeId[]): FoldResult;
 /**
- * @brief fold numeric.
+ * @brief Fold numeric comparisons with two constant operands.
+ * @details Non-number operands fold to false, matching the runtime predicate
+ * path where numeric schema checks require number values before comparison.
+ * @param node Numeric comparison node to fold.
+ * @param nodes Mutable graph node table for constant interning.
+ * @param aliases Mutable alias table updated when a constant is inserted.
+ * @returns Fold result for the comparison node.
  */
 export declare function foldNumeric(node: NumericCompareNode, nodes: GraphNode[], aliases: NodeId[]): FoldResult;
 /**
- * @brief fold string bound.
+ * @brief Fold string length predicates with a constant subject.
+ * @details Non-string subjects fold to false because the separate string guard
+ * may later be removed or reordered by boolean simplification.
+ * @param node String bound node to fold.
+ * @param nodes Mutable graph node table for constant interning.
+ * @param aliases Mutable alias table updated when a constant is inserted.
+ * @returns Fold result for the string bound node.
  */
 export declare function foldStringBound(node: StringBoundNode, nodes: GraphNode[], aliases: NodeId[]): FoldResult;
 /**
- * @brief fold regex.
+ * @brief Fold regular expression checks with a constant string subject.
+ * @details `lastIndex` is reset before and after the test so global or sticky
+ * expressions cannot leak state across optimizer and runtime use.
+ * @param node Regex node to fold.
+ * @param nodes Mutable graph node table for constant interning.
+ * @param aliases Mutable alias table updated when a constant is inserted.
+ * @returns Fold result for the regex node.
  */
 export declare function foldRegex(node: RegexNode, nodes: GraphNode[], aliases: NodeId[]): FoldResult;
 /**
- * @brief fold has own.
+ * @brief Fold own-property presence checks on constant receivers.
+ * @details Const nodes do not carry safe object identity, so the optimizer never
+ * inspects properties here. A constant receiver means the object check cannot be
+ * satisfied through this IR path and folds to false.
+ * @param node Own-property check node to fold.
+ * @param nodes Mutable graph node table for constant interning.
+ * @param aliases Mutable alias table updated when a constant is inserted.
+ * @returns Fold result for the own-property check.
  */
 export declare function foldHasOwn(node: HasOwnNode, nodes: GraphNode[], aliases: NodeId[]): FoldResult;
 /**
- * @brief fold has own data.
+ * @brief Fold own-data-property checks on constant receivers.
+ * @details The optimizer refuses to execute descriptors or getters. Constant
+ * receivers therefore fold to false instead of probing runtime object state.
+ * @param node Own-data-property check node to fold.
+ * @param nodes Mutable graph node table for constant interning.
+ * @param aliases Mutable alias table updated when a constant is inserted.
+ * @returns Fold result for the data-property check.
  */
 export declare function foldHasOwnData(node: HasOwnDataNode, nodes: GraphNode[], aliases: NodeId[]): FoldResult;
 /**
- * @brief fold strict keys.
+ * @brief Fold strict-key checks on constant receivers.
+ * @details Strict-key validation depends on own property keys. The optimizer
+ * does not enumerate runtime objects, so constant receivers fold to false and
+ * non-constant receivers stay intact.
+ * @param node Strict-key node to fold.
+ * @param nodes Mutable graph node table for constant interning.
+ * @param aliases Mutable alias table updated when a constant is inserted.
+ * @returns Fold result for the strict-key node.
  */
 export declare function foldStrictKeys(node: StrictKeysNode, nodes: GraphNode[], aliases: NodeId[]): FoldResult;
 /**
- * @brief fold array every.
+ * @brief Fold array iteration nodes with constant receivers.
+ * @details Iteration semantics require reading runtime indexes and child
+ * schemas. Constants cannot safely stand in for arrays here, so the node folds
+ * to false only when the receiver is already constant.
+ * @param node Array iteration node to fold.
+ * @param nodes Mutable graph node table for constant interning.
+ * @param aliases Mutable alias table updated when a constant is inserted.
+ * @returns Fold result for the array iteration node.
  */
 export declare function foldArrayEvery(node: ArrayEveryNode, nodes: GraphNode[], aliases: NodeId[]): FoldResult;
 /**
- * @brief fold tuple items.
+ * @brief Fold tuple item checks with constant receivers.
+ * @details Tuple validation depends on array length and descriptor-backed item
+ * reads, so the optimizer does not simulate it for constant receivers.
+ * @param node Tuple item node to fold.
+ * @param nodes Mutable graph node table for constant interning.
+ * @param aliases Mutable alias table updated when a constant is inserted.
+ * @returns Fold result for the tuple item node.
  */
 export declare function foldTupleItems(node: TupleItemsNode, nodes: GraphNode[], aliases: NodeId[]): FoldResult;
 /**
- * @brief fold record every.
+ * @brief Fold record iteration nodes with constant receivers.
+ * @details Record validation must enumerate own keys at runtime. The optimizer
+ * keeps non-constant records intact and folds constant receivers closed.
+ * @param node Record iteration node to fold.
+ * @param nodes Mutable graph node table for constant interning.
+ * @param aliases Mutable alias table updated when a constant is inserted.
+ * @returns Fold result for the record iteration node.
  */
 export declare function foldRecordEvery(node: RecordEveryNode, nodes: GraphNode[], aliases: NodeId[]): FoldResult;
 /**
- * @brief fold discriminant dispatch.
+ * @brief Fold discriminant dispatch nodes with constant receivers.
+ * @details Dispatch requires an object tag read, which the optimizer does not
+ * perform on constants. Non-constant receivers remain available for codegen.
+ * @param node Discriminant dispatch node to fold.
+ * @param nodes Mutable graph node table for constant interning.
+ * @param aliases Mutable alias table updated when a constant is inserted.
+ * @returns Fold result for the dispatch node.
  */
 export declare function foldDiscriminantDispatch(node: DiscriminantDispatchNode, nodes: GraphNode[], aliases: NodeId[]): FoldResult;
 //# sourceMappingURL=fold-scalar.d.ts.map

package/dist/optimize/fold-scalar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fold-scalar.d.ts","sourceRoot":"","sources":["../../src/optimize/fold-scalar.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EACV,cAAc,EACd,wBAAwB,EACxB,UAAU,EACV,WAAW,EACX,SAAS,EACT,cAAc,EACd,UAAU,EACV,MAAM,EACN,kBAAkB,EAClB,eAAe,EACf,SAAS,EACT,cAAc,EACd,eAAe,EACf,cAAc,EACd,kBAAkB,EACnB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAOL,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAC;AAE1B;;GAEG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAChB,UAAU,CAMZ;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,kBAAkB,EACxB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAChB,UAAU,CA6BZ;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAChB,UAAU,CAOZ;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,kBAAkB,EACxB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAChB,UAAU,CAWZ;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,eAAe,EACrB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAChB,UAAU,CASZ;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAChB,UAAU,CAYZ;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAChB,UAAU,CAMZ;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAChB,UAAU,CAMZ;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAChB,UAAU,CAMZ;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAChB,UAAU,CAMZ;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAChB,UAAU,CAMZ;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,eAAe,EACrB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAChB,UAAU,CAMZ;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,wBAAwB,EAC9B,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAChB,UAAU,CAMZ"}
+{"version":3,"file":"fold-scalar.d.ts","sourceRoot":"","sources":["../../src/optimize/fold-scalar.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EACR,cAAc,EACd,wBAAwB,EACxB,UAAU,EACV,WAAW,EACX,SAAS,EACT,cAAc,EACd,UAAU,EACV,MAAM,EACN,kBAAkB,EAClB,eAAe,EACf,SAAS,EACT,cAAc,EACd,eAAe,EACf,cAAc,EACd,kBAAkB,EACrB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAOH,KAAK,UAAU,EAClB,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACvB,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAClB,UAAU,CAMZ;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CACrB,IAAI,EAAE,kBAAkB,EACxB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAClB,UAAU,CA6BZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACtB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAClB,UAAU,CAOZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACvB,IAAI,EAAE,kBAAkB,EACxB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAClB,UAAU,CAWZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC3B,IAAI,EAAE,eAAe,EACrB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAClB,UAAU,CASZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACrB,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAClB,UAAU,CAYZ;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACtB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAClB,UAAU,CAMZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC1B,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAClB,UAAU,CAMZ;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC1B,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAClB,UAAU,CAMZ;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC1B,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAClB,UAAU,CAMZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC1B,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAClB,UAAU,CAMZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC3B,IAAI,EAAE,eAAe,EACrB,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAClB,UAAU,CAMZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACpC,IAAI,EAAE,wBAAwB,EAC9B,KAAK,EAAE,SAAS,EAAE,EAClB,OAAO,EAAE,MAAM,EAAE,GAClB,UAAU,CAMZ"}