@invariant-ui/cli 0.0.0-stage → 0.1.0

package/dist/compiler-core/discovery/tokens.js

@@ -0,0 +1,186 @@
+import { cmp, hashText, posix, readBounded } from "./support.js";
+const NOT_TOKENS = /^(?:package(?:-lock)?|tsconfig(?:\..+)?|angular|turbo|nx|lerna|biome|deno|composer)\.json$/i;
+const NAMED_TOKEN_JSON = /(?:^|[./-])tokens?\.json$/i;
+const TOKEN_DIR_JSON = /(?:^|\/)(?:design-)?tokens\/[^/]+\.json$/i;
+const STYLE_DICTIONARY_CONFIG = /^(?:style-dictionary|sd)\.config\.[cm]?[jt]s(?:on)?$/;
+const TAILWIND_CONFIG = /^tailwind\.config\.[cm]?[jt]s$/;
+/** CSS custom-property files, token JSON files, and token-tool config files. Values are recorded raw, never evaluated. */
+export async function discoverTokenFiles(env) {
+    const out = [];
+    for (const file of env.files) {
+        const base = posix.basename(file);
+        if (/\.css$/.test(file) && !/\.min\.css$/.test(file)) {
+            const text = await readBounded(env, file);
+            if (text === undefined)
+                continue;
+            const variables = parseCssCustomProperties(text);
+            if (variables.length === 0)
+                continue;
+            const truncated = variables.length > env.limits.maxCssVariablesPerFile;
+            out.push({
+                path: file,
+                kind: "css-custom-properties",
+                contentHash: hashText(text),
+                cssVariables: variables.slice(0, env.limits.maxCssVariablesPerFile),
+                ...(truncated ? { cssVariablesTruncated: true } : {})
+            });
+        }
+        else if (STYLE_DICTIONARY_CONFIG.test(base) || TAILWIND_CONFIG.test(base)) {
+            const text = await readBounded(env, file);
+            if (text === undefined)
+                continue;
+            out.push({
+                path: file,
+                kind: STYLE_DICTIONARY_CONFIG.test(base) ? "style-dictionary-config" : "tailwind-config",
+                contentHash: hashText(text)
+            });
+        }
+        else if (!NOT_TOKENS.test(base) && (NAMED_TOKEN_JSON.test(file) || TOKEN_DIR_JSON.test(file))) {
+            const text = await readBounded(env, file);
+            if (text === undefined)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                env.diagnostics.warning("discovery.token-json-invalid", `${file} looks like a token file but is not valid JSON`, { location: { path: file } });
+                continue;
+            }
+            const shape = classifyTokenJson(parsed);
+            // A file only matched by directory name must actually look like tokens.
+            if (!NAMED_TOKEN_JSON.test(file) && shape.count === 0)
+                continue;
+            out.push({
+                path: file,
+                kind: "json-tokens",
+                format: shape.format,
+                tokenCount: shape.count,
+                contentHash: hashText(text)
+            });
+        }
+    }
+    return out.sort((a, b) => cmp(a.path, b.path));
+}
+function classifyTokenJson(root) {
+    let dtcg = 0;
+    let sd = 0;
+    const visit = (node, depth) => {
+        if (typeof node !== "object" || node === null || depth > 20)
+            return;
+        const record = node;
+        if ("$value" in record)
+            dtcg++;
+        else if ("value" in record && typeof record.value !== "object")
+            sd++;
+        else
+            for (const child of Object.values(record))
+                visit(child, depth + 1);
+    };
+    visit(root, 0);
+    if (dtcg > 0 && dtcg >= sd)
+        return { format: "dtcg-like", count: dtcg };
+    if (sd > 0)
+        return { format: "style-dictionary-like", count: sd };
+    return { format: "unknown", count: 0 };
+}
+/**
+ * Tolerant CSS scanner for custom-property declarations. Tracks the enclosing selector/at-rule chain,
+ * skips comments, strings, and parenthesized `;` (such as in `url(data:…;base64,…)`).
+ */
+export function parseCssCustomProperties(source) {
+    return scanCssCustomProperties(source).map(({ chain: _chain, ...variable }) => variable);
+}
+/** Like `parseCssCustomProperties`, but also returns the enclosing rule chain (outermost first). */
+export function scanCssCustomProperties(source) {
+    const css = blankComments(source);
+    const found = [];
+    const lineStarts = [0];
+    for (let i = 0; i < css.length; i++)
+        if (css[i] === "\n")
+            lineStarts.push(i + 1);
+    const lineAt = (index) => {
+        let lo = 0;
+        let hi = lineStarts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (lineStarts[mid] <= index)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return lo + 1;
+    };
+    const stack = [];
+    let segmentStart = 0;
+    let parens = 0;
+    const flushDeclaration = (end) => {
+        const raw = css.slice(segmentStart, end);
+        const trimmed = raw.trimStart();
+        const match = /^(--[A-Za-z0-9_-]+)\s*:([\s\S]*)$/.exec(trimmed);
+        if (match && stack.length > 0) {
+            const value = match[2].trim().replace(/\s+/g, " ");
+            const alias = /^var\(\s*(--[A-Za-z0-9_-]+)\s*\)$/.exec(value);
+            found.push({
+                name: match[1],
+                scope: stack.join(" "),
+                chain: [...stack],
+                line: lineAt(segmentStart + (raw.length - trimmed.length)),
+                value: value.slice(0, 200),
+                ...(alias ? { aliasOf: alias[1] } : {})
+            });
+        }
+    };
+    for (let i = 0; i < css.length; i++) {
+        const c = css[i];
+        if (c === '"' || c === "'") {
+            for (i++; i < css.length && css[i] !== c; i++)
+                if (css[i] === "\\")
+                    i++;
+        }
+        else if (c === "(")
+            parens++;
+        else if (c === ")")
+            parens = Math.max(0, parens - 1);
+        else if (parens > 0)
+            continue;
+        else if (c === "{") {
+            stack.push(css.slice(segmentStart, i).trim().replace(/\s+/g, " "));
+            segmentStart = i + 1;
+        }
+        else if (c === ";") {
+            flushDeclaration(i);
+            segmentStart = i + 1;
+        }
+        else if (c === "}") {
+            flushDeclaration(i);
+            stack.pop();
+            segmentStart = i + 1;
+        }
+    }
+    return found;
+}
+/** Replaces comment text with spaces (keeping newlines) so offsets and line numbers stay valid. */
+function blankComments(css) {
+    let out = "";
+    for (let i = 0; i < css.length; i++) {
+        const c = css[i];
+        if (c === "/" && css[i + 1] === "*") {
+            const end = css.indexOf("*/", i + 2);
+            const stop = end < 0 ? css.length : end + 2;
+            out += css.slice(i, stop).replace(/[^\n]/g, " ");
+            i = stop - 1;
+        }
+        else if (c === '"' || c === "'") {
+            let j = i + 1;
+            while (j < css.length && css[j] !== c)
+                j += css[j] === "\\" ? 2 : 1;
+            out += css.slice(i, j + 1);
+            i = j;
+        }
+        else
+            out += c;
+    }
+    return out;
+}
+//# sourceMappingURL=tokens.js.map

package/dist/compiler-core/discovery/tooling.js

@@ -0,0 +1,146 @@
+import { dependencyLine, isRecord } from "./packages.js";
+import { cmp, posix } from "./support.js";
+const FRAMEWORK_PACKAGES = [
+    ["react", "react"],
+    ["angular", "@angular/core"],
+    ["vue", "vue"]
+];
+const BUILD_TOOL_DEPS = {
+    vite: "vite",
+    webpack: "webpack",
+    rollup: "rollup",
+    esbuild: "esbuild",
+    tsup: "tsup",
+    parcel: "parcel",
+    "@rspack/core": "rspack",
+    "@angular/cli": "angular-cli",
+    "@vue/cli-service": "vue-cli",
+    "ng-packagr": "ng-packagr",
+    nx: "nx",
+    turbo: "turbo",
+    typescript: "typescript"
+};
+const BUILD_TOOL_CONFIGS = [
+    [/^vite\.config\.[cm]?[jt]s$/, "vite"],
+    [/^webpack\.config\.[cm]?[jt]s$/, "webpack"],
+    [/^rollup\.config\.[cm]?[jt]s$/, "rollup"],
+    [/^tsup\.config\.[cm]?[jt]s$/, "tsup"],
+    [/^angular\.json$/, "angular-cli"],
+    [/^nx\.json$/, "nx"],
+    [/^turbo\.json$/, "turbo"],
+    [/^tsconfig\.json$/, "typescript"],
+    [/^vue\.config\.[cm]?js$/, "vue-cli"]
+];
+const LOCKFILES = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["package-lock.json", "npm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"]
+];
+export async function detectPackageManager(env, root) {
+    const evidence = [];
+    let fromField;
+    const field = root?.manifest.packageManager;
+    if (typeof field === "string") {
+        const match = /^(npm|pnpm|yarn|bun)@(.+)$/.exec(field);
+        if (match) {
+            fromField = {
+                name: match[1],
+                version: match[2].replace(/\+.*$/, "")
+            };
+            evidence.push("package.json#packageManager");
+        }
+    }
+    const lockfiles = LOCKFILES.filter(([file]) => env.fileSet.has(file));
+    for (const [file] of lockfiles)
+        evidence.push(`lockfile:${file}`);
+    const lockNames = new Set(lockfiles.map(([, name]) => name));
+    if (fromField) {
+        if (lockNames.size > 0 && !lockNames.has(fromField.name)) {
+            env.diagnostics.warning("discovery.package-manager-mismatch", `packageManager field says ${fromField.name} but lockfiles indicate ${[...lockNames].join(", ")}`);
+        }
+        return { name: fromField.name, ...(fromField.version ? { version: fromField.version } : {}), evidence };
+    }
+    if (lockNames.size > 1) {
+        env.diagnostics.warning("discovery.ambiguous-lockfiles", `Multiple lockfiles found (${lockfiles.map(([f]) => f).join(", ")}); package manager left unknown`);
+        return { name: "unknown", evidence };
+    }
+    const only = [...lockNames][0];
+    return only ? { name: only, evidence } : { name: "unknown", evidence };
+}
+/** Declared range from the manifest plus the installed version when node_modules is present (never guessed). */
+export async function detectFrameworks(env, raw) {
+    const found = [];
+    for (const [framework, pkgName] of FRAMEWORK_PACKAGES) {
+        for (const kind of [
+            "dependencies",
+            "peerDependencies",
+            "devDependencies",
+            "optionalDependencies"
+        ]) {
+            const group = raw.manifest[kind];
+            if (!isRecord(group) || typeof group[pkgName] !== "string")
+                continue;
+            const installed = await installedVersion(env, raw.info.dir, pkgName);
+            const line = dependencyLine(raw, kind, pkgName);
+            found.push({
+                name: framework,
+                package: pkgName,
+                dependencyKind: kind,
+                declaredRange: group[pkgName],
+                ...(installed ? { installedVersion: installed } : {}),
+                ...(line ? { line } : {})
+            });
+            break;
+        }
+    }
+    return found;
+}
+export function detectBuildTools(env, raw) {
+    const tools = new Map();
+    const add = (name, type, ref) => {
+        const list = tools.get(name) ?? [];
+        if (!list.some((e) => e.type === type && e.ref === ref))
+            list.push({ type, ref });
+        tools.set(name, list);
+    };
+    for (const dep of raw.info.dependencies) {
+        const tool = BUILD_TOOL_DEPS[dep.name];
+        if (tool)
+            add(tool, "dependency", dep.name);
+    }
+    for (const file of env.files) {
+        if (posix.dirname(file) !== raw.info.dir)
+            continue;
+        const base = posix.basename(file);
+        for (const [pattern, tool] of BUILD_TOOL_CONFIGS)
+            if (pattern.test(base))
+                add(tool, "config-file", file);
+    }
+    return [...tools]
+        .map(([name, evidence]) => ({
+        name,
+        evidence: evidence.sort((a, b) => cmp(a.type, b.type) || cmp(a.ref, b.ref))
+    }))
+        .sort((a, b) => cmp(a.name, b.name));
+}
+/** Looks in `<dir>/node_modules`, then each ancestor directory's, as Node resolution would. */
+async function installedVersion(env, dir, pkgName) {
+    for (let current = dir;; current = posix.dirname(current)) {
+        const candidate = posix.join(current, "node_modules", pkgName, "package.json");
+        if (await env.fs.exists(candidate)) {
+            try {
+                const version = JSON.parse(await env.fs.readFile(candidate)).version;
+                if (typeof version === "string")
+                    return version;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        if (current === ".")
+            return undefined;
+    }
+}
+//# sourceMappingURL=tooling.js.map

package/dist/compiler-core/fs.js

@@ -0,0 +1,89 @@
+import { promises as nodeFsPromises } from "node:fs";
+import path from "node:path";
+/** Reads a real directory. Symlinks are listed but never followed, and no path may escape the root. */
+export function nodeFs(rootDirectory) {
+    const root = path.resolve(rootDirectory);
+    const resolve = (relative) => {
+        const absolute = path.resolve(root, relative);
+        if (absolute !== root && !absolute.startsWith(root + path.sep))
+            throw new Error(`Path escapes project root: ${relative}`);
+        return absolute;
+    };
+    return {
+        async readFile(relative) {
+            const absolute = resolve(relative);
+            const real = await nodeFsPromises.realpath(absolute);
+            const realRoot = await nodeFsPromises.realpath(root);
+            if (real !== realRoot && !real.startsWith(realRoot + path.sep))
+                throw new Error(`Symlink escapes project root: ${relative}`);
+            return nodeFsPromises.readFile(real, "utf8");
+        },
+        async readDir(relative) {
+            const entries = await nodeFsPromises.readdir(resolve(relative), { withFileTypes: true });
+            return entries
+                .map((entry) => ({ name: entry.name, kind: kindOf(entry) }))
+                .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+        },
+        async exists(relative) {
+            try {
+                await nodeFsPromises.access(resolve(relative));
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    };
+}
+/** In-memory project for tests and fixtures. Keys are POSIX paths relative to the root. */
+export function memoryFs(files) {
+    const normalized = new Map(Object.entries(files).map(([key, value]) => [normalize(key), value]));
+    const dirs = new Set(["."]);
+    for (const file of normalized.keys()) {
+        for (let dir = path.posix.dirname(file); dir !== "."; dir = path.posix.dirname(dir))
+            dirs.add(dir);
+    }
+    return {
+        async readFile(p) {
+            const content = normalized.get(normalize(p));
+            if (content === undefined)
+                throw new Error(`ENOENT: ${p}`);
+            return content;
+        },
+        async readDir(p) {
+            const dir = normalize(p);
+            if (!dirs.has(dir))
+                throw new Error(`ENOENT: ${p}`);
+            const prefix = dir === "." ? "" : `${dir}/`;
+            const children = new Map();
+            for (const file of normalized.keys()) {
+                if (!file.startsWith(prefix))
+                    continue;
+                const [first, ...rest] = file.slice(prefix.length).split("/");
+                if (first)
+                    children.set(first, rest.length > 0 ? "dir" : "file");
+            }
+            return [...children]
+                .map(([name, kind]) => ({ name, kind }))
+                .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+        },
+        async exists(p) {
+            const key = normalize(p);
+            return normalized.has(key) || dirs.has(key);
+        }
+    };
+}
+function kindOf(entry) {
+    if (entry.isSymbolicLink())
+        return "symlink";
+    if (entry.isDirectory())
+        return "dir";
+    if (entry.isFile())
+        return "file";
+    return "other";
+}
+function normalize(p) {
+    const result = path.posix.normalize(p.replace(/^\.\//, ""));
+    return result === "" ? "." : result.replace(/\/$/, "");
+}
+//# sourceMappingURL=fs.js.map

package/dist/compiler-core/glob.js

@@ -0,0 +1,3 @@
+// The matcher lives in `@invariant/shared`, so that validation can use it without depending on a compiler.
+export { globToRegExp, matchesAny } from "../shared/index.js";
+//# sourceMappingURL=glob.js.map

package/dist/compiler-core/index.js

@@ -0,0 +1,16 @@
+export { INVENTORY_ADAPTERS, markdownDocsAdapter, npmPackageAdapter, storybookConfigAdapter, tokenFilesAdapter } from "./adapters/inventory.js";
+export { compile, toArtifactEntries } from "./compile.js";
+export { ComponentFacts, cssVariableReferences, variantsFromProps } from "./component-facts.js";
+export { DISCOVERY_VERSION, discoverProject, parseCssCustomProperties, parsePnpmWorkspacePackages, projectDiscoverySchema, scanCssCustomProperties } from "./discovery/index.js";
+export { cmp, fileExists, hashText, owningPackage, posix } from "./discovery/support.js";
+export { memoryFs, nodeFs } from "./fs.js";
+export { globToRegExp, matchesAny } from "./glob.js";
+export { IrBuilder } from "./ir-builder.js";
+export { discoveryJsonSchemas } from "./json-schema.js";
+export { collapse, componentNameFromFile, declarationOf, excerpt, hasModifier, isProjectNode, jsxTargetDeclaration, lineOf, literalValue, relativeFileOf, resolveSymbol, subTarget, topLevelAssignments, typeReferenceInfo, unwrap, walkSameFunction } from "./ts/ast.js";
+export { allowedValuesOf, classifyKind, declarationParentName, describeMember, externalBases, literalDomain, ownProperties } from "./ts/members.js";
+export { createAnalysis } from "./ts/program.js";
+export { evaluate } from "./ts/static-eval.js";
+export { TSCONFIG_FILE, tsconfigPaths } from "./ts/tsconfig-paths.js";
+export { DEFAULT_IGNORED_DIRS, walk } from "./walk.js";
+//# sourceMappingURL=index.js.map

package/dist/compiler-core/ir-builder.js

@@ -0,0 +1,68 @@
+import { canonicalizeIrDocument, IR_VERSION } from "../compiler-ir/index.js";
+import { computeEvidenceId } from "../contract/index.js";
+const MAX_ORIGINAL = 2000;
+/**
+ * Assembles an IR document. Evidence is content-addressed and deduplicated, every fact must cite
+ * evidence, and the result is canonical (sorted), so adapters cannot emit order-dependent output.
+ */
+export class IrBuilder {
+    options;
+    entities = new Map();
+    facts = [];
+    evidenceById = new Map();
+    diagnostics = [];
+    constructor(options) {
+        this.options = options;
+    }
+    entity(ref, kind, name) {
+        this.entities.set(ref, { ref, kind, name });
+        return ref;
+    }
+    evidence(input) {
+        const original = input.original === undefined ? undefined : input.original.slice(0, MAX_ORIGINAL);
+        const base = {
+            sourceId: this.options.source.id,
+            sourceRef: input.sourceRef,
+            location: input.location,
+            method: input.method,
+            extractor: this.options.extractor,
+            ...(original === undefined ? {} : { original })
+        };
+        const evidence = {
+            ...base,
+            id: computeEvidenceId(base),
+            verificationStatus: "unverified",
+            capturedAt: this.options.clock()
+        };
+        if (!this.evidenceById.has(evidence.id))
+            this.evidenceById.set(evidence.id, evidence);
+        return evidence;
+    }
+    fact(subject, path, value, evidence, options = {}) {
+        const list = Array.isArray(evidence) ? evidence : [evidence];
+        this.facts.push({
+            subject,
+            path,
+            value,
+            origin: options.origin ?? "extracted",
+            evidenceIds: [...new Set(list.map((e) => e.id))].sort(),
+            ...(options.completeness ? { completeness: options.completeness } : {})
+        });
+    }
+    diagnostic(diagnostic) {
+        this.diagnostics.push({ ...diagnostic, sourceId: this.options.source.id });
+    }
+    build(completeness) {
+        return canonicalizeIrDocument({
+            irVersion: IR_VERSION,
+            source: this.options.source,
+            capabilities: this.options.capabilities,
+            completeness,
+            entities: [...this.entities.values()],
+            facts: this.facts,
+            evidence: [...this.evidenceById.values()],
+            diagnostics: this.diagnostics
+        });
+    }
+}
+//# sourceMappingURL=ir-builder.js.map

package/dist/compiler-core/json-schema.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+import { projectDiscoverySchema } from "./discovery/schema.js";
+export function discoveryJsonSchemas() {
+    return {
+        "project-discovery-v1.schema.json": {
+            title: "Invariant project discovery v1",
+            ...z.toJSONSchema(projectDiscoverySchema)
+        }
+    };
+}
+//# sourceMappingURL=json-schema.js.map

package/dist/compiler-core/testing/index.js

@@ -0,0 +1,81 @@
+import { irDocumentSchema, serializeIrDocument, verifyIrDocument } from "../../compiler-ir/index.js";
+import { canonicalStringify, hasErrors } from "../../shared/index.js";
+import { compile } from "../compile.js";
+import { discoverProject } from "../discovery/index.js";
+export { memoryFs } from "../fs.js";
+/** A clock that always returns the same instant, for reproducible artifacts in tests. */
+export const FIXED_CLOCK = () => "2026-01-01T00:00:00.000Z";
+/**
+ * Conformance checks every source adapter must pass. Returns human-readable violations (empty when
+ * the adapter conforms), so it works with any test runner.
+ */
+export async function checkAdapterConformance(adapter, options) {
+    const violations = [];
+    const project = await discoverProject({ fs: options.fs });
+    const before = canonicalStringify(project);
+    const typed = adapter;
+    const first = await typed.discover({ fs: options.fs, project });
+    const second = await typed.discover({ fs: options.fs, project });
+    if (canonicalStringify(first) !== canonicalStringify(second))
+        violations.push("discover() is not deterministic");
+    const ids = new Set();
+    for (const source of first.sources) {
+        if (source.type !== adapter.type)
+            violations.push(`source ${source.id} has type ${source.type}, adapter declares ${adapter.type}`);
+        if (ids.has(source.id))
+            violations.push(`duplicate source id ${source.id}`);
+        ids.add(source.id);
+        if (!/^[a-z0-9][a-z0-9._-]*$/.test(source.id))
+            violations.push(`source id ${source.id} is not a valid slug`);
+        if (!/^[0-9a-f]{64}$/.test(source.inputHash))
+            violations.push(`source ${source.id} has no valid inputHash`);
+        const context = { fs: options.fs, project, source, clock: FIXED_CLOCK };
+        const a = await typed.extract(context, source.config);
+        const b = await typed.extract(context, source.config);
+        if (!irDocumentSchema.safeParse(a.ir).success) {
+            violations.push(`extract(${source.id}) returned an IR document that fails the schema`);
+            continue;
+        }
+        if (serializeIrDocument(a.ir) !== serializeIrDocument(b.ir))
+            violations.push(`extract(${source.id}) is not deterministic`);
+        if (a.ir.source.id !== source.id)
+            violations.push(`IR source id ${a.ir.source.id} differs from discovered ${source.id}`);
+        if (a.ir.source.adapter.name !== adapter.id)
+            violations.push(`IR names adapter ${a.ir.source.adapter.name}, expected ${adapter.id}`);
+        const problems = verifyIrDocument(a.ir);
+        if (hasErrors(problems))
+            violations.push(`IR for ${source.id} has errors: ${problems
+                .filter((p) => p.severity === "error")
+                .map((p) => p.code)
+                .join(", ")}`);
+        const validation = await typed.validate({ project, source, ir: a.ir });
+        if (!Array.isArray(validation))
+            violations.push(`validate(${source.id}) did not return diagnostics`);
+    }
+    if (canonicalStringify(project) !== before)
+        violations.push("an adapter mutated the shared project discovery");
+    return violations;
+}
+/**
+ * Compiles twice with different clocks. Everything except evidence capture times must match, and the
+ * time-independent IR content hashes must be equal.
+ */
+export async function checkCompileDeterminism(options) {
+    const violations = [];
+    const a = await compile({ ...options, clock: () => "2026-01-01T00:00:00.000Z" });
+    const b = await compile({ ...options, clock: () => "2031-06-30T12:34:56.000Z" });
+    if (canonicalStringify(a.project) !== canonicalStringify(b.project))
+        violations.push("project discovery differs between runs");
+    if (canonicalStringify(a.diagnostics) !== canonicalStringify(b.diagnostics))
+        violations.push("diagnostics differ between runs");
+    if (canonicalStringify(a.sources) !== canonicalStringify(b.sources))
+        violations.push("source summaries (including irContentHash) differ between runs");
+    const strip = (text) => text.replace(/"capturedAt": "[^"]+"/g, '"capturedAt": "-"');
+    a.irDocuments.forEach((doc, i) => {
+        const other = b.irDocuments[i];
+        if (!other || strip(serializeIrDocument(doc)) !== strip(serializeIrDocument(other)))
+            violations.push(`IR ${doc.source.id} differs beyond capture times`);
+    });
+    return violations;
+}
+//# sourceMappingURL=index.js.map