@nudojs/cli 2.0.0 → 3.0.0

package/dist/index.js

@@ -16305,7 +16305,12 @@ function isRelFn(a) {
   if (!s || s.k !== "fn") return false;
   if (s.returnType === void 0) return false;
   if (s.paramTypes === void 0) return s.params.length === 0;
-  return s.paramTypes.length === s.params.length;
+  if (s.paramTypes.length === s.params.length) return true;
+  let required = 0;
+  for (const p of s.params) {
+    if (p && !p.startsWith("...") && !p.endsWith("?")) required++;
+  }
+  return s.paramTypes.length === required;
 }
 function litOfTerm(t) {
   return t.op === "lit" ? t.value : void 0;
@@ -18910,6 +18915,15 @@ function ok() {
 function fail(reason) {
   return { ok: false, reason };
 }
+function requiredFnArity(params) {
+  if (!params) return 0;
+  let n = 0;
+  for (const p of params) {
+    if (!p || p.startsWith("...") || p.endsWith("?")) continue;
+    n++;
+  }
+  return n;
+}
 function leqAbs(src, tgt, opts = {}) {
   const phi2 = opts.phi ?? pTrue;
   return leqWithPred(src, tgt, phi2, opts.env ?? null, 0);
@@ -19062,8 +19076,12 @@ function leqShape(src, tgt, phi2, env, depth) {
   }
   if (t.k === "fn") {
     if (s.k !== "fn") return fail(`shape ${s.k} \u22AD fn`);
-    if (s.params.length !== t.params.length) {
-      return fail(`fn arity ${s.params.length} \u22AD ${t.params.length}`);
+    const sReq = requiredFnArity(s.params);
+    const tReq = requiredFnArity(t.params);
+    if (sReq > tReq) {
+      return fail(
+        `fn arity required ${sReq} \u22AD target required ${tReq} (params ${s.params.length} / ${t.params.length})`
+      );
     }
     if (t.returnType !== void 0) {
       const sr = s.returnType;
@@ -21319,13 +21337,39 @@ function formatShape(a) {
     case "tuple":
       return `[${s.elements.map(formatShape).join(", ")}]`;
     case "fn": {
-      if (s.paramTypes && s.paramTypes.length > 0) {
-        const ps = s.paramTypes.map((p) => formatShapeSlot(p));
-        const ret2 = s.returnType !== void 0 ? formatShapeSlot(s.returnType) : "?";
-        return `(${ps.join(", ")}) => ${ret2}`;
-      }
       const ret = s.returnType !== void 0 ? formatShapeSlot(s.returnType) : "?";
-      return `(${s.params.join(", ")}) => ${ret}`;
+      const labels = s.params ?? [];
+      const paramTypes = s.paramTypes;
+      const hasMarkers = labels.some(
+        (p) => p.startsWith("...") || p.endsWith("?")
+      );
+      const renderLabeled = () => {
+        const ps = [];
+        const n = paramTypes ? Math.max(paramTypes.length, labels.length) : labels.length;
+        for (let i = 0; i < n; i++) {
+          const label = labels[i];
+          const type = paramTypes?.[i];
+          const typeText = type !== void 0 ? formatShapeSlot(type) : void 0;
+          if (label?.startsWith("...")) {
+            ps.push(typeText ? `...${label.slice(3)}: ${typeText}` : label);
+          } else if (label?.endsWith("?")) {
+            ps.push(typeText ? `${label.slice(0, -1)}?: ${typeText}` : label);
+          } else if (typeText !== void 0) {
+            ps.push(typeText);
+          } else if (label) {
+            ps.push(label);
+          }
+        }
+        return ps;
+      };
+      if (hasMarkers) {
+        return `(${renderLabeled().join(", ")}) => ${ret}`;
+      }
+      if (paramTypes && paramTypes.length > 0) {
+        const ps = paramTypes.map((p) => formatShapeSlot(p));
+        return `(${ps.join(", ")}) => ${ret}`;
+      }
+      return `(${labels.join(", ")}) => ${ret}`;
     }
     case "brand":
       return `${s.name}`;
@@ -21453,20 +21497,17 @@ function any() {
   return makeBuilder(void 0, []);
 }
 function array(item) {
-  if (!isConstraint(item))
-    throw new Error("nudo: array(item) \u671F\u671B\u7EA6\u675F\u503C\uFF08number()/string()/\u2026\u6216\u5176\u7EC4\u5408\u5B50\uFF09");
-  return makeBuilder(void 0, [], { element: item });
+  return makeBuilder(void 0, [], {
+    element: asNestedConstraint(item, "array(item)")
+  });
 }
 function shape(fields) {
   const mapped = {};
   for (const [k, v2] of Object.entries(fields)) {
-    if (!isConstraint(v2))
-      throw new Error(
-        `nudo: shape \u5B57\u6BB5 '${k}' \u671F\u671B\u7EA6\u675F\u503C\uFF08number()/string()/\u2026\u6216\u5176\u7EC4\u5408\u5B50\uFF09\uFF0C\u6536\u5230\u975E\u7EA6\u675F`
-      );
+    const constraint = asNestedConstraint(v2, `shape \u5B57\u6BB5 '${k}'`);
     mapped[k] = {
-      constraint: v2,
-      ...v2.isOptional ? { optional: true } : {}
+      constraint,
+      ...constraint.isOptional ? { optional: true } : {}
     };
   }
   return makeBuilder(void 0, [], { fields: mapped });
@@ -21491,19 +21532,32 @@ function lit3(v2) {
   const prim2 = typeof v2 === "number" ? "number" : typeof v2 === "string" ? "string" : typeof v2 === "boolean" ? "boolean" : void 0;
   return makeBuilder(prim2, [eq(selfTerm(), lit(v2))]);
 }
+function asNestedConstraint(x, ctx) {
+  if (isConstraint(x)) return toPlainConstraint(x);
+  if (x === null || x === void 0 || typeof x === "number" || typeof x === "string" || typeof x === "boolean") {
+    return toPlainConstraint(lit3(x));
+  }
+  throw new Error(
+    `nudo: ${ctx} \u671F\u671B\u7EA6\u675F\u503C\uFF08number()/string()/\u2026\uFF09\u6216\u5177\u4F53\u5B57\u9762\u91CF\uFF0C\u6536\u5230\u975E\u7EA6\u675F`
+  );
+}
 function union(...cs) {
   if (cs.length === 0)
     throw new Error("nudo union(): \u81F3\u5C11\u9700\u8981\u4E00\u4E2A\u6210\u5458\u7EA6\u675F");
-  return makeBuilder(void 0, [], { members: cs.map(toPlainConstraint) });
+  return makeBuilder(void 0, [], {
+    members: cs.map((c) => asNestedConstraint(c, "union \u6210\u5458"))
+  });
 }
 function fn(params, returns, opts) {
   const normalized = {};
-  for (const [k, v2] of Object.entries(params)) normalized[k] = toPlainConstraint(v2);
+  for (const [k, v2] of Object.entries(params)) {
+    normalized[k] = asNestedConstraint(v2, `fn \u53C2\u6570 '${k}'`);
+  }
   return makeBuilder(void 0, [], {
     fn: {
       params: normalized,
-      ...returns !== void 0 ? { returns: toPlainConstraint(returns) } : {},
-      ...opts?.throws !== void 0 ? { throws: toPlainConstraint(opts.throws) } : {}
+      ...returns !== void 0 ? { returns: asNestedConstraint(returns, "fn \u8FD4\u56DE\u503C") } : {},
+      ...opts?.throws !== void 0 ? { throws: asNestedConstraint(opts.throws, "fn throws") } : {}
     }
   });
 }
@@ -31703,6 +31757,7 @@ __export(src_exports, {
   registerBClass: () => registerBClass,
   relationFingerprint: () => relationFingerprint,
   relationFn: () => relationFn,
+  requiredFnArity: () => requiredFnArity,
   resetAbsCallBudget: () => resetAbsCallBudget,
   resetCheckSourceMemo: () => resetCheckSourceMemo,
   resetFnFpCache: () => resetFnFpCache,
@@ -60630,10 +60685,6 @@ function absLit(v2) {
   if (v2 === null) return absNullLit();
   return absUndefLit();
 }
-function absUnion(members) {
-  if (members.length === 0) return absExact({ k: "never" });
-  return members.reduce((acc, m) => joinAbs(acc, m));
-}
 function tryParseConstraint(expr) {
   const s = expr.trim();
   if (!CONSTRAINT_EXPR_RE.test(s)) return void 0;
@@ -60662,15 +60713,15 @@ function flattenPreds(preds) {
 function constraintSelfEqLit(c, selfIds) {
   const leaves = flattenPreds(c.preds);
   const eqs = leaves.filter((p2) => p2.op === "eq");
-  if (eqs.length !== 1) return void 0;
+  if (eqs.length !== 1) return { found: false };
   const p = eqs[0];
-  if (p.op !== "eq") return void 0;
+  if (p.op !== "eq") return { found: false };
   const isSelf = (t) => t.op === "var" && typeof t.id === "string" && selfIds.includes(t.id);
   const a = p.a;
   const b = p.b;
-  if (isSelf(a) && b.op === "lit") return b.value;
-  if (isSelf(b) && a.op === "lit") return a.value;
-  return void 0;
+  if (isSelf(a) && b.op === "lit") return { found: true, value: b.value };
+  if (isSelf(b) && a.op === "lit") return { found: true, value: a.value };
+  return { found: false };
 }
 function constraintToCaseArgAbs(c) {
   if (c.members && c.members.length > 0) {
@@ -60679,10 +60730,32 @@ function constraintToCaseArgAbs(c) {
     return { shape: { k: "sum", members: parts }, conf: "path" };
   }
   const selfIds = [SELF, "__arg", "__nudo_self__"];
-  const lv = constraintSelfEqLit(c, selfIds);
-  if (typeof lv === "number" && !Number.isNaN(lv)) return numLit(lv);
-  if (typeof lv === "string") return strLit(lv);
-  if (typeof lv === "boolean") return boolLit(lv);
+  const litRes = constraintSelfEqLit(c, selfIds);
+  if (litRes.found) {
+    const lv = litRes.value;
+    if (typeof lv === "number" && !Number.isNaN(lv)) return numLit(lv);
+    if (typeof lv === "string") return strLit(lv);
+    if (typeof lv === "boolean") return boolLit(lv);
+    if (lv === null) return absNullLit();
+    return absUndefLit();
+  }
+  if (c.element) {
+    return absExact({ k: "arr", element: constraintToCaseArgAbs(c.element) });
+  }
+  if (c.fields) {
+    const slots = {};
+    for (const [key, field] of Object.entries(c.fields)) {
+      slots[key] = { value: constraintToCaseArgAbs(field.constraint) };
+    }
+    return absExact({ k: "obj", slots });
+  }
+  const bareScalar = !c.fields && !c.element && !c.members && !c.fn && c.int !== true && c.preds.length === 0;
+  if (bareScalar) {
+    if (c.prim === "number" || c.prim === "string" || c.prim === "boolean") {
+      return absExact({ k: "prim", type: c.prim });
+    }
+    if (!c.prim) return absUnknown2();
+  }
   return constraintToEntryAbs(c, "__arg");
 }
 function parseCaseArgExpr(expr) {
@@ -60694,49 +60767,16 @@ function parseCaseArgExpr(expr) {
       return absUnknown2();
     }
   }
-  return parseLegacyTypeExpr(expr);
+  return parseLiteralOrStructure(expr);
 }
-function parseLegacyTypeExpr(expr) {
+function parseLiteralOrStructure(expr) {
   const s = expr.trim();
-  if (s === "T.number") return num();
-  if (s === "T.string") return str();
-  if (s === "T.boolean") return bool();
-  if (s === "T.unknown") return absUnknown2();
-  if (s === "T.never") return absExact({ k: "never" });
-  if (s === "T.null") return absNullLit();
-  if (s === "T.undefined") return absUndefLit();
   if (s === "true") return absLit(true);
   if (s === "false") return absLit(false);
   if (s === "null") return absLit(null);
   if (s === "undefined") return absLit(void 0);
-  const literalMatch = s.match(/^T\.literal\((.+)\)$/);
-  if (literalMatch) {
-    return absLit(parsePrimitiveValue(literalMatch[1].trim()));
-  }
-  if (s.startsWith("T.union(") && s.endsWith(")")) {
-    const inner = s.slice("T.union(".length, -1);
-    const args = splitTopLevelArgs(inner);
-    return absUnion(args.map(parseLegacyTypeExpr));
-  }
-  if (s.startsWith("T.array(") && s.endsWith(")")) {
-    const inner = s.slice("T.array(".length, -1);
-    return absExact({ k: "arr", element: parseLegacyTypeExpr(inner) });
-  }
-  if (s.startsWith("T.tuple(") && s.endsWith(")")) {
-    const inner = s.slice("T.tuple(".length, -1).trim();
-    if (inner.startsWith("[") && inner.endsWith("]")) {
-      const elements = splitTopLevelArgs(inner.slice(1, -1));
-      return absExact({ k: "tuple", elements: elements.map(parseLegacyTypeExpr) });
-    }
-    return absExact({ k: "tuple", elements: [] });
-  }
-  if (s.startsWith("T.object(") && s.endsWith(")")) {
-    const inner = s.slice("T.object(".length, -1).trim();
-    if (inner.startsWith("{") && inner.endsWith("}")) {
-      return parseObjectLiteral(inner.slice(1, -1).trim());
-    }
-    return absExact({ k: "obj", slots: {} });
-  }
+  if (s === "unknown" || s === "any") return absUnknown2();
+  if (s === "never") return absExact({ k: "never" });
   if (findTopLevelArrow(s) !== -1 || /^function\s*[\w$]*\s*\(/.test(s)) {
     const fnExpr = parseArrowFunctionExpr(s);
     if (fnExpr) {
@@ -60754,7 +60794,7 @@ function parseLegacyTypeExpr(expr) {
     const content = s.slice(1, -1).trim();
     if (!content) return absExact({ k: "tuple", elements: [] });
     const elements = splitTopLevelArgs(content);
-    return absExact({ k: "tuple", elements: elements.map(parseLegacyTypeExpr) });
+    return absExact({ k: "tuple", elements: elements.map((e) => parseCaseArgExpr(e)) });
   }
   return absUnknown2();
 }
@@ -60767,21 +60807,10 @@ function parseObjectLiteral(content) {
     if (colonIdx === -1) continue;
     const key = entry.slice(0, colonIdx).trim().replace(/^["']|["']$/g, "");
     const val = entry.slice(colonIdx + 1).trim();
-    slots[key] = { value: parseLegacyTypeExpr(val) };
+    slots[key] = { value: parseCaseArgExpr(val) };
   }
   return absExact({ k: "obj", slots });
 }
-function parsePrimitiveValue(s) {
-  if (s === "true") return true;
-  if (s === "false") return false;
-  if (s === "null") return null;
-  if (s === "undefined") return void 0;
-  if (/^-?\d+(\.\d+)?$/.test(s)) return Number(s);
-  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
-    return s.slice(1, -1);
-  }
-  return s;
-}
 function splitTopLevelArgs(s) {
   const result = [];
   let depth = 0;
@@ -61194,7 +61223,7 @@ function findReplaceSeparator(raw) {
     }
     if (ch === " " && depth === 0) {
       const rest = raw.slice(i + 1).trimStart();
-      if (rest.startsWith("T.") || rest.startsWith("{") || rest.startsWith("[") || rest.startsWith('"') || rest.startsWith("'") || /^-?\d/.test(rest) || rest === "true" || rest === "false" || rest === "null" || rest === "undefined") {
+      if (CONSTRAINT_EXPR_RE.test(rest) || rest.startsWith("{") || rest.startsWith("[") || rest.startsWith('"') || rest.startsWith("'") || rest === "true" || rest === "false" || rest === "null" || rest === "undefined" || rest === "unknown" || rest === "any" || rest === "never" || /^-?\d+(\.\d+)?$/.test(rest) || rest.includes("=>") || /^function\s*[\w$]*\s*\(/.test(rest)) {
         return i;
       }
     }
@@ -61248,7 +61277,7 @@ var init_directives = __esm({
     PURE_REGEX = /@nudo:pure\b/g;
     SKIP_REGEX = /@nudo:skip(?:\s+(.+))?/g;
     SAMPLE_REGEX = /@nudo:sample\s+(\d+)/g;
-    CONSTRAINT_EXPR_RE = /^(number|string|boolean|array|shape|lit|union|fn|partial|pick|omit|record|required|readonly|nonNullable|and)\s*\(/;
+    CONSTRAINT_EXPR_RE = /^(number|string|boolean|any|array|shape|lit|union|fn|partial|pick|omit|record|required|readonly|nonNullable|and)\s*\(/;
     AS_REGEX = /^\s*@nudo:as\s+(.+)/;
     REPLACE_REGEX = /^\s*@nudo:replace\s+(.+)/;
     ENV_REGEX = /^\/\s*@nudo:env\s+(.+)/;
@@ -61461,6 +61490,19 @@ function envFn(paramTypes, returnType, apply, opts) {
   if (opts?.conf && opts.conf !== "exact") a.conf = opts.conf;
   return a;
 }
+function envFnVariadic(restType, returnType, opts) {
+  const required = opts?.required ?? [];
+  const restName = opts?.restName ?? "...rest";
+  const paramTypes = [...required, restType];
+  const params = [
+    ...required.map((_, i) => `x${i}`),
+    restName
+  ];
+  return envFn(paramTypes, returnType, opts?.apply, {
+    params,
+    ...opts?.name ? { name: opts.name } : {}
+  });
+}
 function slotsOf(entries) {
   const out = {};
   for (const [k, v2] of Object.entries(entries)) {
@@ -62235,6 +62277,106 @@ function defineEnv3() {
     chmodSync: envFn([prim.str(), prim.num()], undef2()),
     chownSync: envFn([prim.str(), prim.num(), prim.num()], undef2()),
     accessSync: envFn([prim.str(), prim.num()], undef2()),
+    // Callback-style async on `fs` / `node:fs` (Node actual API).
+    // Promise APIs live only under fs.promises / node:fs/promises.
+    readFile: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "options?", "callback"] }
+    ),
+    writeFile: envFn(
+      [prim.str(), unionOf(prim.str(), bufferBrand), prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "data", "callback"] }
+    ),
+    mkdir: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "options?", "callback"] }
+    ),
+    rm: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "options?", "callback"] }
+    ),
+    stat: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "options?", "callback"] }
+    ),
+    readdir: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "options?", "callback"] }
+    ),
+    access: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "mode?", "callback"] }
+    ),
+    appendFile: envFn(
+      [prim.str(), unionOf(prim.str(), bufferBrand), prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "data", "callback"] }
+    ),
+    unlink: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "options?", "callback"] }
+    ),
+    rename: envFn(
+      [prim.str(), prim.str(), prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["oldPath", "newPath", "callback"] }
+    ),
+    copyFile: envFn(
+      [prim.str(), prim.str(), prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["src", "dest", "callback"] }
+    ),
+    realpath: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "options?", "callback"] }
+    ),
+    readlink: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "options?", "callback"] }
+    ),
+    symlink: envFn(
+      [prim.str(), prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["target", "path", "type?", "callback"] }
+    ),
+    chmod: envFn(
+      [prim.str(), prim.num(), prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "mode", "callback"] }
+    ),
+    open: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "flags?", "callback"] }
+    )
+  };
+  const fsPromisesModule = {
     readFile: envFn(
       [prim.str(), prim.unknown],
       promiseOf(unionOf(prim.str(), bufferBrand))
@@ -62253,7 +62395,19 @@ function defineEnv3() {
       [prim.str(), prim.unknown],
       promiseOf(arrOf(prim.unknown))
     ),
-    access: envFn([prim.str(), prim.num()], promiseOf(undef2()))
+    access: envFn([prim.str(), prim.num()], promiseOf(undef2())),
+    appendFile: envFn(
+      [prim.str(), unionOf(prim.str(), bufferBrand)],
+      promiseOf(undef2())
+    ),
+    unlink: envFn([prim.str()], promiseOf(undef2())),
+    rename: envFn([prim.str(), prim.str()], promiseOf(undef2())),
+    copyFile: envFn([prim.str(), prim.str()], promiseOf(undef2())),
+    realpath: envFn([prim.str()], promiseOf(prim.str())),
+    readlink: envFn([prim.str()], promiseOf(prim.str())),
+    symlink: envFn([prim.str(), prim.str()], promiseOf(undef2())),
+    chmod: envFn([prim.str(), prim.num()], promiseOf(undef2())),
+    open: envFn([prim.str(), prim.str()], promiseOf(prim.unknown))
   };
   const strImpl1Abs = (fn2) => (args) => {
     const a = absStr2(args[0]);
@@ -62283,10 +62437,21 @@ function defineEnv3() {
     return p !== void 0 ? boolLit(nodePath.isAbsolute(p)) : void 0;
   };
   const pathModule = {
-    join: envFn([prim.str(), prim.str()], prim.str(), pathJoinAbs),
-    resolve: envFn([prim.str()], prim.str(), pathResolveAbs),
+    // Node variadic: declare min required arity + rest label (not n fixed slots).
+    join: envFnVariadic(prim.str(), prim.str(), {
+      apply: pathJoinAbs,
+      required: [prim.str()],
+      restName: "...paths"
+    }),
+    resolve: envFnVariadic(prim.str(), prim.str(), {
+      apply: pathResolveAbs,
+      restName: "...paths"
+    }),
     dirname: envFn([prim.str()], prim.str(), strImpl1Abs(nodePath.dirname)),
-    basename: envFn([prim.str(), prim.str()], prim.str(), pathBasenameAbs),
+    // ext is optional in Node — required arity 1; label+type render `ext?: string`.
+    basename: envFn([prim.str(), prim.str()], prim.str(), pathBasenameAbs, {
+      params: ["path", "ext?"]
+    }),
     extname: envFn([prim.str()], prim.str(), strImpl1Abs(nodePath.extname)),
     relative: envFn([prim.str(), prim.str()], prim.str(), pathRelativeAbs),
     normalize: envFn([prim.str()], prim.str(), strImpl1Abs(nodePath.normalize)),
@@ -62364,6 +62529,7 @@ function defineEnv3() {
     toJSON: envFn([], prim.str())
   });
   const urlModule = {
+    // base is optional in Node — required arity 1; label+type render `base?: string`.
     URL: envFn(
       [prim.str(), prim.str()],
       nodeUrlObj,
@@ -62391,7 +62557,8 @@ function defineEnv3() {
         } catch {
           return void 0;
         }
-      }
+      },
+      { params: ["href", "base?"] }
     ),
     URLSearchParams: envFn(
       [prim.unknown],
@@ -62489,15 +62656,27 @@ function defineEnv3() {
     fork: envFn([prim.str(), arrOf(prim.str()), prim.unknown], prim.unknown)
   };
   const utilModule = {
-    promisify: envFn([prim.unknown], prim.unknown),
+    // Signature-level: promisify preserves fn-ness only as unknown (no generic).
+    promisify: envFn([prim.unknown], prim.unknown, void 0, { name: "util.promisify" }),
     inspect: envFn([prim.unknown, prim.unknown], prim.str()),
-    format: envFn([prim.str()], prim.str()),
+    format: envFnVariadic(prim.unknown, prim.str(), {
+      // util.format() with zero args is valid in Node.
+      restName: "...args",
+      name: "util.format"
+    }),
+    callbackify: envFn([prim.unknown], prim.unknown),
+    deprecate: envFn([prim.unknown, prim.str()], prim.unknown),
+    inherits: envFn([prim.unknown, prim.unknown], undef2()),
+    isDeepStrictEqual: envFn([prim.unknown, prim.unknown], prim.bool()),
     types: objAbs({
       isDate: envFn([prim.unknown], prim.bool()),
       isRegExp: envFn([prim.unknown], prim.bool()),
       isPromise: envFn([prim.unknown], prim.bool()),
       isArrayBuffer: envFn([prim.unknown], prim.bool()),
-      isTypedArray: envFn([prim.unknown], prim.bool())
+      isTypedArray: envFn([prim.unknown], prim.bool()),
+      isNativeError: envFn([prim.unknown], prim.bool()),
+      isAsyncFunction: envFn([prim.unknown], prim.bool()),
+      isGeneratorFunction: envFn([prim.unknown], prim.bool())
     }),
     TextEncoder: envFn(
       [],
@@ -62508,6 +62687,79 @@ function defineEnv3() {
       objAbs({ decode: envFn([prim.unknown], prim.str()) })
     )
   };
+  const eventEmitterShape = objAbs({
+    on: envFn([prim.str(), prim.unknown], prim.unknown),
+    once: envFn([prim.str(), prim.unknown], prim.unknown),
+    off: envFn([prim.str(), prim.unknown], prim.unknown),
+    emit: envFn([prim.str()], prim.bool()),
+    addListener: envFn([prim.str(), prim.unknown], prim.unknown),
+    removeListener: envFn([prim.str(), prim.unknown], prim.unknown),
+    removeAllListeners: envFn([prim.str()], prim.unknown),
+    listeners: envFn([prim.str()], arrOf(prim.unknown)),
+    listenerCount: envFn([prim.str()], prim.num()),
+    eventNames: envFn([], arrOf(prim.str()))
+  });
+  const eventEmitterInstance = brandOf2("EventEmitter", eventEmitterShape);
+  const EventEmitterCtor = envFn([prim.unknown], eventEmitterInstance, void 0, {
+    params: ["options?"]
+  });
+  const eventsModule = {
+    EventEmitter: EventEmitterCtor,
+    once: envFn(
+      [prim.unknown, prim.str()],
+      promiseOf(arrOf(prim.unknown))
+    ),
+    on: envFn([prim.unknown, prim.str()], prim.unknown),
+    listenerCount: envFn([prim.unknown, prim.str()], prim.num())
+  };
+  const streamIoMethods = {
+    on: envFn([prim.str(), prim.unknown], prim.unknown),
+    once: envFn([prim.str(), prim.unknown], prim.unknown),
+    off: envFn([prim.str(), prim.unknown], prim.unknown),
+    emit: envFn([prim.str()], prim.bool()),
+    pipe: envFn([prim.unknown], prim.unknown),
+    destroy: envFn([prim.unknown], undef2()),
+    read: envFn([prim.num()], prim.unknown),
+    write: envFn([unionOf(prim.str(), bufferBrand)], prim.bool()),
+    end: envFn([prim.unknown], undef2()),
+    pause: envFn([], prim.unknown),
+    resume: envFn([], prim.unknown),
+    setEncoding: envFn([prim.str()], prim.unknown)
+  };
+  const streamCtor = (brandName) => envFn([prim.unknown], brandOf2(brandName, objAbs(streamIoMethods)), void 0, {
+    params: ["options?"]
+  });
+  const streamModule = {
+    Readable: streamCtor("Readable"),
+    Writable: streamCtor("Writable"),
+    Duplex: streamCtor("Duplex"),
+    Transform: streamCtor("Transform"),
+    pipeline: envFnVariadic(prim.unknown, promiseOf(undef2()), {
+      restName: "...streams"
+    }),
+    finished: envFn([prim.unknown], promiseOf(undef2()))
+  };
+  const parsedQueryString = brandOf2(
+    "ParsedQueryString",
+    objAbs({})
+  );
+  const querystringModule = {
+    // sep/eq/options optional — required arity 1; labels+types render `sep?: string` etc.
+    parse: envFn(
+      [prim.str(), prim.str(), prim.str(), prim.unknown],
+      parsedQueryString,
+      void 0,
+      { params: ["str", "sep?", "eq?", "options?"] }
+    ),
+    stringify: envFn(
+      [prim.unknown, prim.str(), prim.str(), prim.unknown],
+      prim.str(),
+      void 0,
+      { params: ["obj", "sep?", "eq?", "options?"] }
+    ),
+    escape: envFn([prim.str()], prim.str()),
+    unescape: envFn([prim.str()], prim.str())
+  };
   const nodeGlobals = {
     process: objAbs({
       env: objAbs({}),
@@ -62577,15 +62829,8 @@ function defineEnv3() {
   const modules = {
     fs: fsModule,
     "node:fs": fsModule,
-    "node:fs/promises": {
-      readFile: fsModule.readFile,
-      writeFile: fsModule.writeFile,
-      mkdir: fsModule.mkdir,
-      rm: fsModule.rm,
-      stat: fsModule.stat,
-      readdir: fsModule.readdir,
-      access: fsModule.access
-    },
+    "fs/promises": fsPromisesModule,
+    "node:fs/promises": fsPromisesModule,
     path: pathModule,
     "node:path": pathModule,
     os: osModule,
@@ -62597,7 +62842,13 @@ function defineEnv3() {
     child_process: childProcessModule,
     "node:child_process": childProcessModule,
     util: utilModule,
-    "node:util": utilModule
+    "node:util": utilModule,
+    events: eventsModule,
+    "node:events": eventsModule,
+    stream: streamModule,
+    "node:stream": streamModule,
+    querystring: querystringModule,
+    "node:querystring": querystringModule
   };
   return {
     globals: { ...esEnv.globals, ...nodeGlobals },
@@ -63541,7 +63792,7 @@ var require_util2 = __commonJS({
       return path;
     }
     exports.normalize = normalize;
-    function join9(aRoot, aPath) {
+    function join10(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -63573,7 +63824,7 @@ var require_util2 = __commonJS({
       }
       return joined;
     }
-    exports.join = join9;
+    exports.join = join10;
     exports.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -63746,7 +63997,7 @@ var require_util2 = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join9(urlGenerate(parsed), sourceURL);
+        sourceURL = join10(urlGenerate(parsed), sourceURL);
       }
       return normalize(sourceURL);
     }
@@ -74272,7 +74523,7 @@ ${lanes.join("\n")}
               return process.memoryUsage().heapUsed;
             },
             getFileSize(path) {
-              const stat = statSync9(path);
+              const stat = statSync10(path);
               if (stat == null ? void 0 : stat.isFile()) {
                 return stat.size;
               }
@@ -74316,7 +74567,7 @@ ${lanes.join("\n")}
             }
           };
           return nodeSystem;
-          function statSync9(path) {
+          function statSync10(path) {
             try {
               return _fs.statSync(path, statSyncOptions);
             } catch {
@@ -74375,7 +74626,7 @@ ${lanes.join("\n")}
               activeSession.post("Profiler.stop", (err, { profile }) => {
                 var _a;
                 if (!err) {
-                  if ((_a = statSync9(profilePath)) == null ? void 0 : _a.isDirectory()) {
+                  if ((_a = statSync10(profilePath)) == null ? void 0 : _a.isDirectory()) {
                     profilePath = _path.join(profilePath, `${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}+P${process.pid}.cpuprofile`);
                   }
                   try {
@@ -74495,7 +74746,7 @@ ${lanes.join("\n")}
                 let stat;
                 if (typeof dirent === "string" || dirent.isSymbolicLink()) {
                   const name = combinePaths(path, entry);
-                  stat = statSync9(name);
+                  stat = statSync10(name);
                   if (!stat) {
                     continue;
                   }
@@ -74519,7 +74770,7 @@ ${lanes.join("\n")}
             return matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
           }
           function fileSystemEntryExists(path, entryKind) {
-            const stat = statSync9(path);
+            const stat = statSync10(path);
             if (!stat) {
               return false;
             }
@@ -74561,7 +74812,7 @@ ${lanes.join("\n")}
           }
           function getModifiedTime3(path) {
             var _a;
-            return (_a = statSync9(path)) == null ? void 0 : _a.mtime;
+            return (_a = statSync10(path)) == null ? void 0 : _a.mtime;
           }
           function setModifiedTime(path, time) {
             try {
@@ -275245,7 +275496,7 @@ function absFnSig(paramTypes, returnType) {
     returnType
   });
 }
-function absUnion2(members) {
+function absUnion(members) {
   if (members.length === 0) return absNever();
   return members.reduce((acc, m) => joinAbs(acc, m));
 }
@@ -275560,7 +275811,7 @@ function materialize(ctx) {
           const ret = mapType(ctx, decl.type, 0);
           if (!isPlainUnknown(ret)) returns.push(ret);
         }
-        sig2.returnType = returns.length > 0 ? absUnion2(returns) : absUnknown3();
+        sig2.returnType = returns.length > 0 ? absUnion(returns) : absUnknown3();
       }
       rec[p.name] = value;
       continue;
@@ -275584,7 +275835,7 @@ function materialize(ctx) {
           if (ctor) {
             for (const param of ctor.parameters) {
               let type = param.type ? mapType(ctx, param.type, 0) : absUnknown3();
-              if (param.questionToken) type = absUnion2([type, absUndefLit2()]);
+              if (param.questionToken) type = absUnion([type, absUndefLit2()]);
               params.push(type);
             }
           }
@@ -275634,7 +275885,7 @@ function instanceFor(ctx, key) {
         const name = memberName(member);
         if (name === void 0) continue;
         let type = member.type ? mapType(ctx, member.type, 0) : absUnknown3();
-        if (member.questionToken) type = absUnion2([type, absUndefLit2()]);
+        if (member.questionToken) type = absUnion([type, absUndefLit2()]);
         properties[name] = type;
       } else if (import_typescript.default.isMethodSignature(member) || import_typescript.default.isMethodDeclaration(member)) {
         const name = memberName(member);
@@ -275662,7 +275913,7 @@ function signatureToFnSig(ctx, sig2) {
     } else {
       type = param.type ? mapType(ctx, param.type, 0) : absUnknown3();
     }
-    if (param.questionToken && !param.dotDotDotToken) type = absUnion2([type, absUndefLit2()]);
+    if (param.questionToken && !param.dotDotDotToken) type = absUnion([type, absUndefLit2()]);
     return type;
   });
   const returnType = sig2.type ? mapType(ctx, sig2.type, 0) : absUnknown3();
@@ -275675,7 +275926,7 @@ function mapTypeMembers(ctx, members, depth) {
       const name = memberName(member);
       if (name === void 0) continue;
       let type = member.type ? mapType(ctx, member.type, depth) : absUnknown3();
-      if (member.questionToken) type = absUnion2([type, absUndefLit2()]);
+      if (member.questionToken) type = absUnion([type, absUndefLit2()]);
       properties[name] = type;
     } else if (import_typescript.default.isMethodSignature(member)) {
       const name = memberName(member);
@@ -275717,7 +275968,7 @@ function mapType(ctx, node, depth) {
     return absUnknown3();
   }
   if (import_typescript.default.isUnionTypeNode(node)) {
-    return absUnion2(node.types.map((t) => mapType(ctx, t, depth)));
+    return absUnion(node.types.map((t) => mapType(ctx, t, depth)));
   }
   if (import_typescript.default.isIntersectionTypeNode(node)) {
     const members = node.types.map((t) => mapType(ctx, t, depth));
@@ -275751,7 +276002,7 @@ function mapType(ctx, node, depth) {
       const params = [];
       for (const param of ctor.parameters) {
         let type = param.type ? mapType(ctx, param.type, depth) : absUnknown3();
-        if (param.questionToken) type = absUnion2([type, absUndefLit2()]);
+        if (param.questionToken) type = absUnion([type, absUndefLit2()]);
         params.push(type);
       }
       return absFnSig(params, ctor.type ? mapType(ctx, ctor.type, depth) : absUnknown3());
@@ -276035,7 +276286,9 @@ function barePackageName(spec) {
   if (spec.startsWith("@")) {
     return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : void 0;
   }
-  return parts[0];
+  const name = parts[0];
+  if (NODE_BUILTINS.has(name)) return void 0;
+  return name;
 }
 function collectBarePackages(source) {
   try {
@@ -276086,13 +276339,56 @@ function autoHarvestModules(source, fromDir) {
   }
   return modules;
 }
-var harvestCache;
+var NODE_BUILTINS, harvestCache;
 var init_harvest_auto = __esm({
   "../service/src/harvest-auto.ts"() {
     "use strict";
     init_src2();
     init_static_imports();
     init_harvest_package();
+    NODE_BUILTINS = /* @__PURE__ */ new Set([
+      "assert",
+      "async_hooks",
+      "buffer",
+      "child_process",
+      "cluster",
+      "console",
+      "constants",
+      "crypto",
+      "dgram",
+      "diagnostics_channel",
+      "dns",
+      "domain",
+      "events",
+      "fs",
+      "http",
+      "http2",
+      "https",
+      "inspector",
+      "module",
+      "net",
+      "os",
+      "path",
+      "perf_hooks",
+      "process",
+      "punycode",
+      "querystring",
+      "readline",
+      "repl",
+      "stream",
+      "string_decoder",
+      "timers",
+      "tls",
+      "trace_events",
+      "tty",
+      "url",
+      "util",
+      "v8",
+      "vm",
+      "wasi",
+      "worker_threads",
+      "zlib"
+    ]);
     harvestCache = /* @__PURE__ */ new Map();
   }
 });
@@ -276826,6 +277122,49 @@ function collectEnvModules(envNames) {
   }
   return out;
 }
+function setEnvHarvestConflictCollector(collector2) {
+  const prev = envHarvestConflictCollector;
+  envHarvestConflictCollector = collector2;
+  return prev;
+}
+function getEnvHarvestConflictCollector() {
+  return envHarvestConflictCollector;
+}
+function mergeHarvestUnderEnv(harvestModules, envModules, opts) {
+  const out = {};
+  for (const [mod2, exports] of Object.entries(harvestModules)) {
+    const named = { ...exports.named };
+    out[mod2] = exports.default !== void 0 ? { named, default: exports.default } : { named };
+  }
+  const notify = opts?.onConflict ?? envHarvestConflictCollector;
+  for (const [mod2, envExports] of Object.entries(envModules)) {
+    const existing = out[mod2];
+    if (!existing) {
+      const named2 = { ...envExports.named };
+      out[mod2] = envExports.default !== void 0 ? { named: named2, default: envExports.default } : { named: named2 };
+      continue;
+    }
+    const overwritten = [];
+    for (const key of Object.keys(envExports.named)) {
+      if (existing.named[key] !== void 0) overwritten.push(key);
+    }
+    const defaultOverwritten = envExports.default !== void 0 && existing.default !== void 0;
+    if (notify && (overwritten.length > 0 || defaultOverwritten)) {
+      try {
+        notify({
+          module: mod2,
+          exports: overwritten,
+          defaultOverwritten
+        });
+      } catch {
+      }
+    }
+    const named = { ...existing.named, ...envExports.named };
+    const defaultAbs = envExports.default !== void 0 ? envExports.default : existing.default;
+    out[mod2] = defaultAbs !== void 0 ? { named, default: defaultAbs } : { named };
+  }
+  return out;
+}
 function collectBPathReplacements(source) {
   const targets = [];
   const values = {};
@@ -276938,7 +277277,7 @@ function tryRunBPath(source, filePath, opts = {}) {
     try {
       const { modules: graphMods, issues } = evalAbsModuleGraph(source, filePath);
       const envMods = collectEnvModules(opts.envNames ?? []);
-      const modules = { ...envMods, ...graphMods };
+      const modules = mergeHarvestUnderEnv(graphMods, envMods);
       const { targets, values, asTargets, asValues } = collectBPathReplacements(source);
       const envGlobals = {
         ...collectEnvGlobals(opts.envNames ?? []),
@@ -277013,7 +277352,7 @@ function tryBPathCall(source, filePath, fnName, args, opts = {}) {
   if (r.shape.k === "unknown" && !r.term) return void 0;
   return r;
 }
-var bRunByFile, MAX_B_RUN_CACHE;
+var envHarvestConflictCollector, bRunByFile, MAX_B_RUN_CACHE;
 var init_bpath_run = __esm({
   "../service/src/bpath-run.ts"() {
     "use strict";
@@ -277024,6 +277363,7 @@ var init_bpath_run = __esm({
     init_analysis_file_cache();
     init_fn_analysis_cache();
     init_load_module();
+    envHarvestConflictCollector = null;
     bRunByFile = /* @__PURE__ */ new Map();
     MAX_B_RUN_CACHE = 32;
   }
@@ -277345,7 +277685,8 @@ function validateMockDirectives(directives, diagnostics) {
   for (const d of directives) {
     if (d.kind !== "mock" || !d.expression) continue;
     const expr = d.expression.trim();
-    if (expr.includes("(") && expr.includes(")") && !expr.startsWith("T.")) {
+    const isTypeExpr = /^(number|string|boolean|any|array|shape|lit|union|fn|partial|pick|omit|record|required|readonly|nonNullable|and)\s*\(/.test(expr) || expr === "unknown" || expr === "any" || expr === "never" || expr === "true" || expr === "false" || expr === "null" || expr === "undefined" || /^-?\d+(\.\d+)?$/.test(expr) || (expr.startsWith('"') && expr.endsWith('"') || expr.startsWith("'") && expr.endsWith("'")) || expr.startsWith("{") || expr.startsWith("[");
+    if (expr.includes("(") && expr.includes(")") && !isTypeExpr && !expr.includes("=>")) {
       diagnostics.push({
         range: { start: { line: 0, column: 0 }, end: { line: 0, column: 0 } },
         severity: "warning",
@@ -277353,7 +277694,8 @@ function validateMockDirectives(directives, diagnostics) {
         code: "nudo:mock-invalid",
         suggestions: [
           "Supported formats: stub(), stub().returns(value), spy(), mock()",
-          "Arrow functions: (args) => expression or (args) => { statements; return value; }"
+          "Arrow functions: (args) => expression or (args) => { statements; return value; }",
+          "Type expressions: number(), string(), shape({...}), union(...), or concrete literals"
         ]
       });
     }
@@ -277879,6 +278221,24 @@ function analyzeFileUncached(filePath, source, activeCases, externalCallRecords,
     () => analyzeFileUncachedInner(filePath, source, activeCases, externalCallRecords, loadModule)
   );
 }
+function findModuleImportLoc(source, module) {
+  const bare = module.startsWith("node:") ? module.slice("node:".length) : module;
+  const alts = [.../* @__PURE__ */ new Set([module, bare, `node:${bare}`])];
+  const lines = source.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const alt of alts) {
+      const re = new RegExp(
+        `["'\`]${alt.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["'\`]`
+      );
+      const m = re.exec(line);
+      if (m && m.index !== void 0) {
+        return { line: i, column: m.index, length: m[0].length };
+      }
+    }
+  }
+  return null;
+}
 function analyzeFileUncachedInner(filePath, source, activeCases, externalCallRecords, loadModule) {
   const ast = parse(source);
   const functions = extractDirectives(ast);
@@ -277887,6 +278247,18 @@ function analyzeFileUncachedInner(filePath, source, activeCases, externalCallRec
   const nodeAbsMap = /* @__PURE__ */ new Map();
   const functionResults = [];
   const caseHints = [];
+  const envHarvestConflicts = [];
+  const prevHarvestConflictCollector = setEnvHarvestConflictCollector((c) => {
+    if (!envHarvestConflicts.some((x) => x.module === c.module)) {
+      envHarvestConflicts.push(c);
+    } else {
+      const prev = envHarvestConflicts.find((x) => x.module === c.module);
+      for (const e of c.exports) {
+        if (!prev.exports.includes(e)) prev.exports.push(e);
+      }
+      prev.defaultOverwritten ||= c.defaultOverwritten;
+    }
+  });
   const fileDirectives = extractFileDirectives(ast);
   const fileEnvNames = fileDirectives.filter((d) => d.kind === "env").flatMap((d) => d.envs);
   const projectConfig = findProjectConfig(dirname9(filePath));
@@ -277976,7 +278348,7 @@ function analyzeFileUncachedInner(filePath, source, activeCases, externalCallRec
         seedFns: seeds.seedFns,
         ...loadModule ? { loadModule } : {}
       });
-      absGraphModules = { ...collectEnvModules(envNames), ...g.modules };
+      absGraphModules = mergeHarvestUnderEnv(g.modules, collectEnvModules(envNames));
       pushBModuleIssues(g.issues);
     } catch {
     }
@@ -278299,7 +278671,7 @@ function analyzeFileUncachedInner(filePath, source, activeCases, externalCallRec
             diagnostics.push({
               range: { start: { line: directive.commentLine, column: 0 }, end: { line: directive.commentLine, column: 999 } },
               severity: "error",
-              message: `Case "${directive.name}": expected ${formatShape(directive.expected)}, got ${formatShape(caseAbs)}. The inferred return type does not match the expected type declared in the @nudo:case directive`,
+              message: `debug "${directive.name}": expected ${formatShape(directive.expected)}, got ${formatShape(caseAbs)}. The inferred return type does not match the expected type declared in the @nudo:case witness`,
               code: "nudo:case-expected"
             });
           }
@@ -278582,6 +278954,24 @@ function analyzeFileUncachedInner(filePath, source, activeCases, externalCallRec
     filePath,
     analysisConfig(projectConfig?.config).callSiteBudget
   );
+  setEnvHarvestConflictCollector(prevHarvestConflictCollector);
+  for (const c of envHarvestConflicts) {
+    const parts = [];
+    if (c.exports.length > 0) parts.push(`export(s) ${c.exports.join(", ")}`);
+    if (c.defaultOverwritten) parts.push("default");
+    const detail = parts.length > 0 ? ` \u2014 ${parts.join("; ")}` : "";
+    const loc = findModuleImportLoc(source, c.module);
+    const range = loc ? {
+      start: { line: loc.line, column: loc.column },
+      end: { line: loc.line, column: loc.column + loc.length }
+    } : { start: { line: 0, column: 0 }, end: { line: 0, column: 0 } };
+    diagnostics.push({
+      range,
+      severity: "warning",
+      message: `handwritten @nudo:env wins over harvest on module "${c.module}"${detail}; harvest only fills missing slots (B8). code=nudo:env-harvest-conflict`,
+      code: "nudo:env-harvest-conflict"
+    });
+  }
   return {
     functions: functionResults,
     diagnostics,
@@ -278694,7 +279084,7 @@ function collectAbsCallRecords(source, seeds, filePath, precomputedModules, envN
       }
     }
     if (envNames.length > 0) {
-      modules = { ...collectEnvModules(envNames), ...modules ?? {} };
+      modules = mergeHarvestUnderEnv(modules ?? {}, collectEnvModules(envNames));
     }
     try {
       importLocals = buildAbsImportLocalMap(source, filePath);
@@ -279897,18 +280287,93 @@ var init_dep_contents = __esm({
 });
 
 // ../service/src/harvest-node.ts
-import { existsSync as existsSync11 } from "fs";
-function harvestNodeTypes(fromDir, maxFiles = 12, maxMs = 2500) {
+import { existsSync as existsSync11, statSync as statSync8 } from "fs";
+import { join as join7 } from "path";
+function notFoundCacheKey(fromDir) {
+  return `not-found|@types/node|${fromDir ?? ""}`;
+}
+function nodeHarvestCacheKey(root, maxFiles, maxMs) {
+  let sig2 = "nostat";
+  try {
+    const st = statSync8(join7(root, "package.json"));
+    sig2 = `${st.size}:${Math.floor(st.mtimeMs)}`;
+  } catch {
+  }
+  return `${root}|${maxFiles}|${maxMs}|${sig2}`;
+}
+function clearNodeHarvestCache() {
+  nodeHarvestCache.clear();
+}
+function getNodeHarvestCacheSize() {
+  return nodeHarvestCache.size;
+}
+function isHarvestNodeDisabled(env = process.env) {
+  return env.NUDO_HARVEST_NODE === "off";
+}
+function harvestNodeTypes(fromDir, maxFiles = HARVEST_NODE_DEFAULT_MAX_FILES, maxMs = HARVEST_NODE_DEFAULT_MAX_MS) {
+  if (isHarvestNodeDisabled()) {
+    return {
+      ok: false,
+      error: "harvest disabled via NUDO_HARVEST_NODE=off",
+      reason: "disabled"
+    };
+  }
   const root = resolvePackageRoot("@types/node", fromDir) ?? resolvePackageRoot("node", fromDir);
   if (!root || !existsSync11(root)) {
-    return { ok: false, error: "@types/node not found" };
+    const missKey = notFoundCacheKey(fromDir);
+    const miss = nodeHarvestCache.get(missKey);
+    if (miss && !miss.ok && miss.reason === "not-found") {
+      return { ...miss, cached: true };
+    }
+    const result = {
+      ok: false,
+      error: "@types/node not found",
+      reason: "not-found"
+    };
+    nodeHarvestCache.set(missKey, result);
+    return result;
+  }
+  const key = nodeHarvestCacheKey(root, maxFiles, maxMs);
+  const hit = nodeHarvestCache.get(key);
+  if (hit) {
+    return hit.ok ? { ...hit, cached: true } : { ...hit, cached: true };
   }
   const dts = collectDtsFiles(root, maxFiles);
   if (dts.length === 0) {
-    return { ok: false, error: `no .d.ts under ${root}` };
+    const result = {
+      ok: false,
+      error: `no .d.ts under ${root}`,
+      reason: "no-dts"
+    };
+    nodeHarvestCache.set(key, result);
+    return result;
+  }
+  try {
+    const env = harvestDts(dts, { maxMs });
+    const stats = {
+      files: env.stats.files,
+      symbols: env.stats.symbols,
+      skipped: env.stats.skipped
+    };
+    const result = {
+      ok: true,
+      env,
+      root,
+      files: stats.files,
+      stats,
+      cached: false
+    };
+    nodeHarvestCache.set(key, result);
+    return result;
+  } catch (e) {
+    const result = {
+      ok: false,
+      error: `harvest failed: ${e.message}`,
+      reason: "failed"
+    };
+    nodeHarvestCache.set(key, result);
+    return result;
   }
-  const env = harvestDts(dts, { maxMs });
-  return { ok: true, env, root, files: env.stats.files };
 }
 function summarizeNodeEnv(env) {
   return {
@@ -279917,11 +280382,15 @@ function summarizeNodeEnv(env) {
     symbolCount: env.stats.symbols
   };
 }
+var HARVEST_NODE_DEFAULT_MAX_FILES, HARVEST_NODE_DEFAULT_MAX_MS, nodeHarvestCache;
 var init_harvest_node = __esm({
   "../service/src/harvest-node.ts"() {
     "use strict";
     init_src3();
     init_harvest_package();
+    HARVEST_NODE_DEFAULT_MAX_FILES = 12;
+    HARVEST_NODE_DEFAULT_MAX_MS = 2500;
+    nodeHarvestCache = /* @__PURE__ */ new Map();
   }
 });
 
@@ -280694,15 +281163,15 @@ function serializeCaseArg(a) {
   }
   switch (s.k) {
     case "prim":
-      if (s.type === "number" || s.type === "string" || s.type === "boolean") {
-        return `T.${s.type}`;
-      }
+      if (s.type === "number") return "number()";
+      if (s.type === "string") return "string()";
+      if (s.type === "boolean") return "boolean()";
       return null;
     case "unknown":
     case "any":
-      return "T.unknown";
+      return "any()";
     case "never":
-      return "T.never";
+      return "never";
     case "sum": {
       const parts = [];
       for (const member of s.members) {
@@ -280710,11 +281179,11 @@ function serializeCaseArg(a) {
         if (ser === null) return null;
         parts.push(ser);
       }
-      return `T.union(${parts.join(", ")})`;
+      return `union(${parts.join(", ")})`;
     }
     case "arr": {
       const el = serializeCaseArg(s.element);
-      return el === null ? null : `T.array(${el})`;
+      return el === null ? null : `array(${el})`;
     }
     case "tuple": {
       const parts = [];
@@ -281542,7 +282011,7 @@ var init_interface_emitter = __esm({
 
 // ../service/src/interface-draft.ts
 import { existsSync as existsSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync4, realpathSync as realpathSync2 } from "fs";
-import { basename as basename3, dirname as dirname15, isAbsolute as isAbsolute2, join as join7, relative as relative4 } from "path";
+import { basename as basename3, dirname as dirname15, isAbsolute as isAbsolute2, join as join8, relative as relative4 } from "path";
 function collectParamBodyAccesses(source) {
   const out = /* @__PURE__ */ new Map();
   let ast;
@@ -282059,7 +282528,7 @@ function safeRealpath(p) {
     return realpathSync2(p);
   } catch {
     try {
-      return join7(realpathSync2(dirname15(p)), basename3(p));
+      return join8(realpathSync2(dirname15(p)), basename3(p));
     } catch {
       return p;
     }
@@ -283068,6 +283537,8 @@ __export(src_exports2, {
   ANALYSIS_ABI: () => ANALYSIS_ABI,
   DEFAULT_ANALYSIS_MODE: () => DEFAULT_ANALYSIS_MODE,
   DiskCache: () => DiskCache,
+  HARVEST_NODE_DEFAULT_MAX_FILES: () => HARVEST_NODE_DEFAULT_MAX_FILES,
+  HARVEST_NODE_DEFAULT_MAX_MS: () => HARVEST_NODE_DEFAULT_MAX_MS,
   SEMANTIC_TOKEN_MODIFIERS: () => SEMANTIC_TOKEN_MODIFIERS,
   SEMANTIC_TOKEN_TYPES: () => SEMANTIC_TOKEN_TYPES,
   absToTSType: () => absToTSType,
@@ -283092,6 +283563,7 @@ __export(src_exports2, {
   clearEnvPathDeps: () => clearEnvPathDeps,
   clearFnAnalysisCache: () => clearFnAnalysisCache,
   clearHarvestCache: () => clearHarvestCache,
+  clearNodeHarvestCache: () => clearNodeHarvestCache,
   clearPathEnvCaches: () => clearPathEnvCaches,
   collectAbsBindingsFromGraph: () => collectAbsBindingsFromGraph,
   collectAbsInlays: () => collectAbsInlays,
@@ -283144,7 +283616,9 @@ __export(src_exports2, {
   getAnalysisSession: () => getAnalysisSession,
   getCasesForFile: () => getCasesForFile,
   getCompletionsAtPosition: () => getCompletionsAtPosition,
+  getEnvHarvestConflictCollector: () => getEnvHarvestConflictCollector,
   getHoverAtPosition: () => getHoverAtPosition,
+  getNodeHarvestCacheSize: () => getNodeHarvestCacheSize,
   getTypeAtPosition: () => getTypeAtPosition,
   getTypeAtPositionAsync: () => getTypeAtPositionAsync,
   harvestNodeTypes: () => harvestNodeTypes,
@@ -283160,12 +283634,14 @@ __export(src_exports2, {
   isBPathCapable: () => isBPathCapable,
   isDraftableEntry: () => isDraftableEntry,
   isEnvTemplatePath: () => isEnvTemplatePath,
+  isHarvestNodeDisabled: () => isHarvestNodeDisabled,
   isNudoTargetPath: () => isNudoTargetPath,
   isProjectConfigPath: () => isProjectConfigPath,
   isSidecarPath: () => isSidecarPath,
   isWatchRelevantPath: () => isWatchRelevantPath,
   lookupHarvested: () => lookupHarvested,
   matchesEmitAllowlist: () => matchesEmitAllowlist,
+  mergeHarvestUnderEnv: () => mergeHarvestUnderEnv,
   mockDirectivesToAbsSeeds: () => mockDirectivesToAbsSeeds,
   noteEnvPathDeps: () => noteEnvPathDeps,
   packageHarvestToAbsModules: () => packageHarvestToAbsModules,
@@ -283175,6 +283651,7 @@ __export(src_exports2, {
   serializeCaseArg: () => serializeCaseArg,
   serializeInferJson: () => serializeInferJson,
   setAnalysisSession: () => setAnalysisSession,
+  setEnvHarvestConflictCollector: () => setEnvHarvestConflictCollector,
   sha256Hex: () => sha256Hex,
   shouldAnalyzeFile: () => shouldAnalyzeFile,
   sidecarDraftPath: () => sidecarDraftPath,
@@ -283235,8 +283712,8 @@ var init_src4 = __esm({
 init_src();
 init_src4();
 init_src3();
-import { readFileSync as readFileSync15, existsSync as existsSync16, watch, readdirSync as readdirSync2, statSync as statSync8, writeFileSync as writeFileSync6, mkdirSync as mkdirSync3, realpathSync as realpathSync3 } from "fs";
-import { resolve as resolve12, dirname as dirname17, relative as relative6, join as join8, basename as basename5, isAbsolute as isAbsolute3 } from "path";
+import { readFileSync as readFileSync15, existsSync as existsSync16, watch, readdirSync as readdirSync2, statSync as statSync9, writeFileSync as writeFileSync6, mkdirSync as mkdirSync3, realpathSync as realpathSync3 } from "fs";
+import { resolve as resolve12, dirname as dirname17, relative as relative6, join as join9, basename as basename5, isAbsolute as isAbsolute3 } from "path";
 import { fileURLToPath } from "url";
 import { Command } from "commander";
 
@@ -283310,7 +283787,7 @@ function formatTestReport(r) {
 // src/index.ts
 var program = new Command();
 function readPackageVersion() {
-  const pkgPath = join8(dirname17(fileURLToPath(import.meta.url)), "..", "package.json");
+  const pkgPath = join9(dirname17(fileURLToPath(import.meta.url)), "..", "package.json");
   const pkg = JSON.parse(readFileSync15(pkgPath, "utf-8"));
   return pkg.version ?? "0.0.0";
 }
@@ -283330,7 +283807,7 @@ function collectExternalRecords(sites) {
       process.exitCode = 1;
       continue;
     }
-    const siteFiles = statSync8(sitePath).isDirectory() ? collectNudoFiles(sitePath) : [sitePath];
+    const siteFiles = statSync9(sitePath).isDirectory() ? collectNudoFiles(sitePath) : [sitePath];
     for (const sf of siteFiles) {
       records.push(...collectCallRecords(sf, readFileSync15(sf, "utf-8")));
     }
@@ -283352,7 +283829,7 @@ async function runInfer(file, options = {}) {
     }
   }
   if (result.functions.length === 0 && !result.externalFunctions?.length) {
-    console.log("No functions with @nudo:case directives found.");
+    console.log("No functions found to analyze.");
     return;
   }
   const dtsLines = [];
@@ -283376,7 +283853,8 @@ async function runInfer(file, options = {}) {
     }
     for (const c of fn2.cases) {
       const argsStr = c.argAbs.map(formatShape).join(", ");
-      let line = `Case "${c.name}": (${argsStr}) => ${formatShape(c.abs)}`;
+      const label = c.name.startsWith("call@") || c.name.startsWith("entry@") ? c.name : `debug "${c.name}"`;
+      let line = `${label}: (${argsStr}) => ${formatShape(c.abs)}`;
       if (c.throwsAbs.shape.k !== "never") line += ` throws ${formatShape(c.throwsAbs)}`;
       console.log(line);
       if (c.intension?.display) {
@@ -283397,7 +283875,7 @@ async function runInfer(file, options = {}) {
     }
     if (fn2.cases.length > 1 && fn2.combinedAbs) {
       console.log(`
-Combined: ${formatShape(fn2.combinedAbs)}`);
+Observed: ${formatShape(fn2.combinedAbs)}`);
     }
     console.log();
   }
@@ -283418,13 +283896,14 @@ Combined: ${formatShape(fn2.combinedAbs)}`);
 `);
         for (const c of fn2.cases) {
           const argsStr = c.argAbs.map(formatShape).join(", ");
-          let line = `Case "${c.name}": (${argsStr}) => ${formatShape(c.abs)}`;
+          const label = c.name.startsWith("call@") || c.name.startsWith("entry@") ? c.name : `debug "${c.name}"`;
+          let line = `${label}: (${argsStr}) => ${formatShape(c.abs)}`;
           if (c.throwsAbs.shape.k !== "never") line += ` throws ${formatShape(c.throwsAbs)}`;
           console.log(line);
         }
         if (fn2.cases.length > 1 && fn2.combinedAbs) {
           console.log(`
-Combined: ${formatShape(fn2.combinedAbs)}`);
+Observed: ${formatShape(fn2.combinedAbs)}`);
         }
         console.log();
       }
@@ -283480,7 +283959,7 @@ async function runInferJson(file, externalRecords) {
   const { serializeInferJson: serializeInferJson2 } = await Promise.resolve().then(() => (init_src4(), src_exports2));
   console.log(JSON.stringify(serializeInferJson2(result, filePath), null, 2));
 }
-program.command("infer").description("Infer types from a JS/TS file (or a directory of them) \u2014 functions with @nudo:case directives use them; all other functions are inferred from call sites (whole-program analysis)").argument("<file>", "Path to the JS/TS file (or directory)").option("--dts", "Generate .d.ts file").option("--loc", "Show source locations in output").option("--json", "Output as JSON").option("--callsites <paths...>", "Usage-site files (tests/apps) to harvest real call shapes from; their calls to this file's exports become synthesized cases").option("--emit-cases [mode]", "Write synthesized call-site cases back into the source as @nudo:case directives (call@ prefix); mode: update (default: add)").option("--dry-run", "With --emit-cases: print a unified diff instead of writing to disk").option("--exit-on-diff", "With --dry-run: exit with code 1 when the diff is non-empty").action(
+program.command("infer").description("Infer types from a JS/TS file (or a directory) by executing observed call sites; optional @nudo:case witnesses are for debug / nudo test only").argument("<file>", "Path to the JS/TS file (or directory)").option("--dts", "Generate .d.ts file").option("--loc", "Show source locations in output").option("--json", "Output as JSON").option("--callsites <paths...>", "Usage-site files (tests/apps) to harvest real call shapes from; their calls to this file's exports become synthesized cases").option("--emit-cases [mode]", "Debug solidification: write synthesized call-site witnesses back as @nudo:case directives (call@ prefix); not the interface product path. mode: update (default: add)").option("--dry-run", "With --emit-cases: print a unified diff instead of writing to disk").option("--exit-on-diff", "With --dry-run: exit with code 1 when the diff is non-empty").action(
   async (file, opts) => {
     let emit;
     if (opts.emitCases !== void 0) {
@@ -283509,7 +283988,7 @@ program.command("infer").description("Infer types from a JS/TS file (or a direct
       externalRecords = collectExternalRecords(opts.callsites);
     }
     const target = resolve12(file);
-    if (existsSync16(target) && statSync8(target).isDirectory()) {
+    if (existsSync16(target) && statSync9(target).isDirectory()) {
       const files = collectNudoFiles(target);
       if (files.length === 0) {
         console.log("No nudo files found in directory.");
@@ -283673,7 +284152,7 @@ function resolveTargets(path) {
     process.exitCode = 1;
     return [];
   }
-  if (statSync8(resolved).isDirectory()) {
+  if (statSync9(resolved).isDirectory()) {
     const files = collectNudoFiles(resolved);
     if (files.length === 0) {
       console.error(`No nudo files found in directory: ${resolved}`);
@@ -283793,7 +284272,7 @@ async function runInterfaceDraft(file, opts) {
       let dir = dirname17(filePath);
       const fsRoot = resolve12("/");
       while (dir !== fsRoot) {
-        if (existsSync16(join8(dir, "package.json"))) {
+        if (existsSync16(join9(dir, "package.json"))) {
           projectRoot = dir;
           break;
         }
@@ -284022,7 +284501,7 @@ program.command("interface").alias("refine").description(
     }
   }
 );
-program.command("test").description("Run @nudo:case directives as assertions (case-as-test); exit 1 on failure").argument("<file>", "Path to the JS/TS file or a directory of them").action(async (file) => {
+program.command("test").description("Run @nudo:case directives as debug assertions (case-as-test); exit 1 on failure").argument("<file>", "Path to the JS/TS file or a directory of them").action(async (file) => {
   const targets = resolveTargets(file);
   if (targets.length === 0) return;
   for (const filePath of targets) {
@@ -284115,7 +284594,7 @@ async function runDoctor(paths, opts) {
       reports.push({ file: displayPath(abs2), functions: 0, entryOnly: 0, uncovered: [], error: `File not found: ${abs2}` });
       continue;
     }
-    files.push(...statSync8(abs2).isDirectory() ? collectNudoFiles(abs2) : [abs2]);
+    files.push(...statSync9(abs2).isDirectory() ? collectNudoFiles(abs2) : [abs2]);
   }
   for (const filePath of files) {
     reports.push(await doctorFile(filePath, externalRecords));
@@ -284166,12 +284645,12 @@ async function runDoctor(paths, opts) {
       const entryInfo = r.entryOnly > 0 ? `, ${r.entryOnly} entry-only` : "";
       console.log(`  \xB7 ${r.functions} function(s)${entryInfo}`);
       if (r.uncovered.length > 0) {
-        console.log(`  \u26A0 uncovered (no cases): ${r.uncovered.join(", ")}`);
+        console.log(`  \u26A0 uncovered (no call-site evidence): ${r.uncovered.join(", ")}`);
       }
       if (r.drift) {
         const refresh = `nudo infer ${r.file} --callsites ${(opts.callsites ?? []).join(" ")} --emit-cases=update`;
         console.log(
-          `  \u2717 drift: ${r.drift.added + r.drift.removed} directive(s) changed (+${r.drift.added} new, -${r.drift.removed} removed) \u2014 refresh with: ${refresh.trim()}`
+          `  \u2717 drift: ${r.drift.added + r.drift.removed} debug witness directive(s) changed (+${r.drift.added} new, -${r.drift.removed} removed) \u2014 optional refresh: ${refresh.trim()}`
         );
       }
       if ((r.interfaceDrift ?? 0) > 0) {
@@ -284195,7 +284674,7 @@ program.command("doctor").description(
 });
 program.command("watch").description("Watch file(s) for changes and re-run inference").argument("<path>", "File or directory to watch").option("--dts", "Generate .d.ts files on each change").action((watchPath, opts) => {
   const resolved = resolve12(watchPath);
-  const isDir = existsSync16(resolved) && statSync8(resolved).isDirectory();
+  const isDir = existsSync16(resolved) && statSync9(resolved).isDirectory();
   const getFiles = () => {
     if (!isDir) return [resolved];
     return collectNudoFiles(resolved);
@@ -284278,7 +284757,7 @@ program.command("watch").description("Watch file(s) for changes and re-run infer
   const pendingChanged = /* @__PURE__ */ new Set();
   watch(watchTarget, { recursive: isDir }, (_event, filename) => {
     if (!filename) return;
-    const fullPath = isDir ? join8(watchTarget, filename) : resolved;
+    const fullPath = isDir ? join9(watchTarget, filename) : resolved;
     if (!isWatchRelevantPath(fullPath)) return;
     if (!existsSync16(fullPath)) {
       pendingChanged.add(fullPath);
@@ -284305,7 +284784,7 @@ program.command("watch").description("Watch file(s) for changes and re-run infer
 function collectNudoFiles(dir) {
   const results = [];
   for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-    const fullPath = join8(dir, entry.name);
+    const fullPath = join9(dir, entry.name);
     if (entry.isDirectory() && entry.name !== "node_modules") {
       results.push(...collectNudoFiles(fullPath));
     } else if (entry.isFile() && isNudoTargetPath(fullPath)) {
@@ -284318,18 +284797,16 @@ async function runGenerate(file, format, output) {
   const filePath = resolve12(file);
   const source = readFileSync15(filePath, "utf-8");
   const result = await analyzeFileAsync(filePath, source);
-  const functions = result.functions.filter(
-    (f) => f.cases.some((c) => c.source === "directive")
-  );
+  const functions = result.functions.filter((f) => f.cases.length > 0);
   if (functions.length === 0) {
-    console.log("No functions with @nudo:case directives found.");
+    console.log("No analyzed functions found.");
     return;
   }
   const zodChunks = [];
   const guardChunks = [];
   const dtsChunks = [];
   for (const fn2 of functions) {
-    const caseResults = fn2.cases.filter((c) => c.source === "directive");
+    const caseResults = fn2.cases;
     const baseName = fn2.name;
     if (format === "zod" || format === "all") {
       const lines = [`
@@ -284337,7 +284814,8 @@ async function runGenerate(file, format, output) {
       for (const c of caseResults) {
         const inputSchemas = c.argAbs.map((a, i) => `arg${i}: ${absToZodSchema(a)}`).join(", ");
         const outputSchema = absToZodSchema(c.abs);
-        lines.push(`// Case "${c.name}":`);
+        const label = c.name.startsWith("call@") || c.name.startsWith("entry@") ? c.name : `debug "${c.name}"`;
+        lines.push(`// ${label}:`);
         lines.push(`// Input: { ${inputSchemas} }`);
         lines.push(`// Output: ${outputSchema}`);
       }
@@ -284346,9 +284824,9 @@ async function runGenerate(file, format, output) {
     if (format === "guard" || format === "all") {
       const lines = [`
 // === ${baseName} Type Guards ===`];
-      for (const c of caseResults) {
-        const guardName = `is${baseName}${c.name.charAt(0).toUpperCase() + c.name.slice(1)}Output`;
-        lines.push(generateGuardFunctionFromAbs(guardName, c.abs));
+      const absForGuard = fn2.combinedAbs ?? caseResults[0]?.abs;
+      if (absForGuard) {
+        lines.push(generateGuardFunctionFromAbs(`is${baseName}Output`, absForGuard));
       }
       guardChunks.push(lines.join("\n"));
     }
@@ -284362,17 +284840,17 @@ async function runGenerate(file, format, output) {
     mkdirSync3(outDir, { recursive: true });
     const written = [];
     if (zodChunks.length > 0) {
-      const p = join8(outDir, `${stem}.nudo.zod.ts`);
+      const p = join9(outDir, `${stem}.nudo.zod.ts`);
       writeFileSync6(p, zodChunks.join("\n") + "\n", "utf-8");
       written.push(p);
     }
     if (guardChunks.length > 0) {
-      const p = join8(outDir, `${stem}.nudo.guard.ts`);
+      const p = join9(outDir, `${stem}.nudo.guard.ts`);
       writeFileSync6(p, guardChunks.join("\n") + "\n", "utf-8");
       written.push(p);
     }
     if (dtsChunks.length > 0) {
-      const p = join8(outDir, `${stem}.d.ts`);
+      const p = join9(outDir, `${stem}.d.ts`);
       writeFileSync6(p, dtsChunks.join("\n") + "\n", "utf-8");
       written.push(p);
     }
@@ -284409,8 +284887,8 @@ function runHarvest(pkg, outOpt) {
     process.exitCode = 1;
     return;
   }
-  let entry = join8(typesDir, "index.d.ts");
-  const pkgJsonPath = join8(typesDir, "package.json");
+  let entry = join9(typesDir, "index.d.ts");
+  const pkgJsonPath = join9(typesDir, "package.json");
   if (existsSync16(pkgJsonPath)) {
     try {
       const pkgJson = JSON.parse(readFileSync15(pkgJsonPath, "utf-8"));
@@ -284447,10 +284925,10 @@ Usage \u2014 add this directive at the top of your JS file:`);
   const hintPath = resolve12(process.cwd()) === outDir ? basename5(out) : out;
   console.log(`  /// @nudo:env ${hintPath}`);
 }
-program.command("harvest").description("Convert @types/<pkg> .d.ts declarations into a Nudo env file (TS source using T.* constructors)").argument("[pkg]", "Package name under @types (e.g. node)").option("--out <file>", "Output .ts env file (default: ./nudo-harvest-<pkg>.ts)").option("--auto [dir]", "Scan directory (default .) for bare imports and report auto-harvestable @types packages").action(async (pkg, opts) => {
+program.command("harvest").description("Convert @types/<pkg> .d.ts declarations into a Nudo env file (constraint builders, not T.*)").argument("[pkg]", "Package name under @types (e.g. node)").option("--out <file>", "Output .ts env file (default: ./nudo-harvest-<pkg>.ts)").option("--auto [dir]", "Scan directory (default .) for bare imports and report auto-harvestable @types packages").action(async (pkg, opts) => {
   if (opts.auto !== void 0) {
     const dir = resolve12(typeof opts.auto === "string" ? opts.auto : ".");
-    const files = existsSync16(dir) && statSync8(dir).isDirectory() ? collectNudoFiles(dir) : existsSync16(dir) ? [dir] : [];
+    const files = existsSync16(dir) && statSync9(dir).isDirectory() ? collectNudoFiles(dir) : existsSync16(dir) ? [dir] : [];
     if (files.length === 0) {
       console.error(`No inference targets under ${dir}`);
       process.exitCode = 1;