@nudojs/core 1.0.1 → 1.1.1

package/dist/internal.js

@@ -0,0 +1,587 @@
+import {
+  canSkipLiteralCallScan,
+  checkInjectedDomainEvidence,
+  extractAllLoadSpecs,
+  fnFingerprints,
+  generalizeFromAst,
+  generalizeSourceKeyPart,
+  getFnNameAndBodies,
+  hashSource,
+  interfaceTierOf,
+  listTopFunctions,
+  loadModuleDepsFingerprint,
+  normPath,
+  resetFnFpCache,
+  resetHashSourceCache,
+  resolveDepPath,
+  sidecarSpecsOf,
+  stableAnalyzeKeySource
+} from "./chunk-V2I7VXFZ.js";
+import {
+  $tryDigestSoft,
+  $tryMarkSoft,
+  $tryReleaseSoft,
+  ERROR_FAMILY,
+  FORK_TRUNCATION_LABEL,
+  HOST_EFFECT_LABEL_PREFIX,
+  MAX_B_TOTAL_FORKS,
+  MAX_CALL_DEPTH,
+  MAX_TOTAL_CALLS,
+  OBJECT_PROTO_NAMES,
+  abortDerivationSession,
+  absTemplateViews,
+  allFixedTextOfViews,
+  anyMemberResult,
+  awaitAbs,
+  beginDerivationSession,
+  bumpBForkBudget,
+  callBudgetKey,
+  classChainNames,
+  classFromMethods,
+  coerceAsyncReturn,
+  concatString,
+  createTemplateAbs,
+  decideEndsWith,
+  decideIncludes,
+  decideStartsWith,
+  defaultLeakBudget,
+  defineClass,
+  definitelyUncallableMember,
+  derivationChain,
+  endDerivationSession,
+  enterCall,
+  errorTypeAbs,
+  exceedsBudget,
+  exitCall,
+  filterDeclaredThrows,
+  filterGateThrows,
+  filterIgnoredThrows,
+  fixedLengthOfViews,
+  flushMayThrowEffects,
+  formatShape,
+  formatTemplateNameViews,
+  formatThrowsAbs,
+  getAbsCallBudgetStats,
+  getAbsOrigin,
+  getBForkBudgetLimit,
+  getBForkCount,
+  getClass,
+  getClassChain,
+  getDerivation,
+  getMayThrowCollector,
+  hasDerivationSession,
+  instanceOf,
+  instantiateClass,
+  isEvalMissingSlotEnabled,
+  isNullishAbs,
+  isTemplateLike,
+  isThrowsIgnored,
+  knownPrefixOfViews,
+  knownSuffixOfViews,
+  leakIfNeeded,
+  litValue,
+  lookupMethod,
+  lookupMethodWithOwner,
+  lookupSuperMethod,
+  mayThrowEffectsToAbs,
+  maybeLeak,
+  mergeAdjacentFixedViews,
+  noteAbsTruncation,
+  noteAnyMemberMayThrow,
+  noteBForkTruncation,
+  noteDerivationAdd,
+  noteDerivationJoin,
+  noteHostEffectBlocked,
+  noteMemberDispatchMiss,
+  noteNullishMemberThrows,
+  noteObjSlotMissing,
+  notePrimMemberMissing,
+  noteUnknownMemberMissing,
+  orphanMayThrowEffects,
+  parseSource,
+  popCallLoc,
+  popMayThrowFrame,
+  predToString,
+  projectBrand,
+  projectDerivationDsl,
+  pushCallLoc,
+  pushMayThrowFrame,
+  recordMayThrow,
+  recordMemberDiag,
+  resetAbsCallBudget,
+  resetBForkBudget,
+  resetLeakCounter,
+  runWithEvalMissingSlot,
+  runWithMayThrowSession,
+  setAbsTruncationCollector,
+  setBForkBudgetLimit,
+  setDerivation,
+  setDerivationCollector,
+  setEvalMissingSlotEnabled,
+  setMayThrowCollector,
+  setMemberDiagCollector,
+  stableCallId,
+  superNameOf,
+  tagAbsOrigin,
+  tagDerivationRoot,
+  templateMatchesValue,
+  templatePartsOf,
+  termDepth,
+  termKey,
+  termNodes,
+  termToString,
+  throwAbsToKinds,
+  throwsKindCovered,
+  truncatedAbs,
+  viewTemplateParts,
+  wrapPromise
+} from "./chunk-CDH7QCGQ.js";
+
+// src/algebra/inlay.ts
+function listFunctions(source) {
+  const file = parseSource(source);
+  const out = [];
+  const visitDecl = (decl) => {
+    if (decl.type === "FunctionDeclaration" && decl.id) {
+      const fd = decl;
+      out.push({ name: fd.id.name, node: fd });
+    }
+    if (decl.type === "VariableDeclaration") {
+      const dcls = decl.declarations ?? [];
+      for (const d of dcls) {
+        const id = d.id;
+        const init = d.init;
+        if (id?.type === "Identifier" && id.name && init && (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression")) {
+          out.push({ name: id.name, node: init });
+        }
+      }
+    }
+  };
+  for (const stmt of file.program.body) {
+    if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+      visitDecl(stmt.declaration);
+    } else if (stmt.type === "ExportDefaultDeclaration" && stmt.declaration) {
+      visitDecl(stmt.declaration);
+    } else {
+      visitDecl(stmt);
+    }
+  }
+  return out;
+}
+function renameTypeVars(s, varMap) {
+  let out = s;
+  const ids = [...varMap.keys()].sort((a, b) => b.length - a.length);
+  for (const id of ids) {
+    out = out.replaceAll(id, varMap.get(id));
+  }
+  return out;
+}
+function formatReturnDisplay(g) {
+  const varMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < (g.typeParams?.length ?? 0); i++) {
+    const id = g.typeParams[i].id;
+    const pname = g.params[i];
+    if (pname) varMap.set(id, pname);
+  }
+  const stripParens = (t) => t.startsWith("(") && t.endsWith(")") ? t.slice(1, -1) : t;
+  const memberPath = (m) => {
+    if (m.term?.op === "var") {
+      const name = renameTypeVars(m.term.id, varMap);
+      return { key: `var:${name}`, text: name };
+    }
+    if (m.term?.op === "app") {
+      const t = stripParens(renameTypeVars(termToString(m.term), varMap));
+      return { key: `app:${t}`, text: t };
+    }
+    const lv = litValue(m);
+    if (typeof lv === "number" && !Number.isFinite(lv)) {
+      return { key: `lit:${String(lv)}`, text: String(lv) };
+    }
+    if (lv !== void 0) {
+      return { key: `lit:${String(lv)}`, text: JSON.stringify(lv) };
+    }
+    return { key: `shape:${formatShape(m)}`, text: formatShape(m) };
+  };
+  const abs = g.symbolic;
+  if (abs.term && abs.term.op !== "lit") {
+    return stripParens(renameTypeVars(termToString(abs.term), varMap));
+  }
+  if (abs.shape.k === "sum") {
+    const parts = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const m of abs.shape.members) {
+      const { key, text } = memberPath(m);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      parts.push(text);
+    }
+    return parts.join(" | ");
+  }
+  return memberPath(abs).text;
+}
+function collectAbsInlays(source, opts) {
+  const inlays = [];
+  const refineOpts = opts?.loadModule || opts?.fromFile ? {
+    ...opts.loadModule ? { loadModule: opts.loadModule } : {},
+    ...opts.fromFile ? { fromFile: opts.fromFile } : {}
+  } : void 0;
+  for (const { name, node } of listFunctions(source)) {
+    let g;
+    try {
+      g = generalizeFromAst(name, source, refineOpts ? { refine: refineOpts } : {});
+    } catch {
+      continue;
+    }
+    if (!g) continue;
+    const tier = opts?.fromFile !== void 0 ? interfaceTierOf(source, name, opts.fromFile, {
+      ...opts.loadModule ? { loadModule: opts.loadModule } : {},
+      ...opts.autoBind !== void 0 ? { autoBind: opts.autoBind } : {}
+    }) : void 0;
+    const tierSrc = tier?.source;
+    const isImplicitExport = tierSrc === "implicit";
+    const params = g.params;
+    const predsByName = /* @__PURE__ */ new Map();
+    if (g.entryReqs) {
+      for (const r of g.entryReqs) {
+        predsByName.set(r.param, [r.pred]);
+      }
+    }
+    const fnNode = node;
+    const paramList = fnNode.params ?? [];
+    for (let i = 0; i < paramList.length; i++) {
+      const p = paramList[i];
+      const pname = params[i] ?? p?.name;
+      if (!p?.loc || !pname) continue;
+      const preds = predsByName.get(pname);
+      if (preds && preds.length > 0) {
+        const text = preds.map(predToString).join(" \u2227 ");
+        inlays.push({
+          line: p.loc.end.line,
+          character: p.loc.end.column,
+          label: `  where ${text}`,
+          kind: "parameter",
+          ...tierSrc ? { interfaceSource: tierSrc } : {}
+        });
+      }
+    }
+    const bodyLoc = fnNode.body?.loc;
+    if (bodyLoc?.start) {
+      let label;
+      try {
+        label = `: ${formatReturnDisplay(g)}`;
+      } catch {
+        label = `: ${formatShape(g.symbolic)}`;
+      }
+      if (isImplicitExport) label += "  \xB7 derived";
+      inlays.push({
+        line: bodyLoc.start.line,
+        character: Math.max(0, bodyLoc.start.column),
+        label: `${label}  `,
+        kind: "type",
+        ...tierSrc ? { interfaceSource: tierSrc } : {},
+        ...isImplicitExport ? { derived: true } : {}
+      });
+    }
+  }
+  return inlays;
+}
+
+// src/algebra/denote.ts
+function denoteGuard(a, v) {
+  const lv = litValue(a);
+  if (lv !== void 0 && (!a.pred || a.pred.op === "true")) {
+    return eqGuard(v, lv);
+  }
+  const shape = denoteShape(a.shape, v);
+  const pred = denotePred(a, v);
+  if (shape === "true") return pred;
+  if (pred === "true") return shape;
+  return `(${shape}) && (${pred})`;
+}
+function denoteShape(s, v) {
+  switch (s.k) {
+    case "never":
+      return "false";
+    case "unknown":
+    case "any":
+      return "true";
+    case "prim":
+      switch (s.type) {
+        case "number":
+          return `typeof ${v} === "number"`;
+        case "string":
+          return `typeof ${v} === "string"`;
+        case "boolean":
+          return `typeof ${v} === "boolean"`;
+        case "bigint":
+          return `typeof ${v} === "bigint"`;
+        case "symbol":
+          return `typeof ${v} === "symbol"`;
+        default:
+          return "true";
+      }
+    case "obj": {
+      const checks = [`typeof ${v} === "object"`, `${v} !== null`];
+      for (const [key, slot] of Object.entries(s.slots)) {
+        const access = `${v}.${key}`;
+        const inner = denoteGuard(slot.value, access);
+        if (slot.optional) {
+          if (inner !== "true") checks.push(`(${access} === undefined || ${inner})`);
+        } else {
+          if (inner !== "true") checks.push(inner);
+        }
+      }
+      return checks.join(" && ");
+    }
+    case "arr":
+      return `Array.isArray(${v}) && ${v}.every((item) => ${denoteGuard(s.element, "item")})`;
+    case "tuple": {
+      const checks = [`Array.isArray(${v})`];
+      const minLen = s.elements.length;
+      checks.push(s.rest ? `${v}.length >= ${minLen}` : `${v}.length === ${minLen}`);
+      s.elements.forEach((el, i) => {
+        const inner = denoteGuard(el, `${v}[${i}]`);
+        if (inner !== "true") checks.push(inner);
+      });
+      if (s.rest) {
+        const rest = denoteGuard(s.rest, "item");
+        if (rest !== "true") {
+          checks.push(`${v}.slice(${minLen}).every((item) => ${rest})`);
+        }
+      }
+      return checks.join(" && ");
+    }
+    case "fn":
+      return `typeof ${v} === "function"`;
+    case "eff":
+      if (s.eff === "promise") return `${v} instanceof Promise`;
+      return "true";
+    case "brand":
+      return denoteShape(s.shape.shape, v);
+    case "sum": {
+      if (s.members.length === 0) return "false";
+      const parts = s.members.map((m) => denoteGuard(m, v));
+      return `(${parts.join(" || ")})`;
+    }
+  }
+}
+function denotePred(a, v) {
+  const p = a.pred;
+  if (!p || p.op === "true") {
+    const lv = litValue(a);
+    if (lv !== void 0) return eqGuard(v, lv);
+    return "true";
+  }
+  return predAsJs(p, v, a);
+}
+function predAsJs(p, v, a) {
+  switch (p.op) {
+    case "true":
+      return "true";
+    case "false":
+      return "false";
+    case "and":
+      return p.args.map((x) => predAsJs(x, v, a)).join(" && ");
+    case "or":
+      return `(${p.args.map((x) => predAsJs(x, v, a)).join(" || ")})`;
+    case "not": {
+      const inner = predAsJs(p.arg, v, a);
+      return inner === "true" ? "false" : `!(${inner})`;
+    }
+    case "gt":
+    case "ge":
+    case "lt":
+    case "le":
+    case "eq":
+    case "ne": {
+      const op = { gt: ">", ge: ">=", lt: "<", le: "<=", eq: "===", ne: "!==" }[p.op];
+      const leftIsValue = termIsValue(p.a, a);
+      const rightLit = litOfTerm(p.b);
+      if (leftIsValue && rightLit !== void 0) {
+        return cmpOp(v, op, rightLit);
+      }
+      const leftLit = litOfTerm(p.a);
+      const rightIsValue = termIsValue(p.b, a);
+      if (rightIsValue && leftLit !== void 0) {
+        return cmpLitValue(leftLit, op, v);
+      }
+      if (leftLit !== void 0 && rightLit !== void 0) {
+        return `${jsLit(leftLit)} ${op} ${jsLit(rightLit)}`;
+      }
+      return "true";
+    }
+    default:
+      return "true";
+  }
+}
+function litOfTerm(t) {
+  return t.op === "lit" ? t.value : void 0;
+}
+function jsLit(v) {
+  if (v === void 0) return "undefined";
+  if (v === null) return "null";
+  if (typeof v === "number") {
+    if (Number.isNaN(v)) return "NaN";
+    if (v === Infinity) return "Infinity";
+    if (v === -Infinity) return "-Infinity";
+    return String(v);
+  }
+  return JSON.stringify(v);
+}
+function eqGuard(v, lv) {
+  if (typeof lv === "number" && Number.isNaN(lv)) return `Number.isNaN(${v})`;
+  return `${v} === ${jsLit(lv)}`;
+}
+function cmpOp(v, op, lit) {
+  if (typeof lit === "number" && Number.isNaN(lit)) {
+    if (op === "===") return `Number.isNaN(${v})`;
+    if (op === "!==") return `!Number.isNaN(${v})`;
+  }
+  return `${v} ${op} ${jsLit(lit)}`;
+}
+function cmpLitValue(lit, op, v) {
+  if (typeof lit === "number" && Number.isNaN(lit)) {
+    if (op === "===") return `Number.isNaN(${v})`;
+    if (op === "!==") return `!Number.isNaN(${v})`;
+  }
+  return `${jsLit(lit)} ${op} ${v}`;
+}
+function termIsValue(t, a) {
+  if (t.op === "var") return true;
+  if (t.op === "lit") {
+    const lv = litValue(a);
+    return lv !== void 0 && Object.is(lv, t.value);
+  }
+  return false;
+}
+export {
+  $tryDigestSoft,
+  $tryMarkSoft,
+  $tryReleaseSoft,
+  ERROR_FAMILY,
+  FORK_TRUNCATION_LABEL,
+  HOST_EFFECT_LABEL_PREFIX,
+  MAX_B_TOTAL_FORKS,
+  MAX_CALL_DEPTH,
+  MAX_TOTAL_CALLS,
+  OBJECT_PROTO_NAMES,
+  abortDerivationSession,
+  absTemplateViews,
+  allFixedTextOfViews,
+  anyMemberResult,
+  awaitAbs,
+  beginDerivationSession,
+  bumpBForkBudget,
+  callBudgetKey,
+  canSkipLiteralCallScan,
+  checkInjectedDomainEvidence,
+  classChainNames,
+  classFromMethods,
+  coerceAsyncReturn,
+  collectAbsInlays,
+  concatString,
+  createTemplateAbs,
+  decideEndsWith,
+  decideIncludes,
+  decideStartsWith,
+  defaultLeakBudget,
+  defineClass,
+  definitelyUncallableMember,
+  denoteGuard,
+  derivationChain,
+  endDerivationSession,
+  enterCall,
+  errorTypeAbs,
+  exceedsBudget,
+  exitCall,
+  extractAllLoadSpecs,
+  filterDeclaredThrows,
+  filterGateThrows,
+  filterIgnoredThrows,
+  fixedLengthOfViews,
+  flushMayThrowEffects,
+  fnFingerprints,
+  formatTemplateNameViews,
+  formatThrowsAbs,
+  generalizeSourceKeyPart,
+  getAbsCallBudgetStats,
+  getAbsOrigin,
+  getBForkBudgetLimit,
+  getBForkCount,
+  getClass,
+  getClassChain,
+  getDerivation,
+  getFnNameAndBodies,
+  getMayThrowCollector,
+  hasDerivationSession,
+  hashSource,
+  instanceOf,
+  instantiateClass,
+  isEvalMissingSlotEnabled,
+  isNullishAbs,
+  isTemplateLike,
+  isThrowsIgnored,
+  knownPrefixOfViews,
+  knownSuffixOfViews,
+  leakIfNeeded,
+  listTopFunctions,
+  loadModuleDepsFingerprint,
+  lookupMethod,
+  lookupMethodWithOwner,
+  lookupSuperMethod,
+  mayThrowEffectsToAbs,
+  maybeLeak,
+  mergeAdjacentFixedViews,
+  normPath,
+  noteAbsTruncation,
+  noteAnyMemberMayThrow,
+  noteBForkTruncation,
+  noteDerivationAdd,
+  noteDerivationJoin,
+  noteHostEffectBlocked,
+  noteMemberDispatchMiss,
+  noteNullishMemberThrows,
+  noteObjSlotMissing,
+  notePrimMemberMissing,
+  noteUnknownMemberMissing,
+  orphanMayThrowEffects,
+  popCallLoc,
+  popMayThrowFrame,
+  projectBrand,
+  projectDerivationDsl,
+  pushCallLoc,
+  pushMayThrowFrame,
+  recordMayThrow,
+  recordMemberDiag,
+  resetAbsCallBudget,
+  resetBForkBudget,
+  resetFnFpCache,
+  resetHashSourceCache,
+  resetLeakCounter,
+  resolveDepPath,
+  runWithEvalMissingSlot,
+  runWithMayThrowSession,
+  setAbsTruncationCollector,
+  setBForkBudgetLimit,
+  setDerivation,
+  setDerivationCollector,
+  setEvalMissingSlotEnabled,
+  setMayThrowCollector,
+  setMemberDiagCollector,
+  sidecarSpecsOf,
+  stableAnalyzeKeySource,
+  stableCallId,
+  superNameOf,
+  tagAbsOrigin,
+  tagDerivationRoot,
+  templateMatchesValue,
+  templatePartsOf,
+  termDepth,
+  termKey,
+  termNodes,
+  throwAbsToKinds,
+  throwsKindCovered,
+  truncatedAbs,
+  viewTemplateParts,
+  wrapPromise
+};

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@nudojs/core",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "engines": {
     "node": ">=20"
   },
-  "description": "Nudo type system: type-as-computation (Abs) with TypeValue evaluation IR",
+  "description": "Nudo type system: type-as-computation (Abs = shape × term × pred × conf)",
   "type": "module",
   "license": "MIT",
   "keywords": [
@@ -24,6 +24,10 @@
     "./exec": {
       "types": "./dist/exec.d.ts",
       "default": "./dist/exec.js"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.ts",
+      "default": "./dist/internal.js"
     }
   },
   "files": [
@@ -42,20 +46,21 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@babel/parser": "^7.29.0",
-    "@babel/types": "^7.29.0"
+    "@babel/parser": "^8.0.6",
+    "@babel/types": "^8.0.6"
   },
   "devDependencies": {
-    "commander": "^13.0.0",
+    "commander": "^15.0.0",
     "debug": "^4.4.3",
     "escape-string-regexp": "^5.0.0",
     "eventemitter3": "^5.0.4",
     "is-plain-obj": "^4.1.0",
     "kleur": "^4.1.5",
-    "lodash": "^4.17.21",
+    "lodash": "^4.18.1",
     "ms": "^2.1.3",
-    "p-limit": "^7.3.2",
-    "yocto-queue": "^1.2.2"
+    "p-limit": "^7.3.3",
+    "yocto-queue": "^1.2.2",
+    "@types/node": "^26.6.2"
   },
   "scripts": {
     "build": "tsup"