@nudojs/core 1.9.4 → 1.10.0

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

@@ -47,7 +47,7 @@ import {
   withEvalBudgetOverride,
   withExecPhi,
   withFnBudgetOverride
-} from "./chunk-PGTNSUTE.js";
+} from "./chunk-YREYFITQ.js";
 
 // src/algebra/directive-scan.ts
 function cleanDirectiveLine(raw, kind) {
@@ -988,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: "" });
@@ -1011,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",
@@ -1083,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) {
@@ -1167,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;
@@ -1212,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 ?? {});
@@ -1268,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) {
@@ -1298,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();
@@ -1411,7 +1519,8 @@ function extractRefinesFromSource(source, fnName, opts = {}) {
       out.push({
         param,
         pred: instantiateConstraint(c, param),
-        constraint: c
+        constraint: c,
+        name: cName
       });
     }
   }
@@ -1858,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)) {
@@ -1907,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) {
@@ -2014,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 = (() => {
@@ -2028,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"
       };
     }
@@ -2083,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: {
@@ -2236,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;
@@ -2254,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 };
 }
@@ -3480,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) {