vigiles 2.0.0 → 2.2.0

package/dist/evolve.js

@@ -13,6 +13,7 @@ exports.applyMutation = applyMutation;
 exports.runProofSuite = runProofSuite;
 const proofs_js_1 = require("./proofs.js");
 const compile_js_1 = require("./compile.js");
+const hash_js_1 = require("./hash.js");
 /**
  * Shallow-clone a Rule. Rules are simple value types (primitive fields only),
  * so a spread is sufficient to decouple engine state from the caller's
@@ -119,7 +120,7 @@ function applyMutation(rules, mutation) {
                     rules,
                     error: {
                         mutation,
-                        reason: `Rule "${mutation.ruleId}" is already at maximum strength (enforce)`,
+                        reason: `Rule "${mutation.ruleId}" is already at maximum strength (${rule._kind})`,
                     },
                 };
             }
@@ -142,6 +143,12 @@ function applyMutation(rules, mutation) {
                     text: rule.why,
                 };
             }
+            else if (rule._kind === "guard") {
+                next[mutation.ruleId] = {
+                    _kind: "guidance",
+                    text: rule.description,
+                };
+            }
             else {
                 return {
                     rules,
@@ -230,8 +237,13 @@ function applyMutation(rules, mutation) {
             else if (rule._kind === "enforce") {
                 next[mutation.ruleId] = { ...rule, why: mutation.newText };
             }
+            else if (rule._kind === "guard") {
+                next[mutation.ruleId] = { ...rule, description: mutation.newText };
+            }
             return { rules: next };
         }
+        default:
+            return (0, hash_js_1.assertNever)(mutation);
     }
 }
 /**
@@ -258,107 +270,61 @@ function runProofSuite(before, after, options = {}) {
     });
     // 2. NCD deduplication. Only fail on pairs NEWLY INTRODUCED by the
     // candidate change — a repo with historical duplication must not
-    // block every unrelated mutation. Compute similar pairs on `after`
-    // and `before`, then subtract.
-    //
-    // Wrapped in try/catch so an unknown rule kind (legacy data / JS
-    // caller) surfaces as a clean proof failure rather than crashing
-    // the whole audit pipeline.
-    try {
-        const beforePairs = new Set((0, proofs_js_1.findSimilarRules)(before, ncdThreshold).map((p) => [p.idA, p.idB].sort().join("|")));
-        const similar = (0, proofs_js_1.findSimilarRules)(after, ncdThreshold).filter((p) => !beforePairs.has([p.idA, p.idB].sort().join("|")));
-        const ncdPassed = similar.length === 0;
-        receipts.push({
-            name: "ncd-dedup",
-            passed: ncdPassed,
-            detail: ncdPassed
-                ? "No new near-duplicate rules"
-                : `${similar.length} new near-duplicate pairs: ${similar.map((p) => `${p.idA}↔${p.idB} (${p.distance.toFixed(3)})`).join(", ")}`,
-        });
-    }
-    catch (e) {
-        receipts.push({
-            name: "ncd-dedup",
-            passed: false,
-            detail: `Similarity check failed: ${e instanceof Error ? e.message : String(e)}`,
-        });
-    }
+    // block every unrelated mutation.
+    const beforePairs = new Set((0, proofs_js_1.findSimilarRules)(before, ncdThreshold).map((p) => [p.idA, p.idB].sort().join("|")));
+    const similar = (0, proofs_js_1.findSimilarRules)(after, ncdThreshold).filter((p) => !beforePairs.has([p.idA, p.idB].sort().join("|")));
+    const ncdPassed = similar.length === 0;
+    receipts.push({
+        name: "ncd-dedup",
+        passed: ncdPassed,
+        detail: ncdPassed
+            ? "No new near-duplicate rules"
+            : `${similar.length} new near-duplicate pairs: ${similar.map((p) => `${p.idA}↔${p.idB} (${p.distance.toFixed(3)})`).join(", ")}`,
+    });
     // 3. Bloom filter cross-check (fast sanity check for token overlap).
     // Baseline is built from rules that still exist in `after` — any
     // rule removed by the candidate mutation (e.g. the two sources of
     // a merge) must be excluded, otherwise the newly introduced merge
     // rule would collide against its own sources and the merge would
     // be rejected for the very similarity it was meant to deduplicate.
-    //
-    // Wrapped for the same reason as NCD: ruleToBloomFilter → ruleToText
-    // throws on unknown rule kinds.
-    try {
-        let bloomPassed = true;
-        const newRuleIds = Object.keys(after).filter((id) => !(id in before));
-        const existingFilters = new Map();
-        for (const [id, rule] of Object.entries(before)) {
-            if (!(id in after))
-                continue; // removed — skip
-            existingFilters.set(id, (0, proofs_js_1.ruleToBloomFilter)(rule));
-        }
-        const bloomOverlaps = [];
-        for (const newId of newRuleIds) {
-            const newFilter = (0, proofs_js_1.ruleToBloomFilter)(after[newId]);
-            for (const [existingId, existingFilter] of existingFilters) {
-                if (existingId === newId)
-                    continue;
-                try {
-                    const similarity = proofs_js_1.BloomFilter.jaccardSimilarity(newFilter, existingFilter);
-                    if (similarity > 0.7) {
-                        bloomOverlaps.push(`${newId}↔${existingId} (jaccard=${similarity.toFixed(3)})`);
-                        bloomPassed = false;
-                    }
-                }
-                catch {
-                    // Different filter sizes — skip comparison
+    let bloomPassed = true;
+    const newRuleIds = Object.keys(after).filter((id) => !(id in before));
+    const existingFilters = new Map();
+    for (const [id, rule] of Object.entries(before)) {
+        if (!(id in after))
+            continue;
+        existingFilters.set(id, (0, proofs_js_1.ruleToBloomFilter)(rule));
+    }
+    const bloomOverlaps = [];
+    for (const newId of newRuleIds) {
+        const newFilter = (0, proofs_js_1.ruleToBloomFilter)(after[newId]);
+        for (const [existingId, existingFilter] of existingFilters) {
+            if (existingId === newId)
+                continue;
+            try {
+                const similarity = proofs_js_1.BloomFilter.jaccardSimilarity(newFilter, existingFilter);
+                if (similarity > 0.7) {
+                    bloomOverlaps.push(`${newId}↔${existingId} (jaccard=${similarity.toFixed(3)})`);
+                    bloomPassed = false;
                 }
             }
+            catch {
+                // Different filter sizes — skip comparison
+            }
         }
-        receipts.push({
-            name: "bloom-overlap",
-            passed: bloomPassed,
-            detail: bloomPassed
-                ? "No suspicious token overlap"
-                : `High overlap: ${bloomOverlaps.join(", ")}`,
-        });
-    }
-    catch (e) {
-        receipts.push({
-            name: "bloom-overlap",
-            passed: false,
-            detail: `Bloom filter check failed: ${e instanceof Error ? e.message : String(e)}`,
-        });
     }
-    // Compute fitness of the new spec. Guard against bad runtime data: fitness
-    // recomputes similarity internally and would otherwise crash on unknown
-    // rule kinds (legacy `check`, JS caller), propagating the throw up through
-    // the engine. Fall back to a neutral fitness and mark the proof failed.
+    receipts.push({
+        name: "bloom-overlap",
+        passed: bloomPassed,
+        detail: bloomPassed
+            ? "No suspicious token overlap"
+            : `High overlap: ${bloomOverlaps.join(", ")}`,
+    });
     const specForFitness = { rules: after };
-    let fitnessResult;
-    try {
-        fitnessResult = (0, proofs_js_1.fitness)(specForFitness, {
-            maxTokens: options.maxTokens,
-            ncdThreshold,
-        });
-    }
-    catch (e) {
-        receipts.push({
-            name: "fitness",
-            passed: false,
-            detail: `Fitness computation failed: ${e instanceof Error ? e.message : String(e)}`,
-        });
-        fitnessResult = {
-            score: 0,
-            coverage: 0,
-            redundancy: 0,
-            budgetPressure: 0,
-        };
-    }
+    const fitnessResult = (0, proofs_js_1.fitness)(specForFitness, {
+        maxTokens: options.maxTokens,
+        ncdThreshold,
+    });
     const allPassed = receipts.every((r) => r.passed);
     return { passed: allPassed, receipts, fitness: fitnessResult };
 }
@@ -454,40 +420,7 @@ class EvolutionEngine {
      * Returns a detailed result including proof receipts and fitness comparison.
      */
     propose(mutation) {
-        // Guard baseline fitness: if engine state contains a malformed rule
-        // (legacy _kind, JS caller, cast bypass), fitness() reaches ruleToText
-        // and throws BEFORE we enter runProofSuite's own try/catch. Return a
-        // clean rejection with a neutral fitness instead of crashing the flow.
-        let beforeFitness;
-        try {
-            beforeFitness = this.getFitness();
-        }
-        catch (e) {
-            const neutral = {
-                score: 0,
-                coverage: 0,
-                redundancy: 0,
-                budgetPressure: 0,
-            };
-            return {
-                accepted: false,
-                mutation,
-                proofs: {
-                    passed: false,
-                    receipts: [
-                        {
-                            name: "baseline-fitness",
-                            passed: false,
-                            detail: `Baseline fitness failed: ${e instanceof Error ? e.message : String(e)}`,
-                        },
-                    ],
-                    fitness: neutral,
-                },
-                beforeFitness: neutral,
-                afterFitness: neutral,
-                error: `Baseline fitness failed: ${e instanceof Error ? e.message : String(e)}`,
-            };
-        }
+        const beforeFitness = this.getFitness();
         // Apply the mutation
         const { rules: candidateRules, error } = applyMutation(this.rules, mutation);
         if (error) {
@@ -594,6 +527,8 @@ function describeMutation(mutation) {
             return `Merge "${mutation.sourceIds[0]}" + "${mutation.sourceIds[1]}" → "${mutation.mergedId}"`;
         case "reword":
             return `Reword rule "${mutation.ruleId}"`;
+        default:
+            return (0, hash_js_1.assertNever)(mutation);
     }
 }
 //# sourceMappingURL=evolve.js.map

package/dist/frontmatter.d.ts

@@ -0,0 +1,75 @@
+/**
+ * vigiles — YAML frontmatter rule mode (Level 1 adoption).
+ *
+ * Parses a `vigiles.enforce` block out of a markdown file's YAML
+ * frontmatter, so a project can declare enforce rules in structured YAML
+ * instead of `<!-- vigiles:enforce ... -->` HTML comments (Level 0) or a
+ * typed `.spec.ts` (Level 2). Every frontmatter rule goes through the same
+ * `checkLinterRule` verification as inline and spec rules.
+ *
+ * Shape (verbose — chosen so a JSON Schema can give `rule` an enum that
+ * YAML LSP autocompletes and squiggles on typo):
+ *
+ *   ---
+ *   # yaml-language-server: $schema=./.vigiles/schema.json
+ *   vigiles:
+ *     enforce:
+ *       - rule: "@typescript-eslint/no-explicit-any"
+ *         why: "Use unknown"
+ *   ---
+ *
+ * Like inline mode, only `enforce` is supported — the prose body of the
+ * file is the guidance. Malformed YAML is reported, never thrown: a broken
+ * frontmatter block produces an error finding, not a crash.
+ */
+export interface FrontmatterRule {
+    /** Linter rule reference, e.g. "eslint/no-console". */
+    linterRule: string;
+    /** Why this rule is enforced (human-readable, shown in agent context). */
+    why: string;
+    /** 1-based line number of the rule in the source file (best-effort). */
+    line: number;
+}
+/** A `vigiles.files` entry (verified to exist). */
+export interface FrontmatterFileRef {
+    /** Project-relative path to verify exists. */
+    path: string;
+    /** 1-based line number of the entry in the source file (best-effort). */
+    line: number;
+}
+/** A `vigiles.commands` entry (npm scripts verified against package.json). */
+export interface FrontmatterCmdRef {
+    /** Command to verify. */
+    command: string;
+    /** 1-based line number of the entry in the source file (best-effort). */
+    line: number;
+}
+export interface FrontmatterParseResult {
+    rules: FrontmatterRule[];
+    files: FrontmatterFileRef[];
+    commands: FrontmatterCmdRef[];
+    /** Frontmatter that looks like a vigiles block but failed to parse. */
+    errors: {
+        line: number;
+        message: string;
+    }[];
+}
+/**
+ * Parse `vigiles.enforce` rules, `vigiles.files`, and `vigiles.commands` out
+ * of a markdown file's YAML frontmatter. Does not touch the filesystem and
+ * does not verify references — callers feed rules into `checkLinterRule` and
+ * file/command refs into `validateFileRef` / `validateCommandRef`.
+ *
+ * A file with no frontmatter, or frontmatter with no `vigiles` key, yields
+ * empty results with no errors. Malformed YAML or a malformed `vigiles`
+ * block yields error findings (never throws).
+ */
+export declare function parseFrontmatterRules(content: string): FrontmatterParseResult;
+/**
+ * True if the content has at least one parseable `vigiles` reference in its
+ * frontmatter — an `enforce` rule, a `files` entry, or a `commands` entry.
+ * Used by `require-spec` validation to treat frontmatter mode as
+ * spec-equivalent, mirroring `hasInlineRules`.
+ */
+export declare function hasFrontmatterRules(content: string): boolean;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/frontmatter.js

@@ -0,0 +1,263 @@
+"use strict";
+/**
+ * vigiles — YAML frontmatter rule mode (Level 1 adoption).
+ *
+ * Parses a `vigiles.enforce` block out of a markdown file's YAML
+ * frontmatter, so a project can declare enforce rules in structured YAML
+ * instead of `<!-- vigiles:enforce ... -->` HTML comments (Level 0) or a
+ * typed `.spec.ts` (Level 2). Every frontmatter rule goes through the same
+ * `checkLinterRule` verification as inline and spec rules.
+ *
+ * Shape (verbose — chosen so a JSON Schema can give `rule` an enum that
+ * YAML LSP autocompletes and squiggles on typo):
+ *
+ *   ---
+ *   # yaml-language-server: $schema=./.vigiles/schema.json
+ *   vigiles:
+ *     enforce:
+ *       - rule: "@typescript-eslint/no-explicit-any"
+ *         why: "Use unknown"
+ *   ---
+ *
+ * Like inline mode, only `enforce` is supported — the prose body of the
+ * file is the guidance. Malformed YAML is reported, never thrown: a broken
+ * frontmatter block produces an error finding, not a crash.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFrontmatterRules = parseFrontmatterRules;
+exports.hasFrontmatterRules = hasFrontmatterRules;
+const js_yaml_1 = require("js-yaml");
+const BOM = "";
+const OPEN_RE = /^---[ \t]*\r?\n/;
+const CLOSE_RE = /\r?\n(?:---|\.\.\.)[ \t]*(?:\r?\n|$)/;
+/**
+ * Extract the YAML frontmatter block. Frontmatter must be the very first
+ * thing in the file (after an optional BOM): a `---` line, the YAML body,
+ * then a closing `---` or `...` line. Returns null when no block is present.
+ */
+function extractFrontmatter(content) {
+    const text = content.startsWith(BOM) ? content.slice(BOM.length) : content;
+    const open = OPEN_RE.exec(text);
+    if (!open)
+        return null;
+    const rest = text.slice(open[0].length);
+    const close = CLOSE_RE.exec(rest);
+    if (!close)
+        return null;
+    // Line 1 is the opening `---`; YAML content starts on line 2.
+    return { yaml: rest.slice(0, close.index), startLine: 2 };
+}
+/** First 1-based line at or after `fromIndex` whose text contains `needle`. */
+function findLine(lines, needle, fromIndex) {
+    for (let i = fromIndex; i < lines.length; i++) {
+        if (lines[i].includes(needle))
+            return i + 1;
+    }
+    return fromIndex + 1;
+}
+/**
+ * Navigate a parsed frontmatter document to its `vigiles` mapping. Returns
+ * "none" when there's nothing for vigiles to check, "error" when the
+ * `vigiles` key is present but not a mapping, or the mapping itself.
+ */
+function getVigiles(doc, lines, startLine) {
+    if (doc === null || typeof doc !== "object" || Array.isArray(doc)) {
+        return { kind: "none" };
+    }
+    const vigiles = doc.vigiles;
+    if (vigiles === undefined)
+        return { kind: "none" };
+    if (vigiles === null ||
+        typeof vigiles !== "object" ||
+        Array.isArray(vigiles)) {
+        return {
+            kind: "error",
+            error: {
+                line: findLine(lines, "vigiles:", startLine - 1),
+                message: "`vigiles` frontmatter key must be a mapping.",
+            },
+        };
+    }
+    return { kind: "map", vigiles: vigiles };
+}
+/**
+ * Locate the `vigiles.enforce` list. Returns "none" when absent, "error" when
+ * present but not a list, or the list with its source line.
+ */
+function lookupEnforce(vigiles, lines, startLine) {
+    const enforce = vigiles.enforce;
+    if (enforce === undefined)
+        return { kind: "none" };
+    const enforceLine = findLine(lines, "enforce:", startLine - 1);
+    if (!Array.isArray(enforce)) {
+        return {
+            kind: "error",
+            error: {
+                line: enforceLine,
+                message: "`vigiles.enforce` must be a list of { rule, why } entries.",
+            },
+        };
+    }
+    return { kind: "list", enforce, enforceLine };
+}
+/**
+ * Parse a `vigiles.<key>` list of plain strings (used for `files` and
+ * `commands`). Returns located items plus error findings for the wrong shape
+ * or non-string entries; an absent key yields empty results.
+ */
+function parseStringList(vigiles, key, lines, startLine) {
+    const raw = vigiles[key];
+    if (raw === undefined)
+        return { items: [], errors: [] };
+    const keyLine = findLine(lines, `${key}:`, startLine - 1);
+    if (!Array.isArray(raw)) {
+        return {
+            items: [],
+            errors: [
+                {
+                    line: keyLine,
+                    message: `\`vigiles.${key}\` must be a list of strings.`,
+                },
+            ],
+        };
+    }
+    const items = [];
+    const errors = [];
+    let cursor = keyLine;
+    for (let i = 0; i < raw.length; i++) {
+        const v = raw[i];
+        if (typeof v !== "string" || v.trim() === "") {
+            errors.push({
+                line: keyLine,
+                message: `vigiles.${key}[${String(i)}] must be a non-empty string.`,
+            });
+            continue;
+        }
+        const line = findLine(lines, v, cursor);
+        cursor = line;
+        items.push({ value: v, line });
+    }
+    return { items, errors };
+}
+/** Parse one `vigiles.enforce` entry into a rule or an error finding. */
+function parseEntry(entry, index, ctx) {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+        return {
+            error: {
+                line: ctx.enforceLine,
+                message: `vigiles.enforce[${String(index)}] must be a mapping with \`rule\` and \`why\`.`,
+            },
+            nextCursor: ctx.cursor,
+        };
+    }
+    const { rule, why } = entry;
+    if (typeof rule !== "string" || rule.trim() === "") {
+        return {
+            error: {
+                line: ctx.enforceLine,
+                message: `vigiles.enforce[${String(index)}] is missing a string \`rule\`.`,
+            },
+            nextCursor: ctx.cursor,
+        };
+    }
+    const line = findLine(ctx.lines, rule, ctx.cursor);
+    if (typeof why !== "string" || why.trim() === "") {
+        return {
+            error: {
+                line,
+                message: `vigiles.enforce[${String(index)}] (rule "${rule}") is missing a string \`why\`.`,
+            },
+            nextCursor: line,
+        };
+    }
+    return { rule: { linterRule: rule, why, line }, nextCursor: line };
+}
+/** Fresh empty result — callers may push into the arrays, so never shared. */
+function emptyResult() {
+    return { rules: [], files: [], commands: [], errors: [] };
+}
+/**
+ * Parse `vigiles.enforce` rules, `vigiles.files`, and `vigiles.commands` out
+ * of a markdown file's YAML frontmatter. Does not touch the filesystem and
+ * does not verify references — callers feed rules into `checkLinterRule` and
+ * file/command refs into `validateFileRef` / `validateCommandRef`.
+ *
+ * A file with no frontmatter, or frontmatter with no `vigiles` key, yields
+ * empty results with no errors. Malformed YAML or a malformed `vigiles`
+ * block yields error findings (never throws).
+ */
+function parseFrontmatterRules(content) {
+    const fm = extractFrontmatter(content);
+    if (!fm)
+        return emptyResult();
+    const lines = content.split("\n");
+    let doc;
+    try {
+        doc = (0, js_yaml_1.load)(fm.yaml);
+    }
+    catch (e) {
+        const err = e;
+        const line = (err.mark?.line ?? 0) + fm.startLine;
+        return {
+            rules: [],
+            files: [],
+            commands: [],
+            errors: [
+                {
+                    line,
+                    message: `Malformed YAML frontmatter: ${err.reason ?? err.message}`,
+                },
+            ],
+        };
+    }
+    const vig = getVigiles(doc, lines, fm.startLine);
+    if (vig.kind === "none")
+        return emptyResult();
+    if (vig.kind === "error")
+        return { rules: [], files: [], commands: [], errors: [vig.error] };
+    const rules = [];
+    const errors = [];
+    const enforceLookup = lookupEnforce(vig.vigiles, lines, fm.startLine);
+    if (enforceLookup.kind === "error") {
+        errors.push(enforceLookup.error);
+    }
+    else if (enforceLookup.kind === "list") {
+        let cursor = enforceLookup.enforceLine; // search start: line after `enforce:`
+        for (let i = 0; i < enforceLookup.enforce.length; i++) {
+            const r = parseEntry(enforceLookup.enforce[i], i, {
+                lines,
+                enforceLine: enforceLookup.enforceLine,
+                cursor,
+            });
+            cursor = r.nextCursor;
+            if (r.rule)
+                rules.push(r.rule);
+            if (r.error)
+                errors.push(r.error);
+        }
+    }
+    const fileList = parseStringList(vig.vigiles, "files", lines, fm.startLine);
+    errors.push(...fileList.errors);
+    const files = fileList.items.map((it) => ({
+        path: it.value,
+        line: it.line,
+    }));
+    const cmdList = parseStringList(vig.vigiles, "commands", lines, fm.startLine);
+    errors.push(...cmdList.errors);
+    const commands = cmdList.items.map((it) => ({
+        command: it.value,
+        line: it.line,
+    }));
+    return { rules, files, commands, errors };
+}
+/**
+ * True if the content has at least one parseable `vigiles` reference in its
+ * frontmatter — an `enforce` rule, a `files` entry, or a `commands` entry.
+ * Used by `require-spec` validation to treat frontmatter mode as
+ * spec-equivalent, mirroring `hasInlineRules`.
+ */
+function hasFrontmatterRules(content) {
+    const r = parseFrontmatterRules(content);
+    return r.rules.length + r.files.length + r.commands.length > 0;
+}
+//# sourceMappingURL=frontmatter.js.map

package/dist/generate-schema.d.ts

@@ -0,0 +1,51 @@
+/**
+ * vigiles generate-schema — emit a JSON Schema for `vigiles:` frontmatter.
+ *
+ * Sibling of `generate-types` (which emits a `.d.ts` for the spec.ts path).
+ * This emits `.vigiles/schema.json` so a YAML LSP can autocomplete rule
+ * names and squiggle typos in markdown frontmatter:
+ *
+ *   ---
+ *   # yaml-language-server: $schema=./.vigiles/schema.json
+ *   vigiles:
+ *     enforce:
+ *       - rule: eslint/no-consolee   # red squiggle in VS Code
+ *   ---
+ *
+ * The `rule` enum is populated from the project's ACTUAL enabled linter
+ * rules — the same discovery `generate-types` runs — so the schema reflects
+ * what is really enforceable, not a static catalog.
+ */
+export interface GenerateSchemaOptions {
+    basePath?: string;
+    /**
+     * Custom linters from `.vigilesrc.json` (`rulesDir`-backed). These aren't
+     * auto-discovered by `generate-types`, but `vigiles audit` resolves their
+     * rules via `checkLinterRule`, so the schema enum must include them too —
+     * otherwise the YAML LSP false-flags a rule that CI accepts.
+     */
+    linters?: Record<string, {
+        rulesDir?: string | string[];
+    }>;
+}
+export interface GenerateSchemaResult {
+    /** The JSON Schema document. */
+    schema: Record<string, unknown>;
+    /** Pretty-printed JSON, newline-terminated. */
+    json: string;
+    /** Rule names included in the enum (sorted, deduped). */
+    ruleNames: string[];
+    /** Linters discovered, with rule counts. */
+    linters: {
+        linter: string;
+        count: number;
+    }[];
+}
+/**
+ * Build a JSON Schema for the `vigiles:` frontmatter block from the
+ * project's discovered linter rules. When no rules are discoverable the
+ * `rule` field falls back to a freeform string so the schema never
+ * false-flags a valid reference.
+ */
+export declare function generateSchema(options?: GenerateSchemaOptions): GenerateSchemaResult;
+//# sourceMappingURL=generate-schema.d.ts.map