@nudojs/core 1.9.3 → 1.10.0

package/dist/{chunk-VMGJYMIF.js → chunk-HX4IEPRI.js}

@@ -15,6 +15,7 @@ import {
   fnConstraintToEntryReqs,
   foldRequireSpecArg,
   formalParamDisplayNames,
+  formalParamSignatureNames,
   formalParamsFromNodes,
   formatAbs,
   formatShape,
@@ -46,7 +47,7 @@ import {
   withEvalBudgetOverride,
   withExecPhi,
   withFnBudgetOverride
-} from "./chunk-HD6XZFOU.js";
+} from "./chunk-YREYFITQ.js";
 
 // src/algebra/directive-scan.ts
 function cleanDirectiveLine(raw, kind) {
@@ -987,6 +988,75 @@ function rewriteSidecarSource(src, fromFile) {
       }
     }
   }
+  const aliasToImported = /* @__PURE__ */ new Map();
+  const fnAliases = /* @__PURE__ */ new Set(["fn"]);
+  for (const imp of imports) {
+    for (const n of imp.names) {
+      if (n.ns) continue;
+      if (n.imported !== void 0 && n.local !== void 0 && n.imported !== n.local) {
+        aliasToImported.set(n.local, n.imported);
+      }
+      if (n.imported === "fn" && n.local !== void 0) fnAliases.add(n.local);
+    }
+  }
+  const paramTextsOfFnCall = (init) => {
+    const call = init;
+    if (!call || call.type !== "CallExpression") return void 0;
+    if (call.callee?.type !== "Identifier" || !fnAliases.has(call.callee.name ?? "")) {
+      return void 0;
+    }
+    const first = call.arguments?.[0];
+    if (!first || first.type !== "ObjectExpression") return void 0;
+    const texts = /* @__PURE__ */ new Map();
+    for (const prop of first.properties ?? []) {
+      if (prop.type !== "ObjectProperty" || prop.computed) continue;
+      const key = prop.key?.type === "Identifier" ? prop.key.name : prop.key?.type === "StringLiteral" ? prop.key.value : void 0;
+      if (key === void 0) continue;
+      const v2 = prop.value;
+      if (!v2 || v2.start == null || v2.end == null) continue;
+      texts.set(
+        key,
+        v2.type === "Identifier" && aliasToImported.has(v2.name ?? "") ? aliasToImported.get(v2.name ?? "") : src.slice(v2.start, v2.end)
+      );
+    }
+    return texts;
+  };
+  const paramInfosByLocal = /* @__PURE__ */ new Map();
+  const collectVarFns = (decls) => {
+    for (const d of decls) {
+      if (d?.id?.type !== "Identifier" || d.id.name === void 0) continue;
+      const texts = paramTextsOfFnCall(d.init);
+      if (texts)
+        paramInfosByLocal.set(d.id.name, {
+          texts,
+          line: d.loc?.start?.line ?? 1
+        });
+    }
+  };
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "VariableDeclaration") {
+      collectVarFns(
+        stmt.declaration?.declarations ?? []
+      );
+    } else if (stmt.type === "VariableDeclaration") {
+      collectVarFns(
+        stmt.declarations ?? []
+      );
+    } else if (stmt.type === "ExportDefaultDeclaration") {
+      const decl = stmt.declaration;
+      const texts = paramTextsOfFnCall(decl);
+      if (texts)
+        paramInfosByLocal.set(DEFAULT_LOCAL, {
+          texts,
+          line: stmt.loc?.start?.line ?? 1
+        });
+    }
+  }
+  const bindingInfos = /* @__PURE__ */ new Map();
+  for (const p of exportPairs) {
+    const info = paramInfosByLocal.get(p.expr);
+    if (info) bindingInfos.set(p.key, info);
+  }
   if (fromFile?.endsWith(".nudo.ts")) {
     for (const cut of collectTsSyntaxCuts(ast.program, src)) {
       cuts.push({ start: cut.start, end: cut.end, text: "" });
@@ -1010,7 +1080,7 @@ function rewriteSidecarSource(src, fromFile) {
     pos = c.end;
   }
   code += src.slice(pos);
-  return { code, exportPairs, imports };
+  return { code, exportPairs, imports, bindingInfos };
 }
 var TS_STMT_CUT_TYPES = /* @__PURE__ */ new Set([
   "TSInterfaceDeclaration",
@@ -1082,9 +1152,25 @@ function collectTsSyntaxCuts(node, src, cuts = []) {
   }
   return cuts;
 }
+function registerSidecarParamTexts(sidecarPath, contentKey, infos) {
+  let perPath = sidecarParamTextsRegistry.get(sidecarPath);
+  if (perPath === void 0) {
+    perPath = /* @__PURE__ */ new Map();
+    sidecarParamTextsRegistry.set(sidecarPath, perPath);
+    if (sidecarParamTextsRegistry.size > MAX_SIDECAR_PARAM_TEXTS_PATHS) {
+      const oldest = sidecarParamTextsRegistry.keys().next().value;
+      if (oldest !== void 0) sidecarParamTextsRegistry.delete(oldest);
+    }
+  }
+  perPath.set(contentKey, infos);
+  if (perPath.size > MAX_SIDECAR_PARAM_TEXTS_VERSIONS) {
+    const oldest = perPath.keys().next().value;
+    if (oldest !== void 0) perPath.delete(oldest);
+  }
+}
 function execSidecar(src, opts, chain, preloaded) {
   const fromFile = opts?.fromFile;
-  const { code, exportPairs, imports } = rewriteSidecarSource(src, fromFile);
+  const { code, exportPairs, imports, bindingInfos } = rewriteSidecarSource(src, fromFile);
   const prologue = [];
   const deps = {};
   for (const imp of imports) {
@@ -1166,12 +1252,13 @@ function execSidecar(src, opts, chain, preloaded) {
       for (const n of imp.names) deps[n.local] = void 0;
       continue;
     }
-    const depExports = execSidecar(
+    const depOut = execSidecar(
       depSrc,
       { loadModule: load, fromFile: canonical },
       [...chain, canonical],
       preloaded
     );
+    const depExports = depOut.exports;
     for (const n of imp.names) {
       if (n.ns) {
         deps[n.local] = depExports;
@@ -1211,7 +1298,11 @@ return { ${returnObj} };`;
     "__nudoDeps",
     body
   );
-  return fn(...Object.values(sidecarInjects), sidecarInjects, deps);
+  const result = fn(...Object.values(sidecarInjects), sidecarInjects, deps);
+  if (fromFile !== void 0 && bindingInfos.size > 0) {
+    registerSidecarParamTexts(fromFile, hashSource(src), bindingInfos);
+  }
+  return { exports: result, bindingInfos };
 }
 function execNudoModule(src, opts) {
   return execNudoModuleCached(src, opts ?? {});
@@ -1267,22 +1358,29 @@ function execNudoModuleCached(src, opts) {
     if (hit !== void 0) {
       nudoModuleExecCache.delete(key);
       nudoModuleExecCache.set(key, hit);
-      return hit;
+      if (opts.fromFile !== void 0 && hit.bindingInfos.size > 0) {
+        registerSidecarParamTexts(
+          opts.fromFile,
+          hashSource(src),
+          hit.bindingInfos
+        );
+      }
+      return hit.exports;
     }
     if (nudoModuleFailCache.has(key)) {
       throw nudoModuleFailCache.get(key);
     }
   }
   try {
-    const out = execSidecar(src, opts, opts.fromFile ? [opts.fromFile] : [], preloaded);
+    const { exports, bindingInfos } = execSidecar(src, opts, opts.fromFile ? [opts.fromFile] : [], preloaded);
     if (key !== void 0) {
       if (nudoModuleExecCache.size >= MAX_NUDO_MODULE_EXEC) {
         const oldest = nudoModuleExecCache.keys().next().value;
         if (oldest !== void 0) nudoModuleExecCache.delete(oldest);
       }
-      nudoModuleExecCache.set(key, out);
+      nudoModuleExecCache.set(key, { exports, bindingInfos });
     }
-    return out;
+    return exports;
   } catch (e) {
     if (key !== void 0) {
       if (nudoModuleFailCache.size >= MAX_NUDO_MODULE_EXEC) {
@@ -1297,6 +1395,17 @@ function execNudoModuleCached(src, opts) {
 function resetNudoModuleExecCache() {
   nudoModuleExecCache.clear();
   nudoModuleFailCache.clear();
+  sidecarParamTextsRegistry.clear();
+}
+var sidecarParamTextsRegistry = /* @__PURE__ */ new Map();
+var MAX_SIDECAR_PARAM_TEXTS_PATHS = 64;
+var MAX_SIDECAR_PARAM_TEXTS_VERSIONS = 32;
+function lookupSidecarParamTexts(sidecarPath, srcHash, bindingName) {
+  const perPath = sidecarParamTextsRegistry.get(sidecarPath);
+  if (perPath === void 0) return void 0;
+  const perHash = perPath.get(srcHash);
+  if (perHash === void 0) return void 0;
+  return perHash.get(bindingName);
 }
 function collectConstraints(source, opts) {
   const map = /* @__PURE__ */ new Map();
@@ -1410,7 +1519,8 @@ function extractRefinesFromSource(source, fnName, opts = {}) {
       out.push({
         param,
         pred: instantiateConstraint(c, param),
-        constraint: c
+        constraint: c,
+        name: cName
       });
     }
   }
@@ -1857,18 +1967,25 @@ function loadSidecarBinding(source, fnName, opts) {
     return { ok: false };
   }
   let binding = Object.hasOwn(exports, fnName) ? exports[fnName] : void 0;
+  let bindingKey;
+  if (binding !== void 0) bindingKey = fnName;
   if (binding === void 0) {
     const aliasExport2 = exportedNameOfLocal(source, fnName);
     if (aliasExport2 !== void 0 && Object.hasOwn(exports, aliasExport2)) {
       binding = exports[aliasExport2];
+      bindingKey = aliasExport2;
     }
   }
   if (binding === void 0 && exports.default !== void 0 && isDefaultExportLocal(source, fnName)) {
     binding = exports.default;
+    bindingKey = "default";
   }
   if (binding === void 0 && fnName.includes(".")) {
     const [cls, method] = fnName.split(".", 2);
-    binding = Object.hasOwn(exports, `${cls}_${method}`) ? exports[`${cls}_${method}`] : void 0;
+    if (Object.hasOwn(exports, `${cls}_${method}`)) {
+      binding = exports[`${cls}_${method}`];
+      bindingKey = `${cls}_${method}`;
+    }
     if (binding === void 0) {
       const bag = Object.hasOwn(exports, cls) ? exports[cls] : void 0;
       if (bag && typeof bag === "object" && !isNudoConstraint(bag)) {
@@ -1906,11 +2023,14 @@ function loadSidecarBinding(source, fnName, opts) {
     const [cls, method] = fnName.split(".", 2);
     return generatedNames.has(`${cls}_${method}`) || generatedNames.has(cls);
   })() : false);
+  const info = bindingKey !== void 0 ? lookupSidecarParamTexts(sidecarPath, hashSource(sidecarSrc), bindingKey) : void 0;
   return {
     ok: true,
     sidecarPath,
     constraint: binding,
-    generated: isGenerated
+    generated: isGenerated,
+    ...info?.texts !== void 0 ? { paramTexts: info.texts } : {},
+    ...info?.line !== void 0 ? { sidecarLine: info.line } : {}
   };
 }
 function boundsOf(c) {
@@ -2013,8 +2133,24 @@ function effectiveInterface(source, fnName, opts = {}) {
     collectDiag2({ code: d.code, message: d.message, ...d.file ? { file: d.file } : {} });
   }
   const sidecarFn = sidecar.ok ? sidecar.constraint : void 0;
+  const sidecarParamTexts = sidecar.ok ? sidecar.paramTexts : void 0;
   const sidecarGenerated = sidecar.ok && sidecar.generated;
   const sidecarParams = sidecarFn ? fnConstraintToEntryReqs(sidecarFn) : [];
+  const sidecarParamSet = new Set(sidecarParams.map((p) => p.param));
+  const sidecarTexts = /* @__PURE__ */ new Map();
+  if (sidecarParamTexts) {
+    for (const param of sidecarParamSet) {
+      const t = sidecarParamTexts.get(param);
+      if (t !== void 0) sidecarTexts.set(param, t);
+    }
+  }
+  const directiveNames = /* @__PURE__ */ new Map();
+  for (const e of sourceEntries) {
+    if (e.name === void 0) continue;
+    const list = directiveNames.get(e.param);
+    if (list === void 0) directiveNames.set(e.param, [e.name]);
+    else if (!list.includes(e.name)) list.push(e.name);
+  }
   const sidecarReturns = sidecarFn?.fn.returns;
   const sidecarThrowsKinds = throwConstraintToKinds(sidecarFn?.fn.throws);
   const mergedThrows = (() => {
@@ -2027,9 +2163,16 @@ function effectiveInterface(source, fnName, opts = {}) {
     if (sidecarFn !== void 0 && sidecarGenerated) {
       return {
         fnName,
-        params: sidecarParams,
+        params: sidecarParams.map(({ param, constraint }) => {
+          const display = sidecarTexts.get(param);
+          return display !== void 0 ? { param, constraint, display } : { param, constraint };
+        }),
         ...sidecarReturns !== void 0 ? { returns: { constraint: sidecarReturns } } : {},
         ...mergedThrows !== void 0 ? { throws: { kinds: mergedThrows } } : {},
+        ...sidecar.ok ? {
+          sidecarPath: sidecar.sidecarPath,
+          ...sidecar.sidecarLine !== void 0 ? { sidecarLine: sidecar.sidecarLine } : {}
+        } : {},
         source: "generated"
       };
     }
@@ -2082,9 +2225,27 @@ function effectiveInterface(source, fnName, opts = {}) {
   }
   return {
     fnName,
-    params: [...params.entries()].map(([param, constraint]) => ({ param, constraint })),
+    params: [...params.entries()].map(([param, constraint]) => {
+      const sidecarText = sidecarTexts.get(param);
+      const names = directiveNames.get(param);
+      const fromSidecar = sidecarFn !== void 0 && !sidecarGenerated && sidecarParamSet.has(param);
+      const fromDirective = names !== void 0;
+      let display;
+      if (fromSidecar && fromDirective) {
+        display = sidecarText !== void 0 ? `${sidecarText} \u2227 ${names.join(" \u2227 ")}` : void 0;
+      } else if (fromSidecar) {
+        display = sidecarText;
+      } else if (fromDirective) {
+        display = names.join(" \u2227 ");
+      }
+      return display !== void 0 ? { param, constraint, display } : { param, constraint };
+    }),
     ...returnsC !== void 0 ? { returns: { constraint: returnsC } } : {},
     ...mergedThrows !== void 0 ? { throws: { kinds: mergedThrows } } : {},
+    ...sidecar.ok ? {
+      sidecarPath: sidecar.sidecarPath,
+      ...sidecar.sidecarLine !== void 0 ? { sidecarLine: sidecar.sidecarLine } : {}
+    } : {},
     source: "handwritten",
     ...conflictParams.length > 0 || conflictReturns ? {
       conflict: {
@@ -2235,7 +2396,7 @@ function formatConstraint(c) {
   return fmtConstraint(c);
 }
 function formatEffectiveInterfaceDisplay(eff) {
-  const params = eff.params.map((p) => `${p.param}: ${formatConstraint(p.constraint)}`).join(", ");
+  const params = eff.params.map((p) => `${p.param}: ${p.display ?? formatConstraint(p.constraint)}`).join(", ");
   let s = `(${params})`;
   if (eff.returns) s += ` \u2192 ${formatConstraint(eff.returns.constraint)}`;
   return s;
@@ -2253,7 +2414,12 @@ function interfaceTierOf(source, fnName, fromFile, opts = {}) {
   const eff = effectiveInterface(source, fnName, { fromFile, ...opts });
   const src = eff?.source ?? "implicit";
   if (eff && src !== "implicit") {
-    return { source: src, display: formatEffectiveInterfaceDisplay(eff) };
+    return {
+      source: src,
+      display: formatEffectiveInterfaceDisplay(eff),
+      ...eff.sidecarPath !== void 0 ? { sidecarPath: eff.sidecarPath } : {},
+      ...eff.sidecarLine !== void 0 ? { sidecarLine: eff.sidecarLine } : {}
+    };
   }
   return { source: src };
 }
@@ -3479,7 +3645,8 @@ function generalizeFromAstUncached(fnName, source, opts = {}) {
       if (reqs.length > 0) {
         entryReqs = reqs.map((e) => ({
           param: e.param,
-          pred: instantiateConstraint(e.constraint, e.param)
+          pred: instantiateConstraint(e.constraint, e.param),
+          ...e.display !== void 0 ? { display: e.display } : {}
         }));
         const patternFields = /* @__PURE__ */ new Map();
         for (const e of reqs) {
@@ -3504,10 +3671,33 @@ function generalizeFromAstUncached(fnName, source, opts = {}) {
               patternFields.set(hit.index, bag);
             }
             const fieldAbs = constraintToEntryAbs(e.constraint, e.param);
-            bag[hit.field] = {
+            const leaf = {
               abs: fieldAbs,
               ...e.constraint.isOptional ? { optional: true } : {}
             };
+            const segs = hit.fieldPath ?? [hit.field];
+            if (segs.length <= 1) {
+              bag[hit.field] = leaf;
+              continue;
+            }
+            let level = bag;
+            let skip = false;
+            for (let i = 0; i < segs.length - 1; i++) {
+              const node = level[segs[i]];
+              if (node === void 0) {
+                const sub = { slots: {} };
+                level[segs[i]] = sub;
+                level = sub.slots;
+              } else if ("slots" in node) {
+                level = node.slots;
+              } else {
+                skip = true;
+                break;
+              }
+            }
+            if (!skip) {
+              level[segs[segs.length - 1]] = leaf;
+            }
           } else if (hit) {
             const entryAbs = constraintToEntryAbs(e.constraint, e.param);
             typeParams[hit.index] = {
@@ -3520,20 +3710,34 @@ function generalizeFromAstUncached(fnName, source, opts = {}) {
             });
           }
         }
-        for (const [pIdx, bag] of patternFields) {
+        const sigNames = formalParamSignatureNames(formals);
+        const buildPatternObjAbs = (slotsBag, sigName, walked) => {
           const slots = {};
-          for (const [key, rec] of Object.entries(bag)) {
-            slots[key] = {
-              value: rec.abs,
-              ...rec.optional ? { optional: true } : {}
-            };
+          for (const [key, node] of Object.entries(slotsBag)) {
+            if ("abs" in node) {
+              slots[key] = {
+                value: node.abs,
+                ...node.optional ? { optional: true } : {}
+              };
+            } else {
+              slots[key] = {
+                value: buildPatternObjAbs(node.slots, sigName, [...walked, key])
+              };
+            }
           }
-          const objAbs = abs(
+          return abs(
             { k: "obj", slots },
-            v(params[pIdx] ?? `_p${pIdx}`),
+            v(walked.length === 0 ? sigName : `${sigName}.${walked.join(".")}`),
             void 0,
             "path"
           );
+        };
+        for (const [pIdx, bag] of patternFields) {
+          const objAbs = buildPatternObjAbs(
+            bag,
+            sigNames[pIdx] ?? params[pIdx] ?? `_p${pIdx}`,
+            []
+          );
           typeParams[pIdx] = {
             id: typeParams[pIdx].id,
             value: objAbs
@@ -3677,6 +3881,7 @@ function generalizeFromAstUncached(fnName, source, opts = {}) {
       }));
     }
   }
+  const renderNames = formals.length > 0 ? formalParamSignatureNames(formals) : params;
   return {
     name: fnName,
     params,
@@ -3685,6 +3890,7 @@ function generalizeFromAstUncached(fnName, source, opts = {}) {
     instantiate: (args, phi) => run(args, phi ?? pTrue),
     display: formatPoly(
       fnName,
+      renderNames,
       params,
       typeParams,
       symbolic,
@@ -3699,12 +3905,13 @@ function generalizeFromAstUncached(fnName, source, opts = {}) {
     ...hofSites ? { hofSites } : {}
   };
 }
-function formatPoly(name, params, typeParams, symbolic, entryReqs, entryShapes, fnRels) {
+function formatPoly(name, renderNames, params, typeParams, symbolic, entryReqs, entryShapes, fnRels) {
   const reqByParam = new Map((entryReqs ?? []).map((r) => [r.param, r.pred]));
-  const ps = params.map((p, i) => {
+  const ps = renderNames.map((p, i) => {
+    const key = params[i] ?? p;
     const id = typeParams[i]?.id ?? "unknown";
-    const pred = reqByParam.get(p);
-    const promoted = entryShapes?.get(p)?.abs ?? fnRels?.get(p)?.abs;
+    const pred = reqByParam.get(key);
+    const promoted = entryShapes?.get(key)?.abs ?? fnRels?.get(key)?.abs;
     if (promoted) {
       const slot = formatShapeSlot(promoted);
       if (pred && pred.op !== "true") {
@@ -4480,13 +4687,17 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
     eiCache.set(key, r);
     return r;
   };
-  const projectArgField = (arg, field) => {
-    if (!arg) return void 0;
-    if (arg.shape.k === "brand") {
-      return projectArgField(arg.shape.shape, field);
+  const projectArgPath = (arg, segments) => {
+    let cur = arg;
+    for (const seg of segments) {
+      if (!cur) return void 0;
+      if (cur.shape.k === "brand") {
+        cur = cur.shape.shape;
+      }
+      if (cur.shape.k !== "obj") return void 0;
+      cur = getSlot(cur.shape.slots, seg)?.value;
     }
-    if (arg.shape.k !== "obj") return void 0;
-    return getSlot(arg.shape.slots, field)?.value;
+    return cur;
   };
   const interfaceToIndexed = (ei, paramNames, formals) => {
     const conflict = new Set(ei.conflict?.params ?? []);
@@ -4508,7 +4719,7 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
           entries.push([
             hit.index,
             { param, pred: instantiateConstraint(constraint, param), constraint },
-            hit.field
+            hit.fieldPath ?? (hit.field !== void 0 ? [hit.field] : void 0)
           ]);
         }
       }
@@ -4544,17 +4755,18 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
     return lv <= n;
   };
   const checkReqs = (displayName, reqs, paramNames, absArgs, argIndexOf, loc) => {
-    for (const [idx, pred, field, contractParam] of reqs) {
+    for (const [idx, pred, fieldPath, contractParam] of reqs) {
       const argIdx = argIndexOf(idx);
       if (argIdx === void 0) continue;
       let arg = absArgs[argIdx];
       if (!arg) continue;
       const paramName = contractParam || paramNames[idx] || `arg${idx}`;
-      if (field) {
-        const projected = projectArgField(arg, field);
+      if (fieldPath) {
+        const projected = projectArgPath(arg, fieldPath);
         if (!projected) {
           const k = arg.shape.k;
           if (k !== "unknown" && k !== "any") {
+            const field = fieldPath.join(".");
             out.push({
               severity: "error",
               code: "nudo:constraint-violated",
@@ -4895,7 +5107,7 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
     }
   };
   const checkShapeReqs = (displayName, reqs, paramNames, absArgs, argIndexOf, loc) => {
-    for (const [idx, entry, field] of reqs) {
+    for (const [idx, entry, fieldPath] of reqs) {
       const c = entry.constraint;
       if (!c.fields && !c.element && !isIntFlag(c) && !c.prim) continue;
       const argIdx = argIndexOf(idx);
@@ -4903,11 +5115,12 @@ function scanLiteralCalls(source, knownFns, phi, opts) {
       let arg = absArgs[argIdx];
       if (!arg) continue;
       const paramName = entry.param || paramNames[idx] || `arg${idx}`;
-      if (field) {
-        const projected = projectArgField(arg, field);
+      if (fieldPath) {
+        const projected = projectArgPath(arg, fieldPath);
         if (!projected) {
           const k = arg.shape.k;
           if (k !== "unknown" && k !== "any") {
+            const field = fieldPath.join(".");
             out.push({
               severity: "error",
               code: "nudo:constraint-violated",