@openpkg-ts/sdk 0.50.1 → 0.52.0

package/dist/index.js

@@ -83,9 +83,70 @@ function mergeConfig(fileConfig, cliOptions) {
     ...hasExternals ? { externals } : {},
     followExternal: cliOptions.followExternal ?? fileConfig.followExternal,
     only: cliOptions.only ?? fileConfig.only,
-    ignore: cliOptions.ignore ?? fileConfig.ignore
+    ignore: cliOptions.ignore ?? fileConfig.ignore,
+    decisions: cliOptions.decisions ?? fileConfig.decisions
   };
 }
+// src/core/decisions.ts
+var JEV_MODEL = "typesafe-ai/jev";
+var JEV_CONFIDENCE = 0.5;
+var MAX_JEV_QUESTIONS = 50;
+async function loadEvaluate() {
+  try {
+    const specifier = "ai";
+    const mod = await import(specifier);
+    if (typeof mod.experimental_evaluate !== "function") {
+      throw new Error("ai.experimental_evaluate is not a function");
+    }
+    return (request) => mod.experimental_evaluate({
+      ...request,
+      providerOptions: {
+        gateway: { zeroDataRetention: true },
+        ...request.providerOptions
+      }
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`--jev requires the ai package (AI SDK ≥7.0.105): bun add ai
+${msg}`);
+  }
+}
+function namedConfidence(result, id) {
+  const named = result.providerMetadata?.typesafe?.confidence?.[id];
+  return typeof named === "number" ? named : undefined;
+}
+function choiceConfidence(result, id, choice) {
+  const named = namedConfidence(result, id);
+  if (named !== undefined)
+    return named;
+  const p = result.answers[id]?.probabilities?.[choice];
+  return typeof p === "number" ? p : 0;
+}
+async function jevEvaluate(evaluate, state, questions) {
+  return evaluate({
+    model: JEV_MODEL,
+    state: JSON.parse(JSON.stringify(state)),
+    questions,
+    providerOptions: { gateway: { zeroDataRetention: true } }
+  });
+}
+async function jevChoice(args) {
+  const keys = Object.keys(args.criteria);
+  if (keys.length < 2)
+    return null;
+  const id = args.id ?? "choice";
+  const result = await jevEvaluate(args.evaluate, args.state, {
+    [id]: {
+      type: "choice",
+      instructions: args.instructions,
+      criteria: args.criteria
+    }
+  });
+  const choice = result.answers[id]?.choice;
+  if (!choice || !(choice in args.criteria))
+    return null;
+  return { choice, confidence: choiceConfidence(result, id, choice) };
+}
 // src/core/loader.ts
 import * as fs2 from "node:fs";
 import { validateSpec } from "@openpkg-ts/spec";
@@ -1200,6 +1261,584 @@ function extractModuleName(exp) {
   }
   return;
 }
+// src/core/resolve-target.ts
+import { spawn, spawnSync } from "node:child_process";
+import * as fs3 from "node:fs";
+import * as os from "node:os";
+import * as path2 from "node:path";
+var SKIP_DIRS = new Set(["node_modules", "dist", ".git", "target", "coverage", ".next", "out"]);
+var CONV = ["src/index.ts", "src/index.tsx", "src/index.mts", "index.ts", "index.tsx"];
+var ENTRY_EXT = /\.(c|m)?[tj]sx?$/;
+var MAX_PACKAGES = 200;
+function isRemoteInput(input) {
+  return /^(https?:\/\/|git@|github\.com\/)/i.test(input);
+}
+function isEntryFilePath(input) {
+  return ENTRY_EXT.test(input) || /\.d\.(ts|mts|cts)$/.test(input);
+}
+function parseGithubRepo(input) {
+  const trimmed = input.trim().replace(/\.git$/, "");
+  const https = trimmed.match(/github\.com[/:]([^/]+)\/([^/#?]+)/i);
+  if (!https)
+    return null;
+  return { owner: https[1], repo: https[2] };
+}
+function runCmd(cmd, args) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0)
+        resolve2();
+      else
+        reject(new Error(`${cmd} ${args.join(" ")} failed: ${stderr.trim() || code}`));
+    });
+  });
+}
+function whichCmd(cmd) {
+  const checker = process.platform === "win32" ? "where" : "which";
+  return spawnSync(checker, [cmd], { stdio: "ignore" }).status === 0;
+}
+async function cloneRemote(input) {
+  const dest = fs3.mkdtempSync(path2.join(os.tmpdir(), "openpkg-"));
+  const github = parseGithubRepo(input);
+  try {
+    if (github && whichCmd("gh")) {
+      await runCmd("gh", [
+        "repo",
+        "clone",
+        `${github.owner}/${github.repo}`,
+        dest,
+        "--",
+        "--depth",
+        "1"
+      ]);
+    } else {
+      const url = input.startsWith("github.com/") ? `https://${input}` : input;
+      await runCmd("git", ["clone", "--depth", "1", url, dest]);
+    }
+  } catch (err) {
+    fs3.rmSync(dest, { recursive: true, force: true });
+    throw err;
+  }
+  return dest;
+}
+function existsFile(p) {
+  try {
+    return fs3.existsSync(p) && fs3.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function existsDir(p) {
+  try {
+    return fs3.existsSync(p) && fs3.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function readJson(file) {
+  try {
+    return JSON.parse(fs3.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function parsePnpmWorkspace(yaml) {
+  const globs = [];
+  const lines = yaml.split(`
+`);
+  let inPackages = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === "packages:") {
+      inPackages = true;
+      continue;
+    }
+    if (inPackages) {
+      if (!line.startsWith(" ") && !line.startsWith("\t") && !line.startsWith("-") && trimmed) {
+        break;
+      }
+      const match = trimmed.match(/^-\s*['"]?([^'"]+)['"]?$/);
+      if (match)
+        globs.push(match[1]);
+    }
+  }
+  return globs;
+}
+function expandGlob(root, pattern) {
+  const parts = pattern.split("/").filter(Boolean);
+  const out = [];
+  const walk = (dir, i) => {
+    if (out.length >= MAX_PACKAGES)
+      return;
+    if (i === parts.length) {
+      if (existsFile(path2.join(dir, "package.json")))
+        out.push(dir);
+      return;
+    }
+    const part = parts[i];
+    if (!existsDir(dir))
+      return;
+    if (part === "**") {
+      walk(dir, i + 1);
+      let entries = [];
+      try {
+        entries = fs3.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const ent of entries) {
+        if (!ent.isDirectory() || SKIP_DIRS.has(ent.name))
+          continue;
+        walk(path2.join(dir, ent.name), i);
+      }
+      return;
+    }
+    if (part === "*") {
+      let entries = [];
+      try {
+        entries = fs3.readdirSync(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const ent of entries) {
+        if (!ent.isDirectory() || SKIP_DIRS.has(ent.name))
+          continue;
+        walk(path2.join(dir, ent.name), i + 1);
+      }
+      return;
+    }
+    walk(path2.join(dir, part), i + 1);
+  };
+  walk(root, 0);
+  return out;
+}
+function workspaceGlobs(dir) {
+  const pnpm = path2.join(dir, "pnpm-workspace.yaml");
+  if (existsFile(pnpm)) {
+    const globs = parsePnpmWorkspace(fs3.readFileSync(pnpm, "utf-8"));
+    if (globs.length)
+      return globs;
+  }
+  const pkg = readJson(path2.join(dir, "package.json"));
+  if (!pkg)
+    return null;
+  const ws = pkg.workspaces;
+  if (Array.isArray(ws) && ws.every((x) => typeof x === "string"))
+    return ws;
+  if (ws && typeof ws === "object" && Array.isArray(ws.packages)) {
+    return (ws.packages ?? []).filter((x) => typeof x === "string");
+  }
+  return null;
+}
+function findWorkspaceRoot(start) {
+  let dir = path2.resolve(start);
+  for (let i = 0;i < 12; i++) {
+    const globs = workspaceGlobs(dir);
+    if (globs?.length)
+      return dir;
+    const parent = path2.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return;
+}
+function toRecord(dir) {
+  const pkg = readJson(path2.join(dir, "package.json"));
+  if (!pkg)
+    return null;
+  const name = typeof pkg.name === "string" ? pkg.name : path2.basename(dir);
+  const scripts = pkg.scripts && typeof pkg.scripts === "object" ? Object.keys(pkg.scripts) : [];
+  return {
+    name,
+    dir,
+    private: pkg.private === true,
+    ...typeof pkg.description === "string" ? { description: pkg.description } : {},
+    ...typeof pkg.types === "string" ? { types: pkg.types } : {},
+    ...typeof pkg.typings === "string" ? { typings: pkg.typings } : {},
+    ...typeof pkg.main === "string" ? { main: pkg.main } : {},
+    ...typeof pkg.module === "string" ? { module: pkg.module } : {},
+    hasSrc: CONV.some((c) => existsFile(path2.join(dir, c))),
+    hasDist: existsDir(path2.join(dir, "dist")),
+    scripts
+  };
+}
+function catalogPackages(start) {
+  const abs = path2.resolve(start);
+  const root = findWorkspaceRoot(abs) ?? abs;
+  const seen = new Set;
+  const out = [];
+  const add = (dir2) => {
+    const resolved = path2.resolve(dir2);
+    if (seen.has(resolved) || out.length >= MAX_PACKAGES)
+      return;
+    const rec = toRecord(resolved);
+    if (!rec)
+      return;
+    seen.add(resolved);
+    out.push(rec);
+  };
+  const globs = workspaceGlobs(root);
+  if (globs?.length) {
+    for (const glob of globs) {
+      for (const dir2 of expandGlob(root, glob))
+        add(dir2);
+    }
+  }
+  let dir = abs;
+  for (let i = 0;i < 8; i++) {
+    if (existsFile(path2.join(dir, "package.json"))) {
+      add(dir);
+      break;
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return out;
+}
+function collectFromExports(value, out, depth = 0) {
+  if (depth > 4 || value == null)
+    return;
+  if (typeof value === "string") {
+    out.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const v of value)
+      collectFromExports(v, out, depth + 1);
+    return;
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    for (const key of ["types", "import", "default", "require", "node", "browser", "module"]) {
+      if (key in obj)
+        collectFromExports(obj[key], out, depth + 1);
+    }
+  }
+}
+function collectCandidates(pkgDir, pkg) {
+  const seen = new Map;
+  const add = (rel, source) => {
+    const abs = path2.resolve(pkgDir, rel);
+    if (!existsFile(abs))
+      return;
+    const norm = path2.relative(pkgDir, abs).split(path2.sep).join("/");
+    const prev = seen.get(norm);
+    if (!prev)
+      seen.set(norm, { rel: norm, abs, source });
+    else if (!prev.source.includes(source))
+      prev.source += `, ${source}`;
+  };
+  if (typeof pkg.types === "string")
+    add(pkg.types, "types");
+  if (typeof pkg.typings === "string")
+    add(pkg.typings, "typings");
+  if (pkg.exports && typeof pkg.exports === "object") {
+    const exp = pkg.exports;
+    const root = "." in exp ? exp["."] : exp;
+    const paths = [];
+    collectFromExports(root, paths);
+    for (const p of paths)
+      add(p, "exports");
+  }
+  if (typeof pkg.module === "string")
+    add(pkg.module, "module");
+  if (typeof pkg.main === "string")
+    add(pkg.main, "main");
+  for (const c of CONV)
+    add(c, "convention");
+  return [...seen.values()];
+}
+function scoreCandidate(c) {
+  const ts = /\.(ts|tsx|mts)$/.test(c.rel) && !/\.d\.(ts|mts|cts)$/.test(c.rel);
+  const dts = /\.d\.(ts|mts|cts)$/.test(c.rel);
+  const src = c.rel.startsWith("src/");
+  let n = 0;
+  if (ts)
+    n += 40;
+  if (src && ts)
+    n += 20;
+  if (c.source.includes("types") || c.source.includes("typings"))
+    n += dts ? 5 : 10;
+  if (c.source.includes("exports"))
+    n += 8;
+  if (c.source.includes("convention"))
+    n += ts ? 15 : 2;
+  if (c.source.includes("module"))
+    n += 4;
+  if (c.source.includes("main"))
+    n += 2;
+  if (dts)
+    n -= 15;
+  if (/\.(js|mjs|cjs)$/.test(c.rel))
+    n -= 20;
+  return n;
+}
+function methodFor(c) {
+  if (c.source.includes("convention") && /\.(ts|tsx|mts)$/.test(c.rel) && !c.rel.includes(".d.")) {
+    return "fallback";
+  }
+  if (c.source.includes("types") || c.source.includes("typings"))
+    return "types";
+  if (c.source.includes("exports"))
+    return "exports";
+  if (c.source.includes("module"))
+    return "module";
+  if (c.source.includes("main"))
+    return "main";
+  return "fallback";
+}
+function pickEntry(pkgDir) {
+  const pkg = readJson(path2.join(pkgDir, "package.json")) ?? {};
+  const cands = collectCandidates(pkgDir, pkg);
+  if (!cands.length)
+    return null;
+  const best = [...cands].sort((a, b) => scoreCandidate(b) - scoreCandidate(a))[0];
+  return { entryFile: best.abs, entryPointSource: methodFor(best) };
+}
+function listEntryCandidates(pkgDir) {
+  const pkg = readJson(path2.join(pkgDir, "package.json")) ?? {};
+  return collectCandidates(pkgDir, pkg);
+}
+function isIgnoredPath(dir) {
+  const norm = dir.split(path2.sep).join("/");
+  return /\/(examples|fixtures|__tests__|test-fixtures)(\/|$)/.test(norm);
+}
+function isExtractable(pkg) {
+  if (pkg.private)
+    return false;
+  if (isIgnoredPath(pkg.dir))
+    return false;
+  return pkg.hasSrc || Boolean(pkg.types || pkg.typings);
+}
+function intentScore(pkg, intent) {
+  const q = intent.toLowerCase().trim();
+  if (!q)
+    return 0;
+  const words = q.split(/\s+/).filter(Boolean);
+  const name = pkg.name.toLowerCase();
+  const desc = (pkg.description ?? "").toLowerCase();
+  const dir = pkg.dir.split(path2.sep).join("/").toLowerCase();
+  let n = 0;
+  if (name === q || name.endsWith(`/${q}`) || name.split("/").pop() === q)
+    n += 20;
+  for (const w of words) {
+    if (name.includes(w))
+      n += 8;
+    if (desc.includes(w))
+      n += 3;
+    if (dir.includes(w))
+      n += 2;
+  }
+  return n;
+}
+function enclosingPackage(inputDir, catalog) {
+  const abs = path2.resolve(inputDir);
+  let best;
+  for (const pkg of catalog) {
+    if (abs === pkg.dir || abs.startsWith(pkg.dir + path2.sep)) {
+      if (!best || pkg.dir.length > best.dir.length)
+        best = pkg;
+    }
+  }
+  return best;
+}
+function buildCommand(pkg) {
+  if (pkg.scripts.includes("build:sdk-wasm"))
+    return "pnpm run build:sdk-wasm";
+  if (pkg.scripts.includes("build"))
+    return "bun run build";
+  return;
+}
+function head(abs, maxChars = 1200) {
+  try {
+    return fs3.readFileSync(abs, "utf8").slice(0, maxChars);
+  } catch {
+    return "";
+  }
+}
+async function jevPickPackage(candidates, ctx) {
+  if (!ctx.evaluate || candidates.length < 2)
+    return null;
+  const criteria = {};
+  const byId = new Map;
+  for (const [i, pkg] of candidates.entries()) {
+    const id = `p${i}`;
+    byId.set(id, pkg);
+    criteria[id] = `${pkg.name} — ${pkg.description ?? pkg.dir}${pkg.hasSrc ? " (src)" : ""}`;
+  }
+  const picked = await jevChoice({
+    evaluate: ctx.evaluate,
+    instructions: "Which package is the public TypeScript SDK to extract? Prefer the named product, not examples, wasm glue, or private packages.",
+    criteria,
+    state: {
+      intent: ctx.intent ?? null,
+      catalog: candidates.map((p, i) => ({
+        id: `p${i}`,
+        name: p.name,
+        description: p.description ?? null,
+        hasSrc: p.hasSrc,
+        hasDist: p.hasDist,
+        types: p.types ?? p.typings ?? null,
+        private: p.private
+      }))
+    },
+    id: "package"
+  });
+  if (!picked || picked.confidence < JEV_CONFIDENCE)
+    return null;
+  return byId.get(picked.choice) ?? null;
+}
+async function jevPickEntry(cands, ctx) {
+  if (!ctx.evaluate || cands.length < 2)
+    return null;
+  const criteria = {};
+  const byId = new Map;
+  for (const [i, c] of cands.entries()) {
+    const id = `c${i}`;
+    byId.set(id, c);
+    criteria[id] = `${c.rel} (${c.source})`;
+  }
+  const picked = await jevChoice({
+    evaluate: ctx.evaluate,
+    instructions: "Which file is the best OpenPkg entry point? Prefer TypeScript source over .d.ts/.js. Prefer the package root public API.",
+    criteria,
+    state: {
+      candidates: cands.map((c, i) => ({
+        id: `c${i}`,
+        path: c.rel,
+        source: c.source,
+        head: head(c.abs)
+      }))
+    },
+    id: "entry"
+  });
+  if (!picked || picked.confidence < JEV_CONFIDENCE)
+    return null;
+  return byId.get(picked.choice) ?? null;
+}
+async function finishPackage(pkg, ctx) {
+  const cands = listEntryCandidates(pkg.dir);
+  if (!cands.length) {
+    return {
+      kind: "needs-build",
+      package: pkg,
+      reason: `no TypeScript entry found in ${pkg.name}`,
+      ...buildCommand(pkg) ? { command: buildCommand(pkg) } : {}
+    };
+  }
+  const heuristic = [...cands].sort((a, b) => scoreCandidate(b) - scoreCandidate(a))[0];
+  let chosen = heuristic;
+  let source = methodFor(heuristic);
+  if (ctx.decisions === "jev" && cands.length >= 2) {
+    const jev = await jevPickEntry(cands, ctx);
+    if (jev) {
+      chosen = jev;
+      source = "llm";
+    }
+  }
+  return {
+    kind: "ok",
+    package: pkg,
+    entryFile: chosen.abs,
+    entryPointSource: source
+  };
+}
+async function resolveLocal(abs, startDir, ctx) {
+  const catalog = catalogPackages(startDir);
+  if (!catalog.length) {
+    return { kind: "empty", reason: "no JS/TS packages found" };
+  }
+  const root = findWorkspaceRoot(startDir);
+  const pointed = catalog.find((p) => p.dir === abs);
+  if (pointed && (isExtractable(pointed) || pointed.dir !== root)) {
+    return finishPackage(pointed, ctx);
+  }
+  const intent = ctx.intent;
+  if (intent) {
+    const scored = catalog.map((p) => ({ p, n: intentScore(p, intent) })).filter((x) => x.n > 0).sort((a, b) => b.n - a.n);
+    if (!scored.length) {
+      return { kind: "empty", reason: `no package matched intent "${intent}"` };
+    }
+    const top = scored.filter((x) => x.n === scored[0].n).map((x) => x.p);
+    if (top.length === 1)
+      return finishPackage(top[0], ctx);
+    if (ctx.decisions === "jev") {
+      const jev = await jevPickPackage(top, ctx);
+      if (jev)
+        return finishPackage(jev, ctx);
+    }
+    return { kind: "ambiguous", candidates: top };
+  }
+  const enclosed = enclosingPackage(startDir, catalog);
+  if (enclosed && enclosed.dir !== root)
+    return finishPackage(enclosed, ctx);
+  const extractable = catalog.filter(isExtractable);
+  if (extractable.length === 1)
+    return finishPackage(extractable[0], ctx);
+  if (extractable.length > 1) {
+    if (ctx.decisions === "jev") {
+      const jev = await jevPickPackage(extractable, ctx);
+      if (jev)
+        return finishPackage(jev, ctx);
+    }
+    return { kind: "ambiguous", candidates: extractable };
+  }
+  if (catalog.length === 1)
+    return finishPackage(catalog[0], ctx);
+  return { kind: "empty", reason: "no extractable JS/TS packages found" };
+}
+async function resolveTarget(options = {}) {
+  const cwd = path2.resolve(options.cwd ?? process.cwd());
+  const raw = options.input?.trim() || cwd;
+  const decisions = options.decisions ?? "heuristic";
+  const ctx = {
+    decisions,
+    evaluate: options.evaluate,
+    intent: options.intent?.trim() || undefined
+  };
+  if (decisions === "jev" && !ctx.evaluate) {
+    if (!process.env.AI_GATEWAY_API_KEY) {
+      return {
+        kind: "unavailable",
+        reason: `--jev requires AI_GATEWAY_API_KEY
+  https://vercel.com/docs/ai-gateway
+  omit --jev to stay local`
+      };
+    }
+    try {
+      ctx.evaluate = await loadEvaluate();
+    } catch (err) {
+      return { kind: "unavailable", reason: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  if (isRemoteInput(raw)) {
+    try {
+      const cloned = await (options.clone ?? cloneRemote)(raw);
+      const startDir2 = cloned;
+      return resolveLocal(startDir2, startDir2, ctx);
+    } catch (err) {
+      return {
+        kind: "empty",
+        reason: `failed to clone ${raw}: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+  const abs = path2.resolve(cwd, raw);
+  if (existsFile(abs) && isEntryFilePath(abs)) {
+    return { kind: "explicit", entryFile: abs, entryPointSource: "explicit" };
+  }
+  const startDir = existsDir(abs) ? abs : cwd;
+  return resolveLocal(abs, startDir, ctx);
+}
 // src/primitives/filter.ts
 function matchesExport(exp, criteria) {
   if (criteria.kinds && criteria.kinds.length > 0) {
@@ -1304,10 +1943,10 @@ function filterSpec(spec, criteria) {
   };
 }
 // src/primitives/get.ts
-import ts12 from "typescript";
+import ts13 from "typescript";
 
 // src/ast/utils.ts
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 import ts from "typescript";
 var INLINE_TAG_RE = /(^|[^\\])\{@([a-zA-Z][a-zA-Z0-9]*)((?:[^}\\]|\\.)*)\}/g;
 function parseInlineTags(...texts) {
@@ -1366,10 +2005,8 @@ function parseExamplesFromTags(tags) {
 function stripParamSeparator(text) {
   if (!text)
     return;
-  let stripped = text.replace(/^-\s*/, "").trim();
-  const parts = stripped.split(/\n\s*\n/);
-  stripped = parts[0].trim();
-  return stripped || undefined;
+  const stripped = text.replace(/^-\s*/, "").trim();
+  return splitCommentLevelTags(stripped).retained.trim() || undefined;
 }
 function stripTypeParamSeparator(text) {
   if (!text)
@@ -1391,6 +2028,7 @@ function extractSeeTagText(tag) {
   if (seeMatch) {
     let text = seeMatch[1].trim();
     text = text.replace(/\s*\*\s*$/gm, "").trim();
+    text = text.replace(/^[ \t]*\*[ \t]?/gm, "").trim();
     if (text)
       return text;
   }
@@ -1494,8 +2132,8 @@ function getJSDocComment(node, symbol, checker) {
 }
 function getSourceLocation(node, sourceFile) {
   const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-  const relative2 = path2.relative(process.cwd(), sourceFile.fileName);
-  const file = relative2.startsWith("..") ? sourceFile.fileName : relative2;
+  const relative3 = path3.relative(process.cwd(), sourceFile.fileName);
+  const file = relative3.startsWith("..") ? sourceFile.fileName : relative3;
   return {
     file,
     line: line + 1
@@ -1667,8 +2305,8 @@ function getExportKind(declaration, type) {
 }
 
 // src/compiler/program.ts
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
 import ts2 from "typescript";
 function isJsFile(file) {
   return /\.(js|mjs|cjs|jsx)$/.test(file);
@@ -1684,48 +2322,48 @@ function getScriptKind(file) {
 }
 var DEFAULT_COMPILER_OPTIONS = {
   target: ts2.ScriptTarget.Latest,
-  module: ts2.ModuleKind.CommonJS,
+  module: ts2.ModuleKind.NodeNext,
   lib: ["lib.es2021.d.ts"],
   declaration: true,
-  moduleResolution: ts2.ModuleResolutionKind.NodeJs,
+  moduleResolution: ts2.ModuleResolutionKind.NodeNext,
   strict: true
 };
 function resolveWorkspaceEntry(pkgDir) {
   const candidates = [
-    path3.join(pkgDir, "src", "index.ts"),
-    path3.join(pkgDir, "src", "index.tsx"),
-    path3.join(pkgDir, "index.ts")
+    path4.join(pkgDir, "src", "index.ts"),
+    path4.join(pkgDir, "src", "index.tsx"),
+    path4.join(pkgDir, "index.ts")
   ];
   try {
-    const pkg = JSON.parse(fs3.readFileSync(path3.join(pkgDir, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs4.readFileSync(path4.join(pkgDir, "package.json"), "utf-8"));
     for (const field of [pkg.types, pkg.typings]) {
       if (typeof field === "string") {
-        candidates.push(path3.resolve(pkgDir, field));
+        candidates.push(path4.resolve(pkgDir, field));
       }
     }
   } catch {}
-  return candidates.find((c) => fs3.existsSync(c));
+  return candidates.find((c) => fs4.existsSync(c));
 }
 function resolveProjectReferences(configPath, parsedConfig) {
   const additionalFiles = [];
   if (!parsedConfig.projectReferences?.length) {
     return additionalFiles;
   }
-  const configDir = path3.dirname(configPath);
+  const configDir = path4.dirname(configPath);
   for (const ref of parsedConfig.projectReferences) {
-    const refPath = path3.resolve(configDir, ref.path);
-    const refConfigPath = fs3.existsSync(path3.join(refPath, "tsconfig.json")) ? path3.join(refPath, "tsconfig.json") : refPath;
-    if (!fs3.existsSync(refConfigPath))
+    const refPath = path4.resolve(configDir, ref.path);
+    const refConfigPath = fs4.existsSync(path4.join(refPath, "tsconfig.json")) ? path4.join(refPath, "tsconfig.json") : refPath;
+    if (!fs4.existsSync(refConfigPath))
       continue;
     const refConfigFile = ts2.readConfigFile(refConfigPath, ts2.sys.readFile);
     if (refConfigFile.error)
       continue;
-    const refParsed = ts2.parseJsonConfigFileContent(refConfigFile.config, ts2.sys, path3.dirname(refConfigPath));
+    const refParsed = ts2.parseJsonConfigFileContent(refConfigFile.config, ts2.sys, path4.dirname(refConfigPath));
     additionalFiles.push(...refParsed.fileNames);
   }
   return additionalFiles;
 }
-function parsePnpmWorkspace(yamlContent) {
+function parsePnpmWorkspace2(yamlContent) {
   const globs = [];
   const lines = yamlContent.split(`
 `);
@@ -1751,52 +2389,52 @@ function parsePnpmWorkspace(yamlContent) {
 function buildWorkspaceMap(baseDir) {
   let currentDir = baseDir;
   let rootDir;
-  let workspaceGlobs = [];
+  let workspaceGlobs2 = [];
   for (let i = 0;i < 10; i++) {
-    const pnpmPath = path3.join(currentDir, "pnpm-workspace.yaml");
-    if (fs3.existsSync(pnpmPath)) {
+    const pnpmPath = path4.join(currentDir, "pnpm-workspace.yaml");
+    if (fs4.existsSync(pnpmPath)) {
       try {
-        const yamlContent = fs3.readFileSync(pnpmPath, "utf-8");
-        workspaceGlobs = parsePnpmWorkspace(yamlContent);
-        if (workspaceGlobs.length > 0) {
+        const yamlContent = fs4.readFileSync(pnpmPath, "utf-8");
+        workspaceGlobs2 = parsePnpmWorkspace2(yamlContent);
+        if (workspaceGlobs2.length > 0) {
           rootDir = currentDir;
           break;
         }
       } catch {}
     }
-    const pkgPath = path3.join(currentDir, "package.json");
-    if (fs3.existsSync(pkgPath)) {
+    const pkgPath = path4.join(currentDir, "package.json");
+    if (fs4.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+        const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
         if (pkg.workspaces) {
           rootDir = currentDir;
-          workspaceGlobs = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages || [];
+          workspaceGlobs2 = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages || [];
           break;
         }
       } catch {}
     }
-    const parent = path3.dirname(currentDir);
+    const parent = path4.dirname(currentDir);
     if (parent === currentDir)
       break;
     currentDir = parent;
   }
-  if (!rootDir || workspaceGlobs.length === 0)
+  if (!rootDir || workspaceGlobs2.length === 0)
     return;
   const packages = new Map;
-  for (const glob of workspaceGlobs) {
-    const globDir = path3.join(rootDir, glob.replace(/\/\*$/, ""));
-    if (!fs3.existsSync(globDir) || !fs3.statSync(globDir).isDirectory())
+  for (const glob of workspaceGlobs2) {
+    const globDir = path4.join(rootDir, glob.replace(/\/\*$/, ""));
+    if (!fs4.existsSync(globDir) || !fs4.statSync(globDir).isDirectory())
       continue;
-    const entries = fs3.readdirSync(globDir, { withFileTypes: true });
+    const entries = fs4.readdirSync(globDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const pkgDir = path3.join(globDir, entry.name);
-      const pkgJsonPath = path3.join(pkgDir, "package.json");
-      if (!fs3.existsSync(pkgJsonPath))
+      const pkgDir = path4.join(globDir, entry.name);
+      const pkgJsonPath = path4.join(pkgDir, "package.json");
+      if (!fs4.existsSync(pkgJsonPath))
         continue;
       try {
-        const pkg = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
+        const pkg = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
         if (pkg.name) {
           packages.set(pkg.name, pkgDir);
         }
@@ -1805,10 +2443,35 @@ function buildWorkspaceMap(baseDir) {
   }
   return packages.size > 0 ? { packages, rootDir } : undefined;
 }
+function discoverAmbientTypePackages(baseDir) {
+  const found = [];
+  const seen = new Set;
+  let currentDir = baseDir;
+  for (let i = 0;i < 10; i++) {
+    const typesDir = path4.join(currentDir, "node_modules", "@types");
+    try {
+      if (fs4.existsSync(typesDir) && fs4.statSync(typesDir).isDirectory()) {
+        for (const entry of fs4.readdirSync(typesDir, { withFileTypes: true })) {
+          if (!entry.isDirectory() || entry.name.startsWith("."))
+            continue;
+          if (seen.has(entry.name))
+            continue;
+          seen.add(entry.name);
+          found.push(entry.name);
+        }
+      }
+    } catch {}
+    const parent = path4.dirname(currentDir);
+    if (parent === currentDir)
+      break;
+    currentDir = parent;
+  }
+  return found;
+}
 function createProgram(options) {
   const { content } = options;
-  const entryFile = path3.resolve(options.entryFile);
-  const baseDir = path3.resolve(options.baseDir ?? path3.dirname(entryFile));
+  const entryFile = path4.resolve(options.entryFile);
+  const baseDir = path4.resolve(options.baseDir ?? path4.dirname(entryFile));
   let configPath = ts2.findConfigFile(baseDir, ts2.sys.fileExists, "tsconfig.json");
   if (!configPath) {
     configPath = ts2.findConfigFile(baseDir, ts2.sys.fileExists, "jsconfig.json");
@@ -1817,14 +2480,14 @@ function createProgram(options) {
   let additionalRootFiles = [];
   if (configPath) {
     const configFile = ts2.readConfigFile(configPath, ts2.sys.readFile);
-    const parsedConfig = ts2.parseJsonConfigFileContent(configFile.config, ts2.sys, path3.dirname(configPath));
+    const parsedConfig = ts2.parseJsonConfigFileContent(configFile.config, ts2.sys, path4.dirname(configPath));
     compilerOptions = { ...compilerOptions, ...parsedConfig.options };
     additionalRootFiles = resolveProjectReferences(configPath, parsedConfig);
     let sourceFiles = parsedConfig.fileNames.filter((f) => !f.includes(".test.") && !f.includes(".spec.") && !f.includes("/dist/") && !f.includes("/node_modules/"));
     if (/\.d\.[cm]?ts$/.test(entryFile)) {
       sourceFiles = sourceFiles.filter((f) => {
         try {
-          return !ts2.getOutputFileNames(parsedConfig, f, !ts2.sys.useCaseSensitiveFileNames).some((out) => path3.resolve(out) === entryFile);
+          return !ts2.getOutputFileNames(parsedConfig, f, !ts2.sys.useCaseSensitiveFileNames).some((out) => path4.resolve(out) === entryFile);
         } catch {
           return true;
         }
@@ -1845,6 +2508,12 @@ function createProgram(options) {
       compilerOptions = { ...compilerOptions, allowJs: false, checkJs: false };
     }
   }
+  if (compilerOptions.types === undefined && compilerOptions.typeRoots === undefined) {
+    const ambientTypes = discoverAmbientTypePackages(baseDir);
+    if (ambientTypes.length > 0) {
+      compilerOptions = { ...compilerOptions, types: ambientTypes };
+    }
+  }
   const workspaceMap = buildWorkspaceMap(baseDir);
   const compilerHost = ts2.createCompilerHost(compilerOptions, true);
   let inMemorySource;
@@ -1901,7 +2570,7 @@ import ts5 from "typescript";
 import ts4 from "typescript";
 
 // src/ast/type-identity.ts
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 import ts3 from "typescript";
 var NODE_MODULES_PKG = /node_modules\/(@[^/]+\/[^/]+|[^/]+)/;
 function packageLabel(fileName, workspacePackages) {
@@ -1909,7 +2578,7 @@ function packageLabel(fileName, workspacePackages) {
   let pkg = match?.[1];
   if (!pkg) {
     for (const [name, dir] of workspacePackages) {
-      if (fileName.startsWith(`${path4.resolve(dir)}${path4.sep}`)) {
+      if (fileName.startsWith(`${path5.resolve(dir)}${path5.sep}`)) {
         pkg = name;
         break;
       }
@@ -2317,6 +2986,14 @@ function isAnonymous(type) {
   const name = symbol.getName();
   return name.startsWith("__") || name === "";
 }
+function isFluentThisType(type) {
+  if (!(type.flags & ts4.TypeFlags.TypeParameter))
+    return false;
+  const declarations = type.getSymbol()?.declarations;
+  if (!declarations || declarations.length === 0)
+    return false;
+  return declarations.some((decl) => ts4.isClassDeclaration(decl) || ts4.isClassExpression(decl) || ts4.isInterfaceDeclaration(decl));
+}
 function withDepth(ctx, fn) {
   ctx.currentDepth++;
   try {
@@ -2352,7 +3029,7 @@ function buildSchema(type, checker, ctx) {
   return ensureNonEmptySchema(schema, type, checker);
 }
 function buildMaxDepthSchema(type, checker) {
-  if (type.flags & ts4.TypeFlags.TypeParameter && type.isThisType !== true) {
+  if (type.flags & ts4.TypeFlags.TypeParameter && !isFluentThisType(type)) {
     return { "x-ts-type": checker.typeToString(type) };
   }
   const symbol = type.getSymbol() || type.aliasSymbol;
@@ -2440,7 +3117,7 @@ function buildSchemaInternal(type, checker, ctx) {
       return { type: "bigint" };
     if (type.flags & ts4.TypeFlags.ESSymbol)
       return { type: "symbol" };
-    if (type.isThisType === true) {
+    if (isFluentThisType(type)) {
       const constraint = type.getConstraint?.();
       const symbol2 = constraint?.getSymbol() ?? type.getSymbol();
       if (symbol2 && !isAnonymous(type)) {
@@ -4501,12 +5178,13 @@ function serializeResolvedMembers(type, node, ctx) {
 }
 
 // src/schema/registry.ts
+import ts12 from "typescript";
 function isTypeReference(type) {
-  return !!(type.flags & 524288 && type.objectFlags && type.objectFlags & 4);
+  return !!(type.flags & ts12.TypeFlags.Object && type.objectFlags && type.objectFlags & ts12.ObjectFlags.Reference);
 }
 function getNonNullableType(type) {
   if (type.isUnion()) {
-    const nonNullable = type.types.filter((t) => !(t.flags & 32768) && !(t.flags & 65536));
+    const nonNullable = type.types.filter((t) => !(t.flags & ts12.TypeFlags.Undefined) && !(t.flags & ts12.TypeFlags.Null));
     if (nonNullable.length === 1) {
       return nonNullable[0];
     }
@@ -5262,7 +5940,7 @@ async function getExport(options) {
   ctx.exportedIds = exportedIds;
   try {
     const originalDecls = targetSymbol.declarations ?? [];
-    const isNamespaceExportDecl = originalDecls.some((d) => ts12.isNamespaceExport(d) || ts12.isNamespaceImport(d));
+    const isNamespaceExportDecl = originalDecls.some((d) => ts13.isNamespaceExport(d) || ts13.isNamespaceImport(d));
     if (isNamespaceExportDecl) {
       const spec2 = serializeNamespaceForGet(targetSymbol, exportName, ctx);
       const types2 = ctx.typeRegistry.getAll().map((t) => normalizeType(t));
@@ -5313,42 +5991,42 @@ function resolveExportTarget(symbol, checker) {
   let isTypeOnly = false;
   const declarations = symbol.declarations ?? [];
   for (const decl of declarations) {
-    if (ts12.isExportSpecifier(decl)) {
+    if (ts13.isExportSpecifier(decl)) {
       if (decl.isTypeOnly)
         isTypeOnly = true;
       const exportDecl = decl.parent?.parent;
-      if (exportDecl && ts12.isExportDeclaration(exportDecl) && exportDecl.isTypeOnly) {
+      if (exportDecl && ts13.isExportDeclaration(exportDecl) && exportDecl.isTypeOnly) {
         isTypeOnly = true;
       }
     }
   }
-  if (symbol.flags & ts12.SymbolFlags.Alias) {
+  if (symbol.flags & ts13.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       resolvedSymbol = aliased;
     }
   }
   const targetDeclarations = resolvedSymbol.declarations ?? [];
-  const declaration = resolvedSymbol.valueDeclaration || targetDeclarations.find((d) => d.kind !== ts12.SyntaxKind.ExportSpecifier) || targetDeclarations[0];
+  const declaration = resolvedSymbol.valueDeclaration || targetDeclarations.find((d) => d.kind !== ts13.SyntaxKind.ExportSpecifier) || targetDeclarations[0];
   return { declaration, resolvedSymbol, isTypeOnly };
 }
 function serializeDeclaration(declaration, _exportSymbol, _targetSymbol, exportName, ctx, isTypeOnly) {
   let result = null;
-  if (ts12.isFunctionDeclaration(declaration)) {
+  if (ts13.isFunctionDeclaration(declaration)) {
     result = serializeFunctionExport(declaration, ctx);
-  } else if (ts12.isClassDeclaration(declaration)) {
+  } else if (ts13.isClassDeclaration(declaration)) {
     result = serializeClass(declaration, ctx);
-  } else if (ts12.isInterfaceDeclaration(declaration)) {
+  } else if (ts13.isInterfaceDeclaration(declaration)) {
     result = serializeInterface(declaration, ctx);
-  } else if (ts12.isTypeAliasDeclaration(declaration)) {
+  } else if (ts13.isTypeAliasDeclaration(declaration)) {
     result = serializeTypeAlias(declaration, ctx);
-  } else if (ts12.isEnumDeclaration(declaration)) {
+  } else if (ts13.isEnumDeclaration(declaration)) {
     result = serializeEnum(declaration, ctx);
-  } else if (ts12.isVariableDeclaration(declaration)) {
+  } else if (ts13.isVariableDeclaration(declaration)) {
     const varStatement = declaration.parent?.parent;
-    if (varStatement && ts12.isVariableStatement(varStatement)) {
-      if (declaration.initializer && (ts12.isArrowFunction(declaration.initializer) || ts12.isFunctionExpression(declaration.initializer))) {
-        const varName = ts12.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
+    if (varStatement && ts13.isVariableStatement(varStatement)) {
+      if (declaration.initializer && (ts13.isArrowFunction(declaration.initializer) || ts13.isFunctionExpression(declaration.initializer))) {
+        const varName = ts13.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
         result = serializeFunctionExport(declaration.initializer, ctx, varName);
       } else {
         const checker = ctx.program.getTypeChecker();
@@ -5362,7 +6040,7 @@ function serializeDeclaration(declaration, _exportSymbol, _targetSymbol, exportN
         }
       }
     }
-  } else if (ts12.isNamespaceExport(declaration) || ts12.isModuleDeclaration(declaration) || ts12.isNamespaceImport(declaration) || ts12.isSourceFile(declaration)) {
+  } else if (ts13.isNamespaceExport(declaration) || ts13.isModuleDeclaration(declaration) || ts13.isNamespaceImport(declaration) || ts13.isSourceFile(declaration)) {
     result = serializeNamespaceForGet(_exportSymbol, exportName, ctx);
   }
   if (result) {
@@ -5378,7 +6056,7 @@ function serializeDeclaration(declaration, _exportSymbol, _targetSymbol, exportN
 function serializeNamespaceForGet(symbol, exportName, ctx) {
   const checker = ctx.program.getTypeChecker();
   let targetSymbol = symbol;
-  if (symbol.flags & ts12.SymbolFlags.Alias) {
+  if (symbol.flags & ts13.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
@@ -5408,7 +6086,7 @@ function serializeNamespaceForGet(symbol, exportName, ctx) {
 }
 function detectExternalPackage(symbol, checker) {
   let targetSymbol = symbol;
-  if (symbol.flags & ts12.SymbolFlags.Alias) {
+  if (symbol.flags & ts13.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
@@ -5422,9 +6100,9 @@ function detectExternalPackage(symbol, checker) {
       if (match)
         return match[1];
     }
-    if (ts12.isExportSpecifier(decl)) {
+    if (ts13.isExportSpecifier(decl)) {
       const exportDecl = decl.parent?.parent;
-      if (exportDecl && ts12.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
+      if (exportDecl && ts13.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
         const moduleText = exportDecl.moduleSpecifier.text;
         if (!moduleText.startsWith(".") && !moduleText.startsWith("/")) {
           return moduleText;
@@ -5435,8 +6113,8 @@ function detectExternalPackage(symbol, checker) {
   return;
 }
 // src/primitives/list.ts
-import * as path5 from "node:path";
-import ts13 from "typescript";
+import * as path6 from "node:path";
+import ts14 from "typescript";
 async function listExports(options) {
   const { entryFile, baseDir, content } = options;
   const errors = [];
@@ -5479,16 +6157,16 @@ async function listExports(options) {
 }
 function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
   const name = symbol.getName();
-  const isReexport = !!(symbol.flags & ts13.SymbolFlags.Alias);
+  const isReexport = !!(symbol.flags & ts14.SymbolFlags.Alias);
   let targetSymbol = symbol;
-  if (symbol.flags & ts13.SymbolFlags.Alias) {
+  if (symbol.flags & ts14.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
     }
   }
   const declarations = targetSymbol.declarations ?? [];
-  const declaration = targetSymbol.valueDeclaration || declarations.find((d) => d.kind !== ts13.SyntaxKind.ExportSpecifier) || declarations[0];
+  const declaration = targetSymbol.valueDeclaration || declarations.find((d) => d.kind !== ts14.SyntaxKind.ExportSpecifier) || declarations[0];
   if (!declaration) {
     return {
       name,
@@ -5498,11 +6176,11 @@ function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
       reexport: true
     };
   }
-  if (ts13.isSourceFile(declaration)) {
+  if (ts14.isSourceFile(declaration)) {
     return {
       name,
       kind: "namespace",
-      file: path5.relative(path5.dirname(entryFile), declaration.fileName),
+      file: path6.relative(path6.dirname(entryFile), declaration.fileName),
       line: 1,
       reexport: true
     };
@@ -5516,7 +6194,7 @@ function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
   return {
     name,
     kind,
-    file: path5.relative(path5.dirname(entryFile), sourceFile.fileName),
+    file: path6.relative(path6.dirname(entryFile), sourceFile.fileName),
     line: line + 1,
     ...description ? { description } : {},
     ...deprecated ? { deprecated: true } : {},
@@ -5537,21 +6215,21 @@ function getDescriptionPreview(symbol, checker) {
   return `${firstLine.slice(0, 77)}...`;
 }
 // src/builder/spec-builder.ts
-import * as fs6 from "node:fs";
-import * as path9 from "node:path";
+import * as fs7 from "node:fs";
+import * as path10 from "node:path";
 import { SCHEMA_URL, SCHEMA_VERSION } from "@openpkg-ts/spec";
-import ts18 from "typescript";
+import ts19 from "typescript";
 
 // src/ast/resolve.ts
-import ts14 from "typescript";
+import ts15 from "typescript";
 function isTypeOnlyExport(symbol) {
   const declarations = symbol.declarations ?? [];
   for (const decl of declarations) {
-    if (ts14.isExportSpecifier(decl)) {
+    if (ts15.isExportSpecifier(decl)) {
       if (decl.isTypeOnly)
         return true;
       const exportDecl = decl.parent?.parent;
-      if (exportDecl && ts14.isExportDeclaration(exportDecl) && exportDecl.isTypeOnly) {
+      if (exportDecl && ts15.isExportDeclaration(exportDecl) && exportDecl.isTypeOnly) {
         return true;
       }
     }
@@ -5561,22 +6239,22 @@ function isTypeOnlyExport(symbol) {
 function resolveExportTarget2(symbol, checker) {
   let targetSymbol = symbol;
   const isTypeOnly = isTypeOnlyExport(symbol);
-  if (symbol.flags & ts14.SymbolFlags.Alias) {
+  if (symbol.flags & ts15.SymbolFlags.Alias) {
     const aliasTarget = checker.getAliasedSymbol(symbol);
     if (aliasTarget && aliasTarget !== symbol) {
       targetSymbol = aliasTarget;
     }
   }
   const declarations = targetSymbol.declarations ?? [];
-  const declaration = targetSymbol.valueDeclaration || declarations.find((decl) => decl.kind !== ts14.SyntaxKind.ExportSpecifier) || declarations[0];
+  const declaration = targetSymbol.valueDeclaration || declarations.find((decl) => decl.kind !== ts15.SyntaxKind.ExportSpecifier) || declarations[0];
   return { declaration, targetSymbol, isTypeOnly };
 }
 
 // src/schema/standard-schema.ts
-import { spawn, spawnSync } from "node:child_process";
-import * as fs4 from "node:fs";
-import * as os from "node:os";
-import * as path6 from "node:path";
+import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
+import * as fs5 from "node:fs";
+import * as os2 from "node:os";
+import * as path7 from "node:path";
 var MAX_BUFFER_SIZE = 10 * 1024 * 1024;
 function isStandardJSONSchema(obj) {
   if (typeof obj !== "object" || obj === null)
@@ -5598,7 +6276,7 @@ function isStandardJSONSchema(obj) {
 var cachedRuntime;
 function commandExists(cmd) {
   try {
-    const result = spawnSync(process.platform === "win32" ? "where" : "which", [cmd], {
+    const result = spawnSync2(process.platform === "win32" ? "where" : "which", [cmd], {
       stdio: "ignore"
     });
     return result.status === 0;
@@ -5830,21 +6508,21 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
     result.errors.push("No TypeScript runtime available. Install bun, tsx, or ts-node, or use Node 22+.");
     return result;
   }
-  if (!fs4.existsSync(tsFilePath)) {
+  if (!fs5.existsSync(tsFilePath)) {
     result.errors.push(`TypeScript file not found: ${tsFilePath}`);
     return result;
   }
-  const tempDir = os.tmpdir();
-  const workerPath = path6.join(tempDir, `openpkg-extract-worker-${Date.now()}.ts`);
+  const tempDir = os2.tmpdir();
+  const workerPath = path7.join(tempDir, `openpkg-extract-worker-${Date.now()}.ts`);
   try {
-    fs4.writeFileSync(workerPath, TS_WORKER_SCRIPT);
+    fs5.writeFileSync(workerPath, TS_WORKER_SCRIPT);
     const optionsJson = JSON.stringify({ target, libraryOptions });
     const args = [...runtime.args, workerPath, tsFilePath, optionsJson];
-    return await new Promise((resolve3) => {
-      const child = spawn(runtime.cmd, args, {
+    return await new Promise((resolve4) => {
+      const child = spawn2(runtime.cmd, args, {
         timeout,
         stdio: ["ignore", "pipe", "pipe"],
-        cwd: path6.dirname(tsFilePath)
+        cwd: path7.dirname(tsFilePath)
       });
       let stdout = "";
       let stderr = "";
@@ -5868,7 +6546,7 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
       });
       child.on("close", (code) => {
         try {
-          fs4.unlinkSync(workerPath);
+          fs5.unlinkSync(workerPath);
         } catch (cleanupErr) {
           if (cleanupErr?.code !== "ENOENT") {
             result.warnings.push({ code: "CLEANUP_FAILED", message: String(cleanupErr) });
@@ -5876,14 +6554,14 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
         }
         if (code !== 0) {
           result.errors.push(`Extraction failed (${runtime.name}): ${stderr || `exit code ${code}`}`);
-          resolve3(result);
+          resolve4(result);
           return;
         }
         try {
           const parsed = JSON.parse(stdout);
           if (!parsed.success) {
             result.errors.push(`Extraction failed: ${parsed.error}`);
-            resolve3(result);
+            resolve4(result);
             return;
           }
           for (const item of parsed.results) {
@@ -5918,23 +6596,23 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
             message: "stderr exceeded 10MB buffer limit"
           });
         }
-        resolve3(result);
+        resolve4(result);
       });
       child.on("error", (err) => {
         try {
-          fs4.unlinkSync(workerPath);
+          fs5.unlinkSync(workerPath);
         } catch (cleanupErr) {
           if (cleanupErr?.code !== "ENOENT") {
             result.warnings.push({ code: "CLEANUP_FAILED", message: String(cleanupErr) });
           }
         }
         result.errors.push(`Subprocess error: ${err.message}`);
-        resolve3(result);
+        resolve4(result);
       });
     });
   } catch (e) {
     try {
-      fs4.unlinkSync(workerPath);
+      fs5.unlinkSync(workerPath);
     } catch (cleanupErr) {
       if (cleanupErr?.code !== "ENOENT") {
         result.warnings.push({ code: "CLEANUP_FAILED", message: String(cleanupErr) });
@@ -5945,12 +6623,12 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
   }
 }
 function readTsconfigOutDir(baseDir) {
-  const tsconfigPath = path6.join(baseDir, "tsconfig.json");
+  const tsconfigPath = path7.join(baseDir, "tsconfig.json");
   try {
-    if (!fs4.existsSync(tsconfigPath)) {
+    if (!fs5.existsSync(tsconfigPath)) {
       return null;
     }
-    const content = fs4.readFileSync(tsconfigPath, "utf-8");
+    const content = fs5.readFileSync(tsconfigPath, "utf-8");
     const stripped = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
     const tsconfig = JSON.parse(stripped);
     if (tsconfig.compilerOptions?.outDir) {
@@ -5960,7 +6638,7 @@ function readTsconfigOutDir(baseDir) {
   return null;
 }
 function resolveCompiledPath(tsPath, baseDir) {
-  const relativePath = path6.relative(baseDir, tsPath);
+  const relativePath = path7.relative(baseDir, tsPath);
   const withoutExt = relativePath.replace(/\.tsx?$/, "");
   const srcPrefix = withoutExt.replace(/^src\//, "");
   const tsconfigOutDir = readTsconfigOutDir(baseDir);
@@ -5968,7 +6646,7 @@ function resolveCompiledPath(tsPath, baseDir) {
   const candidates = [];
   if (tsconfigOutDir) {
     for (const ext of extensions) {
-      candidates.push(path6.join(baseDir, tsconfigOutDir, `${srcPrefix}${ext}`));
+      candidates.push(path7.join(baseDir, tsconfigOutDir, `${srcPrefix}${ext}`));
     }
   }
   const commonOutDirs = ["dist", "build", "lib", "out"];
@@ -5976,21 +6654,21 @@ function resolveCompiledPath(tsPath, baseDir) {
     if (outDir === tsconfigOutDir)
       continue;
     for (const ext of extensions) {
-      candidates.push(path6.join(baseDir, outDir, `${srcPrefix}${ext}`));
+      candidates.push(path7.join(baseDir, outDir, `${srcPrefix}${ext}`));
     }
   }
   for (const ext of extensions) {
-    candidates.push(path6.join(baseDir, `${withoutExt}${ext}`));
+    candidates.push(path7.join(baseDir, `${withoutExt}${ext}`));
   }
   const workspaceMatch = baseDir.match(/^(.+\/packages\/[^/]+)$/);
   if (workspaceMatch) {
     const pkgRoot = workspaceMatch[1];
     for (const ext of extensions) {
-      candidates.push(path6.join(pkgRoot, "dist", `${srcPrefix}${ext}`));
+      candidates.push(path7.join(pkgRoot, "dist", `${srcPrefix}${ext}`));
     }
   }
   for (const candidate of candidates) {
-    if (fs4.existsSync(candidate)) {
+    if (fs5.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -6003,13 +6681,13 @@ async function extractStandardSchemas(compiledJsPath, options = {}) {
     errors: [],
     warnings: []
   };
-  if (!fs4.existsSync(compiledJsPath)) {
+  if (!fs5.existsSync(compiledJsPath)) {
     result.errors.push(`Compiled JS not found: ${compiledJsPath}`);
     return result;
   }
   const optionsJson = JSON.stringify({ target, libraryOptions });
-  return new Promise((resolve3) => {
-    const child = spawn("node", ["-e", WORKER_SCRIPT, compiledJsPath, optionsJson], {
+  return new Promise((resolve4) => {
+    const child = spawn2("node", ["-e", WORKER_SCRIPT, compiledJsPath, optionsJson], {
       timeout,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -6036,14 +6714,14 @@ async function extractStandardSchemas(compiledJsPath, options = {}) {
     child.on("close", (code) => {
       if (code !== 0) {
         result.errors.push(`Extraction process failed: ${stderr || `exit code ${code}`}`);
-        resolve3(result);
+        resolve4(result);
         return;
       }
       try {
         const parsed = JSON.parse(stdout);
         if (!parsed.success) {
           result.errors.push(`Extraction failed: ${parsed.error}`);
-          resolve3(result);
+          resolve4(result);
           return;
         }
         for (const item of parsed.results) {
@@ -6078,11 +6756,11 @@ async function extractStandardSchemas(compiledJsPath, options = {}) {
           message: "stderr exceeded 10MB buffer limit"
         });
       }
-      resolve3(result);
+      resolve4(result);
     });
     child.on("error", (err) => {
       result.errors.push(`Subprocess error: ${err.message}`);
-      resolve3(result);
+      resolve4(result);
     });
   });
 }
@@ -6119,10 +6797,10 @@ async function extractStandardSchemasFromProject(entryFile, baseDir, options = {
 }
 
 // src/builder/external-resolver.ts
-import * as fs5 from "node:fs";
-import * as path7 from "node:path";
+import * as fs6 from "node:fs";
+import * as path8 from "node:path";
 import picomatch from "picomatch";
-import ts15 from "typescript";
+import ts16 from "typescript";
 function matchesExternalPattern(packageName, include, exclude) {
   if (!include?.length)
     return false;
@@ -6138,7 +6816,7 @@ function matchesExternalPattern(packageName, include, exclude) {
   return true;
 }
 function resolveExternalModule(moduleSpecifier, containingFile, compilerOptions) {
-  const resolved = ts15.resolveModuleName(moduleSpecifier, containingFile, compilerOptions, ts15.sys);
+  const resolved = ts16.resolveModuleName(moduleSpecifier, containingFile, compilerOptions, ts16.sys);
   if (!resolved.resolvedModule) {
     return null;
   }
@@ -6154,20 +6832,20 @@ function findPackageJson(resolvedPath, packageName) {
   const isScoped = packageName.startsWith("@");
   const packageParts = isScoped ? packageName.split("/").slice(0, 2) : [packageName.split("/")[0]];
   const packageDir = packageParts.join("/");
-  let dir = path7.dirname(resolvedPath);
+  let dir = path8.dirname(resolvedPath);
   const maxDepth = 10;
   for (let i = 0;i < maxDepth; i++) {
     if (dir.endsWith(`node_modules/${packageDir}`)) {
-      const pkgPath = path7.join(dir, "package.json");
-      if (fs5.existsSync(pkgPath)) {
+      const pkgPath = path8.join(dir, "package.json");
+      if (fs6.existsSync(pkgPath)) {
         try {
-          return JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+          return JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
         } catch {
           return;
         }
       }
     }
-    const parent = path7.dirname(dir);
+    const parent = path8.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -6203,7 +6881,7 @@ function extractExternalExport(exportName, resolvedModule, program, ctx, visited
     return null;
   }
   let resolvedSymbol = targetExport;
-  if (targetExport.flags & ts15.SymbolFlags.Alias) {
+  if (targetExport.flags & ts16.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(targetExport);
     if (aliased && aliased !== targetExport) {
       resolvedSymbol = aliased;
@@ -6245,6 +6923,80 @@ function extractExternalExport(exportName, resolvedModule, program, ctx, visited
   return specExport;
 }
 
+// src/builder/jev-extract.ts
+var FOLLOW_SCORE_LEVELS = [
+  "opaque — a stub is enough",
+  "useful — expanding helps",
+  "essential — needed to understand the public API"
+];
+var AMBIGUOUS_CODES = new Set([
+  "FORGOTTEN_EXPORT",
+  "SERIALIZATION_FAILED",
+  "RUNTIME_SCHEMA_ERROR"
+]);
+async function selectFollowExternal(refs, evaluate) {
+  const sliced = refs.slice(0, MAX_JEV_QUESTIONS);
+  if (!sliced.length)
+    return [];
+  const questions = {};
+  for (const [i, ref] of sliced.entries()) {
+    questions[`t${i}`] = {
+      type: "score",
+      instructions: `How load-bearing is ${ref.typeName} from ${ref.package} for understanding this public TypeScript API?`,
+      criteria: FOLLOW_SCORE_LEVELS
+    };
+  }
+  const result = await jevEvaluate(evaluate, {
+    types: sliced,
+    task: "OpenPkg extracts a public TS API. Stub opaque externals; expand load-bearing ones."
+  }, questions);
+  const follow = new Set;
+  for (const [i, ref] of sliced.entries()) {
+    const id = `t${i}`;
+    const score = result.answers[id]?.score;
+    if (typeof score !== "number")
+      continue;
+    const conf = namedConfidence(result, id) ?? (score >= 1.5 || score <= 0.5 ? 1 : 0);
+    if (score >= 1.5 || score >= 1 && conf >= JEV_CONFIDENCE)
+      follow.add(ref.package);
+  }
+  return [...follow];
+}
+async function calibrateDiagnostics(diagnostics, evaluate) {
+  const targets = diagnostics.map((d, index) => ({ d, index })).filter(({ d }) => d.code && AMBIGUOUS_CODES.has(d.code)).slice(0, MAX_JEV_QUESTIONS);
+  if (targets.length < 1)
+    return;
+  const questions = {};
+  for (const [i, { d }] of targets.entries()) {
+    questions[`d${i}`] = {
+      type: "choice",
+      instructions: `What severity should this extraction diagnostic have? ${d.message}`,
+      criteria: {
+        error: "Blocks a correct spec",
+        warning: "Likely a real API gap",
+        info: "Informational only"
+      }
+    };
+  }
+  const result = await jevEvaluate(evaluate, {
+    diagnostics: targets.map(({ d }) => ({
+      code: d.code,
+      message: d.message,
+      severity: d.severity
+    }))
+  }, questions);
+  for (const [i, { d }] of targets.entries()) {
+    const id = `d${i}`;
+    const choice = result.answers[id]?.choice;
+    if (choice !== "error" && choice !== "warning" && choice !== "info")
+      continue;
+    const conf = namedConfidence(result, id) ?? result.answers[id]?.probabilities?.[choice] ?? 0;
+    if (conf < JEV_CONFIDENCE)
+      continue;
+    d.severity = choice;
+  }
+}
+
 // src/builder/schema-merger.ts
 function mergeRuntimeSchemas(staticExports, runtimeSchemas) {
   let merged = 0;
@@ -6274,7 +7026,7 @@ function mergeRuntimeSchemas(staticExports, runtimeSchemas) {
 }
 
 // src/builder/type-cache.ts
-import ts16 from "typescript";
+import ts17 from "typescript";
 
 // src/utils/cache-manager.ts
 class CacheManager {
@@ -6381,10 +7133,10 @@ function findTypeDefinition(typeName, program, sourceFile) {
   return typeDefinitionCache.getOrCompute(typeName, () => {
     const checker = program.getTypeChecker();
     const findInNode = (node) => {
-      if ((ts16.isInterfaceDeclaration(node) || ts16.isTypeAliasDeclaration(node) || ts16.isClassDeclaration(node) || ts16.isEnumDeclaration(node)) && node.name?.text === typeName) {
+      if ((ts17.isInterfaceDeclaration(node) || ts17.isTypeAliasDeclaration(node) || ts17.isClassDeclaration(node) || ts17.isEnumDeclaration(node)) && node.name?.text === typeName) {
         return node.getSourceFile().fileName;
       }
-      return ts16.forEachChild(node, findInNode);
+      return ts17.forEachChild(node, findInNode);
     };
     const entryResult = findInNode(sourceFile);
     if (entryResult)
@@ -6396,14 +7148,14 @@ function findTypeDefinition(typeName, program, sourceFile) {
           return result;
       }
     }
-    const symbol = checker.resolveName(typeName, sourceFile, ts16.SymbolFlags.Type, false);
+    const symbol = checker.resolveName(typeName, sourceFile, ts17.SymbolFlags.Type, false);
     return symbol?.declarations?.[0]?.getSourceFile().fileName;
   });
 }
 function hasInternalTag(typeName, program, sourceFile) {
   return internalTagCache.getOrCompute(typeName, () => {
     const checker = program.getTypeChecker();
-    const symbol = checker.resolveName(typeName, sourceFile, ts16.SymbolFlags.Type, false);
+    const symbol = checker.resolveName(typeName, sourceFile, ts17.SymbolFlags.Type, false);
     if (!symbol)
       return false;
     return symbol.getJsDocTags().some((tag) => tag.name === "internal");
@@ -6411,7 +7163,7 @@ function hasInternalTag(typeName, program, sourceFile) {
 }
 
 // src/builder/type-expansion.ts
-import ts17 from "typescript";
+import ts18 from "typescript";
 var NODE_MODULES_PKG2 = /node_modules\/(@[^/]+\/[^/]+|[^/]+)/;
 function isLibFile(fileName) {
   return fileName.includes("/typescript/lib/lib.") || fileName.includes("\\typescript\\lib\\lib.");
@@ -6428,8 +7180,9 @@ function createExternalExpansionPredicate(opts) {
       return false;
     if (opts.followExternal === true)
       return true;
-    if (Array.isArray(opts.followExternal) && opts.followExternal.some((e) => matchesEntry(e, pkg)))
+    if (Array.isArray(opts.followExternal) && opts.followExternal.some((e) => matchesEntry(e, pkg))) {
       return true;
+    }
     return opts.workspacePackages.has(pkg);
   };
   return (symbol) => {
@@ -6445,6 +7198,66 @@ function createExternalExpansionPredicate(opts) {
     return true;
   };
 }
+function collectReferencedExternals(exportedSymbols, checker, workspacePackages) {
+  const out = [];
+  const seen = new Set;
+  const visited = new Set;
+  const consider = (symbol) => {
+    if (!symbol)
+      return;
+    const decl = symbol.declarations?.[0];
+    if (!decl)
+      return;
+    const fileName = decl.getSourceFile().fileName;
+    if (isLibFile(fileName))
+      return;
+    const match = fileName.match(NODE_MODULES_PKG2);
+    if (!match)
+      return;
+    const pkg = match[1];
+    if (pkg === "typescript" || workspacePackages.has(pkg))
+      return;
+    const typeName = symbol.getName();
+    if (typeName.startsWith("__"))
+      return;
+    const key = `${pkg}:${typeName}`;
+    if (seen.has(key))
+      return;
+    seen.add(key);
+    out.push({ typeName, package: pkg });
+  };
+  const visit = (type, depth) => {
+    if (!type || depth > 20 || visited.has(type))
+      return;
+    visited.add(type);
+    const symbol = type.aliasSymbol ?? type.getSymbol();
+    consider(symbol);
+    const match = symbol?.declarations?.[0]?.getSourceFile().fileName.match(NODE_MODULES_PKG2);
+    if (match && !workspacePackages.has(match[1]))
+      return;
+    for (const arg of type.aliasTypeArguments ?? [])
+      visit(arg, depth + 1);
+    const typeRef = type;
+    if (typeRef.target) {
+      for (const arg of checker.getTypeArguments(typeRef) ?? [])
+        visit(arg, depth + 1);
+    }
+    if (type.isUnion() || type.isIntersection()) {
+      for (const t of type.types)
+        visit(t, depth + 1);
+    }
+    for (const sig of [...type.getCallSignatures(), ...type.getConstructSignatures()]) {
+      for (const param of sig.getParameters())
+        visit(checker.getTypeOfSymbol(param), depth + 1);
+      visit(sig.getReturnType(), depth + 1);
+    }
+  };
+  for (const symbol of exportedSymbols) {
+    visit(checker.getTypeOfSymbol(symbol), 0);
+    visit(checker.getDeclaredTypeOfSymbol(symbol), 0);
+  }
+  return out;
+}
 function expandReachableTypes(exportedSymbols, ctx, opts) {
   if (opts.followExternal === false)
     return;
@@ -6480,7 +7293,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
         visit(t, depth + 1);
       }
     }
-    if (!allowed || !(type.flags & ts17.TypeFlags.Object || type.isClassOrInterface())) {
+    if (!allowed || !(type.flags & ts18.TypeFlags.Object || type.isClassOrInterface())) {
       return;
     }
     if (type.isClassOrInterface()) {
@@ -6503,19 +7316,19 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
       visit(info.type, depth + 1);
     }
   };
-  const TYPE_SYMBOL_FLAGS = ts17.SymbolFlags.Interface | ts17.SymbolFlags.TypeAlias | ts17.SymbolFlags.Class | ts17.SymbolFlags.RegularEnum | ts17.SymbolFlags.ConstEnum;
+  const TYPE_SYMBOL_FLAGS = ts18.SymbolFlags.Interface | ts18.SymbolFlags.TypeAlias | ts18.SymbolFlags.Class | ts18.SymbolFlags.RegularEnum | ts18.SymbolFlags.ConstEnum;
   const visitedSymbols = new Set;
   const symbolKind = (symbol) => {
-    if (symbol.flags & ts17.SymbolFlags.Interface)
+    if (symbol.flags & ts18.SymbolFlags.Interface)
       return "interface";
-    if (symbol.flags & ts17.SymbolFlags.Class)
+    if (symbol.flags & ts18.SymbolFlags.Class)
       return "class";
-    if (symbol.flags & (ts17.SymbolFlags.RegularEnum | ts17.SymbolFlags.ConstEnum))
+    if (symbol.flags & (ts18.SymbolFlags.RegularEnum | ts18.SymbolFlags.ConstEnum))
       return "enum";
     return "type";
   };
   const resolveAlias = (symbol) => {
-    if (symbol.flags & ts17.SymbolFlags.Alias) {
+    if (symbol.flags & ts18.SymbolFlags.Alias) {
       try {
         return checker.getAliasedSymbol(symbol);
       } catch {
@@ -6567,7 +7380,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
     const target = symbol && resolveAlias(symbol);
     if (!target || visitedSymbols.has(target))
       return;
-    if (!(target.flags & (ts17.SymbolFlags.ValueModule | ts17.SymbolFlags.NamespaceModule)))
+    if (!(target.flags & (ts18.SymbolFlags.ValueModule | ts18.SymbolFlags.NamespaceModule)))
       return;
     if (!symbolAllowed(target))
       return;
@@ -6582,22 +7395,22 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
     }
   };
   const walkNode = (node) => {
-    if (ts17.isTypeReferenceNode(node)) {
+    if (ts18.isTypeReferenceNode(node)) {
       handleRef(node.typeName);
-      if (ts17.isQualifiedName(node.typeName)) {
+      if (ts18.isQualifiedName(node.typeName)) {
         handleNamespaceRef(node.typeName.left);
       }
-    } else if (ts17.isExpressionWithTypeArguments(node)) {
+    } else if (ts18.isExpressionWithTypeArguments(node)) {
       handleRef(node.expression);
-    } else if (ts17.isTypeQueryNode(node)) {
+    } else if (ts18.isTypeQueryNode(node)) {
       handleRef(node.exprName);
-      if (ts17.isQualifiedName(node.exprName)) {
+      if (ts18.isQualifiedName(node.exprName)) {
         handleRef(node.exprName.left);
         handleNamespaceRef(node.exprName.left);
       }
-    } else if (ts17.isImportTypeNode(node) && node.qualifier) {
+    } else if (ts18.isImportTypeNode(node) && node.qualifier) {
       handleRef(node.qualifier);
-      if (ts17.isQualifiedName(node.qualifier)) {
+      if (ts18.isQualifiedName(node.qualifier)) {
         handleNamespaceRef(node.qualifier.left);
       }
     }
@@ -6613,7 +7426,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
   };
   for (const exportSymbol of exportedSymbols) {
     let target = exportSymbol;
-    if (exportSymbol.flags & ts17.SymbolFlags.Alias) {
+    if (exportSymbol.flags & ts18.SymbolFlags.Alias) {
       try {
         target = checker.getAliasedSymbol(exportSymbol);
       } catch {
@@ -6632,7 +7445,7 @@ function expandReachableTypes(exportedSymbols, ctx, opts) {
 }
 
 // src/builder/verification.ts
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 var BUILTIN_TYPES2 = new Set([
   "Array",
   "ArrayBuffer",
@@ -6721,8 +7534,8 @@ function isExternalType2(definedIn, baseDir) {
     return true;
   if (definedIn.includes("node_modules"))
     return true;
-  const normalizedDefined = path8.resolve(definedIn);
-  const normalizedBase = path8.resolve(baseDir);
+  const normalizedDefined = path9.resolve(definedIn);
+  const normalizedBase = path9.resolve(baseDir);
   return !normalizedDefined.startsWith(normalizedBase);
 }
 function shouldSkipDanglingRef(name) {
@@ -6887,7 +7700,7 @@ async function extract(options) {
     const { program, sourceFile } = result;
     if (!sourceFile) {
       return {
-        spec: createEmptySpec(entryFile, includeSchema, isDtsSource),
+        spec: createEmptySpec(entryFile, includeSchema, isDtsSource, options.entryPointSource),
         diagnostics: [
           {
             message: `Entry file not found: ${entryFile}. Specify with: drift list src/index.ts`,
@@ -6900,7 +7713,7 @@ async function extract(options) {
     const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
     if (!moduleSymbol) {
       return {
-        spec: createEmptySpec(entryFile, includeSchema, isDtsSource),
+        spec: createEmptySpec(entryFile, includeSchema, isDtsSource, options.entryPointSource),
         diagnostics: [
           {
             message: `No exports found in ${entryFile}. Is this the right entry point?`,
@@ -6912,7 +7725,7 @@ async function extract(options) {
     const exportedSymbols = typeChecker.getExportsOfModule(moduleSymbol);
     if (exportedSymbols.length === 0) {
       return {
-        spec: createEmptySpec(entryFile, includeSchema, isDtsSource),
+        spec: createEmptySpec(entryFile, includeSchema, isDtsSource, options.entryPointSource),
         diagnostics: [
           {
             message: `No exports found in ${entryFile}. Is this the right entry point?`,
@@ -6936,6 +7749,36 @@ async function extract(options) {
         ...included ? {} : { skipReason: "filtered" }
       });
     }
+    let followExternal = options.followExternal;
+    let evaluate = options.evaluate;
+    const wantsJev = options.decisions === "jev" || followExternal === "auto";
+    if (wantsJev && !evaluate) {
+      if (process.env.AI_GATEWAY_API_KEY) {
+        try {
+          evaluate = await loadEvaluate();
+        } catch (err) {
+          diagnostics.push({
+            message: err instanceof Error ? err.message : String(err),
+            severity: "error",
+            code: "JEV_UNAVAILABLE"
+          });
+        }
+      } else if (followExternal === "auto") {
+        diagnostics.push({
+          message: "followExternal auto requires --jev and AI_GATEWAY_API_KEY",
+          severity: "error",
+          code: "JEV_UNAVAILABLE"
+        });
+      }
+    }
+    if (followExternal === "auto") {
+      if (!evaluate) {
+        followExternal = undefined;
+      } else {
+        const refs = collectReferencedExternals(exportedSymbols, typeChecker, result.workspacePackages ?? new Map);
+        followExternal = await selectFollowExternal(refs, evaluate);
+      }
+    }
     const ctx = createContext(program, sourceFile, {
       maxTypeDepth,
       maxExternalTypeDepth,
@@ -6944,7 +7787,7 @@ async function extract(options) {
       maxProperties,
       onTruncation,
       shouldExpandExternal: createExternalExpansionPredicate({
-        followExternal: options.followExternal,
+        followExternal,
         workspacePackages: result.workspacePackages ?? new Map
       }),
       workspacePackages: result.workspacePackages ?? new Map
@@ -6976,9 +7819,9 @@ async function extract(options) {
                 break;
               }
             }
-            if (ts18.isExportSpecifier(decl)) {
+            if (ts19.isExportSpecifier(decl)) {
               const exportDecl = decl.parent?.parent;
-              if (exportDecl && ts18.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
+              if (exportDecl && ts19.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
                 const moduleText = exportDecl.moduleSpecifier.getText().slice(1, -1);
                 if (!moduleText.startsWith(".") && !moduleText.startsWith("/")) {
                   externalPackage = moduleText;
@@ -7042,12 +7885,12 @@ async function extract(options) {
     const verification = buildVerificationSummary(exportedSymbols.length, exports.length, exportTracker);
     const meta = await getPackageMeta(entryFile, baseDir);
     expandReachableTypes(filteredSymbols, ctx, {
-      followExternal: options.followExternal,
+      followExternal,
       workspacePackages: result.workspacePackages ?? new Map,
       entryFile
     });
     {
-      const symFlags = ts18.SymbolFlags.Type | ts18.SymbolFlags.Interface | ts18.SymbolFlags.Class;
+      const symFlags = ts19.SymbolFlags.Type | ts19.SymbolFlags.Interface | ts19.SymbolFlags.Class;
       const maxPasses = 5;
       for (let pass = 0;pass < maxPasses; pass++) {
         const allRefs = new Map;
@@ -7082,7 +7925,7 @@ async function extract(options) {
       }
     }
     const types = ctx.typeRegistry.getAll();
-    const projectBaseDir = baseDir ?? path9.dirname(entryFile);
+    const projectBaseDir = baseDir ?? path10.dirname(entryFile);
     const definedTypes = new Set(types.map((t) => t.id));
     const forgottenExports = collectForgottenExports(exports, types, program, sourceFile, exportedIds, projectBaseDir, definedTypes);
     for (const forgotten of forgottenExports) {
@@ -7115,7 +7958,7 @@ async function extract(options) {
     }
     let runtimeMetadata;
     if (options.schemaExtraction === "hybrid") {
-      const projectBaseDir2 = baseDir || path9.dirname(entryFile);
+      const projectBaseDir2 = baseDir || path10.dirname(entryFile);
       const runtimeResult = await extractStandardSchemasFromProject(entryFile, projectBaseDir2, {
         target: "draft-2020-12",
         timeout: 15000
@@ -7160,6 +8003,7 @@ async function extract(options) {
         generator: "@openpkg-ts/sdk",
         timestamp: new Date().toISOString(),
         mode: isDtsSource ? "declaration-only" : "source",
+        ...generationEntry(entryFile, options.entryPointSource),
         ...options.schemaExtraction === "hybrid" ? { schemaExtraction: "hybrid" } : {},
         ...isDtsSource && {
           limitations: ["No JSDoc descriptions", "No @example tags", "No @param descriptions"]
@@ -7180,6 +8024,9 @@ async function extract(options) {
         suggestion: "Check serialization errors for these exports"
       });
     }
+    if (evaluate) {
+      await calibrateDiagnostics(diagnostics, evaluate);
+    }
     return {
       spec,
       diagnostics,
@@ -7194,21 +8041,21 @@ async function extract(options) {
 }
 function serializeDeclaration2(declaration, exportSymbol, exportName, ctx, isTypeOnly = false) {
   let result = null;
-  if (ts18.isFunctionDeclaration(declaration)) {
+  if (ts19.isFunctionDeclaration(declaration)) {
     result = serializeFunctionExport(declaration, ctx);
-  } else if (ts18.isClassDeclaration(declaration)) {
+  } else if (ts19.isClassDeclaration(declaration)) {
     result = serializeClass(declaration, ctx);
-  } else if (ts18.isInterfaceDeclaration(declaration)) {
+  } else if (ts19.isInterfaceDeclaration(declaration)) {
     result = serializeInterface(declaration, ctx);
-  } else if (ts18.isTypeAliasDeclaration(declaration)) {
+  } else if (ts19.isTypeAliasDeclaration(declaration)) {
     result = serializeTypeAlias(declaration, ctx);
-  } else if (ts18.isEnumDeclaration(declaration)) {
+  } else if (ts19.isEnumDeclaration(declaration)) {
     result = serializeEnum(declaration, ctx);
-  } else if (ts18.isVariableDeclaration(declaration)) {
+  } else if (ts19.isVariableDeclaration(declaration)) {
     const varStatement = declaration.parent?.parent;
-    if (varStatement && ts18.isVariableStatement(varStatement)) {
-      if (declaration.initializer && (ts18.isArrowFunction(declaration.initializer) || ts18.isFunctionExpression(declaration.initializer))) {
-        const varName = ts18.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
+    if (varStatement && ts19.isVariableStatement(varStatement)) {
+      if (declaration.initializer && (ts19.isArrowFunction(declaration.initializer) || ts19.isFunctionExpression(declaration.initializer))) {
+        const varName = ts19.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
         result = serializeFunctionExport(declaration.initializer, ctx, varName);
       } else {
         result = serializeVariable(declaration, varStatement, ctx);
@@ -7220,7 +8067,7 @@ function serializeDeclaration2(declaration, exportSymbol, exportName, ctx, isTyp
         }
       }
     }
-  } else if (ts18.isNamespaceExport(declaration) || ts18.isModuleDeclaration(declaration) || ts18.isNamespaceImport(declaration) || ts18.isSourceFile(declaration)) {
+  } else if (ts19.isNamespaceExport(declaration) || ts19.isModuleDeclaration(declaration) || ts19.isNamespaceImport(declaration) || ts19.isSourceFile(declaration)) {
     try {
       result = serializeNamespaceExport(exportSymbol, exportName, ctx);
     } catch {
@@ -7257,7 +8104,7 @@ function serializeNamespaceExport(symbol, exportName, ctx) {
   const members = [];
   const checker = ctx.program.getTypeChecker();
   let targetSymbol = symbol;
-  if (symbol.flags & ts18.SymbolFlags.Alias) {
+  if (symbol.flags & ts19.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
@@ -7285,31 +8132,31 @@ function serializeNamespaceExport(symbol, exportName, ctx) {
 function serializeNamespaceMember(symbol, memberName, ctx) {
   const checker = ctx.program.getTypeChecker();
   let targetSymbol = symbol;
-  if (symbol.flags & ts18.SymbolFlags.Alias) {
+  if (symbol.flags & ts19.SymbolFlags.Alias) {
     const aliased = checker.getAliasedSymbol(symbol);
     if (aliased && aliased !== symbol) {
       targetSymbol = aliased;
     }
   }
   const declarations = targetSymbol.declarations ?? [];
-  const declaration = targetSymbol.valueDeclaration || declarations.find((d) => d.kind !== ts18.SyntaxKind.ExportSpecifier) || declarations[0];
+  const declaration = targetSymbol.valueDeclaration || declarations.find((d) => d.kind !== ts19.SyntaxKind.ExportSpecifier) || declarations[0];
   if (!declaration)
     return null;
   const type = checker.getTypeAtLocation(declaration);
   const callSignatures = type.getCallSignatures();
   const { deprecated } = isSymbolDeprecated(targetSymbol);
   let kind = "variable";
-  if (ts18.isFunctionDeclaration(declaration) || ts18.isFunctionExpression(declaration)) {
+  if (ts19.isFunctionDeclaration(declaration) || ts19.isFunctionExpression(declaration)) {
     kind = "function";
-  } else if (ts18.isClassDeclaration(declaration)) {
+  } else if (ts19.isClassDeclaration(declaration)) {
     kind = "class";
-  } else if (ts18.isInterfaceDeclaration(declaration)) {
+  } else if (ts19.isInterfaceDeclaration(declaration)) {
     kind = "interface";
-  } else if (ts18.isTypeAliasDeclaration(declaration)) {
+  } else if (ts19.isTypeAliasDeclaration(declaration)) {
     kind = "type";
-  } else if (ts18.isEnumDeclaration(declaration)) {
+  } else if (ts19.isEnumDeclaration(declaration)) {
     kind = "enum";
-  } else if (ts18.isVariableDeclaration(declaration)) {
+  } else if (ts19.isVariableDeclaration(declaration)) {
     if (callSignatures.length > 0) {
       kind = "function";
     }
@@ -7340,18 +8187,18 @@ function serializeNamespaceMember(symbol, memberName, ctx) {
 function flattenJSDocComment(comment) {
   if (comment === undefined)
     return "";
-  return typeof comment === "string" ? comment : ts18.getTextOfJSDocComment(comment) ?? "";
+  return typeof comment === "string" ? comment : ts19.getTextOfJSDocComment(comment) ?? "";
 }
 function getJSDocFromExportSymbol(symbol) {
   const tags = [];
   const examples = [];
   const decl = symbol.declarations?.[0];
   if (decl) {
-    const exportDecl = ts18.isNamespaceExport(decl) ? decl.parent : decl;
-    if (exportDecl && ts18.isExportDeclaration(exportDecl)) {
-      const jsDocs = ts18.getJSDocCommentsAndTags(exportDecl);
+    const exportDecl = ts19.isNamespaceExport(decl) ? decl.parent : decl;
+    if (exportDecl && ts19.isExportDeclaration(exportDecl)) {
+      const jsDocs = ts19.getJSDocCommentsAndTags(exportDecl);
       for (const doc of jsDocs) {
-        if (ts18.isJSDoc(doc) && doc.comment) {
+        if (ts19.isJSDoc(doc) && doc.comment) {
           const commentText = flattenJSDocComment(doc.comment);
           if (commentText) {
             return {
@@ -7410,16 +8257,24 @@ function withExportName(entry, exportName) {
     name: exportName
   };
 }
-function createEmptySpec(entryFile, includeSchema, isDtsSource) {
+function generationEntry(entryFile, source) {
+  const rel = path10.relative(process.cwd(), entryFile).split(path10.sep).join("/");
+  return {
+    entryPoint: rel || entryFile,
+    entryPointSource: source ?? "explicit"
+  };
+}
+function createEmptySpec(entryFile, includeSchema, isDtsSource, entryPointSource) {
   return {
     ...includeSchema ? { $schema: SCHEMA_URL } : {},
     openpkg: SCHEMA_VERSION,
-    meta: { name: path9.basename(entryFile, path9.extname(entryFile)) },
+    meta: { name: path10.basename(entryFile, path10.extname(entryFile)) },
     exports: [],
     generation: {
       generator: "@openpkg-ts/sdk",
       timestamp: new Date().toISOString(),
       mode: isDtsSource ? "declaration-only" : "source",
+      ...generationEntry(entryFile, entryPointSource),
       ...isDtsSource && {
         limitations: ["No JSDoc descriptions", "No @example tags", "No @param descriptions"]
       }
@@ -7430,7 +8285,7 @@ function findTypeInProgram(name, checker, program, sourceFile, symFlags) {
   const localSym = checker.resolveName(name, sourceFile, symFlags, false);
   if (localSym)
     return checker.getDeclaredTypeOfSymbol(localSym);
-  const entryDir = path9.dirname(sourceFile.fileName);
+  const entryDir = path10.dirname(sourceFile.fileName);
   for (const sf of program.getSourceFiles()) {
     const fn = sf.fileName;
     if (fn.includes("/typescript/lib/lib.") || fn.includes("\\typescript\\lib\\lib."))
@@ -7446,22 +8301,22 @@ function findTypeInProgram(name, checker, program, sourceFile, symFlags) {
   return;
 }
 async function getPackageMeta(entryFile, baseDir) {
-  let dir = baseDir ?? path9.dirname(entryFile);
-  while (dir !== path9.dirname(dir)) {
-    const pkgPath = path9.join(dir, "package.json");
+  let dir = baseDir ?? path10.dirname(entryFile);
+  while (dir !== path10.dirname(dir)) {
+    const pkgPath = path10.join(dir, "package.json");
     try {
-      if (fs6.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+      if (fs7.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
         return {
-          name: pkg.name ?? path9.basename(dir),
+          name: pkg.name ?? path10.basename(dir),
           version: pkg.version,
           description: pkg.description
         };
       }
     } catch {}
-    dir = path9.dirname(dir);
+    dir = path10.dirname(dir);
   }
-  return { name: path9.basename(baseDir ?? path9.dirname(entryFile)) };
+  return { name: path10.basename(baseDir ?? path10.dirname(entryFile)) };
 }
 
 // src/primitives/spec.ts
@@ -7946,12 +8801,12 @@ function toToolSchema(exp, spec, options) {
   };
 }
 // src/types/utils.ts
-import ts19 from "typescript";
+import ts20 from "typescript";
 function isExported(node) {
   const modifiers = node.modifiers;
   if (!modifiers)
     return false;
-  return modifiers.some((m) => m.kind === ts19.SyntaxKind.ExportKeyword);
+  return modifiers.some((m) => m.kind === ts20.SyntaxKind.ExportKeyword);
 }
 function getNodeName(node) {
   if ("name" in node && node.name) {
@@ -7995,6 +8850,7 @@ export {
   schemasAreEqual,
   schemaIsAny,
   resolveTypeRef,
+  resolveTarget,
   resolveExportTarget2 as resolveExportTarget,
   resolveCompiledPath,
   renderTypeText,
@@ -8002,6 +8858,8 @@ export {
   registerAdapter,
   recommendSemverBump,
   query,
+  pickEntry,
+  parseGithubRepo,
   normalizeType,
   normalizeSchema,
   normalizeMembers,
@@ -8015,12 +8873,14 @@ export {
   isSymbolDeprecated,
   isStandardJSONSchema,
   isSchemaType,
+  isRemoteInput,
   isReadonlyPropertySymbol,
   isPureRefSchema,
   isProperty,
   isPrimitiveName,
   isMethod,
   isExported,
+  isEntryFilePath,
   isBuiltinSymbol,
   isBuiltinGeneric,
   isAnonymous,
@@ -8048,6 +8908,7 @@ export {
   formatMappedType,
   formatConditionalType,
   formatBadges,
+  findWorkspaceRoot,
   findMissingParamDocs,
   findDiscriminatorProperty,
   findAdapter,
@@ -8071,7 +8932,9 @@ export {
   declaredTypeNode,
   createProgram,
   createDocs,
+  cloneRemote,
   categorizeBreakingChanges,
+  catalogPackages,
   calculateNextVersion,
   bundleRefs,
   buildSignatureString,
@@ -8088,6 +8951,8 @@ export {
   PRIMITIVES,
   NUMBER_PROTOTYPE_METHODS,
   LATEST_VERSION,
+  JEV_MODEL,
+  JEV_CONFIDENCE,
   CacheManager,
   CONFIG_FILENAME,
   BUILTIN_TYPE_SCHEMAS,