@nudojs/cli 0.3.0 → 0.4.0

package/src/builtins/builtin-static.ts

@@ -1,260 +0,0 @@
-/**
- * 内置静态命名空间与直接全局值（process/Math/JSON/Object statics/Number
- * 常量…）及其实现辅助（JSON 字面量解码、属性描述符、结构 instanceof 判定、
- * fromCharCode 实参收割）。
- */
-
-import { T, simplifyUnion, type TypeValue } from "@nudojs/core";
-import { protoOfValue } from "./builtin-prototype.ts";
-import { PROMISE_STATIC_METHODS } from "./builtin-promise.ts";
-import { SYMBOL_STATIC_METHODS, SYMBOL_STATIC_PROPS } from "./builtin-symbol.ts";
-import { REFLECT_METHODS } from "./builtin-reflect.ts";
-import { INTL_DATETIMEFORMAT_METHODS, INTL_NUMBERFORMAT_METHODS } from "./builtin-intl.ts";
-
-// hasOwnProp 守卫：普通 Record 表查找会从原型链泄漏原生函数（与
-// builtin-prototype.ts / evaluator 内同名 helper 同语义）。
-function hasOwnProp(props: Record<string, unknown>, name: string): boolean {
-  return Object.prototype.hasOwnProperty.call(props, name);
-}
-
-// Built-in JavaScript API type mappings
-// Namespace objects (e.g. Math.floor) and direct global values (e.g. parseInt)
-const BUILTIN_STATIC_METHODS: Record<string, Record<string, TypeValue> | TypeValue> = {
-  // Node CJS 库普遍依赖的 process 全局——缺它时 process.nextTick(cb) 走
-  // 未知全局 → undefined → no-method 假错（hoek wait 的 usage-site 执行）
-  process: {
-    nextTick: T.fn(["callback", "...args"], { type: "BlockStatement", body: [], directives: [] } as any, undefined as any),
-    env: T.object({}),
-    platform: T.string,
-    versions: T.object({}),
-    argv: T.array(T.string),
-    cwd: T.fn([], { type: "BlockStatement", body: [], directives: [] } as any, undefined as any),
-    exit: T.fn(["code"], { type: "BlockStatement", body: [], directives: [] } as any, undefined as any),
-    hrtime: T.fn(["time"], { type: "BlockStatement", body: [], directives: [] } as any, undefined as any),
-    stdout: T.instanceOf("Socket"),
-    stderr: T.instanceOf("Socket"),
-  },
-  Date: {
-    now: T.number,
-    parse: T.number,
-    UTC: T.number,
-  },
-  Math: {
-    random: T.number,
-    floor: T.fn(["x"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    ceil: T.fn(["x"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    round: T.fn(["x"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    abs: T.fn(["x"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    max: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    min: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    sqrt: T.fn(["x"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    pow: T.fn(["base", "exp"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    // Math 常量与 @nudo:env es 的 Math 定义对齐（env 绑定优先）；无 env
-    // 指令时也在此解析，避免 Math.PI 走 unknown-property。
-    PI: T.number,
-    E: T.number,
-    LN2: T.number,
-    LN10: T.number,
-    LOG2E: T.number,
-    LOG10E: T.number,
-    SQRT2: T.number,
-    SQRT1_2: T.number,
-  },
-  JSON: {
-    // JSON.parse(literal-string): evaluate with the real JSON.parse and
-    // re-encode through jsonToTypeValue, so fixture-style calls
-    // (`JSON.parse('{"a":1}')`) keep literal-level precision instead of
-    // poisoning downstream clone/deepEqual args with unknown. Degrades to
-    // the unknown fallback when the argument is not a literal string or
-    // the text is not valid JSON. A reviver argument also degrades: it can
-    // replace every value (and the root) with an arbitrary one, so the
-    // parse structure is not a sound answer (hoek/json-ext never pass one).
-    parse: T.fnSig([T.string], T.unknown, T.never, (args) => {
-      const text = args[0];
-      if (text?.kind !== "literal" || typeof text.value !== "string") return undefined;
-      const reviver = args[1];
-      if (reviver && !(reviver.kind === "literal" && reviver.value === undefined)) return undefined;
-      try {
-        return jsonToTypeValue(JSON.parse(text.value));
-      } catch {
-        return undefined;
-      }
-    }),
-    stringify: T.string,
-  },
-  Object: {
-    keys: T.array(T.string),
-    values: T.array(T.unknown),
-    entries: T.array(T.tuple([T.string, T.unknown])),
-    assign: T.fnSig([T.unknown], T.unknown, T.never, (args) => {
-      // Object.assign(target, ...sources): later sources overwrite; a
-      // symbolic source keeps the symbolic unknown fallback.
-      const target = args[0];
-      if (target?.kind !== "object") return undefined;
-      const props: Record<string, TypeValue> = { ...target.properties };
-      for (const src of args.slice(1)) {
-        if (src?.kind !== "object") return undefined;
-        Object.assign(props, src.properties);
-      }
-      return T.object(props);
-    }),
-    // Prototype-reflection statics. getPrototypeOf maps receivers onto the
-    // cached prototype singletons so `getPrototypeOf(x) !== getPrototypeOf(y)`
-    // resolves literally; create/setPrototypeOf cover the clone-style
-    // prototype dance; getOwnPropertyDescriptor feeds descriptor.get/set
-    // branches with the property's value type.
-    getPrototypeOf: T.fnSig([T.unknown], T.unknown, T.never, (args) => protoOfValue(args[0])),
-    create: T.fnSig([T.unknown], T.object({}), T.never, () => T.object({})),
-    setPrototypeOf: T.fnSig([T.unknown, T.unknown], T.unknown, T.never, (args) => args[0]),
-    defineProperty: T.fnSig([T.unknown, T.unknown, T.unknown], T.unknown, T.never, (args) => args[0]),
-    getOwnPropertyDescriptor: T.fnSig([T.unknown, T.unknown], T.union(T.object({}), T.undefined), T.never, (args) => {
-      const obj = args[0];
-      const key = args[1];
-      if (obj?.kind !== "object" && obj?.kind !== "instance") return T.undefined;
-      if (!key) return T.undefined;
-      if (key.kind === "literal" && typeof key.value === "string") {
-        const prop = hasOwnProp(obj.properties, key.value) ? obj.properties[key.value] : undefined;
-        if (!prop) return T.undefined;
-        return descriptorOf(prop);
-      }
-      if (key.kind === "primitive" && key.type === "string") {
-        const props = Object.keys(obj.properties);
-        if (props.length === 0) return T.undefined;
-        return descriptorOf(simplifyUnion(props.map((k) => obj.properties[k])));
-      }
-      return T.undefined;
-    }),
-  },
-  Buffer: {
-    from: T.fnSig([T.unknown], T.instanceOf("Buffer")),
-    alloc: T.fnSig([T.number], T.instanceOf("Buffer")),
-    concat: T.fnSig([T.unknown], T.instanceOf("Buffer")),
-    byteLength: T.fnSig([T.unknown], T.number),
-    isEncoding: T.fnSig([T.unknown], T.boolean),
-    isBuffer: T.fnSig([T.unknown], T.boolean, T.never, (args) => {
-      const lit = builtinInstanceTest(args[0], "Buffer");
-      return lit === undefined ? undefined : T.literal(lit);
-    }),
-  },
-  Array: {
-    isArray: T.boolean,
-    from: T.array(T.unknown),
-  },
-  Number: {
-    isNaN: T.boolean,
-    isFinite: T.boolean,
-    parseInt: T.number,
-    parseFloat: T.number,
-    // Number 常量与 @nudo:env es 的 Number 定义对齐（env 绑定优先）；
-    // 均为 number（case 序列化器对非有限数返回 null，不产出字面量值）。
-    MAX_SAFE_INTEGER: T.number,
-    MIN_SAFE_INTEGER: T.number,
-    MAX_VALUE: T.number,
-    MIN_VALUE: T.number,
-    POSITIVE_INFINITY: T.number,
-    NEGATIVE_INFINITY: T.number,
-    NaN: T.number,
-    EPSILON: T.number,
-  },
-  String: {
-    // fromCharCode/fromCodePoint over all-number-literal args evaluate
-    // with the real String static (hoek's escaper builds its 0x2028
-    // separator literal this way before handing it to escapeJson); any
-    // non-literal arg keeps only the string return type (the result is
-    // always a string, just not a knowable one). fromCodePoint also
-    // falls back on out-of-range literals (real RangeError → string).
-    fromCharCode: T.fnSig([T.number], T.string, T.never, (args) => {
-      const codes = literalCodeUnits(args);
-      return codes === null ? T.string : T.literal(String.fromCharCode(...codes));
-    }),
-    fromCodePoint: T.fnSig([T.number], T.string, T.never, (args) => {
-      const codes = literalCodeUnits(args);
-      if (codes === null) return T.string;
-      try {
-        return T.literal(String.fromCodePoint(...codes));
-      } catch {
-        return undefined;
-      }
-    }),
-  },
-  Promise: PROMISE_STATIC_METHODS,
-  Symbol: { ...SYMBOL_STATIC_METHODS, ...SYMBOL_STATIC_PROPS },
-  Reflect: REFLECT_METHODS as unknown as Record<string, TypeValue>,
-  Intl: {
-    DateTimeFormat: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    NumberFormat: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-  },
-  parseInt: T.number,
-  parseFloat: T.number,
-  isNaN: T.boolean,
-  isFinite: T.boolean,
-  // 全局数值常量：与 @nudo:env es 的 globals 对齐（env 绑定优先）。无 env
-  // 指令时在此解析为 number——否则 Infinity/NaN 命中大写开头的未知全局
-  // 检测，触发 nudo:unknown-global 与 nudo:builtin-unknown 诊断。
-  Infinity: T.number,
-  NaN: T.number,
-};
-/** Harvest String.fromCharCode/fromCodePoint arguments: a list of number
- * literals ready for real evaluation, or null when any argument is
- * non-literal (symbolic → the caller keeps its plain string fallback).
- * An empty argument list yields [] (both statics return ""). */
-function literalCodeUnits(args: TypeValue[]): number[] | null {
-  const codes: number[] = [];
-  for (const a of args) {
-    if (a?.kind !== "literal" || typeof a.value !== "number") return null;
-    codes.push(a.value);
-  }
-  return codes;
-}
-function descriptorOf(prop: TypeValue): TypeValue {
-  return T.object({
-    value: prop,
-    writable: T.boolean,
-    enumerable: T.boolean,
-    configurable: T.boolean,
-  });
-}
-// `x instanceof C` / `Buffer.isBuffer(x)` / `Array.isArray(x)` literal
-// answer for structurally-known receivers; undefined keeps the symbolic
-// fallback (boolean).
-function builtinInstanceTest(v: TypeValue | undefined, className: string): boolean | undefined {
-  if (!v) return undefined;
-  let base: TypeValue = v;
-  while (base.kind === "refined") base = base.base;
-  switch (base.kind) {
-    case "array":
-    case "tuple": return className === "Array" || className === "Object";
-    case "object": return className === "Object";
-    case "function": return className === "Function" || className === "Object";
-    case "promise": return className === "Promise" || className === "Object";
-    case "literal":
-    case "primitive": return false;
-    default: return undefined;
-  }
-}
-/** JSON 值 → TypeValue（字面量级精确：package.json 版本号等成为 string 字面量） */
-function jsonToTypeValue(v: unknown): TypeValue {
-  if (v === null) return T.literal(null);
-  if (typeof v === "string") return T.literal(v);
-  if (typeof v === "number") return T.literal(v);
-  if (typeof v === "boolean") return T.literal(v);
-  if (Array.isArray(v)) return T.tuple(v.map(jsonToTypeValue));
-  if (typeof v === "object") {
-    const props: Record<string, TypeValue> = {};
-    for (const [k, val] of Object.entries(v)) {
-      // Define-as-own: plain assignment would let a "__proto__" key trip
-      // the setter on the props record (dropping it and corrupting the
-      // record's prototype) — JSON.parse creates an own property, and
-      // hoek's prototype-poisoning fixtures exercise exactly that key.
-      Object.defineProperty(props, k, {
-        value: jsonToTypeValue(val),
-        enumerable: true,
-        writable: true,
-        configurable: true,
-      });
-    }
-    return T.object(props);
-  }
-  return T.unknown;
-}
-export { BUILTIN_STATIC_METHODS, builtinInstanceTest, jsonToTypeValue };

package/src/builtins/builtin-symbol.ts

@@ -1,16 +0,0 @@
-import { type TypeValue, T } from "@nudojs/core";
-
-export const SYMBOL_STATIC_METHODS: Record<string, TypeValue> = {
-  for: T.symbol,
-  keyFor: T.union(T.string, T.undefined),
-};
-
-export const SYMBOL_STATIC_PROPS: Record<string, TypeValue> = {
-  asyncIterator: T.symbol,
-  iterator: T.symbol,
-  toPrimitive: T.symbol,
-  toStringTag: T.symbol,
-  hasInstance: T.symbol,
-  species: T.symbol,
-  isConcatSpreadable: T.symbol,
-};

package/src/builtins/builtin-url.ts

@@ -1,58 +0,0 @@
-import { type TypeValue, T } from "@nudojs/core";
-
-export const URL_PROPS: Record<string, TypeValue> = {
-  href: T.string,
-  origin: T.string,
-  protocol: T.string,
-  host: T.string,
-  hostname: T.string,
-  port: T.string,
-  pathname: T.string,
-  search: T.string,
-  hash: T.string,
-  username: T.string,
-  password: T.string,
-};
-
-export const URL_INSTANCE_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  toString: () => T.string,
-};
-
-export const URLSearchParams_INSTANCE_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  get: () => T.union(T.string, T.null),
-  set: () => T.undefined,
-  has: () => T.boolean,
-  delete: () => T.undefined,
-  append: () => T.undefined,
-  toString: () => T.string,
-  getAll: () => T.array(T.string),
-};
-
-export function createURLType(): TypeValue {
-  return T.instanceOf("URL", {
-    href: T.string,
-    origin: T.string,
-    protocol: T.string,
-    host: T.string,
-    hostname: T.string,
-    port: T.string,
-    pathname: T.string,
-    search: T.string,
-    hash: T.string,
-    username: T.string,
-    password: T.string,
-    toString: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-  });
-}
-
-export function createURLSearchParamsType(): TypeValue {
-  return T.instanceOf("URLSearchParams", {
-    get: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    set: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    has: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    delete: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    append: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    toString: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    getAll: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-  });
-}

package/src/builtins/builtin-weak.ts

@@ -1,22 +0,0 @@
-import { type TypeValue, T } from "@nudojs/core";
-
-export const WEAKMAP_INSTANCE_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  get: (_key: TypeValue) => T.union(T.unknown, T.undefined),
-  set: (_key: TypeValue, _value: TypeValue, map?: TypeValue) => map ?? T.unknown,
-  has: () => T.boolean,
-  delete: () => T.boolean,
-};
-
-export const WEAKSET_INSTANCE_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  add: (_value: TypeValue, set?: TypeValue) => set ?? T.unknown,
-  has: () => T.boolean,
-  delete: () => T.boolean,
-};
-
-export function createWeakMapType(): TypeValue {
-  return T.instanceOf("WeakMap", {});
-}
-
-export function createWeakSetType(): TypeValue {
-  return T.instanceOf("WeakSet", {});
-}

package/src/builtins/builtin-web.ts

@@ -1,111 +0,0 @@
-import { type TypeValue, T } from "@nudojs/core";
-
-export const RESPONSE_PROPS: Record<string, TypeValue> = {
-  ok: T.boolean,
-  status: T.number,
-  statusText: T.string,
-  url: T.string,
-  type: T.string,
-  redirected: T.boolean,
-  headers: T.unknown, // Headers instance
-  body: T.unknown,
-  bodyUsed: T.boolean,
-};
-
-export const RESPONSE_INSTANCE_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  json: () => T.promise(T.unknown),
-  text: () => T.promise(T.string),
-  arrayBuffer: () => T.promise(T.unknown),
-  blob: () => T.promise(T.unknown),
-  clone: () => T.unknown,
-  formData: () => T.promise(T.unknown),
-};
-
-export const HEADERS_INSTANCE_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  get: () => T.union(T.string, T.null),
-  set: () => T.undefined,
-  has: () => T.boolean,
-  delete: () => T.undefined,
-  append: () => T.undefined,
-  entries: () => T.unknown,
-  keys: () => T.unknown,
-  values: () => T.unknown,
-  forEach: () => T.undefined,
-};
-
-export const FORMDATA_INSTANCE_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  get: () => T.union(T.string, T.null),
-  set: () => T.undefined,
-  has: () => T.boolean,
-  delete: () => T.undefined,
-  append: () => T.undefined,
-  getAll: () => T.array(T.unknown),
-  entries: () => T.unknown,
-  keys: () => T.unknown,
-  values: () => T.unknown,
-  forEach: () => T.undefined,
-};
-
-export const ABORTCONTROLLER_PROPS: Record<string, TypeValue> = {
-  signal: T.unknown,
-};
-
-export const ABORTCONTROLLER_INSTANCE_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  abort: () => T.undefined,
-};
-
-export function createResponseType(): TypeValue {
-  return T.instanceOf("Response", {
-    ok: T.boolean,
-    status: T.number,
-    statusText: T.string,
-    url: T.string,
-    type: T.string,
-    redirected: T.boolean,
-    headers: T.unknown,
-    body: T.unknown,
-    bodyUsed: T.boolean,
-    json: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    text: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    arrayBuffer: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    blob: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    clone: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    formData: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-  });
-}
-
-export function createHeadersType(): TypeValue {
-  return T.instanceOf("Headers", {
-    get: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    set: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    has: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    delete: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    append: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    entries: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    keys: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    values: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    forEach: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-  });
-}
-
-export function createFormDataType(): TypeValue {
-  return T.instanceOf("FormData", {
-    get: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    set: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    has: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    delete: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    append: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    getAll: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    entries: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    keys: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    values: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    forEach: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-  });
-}
-
-export function createAbortControllerType(): TypeValue {
-  return T.instanceOf("AbortController", {
-    signal: T.unknown,
-    abort: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-  });
-}

package/src/config.ts

@@ -1,32 +0,0 @@
-import { readFileSync, existsSync } from "node:fs";
-import { resolve, dirname } from "node:path";
-
-export type NudoConfig = {
-  env?: string[];
-  mocks?: Record<string, string>;
-};
-
-export function findProjectConfig(startDir: string): { config: NudoConfig; projectDir: string } | null {
-  let dir = resolve(startDir);
-  const root = resolve("/");
-
-  while (dir !== root) {
-    const pkgPath = resolve(dir, "package.json");
-    if (existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        if (pkg.nudo) {
-          return { config: pkg.nudo as NudoConfig, projectDir: dir };
-        }
-      } catch {
-        // ignore parse errors
-      }
-      return null;
-    }
-    const parent = dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-
-  return null;
-}

package/src/env-loader.ts

@@ -1,174 +0,0 @@
-import { readFileSync, existsSync, statSync, mkdirSync, writeFileSync } from "node:fs";
-import { resolve as resolvePath, join as joinPath } from "node:path";
-import { pathToFileURL } from "node:url";
-import { createRequire } from "node:module";
-import { createHash } from "node:crypto";
-import { tmpdir } from "node:os";
-import { type TypeValue, type Environment } from "@nudojs/core";
-import { defineEnv as defineEsEnv } from "@nudojs/env/es";
-import { defineEnv as defineWebEnv } from "@nudojs/env/web";
-import { defineEnv as defineNodeEnv } from "@nudojs/env/node";
-
-type EnvDefinition = {
-  globals: Record<string, TypeValue>;
-  modules?: Record<string, Record<string, TypeValue>>;
-};
-
-const envFactories: Record<string, () => EnvDefinition> = {
-  es: defineEsEnv,
-  web: defineWebEnv,
-  node: defineNodeEnv,
-};
-
-const impliedDeps: Record<string, string[]> = {
-  web: ["es"],
-  node: ["es"],
-};
-
-function resolveEnvNames(names: string[]): string[] {
-  const resolved = new Set<string>();
-  const visit = (name: string) => {
-    if (resolved.has(name)) return;
-    const deps = impliedDeps[name];
-    if (deps) deps.forEach(visit);
-    resolved.add(name);
-  };
-  names.forEach(visit);
-  return [...resolved];
-}
-
-export type LoadedEnv = {
-  modules: Record<string, Record<string, TypeValue>>;
-};
-
-// Path-based env files (`/// @nudo:env ./nudo-harvest-node.ts`) are imported
-// asynchronously and cached here; the sync loadEnvs() below consults this map
-// so sync consumers (analyzeFile & friends) see them after a preload pass.
-const pathEnvCache = new Map<string, () => EnvDefinition>();
-// resolvedPath → factory; looked up by trying the directive spelling as-is and
-// resolved against every baseDir seen during preload (covers `./env.ts`,
-// `../env.ts`, and bare `env.ts` spellings from different analyzed files).
-const pathEnvByPath = new Map<string, () => EnvDefinition>();
-const pathEnvBaseDirs = new Set<string>();
-
-function isPathEnvName(name: string, baseDir: string): boolean {
-  if (name in envFactories) return false;
-  if (name.includes("/") || name.startsWith("./") || name.startsWith("../")) return true;
-  const resolved = resolvePath(baseDir, name);
-  return resolved.endsWith(".ts") && existsSync(resolved);
-}
-
-// A harvested env file lives anywhere on disk (e.g. /tmp) and imports
-// "@nudojs/core" — a bare specifier that only resolves from inside the repo's
-// packages. When the direct import fails, rewrite those specifiers to absolute
-// file URLs (resolved from this package, which depends on them) and import a
-// cached copy under the OS tmpdir.
-function rewriteBareImports(text: string): string | null {
-  const require = createRequire(import.meta.url);
-  let rewrote = false;
-  const out = text.replace(/(["'])(@nudojs\/[a-z0-9-]+)\1/g, (_m, quote: string, spec: string) => {
-    try {
-      const entry = require.resolve(spec);
-      const url = pathToFileURL(entry).href;
-      rewrote = true;
-      return `${quote}${url}${quote}`;
-    } catch {
-      return `${quote}${spec}${quote}`;
-    }
-  });
-  return rewrote ? out : null;
-}
-
-async function importPathEnv(resolvedPath: string, mtimeMs: number): Promise<void> {
-  const cacheKey = `${resolvedPath}:${mtimeMs}`;
-  if (pathEnvCache.has(cacheKey)) return;
-
-  let mod: { defineEnv?: unknown } | null = null;
-  try {
-    const url = pathToFileURL(resolvedPath).href + `?mtime=${mtimeMs}`;
-    mod = (await import(url)) as { defineEnv?: unknown };
-  } catch {
-    // Fall through to the rewritten-copy fallback below.
-    mod = null;
-  }
-
-  if (!mod) {
-    try {
-      const text = readFileSync(resolvedPath, "utf-8");
-      const rewritten = rewriteBareImports(text);
-      if (rewritten === null) return; // nothing to fix; the import failure was something else
-      const cacheDir = joinPath(tmpdir(), "nudo-env");
-      mkdirSync(cacheDir, { recursive: true });
-      const hash = createHash("md5").update(`${resolvedPath}:${mtimeMs}`).digest("hex").slice(0, 16);
-      const copyPath = joinPath(cacheDir, `${hash}.ts`);
-      writeFileSync(copyPath, rewritten, "utf-8");
-      mod = (await import(pathToFileURL(copyPath).href)) as { defineEnv?: unknown };
-    } catch {
-      return;
-    }
-  }
-
-  if (mod && typeof mod.defineEnv === "function") {
-    pathEnvCache.set(cacheKey, mod.defineEnv as () => EnvDefinition);
-    pathEnvByPath.set(resolvedPath, mod.defineEnv as () => EnvDefinition);
-  }
-}
-
-function lookupPathEnv(name: string): (() => EnvDefinition) | undefined {
-  if (pathEnvByPath.size === 0) return undefined;
-  const candidates = name.startsWith("/")
-    ? [name]
-    : [name, ...[...pathEnvBaseDirs].map((d) => resolvePath(d, name))];
-  for (const candidate of candidates) {
-    const hit = pathEnvByPath.get(candidate);
-    if (hit) return hit;
-  }
-  return undefined;
-}
-
-export async function preloadPathEnvs(envNames: string[], baseDir: string): Promise<void> {
-  pathEnvBaseDirs.add(baseDir);
-  for (const name of envNames) {
-    if (!isPathEnvName(name, baseDir)) continue;
-    const resolved = resolvePath(baseDir, name);
-    if (!existsSync(resolved)) continue; // silent skip, matching registry behavior
-    try {
-      const { mtimeMs } = statSync(resolved);
-      await importPathEnv(resolved, mtimeMs);
-    } catch {
-      // unreadable/unstattable — skip
-    }
-  }
-}
-
-export async function loadEnvsAsync(
-  envNames: string[],
-  globalEnv: Environment,
-  baseDir: string = process.cwd(),
-): Promise<LoadedEnv> {
-  await preloadPathEnvs(envNames, baseDir);
-  return loadEnvs(envNames, globalEnv);
-}
-
-export function loadEnvs(envNames: string[], globalEnv: Environment): LoadedEnv {
-  const allModules: Record<string, Record<string, TypeValue>> = {};
-  const resolved = resolveEnvNames(envNames);
-
-  for (const name of resolved) {
-    const factory = envFactories[name] ?? lookupPathEnv(name);
-    if (!factory) continue;
-    const def = factory();
-
-    for (const [key, value] of Object.entries(def.globals)) {
-      globalEnv.bind(key, value);
-    }
-
-    if (def.modules) {
-      for (const [modName, exports] of Object.entries(def.modules)) {
-        allModules[modName] = { ...allModules[modName], ...exports };
-      }
-    }
-  }
-
-  return { modules: allModules };
-}