@openpkg-ts/sdk 0.37.0 → 0.38.0

package/dist/index.js

@@ -29,7 +29,7 @@ import {
   toPagefindRecords,
   toSearchIndex,
   toSearchIndexJSON
-} from "./shared/chunk-hnajr1tb.js";
+} from "./shared/chunk-zrx9s0n4.js";
 
 // src/primitives/diff.ts
 import {
@@ -86,6 +86,9 @@ import * as fs2 from "node:fs";
 import { validateSpec } from "@openpkg-ts/spec";
 
 // src/render/html.ts
+import {
+  KIND_LABELS
+} from "@openpkg-ts/spec";
 var defaultCSS = `
 :root {
   --text: #1a1a1a;
@@ -381,14 +384,14 @@ function toHTML(spec, options = {}) {
   const byKind = groupByKind(specExports);
   const navItems = Object.entries(byKind).map(([kind, exports]) => {
     const links = exports.map((e) => `<a href="#${e.id}">${escapeHTML(e.name)}</a>`).join("");
-    return `<li><strong>${kind}s:</strong> ${links}</li>`;
+    return `<li><strong>${KIND_LABELS[kind] ?? kind}:</strong> ${links}</li>`;
   }).join("");
   const nav = `<nav><ul>${navItems}</ul></nav>`;
   const sections = KIND_ORDER.filter((kind) => byKind[kind]?.length).map((kind) => {
     const exports = byKind[kind].map(renderExport).join("");
     return `
         <section class="kind-section">
-          <h2>${kind.charAt(0).toUpperCase() + kind.slice(1)}s</h2>
+          <h2>${KIND_LABELS[kind]}</h2>
           ${exports}
         </section>`;
   }).join("");
@@ -533,6 +536,9 @@ function toJSONString(spec, options = {}) {
 }
 
 // src/render/markdown.ts
+import {
+  KIND_LABELS as KIND_LABELS2
+} from "@openpkg-ts/spec";
 var defaultSections = {
   signature: true,
   description: true,
@@ -898,7 +904,7 @@ function toMarkdown(spec, options = {}) {
     const exports = byKind[kind];
     if (!exports?.length)
       continue;
-    parts.push(`## ${kind.charAt(0).toUpperCase() + kind.slice(1)}s`);
+    parts.push(`## ${KIND_LABELS2[kind]}`);
     parts.push("");
     for (const exp of exports) {
       const content = exportToMarkdown(exp, {
@@ -915,18 +921,7 @@ function toMarkdown(spec, options = {}) {
 }
 
 // src/render/nav.ts
-var defaultKindLabels = {
-  function: "Functions",
-  class: "Classes",
-  interface: "Interfaces",
-  type: "Types",
-  enum: "Enums",
-  variable: "Variables",
-  namespace: "Namespaces",
-  module: "Modules",
-  reference: "References",
-  external: "External"
-};
+import { KIND_LABELS as KIND_LABELS3 } from "@openpkg-ts/spec";
 var defaultSlugify = (name) => name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
 function getModuleName(exp) {
   if (exp.source?.file) {
@@ -980,9 +975,9 @@ function toGenericNav(spec, options) {
     sortAlphabetically = true,
     includeGroupIndex = false
   } = options;
-  const labels = { ...defaultKindLabels, ...kindLabels };
+  const labels = { ...KIND_LABELS3, ...kindLabels };
   const grouped = groupExports(spec.exports, groupBy);
-  const groups = [];
+  const keyedGroups = [];
   for (const [key, exports] of grouped) {
     const sortedExports = sortAlphabetically ? sortByName(exports) : exports;
     const items = sortedExports.map((exp) => ({
@@ -990,19 +985,19 @@ function toGenericNav(spec, options) {
       href: `${basePath}/${slugify(exp.name)}`
     }));
     const title = groupBy === "kind" ? labels[key] || key : key;
-    groups.push({
-      title,
-      items,
-      index: includeGroupIndex ? `${basePath}/${slugify(key)}` : undefined
+    keyedGroups.push({
+      key,
+      group: {
+        title,
+        items,
+        index: includeGroupIndex ? `${basePath}/${slugify(key)}` : undefined
+      }
     });
   }
   if (groupBy === "kind") {
-    groups.sort((a, b) => {
-      const aIdx = KIND_ORDER.indexOf(a.title.toLowerCase().replace(/s$/, ""));
-      const bIdx = KIND_ORDER.indexOf(b.title.toLowerCase().replace(/s$/, ""));
-      return aIdx - bIdx;
-    });
+    keyedGroups.sort((a, b) => KIND_ORDER.indexOf(a.key) - KIND_ORDER.indexOf(b.key));
   }
+  const groups = keyedGroups.map((g) => g.group);
   const flatItems = groupBy === "none" ? groups.flatMap((g) => g.items) : groups.map((g) => ({
     title: g.title,
     items: g.items
@@ -1196,221 +1191,6 @@ function extractModuleName(exp) {
   }
   return;
 }
-// src/render/react.ts
-import * as fs3 from "node:fs";
-import * as path2 from "node:path";
-function generateFullLayout(spec, componentsPath) {
-  const pkgName = spec.meta.name;
-  return `'use client';
-
-import type { OpenPkg, SpecExport } from '@openpkg-ts/spec';
-import spec from './openpkg.json';
-
-// Add components via: openpkg docs add function-section class-section interface-section
-// Then uncomment the imports below and customize as needed.
-
-// import { FunctionSection } from '${componentsPath}/function-section';
-// import { ClassSection } from '${componentsPath}/class-section';
-// import { InterfaceSection } from '${componentsPath}/interface-section';
-// import { VariableSection } from '${componentsPath}/variable-section';
-// import { EnumSection } from '${componentsPath}/enum-section';
-
-/**
- * Renders a single export based on its kind.
- * Customize this to match your design system.
- */
-function ExportSection({ exp }: { exp: SpecExport }) {
-  // Uncomment the switch once you've added components:
-  // switch (exp.kind) {
-  //   case 'function':
-  //     return <FunctionSection key={exp.id} export={exp} spec={spec as OpenPkg} />;
-  //   case 'class':
-  //     return <ClassSection key={exp.id} export={exp} spec={spec as OpenPkg} />;
-  //   case 'interface':
-  //   case 'type':
-  //     return <InterfaceSection key={exp.id} export={exp} spec={spec as OpenPkg} />;
-  //   case 'variable':
-  //     return <VariableSection key={exp.id} export={exp} spec={spec as OpenPkg} />;
-  //   case 'enum':
-  //     return <EnumSection key={exp.id} export={exp} spec={spec as OpenPkg} />;
-  //   default:
-  //     return null;
-  // }
-
-  // Placeholder: replace with component imports above
-  return (
-    <section id={exp.id} className="py-8 border-b">
-      <h2 className="text-xl font-semibold">{exp.name}</h2>
-      <p className="text-muted-foreground">{exp.description || 'No description'}</p>
-      <code className="text-sm">{exp.kind}</code>
-    </section>
-  );
-}
-
-/**
- * Full API Reference Page for ${pkgName}
- *
- * This layout renders all exports on a single page.
- * Customize the grouping, styling, and components to match your docs.
- */
-export default function APIReferencePage() {
-  const typedSpec = spec as OpenPkg;
-  const exports = typedSpec.exports;
-
-  // Group exports by kind
-  const functions = exports.filter((e) => e.kind === 'function');
-  const classes = exports.filter((e) => e.kind === 'class');
-  const interfaces = exports.filter((e) => e.kind === 'interface' || e.kind === 'type');
-  const variables = exports.filter((e) => e.kind === 'variable');
-  const enums = exports.filter((e) => e.kind === 'enum');
-
-  return (
-    <div className="max-w-4xl mx-auto px-4 py-8">
-      <header className="mb-12">
-        <h1 className="text-3xl font-bold">{typedSpec.meta.name}</h1>
-        {typedSpec.meta.description && (
-          <p className="text-lg text-muted-foreground mt-2">{typedSpec.meta.description}</p>
-        )}
-        {typedSpec.meta.version && (
-          <p className="text-sm text-muted-foreground">v{typedSpec.meta.version}</p>
-        )}
-      </header>
-
-      {functions.length > 0 && (
-        <section className="mb-12">
-          <h2 className="text-2xl font-bold mb-6">Functions</h2>
-          {functions.map((exp) => (
-            <ExportSection key={exp.id} exp={exp} />
-          ))}
-        </section>
-      )}
-
-      {classes.length > 0 && (
-        <section className="mb-12">
-          <h2 className="text-2xl font-bold mb-6">Classes</h2>
-          {classes.map((exp) => (
-            <ExportSection key={exp.id} exp={exp} />
-          ))}
-        </section>
-      )}
-
-      {interfaces.length > 0 && (
-        <section className="mb-12">
-          <h2 className="text-2xl font-bold mb-6">Types & Interfaces</h2>
-          {interfaces.map((exp) => (
-            <ExportSection key={exp.id} exp={exp} />
-          ))}
-        </section>
-      )}
-
-      {variables.length > 0 && (
-        <section className="mb-12">
-          <h2 className="text-2xl font-bold mb-6">Variables</h2>
-          {variables.map((exp) => (
-            <ExportSection key={exp.id} exp={exp} />
-          ))}
-        </section>
-      )}
-
-      {enums.length > 0 && (
-        <section className="mb-12">
-          <h2 className="text-2xl font-bold mb-6">Enums</h2>
-          {enums.map((exp) => (
-            <ExportSection key={exp.id} exp={exp} />
-          ))}
-        </section>
-      )}
-    </div>
-  );
-}
-
-export { spec };
-`;
-}
-function generateIndexLayout(spec, componentsPath) {
-  const pkgName = spec.meta.name;
-  return `'use client';
-
-import type { OpenPkg } from '@openpkg-ts/spec';
-import spec from './openpkg.json';
-
-// Add the export-card component: openpkg docs add export-card
-// import { ExportCard } from '${componentsPath}/export-card';
-
-/**
- * API Reference Index Page for ${pkgName}
- *
- * Links to individual export pages. Best with file-based routing.
- * Customize the card component and links to match your docs.
- */
-export default function APIReferenceIndex() {
-  const typedSpec = spec as OpenPkg;
-  const exports = typedSpec.exports;
-
-  // Group exports by kind
-  const groups = [
-    { title: 'Functions', items: exports.filter((e) => e.kind === 'function') },
-    { title: 'Classes', items: exports.filter((e) => e.kind === 'class') },
-    { title: 'Types & Interfaces', items: exports.filter((e) => e.kind === 'interface' || e.kind === 'type') },
-    { title: 'Variables', items: exports.filter((e) => e.kind === 'variable') },
-    { title: 'Enums', items: exports.filter((e) => e.kind === 'enum') },
-  ].filter((g) => g.items.length > 0);
-
-  return (
-    <div className="max-w-4xl mx-auto px-4 py-8">
-      <header className="mb-12">
-        <h1 className="text-3xl font-bold">{typedSpec.meta.name}</h1>
-        {typedSpec.meta.description && (
-          <p className="text-lg text-muted-foreground mt-2">{typedSpec.meta.description}</p>
-        )}
-      </header>
-
-      {groups.map((group) => (
-        <section key={group.title} className="mb-12">
-          <h2 className="text-2xl font-bold mb-6">{group.title}</h2>
-          <div className="grid gap-4 md:grid-cols-2">
-            {group.items.map((exp) => (
-              // Replace with ExportCard once installed:
-              // <ExportCard key={exp.id} export={exp} href={\`/api/\${exp.name}\`} />
-              <a
-                key={exp.id}
-                href={\`/api/\${exp.name}\`}
-                className="block p-4 border rounded-lg hover:bg-muted transition-colors"
-              >
-                <h3 className="font-semibold">{exp.name}</h3>
-                <p className="text-sm text-muted-foreground line-clamp-2">
-                  {exp.description || 'No description'}
-                </p>
-                <span className="text-xs bg-muted px-2 py-1 rounded mt-2 inline-block">
-                  {exp.kind}
-                </span>
-              </a>
-            ))}
-          </div>
-        </section>
-      ))}
-    </div>
-  );
-}
-
-export { spec };
-`;
-}
-async function toReact(spec, options) {
-  const { outDir, variant = "full", componentsPath = "@/components/api" } = options;
-  if (!fs3.existsSync(outDir)) {
-    fs3.mkdirSync(outDir, { recursive: true });
-  }
-  const specPath = path2.join(outDir, "openpkg.json");
-  fs3.writeFileSync(specPath, JSON.stringify(spec, null, 2));
-  const layoutContent = variant === "index" ? generateIndexLayout(spec, componentsPath) : generateFullLayout(spec, componentsPath);
-  const layoutPath = path2.join(outDir, "page.tsx");
-  fs3.writeFileSync(layoutPath, layoutContent);
-}
-function toReactString(spec, options = {}) {
-  const { variant = "full", componentsPath = "@/components/api" } = options;
-  return variant === "index" ? generateIndexLayout(spec, componentsPath) : generateFullLayout(spec, componentsPath);
-}
 // src/primitives/filter.ts
 function matchesExport(exp, criteria) {
   if (criteria.kinds && criteria.kinds.length > 0) {
@@ -1517,211 +1297,8 @@ function filterSpec(spec, criteria) {
 // src/primitives/get.ts
 import ts11 from "typescript";
 
-// src/compiler/program.ts
-import * as fs4 from "node:fs";
-import * as path3 from "node:path";
-import ts from "typescript";
-function isJsFile(file) {
-  return /\.(js|mjs|cjs|jsx)$/.test(file);
-}
-function getScriptKind(file) {
-  if (/\.tsx$/.test(file))
-    return ts.ScriptKind.TSX;
-  if (/\.jsx$/.test(file))
-    return ts.ScriptKind.JSX;
-  if (/\.(js|mjs|cjs)$/.test(file))
-    return ts.ScriptKind.JS;
-  return ts.ScriptKind.TS;
-}
-var DEFAULT_COMPILER_OPTIONS = {
-  target: ts.ScriptTarget.Latest,
-  module: ts.ModuleKind.CommonJS,
-  lib: ["lib.es2021.d.ts"],
-  declaration: true,
-  moduleResolution: ts.ModuleResolutionKind.NodeJs
-};
-function resolveProjectReferences(configPath, parsedConfig) {
-  const additionalFiles = [];
-  if (!parsedConfig.projectReferences?.length) {
-    return additionalFiles;
-  }
-  const configDir = path3.dirname(configPath);
-  for (const ref of parsedConfig.projectReferences) {
-    const refPath = path3.resolve(configDir, ref.path);
-    const refConfigPath = fs4.existsSync(path3.join(refPath, "tsconfig.json")) ? path3.join(refPath, "tsconfig.json") : refPath;
-    if (!fs4.existsSync(refConfigPath))
-      continue;
-    const refConfigFile = ts.readConfigFile(refConfigPath, ts.sys.readFile);
-    if (refConfigFile.error)
-      continue;
-    const refParsed = ts.parseJsonConfigFileContent(refConfigFile.config, ts.sys, path3.dirname(refConfigPath));
-    additionalFiles.push(...refParsed.fileNames);
-  }
-  return additionalFiles;
-}
-function parsePnpmWorkspace(yamlContent) {
-  const globs = [];
-  const lines = yamlContent.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("-") && trimmed) {
-        break;
-      }
-      const match = trimmed.match(/^-\s*['"]?([^'"]+)['"]?$/);
-      if (match) {
-        globs.push(match[1]);
-      }
-    }
-  }
-  return globs;
-}
-function buildWorkspaceMap(baseDir) {
-  let currentDir = baseDir;
-  let rootDir;
-  let workspaceGlobs = [];
-  for (let i = 0;i < 10; i++) {
-    const pnpmPath = path3.join(currentDir, "pnpm-workspace.yaml");
-    if (fs4.existsSync(pnpmPath)) {
-      try {
-        const yamlContent = fs4.readFileSync(pnpmPath, "utf-8");
-        workspaceGlobs = parsePnpmWorkspace(yamlContent);
-        if (workspaceGlobs.length > 0) {
-          rootDir = currentDir;
-          break;
-        }
-      } catch {}
-    }
-    const pkgPath = path3.join(currentDir, "package.json");
-    if (fs4.existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
-        if (pkg.workspaces) {
-          rootDir = currentDir;
-          workspaceGlobs = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages || [];
-          break;
-        }
-      } catch {}
-    }
-    const parent = path3.dirname(currentDir);
-    if (parent === currentDir)
-      break;
-    currentDir = parent;
-  }
-  if (!rootDir || workspaceGlobs.length === 0)
-    return;
-  const packages = new Map;
-  for (const glob of workspaceGlobs) {
-    const globDir = path3.join(rootDir, glob.replace(/\/\*$/, ""));
-    if (!fs4.existsSync(globDir) || !fs4.statSync(globDir).isDirectory())
-      continue;
-    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 (!fs4.existsSync(pkgJsonPath))
-        continue;
-      try {
-        const pkg = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
-        if (pkg.name) {
-          const srcDir = fs4.existsSync(path3.join(pkgDir, "src")) ? path3.join(pkgDir, "src") : pkgDir;
-          packages.set(pkg.name, srcDir);
-        }
-      } catch {}
-    }
-  }
-  return packages.size > 0 ? { packages, rootDir } : undefined;
-}
-function createProgram({
-  entryFile,
-  baseDir = path3.dirname(entryFile),
-  content
-}) {
-  let configPath = ts.findConfigFile(baseDir, ts.sys.fileExists, "tsconfig.json");
-  if (!configPath) {
-    configPath = ts.findConfigFile(baseDir, ts.sys.fileExists, "jsconfig.json");
-  }
-  let compilerOptions = { ...DEFAULT_COMPILER_OPTIONS };
-  let additionalRootFiles = [];
-  if (configPath) {
-    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path3.dirname(configPath));
-    compilerOptions = { ...compilerOptions, ...parsedConfig.options };
-    additionalRootFiles = resolveProjectReferences(configPath, parsedConfig);
-    const sourceFiles = parsedConfig.fileNames.filter((f) => !f.includes(".test.") && !f.includes(".spec.") && !f.includes("/dist/") && !f.includes("/node_modules/"));
-    additionalRootFiles.push(...sourceFiles);
-  }
-  if (isJsFile(entryFile)) {
-    compilerOptions = {
-      ...compilerOptions,
-      allowJs: true,
-      checkJs: true,
-      isolatedDeclarations: false
-    };
-  } else {
-    const allowJsVal = compilerOptions.allowJs;
-    if (typeof allowJsVal === "boolean" && allowJsVal) {
-      compilerOptions = { ...compilerOptions, allowJs: false, checkJs: false };
-    }
-  }
-  const workspaceMap = buildWorkspaceMap(baseDir);
-  const compilerHost = ts.createCompilerHost(compilerOptions, true);
-  let inMemorySource;
-  if (workspaceMap) {
-    const originalResolveModuleNames = compilerHost.resolveModuleNames?.bind(compilerHost);
-    compilerHost.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, options) => {
-      return moduleNames.map((moduleName) => {
-        const srcDir = workspaceMap.packages.get(moduleName);
-        if (srcDir) {
-          const indexFile = path3.join(srcDir, "index.ts");
-          if (fs4.existsSync(indexFile)) {
-            return { resolvedFileName: indexFile, isExternalLibraryImport: false };
-          }
-        }
-        if (originalResolveModuleNames) {
-          const result = originalResolveModuleNames([moduleName], containingFile, _reusedNames, redirectedReference, options);
-          return result[0];
-        }
-        const resolved = ts.resolveModuleName(moduleName, containingFile, options, compilerHost);
-        return resolved.resolvedModule;
-      });
-    };
-  }
-  if (content !== undefined) {
-    inMemorySource = ts.createSourceFile(entryFile, content, ts.ScriptTarget.Latest, true, getScriptKind(entryFile));
-    const originalGetSourceFile = compilerHost.getSourceFile.bind(compilerHost);
-    compilerHost.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
-      if (fileName === entryFile) {
-        return inMemorySource;
-      }
-      return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
-    };
-  }
-  const rootFiles = [entryFile, ...additionalRootFiles];
-  const program = ts.createProgram(rootFiles, compilerOptions, compilerHost);
-  const sourceFile = inMemorySource ?? program.getSourceFile(entryFile);
-  return {
-    program,
-    compilerHost,
-    compilerOptions,
-    sourceFile,
-    configPath
-  };
-}
-
-// src/serializers/classes.ts
-import ts7 from "typescript";
-
 // src/ast/utils.ts
-import ts2 from "typescript";
+import ts from "typescript";
 function parseExamplesFromTags(tags) {
   const examples = [];
   for (const tag of tags) {
@@ -1783,12 +1360,12 @@ function extractSeeTagText(tag) {
     if (Array.isArray(tag.comment)) {
       const parts = [];
       for (const part of tag.comment) {
-        if (ts2.isJSDocLink(part) || ts2.isJSDocLinkCode(part) || ts2.isJSDocLinkPlain(part)) {
+        if (ts.isJSDocLink(part) || ts.isJSDocLinkCode(part) || ts.isJSDocLinkPlain(part)) {
           if (part.name) {
             try {
               parts.push(part.name.getText());
             } catch {
-              if (ts2.isIdentifier(part.name)) {
+              if (ts.isIdentifier(part.name)) {
                 parts.push(part.name.text);
               }
             }
@@ -1796,7 +1373,7 @@ function extractSeeTagText(tag) {
           if (part.text) {
             parts.push(part.text);
           }
-        } else if (part.kind === ts2.SyntaxKind.JSDocText) {
+        } else if (part.kind === ts.SyntaxKind.JSDocText) {
           parts.push(part.text);
         }
       }
@@ -1805,12 +1382,12 @@ function extractSeeTagText(tag) {
         return result;
     }
   }
-  return typeof tag.comment === "string" ? tag.comment : ts2.getTextOfJSDocComment(tag.comment) ?? "";
+  return typeof tag.comment === "string" ? tag.comment : ts.getTextOfJSDocComment(tag.comment) ?? "";
 }
 function getJSDocComment(node, symbol, checker) {
-  const jsDocTags = ts2.getJSDocTags(node);
+  const jsDocTags = ts.getJSDocTags(node);
   const tags = jsDocTags.map((tag) => {
-    const rawText = typeof tag.comment === "string" ? tag.comment : ts2.getTextOfJSDocComment(tag.comment) ?? "";
+    const rawText = typeof tag.comment === "string" ? tag.comment : ts.getTextOfJSDocComment(tag.comment) ?? "";
     if (tag.tagName.text === "param") {
       const paramTag = tag;
       let paramName = "";
@@ -1845,12 +1422,12 @@ function getJSDocComment(node, symbol, checker) {
     }
     return { name: tag.tagName.text, text: rawText };
   });
-  const jsDocComments = ts2.getJSDocCommentsAndTags(node).filter(ts2.isJSDoc);
+  const jsDocComments = ts.getJSDocCommentsAndTags(node).filter(ts.isJSDoc);
   let description;
   if (jsDocComments.length > 0) {
     const firstDoc = jsDocComments[0];
     if (firstDoc.comment) {
-      description = typeof firstDoc.comment === "string" ? firstDoc.comment : ts2.getTextOfJSDocComment(firstDoc.comment);
+      description = typeof firstDoc.comment === "string" ? firstDoc.comment : ts.getTextOfJSDocComment(firstDoc.comment);
     }
   }
   if (!description && symbol && checker) {
@@ -1883,7 +1460,7 @@ function getParamDescription(propertyName, jsdocTags, inferredAlias) {
     }
     const isMatch = tagParamName === propertyName || inferredAlias && tagParamName === `${inferredAlias}.${propertyName}` || tagParamName.endsWith(`.${propertyName}`);
     if (isMatch) {
-      const comment = typeof tag.comment === "string" ? tag.comment : ts2.getTextOfJSDocComment(tag.comment);
+      const comment = typeof tag.comment === "string" ? tag.comment : ts.getTextOfJSDocComment(tag.comment);
       return stripParamSeparator(comment);
     }
   }
@@ -1896,11 +1473,11 @@ function extractVarianceModifiers(modifiers) {
   let hasOut = false;
   let isConst;
   for (const mod of modifiers) {
-    if (mod.kind === ts2.SyntaxKind.InKeyword)
+    if (mod.kind === ts.SyntaxKind.InKeyword)
       hasIn = true;
-    if (mod.kind === ts2.SyntaxKind.OutKeyword)
+    if (mod.kind === ts.SyntaxKind.OutKeyword)
       hasOut = true;
-    if (mod.kind === ts2.SyntaxKind.ConstKeyword)
+    if (mod.kind === ts.SyntaxKind.ConstKeyword)
       isConst = true;
   }
   const variance = hasIn && hasOut ? "inout" : hasIn ? "in" : hasOut ? "out" : undefined;
@@ -1922,7 +1499,7 @@ function extractTypeParameters(node, checker) {
       const defType = checker.getTypeAtLocation(tp.default);
       defaultType = checker.typeToString(defType);
     }
-    const { variance, isConst } = extractVarianceModifiers(ts2.getModifiers(tp));
+    const { variance, isConst } = extractVarianceModifiers(ts.getModifiers(tp));
     return {
       name,
       ...constraint ? { constraint } : {},
@@ -1943,7 +1520,7 @@ function isSymbolDeprecated(symbol) {
     return { deprecated: true, reason };
   }
   for (const declaration of symbol.getDeclarations() ?? []) {
-    const tag = ts2.getJSDocDeprecatedTag(declaration);
+    const tag = ts.getJSDocDeprecatedTag(declaration);
     if (tag) {
       let reason;
       if (typeof tag.comment === "string") {
@@ -1953,10 +1530,10 @@ function isSymbolDeprecated(symbol) {
       }
       return { deprecated: true, reason };
     }
-    if (ts2.isExportSpecifier(declaration)) {
+    if (ts.isExportSpecifier(declaration)) {
       const exportDecl = declaration.parent?.parent;
-      if (exportDecl && ts2.isExportDeclaration(exportDecl)) {
-        const parentTag = ts2.getJSDocDeprecatedTag(exportDecl);
+      if (exportDecl && ts.isExportDeclaration(exportDecl)) {
+        const parentTag = ts.getJSDocDeprecatedTag(exportDecl);
         if (parentTag) {
           let reason;
           if (typeof parentTag.comment === "string") {
@@ -2001,8 +1578,8 @@ function extractTypeParametersFromSignature(signature, checker) {
     const tpSymbol = tp.getSymbol();
     const declarations = tpSymbol?.getDeclarations() ?? [];
     for (const decl of declarations) {
-      if (ts2.isTypeParameterDeclaration(decl)) {
-        ({ variance, isConst } = extractVarianceModifiers(ts2.getModifiers(decl)));
+      if (ts.isTypeParameterDeclaration(decl)) {
+        ({ variance, isConst } = extractVarianceModifiers(ts.getModifiers(decl)));
         break;
       }
     }
@@ -2016,25 +1593,228 @@ function extractTypeParametersFromSignature(signature, checker) {
   });
 }
 function getExportKind(declaration, type) {
-  if (ts2.isFunctionDeclaration(declaration) || ts2.isFunctionExpression(declaration))
+  if (ts.isFunctionDeclaration(declaration) || ts.isFunctionExpression(declaration))
     return "function";
-  if (ts2.isClassDeclaration(declaration))
+  if (ts.isClassDeclaration(declaration))
     return "class";
-  if (ts2.isInterfaceDeclaration(declaration))
+  if (ts.isInterfaceDeclaration(declaration))
     return "interface";
-  if (ts2.isTypeAliasDeclaration(declaration))
+  if (ts.isTypeAliasDeclaration(declaration))
     return "type";
-  if (ts2.isEnumDeclaration(declaration))
+  if (ts.isEnumDeclaration(declaration))
     return "enum";
-  if (ts2.isModuleDeclaration(declaration) || ts2.isNamespaceExport(declaration))
+  if (ts.isModuleDeclaration(declaration) || ts.isNamespaceExport(declaration))
     return "namespace";
-  if (ts2.isVariableDeclaration(declaration) && type.getConstructSignatures().length > 0)
+  if (ts.isVariableDeclaration(declaration) && type.getConstructSignatures().length > 0)
     return "class";
-  if (ts2.isVariableDeclaration(declaration) && type.getCallSignatures().length > 0)
+  if (ts.isVariableDeclaration(declaration) && type.getCallSignatures().length > 0)
     return "function";
   return "variable";
 }
 
+// src/compiler/program.ts
+import * as fs3 from "node:fs";
+import * as path2 from "node:path";
+import ts2 from "typescript";
+function isJsFile(file) {
+  return /\.(js|mjs|cjs|jsx)$/.test(file);
+}
+function getScriptKind(file) {
+  if (/\.tsx$/.test(file))
+    return ts2.ScriptKind.TSX;
+  if (/\.jsx$/.test(file))
+    return ts2.ScriptKind.JSX;
+  if (/\.(js|mjs|cjs)$/.test(file))
+    return ts2.ScriptKind.JS;
+  return ts2.ScriptKind.TS;
+}
+var DEFAULT_COMPILER_OPTIONS = {
+  target: ts2.ScriptTarget.Latest,
+  module: ts2.ModuleKind.CommonJS,
+  lib: ["lib.es2021.d.ts"],
+  declaration: true,
+  moduleResolution: ts2.ModuleResolutionKind.NodeJs
+};
+function resolveProjectReferences(configPath, parsedConfig) {
+  const additionalFiles = [];
+  if (!parsedConfig.projectReferences?.length) {
+    return additionalFiles;
+  }
+  const configDir = path2.dirname(configPath);
+  for (const ref of parsedConfig.projectReferences) {
+    const refPath = path2.resolve(configDir, ref.path);
+    const refConfigPath = fs3.existsSync(path2.join(refPath, "tsconfig.json")) ? path2.join(refPath, "tsconfig.json") : refPath;
+    if (!fs3.existsSync(refConfigPath))
+      continue;
+    const refConfigFile = ts2.readConfigFile(refConfigPath, ts2.sys.readFile);
+    if (refConfigFile.error)
+      continue;
+    const refParsed = ts2.parseJsonConfigFileContent(refConfigFile.config, ts2.sys, path2.dirname(refConfigPath));
+    additionalFiles.push(...refParsed.fileNames);
+  }
+  return additionalFiles;
+}
+function parsePnpmWorkspace(yamlContent) {
+  const globs = [];
+  const lines = yamlContent.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("-") && trimmed) {
+        break;
+      }
+      const match = trimmed.match(/^-\s*['"]?([^'"]+)['"]?$/);
+      if (match) {
+        globs.push(match[1]);
+      }
+    }
+  }
+  return globs;
+}
+function buildWorkspaceMap(baseDir) {
+  let currentDir = baseDir;
+  let rootDir;
+  let workspaceGlobs = [];
+  for (let i = 0;i < 10; i++) {
+    const pnpmPath = path2.join(currentDir, "pnpm-workspace.yaml");
+    if (fs3.existsSync(pnpmPath)) {
+      try {
+        const yamlContent = fs3.readFileSync(pnpmPath, "utf-8");
+        workspaceGlobs = parsePnpmWorkspace(yamlContent);
+        if (workspaceGlobs.length > 0) {
+          rootDir = currentDir;
+          break;
+        }
+      } catch {}
+    }
+    const pkgPath = path2.join(currentDir, "package.json");
+    if (fs3.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+        if (pkg.workspaces) {
+          rootDir = currentDir;
+          workspaceGlobs = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages || [];
+          break;
+        }
+      } catch {}
+    }
+    const parent = path2.dirname(currentDir);
+    if (parent === currentDir)
+      break;
+    currentDir = parent;
+  }
+  if (!rootDir || workspaceGlobs.length === 0)
+    return;
+  const packages = new Map;
+  for (const glob of workspaceGlobs) {
+    const globDir = path2.join(rootDir, glob.replace(/\/\*$/, ""));
+    if (!fs3.existsSync(globDir) || !fs3.statSync(globDir).isDirectory())
+      continue;
+    const entries = fs3.readdirSync(globDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const pkgDir = path2.join(globDir, entry.name);
+      const pkgJsonPath = path2.join(pkgDir, "package.json");
+      if (!fs3.existsSync(pkgJsonPath))
+        continue;
+      try {
+        const pkg = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
+        if (pkg.name) {
+          const srcDir = fs3.existsSync(path2.join(pkgDir, "src")) ? path2.join(pkgDir, "src") : pkgDir;
+          packages.set(pkg.name, srcDir);
+        }
+      } catch {}
+    }
+  }
+  return packages.size > 0 ? { packages, rootDir } : undefined;
+}
+function createProgram({
+  entryFile,
+  baseDir = path2.dirname(entryFile),
+  content
+}) {
+  let configPath = ts2.findConfigFile(baseDir, ts2.sys.fileExists, "tsconfig.json");
+  if (!configPath) {
+    configPath = ts2.findConfigFile(baseDir, ts2.sys.fileExists, "jsconfig.json");
+  }
+  let compilerOptions = { ...DEFAULT_COMPILER_OPTIONS };
+  let additionalRootFiles = [];
+  if (configPath) {
+    const configFile = ts2.readConfigFile(configPath, ts2.sys.readFile);
+    const parsedConfig = ts2.parseJsonConfigFileContent(configFile.config, ts2.sys, path2.dirname(configPath));
+    compilerOptions = { ...compilerOptions, ...parsedConfig.options };
+    additionalRootFiles = resolveProjectReferences(configPath, parsedConfig);
+    const sourceFiles = parsedConfig.fileNames.filter((f) => !f.includes(".test.") && !f.includes(".spec.") && !f.includes("/dist/") && !f.includes("/node_modules/"));
+    additionalRootFiles.push(...sourceFiles);
+  }
+  if (isJsFile(entryFile)) {
+    compilerOptions = {
+      ...compilerOptions,
+      allowJs: true,
+      checkJs: true,
+      isolatedDeclarations: false
+    };
+  } else {
+    const allowJsVal = compilerOptions.allowJs;
+    if (typeof allowJsVal === "boolean" && allowJsVal) {
+      compilerOptions = { ...compilerOptions, allowJs: false, checkJs: false };
+    }
+  }
+  const workspaceMap = buildWorkspaceMap(baseDir);
+  const compilerHost = ts2.createCompilerHost(compilerOptions, true);
+  let inMemorySource;
+  if (workspaceMap) {
+    const originalResolveModuleNames = compilerHost.resolveModuleNames?.bind(compilerHost);
+    compilerHost.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, options) => {
+      return moduleNames.map((moduleName) => {
+        const srcDir = workspaceMap.packages.get(moduleName);
+        if (srcDir) {
+          const indexFile = path2.join(srcDir, "index.ts");
+          if (fs3.existsSync(indexFile)) {
+            return { resolvedFileName: indexFile, isExternalLibraryImport: false };
+          }
+        }
+        if (originalResolveModuleNames) {
+          const result = originalResolveModuleNames([moduleName], containingFile, _reusedNames, redirectedReference, options);
+          return result[0];
+        }
+        const resolved = ts2.resolveModuleName(moduleName, containingFile, options, compilerHost);
+        return resolved.resolvedModule;
+      });
+    };
+  }
+  if (content !== undefined) {
+    inMemorySource = ts2.createSourceFile(entryFile, content, ts2.ScriptTarget.Latest, true, getScriptKind(entryFile));
+    const originalGetSourceFile = compilerHost.getSourceFile.bind(compilerHost);
+    compilerHost.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+      if (fileName === entryFile) {
+        return inMemorySource;
+      }
+      return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+    };
+  }
+  const rootFiles = [entryFile, ...additionalRootFiles];
+  const program = ts2.createProgram(rootFiles, compilerOptions, compilerHost);
+  const sourceFile = inMemorySource ?? program.getSourceFile(entryFile);
+  return {
+    program,
+    compilerHost,
+    compilerOptions,
+    sourceFile,
+    configPath
+  };
+}
+
+// src/serializers/classes.ts
+import ts7 from "typescript";
+
 // src/types/parameters.ts
 import ts4 from "typescript";
 
@@ -2595,7 +2375,7 @@ function buildSchemaInternal(type, checker, ctx) {
     return { type: checker.typeToString(type) };
   } finally {
     if (addedToVisited) {
-      ctx.visitedTypes.delete(type);
+      ctx?.visitedTypes.delete(type);
     }
   }
 }
@@ -4647,12 +4427,20 @@ async function getExport(options) {
   const result = createProgram({ entryFile, baseDir, content });
   const { program, sourceFile } = result;
   if (!sourceFile) {
-    return { export: null, types: [], errors: [`Entry file not found: ${entryFile}. Specify with: drift get src/index.ts <name>`] };
+    return {
+      export: null,
+      types: [],
+      errors: [`Entry file not found: ${entryFile}. Specify with: drift get src/index.ts <name>`]
+    };
   }
   const checker = program.getTypeChecker();
   const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
   if (!moduleSymbol) {
-    return { export: null, types: [], errors: [`No exports found in ${entryFile}. Is this the right entry point?`] };
+    return {
+      export: null,
+      types: [],
+      errors: [`No exports found in ${entryFile}. Is this the right entry point?`]
+    };
   }
   const exportedSymbols = checker.getExportsOfModule(moduleSymbol);
   const targetSymbol = exportedSymbols.find((s) => s.getName() === exportName);
@@ -4671,7 +4459,11 @@ async function getExport(options) {
     if (isNamespaceExportDecl) {
       const spec2 = serializeNamespaceForGet(targetSymbol, exportName, ctx);
       const types2 = ctx.typeRegistry.getAll().map((t) => normalizeType(t, { dialect: "draft-2020-12" }));
-      return { export: normalizeExport(spec2, { dialect: "draft-2020-12" }), types: types2, errors };
+      return {
+        export: normalizeExport(spec2, { dialect: "draft-2020-12" }),
+        types: types2,
+        errors
+      };
     }
     const { declaration, resolvedSymbol, isTypeOnly } = resolveExportTarget(targetSymbol, checker);
     if (!declaration) {
@@ -4836,7 +4628,7 @@ function detectExternalPackage(symbol, checker) {
   return;
 }
 // src/primitives/list.ts
-import * as path4 from "node:path";
+import * as path3 from "node:path";
 import ts12 from "typescript";
 async function listExports(options) {
   const { entryFile, baseDir, content } = options;
@@ -4845,12 +4637,18 @@ async function listExports(options) {
   const result = createProgram({ entryFile, baseDir, content });
   const { program, sourceFile } = result;
   if (!sourceFile) {
-    return { exports: [], errors: [`Entry file not found: ${entryFile}. Specify with: drift list src/index.ts`] };
+    return {
+      exports: [],
+      errors: [`Entry file not found: ${entryFile}. Specify with: drift list src/index.ts`]
+    };
   }
   const checker = program.getTypeChecker();
   const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
   if (!moduleSymbol) {
-    return { exports: [], errors: [`No exports found in ${entryFile}. Is this the right entry point?`] };
+    return {
+      exports: [],
+      errors: [`No exports found in ${entryFile}. Is this the right entry point?`]
+    };
   }
   const exportedSymbols = checker.getExportsOfModule(moduleSymbol);
   for (const symbol of exportedSymbols) {
@@ -4891,7 +4689,7 @@ function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
     return {
       name,
       kind: "namespace",
-      file: path4.relative(path4.dirname(entryFile), declaration.fileName),
+      file: path3.relative(path3.dirname(entryFile), declaration.fileName),
       line: 1,
       reexport: true
     };
@@ -4905,7 +4703,7 @@ function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
   return {
     name,
     kind,
-    file: path4.relative(path4.dirname(entryFile), sourceFile.fileName),
+    file: path3.relative(path3.dirname(entryFile), sourceFile.fileName),
     line: line + 1,
     ...description ? { description } : {},
     ...deprecated ? { deprecated: true } : {},
@@ -4926,8 +4724,8 @@ function getDescriptionPreview(symbol, checker) {
   return `${firstLine.slice(0, 77)}...`;
 }
 // src/builder/spec-builder.ts
-import * as fs7 from "node:fs";
-import * as path8 from "node:path";
+import * as fs6 from "node:fs";
+import * as path7 from "node:path";
 import { SCHEMA_URL, SCHEMA_VERSION } from "@openpkg-ts/spec";
 import ts16 from "typescript";
 
@@ -4963,9 +4761,9 @@ function resolveExportTarget2(symbol, checker) {
 
 // src/schema/standard-schema.ts
 import { spawn, spawnSync } from "node:child_process";
-import * as fs5 from "node:fs";
+import * as fs4 from "node:fs";
 import * as os from "node:os";
-import * as path5 from "node:path";
+import * as path4 from "node:path";
 var MAX_BUFFER_SIZE = 10 * 1024 * 1024;
 function isStandardJSONSchema(obj) {
   if (typeof obj !== "object" || obj === null)
@@ -5219,21 +5017,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 (!fs5.existsSync(tsFilePath)) {
+  if (!fs4.existsSync(tsFilePath)) {
     result.errors.push(`TypeScript file not found: ${tsFilePath}`);
     return result;
   }
   const tempDir = os.tmpdir();
-  const workerPath = path5.join(tempDir, `openpkg-extract-worker-${Date.now()}.ts`);
+  const workerPath = path4.join(tempDir, `openpkg-extract-worker-${Date.now()}.ts`);
   try {
-    fs5.writeFileSync(workerPath, TS_WORKER_SCRIPT);
+    fs4.writeFileSync(workerPath, TS_WORKER_SCRIPT);
     const optionsJson = JSON.stringify({ target, libraryOptions });
     const args = [...runtime.args, workerPath, tsFilePath, optionsJson];
     return await new Promise((resolve2) => {
       const child = spawn(runtime.cmd, args, {
         timeout,
         stdio: ["ignore", "pipe", "pipe"],
-        cwd: path5.dirname(tsFilePath)
+        cwd: path4.dirname(tsFilePath)
       });
       let stdout = "";
       let stderr = "";
@@ -5257,7 +5055,7 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
       });
       child.on("close", (code) => {
         try {
-          fs5.unlinkSync(workerPath);
+          fs4.unlinkSync(workerPath);
         } catch (cleanupErr) {
           if (cleanupErr?.code !== "ENOENT") {
             result.warnings.push({ code: "CLEANUP_FAILED", message: String(cleanupErr) });
@@ -5311,7 +5109,7 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
       });
       child.on("error", (err) => {
         try {
-          fs5.unlinkSync(workerPath);
+          fs4.unlinkSync(workerPath);
         } catch (cleanupErr) {
           if (cleanupErr?.code !== "ENOENT") {
             result.warnings.push({ code: "CLEANUP_FAILED", message: String(cleanupErr) });
@@ -5323,7 +5121,7 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
     });
   } catch (e) {
     try {
-      fs5.unlinkSync(workerPath);
+      fs4.unlinkSync(workerPath);
     } catch (cleanupErr) {
       if (cleanupErr?.code !== "ENOENT") {
         result.warnings.push({ code: "CLEANUP_FAILED", message: String(cleanupErr) });
@@ -5334,12 +5132,12 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
   }
 }
 function readTsconfigOutDir(baseDir) {
-  const tsconfigPath = path5.join(baseDir, "tsconfig.json");
+  const tsconfigPath = path4.join(baseDir, "tsconfig.json");
   try {
-    if (!fs5.existsSync(tsconfigPath)) {
+    if (!fs4.existsSync(tsconfigPath)) {
       return null;
     }
-    const content = fs5.readFileSync(tsconfigPath, "utf-8");
+    const content = fs4.readFileSync(tsconfigPath, "utf-8");
     const stripped = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
     const tsconfig = JSON.parse(stripped);
     if (tsconfig.compilerOptions?.outDir) {
@@ -5349,7 +5147,7 @@ function readTsconfigOutDir(baseDir) {
   return null;
 }
 function resolveCompiledPath(tsPath, baseDir) {
-  const relativePath = path5.relative(baseDir, tsPath);
+  const relativePath = path4.relative(baseDir, tsPath);
   const withoutExt = relativePath.replace(/\.tsx?$/, "");
   const srcPrefix = withoutExt.replace(/^src\//, "");
   const tsconfigOutDir = readTsconfigOutDir(baseDir);
@@ -5357,7 +5155,7 @@ function resolveCompiledPath(tsPath, baseDir) {
   const candidates = [];
   if (tsconfigOutDir) {
     for (const ext of extensions) {
-      candidates.push(path5.join(baseDir, tsconfigOutDir, `${srcPrefix}${ext}`));
+      candidates.push(path4.join(baseDir, tsconfigOutDir, `${srcPrefix}${ext}`));
     }
   }
   const commonOutDirs = ["dist", "build", "lib", "out"];
@@ -5365,21 +5163,21 @@ function resolveCompiledPath(tsPath, baseDir) {
     if (outDir === tsconfigOutDir)
       continue;
     for (const ext of extensions) {
-      candidates.push(path5.join(baseDir, outDir, `${srcPrefix}${ext}`));
+      candidates.push(path4.join(baseDir, outDir, `${srcPrefix}${ext}`));
     }
   }
   for (const ext of extensions) {
-    candidates.push(path5.join(baseDir, `${withoutExt}${ext}`));
+    candidates.push(path4.join(baseDir, `${withoutExt}${ext}`));
   }
   const workspaceMatch = baseDir.match(/^(.+\/packages\/[^/]+)$/);
   if (workspaceMatch) {
     const pkgRoot = workspaceMatch[1];
     for (const ext of extensions) {
-      candidates.push(path5.join(pkgRoot, "dist", `${srcPrefix}${ext}`));
+      candidates.push(path4.join(pkgRoot, "dist", `${srcPrefix}${ext}`));
     }
   }
   for (const candidate of candidates) {
-    if (fs5.existsSync(candidate)) {
+    if (fs4.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -5392,7 +5190,7 @@ async function extractStandardSchemas(compiledJsPath, options = {}) {
     errors: [],
     warnings: []
   };
-  if (!fs5.existsSync(compiledJsPath)) {
+  if (!fs4.existsSync(compiledJsPath)) {
     result.errors.push(`Compiled JS not found: ${compiledJsPath}`);
     return result;
   }
@@ -5508,8 +5306,8 @@ async function extractStandardSchemasFromProject(entryFile, baseDir, options = {
 }
 
 // src/builder/external-resolver.ts
-import * as fs6 from "node:fs";
-import * as path6 from "node:path";
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
 import picomatch from "picomatch";
 import ts14 from "typescript";
 function matchesExternalPattern(packageName, include, exclude) {
@@ -5543,20 +5341,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 = path6.dirname(resolvedPath);
+  let dir = path5.dirname(resolvedPath);
   const maxDepth = 10;
   for (let i = 0;i < maxDepth; i++) {
     if (dir.endsWith(`node_modules/${packageDir}`)) {
-      const pkgPath = path6.join(dir, "package.json");
-      if (fs6.existsSync(pkgPath)) {
+      const pkgPath = path5.join(dir, "package.json");
+      if (fs5.existsSync(pkgPath)) {
         try {
-          return JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+          return JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
         } catch {
           return;
         }
       }
     }
-    const parent = path6.dirname(dir);
+    const parent = path5.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -5800,7 +5598,7 @@ function hasInternalTag(typeName, program, sourceFile) {
 }
 
 // src/builder/verification.ts
-import * as path7 from "node:path";
+import * as path6 from "node:path";
 var BUILTIN_TYPES2 = new Set([
   "Array",
   "ArrayBuffer",
@@ -5889,8 +5687,8 @@ function isExternalType2(definedIn, baseDir) {
     return true;
   if (definedIn.includes("node_modules"))
     return true;
-  const normalizedDefined = path7.resolve(definedIn);
-  const normalizedBase = path7.resolve(baseDir);
+  const normalizedDefined = path6.resolve(definedIn);
+  const normalizedBase = path6.resolve(baseDir);
   return !normalizedDefined.startsWith(normalizedBase);
 }
 function shouldSkipDanglingRef(name) {
@@ -6056,7 +5854,12 @@ async function extract(options) {
     if (!sourceFile) {
       return {
         spec: createEmptySpec(entryFile, includeSchema, isDtsSource),
-        diagnostics: [{ message: `Entry file not found: ${entryFile}. Specify with: drift list src/index.ts`, severity: "error" }]
+        diagnostics: [
+          {
+            message: `Entry file not found: ${entryFile}. Specify with: drift list src/index.ts`,
+            severity: "error"
+          }
+        ]
       };
     }
     const typeChecker = program.getTypeChecker();
@@ -6064,7 +5867,12 @@ async function extract(options) {
     if (!moduleSymbol) {
       return {
         spec: createEmptySpec(entryFile, includeSchema, isDtsSource),
-        diagnostics: [{ message: `No exports found in ${entryFile}. Is this the right entry point?`, severity: "warning" }]
+        diagnostics: [
+          {
+            message: `No exports found in ${entryFile}. Is this the right entry point?`,
+            severity: "warning"
+          }
+        ]
       };
     }
     const exportedSymbols = typeChecker.getExportsOfModule(moduleSymbol);
@@ -6219,7 +6027,7 @@ async function extract(options) {
       }
     }
     const types = ctx.typeRegistry.getAll();
-    const projectBaseDir = baseDir ?? path8.dirname(entryFile);
+    const projectBaseDir = baseDir ?? path7.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) {
@@ -6252,7 +6060,7 @@ async function extract(options) {
     }
     let runtimeMetadata;
     if (options.schemaExtraction === "hybrid") {
-      const projectBaseDir2 = baseDir || path8.dirname(entryFile);
+      const projectBaseDir2 = baseDir || path7.dirname(entryFile);
       const runtimeResult = await extractStandardSchemasFromProject(entryFile, projectBaseDir2, {
         target: options.schemaTarget || "draft-2020-12",
         timeout: 15000
@@ -6541,7 +6349,7 @@ function createEmptySpec(entryFile, includeSchema, isDtsSource) {
   return {
     ...includeSchema ? { $schema: SCHEMA_URL } : {},
     openpkg: SCHEMA_VERSION,
-    meta: { name: path8.basename(entryFile, path8.extname(entryFile)) },
+    meta: { name: path7.basename(entryFile, path7.extname(entryFile)) },
     exports: [],
     generation: {
       generator: "@openpkg-ts/sdk",
@@ -6557,7 +6365,7 @@ function findTypeInProgram(name, checker, program, sourceFile, symFlags) {
   const localSym = checker.resolveName(name, sourceFile, symFlags, false);
   if (localSym)
     return checker.getDeclaredTypeOfSymbol(localSym);
-  const entryDir = path8.dirname(sourceFile.fileName);
+  const entryDir = path7.dirname(sourceFile.fileName);
   for (const sf of program.getSourceFiles()) {
     const fn = sf.fileName;
     if (fn.includes("/typescript/lib/lib.") || fn.includes("\\typescript\\lib\\lib."))
@@ -6573,22 +6381,22 @@ function findTypeInProgram(name, checker, program, sourceFile, symFlags) {
   return;
 }
 async function getPackageMeta(entryFile, baseDir) {
-  let dir = baseDir ?? path8.dirname(entryFile);
-  while (dir !== path8.dirname(dir)) {
-    const pkgPath = path8.join(dir, "package.json");
+  let dir = baseDir ?? path7.dirname(entryFile);
+  while (dir !== path7.dirname(dir)) {
+    const pkgPath = path7.join(dir, "package.json");
     try {
-      if (fs7.existsSync(pkgPath)) {
-        const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+      if (fs6.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
         return {
-          name: pkg.name ?? path8.basename(dir),
+          name: pkg.name ?? path7.basename(dir),
           version: pkg.version,
           description: pkg.description
         };
       }
     } catch {}
-    dir = path8.dirname(dir);
+    dir = path7.dirname(dir);
   }
-  return { name: path8.basename(baseDir ?? path8.dirname(entryFile)) };
+  return { name: path7.basename(baseDir ?? path7.dirname(entryFile)) };
 }
 
 // src/primitives/spec.ts
@@ -6615,8 +6423,6 @@ export {
   typeboxAdapter,
   toSearchIndexJSON,
   toSearchIndex,
-  toReactString,
-  toReact,
   toPagefindRecords,
   toNavigation,
   toMarkdown,