@nudojs/cli 0.2.1 → 0.3.1

package/src/builtins/builtin-regexp.ts

@@ -1,34 +0,0 @@
-import { type TypeValue, T } from "@nudojs/core";
-
-export const REGEXP_INSTANCE_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  test: () => T.boolean,
-  exec: () => T.union(T.null, T.object({})),
-  toString: () => T.string,
-};
-
-export const REGEXP_PROPS: Record<string, TypeValue> = {
-  source: T.string,
-  flags: T.string,
-  global: T.boolean,
-  ignoreCase: T.boolean,
-  multiline: T.boolean,
-  dotAll: T.boolean,
-  unicode: T.boolean,
-  sticky: T.boolean,
-};
-
-export function createRegExpType(): TypeValue {
-  return T.instanceOf("RegExp", {
-    source: T.string,
-    flags: T.string,
-    global: T.boolean,
-    ignoreCase: T.boolean,
-    multiline: T.boolean,
-    dotAll: T.boolean,
-    unicode: T.boolean,
-    sticky: T.boolean,
-    test: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    exec: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    toString: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-  });
-}

package/src/builtins/builtin-set.ts

@@ -1,131 +0,0 @@
-import { type TypeValue, T, simplifyUnion, typeValueEquals } from "@nudojs/core";
-
-// Literal/instance values recorded at construction (`new Set([a, b])`) or
-// via add() — precise enough for typeValueEquals lookup in has(). Symbolic
-// values are skipped and has() falls back to boolean.
-function valueTrackable(v: TypeValue | undefined): boolean {
-  return v?.kind === "literal" || v?.kind === "instance";
-}
-
-// Union values distribute: every member present → true, none present →
-// false, mixed/not comparable → null (symbolic boolean fallback).
-function lookupValues(values: TypeValue[], value: TypeValue): boolean | null {
-  if (value.kind === "union") {
-    const results = value.members.map((m) => lookupValues(values, m));
-    if (results.some((r) => r === null)) return null;
-    return results.some((r) => r === true) && results.every((r) => r === true);
-  }
-  if (!valueTrackable(value)) return null;
-  return values.some((v) => typeValueEquals(v, value));
-}
-
-export const SET_INSTANCE_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  add: (value: TypeValue, set?: TypeValue) => {
-    if (set) {
-      const typeArgs = (set as any)._typeArgs || { T: T.unknown };
-      (set as any)._typeArgs = {
-        T: typeArgs.T.kind === "unknown" ? value : simplifyUnion([typeArgs.T, value]),
-      };
-      if (valueTrackable(value)) {
-        // An exact list can start on the first trackable add (nothing
-        // untracked came before); once partial it stays partial.
-        if ((set as any)._values === undefined && (set as any)._valuesExact !== false) {
-          (set as any)._values = [];
-          (set as any)._valuesExact = true;
-        }
-        if ((set as any)._valuesExact) {
-          const values = (set as any)._values as TypeValue[];
-          if (!values.some((v) => typeValueEquals(v, value))) values.push(value);
-        }
-      } else {
-        (set as any)._valuesExact = false;
-      }
-    }
-    return set ?? T.unknown;
-  },
-  has: (value: TypeValue, set?: TypeValue) => {
-    const values = exactSetValues(set);
-    if (values) {
-      const looked = lookupValues(values, value);
-      if (looked !== null) return T.literal(looked);
-    }
-    return T.boolean;
-  },
-  delete: (value: TypeValue, set?: TypeValue) => {
-    const values = exactSetValues(set);
-    if (values && valueTrackable(value)) {
-      const idx = values.findIndex((v) => typeValueEquals(v, value));
-      if (idx >= 0) {
-        values.splice(idx, 1);
-        return T.literal(true);
-      }
-      return T.literal(false);
-    }
-    return T.boolean;
-  },
-  clear: (value?: TypeValue, set?: TypeValue) => {
-    // s.clear() arrives as clear(receiver): the set sits in the first
-    // param slot when the call has no arguments.
-    const target = set ?? value;
-    if (target && (target as any)._valuesExact) {
-      (target as any)._values = [];
-    }
-    return T.undefined;
-  },
-  forEach: () => T.undefined,
-  values: (set?: TypeValue) => setValuesIterable(set),
-  // For Set, keys() is the same as values()
-  keys: (set?: TypeValue) => setValuesIterable(set),
-  entries: (set?: TypeValue) => {
-    const values = exactSetValues(set);
-    if (values) return T.tuple(values.map((v) => T.tuple([v, v])));
-    const typeArgs = (set as any)?._typeArgs;
-    if (typeArgs?.T) return T.array(T.tuple([typeArgs.T, typeArgs.T]));
-    return T.array(T.tuple([T.unknown, T.unknown]));
-  },
-};
-
-// Exact membership side table: present only when every member seen so far
-// (construction elements + adds) was trackable. Partial tables must not
-// decide has()/delete()/iteration — an untracked member could be anything.
-export function exactSetValues(set: TypeValue | undefined): TypeValue[] | undefined {
-  if (!set || (set as any)._valuesExact !== true) return undefined;
-  return (set as any)._values as TypeValue[] | undefined;
-}
-
-// values()/keys() keep feeding `new Set(...)`-style consumers: a tuple of
-// the exact members when the side table is complete, else array<T>.
-export function setValuesIterable(set: TypeValue | undefined): TypeValue {
-  const values = exactSetValues(set);
-  if (values) return T.tuple([...values]);
-  const typeArgs = (set as any)?._typeArgs;
-  if (typeArgs?.T) return T.array(typeArgs.T);
-  return T.array(T.unknown);
-}
-
-export function createSetType(args?: TypeValue[]): TypeValue {
-  const obj = T.instanceOf("Set", {});
-
-  if (args && args.length > 0) {
-    const arg = args[0];
-    if (arg.kind === "tuple" || arg.kind === "array") {
-      const elements = arg.kind === "tuple" ? arg.elements : [arg.element];
-      (obj as any)._typeArgs = { T: simplifyUnion(elements) };
-      // Only a fully trackable element list is exact: symbolic elements
-      // mean the recorded values are a subset of the real membership.
-      const exact = elements.every(valueTrackable);
-      if (exact && elements.length > 0) {
-        (obj as any)._values = elements;
-        (obj as any)._valuesExact = true;
-      } else if (!exact) {
-        (obj as any)._valuesExact = false;
-      }
-    }
-  }
-
-  if (!(obj as any)._typeArgs) {
-    (obj as any)._typeArgs = { T: T.unknown };
-  }
-
-  return obj;
-}

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/builtins/index.ts

@@ -1,61 +0,0 @@
-import { type TypeValue } from "@nudojs/core";
-import { PROMISE_STATIC_METHODS } from "./builtin-promise.ts";
-import { MAP_INSTANCE_METHODS, createMapType } from "./builtin-map.ts";
-import { SET_INSTANCE_METHODS, createSetType } from "./builtin-set.ts";
-import { REGEXP_INSTANCE_METHODS, createRegExpType } from "./builtin-regexp.ts";
-import { URL_INSTANCE_METHODS, URLSearchParams_INSTANCE_METHODS, createURLType, createURLSearchParamsType } from "./builtin-url.ts";
-import {
-  RESPONSE_INSTANCE_METHODS,
-  HEADERS_INSTANCE_METHODS,
-  FORMDATA_INSTANCE_METHODS,
-  ABORTCONTROLLER_INSTANCE_METHODS,
-  createResponseType,
-  createHeadersType,
-  createFormDataType,
-  createAbortControllerType,
-} from "./builtin-web.ts";
-import { WEAKMAP_INSTANCE_METHODS, WEAKSET_INSTANCE_METHODS, createWeakMapType, createWeakSetType } from "./builtin-weak.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, createDateTimeFormatType, createNumberFormatType } from "./builtin-intl.ts";
-
-export const ALL_STATIC_METHODS: Record<string, Record<string, TypeValue>> = {
-  Promise: PROMISE_STATIC_METHODS,
-  Symbol: SYMBOL_STATIC_METHODS,
-};
-
-export const ALL_STATIC_PROPS: Record<string, Record<string, TypeValue>> = {
-  Symbol: SYMBOL_STATIC_PROPS,
-};
-
-export const ALL_INSTANCE_METHODS: Record<string, Record<string, (...args: TypeValue[]) => TypeValue>> = {
-  Map: MAP_INSTANCE_METHODS,
-  Set: SET_INSTANCE_METHODS,
-  RegExp: REGEXP_INSTANCE_METHODS,
-  URL: URL_INSTANCE_METHODS,
-  URLSearchParams: URLSearchParams_INSTANCE_METHODS,
-  Response: RESPONSE_INSTANCE_METHODS,
-  Headers: HEADERS_INSTANCE_METHODS,
-  FormData: FORMDATA_INSTANCE_METHODS,
-  AbortController: ABORTCONTROLLER_INSTANCE_METHODS,
-  WeakMap: WEAKMAP_INSTANCE_METHODS,
-  WeakSet: WEAKSET_INSTANCE_METHODS,
-  DateTimeFormat: INTL_DATETIMEFORMAT_METHODS,
-  NumberFormat: INTL_NUMBERFORMAT_METHODS,
-};
-
-export {
-  createMapType,
-  createSetType,
-  createRegExpType,
-  createURLType,
-  createURLSearchParamsType,
-  createResponseType,
-  createHeadersType,
-  createFormDataType,
-  createAbortControllerType,
-  createWeakMapType,
-  createWeakSetType,
-  createDateTimeFormatType,
-  createNumberFormatType,
-};

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 };
-}

package/src/evaluator-api.ts

@@ -1,36 +0,0 @@
-export {
-  evaluate,
-  evaluateFunction,
-  evaluateFunctionFull,
-  evaluateProgram,
-  setModuleResolver,
-  setCurrentFileDir,
-  resetMemo,
-  getUnreachableRanges,
-  resetUnreachableRanges,
-  setNodeTypeCollector,
-  setCallCollector,
-  type CallRecord,
-  setUnknownCollector,
-  setProvenanceTracking,
-  type UnknownRecord,
-  setSampleCount,
-  setMaxConcreteIter,
-  setUnknownBuiltinHandler,
-  setEnvModules,
-  resetEnvModules,
-  setMockModules,
-  resetMockModules,
-  setCurrentSource,
-  memberMayExistOn,
-  setUsageSiteTag,
-  USAGE_SITE_MODULE,
-} from "./evaluator.ts";
-
-export { narrow } from "./narrowing.ts";
-
-export { loadEnvs, loadEnvsAsync, preloadPathEnvs, type LoadedEnv } from "./env-loader.ts";
-
-export { findProjectConfig, type NudoConfig } from "./config.ts";
-
-export { resolveNpmNudo } from "./resolve-npm.ts";