@frontmcp/uipack 0.6.1

package/typings/index.js

@@ -0,0 +1,868 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/uipack/src/typings/index.ts
+var typings_exports = {};
+__export(typings_exports, {
+  DEFAULT_CACHE_OPTIONS: () => DEFAULT_CACHE_OPTIONS,
+  DEFAULT_TYPE_CACHE_TTL: () => DEFAULT_TYPE_CACHE_TTL,
+  DEFAULT_TYPE_FETCHER_OPTIONS: () => DEFAULT_TYPE_FETCHER_OPTIONS,
+  MemoryTypeCache: () => MemoryTypeCache,
+  TYPE_CACHE_PREFIX: () => TYPE_CACHE_PREFIX,
+  TypeFetcher: () => TypeFetcher,
+  combineDtsContents: () => combineDtsContents,
+  createTypeFetcher: () => createTypeFetcher,
+  dtsImportSchema: () => dtsImportSchema,
+  dtsImportTypeSchema: () => dtsImportTypeSchema,
+  dtsParseResultSchema: () => dtsParseResultSchema,
+  getPackageFromSpecifier: () => getPackageFromSpecifier,
+  getSubpathFromSpecifier: () => getSubpathFromSpecifier,
+  globalTypeCache: () => globalTypeCache,
+  isRelativeImport: () => isRelativeImport,
+  packageResolutionSchema: () => packageResolutionSchema,
+  parseDtsImports: () => parseDtsImports,
+  parseImportStatement: () => parseImportStatement,
+  safeParseBatchRequest: () => safeParseBatchRequest,
+  safeParseTypeFetcherOptions: () => safeParseTypeFetcherOptions,
+  typeCacheEntrySchema: () => typeCacheEntrySchema,
+  typeCacheStatsSchema: () => typeCacheStatsSchema,
+  typeFetchBatchRequestSchema: () => typeFetchBatchRequestSchema,
+  typeFetchBatchResultSchema: () => typeFetchBatchResultSchema,
+  typeFetchErrorCodeSchema: () => typeFetchErrorCodeSchema,
+  typeFetchErrorSchema: () => typeFetchErrorSchema,
+  typeFetchResultSchema: () => typeFetchResultSchema,
+  typeFetcherOptionsSchema: () => typeFetcherOptionsSchema,
+  validateBatchRequest: () => validateBatchRequest,
+  validateTypeFetcherOptions: () => validateTypeFetcherOptions
+});
+module.exports = __toCommonJS(typings_exports);
+
+// libs/uipack/src/typings/types.ts
+var DEFAULT_TYPE_FETCHER_OPTIONS = {
+  maxDepth: 2,
+  timeout: 1e4,
+  maxConcurrency: 5,
+  cdnBaseUrl: "https://esm.sh"
+};
+var TYPE_CACHE_PREFIX = "types:";
+var DEFAULT_TYPE_CACHE_TTL = 60 * 60 * 1e3;
+
+// libs/uipack/src/typings/schemas.ts
+var import_zod = require("zod");
+var typeFetchErrorCodeSchema = import_zod.z.enum([
+  "NETWORK_ERROR",
+  "TIMEOUT",
+  "NO_TYPES_HEADER",
+  "INVALID_SPECIFIER",
+  "PACKAGE_NOT_FOUND",
+  "PARSE_ERROR"
+]);
+var typeFetchResultSchema = import_zod.z.object({
+  specifier: import_zod.z.string().min(1),
+  resolvedPackage: import_zod.z.string().min(1),
+  version: import_zod.z.string().min(1),
+  content: import_zod.z.string(),
+  fetchedUrls: import_zod.z.array(import_zod.z.string().url()),
+  fetchedAt: import_zod.z.string().datetime()
+}).strict();
+var typeFetchErrorSchema = import_zod.z.object({
+  specifier: import_zod.z.string().min(1),
+  code: typeFetchErrorCodeSchema,
+  message: import_zod.z.string().min(1),
+  url: import_zod.z.string().url().optional()
+}).strict();
+var typeFetchBatchRequestSchema = import_zod.z.object({
+  imports: import_zod.z.array(import_zod.z.string().min(1)).min(1),
+  maxDepth: import_zod.z.number().int().min(0).max(10).optional(),
+  timeout: import_zod.z.number().int().min(1e3).max(6e4).optional(),
+  maxConcurrency: import_zod.z.number().int().min(1).max(20).optional(),
+  skipCache: import_zod.z.boolean().optional(),
+  versionOverrides: import_zod.z.record(import_zod.z.string().min(1), import_zod.z.string().min(1)).optional()
+}).strict();
+var typeFetchBatchResultSchema = import_zod.z.object({
+  results: import_zod.z.array(typeFetchResultSchema),
+  errors: import_zod.z.array(typeFetchErrorSchema),
+  totalTimeMs: import_zod.z.number().nonnegative(),
+  cacheHits: import_zod.z.number().int().nonnegative(),
+  networkRequests: import_zod.z.number().int().nonnegative()
+}).strict();
+var typeCacheEntrySchema = import_zod.z.object({
+  result: typeFetchResultSchema,
+  cachedAt: import_zod.z.number().int().positive(),
+  size: import_zod.z.number().int().nonnegative(),
+  accessCount: import_zod.z.number().int().nonnegative()
+}).strict();
+var typeCacheStatsSchema = import_zod.z.object({
+  entries: import_zod.z.number().int().nonnegative(),
+  totalSize: import_zod.z.number().nonnegative(),
+  hits: import_zod.z.number().int().nonnegative(),
+  misses: import_zod.z.number().int().nonnegative(),
+  hitRate: import_zod.z.number().min(0).max(1)
+}).strict();
+var dtsImportTypeSchema = import_zod.z.enum(["import", "export", "reference", "declare-module"]);
+var dtsImportSchema = import_zod.z.object({
+  type: dtsImportTypeSchema,
+  specifier: import_zod.z.string().min(1),
+  statement: import_zod.z.string(),
+  line: import_zod.z.number().int().positive()
+}).strict();
+var dtsParseResultSchema = import_zod.z.object({
+  imports: import_zod.z.array(dtsImportSchema),
+  externalPackages: import_zod.z.array(import_zod.z.string().min(1)),
+  relativeImports: import_zod.z.array(import_zod.z.string())
+}).strict();
+var typeFetcherOptionsSchema = import_zod.z.object({
+  maxDepth: import_zod.z.number().int().min(0).max(10).optional(),
+  timeout: import_zod.z.number().int().min(1e3).max(6e4).optional(),
+  maxConcurrency: import_zod.z.number().int().min(1).max(20).optional(),
+  cdnBaseUrl: import_zod.z.string().url().optional()
+}).strict();
+var packageResolutionSchema = import_zod.z.object({
+  packageName: import_zod.z.string().min(1),
+  subpath: import_zod.z.string().optional(),
+  version: import_zod.z.string().min(1),
+  typesUrl: import_zod.z.string().url()
+}).strict();
+function validateBatchRequest(data) {
+  return typeFetchBatchRequestSchema.parse(data);
+}
+function safeParseBatchRequest(data) {
+  return typeFetchBatchRequestSchema.safeParse(data);
+}
+function validateTypeFetcherOptions(data) {
+  return typeFetcherOptionsSchema.parse(data);
+}
+function safeParseTypeFetcherOptions(data) {
+  return typeFetcherOptionsSchema.safeParse(data);
+}
+
+// libs/uipack/src/typings/cache/cache-adapter.ts
+var DEFAULT_CACHE_OPTIONS = {
+  maxSize: 500,
+  defaultTtl: 60 * 60 * 1e3,
+  // 1 hour
+  trackStats: true
+};
+
+// libs/uipack/src/typings/cache/memory-cache.ts
+var MemoryTypeCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  defaultTtl;
+  trackStats;
+  /** Cache statistics */
+  stats = {
+    hits: 0,
+    misses: 0,
+    evictions: 0
+  };
+  constructor(options = {}) {
+    const opts = { ...DEFAULT_CACHE_OPTIONS, ...options };
+    this.maxSize = opts.maxSize;
+    this.defaultTtl = opts.defaultTtl;
+    this.trackStats = opts.trackStats;
+  }
+  /**
+   * Get a cached entry by key.
+   */
+  async get(key) {
+    const internal = this.cache.get(key);
+    if (!internal) {
+      if (this.trackStats) this.stats.misses++;
+      return void 0;
+    }
+    if (internal.expiresAt > 0 && Date.now() > internal.expiresAt) {
+      this.cache.delete(key);
+      if (this.trackStats) this.stats.misses++;
+      return void 0;
+    }
+    this.cache.delete(key);
+    internal.entry.accessCount++;
+    this.cache.set(key, internal);
+    if (this.trackStats) this.stats.hits++;
+    return internal.entry;
+  }
+  /**
+   * Store an entry in the cache.
+   */
+  async set(key, entry, ttl) {
+    if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey) {
+        this.cache.delete(oldestKey);
+        if (this.trackStats) this.stats.evictions++;
+      }
+    }
+    const effectiveTtl = ttl ?? this.defaultTtl;
+    const expiresAt = effectiveTtl > 0 ? Date.now() + effectiveTtl : 0;
+    this.cache.set(key, { entry, expiresAt });
+  }
+  /**
+   * Check if a key exists in the cache.
+   */
+  async has(key) {
+    const internal = this.cache.get(key);
+    if (!internal) return false;
+    if (internal.expiresAt > 0 && Date.now() > internal.expiresAt) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Delete a cached entry.
+   */
+  async delete(key) {
+    return this.cache.delete(key);
+  }
+  /**
+   * Clear all cached entries.
+   */
+  async clear() {
+    this.cache.clear();
+    this.stats = { hits: 0, misses: 0, evictions: 0 };
+  }
+  /**
+   * Get cache statistics.
+   */
+  async getStats() {
+    let totalSize = 0;
+    for (const { entry } of this.cache.values()) {
+      totalSize += entry.size;
+    }
+    const total = this.stats.hits + this.stats.misses;
+    return {
+      entries: this.cache.size,
+      totalSize,
+      hits: this.stats.hits,
+      misses: this.stats.misses,
+      hitRate: total > 0 ? this.stats.hits / total : 0
+    };
+  }
+  /**
+   * Get current cache size.
+   */
+  get size() {
+    return this.cache.size;
+  }
+  /**
+   * Get number of evictions.
+   */
+  get evictions() {
+    return this.stats.evictions;
+  }
+  /**
+   * Clean up expired entries.
+   * Call periodically to free memory from expired entries.
+   *
+   * @returns Number of entries cleaned up
+   */
+  cleanup() {
+    const now = Date.now();
+    let cleaned = 0;
+    for (const [key, internal] of this.cache.entries()) {
+      if (internal.expiresAt > 0 && now > internal.expiresAt) {
+        this.cache.delete(key);
+        cleaned++;
+      }
+    }
+    return cleaned;
+  }
+};
+var globalTypeCache = new MemoryTypeCache({
+  maxSize: 500,
+  defaultTtl: 60 * 60 * 1e3
+  // 1 hour
+});
+
+// libs/uipack/src/typings/dts-parser.ts
+var IMPORT_PATTERN = /^import\s+(?:type\s+)?(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+)?['"]([^'"]+)['"]/gm;
+var EXPORT_FROM_PATTERN = /^export\s+(?:\{[^}]*\}|\*)\s+from\s+['"]([^'"]+)['"]/gm;
+var REFERENCE_TYPES_PATTERN = /^\/\/\/\s*<reference\s+types\s*=\s*['"]([^'"]+)['"]\s*\/>/gm;
+var REFERENCE_PATH_PATTERN = /^\/\/\/\s*<reference\s+path\s*=\s*['"]([^'"]+)['"]\s*\/>/gm;
+var DECLARE_MODULE_PATTERN = /^declare\s+module\s+['"]([^'"]+)['"]/gm;
+function parseDtsImports(content) {
+  const imports = [];
+  const externalPackages = /* @__PURE__ */ new Set();
+  const relativeImports = /* @__PURE__ */ new Set();
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    IMPORT_PATTERN.lastIndex = 0;
+    let match = IMPORT_PATTERN.exec(line);
+    if (match) {
+      const specifier = match[1];
+      imports.push({
+        type: "import",
+        specifier,
+        statement: line.trim(),
+        line: lineNum
+      });
+      categorizeSpecifier(specifier, externalPackages, relativeImports);
+    }
+    EXPORT_FROM_PATTERN.lastIndex = 0;
+    match = EXPORT_FROM_PATTERN.exec(line);
+    if (match) {
+      const specifier = match[1];
+      imports.push({
+        type: "export",
+        specifier,
+        statement: line.trim(),
+        line: lineNum
+      });
+      categorizeSpecifier(specifier, externalPackages, relativeImports);
+    }
+    REFERENCE_TYPES_PATTERN.lastIndex = 0;
+    match = REFERENCE_TYPES_PATTERN.exec(line);
+    if (match) {
+      const specifier = match[1];
+      imports.push({
+        type: "reference",
+        specifier,
+        statement: line.trim(),
+        line: lineNum
+      });
+      externalPackages.add(getPackageFromSpecifier(specifier));
+    }
+    REFERENCE_PATH_PATTERN.lastIndex = 0;
+    match = REFERENCE_PATH_PATTERN.exec(line);
+    if (match) {
+      const specifier = match[1];
+      imports.push({
+        type: "reference",
+        specifier,
+        statement: line.trim(),
+        line: lineNum
+      });
+      relativeImports.add(specifier);
+    }
+    DECLARE_MODULE_PATTERN.lastIndex = 0;
+    match = DECLARE_MODULE_PATTERN.exec(line);
+    if (match) {
+      const specifier = match[1];
+      imports.push({
+        type: "declare-module",
+        specifier,
+        statement: line.trim(),
+        line: lineNum
+      });
+    }
+  }
+  return {
+    imports,
+    externalPackages: Array.from(externalPackages),
+    relativeImports: Array.from(relativeImports)
+  };
+}
+function categorizeSpecifier(specifier, externalPackages, relativeImports) {
+  if (isRelativeImport(specifier)) {
+    relativeImports.add(specifier);
+  } else {
+    externalPackages.add(getPackageFromSpecifier(specifier));
+  }
+}
+function isRelativeImport(specifier) {
+  return specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/") || // Check for Windows-style paths
+  /^[A-Za-z]:/.test(specifier);
+}
+function getPackageFromSpecifier(specifier) {
+  if (specifier.startsWith("@")) {
+    const parts = specifier.split("/");
+    if (parts.length >= 2) {
+      return `${parts[0]}/${parts[1]}`;
+    }
+    return specifier;
+  }
+  const slashIndex = specifier.indexOf("/");
+  if (slashIndex > 0) {
+    return specifier.substring(0, slashIndex);
+  }
+  return specifier;
+}
+function getSubpathFromSpecifier(specifier) {
+  const packageName = getPackageFromSpecifier(specifier);
+  if (specifier.length > packageName.length + 1) {
+    return specifier.substring(packageName.length + 1);
+  }
+  return void 0;
+}
+function parseImportStatement(statement) {
+  const namedMatch = /import\s+(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+['"]([^'"]+)['"]/.exec(statement);
+  if (namedMatch) {
+    return namedMatch[1];
+  }
+  const sideEffectMatch = /import\s+['"]([^'"]+)['"]/.exec(statement);
+  if (sideEffectMatch) {
+    return sideEffectMatch[1];
+  }
+  return null;
+}
+function combineDtsContents(contents) {
+  const seenReferences = /* @__PURE__ */ new Set();
+  const references = [];
+  const declarations = [];
+  for (const [url, content] of contents.entries()) {
+    const lines = content.split("\n");
+    let inReferences = true;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("///")) {
+        if (!seenReferences.has(trimmed)) {
+          seenReferences.add(trimmed);
+          references.push(trimmed);
+        }
+        continue;
+      }
+      if (inReferences && trimmed === "") {
+        continue;
+      }
+      inReferences = false;
+      if (declarations.length === 0 || declarations[declarations.length - 1] !== "") {
+        if (trimmed !== "") {
+          if (!declarations.some((d) => d.includes(`// Source: ${url}`))) {
+            declarations.push(`
+// Source: ${url}`);
+          }
+        }
+      }
+      declarations.push(line);
+    }
+  }
+  const parts = [];
+  if (references.length > 0) {
+    parts.push(references.join("\n"));
+    parts.push("");
+  }
+  parts.push(declarations.join("\n").trim());
+  return parts.join("\n");
+}
+
+// libs/uipack/src/typings/type-fetcher.ts
+var Semaphore = class {
+  permits;
+  waiting = [];
+  constructor(permits) {
+    this.permits = permits;
+  }
+  async acquire() {
+    if (this.permits > 0) {
+      this.permits--;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.waiting.push(resolve);
+    });
+  }
+  release() {
+    if (this.waiting.length > 0) {
+      const next = this.waiting.shift();
+      next?.();
+    } else {
+      this.permits++;
+    }
+  }
+};
+var TypeFetcher = class {
+  maxDepth;
+  timeout;
+  maxConcurrency;
+  cdnBaseUrl;
+  fetchFn;
+  cache;
+  constructor(options = {}, cache) {
+    this.maxDepth = options.maxDepth ?? 2;
+    this.timeout = options.timeout ?? 1e4;
+    this.maxConcurrency = options.maxConcurrency ?? 5;
+    this.cdnBaseUrl = options.cdnBaseUrl ?? "https://esm.sh";
+    this.fetchFn = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.cache = cache ?? globalTypeCache;
+  }
+  /**
+   * Fetch types for a batch of import statements.
+   *
+   * @param request - Batch request configuration
+   * @returns Batch result with results and errors
+   */
+  async fetchBatch(request) {
+    const startTime = Date.now();
+    const results = [];
+    const errors = [];
+    let cacheHits = 0;
+    let networkRequests = 0;
+    const maxDepth = request.maxDepth ?? this.maxDepth;
+    const timeout = request.timeout ?? this.timeout;
+    const maxConcurrency = request.maxConcurrency ?? this.maxConcurrency;
+    const skipCache = request.skipCache ?? false;
+    const versionOverrides = request.versionOverrides ?? {};
+    const semaphore = new Semaphore(maxConcurrency);
+    const promises = request.imports.map(async (importStatement) => {
+      await semaphore.acquire();
+      try {
+        const specifier = parseImportStatement(importStatement);
+        if (!specifier) {
+          errors.push({
+            specifier: importStatement,
+            code: "INVALID_SPECIFIER",
+            message: `Could not parse import statement: ${importStatement}`
+          });
+          return;
+        }
+        const packageName = getPackageFromSpecifier(specifier);
+        const version = versionOverrides[packageName] ?? "latest";
+        const cacheKey = `${TYPE_CACHE_PREFIX}${packageName}@${version}`;
+        if (!skipCache) {
+          const cached = await this.cache.get(cacheKey);
+          if (cached) {
+            cacheHits++;
+            results.push(cached.result);
+            return;
+          }
+        }
+        const result = await this.fetchTypesForSpecifier(specifier, {
+          maxDepth,
+          timeout,
+          version
+        });
+        if (result.success) {
+          results.push(result.data);
+          networkRequests += result.fetchCount;
+          const entry = {
+            result: result.data,
+            cachedAt: Date.now(),
+            size: result.data.content.length,
+            accessCount: 1
+          };
+          await this.cache.set(cacheKey, entry);
+        } else {
+          errors.push(result.error);
+          networkRequests += result.fetchCount;
+        }
+      } finally {
+        semaphore.release();
+      }
+    });
+    await Promise.all(promises);
+    return {
+      results,
+      errors,
+      totalTimeMs: Date.now() - startTime,
+      cacheHits,
+      networkRequests
+    };
+  }
+  /**
+   * Fetch types for a single import specifier.
+   */
+  async fetchTypesForSpecifier(specifier, options) {
+    let fetchCount = 0;
+    const fetchedUrls = [];
+    const visitedUrls = /* @__PURE__ */ new Set();
+    const contents = /* @__PURE__ */ new Map();
+    try {
+      const resolution = await this.resolvePackage(specifier, options.version, options.timeout);
+      if (!resolution) {
+        return {
+          success: false,
+          error: {
+            specifier,
+            code: "PACKAGE_NOT_FOUND",
+            message: `Could not resolve package: ${specifier}`
+          },
+          fetchCount
+        };
+      }
+      fetchCount++;
+      const fetchResult = await this.fetchRecursive(
+        resolution.typesUrl,
+        options.maxDepth,
+        options.timeout,
+        visitedUrls,
+        contents
+      );
+      fetchCount += fetchResult.fetchCount;
+      fetchedUrls.push(...fetchResult.fetchedUrls);
+      if (!fetchResult.success) {
+        return {
+          success: false,
+          error: {
+            specifier,
+            code: fetchResult.errorCode,
+            message: fetchResult.errorMessage ?? "Unknown error",
+            url: fetchResult.errorUrl
+          },
+          fetchCount
+        };
+      }
+      const combinedContent = combineDtsContents(contents);
+      const result = {
+        specifier,
+        resolvedPackage: resolution.packageName,
+        version: resolution.version,
+        content: combinedContent,
+        fetchedUrls,
+        fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      return { success: true, data: result, fetchCount };
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          specifier,
+          code: "NETWORK_ERROR",
+          message: error instanceof Error ? error.message : String(error)
+        },
+        fetchCount
+      };
+    }
+  }
+  /**
+   * Resolve a package specifier to a types URL.
+   * Uses path fallback: try full path, then remove last segment until found.
+   */
+  async resolvePackage(specifier, version, timeout) {
+    const packageName = getPackageFromSpecifier(specifier);
+    const subpath = getSubpathFromSpecifier(specifier);
+    const versionSuffix = version === "latest" ? "" : `@${version}`;
+    const baseUrl = `${this.cdnBaseUrl}/${packageName}${versionSuffix}`;
+    const urlsToTry = subpath ? [`${baseUrl}/${subpath}`, baseUrl] : [baseUrl];
+    for (const url of urlsToTry) {
+      try {
+        const response = await this.fetchWithTimeout(url, timeout, "HEAD");
+        if (response.ok) {
+          const typesHeader = response.headers.get("X-TypeScript-Types");
+          if (typesHeader) {
+            const typesUrl = typesHeader.startsWith("/") ? `${this.cdnBaseUrl}${typesHeader}` : typesHeader;
+            const versionMatch = /@(\d+\.\d+\.\d+[^/]*)/.exec(typesUrl);
+            const resolvedVersion = versionMatch ? versionMatch[1] : version;
+            return {
+              packageName,
+              subpath,
+              version: resolvedVersion,
+              typesUrl
+            };
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+  /**
+   * Recursively fetch .d.ts files.
+   */
+  async fetchRecursive(url, depth, timeout, visited, contents) {
+    if (visited.has(url)) {
+      return { success: true, fetchCount: 0, fetchedUrls: [] };
+    }
+    visited.add(url);
+    let fetchCount = 1;
+    const fetchedUrls = [url];
+    try {
+      const response = await this.fetchWithTimeout(url, timeout, "GET");
+      if (!response.ok) {
+        return {
+          success: false,
+          fetchCount,
+          fetchedUrls,
+          errorCode: "NETWORK_ERROR",
+          errorMessage: `HTTP ${response.status}: ${response.statusText}`,
+          errorUrl: url
+        };
+      }
+      const content = await response.text();
+      contents.set(url, content);
+      if (depth <= 0) {
+        return { success: true, fetchCount, fetchedUrls };
+      }
+      const parsed = parseDtsImports(content);
+      for (const pkg of parsed.externalPackages) {
+        if (pkg.startsWith("@types/") || isBuiltinModule(pkg)) {
+          continue;
+        }
+        const resolution = await this.resolvePackage(pkg, "latest", timeout);
+        fetchCount++;
+        if (resolution && !visited.has(resolution.typesUrl)) {
+          const result = await this.fetchRecursive(resolution.typesUrl, depth - 1, timeout, visited, contents);
+          fetchCount += result.fetchCount;
+          fetchedUrls.push(...result.fetchedUrls);
+        }
+      }
+      for (const relativePath of parsed.relativeImports) {
+        const resolvedUrl = resolveRelativeUrl(url, relativePath);
+        if (resolvedUrl && !visited.has(resolvedUrl)) {
+          const result = await this.fetchRecursive(resolvedUrl, depth - 1, timeout, visited, contents);
+          fetchCount += result.fetchCount;
+          fetchedUrls.push(...result.fetchedUrls);
+        }
+      }
+      return { success: true, fetchCount, fetchedUrls };
+    } catch (error) {
+      const isTimeout = error instanceof Error && error.message.includes("timeout");
+      return {
+        success: false,
+        fetchCount,
+        fetchedUrls,
+        errorCode: isTimeout ? "TIMEOUT" : "NETWORK_ERROR",
+        errorMessage: error instanceof Error ? error.message : String(error),
+        errorUrl: url
+      };
+    }
+  }
+  /**
+   * Fetch with timeout support.
+   */
+  async fetchWithTimeout(url, timeout, method) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await this.fetchFn(url, {
+        method,
+        signal: controller.signal,
+        headers: {
+          Accept: "application/typescript, text/plain, */*"
+        }
+      });
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+function isBuiltinModule(name) {
+  const builtins = /* @__PURE__ */ new Set([
+    "assert",
+    "buffer",
+    "child_process",
+    "cluster",
+    "console",
+    "constants",
+    "crypto",
+    "dgram",
+    "dns",
+    "domain",
+    "events",
+    "fs",
+    "http",
+    "https",
+    "module",
+    "net",
+    "os",
+    "path",
+    "punycode",
+    "querystring",
+    "readline",
+    "repl",
+    "stream",
+    "string_decoder",
+    "sys",
+    "timers",
+    "tls",
+    "tty",
+    "url",
+    "util",
+    "v8",
+    "vm",
+    "zlib",
+    // Node.js prefixed modules
+    "node:assert",
+    "node:buffer",
+    "node:child_process",
+    "node:cluster",
+    "node:console",
+    "node:constants",
+    "node:crypto",
+    "node:dgram",
+    "node:dns",
+    "node:domain",
+    "node:events",
+    "node:fs",
+    "node:http",
+    "node:https",
+    "node:module",
+    "node:net",
+    "node:os",
+    "node:path",
+    "node:punycode",
+    "node:querystring",
+    "node:readline",
+    "node:repl",
+    "node:stream",
+    "node:string_decoder",
+    "node:sys",
+    "node:timers",
+    "node:tls",
+    "node:tty",
+    "node:url",
+    "node:util",
+    "node:v8",
+    "node:vm",
+    "node:zlib"
+  ]);
+  return builtins.has(name);
+}
+function resolveRelativeUrl(base, relative) {
+  try {
+    let path = relative;
+    if (!path.endsWith(".d.ts") && !path.endsWith(".ts")) {
+      path = `${path}.d.ts`;
+    }
+    const resolved = new URL(path, base);
+    return resolved.toString();
+  } catch {
+    return null;
+  }
+}
+function createTypeFetcher(options, cache) {
+  return new TypeFetcher(options, cache);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_CACHE_OPTIONS,
+  DEFAULT_TYPE_CACHE_TTL,
+  DEFAULT_TYPE_FETCHER_OPTIONS,
+  MemoryTypeCache,
+  TYPE_CACHE_PREFIX,
+  TypeFetcher,
+  combineDtsContents,
+  createTypeFetcher,
+  dtsImportSchema,
+  dtsImportTypeSchema,
+  dtsParseResultSchema,
+  getPackageFromSpecifier,
+  getSubpathFromSpecifier,
+  globalTypeCache,
+  isRelativeImport,
+  packageResolutionSchema,
+  parseDtsImports,
+  parseImportStatement,
+  safeParseBatchRequest,
+  safeParseTypeFetcherOptions,
+  typeCacheEntrySchema,
+  typeCacheStatsSchema,
+  typeFetchBatchRequestSchema,
+  typeFetchBatchResultSchema,
+  typeFetchErrorCodeSchema,
+  typeFetchErrorSchema,
+  typeFetchResultSchema,
+  typeFetcherOptionsSchema,
+  validateBatchRequest,
+  validateTypeFetcherOptions
+});