@openpkg-ts/sdk 0.36.0 → 0.37.1

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
@@ -1517,211 +1512,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 +1575,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 +1588,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 +1597,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 +1637,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 +1675,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 +1688,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 +1714,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 +1735,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,6 +1745,21 @@ function isSymbolDeprecated(symbol) {
       }
       return { deprecated: true, reason };
     }
+    if (ts.isExportSpecifier(declaration)) {
+      const exportDecl = declaration.parent?.parent;
+      if (exportDecl && ts.isExportDeclaration(exportDecl)) {
+        const parentTag = ts.getJSDocDeprecatedTag(exportDecl);
+        if (parentTag) {
+          let reason;
+          if (typeof parentTag.comment === "string") {
+            reason = parentTag.comment;
+          } else if (Array.isArray(parentTag.comment)) {
+            reason = parentTag.comment.map((c) => typeof c === "string" ? c : c.text).join("");
+          }
+          return { deprecated: true, reason };
+        }
+      }
+    }
   }
   return { deprecated: false };
 }
@@ -1986,8 +1793,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;
       }
     }
@@ -2001,23 +1808,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.getCallSignatures().length > 0)
+  if (ts.isVariableDeclaration(declaration) && type.getConstructSignatures().length > 0)
+    return "class";
+  if (ts.isVariableDeclaration(declaration) && type.getCallSignatures().length > 0)
     return "function";
   return "variable";
 }
 
+// src/compiler/program.ts
+import * as fs4 from "node:fs";
+import * as path3 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 = 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 = ts2.readConfigFile(refConfigPath, ts2.sys.readFile);
+    if (refConfigFile.error)
+      continue;
+    const refParsed = ts2.parseJsonConfigFileContent(refConfigFile.config, ts2.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 = 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, 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 = 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 = 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 = 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";
 
@@ -2157,6 +2169,63 @@ var ARRAY_PROTOTYPE_METHODS = new Set([
   "toString",
   "toLocaleString"
 ]);
+var STRING_PROTOTYPE_METHODS = new Set([
+  "charAt",
+  "charCodeAt",
+  "codePointAt",
+  "concat",
+  "endsWith",
+  "includes",
+  "indexOf",
+  "lastIndexOf",
+  "localeCompare",
+  "match",
+  "matchAll",
+  "normalize",
+  "padEnd",
+  "padStart",
+  "repeat",
+  "replace",
+  "replaceAll",
+  "search",
+  "slice",
+  "split",
+  "startsWith",
+  "substring",
+  "toLocaleLowerCase",
+  "toLocaleUpperCase",
+  "toLowerCase",
+  "toUpperCase",
+  "trim",
+  "trimEnd",
+  "trimStart",
+  "at",
+  "bold",
+  "fixed",
+  "italics",
+  "link",
+  "small",
+  "strike",
+  "sub",
+  "sup",
+  "anchor",
+  "big",
+  "blink",
+  "fontcolor",
+  "fontsize",
+  "substr",
+  "toString",
+  "valueOf",
+  "length"
+]);
+var NUMBER_PROTOTYPE_METHODS = new Set([
+  "toFixed",
+  "toExponential",
+  "toPrecision",
+  "toString",
+  "valueOf",
+  "toLocaleString"
+]);
 function isPrimitiveName(name) {
   return PRIMITIVES.has(name);
 }
@@ -2301,7 +2370,7 @@ function buildSchemaInternal(type, checker, ctx) {
       return { type: "bigint" };
     if (type.flags & ts3.TypeFlags.ESSymbol)
       return { type: "symbol" };
-    if (type.isThisType?.()) {
+    if (type.isThisType === true) {
       const constraint = type.getConstraint?.();
       const symbol2 = constraint?.getSymbol() ?? type.getSymbol();
       if (symbol2 && !isAnonymous(type)) {
@@ -2521,7 +2590,7 @@ function buildSchemaInternal(type, checker, ctx) {
     return { type: checker.typeToString(type) };
   } finally {
     if (addedToVisited) {
-      ctx.visitedTypes.delete(type);
+      ctx?.visitedTypes.delete(type);
     }
   }
 }
@@ -2556,6 +2625,7 @@ function buildFunctionSchema(callSignatures, checker, ctx) {
   return { type: "function", signatures: buildSignatures() };
 }
 function buildObjectSchema(properties, checker, ctx, originalType) {
+  const isArrayLikeType = originalType ? checker.isArrayType(originalType) || checker.isTupleType(originalType) || originalType.symbol?.getName() === "Array" && isBuiltinSymbol(originalType.symbol) : false;
   const buildProps = () => {
     const props = {};
     const required = [];
@@ -2563,7 +2633,7 @@ function buildObjectSchema(properties, checker, ctx, originalType) {
       const propName = prop.getName();
       if (propName.startsWith("_"))
         continue;
-      if (ARRAY_PROTOTYPE_METHODS.has(propName)) {
+      if (isArrayLikeType && ARRAY_PROTOTYPE_METHODS.has(propName)) {
         continue;
       }
       const propType = checker.getTypeOfSymbol(prop);
@@ -2945,8 +3015,6 @@ function isGenericTypeParameter(name) {
     return true;
   if (/^T[A-Z]/.test(name))
     return true;
-  if (["Key", "Value", "Item", "Element"].includes(name))
-    return true;
   return false;
 }
 function isExternalType(decl) {
@@ -2972,7 +3040,7 @@ class TypeRegistry {
     return Array.from(this.types.values());
   }
   registerType(type, ctx) {
-    const symbol = type.getSymbol() || type.aliasSymbol;
+    const symbol = type.aliasSymbol || type.getSymbol();
     if (!symbol)
       return;
     const name = symbol.getName();
@@ -3027,7 +3095,7 @@ class TypeRegistry {
     }
     let schema = buildSchema(type, checker, ctx);
     if (this.isSelfRef(schema, name)) {
-      schema = this.buildObjectSchemaFromType(type, checker, ctx);
+      schema = this.resolveSelRefSchema(type, checker, ctx);
     }
     return {
       id: name,
@@ -3043,7 +3111,56 @@ class TypeRegistry {
     const obj = schema;
     return obj.$ref === `#/types/${typeName}`;
   }
-  buildObjectSchemaFromType(type, checker, ctx) {
+  resolveSelRefSchema(type, checker, ctx) {
+    if (type.isUnion()) {
+      const types = type.types;
+      const allStringLiterals = types.every((t) => t.flags & ts5.TypeFlags.StringLiteral);
+      if (allStringLiterals) {
+        return {
+          type: "string",
+          enum: types.map((t) => t.value)
+        };
+      }
+      const allNumberLiterals = types.every((t) => t.flags & ts5.TypeFlags.NumberLiteral);
+      if (allNumberLiterals) {
+        return {
+          type: "number",
+          enum: types.map((t) => t.value)
+        };
+      }
+      return {
+        anyOf: types.map((t) => buildSchema(t, checker, ctx))
+      };
+    }
+    const symbol = type.getSymbol() ?? type.aliasSymbol;
+    if (symbol) {
+      const decl = symbol.declarations?.find(ts5.isEnumDeclaration);
+      if (decl) {
+        const members = [];
+        for (const member of decl.members) {
+          const memberSymbol = checker.getSymbolAtLocation(member.name);
+          if (memberSymbol) {
+            const constantValue = checker.getConstantValue(member);
+            if (constantValue !== undefined) {
+              members.push({
+                name: memberSymbol.getName(),
+                value: constantValue
+              });
+            }
+          }
+        }
+        if (members.length > 0) {
+          return {
+            type: typeof members[0].value === "string" ? "string" : "number",
+            enum: members.map((m) => m.value),
+            "x-enum-members": members
+          };
+        }
+      }
+    }
+    return this.buildObjectSchemaFromProperties(type, checker, ctx);
+  }
+  buildObjectSchemaFromProperties(type, checker, ctx) {
     const properties = type.getProperties();
     if (properties.length === 0) {
       return { type: checker.typeToString(type) };
@@ -3055,11 +3172,18 @@ class TypeRegistry {
       const typeName = type.getSymbol()?.getName() ?? "anonymous";
       ctx.onTruncation(typeName, properties.length, limit);
     }
+    const isArrayLike = checker.isArrayType(type) || checker.isTupleType(type) || type.symbol?.getName() === "Array" && type.symbol?.getDeclarations()?.[0]?.getSourceFile()?.fileName?.includes("/typescript/lib/lib.");
+    const isStringLike = type.flags & ts5.TypeFlags.StringLike;
+    const isNumberLike = type.flags & ts5.TypeFlags.NumberLike;
     for (const prop of properties.slice(0, limit)) {
       const propName = prop.getName();
       if (propName.startsWith("_"))
         continue;
-      if (ARRAY_PROTOTYPE_METHODS.has(propName))
+      if (isArrayLike && ARRAY_PROTOTYPE_METHODS.has(propName))
+        continue;
+      if (isStringLike && STRING_PROTOTYPE_METHODS.has(propName))
+        continue;
+      if (isNumberLike && NUMBER_PROTOTYPE_METHODS.has(propName))
         continue;
       const propType = checker.getTypeOfSymbol(prop);
       this.registerType(propType, ctx);
@@ -3091,7 +3215,7 @@ function createContext(program, sourceFile, options = {}) {
     visitedTypes: new Set,
     registeredTypes: new Set,
     includePrivate: options.includePrivate ?? false,
-    maxProperties: options.maxProperties ?? 20,
+    maxProperties: options.maxProperties ?? 100,
     onTruncation: options.onTruncation
   };
 }
@@ -3388,6 +3512,8 @@ function serializeProperty(node, ctx) {
     flags.readonly = true;
   if (node.questionToken)
     flags.optional = true;
+  const symbol = checker.getSymbolAtLocation(node.name ?? node);
+  const { deprecated, reason: deprecationReason } = isSymbolDeprecated(symbol);
   return {
     name,
     kind: "property",
@@ -3395,7 +3521,8 @@ function serializeProperty(node, ctx) {
     tags: tags.length > 0 ? tags : undefined,
     visibility,
     schema,
-    flags: Object.keys(flags).length > 0 ? flags : undefined
+    flags: Object.keys(flags).length > 0 ? flags : undefined,
+    ...deprecated ? { deprecated: true, deprecationReason } : {}
   };
 }
 function serializeMethod(node, ctx) {
@@ -3423,6 +3550,8 @@ function serializeMethod(node, ctx) {
   if (modifiers?.some((m) => m.kind === ts7.SyntaxKind.AbstractKeyword)) {
     flags.abstract = true;
   }
+  const symbol = checker.getSymbolAtLocation(node.name ?? node);
+  const { deprecated, reason: deprecationReason } = isSymbolDeprecated(symbol);
   return {
     name,
     kind: "method",
@@ -3430,7 +3559,8 @@ function serializeMethod(node, ctx) {
     tags: tags.length > 0 ? tags : undefined,
     visibility,
     signatures: signatures.length > 0 ? signatures : undefined,
-    flags: Object.keys(flags).length > 0 ? flags : undefined
+    flags: Object.keys(flags).length > 0 ? flags : undefined,
+    ...deprecated ? { deprecated: true, deprecationReason } : {}
   };
 }
 function serializeConstructor(node, ctx) {
@@ -3616,6 +3746,14 @@ function serializeFunctionExport(node, ctx, nameOverride) {
       ...callSignatures.length > 1 ? { overloadIndex: index } : {}
     };
   });
+  const flags = {};
+  const modifiers = ts8.getModifiers(node);
+  if (modifiers?.some((m) => m.kind === ts8.SyntaxKind.AsyncKeyword)) {
+    flags.async = true;
+  }
+  if (node.asteriskToken) {
+    flags.generator = true;
+  }
   return {
     id: name,
     name,
@@ -3625,6 +3763,7 @@ function serializeFunctionExport(node, ctx, nameOverride) {
     source,
     typeParameters,
     signatures,
+    ...Object.keys(flags).length > 0 ? { flags } : {},
     ...deprecated ? { deprecated: true, deprecationReason } : {},
     ...examples.length > 0 ? { examples } : {}
   };
@@ -3732,13 +3871,16 @@ function serializePropertySignature(node, ctx) {
   if (node.modifiers?.some((m) => m.kind === ts9.SyntaxKind.ReadonlyKeyword)) {
     flags.readonly = true;
   }
+  const symbol = checker.getSymbolAtLocation(node.name);
+  const { deprecated, reason: deprecationReason } = isSymbolDeprecated(symbol);
   return {
     name,
     kind: "property",
     description,
     tags: tags.length > 0 ? tags : undefined,
     schema,
-    flags: Object.keys(flags).length > 0 ? flags : undefined
+    flags: Object.keys(flags).length > 0 ? flags : undefined,
+    ...deprecated ? { deprecated: true, deprecationReason } : {}
   };
 }
 function serializeMethodSignature(node, ctx) {
@@ -3751,13 +3893,16 @@ function serializeMethodSignature(node, ctx) {
   const flags = {};
   if (node.questionToken)
     flags.optional = true;
+  const symbol = checker.getSymbolAtLocation(node.name);
+  const { deprecated, reason: deprecationReason } = isSymbolDeprecated(symbol);
   return {
     name,
     kind: "method",
     description,
     tags: tags.length > 0 ? tags : undefined,
     signatures: signatures.length > 0 ? signatures : undefined,
-    flags: Object.keys(flags).length > 0 ? flags : undefined
+    flags: Object.keys(flags).length > 0 ? flags : undefined,
+    ...deprecated ? { deprecated: true, deprecationReason } : {}
   };
 }
 function serializeCallSignature(node, ctx) {
@@ -4497,12 +4642,20 @@ async function getExport(options) {
   const result = createProgram({ entryFile, baseDir, content });
   const { program, sourceFile } = result;
   if (!sourceFile) {
-    return { export: null, types: [], errors: [`Could not load source file: ${entryFile}`] };
+    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: ["Could not get module symbol"] };
+    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);
@@ -4516,12 +4669,43 @@ async function getExport(options) {
   const ctx = createContext(program, sourceFile, { maxTypeDepth });
   ctx.exportedIds = exportedIds;
   try {
+    const originalDecls = targetSymbol.declarations ?? [];
+    const isNamespaceExportDecl = originalDecls.some((d) => ts11.isNamespaceExport(d) || ts11.isNamespaceImport(d));
+    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
+      };
+    }
     const { declaration, resolvedSymbol, isTypeOnly } = resolveExportTarget(targetSymbol, checker);
     if (!declaration) {
+      const externalPackage = detectExternalPackage(targetSymbol, checker);
+      if (externalPackage) {
+        const stub = {
+          id: exportName,
+          name: exportName,
+          kind: "external",
+          source: { package: externalPackage }
+        };
+        return { export: stub, types: [], errors };
+      }
       return { export: null, types: [], errors: [`No declaration found for '${exportName}'`] };
     }
     let spec = serializeDeclaration(declaration, targetSymbol, resolvedSymbol, exportName, ctx, isTypeOnly);
     if (!spec) {
+      const externalPackage = detectExternalPackage(targetSymbol, checker);
+      if (externalPackage) {
+        const stub = {
+          id: exportName,
+          name: exportName,
+          kind: "external",
+          source: { package: externalPackage }
+        };
+        return { export: stub, types: [], errors };
+      }
       return { export: null, types: [], errors: [`Could not serialize '${exportName}'`] };
     }
     spec = normalizeExport(spec, { dialect: "draft-2020-12" });
@@ -4571,17 +4755,27 @@ function serializeDeclaration(declaration, _exportSymbol, _targetSymbol, exportN
   } else if (ts11.isVariableDeclaration(declaration)) {
     const varStatement = declaration.parent?.parent;
     if (varStatement && ts11.isVariableStatement(varStatement)) {
-      if (declaration.initializer && ts11.isArrowFunction(declaration.initializer)) {
+      if (declaration.initializer && (ts11.isArrowFunction(declaration.initializer) || ts11.isFunctionExpression(declaration.initializer))) {
         const varName = ts11.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
         result = serializeFunctionExport(declaration.initializer, ctx, varName);
       } else {
-        result = serializeVariable(declaration, varStatement, ctx);
+        const checker = ctx.program.getTypeChecker();
+        const varType = checker.getTypeAtLocation(declaration);
+        if (varType.getCallSignatures().length > 0) {
+          result = serializeVariable(declaration, varStatement, ctx);
+          if (result)
+            result = { ...result, kind: "function" };
+        } else {
+          result = serializeVariable(declaration, varStatement, ctx);
+        }
       }
     }
+  } else if (ts11.isNamespaceExport(declaration) || ts11.isModuleDeclaration(declaration) || ts11.isNamespaceImport(declaration) || ts11.isSourceFile(declaration)) {
+    result = serializeNamespaceForGet(_exportSymbol, exportName, ctx);
   }
   if (result) {
     if (result.name !== exportName) {
-      result = { ...result, id: exportName, name: result.name };
+      result = { ...result, id: exportName, name: exportName };
     }
     if (isTypeOnly) {
       result = { ...result, flags: { ...result.flags ?? {}, typeOnly: true } };
@@ -4589,6 +4783,65 @@ function serializeDeclaration(declaration, _exportSymbol, _targetSymbol, exportN
   }
   return result;
 }
+function serializeNamespaceForGet(symbol, exportName, ctx) {
+  const checker = ctx.program.getTypeChecker();
+  let targetSymbol = symbol;
+  if (symbol.flags & ts11.SymbolFlags.Alias) {
+    const aliased = checker.getAliasedSymbol(symbol);
+    if (aliased && aliased !== symbol) {
+      targetSymbol = aliased;
+    }
+  }
+  const members = [];
+  try {
+    const nsExports = checker.getExportsOfModule(targetSymbol);
+    for (const memberSymbol of nsExports) {
+      const memberName = memberSymbol.getName();
+      const memberDecls = memberSymbol.declarations ?? [];
+      const memberDecl = memberSymbol.valueDeclaration || memberDecls[0];
+      if (memberDecl) {
+        const type = checker.getTypeAtLocation(memberDecl);
+        const kind = getExportKind(memberDecl, type);
+        members.push({ name: memberName, kind });
+      }
+    }
+  } catch {}
+  return {
+    id: exportName,
+    name: exportName,
+    kind: "namespace",
+    tags: [],
+    ...members.length > 0 ? { members } : {}
+  };
+}
+function detectExternalPackage(symbol, checker) {
+  let targetSymbol = symbol;
+  if (symbol.flags & ts11.SymbolFlags.Alias) {
+    const aliased = checker.getAliasedSymbol(symbol);
+    if (aliased && aliased !== symbol) {
+      targetSymbol = aliased;
+    }
+  }
+  const allDecls = [...targetSymbol.declarations ?? [], ...symbol.declarations ?? []];
+  for (const decl of allDecls) {
+    const sf = decl.getSourceFile();
+    if (sf?.fileName.includes("node_modules")) {
+      const match = sf.fileName.match(/node_modules\/(@[^/]+\/[^/]+|[^/]+)/);
+      if (match)
+        return match[1];
+    }
+    if (ts11.isExportSpecifier(decl)) {
+      const exportDecl = decl.parent?.parent;
+      if (exportDecl && ts11.isExportDeclaration(exportDecl) && exportDecl.moduleSpecifier) {
+        const moduleText = exportDecl.moduleSpecifier.text;
+        if (!moduleText.startsWith(".") && !moduleText.startsWith("/")) {
+          return moduleText;
+        }
+      }
+    }
+  }
+  return;
+}
 // src/primitives/list.ts
 import * as path4 from "node:path";
 import ts12 from "typescript";
@@ -4599,12 +4852,18 @@ async function listExports(options) {
   const result = createProgram({ entryFile, baseDir, content });
   const { program, sourceFile } = result;
   if (!sourceFile) {
-    return { exports: [], errors: [`Could not load source file: ${entryFile}`] };
+    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: ["Could not get module symbol"] };
+    return {
+      exports: [],
+      errors: [`No exports found in ${entryFile}. Is this the right entry point?`]
+    };
   }
   const exportedSymbols = checker.getExportsOfModule(moduleSymbol);
   for (const symbol of exportedSymbols) {
@@ -4632,8 +4891,15 @@ function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
   }
   const declarations = targetSymbol.declarations ?? [];
   const declaration = targetSymbol.valueDeclaration || declarations.find((d) => d.kind !== ts12.SyntaxKind.ExportSpecifier) || declarations[0];
-  if (!declaration)
-    return null;
+  if (!declaration) {
+    return {
+      name,
+      kind: "external",
+      file: "<external>",
+      line: 0,
+      reexport: true
+    };
+  }
   if (ts12.isSourceFile(declaration)) {
     return {
       name,
@@ -5803,7 +6069,12 @@ async function extract(options) {
     if (!sourceFile) {
       return {
         spec: createEmptySpec(entryFile, includeSchema, isDtsSource),
-        diagnostics: [{ message: `Could not load source file: ${entryFile}`, severity: "error" }]
+        diagnostics: [
+          {
+            message: `Entry file not found: ${entryFile}. Specify with: drift list src/index.ts`,
+            severity: "error"
+          }
+        ]
       };
     }
     const typeChecker = program.getTypeChecker();
@@ -5811,7 +6082,12 @@ async function extract(options) {
     if (!moduleSymbol) {
       return {
         spec: createEmptySpec(entryFile, includeSchema, isDtsSource),
-        diagnostics: [{ message: "Could not get module symbol", severity: "warning" }]
+        diagnostics: [
+          {
+            message: `No exports found in ${entryFile}. Is this the right entry point?`,
+            severity: "warning"
+          }
+        ]
       };
     }
     const exportedSymbols = typeChecker.getExportsOfModule(moduleSymbol);
@@ -6091,11 +6367,17 @@ function serializeDeclaration2(declaration, exportSymbol, exportName, ctx, isTyp
   } else if (ts16.isVariableDeclaration(declaration)) {
     const varStatement = declaration.parent?.parent;
     if (varStatement && ts16.isVariableStatement(varStatement)) {
-      if (declaration.initializer && ts16.isArrowFunction(declaration.initializer)) {
+      if (declaration.initializer && (ts16.isArrowFunction(declaration.initializer) || ts16.isFunctionExpression(declaration.initializer))) {
         const varName = ts16.isIdentifier(declaration.name) ? declaration.name.text : declaration.name.getText();
         result = serializeFunctionExport(declaration.initializer, ctx, varName);
       } else {
         result = serializeVariable(declaration, varStatement, ctx);
+        if (result?.kind === "variable") {
+          const type = ctx.typeChecker.getTypeAtLocation(declaration);
+          if (type.getConstructSignatures().length > 0) {
+            result = { ...result, kind: "class" };
+          }
+        }
       }
     }
   } else if (ts16.isNamespaceExport(declaration) || ts16.isModuleDeclaration(declaration) || ts16.isNamespaceImport(declaration) || ts16.isSourceFile(declaration)) {
@@ -6120,6 +6402,12 @@ function serializeDeclaration2(declaration, exportSymbol, exportName, ctx, isTyp
         flags: { ...result.flags ?? {}, typeOnly: true }
       };
     }
+    if (!result.deprecated) {
+      const { deprecated, reason: deprecationReason } = isSymbolDeprecated(exportSymbol);
+      if (deprecated) {
+        result = { ...result, deprecated: true, deprecationReason };
+      }
+    }
   }
   return result;
 }
@@ -6167,7 +6455,7 @@ function serializeNamespaceMember(symbol, memberName, ctx) {
     return null;
   const type = checker.getTypeAtLocation(declaration);
   const callSignatures = type.getCallSignatures();
-  const deprecated = isSymbolDeprecated(targetSymbol);
+  const { deprecated } = isSymbolDeprecated(targetSymbol);
   let kind = "variable";
   if (ts16.isFunctionDeclaration(declaration) || ts16.isFunctionExpression(declaration)) {
     kind = "function";
@@ -6446,8 +6734,10 @@ export {
   arktypeAdapter,
   analyzeSpec,
   TypeRegistry,
+  STRING_PROTOTYPE_METHODS,
   QueryBuilder,
   PRIMITIVES,
+  NUMBER_PROTOTYPE_METHODS,
   CacheManager,
   CONFIG_FILENAME,
   BUILTIN_TYPE_SCHEMAS,