@nudojs/core 1.0.0 → 1.0.1

package/dist/index.js

@@ -59,14 +59,17 @@ import {
   MAX_CALL_DEPTH,
   MAX_TOTAL_CALLS,
   NudoThrow,
+  abortDerivationSession,
   abs,
   absFunction,
+  absShapeKey,
   absTemplateViews,
   absToString,
   add,
   allFixedTextOfViews,
   alphaOf,
   analyzeFn,
+  analyzeFnFull,
   and,
   anyVar,
   app,
@@ -76,12 +79,14 @@ import {
   asAbsVal,
   attachFnImpl,
   awaitAbs,
+  beginDerivationSession,
   betaOf,
   bindImports,
   bool,
   boolLit,
   callAbsMethod,
   callFunction,
+  callFunctionFull,
   callTranspiledExport,
   callTranspiledExportFull,
   classFromMethods,
@@ -101,9 +106,11 @@ import {
   defaultLeakBudget,
   defineClass,
   definitelyNotNullishShape,
+  derivationChain,
   div,
   emptyEnv,
   emptyPhi,
+  endDerivationSession,
   eq,
   evalArrayStatic,
   evalBuiltinInstanceMethod,
@@ -139,11 +146,13 @@ import {
   getBClass,
   getClass,
   getClassChain,
+  getDerivation,
   getFnImpl,
   getParseSourceCacheSize,
   getSlot,
   gt,
   gtNum,
+  hasDerivationSession,
   implies,
   instanceOf,
   instantiateClass,
@@ -189,6 +198,8 @@ import {
   never,
   not,
   notAbs,
+  noteDerivationAdd,
+  noteDerivationJoin,
   noteMemberDispatchMiss,
   notePrimMemberMissing,
   noteUnknownMemberMissing,
@@ -206,6 +217,7 @@ import {
   predToString,
   predVars,
   projectBrand,
+  projectDerivationDsl,
   projectFlatMapResult,
   promoteParamShape,
   ptypeof,
@@ -224,6 +236,8 @@ import {
   setAbsTruncationCollector,
   setApplyCallbackHost,
   setBCallCollector,
+  setDerivation,
+  setDerivationCollector,
   setMemberDiagCollector,
   shapeOfTerm,
   shapeOnlyFn,
@@ -241,10 +255,12 @@ import {
   substPredAbs,
   superNameOf,
   tagAbsOrigin,
+  tagDerivationRoot,
   templateMatchesValue,
   templatePartsOf,
   termDepth,
   termEquals,
+  termKey,
   termNodes,
   termToString,
   transpile,
@@ -264,711 +280,7 @@ import {
   withExecPhi,
   withVar,
   wrapPromise
-} from "./chunk-RZOQL6PT.js";
-
-// src/refinements/template-predicates.ts
-function isTemplate(tv) {
-  return tv.kind === "refined" && Array.isArray(tv.refinement.meta.parts);
-}
-
-// src/type-value.ts
-function createUnion(...members) {
-  return simplifyUnion(members);
-}
-var T = {
-  literal: (value) => ({ kind: "literal", value }),
-  number: { kind: "primitive", type: "number" },
-  string: { kind: "primitive", type: "string" },
-  boolean: { kind: "primitive", type: "boolean" },
-  bigint: { kind: "primitive", type: "bigint" },
-  symbol: { kind: "primitive", type: "symbol" },
-  null: { kind: "literal", value: null },
-  undefined: { kind: "literal", value: void 0 },
-  unknown: { kind: "unknown" },
-  never: { kind: "never" },
-  object: (properties) => ({
-    kind: "object",
-    properties,
-    id: Symbol("object")
-  }),
-  array: (element) => ({ kind: "array", element }),
-  tuple: (elements) => ({ kind: "tuple", elements }),
-  promise: (value) => ({ kind: "promise", value }),
-  instanceOf: (className, properties = {}) => ({
-    kind: "instance",
-    className,
-    properties
-  }),
-  union: createUnion,
-  fn: (params, body, closure) => ({
-    kind: "function",
-    params,
-    body,
-    closure
-  }),
-  refine: (base, refinement) => ({
-    kind: "refined",
-    base,
-    refinement
-  }),
-  fnSig: (paramTypes, returnType, throwsType = { kind: "never" }, impl) => {
-    const dummy = {
-      kind: "function",
-      params: paramTypes.map((_p, i) => `_arg${i}`),
-      body: { type: "BlockStatement", body: [], directives: [] },
-      closure: null
-    };
-    dummy._signature = { paramTypes, returnType, throwsType, impl };
-    return dummy;
-  }
-};
-function typeValueEquals(a, b) {
-  if (a.kind !== b.kind) return false;
-  if (a.kind === "literal" && b.kind === "literal") return a.value === b.value;
-  if (a.kind === "primitive" && b.kind === "primitive") return a.type === b.type;
-  if (a.kind === "never" && b.kind === "never") return true;
-  if (a.kind === "unknown" && b.kind === "unknown") return true;
-  if (a.kind === "refined" && b.kind === "refined") {
-    return a.refinement.name === b.refinement.name && typeValueEquals(a.base, b.base);
-  }
-  if (a.kind === "promise" && b.kind === "promise") {
-    return typeValueEquals(a.value, b.value);
-  }
-  if (a.kind === "instance" && b.kind === "instance") {
-    return a.className === b.className;
-  }
-  if (a.kind === "union" && b.kind === "union") {
-    return a.members.length === b.members.length && a.members.every((m, i) => typeValueEquals(m, b.members[i]));
-  }
-  return a === b;
-}
-function simplifyUnion(members) {
-  if (members.length === 0) return T.never;
-  if (members.length === 1) return members[0].kind === "never" ? T.never : members[0];
-  if (members.length === 2) {
-    const a = members[0];
-    const b = members[1];
-    if (a.kind !== "union" && b.kind !== "union") {
-      if (a.kind === "never") return b.kind === "never" ? T.never : b;
-      if (b.kind === "never") return a;
-      if (typeValueEquals(a, b)) return a;
-      if (a.kind === "unknown" || b.kind === "unknown") return T.unknown;
-      const aBase = absorbablePrimitiveBase(a);
-      if (aBase !== void 0 && typeValueEquals(aBase, b)) return b;
-      const bBase = absorbablePrimitiveBase(b);
-      if (bBase !== void 0 && typeValueEquals(bBase, a)) return a;
-      return { kind: "union", members: [a, b] };
-    }
-  }
-  const flat = [];
-  for (const m of members) {
-    if (m.kind === "never") continue;
-    if (m.kind === "union") {
-      flat.push(...m.members);
-    } else {
-      flat.push(m);
-    }
-  }
-  const deduped = [];
-  for (const m of flat) {
-    if (!deduped.some((d) => typeValueEquals(d, m))) {
-      deduped.push(m);
-    }
-  }
-  const primitives = deduped.filter((m) => m.kind === "primitive");
-  const absorbed = primitives.length > 0 ? deduped.filter((m) => {
-    const base = absorbablePrimitiveBase(m);
-    return base === void 0 || !primitives.some((p) => typeValueEquals(p, base));
-  }) : deduped;
-  if (absorbed.length === 0) return T.never;
-  if (absorbed.length === 1) return absorbed[0];
-  if (absorbed.some((m) => m.kind === "unknown")) return T.unknown;
-  return { kind: "union", members: absorbed };
-}
-function absorbablePrimitiveBase(tv) {
-  if (tv.kind === "literal") {
-    const widened = widenLiteral(tv);
-    return widened.kind === "primitive" ? widened : void 0;
-  }
-  if (isTemplate(tv)) return T.string;
-  return void 0;
-}
-function widenLiteral(tv) {
-  if (tv.kind !== "literal") return tv;
-  const v2 = tv.value;
-  if (typeof v2 === "number") return T.number;
-  if (typeof v2 === "string") return T.string;
-  if (typeof v2 === "boolean") return T.boolean;
-  if (typeof v2 === "bigint") return T.bigint;
-  if (v2 === null) return T.null;
-  if (v2 === void 0) return T.undefined;
-  return T.unknown;
-}
-function collapseLiteralUnion(tv, maxLiterals) {
-  if (tv.kind !== "union") return tv;
-  if (tv.members.length <= maxLiterals) return tv;
-  const simplified = simplifyUnion(tv.members);
-  if (simplified.kind !== "union") return simplified;
-  if (!simplified.members.every((m) => m.kind === "literal")) return simplified;
-  const first = widenLiteral(simplified.members[0]);
-  if (!simplified.members.every((m) => typeValueEquals(widenLiteral(m), first))) return simplified;
-  return first;
-}
-function isSubtypeOf(a, b) {
-  if (b.kind === "unknown") return true;
-  if (a.kind === "never") return true;
-  if (typeValueEquals(a, b)) return true;
-  if (a.kind === "literal" && b.kind === "primitive") {
-    const v2 = a.value;
-    if (b.type === "number" && typeof v2 === "number") return true;
-    if (b.type === "string" && typeof v2 === "string") return true;
-    if (b.type === "boolean" && typeof v2 === "boolean") return true;
-    return false;
-  }
-  if (a.kind === "literal" && b.kind === "refined") {
-    if (!isSubtypeOf(a, b.base)) return false;
-    return b.refinement.check ? b.refinement.check(a.value) : false;
-  }
-  if (a.kind === "refined") {
-    if (b.kind === "refined" && a.refinement.name === b.refinement.name) {
-      return isSubtypeOf(a.base, b.base);
-    }
-    return isSubtypeOf(a.base, b);
-  }
-  if (a.kind === "object" && b.kind === "object") {
-    return Object.entries(b.properties).every(
-      ([k, bv]) => k in a.properties && isSubtypeOf(a.properties[k], bv)
-    );
-  }
-  if (a.kind === "array" && b.kind === "array") {
-    return isSubtypeOf(a.element, b.element);
-  }
-  if (a.kind === "tuple" && b.kind === "tuple") {
-    return a.elements.length === b.elements.length && a.elements.every((el, i) => isSubtypeOf(el, b.elements[i]));
-  }
-  if (a.kind === "tuple" && b.kind === "array") {
-    return a.elements.every((el) => isSubtypeOf(el, b.element));
-  }
-  if (a.kind === "promise" && b.kind === "promise") {
-    return isSubtypeOf(a.value, b.value);
-  }
-  if (a.kind === "instance" && b.kind === "instance") {
-    return a.className === b.className || isErrorSubclass(a.className, b.className);
-  }
-  if (a.kind === "union") {
-    return a.members.every((m) => isSubtypeOf(m, b));
-  }
-  if (b.kind === "union") {
-    return b.members.some((m) => isSubtypeOf(a, m));
-  }
-  return false;
-}
-var errorHierarchy = {
-  TypeError: "Error",
-  SyntaxError: "Error",
-  RangeError: "Error",
-  ReferenceError: "Error",
-  URIError: "Error",
-  EvalError: "Error"
-};
-function isErrorSubclass(child, parent) {
-  if (child === parent) return true;
-  const sup = errorHierarchy[child];
-  return sup ? isErrorSubclass(sup, parent) : false;
-}
-function deepCloneTypeValue(tv, idMap) {
-  const map = idMap ?? /* @__PURE__ */ new Map();
-  if (tv.kind === "object") {
-    let newId = map.get(tv.id);
-    if (!newId) {
-      newId = Symbol("object");
-      map.set(tv.id, newId);
-    }
-    const newProps = {};
-    for (const [k, v2] of Object.entries(tv.properties)) {
-      newProps[k] = deepCloneTypeValue(v2, map);
-    }
-    return { kind: "object", properties: newProps, id: newId };
-  }
-  if (tv.kind === "array") {
-    return { kind: "array", element: deepCloneTypeValue(tv.element, map) };
-  }
-  if (tv.kind === "tuple") {
-    return { kind: "tuple", elements: tv.elements.map((e) => deepCloneTypeValue(e, map)) };
-  }
-  if (tv.kind === "promise") {
-    return { kind: "promise", value: deepCloneTypeValue(tv.value, map) };
-  }
-  if (tv.kind === "instance") {
-    const newProps = {};
-    for (const [k, v2] of Object.entries(tv.properties)) {
-      newProps[k] = deepCloneTypeValue(v2, map);
-    }
-    return { kind: "instance", className: tv.className, properties: newProps };
-  }
-  if (tv.kind === "refined") {
-    return { kind: "refined", base: deepCloneTypeValue(tv.base, map), refinement: tv.refinement };
-  }
-  if (tv.kind === "union") {
-    return simplifyUnion(tv.members.map((m) => deepCloneTypeValue(m, map)));
-  }
-  return tv;
-}
-function mergeObjectProperties(a, b) {
-  const allKeys = /* @__PURE__ */ new Set([...Object.keys(a.properties), ...Object.keys(b.properties)]);
-  const merged = {};
-  for (const k of allKeys) {
-    const av = a.properties[k];
-    const bv = b.properties[k];
-    if (av && bv) {
-      merged[k] = simplifyUnion([av, bv]);
-    } else {
-      merged[k] = av ?? bv;
-    }
-  }
-  return { kind: "object", properties: merged, id: a.id };
-}
-function typeValueToString(tv) {
-  return typeValueToStringInner(tv, /* @__PURE__ */ new Set());
-}
-function typeValueToStringInner(tv, seen, depth = 0) {
-  if (depth > 48) return "\u2026";
-  const recur = (inner) => {
-    if (inner && typeof inner === "object") {
-      if (seen.has(inner)) return "\u2026";
-      seen.add(inner);
-      const out = typeValueToStringInner(inner, seen, depth + 1);
-      seen.delete(inner);
-      return out;
-    }
-    return typeValueToStringInner(inner, seen, depth + 1);
-  };
-  switch (tv.kind) {
-    case "literal": {
-      const v2 = tv.value;
-      if (v2 === null) return "null";
-      if (v2 === void 0) return "undefined";
-      if (typeof v2 === "string") return JSON.stringify(v2);
-      return String(v2);
-    }
-    case "primitive":
-      return tv.type;
-    case "refined":
-      return tv.refinement.name;
-    case "object": {
-      const entries = Object.entries(tv.properties);
-      if (entries.length === 0) return "{}";
-      const inner = entries.map(([k, v2]) => `${k}: ${recur(v2)}`).join(", ");
-      return `{ ${inner} }`;
-    }
-    case "array":
-      return `${recur(tv.element)}[]`;
-    case "tuple": {
-      const inner = tv.elements.map(recur).join(", ");
-      return `[${inner}]`;
-    }
-    case "function": {
-      const sig = getFnSig(tv);
-      if (sig) {
-        const params2 = sig.paramTypes.map((p, i) => `${tv.params[i]}: ${recur(p)}`).join(", ");
-        return `(${params2}) => ${recur(sig.returnType)}`;
-      }
-      const params = tv.params.join(", ");
-      return `(${params}) => ...`;
-    }
-    case "promise":
-      return `Promise<${recur(tv.value)}>`;
-    case "instance": {
-      const entries = Object.entries(tv.properties);
-      if (entries.length === 0) return tv.className;
-      const inner = entries.map(([k, v2]) => `${k}: ${recur(v2)}`).join(", ");
-      return `${tv.className} { ${inner} }`;
-    }
-    case "union": {
-      return tv.members.map(recur).join(" | ");
-    }
-    case "never":
-      return "never";
-    case "unknown":
-      return "unknown";
-  }
-}
-function narrowType(tv, predicate) {
-  if (tv.kind === "union") {
-    return simplifyUnion(tv.members.filter(predicate));
-  }
-  return predicate(tv) ? tv : T.never;
-}
-function subtractType(tv, predicate) {
-  return narrowType(tv, (m) => !predicate(m));
-}
-function getPrimitiveTypeOf(tv) {
-  if (tv.kind === "literal") {
-    const v2 = tv.value;
-    if (v2 === null) return "object";
-    return typeof v2;
-  }
-  if (tv.kind === "primitive") return tv.type;
-  if (tv.kind === "refined") return getPrimitiveTypeOf(tv.base);
-  if (tv.kind === "object") return "object";
-  if (tv.kind === "array" || tv.kind === "tuple") return "object";
-  if (tv.kind === "function") return "function";
-  if (tv.kind === "promise") return "object";
-  if (tv.kind === "instance") return "object";
-  return void 0;
-}
-function getRefinedBase(tv) {
-  return tv.kind === "refined" ? getRefinedBase(tv.base) : tv;
-}
-function isFnSig(tv) {
-  return tv.kind === "function" && "_signature" in tv;
-}
-function getFnSig(tv) {
-  if (tv.kind === "function" && "_signature" in tv) {
-    return tv._signature;
-  }
-  return void 0;
-}
-
-// src/refinements/range.ts
-function formatRangeName(meta) {
-  const parts = [];
-  if (meta.integer) parts.push("integer");
-  else parts.push("number");
-  const constraints = [];
-  if (meta.min != null) {
-    constraints.push(meta.minExclusive ? `> ${meta.min}` : `>= ${meta.min}`);
-  }
-  if (meta.max != null) {
-    constraints.push(meta.maxExclusive ? `< ${meta.max}` : `<= ${meta.max}`);
-  }
-  if (constraints.length > 0) parts.push(`(${constraints.join(", ")})`);
-  return parts.join(" ");
-}
-function createRangeRefinement(meta) {
-  return {
-    name: formatRangeName(meta),
-    meta: { ...meta },
-    check(value) {
-      if (typeof value !== "number") return false;
-      if (meta.integer && !Number.isInteger(value)) return false;
-      if (meta.min != null) {
-        if (meta.minExclusive ? value <= meta.min : value < meta.min) return false;
-      }
-      if (meta.max != null) {
-        if (meta.maxExclusive ? value >= meta.max : value > meta.max) return false;
-      }
-      return true;
-    },
-    ops: {
-      ">="(self, other) {
-        const m = getRangeMeta(self);
-        if (!m || other.kind !== "literal" || typeof other.value !== "number") return void 0;
-        if (m.min != null) {
-          if (m.minExclusive && m.min >= other.value) return T.literal(true);
-          if (!m.minExclusive && m.min >= other.value) return T.literal(true);
-        }
-        if (m.max != null) {
-          if (m.maxExclusive && m.max <= other.value) return T.literal(false);
-          if (!m.maxExclusive && m.max < other.value) return T.literal(false);
-        }
-        return void 0;
-      },
-      ">"(self, other) {
-        const m = getRangeMeta(self);
-        if (!m || other.kind !== "literal" || typeof other.value !== "number") return void 0;
-        if (m.min != null) {
-          if (m.minExclusive && m.min >= other.value) return T.literal(true);
-          if (!m.minExclusive && m.min > other.value) return T.literal(true);
-        }
-        if (m.max != null) {
-          if (m.max <= other.value) return T.literal(false);
-        }
-        return void 0;
-      },
-      "<="(self, other) {
-        const m = getRangeMeta(self);
-        if (!m || other.kind !== "literal" || typeof other.value !== "number") return void 0;
-        if (m.max != null) {
-          if (m.maxExclusive && m.max <= other.value) return T.literal(true);
-          if (!m.maxExclusive && m.max <= other.value) return T.literal(true);
-        }
-        if (m.min != null) {
-          if (m.minExclusive && m.min >= other.value) return T.literal(false);
-          if (!m.minExclusive && m.min > other.value) return T.literal(false);
-        }
-        return void 0;
-      },
-      "<"(self, other) {
-        const m = getRangeMeta(self);
-        if (!m || other.kind !== "literal" || typeof other.value !== "number") return void 0;
-        if (m.max != null) {
-          if (m.maxExclusive && m.max <= other.value) return T.literal(true);
-          if (!m.maxExclusive && m.max < other.value) return T.literal(true);
-        }
-        if (m.min != null) {
-          if (m.min >= other.value) return T.literal(false);
-        }
-        return void 0;
-      }
-    }
-  };
-}
-function createRange(meta) {
-  if (meta.min != null && meta.max != null && meta.min === meta.max && !meta.minExclusive && !meta.maxExclusive) {
-    return T.literal(meta.min);
-  }
-  return T.refine(T.number, createRangeRefinement(meta));
-}
-function isRange(tv) {
-  if (tv.kind !== "refined") return false;
-  const m = tv.refinement.meta;
-  return m.min !== void 0 || m.max !== void 0 || m.minExclusive !== void 0 || m.maxExclusive !== void 0 || m.integer !== void 0;
-}
-function getRangeMeta(tv) {
-  if (tv.kind !== "refined") return void 0;
-  const m = tv.refinement.meta;
-  if (m.min !== void 0 || m.max !== void 0 || m.minExclusive !== void 0 || m.maxExclusive !== void 0 || m.integer !== void 0) {
-    return m;
-  }
-  return void 0;
-}
-
-// src/refinements/template.ts
-function tvTemplateViews(parts) {
-  return viewTemplateParts(
-    parts,
-    (p) => p.kind === "literal" && typeof p.value === "string" ? { fixed: p.value } : { render: typeValueToString(p) }
-  );
-}
-function formatTemplateName(parts) {
-  return formatTemplateNameViews(tvTemplateViews(parts));
-}
-function normalizeParts(parts) {
-  const merged = mergeAdjacentFixedViews(tvTemplateViews(parts), (text) => ({
-    fixed: text,
-    render: text,
-    part: T.literal(text)
-  }));
-  const out = [];
-  for (const { part: p } of merged) {
-    const last = out[out.length - 1];
-    if (last?.kind === "primitive" && last.type === "string" && p.kind === "primitive" && p.type === "string") {
-    } else {
-      out.push(p);
-    }
-  }
-  return out;
-}
-function createTemplateRefinement(parts) {
-  return {
-    name: formatTemplateName(parts),
-    meta: { parts },
-    check(value) {
-      if (typeof value !== "string") return false;
-      return templateMatchesValue(value, tvTemplateViews(parts));
-    },
-    ops: {
-      "+"(self, other) {
-        return concatTemplates(self, other);
-      }
-    },
-    methods: {
-      startsWith(_self, args) {
-        const arg = args[0];
-        if (arg?.kind !== "literal" || typeof arg.value !== "string") return void 0;
-        const parts2 = _self.refinement.meta.parts;
-        const d = decideStartsWith(knownPrefixOfViews(tvTemplateViews(parts2)), arg.value);
-        return d === "unknown" ? void 0 : T.literal(d);
-      },
-      endsWith(_self, args) {
-        const arg = args[0];
-        if (arg?.kind !== "literal" || typeof arg.value !== "string") return void 0;
-        const parts2 = _self.refinement.meta.parts;
-        const d = decideEndsWith(knownSuffixOfViews(tvTemplateViews(parts2)), arg.value);
-        return d === "unknown" ? void 0 : T.literal(d);
-      },
-      includes(_self, args) {
-        const arg = args[0];
-        if (arg?.kind !== "literal" || typeof arg.value !== "string") return void 0;
-        const parts2 = _self.refinement.meta.parts;
-        const d = decideIncludes(allFixedTextOfViews(tvTemplateViews(parts2)), arg.value);
-        return d === "unknown" ? void 0 : T.literal(d);
-      }
-    },
-    properties: {
-      length(_self) {
-        const parts2 = _self.refinement.meta.parts;
-        const hasAbstract = parts2.some((p) => p.kind !== "literal");
-        if (!hasAbstract) return void 0;
-        return createRange({ min: allFixedTextOfViews(tvTemplateViews(parts2)).length });
-      }
-    }
-  };
-}
-function createTemplate(parts) {
-  const normalized = normalizeParts(parts);
-  if (normalized.length === 1 && normalized[0].kind === "literal") {
-    return normalized[0];
-  }
-  if (normalized.length === 1 && normalized[0].kind === "primitive" && normalized[0].type === "string") {
-    return T.string;
-  }
-  return T.refine(T.string, createTemplateRefinement(normalized));
-}
-function getTemplateParts(tv) {
-  if (tv.kind === "refined" && Array.isArray(tv.refinement.meta.parts)) {
-    return tv.refinement.meta.parts;
-  }
-  return void 0;
-}
-function concatTemplates(left, right) {
-  const leftParts = getTemplateParts(left) ?? [left];
-  const rightParts = getTemplateParts(right) ?? [right];
-  return createTemplate([...leftParts, ...rightParts]);
-}
-
-// src/ops.ts
-function bothLiteral(l, r) {
-  if (l.kind === "literal" && r.kind === "literal") {
-    return { lv: l.value, rv: r.value };
-  }
-  return null;
-}
-function isNullishLiteral(tv) {
-  return tv.kind === "literal" && (tv.value === null || tv.value === void 0);
-}
-function definitelyNotNullish(tv) {
-  switch (tv.kind) {
-    case "literal":
-      return tv.value !== null && tv.value !== void 0;
-    case "primitive":
-    case "object":
-    case "array":
-    case "tuple":
-    case "function":
-    case "instance":
-    case "promise":
-      return true;
-    case "refined":
-      return definitelyNotNullish(tv.base);
-    case "union":
-      return tv.members.every(definitelyNotNullish);
-    default:
-      return false;
-  }
-}
-var Ops = {
-  add(left, right) {
-    const lit3 = bothLiteral(left, right);
-    if (lit3) {
-      return T.literal(lit3.lv + lit3.rv);
-    }
-    const leftIsString = isSubtypeOf(left, T.string) || isTemplate(left);
-    const rightIsString = isSubtypeOf(right, T.string) || isTemplate(right);
-    if (leftIsString || rightIsString) {
-      const hasStructure = left.kind === "literal" && typeof left.value === "string" || right.kind === "literal" && typeof right.value === "string" || isTemplate(left) || isTemplate(right);
-      if (hasStructure) {
-        return concatTemplates(left, right);
-      }
-      return T.string;
-    }
-    if (isSubtypeOf(left, T.number) && isSubtypeOf(right, T.number)) {
-      return T.number;
-    }
-    return T.union(T.number, T.string);
-  },
-  strictEq(left, right) {
-    const lit3 = bothLiteral(left, right);
-    if (lit3) return T.literal(lit3.lv === lit3.rv);
-    if (isNullishLiteral(right) && definitelyNotNullish(left) || isNullishLiteral(left) && definitelyNotNullish(right)) {
-      return T.literal(false);
-    }
-    return T.boolean;
-  },
-  strictNeq(left, right) {
-    const lit3 = bothLiteral(left, right);
-    if (lit3) return T.literal(lit3.lv !== lit3.rv);
-    if (isNullishLiteral(right) && definitelyNotNullish(left) || isNullishLiteral(left) && definitelyNotNullish(right)) {
-      return T.literal(true);
-    }
-    return T.boolean;
-  },
-  gt(left, right) {
-    const lit3 = bothLiteral(left, right);
-    if (lit3) return T.literal(lit3.lv > lit3.rv);
-    return T.boolean;
-  },
-  lt(left, right) {
-    const lit3 = bothLiteral(left, right);
-    if (lit3) return T.literal(lit3.lv < lit3.rv);
-    return T.boolean;
-  },
-  gte(left, right) {
-    const lit3 = bothLiteral(left, right);
-    if (lit3) return T.literal(lit3.lv >= lit3.rv);
-    return T.boolean;
-  },
-  lte(left, right) {
-    const lit3 = bothLiteral(left, right);
-    if (lit3) return T.literal(lit3.lv <= lit3.rv);
-    return T.boolean;
-  },
-  not(operand) {
-    if (operand.kind === "literal") return T.literal(!operand.value);
-    return T.boolean;
-  }
-};
-var binaryOpMap = {
-  "+": Ops.add,
-  "===": Ops.strictEq,
-  "!==": Ops.strictNeq,
-  ">": Ops.gt,
-  "<": Ops.lt,
-  ">=": Ops.gte,
-  "<=": Ops.lte
-};
-function applyBinaryOp(op, left, right) {
-  const fn2 = binaryOpMap[op];
-  if (!fn2) return T.unknown;
-  return fn2(left, right);
-}
-function dispatchBinaryOp(op, left, right) {
-  if (left.kind === "refined" && left.refinement.ops?.[op]) {
-    const result = left.refinement.ops[op](left, right);
-    if (result !== void 0) return result;
-  }
-  if (right.kind === "refined" && right.refinement.ops?.[op]) {
-    const result = right.refinement.ops[op](right, left);
-    if (result !== void 0) return result;
-  }
-  const baseLeft = left.kind === "refined" ? left.base : left;
-  const baseRight = right.kind === "refined" ? right.base : right;
-  if (baseLeft !== left || baseRight !== right) {
-    return dispatchBinaryOp(op, baseLeft, baseRight);
-  }
-  return applyBinaryOp(op, left, right);
-}
-function dispatchMethod(receiver, name, args) {
-  if (receiver.kind === "refined" && receiver.refinement.methods?.[name]) {
-    const result = receiver.refinement.methods[name](receiver, args);
-    if (result !== void 0) return result;
-  }
-  if (receiver.kind === "refined") {
-    return dispatchMethod(receiver.base, name, args);
-  }
-  return void 0;
-}
-function dispatchProperty(receiver, name) {
-  if (receiver.kind === "refined" && receiver.refinement.properties?.[name]) {
-    const result = receiver.refinement.properties[name](receiver);
-    if (result !== void 0) return result;
-  }
-  if (receiver.kind === "refined") {
-    return dispatchProperty(receiver.base, name);
-  }
-  return void 0;
-}
+} from "./chunk-P3G2TODS.js";
 
 // src/environment.ts
 function createEnvironment(parent, bindings = /* @__PURE__ */ new Map()) {
@@ -978,7 +290,7 @@ function createEnvironment(parent, bindings = /* @__PURE__ */ new Map()) {
       const val = store.get(name);
       if (val !== void 0) return val;
       if (parent) return parent.lookup(name);
-      return T.undefined;
+      return unknown;
     },
     bind(name, value) {
       store.set(name, value);
@@ -1041,7 +353,8 @@ stub.onSecondCall = function(value) {
   return { kind: "mock-helper", onSecondCallValue: value };
 };
 stub.withArgs = function(...args) {
-  return { kind: "mock-helper", withArgsCases: [{ args, returnValue: T.unknown }] };
+  const unknownAbs = { shape: { k: "unknown" }, conf: "partial" };
+  return { kind: "mock-helper", withArgsCases: [{ args, returnValue: unknownAbs }] };
 };
 stub.callsFake = function(fn2) {
   return { kind: "mock-helper", callsFakeImpl: fn2 };
@@ -1055,57 +368,6 @@ spy.returns = function(value) {
 function mock() {
   return { kind: "mock-helper" };
 }
-function mockArgMatches(declared, actual) {
-  if (actual === void 0) return false;
-  if (typeValueEquals(declared, actual)) return true;
-  if (declared.kind === "primitive" && actual.kind === "literal") {
-    const t = typeof actual.value;
-    return declared.type === "number" && t === "number" || declared.type === "string" && t === "string" || declared.type === "boolean" && t === "boolean" || declared.type === "bigint" && t === "bigint" || declared.type === "symbol" && t === "symbol";
-  }
-  return false;
-}
-function mockHelperToTypeValue(helper, env) {
-  if (helper.callsFakeImpl) {
-    if (helper.callsFakeImpl.kind === "function") {
-      return helper.callsFakeImpl;
-    }
-    const plain = T.fn(["...args"], { type: "BlockStatement", body: [] }, env);
-    plain._directReturn = helper.callsFakeImpl;
-    return plain;
-  }
-  let defaultReturn;
-  if (helper.resolvedValue) {
-    defaultReturn = T.promise(helper.resolvedValue);
-  } else if (helper.rejectedValue) {
-    defaultReturn = T.never;
-  } else if (helper.returnValue) {
-    defaultReturn = helper.returnValue;
-  } else if (helper.onFirstCallValue) {
-    defaultReturn = helper.onFirstCallValue;
-  } else {
-    defaultReturn = T.unknown;
-  }
-  if (helper.withArgsCases?.length) {
-    const cases = helper.withArgsCases;
-    return T.fnSig(
-      cases[0].args.map(() => T.unknown),
-      T.union(...cases.map((c) => c.returnValue), defaultReturn),
-      T.never,
-      (args) => {
-        for (const c of cases) {
-          if (c.args.every((a, i) => mockArgMatches(a, args[i]))) {
-            return c.returnValue;
-          }
-        }
-        return defaultReturn;
-      }
-    );
-  }
-  const body = { type: "BlockStatement", body: [] };
-  const fn2 = T.fn(["...args"], body, env);
-  fn2._directReturn = defaultReturn;
-  return fn2;
-}
 
 // src/algebra/phi.ts
 var phiStack = [pTrue];
@@ -1541,6 +803,46 @@ function constraintToEntryAbs(c, paramName) {
   }
   return constraintOnTermAbs(c, t);
 }
+function memberLitValue(m) {
+  const leaves = [];
+  const visit = (p2) => {
+    if (p2.op === "and") {
+      p2.args.forEach(visit);
+      return;
+    }
+    leaves.push(p2);
+  };
+  m.preds.forEach(visit);
+  if (leaves.length !== 1) return void 0;
+  const p = leaves[0];
+  if (p.op !== "eq") return void 0;
+  if (p.a.op === "var" && p.b.op === "lit") return p.b.value;
+  if (p.b.op === "var" && p.a.op === "lit") return p.a.value;
+  return void 0;
+}
+function samePrimLiteralUnionAbs(members, t) {
+  if (members.length === 0) return void 0;
+  const values = [];
+  let prim;
+  for (const m of members) {
+    const v2 = memberLitValue(m);
+    if (v2 === void 0) return void 0;
+    if (v2 === null) return void 0;
+    const mp = m.prim ?? (typeof v2 === "number" ? "number" : typeof v2 === "string" ? "string" : "boolean");
+    if (prim === void 0) prim = mp;
+    else if (prim !== mp) return void 0;
+    values.push(v2);
+  }
+  if (prim === void 0) return void 0;
+  const uniq = [];
+  for (const v2 of values) {
+    if (!uniq.some((u) => Object.is(u, v2))) uniq.push(v2);
+  }
+  const disj = or(
+    ...uniq.map((v2) => eq(t, lit(v2)))
+  );
+  return abs({ k: "prim", type: prim }, t, disj, "path");
+}
 function constraintOnTermAbs(c, t) {
   if (c.fields) {
     const slots = {};
@@ -1553,6 +855,8 @@ function constraintOnTermAbs(c, t) {
     return abs({ k: "obj", slots }, t, void 0, "path");
   }
   if (c.members) {
+    const litUnion = samePrimLiteralUnionAbs(c.members, t);
+    if (litUnion) return litUnion;
     const joined = c.members.map((m) => constraintOnTermAbs(m, t)).reduce((a, b) => joinAbs(a, b));
     if (joined.shape.k === "prim" && joined.pred === void 0 && c.members.every((m) => m.prim === joined.shape.type)) {
       const type = joined.shape.type;
@@ -2304,7 +1608,9 @@ function generatedExportNames(sidecarSrc) {
   } catch {
     return out;
   }
-  for (const stmt of ast.program.body) {
+  const stmts = ast.program.body;
+  for (let i = 0; i < stmts.length; i++) {
+    const stmt = stmts[i];
     if (stmt.type !== "ExportNamedDeclaration") continue;
     if (stmt.source) continue;
     const d = stmt.declaration;
@@ -2318,25 +1624,26 @@ function generatedExportNames(sidecarSrc) {
       if (d.id) names.push(d.id.name);
     }
     if (names.length === 0) continue;
-    if (leadingCommentHas(stmt.start, sidecarSrc)) {
+    if (regionHasGeneratedMarker(stmts, i, sidecarSrc)) {
       for (const n of names) out.add(n);
     }
   }
   return out;
 }
-function leadingCommentHas(pos, src) {
-  const lines = src.slice(0, pos).replace(/\n$/, "").split("\n");
-  for (let i = lines.length - 1; i >= 0; i--) {
-    const line = lines[i].trim();
-    if (line === "") break;
-    if (line === "*/") continue;
-    if (line.startsWith("//") || line.startsWith("/*") || line.startsWith("*")) {
-      if (/@generated/.test(line)) return true;
-      continue;
-    }
+function regionHasGeneratedMarker(stmts, exportIdx, src) {
+  const exportStart = stmts[exportIdx].start;
+  if (exportStart == null) return false;
+  let regionStart = 0;
+  for (let j = exportIdx - 1; j >= 0; j--) {
+    const prev = stmts[j];
+    if (prev.type === "ImportDeclaration" || prev.type === "VariableDeclaration") continue;
+    regionStart = prev.end ?? 0;
     break;
   }
-  return false;
+  return src.slice(regionStart, exportStart).split("\n").some((line) => {
+    const t = line.trim();
+    return (t.startsWith("//") || t.startsWith("/*") || t.startsWith("*")) && /@generated/.test(t);
+  });
 }
 function sidecarAutoBindAllowed(sidecarPath, autoBind) {
   if (isNodeModulesPath(sidecarPath)) return false;
@@ -3074,14 +2381,14 @@ function generalizeMemoSet(key, value, depPaths) {
 function isCacheableAbs(a) {
   return a.conf === "exact" || a.conf === "path" || a.conf === "widened" || a.conf === "mock";
 }
-function termKey(t, rename) {
+function termKey2(t, rename) {
   switch (t.op) {
     case "lit":
       return `L:${typeof t.value}:${String(t.value)}`;
     case "var":
       return `V:${rename?.get(t.id) ?? t.id}`;
     case "app":
-      return `A:${t.fn}(${t.args.map((a) => termKey(a, rename)).join(",")})`;
+      return `A:${t.fn}(${t.args.map((a) => termKey2(a, rename)).join(",")})`;
   }
 }
 function predKey(p, rename) {
@@ -3096,7 +2403,7 @@ function predKey(p, rename) {
     case "le":
     case "gt":
     case "ge":
-      return `${p.op}(${termKey(p.a, rename)},${termKey(p.b, rename)})`;
+      return `${p.op}(${termKey2(p.a, rename)},${termKey2(p.b, rename)})`;
     case "and":
     case "or": {
       const keys = p.args.map((a) => predKey(a, rename)).sort();
@@ -3105,7 +2412,7 @@ function predKey(p, rename) {
     case "not":
       return `not(${predKey(p.arg, rename)})`;
     case "typeof":
-      return `typeof(${termKey(p.t, rename)},${p.type})`;
+      return `typeof(${termKey2(p.t, rename)},${p.type})`;
   }
 }
 function shapeKey(s, seen, rename) {
@@ -3150,7 +2457,7 @@ function shapeKey(s, seen, rename) {
 function absKeyInner(a, seen, rename) {
   if (seen.has(a)) return "cycle";
   seen.add(a);
-  const t = a.term ? `=${termKey(a.term, rename)}` : "";
+  const t = a.term ? `=${termKey2(a.term, rename)}` : "";
   const p = a.pred ? `@${predKey(a.pred, rename)}` : "";
   return `${shapeKey(a.shape, seen, rename)}${t}${p}`;
 }
@@ -3530,9 +2837,8 @@ function formatPoly(name, params, typeParams, symbolic, entryReqs, entryShapes,
     return `${p}: ${id}`;
   }).join(", ");
   const ret = formatShapeSlot(symbolic);
-  const termPart = symbolic.term && symbolic.term.op !== "lit" ? ` = ${termToString(symbolic.term)}` : "";
   const predPart = symbolic.pred && symbolic.pred.op !== "true" ? `  where ${predToString(symbolic.pred)}` : "";
-  return `${name}: (${ps}) => ${ret}${termPart}${predPart}`;
+  return `${name}: (${ps}) => ${ret}${predPart}`;
 }
 function generalizeAll(source, opts = {}) {
   const file = parseSource(source);
@@ -3849,7 +3155,7 @@ function boundsSatisfiable(bounds) {
         loStrict = true;
       }
     } else if (b.op === "ge") {
-      if (b.n > lo || b.n === lo && loStrict) {
+      if (b.n > lo) {
         lo = b.n;
         loStrict = false;
       }
@@ -3859,7 +3165,7 @@ function boundsSatisfiable(bounds) {
         hiStrict = true;
       }
     } else if (b.op === "le") {
-      if (b.n < hi || b.n === hi && hiStrict) {
+      if (b.n < hi) {
         hi = b.n;
         hiStrict = false;
       }
@@ -4189,281 +3495,6 @@ function isLengthSelf(t) {
   return t.op === "app" && t.fn === "length" && t.args.length === 1 && isSelfVar(t.args[0]);
 }
 
-// src/algebra/bridge.ts
-var confByTv = /* @__PURE__ */ new WeakMap();
-function setTvConfidence(tv, conf) {
-  if (tv && typeof tv === "object") confByTv.set(tv, conf);
-}
-function getTvConfidence(tv) {
-  if (tv && typeof tv === "object") return confByTv.get(tv);
-  return void 0;
-}
-function absToTypeValue(a) {
-  let conf = a.conf;
-  let result;
-  switch (a.shape.k) {
-    case "never":
-      result = T.never;
-      break;
-    case "unknown":
-      if (a.term?.op === "lit" && a.term.value === null) {
-        result = T.literal(null);
-        break;
-      }
-      result = T.unknown;
-      break;
-    case "any":
-      result = T.unknown;
-      break;
-    case "prim": {
-      const lv = litValue(a);
-      if (lv !== void 0) {
-        result = T.literal(lv);
-        break;
-      }
-      if (isTemplateLike(a) && a.shape.k === "prim" && a.shape.type === "string") {
-        const parts = templatePartsOf(a).map(absToTypeValue);
-        result = createTemplate(parts);
-        break;
-      }
-      const prim = primToT(a.shape.type);
-      if (a.pred && a.pred.op !== "true") {
-        const refined = tryEncodeRefined(prim, a);
-        if (refined) {
-          result = refined;
-        } else {
-          result = prim;
-          conf = confJoin(conf, "widened");
-        }
-      } else {
-        result = prim;
-        if (a.term && a.term.op !== "lit") conf = confJoin(conf, "widened");
-      }
-      break;
-    }
-    case "obj": {
-      const props = {};
-      for (const [k, slot] of Object.entries(a.shape.slots)) {
-        let v2 = absToTypeValue(slot.value);
-        if (slot.optional) {
-          v2 = T.union(v2, T.undefined);
-        }
-        props[k] = v2;
-      }
-      result = T.object(props);
-      if (a.shape.open) conf = confJoin(conf, "widened");
-      break;
-    }
-    case "arr":
-      result = T.array(absToTypeValue(a.shape.element));
-      break;
-    case "tuple":
-      result = T.tuple(a.shape.elements.map(absToTypeValue));
-      break;
-    case "fn": {
-      const body = { type: "BlockStatement", body: [], directives: [] };
-      result = T.fn(a.shape.params, body, null);
-      break;
-    }
-    case "brand":
-      result = T.instanceOf(a.shape.name, brandProps(a.shape.shape));
-      break;
-    case "eff":
-      result = T.promise(absToTypeValue(a.shape.inner));
-      break;
-    case "sum":
-      result = T.union(...a.shape.members.map(absToTypeValue));
-      break;
-    default:
-      result = T.unknown;
-      conf = confJoin(conf, "partial");
-  }
-  setTvConfidence(result, conf);
-  return result;
-}
-function primToT(type) {
-  switch (type) {
-    case "number":
-      return T.number;
-    case "string":
-      return T.string;
-    case "boolean":
-      return T.boolean;
-    case "bigint":
-      return T.bigint;
-    case "symbol":
-      return T.symbol;
-    default:
-      return T.unknown;
-  }
-}
-function brandProps(shape2) {
-  if (shape2.shape.k === "obj") {
-    const out = {};
-    for (const [k, slot] of Object.entries(shape2.shape.slots)) {
-      out[k] = absToTypeValue(slot.value);
-    }
-    return out;
-  }
-  return {};
-}
-function tryEncodeRefined(base, a) {
-  if (base.kind !== "primitive" || base.type !== "number") return void 0;
-  const p = a.pred;
-  if (!p) return void 0;
-  if ((p.op === "gt" || p.op === "ge" || p.op === "lt" || p.op === "le") && p.b.op === "lit" && typeof p.b.value === "number") {
-    const n = p.b.value;
-    const op = p.op;
-    const check = (value) => {
-      if (typeof value !== "number") return false;
-      switch (op) {
-        case "gt":
-          return value > n;
-        case "ge":
-          return value >= n;
-        case "lt":
-          return value < n;
-        case "le":
-          return value <= n;
-      }
-    };
-    const opSym = op === "gt" ? ">" : op === "ge" ? ">=" : op === "lt" ? "<" : "<=";
-    return T.refine(base, {
-      name: `number (${opSym} ${n})`,
-      meta: { op, n, pred: predToString(p) },
-      check
-    });
-  }
-  return void 0;
-}
-function typeValueToAbs(tv) {
-  if (!tv) return abs({ k: "unknown" }, void 0, void 0, "partial");
-  const confOr = (fallback) => getTvConfidence(tv) ?? fallback;
-  switch (tv.kind) {
-    case "never":
-      return abs({ k: "never" }, void 0, void 0, confOr("exact"));
-    case "unknown":
-      return abs(
-        { k: "unknown" },
-        void 0,
-        void 0,
-        confOr("partial")
-      );
-    case "literal":
-      if (typeof tv.value === "bigint") {
-        return abs(
-          { k: "prim", type: "bigint" },
-          void 0,
-          void 0,
-          confOr("exact")
-        );
-      }
-      return abs(
-        shapeOfLit(tv.value),
-        lit(tv.value),
-        pTrue,
-        confOr("exact")
-      );
-    case "primitive":
-      return abs({ k: "prim", type: tv.type }, void 0, void 0, confOr("exact"));
-    case "refined": {
-      const tplParts = getTemplateParts(tv);
-      if (tplParts) {
-        return createTemplateAbs(tplParts.map(typeValueToAbs));
-      }
-      const base = typeValueToAbs(tv.base);
-      const decoded = tryDecodeRefinedPred(tv, base.term);
-      return abs(
-        base.shape,
-        base.term ?? (decoded ? v("_r") : void 0),
-        decoded ?? base.pred,
-        confOr(confJoin(base.conf, "path"))
-      );
-    }
-    case "object": {
-      const slots = {};
-      for (const [k, v2] of Object.entries(tv.properties)) {
-        slots[k] = { value: typeValueToAbs(v2) };
-      }
-      return abs({ k: "obj", slots }, void 0, void 0, confOr("exact"));
-    }
-    case "array":
-      return abs(
-        { k: "arr", element: typeValueToAbs(tv.element) },
-        void 0,
-        void 0,
-        confOr("exact")
-      );
-    case "tuple":
-      return abs(
-        { k: "tuple", elements: tv.elements.map(typeValueToAbs) },
-        void 0,
-        void 0,
-        confOr("exact")
-      );
-    case "function": {
-      const params = tv.params ?? [];
-      return abs({ k: "fn", params }, void 0, void 0, confOr("exact"));
-    }
-    case "promise":
-      return abs(
-        { k: "eff", eff: "promise", inner: typeValueToAbs(tv.value) },
-        void 0,
-        void 0,
-        confOr("exact")
-      );
-    case "instance": {
-      const slots = {};
-      for (const [k, v2] of Object.entries(tv.properties ?? {})) {
-        slots[k] = { value: typeValueToAbs(v2) };
-      }
-      const inner = abs({ k: "obj", slots }, void 0, void 0, confOr("exact"));
-      return abs(
-        { k: "brand", name: tv.className, shape: inner },
-        void 0,
-        void 0,
-        confOr("exact")
-      );
-    }
-    case "union":
-      return abs(
-        { k: "sum", members: tv.members.map(typeValueToAbs) },
-        void 0,
-        void 0,
-        confOr("path")
-      );
-    default:
-      return abs({ k: "unknown" }, void 0, void 0, confOr("partial"));
-  }
-}
-function tryDecodeRefinedPred(tv, term) {
-  if (tv.kind !== "refined") return void 0;
-  const meta = tv.refinement.meta;
-  const op = meta?.op;
-  const n = meta?.n;
-  if (typeof n !== "number") return void 0;
-  if (op !== "gt" && op !== "ge" && op !== "lt" && op !== "le") return void 0;
-  const t = term ?? v("_r");
-  const b = lit(n);
-  switch (op) {
-    case "gt":
-      return gt(t, b);
-    case "ge":
-      return ge(t, b);
-    case "lt":
-      return lt(t, b);
-    case "le":
-      return le(t, b);
-  }
-}
-function shapeOfLit(v2) {
-  if (typeof v2 === "number") return { k: "prim", type: "number" };
-  if (typeof v2 === "string") return { k: "prim", type: "string" };
-  if (typeof v2 === "boolean") return { k: "prim", type: "boolean" };
-  if (typeof v2 === "bigint") return { k: "prim", type: "bigint" };
-  return { k: "unknown" };
-}
-
 // src/algebra/scan.ts
 function hofFnArgOk(src, tgt) {
   if (src.shape.k !== "fn") return false;
@@ -5670,9 +4701,13 @@ function evidenceToString(v2) {
   return typeof v2 === "string" ? JSON.stringify(v2) : String(v2);
 }
 function checkInjectedDomainEvidence(fnName, source, records, opts) {
-  const usable = records.filter(
-    (r) => !(r.resultType?.kind === "never" && r.throws?.kind === "never")
-  );
+  const isLeaked = (r) => {
+    if (r.resultAbs && r.throwsAbs) {
+      return r.resultAbs.shape.k === "never" && r.throwsAbs.shape.k === "never";
+    }
+    return false;
+  };
+  const usable = records.filter((r) => !isLeaked(r));
   if (usable.length === 0) return [];
   let ei;
   try {
@@ -5701,15 +4736,9 @@ function checkInjectedDomainEvidence(fnName, source, records, opts) {
     if (idx < 0) continue;
     const failures = [];
     for (const rec of usable) {
-      const arg = rec.argTypes[idx];
-      if (!arg || arg.kind !== "literal") continue;
-      const v2 = arg.value;
-      if (typeof v2 !== "number" && typeof v2 !== "string" && typeof v2 !== "boolean") {
-        continue;
-      }
-      const conf = getTvConfidence(arg);
-      if (conf !== void 0 && conf !== "exact" && conf !== "path") continue;
-      if (!literalMeetsConstraint(v2, constraint)) failures.push(v2);
+      const lit3 = extractLiteralEvidence(rec, idx);
+      if (lit3 === void 0) continue;
+      if (!literalMeetsConstraint(lit3, constraint)) failures.push(lit3);
     }
     if (failures.length === 0) continue;
     const shown = [...new Set(failures)].map(evidenceToString).join(", ");
@@ -5727,6 +4756,16 @@ function checkInjectedDomainEvidence(fnName, source, records, opts) {
   }
   return out;
 }
+function extractLiteralEvidence(rec, idx) {
+  const absArg = rec.argAbs?.[idx];
+  if (!absArg) return void 0;
+  if (absArg.conf !== "exact" && absArg.conf !== "path") return void 0;
+  const lv = litValue(absArg);
+  if (typeof lv === "number" || typeof lv === "string" || typeof lv === "boolean") {
+    return lv;
+  }
+  return void 0;
+}
 
 // src/algebra/check.ts
 var checkReportMemo = /* @__PURE__ */ new Map();
@@ -6046,14 +5085,14 @@ function checkSourceInner(filePath, source, file, phi, opts, issues, signatures,
   const varAbs = /* @__PURE__ */ new Map();
   const callRecords = [];
   setAbsAssignCollector((r) => records.push(r));
-  setAbsCallCollector((r) => callRecords.push(r));
+  const prevCallCollector = setAbsCallCollector((r) => callRecords.push(r));
   try {
     const { env } = evalProgramAbs(source, { file });
     for (const [k, v2] of env.vars) varAbs.set(k, v2);
   } catch {
   } finally {
     setAbsAssignCollector(null);
-    setAbsCallCollector(null);
+    setAbsCallCollector(prevCallCollector);
   }
   const callIssues = canSkipLiteralCallScan(source, file) ? [] : scanLiteralCalls(source, names, phi, {
     loadModule: opts.loadModule,
@@ -6676,7 +5715,7 @@ function collectAbsInlays(source, refineOpts) {
 function denoteGuard(a, v2) {
   const lv = litValue(a);
   if (lv !== void 0 && (!a.pred || a.pred.op === "true")) {
-    return `${v2} === ${JSON.stringify(lv)}`;
+    return eqGuard(v2, lv);
   }
   const shape2 = denoteShape(a.shape, v2);
   const pred = denotePred(a, v2);
@@ -6755,7 +5794,7 @@ function denotePred(a, v2) {
   const p = a.pred;
   if (!p || p.op === "true") {
     const lv = litValue(a);
-    if (lv !== void 0) return `${v2} === ${JSON.stringify(lv)}`;
+    if (lv !== void 0) return eqGuard(v2, lv);
     return "true";
   }
   return predAsJs(p, v2, a);
@@ -6784,15 +5823,15 @@ function predAsJs(p, v2, a) {
       const leftIsValue = termIsValue(p.a, a);
       const rightLit = litOfTerm(p.b);
       if (leftIsValue && rightLit !== void 0) {
-        return `${v2} ${op} ${JSON.stringify(rightLit)}`;
+        return cmpOp(v2, op, rightLit);
       }
       const leftLit = litOfTerm(p.a);
       const rightIsValue = termIsValue(p.b, a);
       if (rightIsValue && leftLit !== void 0) {
-        return `${JSON.stringify(leftLit)} ${op} ${v2}`;
+        return cmpLitValue(leftLit, op, v2);
       }
       if (leftLit !== void 0 && rightLit !== void 0) {
-        return `${JSON.stringify(leftLit)} ${op} ${JSON.stringify(rightLit)}`;
+        return `${jsLit(leftLit)} ${op} ${jsLit(rightLit)}`;
       }
       return "true";
     }
@@ -6803,6 +5842,35 @@ function predAsJs(p, v2, a) {
 function litOfTerm(t) {
   return t.op === "lit" ? t.value : void 0;
 }
+function jsLit(v2) {
+  if (v2 === void 0) return "undefined";
+  if (v2 === null) return "null";
+  if (typeof v2 === "number") {
+    if (Number.isNaN(v2)) return "NaN";
+    if (v2 === Infinity) return "Infinity";
+    if (v2 === -Infinity) return "-Infinity";
+    return String(v2);
+  }
+  return JSON.stringify(v2);
+}
+function eqGuard(v2, lv) {
+  if (typeof lv === "number" && Number.isNaN(lv)) return `Number.isNaN(${v2})`;
+  return `${v2} === ${jsLit(lv)}`;
+}
+function cmpOp(v2, op, lit3) {
+  if (typeof lit3 === "number" && Number.isNaN(lit3)) {
+    if (op === "===") return `Number.isNaN(${v2})`;
+    if (op === "!==") return `!Number.isNaN(${v2})`;
+  }
+  return `${v2} ${op} ${jsLit(lit3)}`;
+}
+function cmpLitValue(lit3, op, v2) {
+  if (typeof lit3 === "number" && Number.isNaN(lit3)) {
+    if (op === "===") return `Number.isNaN(${v2})`;
+    if (op === "!==") return `!Number.isNaN(${v2})`;
+  }
+  return `${jsLit(lit3)} ${op} ${v2}`;
+}
 function termIsValue(t, a) {
   if (t.op === "var") return true;
   if (t.op === "lit") {
@@ -6873,30 +5941,30 @@ export {
   MAX_TOTAL_CALLS,
   NudoSidecarError,
   NudoThrow,
-  Ops,
   SELF,
-  T,
+  abortDerivationSession,
   abs,
   absFunction,
+  absShapeKey,
   absTemplateViews,
   absToConstraint,
   absToString,
-  absToTypeValue,
   add,
   allFixedTextOfViews,
   alphaOf,
   analyzeFn,
+  analyzeFnFull,
   and,
   anyVar,
   app,
   applyAbsFn,
-  applyBinaryOp,
   applyCallbackAbs,
   array,
   asAbs,
   asAbsVal,
   attachFnImpl,
   awaitAbs,
+  beginDerivationSession,
   betaOf,
   bindImports,
   bool,
@@ -6905,6 +5973,7 @@ export {
   buildArgsFromAssume,
   callAbsMethod,
   callFunction,
+  callFunctionFull,
   callTranspiledExport,
   callTranspiledExportFull,
   canSkipLiteralCallScan,
@@ -6916,37 +5985,31 @@ export {
   clearBClasses,
   cmp,
   coerceAsyncReturn,
-  collapseLiteralUnion,
   collectAbsExports,
   collectAbsInlays,
   collectAbsNodeTypes,
   concatString,
-  concatTemplates,
   confJoin,
   constraintToEntryAbs,
   createEnvironment,
   createHofCollectCtx,
-  createRange,
-  createTemplate,
   createTemplateAbs,
   currentExecPhi,
   currentPhi,
   decideEndsWith,
   decideIncludes,
   decideStartsWith,
-  deepCloneTypeValue,
   defaultLeakBudget,
   defineClass,
   definitelyNotNullishShape,
   denoteGuard,
+  derivationChain,
   describePhi,
-  dispatchBinaryOp,
-  dispatchMethod,
-  dispatchProperty,
   div,
   effectiveInterface,
   emptyEnv,
   emptyPhi,
+  endDerivationSession,
   eq,
   evalArrayStatic,
   evalBuiltinInstanceMethod,
@@ -7004,20 +6067,16 @@ export {
   getBClass,
   getClass,
   getClassChain,
+  getDerivation,
   getFnImpl,
   getFnNameAndBodies,
-  getFnSig,
   getGeneralizeMemoSize,
   getParseSourceCacheSize,
-  getPrimitiveTypeOf,
-  getRangeMeta,
-  getRefinedBase,
   getSlot,
-  getTemplateParts,
   getTerm,
-  getTvConfidence,
   gt,
   gtNum,
+  hasDerivationSession,
   hashSource,
   implies,
   instanceOf,
@@ -7028,7 +6087,6 @@ export {
   isDefinitelyFalse,
   isDefinitelyTrue,
   isExactLit,
-  isFnSig,
   isIntFlag,
   isNodeModulesPath,
   isNudoConstraint,
@@ -7036,11 +6094,8 @@ export {
   isNullishLitAbs,
   isNumPrim,
   isObj,
-  isRange,
   isRelFn,
   isStrPrim,
-  isSubtypeOf,
-  isTemplate,
   isTemplateLike,
   joinAbs,
   joinFunctions,
@@ -7071,19 +6126,18 @@ export {
   matchRelIdentLit,
   maybeLeak,
   mergeAdjacentFixedViews,
-  mergeObjectProperties,
   mock,
-  mockHelperToTypeValue,
   mod,
   mul,
   namespaceNameOf,
-  narrowType,
   ne,
   negAbs,
   never,
   normPath,
   not,
   notAbs,
+  noteDerivationAdd,
+  noteDerivationJoin,
   noteMemberDispatchMiss,
   notePrimMemberMissing,
   noteUnknownMemberMissing,
@@ -7106,6 +6160,7 @@ export {
   predToString,
   predVars,
   projectBrand,
+  projectDerivationDsl,
   projectFlatMapResult,
   promoteParamShape,
   ptypeof,
@@ -7135,10 +6190,11 @@ export {
   setAbsTruncationCollector,
   setApplyCallbackHost,
   setBCallCollector,
+  setDerivation,
+  setDerivationCollector,
   setInterfaceDiagCollector,
   setMemberDiagCollector,
   setRefineDiagCollector,
-  setTvConfidence,
   shape,
   shapeOfTerm,
   shapeOnlyFn,
@@ -7147,7 +6203,6 @@ export {
   sidecarPathOf,
   sidecarSpecsOf,
   simplifyTerm,
-  simplifyUnion,
   snapshotAbs,
   spread,
   spy,
@@ -7162,9 +6217,9 @@ export {
   substAbs,
   substPred,
   substPredAbs,
-  subtractType,
   superNameOf,
   tagAbsOrigin,
+  tagDerivationRoot,
   takeInterfaceDiags,
   takeInterfaceDiagsSince,
   takeRefineDiags,
@@ -7173,6 +6228,7 @@ export {
   templatePartsOf,
   termDepth,
   termEquals,
+  termKey,
   termNodes,
   termToString,
   transpile,
@@ -7184,16 +6240,12 @@ export {
   tryPromoteForOfIteratee,
   tryPromoteHofCallback,
   tryPromoteReceiverAsArr,
-  typeValueEquals,
-  typeValueToAbs,
-  typeValueToString,
   typeofAbs,
   undefAbs,
   union,
   unknown,
   v,
   viewTemplateParts,
-  widenLiteral,
   withExecPhi,
   withPhiConstraint,
   withVar,