@invariant-ui/cli 0.1.0 → 0.2.0

package/README.md

@@ -1,17 +1,17 @@
 <p align="center">
   <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/mcarlucci/invariant/main/site/assets/logo-wordmark.svg">
-    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/mcarlucci/invariant/main/site/assets/logo-wordmark-light.svg">
-    <img alt="Invariant" src="https://raw.githubusercontent.com/mcarlucci/invariant/main/site/assets/logo-wordmark-light.svg" width="280">
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/invariant-ui/invariant/main/site/assets/logo-wordmark.svg">
+    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/invariant-ui/invariant/main/site/assets/logo-wordmark-light.svg">
+    <img alt="Invariant" src="https://raw.githubusercontent.com/invariant-ui/invariant/main/site/assets/logo-wordmark-light.svg" width="280">
   </picture>
 </p>
 
 <p align="center"><strong>Turn your design system into a contract that AI agents can read and check.</strong></p>
 
 <p align="center">
-  <a href="https://mcarlucci.github.io/invariant/">Website</a> &middot;
-  <a href="https://mcarlucci.github.io/invariant/docs/">Documentation</a> &middot;
-  <a href="https://github.com/mcarlucci/invariant/blob/main/docs/specifications">Specifications</a>
+  <a href="https://invariant-ui.com/">Website</a> &middot;
+  <a href="https://invariant-ui.com/docs/">Documentation</a> &middot;
+  <a href="https://github.com/invariant-ui/invariant/blob/main/docs/specifications">Specifications</a>
 </p>
 
 Invariant scans your existing design system (React, Vue, Angular, Storybook, design tokens) and compiles it into one machine-readable file: the **contract**. AI coding tools then use that contract to learn which components, props and tokens really exist, and to check that generated code follows them.
@@ -157,6 +157,8 @@ invariant agent init claude-code   # or cursor, codex, windsurf, all
 
 With Claude Code, you watch the contract being enforced. Ask an agent for a settings page with a delete button and every file it writes is checked before it lands:
 
+![An agent is blocked three times, then passes: the enforcement loop in the terminal](https://github.com/invariant-ui/invariant/blob/main/docs/demo/enforcement-loop.gif)
+
 ```text
 1. invariant blocked app/pages/Settings.tsx: 1 error against the @acme/ui contract
    ✗ prop-value-not-allowed: Button.variant is "danger", which is not one of "primary", "secondary", "ghost" (line 8)
@@ -166,7 +168,7 @@ With Claude Code, you watch the contract being enforced. Ask an agent for a sett
 4. invariant ✓ app/pages/Settings.tsx follows the @acme/ui contract (6 component uses checked)
 ```
 
-Run `pnpm demo` in a checkout to replay exactly that, and `invariant enforcement report` (add `--format html --to report.html`) to get a forwardable timeline: `4 writes checked · 3 violations caught · 3 fixed · 0 outstanding`. See [See it working in your agent chat](https://mcarlucci.github.io/invariant/docs/#enforcement).
+Run `pnpm demo` in a checkout to replay exactly that, and `invariant enforcement report` (add `--format html --to report.html`) to get a forwardable timeline: `4 writes checked · 3 violations caught · 3 fixed · 0 outstanding`. See [See it working in your agent chat](https://invariant-ui.com/docs/#enforcement).
 
 `agent init` installs the hooks for Claude Code: a write that would introduce an error-severity violation is blocked with the exact finding and fix; warnings show up right after the write; clean passes get a green line in the chat. The hooks fail open (if invariant cannot run, the write proceeds) and respect your baseline and rule overrides. Set `enforcement.hooks` to `warn` or `off` in `invariant.config.json` to soften or disable this.
 
@@ -223,17 +225,17 @@ pnpm update:golden     # regenerate golden fixtures
 
 ## Documentation
 
-- [Website](https://mcarlucci.github.io/invariant/) and [documentation site](https://mcarlucci.github.io/invariant/docs/)
-- [System architecture](https://github.com/mcarlucci/invariant/blob/main/docs/architecture/system-architecture.md)
-- [Pattern definitions](https://github.com/mcarlucci/invariant/blob/main/docs/specifications/pattern-definitions-v1.md): write layouts, interactions and page archetypes in `invariant.patterns.json`
-- [Browser verification](https://github.com/mcarlucci/invariant/blob/main/docs/specifications/browser-verification-v1.md): opt-in runtime checks for focus, keyboard order, rendered composition and responsive layout
-- [Pattern discovery](https://github.com/mcarlucci/invariant/blob/main/docs/specifications/pattern-discovery-v1.md): find recurring structures in your code and review them as candidates
-- [ADR 0001: Foundational architecture](https://github.com/mcarlucci/invariant/blob/main/docs/decisions/0001-architecture.md)
-- Specifications in [`docs/specifications/`](https://github.com/mcarlucci/invariant/blob/main/docs/specifications): [CLI](https://github.com/mcarlucci/invariant/blob/main/docs/specifications/cli-v1.md), [contract](https://github.com/mcarlucci/invariant/blob/main/docs/specifications/contract-v1.md), [MCP and agents](https://github.com/mcarlucci/invariant/blob/main/docs/specifications/mcp-and-agents-v1.md), [validation and governance](https://github.com/mcarlucci/invariant/blob/main/docs/specifications/validation-and-governance-v1.md), and more
+- [Website](https://invariant-ui.com/) and [documentation site](https://invariant-ui.com/docs/)
+- [System architecture](https://github.com/invariant-ui/invariant/blob/main/docs/architecture/system-architecture.md)
+- [Pattern definitions](https://github.com/invariant-ui/invariant/blob/main/docs/specifications/pattern-definitions-v1.md): write layouts, interactions and page archetypes in `invariant.patterns.json`
+- [Browser verification](https://github.com/invariant-ui/invariant/blob/main/docs/specifications/browser-verification-v1.md): opt-in runtime checks for focus, keyboard order, rendered composition and responsive layout
+- [Pattern discovery](https://github.com/invariant-ui/invariant/blob/main/docs/specifications/pattern-discovery-v1.md): find recurring structures in your code and review them as candidates
+- [ADR 0001: Foundational architecture](https://github.com/invariant-ui/invariant/blob/main/docs/decisions/0001-architecture.md)
+- Specifications in [`docs/specifications/`](https://github.com/invariant-ui/invariant/blob/main/docs/specifications): [CLI](https://github.com/invariant-ui/invariant/blob/main/docs/specifications/cli-v1.md), [contract](https://github.com/invariant-ui/invariant/blob/main/docs/specifications/contract-v1.md), [MCP and agents](https://github.com/invariant-ui/invariant/blob/main/docs/specifications/mcp-and-agents-v1.md), [validation and governance](https://github.com/invariant-ui/invariant/blob/main/docs/specifications/validation-and-governance-v1.md), and more
 
 ## License
 
-Invariant is source-available under the [Functional Source License, Version 1.1, ALv2 Future License](https://github.com/mcarlucci/invariant/blob/main/LICENSE) (FSL-1.1-ALv2).
+Invariant is source-available under the [Functional Source License, Version 1.1, ALv2 Future License](https://github.com/invariant-ui/invariant/blob/main/LICENSE) (FSL-1.1-ALv2).
 
 You can read, run, modify and redistribute it for any purpose except a Competing Use: offering it in a commercial product or service that substitutes for Invariant or offers the same or similar functionality. Internal use, non-commercial education and research, and professional services for a licensee are always allowed.
 

package/dist/agent-kit/plugin.js

@@ -44,10 +44,10 @@ Also ask which folders hold the applications that use it, if that is not obvious
 
 ## 3. Compile and look
 Run \`invariant setup\` with the choices from step 2. Run like this, without a terminal, it compiles and prints a plan, and changes nothing else.
-Summarize in plain words, using only the output: how many components and what kinds of tokens were found, which frameworks, any errors or warnings that matter, and anything it said it could not extract. If compile failed, explain why and stop.
+Summarize in plain words, using only the output: how many components were found, how many tokens (say plainly if there are none, since then colors and spacing cannot be checked), which frameworks, how many conflicts between sources (for example Storybook claiming a value the code does not have), any errors or warnings that matter, and anything it said it could not extract. If compile failed, explain why and stop.
 
 ## 4. Does this match?
-Ask: "Does this match your design system? Is anything missing or wrong?" If something is off, adjust (\`invariant source add <type> [path]\` or \`invariant source remove <id>\`, or a different \`--paths\`), run \`invariant compile\`, and show the new summary. Repeat until they say it matches. Do not go on before that.
+Ask: "Does this match your design system? Is anything missing or wrong?" If there are conflicts or no tokens, say so in the question and ask whether to go on anyway: conflicts stay unresolved and are listed in \`invariant/invariant.review.json\` for a person to decide. If something is off, adjust (\`invariant source add <type> [path]\` or \`invariant source remove <id>\`, or a different \`--paths\`), run \`invariant compile\`, and show the new summary. Repeat until they say it matches. Do not go on before that.
 
 ## 5. Patterns
 If the plan lists recurring structures found in their application code, say each one in a plain sentence and explain that approved patterns guide AI tools and unapproved ones are only proposals. They are numbered in the plan. Ask: approve all, approve some, or none for now. For some, ask which numbers. Then ask for the approver's name.
@@ -63,13 +63,13 @@ Summarize every decision in a short list and ask for a final yes. Then run, once
 
     invariant setup --confirm-contract --as "<their name>" --no-agent --posture <choice> [--only <numbers>|none] [--no-baseline] [--no-ci] [--paths ...] [--contract ...]
 
-\`--no-agent\` is always passed here: the plugin already connects the AI tool, so setup must not add a second connection. Report what it did, using its output.
+\`--no-agent\` is always passed here: the plugin already connects the AI tool, so setup must not add a second connection. Report what it did, using its output. Setup can also add a \`prepack\` script to \`package.json\` (so a published design system carries its contract), write \`invariant.candidate-reviews.json\`, and turn on a few starter rules as warnings; say so if it did.
 
 ## 8. Prove it works
 Pick a component from the contract (\`get_component\`) with a property that accepts a fixed set of values. Try to write a small file that uses a value outside that set. If blocking was chosen, the write is refused: show the person the message, and nothing is left behind. If the write succeeded, say so plainly, delete the file, and explain the check did not run (Claude Code may need a restart before the checks start in a project that had no configuration when the session began).
 
 ## 9. Wrap up
-Tell the person, in a short list: what was approved and by whom, what is still only a proposal, what was skipped or could not be extracted, and what changes from now on (every file an AI tool writes is checked, and a mistake is shown with the exact fix). Name the files to commit so teammates get the same contract: \`invariant.config.json\`, the \`invariant/\` folder, \`invariant.patterns.json\`, \`invariant.decisions.json\` and \`invariant.policies.json\` when present, \`invariant.baseline.json\`, and the CI workflow. Mention \`invariant enforcement report\` for a record of what was caught, and that teammates only need to install this plugin.
+Tell the person, in a short list: what was approved and by whom, what is still only a proposal, what was skipped or could not be extracted, and what changes from now on (every file an AI tool writes is checked, and a mistake is shown with the exact fix). Run \`git status\` and list the files Invariant added or changed, so they can be committed and teammates get the same contract (never the \`.invariant/\` folder, which ignores itself). Mention \`invariant enforcement report\` for a record of what was caught, and that teammates only need to install this plugin.
 `;
 const COMMENT = `${MARKER}; part of the invariant plugin`;
 /** The setup skill and the generic copies of the build, discovery, layout, review and refactor skills. */

package/dist/cli/version.js

@@ -1,5 +1,5 @@
 export const CLI_NAME = "invariant";
-export const CLI_VERSION = "0.1.0";
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@invariant-ui/cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Compile your design system, UX patterns and page layouts into a contract AI agents can read, and check code against it.",
   "keywords": [
     "design-system",
@@ -12,13 +12,13 @@
     "ux-patterns"
   ],
   "license": "SEE LICENSE IN LICENSE",
-  "homepage": "https://mcarlucci.github.io/invariant/",
+  "homepage": "https://invariant-ui.com/",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/mcarlucci/invariant.git"
+    "url": "git+https://github.com/invariant-ui/invariant.git"
   },
   "bugs": {
-    "url": "https://github.com/mcarlucci/invariant/issues"
+    "url": "https://github.com/invariant-ui/invariant/issues"
   },
   "type": "module",
   "bin": {

package/dist/compiler-react/ast.js

@@ -1,105 +0,0 @@
-import ts from "typescript";
-export function unwrap(node) {
-    let current = node;
-    while (ts.isParenthesizedExpression(current) ||
-        ts.isAsExpression(current) ||
-        ts.isSatisfiesExpression(current) ||
-        ts.isNonNullExpression(current) ||
-        ts.isTypeAssertionExpression(current)) {
-        current = current.expression;
-    }
-    return current;
-}
-export function collapse(text) {
-    return text.replace(/\s+/g, " ").trim();
-}
-/** JSON value of a static literal expression, or undefined when the expression is not a plain literal. */
-export function literalValue(expression) {
-    const node = unwrap(expression);
-    if (ts.isStringLiteralLike(node))
-        return node.text;
-    if (ts.isNumericLiteral(node))
-        return Number(node.text);
-    if (node.kind === ts.SyntaxKind.TrueKeyword)
-        return true;
-    if (node.kind === ts.SyntaxKind.FalseKeyword)
-        return false;
-    if (node.kind === ts.SyntaxKind.NullKeyword)
-        return null;
-    if (ts.isPrefixUnaryExpression(node) &&
-        node.operator === ts.SyntaxKind.MinusToken &&
-        ts.isNumericLiteral(node.operand)) {
-        return -Number(node.operand.text);
-    }
-    if (ts.isArrayLiteralExpression(node)) {
-        const items = node.elements.map((e) => literalValue(e));
-        return items.every((i) => i !== undefined) ? items : undefined;
-    }
-    if (ts.isObjectLiteralExpression(node)) {
-        const out = {};
-        for (const p of node.properties) {
-            if (!ts.isPropertyAssignment(p) || !(ts.isIdentifier(p.name) || ts.isStringLiteralLike(p.name)))
-                return undefined;
-            const v = literalValue(p.initializer);
-            if (v === undefined)
-                return undefined;
-            out[p.name.text] = v;
-        }
-        return out;
-    }
-    return undefined;
-}
-export function lineOf(node) {
-    const sf = node.getSourceFile();
-    return sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
-}
-/** First source line of a node, trimmed and bounded, for use as an evidence excerpt. */
-export function excerpt(node) {
-    const text = node.getText(node.getSourceFile());
-    return collapse(text.split("\n")[0] ?? "").slice(0, 200);
-}
-export function relativeFileOf(analysis, node) {
-    return analysis.relativePath(node.getSourceFile().fileName);
-}
-export function isProjectNode(analysis, node) {
-    return relativeFileOf(analysis, node) !== undefined;
-}
-export function hasModifier(node, kind) {
-    return ts.canHaveModifiers(node) && !!ts.getModifiers(node)?.some((m) => m.kind === kind);
-}
-/** Resolves aliases (imports and re-exports) to the symbol that declares the value. */
-export function resolveSymbol(checker, symbol) {
-    if (!symbol)
-        return undefined;
-    return symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
-}
-export function declarationOf(symbol) {
-    return symbol?.valueDeclaration ?? symbol?.declarations?.[0];
-}
-/** `Foo.bar = value` assignments at the top level of a file, keyed `Foo.bar`. */
-export function topLevelAssignments(sf) {
-    const out = new Map();
-    for (const statement of sf.statements) {
-        if (!ts.isExpressionStatement(statement))
-            continue;
-        const e = statement.expression;
-        if (ts.isBinaryExpression(e) &&
-            e.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-            ts.isPropertyAccessExpression(e.left) &&
-            ts.isIdentifier(e.left.expression)) {
-            out.set(`${e.left.expression.text}.${e.left.name.text}`, e.right);
-        }
-    }
-    return out;
-}
-/** Walks `node` without descending into nested function-like bodies (other than `node` itself). */
-export function walkSameFunction(node, visit) {
-    const go = (n) => {
-        if (n !== node && ts.isFunctionLike(n))
-            return;
-        visit(n);
-        ts.forEachChild(n, go);
-    };
-    ts.forEachChild(node, go);
-}
-//# sourceMappingURL=ast.js.map

package/dist/compiler-react/program.js

@@ -1,58 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import ts from "typescript";
-/**
- * Builds a type-checking program over the supplied project files only. Nothing is read from
- * `node_modules` and no customer code runs: third-party types (including `@types/react`) are not
- * loaded, so references to them stay unresolved and are reported as such rather than guessed.
- * TypeScript's own `lib.es2022.d.ts` is read so built-in utility types like `Omit` resolve.
- */
-export function createAnalysis(files) {
-    const virtual = new Map([...files].map(([rel, text]) => [`/${rel}`, text]));
-    const options = {
-        target: ts.ScriptTarget.ES2022,
-        module: ts.ModuleKind.ESNext,
-        moduleResolution: ts.ModuleResolutionKind.Bundler,
-        jsx: ts.JsxEmit.ReactJSX,
-        lib: ["lib.es2022.d.ts"],
-        types: [],
-        strict: true,
-        allowJs: true,
-        checkJs: false,
-        noEmit: true,
-        skipLibCheck: true,
-        resolveJsonModule: true,
-        allowArbitraryExtensions: true
-    };
-    const libDir = ts.getDefaultLibFilePath(options).replace(/[^/\\]+$/, "");
-    const isLib = (file) => file.startsWith(libDir);
-    const read = (file) => {
-        const text = virtual.get(file);
-        if (text !== undefined)
-            return text;
-        return isLib(file) && existsSync(file) ? readFileSync(file, "utf8") : undefined;
-    };
-    const host = {
-        getSourceFile: (file, languageVersion) => {
-            const text = read(file);
-            return text === undefined ? undefined : ts.createSourceFile(file, text, languageVersion, true);
-        },
-        getDefaultLibFileName: (o) => ts.getDefaultLibFilePath(o),
-        writeFile: () => { },
-        getCurrentDirectory: () => "/",
-        getDirectories: () => [],
-        fileExists: (file) => read(file) !== undefined,
-        readFile: read,
-        getCanonicalFileName: (file) => file,
-        useCaseSensitiveFileNames: () => true,
-        getNewLine: () => "\n"
-    };
-    const roots = [...virtual.keys()].filter((f) => /\.(?:[cm]?[jt]sx?)$/.test(f));
-    const program = ts.createProgram({ rootNames: roots, options, host });
-    return {
-        program,
-        checker: program.getTypeChecker(),
-        relativePath: (fileName) => (virtual.has(fileName) ? fileName.slice(1) : undefined),
-        sourceFile: (rel) => program.getSourceFile(`/${rel}`)
-    };
-}
-//# sourceMappingURL=program.js.map

package/dist/compiler-storybook/static-eval.js

@@ -1,145 +0,0 @@
-import { declarationOf, resolveSymbol, unwrap } from "../compiler-core/index.js";
-import ts from "typescript";
-const MAX_DEPTH = 8;
-const SPY_CALLEES = new Set(["fn", "action"]);
-export function evaluate(checker, expression, depth = 0) {
-    const node = unwrap(expression);
-    if (depth > MAX_DEPTH)
-        return dynamic();
-    if (ts.isStringLiteralLike(node))
-        return resolved(node.text);
-    if (ts.isNumericLiteral(node))
-        return resolved(Number(node.text));
-    if (node.kind === ts.SyntaxKind.TrueKeyword)
-        return resolved(true);
-    if (node.kind === ts.SyntaxKind.FalseKeyword)
-        return resolved(false);
-    if (node.kind === ts.SyntaxKind.NullKeyword)
-        return resolved(null);
-    if (ts.isIdentifier(node) && node.text === "undefined")
-        return { unresolved: [], spies: [] };
-    if (ts.isPrefixUnaryExpression(node) &&
-        node.operator === ts.SyntaxKind.MinusToken &&
-        ts.isNumericLiteral(node.operand)) {
-        return resolved(-Number(node.operand.text));
-    }
-    if (ts.isObjectLiteralExpression(node))
-        return evaluateObject(checker, node, depth);
-    if (ts.isArrayLiteralExpression(node)) {
-        const items = [];
-        const unresolved = [];
-        for (const element of node.elements) {
-            const inner = evaluate(checker, element, depth + 1);
-            if (inner.value === undefined || inner.unresolved.length > 0)
-                unresolved.push("[]");
-            else
-                items.push(inner.value);
-        }
-        // An array with any unresolvable element is not partially trusted.
-        return unresolved.length > 0 ? dynamic() : resolved(items);
-    }
-    if (ts.isIdentifier(node)) {
-        const decl = declarationOf(resolveSymbol(checker, checker.getSymbolAtLocation(node)));
-        if (decl && ts.isVariableDeclaration(decl) && decl.initializer && decl !== node.parent)
-            return evaluate(checker, decl.initializer, depth + 1);
-        return dynamic();
-    }
-    if (ts.isPropertyAccessExpression(node) ||
-        (ts.isElementAccessExpression(node) &&
-            node.argumentExpression &&
-            ts.isStringLiteralLike(node.argumentExpression))) {
-        const key = ts.isPropertyAccessExpression(node)
-            ? node.name.text
-            : node.argumentExpression.text;
-        const base = evaluate(checker, node.expression, depth + 1);
-        if (base.value !== null &&
-            typeof base.value === "object" &&
-            !Array.isArray(base.value) &&
-            key in base.value) {
-            const picked = base.value[key];
-            return {
-                ...(picked === undefined ? {} : { value: picked }),
-                unresolved: base.unresolved
-                    .filter((p) => p === key || p.startsWith(`${key}.`))
-                    .map((p) => (p === key ? "" : p.slice(key.length + 1))),
-                spies: base.spies
-                    .filter((p) => p === key || p.startsWith(`${key}.`))
-                    .map((p) => (p === key ? "" : p.slice(key.length + 1)))
-            };
-        }
-        return dynamic();
-    }
-    if (ts.isCallExpression(node) && SPY_CALLEES.has(node.expression.getText().replace(/^.*\./, ""))) {
-        return { unresolved: [""], spies: [""] };
-    }
-    return dynamic();
-}
-function evaluateObject(checker, node, depth) {
-    const value = {};
-    const unresolved = [];
-    const spies = [];
-    const keys = new Set();
-    const mark = (key, inner) => {
-        for (const p of inner.unresolved)
-            unresolved.push(p === "" ? key : `${key}.${p}`);
-        for (const p of inner.spies)
-            spies.push(p === "" ? key : `${key}.${p}`);
-    };
-    for (const property of node.properties) {
-        if (ts.isSpreadAssignment(property)) {
-            const inner = evaluate(checker, property.expression, depth + 1);
-            if (inner.value !== null && typeof inner.value === "object" && !Array.isArray(inner.value)) {
-                for (const [k, v] of Object.entries(inner.value))
-                    value[k] = v;
-                for (const k of inner.keys ?? Object.keys(inner.value))
-                    keys.add(k);
-                unresolved.push(...inner.unresolved);
-                spies.push(...inner.spies);
-            }
-            else
-                unresolved.push("...");
-            continue;
-        }
-        const name = propertyName(property);
-        if (name === undefined) {
-            unresolved.push("<computed>");
-            continue;
-        }
-        keys.add(name);
-        if (ts.isPropertyAssignment(property)) {
-            const inner = evaluate(checker, property.initializer, depth + 1);
-            if (inner.value !== undefined)
-                value[name] = inner.value;
-            mark(name, inner);
-        }
-        else if (ts.isShorthandPropertyAssignment(property)) {
-            const target = declarationOf(resolveSymbol(checker, checker.getShorthandAssignmentValueSymbol(property)));
-            const inner = target && ts.isVariableDeclaration(target) && target.initializer
-                ? evaluate(checker, target.initializer, depth + 1)
-                : dynamic();
-            if (inner.value !== undefined)
-                value[name] = inner.value;
-            mark(name, inner);
-        }
-        else {
-            // Methods and accessors: present, but not statically evaluable.
-            unresolved.push(name);
-        }
-    }
-    return { value, unresolved, spies, keys: [...keys].sort() };
-}
-function propertyName(property) {
-    const name = property.name;
-    if (!name)
-        return undefined;
-    if (ts.isIdentifier(name) || ts.isStringLiteralLike(name) || ts.isNumericLiteral(name))
-        return name.text;
-    return undefined;
-}
-function resolved(value) {
-    return { value, unresolved: [], spies: [] };
-}
-function dynamic() {
-    return { unresolved: [""], spies: [] };
-}
-//# sourceMappingURL=static-eval.js.map

package/dist/contract-query/scan.js

@@ -1,164 +0,0 @@
-import ts from "typescript";
-const dyn = (text) => ({ expression: text.replace(/\s+/g, " ").trim().slice(0, 80) });
-function jsxValue(init, sf) {
-    if (!init)
-        return true;
-    if (ts.isStringLiteral(init))
-        return init.text;
-    if (ts.isJsxExpression(init) && init.expression) {
-        const e = init.expression;
-        if (ts.isStringLiteralLike(e))
-            return e.text;
-        if (ts.isNumericLiteral(e))
-            return Number(e.text);
-        if (e.kind === ts.SyntaxKind.TrueKeyword)
-            return true;
-        if (e.kind === ts.SyntaxKind.FalseKeyword)
-            return false;
-        if (e.kind === ts.SyntaxKind.NullKeyword)
-            return null;
-        return dyn(e.getText(sf));
-    }
-    return dyn(init.getText(sf));
-}
-/** JSX elements in a TypeScript/JavaScript snippet, by syntax only. Nothing is evaluated. */
-export function scanJsx(code, filename = "snippet.tsx") {
-    const kind = /\.jsx?$/i.test(filename) ? ts.ScriptKind.JSX : ts.ScriptKind.TSX;
-    const sf = ts.createSourceFile(filename, code, ts.ScriptTarget.Latest, true, kind);
-    const uses = [];
-    const visit = (node) => {
-        if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) {
-            const opening = ts.isJsxElement(node) ? node.openingElement : node;
-            const attrs = {};
-            let spread = false;
-            for (const a of opening.attributes.properties) {
-                if (ts.isJsxSpreadAttribute(a))
-                    spread = true;
-                else
-                    attrs[a.name.getText(sf)] = jsxValue(a.initializer, sf);
-            }
-            const hasChildren = ts.isJsxElement(node)
-                ? node.children.some((c) => !(ts.isJsxText(c) && c.containsOnlyTriviaWhiteSpaces))
-                : false;
-            uses.push({
-                tag: opening.tagName.getText(sf),
-                line: sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1,
-                attrs,
-                hasChildren,
-                hasSpread: spread
-            });
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(sf);
-    return uses;
-}
-const RAW_TEXT = new Set(["script", "style"]);
-const camel = (n) => /^(data|aria)-/.test(n) ? n : n.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
-/**
- * Element start tags in an HTML-like template (Vue, Angular, HTML). A single linear pass: no DOM, no
- * expression evaluation. Event handlers, structural directives and references are skipped; bindings are
- * kept as dynamic values.
- */
-export function scanMarkup(code) {
-    const uses = [];
-    let i = 0;
-    let line = 1;
-    const n = code.length;
-    const advance = (to) => {
-        for (; i < to && i < n; i++)
-            if (code[i] === "\n")
-                line++;
-    };
-    while (i < n) {
-        const lt = code.indexOf("<", i);
-        if (lt < 0)
-            break;
-        advance(lt);
-        if (code.startsWith("<!--", i)) {
-            const end = code.indexOf("-->", i + 4);
-            advance(end < 0 ? n : end + 3);
-            continue;
-        }
-        const m = /^<([A-Za-z][A-Za-z0-9_.:-]*)/.exec(code.slice(i, i + 130));
-        if (!m) {
-            advance(i + 1);
-            continue;
-        }
-        const tag = m[1];
-        const startLine = line;
-        let j = i + m[0].length;
-        const attrs = {};
-        let spread = false;
-        let selfClosing = false;
-        while (j < n) {
-            while (j < n && /\s/.test(code[j]))
-                j++;
-            const c = code[j];
-            if (c === undefined)
-                break;
-            if (c === ">") {
-                j++;
-                break;
-            }
-            if (c === "/" && code[j + 1] === ">") {
-                selfClosing = true;
-                j += 2;
-                break;
-            }
-            const nm = /^[^\s=>/"']+/.exec(code.slice(j, j + 200));
-            if (!nm) {
-                j++;
-                continue;
-            }
-            const raw = nm[0];
-            j += raw.length;
-            let value;
-            let k = j;
-            while (k < n && /\s/.test(code[k]))
-                k++;
-            if (code[k] === "=") {
-                k++;
-                while (k < n && /\s/.test(code[k]))
-                    k++;
-                const q = code[k];
-                if (q === '"' || q === "'") {
-                    const end = code.indexOf(q, k + 1);
-                    value = code.slice(k + 1, end < 0 ? n : end);
-                    j = end < 0 ? n : end + 1;
-                }
-                else {
-                    const um = /^[^\s>]+/.exec(code.slice(k, k + 200));
-                    value = um?.[0] ?? "";
-                    j = k + value.length;
-                }
-            }
-            if (/^(@|\(|v-on:|v-on$|#|\*|v-if|v-else|v-for|v-show|v-model|v-slot|ng)/.test(raw) &&
-                !/^\[/.test(raw)) {
-                if (raw === "v-bind" || raw.startsWith("v-bind="))
-                    spread = true;
-                continue;
-            }
-            const bound = /^(:|v-bind:|\[)/.test(raw);
-            const name = camel(raw
-                .replace(/^(:|v-bind:)/, "")
-                .replace(/^\[|\]$/g, "")
-                .replace(/^attr\./, ""));
-            attrs[name] = bound ? dyn(value ?? "") : value === undefined ? true : value;
-        }
-        uses.push({
-            tag,
-            line: startLine,
-            attrs,
-            hasChildren: selfClosing ? false : undefined,
-            hasSpread: spread
-        });
-        advance(j);
-        if (RAW_TEXT.has(tag.toLowerCase()) && !selfClosing) {
-            const close = code.toLowerCase().indexOf(`</${tag.toLowerCase()}`, i);
-            advance(close < 0 ? n : close);
-        }
-    }
-    return uses;
-}
-//# sourceMappingURL=scan.js.map

package/dist/contract-query/validate-code.js

@@ -1,239 +0,0 @@
-import { scanJsx, scanMarkup } from "./scan.js";
-import { normalize } from "./system.js";
-import { validateUsage } from "./validate-usage.js";
-export const MAX_CODE_CHARS = 200_000;
-export const MAX_FINDINGS = 200;
-const NATIVE_EQUIVALENTS = {
-    button: ["button"],
-    input: ["input", "textfield", "textinput"],
-    select: ["select", "dropdown"],
-    textarea: ["textarea", "textfield"],
-    dialog: ["dialog", "modal"],
-    table: ["table", "datatable"],
-    a: ["link"],
-    img: ["image", "img"],
-    label: ["label"],
-    progress: ["progress", "progressbar"]
-};
-const HEX = /#(?:[0-9a-fA-F]{8}|[0-9a-fA-F]{6}|[0-9a-fA-F]{3,4})(?![0-9A-Za-z_-])/g;
-const CSS_VAR = /var\(\s*(--[A-Za-z0-9_-]+)/g;
-function expandHex(hex) {
-    const h = hex.slice(1).toLowerCase();
-    return `#${h.length <= 4 ? [...h].map((c) => c + c).join("") : h}`;
-}
-function tagIndex(ds) {
-    const map = new Map();
-    const add = (key, c) => {
-        if (key === "")
-            return;
-        const list = map.get(key) ?? [];
-        if (!list.includes(c))
-            list.push(c);
-        map.set(key, list);
-    };
-    for (const c of ds.contract.components) {
-        add(normalize(c.name), c);
-        for (const i of c.implementations) {
-            if (i.exportName)
-                add(normalize(i.exportName), c);
-            const sel = i.extensions?.[i.framework]?.selector;
-            if (typeof sel === "string")
-                add(normalize(/^[a-z][a-z0-9-]*/.exec(sel)?.[0] ?? ""), c);
-        }
-    }
-    return map;
-}
-function tokenColors(ds) {
-    const colors = new Map();
-    for (const t of ds.contract.tokens) {
-        const values = [
-            ds.resolveToken(t).value,
-            ...Object.keys(t.modes ?? {}).map((m) => ds.resolveToken(t, m).value)
-        ];
-        for (const v of values)
-            if (typeof v === "string" && /^#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.test(v.trim())) {
-                const key = expandHex(v.trim());
-                if (!colors.has(key))
-                    colors.set(key, t.id);
-            }
-    }
-    return colors;
-}
-function cssVariableNames(ds) {
-    const names = new Set();
-    for (const t of ds.contract.tokens) {
-        const css = t.extensions?.css;
-        if (typeof css?.name === "string")
-            names.add(css.name);
-        names.add(t.name.startsWith("--") ? t.name : `--${t.name.replace(/\./g, "-")}`);
-    }
-    return names;
-}
-/** From the file name, else the contract's only framework, else React. */
-export function defaultFramework(ds, filename) {
-    if (filename) {
-        if (/\.vue$/i.test(filename))
-            return "vue";
-        if (/\.component\.html$/i.test(filename))
-            return "angular";
-        if (/\.html?$/i.test(filename))
-            return "html";
-        if (/\.[cm]?[jt]sx?$/i.test(filename))
-            return "react";
-    }
-    const known = ds.contract.metadata.frameworks.filter((f) => f === "react" || f === "vue" || f === "angular");
-    return known.length === 1 ? known[0] : "react";
-}
-/**
- * Checks a code snippet against the contract without running it: uses of known components are validated
- * with their literal props, literal colors and CSS variables are compared with the tokens. Dynamic values
- * are counted, not guessed.
- */
-export function validateCode(ds, input) {
-    const framework = input.framework ?? defaultFramework(ds, input.filename);
-    const findings = [];
-    const limitations = [
-        "Static check of the given snippet only: nothing is executed or imported.",
-        "Only literal prop values are verified; expressions and bindings are counted as unverified.",
-        "A component is recognized by name or selector. Components from other libraries are not checked."
-    ];
-    const checked = new Set();
-    const unknown = new Set();
-    let unverified = 0;
-    if (input.code.length > MAX_CODE_CHARS) {
-        return {
-            valid: false,
-            framework,
-            summary: {
-                errors: 1,
-                warnings: 0,
-                info: 0,
-                componentsChecked: [],
-                elementsNotInContract: [],
-                unverifiedValues: 0
-            },
-            findings: [
-                {
-                    code: "input-too-large",
-                    severity: "error",
-                    message: `The snippet is ${input.code.length} characters; the limit is ${MAX_CODE_CHARS}`,
-                    basis: "discovered"
-                }
-            ],
-            truncated: false,
-            limitations
-        };
-    }
-    const index = tagIndex(ds);
-    const uses = framework === "react" ? scanJsx(input.code, input.filename) : scanMarkup(input.code);
-    for (const use of uses) {
-        const key = normalize(use.tag.replace(/^.*:/, ""));
-        // A lowercase tag without a hyphen is a native element in every framework (custom elements need a hyphen).
-        const nativeTag = /^[a-z][a-z0-9]*$/.test(use.tag);
-        const matches = nativeTag ? [] : (index.get(key) ?? []);
-        if (matches.length === 1) {
-            const result = validateUsage(ds, {
-                component: matches[0].id,
-                framework: framework === "html" ? undefined : framework,
-                props: use.attrs,
-                hasChildren: use.hasChildren,
-                hasSpread: use.hasSpread
-            });
-            checked.add(matches[0].id);
-            unverified += result.unverifiedValues;
-            for (const f of result.findings)
-                findings.push({ ...f, line: use.line });
-            continue;
-        }
-        if (matches.length > 1) {
-            findings.push({
-                code: "component-ambiguous",
-                severity: "info",
-                message: `<${use.tag}> matches ${matches.map((m) => m.id).join(", ")}; it was not checked`,
-                line: use.line,
-                basis: "discovered"
-            });
-            continue;
-        }
-        const native = NATIVE_EQUIVALENTS[use.tag.toLowerCase()];
-        const equivalent = native
-            ? ds.contract.components.find((c) => native.includes(normalize(c.name)))
-            : undefined;
-        if (equivalent)
-            findings.push({
-                code: "native-element-has-equivalent",
-                severity: "info",
-                message: `<${use.tag}> is a native element and the design system has ${equivalent.name}. This is a name match, not a rule`,
-                line: use.line,
-                basis: "heuristic",
-                confidence: 0.5
-            });
-        else if (/^[A-Z]/.test(use.tag) || use.tag.includes("-"))
-            unknown.add(use.tag);
-    }
-    const colors = tokenColors(ds);
-    if (colors.size > 0) {
-        const lines = input.code.split("\n");
-        lines.forEach((text, idx) => {
-            for (const m of text.matchAll(HEX)) {
-                const before = text.slice(Math.max(0, (m.index ?? 0) - 14), m.index ?? 0);
-                if (/(href|to|id|name)\s*=\s*["']?$/i.test(before) || /&$/.test(before))
-                    continue;
-                const token = colors.get(expandHex(m[0]));
-                findings.push(token
-                    ? {
-                        code: "color-matches-token",
-                        severity: "info",
-                        message: `${m[0]} equals the value of ${token}; reference the token instead`,
-                        line: idx + 1,
-                        basis: "discovered"
-                    }
-                    : {
-                        code: "color-not-in-tokens",
-                        severity: "warning",
-                        message: `${m[0]} is a literal color that is not the value of any token`,
-                        line: idx + 1,
-                        basis: "discovered"
-                    });
-            }
-        });
-    }
-    else
-        limitations.push("No token has a literal color value, so literal colors were not checked.");
-    if (ds.contract.tokens.length > 0) {
-        const known = cssVariableNames(ds);
-        input.code.split("\n").forEach((text, idx) => {
-            for (const m of text.matchAll(CSS_VAR)) {
-                const name = m[1];
-                if (!known.has(name))
-                    findings.push({
-                        code: "unknown-css-variable",
-                        severity: "warning",
-                        message: `${name} is not a token in the contract`,
-                        line: idx + 1,
-                        basis: "discovered"
-                    });
-            }
-        });
-    }
-    else
-        limitations.push("The contract has no tokens, so CSS variables were not checked.");
-    findings.sort((a, b) => (a.line ?? 0) - (b.line ?? 0) || (a.code < b.code ? -1 : a.code > b.code ? 1 : 0));
-    const count = (s) => findings.filter((f) => f.severity === s).length;
-    return {
-        valid: count("error") === 0,
-        framework,
-        summary: {
-            errors: count("error"),
-            warnings: count("warning"),
-            info: count("info"),
-            componentsChecked: [...checked].sort(),
-            elementsNotInContract: [...unknown].sort().slice(0, 50),
-            unverifiedValues: unverified
-        },
-        findings: findings.slice(0, MAX_FINDINGS),
-        truncated: findings.length > MAX_FINDINGS,
-        limitations
-    };
-}
-//# sourceMappingURL=validate-code.js.map

package/dist/contract-query/validate-usage.js

@@ -1,150 +0,0 @@
-import { normalize } from "./system.js";
-export const isDynamic = (v) => typeof v === "object" &&
-    v !== null &&
-    !Array.isArray(v) &&
-    Object.keys(v).length === 1 &&
-    typeof v.expression === "string";
-const PASSTHROUGH = /^(data-|aria-)|^(key|ref|class|className|style|id|slot|role|tabindex|title|hidden)$/i;
-function sameValue(allowed, v) {
-    if (allowed === v)
-        return true;
-    return typeof v === "string" && typeof allowed !== "string" && String(allowed) === v;
-}
-export function validateUsage(ds, input) {
-    const findings = [];
-    const found = ds.findComponent(input.component);
-    if (!found.match) {
-        const names = found.candidates.map((c) => c.name);
-        findings.push({
-            code: found.candidates.length > 1 && names.some((n) => normalize(n) === normalize(input.component))
-                ? "component-ambiguous"
-                : "component-unknown",
-            severity: "error",
-            message: `No single component "${input.component}" in the contract${names.length > 0 ? `. Candidates: ${names.join(", ")}` : ""}`,
-            basis: "discovered"
-        });
-        return { findings, unverifiedValues: 0 };
-    }
-    const c = found.match;
-    const framework = input.framework;
-    if (framework && !c.implementations.some((i) => i.framework === framework))
-        findings.push({
-            code: "framework-not-implemented",
-            severity: "error",
-            message: `${c.name} has no ${framework} implementation (it has: ${c.implementations.map((i) => i.framework).join(", ")})`,
-            basis: "discovered"
-        });
-    if (c.lifecycle === "deprecated")
-        findings.push({
-            code: "component-deprecated",
-            severity: "warning",
-            message: `${c.name} is deprecated`,
-            basis: ds.factView(c.facts, "lifecycle")?.status === "documented" ? "documented" : "discovered"
-        });
-    const complete = ds.propsComplete(c, framework);
-    const props = input.props ?? {};
-    let unverified = 0;
-    const basisOf = (path) => {
-        const s = ds.factView(c.facts, path)?.status;
-        return s === "documented" || s === "inferred" ? s : "discovered";
-    };
-    const where = (path) => {
-        const s = ds.factView(c.facts, path)?.source;
-        return s ? { source: s } : {};
-    };
-    const eventNames = new Set(c.events.map((e) => normalize(e.name)));
-    const slotNames = new Set(c.slots.map((s) => normalize(s.name)));
-    for (const [name, value] of Object.entries(props)) {
-        const prop = c.props.find((p) => p.name === name);
-        if (!prop) {
-            if (PASSTHROUGH.test(name) ||
-                eventNames.has(normalize(name.replace(/^on(?=[A-Z])/, ""))) ||
-                slotNames.has(normalize(name)))
-                continue;
-            findings.push(complete
-                ? {
-                    code: "unknown-prop",
-                    severity: "warning",
-                    message: `${c.name} does not declare a prop "${name}"`,
-                    path: `props.${name}`,
-                    basis: "discovered"
-                }
-                : {
-                    code: "unverifiable-prop",
-                    severity: "info",
-                    message: `${c.name}'s prop list is incomplete, so "${name}" could not be verified`,
-                    path: `props.${name}`,
-                    basis: "discovered"
-                });
-            continue;
-        }
-        const base = `props.${name}`;
-        if (prop.deprecated)
-            findings.push({
-                code: "prop-deprecated",
-                severity: "warning",
-                message: `${c.name}.${name} is deprecated${prop.deprecated.reason ? `: ${prop.deprecated.reason}` : ""}`,
-                path: base,
-                basis: basisOf(`${base}.deprecated`),
-                ...where(`${base}.deprecated`)
-            });
-        if (isDynamic(value)) {
-            unverified++;
-            continue;
-        }
-        if (prop.allowedValues &&
-            (typeof value === "string" || typeof value === "number" || typeof value === "boolean")) {
-            if (!prop.allowedValues.some((a) => sameValue(a, value)))
-                findings.push({
-                    code: "prop-value-not-allowed",
-                    severity: "error",
-                    message: `${c.name}.${name} is ${JSON.stringify(value)}, which is not one of ${prop.allowedValues.map((a) => JSON.stringify(a)).join(", ")}`,
-                    path: `${base}.allowedValues`,
-                    basis: basisOf(`${base}.allowedValues`),
-                    ...where(`${base}.allowedValues`)
-                });
-        }
-        else {
-            const kind = prop.type.kind;
-            const bad = (kind === "boolean" && typeof value !== "boolean") ||
-                (kind === "number" && typeof value !== "number") ||
-                (kind === "string" && typeof value !== "string");
-            if (bad)
-                findings.push({
-                    code: "prop-type-mismatch",
-                    severity: "warning",
-                    message: `${c.name}.${name} expects ${kind} (${prop.type.text}) but got ${JSON.stringify(value)}`,
-                    path: `${base}.type`,
-                    basis: basisOf(`${base}.type.text`),
-                    ...where(`${base}.type.text`)
-                });
-        }
-    }
-    if (!input.hasSpread)
-        for (const p of c.props) {
-            if (!p.required || p.name in props)
-                continue;
-            if (p.name === "children") {
-                if (input.hasChildren === false)
-                    findings.push({
-                        code: "required-prop-missing",
-                        severity: "error",
-                        message: `${c.name} requires children`,
-                        path: "props.children",
-                        basis: basisOf("props.children.required"),
-                        ...where("props.children.required")
-                    });
-                continue;
-            }
-            findings.push({
-                code: "required-prop-missing",
-                severity: "error",
-                message: `${c.name} requires the prop "${p.name}"`,
-                path: `props.${p.name}`,
-                basis: basisOf(`props.${p.name}.required`),
-                ...where(`props.${p.name}.required`)
-            });
-        }
-    return { component: c.id, findings, unverifiedValues: unverified };
-}
-//# sourceMappingURL=validate-usage.js.map