vigiles 2.0.0 → 2.1.1

package/dist/compile.js

@@ -10,13 +10,14 @@ exports.computeHash = computeHash;
 exports.addHash = addHash;
 exports.verifyHash = verifyHash;
 exports.estimateTokens = estimateTokens;
+exports.readPackageScripts = readPackageScripts;
 exports.compileClaude = compileClaude;
 exports.compileSkill = compileSkill;
 exports.checkFileHash = checkFileHash;
 exports.adoptDiff = adoptDiff;
-const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const hash_js_1 = require("./hash.js");
 const linters_js_1 = require("./linters.js");
 // ---------------------------------------------------------------------------
 // Hash utilities
@@ -25,7 +26,7 @@ const HASH_RE = /^<!-- vigiles:sha256:([a-f0-9]+) compiled from (.+) -->\r?\n\r?
 /** @internal Compute SHA-256 hash of content (excluding any existing hash line). */
 function computeHash(content) {
     const body = content.replace(HASH_RE, "");
-    return (0, node_crypto_1.createHash)("sha256").update(body).digest("hex").slice(0, 16);
+    return (0, hash_js_1.sha256short)(body);
 }
 /** @internal Prepend a hash comment to compiled content. */
 function addHash(content, specFile) {
@@ -40,10 +41,7 @@ function verifyHash(content) {
     const expectedHash = match[1];
     const specFile = match[2];
     const body = content.replace(HASH_RE, "");
-    const actualHash = (0, node_crypto_1.createHash)("sha256")
-        .update(body)
-        .digest("hex")
-        .slice(0, 16);
+    const actualHash = (0, hash_js_1.sha256short)(body);
     return { valid: actualHash === expectedHash, specFile };
 }
 // ---------------------------------------------------------------------------
@@ -141,14 +139,15 @@ function validateRefs(fragments, basePath) {
 function renderFragment(fragment) {
     if (typeof fragment === "string")
         return fragment;
-    const r = fragment;
-    switch (r._ref) {
+    switch (fragment._ref) {
         case "file":
-            return `\`${r.path}\``;
+            return `\`${fragment.path}\``;
         case "cmd":
-            return `\`${r.command}\``;
+            return `\`${fragment.command}\``;
         case "skill":
-            return `[${(0, node_path_1.basename)((0, node_path_1.dirname)(r.path))}](${r.path})`;
+            return `[${(0, node_path_1.basename)((0, node_path_1.dirname)(fragment.path))}](${fragment.path})`;
+        default:
+            return (0, hash_js_1.assertNever)(fragment);
     }
 }
 // ---------------------------------------------------------------------------
@@ -168,15 +167,19 @@ function compileRule(id, rule) {
             ].join("\n");
         case "guidance":
             return [`### ${title}`, "", `**Guidance only** — ${rule.text}`].join("\n");
-        default: {
-            // Unknown rule kind — legacy compiled JS spec artifacts, JS caller,
-            // or cast bypass. Fail loudly rather than silently dropping the
-            // rule from output, which would remove constraints without any
-            // compile error.
-            const unknown = rule._kind;
-            throw new Error(`Unknown rule kind "${String(unknown)}" for rule "${id}". ` +
-                `Expected "enforce" or "guidance". Runtime data is out of sync with the Rule type.`);
+        case "guard": {
+            const patterns = Array.isArray(rule.watch)
+                ? rule.watch.join("`, `")
+                : rule.watch;
+            return [
+                `### ${title}`,
+                "",
+                `**Guard:** \`${patterns}\` → \`${rule.run}\``,
+                `**Why:** ${rule.description}`,
+            ].join("\n");
         }
+        default:
+            return (0, hash_js_1.assertNever)(rule);
     }
 }
 function validateSectionContent(name, text, maxSectionLines) {

package/dist/coverage.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Spec coverage analysis: how much of the project surface is documented in specs.
+ *
+ * Two metrics:
+ * - Linter rule coverage: % of enabled linter rules with enforce() declarations
+ * - Script coverage: % of npm scripts documented in spec commands
+ *
+ * Configurable thresholds in .vigilesrc.json trigger warnings or errors when
+ * coverage drops below the minimum.
+ */
+import type { CoverageThresholds } from "./types.js";
+import type { ClaudeSpec } from "./spec.js";
+export interface CoverageMetric {
+    name: string;
+    total: number;
+    covered: number;
+    percent: number;
+    threshold: number | undefined;
+    passing: boolean;
+    /** Items that ARE covered. */
+    coveredItems: string[];
+    /** Items that are NOT covered. */
+    uncoveredItems: string[];
+}
+export interface CoverageReport {
+    metrics: CoverageMetric[];
+    passing: boolean;
+}
+/**
+ * Read npm script names from package.json. Reuses readPackageScripts
+ * from compile.ts and returns sorted keys.
+ */
+export declare function readNpmScripts(basePath: string): string[];
+/**
+ * Collect commands documented in specs by loading spec source files directly.
+ * Reads the structured `commands` field — no markdown parsing.
+ */
+export declare function collectDocumentedCommands(basePath: string, specs?: ClaudeSpec[]): Set<string>;
+/**
+ * Compute script coverage: what % of npm scripts are documented in specs.
+ */
+export declare function computeScriptCoverage(basePath: string, threshold?: number, specs?: ClaudeSpec[]): CoverageMetric;
+/**
+ * Compute linter rule coverage from pre-computed totals.
+ * The actual linter scanning is done by the existing discover() in cli.ts.
+ */
+export declare function computeLinterRuleCoverage(enabled: number, documented: number, threshold?: number): CoverageMetric;
+/**
+ * Check all coverage metrics against thresholds.
+ */
+export declare function checkCoverage(basePath: string, thresholds: CoverageThresholds, linterEnabled: number, linterDocumented: number, specs?: ClaudeSpec[]): CoverageReport;
+/**
+ * Format coverage report as human-readable text.
+ */
+export declare function formatCoverageReport(report: CoverageReport): string;
+//# sourceMappingURL=coverage.d.ts.map

package/dist/coverage.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * Spec coverage analysis: how much of the project surface is documented in specs.
+ *
+ * Two metrics:
+ * - Linter rule coverage: % of enabled linter rules with enforce() declarations
+ * - Script coverage: % of npm scripts documented in spec commands
+ *
+ * Configurable thresholds in .vigilesrc.json trigger warnings or errors when
+ * coverage drops below the minimum.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readNpmScripts = readNpmScripts;
+exports.collectDocumentedCommands = collectDocumentedCommands;
+exports.computeScriptCoverage = computeScriptCoverage;
+exports.computeLinterRuleCoverage = computeLinterRuleCoverage;
+exports.checkCoverage = checkCoverage;
+exports.formatCoverageReport = formatCoverageReport;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const glob_1 = require("glob");
+const compile_js_1 = require("./compile.js");
+// ---------------------------------------------------------------------------
+// Script coverage
+// ---------------------------------------------------------------------------
+/**
+ * Read npm script names from package.json. Reuses readPackageScripts
+ * from compile.ts and returns sorted keys.
+ */
+function readNpmScripts(basePath) {
+    const scripts = (0, compile_js_1.readPackageScripts)(basePath);
+    return scripts ? Object.keys(scripts).sort() : [];
+}
+/**
+ * Collect commands documented in specs by loading spec source files directly.
+ * Reads the structured `commands` field — no markdown parsing.
+ */
+function collectDocumentedCommands(basePath, specs) {
+    const commands = new Set();
+    if (specs) {
+        for (const spec of specs) {
+            if (spec.commands) {
+                for (const cmd of Object.keys(spec.commands))
+                    commands.add(cmd);
+            }
+        }
+        return commands;
+    }
+    // Fallback: scan compiled markdown for spec file references, then
+    // load the compiled JS spec from dist/. If that fails, try to
+    // extract commands from the compiled output (last resort).
+    const mdFiles = (0, glob_1.globSync)("**/*.md", {
+        ignore: ["node_modules/**", "dist/**", ".vigiles/**"],
+        cwd: basePath,
+    });
+    for (const mdFile of mdFiles) {
+        const fullPath = (0, node_path_1.resolve)(basePath, mdFile);
+        try {
+            const content = (0, node_fs_1.readFileSync)(fullPath, "utf-8");
+            const specMatch = content.match(/^<!-- vigiles:sha256:[a-f0-9]+ compiled from (.+) -->/);
+            if (!specMatch)
+                continue;
+            // Try to load the spec's compiled JS from dist/
+            const specFile = specMatch[1];
+            const jsPath = (0, node_path_1.resolve)(basePath, "dist", specFile.replace(/\.ts$/, ".js"));
+            if ((0, node_fs_1.existsSync)(jsPath)) {
+                try {
+                    const mod = require(jsPath);
+                    const spec = mod.default && "default" in mod.default
+                        ? mod.default.default
+                        : mod.default;
+                    if (spec?.commands) {
+                        for (const cmd of Object.keys(spec.commands))
+                            commands.add(cmd);
+                    }
+                    continue;
+                }
+                catch {
+                    // Fall through to next file
+                }
+            }
+        }
+        catch {
+            // Skip unreadable files
+        }
+    }
+    return commands;
+}
+/**
+ * Compute script coverage: what % of npm scripts are documented in specs.
+ */
+function computeScriptCoverage(basePath, threshold, specs) {
+    const allScripts = readNpmScripts(basePath);
+    const documented = collectDocumentedCommands(basePath, specs);
+    const covered = [];
+    const uncovered = [];
+    for (const script of allScripts) {
+        // Match the same forms compile-time validation accepts in cmd():
+        // "npm run <script>" or "npm <script>". Bare script names are not
+        // executable refs — accepting them here would let stale entries
+        // satisfy the coverage threshold without being verifiable.
+        const npmRun = `npm run ${script}`;
+        const npmDirect = `npm ${script}`;
+        if (documented.has(npmRun) || documented.has(npmDirect)) {
+            covered.push(script);
+        }
+        else {
+            uncovered.push(script);
+        }
+    }
+    const total = allScripts.length;
+    const percent = total > 0 ? Math.round((covered.length / total) * 100) : 100;
+    const passing = threshold === undefined || percent >= threshold;
+    return {
+        name: "scripts",
+        total,
+        covered: covered.length,
+        percent,
+        threshold,
+        passing,
+        coveredItems: covered,
+        uncoveredItems: uncovered,
+    };
+}
+/**
+ * Compute linter rule coverage from pre-computed totals.
+ * The actual linter scanning is done by the existing discover() in cli.ts.
+ */
+function computeLinterRuleCoverage(enabled, documented, threshold) {
+    const percent = enabled > 0 ? Math.round((documented / enabled) * 100) : 100;
+    const passing = threshold === undefined || percent >= threshold;
+    return {
+        name: "linterRules",
+        total: enabled,
+        covered: documented,
+        percent,
+        threshold,
+        passing,
+        coveredItems: [],
+        uncoveredItems: [],
+    };
+}
+/**
+ * Check all coverage metrics against thresholds.
+ */
+function checkCoverage(basePath, thresholds, linterEnabled, linterDocumented, specs) {
+    const metrics = [];
+    // Linter rule coverage
+    const linterMetric = computeLinterRuleCoverage(linterEnabled, linterDocumented, thresholds.linterRules);
+    metrics.push(linterMetric);
+    // Script coverage
+    const scriptMetric = computeScriptCoverage(basePath, thresholds.scripts, specs);
+    metrics.push(scriptMetric);
+    const passing = metrics.every((m) => m.passing);
+    return { metrics, passing };
+}
+/**
+ * Format coverage report as human-readable text.
+ */
+function formatCoverageReport(report) {
+    const lines = [];
+    for (const m of report.metrics) {
+        const status = m.threshold !== undefined ? (m.passing ? "✓" : "✗") : " ";
+        const thresholdStr = m.threshold !== undefined ? ` (threshold: ${String(m.threshold)}%)` : "";
+        lines.push(`  ${status} ${m.name}: ${String(m.covered)}/${String(m.total)} (${String(m.percent)}%)${thresholdStr}`);
+        if (!m.passing && m.uncoveredItems.length > 0) {
+            const show = m.uncoveredItems.slice(0, 5);
+            for (const item of show) {
+                lines.push(`      missing: ${item}`);
+            }
+            if (m.uncoveredItems.length > 5) {
+                lines.push(`      ... and ${String(m.uncoveredItems.length - 5)} more`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=coverage.js.map

package/dist/doc-refs.d.ts

@@ -0,0 +1,60 @@
+/**
+ * vigiles — Validate vigiles-builder calls in markdown code blocks.
+ *
+ * Mirror of inline mode but inverted: inline mode skips fenced code blocks
+ * (so `<!-- vigiles:enforce -->` in prose doesn't accidentally match an
+ * example). This module enters fenced code blocks (ts/typescript/js/
+ * javascript) and validates the vigiles builder calls inside —
+ * `enforce("...")`, `file("...")`, `cmd("...")`, `ref("...")` — using the
+ * same engines that validate them in spec.ts.
+ *
+ * Default: validate every ref. Illustrative blocks opt out via
+ * `<!-- vigiles:ignore -->` immediately before the fence. Whole files
+ * opt out via `<!-- vigiles:ignore-file -->` anywhere in the file
+ * (intended for research/design docs that quote hypothetical refs).
+ *
+ * Scope: ONLY vigiles builder calls. Generic TS syntax / type checking
+ * in markdown is explicitly out of scope — use eslint-plugin-markdown or
+ * twoslash for that.
+ */
+export type DocRefKind = "enforce" | "file" | "cmd" | "ref";
+export interface DocRef {
+    readonly file: string;
+    readonly line: number;
+    readonly kind: DocRefKind;
+    readonly value: string;
+}
+export interface DocRefError extends DocRef {
+    readonly message: string;
+}
+export interface DocRefReport {
+    readonly filesScanned: number;
+    readonly filesIgnored: number;
+    readonly blocksIgnored: number;
+    readonly refs: readonly DocRef[];
+    readonly errors: readonly DocRefError[];
+    /** Refs that couldn't be verified because the underlying tool isn't available in this env. */
+    readonly unverified: number;
+    /** Refs that contained placeholder syntax (e.g. <linter>/<rule>) and were skipped. */
+    readonly placeholders: number;
+}
+export interface FindDocRefsOptions {
+    readonly basePath?: string;
+    readonly ignore?: readonly string[];
+}
+interface ExtractResult {
+    refs: DocRef[];
+    blocksIgnored: number;
+}
+/** @internal */ export declare function extractDocRefs(content: string, file: string): ExtractResult;
+/**
+ * Walk every `.md` under `basePath`, extract vigiles builder calls from
+ * fenced TS/JS code blocks, validate against the same engines used for
+ * spec.ts. Honors `<!-- vigiles:ignore-file -->` (skip the whole file)
+ * and `<!-- vigiles:ignore -->` (skip the next code block).
+ */
+export declare function findDocRefs(options?: FindDocRefsOptions): DocRefReport;
+/** Format a DocRefReport as human-readable text. */
+export declare function formatDocRefReport(report: DocRefReport): string;
+export {};
+//# sourceMappingURL=doc-refs.d.ts.map

package/dist/doc-refs.js

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * vigiles — Validate vigiles-builder calls in markdown code blocks.
+ *
+ * Mirror of inline mode but inverted: inline mode skips fenced code blocks
+ * (so `<!-- vigiles:enforce -->` in prose doesn't accidentally match an
+ * example). This module enters fenced code blocks (ts/typescript/js/
+ * javascript) and validates the vigiles builder calls inside —
+ * `enforce("...")`, `file("...")`, `cmd("...")`, `ref("...")` — using the
+ * same engines that validate them in spec.ts.
+ *
+ * Default: validate every ref. Illustrative blocks opt out via
+ * `<!-- vigiles:ignore -->` immediately before the fence. Whole files
+ * opt out via `<!-- vigiles:ignore-file -->` anywhere in the file
+ * (intended for research/design docs that quote hypothetical refs).
+ *
+ * Scope: ONLY vigiles builder calls. Generic TS syntax / type checking
+ * in markdown is explicitly out of scope — use eslint-plugin-markdown or
+ * twoslash for that.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDocRefs = extractDocRefs;
+exports.findDocRefs = findDocRefs;
+exports.formatDocRefReport = formatDocRefReport;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const glob_1 = require("glob");
+const linters_js_1 = require("./linters.js");
+const compile_js_1 = require("./compile.js");
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const DEFAULT_IGNORE = [
+    "node_modules/**",
+    "dist/**",
+    ".vigiles/**",
+    ".git/**",
+];
+const FENCE_RE = /^(\s{0,3})(`{3,}|~{3,})(.*)$/;
+const TS_LANGS = new Set(["ts", "typescript", "js", "javascript"]);
+// Ignore markers must appear as standalone lines (whole line is the
+// comment, modulo whitespace) so an inline-code mention like
+// `` `<!-- vigiles:ignore-file -->` `` in prose documenting the syntax
+// doesn't accidentally disable validation.
+const IGNORE_BLOCK_RE = /^\s{0,3}<!--\s*vigiles:ignore\s*-->\s*$/;
+const IGNORE_FILE_RE = /^\s{0,3}<!--\s*vigiles:ignore-file\s*-->\s*$/m;
+const CALL_RE = /\b(enforce|file|cmd|ref)\(\s*["']([^"'\n]+)["']/g;
+const PLACEHOLDER_RE = /[<>]/;
+/**
+ * Error-message patterns that mean "tool not available in this env" rather
+ * than "ref is actually broken." We can't decide between valid and invalid
+ * when the underlying linter or CLI isn't installed, so count these
+ * separately from real errors.
+ */
+const UNVERIFIABLE_PATTERNS = [
+    /Unknown linter:/i,
+    /not found on PATH/i,
+    /No Cedar policies found/i,
+];
+/** @internal */ function extractDocRefs(content, file) {
+    const lines = content.split("\n");
+    const refs = [];
+    let blocksIgnored = 0;
+    let fenceChar = null;
+    let fenceLen = 0;
+    let fenceLang = "";
+    let blockLines = [];
+    let nextBlockIgnored = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const fm = FENCE_RE.exec(line);
+        if (fm) {
+            const marker = fm[2];
+            const ch = marker[0];
+            const len = marker.length;
+            const info = fm[3].trim();
+            if (fenceChar === null) {
+                fenceChar = ch;
+                fenceLen = len;
+                fenceLang = info.split(/\s+/)[0].toLowerCase();
+                blockLines = [];
+                continue;
+            }
+            else if (ch === fenceChar && len >= fenceLen && info === "") {
+                // Closing fence
+                if (TS_LANGS.has(fenceLang)) {
+                    if (nextBlockIgnored) {
+                        blocksIgnored++;
+                    }
+                    else {
+                        for (const { lineNo, text } of blockLines) {
+                            for (const m of text.matchAll(CALL_RE)) {
+                                refs.push({
+                                    file,
+                                    line: lineNo,
+                                    kind: m[1],
+                                    value: m[2],
+                                });
+                            }
+                        }
+                    }
+                }
+                fenceChar = null;
+                fenceLen = 0;
+                fenceLang = "";
+                nextBlockIgnored = false;
+                blockLines = [];
+                continue;
+            }
+        }
+        if (fenceChar !== null) {
+            blockLines.push({ lineNo: i + 1, text: line });
+            continue;
+        }
+        if (IGNORE_BLOCK_RE.test(line)) {
+            nextBlockIgnored = true;
+        }
+    }
+    return { refs, blocksIgnored };
+}
+function isUnverifiable(message) {
+    return UNVERIFIABLE_PATTERNS.some((p) => p.test(message));
+}
+function validateRefs(refs, basePath) {
+    const errors = [];
+    let unverified = 0;
+    let placeholders = 0;
+    const scripts = (0, compile_js_1.readPackageScripts)(basePath) ?? {};
+    for (const r of refs) {
+        // Skip obvious placeholders like enforce("<linter>/<rule>") that
+        // appear in skill format documentation. They aren't typos — they're
+        // syntax templates. Real refs don't contain < or >.
+        if (PLACEHOLDER_RE.test(r.value)) {
+            placeholders++;
+            continue;
+        }
+        switch (r.kind) {
+            case "enforce": {
+                const result = (0, linters_js_1.checkLinterRule)(r.value, basePath, {
+                    catalogOnly: true,
+                });
+                if (!result.exists) {
+                    const msg = result.error ?? `Rule "${r.value}" not found`;
+                    if (isUnverifiable(msg)) {
+                        unverified++;
+                    }
+                    else {
+                        errors.push({ ...r, message: msg });
+                    }
+                }
+                break;
+            }
+            case "file":
+            case "ref": {
+                if (!(0, node_fs_1.existsSync)((0, node_path_1.resolve)(basePath, r.value))) {
+                    errors.push({ ...r, message: `File not found: "${r.value}"` });
+                }
+                break;
+            }
+            case "cmd": {
+                const npmRun = r.value.match(/^npm\s+run\s+(\S+)/);
+                const npmDirect = r.value.match(/^npm\s+(test|start|build|pretest)\b/);
+                const scriptName = npmRun?.[1] ?? npmDirect?.[1];
+                if (scriptName && !scripts[scriptName]) {
+                    errors.push({
+                        ...r,
+                        message: `Script "${scriptName}" not found in package.json`,
+                    });
+                }
+                break;
+            }
+        }
+    }
+    return { errors, unverified, placeholders };
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Walk every `.md` under `basePath`, extract vigiles builder calls from
+ * fenced TS/JS code blocks, validate against the same engines used for
+ * spec.ts. Honors `<!-- vigiles:ignore-file -->` (skip the whole file)
+ * and `<!-- vigiles:ignore -->` (skip the next code block).
+ */
+function findDocRefs(options = {}) {
+    const basePath = options.basePath ?? process.cwd();
+    const ignore = [...DEFAULT_IGNORE, ...(options.ignore ?? [])];
+    const files = (0, glob_1.globSync)("**/*.md", { cwd: basePath, ignore });
+    const allRefs = [];
+    let filesIgnored = 0;
+    let blocksIgnored = 0;
+    for (const f of files) {
+        let content;
+        try {
+            content = (0, node_fs_1.readFileSync)((0, node_path_1.resolve)(basePath, f), "utf-8");
+        }
+        catch {
+            continue;
+        }
+        if (IGNORE_FILE_RE.test(content)) {
+            filesIgnored++;
+            continue;
+        }
+        const r = extractDocRefs(content, f);
+        allRefs.push(...r.refs);
+        blocksIgnored += r.blocksIgnored;
+    }
+    const outcome = validateRefs(allRefs, basePath);
+    return {
+        filesScanned: files.length,
+        filesIgnored,
+        blocksIgnored,
+        refs: allRefs,
+        errors: outcome.errors,
+        unverified: outcome.unverified,
+        placeholders: outcome.placeholders,
+    };
+}
+/** Format a DocRefReport as human-readable text. */
+function formatDocRefReport(report) {
+    const lines = [];
+    const meta = [];
+    if (report.filesIgnored > 0)
+        meta.push(`${String(report.filesIgnored)} via vigiles:ignore-file`);
+    if (report.blocksIgnored > 0)
+        meta.push(`${String(report.blocksIgnored)} blocks via vigiles:ignore`);
+    if (report.placeholders > 0)
+        meta.push(`${String(report.placeholders)} placeholders skipped`);
+    if (report.unverified > 0)
+        meta.push(`${String(report.unverified)} unverified (tool unavailable)`);
+    const metaStr = meta.length > 0 ? ` (${meta.join(", ")})` : "";
+    lines.push(`scanned ${String(report.filesScanned)} files${metaStr}`);
+    lines.push(`${String(report.refs.length)} vigiles refs in code blocks${report.errors.length === 0 ? " — all valid" : ""}`);
+    if (report.errors.length === 0)
+        return lines.join("\n");
+    lines.push(`✗ ${String(report.errors.length)} broken ref(s):`);
+    for (const e of report.errors.slice(0, 12)) {
+        const trunc = e.message.length > 80 ? `${e.message.slice(0, 80)}…` : e.message;
+        lines.push(`    ${e.file}:${String(e.line)} ${e.kind}("${e.value}") — ${trunc}`);
+    }
+    if (report.errors.length > 12) {
+        lines.push(`    ... +${String(report.errors.length - 12)} more`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=doc-refs.js.map