@invariant-ui/cli 0.0.0-stage → 0.2.0

package/dist/cli/pipeline.js

@@ -0,0 +1,262 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { renderArtifacts } from "../artifact-generator/index.js";
+import { angularAdapter } from "../compiler-angular/index.js";
+import { compile, INVENTORY_ADAPTERS, nodeFs, toArtifactEntries } from "../compiler-core/index.js";
+import { reactAdapter } from "../compiler-react/index.js";
+import { storybookAdapter } from "../compiler-storybook/index.js";
+import { designTokensAdapter } from "../compiler-tokens/index.js";
+import { vueAdapter } from "../compiler-vue/index.js";
+import { applyDecisions, compilePatterns, compilePolicies, DECISIONS_FILE, PATTERNS_FILE, POLICIES_FILE, parseDecisions, parsePatterns, parsePolicies } from "../governance/index.js";
+import { buildReviewQueue, finalizeAndVerify, reconcile } from "../reconciliation/index.js";
+import { enrich } from "../semantic-engine/index.js";
+import { DIAGNOSTICS_FILE_VERSION, DiagnosticCollector, hasErrors } from "../shared/index.js";
+import { renderReport } from "./report.js";
+import { loadCompiled } from "./store.js";
+import { CLI_NAME, CLI_VERSION } from "./version.js";
+const ADAPTERS = {
+    react: reactAdapter,
+    vue: vueAdapter,
+    angular: angularAdapter,
+    storybook: storybookAdapter,
+    tokens: designTokensAdapter
+};
+export const REVIEW_VERSION = "1.0.0";
+const within = (location, dir) => dir === "." || location === dir || location.startsWith(`${dir}/`);
+/** Limits an adapter to the directories the configuration names for its type. No path means everything. */
+function scoped(adapter, paths) {
+    if (!paths)
+        return adapter;
+    return {
+        ...adapter,
+        discover: async (context) => {
+            const found = await adapter.discover(context);
+            return { ...found, sources: found.sources.filter((s) => paths.some((p) => within(s.location, p))) };
+        }
+    };
+}
+export function adaptersFor(config) {
+    const adapters = [...INVENTORY_ADAPTERS];
+    for (const type of Object.keys(ADAPTERS)) {
+        const entries = config.sources.filter((s) => s.type === type);
+        if (entries.length === 0)
+            continue;
+        const unrestricted = entries.some((e) => e.path === undefined);
+        adapters.push(scoped(ADAPTERS[type], unrestricted ? undefined : entries.flatMap((e) => (e.path === undefined ? [] : [e.path]))));
+    }
+    return adapters;
+}
+/**
+ * Adds pattern definitions and approved policies, then applies people's decisions, from the human-written files in
+ * the project. Patterns come first so that a policy can name them.
+ */
+function applyGovernance(cwd, config, draft, clock) {
+    const diagnostics = [];
+    const summary = {
+        patterns: 0,
+        patternsSkipped: 0,
+        patternsAwaitingApproval: 0,
+        policies: 0,
+        decisionsApplied: 0,
+        decisionsStale: 0
+    };
+    const evidence = [];
+    const read = (rel) => {
+        const file = path.resolve(cwd, rel);
+        return existsSync(file) ? readFileSync(file, "utf8") : undefined;
+    };
+    const bad = (message) => {
+        diagnostics.push({ code: "governance.invalid-file", severity: "error", message });
+    };
+    let contract = draft;
+    const patternsFile = config.governance?.patternsFile ?? PATTERNS_FILE;
+    const patternsText = read(patternsFile);
+    if (patternsText !== undefined) {
+        const parsed = parsePatterns(patternsText, patternsFile);
+        if (parsed.ok) {
+            const compiled = compilePatterns(contract, parsed.value, {
+                file: patternsFile,
+                text: patternsText,
+                clock
+            });
+            contract = compiled.contract;
+            evidence.push(...compiled.evidence);
+            diagnostics.push(...compiled.diagnostics);
+            summary.patterns = compiled.summary.added;
+            summary.patternsSkipped = compiled.summary.skipped;
+            summary.patternsAwaitingApproval = compiled.summary.awaitingApproval;
+        }
+        else
+            bad(parsed.message);
+    }
+    const policiesFile = config.governance?.policiesFile ?? POLICIES_FILE;
+    const policiesText = read(policiesFile);
+    if (policiesText !== undefined) {
+        const parsed = parsePolicies(policiesText);
+        if (parsed.ok) {
+            const compiled = compilePolicies(contract, parsed.value, policiesFile);
+            contract = compiled.contract;
+            diagnostics.push(...compiled.diagnostics);
+        }
+        else
+            bad(parsed.message);
+    }
+    const decisionsText = read(config.governance?.decisionsFile ?? DECISIONS_FILE);
+    if (decisionsText !== undefined) {
+        const parsed = parseDecisions(decisionsText);
+        if (parsed.ok) {
+            const result = applyDecisions(contract, parsed.value, { approvers: config.governance?.approvers });
+            contract = result.contract;
+            diagnostics.push(...result.diagnostics);
+            summary.decisionsApplied = result.applied.length;
+            summary.decisionsStale = result.stale.length;
+        }
+        else
+            bad(parsed.message);
+    }
+    summary.policies = contract.policies.length - draft.policies.length;
+    return { contract, evidence, diagnostics, summary };
+}
+function mapSources(config, compiled) {
+    return config.sources.map((entry) => {
+        const sources = compiled.irDocuments
+            .filter((d) => d.source.type === entry.type || (entry.type === "tokens" && d.source.type === "tokens"))
+            .filter((d) => entry.path === undefined || within(d.source.location, entry.path))
+            .map((d) => d.source.id)
+            .sort();
+        return { configId: entry.id, type: entry.type, ...(entry.path ? { path: entry.path } : {}), sources };
+    });
+}
+/** discover, extract, reconcile, enrich, verify and render. Reads the project; writes nothing. */
+export async function runPipeline(input) {
+    const { config, clock } = input;
+    const declarationRoots = config.sources.flatMap((s) => (s.declarations && s.path ? [s.path] : []));
+    const declaredFrameworks = Object.fromEntries(config.sources.flatMap((s) => s.declarations && s.path && (s.type === "react" || s.type === "vue" || s.type === "angular")
+        ? [[s.path, s.type]]
+        : []));
+    const compiled = await compile({
+        fs: nodeFs(input.cwd),
+        adapters: adaptersFor(config),
+        clock,
+        ...(declarationRoots.length > 0 ? { discovery: { declarationRoots, declaredFrameworks } } : {})
+    });
+    const reconciled = reconcile(compiled.irDocuments, {
+        name: config.name,
+        ...(config.contractId ? { contractId: config.contractId } : {}),
+        ...(config.description ? { description: config.description } : {}),
+        compilerVersion: CLI_VERSION,
+        clock
+    });
+    const enriched = enrich({
+        contract: reconciled.contract,
+        evidence: reconciled.evidence,
+        docs: compiled.irDocuments
+    });
+    const governed = applyGovernance(input.cwd, config, enriched.contract, clock);
+    const final = finalizeAndVerify(governed.contract, [...enriched.evidence, ...governed.evidence]);
+    const review = buildReviewQueue(governed.contract);
+    const mapping = mapSources(config, compiled);
+    const collector = new DiagnosticCollector();
+    collector.addAll(compiled.diagnostics);
+    collector.addAll(reconciled.diagnostics);
+    collector.addAll(enriched.diagnostics);
+    collector.addAll(governed.diagnostics);
+    collector.addAll(final.diagnostics);
+    for (const m of mapping)
+        if (m.sources.length === 0)
+            collector.warning("cli.source-matched-nothing", `configured source "${m.configId}" (${m.type}${m.path ? ` at ${m.path}` : ""}) matched no source`);
+    const diagnostics = collector.toArray();
+    const entries = [
+        { path: "invariant.contract.json", value: final.contract },
+        { path: "invariant.evidence.json", value: final.evidenceFile },
+        {
+            path: "invariant.diagnostics.json",
+            value: { diagnosticsVersion: DIAGNOSTICS_FILE_VERSION, diagnostics }
+        },
+        {
+            path: "invariant.review.json",
+            value: { reviewVersion: REVIEW_VERSION, items: review }
+        },
+        { path: "invariant.report.html", text: renderReport({ contract: final.contract, review, diagnostics }) }
+    ];
+    if (input.keepIr)
+        entries.push(...toArtifactEntries(compiled).filter((e) => e.path.startsWith("ir/") || e.path === "invariant.project.json"));
+    const artifacts = renderArtifacts(entries, {
+        tool: { name: CLI_NAME, version: CLI_VERSION },
+        generatedAt: clock(),
+        sources: compiled.sources
+    });
+    return {
+        compiled,
+        reconciled,
+        final,
+        review,
+        diagnostics,
+        mapping,
+        governance: governed.summary,
+        ok: !hasErrors(diagnostics),
+        artifacts
+    };
+}
+/**
+ * Compiles a project that uses a design system it does not contain. The contract the library ships is the base:
+ * its components, tokens and patterns are taken as they are, with their evidence and approvals. This project's own
+ * pattern definitions, policies and decisions are applied on top, the result is verified and written locally. Nothing is
+ * read from sources, so a new version of the library shows up as a stale contract (`verify --fresh`).
+ */
+export function runLayeredPipeline(input) {
+    const { config, clock } = input;
+    const from = config.extends?.contract;
+    if (!from)
+        throw new Error("runLayeredPipeline needs extends.contract");
+    const base = loadCompiled(path.resolve(input.cwd, from));
+    const { integrity: _integrity, ...draft } = base.contract;
+    const governed = applyGovernance(input.cwd, config, draft, clock);
+    const final = finalizeAndVerify(governed.contract, [...base.evidence.evidence, ...governed.evidence]);
+    const review = buildReviewQueue(governed.contract);
+    const collector = new DiagnosticCollector();
+    collector.addAll(governed.diagnostics);
+    collector.addAll(final.diagnostics);
+    const diagnostics = collector.toArray();
+    const baseHash = base.contract.integrity.contentHash;
+    const entries = [
+        { path: "invariant.contract.json", value: final.contract },
+        { path: "invariant.evidence.json", value: final.evidenceFile },
+        {
+            path: "invariant.diagnostics.json",
+            value: { diagnosticsVersion: DIAGNOSTICS_FILE_VERSION, diagnostics }
+        },
+        {
+            path: "invariant.review.json",
+            value: { reviewVersion: REVIEW_VERSION, items: review }
+        },
+        { path: "invariant.report.html", text: renderReport({ contract: final.contract, review, diagnostics }) }
+    ];
+    const artifacts = renderArtifacts(entries, {
+        tool: { name: CLI_NAME, version: CLI_VERSION },
+        generatedAt: clock(),
+        sources: [
+            {
+                id: "extends",
+                type: "contract",
+                adapterId: "extends",
+                adapterVersion: "1",
+                inputHash: baseHash,
+                irContentHash: baseHash,
+                completeness: "complete"
+            }
+        ]
+    });
+    return {
+        final,
+        review,
+        diagnostics,
+        mapping: [
+            { configId: "extends", type: "contract", path: from, sources: [`contract ${baseHash.slice(0, 12)}`] }
+        ],
+        governance: governed.summary,
+        ok: !hasErrors(diagnostics),
+        artifacts
+    };
+}
+//# sourceMappingURL=pipeline.js.map

package/dist/cli/publish.js

@@ -0,0 +1,77 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { CLI_VERSION, NPM_PACKAGE } from "./version.js";
+const posix = (p) => p.split(path.sep).join("/");
+/**
+ * Finds the package that ships the design system and says what it needs so that its published tarball carries the
+ * compiled contract. A private package is skipped: it is not published, so apps in the same repository use it directly.
+ */
+export function planPublish(cwd, config, outputDirectory) {
+    const framework = config.sources.filter((s) => s.type === "react" || s.type === "vue" || s.type === "angular");
+    const dirs = [...framework.map((s) => s.path ?? "."), "."];
+    for (const dir of dirs) {
+        const file = path.join(cwd, dir, "package.json");
+        if (!existsSync(file))
+            continue;
+        let pkg;
+        try {
+            pkg = JSON.parse(readFileSync(file, "utf8"));
+        }
+        catch {
+            return { ok: false, reason: `${posix(path.join(dir, "package.json"))} is not valid JSON` };
+        }
+        if (typeof pkg.name !== "string" || pkg.name === "")
+            return {
+                ok: false,
+                reason: `${posix(path.join(dir, "package.json"))} has no name, so it is not a published package`
+            };
+        if (pkg.private === true)
+            return {
+                ok: false,
+                reason: `${pkg.name} is private, so it is not published (apps in this repository use it directly)`
+            };
+        const rel = dir === "." ? "." : posix(path.normalize(dir));
+        const pkgDirFromRoot = rel;
+        const out = posix(path.normalize(outputDirectory));
+        const run = `npx ${NPM_PACKAGE}@${CLI_VERSION}`;
+        // In the package's own folder the output directory is the folder to ship. Anywhere else it is copied there.
+        const toRoot = rel === "." ? "" : ` --cwd ${posix(path.relative(path.join(cwd, rel), cwd)) || "."}`;
+        const prepack = rel === "." && out === "invariant"
+            ? `${run} compile`
+            : `${run} compile${toRoot} && ${run} export --to ${posix(path.join(pkgDirFromRoot, "invariant"))} --force${toRoot}`;
+        const files = Array.isArray(pkg.files) ? pkg.files : undefined;
+        return {
+            ok: true,
+            plan: {
+                file,
+                name: pkg.name,
+                dir: rel,
+                prepack,
+                hasFiles: files === undefined
+                    ? true
+                    : files.some((f) => f === "invariant" || f === "invariant/" || f === "invariant/**"),
+                hasPrepack: typeof pkg.scripts?.prepack === "string"
+            }
+        };
+    }
+    return { ok: false, reason: "no package.json with a name was found for the design system" };
+}
+/** Adds `invariant` to `files` (only if the package lists its files) and a `prepack` script (only if it has none). */
+export function applyPublish(plan) {
+    const raw = readFileSync(plan.file, "utf8");
+    const indent = /^\{\n(\t| +)"/.exec(raw)?.[1] ?? 2;
+    const pkg = JSON.parse(raw);
+    const done = [];
+    if (Array.isArray(pkg.files) && !plan.hasFiles) {
+        pkg.files = [...pkg.files, "invariant"];
+        done.push('added "invariant" to files');
+    }
+    if (!plan.hasPrepack) {
+        pkg.scripts = { ...(pkg.scripts ?? {}), prepack: plan.prepack };
+        done.push("added a prepack script that compiles the contract");
+    }
+    if (done.length > 0)
+        writeFileSync(plan.file, `${JSON.stringify(pkg, null, indent)}${raw.endsWith("\n") ? "\n" : ""}`);
+    return done;
+}
+//# sourceMappingURL=publish.js.map

package/dist/cli/report.js

@@ -0,0 +1,127 @@
+const ESCAPES = {
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+};
+/** Every value that reaches the page goes through here: names and messages come from customer source. */
+export const esc = (value) => String(value).replace(/[&<>"']/g, (c) => ESCAPES[c]);
+export const STYLE = `body{font:14px/1.5 system-ui,sans-serif;margin:2rem auto;max-width:72rem;padding:0 1rem;color:#1a1a1a}
+h1,h2{font-weight:600}table{border-collapse:collapse;width:100%;margin:.5rem 0 1.5rem}
+th,td{border:1px solid #d0d0d0;padding:.3rem .5rem;text-align:left;vertical-align:top}th{background:#f3f3f3}
+code{font:12px ui-monospace,monospace}summary{cursor:pointer;margin:.5rem 0}.error{color:#a40000}.warning{color:#8a5a00}.info{color:#555}`;
+function table(head, rows) {
+    if (rows.length === 0)
+        return "<p>None.</p>";
+    const th = head.map((h) => `<th>${esc(h)}</th>`).join("");
+    const body = rows.map((r) => `<tr>${r.map((c) => `<td>${c}</td>`).join("")}</tr>`).join("\n");
+    return `<table><thead><tr>${th}</tr></thead><tbody>\n${body}\n</tbody></table>`;
+}
+/** Rows shown before the rest fold into a `<details>` block. The report never drops rows and needs no script. */
+const VISIBLE_ROWS = 200;
+function longTable(head, rows) {
+    if (rows.length <= VISIBLE_ROWS)
+        return table(head, rows);
+    const rest = rows.length - VISIBLE_ROWS;
+    return `${table(head, rows.slice(0, VISIBLE_ROWS))}
+<details><summary>Show the remaining ${esc(rest)} rows</summary>
+${table(head, rows.slice(VISIBLE_ROWS))}
+</details>`;
+}
+const anchor = (id) => `c-${id.replace(/[^A-Za-z0-9_-]/g, "_")}`;
+/**
+ * A self-contained, static HTML summary: no scripts, no external requests, no timestamps. It is a view of the
+ * contract for people; the contract file stays canonical.
+ */
+export function renderReport(input) {
+    const { contract: c, review, diagnostics } = input;
+    const inferred = review.filter((r) => r.kind === "inferred-fact").length;
+    const openConflicts = c.conflicts.filter((x) => x.resolution.state === "open").length;
+    const counts = (sev) => diagnostics.filter((d) => d.severity === sev).length;
+    const parts = [];
+    parts.push(`<h1>${esc(c.metadata.name)}</h1>`);
+    parts.push(`<p>Contract <code>${esc(c.metadata.contractId)}</code> v${esc(c.contractVersion)}, compiler ${esc(c.metadata.compilerVersion)}, content hash <code>${esc(c.integrity.contentHash)}</code>.</p>`);
+    parts.push(table([
+        "Components",
+        "Tokens",
+        "Themes",
+        "Guidelines",
+        "Open conflicts",
+        "Inferred facts",
+        "Errors",
+        "Warnings"
+    ], [
+        [
+            c.components.length,
+            c.tokens.length,
+            c.themes.length,
+            c.guidelines.length,
+            openConflicts,
+            inferred,
+            counts("error"),
+            counts("warning")
+        ].map(esc)
+    ]));
+    parts.push("<h2>Sources</h2>");
+    parts.push(table(["Id", "Type", "Location", "Health", "Diagnostics"], c.sources.map((s) => [
+        esc(s.id),
+        esc(s.type),
+        esc(s.location),
+        esc(s.health.status),
+        esc(s.health.diagnosticCount)
+    ])));
+    parts.push("<h2>Conflicts</h2>");
+    parts.push(longTable(["Severity", "Type", "Subject", "Path", "Claims", "State"], c.conflicts.map((x) => [
+        `<span class="${esc(x.severity)}">${esc(x.severity)}</span>`,
+        esc(x.type),
+        `<a href="#${esc(anchor(x.subject))}">${esc(x.subject)}</a>`,
+        `<code>${esc(x.path ?? "")}</code>`,
+        x.claims
+            .map((cl) => `${esc(cl.sourceId)}: <code>${esc(cl.value === undefined ? "(absent)" : JSON.stringify(cl.value))}</code> (${esc(cl.status)})`)
+            .join("<br>"),
+        esc(x.resolution.state)
+    ])));
+    parts.push("<h2>Components</h2>");
+    parts.push(longTable(["Id", "Name", "Implementations", "Props", "Events", "Slots", "Variants"], c.components.map((x) => [
+        `<a id="${esc(anchor(x.id))}"></a><code>${esc(x.id)}</code>`,
+        esc(x.name),
+        esc(x.implementations.map((i) => i.framework).join(", ")),
+        esc(x.props.length),
+        esc(x.events.length),
+        esc(x.slots.length),
+        esc(x.variants.length)
+    ])));
+    parts.push("<h2>Tokens</h2>");
+    parts.push(longTable(["Id", "Category", "Value", "Modes"], c.tokens.map((t) => [
+        `<code>${esc(t.id)}</code>`,
+        `${esc(t.category)}${t.facts.category?.status === "inferred" ? " (inferred)" : ""}`,
+        `<code>${esc("aliasOf" in t.value && t.value.aliasOf ? `-> ${t.value.aliasOf}` : JSON.stringify(t.value.value))}</code>`,
+        esc(Object.keys(t.modes ?? {}).join(", "))
+    ])));
+    parts.push("<h2>Needs review</h2>");
+    parts.push(longTable(["Priority", "Kind", "Subject", "Path", "Confidence", "Reason"], review.map((r) => [
+        esc(r.priority),
+        esc(r.kind),
+        esc(r.subject),
+        `<code>${esc(r.path ?? "")}</code>`,
+        esc(r.confidence ?? ""),
+        esc(r.reason)
+    ])));
+    parts.push("<h2>Diagnostics</h2>");
+    parts.push(longTable(["Severity", "Code", "Message", "Location"], diagnostics.map((d) => [
+        `<span class="${esc(d.severity)}">${esc(d.severity)}</span>`,
+        `<code>${esc(d.code)}</code>`,
+        esc(d.message),
+        esc(d.location ? `${d.location.path}${d.location.line ? `:${d.location.line}` : ""}` : "")
+    ])));
+    return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'">
+<title>${esc(c.metadata.name)} - Invariant report</title>
+<style>${STYLE}</style></head><body>
+${parts.join("\n")}
+</body></html>
+`;
+}
+//# sourceMappingURL=report.js.map

package/dist/cli/starter-rules.js

@@ -0,0 +1,57 @@
+const MAX_RULES = 6;
+const slug = (name) => name
+    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+const idOf = (...parts) => parts.join("-").slice(0, 60).replace(/-+$/, "");
+/**
+ * Rules that restate what an observed arrangement already does every time, so they are true of the code that was
+ * observed and can be checked against the rest: a parent contains the children it always had, and its children come in
+ * the order they always did. Optional children, repeated children and parents whose children may come from elsewhere
+ * give no rule, because their absence or order was never consistent. All rules are warnings: they annotate, they do not
+ * fail a build, until a person raises them.
+ */
+export function starterRules(tree) {
+    if (!tree)
+        return [];
+    const rules = [];
+    const seen = new Set();
+    const add = (rule) => {
+        if (seen.has(rule.id) || rules.length >= MAX_RULES)
+            return;
+        seen.add(rule.id);
+        rules.push(rule);
+    };
+    const visit = (node) => {
+        if (!node.opaque) {
+            const fixed = node.children.filter((c) => !c.optional);
+            for (const child of fixed)
+                add({
+                    id: idOf(slug(node.name), "has", slug(child.name)),
+                    kind: "required-child",
+                    description: `A ${node.name} contains a ${child.name}.`,
+                    details: { parent: node.id, child: child.id },
+                    enforce: { severity: "warning", enforcement: "warn" }
+                });
+            for (let i = 0; i + 1 < fixed.length; i++) {
+                const before = fixed[i];
+                const after = fixed[i + 1];
+                if (before.id === after.id)
+                    continue;
+                add({
+                    id: idOf(slug(before.name), "before", slug(after.name)),
+                    kind: "ordering",
+                    description: `In a ${node.name}, ${before.name} comes before ${after.name}.`,
+                    details: { before: before.id, after: after.id, within: node.id },
+                    enforce: { severity: "warning", enforcement: "warn" }
+                });
+            }
+        }
+        for (const child of node.children)
+            visit(child);
+    };
+    visit(tree);
+    return rules;
+}
+//# sourceMappingURL=starter-rules.js.map

package/dist/cli/store.js

@@ -0,0 +1,60 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { manifestSchema } from "../artifact-generator/index.js";
+import { evidenceFileSchema, parseContract, verifyContract } from "../contract/index.js";
+import { DiagnosticCollector, sha256Hex } from "../shared/index.js";
+import { CliError } from "./errors.js";
+function readText(file, what) {
+    if (!existsSync(file))
+        throw new CliError(`${what} not found at ${file}. Run \`invariant compile\` first.`);
+    return readFileSync(file, "utf8");
+}
+/** Loads the compiled contract and evidence from an output directory, checking structure only. */
+export function loadCompiled(dir) {
+    const contractText = readText(path.join(dir, "invariant.contract.json"), "contract");
+    const evidenceText = readText(path.join(dir, "invariant.evidence.json"), "evidence file");
+    let contractRaw;
+    let evidenceRaw;
+    try {
+        contractRaw = JSON.parse(contractText);
+        evidenceRaw = JSON.parse(evidenceText);
+    }
+    catch (error) {
+        throw new CliError(`output in ${dir} is not valid JSON: ${error.message}`, 1);
+    }
+    const parsed = parseContract(contractRaw);
+    if (!parsed.ok)
+        throw new CliError(`invariant.contract.json is invalid: ${parsed.diagnostics[0]?.message ?? "schema error"}`, 1);
+    const evidence = evidenceFileSchema.safeParse(evidenceRaw);
+    if (!evidence.success)
+        throw new CliError(`invariant.evidence.json is invalid: ${evidence.error.issues[0]?.message ?? "schema error"}`, 1);
+    return { dir, contract: parsed.value, evidence: evidence.data };
+}
+/**
+ * Everything that can be checked without recompiling: the contract's own rules with its evidence, and the
+ * manifest's hashes against the files on disk.
+ */
+export function checkOutput(dir) {
+    const compiled = loadCompiled(dir);
+    const collector = new DiagnosticCollector();
+    collector.addAll(verifyContract(compiled.contract, compiled.evidence));
+    const manifestFile = path.join(dir, "invariant.manifest.json");
+    if (!existsSync(manifestFile)) {
+        collector.warning("verify.manifest-missing", "invariant.manifest.json is missing, so file hashes were not checked");
+    }
+    else {
+        const manifest = manifestSchema.safeParse(JSON.parse(readFileSync(manifestFile, "utf8")));
+        if (!manifest.success)
+            collector.error("verify.manifest-invalid", "invariant.manifest.json does not match its schema");
+        else
+            for (const a of manifest.data.artifacts) {
+                const file = path.join(dir, a.path);
+                if (!existsSync(file))
+                    collector.error("verify.artifact-missing", `${a.path} is listed in the manifest but missing`);
+                else if (sha256Hex(readFileSync(file, "utf8")) !== a.sha256)
+                    collector.error("verify.artifact-modified", `${a.path} does not match its hash in the manifest`);
+            }
+    }
+    return { compiled, diagnostics: collector.toArray() };
+}
+//# sourceMappingURL=store.js.map

package/dist/cli/version.js

@@ -0,0 +1,5 @@
+export const CLI_NAME = "invariant";
+export const CLI_VERSION = "0.2.0"; // x-release-please-version
+/** The name this is published under on npm (`invariant` belongs to an unrelated package). */
+export const NPM_PACKAGE = "@invariant-ui/cli";
+//# sourceMappingURL=version.js.map

package/dist/cli/watch.js

@@ -0,0 +1,68 @@
+import { watch } from "node:fs/promises";
+import path from "node:path";
+/** Directories whose contents are never sources. The output directory is added by the caller. */
+const NEVER = new Set(["node_modules", ".git", ".hg", ".svn", ".turbo", ".next", "coverage"]);
+/** True when a project-relative path is inside the output directory or a directory that is never a source. */
+export function isIgnored(rel, outputRel) {
+    const parts = rel.split(path.sep).filter(Boolean);
+    if (parts.some((p) => NEVER.has(p)))
+        return true;
+    if (outputRel && outputRel !== ".") {
+        const out = outputRel.split(path.sep).filter(Boolean);
+        if (out.every((seg, i) => parts[i] === seg))
+            return true;
+    }
+    return false;
+}
+/**
+ * Watches a project and calls `onChange` after changes settle. Changes that arrive while `onChange` is running
+ * are collected and trigger exactly one more run, so a burst of saves never queues many compiles.
+ * Resolves when `signal` aborts.
+ */
+export async function watchProject(options) {
+    const { root, signal, debounceMs = 250 } = options;
+    const outputRel = path.isAbsolute(options.outputDir)
+        ? path.relative(root, options.outputDir)
+        : path.normalize(options.outputDir);
+    const pending = new Set();
+    let timer;
+    let running = false;
+    const flush = async () => {
+        timer = undefined;
+        if (running || pending.size === 0)
+            return;
+        running = true;
+        try {
+            while (pending.size > 0) {
+                const files = [...pending].sort();
+                pending.clear();
+                await options.onChange(files);
+            }
+        }
+        finally {
+            running = false;
+        }
+    };
+    try {
+        const events = watch(root, { recursive: true, ...(signal ? { signal } : {}) });
+        options.onReady?.();
+        for await (const event of events) {
+            const rel = event.filename ? path.normalize(event.filename.toString()) : "";
+            if (!rel || isIgnored(rel, outputRel))
+                continue;
+            pending.add(rel);
+            if (timer)
+                clearTimeout(timer);
+            timer = setTimeout(() => void flush(), debounceMs);
+        }
+    }
+    catch (error) {
+        if (error.name !== "AbortError")
+            throw error;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=watch.js.map