@oxog/npm-llms 1.0.0

package/dist/plugins/index.cjs

@@ -0,0 +1,4171 @@
+'use strict';
+
+var zlib = require('zlib');
+
+// src/errors.ts
+var NpmLlmsError = class extends Error {
+  /**
+   * Create a new NpmLlmsError
+   * @param message - Error message
+   * @param code - Error code
+   * @param details - Additional error details
+   */
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "NpmLlmsError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * Convert error to JSON
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      details: this.details
+    };
+  }
+};
+var PackageNotFoundError = class extends NpmLlmsError {
+  constructor(packageName) {
+    super(`Package "${packageName}" not found on npm`, "PACKAGE_NOT_FOUND", { packageName });
+    this.name = "PackageNotFoundError";
+  }
+};
+var VersionNotFoundError = class extends NpmLlmsError {
+  constructor(packageName, version) {
+    super(`Version "${version}" not found for package "${packageName}"`, "VERSION_NOT_FOUND", {
+      packageName,
+      version
+    });
+    this.name = "VersionNotFoundError";
+  }
+};
+var DownloadError = class extends NpmLlmsError {
+  constructor(message, url) {
+    super(message, "DOWNLOAD_FAILED", { url });
+    this.name = "DownloadError";
+  }
+};
+var AIError = class extends NpmLlmsError {
+  constructor(message, provider) {
+    super(message, "AI_ERROR", { provider });
+    this.name = "AIError";
+  }
+};
+var PluginError = class extends NpmLlmsError {
+  constructor(message, pluginName) {
+    super(message, "PLUGIN_ERROR", { pluginName });
+    this.name = "PluginError";
+  }
+};
+var TarError = class extends NpmLlmsError {
+  constructor(message, offset) {
+    super(message, "TAR_ERROR", { offset });
+    this.name = "TarError";
+  }
+};
+var TimeoutError = class extends NpmLlmsError {
+  constructor(message, timeout) {
+    super(message, "TIMEOUT_ERROR", { timeout });
+    this.name = "TimeoutError";
+  }
+};
+var ValidationError = class extends NpmLlmsError {
+  constructor(message, field) {
+    super(message, "VALIDATION_ERROR", { field });
+    this.name = "ValidationError";
+  }
+};
+var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+var DEFAULT_TIMEOUT = 3e4;
+function createTimeoutController(timeout) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => {
+    controller.abort();
+  }, timeout);
+  return {
+    controller,
+    cleanup: () => clearTimeout(timeoutId)
+  };
+}
+async function fetchJson(url, options = {}) {
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  const { controller, cleanup } = createTimeoutController(timeout);
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        ...options.headers
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new DownloadError(`HTTP ${response.status}: ${response.statusText}`, url);
+    }
+    const data = await response.json();
+    return {
+      data,
+      status: response.status,
+      headers: response.headers
+    };
+  } catch (error) {
+    if (error instanceof DownloadError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        throw new TimeoutError(`Request timed out after ${timeout}ms`, timeout);
+      }
+      throw new DownloadError(error.message, url);
+    }
+    throw new DownloadError("Unknown fetch error", url);
+  } finally {
+    cleanup();
+  }
+}
+async function fetchBinary(url, options = {}) {
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  const { controller, cleanup } = createTimeoutController(timeout);
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/octet-stream",
+        ...options.headers
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new DownloadError(`HTTP ${response.status}: ${response.statusText}`, url);
+    }
+    const data = await response.arrayBuffer();
+    return {
+      data,
+      status: response.status,
+      headers: response.headers
+    };
+  } catch (error) {
+    if (error instanceof DownloadError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        throw new TimeoutError(`Request timed out after ${timeout}ms`, timeout);
+      }
+      throw new DownloadError(error.message, url);
+    }
+    throw new DownloadError("Unknown fetch error", url);
+  } finally {
+    cleanup();
+  }
+}
+async function fetchGzipped(url, options = {}) {
+  const { data: gzipped } = await fetchBinary(url, options);
+  try {
+    return zlib.gunzipSync(Buffer.from(gzipped));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown decompression error";
+    throw new DownloadError(`Failed to decompress gzip: ${message}`, url);
+  }
+}
+function encodePackageName(name) {
+  if (name.startsWith("@")) {
+    const slashIndex = name.indexOf("/");
+    if (slashIndex === -1) {
+      return encodeURIComponent(name);
+    }
+    const scope = name.slice(0, slashIndex);
+    const pkg = name.slice(slashIndex + 1);
+    return `${scope}%2F${encodeURIComponent(pkg)}`;
+  }
+  return encodeURIComponent(name);
+}
+function buildPackageUrl(name, version, registry = DEFAULT_REGISTRY) {
+  const encodedName = encodePackageName(name);
+  const base = `${registry}/${encodedName}`;
+  return version ? `${base}/${version}` : base;
+}
+
+// src/utils/tar.ts
+var BLOCK_SIZE = 512;
+var TAR_TYPES = {
+  FILE: "0",
+  FILE_ALT: "",
+  GNU_LONGNAME: "L"};
+var decoder = new TextDecoder("utf-8");
+function isZeroBlock(buffer, offset) {
+  const end = Math.min(offset + BLOCK_SIZE, buffer.length);
+  for (let i = offset; i < end; i++) {
+    if (buffer[i] !== 0) return false;
+  }
+  return true;
+}
+function parseOctal(buffer, offset, length) {
+  const bytes = buffer.slice(offset, offset + length);
+  const str = decoder.decode(bytes).replace(/\0/g, "").trim();
+  if (!str) return 0;
+  return parseInt(str, 8) || 0;
+}
+function parseString(buffer, offset, length) {
+  const bytes = buffer.slice(offset, offset + length);
+  const str = decoder.decode(bytes);
+  const nullIndex = str.indexOf("\0");
+  return nullIndex >= 0 ? str.slice(0, nullIndex) : str;
+}
+function calculateChecksum(buffer, offset) {
+  let sum = 0;
+  for (let i = 0; i < BLOCK_SIZE; i++) {
+    if (i >= 148 && i < 156) {
+      sum += 32;
+    } else {
+      sum += buffer[offset + i] ?? 0;
+    }
+  }
+  return sum;
+}
+function parseTarHeader(buffer, offset) {
+  if (isZeroBlock(buffer, offset)) {
+    return null;
+  }
+  if (offset + BLOCK_SIZE > buffer.length) {
+    throw new TarError("Unexpected end of tar archive", offset);
+  }
+  const name = parseString(buffer, offset, 100);
+  const mode = parseOctal(buffer, offset + 100, 8);
+  const uid = parseOctal(buffer, offset + 108, 8);
+  const gid = parseOctal(buffer, offset + 116, 8);
+  const size = parseOctal(buffer, offset + 124, 12);
+  const mtime = parseOctal(buffer, offset + 136, 12);
+  const checksum = parseOctal(buffer, offset + 148, 8);
+  const type = parseString(buffer, offset + 156, 1);
+  const linkname = parseString(buffer, offset + 157, 100);
+  const calculatedChecksum = calculateChecksum(buffer, offset);
+  if (checksum !== 0 && checksum !== calculatedChecksum) {
+    throw new TarError(`Invalid tar header checksum: expected ${checksum}, got ${calculatedChecksum}`, offset);
+  }
+  const magic = parseString(buffer, offset + 257, 6);
+  let fullName = name;
+  if (magic === "ustar" || magic === "ustar ") {
+    const prefix = parseString(buffer, offset + 345, 155);
+    if (prefix) {
+      fullName = `${prefix}/${name}`;
+    }
+  }
+  return {
+    name: fullName,
+    mode,
+    uid,
+    gid,
+    size,
+    mtime,
+    checksum,
+    type,
+    linkname
+  };
+}
+function sanitizePath(path) {
+  let normalized = path.replace(/\\/g, "/");
+  if (normalized.startsWith("/")) {
+    normalized = normalized.slice(1);
+  }
+  const parts = normalized.split("/");
+  const safeParts = [];
+  for (const part of parts) {
+    if (part === "..") {
+      throw new TarError(`Path traversal detected: ${path}`);
+    }
+    if (part && part !== ".") {
+      safeParts.push(part);
+    }
+  }
+  return safeParts.join("/");
+}
+function removePackagePrefix(path) {
+  const prefixes = ["package/", "package\\"];
+  for (const prefix of prefixes) {
+    if (path.startsWith(prefix)) {
+      return path.slice(prefix.length);
+    }
+  }
+  return path;
+}
+function getEntryType(_type) {
+  return "file";
+}
+function shouldExtract(path) {
+  const lower = path.toLowerCase();
+  if (lower.endsWith(".d.ts") || lower.endsWith(".d.mts") || lower.endsWith(".d.cts")) {
+    return true;
+  }
+  if (lower.endsWith(".ts") || lower.endsWith(".tsx") || lower.endsWith(".js") || lower.endsWith(".mjs") || lower.endsWith(".cjs") || lower.endsWith(".jsx")) {
+    return true;
+  }
+  if (lower.endsWith(".md") || lower.endsWith(".txt") || lower.endsWith(".json") || lower.endsWith(".yaml") || lower.endsWith(".yml")) {
+    return true;
+  }
+  const filename = path.split("/").pop() ?? "";
+  if (filename === "package.json" || filename === "README.md" || filename === "CHANGELOG.md" || filename === "LICENSE" || filename === "LICENSE.md") {
+    return true;
+  }
+  return false;
+}
+function* extractTarSync(buffer) {
+  const data = buffer instanceof Buffer ? new Uint8Array(buffer) : new Uint8Array(buffer);
+  let offset = 0;
+  let gnuLongName = null;
+  while (offset < data.length) {
+    const header = parseTarHeader(data, offset);
+    if (!header) {
+      break;
+    }
+    offset += BLOCK_SIZE;
+    if (header.type === TAR_TYPES.GNU_LONGNAME) {
+      const contentBytes = data.slice(offset, offset + header.size);
+      gnuLongName = decoder.decode(contentBytes).replace(/\0/g, "");
+      offset += Math.ceil(header.size / BLOCK_SIZE) * BLOCK_SIZE;
+      continue;
+    }
+    const entryName = gnuLongName ?? header.name;
+    gnuLongName = null;
+    if (header.type !== TAR_TYPES.FILE && header.type !== TAR_TYPES.FILE_ALT) {
+      offset += Math.ceil(header.size / BLOCK_SIZE) * BLOCK_SIZE;
+      continue;
+    }
+    let path;
+    try {
+      path = sanitizePath(entryName);
+      path = removePackagePrefix(path);
+    } catch {
+      offset += Math.ceil(header.size / BLOCK_SIZE) * BLOCK_SIZE;
+      continue;
+    }
+    if (!shouldExtract(path)) {
+      offset += Math.ceil(header.size / BLOCK_SIZE) * BLOCK_SIZE;
+      continue;
+    }
+    const content = data.slice(offset, offset + header.size);
+    const textContent = decoder.decode(content);
+    yield {
+      path,
+      content: textContent,
+      size: header.size,
+      type: getEntryType(header.type)
+    };
+    offset += Math.ceil(header.size / BLOCK_SIZE) * BLOCK_SIZE;
+  }
+}
+function extractTarToMap(buffer) {
+  const files = /* @__PURE__ */ new Map();
+  for (const entry of extractTarSync(buffer)) {
+    if (entry.type === "file") {
+      files.set(entry.path, entry.content);
+    }
+  }
+  return files;
+}
+
+// src/core/fetcher.ts
+function validatePackageName(name) {
+  if (!name || typeof name !== "string") {
+    throw new ValidationError("Package name is required", "name");
+  }
+  const validPattern = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+  if (!validPattern.test(name)) {
+    throw new ValidationError(
+      `Invalid package name: "${name}". Package names must be lowercase and may contain letters, numbers, hyphens, dots, and underscores.`,
+      "name"
+    );
+  }
+  if (name.length > 214) {
+    throw new ValidationError("Package name cannot exceed 214 characters", "name");
+  }
+}
+function parsePackageSpec(spec) {
+  if (!spec || typeof spec !== "string") {
+    throw new ValidationError("Package specifier is required", "spec");
+  }
+  const trimmed = spec.trim();
+  if (trimmed.startsWith("@")) {
+    const firstSlash = trimmed.indexOf("/");
+    if (firstSlash === -1) {
+      throw new ValidationError(`Invalid scoped package: "${spec}"`, "spec");
+    }
+    const afterScope = trimmed.slice(firstSlash + 1);
+    const versionSep = afterScope.lastIndexOf("@");
+    if (versionSep > 0) {
+      const name = trimmed.slice(0, firstSlash + 1 + versionSep);
+      const version = afterScope.slice(versionSep + 1);
+      return { name, version: version || void 0 };
+    }
+    return { name: trimmed };
+  }
+  const atIndex = trimmed.lastIndexOf("@");
+  if (atIndex > 0) {
+    const name = trimmed.slice(0, atIndex);
+    const version = trimmed.slice(atIndex + 1);
+    return { name, version: version || void 0 };
+  }
+  return { name: trimmed };
+}
+function resolveVersion(packageName, versions, distTags, requested) {
+  if (!requested) {
+    const latest = distTags["latest"];
+    if (latest && versions.includes(latest)) {
+      return latest;
+    }
+    return versions.sort(compareVersions).pop();
+  }
+  if (distTags[requested]) {
+    return distTags[requested];
+  }
+  if (versions.includes(requested)) {
+    return requested;
+  }
+  const matching = versions.filter((v) => v.startsWith(requested));
+  if (matching.length > 0) {
+    return matching.sort(compareVersions).pop();
+  }
+  throw new VersionNotFoundError(packageName, requested);
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map((n) => parseInt(n, 10) || 0);
+  const pb = b.split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const na = pa[i] || 0;
+    const nb = pb[i] || 0;
+    if (na !== nb) return na - nb;
+  }
+  return 0;
+}
+async function fetchPackageMetadata(name, version, options = {}) {
+  validatePackageName(name);
+  const registry = options.registry ?? DEFAULT_REGISTRY;
+  const httpOptions = { timeout: options.timeout };
+  if (version && !["latest", "next", "beta", "alpha"].includes(version)) {
+    try {
+      const url2 = buildPackageUrl(name, version, registry);
+      const { data } = await fetchJson(url2, httpOptions);
+      return extractMetadata(data);
+    } catch (error) {
+      if (!(error instanceof DownloadError) || !error.message.includes("404")) {
+        throw error;
+      }
+    }
+  }
+  const url = buildPackageUrl(name, void 0, registry);
+  try {
+    const { data } = await fetchJson(url, httpOptions);
+    const versions = Object.keys(data.versions ?? {});
+    if (versions.length === 0) {
+      throw new PackageNotFoundError(name);
+    }
+    const resolvedVersion = resolveVersion(
+      name,
+      versions,
+      data["dist-tags"] ?? {},
+      version
+    );
+    const versionData = data.versions[resolvedVersion];
+    if (!versionData) {
+      throw new VersionNotFoundError(name, resolvedVersion);
+    }
+    return extractMetadata(versionData);
+  } catch (error) {
+    if (error instanceof DownloadError && error.message.includes("404")) {
+      throw new PackageNotFoundError(name);
+    }
+    throw error;
+  }
+}
+function extractMetadata(data) {
+  if (!data.dist?.tarball) {
+    throw new DownloadError("Package metadata missing tarball URL");
+  }
+  let repository;
+  if (data.repository) {
+    if (typeof data.repository === "string") {
+      repository = { type: "git", url: data.repository };
+    } else {
+      repository = data.repository;
+    }
+  }
+  return {
+    name: data.name,
+    version: data.version,
+    description: data.description,
+    tarball: data.dist.tarball,
+    types: data.types ?? data.typings,
+    main: data.main,
+    exports: data.exports,
+    repository,
+    keywords: data.keywords,
+    author: data.author,
+    license: data.license,
+    homepage: data.homepage
+  };
+}
+async function downloadPackageFiles(tarballUrl, options = {}) {
+  const buffer = await fetchGzipped(tarballUrl, options);
+  return extractTarToMap(buffer);
+}
+async function fetchPackage(spec, options = {}) {
+  const { name, version } = parsePackageSpec(spec);
+  const metadata = await fetchPackageMetadata(name, version, options);
+  const files = await downloadPackageFiles(metadata.tarball, {
+    timeout: options.timeout
+  });
+  return {
+    ...metadata,
+    files
+  };
+}
+
+// src/plugins/core/types-resolver.ts
+function hasDtsFiles(files) {
+  for (const path of files.keys()) {
+    if (path.endsWith(".d.ts")) {
+      return true;
+    }
+  }
+  return false;
+}
+function getTypesPackageName(packageName) {
+  if (packageName.startsWith("@")) {
+    const withoutAt = packageName.slice(1);
+    return `@types/${withoutAt.replace("/", "__")}`;
+  }
+  return `@types/${packageName}`;
+}
+function isTypesPackage(packageName) {
+  return packageName.startsWith("@types/");
+}
+var typesResolverPlugin = {
+  name: "types-resolver",
+  version: "1.0.0",
+  category: "parser",
+  install(kernel) {
+    kernel.on("package:fetched", async (context) => {
+      const { files, name } = context.package;
+      if (isTypesPackage(name)) {
+        return;
+      }
+      if (hasDtsFiles(files)) {
+        return;
+      }
+      const typesPackageName = getTypesPackageName(name);
+      try {
+        const typesPackage = await fetchPackage(typesPackageName);
+        let mergedCount = 0;
+        for (const [path, content] of typesPackage.files) {
+          if (path.endsWith(".d.ts")) {
+            const newPath = `__types__/${path}`;
+            files.set(newPath, content);
+            mergedCount++;
+          }
+        }
+        if (typesPackage.types && !context.package.types) {
+          context.package.types = `__types__/${typesPackage.types}`;
+        }
+        if (mergedCount > 0) {
+          console.error(
+            `[types-resolver] Merged ${mergedCount} .d.ts files from ${typesPackageName}`
+          );
+        }
+      } catch (error) {
+      }
+    });
+  }
+};
+
+// src/parsers/jsdoc.ts
+var TAG_PATTERNS = {
+  /** @param {type} name - description */
+  param: /@param\s+(?:\{([^}]*)\})?\s*(\[?\w+(?:\.\w+)*\]?)\s*(?:-\s*)?(.*)$/gm,
+  /** @returns {type} description */
+  returns: /@returns?\s+(?:\{([^}]*)\})?\s*(.*)/g,
+  /** @example ... */
+  example: /@example\s*([\s\S]*?)(?=@\w|$)/g,
+  /** @deprecated reason */
+  deprecated: /@deprecated\s*(.*)/g,
+  /** @since version */
+  since: /@since\s*(.*)/g,
+  /** @see reference */
+  see: /@see\s*(.*)/g,
+  /** @throws {type} description */
+  throws: /@throws?\s+(?:\{([^}]*)\})?\s*(.*)/g,
+  /** @template T - description */
+  typeParam: /@template\s+(\w+)\s*(?:-\s*)?(.*)/g};
+function cleanJSDocComment(comment) {
+  return comment.replace(/^\/\*\*\s*/, "").replace(/\s*\*\/$/, "").replace(/^\s*\*\s?/gm, "").trim();
+}
+function extractDescription(content) {
+  const tagMatch = content.match(/@\w+/);
+  if (!tagMatch) {
+    return content.trim() || void 0;
+  }
+  const description = content.slice(0, tagMatch.index).trim();
+  return description || void 0;
+}
+function parseParams(content) {
+  const params = [];
+  const pattern = new RegExp(TAG_PATTERNS.param.source, "gm");
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const [, type, rawName, description] = match;
+    if (!rawName) continue;
+    const name = rawName;
+    const isOptional = name.startsWith("[") && name.endsWith("]");
+    const cleanName = isOptional ? name.slice(1, -1) : name;
+    params.push({
+      name: cleanName,
+      type: type?.trim(),
+      description: description?.trim() || void 0,
+      optional: isOptional
+    });
+  }
+  return params;
+}
+function parseReturns(content) {
+  const pattern = new RegExp(TAG_PATTERNS.returns.source, "g");
+  const match = pattern.exec(content);
+  if (!match) return void 0;
+  const [, type, description] = match;
+  return {
+    type: type?.trim(),
+    description: description?.trim() || void 0
+  };
+}
+function parseExamples(content) {
+  const examples = [];
+  const pattern = new RegExp(TAG_PATTERNS.example.source, "g");
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const example = match[1]?.trim();
+    if (example) {
+      examples.push(example);
+    }
+  }
+  return examples;
+}
+function parseDeprecated(content) {
+  const pattern = new RegExp(TAG_PATTERNS.deprecated.source, "g");
+  const match = pattern.exec(content);
+  return match ? match[1]?.trim() || "true" : void 0;
+}
+function parseSince(content) {
+  const pattern = new RegExp(TAG_PATTERNS.since.source, "g");
+  const match = pattern.exec(content);
+  return match ? match[1]?.trim() : void 0;
+}
+function parseSee(content) {
+  const refs = [];
+  const pattern = new RegExp(TAG_PATTERNS.see.source, "g");
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const ref = match[1]?.trim();
+    if (ref) {
+      refs.push(ref);
+    }
+  }
+  return refs;
+}
+function parseThrows(content) {
+  const throws = [];
+  const pattern = new RegExp(TAG_PATTERNS.throws.source, "g");
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const [, type, description] = match;
+    throws.push({
+      type: type?.trim(),
+      description: description?.trim() || void 0
+    });
+  }
+  return throws;
+}
+function parseTypeParams(content) {
+  const params = [];
+  const pattern = new RegExp(TAG_PATTERNS.typeParam.source, "g");
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const [, name, description] = match;
+    if (!name) continue;
+    params.push({
+      name: name.trim(),
+      description: description?.trim() || void 0
+    });
+  }
+  return params;
+}
+function parseJSDoc(comment) {
+  const content = cleanJSDocComment(comment);
+  return {
+    description: extractDescription(content),
+    params: parseParams(content).map((p) => ({
+      name: p.name,
+      type: p.type,
+      description: p.description,
+      optional: p.optional,
+      defaultValue: p.defaultValue
+    })),
+    returns: parseReturns(content),
+    examples: parseExamples(content),
+    deprecated: parseDeprecated(content),
+    since: parseSince(content),
+    see: parseSee(content),
+    throws: parseThrows(content),
+    typeParams: parseTypeParams(content)
+  };
+}
+function extractJSDocComments(source) {
+  const comments = [];
+  const pattern = /\/\*\*[\s\S]*?\*\//g;
+  let match;
+  while ((match = pattern.exec(source)) !== null) {
+    comments.push({
+      comment: match[0],
+      start: match.index,
+      end: match.index + match[0].length
+    });
+  }
+  return comments;
+}
+function findPrecedingJSDoc(source, position, comments) {
+  const allComments = comments ?? extractJSDocComments(source);
+  for (let i = allComments.length - 1; i >= 0; i--) {
+    const comment = allComments[i];
+    if (!comment || comment.end > position) continue;
+    const between = source.slice(comment.end, position);
+    if (/^\s*$/.test(between)) {
+      return parseJSDoc(comment.comment);
+    }
+    if (comment.end < position - 500) break;
+  }
+  return void 0;
+}
+
+// src/parsers/dts.ts
+var PATTERNS = {
+  /** Export function declaration */
+  exportFunction: /export\s+(?:declare\s+)?function\s+(\w+)\s*(<[^>]*>)?\s*\(([^)]*)\)\s*:\s*([^;{]+)/g,
+  /** Export const declaration */
+  exportConst: /export\s+(?:declare\s+)?const\s+(\w+)\s*:\s*([^;=]+)/g,
+  /** Export class declaration */
+  exportClass: /export\s+(?:declare\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s*<([^>]*)>)?(?:\s+extends\s+([^\s{]+))?(?:\s+implements\s+([^{]+))?\s*\{/g,
+  /** Export interface declaration */
+  exportInterface: /export\s+(?:declare\s+)?interface\s+(\w+)(?:\s*<([^>]*)>)?(?:\s+extends\s+([^{]+))?\s*\{/g,
+  /** Export type declaration */
+  exportType: /export\s+(?:declare\s+)?type\s+(\w+)(?:\s*<([^>]*)>)?\s*=\s*([^;]+)/g,
+  /** Export enum declaration */
+  exportEnum: /export\s+(?:declare\s+)?(?:const\s+)?enum\s+(\w+)\s*\{/g,
+  /** Import statement */
+  importStatement: /import\s*(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s*from\s*['"]([^'"]+)['"]/g,
+  /** Declare module (module augmentation) */
+  declareModule: /declare\s+module\s+['"]([^'"]+)['"]\s*\{/g};
+function parseParameters(paramStr) {
+  if (!paramStr.trim()) return [];
+  const params = [];
+  const parts = splitParameters(paramStr);
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      const colonIndex = findTypeColonIndex(trimmed);
+      if (colonIndex > 0) {
+        params.push({
+          name: "options",
+          type: trimmed.slice(colonIndex + 1).trim(),
+          optional: trimmed.includes("?")
+        });
+      }
+      continue;
+    }
+    const match = trimmed.match(/^(\w+)(\?)?\s*:\s*(.+?)(?:\s*=\s*(.+))?$/);
+    if (match) {
+      const [, name, optional, type, defaultValue] = match;
+      if (name && type) {
+        params.push({
+          name,
+          type: type.trim(),
+          optional: !!optional,
+          defaultValue: defaultValue?.trim()
+        });
+      }
+    } else {
+      const nameMatch = trimmed.match(/^(\w+)(\?)?$/);
+      if (nameMatch && nameMatch[1]) {
+        params.push({
+          name: nameMatch[1],
+          type: "unknown",
+          optional: !!nameMatch[2]
+        });
+      }
+    }
+  }
+  return params;
+}
+function splitParameters(paramStr) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  for (let i = 0; i < paramStr.length; i++) {
+    const char = paramStr[i];
+    if (char === "<" || char === "{" || char === "[" || char === "(") {
+      depth++;
+      current += char;
+    } else if (char === ">" || char === "}" || char === "]" || char === ")") {
+      depth--;
+      current += char;
+    } else if (char === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) {
+    parts.push(current);
+  }
+  return parts;
+}
+function findTypeColonIndex(str) {
+  let depth = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i];
+    if (char === "{" || char === "[" || char === "<" || char === "(") {
+      depth++;
+    } else if (char === "}" || char === "]" || char === ">" || char === ")") {
+      depth--;
+    } else if (char === ":" && depth === 0) {
+      return i;
+    }
+  }
+  return -1;
+}
+function extractBody(source, startIndex) {
+  let depth = 0;
+  let i = startIndex;
+  while (i < source.length) {
+    if (source[i] === "{") depth++;
+    else if (source[i] === "}") {
+      depth--;
+      if (depth === 0) break;
+    }
+    i++;
+  }
+  return source.slice(startIndex + 1, i);
+}
+function parseClassMembers(body, comments, bodyOffset) {
+  const methods = [];
+  const properties = [];
+  const methodPattern = /(?:(?:public|private|protected|static|readonly)\s+)*(\w+)\s*(<[^>]*>)?\s*\(([^)]*)\)\s*:\s*([^;{]+)/g;
+  let match;
+  while ((match = methodPattern.exec(body)) !== null) {
+    const [fullMatch, name, generics, params, returnType] = match;
+    if (!name || !returnType) continue;
+    const jsdoc = findPrecedingJSDoc(body, match.index, comments.map((c) => ({
+      ...c,
+      start: c.start - bodyOffset,
+      end: c.end - bodyOffset
+    })));
+    methods.push({
+      kind: "function",
+      name,
+      signature: `${name}${generics || ""}(${params || ""}): ${returnType.trim()}`,
+      description: jsdoc?.description,
+      params: mergeParamDocs(parseParameters(params || ""), jsdoc?.params),
+      returns: {
+        type: returnType.trim(),
+        description: jsdoc?.returns?.description
+      },
+      examples: jsdoc?.examples
+    });
+  }
+  const propPattern = /(?:(?:public|private|protected|static|readonly)\s+)*(\w+)(\?)?\s*:\s*([^;]+)/g;
+  while ((match = propPattern.exec(body)) !== null) {
+    const [, name, optional, type] = match;
+    if (!name || !type) continue;
+    if (type.includes("=>") || type.includes("(")) continue;
+    properties.push({
+      kind: "constant",
+      name,
+      signature: `${name}${optional || ""}: ${type.trim()}`,
+      description: findPrecedingJSDoc(body, match.index)?.description
+    });
+  }
+  return { methods, properties };
+}
+function mergeParamDocs(sigParams, jsdocParams) {
+  if (!jsdocParams || jsdocParams.length === 0) return sigParams;
+  return sigParams.map((param) => {
+    const jsdocParam = jsdocParams.find((p) => p.name === param.name);
+    if (jsdocParam) {
+      return {
+        ...param,
+        description: jsdocParam.description || param.description,
+        type: param.type || jsdocParam.type,
+        optional: param.optional || jsdocParam.optional,
+        defaultValue: param.defaultValue || jsdocParam.defaultValue
+      };
+    }
+    return param;
+  });
+}
+function parseEnumMembers(body) {
+  const members = [];
+  const pattern = /(\w+)\s*(?:=\s*([^,}]+))?/g;
+  let match;
+  while ((match = pattern.exec(body)) !== null) {
+    const [, name, value] = match;
+    if (!name) continue;
+    let parsedValue;
+    if (value !== void 0) {
+      const trimmed = value.trim();
+      const num = Number(trimmed);
+      if (!isNaN(num)) {
+        parsedValue = num;
+      } else {
+        parsedValue = trimmed.replace(/^['"]|['"]$/g, "");
+      }
+    }
+    members.push({ name, value: parsedValue });
+  }
+  return members;
+}
+function parseDts(content, filePath) {
+  const exports$1 = [];
+  const imports = [];
+  let moduleName;
+  const comments = extractJSDocComments(content);
+  const moduleMatch = PATTERNS.declareModule.exec(content);
+  if (moduleMatch) {
+    moduleName = moduleMatch[1];
+  }
+  let match;
+  PATTERNS.exportFunction.lastIndex = 0;
+  while ((match = PATTERNS.exportFunction.exec(content)) !== null) {
+    const [fullMatch, name, generics, params, returnType] = match;
+    if (!name || !returnType) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    exports$1.push({
+      kind: "function",
+      name,
+      signature: `function ${name}${generics || ""}(${params || ""}): ${returnType.trim()}`,
+      description: jsdoc?.description,
+      params: mergeParamDocs(parseParameters(params || ""), jsdoc?.params),
+      returns: {
+        type: returnType.trim(),
+        description: jsdoc?.returns?.description
+      },
+      examples: jsdoc?.examples,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      since: jsdoc?.since,
+      see: jsdoc?.see,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS.exportConst.lastIndex = 0;
+  while ((match = PATTERNS.exportConst.exec(content)) !== null) {
+    const [, name, type] = match;
+    if (!name || !type) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    exports$1.push({
+      kind: "constant",
+      name,
+      signature: `const ${name}: ${type.trim()}`,
+      description: jsdoc?.description,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS.exportClass.lastIndex = 0;
+  while ((match = PATTERNS.exportClass.exec(content)) !== null) {
+    const [, name, generics, extendsClause, implementsClause] = match;
+    if (!name) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    const bodyStart = match.index + match[0].length - 1;
+    const body = extractBody(content, bodyStart);
+    const { methods, properties } = parseClassMembers(body, comments, bodyStart);
+    exports$1.push({
+      kind: "class",
+      name,
+      signature: `class ${name}${generics ? `<${generics}>` : ""}`,
+      description: jsdoc?.description,
+      extends: extendsClause ? [extendsClause.trim()] : void 0,
+      implements: implementsClause ? implementsClause.split(",").map((s) => s.trim()) : void 0,
+      methods,
+      properties,
+      typeParams: generics ? generics.split(",").map((s) => s.trim()) : void 0,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS.exportInterface.lastIndex = 0;
+  while ((match = PATTERNS.exportInterface.exec(content)) !== null) {
+    const [, name, generics, extendsClause] = match;
+    if (!name) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    const bodyStart = match.index + match[0].length - 1;
+    const body = extractBody(content, bodyStart);
+    const { methods, properties } = parseClassMembers(body, comments, bodyStart);
+    exports$1.push({
+      kind: "interface",
+      name,
+      signature: `interface ${name}${generics ? `<${generics}>` : ""}`,
+      description: jsdoc?.description,
+      extends: extendsClause ? extendsClause.split(",").map((s) => s.trim()) : void 0,
+      methods,
+      properties,
+      typeParams: generics ? generics.split(",").map((s) => s.trim()) : void 0,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS.exportType.lastIndex = 0;
+  while ((match = PATTERNS.exportType.exec(content)) !== null) {
+    const [, name, generics, definition] = match;
+    if (!name || !definition) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    exports$1.push({
+      kind: "type",
+      name,
+      signature: `type ${name}${generics ? `<${generics}>` : ""} = ${definition.trim()}`,
+      description: jsdoc?.description,
+      typeParams: generics ? generics.split(",").map((s) => s.trim()) : void 0,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS.exportEnum.lastIndex = 0;
+  while ((match = PATTERNS.exportEnum.exec(content)) !== null) {
+    const [, name] = match;
+    if (!name) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    const bodyStart = match.index + match[0].length - 1;
+    const body = extractBody(content, bodyStart);
+    const members = parseEnumMembers(body);
+    exports$1.push({
+      kind: "enum",
+      name,
+      signature: `enum ${name}`,
+      description: jsdoc?.description,
+      members,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS.importStatement.lastIndex = 0;
+  while ((match = PATTERNS.importStatement.exec(content)) !== null) {
+    if (match[1]) {
+      imports.push(match[1]);
+    }
+  }
+  PATTERNS.declareModule.lastIndex = 0;
+  while ((match = PATTERNS.declareModule.exec(content)) !== null) {
+    const moduleBodyStart = match.index + match[0].length - 1;
+    const moduleBody = extractBody(content, moduleBodyStart);
+    const moduleExports = parseModuleAugmentation(moduleBody, comments, moduleBodyStart, filePath);
+    for (const entry of moduleExports) {
+      exports$1.push(entry);
+    }
+  }
+  return { exports: exports$1, imports, moduleName };
+}
+function parseModuleAugmentation(body, _comments, _bodyOffset, filePath) {
+  const entries = [];
+  const moduleComments = extractJSDocComments(body);
+  const interfacePattern = /interface\s+(\w+)(?:\s*<([^>]*)>)?(?:\s+extends\s+([^{]+))?\s*\{/g;
+  let match;
+  while ((match = interfacePattern.exec(body)) !== null) {
+    const [, interfaceName, generics, extendsClause] = match;
+    if (!interfaceName) continue;
+    const ifaceBodyStart = match.index + match[0].length - 1;
+    const ifaceBody = extractBody(body, ifaceBodyStart);
+    if (interfaceName === "LoDashStatic" || interfaceName.endsWith("Static")) {
+      const methods = parseInterfaceMethodsAsExports(
+        ifaceBody,
+        moduleComments,
+        ifaceBodyStart,
+        filePath
+      );
+      for (const method of methods) {
+        entries.push(method);
+      }
+    }
+  }
+  return entries;
+}
+function parseInterfaceMethodsAsExports(body, _comments, _bodyOffset, filePath) {
+  const methods = [];
+  const bodyComments = extractJSDocComments(body);
+  const methodPattern = /(\w+)\s*(<[^>]*>)?\s*\(([^)]*)\)\s*:\s*([^;]+);/g;
+  let match;
+  while ((match = methodPattern.exec(body)) !== null) {
+    const [fullMatch, name, generics, params, returnType] = match;
+    if (!name || !returnType) continue;
+    if (["constructor", "toString", "valueOf", "toJSON"].includes(name)) continue;
+    const jsdoc = findPrecedingJSDoc(body, match.index, bodyComments);
+    methods.push({
+      kind: "function",
+      name,
+      signature: `function ${name}${generics || ""}(${params || ""}): ${returnType.trim()}`,
+      description: jsdoc?.description,
+      params: mergeParamDocs(parseParameters(params || ""), jsdoc?.params),
+      returns: {
+        type: returnType.trim(),
+        description: jsdoc?.returns?.description
+      },
+      examples: jsdoc?.examples,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      since: jsdoc?.since,
+      see: jsdoc?.see,
+      sourceFile: filePath
+    });
+  }
+  return methods;
+}
+function sortExports(exports$1) {
+  const kindOrder = {
+    function: 1,
+    class: 2,
+    interface: 3,
+    type: 4,
+    enum: 5,
+    constant: 6
+  };
+  return [...exports$1].sort((a, b) => {
+    const kindDiff = kindOrder[a.kind] - kindOrder[b.kind];
+    if (kindDiff !== 0) return kindDiff;
+    return a.name.localeCompare(b.name);
+  });
+}
+function findMainDtsFile(files, typesField) {
+  if (typesField) {
+    const normalized = typesField.replace(/^\.\//, "");
+    if (files.has(normalized)) return normalized;
+  }
+  const priorities = [
+    "index.d.ts",
+    "dist/index.d.ts",
+    "lib/index.d.ts",
+    "types/index.d.ts",
+    "src/index.d.ts",
+    // @types packages merged via types-resolver plugin
+    "__types__/index.d.ts",
+    "__types__/dist/index.d.ts",
+    "__types__/lib/index.d.ts",
+    "__types__/types/index.d.ts"
+  ];
+  for (const path of priorities) {
+    if (files.has(path)) return path;
+  }
+  for (const path of files.keys()) {
+    if (path.endsWith(".d.ts") && !path.startsWith("__types__/")) {
+      return path;
+    }
+  }
+  for (const path of files.keys()) {
+    if (path.endsWith(".d.ts") && path.startsWith("__types__/")) {
+      return path;
+    }
+  }
+  return void 0;
+}
+
+// src/plugins/core/dts-parser.ts
+var dtsParserPlugin = {
+  name: "dts-parser",
+  version: "1.0.0",
+  category: "parser",
+  install(kernel) {
+    kernel.on("parse:start", async (context) => {
+      const { files } = context.package;
+      const mainDts = findMainDtsFile(files, context.package.types);
+      if (!mainDts) {
+        return;
+      }
+      const dtsFiles = Array.from(files.entries()).filter(([path]) => path.endsWith(".d.ts")).sort(([a], [b]) => {
+        if (a === mainDts) return -1;
+        if (b === mainDts) return 1;
+        if (a.includes("index.d.ts")) return -1;
+        if (b.includes("index.d.ts")) return 1;
+        return a.localeCompare(b);
+      });
+      const seenNames = /* @__PURE__ */ new Set();
+      for (const [path, content] of dtsFiles) {
+        try {
+          const result = parseDts(content, path);
+          for (const entry of result.exports) {
+            if (!seenNames.has(entry.name)) {
+              seenNames.add(entry.name);
+              context.api.push(entry);
+            }
+          }
+        } catch (error) {
+          context.errors.push(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+      context.api = sortExports(context.api);
+    });
+  }
+};
+
+// src/parsers/typescript.ts
+var PATTERNS2 = {
+  /** Export function */
+  exportFunction: /export\s+(?:async\s+)?function\s+(\w+)\s*(<[^>]*>)?\s*\(([^)]*)\)(?:\s*:\s*([^{]+))?\s*\{/g,
+  /** Export arrow function */
+  exportArrow: /export\s+const\s+(\w+)\s*(?::\s*([^=]+))?\s*=\s*(?:async\s*)?\([^)]*\)\s*(?::\s*([^=]+))?\s*=>/g,
+  /** Export class */
+  exportClass: /export\s+(?:abstract\s+)?class\s+(\w+)(?:\s*<([^>]*)>)?(?:\s+extends\s+([^\s{]+))?(?:\s+implements\s+([^{]+))?\s*\{/g,
+  /** Export interface */
+  exportInterface: /export\s+interface\s+(\w+)(?:\s*<([^>]*)>)?(?:\s+extends\s+([^{]+))?\s*\{/g,
+  /** Export type */
+  exportType: /export\s+type\s+(\w+)(?:\s*<([^>]*)>)?\s*=\s*([^;]+)/g,
+  /** Export const/let */
+  exportConst: /export\s+(?:const|let)\s+(\w+)(?:\s*:\s*([^=]+))?\s*=/g,
+  /** Export enum */
+  exportEnum: /export\s+(?:const\s+)?enum\s+(\w+)\s*\{/g};
+function parseSourceParams(paramStr) {
+  if (!paramStr.trim()) return [];
+  const params = [];
+  const parts = splitParams(paramStr);
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      const colonIndex = findBalancedColon(trimmed);
+      if (colonIndex > 0) {
+        params.push({
+          name: "options",
+          type: trimmed.slice(colonIndex + 1).trim(),
+          optional: trimmed.includes("?")
+        });
+      } else {
+        params.push({
+          name: "options",
+          type: "object"
+        });
+      }
+      continue;
+    }
+    const match = trimmed.match(/^(\w+)(\?)?\s*(?::\s*(.+?))?(?:\s*=\s*(.+))?$/);
+    if (match && match[1]) {
+      const [, name, optional, type, defaultValue] = match;
+      params.push({
+        name,
+        type: type?.trim() || inferTypeFromDefault(defaultValue),
+        optional: !!optional || !!defaultValue,
+        defaultValue: defaultValue?.trim()
+      });
+    }
+  }
+  return params;
+}
+function splitParams(str) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  for (const char of str) {
+    if (char === "<" || char === "{" || char === "[" || char === "(") {
+      depth++;
+      current += char;
+    } else if (char === ">" || char === "}" || char === "]" || char === ")") {
+      depth--;
+      current += char;
+    } else if (char === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) parts.push(current);
+  return parts;
+}
+function findBalancedColon(str) {
+  let depth = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i];
+    if (char === "{" || char === "[" || char === "<" || char === "(") {
+      depth++;
+    } else if (char === "}" || char === "]" || char === ">" || char === ")") {
+      depth--;
+    } else if (char === ":" && depth === 0) {
+      return i;
+    }
+  }
+  return -1;
+}
+function inferTypeFromDefault(defaultValue) {
+  if (!defaultValue) return "unknown";
+  const trimmed = defaultValue.trim();
+  if (trimmed === "true" || trimmed === "false") return "boolean";
+  if (trimmed.startsWith("'") || trimmed.startsWith('"') || trimmed.startsWith("`")) {
+    return "string";
+  }
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) return "number";
+  if (trimmed === "null") return "null";
+  if (trimmed === "undefined") return "undefined";
+  if (trimmed.startsWith("[")) return "unknown[]";
+  if (trimmed.startsWith("{")) return "object";
+  if (trimmed.startsWith("()") || trimmed.includes("=>")) return "Function";
+  return "unknown";
+}
+function parseTypeScript(content, filePath) {
+  const exports$1 = [];
+  let hasTypes = false;
+  hasTypes = /:\s*\w+/.test(content) || content.includes("interface ") || content.includes("type ");
+  const comments = extractJSDocComments(content);
+  let match;
+  PATTERNS2.exportFunction.lastIndex = 0;
+  while ((match = PATTERNS2.exportFunction.exec(content)) !== null) {
+    const [, name, generics, params, returnType] = match;
+    if (!name) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    const paramStr = params || "";
+    exports$1.push({
+      kind: "function",
+      name,
+      signature: `function ${name}${generics || ""}(${paramStr})${returnType ? `: ${returnType.trim()}` : ""}`,
+      description: jsdoc?.description,
+      params: mergeParams(parseSourceParams(paramStr), jsdoc?.params),
+      returns: returnType ? { type: returnType.trim(), description: jsdoc?.returns?.description } : void 0,
+      examples: jsdoc?.examples,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS2.exportArrow.lastIndex = 0;
+  while ((match = PATTERNS2.exportArrow.exec(content)) !== null) {
+    const [fullMatch, name, typeAnnotation, returnType] = match;
+    if (!name || !fullMatch) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    const paramsStart = fullMatch.indexOf("(");
+    const paramsEnd = fullMatch.indexOf(")", paramsStart);
+    const params = fullMatch.slice(paramsStart + 1, paramsEnd);
+    exports$1.push({
+      kind: "function",
+      name,
+      signature: typeAnnotation ? `const ${name}: ${typeAnnotation.trim()}` : `const ${name} = (${params})${returnType ? ` => ${returnType.trim()}` : ""}`,
+      description: jsdoc?.description,
+      params: mergeParams(parseSourceParams(params), jsdoc?.params),
+      returns: returnType ? { type: returnType.trim(), description: jsdoc?.returns?.description } : void 0,
+      examples: jsdoc?.examples,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS2.exportClass.lastIndex = 0;
+  while ((match = PATTERNS2.exportClass.exec(content)) !== null) {
+    const [, name, generics, extendsClause, implementsClause] = match;
+    if (!name) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    exports$1.push({
+      kind: "class",
+      name,
+      signature: `class ${name}${generics ? `<${generics}>` : ""}`,
+      description: jsdoc?.description,
+      extends: extendsClause ? [extendsClause.trim()] : void 0,
+      implements: implementsClause ? implementsClause.split(",").map((s) => s.trim()) : void 0,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS2.exportInterface.lastIndex = 0;
+  while ((match = PATTERNS2.exportInterface.exec(content)) !== null) {
+    const [, name, generics, extendsClause] = match;
+    if (!name) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    exports$1.push({
+      kind: "interface",
+      name,
+      signature: `interface ${name}${generics ? `<${generics}>` : ""}`,
+      description: jsdoc?.description,
+      extends: extendsClause ? extendsClause.split(",").map((s) => s.trim()) : void 0,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS2.exportType.lastIndex = 0;
+  while ((match = PATTERNS2.exportType.exec(content)) !== null) {
+    const [, name, generics, definition] = match;
+    if (!name || !definition) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    exports$1.push({
+      kind: "type",
+      name,
+      signature: `type ${name}${generics ? `<${generics}>` : ""} = ${definition.trim()}`,
+      description: jsdoc?.description,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS2.exportConst.lastIndex = 0;
+  while ((match = PATTERNS2.exportConst.exec(content)) !== null) {
+    const [, name, type] = match;
+    if (!name) continue;
+    if (content.slice(match.index, match.index + 200).includes("=>")) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    exports$1.push({
+      kind: "constant",
+      name,
+      signature: `const ${name}${type ? `: ${type.trim()}` : ""}`,
+      description: jsdoc?.description,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  PATTERNS2.exportEnum.lastIndex = 0;
+  while ((match = PATTERNS2.exportEnum.exec(content)) !== null) {
+    const [, name] = match;
+    if (!name) continue;
+    const jsdoc = findPrecedingJSDoc(content, match.index, comments);
+    exports$1.push({
+      kind: "enum",
+      name,
+      signature: `enum ${name}`,
+      description: jsdoc?.description,
+      deprecated: jsdoc?.deprecated ? jsdoc.deprecated : void 0,
+      sourceFile: filePath
+    });
+  }
+  return { exports: exports$1, hasTypes };
+}
+function mergeParams(sourceParams, jsdocParams) {
+  if (!jsdocParams || jsdocParams.length === 0) return sourceParams;
+  return sourceParams.map((param) => {
+    const jsdocParam = jsdocParams.find((p) => p.name === param.name);
+    if (jsdocParam) {
+      return {
+        ...param,
+        description: jsdocParam.description || param.description,
+        type: param.type !== "unknown" ? param.type : jsdocParam.type
+      };
+    }
+    return param;
+  });
+}
+function findTypeScriptFiles(files, mainField) {
+  const tsFiles = [];
+  const priorities = [];
+  if (mainField) {
+    const base = mainField.replace(/^\.\//, "").replace(/\.[jt]sx?$/, "");
+    priorities.push(
+      `${base}.ts`,
+      `${base}.tsx`,
+      `src/${base}.ts`,
+      `src/${base}.tsx`
+    );
+  }
+  priorities.push(
+    "src/index.ts",
+    "src/index.tsx",
+    "index.ts",
+    "index.tsx",
+    "lib/index.ts",
+    "src/main.ts"
+  );
+  for (const path of priorities) {
+    if (files.has(path) && !tsFiles.includes(path)) {
+      tsFiles.push(path);
+    }
+  }
+  for (const path of files.keys()) {
+    if ((path.endsWith(".ts") || path.endsWith(".tsx")) && !path.endsWith(".d.ts")) {
+      if (!tsFiles.includes(path)) {
+        tsFiles.push(path);
+      }
+    }
+  }
+  return tsFiles;
+}
+
+// src/plugins/core/ts-source-parser.ts
+var tsSourceParserPlugin = {
+  name: "ts-source-parser",
+  version: "1.0.0",
+  category: "parser",
+  install(kernel) {
+    kernel.on("parse:start", async (context) => {
+      if (context.api.length > 0) {
+        return;
+      }
+      const { files } = context.package;
+      const tsFiles = findTypeScriptFiles(files, context.package.main);
+      if (tsFiles.length === 0) {
+        return;
+      }
+      const seenNames = /* @__PURE__ */ new Set();
+      for (const path of tsFiles) {
+        const content = files.get(path);
+        if (!content) continue;
+        try {
+          const result = parseTypeScript(content, path);
+          for (const entry of result.exports) {
+            if (!seenNames.has(entry.name)) {
+              seenNames.add(entry.name);
+              context.api.push(entry);
+            }
+          }
+        } catch (error) {
+          context.errors.push(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+      context.api = sortExports(context.api);
+    });
+  }
+};
+
+// src/parsers/readme.ts
+var SECTION_PATTERNS = {
+  installation: /^#+\s*(installation|install|setup|getting started)/i,
+  quickStart: /^#+\s*(quick\s*start|usage|getting\s*started|basic\s*usage)/i,
+  api: /^#+\s*(api|api\s*reference|reference|methods|functions)/i,
+  examples: /^#+\s*(examples?|code\s*examples?)/i};
+var BADGE_PATTERN = /\[!\[([^\]]*)\]\(([^)]+)\)\]\([^)]+\)|\!\[([^\]]*)\]\(([^)]+)\)/g;
+var CODE_BLOCK_PATTERN = /```(\w+)?\s*\n([\s\S]*?)```/g;
+function parseReadme(content) {
+  const sections = extractSections(content);
+  const badges = extractBadges(content);
+  const { title, description } = extractTitleAndDescription(content, sections);
+  const installation = findSection(sections, SECTION_PATTERNS.installation);
+  const quickStart = findSection(sections, SECTION_PATTERNS.quickStart);
+  const api = findSection(sections, SECTION_PATTERNS.api);
+  const examples = findExampleSections(sections);
+  return {
+    title,
+    description,
+    badges,
+    installation: installation?.content,
+    quickStart: quickStart?.content || findQuickStartFromCode(content),
+    examples,
+    api: api?.content,
+    sections
+  };
+}
+function extractSections(content) {
+  const sections = [];
+  const lines = content.split("\n");
+  let currentSection = null;
+  let currentContent = [];
+  let charIndex = 0;
+  function finishSection() {
+    if (currentSection) {
+      currentSection.content = currentContent.join("\n").trim();
+      currentSection.endIndex = charIndex;
+      sections.push(currentSection);
+      currentContent = [];
+    }
+  }
+  for (const line of lines) {
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch && headingMatch[1] && headingMatch[2]) {
+      finishSection();
+      const level = headingMatch[1].length;
+      const title = headingMatch[2].trim();
+      currentSection = {
+        title,
+        content: "",
+        level,
+        startIndex: charIndex,
+        endIndex: 0
+      };
+      currentContent = [];
+    } else if (currentSection) {
+      currentContent.push(line);
+    }
+    charIndex += line.length + 1;
+  }
+  finishSection();
+  return sections;
+}
+function findSection(sections, pattern) {
+  return sections.find((s) => pattern.test(`# ${s.title}`));
+}
+function findExampleSections(sections) {
+  const examples = [];
+  for (const section of sections) {
+    if (SECTION_PATTERNS.examples.test(`# ${section.title}`)) {
+      const codeBlocks = extractCodeBlocks(section.content);
+      examples.push(...codeBlocks);
+    }
+  }
+  return examples;
+}
+function extractCodeBlocks(content) {
+  const blocks = [];
+  const pattern = new RegExp(CODE_BLOCK_PATTERN.source, "g");
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const [, language, code] = match;
+    if (code && code.trim()) {
+      blocks.push(language ? `\`\`\`${language}
+${code.trim()}
+\`\`\`` : code.trim());
+    }
+  }
+  return blocks;
+}
+function extractBadges(content) {
+  const badges = [];
+  const pattern = new RegExp(BADGE_PATTERN.source, "g");
+  let match;
+  while ((match = pattern.exec(content)) !== null) {
+    const altText = match[1] || match[3] || "";
+    if (altText) {
+      badges.push(altText);
+    }
+  }
+  return badges;
+}
+function extractTitleAndDescription(content, sections) {
+  let title;
+  let description;
+  const firstHeading = sections[0];
+  if (firstHeading?.level === 1) {
+    title = firstHeading.title;
+  } else {
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      if (trimmed.startsWith("!") || trimmed.startsWith("[!")) continue;
+      if (trimmed.startsWith("#")) {
+        title = trimmed.replace(/^#+\s*/, "");
+        break;
+      }
+    }
+  }
+  const afterTitle = content.split("\n").slice(1);
+  let foundContent = false;
+  for (const line of afterTitle) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("!") || trimmed.startsWith("[!")) continue;
+    if (trimmed.startsWith("#")) break;
+    if (!trimmed && !foundContent) continue;
+    if (!trimmed && foundContent) break;
+    if (trimmed) {
+      foundContent = true;
+      if (!description) {
+        description = trimmed;
+      } else {
+        description += " " + trimmed;
+      }
+    }
+  }
+  if (description) {
+    description = description.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").trim();
+  }
+  return { title, description };
+}
+function findQuickStartFromCode(content) {
+  const installMatch = content.match(/installation|install|setup/i);
+  const startIndex = installMatch?.index ?? 0;
+  const searchArea = content.slice(startIndex, startIndex + 2e3);
+  const codeBlocks = extractCodeBlocks(searchArea);
+  for (const block of codeBlocks) {
+    if (block.startsWith("```javascript") || block.startsWith("```typescript") || block.startsWith("```js") || block.startsWith("```ts") || block.startsWith("```jsx") || block.startsWith("```tsx")) {
+      return block;
+    }
+  }
+  return codeBlocks[0];
+}
+
+// src/plugins/core/readme-parser.ts
+var readmeParserPlugin = {
+  name: "readme-parser",
+  version: "1.0.0",
+  category: "parser",
+  install(kernel) {
+    kernel.on("parse:start", async (context) => {
+      const { files } = context.package;
+      let readmeContent;
+      const readmePatterns = [
+        "README.md",
+        "readme.md",
+        "Readme.md",
+        "README.MD",
+        "README",
+        "readme"
+      ];
+      for (const pattern of readmePatterns) {
+        if (files.has(pattern)) {
+          readmeContent = files.get(pattern);
+          break;
+        }
+      }
+      if (!readmeContent) {
+        for (const [path, content] of files) {
+          if (path.toLowerCase().includes("readme")) {
+            readmeContent = content;
+            break;
+          }
+        }
+      }
+      if (!readmeContent) {
+        return;
+      }
+      try {
+        context.readme = parseReadme(readmeContent);
+        if (!context.package.description && context.readme.description) {
+          context.package.description = context.readme.description;
+        }
+      } catch (error) {
+        context.errors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+};
+
+// src/core/tokens.ts
+var CHARS_PER_TOKEN = {
+  /** English prose: ~4 chars per token */
+  prose: 4,
+  /** Code blocks: ~3 chars per token (more special tokens) */
+  code: 3};
+var PRIORITY_ORDER = {
+  functions: 100,
+  examples: 90,
+  classes: 80,
+  interfaces: 70,
+  types: 60,
+  readme: 50
+};
+function countTokens(text) {
+  if (!text) return 0;
+  let tokens = 0;
+  const codeBlockRegex = /```[\s\S]*?```/g;
+  const parts = [];
+  let lastIndex = 0;
+  let match;
+  while ((match = codeBlockRegex.exec(text)) !== null) {
+    if (match.index > lastIndex) {
+      parts.push({
+        text: text.slice(lastIndex, match.index),
+        isCode: false
+      });
+    }
+    parts.push({
+      text: match[0],
+      isCode: true
+    });
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < text.length) {
+    parts.push({
+      text: text.slice(lastIndex),
+      isCode: false
+    });
+  }
+  for (const part of parts) {
+    const charsPerToken = part.isCode ? CHARS_PER_TOKEN.code : CHARS_PER_TOKEN.prose;
+    tokens += Math.ceil(part.text.length / charsPerToken);
+  }
+  return tokens;
+}
+function parseSections(text) {
+  const sections = [];
+  const lines = text.split("\n");
+  let currentSection = null;
+  let currentContent = [];
+  function finishSection() {
+    if (currentSection) {
+      currentSection.content = currentContent.join("\n").trim();
+      currentSection.tokens = countTokens(currentSection.content);
+      sections.push(currentSection);
+      currentContent = [];
+    }
+  }
+  for (const line of lines) {
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch && headingMatch[2]) {
+      finishSection();
+      const title = headingMatch[2].trim();
+      const priority = inferPriority(title);
+      currentSection = {
+        id: title.toLowerCase().replace(/[^a-z0-9]+/g, "-"),
+        title,
+        content: "",
+        priority,
+        tokens: 0
+      };
+      currentContent = [line];
+    } else if (currentSection) {
+      currentContent.push(line);
+    } else {
+      if (line.trim()) {
+        if (!currentSection) {
+          currentSection = {
+            id: "intro",
+            title: "Introduction",
+            content: "",
+            priority: "readme",
+            tokens: 0
+          };
+        }
+        currentContent.push(line);
+      }
+    }
+  }
+  finishSection();
+  return sections;
+}
+function inferPriority(title) {
+  const lower = title.toLowerCase();
+  if (lower.includes("function") || lower.includes("method") || lower.includes("api")) {
+    return "functions";
+  }
+  if (lower.includes("example") || lower.includes("usage") || lower.includes("quick start")) {
+    return "examples";
+  }
+  if (lower.includes("class")) {
+    return "classes";
+  }
+  if (lower.includes("interface")) {
+    return "interfaces";
+  }
+  if (lower.includes("type")) {
+    return "types";
+  }
+  return "readme";
+}
+function prioritizeSections(sections, priorities = ["functions", "examples"]) {
+  const customOrder = { ...PRIORITY_ORDER };
+  priorities.forEach((p, i) => {
+    customOrder[p] = 1e3 - i;
+  });
+  return [...sections].sort((a, b) => {
+    return (customOrder[b.priority] ?? 0) - (customOrder[a.priority] ?? 0);
+  });
+}
+function truncateToTokenLimit(text, limit, priorities = ["functions", "examples"]) {
+  const currentTokens = countTokens(text);
+  if (currentTokens <= limit) {
+    return {
+      text,
+      truncated: false,
+      tokenCount: currentTokens,
+      includedSections: [],
+      removedSections: []
+    };
+  }
+  const sections = parseSections(text);
+  const prioritized = prioritizeSections(sections, priorities);
+  const included = [];
+  const removed = [];
+  let usedTokens = 0;
+  for (const section of prioritized) {
+    if (usedTokens + section.tokens <= limit) {
+      included.push(section);
+      usedTokens += section.tokens;
+    } else {
+      const remaining = limit - usedTokens;
+      if (remaining > 50 && section.tokens > 0) {
+        const truncated = truncateSectionContent(section, remaining);
+        if (truncated) {
+          included.push(truncated);
+          usedTokens += truncated.tokens;
+        }
+      }
+      removed.push(section);
+    }
+  }
+  const sectionOrder = sections.map((s) => s.id);
+  included.sort((a, b) => sectionOrder.indexOf(a.id) - sectionOrder.indexOf(b.id));
+  const output = included.map((s) => s.content).join("\n\n");
+  return {
+    text: output.trim(),
+    truncated: true,
+    tokenCount: countTokens(output),
+    includedSections: included.map((s) => s.title),
+    removedSections: removed.map((s) => s.title)
+  };
+}
+function truncateSectionContent(section, maxTokens) {
+  const lines = section.content.split("\n");
+  const truncatedLines = [];
+  let tokens = 0;
+  for (const line of lines) {
+    const lineTokens = countTokens(line);
+    if (tokens + lineTokens <= maxTokens) {
+      truncatedLines.push(line);
+      tokens += lineTokens;
+    } else {
+      break;
+    }
+  }
+  if (truncatedLines.length === 0) {
+    return null;
+  }
+  truncatedLines.push("\n...(truncated)");
+  return {
+    ...section,
+    content: truncatedLines.join("\n"),
+    tokens: countTokens(truncatedLines.join("\n"))
+  };
+}
+
+// src/outputs/llms.ts
+var DEFAULT_LLMS_TOKEN_LIMIT = Infinity;
+function generateLlmsTxt(context, options = {}) {
+  const {
+    tokenLimit = DEFAULT_LLMS_TOKEN_LIMIT,
+    includeInstall = true,
+    includeQuickStart = true,
+    maxFunctions = Infinity,
+    maxClasses = Infinity
+  } = options;
+  const { package: pkg, api, readme } = context;
+  const sections = [];
+  sections.push(`# ${pkg.name}`);
+  if (pkg.description) {
+    sections.push(`
+> ${pkg.description}`);
+  }
+  sections.push("");
+  if (includeInstall) {
+    sections.push("## Install\n");
+    sections.push("```bash");
+    sections.push(`npm install ${pkg.name}`);
+    sections.push("```\n");
+  }
+  if (includeQuickStart && readme?.quickStart) {
+    sections.push("## Quick Start\n");
+    sections.push(readme.quickStart);
+    sections.push("");
+  }
+  sections.push("## API\n");
+  const functions = api.filter((e) => e.kind === "function");
+  const classes = api.filter((e) => e.kind === "class");
+  const interfaces = api.filter((e) => e.kind === "interface");
+  const types = api.filter((e) => e.kind === "type");
+  const constants = api.filter((e) => e.kind === "constant");
+  if (functions.length > 0) {
+    sections.push("### Functions\n");
+    const limit = Math.min(functions.length, maxFunctions);
+    for (let i = 0; i < limit; i++) {
+      sections.push(formatFunctionBrief(functions[i]));
+    }
+    if (functions.length > maxFunctions && maxFunctions < Infinity) {
+      sections.push(`
+...and ${functions.length - maxFunctions} more functions.`);
+    }
+    sections.push("");
+  }
+  if (classes.length > 0) {
+    sections.push("### Classes\n");
+    const limit = Math.min(classes.length, maxClasses);
+    for (let i = 0; i < limit; i++) {
+      sections.push(formatClassBrief(classes[i]));
+    }
+    if (classes.length > maxClasses && maxClasses < Infinity) {
+      sections.push(`
+...and ${classes.length - maxClasses} more classes.`);
+    }
+    sections.push("");
+  }
+  if (interfaces.length > 0 || types.length > 0) {
+    sections.push("### Types\n");
+    const allTypes = [...interfaces, ...types];
+    for (const t of allTypes) {
+      const desc = t.description ? ` - ${truncate(t.description, 80)}` : "";
+      sections.push(`- \`${t.name}\`${desc}`);
+    }
+    sections.push("");
+  }
+  if (constants.length > 0) {
+    sections.push("### Constants\n");
+    for (const c of constants) {
+      const desc = c.description ? ` - ${truncate(c.description, 80)}` : "";
+      sections.push(`- \`${c.name}\`${desc}`);
+    }
+    sections.push("");
+  }
+  let output = sections.join("\n");
+  const currentTokens = countTokens(output);
+  if (currentTokens > tokenLimit) {
+    const result = truncateToTokenLimit(output, tokenLimit, ["functions", "examples"]);
+    output = result.text;
+    context.truncated = result.truncated;
+  }
+  context.tokenCount = countTokens(output);
+  return output;
+}
+function formatFunctionBrief(fn) {
+  const params = fn.params?.map((p) => `${p.name}${p.optional ? "?" : ""}`).join(", ") || "";
+  const returnType = fn.returns?.type ? `: ${simplifyType(fn.returns.type)}` : "";
+  const desc = fn.description ? ` - ${truncate(fn.description, 60)}` : "";
+  return `- \`${fn.name}(${params})${returnType}\`${desc}`;
+}
+function formatClassBrief(cls) {
+  const lines = [];
+  const desc = cls.description ? ` - ${truncate(cls.description, 60)}` : "";
+  lines.push(`- \`${cls.name}\`${desc}`);
+  if (cls.methods && cls.methods.length > 0) {
+    const keyMethods = cls.methods.slice(0, 3);
+    for (const method of keyMethods) {
+      lines.push(`  - \`${method.name}()\``);
+    }
+    if (cls.methods.length > 3) {
+      lines.push(`  - ...${cls.methods.length - 3} more methods`);
+    }
+  }
+  return lines.join("\n");
+}
+function simplifyType(type) {
+  if (type.length > 30) {
+    const genericStart = type.indexOf("<");
+    if (genericStart > 0) {
+      return type.slice(0, genericStart) + "<...>";
+    }
+  }
+  return type;
+}
+function truncate(text, maxLength) {
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength - 3) + "...";
+}
+
+// src/plugins/core/llms-output.ts
+var llmsOutputPlugin = {
+  name: "llms-output",
+  version: "1.0.0",
+  category: "output",
+  install(kernel) {
+    kernel.on("output:start", async (context) => {
+      if (!context.options.formats?.includes("llms")) {
+        return;
+      }
+      try {
+        const tokenLimit = context.options.llmsTokenLimit ?? DEFAULT_LLMS_TOKEN_LIMIT;
+        const output = generateLlmsTxt(context, {
+          tokenLimit,
+          includeInstall: true,
+          includeQuickStart: true
+        });
+        context.outputs.set("llms", output);
+      } catch (error) {
+        context.errors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+};
+
+// src/outputs/llms-full.ts
+function generateLlmsFullTxt(context, options = {}) {
+  const {
+    includeExamples = true,
+    includeParamDescriptions = true,
+    includeSourceLocations = false,
+    includeDeprecations = true
+  } = options;
+  const { package: pkg, api, readme } = context;
+  const sections = [];
+  sections.push(`# ${pkg.name} v${pkg.version}`);
+  if (pkg.description) {
+    sections.push(`
+> ${pkg.description}`);
+  }
+  sections.push("");
+  sections.push("## Package Info\n");
+  sections.push(`- **Version:** ${pkg.version}`);
+  if (pkg.license) {
+    sections.push(`- **License:** ${pkg.license}`);
+  }
+  if (pkg.homepage) {
+    sections.push(`- **Homepage:** ${pkg.homepage}`);
+  }
+  if (pkg.repository) {
+    sections.push(`- **Repository:** ${pkg.repository.url}`);
+  }
+  sections.push("");
+  sections.push("## Installation\n");
+  sections.push("```bash");
+  sections.push(`# npm`);
+  sections.push(`npm install ${pkg.name}`);
+  sections.push("");
+  sections.push(`# yarn`);
+  sections.push(`yarn add ${pkg.name}`);
+  sections.push("");
+  sections.push(`# pnpm`);
+  sections.push(`pnpm add ${pkg.name}`);
+  sections.push("```\n");
+  if (readme?.quickStart) {
+    sections.push("## Quick Start\n");
+    sections.push(readme.quickStart);
+    sections.push("");
+  }
+  sections.push("## API Reference\n");
+  const functions = api.filter((e) => e.kind === "function");
+  const classes = api.filter((e) => e.kind === "class");
+  const interfaces = api.filter((e) => e.kind === "interface");
+  const types = api.filter((e) => e.kind === "type");
+  const constants = api.filter((e) => e.kind === "constant");
+  const enums = api.filter((e) => e.kind === "enum");
+  if (functions.length > 0) {
+    sections.push("### Functions\n");
+    for (const fn of functions) {
+      sections.push(formatFunction(fn, { includeExamples, includeParamDescriptions, includeDeprecations, includeSourceLocations }));
+      sections.push("");
+    }
+  }
+  if (classes.length > 0) {
+    sections.push("### Classes\n");
+    for (const cls of classes) {
+      sections.push(formatClass(cls, { includeExamples, includeDeprecations}));
+      sections.push("");
+    }
+  }
+  if (interfaces.length > 0) {
+    sections.push("### Interfaces\n");
+    for (const iface of interfaces) {
+      sections.push(formatInterface(iface, { includeDeprecations}));
+      sections.push("");
+    }
+  }
+  if (types.length > 0) {
+    sections.push("### Types\n");
+    for (const type of types) {
+      sections.push(formatType(type, { includeDeprecations }));
+      sections.push("");
+    }
+  }
+  if (enums.length > 0) {
+    sections.push("### Enums\n");
+    for (const enumEntry of enums) {
+      sections.push(formatEnum(enumEntry));
+      sections.push("");
+    }
+  }
+  if (constants.length > 0) {
+    sections.push("### Constants\n");
+    for (const constant of constants) {
+      sections.push(formatConstant(constant));
+      sections.push("");
+    }
+  }
+  const output = sections.join("\n");
+  context.tokenCount = countTokens(output);
+  return output;
+}
+function formatFunction(fn, options) {
+  const lines = [];
+  lines.push(`#### \`${fn.name}\``);
+  if (options.includeDeprecations && fn.deprecated) {
+    lines.push(`
+> \u26A0\uFE0F **Deprecated:** ${typeof fn.deprecated === "string" ? fn.deprecated : "This function is deprecated."}`);
+  }
+  if (fn.description) {
+    lines.push(`
+${fn.description}`);
+  }
+  lines.push("\n**Signature:**");
+  lines.push("```typescript");
+  lines.push(fn.signature);
+  lines.push("```");
+  if (fn.params && fn.params.length > 0 && options.includeParamDescriptions) {
+    lines.push("\n**Parameters:**\n");
+    for (const param of fn.params) {
+      const optional = param.optional ? " (optional)" : "";
+      const defaultVal = param.defaultValue ? ` = \`${param.defaultValue}\`` : "";
+      lines.push(`- \`${param.name}: ${param.type || "unknown"}\`${optional}${defaultVal}`);
+      if (param.description) {
+        lines.push(`  - ${param.description}`);
+      }
+    }
+  }
+  if (fn.returns) {
+    lines.push("\n**Returns:**");
+    lines.push(`- \`${fn.returns.type}\`${fn.returns.description ? ` - ${fn.returns.description}` : ""}`);
+  }
+  if (options.includeExamples && fn.examples && fn.examples.length > 0) {
+    lines.push("\n**Examples:**");
+    for (const example of fn.examples) {
+      if (example.includes("```")) {
+        lines.push(example);
+      } else {
+        lines.push("```typescript");
+        lines.push(example);
+        lines.push("```");
+      }
+    }
+  }
+  if (options.includeSourceLocations && fn.sourceFile) {
+    lines.push(`
+*Source: ${fn.sourceFile}${fn.line ? `:${fn.line}` : ""}*`);
+  }
+  return lines.join("\n");
+}
+function formatClass(cls, options) {
+  const lines = [];
+  lines.push(`#### \`${cls.name}\``);
+  if (options.includeDeprecations && cls.deprecated) {
+    lines.push(`
+> \u26A0\uFE0F **Deprecated:** ${typeof cls.deprecated === "string" ? cls.deprecated : "This class is deprecated."}`);
+  }
+  if (cls.description) {
+    lines.push(`
+${cls.description}`);
+  }
+  lines.push("\n**Signature:**");
+  lines.push("```typescript");
+  let sig = cls.signature;
+  if (cls.extends && cls.extends.length > 0) {
+    sig += ` extends ${cls.extends.join(", ")}`;
+  }
+  if (cls.implements && cls.implements.length > 0) {
+    sig += ` implements ${cls.implements.join(", ")}`;
+  }
+  lines.push(sig);
+  lines.push("```");
+  if (cls.properties && cls.properties.length > 0) {
+    lines.push("\n**Properties:**\n");
+    for (const prop of cls.properties) {
+      lines.push(`- \`${prop.name}\`: \`${prop.signature.split(":").slice(1).join(":").trim() || "unknown"}\``);
+      if (prop.description) {
+        lines.push(`  - ${prop.description}`);
+      }
+    }
+  }
+  if (cls.methods && cls.methods.length > 0) {
+    lines.push("\n**Methods:**\n");
+    for (const method of cls.methods) {
+      const params = method.params?.map((p) => `${p.name}: ${p.type || "unknown"}`).join(", ") || "";
+      const returnType = method.returns?.type || "void";
+      lines.push(`- \`${method.name}(${params}): ${returnType}\``);
+      if (method.description) {
+        lines.push(`  - ${method.description}`);
+      }
+    }
+  }
+  if (options.includeExamples && cls.examples && cls.examples.length > 0) {
+    lines.push("\n**Examples:**");
+    for (const example of cls.examples) {
+      if (example.includes("```")) {
+        lines.push(example);
+      } else {
+        lines.push("```typescript");
+        lines.push(example);
+        lines.push("```");
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function formatInterface(iface, options) {
+  const lines = [];
+  lines.push(`#### \`${iface.name}\``);
+  if (options.includeDeprecations && iface.deprecated) {
+    lines.push(`
+> \u26A0\uFE0F **Deprecated**`);
+  }
+  if (iface.description) {
+    lines.push(`
+${iface.description}`);
+  }
+  lines.push("\n```typescript");
+  let sig = iface.signature;
+  if (iface.extends && iface.extends.length > 0) {
+    sig += ` extends ${iface.extends.join(", ")}`;
+  }
+  lines.push(sig + " {");
+  if (iface.properties && iface.properties.length > 0) {
+    for (const prop of iface.properties) {
+      lines.push(`  ${prop.signature};`);
+    }
+  }
+  if (iface.methods && iface.methods.length > 0) {
+    for (const method of iface.methods) {
+      lines.push(`  ${method.signature};`);
+    }
+  }
+  lines.push("}");
+  lines.push("```");
+  return lines.join("\n");
+}
+function formatType(type, options) {
+  const lines = [];
+  lines.push(`#### \`${type.name}\``);
+  if (options.includeDeprecations && type.deprecated) {
+    lines.push(`
+> \u26A0\uFE0F **Deprecated**`);
+  }
+  if (type.description) {
+    lines.push(`
+${type.description}`);
+  }
+  lines.push("\n```typescript");
+  lines.push(type.signature);
+  lines.push("```");
+  return lines.join("\n");
+}
+function formatEnum(enumEntry) {
+  const lines = [];
+  lines.push(`#### \`${enumEntry.name}\``);
+  if (enumEntry.description) {
+    lines.push(`
+${enumEntry.description}`);
+  }
+  lines.push("\n```typescript");
+  lines.push(`enum ${enumEntry.name} {`);
+  if (enumEntry.members) {
+    for (const member of enumEntry.members) {
+      if (member.value !== void 0) {
+        lines.push(`  ${member.name} = ${JSON.stringify(member.value)},`);
+      } else {
+        lines.push(`  ${member.name},`);
+      }
+    }
+  }
+  lines.push("}");
+  lines.push("```");
+  return lines.join("\n");
+}
+function formatConstant(constant) {
+  const lines = [];
+  lines.push(`#### \`${constant.name}\``);
+  if (constant.description) {
+    lines.push(`
+${constant.description}`);
+  }
+  lines.push("\n```typescript");
+  lines.push(constant.signature);
+  lines.push("```");
+  return lines.join("\n");
+}
+
+// src/plugins/core/llms-full-output.ts
+var llmsFullOutputPlugin = {
+  name: "llms-full-output",
+  version: "1.0.0",
+  category: "output",
+  install(kernel) {
+    kernel.on("output:start", async (context) => {
+      if (!context.options.formats?.includes("llms-full")) {
+        return;
+      }
+      try {
+        const output = generateLlmsFullTxt(context, {
+          includeExamples: true,
+          includeParamDescriptions: true,
+          includeDeprecations: true
+        });
+        context.outputs.set("llms-full", output);
+      } catch (error) {
+        context.errors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+};
+
+// src/outputs/markdown.ts
+function generateMarkdown(context, options = {}) {
+  const {
+    includeToc = true,
+    includeParamTables = true,
+    includeBadges = true,
+    repositoryUrl
+  } = options;
+  const { package: pkg, api, readme } = context;
+  const sections = [];
+  sections.push(`# ${pkg.name}`);
+  sections.push("");
+  if (includeBadges) {
+    const badges = [];
+    badges.push(`![npm version](https://img.shields.io/npm/v/${encodeURIComponent(pkg.name)})`);
+    if (pkg.license) {
+      badges.push(`![license](https://img.shields.io/npm/l/${encodeURIComponent(pkg.name)})`);
+    }
+    if (badges.length > 0) {
+      sections.push(badges.join(" "));
+      sections.push("");
+    }
+  }
+  if (pkg.description) {
+    sections.push(`> ${pkg.description}`);
+    sections.push("");
+  }
+  if (includeToc) {
+    sections.push("## Table of Contents\n");
+    sections.push("- [Installation](#installation)");
+    if (readme?.quickStart) {
+      sections.push("- [Quick Start](#quick-start)");
+    }
+    sections.push("- [API Reference](#api-reference)");
+    const functions2 = api.filter((e) => e.kind === "function");
+    const classes2 = api.filter((e) => e.kind === "class");
+    const interfaces2 = api.filter((e) => e.kind === "interface");
+    const types2 = api.filter((e) => e.kind === "type");
+    if (functions2.length > 0) {
+      sections.push("  - [Functions](#functions)");
+    }
+    if (classes2.length > 0) {
+      sections.push("  - [Classes](#classes)");
+    }
+    if (interfaces2.length > 0) {
+      sections.push("  - [Interfaces](#interfaces)");
+    }
+    if (types2.length > 0) {
+      sections.push("  - [Types](#types)");
+    }
+    sections.push("");
+  }
+  sections.push("## Installation\n");
+  sections.push("```bash");
+  sections.push(`npm install ${pkg.name}`);
+  sections.push("```\n");
+  sections.push("Or with yarn:\n");
+  sections.push("```bash");
+  sections.push(`yarn add ${pkg.name}`);
+  sections.push("```\n");
+  if (readme?.quickStart) {
+    sections.push("## Quick Start\n");
+    sections.push(readme.quickStart);
+    sections.push("");
+  }
+  sections.push("## API Reference\n");
+  const functions = api.filter((e) => e.kind === "function");
+  const classes = api.filter((e) => e.kind === "class");
+  const interfaces = api.filter((e) => e.kind === "interface");
+  const types = api.filter((e) => e.kind === "type");
+  const enums = api.filter((e) => e.kind === "enum");
+  const constants = api.filter((e) => e.kind === "constant");
+  if (functions.length > 0) {
+    sections.push("### Functions\n");
+    for (const fn of functions) {
+      sections.push(formatFunctionMd(fn, { includeParamTables, repositoryUrl }));
+      sections.push("");
+      sections.push("---\n");
+    }
+  }
+  if (classes.length > 0) {
+    sections.push("### Classes\n");
+    for (const cls of classes) {
+      sections.push(formatClassMd(cls));
+      sections.push("");
+      sections.push("---\n");
+    }
+  }
+  if (interfaces.length > 0) {
+    sections.push("### Interfaces\n");
+    for (const iface of interfaces) {
+      sections.push(formatInterfaceMd(iface));
+      sections.push("");
+      sections.push("---\n");
+    }
+  }
+  if (types.length > 0) {
+    sections.push("### Types\n");
+    for (const type of types) {
+      sections.push(formatTypeMd(type));
+      sections.push("");
+    }
+  }
+  if (enums.length > 0) {
+    sections.push("### Enums\n");
+    for (const enumEntry of enums) {
+      sections.push(formatEnumMd(enumEntry));
+      sections.push("");
+    }
+  }
+  if (constants.length > 0) {
+    sections.push("### Constants\n");
+    for (const constant of constants) {
+      sections.push(formatConstantMd(constant));
+    }
+    sections.push("");
+  }
+  const output = sections.join("\n");
+  context.tokenCount = countTokens(output);
+  return output;
+}
+function formatFunctionMd(fn, options) {
+  const lines = [];
+  const anchor = fn.name.toLowerCase();
+  lines.push(`<a name="${anchor}"></a>`);
+  lines.push(`#### \`${fn.name}()\``);
+  if (fn.deprecated) {
+    lines.push(`
+> \u26A0\uFE0F **Deprecated:** ${typeof fn.deprecated === "string" ? fn.deprecated : "This function is deprecated."}
+`);
+  }
+  if (fn.description) {
+    lines.push(`
+${fn.description}
+`);
+  }
+  lines.push("**Signature:**\n");
+  lines.push("```typescript");
+  lines.push(fn.signature);
+  lines.push("```\n");
+  if (fn.params && fn.params.length > 0 && options.includeParamTables) {
+    lines.push("**Parameters:**\n");
+    lines.push("| Name | Type | Required | Description |");
+    lines.push("|------|------|----------|-------------|");
+    for (const param of fn.params) {
+      const required = param.optional ? "No" : "Yes";
+      const desc = param.description || "-";
+      const defaultVal = param.defaultValue ? ` (default: \`${param.defaultValue}\`)` : "";
+      lines.push(`| \`${param.name}\` | \`${param.type || "unknown"}\` | ${required} | ${desc}${defaultVal} |`);
+    }
+    lines.push("");
+  }
+  if (fn.returns) {
+    lines.push("**Returns:**\n");
+    lines.push(`\`${fn.returns.type}\`${fn.returns.description ? ` - ${fn.returns.description}` : ""}
+`);
+  }
+  if (fn.examples && fn.examples.length > 0) {
+    lines.push("**Example:**\n");
+    for (const example of fn.examples) {
+      if (example.includes("```")) {
+        lines.push(example);
+      } else {
+        lines.push("```typescript");
+        lines.push(example);
+        lines.push("```");
+      }
+    }
+    lines.push("");
+  }
+  if (options.repositoryUrl && fn.sourceFile) {
+    const sourceUrl = `${options.repositoryUrl}/blob/main/${fn.sourceFile}${fn.line ? `#L${fn.line}` : ""}`;
+    lines.push(`[View source](${sourceUrl})
+`);
+  }
+  return lines.join("\n");
+}
+function formatClassMd(cls, options) {
+  const lines = [];
+  const anchor = cls.name.toLowerCase();
+  lines.push(`<a name="${anchor}"></a>`);
+  lines.push(`#### \`${cls.name}\``);
+  if (cls.deprecated) {
+    lines.push(`
+> \u26A0\uFE0F **Deprecated**
+`);
+  }
+  if (cls.description) {
+    lines.push(`
+${cls.description}
+`);
+  }
+  if (cls.extends && cls.extends.length > 0) {
+    lines.push(`**Extends:** ${cls.extends.map((e) => `\`${e}\``).join(", ")}
+`);
+  }
+  if (cls.implements && cls.implements.length > 0) {
+    lines.push(`**Implements:** ${cls.implements.map((e) => `\`${e}\``).join(", ")}
+`);
+  }
+  const constructor = cls.methods?.find((m) => m.name === "constructor");
+  if (constructor) {
+    lines.push("**Constructor:**\n");
+    lines.push("```typescript");
+    lines.push(`new ${cls.name}(${constructor.params?.map((p) => `${p.name}: ${p.type}`).join(", ") || ""})`);
+    lines.push("```\n");
+  }
+  if (cls.properties && cls.properties.length > 0) {
+    lines.push("**Properties:**\n");
+    lines.push("| Name | Type | Description |");
+    lines.push("|------|------|-------------|");
+    for (const prop of cls.properties) {
+      const type = prop.signature.split(":").slice(1).join(":").trim() || "unknown";
+      lines.push(`| \`${prop.name}\` | \`${type}\` | ${prop.description || "-"} |`);
+    }
+    lines.push("");
+  }
+  const methods = cls.methods?.filter((m) => m.name !== "constructor") || [];
+  if (methods.length > 0) {
+    lines.push("**Methods:**\n");
+    lines.push("| Method | Returns | Description |");
+    lines.push("|--------|---------|-------------|");
+    for (const method of methods) {
+      const params = method.params?.map((p) => `${p.name}`).join(", ") || "";
+      const returnType = method.returns?.type || "void";
+      lines.push(`| \`${method.name}(${params})\` | \`${returnType}\` | ${method.description || "-"} |`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatInterfaceMd(iface) {
+  const lines = [];
+  lines.push(`#### \`${iface.name}\``);
+  if (iface.description) {
+    lines.push(`
+${iface.description}
+`);
+  }
+  if (iface.extends && iface.extends.length > 0) {
+    lines.push(`**Extends:** ${iface.extends.map((e) => `\`${e}\``).join(", ")}
+`);
+  }
+  if (iface.properties && iface.properties.length > 0) {
+    lines.push("| Property | Type | Description |");
+    lines.push("|----------|------|-------------|");
+    for (const prop of iface.properties) {
+      const type = prop.signature.split(":").slice(1).join(":").trim() || "unknown";
+      lines.push(`| \`${prop.name}\` | \`${type}\` | ${prop.description || "-"} |`);
+    }
+    lines.push("");
+  }
+  lines.push("<details>");
+  lines.push("<summary>Full Definition</summary>\n");
+  lines.push("```typescript");
+  lines.push(`interface ${iface.name} {`);
+  if (iface.properties) {
+    for (const prop of iface.properties) {
+      lines.push(`  ${prop.signature};`);
+    }
+  }
+  if (iface.methods) {
+    for (const method of iface.methods) {
+      lines.push(`  ${method.signature};`);
+    }
+  }
+  lines.push("}");
+  lines.push("```");
+  lines.push("</details>");
+  return lines.join("\n");
+}
+function formatTypeMd(type) {
+  const lines = [];
+  lines.push(`#### \`${type.name}\``);
+  if (type.description) {
+    lines.push(`
+${type.description}
+`);
+  }
+  lines.push("```typescript");
+  lines.push(type.signature);
+  lines.push("```");
+  return lines.join("\n");
+}
+function formatEnumMd(enumEntry) {
+  const lines = [];
+  lines.push(`#### \`${enumEntry.name}\``);
+  if (enumEntry.description) {
+    lines.push(`
+${enumEntry.description}
+`);
+  }
+  if (enumEntry.members && enumEntry.members.length > 0) {
+    lines.push("| Member | Value |");
+    lines.push("|--------|-------|");
+    for (const member of enumEntry.members) {
+      const value = member.value !== void 0 ? `\`${JSON.stringify(member.value)}\`` : "-";
+      lines.push(`| \`${member.name}\` | ${value} |`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatConstantMd(constant) {
+  const lines = [];
+  lines.push(`- **\`${constant.name}\`**: \`${constant.signature.split(":").slice(1).join(":").trim() || "unknown"}\``);
+  if (constant.description) {
+    lines.push(`  - ${constant.description}`);
+  }
+  return lines.join("\n");
+}
+
+// src/plugins/core/markdown-output.ts
+var markdownOutputPlugin = {
+  name: "markdown-output",
+  version: "1.0.0",
+  category: "output",
+  install(kernel) {
+    kernel.on("output:start", async (context) => {
+      if (!context.options.formats?.includes("markdown")) {
+        return;
+      }
+      try {
+        const repositoryUrl = context.package.repository?.url?.replace(/^git\+/, "").replace(/\.git$/, "");
+        const output = generateMarkdown(context, {
+          includeToc: true,
+          includeParamTables: true,
+          includeBadges: true,
+          repositoryUrl
+        });
+        context.outputs.set("markdown", output);
+      } catch (error) {
+        context.errors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+};
+
+// src/outputs/json.ts
+function generateJson(context, options = {}) {
+  const { pretty = true, includeEmpty = false, includeSourceLocations = true } = options;
+  const output = generateJsonObject(context, { includeEmpty, includeSourceLocations });
+  return pretty ? JSON.stringify(output, null, 2) : JSON.stringify(output);
+}
+function generateJsonObject(context, options = {}) {
+  const { includeEmpty = false, includeSourceLocations = true } = options;
+  const { package: pkg, api } = context;
+  const functions = api.filter((e) => e.kind === "function");
+  const classes = api.filter((e) => e.kind === "class");
+  const interfaces = api.filter((e) => e.kind === "interface");
+  const types = api.filter((e) => e.kind === "type");
+  const enums = api.filter((e) => e.kind === "enum");
+  const constants = api.filter((e) => e.kind === "constant");
+  const documented = api.filter((e) => e.description).length;
+  const withExamples = api.filter((e) => e.examples && e.examples.length > 0).length;
+  const output = {
+    $schema: "https://npm-llms.oxog.dev/schema/v1.json",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    package: {
+      name: pkg.name,
+      version: pkg.version,
+      description: pkg.description,
+      license: pkg.license,
+      homepage: pkg.homepage,
+      repository: pkg.repository?.url,
+      keywords: pkg.keywords
+    },
+    api: {
+      functions: functions.map((fn) => transformFunction(fn, includeSourceLocations)),
+      classes: classes.map((cls) => transformClass(cls, includeSourceLocations)),
+      interfaces: interfaces.map(transformInterface),
+      types: types.map(transformType),
+      enums: enums.map(transformEnum),
+      constants: constants.map(transformConstant)
+    },
+    stats: {
+      totalExports: api.length,
+      functions: functions.length,
+      classes: classes.length,
+      interfaces: interfaces.length,
+      types: types.length,
+      enums: enums.length,
+      constants: constants.length,
+      documented,
+      withExamples
+    }
+  };
+  if (!includeEmpty) {
+    const apiObj = output.api;
+    for (const [key, value] of Object.entries(apiObj)) {
+      if (Array.isArray(value) && value.length === 0) {
+        delete apiObj[key];
+      }
+    }
+  }
+  return output;
+}
+function transformFunction(entry, includeSource) {
+  const result = {
+    name: entry.name,
+    signature: entry.signature,
+    description: entry.description,
+    params: (entry.params || []).map((p) => ({
+      name: p.name,
+      type: p.type || "unknown",
+      optional: p.optional ?? false,
+      defaultValue: p.defaultValue,
+      description: p.description
+    })),
+    returns: entry.returns ? {
+      type: entry.returns.type,
+      description: entry.returns.description
+    } : void 0,
+    examples: entry.examples || [],
+    deprecated: entry.deprecated,
+    since: entry.since,
+    see: entry.see
+  };
+  if (includeSource) {
+    result.sourceFile = entry.sourceFile;
+    result.line = entry.line;
+  }
+  return result;
+}
+function transformClass(entry, includeSource) {
+  const result = {
+    name: entry.name,
+    signature: entry.signature,
+    description: entry.description,
+    extends: entry.extends,
+    implements: entry.implements,
+    typeParams: entry.typeParams,
+    properties: (entry.properties || []).map((p) => ({
+      name: p.name,
+      type: p.signature.split(":").slice(1).join(":").trim() || "unknown",
+      description: p.description
+    })),
+    methods: (entry.methods || []).map((m) => transformFunction(m, includeSource)),
+    deprecated: entry.deprecated
+  };
+  if (includeSource) {
+    result.sourceFile = entry.sourceFile;
+  }
+  return result;
+}
+function transformInterface(entry) {
+  return {
+    name: entry.name,
+    signature: entry.signature,
+    description: entry.description,
+    extends: entry.extends,
+    typeParams: entry.typeParams,
+    properties: (entry.properties || []).map((p) => ({
+      name: p.name,
+      type: p.signature.split(":").slice(1).join(":").trim() || "unknown",
+      optional: p.signature.includes("?:"),
+      description: p.description
+    })),
+    methods: (entry.methods || []).map((m) => ({
+      name: m.name,
+      signature: m.signature,
+      description: m.description
+    })),
+    deprecated: entry.deprecated
+  };
+}
+function transformType(entry) {
+  return {
+    name: entry.name,
+    signature: entry.signature,
+    description: entry.description,
+    typeParams: entry.typeParams,
+    deprecated: entry.deprecated
+  };
+}
+function transformEnum(entry) {
+  return {
+    name: entry.name,
+    description: entry.description,
+    members: entry.members || []
+  };
+}
+function transformConstant(entry) {
+  return {
+    name: entry.name,
+    type: entry.signature.split(":").slice(1).join(":").trim() || "unknown",
+    description: entry.description
+  };
+}
+
+// src/plugins/core/json-output.ts
+var jsonOutputPlugin = {
+  name: "json-output",
+  version: "1.0.0",
+  category: "output",
+  install(kernel) {
+    kernel.on("output:start", async (context) => {
+      if (!context.options.formats?.includes("json")) {
+        return;
+      }
+      try {
+        const output = generateJson(context, {
+          pretty: true,
+          includeEmpty: false,
+          includeSourceLocations: true
+        });
+        context.outputs.set("json", output);
+      } catch (error) {
+        context.errors.push(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+};
+
+// src/plugins/core/index.ts
+var coreParserPlugins = [
+  typesResolverPlugin,
+  dtsParserPlugin,
+  tsSourceParserPlugin,
+  readmeParserPlugin
+];
+var coreOutputPlugins = [
+  llmsOutputPlugin,
+  llmsFullOutputPlugin,
+  markdownOutputPlugin,
+  jsonOutputPlugin
+];
+var corePlugins = [
+  ...coreParserPlugins,
+  ...coreOutputPlugins
+];
+
+// src/plugins/optional/ai-base.ts
+var DEFAULT_OPTIONS = {
+  tasks: ["descriptions", "examples"],
+  maxTokensPerRequest: 1e3,
+  temperature: 0.3,
+  batchSize: 5,
+  skipExisting: true
+};
+var SYSTEM_PROMPTS = {
+  descriptions: `You are a technical documentation expert. Generate concise, clear descriptions for API entries.
+Rules:
+- Be specific about what the function/class does
+- Mention important parameters and return values
+- Keep descriptions under 100 words
+- Use present tense ("Returns..." not "Will return...")
+- Don't include example code in descriptions`,
+  examples: `You are a technical documentation expert. Generate practical usage examples for API entries.
+Rules:
+- Create 1-2 realistic examples
+- Show common use cases
+- Include proper TypeScript/JavaScript syntax
+- Keep examples concise but complete
+- Use meaningful variable names`,
+  summary: `You are a technical documentation expert. Generate a summary of an npm package.
+Rules:
+- Describe the main purpose and use cases
+- Mention key features
+- Keep it under 150 words
+- Be objective and informative`,
+  params: `You are a technical documentation expert. Generate parameter descriptions.
+Rules:
+- Be specific about expected values
+- Mention valid ranges or formats
+- Note if parameter is optional
+- Keep each description under 20 words`,
+  returns: `You are a technical documentation expert. Generate return value descriptions.
+Rules:
+- Describe what is returned
+- Mention possible values or states
+- Keep descriptions under 30 words`
+};
+function generateEntryPrompt(entry, task) {
+  const parts = [`${entry.kind}: ${entry.name}`, `Signature: ${entry.signature}`];
+  if (entry.description) {
+    parts.push(`Current description: ${entry.description}`);
+  }
+  if (entry.params && entry.params.length > 0) {
+    const paramList = entry.params.map((p) => `- ${p.name}: ${p.type || "unknown"}`).join("\n");
+    parts.push(`Parameters:
+${paramList}`);
+  }
+  if (entry.returns) {
+    parts.push(`Returns: ${entry.returns.type}`);
+  }
+  switch (task) {
+    case "descriptions":
+      parts.push("\nGenerate a clear description for this API entry:");
+      break;
+    case "examples":
+      parts.push("\nGenerate a practical usage example:");
+      break;
+  }
+  return parts.join("\n");
+}
+function generateSummaryPrompt(context) {
+  const { package: pkg, api } = context;
+  const functionCount = api.filter((e) => e.kind === "function").length;
+  const classCount = api.filter((e) => e.kind === "class").length;
+  const typeCount = api.filter((e) => e.kind === "type" || e.kind === "interface").length;
+  return `
+Package: ${pkg.name}@${pkg.version}
+Description: ${pkg.description || "No description available"}
+Functions: ${functionCount}
+Classes: ${classCount}
+Types: ${typeCount}
+
+Top exports:
+${api.slice(0, 10).map((e) => `- ${e.kind} ${e.name}`).join("\n")}
+
+Generate a summary of this package that explains its purpose and main features:
+`.trim();
+}
+function parseDescriptionResponse(response) {
+  return response.trim().replace(/^Description:\s*/i, "").replace(/^["']|["']$/g, "");
+}
+function parseExampleResponse(response) {
+  const examples = [];
+  const codeBlockRegex = /```(?:\w+)?\n?([\s\S]*?)```/g;
+  let match;
+  while ((match = codeBlockRegex.exec(response)) !== null) {
+    if (match[1]?.trim()) {
+      examples.push(match[1].trim());
+    }
+  }
+  if (examples.length === 0 && response.trim()) {
+    examples.push(response.trim());
+  }
+  return examples;
+}
+function createAIEnrichmentPlugin(provider, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  return {
+    name: `ai-enrichment-${provider.name}`,
+    version: "1.0.0",
+    category: "ai",
+    install(kernel) {
+      kernel.on("ai:enrich", async (context) => {
+        if (!provider.isAvailable()) {
+          throw new AIError(`AI provider ${provider.name} is not available`, provider.name);
+        }
+        if (opts.tasks.includes("descriptions") || opts.tasks.includes("examples")) {
+          await enrichEntries(context, provider, opts);
+        }
+        if (opts.tasks.includes("summary")) {
+          await enrichSummary(context, provider, opts);
+        }
+      });
+    }
+  };
+}
+async function enrichEntries(context, provider, options) {
+  const { api } = context;
+  const { tasks, batchSize, skipExisting, maxTokensPerRequest, temperature } = options;
+  const entriesToEnrich = api.filter((entry) => {
+    if (skipExisting) {
+      if (tasks.includes("descriptions") && entry.description) return false;
+      if (tasks.includes("examples") && entry.examples && entry.examples.length > 0) return false;
+    }
+    return entry.kind === "function" || entry.kind === "class";
+  });
+  for (let i = 0; i < entriesToEnrich.length; i += batchSize) {
+    const batch = entriesToEnrich.slice(i, i + batchSize);
+    await Promise.all(
+      batch.map(async (entry) => {
+        try {
+          if (tasks.includes("descriptions") && (!skipExisting || !entry.description)) {
+            const prompt = generateEntryPrompt(entry, "descriptions");
+            const response = await provider.complete(prompt, {
+              maxTokens: maxTokensPerRequest,
+              temperature,
+              systemPrompt: SYSTEM_PROMPTS.descriptions
+            });
+            entry.description = parseDescriptionResponse(response);
+          }
+          if (tasks.includes("examples") && (!skipExisting || !entry.examples?.length)) {
+            const prompt = generateEntryPrompt(entry, "examples");
+            const response = await provider.complete(prompt, {
+              maxTokens: maxTokensPerRequest,
+              temperature,
+              systemPrompt: SYSTEM_PROMPTS.examples
+            });
+            entry.examples = parseExampleResponse(response);
+          }
+        } catch (error) {
+          context.errors.push(
+            error instanceof Error ? error : new Error(`AI enrichment failed for ${entry.name}`)
+          );
+        }
+      })
+    );
+  }
+}
+async function enrichSummary(context, provider, options) {
+  try {
+    const prompt = generateSummaryPrompt(context);
+    const response = await provider.complete(prompt, {
+      maxTokens: options.maxTokensPerRequest,
+      temperature: options.temperature,
+      systemPrompt: SYSTEM_PROMPTS.summary
+    });
+    if (context.readme) {
+      if (!context.readme.description) {
+        context.readme.description = response.trim();
+      }
+    }
+  } catch (error) {
+    context.errors.push(
+      error instanceof Error ? error : new Error("AI summary generation failed")
+    );
+  }
+}
+function createSimpleProvider(name, completeFn, isAvailableFn = () => true) {
+  return {
+    name,
+    isAvailable: isAvailableFn,
+    complete: completeFn
+  };
+}
+
+// src/plugins/optional/claude-ai.ts
+var DEFAULT_CONFIG = {
+  apiKey: "",
+  model: "claude-haiku-4-5-20251001",
+  baseUrl: "https://api.anthropic.com",
+  timeout: 3e4
+};
+function createClaudeProvider(config = {}) {
+  const cfg = {
+    ...DEFAULT_CONFIG,
+    ...config,
+    apiKey: config.apiKey || process.env["ANTHROPIC_API_KEY"] || ""
+  };
+  return {
+    name: "claude",
+    isAvailable() {
+      return !!cfg.apiKey;
+    },
+    async complete(prompt, options) {
+      if (!cfg.apiKey) {
+        throw new AIError("ANTHROPIC_API_KEY not set", "claude");
+      }
+      const requestBody = {
+        model: cfg.model,
+        max_tokens: options?.maxTokens ?? 1e3,
+        messages: [{ role: "user", content: prompt }],
+        temperature: options?.temperature ?? 0.3
+      };
+      if (options?.systemPrompt) {
+        requestBody.system = options.systemPrompt;
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), cfg.timeout);
+      try {
+        const response = await fetch(`${cfg.baseUrl}/v1/messages`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-api-key": cfg.apiKey,
+            "anthropic-version": "2023-06-01"
+          },
+          body: JSON.stringify(requestBody),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new AIError(
+            `Claude API error: ${response.status} ${response.statusText} - ${errorText}`,
+            "claude"
+          );
+        }
+        const data = await response.json();
+        const textContent = data.content.find((c) => c.type === "text");
+        if (!textContent) {
+          throw new AIError("No text content in Claude response", "claude");
+        }
+        return textContent.text;
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof AIError) {
+          throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new AIError("Claude API request timed out", "claude");
+        }
+        throw new AIError(
+          `Claude API request failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+          "claude"
+        );
+      }
+    }
+  };
+}
+function createClaudePlugin(config = {}, enrichmentOptions) {
+  const provider = createClaudeProvider(config);
+  return createAIEnrichmentPlugin(provider, enrichmentOptions);
+}
+
+// src/plugins/optional/openai-ai.ts
+var OPENAI_COMPATIBLE_PRESETS = {
+  openai: {
+    name: "openai",
+    baseUrl: "https://api.openai.com/v1",
+    envKey: "OPENAI_API_KEY",
+    defaultModel: "gpt-4.1-nano"
+  },
+  xai: {
+    name: "xai",
+    baseUrl: "https://api.x.ai/v1",
+    envKey: "XAI_API_KEY",
+    defaultModel: "grok-3-mini-fast"
+  },
+  zai: {
+    name: "zai",
+    baseUrl: "https://api.z.ai/api/paas/v4",
+    envKey: "ZAI_API_KEY",
+    defaultModel: "glm-4.7"
+  },
+  together: {
+    name: "together",
+    baseUrl: "https://api.together.xyz/v1",
+    envKey: "TOGETHER_API_KEY",
+    defaultModel: "meta-llama/Llama-3.3-70B-Instruct-Turbo"
+  },
+  perplexity: {
+    name: "perplexity",
+    baseUrl: "https://api.perplexity.ai",
+    envKey: "PERPLEXITY_API_KEY",
+    defaultModel: "sonar-pro"
+  },
+  openrouter: {
+    name: "openrouter",
+    baseUrl: "https://openrouter.ai/api/v1",
+    envKey: "OPENROUTER_API_KEY",
+    defaultModel: "anthropic/claude-3.5-sonnet"
+  },
+  deepseek: {
+    name: "deepseek",
+    baseUrl: "https://api.deepseek.com/v1",
+    envKey: "DEEPSEEK_API_KEY",
+    defaultModel: "deepseek-chat"
+  },
+  mistral: {
+    name: "mistral",
+    baseUrl: "https://api.mistral.ai/v1",
+    envKey: "MISTRAL_API_KEY",
+    defaultModel: "mistral-small-latest"
+  }
+};
+var DEFAULT_CONFIG2 = {
+  apiKey: "",
+  model: "gpt-4.1-nano",
+  baseUrl: "https://api.openai.com/v1",
+  timeout: 3e4,
+  organization: void 0,
+  preset: void 0
+};
+function createOpenAIProvider(config = {}) {
+  const preset = config.preset ? OPENAI_COMPATIBLE_PRESETS[config.preset] : null;
+  const cfg = {
+    ...DEFAULT_CONFIG2,
+    ...preset && {
+      baseUrl: preset.baseUrl,
+      model: preset.defaultModel
+    },
+    ...config,
+    apiKey: config.apiKey || process.env[preset?.envKey ?? "OPENAI_API_KEY"] || ""
+  };
+  const providerName = preset?.name ?? "openai";
+  return {
+    name: providerName,
+    isAvailable() {
+      return !!cfg.apiKey;
+    },
+    async complete(prompt, options) {
+      if (!cfg.apiKey) {
+        throw new AIError(`${preset?.envKey ?? "OPENAI_API_KEY"} not set`, providerName);
+      }
+      const messages = [];
+      if (options?.systemPrompt) {
+        messages.push({ role: "system", content: options.systemPrompt });
+      }
+      messages.push({ role: "user", content: prompt });
+      const requestBody = {
+        model: cfg.model,
+        messages,
+        max_tokens: options?.maxTokens ?? 1e3,
+        temperature: options?.temperature ?? 0.3
+      };
+      const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${cfg.apiKey}`
+      };
+      if (cfg.organization) {
+        headers["OpenAI-Organization"] = cfg.organization;
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), cfg.timeout);
+      try {
+        const response = await fetch(`${cfg.baseUrl}/chat/completions`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(requestBody),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new AIError(
+            `${providerName} API error: ${response.status} ${response.statusText} - ${errorText}`,
+            providerName
+          );
+        }
+        const data = await response.json();
+        const choice = data.choices[0];
+        if (!choice || !choice.message.content) {
+          throw new AIError(`No content in ${providerName} response`, providerName);
+        }
+        return choice.message.content;
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof AIError) {
+          throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new AIError(`${providerName} API request timed out`, providerName);
+        }
+        throw new AIError(
+          `${providerName} API request failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+          providerName
+        );
+      }
+    }
+  };
+}
+function createOpenAIPlugin(config = {}, enrichmentOptions) {
+  const provider = createOpenAIProvider(config);
+  return createAIEnrichmentPlugin(provider, enrichmentOptions);
+}
+
+// src/plugins/optional/gemini-ai.ts
+var DEFAULT_CONFIG3 = {
+  model: "gemini-3-flash-preview",
+  baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+  timeout: 6e4,
+  maxTokens: 1024,
+  temperature: 0.3
+};
+function createGeminiProvider(config = {}) {
+  const cfg = {
+    ...DEFAULT_CONFIG3,
+    ...config,
+    apiKey: config.apiKey || process.env["GOOGLE_API_KEY"] || process.env["GEMINI_API_KEY"] || ""
+  };
+  return {
+    name: "gemini",
+    isAvailable() {
+      return !!cfg.apiKey;
+    },
+    async complete(prompt, options) {
+      if (!cfg.apiKey) {
+        throw new Error("Gemini API key not configured. Set GOOGLE_API_KEY or GEMINI_API_KEY environment variable.");
+      }
+      const url = `${cfg.baseUrl}/models/${cfg.model}:generateContent?key=${cfg.apiKey}`;
+      const contents = [];
+      if (options?.systemPrompt) {
+        contents.push({
+          role: "user",
+          parts: [{ text: `System instruction: ${options.systemPrompt}
+
+Now respond to the following:` }]
+        });
+        contents.push({
+          role: "model",
+          parts: [{ text: "Understood. I will follow those instructions." }]
+        });
+      }
+      contents.push({
+        role: "user",
+        parts: [{ text: prompt }]
+      });
+      const body = {
+        contents,
+        generationConfig: {
+          maxOutputTokens: options?.maxTokens ?? cfg.maxTokens,
+          temperature: options?.temperature ?? cfg.temperature
+        }
+      };
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), cfg.timeout);
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(body),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new Error(`Gemini API error (${response.status}): ${errorText}`);
+        }
+        const data = await response.json();
+        if (data.error) {
+          throw new Error(`Gemini API error: ${data.error.message}`);
+        }
+        const text = data.candidates?.[0]?.content?.parts?.[0]?.text;
+        if (!text) {
+          throw new Error("No response generated from Gemini");
+        }
+        return text;
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new Error(`Gemini request timed out after ${cfg.timeout}ms`);
+        }
+        throw error;
+      }
+    }
+  };
+}
+function createGeminiPlugin(config = {}, enrichmentOptions) {
+  const provider = createGeminiProvider(config);
+  return createAIEnrichmentPlugin(provider, enrichmentOptions);
+}
+function checkGeminiAvailable() {
+  return !!(process.env["GOOGLE_API_KEY"] || process.env["GEMINI_API_KEY"]);
+}
+
+// src/plugins/optional/ollama-ai.ts
+var DEFAULT_CONFIG4 = {
+  model: "llama3.2",
+  baseUrl: "http://localhost:11434",
+  timeout: 12e4
+  // Longer timeout for local models
+};
+function createOllamaProvider(config = {}) {
+  const cfg = { ...DEFAULT_CONFIG4, ...config };
+  let available = null;
+  return {
+    name: "ollama",
+    isAvailable() {
+      if (available !== null) {
+        return available;
+      }
+      return true;
+    },
+    async complete(prompt, options) {
+      const requestBody = {
+        model: cfg.model,
+        prompt,
+        stream: false,
+        options: {
+          temperature: options?.temperature ?? 0.3,
+          num_predict: options?.maxTokens ?? 1e3
+        }
+      };
+      if (options?.systemPrompt) {
+        requestBody.system = options.systemPrompt;
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), cfg.timeout);
+      try {
+        const response = await fetch(`${cfg.baseUrl}/api/generate`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(requestBody),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          available = false;
+          const errorText = await response.text();
+          throw new AIError(
+            `Ollama API error: ${response.status} ${response.statusText} - ${errorText}`,
+            "ollama"
+          );
+        }
+        available = true;
+        const data = await response.json();
+        if (!data.response) {
+          throw new AIError("No response from Ollama", "ollama");
+        }
+        return data.response;
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof AIError) {
+          throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new AIError("Ollama request timed out", "ollama");
+        }
+        if (error instanceof Error && error.message.includes("ECONNREFUSED")) {
+          available = false;
+          throw new AIError("Ollama is not running. Start it with: ollama serve", "ollama");
+        }
+        throw new AIError(
+          `Ollama request failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+          "ollama"
+        );
+      }
+    }
+  };
+}
+function createOllamaPlugin(config = {}, enrichmentOptions) {
+  const provider = createOllamaProvider(config);
+  return createAIEnrichmentPlugin(provider, enrichmentOptions);
+}
+async function checkOllamaAvailable(baseUrl = "http://localhost:11434") {
+  try {
+    const response = await fetch(`${baseUrl}/api/tags`, {
+      method: "GET",
+      signal: AbortSignal.timeout(5e3)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function listOllamaModels(baseUrl = "http://localhost:11434") {
+  try {
+    const response = await fetch(`${baseUrl}/api/tags`, {
+      method: "GET",
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!response.ok) {
+      return [];
+    }
+    const data = await response.json();
+    return data.models.map((m) => m.name);
+  } catch {
+    return [];
+  }
+}
+
+// src/plugins/optional/groq-ai.ts
+var DEFAULT_CONFIG5 = {
+  apiKey: "",
+  model: "llama-3.1-8b-instant",
+  baseUrl: "https://api.groq.com/openai",
+  timeout: 3e4
+};
+function createGroqProvider(config = {}) {
+  const cfg = {
+    ...DEFAULT_CONFIG5,
+    ...config,
+    apiKey: config.apiKey || process.env["GROQ_API_KEY"] || ""
+  };
+  return {
+    name: "groq",
+    isAvailable() {
+      return !!cfg.apiKey;
+    },
+    async complete(prompt, options) {
+      if (!cfg.apiKey) {
+        throw new AIError("GROQ_API_KEY not set", "groq");
+      }
+      const messages = [];
+      if (options?.systemPrompt) {
+        messages.push({ role: "system", content: options.systemPrompt });
+      }
+      messages.push({ role: "user", content: prompt });
+      const requestBody = {
+        model: cfg.model,
+        messages,
+        max_tokens: options?.maxTokens ?? 1e3,
+        temperature: options?.temperature ?? 0.3
+      };
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), cfg.timeout);
+      try {
+        const response = await fetch(`${cfg.baseUrl}/v1/chat/completions`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${cfg.apiKey}`
+          },
+          body: JSON.stringify(requestBody),
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new AIError(
+            `Groq API error: ${response.status} ${response.statusText} - ${errorText}`,
+            "groq"
+          );
+        }
+        const data = await response.json();
+        const choice = data.choices[0];
+        if (!choice || !choice.message.content) {
+          throw new AIError("No content in Groq response", "groq");
+        }
+        return choice.message.content;
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof AIError) {
+          throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          throw new AIError("Groq API request timed out", "groq");
+        }
+        throw new AIError(
+          `Groq API request failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+          "groq"
+        );
+      }
+    }
+  };
+}
+function createGroqPlugin(config = {}, enrichmentOptions) {
+  const provider = createGroqProvider(config);
+  return createAIEnrichmentPlugin(provider, enrichmentOptions);
+}
+
+// src/kernel.ts
+function createKernel() {
+  const plugins = /* @__PURE__ */ new Map();
+  const eventHandlers = /* @__PURE__ */ new Map();
+  const handlerToPlugin = /* @__PURE__ */ new Map();
+  function handlePluginError(error, pluginName) {
+    const plugin = pluginName ? plugins.get(pluginName) : void 0;
+    if (plugin?.onError) {
+      try {
+        plugin.onError(error);
+      } catch {
+      }
+    }
+  }
+  function use(plugin) {
+    if (!plugin.name) {
+      throw new PluginError("Plugin must have a name");
+    }
+    if (plugins.has(plugin.name)) {
+      throw new PluginError(`Plugin "${plugin.name}" is already registered`, plugin.name);
+    }
+    if (plugin.dependencies) {
+      for (const dep of plugin.dependencies) {
+        if (!plugins.has(dep)) {
+          throw new PluginError(
+            `Plugin "${plugin.name}" depends on "${dep}" which is not registered`,
+            plugin.name
+          );
+        }
+      }
+    }
+    try {
+      plugin.install(kernel);
+      plugins.set(plugin.name, plugin);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      throw new PluginError(
+        `Failed to install plugin "${plugin.name}": ${err.message}`,
+        plugin.name
+      );
+    }
+    return kernel;
+  }
+  function unregister(name) {
+    const plugin = plugins.get(name);
+    if (!plugin) {
+      return false;
+    }
+    for (const [, p] of plugins) {
+      if (p.dependencies?.includes(name)) {
+        throw new PluginError(
+          `Cannot unregister "${name}": plugin "${p.name}" depends on it`,
+          name
+        );
+      }
+    }
+    for (const [event, handlers] of eventHandlers) {
+      const toRemove = [];
+      for (const entry of handlers) {
+        if (entry.pluginName === name) {
+          toRemove.push(entry);
+          handlerToPlugin.delete(entry.handler);
+        }
+      }
+      for (const entry of toRemove) {
+        handlers.delete(entry);
+      }
+      if (handlers.size === 0) {
+        eventHandlers.delete(event);
+      }
+    }
+    try {
+      plugin.onDestroy?.();
+    } catch {
+    }
+    plugins.delete(name);
+    return true;
+  }
+  function on(event, handler) {
+    if (!eventHandlers.has(event)) {
+      eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    const pluginName = getCurrentPluginContext() ?? "unknown";
+    const entry = { handler, pluginName };
+    eventHandlers.get(event).add(entry);
+    handlerToPlugin.set(handler, pluginName);
+  }
+  function off(event, handler) {
+    const handlers = eventHandlers.get(event);
+    if (!handlers) return;
+    for (const entry of handlers) {
+      if (entry.handler === handler) {
+        handlers.delete(entry);
+        handlerToPlugin.delete(handler);
+        break;
+      }
+    }
+    if (handlers.size === 0) {
+      eventHandlers.delete(event);
+    }
+  }
+  async function emit(event, context, ...args) {
+    const handlers = eventHandlers.get(event);
+    if (!handlers || handlers.size === 0) return;
+    for (const entry of handlers) {
+      try {
+        await entry.handler(context, ...args);
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        handlePluginError(err, entry.pluginName);
+      }
+    }
+  }
+  function listPlugins() {
+    return Array.from(plugins.values()).map((p) => ({
+      name: p.name,
+      version: p.version,
+      category: p.category,
+      dependencies: p.dependencies ?? []
+    }));
+  }
+  function getPlugin(name) {
+    return plugins.get(name);
+  }
+  function hasPlugin(name) {
+    return plugins.has(name);
+  }
+  async function destroy() {
+    const pluginNames = Array.from(plugins.keys()).reverse();
+    for (const name of pluginNames) {
+      const plugin = plugins.get(name);
+      if (plugin?.onDestroy) {
+        try {
+          await plugin.onDestroy();
+        } catch {
+        }
+      }
+    }
+    plugins.clear();
+    eventHandlers.clear();
+    handlerToPlugin.clear();
+  }
+  let currentPluginContext = null;
+  function getCurrentPluginContext() {
+    return currentPluginContext;
+  }
+  const originalUse = use;
+  function wrappedUse(plugin) {
+    currentPluginContext = plugin.name;
+    try {
+      originalUse(plugin);
+      return kernel;
+    } finally {
+      currentPluginContext = null;
+    }
+  }
+  const kernel = {
+    use: wrappedUse,
+    unregister,
+    on,
+    off,
+    emit,
+    listPlugins,
+    getPlugin,
+    hasPlugin,
+    destroy
+  };
+  return kernel;
+}
+function definePlugin(definition) {
+  return definition;
+}
+function composePlugins(name, plugins) {
+  return {
+    name,
+    version: "1.0.0",
+    category: "utility",
+    dependencies: plugins.flatMap((p) => p.dependencies ?? []),
+    install(kernel) {
+      for (const plugin of plugins) {
+        kernel.use(plugin);
+      }
+    },
+    async onDestroy() {
+    }
+  };
+}
+
+// src/plugins/optional/changelog-parser.ts
+function parseChangelog(content) {
+  const versions = [];
+  const lines = content.split("\n");
+  let currentVersion = null;
+  let currentType = "other";
+  const versionRegex = /^##\s+\[?(\d+\.\d+\.\d+(?:-[\w.]+)?)\]?(?:\s*[-–(]\s*(\d{4}-\d{2}-\d{2}))?/;
+  const typeMap = {
+    added: "added",
+    changed: "changed",
+    deprecated: "deprecated",
+    removed: "removed",
+    fixed: "fixed",
+    security: "security"
+  };
+  for (const line of lines) {
+    const versionMatch = versionRegex.exec(line);
+    if (versionMatch) {
+      if (currentVersion) {
+        versions.push(currentVersion);
+      }
+      currentVersion = {
+        version: versionMatch[1],
+        date: versionMatch[2],
+        changes: []
+      };
+      currentType = "other";
+      continue;
+    }
+    if (line.startsWith("### ")) {
+      const typeText = line.slice(4).toLowerCase().trim();
+      currentType = typeMap[typeText] || "other";
+      continue;
+    }
+    const itemMatch = /^[-*]\s+(.+)/.exec(line);
+    if (itemMatch && currentVersion) {
+      currentVersion.changes.push({
+        type: currentType,
+        description: itemMatch[1].trim()
+      });
+    }
+  }
+  if (currentVersion) {
+    versions.push(currentVersion);
+  }
+  return { versions };
+}
+function findChangelog(files) {
+  const names = [
+    "CHANGELOG.md",
+    "changelog.md",
+    "CHANGELOG",
+    "changelog",
+    "HISTORY.md",
+    "history.md",
+    "CHANGES.md",
+    "changes.md"
+  ];
+  for (const name of names) {
+    const content = files.get(name) || files.get(`package/${name}`);
+    if (content) {
+      return content;
+    }
+  }
+  return void 0;
+}
+function getLatestVersion(changelog) {
+  return changelog.versions[0];
+}
+function getVersion(changelog, version) {
+  return changelog.versions.find((v) => v.version === version);
+}
+function formatChangelogEntry(entry) {
+  const lines = [];
+  lines.push(`## ${entry.version}${entry.date ? ` (${entry.date})` : ""}`);
+  lines.push("");
+  const grouped = /* @__PURE__ */ new Map();
+  for (const change of entry.changes) {
+    const existing = grouped.get(change.type) || [];
+    existing.push(change.description);
+    grouped.set(change.type, existing);
+  }
+  const typeLabels = {
+    added: "Added",
+    changed: "Changed",
+    deprecated: "Deprecated",
+    removed: "Removed",
+    fixed: "Fixed",
+    security: "Security",
+    other: "Other"
+  };
+  for (const [type, changes] of grouped) {
+    lines.push(`### ${typeLabels[type] || type}`);
+    for (const change of changes) {
+      lines.push(`- ${change}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function createChangelogParserPlugin() {
+  return definePlugin({
+    name: "changelog-parser",
+    version: "1.0.0",
+    category: "parser",
+    install(kernel) {
+      kernel.on("parse:changelog", async (ctx) => {
+        const changelogContent = findChangelog(ctx.package.files);
+        if (changelogContent) {
+          ctx.changelog = parseChangelog(changelogContent);
+        }
+      });
+    }
+  });
+}
+
+// src/plugins/optional/html-output.ts
+var DEFAULT_OPTIONS2 = {
+  includeStyles: true,
+  syntaxHighlighting: true,
+  darkMode: true
+};
+function escapeHTML(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function generateStyles(options) {
+  if (!options.includeStyles) return "";
+  let css = `
+    :root {
+      --bg: #ffffff;
+      --text: #1a1a1a;
+      --code-bg: #f5f5f5;
+      --border: #e5e5e5;
+      --link: #0066cc;
+      --heading: #000000;
+      --param-type: #0550ae;
+      --deprecated: #d93025;
+    }
+    ${options.darkMode ? `
+    @media (prefers-color-scheme: dark) {
+      :root {
+        --bg: #1a1a1a;
+        --text: #e5e5e5;
+        --code-bg: #2d2d2d;
+        --border: #404040;
+        --link: #58a6ff;
+        --heading: #ffffff;
+        --param-type: #79c0ff;
+        --deprecated: #f85149;
+      }
+    }` : ""}
+    * { box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      line-height: 1.6;
+      color: var(--text);
+      background: var(--bg);
+      max-width: 900px;
+      margin: 0 auto;
+      padding: 2rem;
+    }
+    h1, h2, h3, h4 { color: var(--heading); margin-top: 2rem; }
+    h1 { border-bottom: 2px solid var(--border); padding-bottom: 0.5rem; }
+    code {
+      font-family: 'SFMono-Regular', Consolas, monospace;
+      font-size: 0.9em;
+      background: var(--code-bg);
+      padding: 0.2em 0.4em;
+      border-radius: 3px;
+    }
+    pre {
+      background: var(--code-bg);
+      padding: 1rem;
+      overflow-x: auto;
+      border-radius: 6px;
+      border: 1px solid var(--border);
+    }
+    pre code { background: none; padding: 0; }
+    a { color: var(--link); text-decoration: none; }
+    a:hover { text-decoration: underline; }
+    .api-entry {
+      margin: 2rem 0;
+      padding: 1.5rem;
+      border: 1px solid var(--border);
+      border-radius: 8px;
+    }
+    .api-entry h3 { margin-top: 0; }
+    .signature { font-size: 0.95rem; }
+    .param-type { color: var(--param-type); }
+    .deprecated { color: var(--deprecated); font-style: italic; }
+    .params-table {
+      width: 100%;
+      border-collapse: collapse;
+      margin: 1rem 0;
+    }
+    .params-table th, .params-table td {
+      text-align: left;
+      padding: 0.5rem;
+      border-bottom: 1px solid var(--border);
+    }
+    .params-table th { font-weight: 600; }
+    .toc { background: var(--code-bg); padding: 1rem; border-radius: 6px; }
+    .toc ul { margin: 0; padding-left: 1.5rem; }
+    .badge {
+      display: inline-block;
+      padding: 0.2em 0.5em;
+      font-size: 0.75rem;
+      font-weight: 600;
+      border-radius: 4px;
+      margin-left: 0.5rem;
+    }
+    .badge-function { background: #ddf4ff; color: #0550ae; }
+    .badge-class { background: #fff8c5; color: #735c0f; }
+    .badge-interface { background: #dafbe1; color: #116329; }
+    .badge-type { background: #f6e8ff; color: #8250df; }
+    .badge-constant { background: #ffebe9; color: #cf222e; }
+    .badge-enum { background: #fdf4ff; color: #bf3989; }
+  `;
+  if (options.customCSS) {
+    css += options.customCSS;
+  }
+  return `<style>${css}</style>`;
+}
+function kindBadge(kind) {
+  return `<span class="badge badge-${kind}">${kind}</span>`;
+}
+function generateTOC(entries) {
+  if (entries.length === 0) return "";
+  const grouped = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const list = grouped.get(entry.kind) || [];
+    list.push(entry);
+    grouped.set(entry.kind, list);
+  }
+  let html = '<nav class="toc"><h2>Table of Contents</h2>';
+  for (const [kind, items] of grouped) {
+    html += `<h4>${kind.charAt(0).toUpperCase() + kind.slice(1)}s</h4><ul>`;
+    for (const item of items) {
+      const id = `${kind}-${item.name}`.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+      html += `<li><a href="#${id}">${escapeHTML(item.name)}</a></li>`;
+    }
+    html += "</ul>";
+  }
+  html += "</nav>";
+  return html;
+}
+function generateParams(entry) {
+  if (!entry.params || entry.params.length === 0) return "";
+  let html = '<h4>Parameters</h4><table class="params-table"><thead><tr>';
+  html += "<th>Name</th><th>Type</th><th>Description</th></tr></thead><tbody>";
+  for (const param of entry.params) {
+    const name = param.optional ? `${param.name}?` : param.name;
+    const type = param.type ? `<code class="param-type">${escapeHTML(param.type)}</code>` : "-";
+    const desc = param.description ? escapeHTML(param.description) : "-";
+    html += `<tr><td><code>${escapeHTML(name)}</code></td><td>${type}</td><td>${desc}</td></tr>`;
+  }
+  html += "</tbody></table>";
+  return html;
+}
+function generateExamples(examples) {
+  if (examples.length === 0) return "";
+  let html = "<h4>Examples</h4>";
+  for (const example of examples) {
+    html += `<pre><code>${escapeHTML(example)}</code></pre>`;
+  }
+  return html;
+}
+function generateEntry(entry) {
+  const id = `${entry.kind}-${entry.name}`.toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  let html = `<div class="api-entry" id="${id}">`;
+  html += `<h3>${escapeHTML(entry.name)} ${kindBadge(entry.kind)}</h3>`;
+  if (entry.deprecated) {
+    const reason = typeof entry.deprecated === "string" ? entry.deprecated : "";
+    html += `<p class="deprecated">Deprecated${reason ? `: ${escapeHTML(reason)}` : ""}</p>`;
+  }
+  if (entry.description) {
+    html += `<p>${escapeHTML(entry.description)}</p>`;
+  }
+  html += `<pre class="signature"><code>${escapeHTML(entry.signature)}</code></pre>`;
+  html += generateParams(entry);
+  if (entry.returns) {
+    html += "<h4>Returns</h4>";
+    html += `<p><code class="param-type">${escapeHTML(entry.returns.type)}</code>`;
+    if (entry.returns.description) {
+      html += ` - ${escapeHTML(entry.returns.description)}`;
+    }
+    html += "</p>";
+  }
+  if (entry.examples && entry.examples.length > 0) {
+    html += generateExamples(entry.examples);
+  }
+  html += "</div>";
+  return html;
+}
+function generateHeader(name, version, description, readme) {
+  let html = `<header>`;
+  html += `<h1>${escapeHTML(name)} <small>v${escapeHTML(version)}</small></h1>`;
+  if (description) {
+    html += `<p>${escapeHTML(description)}</p>`;
+  }
+  if (readme?.installation) {
+    html += "<h2>Installation</h2>";
+    html += `<pre><code>${escapeHTML(readme.installation)}</code></pre>`;
+  }
+  html += "</header>";
+  return html;
+}
+function generateHTML(ctx, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS2, ...options };
+  const title = opts.title || `${ctx.package.name} API Documentation`;
+  let html = '<!DOCTYPE html>\n<html lang="en">\n<head>\n';
+  html += '<meta charset="UTF-8">\n';
+  html += '<meta name="viewport" content="width=device-width, initial-scale=1.0">\n';
+  html += `<title>${escapeHTML(title)}</title>
+`;
+  html += generateStyles(opts);
+  html += "</head>\n<body>\n";
+  html += generateHeader(ctx.package.name, ctx.package.version, ctx.package.description, ctx.readme);
+  html += generateTOC(ctx.api);
+  html += "<main>";
+  const grouped = /* @__PURE__ */ new Map();
+  for (const entry of ctx.api) {
+    const list = grouped.get(entry.kind) || [];
+    list.push(entry);
+    grouped.set(entry.kind, list);
+  }
+  const kindOrder = ["function", "class", "interface", "type", "constant", "enum"];
+  for (const kind of kindOrder) {
+    const entries = grouped.get(kind);
+    if (!entries || entries.length === 0) continue;
+    html += `<section><h2>${kind.charAt(0).toUpperCase() + kind.slice(1)}s</h2>`;
+    for (const entry of entries) {
+      html += generateEntry(entry);
+    }
+    html += "</section>";
+  }
+  html += "</main>\n";
+  html += '<footer><p>Generated by <a href="https://github.com/oxog/npm-llms">@oxog/npm-llms</a></p></footer>\n';
+  html += "</body>\n</html>";
+  return html;
+}
+function createHTMLOutputPlugin(options = {}) {
+  return definePlugin({
+    name: "html-output",
+    version: "1.0.0",
+    category: "output",
+    install(kernel) {
+      kernel.on("output:generate", async (ctx) => {
+        if (!ctx.options.formats?.includes("html")) return;
+        const html = generateHTML(ctx, options);
+        ctx.outputs.set("html", html);
+      });
+    }
+  });
+}
+
+exports.checkGeminiAvailable = checkGeminiAvailable;
+exports.checkOllamaAvailable = checkOllamaAvailable;
+exports.composePlugins = composePlugins;
+exports.coreOutputPlugins = coreOutputPlugins;
+exports.coreParserPlugins = coreParserPlugins;
+exports.corePlugins = corePlugins;
+exports.createAIEnrichmentPlugin = createAIEnrichmentPlugin;
+exports.createChangelogParserPlugin = createChangelogParserPlugin;
+exports.createClaudePlugin = createClaudePlugin;
+exports.createClaudeProvider = createClaudeProvider;
+exports.createGeminiPlugin = createGeminiPlugin;
+exports.createGeminiProvider = createGeminiProvider;
+exports.createGroqPlugin = createGroqPlugin;
+exports.createGroqProvider = createGroqProvider;
+exports.createHTMLOutputPlugin = createHTMLOutputPlugin;
+exports.createKernel = createKernel;
+exports.createOllamaPlugin = createOllamaPlugin;
+exports.createOllamaProvider = createOllamaProvider;
+exports.createOpenAIPlugin = createOpenAIPlugin;
+exports.createOpenAIProvider = createOpenAIProvider;
+exports.createSimpleProvider = createSimpleProvider;
+exports.definePlugin = definePlugin;
+exports.dtsParserPlugin = dtsParserPlugin;
+exports.findChangelog = findChangelog;
+exports.formatChangelogEntry = formatChangelogEntry;
+exports.generateHTML = generateHTML;
+exports.getLatestVersion = getLatestVersion;
+exports.getVersion = getVersion;
+exports.jsonOutputPlugin = jsonOutputPlugin;
+exports.listOllamaModels = listOllamaModels;
+exports.llmsFullOutputPlugin = llmsFullOutputPlugin;
+exports.llmsOutputPlugin = llmsOutputPlugin;
+exports.markdownOutputPlugin = markdownOutputPlugin;
+exports.parseChangelog = parseChangelog;
+exports.readmeParserPlugin = readmeParserPlugin;
+exports.tsSourceParserPlugin = tsSourceParserPlugin;
+exports.typesResolverPlugin = typesResolverPlugin;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map