@nudojs/service 3.0.0 → 5.0.0-beta.0

package/dist/chunk-U7JYTRIB.js

@@ -0,0 +1,888 @@
+import {
+  BoundedLruMap
+} from "./chunk-PVJIMQRI.js";
+
+// src/static-imports.ts
+import { parse } from "@nudojs/parser";
+import { readFileSync, existsSync } from "fs";
+import { resolve, dirname, join } from "path";
+import { generalizeFromAst, foldStaticStringExpr } from "@nudojs/core";
+function resolveRelative(fromFile, spec) {
+  if (!spec.startsWith(".") && !spec.startsWith("/")) return void 0;
+  const base = resolve(dirname(fromFile), spec);
+  for (const cand of [
+    base,
+    base + ".js",
+    base + ".cjs",
+    base + ".mjs",
+    base + ".ts",
+    base + ".mts",
+    base + ".cts",
+    join(base, "index.js"),
+    join(base, "index.cjs"),
+    join(base, "index.mjs"),
+    join(base, "index.ts")
+  ]) {
+    if (existsSync(cand)) return cand;
+  }
+  return void 0;
+}
+function collectDependencySpecs(ast) {
+  const specs = [];
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "ImportDeclaration") {
+      specs.push(stmt.source.value);
+    }
+    if (stmt.type === "ExportNamedDeclaration" && stmt.source) {
+      specs.push(stmt.source.value);
+    }
+    if (stmt.type === "ExportAllDeclaration" && stmt.source) {
+      specs.push(stmt.source.value);
+    }
+    collectRequires(stmt, specs);
+  }
+  return specs;
+}
+function collectRequires(node, out) {
+  const visit = (n) => {
+    if (!n || typeof n !== "object") return;
+    const obj = n;
+    if (obj.type === "CallExpression" && obj.callee) {
+      const c = obj.callee;
+      let spec;
+      if (c.type === "Identifier" && c.name === "require") {
+        spec = foldStaticStringExpr(obj.arguments?.[0]);
+      } else if (c.type === "MemberExpression" && !c.computed && c.object?.type === "Identifier" && c.object.name === "require" && c.property?.type === "Identifier" && c.property.name === "resolve") {
+        spec = foldStaticStringExpr(obj.arguments?.[0]);
+      }
+      if (spec !== void 0) out.push(spec);
+    }
+    for (const key of Object.keys(obj)) {
+      if (key === "loc" || key === "start" || key === "end") continue;
+      const v = obj[key];
+      if (Array.isArray(v)) v.forEach(visit);
+      else if (v && typeof v === "object") visit(v);
+    }
+  };
+  visit(node);
+}
+function analyzeExportsFromSource(filePath, source) {
+  const file = parse(source);
+  const named = /* @__PURE__ */ new Map();
+  let defaultExport;
+  const poly = /* @__PURE__ */ new Map();
+  for (const stmt of file.program.body) {
+    let decl = stmt;
+    if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+      decl = stmt.declaration;
+    }
+    if (decl.type === "FunctionDeclaration" && decl.id) {
+      named.set(decl.id.name, decl.id.name);
+    }
+    if (decl.type === "VariableDeclaration") {
+      for (const d of decl.declarations) {
+        if (d.id.type === "Identifier") named.set(d.id.name, d.id.name);
+      }
+    }
+    if (decl.type === "ClassDeclaration" && decl.id) {
+      named.set(decl.id.name, decl.id.name);
+    }
+    if (stmt.type === "ExportDefaultDeclaration") {
+      const d = stmt.declaration;
+      if (d.type === "FunctionDeclaration" && d.id) defaultExport = d.id.name;
+      if (d.type === "Identifier") defaultExport = d.name;
+    }
+    collectCjsExports(stmt, named, (n) => {
+      defaultExport = n;
+    });
+  }
+  for (const name of named.values()) {
+    const g = generalizeFromAst(name, source);
+    if (g) poly.set(name, g);
+  }
+  if (defaultExport) {
+    const g = generalizeFromAst(defaultExport, source);
+    if (g) poly.set("default", g);
+  }
+  return { path: filePath, named, defaultExport, source, poly };
+}
+function collectCjsExports(stmt, named, setDefault) {
+  const visit = (n) => {
+    if (!n || typeof n !== "object") return;
+    const obj = n;
+    if (obj.type !== "AssignmentExpression") {
+      for (const key of Object.keys(obj)) {
+        if (key === "loc" || key === "start" || key === "end") continue;
+        const v = obj[key];
+        if (Array.isArray(v)) v.forEach(visit);
+        else if (v && typeof v === "object") visit(v);
+      }
+      return;
+    }
+    const left = obj.left;
+    const right = obj.right;
+    if (left?.type === "MemberExpression" && left.object?.type === "Identifier" && left.object.name === "exports" && left.property?.type === "Identifier" && left.property.name) {
+      named.set(left.property.name, left.property.name);
+    }
+    if (left?.type === "MemberExpression" && left.object?.type === "Identifier" && left.object.name === "module" && left.property?.type === "Identifier" && left.property.name === "exports") {
+      if (right?.type === "Identifier" && typeof right.name === "string") {
+        named.set(right.name, right.name);
+        setDefault(right.name);
+      }
+      if (right?.type === "ObjectExpression") {
+        const props = right.properties;
+        for (const p of props) {
+          if (p.type !== "ObjectProperty") continue;
+          const key = p.key;
+          const val = p.value;
+          const exportName = key?.type === "Identifier" ? key.name : key?.type === "StringLiteral" ? key.value : void 0;
+          if (exportName) named.set(exportName, exportName);
+          if (val?.type === "Identifier" && val.name && exportName) {
+          }
+        }
+      }
+    }
+  };
+  visit(stmt);
+}
+function collectStaticImports(entryFile, maxDepth = 8) {
+  const graph = /* @__PURE__ */ new Map();
+  const queue = [
+    { file: resolve(entryFile), depth: 0 }
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const { file, depth } = queue.shift();
+    if (seen.has(file) || depth > maxDepth) continue;
+    seen.add(file);
+    if (!existsSync(file)) continue;
+    const source = readFileSync(file, "utf8");
+    const mod = analyzeExportsFromSource(file, source);
+    graph.set(file, mod);
+    const ast = parse(source);
+    for (const spec of collectDependencySpecs(ast)) {
+      const resolved = resolveRelative(file, spec);
+      if (resolved) queue.push({ file: resolved, depth: depth + 1 });
+    }
+  }
+  return graph;
+}
+
+// src/harvest-package.ts
+import { existsSync as existsSync2, readdirSync, statSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2, resolve as resolve2, dirname as dirname2, basename } from "path";
+import { harvestDts } from "@nudojs/harvester";
+import { formatShape } from "@nudojs/core";
+function resolvePackageRoot(pkg, fromDir = process.cwd()) {
+  let dir = resolve2(fromDir);
+  const bare = pkg.replace(/^@/, "").replace(/\//g, "__");
+  for (let i = 0; i < 8; i++) {
+    const typesPath = join2(dir, "node_modules", "@types", bare);
+    if (existsSync2(typesPath)) return typesPath;
+    const pkgPath = join2(dir, "node_modules", pkg);
+    if (existsSync2(pkgPath)) return pkgPath;
+    const parent = resolve2(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "test", "tests", "docs", "doc", "examples", "__tests__"]);
+var MAX_DTS_BYTES = 15e5;
+function dtsPriority(p, root) {
+  const base = basename(p);
+  const rel = p.slice(root.length);
+  if (base === "index.d.ts") return 0;
+  if (base === "index.d.mts") return 1;
+  if (rel.includes("/types/") && base === "index.d.ts") return 2;
+  if (base.endsWith(".d.ts") && !base.includes(".")) return 3;
+  return 10;
+}
+function collectDtsFiles(root, maxFiles = 8) {
+  const out = [];
+  const walk = (dir) => {
+    if (out.length >= maxFiles * 3) return;
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (out.length >= maxFiles * 3) return;
+      if (SKIP_DIRS.has(name)) continue;
+      const p = join2(dir, name);
+      let st;
+      try {
+        st = statSync(p);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) walk(p);
+      else if (name.endsWith(".d.ts") && !name.endsWith(".d.ts.map")) {
+        if (st.size > MAX_DTS_BYTES) continue;
+        out.push(p);
+      }
+    }
+  };
+  walk(root);
+  out.sort((a, b) => dtsPriority(a, root) - dtsPriority(b, root) || a.length - b.length);
+  return out.slice(0, maxFiles);
+}
+function entryDtsFromPackageJson(root) {
+  const pj = join2(root, "package.json");
+  if (!existsSync2(pj)) return void 0;
+  try {
+    const raw = JSON.parse(readFileSync2(pj, "utf8"));
+    const entry = raw.types ?? raw.typings;
+    if (typeof entry === "string" && entry.endsWith(".d.ts")) {
+      const p = resolve2(root, entry);
+      if (existsSync2(p)) {
+        const st = statSync(p);
+        if (st.size <= MAX_DTS_BYTES) return p;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function collectDtsFromEntry(entry, maxFiles = 200) {
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [entry];
+  const REFERENCE_PATH_REGEX = /<reference\s+path=["']([^"']+)["']\s*\/>/g;
+  const RELATIVE_FROM_REGEX = /\bfrom\s+["'](\.[^"']+)["']/g;
+  while (queue.length > 0 && files.length < maxFiles) {
+    const current = queue.shift();
+    if (seen.has(current) || !existsSync2(current)) continue;
+    seen.add(current);
+    if (!current.endsWith(".d.ts")) continue;
+    files.push(current);
+    let text;
+    try {
+      text = readFileSync2(current, "utf-8");
+    } catch {
+      continue;
+    }
+    const dir = dirname2(current);
+    for (const match of text.matchAll(REFERENCE_PATH_REGEX)) {
+      queue.push(resolve2(dir, match[1]));
+    }
+    for (const match of text.matchAll(RELATIVE_FROM_REGEX)) {
+      const base = resolve2(dir, match[1]);
+      for (const candidate of [`${base}.d.ts`, join2(base, "index.d.ts")]) {
+        if (existsSync2(candidate)) {
+          queue.push(candidate);
+          break;
+        }
+      }
+    }
+  }
+  return files;
+}
+function harvestPackage(pkg, fromDir, maxFiles = 24) {
+  const root = resolvePackageRoot(pkg, fromDir);
+  if (!root) return { error: `package not found: ${pkg}` };
+  const entry = entryDtsFromPackageJson(root) ?? join2(root, "index.d.ts");
+  let dtsFiles = existsSync2(entry) ? collectDtsFromEntry(entry, maxFiles) : [];
+  if (dtsFiles.length === 0) {
+    const collected = collectDtsFiles(root, maxFiles);
+    dtsFiles = entry && existsSync2(entry) && !collected.includes(entry) ? [entry, ...collected.filter((f) => f !== entry)].slice(0, maxFiles) : collected;
+  }
+  if (dtsFiles.length === 0) {
+    return { error: `no .d.ts under ${root}` };
+  }
+  const env = harvestDts(dtsFiles);
+  return { pkg, root, dtsFiles, env };
+}
+function formatHarvestSummary(h) {
+  const lines = [];
+  lines.push(`${h.pkg}: ${h.dtsFiles.length} d.ts, ${h.env.stats.symbols} symbols`);
+  const mods = Object.keys(h.env.modules);
+  for (const m of mods.slice(0, 5)) {
+    const exports = h.env.modules[m];
+    const names = Object.keys(exports).slice(0, 12);
+    lines.push(`  module "${m}": ${names.join(", ")}${Object.keys(exports).length > 12 ? "\u2026" : ""}`);
+  }
+  if (mods.length > 5) lines.push(`  \u2026 ${mods.length - 5} more modules`);
+  return lines.join("\n");
+}
+function lookupHarvested(h, moduleName, exportName) {
+  const mod = h.env.modules[moduleName];
+  const a = mod?.[exportName] ?? h.env.globals[exportName];
+  if (!a) return void 0;
+  return formatShape(a);
+}
+
+// src/harvest-json.ts
+import { createHash } from "crypto";
+import {
+  abs,
+  confJoin,
+  relationFn,
+  getFnImpl
+} from "@nudojs/core";
+var HARVEST_DISK_ABI = "nudo-harvest-disk-v7";
+function sha256Hex(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+function absToHarvestSig(a) {
+  if (a.term?.op === "var") {
+    return { k: "tvar", name: a.term.id };
+  }
+  const s = a.shape;
+  switch (s.k) {
+    case "prim":
+      return { k: "prim", type: s.type };
+    case "unknown":
+      return { k: "unknown" };
+    case "any":
+      return { k: "any" };
+    case "never":
+      return { k: "never" };
+    case "arr":
+      return { k: "arr", element: absToHarvestSig(s.element) };
+    case "tuple":
+      return { k: "tuple", elements: s.elements.map(absToHarvestSig) };
+    case "obj": {
+      const slots = {};
+      for (const [key, slot] of Object.entries(s.slots)) {
+        slots[key] = {
+          v: absToHarvestSig(slot.value),
+          ...slot.optional ? { opt: true } : {}
+        };
+      }
+      return { k: "obj", slots };
+    }
+    case "fn": {
+      const rel = getFnImpl(a)?.relation;
+      const pts = rel?.paramTypes ?? s.paramTypes ?? s.params.map(() => ({ shape: { k: "unknown" }, conf: "mock" }));
+      const paramTypes = pts.map(absToHarvestSig);
+      const retSrc = rel?.returnType ?? s.returnType ?? { shape: { k: "unknown" }, conf: "mock" };
+      return {
+        k: "fn",
+        params: s.params,
+        paramTypes,
+        returns: absToHarvestSig(retSrc)
+      };
+    }
+    case "sum":
+      return { k: "sum", members: s.members.map(absToHarvestSig) };
+    case "eff":
+      return {
+        k: s.eff === "generator" ? "generator" : "promise",
+        value: absToHarvestSig(s.inner)
+      };
+    case "brand":
+      return { k: "brand", name: s.name, shape: absToHarvestSig(s.shape) };
+    default:
+      return { k: "unknown" };
+  }
+}
+function harvestSigToAbs(sig) {
+  const mark = (a) => {
+    a.conf = confJoin(a.conf, "mock");
+    return a;
+  };
+  switch (sig.k) {
+    case "prim":
+      return mark(
+        abs(
+          { k: "prim", type: sig.type },
+          void 0,
+          void 0,
+          "mock"
+        )
+      );
+    case "unknown":
+      return mark(abs({ k: "unknown" }, void 0, void 0, "mock"));
+    case "any":
+      return mark(abs({ k: "any" }, void 0, void 0, "mock"));
+    case "never":
+      return mark(abs({ k: "never" }, void 0, void 0, "mock"));
+    case "lit": {
+      const t = typeof sig.value === "number" ? "number" : typeof sig.value === "string" ? "string" : typeof sig.value === "boolean" ? "boolean" : typeof sig.value === "bigint" ? "bigint" : null;
+      if (sig.value === null || t === null) {
+        return mark(
+          abs({ k: "unknown" }, { op: "lit", value: sig.value }, void 0, "mock")
+        );
+      }
+      return mark(
+        abs(
+          { k: "prim", type: t },
+          { op: "lit", value: sig.value },
+          void 0,
+          "mock"
+        )
+      );
+    }
+    case "arr":
+      return mark(abs({ k: "arr", element: harvestSigToAbs(sig.element) }, void 0, void 0, "mock"));
+    case "tuple":
+      return mark(
+        abs({ k: "tuple", elements: sig.elements.map(harvestSigToAbs) }, void 0, void 0, "mock")
+      );
+    case "obj": {
+      const slots = {};
+      for (const [key, slot] of Object.entries(sig.slots)) {
+        slots[key] = {
+          value: harvestSigToAbs(slot.v),
+          ...slot.opt ? { optional: true } : {}
+        };
+      }
+      return mark(abs({ k: "obj", slots }, void 0, void 0, "mock"));
+    }
+    case "tvar":
+      return mark(abs({ k: "any" }, { op: "var", id: sig.name }, void 0, "mock"));
+    case "fn": {
+      const paramTypes = sig.paramTypes.map(harvestSigToAbs);
+      const returnType = harvestSigToAbs(sig.returns);
+      return mark(
+        relationFn(paramTypes, returnType, {
+          params: sig.params,
+          conf: "mock"
+        })
+      );
+    }
+    case "sum":
+      return mark(
+        abs({ k: "sum", members: sig.members.map(harvestSigToAbs) }, void 0, void 0, "mock")
+      );
+    case "promise":
+    case "generator":
+      return mark(
+        abs(
+          {
+            k: "eff",
+            eff: sig.k === "generator" ? "generator" : "promise",
+            inner: harvestSigToAbs(sig.value)
+          },
+          void 0,
+          void 0,
+          "mock"
+        )
+      );
+    case "brand":
+      return mark(
+        abs(
+          { k: "brand", name: sig.name, shape: harvestSigToAbs(sig.shape) },
+          void 0,
+          void 0,
+          "mock"
+        )
+      );
+    default:
+      return mark(abs({ k: "unknown" }, void 0, void 0, "mock"));
+  }
+}
+function serializeHarvestJson(pkg, env, meta) {
+  const modules = {};
+  for (const [mod, rec] of Object.entries(env.modules)) {
+    const named = {};
+    for (const [k, v] of Object.entries(rec)) named[k] = absToHarvestSig(v);
+    modules[mod] = named;
+  }
+  const globals = {};
+  for (const [k, v] of Object.entries(env.globals)) globals[k] = absToHarvestSig(v);
+  return {
+    v: 1,
+    pkg,
+    ...meta.pkgVersion ? { pkgVersion: meta.pkgVersion } : {},
+    knobs: { maxFiles: meta.maxFiles, abi: HARVEST_DISK_ABI },
+    dtsHash: meta.dtsHash,
+    modules,
+    globals,
+    stats: env.stats
+  };
+}
+function materializeHarvestJson(j) {
+  if (!j || typeof j !== "object") return null;
+  const h = j;
+  if (h.v !== 1) return null;
+  if (h.knobs?.abi !== HARVEST_DISK_ABI) return null;
+  if (!h.modules || typeof h.modules !== "object") return null;
+  try {
+    const modules = {};
+    for (const [mod, rec] of Object.entries(h.modules)) {
+      const named = {};
+      for (const [k, sig] of Object.entries(rec)) named[k] = harvestSigToAbs(sig);
+      modules[mod] = named;
+    }
+    const globals = {};
+    for (const [k, sig] of Object.entries(h.globals ?? {})) {
+      globals[k] = harvestSigToAbs(sig);
+    }
+    return {
+      globals,
+      modules,
+      stats: h.stats ?? { files: 0, symbols: 0, skipped: 0 }
+    };
+  } catch {
+    return null;
+  }
+}
+function harvestCacheKey(pkg, meta) {
+  const raw = [
+    HARVEST_DISK_ABI,
+    pkg,
+    meta.pkgVersion ?? "-",
+    String(meta.maxFiles),
+    meta.dtsHash
+  ].join("\0");
+  return sha256Hex(raw);
+}
+
+// src/harvest-disk.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join as join3, dirname as dirname3 } from "path";
+function depsCacheRoot() {
+  const env = process.env.NUDO_DEPS_CACHE_DIR;
+  if (env === "off" || env === "0") return void 0;
+  if (env && env.length > 0) return env;
+  try {
+    return join3(homedir(), ".cache", "nudo", "deps");
+  } catch {
+    return void 0;
+  }
+}
+function readPkgVersion(root) {
+  try {
+    const raw = JSON.parse(readFileSync3(join3(root, "package.json"), "utf8"));
+    return raw.version;
+  } catch {
+    return void 0;
+  }
+}
+function dtsClosureHash(files) {
+  const h = createHash2("sha256");
+  for (const f of [...files].sort()) {
+    h.update(f.replace(/\\/g, "/"));
+    try {
+      h.update(readFileSync3(f));
+    } catch {
+      h.update("miss");
+    }
+  }
+  return h.digest("hex");
+}
+function diskPath(root, key) {
+  return join3(root, key.slice(0, 2), `${key}.json`);
+}
+function readHarvestDisk(root, key) {
+  try {
+    const p = diskPath(root, key);
+    if (!existsSync3(p)) return void 0;
+    const parsed = JSON.parse(readFileSync3(p, "utf8"));
+    if (parsed?.abi !== HARVEST_DISK_ABI) return void 0;
+    return parsed.value;
+  } catch {
+    return void 0;
+  }
+}
+function writeHarvestDisk(root, key, value) {
+  try {
+    const p = diskPath(root, key);
+    mkdirSync(dirname3(p), { recursive: true });
+    writeFileSync(p, JSON.stringify({ abi: HARVEST_DISK_ABI, value }), "utf8");
+  } catch {
+  }
+}
+function listPackageDts(pkg, fromDir, maxFiles) {
+  const root = resolvePackageRoot(pkg, fromDir);
+  if (!root) return null;
+  const entry = (() => {
+    try {
+      const raw = JSON.parse(readFileSync3(join3(root, "package.json"), "utf8"));
+      const e = raw.types ?? raw.typings;
+      return typeof e === "string" && e.endsWith(".d.ts") ? join3(root, e) : void 0;
+    } catch {
+      return void 0;
+    }
+  })();
+  let dtsFiles = entry && existsSync3(entry) ? collectDtsFromEntry(entry, Math.max(maxFiles, 24)) : [];
+  if (dtsFiles.length === 0) {
+    const collected = collectDtsFiles(root, maxFiles);
+    dtsFiles = entry && existsSync3(entry) && !collected.includes(entry) ? [entry, ...collected.filter((f) => f !== entry)].slice(0, maxFiles) : collected;
+  }
+  if (dtsFiles.length === 0) return null;
+  return { root, dtsFiles, pkgVersion: readPkgVersion(root) };
+}
+function harvestPackageWithDisk(pkg, fromDir, maxFiles = 24) {
+  const cacheRoot = depsCacheRoot();
+  const listed = listPackageDts(pkg, fromDir, maxFiles);
+  if (!listed) return null;
+  const key = harvestCacheKey(pkg, {
+    dtsHash: dtsClosureHash(listed.dtsFiles),
+    maxFiles,
+    pkgVersion: listed.pkgVersion
+  });
+  if (cacheRoot) {
+    const hit = readHarvestDisk(cacheRoot, key);
+    if (hit) {
+      const env = materializeHarvestJson(hit);
+      if (env) {
+        return { pkg, root: listed.root, dtsFiles: listed.dtsFiles, env };
+      }
+    }
+  }
+  let h = null;
+  try {
+    const raw = harvestPackage(pkg, fromDir, maxFiles);
+    if (!("error" in raw)) h = raw;
+  } catch {
+    h = null;
+  }
+  if (!h) return null;
+  if (cacheRoot) {
+    writeHarvestDisk(
+      cacheRoot,
+      key,
+      serializeHarvestJson(pkg, h.env, {
+        dtsHash: dtsClosureHash(h.dtsFiles),
+        maxFiles,
+        pkgVersion: listed.pkgVersion
+      })
+    );
+  }
+  return h;
+}
+function loadHarvestEnvFromDisk(pkg, meta) {
+  const root = depsCacheRoot();
+  if (!root) return null;
+  const key = harvestCacheKey(pkg, meta);
+  const hit = readHarvestDisk(root, key);
+  return hit ? materializeHarvestJson(hit) : null;
+}
+
+// src/harvest-auto.ts
+import { parse as parse2 } from "@nudojs/parser";
+var 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"
+]);
+function barePackageName(spec) {
+  if (!spec) return void 0;
+  if (spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("node:")) return void 0;
+  const parts = spec.split("/");
+  if (spec.startsWith("@")) {
+    return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : void 0;
+  }
+  const name = parts[0];
+  if (NODE_BUILTINS.has(name)) return void 0;
+  return name;
+}
+function collectBarePackages(source) {
+  try {
+    const ast = parse2(source);
+    const names = /* @__PURE__ */ new Set();
+    for (const spec of collectDependencySpecs(ast)) {
+      const pkg = barePackageName(spec);
+      if (pkg) names.add(pkg);
+    }
+    return [...names];
+  } catch {
+    return [];
+  }
+}
+var HARVEST_CACHE_MAX = 128;
+var harvestCache = new BoundedLruMap(HARVEST_CACHE_MAX);
+function getHarvestCacheSize() {
+  return harvestCache.size;
+}
+function harvestPackageCached(pkg, fromDir) {
+  const key = `${fromDir}::${pkg}`;
+  if (harvestCache.has(key)) return harvestCache.get(key);
+  let result = null;
+  try {
+    result = harvestPackageWithDisk(pkg, fromDir);
+  } catch {
+    result = null;
+  }
+  harvestCache.set(key, result);
+  return result;
+}
+function clearHarvestCache() {
+  harvestCache.clear();
+}
+function autoHarvestModules(source, fromDir) {
+  const packages = collectBarePackages(source);
+  if (packages.length === 0) return {};
+  const modules = {};
+  for (const pkg of packages) {
+    const h = harvestPackageCached(pkg, fromDir);
+    if (!h) continue;
+    for (const [mod, exports] of Object.entries(h.env.modules)) {
+      modules[mod] = exports;
+      if (!modules[pkg]) modules[pkg] = exports;
+      const base = mod.replace(/^@types\//, "").replace(/\\/g, "/");
+      if (base && !modules[base]) modules[base] = exports;
+    }
+    for (const [k, v] of Object.entries(h.env.globals)) {
+      if (!modules[pkg]) modules[pkg] = {};
+      if (modules[pkg][k] === void 0) modules[pkg][k] = v;
+    }
+  }
+  return modules;
+}
+
+// src/harvest-to-abs.ts
+import {
+  confJoin as confJoin2,
+  absFunction,
+  getFnImpl as getFnImpl2,
+  instantiateReturn
+} from "@nudojs/core";
+import { dirname as dirname4 } from "path";
+function markMockConf(a) {
+  a.conf = confJoin2(a.conf, "mock");
+  return a;
+}
+function harvestedValueToAbs(a) {
+  if (a.shape.k === "fn") {
+    const ret = a.shape.returnType ?? { shape: { k: "unknown" }, conf: "mock" };
+    const relation = getFnImpl2(a)?.relation;
+    const params = a.shape.params.length > 0 ? a.shape.params : a.shape.paramTypes?.map((_, i) => `_arg${i}`) ?? ["...args"];
+    const dummyBody = {
+      type: "BlockStatement",
+      body: [],
+      directives: []
+    };
+    return markMockConf(
+      absFunction(params, {
+        body: dummyBody,
+        apply: (args) => {
+          if (relation) {
+            return markMockConf(instantiateReturn(a, args));
+          }
+          return markMockConf({ ...ret });
+        },
+        ...relation ? { relation } : {}
+      })
+    );
+  }
+  return markMockConf({ ...a });
+}
+function harvestToAbsModules(pkg, fromDir) {
+  const h = harvestPackageCached(pkg, fromDir);
+  if (!h) return {};
+  return packageHarvestToAbsModules(pkg, h);
+}
+function packageHarvestToAbsModules(pkg, h) {
+  const out = {};
+  const convertRecord = (rec) => {
+    const named = {};
+    for (const [k, v] of Object.entries(rec)) {
+      named[k] = harvestedValueToAbs(v);
+    }
+    return named;
+  };
+  const register = (key, exports) => {
+    if (!out[key]) out[key] = exports;
+  };
+  for (const [mod, rec] of Object.entries(h.env.modules)) {
+    const named = convertRecord(rec);
+    const exports = { named };
+    const def = rec["default"];
+    if (def) exports.default = harvestedValueToAbs(def);
+    register(mod, exports);
+    register(pkg, exports);
+    const stripped = mod.replace(/^@types\//, "").replace(/\\/g, "/");
+    if (stripped) register(stripped, exports);
+    const base = stripped.split("/").filter(Boolean).pop();
+    if (base && base !== pkg) register(base, exports);
+  }
+  const globalNamed = convertRecord(h.env.globals);
+  if (Object.keys(globalNamed).length > 0) {
+    const existing = out[pkg];
+    if (existing) {
+      out[pkg] = { named: { ...globalNamed, ...existing.named }, default: existing.default };
+    } else {
+      out[pkg] = { named: globalNamed };
+    }
+  }
+  return out;
+}
+function bareSpecToAbsModules(spec, fromFile) {
+  if (!spec || spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("node:")) {
+    return void 0;
+  }
+  const parts = spec.split("/");
+  const pkg = spec.startsWith("@") ? parts.length >= 2 ? `${parts[0]}/${parts[1]}` : void 0 : parts[0];
+  if (!pkg) return void 0;
+  const table = harvestToAbsModules(pkg, dirname4(fromFile));
+  return table[spec] ?? table[pkg];
+}
+
+export {
+  collectDependencySpecs,
+  analyzeExportsFromSource,
+  collectStaticImports,
+  resolvePackageRoot,
+  collectDtsFiles,
+  collectDtsFromEntry,
+  harvestPackage,
+  formatHarvestSummary,
+  lookupHarvested,
+  absToHarvestSig,
+  harvestSigToAbs,
+  serializeHarvestJson,
+  materializeHarvestJson,
+  harvestCacheKey,
+  depsCacheRoot,
+  dtsClosureHash,
+  readHarvestDisk,
+  writeHarvestDisk,
+  harvestPackageWithDisk,
+  loadHarvestEnvFromDisk,
+  barePackageName,
+  collectBarePackages,
+  getHarvestCacheSize,
+  harvestPackageCached,
+  clearHarvestCache,
+  autoHarvestModules,
+  harvestedValueToAbs,
+  harvestToAbsModules,
+  packageHarvestToAbsModules,
+  bareSpecToAbsModules
+};