@doccov/cli 0.28.2 → 0.29.0

package/dist/cli.js

@@ -74,8 +74,8 @@ ${formatIssues(issues)}`);
 // src/config/index.ts
 var defineConfig = (config) => config;
 // src/cli.ts
-import { readFileSync as readFileSync5 } from "node:fs";
-import * as path10 from "node:path";
+import { readFileSync as readFileSync7 } from "node:fs";
+import * as path12 from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
 
@@ -1650,6 +1650,1897 @@ function displayApiSurfaceOutput(doccov, deps) {
 
 // src/commands/check/validation.ts
 import { validateExamples } from "@doccov/sdk";
+
+// src/commands/check/docs-fetcher.ts
+import * as cheerio from "cheerio";
+
+// src/commands/check/docsCache.ts
+import * as crypto from "node:crypto";
+import * as fs4 from "node:fs";
+import * as path6 from "node:path";
+var DEFAULT_TTL = 60 * 60 * 1000;
+function getCacheDir(cwd) {
+  return path6.join(cwd, ".doccov", "cache");
+}
+function getCacheSubdir(cwd, type) {
+  return path6.join(getCacheDir(cwd), type);
+}
+function ensureCacheDir(cwd) {
+  const subdirs = ["urls", "github", "gitlab"];
+  for (const subdir of subdirs) {
+    const dir = getCacheSubdir(cwd, subdir);
+    if (!fs4.existsSync(dir)) {
+      fs4.mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+function getCacheFilename(key) {
+  const hash = crypto.createHash("sha256").update(key).digest("hex").slice(0, 16);
+  const sanitized = key.replace(/[^a-zA-Z0-9-_]/g, "_").slice(0, 50);
+  return `${sanitized}_${hash}.json`;
+}
+function getFromCache(cwd, type, key, ttl = DEFAULT_TTL) {
+  const cacheFile = path6.join(getCacheSubdir(cwd, type), getCacheFilename(key));
+  if (!fs4.existsSync(cacheFile)) {
+    return null;
+  }
+  try {
+    const data = JSON.parse(fs4.readFileSync(cacheFile, "utf-8"));
+    if (Date.now() - data.fetchedAt > ttl) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function writeToCache(cwd, type, key, content) {
+  ensureCacheDir(cwd);
+  const cacheFile = path6.join(getCacheSubdir(cwd, type), getCacheFilename(key));
+  const entry = {
+    content,
+    fetchedAt: Date.now(),
+    source: key
+  };
+  fs4.writeFileSync(cacheFile, JSON.stringify(entry, null, 2));
+}
+
+// src/commands/check/docs-fetcher.ts
+var DEFAULT_TIMEOUT = 1e4;
+var DEFAULT_TTL2 = 60 * 60 * 1000;
+async function fetchUrlDocs(source, options = {}) {
+  const { timeout = DEFAULT_TIMEOUT, ttl = DEFAULT_TTL2, useCache = true, cwd = process.cwd() } = options;
+  if (useCache) {
+    const cached = getFromCache(cwd, "urls", source.url, ttl);
+    if (cached) {
+      const doc = parseContentToDoc(cached.content, source.url);
+      return { source, doc, cached: true };
+    }
+  }
+  try {
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const response = await fetch(source.url, {
+      signal: controller.signal,
+      headers: {
+        "User-Agent": "doccov-cli",
+        Accept: "text/html, text/markdown, text/plain, */*"
+      },
+      redirect: "follow"
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      return {
+        source,
+        doc: null,
+        error: `HTTP ${response.status}: ${response.statusText}`
+      };
+    }
+    const content = await response.text();
+    const contentType = response.headers.get("content-type") ?? "";
+    if (useCache) {
+      writeToCache(cwd, "urls", source.url, content);
+    }
+    const doc = parseContentToDoc(content, source.url, contentType);
+    return { source, doc };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("abort")) {
+      return { source, doc: null, error: `Timeout after ${timeout}ms` };
+    }
+    return { source, doc: null, error: message };
+  }
+}
+async function fetchUrlDocsBatch(sources, options = {}) {
+  return Promise.all(sources.map((s) => fetchUrlDocs(s, options)));
+}
+function parseContentToDoc(content, url, contentType) {
+  const isMarkdown = contentType?.includes("markdown") || url.endsWith(".md") || url.endsWith(".mdx");
+  if (isMarkdown) {
+    return parseMarkdownContent(content, url);
+  }
+  return parseHtmlContent(content, url);
+}
+function parseMarkdownContent(content, url) {
+  const codeBlocks = extractMarkdownCodeBlocks(content);
+  return { path: url, codeBlocks };
+}
+function parseHtmlContent(content, url) {
+  const $ = cheerio.load(content);
+  const codeBlocks = [];
+  const selectors = [
+    "pre code",
+    "pre.highlight code",
+    "pre.prism-code",
+    ".theme-code-block pre",
+    "pre.nextra-code",
+    "[data-language] code",
+    "pre.shiki code",
+    ".code-block pre",
+    ".codeblock pre"
+  ];
+  const seen = new Set;
+  for (const selector of selectors) {
+    $(selector).each((_, el) => {
+      const $el = $(el);
+      const code = $el.text().trim();
+      if (!code || seen.has(code))
+        return;
+      seen.add(code);
+      const lang = detectLanguage($el, $);
+      if (!isExecutableLang(lang))
+        return;
+      codeBlocks.push({
+        lang: lang || "ts",
+        code,
+        lineStart: 0,
+        lineEnd: 0
+      });
+    });
+  }
+  return { path: url, codeBlocks };
+}
+function detectLanguage($el, $) {
+  const classes = [
+    $el.attr("class") ?? "",
+    $el.parent().attr("class") ?? "",
+    $el.attr("data-language") ?? "",
+    $el.parent().attr("data-language") ?? ""
+  ].join(" ");
+  const langMatch = classes.match(/(?:language|lang|prism)-(\w+)/i);
+  if (langMatch) {
+    return normalizeLanguage(langMatch[1]);
+  }
+  const dataLang = $el.attr("data-lang") || $el.parent().attr("data-lang");
+  if (dataLang) {
+    return normalizeLanguage(dataLang);
+  }
+  return null;
+}
+function normalizeLanguage(lang) {
+  const lower = lang.toLowerCase();
+  const aliases = {
+    typescript: "ts",
+    javascript: "js",
+    tsx: "tsx",
+    jsx: "jsx",
+    node: "js",
+    esm: "js"
+  };
+  return aliases[lower] ?? lower;
+}
+function isExecutableLang(lang) {
+  if (!lang)
+    return false;
+  const executableLangs = new Set(["ts", "typescript", "js", "javascript", "tsx", "jsx", "mts", "mjs"]);
+  return executableLangs.has(lang.toLowerCase());
+}
+function extractMarkdownCodeBlocks(content) {
+  const codeBlocks = [];
+  const lines = content.split(`
+`);
+  let inBlock = false;
+  let blockLang = "";
+  let blockCode = [];
+  let blockStart = 0;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (!inBlock && line.startsWith("```")) {
+      inBlock = true;
+      blockLang = line.slice(3).trim().split(/\s/)[0] || "";
+      blockCode = [];
+      blockStart = i + 1;
+    } else if (inBlock && line.startsWith("```")) {
+      if (isExecutableLang(blockLang)) {
+        codeBlocks.push({
+          lang: normalizeLanguage(blockLang) || "ts",
+          code: blockCode.join(`
+`),
+          lineStart: blockStart,
+          lineEnd: i
+        });
+      }
+      inBlock = false;
+      blockLang = "";
+      blockCode = [];
+    } else if (inBlock) {
+      blockCode.push(line);
+    }
+  }
+  return codeBlocks;
+}
+
+// ../../node_modules/@isaacs/balanced-match/dist/esm/index.js
+var balanced = (a, b, str) => {
+  const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+  const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+  const r = ma !== null && mb != null && range(ma, mb, str);
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: str.slice(0, r[0]),
+    body: str.slice(r[0] + ma.length, r[1]),
+    post: str.slice(r[1] + mb.length)
+  };
+};
+var maybeMatch = (reg, str) => {
+  const m = str.match(reg);
+  return m ? m[0] : null;
+};
+var range = (a, b, str) => {
+  let begs, beg, left, right = undefined, result;
+  let ai = str.indexOf(a);
+  let bi = str.indexOf(b, ai + 1);
+  let i = ai;
+  if (ai >= 0 && bi > 0) {
+    if (a === b) {
+      return [ai, bi];
+    }
+    begs = [];
+    left = str.length;
+    while (i >= 0 && !result) {
+      if (i === ai) {
+        begs.push(i);
+        ai = str.indexOf(a, i + 1);
+      } else if (begs.length === 1) {
+        const r = begs.pop();
+        if (r !== undefined)
+          result = [r, bi];
+      } else {
+        beg = begs.pop();
+        if (beg !== undefined && beg < left) {
+          left = beg;
+          right = bi;
+        }
+        bi = str.indexOf(b, i + 1);
+      }
+      i = ai < bi && ai >= 0 ? ai : bi;
+    }
+    if (begs.length && right !== undefined) {
+      result = [left, right];
+    }
+  }
+  return result;
+};
+
+// ../../node_modules/@isaacs/brace-expansion/dist/esm/index.js
+var escSlash = "\x00SLASH" + Math.random() + "\x00";
+var escOpen = "\x00OPEN" + Math.random() + "\x00";
+var escClose = "\x00CLOSE" + Math.random() + "\x00";
+var escComma = "\x00COMMA" + Math.random() + "\x00";
+var escPeriod = "\x00PERIOD" + Math.random() + "\x00";
+var escSlashPattern = new RegExp(escSlash, "g");
+var escOpenPattern = new RegExp(escOpen, "g");
+var escClosePattern = new RegExp(escClose, "g");
+var escCommaPattern = new RegExp(escComma, "g");
+var escPeriodPattern = new RegExp(escPeriod, "g");
+var slashPattern = /\\\\/g;
+var openPattern = /\\{/g;
+var closePattern = /\\}/g;
+var commaPattern = /\\,/g;
+var periodPattern = /\\./g;
+function numeric(str) {
+  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
+}
+function escapeBraces(str) {
+  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
+}
+function unescapeBraces(str) {
+  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+}
+function parseCommaParts(str) {
+  if (!str) {
+    return [""];
+  }
+  const parts = [];
+  const m = balanced("{", "}", str);
+  if (!m) {
+    return str.split(",");
+  }
+  const { pre, body, post } = m;
+  const p = pre.split(",");
+  p[p.length - 1] += "{" + body + "}";
+  const postParts = parseCommaParts(post);
+  if (post.length) {
+    p[p.length - 1] += postParts.shift();
+    p.push.apply(p, postParts);
+  }
+  parts.push.apply(parts, p);
+  return parts;
+}
+function expand(str) {
+  if (!str) {
+    return [];
+  }
+  if (str.slice(0, 2) === "{}") {
+    str = "\\{\\}" + str.slice(2);
+  }
+  return expand_(escapeBraces(str), true).map(unescapeBraces);
+}
+function embrace(str) {
+  return "{" + str + "}";
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+function lte(i, y) {
+  return i <= y;
+}
+function gte(i, y) {
+  return i >= y;
+}
+function expand_(str, isTop) {
+  const expansions = [];
+  const m = balanced("{", "}", str);
+  if (!m)
+    return [str];
+  const pre = m.pre;
+  const post = m.post.length ? expand_(m.post, false) : [""];
+  if (/\$$/.test(m.pre)) {
+    for (let k = 0;k < post.length; k++) {
+      const expansion = pre + "{" + m.body + "}" + post[k];
+      expansions.push(expansion);
+    }
+  } else {
+    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+    const isSequence = isNumericSequence || isAlphaSequence;
+    const isOptions = m.body.indexOf(",") >= 0;
+    if (!isSequence && !isOptions) {
+      if (m.post.match(/,(?!,).*\}/)) {
+        str = m.pre + "{" + m.body + escClose + m.post;
+        return expand_(str);
+      }
+      return [str];
+    }
+    let n;
+    if (isSequence) {
+      n = m.body.split(/\.\./);
+    } else {
+      n = parseCommaParts(m.body);
+      if (n.length === 1 && n[0] !== undefined) {
+        n = expand_(n[0], false).map(embrace);
+        if (n.length === 1) {
+          return post.map((p) => m.pre + n[0] + p);
+        }
+      }
+    }
+    let N;
+    if (isSequence && n[0] !== undefined && n[1] !== undefined) {
+      const x = numeric(n[0]);
+      const y = numeric(n[1]);
+      const width = Math.max(n[0].length, n[1].length);
+      let incr = n.length === 3 && n[2] !== undefined ? Math.abs(numeric(n[2])) : 1;
+      let test = lte;
+      const reverse = y < x;
+      if (reverse) {
+        incr *= -1;
+        test = gte;
+      }
+      const pad = n.some(isPadded);
+      N = [];
+      for (let i = x;test(i, y); i += incr) {
+        let c;
+        if (isAlphaSequence) {
+          c = String.fromCharCode(i);
+          if (c === "\\") {
+            c = "";
+          }
+        } else {
+          c = String(i);
+          if (pad) {
+            const need = width - c.length;
+            if (need > 0) {
+              const z = new Array(need + 1).join("0");
+              if (i < 0) {
+                c = "-" + z + c.slice(1);
+              } else {
+                c = z + c;
+              }
+            }
+          }
+        }
+        N.push(c);
+      }
+    } else {
+      N = [];
+      for (let j = 0;j < n.length; j++) {
+        N.push.apply(N, expand_(n[j], false));
+      }
+    }
+    for (let j = 0;j < N.length; j++) {
+      for (let k = 0;k < post.length; k++) {
+        const expansion = pre + N[j] + post[k];
+        if (!isTop || isSequence || expansion) {
+          expansions.push(expansion);
+        }
+      }
+    }
+  }
+  return expansions;
+}
+
+// ../../node_modules/minimatch/dist/esm/assert-valid-pattern.js
+var MAX_PATTERN_LENGTH = 1024 * 64;
+var assertValidPattern = (pattern) => {
+  if (typeof pattern !== "string") {
+    throw new TypeError("invalid pattern");
+  }
+  if (pattern.length > MAX_PATTERN_LENGTH) {
+    throw new TypeError("pattern is too long");
+  }
+};
+
+// ../../node_modules/minimatch/dist/esm/brace-expressions.js
+var posixClasses = {
+  "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
+  "[:alpha:]": ["\\p{L}\\p{Nl}", true],
+  "[:ascii:]": ["\\x" + "00-\\x" + "7f", false],
+  "[:blank:]": ["\\p{Zs}\\t", true],
+  "[:cntrl:]": ["\\p{Cc}", true],
+  "[:digit:]": ["\\p{Nd}", true],
+  "[:graph:]": ["\\p{Z}\\p{C}", true, true],
+  "[:lower:]": ["\\p{Ll}", true],
+  "[:print:]": ["\\p{C}", true],
+  "[:punct:]": ["\\p{P}", true],
+  "[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
+  "[:upper:]": ["\\p{Lu}", true],
+  "[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
+  "[:xdigit:]": ["A-Fa-f0-9", false]
+};
+var braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&");
+var regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var rangesToString = (ranges) => ranges.join("");
+var parseClass = (glob2, position) => {
+  const pos = position;
+  if (glob2.charAt(pos) !== "[") {
+    throw new Error("not in a brace expression");
+  }
+  const ranges = [];
+  const negs = [];
+  let i = pos + 1;
+  let sawStart = false;
+  let uflag = false;
+  let escaping = false;
+  let negate = false;
+  let endPos = pos;
+  let rangeStart = "";
+  WHILE:
+    while (i < glob2.length) {
+      const c = glob2.charAt(i);
+      if ((c === "!" || c === "^") && i === pos + 1) {
+        negate = true;
+        i++;
+        continue;
+      }
+      if (c === "]" && sawStart && !escaping) {
+        endPos = i + 1;
+        break;
+      }
+      sawStart = true;
+      if (c === "\\") {
+        if (!escaping) {
+          escaping = true;
+          i++;
+          continue;
+        }
+      }
+      if (c === "[" && !escaping) {
+        for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
+          if (glob2.startsWith(cls, i)) {
+            if (rangeStart) {
+              return ["$.", false, glob2.length - pos, true];
+            }
+            i += cls.length;
+            if (neg)
+              negs.push(unip);
+            else
+              ranges.push(unip);
+            uflag = uflag || u;
+            continue WHILE;
+          }
+        }
+      }
+      escaping = false;
+      if (rangeStart) {
+        if (c > rangeStart) {
+          ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c));
+        } else if (c === rangeStart) {
+          ranges.push(braceEscape(c));
+        }
+        rangeStart = "";
+        i++;
+        continue;
+      }
+      if (glob2.startsWith("-]", i + 1)) {
+        ranges.push(braceEscape(c + "-"));
+        i += 2;
+        continue;
+      }
+      if (glob2.startsWith("-", i + 1)) {
+        rangeStart = c;
+        i += 2;
+        continue;
+      }
+      ranges.push(braceEscape(c));
+      i++;
+    }
+  if (endPos < i) {
+    return ["", false, 0, false];
+  }
+  if (!ranges.length && !negs.length) {
+    return ["$.", false, glob2.length - pos, true];
+  }
+  if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate) {
+    const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
+    return [regexpEscape(r), false, endPos - pos, false];
+  }
+  const sranges = "[" + (negate ? "^" : "") + rangesToString(ranges) + "]";
+  const snegs = "[" + (negate ? "" : "^") + rangesToString(negs) + "]";
+  const comb = ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs;
+  return [comb, uflag, endPos - pos, true];
+};
+
+// ../../node_modules/minimatch/dist/esm/unescape.js
+var unescape = (s, { windowsPathsNoEscape = false, magicalBraces = true } = {}) => {
+  if (magicalBraces) {
+    return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+  }
+  return windowsPathsNoEscape ? s.replace(/\[([^\/\\{}])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, "$1$2").replace(/\\([^\/{}])/g, "$1");
+};
+
+// ../../node_modules/minimatch/dist/esm/ast.js
+var types = new Set(["!", "?", "+", "*", "@"]);
+var isExtglobType = (c) => types.has(c);
+var startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
+var startNoDot = "(?!\\.)";
+var addPatternStart = new Set(["[", "."]);
+var justDots = new Set(["..", "."]);
+var reSpecials = new Set("().*{}+?[]^$\\!");
+var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var qmark = "[^/]";
+var star = qmark + "*?";
+var starNoEmpty = qmark + "+?";
+
+class AST {
+  type;
+  #root;
+  #hasMagic;
+  #uflag = false;
+  #parts = [];
+  #parent;
+  #parentIndex;
+  #negs;
+  #filledNegs = false;
+  #options;
+  #toString;
+  #emptyExt = false;
+  constructor(type, parent, options = {}) {
+    this.type = type;
+    if (type)
+      this.#hasMagic = true;
+    this.#parent = parent;
+    this.#root = this.#parent ? this.#parent.#root : this;
+    this.#options = this.#root === this ? options : this.#root.#options;
+    this.#negs = this.#root === this ? [] : this.#root.#negs;
+    if (type === "!" && !this.#root.#filledNegs)
+      this.#negs.push(this);
+    this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
+  }
+  get hasMagic() {
+    if (this.#hasMagic !== undefined)
+      return this.#hasMagic;
+    for (const p of this.#parts) {
+      if (typeof p === "string")
+        continue;
+      if (p.type || p.hasMagic)
+        return this.#hasMagic = true;
+    }
+    return this.#hasMagic;
+  }
+  toString() {
+    if (this.#toString !== undefined)
+      return this.#toString;
+    if (!this.type) {
+      return this.#toString = this.#parts.map((p) => String(p)).join("");
+    } else {
+      return this.#toString = this.type + "(" + this.#parts.map((p) => String(p)).join("|") + ")";
+    }
+  }
+  #fillNegs() {
+    if (this !== this.#root)
+      throw new Error("should only call on root");
+    if (this.#filledNegs)
+      return this;
+    this.toString();
+    this.#filledNegs = true;
+    let n;
+    while (n = this.#negs.pop()) {
+      if (n.type !== "!")
+        continue;
+      let p = n;
+      let pp = p.#parent;
+      while (pp) {
+        for (let i = p.#parentIndex + 1;!pp.type && i < pp.#parts.length; i++) {
+          for (const part of n.#parts) {
+            if (typeof part === "string") {
+              throw new Error("string part in extglob AST??");
+            }
+            part.copyIn(pp.#parts[i]);
+          }
+        }
+        p = pp;
+        pp = p.#parent;
+      }
+    }
+    return this;
+  }
+  push(...parts) {
+    for (const p of parts) {
+      if (p === "")
+        continue;
+      if (typeof p !== "string" && !(p instanceof AST && p.#parent === this)) {
+        throw new Error("invalid part: " + p);
+      }
+      this.#parts.push(p);
+    }
+  }
+  toJSON() {
+    const ret = this.type === null ? this.#parts.slice().map((p) => typeof p === "string" ? p : p.toJSON()) : [this.type, ...this.#parts.map((p) => p.toJSON())];
+    if (this.isStart() && !this.type)
+      ret.unshift([]);
+    if (this.isEnd() && (this === this.#root || this.#root.#filledNegs && this.#parent?.type === "!")) {
+      ret.push({});
+    }
+    return ret;
+  }
+  isStart() {
+    if (this.#root === this)
+      return true;
+    if (!this.#parent?.isStart())
+      return false;
+    if (this.#parentIndex === 0)
+      return true;
+    const p = this.#parent;
+    for (let i = 0;i < this.#parentIndex; i++) {
+      const pp = p.#parts[i];
+      if (!(pp instanceof AST && pp.type === "!")) {
+        return false;
+      }
+    }
+    return true;
+  }
+  isEnd() {
+    if (this.#root === this)
+      return true;
+    if (this.#parent?.type === "!")
+      return true;
+    if (!this.#parent?.isEnd())
+      return false;
+    if (!this.type)
+      return this.#parent?.isEnd();
+    const pl = this.#parent ? this.#parent.#parts.length : 0;
+    return this.#parentIndex === pl - 1;
+  }
+  copyIn(part) {
+    if (typeof part === "string")
+      this.push(part);
+    else
+      this.push(part.clone(this));
+  }
+  clone(parent) {
+    const c = new AST(this.type, parent);
+    for (const p of this.#parts) {
+      c.copyIn(p);
+    }
+    return c;
+  }
+  static #parseAST(str, ast, pos, opt) {
+    let escaping = false;
+    let inBrace = false;
+    let braceStart = -1;
+    let braceNeg = false;
+    if (ast.type === null) {
+      let i2 = pos;
+      let acc2 = "";
+      while (i2 < str.length) {
+        const c = str.charAt(i2++);
+        if (escaping || c === "\\") {
+          escaping = !escaping;
+          acc2 += c;
+          continue;
+        }
+        if (inBrace) {
+          if (i2 === braceStart + 1) {
+            if (c === "^" || c === "!") {
+              braceNeg = true;
+            }
+          } else if (c === "]" && !(i2 === braceStart + 2 && braceNeg)) {
+            inBrace = false;
+          }
+          acc2 += c;
+          continue;
+        } else if (c === "[") {
+          inBrace = true;
+          braceStart = i2;
+          braceNeg = false;
+          acc2 += c;
+          continue;
+        }
+        if (!opt.noext && isExtglobType(c) && str.charAt(i2) === "(") {
+          ast.push(acc2);
+          acc2 = "";
+          const ext = new AST(c, ast);
+          i2 = AST.#parseAST(str, ext, i2, opt);
+          ast.push(ext);
+          continue;
+        }
+        acc2 += c;
+      }
+      ast.push(acc2);
+      return i2;
+    }
+    let i = pos + 1;
+    let part = new AST(null, ast);
+    const parts = [];
+    let acc = "";
+    while (i < str.length) {
+      const c = str.charAt(i++);
+      if (escaping || c === "\\") {
+        escaping = !escaping;
+        acc += c;
+        continue;
+      }
+      if (inBrace) {
+        if (i === braceStart + 1) {
+          if (c === "^" || c === "!") {
+            braceNeg = true;
+          }
+        } else if (c === "]" && !(i === braceStart + 2 && braceNeg)) {
+          inBrace = false;
+        }
+        acc += c;
+        continue;
+      } else if (c === "[") {
+        inBrace = true;
+        braceStart = i;
+        braceNeg = false;
+        acc += c;
+        continue;
+      }
+      if (isExtglobType(c) && str.charAt(i) === "(") {
+        part.push(acc);
+        acc = "";
+        const ext = new AST(c, part);
+        part.push(ext);
+        i = AST.#parseAST(str, ext, i, opt);
+        continue;
+      }
+      if (c === "|") {
+        part.push(acc);
+        acc = "";
+        parts.push(part);
+        part = new AST(null, ast);
+        continue;
+      }
+      if (c === ")") {
+        if (acc === "" && ast.#parts.length === 0) {
+          ast.#emptyExt = true;
+        }
+        part.push(acc);
+        acc = "";
+        ast.push(...parts, part);
+        return i;
+      }
+      acc += c;
+    }
+    ast.type = null;
+    ast.#hasMagic = undefined;
+    ast.#parts = [str.substring(pos - 1)];
+    return i;
+  }
+  static fromGlob(pattern, options = {}) {
+    const ast = new AST(null, undefined, options);
+    AST.#parseAST(pattern, ast, 0, options);
+    return ast;
+  }
+  toMMPattern() {
+    if (this !== this.#root)
+      return this.#root.toMMPattern();
+    const glob2 = this.toString();
+    const [re, body, hasMagic, uflag] = this.toRegExpSource();
+    const anyMagic = hasMagic || this.#hasMagic || this.#options.nocase && !this.#options.nocaseMagicOnly && glob2.toUpperCase() !== glob2.toLowerCase();
+    if (!anyMagic) {
+      return body;
+    }
+    const flags = (this.#options.nocase ? "i" : "") + (uflag ? "u" : "");
+    return Object.assign(new RegExp(`^${re}$`, flags), {
+      _src: re,
+      _glob: glob2
+    });
+  }
+  get options() {
+    return this.#options;
+  }
+  toRegExpSource(allowDot) {
+    const dot = allowDot ?? !!this.#options.dot;
+    if (this.#root === this)
+      this.#fillNegs();
+    if (!this.type) {
+      const noEmpty = this.isStart() && this.isEnd() && !this.#parts.some((s) => typeof s !== "string");
+      const src = this.#parts.map((p) => {
+        const [re, _, hasMagic, uflag] = typeof p === "string" ? AST.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
+        this.#hasMagic = this.#hasMagic || hasMagic;
+        this.#uflag = this.#uflag || uflag;
+        return re;
+      }).join("");
+      let start2 = "";
+      if (this.isStart()) {
+        if (typeof this.#parts[0] === "string") {
+          const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);
+          if (!dotTravAllowed) {
+            const aps = addPatternStart;
+            const needNoTrav = dot && aps.has(src.charAt(0)) || src.startsWith("\\.") && aps.has(src.charAt(2)) || src.startsWith("\\.\\.") && aps.has(src.charAt(4));
+            const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
+            start2 = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : "";
+          }
+        }
+      }
+      let end = "";
+      if (this.isEnd() && this.#root.#filledNegs && this.#parent?.type === "!") {
+        end = "(?:$|\\/)";
+      }
+      const final2 = start2 + src + end;
+      return [
+        final2,
+        unescape(src),
+        this.#hasMagic = !!this.#hasMagic,
+        this.#uflag
+      ];
+    }
+    const repeated = this.type === "*" || this.type === "+";
+    const start = this.type === "!" ? "(?:(?!(?:" : "(?:";
+    let body = this.#partsToRegExp(dot);
+    if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
+      const s = this.toString();
+      this.#parts = [s];
+      this.type = null;
+      this.#hasMagic = undefined;
+      return [s, unescape(this.toString()), false, false];
+    }
+    let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? "" : this.#partsToRegExp(true);
+    if (bodyDotAllowed === body) {
+      bodyDotAllowed = "";
+    }
+    if (bodyDotAllowed) {
+      body = `(?:${body})(?:${bodyDotAllowed})*?`;
+    }
+    let final = "";
+    if (this.type === "!" && this.#emptyExt) {
+      final = (this.isStart() && !dot ? startNoDot : "") + starNoEmpty;
+    } else {
+      const close = this.type === "!" ? "))" + (this.isStart() && !dot && !allowDot ? startNoDot : "") + star + ")" : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
+      final = start + body + close;
+    }
+    return [
+      final,
+      unescape(body),
+      this.#hasMagic = !!this.#hasMagic,
+      this.#uflag
+    ];
+  }
+  #partsToRegExp(dot) {
+    return this.#parts.map((p) => {
+      if (typeof p === "string") {
+        throw new Error("string type in extglob ast??");
+      }
+      const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);
+      this.#uflag = this.#uflag || uflag;
+      return re;
+    }).filter((p) => !(this.isStart() && this.isEnd()) || !!p).join("|");
+  }
+  static #parseGlob(glob2, hasMagic, noEmpty = false) {
+    let escaping = false;
+    let re = "";
+    let uflag = false;
+    for (let i = 0;i < glob2.length; i++) {
+      const c = glob2.charAt(i);
+      if (escaping) {
+        escaping = false;
+        re += (reSpecials.has(c) ? "\\" : "") + c;
+        continue;
+      }
+      if (c === "\\") {
+        if (i === glob2.length - 1) {
+          re += "\\\\";
+        } else {
+          escaping = true;
+        }
+        continue;
+      }
+      if (c === "[") {
+        const [src, needUflag, consumed, magic] = parseClass(glob2, i);
+        if (consumed) {
+          re += src;
+          uflag = uflag || needUflag;
+          i += consumed - 1;
+          hasMagic = hasMagic || magic;
+          continue;
+        }
+      }
+      if (c === "*") {
+        re += noEmpty && glob2 === "*" ? starNoEmpty : star;
+        hasMagic = true;
+        continue;
+      }
+      if (c === "?") {
+        re += qmark;
+        hasMagic = true;
+        continue;
+      }
+      re += regExpEscape(c);
+    }
+    return [re, unescape(glob2), !!hasMagic, uflag];
+  }
+}
+
+// ../../node_modules/minimatch/dist/esm/escape.js
+var escape = (s, { windowsPathsNoEscape = false, magicalBraces = false } = {}) => {
+  if (magicalBraces) {
+    return windowsPathsNoEscape ? s.replace(/[?*()[\]{}]/g, "[$&]") : s.replace(/[?*()[\]\\{}]/g, "\\$&");
+  }
+  return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
+};
+
+// ../../node_modules/minimatch/dist/esm/index.js
+var minimatch = (p, pattern, options = {}) => {
+  assertValidPattern(pattern);
+  if (!options.nocomment && pattern.charAt(0) === "#") {
+    return false;
+  }
+  return new Minimatch(pattern, options).match(p);
+};
+var starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
+var starDotExtTest = (ext) => (f) => !f.startsWith(".") && f.endsWith(ext);
+var starDotExtTestDot = (ext) => (f) => f.endsWith(ext);
+var starDotExtTestNocase = (ext) => {
+  ext = ext.toLowerCase();
+  return (f) => !f.startsWith(".") && f.toLowerCase().endsWith(ext);
+};
+var starDotExtTestNocaseDot = (ext) => {
+  ext = ext.toLowerCase();
+  return (f) => f.toLowerCase().endsWith(ext);
+};
+var starDotStarRE = /^\*+\.\*+$/;
+var starDotStarTest = (f) => !f.startsWith(".") && f.includes(".");
+var starDotStarTestDot = (f) => f !== "." && f !== ".." && f.includes(".");
+var dotStarRE = /^\.\*+$/;
+var dotStarTest = (f) => f !== "." && f !== ".." && f.startsWith(".");
+var starRE = /^\*+$/;
+var starTest = (f) => f.length !== 0 && !f.startsWith(".");
+var starTestDot = (f) => f.length !== 0 && f !== "." && f !== "..";
+var qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
+var qmarksTestNocase = ([$0, ext = ""]) => {
+  const noext = qmarksTestNoExt([$0]);
+  if (!ext)
+    return noext;
+  ext = ext.toLowerCase();
+  return (f) => noext(f) && f.toLowerCase().endsWith(ext);
+};
+var qmarksTestNocaseDot = ([$0, ext = ""]) => {
+  const noext = qmarksTestNoExtDot([$0]);
+  if (!ext)
+    return noext;
+  ext = ext.toLowerCase();
+  return (f) => noext(f) && f.toLowerCase().endsWith(ext);
+};
+var qmarksTestDot = ([$0, ext = ""]) => {
+  const noext = qmarksTestNoExtDot([$0]);
+  return !ext ? noext : (f) => noext(f) && f.endsWith(ext);
+};
+var qmarksTest = ([$0, ext = ""]) => {
+  const noext = qmarksTestNoExt([$0]);
+  return !ext ? noext : (f) => noext(f) && f.endsWith(ext);
+};
+var qmarksTestNoExt = ([$0]) => {
+  const len = $0.length;
+  return (f) => f.length === len && !f.startsWith(".");
+};
+var qmarksTestNoExtDot = ([$0]) => {
+  const len = $0.length;
+  return (f) => f.length === len && f !== "." && f !== "..";
+};
+var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
+var path7 = {
+  win32: { sep: "\\" },
+  posix: { sep: "/" }
+};
+var sep = defaultPlatform === "win32" ? path7.win32.sep : path7.posix.sep;
+minimatch.sep = sep;
+var GLOBSTAR = Symbol("globstar **");
+minimatch.GLOBSTAR = GLOBSTAR;
+var qmark2 = "[^/]";
+var star2 = qmark2 + "*?";
+var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+var filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options);
+minimatch.filter = filter;
+var ext = (a, b = {}) => Object.assign({}, a, b);
+var defaults = (def) => {
+  if (!def || typeof def !== "object" || !Object.keys(def).length) {
+    return minimatch;
+  }
+  const orig = minimatch;
+  const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
+  return Object.assign(m, {
+    Minimatch: class Minimatch extends orig.Minimatch {
+      constructor(pattern, options = {}) {
+        super(pattern, ext(def, options));
+      }
+      static defaults(options) {
+        return orig.defaults(ext(def, options)).Minimatch;
+      }
+    },
+    AST: class AST2 extends orig.AST {
+      constructor(type, parent, options = {}) {
+        super(type, parent, ext(def, options));
+      }
+      static fromGlob(pattern, options = {}) {
+        return orig.AST.fromGlob(pattern, ext(def, options));
+      }
+    },
+    unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
+    escape: (s, options = {}) => orig.escape(s, ext(def, options)),
+    filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
+    defaults: (options) => orig.defaults(ext(def, options)),
+    makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
+    braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
+    match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
+    sep: orig.sep,
+    GLOBSTAR
+  });
+};
+minimatch.defaults = defaults;
+var braceExpand = (pattern, options = {}) => {
+  assertValidPattern(pattern);
+  if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+    return [pattern];
+  }
+  return expand(pattern);
+};
+minimatch.braceExpand = braceExpand;
+var makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
+minimatch.makeRe = makeRe;
+var match = (list, pattern, options = {}) => {
+  const mm = new Minimatch(pattern, options);
+  list = list.filter((f) => mm.match(f));
+  if (mm.options.nonull && !list.length) {
+    list.push(pattern);
+  }
+  return list;
+};
+minimatch.match = match;
+var globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
+var regExpEscape2 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+
+class Minimatch {
+  options;
+  set;
+  pattern;
+  windowsPathsNoEscape;
+  nonegate;
+  negate;
+  comment;
+  empty;
+  preserveMultipleSlashes;
+  partial;
+  globSet;
+  globParts;
+  nocase;
+  isWindows;
+  platform;
+  windowsNoMagicRoot;
+  regexp;
+  constructor(pattern, options = {}) {
+    assertValidPattern(pattern);
+    options = options || {};
+    this.options = options;
+    this.pattern = pattern;
+    this.platform = options.platform || defaultPlatform;
+    this.isWindows = this.platform === "win32";
+    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
+    if (this.windowsPathsNoEscape) {
+      this.pattern = this.pattern.replace(/\\/g, "/");
+    }
+    this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
+    this.regexp = null;
+    this.negate = false;
+    this.nonegate = !!options.nonegate;
+    this.comment = false;
+    this.empty = false;
+    this.partial = !!options.partial;
+    this.nocase = !!this.options.nocase;
+    this.windowsNoMagicRoot = options.windowsNoMagicRoot !== undefined ? options.windowsNoMagicRoot : !!(this.isWindows && this.nocase);
+    this.globSet = [];
+    this.globParts = [];
+    this.set = [];
+    this.make();
+  }
+  hasMagic() {
+    if (this.options.magicalBraces && this.set.length > 1) {
+      return true;
+    }
+    for (const pattern of this.set) {
+      for (const part of pattern) {
+        if (typeof part !== "string")
+          return true;
+      }
+    }
+    return false;
+  }
+  debug(..._) {}
+  make() {
+    const pattern = this.pattern;
+    const options = this.options;
+    if (!options.nocomment && pattern.charAt(0) === "#") {
+      this.comment = true;
+      return;
+    }
+    if (!pattern) {
+      this.empty = true;
+      return;
+    }
+    this.parseNegate();
+    this.globSet = [...new Set(this.braceExpand())];
+    if (options.debug) {
+      this.debug = (...args) => console.error(...args);
+    }
+    this.debug(this.pattern, this.globSet);
+    const rawGlobParts = this.globSet.map((s) => this.slashSplit(s));
+    this.globParts = this.preprocess(rawGlobParts);
+    this.debug(this.pattern, this.globParts);
+    let set = this.globParts.map((s, _, __) => {
+      if (this.isWindows && this.windowsNoMagicRoot) {
+        const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
+        const isDrive = /^[a-z]:/i.test(s[0]);
+        if (isUNC) {
+          return [...s.slice(0, 4), ...s.slice(4).map((ss) => this.parse(ss))];
+        } else if (isDrive) {
+          return [s[0], ...s.slice(1).map((ss) => this.parse(ss))];
+        }
+      }
+      return s.map((ss) => this.parse(ss));
+    });
+    this.debug(this.pattern, set);
+    this.set = set.filter((s) => s.indexOf(false) === -1);
+    if (this.isWindows) {
+      for (let i = 0;i < this.set.length; i++) {
+        const p = this.set[i];
+        if (p[0] === "" && p[1] === "" && this.globParts[i][2] === "?" && typeof p[3] === "string" && /^[a-z]:$/i.test(p[3])) {
+          p[2] = "?";
+        }
+      }
+    }
+    this.debug(this.pattern, this.set);
+  }
+  preprocess(globParts) {
+    if (this.options.noglobstar) {
+      for (let i = 0;i < globParts.length; i++) {
+        for (let j = 0;j < globParts[i].length; j++) {
+          if (globParts[i][j] === "**") {
+            globParts[i][j] = "*";
+          }
+        }
+      }
+    }
+    const { optimizationLevel = 1 } = this.options;
+    if (optimizationLevel >= 2) {
+      globParts = this.firstPhasePreProcess(globParts);
+      globParts = this.secondPhasePreProcess(globParts);
+    } else if (optimizationLevel >= 1) {
+      globParts = this.levelOneOptimize(globParts);
+    } else {
+      globParts = this.adjascentGlobstarOptimize(globParts);
+    }
+    return globParts;
+  }
+  adjascentGlobstarOptimize(globParts) {
+    return globParts.map((parts) => {
+      let gs = -1;
+      while ((gs = parts.indexOf("**", gs + 1)) !== -1) {
+        let i = gs;
+        while (parts[i + 1] === "**") {
+          i++;
+        }
+        if (i !== gs) {
+          parts.splice(gs, i - gs);
+        }
+      }
+      return parts;
+    });
+  }
+  levelOneOptimize(globParts) {
+    return globParts.map((parts) => {
+      parts = parts.reduce((set, part) => {
+        const prev = set[set.length - 1];
+        if (part === "**" && prev === "**") {
+          return set;
+        }
+        if (part === "..") {
+          if (prev && prev !== ".." && prev !== "." && prev !== "**") {
+            set.pop();
+            return set;
+          }
+        }
+        set.push(part);
+        return set;
+      }, []);
+      return parts.length === 0 ? [""] : parts;
+    });
+  }
+  levelTwoFileOptimize(parts) {
+    if (!Array.isArray(parts)) {
+      parts = this.slashSplit(parts);
+    }
+    let didSomething = false;
+    do {
+      didSomething = false;
+      if (!this.preserveMultipleSlashes) {
+        for (let i = 1;i < parts.length - 1; i++) {
+          const p = parts[i];
+          if (i === 1 && p === "" && parts[0] === "")
+            continue;
+          if (p === "." || p === "") {
+            didSomething = true;
+            parts.splice(i, 1);
+            i--;
+          }
+        }
+        if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
+          didSomething = true;
+          parts.pop();
+        }
+      }
+      let dd = 0;
+      while ((dd = parts.indexOf("..", dd + 1)) !== -1) {
+        const p = parts[dd - 1];
+        if (p && p !== "." && p !== ".." && p !== "**") {
+          didSomething = true;
+          parts.splice(dd - 1, 2);
+          dd -= 2;
+        }
+      }
+    } while (didSomething);
+    return parts.length === 0 ? [""] : parts;
+  }
+  firstPhasePreProcess(globParts) {
+    let didSomething = false;
+    do {
+      didSomething = false;
+      for (let parts of globParts) {
+        let gs = -1;
+        while ((gs = parts.indexOf("**", gs + 1)) !== -1) {
+          let gss = gs;
+          while (parts[gss + 1] === "**") {
+            gss++;
+          }
+          if (gss > gs) {
+            parts.splice(gs + 1, gss - gs);
+          }
+          let next = parts[gs + 1];
+          const p = parts[gs + 2];
+          const p2 = parts[gs + 3];
+          if (next !== "..")
+            continue;
+          if (!p || p === "." || p === ".." || !p2 || p2 === "." || p2 === "..") {
+            continue;
+          }
+          didSomething = true;
+          parts.splice(gs, 1);
+          const other = parts.slice(0);
+          other[gs] = "**";
+          globParts.push(other);
+          gs--;
+        }
+        if (!this.preserveMultipleSlashes) {
+          for (let i = 1;i < parts.length - 1; i++) {
+            const p = parts[i];
+            if (i === 1 && p === "" && parts[0] === "")
+              continue;
+            if (p === "." || p === "") {
+              didSomething = true;
+              parts.splice(i, 1);
+              i--;
+            }
+          }
+          if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
+            didSomething = true;
+            parts.pop();
+          }
+        }
+        let dd = 0;
+        while ((dd = parts.indexOf("..", dd + 1)) !== -1) {
+          const p = parts[dd - 1];
+          if (p && p !== "." && p !== ".." && p !== "**") {
+            didSomething = true;
+            const needDot = dd === 1 && parts[dd + 1] === "**";
+            const splin = needDot ? ["."] : [];
+            parts.splice(dd - 1, 2, ...splin);
+            if (parts.length === 0)
+              parts.push("");
+            dd -= 2;
+          }
+        }
+      }
+    } while (didSomething);
+    return globParts;
+  }
+  secondPhasePreProcess(globParts) {
+    for (let i = 0;i < globParts.length - 1; i++) {
+      for (let j = i + 1;j < globParts.length; j++) {
+        const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
+        if (matched) {
+          globParts[i] = [];
+          globParts[j] = matched;
+          break;
+        }
+      }
+    }
+    return globParts.filter((gs) => gs.length);
+  }
+  partsMatch(a, b, emptyGSMatch = false) {
+    let ai = 0;
+    let bi = 0;
+    let result = [];
+    let which = "";
+    while (ai < a.length && bi < b.length) {
+      if (a[ai] === b[bi]) {
+        result.push(which === "b" ? b[bi] : a[ai]);
+        ai++;
+        bi++;
+      } else if (emptyGSMatch && a[ai] === "**" && b[bi] === a[ai + 1]) {
+        result.push(a[ai]);
+        ai++;
+      } else if (emptyGSMatch && b[bi] === "**" && a[ai] === b[bi + 1]) {
+        result.push(b[bi]);
+        bi++;
+      } else if (a[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
+        if (which === "b")
+          return false;
+        which = "a";
+        result.push(a[ai]);
+        ai++;
+        bi++;
+      } else if (b[bi] === "*" && a[ai] && (this.options.dot || !a[ai].startsWith(".")) && a[ai] !== "**") {
+        if (which === "a")
+          return false;
+        which = "b";
+        result.push(b[bi]);
+        ai++;
+        bi++;
+      } else {
+        return false;
+      }
+    }
+    return a.length === b.length && result;
+  }
+  parseNegate() {
+    if (this.nonegate)
+      return;
+    const pattern = this.pattern;
+    let negate = false;
+    let negateOffset = 0;
+    for (let i = 0;i < pattern.length && pattern.charAt(i) === "!"; i++) {
+      negate = !negate;
+      negateOffset++;
+    }
+    if (negateOffset)
+      this.pattern = pattern.slice(negateOffset);
+    this.negate = negate;
+  }
+  matchOne(file, pattern, partial = false) {
+    const options = this.options;
+    if (this.isWindows) {
+      const fileDrive = typeof file[0] === "string" && /^[a-z]:$/i.test(file[0]);
+      const fileUNC = !fileDrive && file[0] === "" && file[1] === "" && file[2] === "?" && /^[a-z]:$/i.test(file[3]);
+      const patternDrive = typeof pattern[0] === "string" && /^[a-z]:$/i.test(pattern[0]);
+      const patternUNC = !patternDrive && pattern[0] === "" && pattern[1] === "" && pattern[2] === "?" && typeof pattern[3] === "string" && /^[a-z]:$/i.test(pattern[3]);
+      const fdi = fileUNC ? 3 : fileDrive ? 0 : undefined;
+      const pdi = patternUNC ? 3 : patternDrive ? 0 : undefined;
+      if (typeof fdi === "number" && typeof pdi === "number") {
+        const [fd, pd] = [file[fdi], pattern[pdi]];
+        if (fd.toLowerCase() === pd.toLowerCase()) {
+          pattern[pdi] = fd;
+          if (pdi > fdi) {
+            pattern = pattern.slice(pdi);
+          } else if (fdi > pdi) {
+            file = file.slice(fdi);
+          }
+        }
+      }
+    }
+    const { optimizationLevel = 1 } = this.options;
+    if (optimizationLevel >= 2) {
+      file = this.levelTwoFileOptimize(file);
+    }
+    this.debug("matchOne", this, { file, pattern });
+    this.debug("matchOne", file.length, pattern.length);
+    for (var fi = 0, pi = 0, fl = file.length, pl = pattern.length;fi < fl && pi < pl; fi++, pi++) {
+      this.debug("matchOne loop");
+      var p = pattern[pi];
+      var f = file[fi];
+      this.debug(pattern, p, f);
+      if (p === false) {
+        return false;
+      }
+      if (p === GLOBSTAR) {
+        this.debug("GLOBSTAR", [pattern, p, f]);
+        var fr = fi;
+        var pr = pi + 1;
+        if (pr === pl) {
+          this.debug("** at the end");
+          for (;fi < fl; fi++) {
+            if (file[fi] === "." || file[fi] === ".." || !options.dot && file[fi].charAt(0) === ".")
+              return false;
+          }
+          return true;
+        }
+        while (fr < fl) {
+          var swallowee = file[fr];
+          this.debug(`
+globstar while`, file, fr, pattern, pr, swallowee);
+          if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+            this.debug("globstar found match!", fr, fl, swallowee);
+            return true;
+          } else {
+            if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
+              this.debug("dot detected!", file, fr, pattern, pr);
+              break;
+            }
+            this.debug("globstar swallow a segment, and continue");
+            fr++;
+          }
+        }
+        if (partial) {
+          this.debug(`
+>>> no match, partial?`, file, fr, pattern, pr);
+          if (fr === fl) {
+            return true;
+          }
+        }
+        return false;
+      }
+      let hit;
+      if (typeof p === "string") {
+        hit = f === p;
+        this.debug("string match", p, f, hit);
+      } else {
+        hit = p.test(f);
+        this.debug("pattern match", p, f, hit);
+      }
+      if (!hit)
+        return false;
+    }
+    if (fi === fl && pi === pl) {
+      return true;
+    } else if (fi === fl) {
+      return partial;
+    } else if (pi === pl) {
+      return fi === fl - 1 && file[fi] === "";
+    } else {
+      throw new Error("wtf?");
+    }
+  }
+  braceExpand() {
+    return braceExpand(this.pattern, this.options);
+  }
+  parse(pattern) {
+    assertValidPattern(pattern);
+    const options = this.options;
+    if (pattern === "**")
+      return GLOBSTAR;
+    if (pattern === "")
+      return "";
+    let m;
+    let fastTest = null;
+    if (m = pattern.match(starRE)) {
+      fastTest = options.dot ? starTestDot : starTest;
+    } else if (m = pattern.match(starDotExtRE)) {
+      fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options.dot ? starDotExtTestDot : starDotExtTest)(m[1]);
+    } else if (m = pattern.match(qmarksRE)) {
+      fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot : qmarksTestNocase : options.dot ? qmarksTestDot : qmarksTest)(m);
+    } else if (m = pattern.match(starDotStarRE)) {
+      fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
+    } else if (m = pattern.match(dotStarRE)) {
+      fastTest = dotStarTest;
+    }
+    const re = AST.fromGlob(pattern, this.options).toMMPattern();
+    if (fastTest && typeof re === "object") {
+      Reflect.defineProperty(re, "test", { value: fastTest });
+    }
+    return re;
+  }
+  makeRe() {
+    if (this.regexp || this.regexp === false)
+      return this.regexp;
+    const set = this.set;
+    if (!set.length) {
+      this.regexp = false;
+      return this.regexp;
+    }
+    const options = this.options;
+    const twoStar = options.noglobstar ? star2 : options.dot ? twoStarDot : twoStarNoDot;
+    const flags = new Set(options.nocase ? ["i"] : []);
+    let re = set.map((pattern) => {
+      const pp = pattern.map((p) => {
+        if (p instanceof RegExp) {
+          for (const f of p.flags.split(""))
+            flags.add(f);
+        }
+        return typeof p === "string" ? regExpEscape2(p) : p === GLOBSTAR ? GLOBSTAR : p._src;
+      });
+      pp.forEach((p, i) => {
+        const next = pp[i + 1];
+        const prev = pp[i - 1];
+        if (p !== GLOBSTAR || prev === GLOBSTAR) {
+          return;
+        }
+        if (prev === undefined) {
+          if (next !== undefined && next !== GLOBSTAR) {
+            pp[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
+          } else {
+            pp[i] = twoStar;
+          }
+        } else if (next === undefined) {
+          pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + ")?";
+        } else if (next !== GLOBSTAR) {
+          pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
+          pp[i + 1] = GLOBSTAR;
+        }
+      });
+      const filtered = pp.filter((p) => p !== GLOBSTAR);
+      if (this.partial && filtered.length >= 1) {
+        const prefixes = [];
+        for (let i = 1;i <= filtered.length; i++) {
+          prefixes.push(filtered.slice(0, i).join("/"));
+        }
+        return "(?:" + prefixes.join("|") + ")";
+      }
+      return filtered.join("/");
+    }).join("|");
+    const [open, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
+    re = "^" + open + re + close + "$";
+    if (this.partial) {
+      re = "^(?:\\/|" + open + re.slice(1, -1) + close + ")$";
+    }
+    if (this.negate)
+      re = "^(?!" + re + ").+$";
+    try {
+      this.regexp = new RegExp(re, [...flags].join(""));
+    } catch (ex) {
+      this.regexp = false;
+    }
+    return this.regexp;
+  }
+  slashSplit(p) {
+    if (this.preserveMultipleSlashes) {
+      return p.split("/");
+    } else if (this.isWindows && /^\/\/[^\/]+/.test(p)) {
+      return ["", ...p.split(/\/+/)];
+    } else {
+      return p.split(/\/+/);
+    }
+  }
+  match(f, partial = this.partial) {
+    this.debug("match", f, this.pattern);
+    if (this.comment) {
+      return false;
+    }
+    if (this.empty) {
+      return f === "";
+    }
+    if (f === "/" && partial) {
+      return true;
+    }
+    const options = this.options;
+    if (this.isWindows) {
+      f = f.split("\\").join("/");
+    }
+    const ff = this.slashSplit(f);
+    this.debug(this.pattern, "split", ff);
+    const set = this.set;
+    this.debug(this.pattern, "set", set);
+    let filename = ff[ff.length - 1];
+    if (!filename) {
+      for (let i = ff.length - 2;!filename && i >= 0; i--) {
+        filename = ff[i];
+      }
+    }
+    for (let i = 0;i < set.length; i++) {
+      const pattern = set[i];
+      let file = ff;
+      if (options.matchBase && pattern.length === 1) {
+        file = [filename];
+      }
+      const hit = this.matchOne(file, pattern, partial);
+      if (hit) {
+        if (options.flipNegate) {
+          return true;
+        }
+        return !this.negate;
+      }
+    }
+    if (options.flipNegate) {
+      return false;
+    }
+    return this.negate;
+  }
+  static defaults(def) {
+    return minimatch.defaults(def).Minimatch;
+  }
+}
+minimatch.AST = AST;
+minimatch.Minimatch = Minimatch;
+minimatch.escape = escape;
+minimatch.unescape = unescape;
+
+// src/commands/check/github-fetcher.ts
+var DEFAULT_TIMEOUT2 = 15000;
+var DEFAULT_TTL3 = 60 * 60 * 1000;
+function getGitHubToken() {
+  return process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+}
+function buildHeaders() {
+  const headers = {
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "doccov-cli"
+  };
+  const token = getGitHubToken();
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  return headers;
+}
+async function fetchFileTree(owner, repo, ref, timeout) {
+  const url = `https://api.github.com/repos/${owner}/${repo}/git/trees/${ref}?recursive=1`;
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: buildHeaders()
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        throw new Error(`GitHub API auth error (${response.status}). Set GITHUB_TOKEN for private repos or higher rate limits.`);
+      }
+      if (response.status === 404) {
+        throw new Error(`GitHub repo not found: ${owner}/${repo}@${ref}`);
+      }
+      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  } catch (err) {
+    clearTimeout(timeoutId);
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new Error(`GitHub API timeout after ${timeout}ms`);
+    }
+    throw err;
+  }
+}
+async function fetchRawContent(owner, repo, ref, path8, timeout) {
+  const url = `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${path8}`;
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        "User-Agent": "doccov-cli",
+        ...getGitHubToken() ? { Authorization: `Bearer ${getGitHubToken()}` } : {}
+      }
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${path8}: ${response.status}`);
+    }
+    return response.text();
+  } catch (err) {
+    clearTimeout(timeoutId);
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new Error(`Timeout fetching ${path8}`);
+    }
+    throw err;
+  }
+}
+function matchGlob(files, pattern) {
+  const glob2 = pattern || "**/*.md";
+  return files.filter((file) => minimatch(file, glob2, { matchBase: true }));
+}
+function parseMarkdownContent2(content, sourcePath) {
+  const codeBlocks = [];
+  const lines = content.split(`
+`);
+  let inBlock = false;
+  let blockLang = "";
+  let blockCode = [];
+  let blockStart = 0;
+  const executableLangs = new Set(["ts", "typescript", "js", "javascript", "tsx", "jsx", "mts", "mjs"]);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (!inBlock && line.startsWith("```")) {
+      inBlock = true;
+      blockLang = line.slice(3).trim().split(/\s/)[0] || "";
+      blockCode = [];
+      blockStart = i + 1;
+    } else if (inBlock && line.startsWith("```")) {
+      const normalizedLang = normalizeLang(blockLang);
+      if (executableLangs.has(normalizedLang.toLowerCase())) {
+        codeBlocks.push({
+          lang: normalizedLang || "ts",
+          code: blockCode.join(`
+`),
+          lineStart: blockStart,
+          lineEnd: i
+        });
+      }
+      inBlock = false;
+      blockLang = "";
+      blockCode = [];
+    } else if (inBlock) {
+      blockCode.push(line);
+    }
+  }
+  return { path: sourcePath, codeBlocks };
+}
+function normalizeLang(lang) {
+  const aliases = {
+    typescript: "ts",
+    javascript: "js",
+    tsx: "tsx",
+    jsx: "jsx"
+  };
+  return aliases[lang.toLowerCase()] ?? lang;
+}
+function getCacheKey(source) {
+  return `${source.org}/${source.repo}/${source.path ?? "**/*.md"}#${source.branch ?? "HEAD"}`;
+}
+async function fetchGitHubDocs(source, options = {}) {
+  const {
+    timeout = DEFAULT_TIMEOUT2,
+    ttl = DEFAULT_TTL3,
+    useCache = true,
+    cwd = process.cwd()
+  } = options;
+  const cacheKey = getCacheKey(source);
+  if (useCache) {
+    const cached = getFromCache(cwd, "github", cacheKey, ttl);
+    if (cached) {
+      try {
+        const docs = JSON.parse(cached.content);
+        return { source, docs, cached: true };
+      } catch {}
+    }
+  }
+  try {
+    const ref = source.branch ?? "HEAD";
+    const tree = await fetchFileTree(source.org, source.repo, ref, timeout);
+    const allPaths = tree.tree.filter((item) => item.type === "blob").map((item) => item.path);
+    const mdPaths = matchGlob(allPaths, source.path ?? "**/*.md").filter((p) => p.endsWith(".md") || p.endsWith(".mdx"));
+    if (mdPaths.length === 0) {
+      return { source, docs: [] };
+    }
+    const docs = [];
+    const BATCH_SIZE = 5;
+    for (let i = 0;i < mdPaths.length; i += BATCH_SIZE) {
+      const batch = mdPaths.slice(i, i + BATCH_SIZE);
+      const results = await Promise.all(batch.map(async (filePath) => {
+        try {
+          const content = await fetchRawContent(source.org, source.repo, ref, filePath, timeout);
+          const sourcePath = `github:${source.org}/${source.repo}/${filePath}`;
+          return parseMarkdownContent2(content, sourcePath);
+        } catch {
+          return null;
+        }
+      }));
+      for (const doc of results) {
+        if (doc && doc.codeBlocks.length > 0) {
+          docs.push(doc);
+        }
+      }
+    }
+    if (useCache) {
+      writeToCache(cwd, "github", cacheKey, JSON.stringify(docs));
+    }
+    return { source, docs };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { source, docs: [], error: message };
+  }
+}
+async function fetchGitHubDocsBatch(sources, options = {}) {
+  const results = [];
+  for (const source of sources) {
+    results.push(await fetchGitHubDocs(source, options));
+  }
+  return results;
+}
+
+// src/commands/check/parseDocsPattern.ts
+function parseDocsPattern(pattern) {
+  if (/^https?:\/\//i.test(pattern)) {
+    return { type: "url", url: pattern };
+  }
+  if (/^(github|gh):/i.test(pattern)) {
+    return parseGitHubPattern(pattern);
+  }
+  if (/^(gitlab|gl):/i.test(pattern)) {
+    return parseGitLabPattern(pattern);
+  }
+  return { type: "local", pattern };
+}
+function parseGitHubPattern(pattern) {
+  const rest = pattern.replace(/^(github|gh):/i, "");
+  const [pathPart, branch] = rest.split("#");
+  const parts = pathPart.split("/");
+  if (parts.length < 2) {
+    throw new Error(`Invalid GitHub pattern: ${pattern}. Expected format: github:org/repo[/path][#branch]`);
+  }
+  const org = parts[0];
+  const repo = parts[1];
+  const path8 = parts.length > 2 ? parts.slice(2).join("/") : undefined;
+  return {
+    type: "github",
+    org,
+    repo,
+    ...path8 && { path: path8 },
+    ...branch && { branch }
+  };
+}
+function parseGitLabPattern(pattern) {
+  const rest = pattern.replace(/^(gitlab|gl):/i, "");
+  const [pathPart, branch] = rest.split("#");
+  const parts = pathPart.split("/");
+  if (parts.length < 2) {
+    throw new Error(`Invalid GitLab pattern: ${pattern}. Expected format: gitlab:org/repo[/path][#branch]`);
+  }
+  const org = parts[0];
+  const repo = parts[1];
+  const path8 = parts.length > 2 ? parts.slice(2).join("/") : undefined;
+  return {
+    type: "gitlab",
+    org,
+    repo,
+    ...path8 && { path: path8 },
+    ...branch && { branch }
+  };
+}
+function parseDocsPatterns(patterns) {
+  return patterns.map(parseDocsPattern);
+}
+
+// src/commands/check/validation.ts
 async function runExampleValidation(openpkg, options) {
   const { validations, targetDir, timeout = 5000, installTimeout = 60000 } = options;
   const typecheckErrors = [];
@@ -1682,18 +3573,62 @@ async function runExampleValidation(openpkg, options) {
   }
   return { result, typecheckErrors, runtimeDrifts };
 }
+function parseAndSeparateDocsSources(patterns) {
+  const sources = parseDocsPatterns(patterns);
+  const local = [];
+  const remote = [];
+  for (const source of sources) {
+    if (source.type === "local") {
+      local.push(source.pattern);
+    } else {
+      remote.push(source);
+    }
+  }
+  return { local, remote };
+}
 async function validateMarkdownDocs(options) {
-  const { docsPatterns, targetDir, exportNames } = options;
+  const { docsPatterns, targetDir, exportNames, useCache = true, fetchTimeout, cacheTtl } = options;
   const staleRefs = [];
   if (docsPatterns.length === 0) {
     return staleRefs;
   }
-  const markdownFiles = await loadMarkdownFiles(docsPatterns, targetDir);
-  if (markdownFiles.length === 0) {
+  const { local, remote } = parseAndSeparateDocsSources(docsPatterns);
+  const allDocs = [];
+  if (local.length > 0) {
+    const localDocs = await loadMarkdownFiles(local, targetDir);
+    allDocs.push(...localDocs);
+  }
+  const urlSources = remote.filter((s) => s.type === "url");
+  if (urlSources.length > 0) {
+    const results = await fetchUrlDocsBatch(urlSources, {
+      useCache,
+      timeout: fetchTimeout,
+      ttl: cacheTtl,
+      cwd: targetDir
+    });
+    for (const result of results) {
+      if (result.doc) {
+        allDocs.push(result.doc);
+      }
+    }
+  }
+  const githubSources = remote.filter((s) => s.type === "github");
+  if (githubSources.length > 0) {
+    const results = await fetchGitHubDocsBatch(githubSources, {
+      useCache,
+      timeout: fetchTimeout,
+      ttl: cacheTtl,
+      cwd: targetDir
+    });
+    for (const result of results) {
+      allDocs.push(...result.docs);
+    }
+  }
+  if (allDocs.length === 0) {
     return staleRefs;
   }
   const exportSet = new Set(exportNames);
-  for (const mdFile of markdownFiles) {
+  for (const mdFile of allDocs) {
     for (const block of mdFile.codeBlocks) {
       const codeLines = block.code.split(`
 `);
@@ -1885,8 +3820,8 @@ function registerCheckCommand(program, dependencies = {}) {
   });
 }
 // src/commands/diff.ts
-import * as fs4 from "node:fs";
-import * as path6 from "node:path";
+import * as fs5 from "node:fs";
+import * as path8 from "node:path";
 import {
   diffSpecWithDocs,
   ensureSpecCoverage,
@@ -1900,7 +3835,7 @@ import { calculateNextVersion, recommendSemverBump } from "@openpkg-ts/spec";
 import chalk7 from "chalk";
 import { glob as glob2 } from "glob";
 var defaultDependencies2 = {
-  readFileSync: fs4.readFileSync,
+  readFileSync: fs5.readFileSync,
   log: console.log,
   error: console.error
 };
@@ -1919,7 +3854,7 @@ function getStrictChecks(preset) {
   return checks;
 }
 function registerDiffCommand(program, dependencies = {}) {
-  const { readFileSync: readFileSync3, log, error } = {
+  const { readFileSync: readFileSync4, log, error } = {
     ...defaultDependencies2,
     ...dependencies
   };
@@ -1933,18 +3868,18 @@ function registerDiffCommand(program, dependencies = {}) {
 ` + "   or: doccov diff --base main.json --head feature.json");
       }
       const spin = spinner("Comparing specs...");
-      const baseSpec = loadSpec(baseFile, readFileSync3);
-      const headSpec = loadSpec(headFile, readFileSync3);
+      const baseSpec = loadSpec(baseFile, readFileSync4);
+      const headSpec = loadSpec(headFile, readFileSync4);
       const config = await loadDocCovConfig(options.cwd);
       const baseHash = hashString(JSON.stringify(baseSpec));
       const headHash = hashString(JSON.stringify(headSpec));
       const cacheEnabled = options.cache !== false;
-      const cachedReportPath = path6.resolve(options.cwd, getDiffReportPath(baseHash, headHash, "json"));
+      const cachedReportPath = path8.resolve(options.cwd, getDiffReportPath(baseHash, headHash, "json"));
       let diff;
       let fromCache = false;
-      if (cacheEnabled && fs4.existsSync(cachedReportPath)) {
+      if (cacheEnabled && fs5.existsSync(cachedReportPath)) {
         try {
-          const cached = JSON.parse(fs4.readFileSync(cachedReportPath, "utf-8"));
+          const cached = JSON.parse(fs5.readFileSync(cachedReportPath, "utf-8"));
           diff = cached;
           fromCache = true;
         } catch {
@@ -1982,8 +3917,8 @@ function registerDiffCommand(program, dependencies = {}) {
       const format = options.format ?? "text";
       const limit = parseInt(options.limit, 10) || 10;
       const checks = getStrictChecks(options.strict);
-      const baseName = path6.basename(baseFile);
-      const headName = path6.basename(headFile);
+      const baseName = path8.basename(baseFile);
+      const headName = path8.basename(headFile);
       const reportData = {
         baseName,
         headName,
@@ -2088,7 +4023,7 @@ async function loadMarkdownFiles2(patterns) {
     const matches = await glob2(pattern, { nodir: true });
     for (const filePath of matches) {
       try {
-        const content = fs4.readFileSync(filePath, "utf-8");
+        const content = fs5.readFileSync(filePath, "utf-8");
         files.push({ path: filePath, content });
       } catch {}
     }
@@ -2109,13 +4044,13 @@ async function generateDiff(baseSpec, headSpec, options, config, log) {
   }
   return diffSpecWithDocs(baseSpec, headSpec, { markdownFiles });
 }
-function loadSpec(filePath, readFileSync3) {
-  const resolvedPath = path6.resolve(filePath);
-  if (!fs4.existsSync(resolvedPath)) {
+function loadSpec(filePath, readFileSync4) {
+  const resolvedPath = path8.resolve(filePath);
+  if (!fs5.existsSync(resolvedPath)) {
     throw new Error(`File not found: ${filePath}`);
   }
   try {
-    const content = readFileSync3(resolvedPath, "utf-8");
+    const content = readFileSync4(resolvedPath, "utf-8");
     const spec = JSON.parse(content);
     return ensureSpecCoverage(spec);
   } catch (parseError) {
@@ -2235,34 +4170,34 @@ function printGitHubAnnotations(diff, log) {
 }
 
 // src/commands/init.ts
-import * as fs5 from "node:fs";
-import * as path7 from "node:path";
+import * as fs6 from "node:fs";
+import * as path9 from "node:path";
 import chalk8 from "chalk";
 var defaultDependencies3 = {
-  fileExists: fs5.existsSync,
-  writeFileSync: fs5.writeFileSync,
-  readFileSync: fs5.readFileSync,
-  mkdirSync: fs5.mkdirSync,
+  fileExists: fs6.existsSync,
+  writeFileSync: fs6.writeFileSync,
+  readFileSync: fs6.readFileSync,
+  mkdirSync: fs6.mkdirSync,
   log: console.log,
   error: console.error
 };
 function registerInitCommand(program, dependencies = {}) {
-  const { fileExists: fileExists2, writeFileSync: writeFileSync3, readFileSync: readFileSync4, mkdirSync: mkdirSync3, log, error } = {
+  const { fileExists: fileExists2, writeFileSync: writeFileSync4, readFileSync: readFileSync5, mkdirSync: mkdirSync4, log, error } = {
     ...defaultDependencies3,
     ...dependencies
   };
   program.command("init").description("Initialize DocCov: config, GitHub Action, and badge").option("--cwd <dir>", "Working directory", process.cwd()).option("--skip-action", "Skip GitHub Action workflow creation").action((options) => {
-    const cwd = path7.resolve(options.cwd);
+    const cwd = path9.resolve(options.cwd);
     const existing = findExistingConfig(cwd, fileExists2);
     if (existing) {
-      error(chalk8.red(`A DocCov config already exists at ${path7.relative(cwd, existing) || "./doccov.config.*"}.`));
+      error(chalk8.red(`A DocCov config already exists at ${path9.relative(cwd, existing) || "./doccov.config.*"}.`));
       process.exitCode = 1;
       return;
     }
-    const packageType = detectPackageType(cwd, fileExists2, readFileSync4);
+    const packageType = detectPackageType(cwd, fileExists2, readFileSync5);
     const targetFormat = packageType === "module" ? "ts" : "mts";
     const fileName = `doccov.config.${targetFormat}`;
-    const outputPath = path7.join(cwd, fileName);
+    const outputPath = path9.join(cwd, fileName);
     if (fileExists2(outputPath)) {
       error(chalk8.red(`Cannot create ${fileName}; file already exists.`));
       process.exitCode = 1;
@@ -2270,20 +4205,20 @@ function registerInitCommand(program, dependencies = {}) {
     }
     const sym = getSymbols(supportsUnicode());
     const template = buildConfigTemplate();
-    writeFileSync3(outputPath, template, { encoding: "utf8" });
+    writeFileSync4(outputPath, template, { encoding: "utf8" });
     log(colors.success(`${sym.success} Created ${fileName}`));
     if (!options.skipAction) {
-      const workflowDir = path7.join(cwd, ".github", "workflows");
-      const workflowPath = path7.join(workflowDir, "doccov.yml");
+      const workflowDir = path9.join(cwd, ".github", "workflows");
+      const workflowPath = path9.join(workflowDir, "doccov.yml");
       if (!fileExists2(workflowPath)) {
-        mkdirSync3(workflowDir, { recursive: true });
-        writeFileSync3(workflowPath, buildWorkflowTemplate(), { encoding: "utf8" });
+        mkdirSync4(workflowDir, { recursive: true });
+        writeFileSync4(workflowPath, buildWorkflowTemplate(), { encoding: "utf8" });
         log(colors.success(`${sym.success} Created .github/workflows/doccov.yml`));
       } else {
         log(colors.warning(`${sym.bullet} Skipped .github/workflows/doccov.yml (already exists)`));
       }
     }
-    const repoInfo = detectRepoInfo(cwd, fileExists2, readFileSync4);
+    const repoInfo = detectRepoInfo(cwd, fileExists2, readFileSync5);
     log("");
     log(chalk8.bold("Add this badge to your README:"));
     log("");
@@ -2298,11 +4233,11 @@ function registerInitCommand(program, dependencies = {}) {
   });
 }
 var findExistingConfig = (cwd, fileExists2) => {
-  let current = path7.resolve(cwd);
-  const { root } = path7.parse(current);
+  let current = path9.resolve(cwd);
+  const { root } = path9.parse(current);
   while (true) {
     for (const candidate of DOCCOV_CONFIG_FILENAMES) {
-      const candidatePath = path7.join(current, candidate);
+      const candidatePath = path9.join(current, candidate);
       if (fileExists2(candidatePath)) {
         return candidatePath;
       }
@@ -2310,17 +4245,17 @@ var findExistingConfig = (cwd, fileExists2) => {
     if (current === root) {
       break;
     }
-    current = path7.dirname(current);
+    current = path9.dirname(current);
   }
   return null;
 };
-var detectPackageType = (cwd, fileExists2, readFileSync4) => {
+var detectPackageType = (cwd, fileExists2, readFileSync5) => {
   const packageJsonPath = findNearestPackageJson(cwd, fileExists2);
   if (!packageJsonPath) {
     return;
   }
   try {
-    const raw = readFileSync4(packageJsonPath, "utf8");
+    const raw = readFileSync5(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.type === "module") {
       return "module";
@@ -2332,17 +4267,17 @@ var detectPackageType = (cwd, fileExists2, readFileSync4) => {
   return;
 };
 var findNearestPackageJson = (cwd, fileExists2) => {
-  let current = path7.resolve(cwd);
-  const { root } = path7.parse(current);
+  let current = path9.resolve(cwd);
+  const { root } = path9.parse(current);
   while (true) {
-    const candidate = path7.join(current, "package.json");
+    const candidate = path9.join(current, "package.json");
     if (fileExists2(candidate)) {
       return candidate;
     }
     if (current === root) {
       break;
     }
-    current = path7.dirname(current);
+    current = path9.dirname(current);
   }
   return null;
 };
@@ -2384,11 +4319,11 @@ jobs:
           comment-on-pr: true
 `;
 };
-var detectRepoInfo = (cwd, fileExists2, readFileSync4) => {
+var detectRepoInfo = (cwd, fileExists2, readFileSync5) => {
   const packageJsonPath = findNearestPackageJson(cwd, fileExists2);
   if (packageJsonPath) {
     try {
-      const raw = readFileSync4(packageJsonPath, "utf8");
+      const raw = readFileSync5(packageJsonPath, "utf8");
       const parsed = JSON.parse(raw);
       let repoUrl;
       if (typeof parsed.repository === "string") {
@@ -2397,20 +4332,20 @@ var detectRepoInfo = (cwd, fileExists2, readFileSync4) => {
         repoUrl = parsed.repository.url;
       }
       if (repoUrl) {
-        const match = repoUrl.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
-        if (match) {
-          return { owner: match[1], repo: match[2] };
+        const match2 = repoUrl.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+        if (match2) {
+          return { owner: match2[1], repo: match2[2] };
         }
       }
     } catch {}
   }
-  const gitConfigPath = path7.join(cwd, ".git", "config");
+  const gitConfigPath = path9.join(cwd, ".git", "config");
   if (fileExists2(gitConfigPath)) {
     try {
-      const config = readFileSync4(gitConfigPath, "utf8");
-      const match = config.match(/url\s*=\s*.*github\.com[/:]([^/]+)\/([^/.]+)/);
-      if (match) {
-        return { owner: match[1], repo: match[2].replace(/\.git$/, "") };
+      const config = readFileSync5(gitConfigPath, "utf8");
+      const match2 = config.match(/url\s*=\s*.*github\.com[/:]([^/]+)\/([^/.]+)/);
+      if (match2) {
+        return { owner: match2[1], repo: match2[2].replace(/\.git$/, "") };
       }
     } catch {}
   }
@@ -2418,8 +4353,8 @@ var detectRepoInfo = (cwd, fileExists2, readFileSync4) => {
 };
 
 // src/commands/spec.ts
-import * as fs6 from "node:fs";
-import * as path8 from "node:path";
+import * as fs7 from "node:fs";
+import * as path10 from "node:path";
 import {
   buildDocCovSpec as buildDocCovSpec2,
   DocCov as DocCov2,
@@ -2436,7 +4371,7 @@ import {
 import chalk9 from "chalk";
 var defaultDependencies4 = {
   createDocCov: (options) => new DocCov2(options),
-  writeFileSync: fs6.writeFileSync,
+  writeFileSync: fs7.writeFileSync,
   log: console.log,
   error: console.error
 };
@@ -2445,13 +4380,13 @@ function getArrayLength(value) {
 }
 function formatDiagnosticOutput(prefix2, diagnostic, baseDir) {
   const location = diagnostic.location;
-  const relativePath = location?.file ? path8.relative(baseDir, location.file) || location.file : undefined;
+  const relativePath = location?.file ? path10.relative(baseDir, location.file) || location.file : undefined;
   const locationText = location && relativePath ? chalk9.gray(`${relativePath}:${location.line ?? 1}:${location.column ?? 1}`) : null;
   const locationPrefix = locationText ? `${locationText} ` : "";
   return `${prefix2} ${locationPrefix}${diagnostic.message}`;
 }
 function registerSpecCommand(program, dependencies = {}) {
-  const { createDocCov, writeFileSync: writeFileSync4, log, error } = {
+  const { createDocCov, writeFileSync: writeFileSync5, log, error } = {
     ...defaultDependencies4,
     ...dependencies
   };
@@ -2528,24 +4463,38 @@ function registerSpecCommand(program, dependencies = {}) {
         }
       }
       const format = options.format ?? "json";
-      const outputDir = path8.resolve(options.cwd, options.output);
-      fs6.mkdirSync(outputDir, { recursive: true });
+      let packageName;
+      if (resolved.packageInfo) {
+        packageName = resolved.packageInfo.name;
+      } else {
+        const pkgJsonPath = path10.join(targetDir, "package.json");
+        try {
+          const pkgJson = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf-8"));
+          packageName = pkgJson.name ?? "unknown";
+        } catch {
+          packageName = "unknown";
+        }
+      }
+      const baseOutputDir = path10.resolve(options.cwd, options.output);
+      const outputDir = path10.join(baseOutputDir, packageName);
+      fs7.mkdirSync(outputDir, { recursive: true });
+      const displayPath = `${options.output}/${packageName}`;
       if (format === "api-surface") {
         const apiSurface = renderApiSurface(normalized);
-        const apiSurfacePath = path8.join(outputDir, "api-surface.txt");
-        writeFileSync4(apiSurfacePath, apiSurface);
-        spin.success(`Generated ${options.output}/ (API surface)`);
+        const apiSurfacePath = path10.join(outputDir, "api-surface.txt");
+        writeFileSync5(apiSurfacePath, apiSurface);
+        spin.success(`Generated ${displayPath}/ (API surface)`);
       } else {
-        const openpkgPath = path8.join(outputDir, "openpkg.json");
-        writeFileSync4(openpkgPath, JSON.stringify(normalized, null, 2));
+        const openpkgPath = path10.join(outputDir, "openpkg.json");
+        writeFileSync5(openpkgPath, JSON.stringify(normalized, null, 2));
         if (doccovSpec) {
-          const doccovPath = path8.join(outputDir, "doccov.json");
-          writeFileSync4(doccovPath, JSON.stringify(doccovSpec, null, 2));
-          spin.success(`Generated ${options.output}/`);
+          const doccovPath = path10.join(outputDir, "doccov.json");
+          writeFileSync5(doccovPath, JSON.stringify(doccovSpec, null, 2));
+          spin.success(`Generated ${displayPath}/`);
           log(chalk9.gray(`  openpkg.json: ${getArrayLength(normalized.exports)} exports`));
           log(chalk9.gray(`  doccov.json:  ${doccovSpec.summary.score}% coverage, ${doccovSpec.summary.drift.total} drift issues`));
         } else {
-          spin.success(`Generated ${options.output}/openpkg.json`);
+          spin.success(`Generated ${displayPath}/openpkg.json`);
           log(chalk9.gray(`  ${getArrayLength(normalized.exports)} exports`));
           log(chalk9.gray(`  ${getArrayLength(normalized.types)} types`));
         }
@@ -2621,8 +4570,8 @@ function registerSpecCommand(program, dependencies = {}) {
 }
 
 // src/commands/trends.ts
-import * as fs7 from "node:fs";
-import * as path9 from "node:path";
+import * as fs8 from "node:fs";
+import * as path11 from "node:path";
 import {
   formatDelta as formatDelta2,
   getExtendedTrend,
@@ -2672,7 +4621,7 @@ function formatVelocity(velocity) {
 }
 function registerTrendsCommand(program) {
   program.command("trends").description("Show coverage trends over time").option("--cwd <dir>", "Working directory", process.cwd()).option("-n, --limit <count>", "Number of snapshots to show", "10").option("--prune <count>", "Prune history to keep only N snapshots").option("--record", "Record current coverage to history").option("--json", "Output as JSON").option("--extended", "Show extended trend analysis (velocity, projections)").option("--weekly", "Show weekly summary breakdown").action(async (options) => {
-    const cwd = path9.resolve(options.cwd);
+    const cwd = path11.resolve(options.cwd);
     if (options.prune) {
       const keepCount = parseInt(options.prune, 10);
       if (!Number.isNaN(keepCount)) {
@@ -2682,14 +4631,14 @@ function registerTrendsCommand(program) {
       return;
     }
     if (options.record) {
-      const specPath = path9.resolve(cwd, "openpkg.json");
-      if (!fs7.existsSync(specPath)) {
+      const specPath = path11.resolve(cwd, "openpkg.json");
+      if (!fs8.existsSync(specPath)) {
         console.error(chalk10.red("No openpkg.json found. Run `doccov spec` first to generate a spec."));
         process.exit(1);
       }
       const spin = spinner("Recording coverage snapshot");
       try {
-        const specContent = fs7.readFileSync(specPath, "utf-8");
+        const specContent = fs8.readFileSync(specPath, "utf-8");
         const spec = JSON.parse(specContent);
         const trend = getTrend(spec, cwd);
         saveSnapshot(trend.current, cwd);
@@ -2740,10 +4689,10 @@ function registerTrendsCommand(program) {
       console.log("");
     }
     if (options.extended) {
-      const specPath = path9.resolve(cwd, "openpkg.json");
-      if (fs7.existsSync(specPath)) {
+      const specPath = path11.resolve(cwd, "openpkg.json");
+      if (fs8.existsSync(specPath)) {
         try {
-          const specContent = fs7.readFileSync(specPath, "utf-8");
+          const specContent = fs8.readFileSync(specPath, "utf-8");
           const spec = JSON.parse(specContent);
           const extended = getExtendedTrend(spec, cwd);
           console.log(chalk10.bold("Extended Analysis"));
@@ -2801,8 +4750,8 @@ function registerTrendsCommand(program) {
 
 // src/cli.ts
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path10.dirname(__filename2);
-var packageJson = JSON.parse(readFileSync5(path10.join(__dirname2, "../package.json"), "utf-8"));
+var __dirname2 = path12.dirname(__filename2);
+var packageJson = JSON.parse(readFileSync7(path12.join(__dirname2, "../package.json"), "utf-8"));
 var program = new Command;
 program.name("doccov").description("DocCov - Documentation coverage and drift detection for TypeScript").version(packageJson.version);
 registerCheckCommand(program);