@oprt/cli 0.1.0 → 0.3.0

package/dist/bin.js

@@ -39,6 +39,205 @@ var init_types = __esm({
   }
 });
 
+// src/lookup.ts
+function distance(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (let i = 1; i <= a.length; i++) {
+    let diagonal = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const above = row[j];
+      row[j] = Math.min(above + 1, row[j - 1] + 1, diagonal + (a[i - 1] === b[j - 1] ? 0 : 1));
+      diagonal = above;
+    }
+  }
+  return row[b.length];
+}
+function nearest(wanted, names2, limit = 5) {
+  const target = squash(wanted);
+  return names2.map((name) => {
+    const candidate = squash(name);
+    const apart = distance(target, candidate);
+    const close = apart <= 2 || target.length >= 3 && (candidate.includes(target) || target.includes(candidate));
+    return { name, apart, close };
+  }).filter(({ close }) => close).sort((a, b) => a.apart - b.apart || a.name.localeCompare(b.name)).slice(0, limit).map(({ name }) => name);
+}
+function resolveComponent(contract2, wanted) {
+  const names2 = Object.keys(contract2.components);
+  const found = names2.find((name) => name === wanted) ?? names2.find((name) => squash(name) === squash(wanted));
+  if (found !== void 0) return found;
+  const suggestions = nearest(wanted, names2);
+  throw new CliError(
+    `Unknown component ${JSON.stringify(wanted)}.` + (suggestions.length > 0 ? ` Did you mean ${suggestions.join(", ")}?` : "") + " Run oprt component --list.",
+    2,
+    { code: "ERR_UNKNOWN_COMPONENT", suggestions }
+  );
+}
+function allowedChildren(rules, name) {
+  for (const [parent, rule] of Object.entries(rules ?? {})) {
+    if (parent === name) return rule.allowed_children;
+    const nested = allowedChildren(rule.children, name);
+    if (nested !== void 0) return nested;
+  }
+  return void 0;
+}
+function componentIndex(contract2) {
+  return Object.keys(contract2.components).filter((name) => (contract2.guidance.components[name]?.use_for ?? []).length > 0).sort((a, b) => a.localeCompare(b)).map((name) => ({
+    name,
+    purpose: contract2.guidance.components[name].use_for.join("; "),
+    parts: partsOf(contract2, name)
+  }));
+}
+function componentDetail(contract2, wanted) {
+  const name = resolveComponent(contract2, wanted);
+  const component = contract2.components[name];
+  const guide = contract2.guidance.components[name] ?? {};
+  const props = Object.entries(component.props).map(([prop, definition]) => {
+    const notes = guide.values?.[prop];
+    return { name: prop, ...definition, ...notes === void 0 ? {} : { notes } };
+  });
+  const allowed = allowedChildren(contract2.composition_rules, name);
+  return {
+    name,
+    description: component.description,
+    use_for: guide.use_for ?? [],
+    not_for: guide.not_for ?? [],
+    ...guide.part_of === void 0 ? {} : { part_of: guide.part_of },
+    parts: partsOf(contract2, name),
+    props,
+    ...component.slots === void 0 ? {} : { slots: component.slots },
+    composable_with: component.composable_with ?? [],
+    never_inside: component.never_inside ?? [],
+    ...allowed === void 0 ? {} : { allowed_children: allowed },
+    example: component.example
+  };
+}
+function propLine(prop, dense) {
+  const kind = prop.type === "enum" ? (prop.values ?? []).map((value) => value === prop.default ? `${value} (default)` : value).join(" | ") : (prop.type === "union" ? (prop.types ?? []).join(" or ") : prop.type) + (prop.default === void 0 ? "" : ` (default ${String(prop.default)})`);
+  const description = prop.description === void 0 ? "" : dense ? firstSentence(prop.description) : prop.description;
+  const lines = [
+    `  ${prop.name}: ${kind}${prop.required ? ", required" : ""}${description ? `. ${description}` : ""}`
+  ];
+  for (const [value, note] of Object.entries(prop.notes ?? {})) lines.push(`    ${value}: ${note}`);
+  return lines;
+}
+function renderComponent(detail, { dense }) {
+  const lines = [
+    detail.part_of === void 0 ? `${detail.name}: ${detail.use_for.join("; ")}` : `${detail.name}: a part of ${detail.part_of}. ${firstSentence(detail.description)}`
+  ];
+  if (detail.not_for.length > 0)
+    lines.push(
+      `Not for: ${detail.not_for.map(({ need, use }) => `${need} (use ${use})`).join("; ")}`
+    );
+  if (!dense) lines.push("", detail.description, "");
+  if (detail.props.length > 0) {
+    lines.push("Props:");
+    for (const prop of detail.props) lines.push(...propLine(prop, dense));
+  }
+  for (const [slot, { type, required }] of Object.entries(detail.slots ?? {}))
+    lines.push(
+      `${slot === "children" ? "Children" : `Slot ${slot}`}: ${type}${required ? ", required" : ""}`
+    );
+  if (detail.parts.length > 0) lines.push(`Parts: ${detail.parts.join(", ")}`);
+  if (detail.allowed_children !== void 0)
+    lines.push(`Takes directly inside: ${detail.allowed_children.join(", ")}`);
+  if (detail.composable_with.length > 0)
+    lines.push(`Goes inside: ${detail.composable_with.join(", ")}`);
+  if (detail.never_inside.length > 0) lines.push(`Never inside: ${detail.never_inside.join(", ")}`);
+  lines.push(
+    detail.example.includes("\n") ? `Example:
+${detail.example.split("\n").map((line) => `  ${line}`).join("\n")}` : `Example: ${detail.example}`
+  );
+  return `${lines.join("\n")}
+`;
+}
+function search(contract2, registry2, query, limit = SEARCH_LIMIT_DEFAULT) {
+  const wanted = words(query);
+  if (wanted.length === 0) return [];
+  const whole = squash(query);
+  const scores = /* @__PURE__ */ new Map();
+  const add = (name, points, why) => {
+    const before = scores.get(name) ?? { score: 0 };
+    scores.set(name, {
+      score: before.score + points,
+      ...before.why !== void 0 ? { why: before.why } : why !== void 0 ? { why } : {}
+    });
+  };
+  for (const [name, component] of Object.entries(contract2.components)) {
+    const guide = contract2.guidance.components[name] ?? {};
+    const plain = squash(name);
+    if (plain === whole) add(name, 100);
+    else if (wanted.some((word) => word.length >= 3 && plain.includes(word))) add(name, 15);
+    else if (wanted.some((word) => word.length >= 4 && distance(word, plain) <= 1)) add(name, 12);
+    for (const phrase of guide.use_for ?? []) {
+      const hits = matched(wanted, phrase);
+      if (hits > 0) add(name, 12 * hits + (hits === wanted.length ? 40 : 0));
+    }
+    for (const { need, use } of guide.not_for ?? []) {
+      const hits = matched(wanted, need);
+      if (hits > 0 && hits >= Math.ceil(wanted.length * 0.6))
+        add(use, 10 * hits + (hits === wanted.length ? 15 : 0), `${name} is not for this: ${need}`);
+    }
+    const inDescription = matched(wanted, component.description);
+    if (inDescription > 0) add(name, 2 * inDescription);
+  }
+  const results = [];
+  for (const [name, { score, why }] of scores) {
+    const guide = contract2.guidance.components[name] ?? {};
+    results.push({
+      kind: "component",
+      name,
+      purpose: guide.part_of === void 0 ? (guide.use_for ?? []).join("; ") : `a part of ${guide.part_of}`,
+      score,
+      ...why === void 0 ? {} : { why },
+      next: `oprt component ${name}`
+    });
+  }
+  for (const entry of registry2.entries.filter(({ kind }) => kind === "recipe")) {
+    const recipe = contract2.patterns?.[entry.name];
+    const plain = squash(entry.name);
+    const inName = plain === whole ? 100 : wanted.some((word) => word.length >= 3 && plain.includes(word)) ? 15 : 0;
+    const hits = matched(wanted, entry.description);
+    const score = inName + (hits > 0 ? 10 * hits + (hits === wanted.length ? 15 : 0) : 0);
+    if (score > 0)
+      results.push({
+        kind: "recipe",
+        name: entry.name,
+        purpose: firstSentence(entry.description),
+        score,
+        next: recipe?.install ?? `oprt add ${entry.slug}`
+      });
+  }
+  results.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
+  const floor = Math.max(4, (results[0]?.score ?? 0) * 0.15);
+  return results.filter(({ score }) => score >= floor).slice(0, limit);
+}
+var SEARCH_LIMIT_MAX, SEARCH_LIMIT_DEFAULT, squash, firstSentence, partsOf, STOP, words, matched;
+var init_lookup = __esm({
+  "src/lookup.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_types();
+    SEARCH_LIMIT_MAX = 50;
+    SEARCH_LIMIT_DEFAULT = 10;
+    squash = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
+    firstSentence = (text2) => /^.*?[.!?](?=\s|$)/.exec(text2)?.[0] ?? text2;
+    partsOf = (contract2, name) => Object.keys(contract2.components).filter(
+      (part) => contract2.guidance.components[part]?.part_of === name
+    );
+    STOP = new Set(
+      "a an the to of for in on at with and or i we need want that which is are it its my some from by".split(
+        " "
+      )
+    );
+    words = (text2) => (text2.toLowerCase().match(/[a-z0-9]+/g) ?? []).filter((word) => !STOP.has(word)).map((word) => word.length > 4 ? word.replace(/(?:ing|ed|es|s)$/, "") : word);
+    matched = (query, text2) => {
+      const present = new Set(words(text2));
+      return query.filter((word) => present.has(word)).length;
+    };
+  }
+});
+
 // src/args.ts
 function split(command, rest, spec) {
   const flags = /* @__PURE__ */ new Set();
@@ -90,7 +289,8 @@ function parseArgs(args) {
     names: [],
     out: DEFAULT_OUT,
     dryRun: false,
-    overwrite: false
+    overwrite: false,
+    json: false
   };
   const seen = /* @__PURE__ */ new Set();
   for (let i = 0; i < rest.length; i++) {
@@ -99,7 +299,7 @@ function parseArgs(args) {
       parsed.names.push(token);
       continue;
     }
-    if (!["--out", "--dry-run", "--overwrite"].includes(token))
+    if (!["--out", "--dry-run", "--overwrite", "--json"].includes(token))
       throw new CliError(`Unknown option ${JSON.stringify(token)}. Run oprt --help.`, 2);
     if (seen.has(token)) throw new CliError(`Duplicate option ${token}.`, 2);
     seen.add(token);
@@ -109,6 +309,7 @@ function parseArgs(args) {
         throw new CliError("--out requires a relative directory.", 2);
       parsed.out = value;
     } else if (token === "--dry-run") parsed.dryRun = true;
+    else if (token === "--json") parsed.json = true;
     else parsed.overwrite = true;
   }
   if (!parsed.names.length)
@@ -120,6 +321,7 @@ var init_args = __esm({
   "src/args.ts"() {
     "use strict";
     init_esm_shims();
+    init_lookup();
     init_types();
     DEFAULT_OUT = "src/components/operator";
     AGENT_COMMANDS = {
@@ -145,9 +347,10 @@ var init_args = __esm({
           "--json": "flag"
         });
         if (positional.length === 0) throw new CliError("Usage: oprt search <need> [--limit <n>]", 2);
-        const limit = value("--limit") === void 0 ? 10 : Number(value("--limit"));
-        if (!Number.isInteger(limit) || limit < 1)
-          throw new CliError("--limit takes a whole number above zero.", 2);
+        const given = value("--limit");
+        const limit = given === void 0 ? SEARCH_LIMIT_DEFAULT : Number(given);
+        if (!Number.isInteger(limit) || limit < 1 || limit > SEARCH_LIMIT_MAX)
+          throw new CliError(`--limit takes a whole number from 1 to ${SEARCH_LIMIT_MAX}.`, 2);
         return { command: "search", query: positional.join(" "), limit, json: has("--json") };
       },
       init(rest) {
@@ -193,448 +396,133 @@ var init_args = __esm({
   }
 });
 
-// package.json
-var package_default;
-var init_package = __esm({
-  "package.json"() {
-    package_default = {
-      name: "@oprt/cli",
-      version: "0.1.0",
-      description: "The OPERATOR command line: copy components and recipes into your app as source, give coding agents the contract, and check their code against it. Includes an MCP server.",
-      keywords: [
-        "design-system",
-        "cli",
-        "coding-agents",
-        "mcp",
-        "model-context-protocol",
-        "code-check",
-        "components"
-      ],
-      homepage: "https://oprt.dev/docs/agents/cli",
-      type: "module",
-      main: "./dist/index.cjs",
-      module: "./dist/index.js",
-      types: "./dist/index.d.ts",
-      bin: {
-        oprt: "./dist/bin.js"
-      },
-      engines: {
-        node: ">=22"
-      },
-      exports: {
-        ".": {
-          import: {
-            types: "./dist/index.d.ts",
-            default: "./dist/index.js"
-          },
-          require: {
-            types: "./dist/index.d.cts",
-            default: "./dist/index.cjs"
-          }
-        },
-        "./read": {
-          import: {
-            types: "./dist/read.d.ts",
-            default: "./dist/read.js"
-          },
-          require: {
-            types: "./dist/read.d.cts",
-            default: "./dist/read.cjs"
-          }
-        }
-      },
-      files: [
-        "dist"
-      ],
-      scripts: {
-        clean: `node -e "require('node:fs').rmSync('dist',{recursive:true,force:true})"`,
-        build: "pnpm run clean && node scripts/build-registry.mjs && tsup",
-        dev: "pnpm run clean && node scripts/build-registry.mjs && tsup --watch",
-        test: "vitest run",
-        typecheck: "tsc --noEmit",
-        lint: "eslint src scripts"
-      },
-      devDependencies: {
-        tsup: "^8.3.0",
-        typescript: "^5.6.3",
-        vitest: "^2.1.3"
-      },
-      license: "MIT",
-      publishConfig: {
-        access: "public"
-      }
-    };
-  }
-});
-
-// src/contract.ts
-import { existsSync, readFileSync } from "fs";
-import { dirname, join } from "path";
+// src/parser.ts
+import { createRequire } from "module";
+import { join } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-function loadContract() {
-  const here = dirname(fileURLToPath2(import.meta.url));
-  const candidates = [join(here, "contract.json"), join(here, "../generated/contract.json")];
-  const found = candidates.find((candidate) => existsSync(candidate));
-  if (found === void 0) {
-    throw new Error(
-      `contract.json is missing next to ${here}. Install @oprt/cli again: the contract ships beside the executable, and the executable cannot be copied without it.`
-    );
-  }
-  return JSON.parse(readFileSync(found, "utf8"));
-}
-var init_contract = __esm({
-  "src/contract.ts"() {
-    "use strict";
-    init_esm_shims();
-  }
-});
-
-// src/installer.ts
-import {
-  constants,
-  closeSync,
-  lstatSync,
-  mkdirSync,
-  openSync,
-  readFileSync as readFileSync2,
-  realpathSync,
-  writeFileSync
-} from "fs";
-import { dirname as dirname2, isAbsolute, relative, resolve, sep } from "path";
-function resolveEntries(names, registry2) {
-  if (!names.length) throw new CliError("add requires one or more names.", 2);
-  const selected = /* @__PURE__ */ new Map();
-  for (const name of names) {
-    const normalized = name.toLowerCase();
-    const entry = registry2.entries.find(
-      (candidate) => candidate.slug === normalized || candidate.name.toLowerCase() === normalized
-    );
-    if (!entry)
-      throw new CliError(`Unknown component or recipe ${JSON.stringify(name)}. Run oprt list.`, 2);
-    selected.set(entry.name, entry);
-  }
-  return [...selected.values()];
-}
-function validateRelative(path2) {
-  if (!path2 || isAbsolute(path2) || /[\\:\0]/.test(path2) || path2.split("/").includes(".."))
-    throw new CliError(
-      `Unsafe path ${JSON.stringify(path2)}: use a nonempty relative path without traversal.`,
-      2
-    );
-}
-function stat(path2) {
+function usable(typescript) {
+  const ts = typescript;
+  if (typeof ts.createSourceFile !== "function" || ts.ScriptKind === void 0)
+    return `TypeScript ${ts.version ?? "(unknown version)"} has no JavaScript syntax API (createSourceFile), which oprt reads code with; ${SUPPORTED_TYPESCRIPT} has it`;
   try {
-    return lstatSync(path2);
+    const probe = ts.createSourceFile(
+      "probe.tsx",
+      "<a>",
+      ts.ScriptTarget?.Latest ?? 99,
+      true,
+      ts.ScriptKind.TSX
+    );
+    const diagnostics = probe.parseDiagnostics;
+    if (!Array.isArray(diagnostics)) return "it does not report parse errors on a source file";
+    if (diagnostics.length === 0) return "it did not report a syntax error in code that has one";
   } catch (error) {
-    if (error.code === "ENOENT") return void 0;
-    throw error;
-  }
-}
-function inspectPath(root, destination, directory = false) {
-  const path2 = relative(root, destination);
-  if (path2 === ".." || path2.startsWith(`..${sep}`) || isAbsolute(path2))
-    throw new CliError("Output path escapes the working directory.");
-  let cursor = root;
-  const segments = path2 ? path2.split(sep) : [];
-  for (let i = 0; i < segments.length; i++) {
-    cursor = resolve(cursor, segments[i]);
-    const info = stat(cursor);
-    if (!info) continue;
-    if (info.isSymbolicLink()) throw new CliError(`Refusing symlink in output path: ${cursor}`);
-    const needsDirectory = i < segments.length - 1 || directory;
-    if (needsDirectory && !info.isDirectory())
-      throw new CliError(`Output ancestor is not a directory: ${cursor}`);
-    if (!needsDirectory && !info.isFile())
-      throw new CliError(`Output target is not a regular file: ${cursor}`);
+    return `it failed on a probe parse: ${error instanceof Error ? error.message : String(error)}`;
   }
-  return stat(destination);
+  return null;
 }
-function installSources(options, context) {
-  const entries = resolveEntries(options.names, context.registry);
-  const out = options.out ?? DEFAULT_OUT;
-  validateRelative(out);
-  const root = realpathSync(context.cwd);
-  const outputDirectory = resolve(root, out);
-  inspectPath(root, outputDirectory, true);
-  const paths = [...new Set(entries.flatMap((entry) => entry.files))].sort();
-  const files = paths.map((path2) => {
-    validateRelative(path2);
-    const content = context.registry.files[path2];
-    if (!Object.hasOwn(context.registry.files, path2) || typeof content !== "string")
-      throw new CliError(`Registry is missing source ${path2}.`);
-    const destination = resolve(outputDirectory, path2);
-    const info = inspectPath(root, destination);
-    if (!info) return { path: path2, destination, action: "create" };
-    if (readFileSync2(destination, "utf8") === content) return { path: path2, destination, action: "skip" };
-    if (!options.overwrite)
-      throw new CliError(
-        `Refusing to overwrite modified file ${destination}. Use --overwrite to replace it explicitly.`
-      );
-    return { path: path2, destination, action: "overwrite" };
-  });
-  const dependencies = [...new Set(entries.flatMap((entry) => entry.dependencies))].sort();
-  const runtime = new Set(
-    entries.flatMap(
-      (entry) => entry.dependencies.filter((name) => !(entry.devDependencies ?? []).includes(name))
-    )
-  );
-  const result = {
-    outputDirectory,
-    entries: entries.map((entry) => entry.name),
-    dependencies,
-    devDependencies: dependencies.filter(
-      (name) => !runtime.has(name) && entries.some((entry) => (entry.devDependencies ?? []).includes(name))
-    ),
-    ranges: Object.fromEntries(
-      dependencies.flatMap((name) => {
-        const range = context.registry.ranges?.[name];
-        return range === void 0 ? [] : [[name, range]];
-      })
-    ),
-    files,
-    dryRun: options.dryRun ?? false
-  };
-  if (result.dryRun) return result;
-  for (const file of files) {
-    if (file.action === "skip") continue;
-    inspectPath(root, file.destination);
-    const parent = dirname2(file.destination);
-    mkdirSync(parent, { recursive: true });
-    inspectPath(root, parent, true);
-    const flags = constants.O_WRONLY | constants.O_CREAT | (constants.O_NOFOLLOW ?? 0) | (file.action === "create" ? constants.O_EXCL : constants.O_TRUNC);
-    const descriptor = openSync(file.destination, flags, 420);
+function probeTypeScript(cwd, options = {}) {
+  const places = [
+    { from: join(cwd, "package.json"), source: "project" },
+    ...options.installer === false ? [] : [{ from: fileURLToPath2(import.meta.url), source: "installer" }]
+  ];
+  let unusable;
+  for (const { from, source } of places) {
+    let file;
+    let loaded2;
     try {
-      writeFileSync(descriptor, context.registry.files[file.path]);
-    } finally {
-      closeSync(descriptor);
+      const require2 = createRequire(from);
+      file = require2.resolve("typescript");
+      loaded2 = require2("typescript");
+    } catch (error) {
+      if (error.code !== "MODULE_NOT_FOUND")
+        unusable ??= `typescript was found but failed to load: ${error instanceof Error ? error.message : String(error)}`;
+      continue;
+    }
+    const typescript = loaded2.default ?? loaded2;
+    const problem = usable(typescript);
+    if (problem !== null) {
+      unusable ??= `${problem} (at ${packageFolder(file)}).`;
+      continue;
     }
+    return {
+      ready: true,
+      typescript,
+      resolution: {
+        name: "typescript",
+        version: typescript.version,
+        source,
+        resolved_from: packageFolder(file)
+      }
+    };
   }
-  return result;
+  if (unusable !== void 0)
+    return { ready: false, reason: "typescript_unusable", detail: unusable };
+  return {
+    ready: false,
+    reason: "typescript_missing",
+    detail: `typescript could not be resolved from ${cwd}${options.installer === false ? "" : " or from beside the installer"}.`
+  };
 }
-var init_installer = __esm({
-  "src/installer.ts"() {
+var SUPPORTED_TYPESCRIPT, INSTALL_TYPESCRIPT, packageFolder;
+var init_parser = __esm({
+  "src/parser.ts"() {
     "use strict";
     init_esm_shims();
-    init_args();
-    init_types();
+    SUPPORTED_TYPESCRIPT = "TypeScript 5 or 6";
+    INSTALL_TYPESCRIPT = "npm install -D typescript@6";
+    packageFolder = (file) => /^(.*[\\/]node_modules[\\/]typescript)[\\/]/.exec(file)?.[1] ?? file;
   }
 });
 
-// src/lookup.ts
-function distance(a, b) {
-  const row = Array.from({ length: b.length + 1 }, (_, index) => index);
-  for (let i = 1; i <= a.length; i++) {
-    let diagonal = row[0];
-    row[0] = i;
-    for (let j = 1; j <= b.length; j++) {
-      const above = row[j];
-      row[j] = Math.min(above + 1, row[j - 1] + 1, diagonal + (a[i - 1] === b[j - 1] ? 0 : 1));
-      diagonal = above;
-    }
-  }
-  return row[b.length];
-}
-function nearest(wanted, names, limit = 5) {
-  const target = squash(wanted);
-  return names.map((name) => {
-    const candidate = squash(name);
-    const apart = distance(target, candidate);
-    const close = apart <= 2 || target.length >= 3 && (candidate.includes(target) || target.includes(candidate));
-    return { name, apart, close };
-  }).filter(({ close }) => close).sort((a, b) => a.apart - b.apart || a.name.localeCompare(b.name)).slice(0, limit).map(({ name }) => name);
-}
-function resolveComponent(contract2, wanted) {
-  const names = Object.keys(contract2.components);
-  const found = names.find((name) => name === wanted) ?? names.find((name) => squash(name) === squash(wanted));
-  if (found !== void 0) return found;
-  const suggestions = nearest(wanted, names);
-  throw new CliError(
-    `Unknown component ${JSON.stringify(wanted)}.` + (suggestions.length > 0 ? ` Did you mean ${suggestions.join(", ")}?` : "") + " Run oprt component --list.",
-    2,
-    { code: "ERR_UNKNOWN_COMPONENT", suggestions }
-  );
-}
-function allowedChildren(rules, name) {
+// src/check.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { basename, extname, join as join2, relative, resolve, sep } from "path";
+function allowedChildren2(rules, name) {
   for (const [parent, rule] of Object.entries(rules ?? {})) {
     if (parent === name) return rule.allowed_children;
-    const nested = allowedChildren(rule.children, name);
+    const nested = allowedChildren2(rule.children, name);
     if (nested !== void 0) return nested;
   }
   return void 0;
 }
-function componentIndex(contract2) {
-  return Object.keys(contract2.components).filter((name) => (contract2.guidance.components[name]?.use_for ?? []).length > 0).sort((a, b) => a.localeCompare(b)).map((name) => ({
-    name,
-    purpose: contract2.guidance.components[name].use_for.join("; "),
-    parts: partsOf(contract2, name)
-  }));
-}
-function componentDetail(contract2, wanted) {
-  const name = resolveComponent(contract2, wanted);
-  const component = contract2.components[name];
-  const guide = contract2.guidance.components[name] ?? {};
-  const props = Object.entries(component.props).map(([prop, definition]) => {
-    const notes = guide.values?.[prop];
-    return { name: prop, ...definition, ...notes === void 0 ? {} : { notes } };
-  });
-  const allowed = allowedChildren(contract2.composition_rules, name);
-  return {
-    name,
-    description: component.description,
-    use_for: guide.use_for ?? [],
-    not_for: guide.not_for ?? [],
-    ...guide.part_of === void 0 ? {} : { part_of: guide.part_of },
-    parts: partsOf(contract2, name),
-    props,
-    ...component.slots === void 0 ? {} : { slots: component.slots },
-    composable_with: component.composable_with ?? [],
-    never_inside: component.never_inside ?? [],
-    ...allowed === void 0 ? {} : { allowed_children: allowed },
-    example: component.example
-  };
-}
-function propLine(prop, dense) {
-  const kind = prop.type === "enum" ? (prop.values ?? []).map((value) => value === prop.default ? `${value} (default)` : value).join(" | ") : (prop.type === "union" ? (prop.types ?? []).join(" or ") : prop.type) + (prop.default === void 0 ? "" : ` (default ${String(prop.default)})`);
-  const description = prop.description === void 0 ? "" : dense ? firstSentence(prop.description) : prop.description;
-  const lines = [
-    `  ${prop.name}: ${kind}${prop.required ? ", required" : ""}${description ? `. ${description}` : ""}`
-  ];
-  for (const [value, note] of Object.entries(prop.notes ?? {})) lines.push(`    ${value}: ${note}`);
-  return lines;
-}
-function renderComponent(detail, { dense }) {
-  const lines = [
-    detail.part_of === void 0 ? `${detail.name}: ${detail.use_for.join("; ")}` : `${detail.name}: a part of ${detail.part_of}. ${firstSentence(detail.description)}`
-  ];
-  if (detail.not_for.length > 0)
-    lines.push(
-      `Not for: ${detail.not_for.map(({ need, use }) => `${need} (use ${use})`).join("; ")}`
+function checkSource(typescript, contract2, file, text2) {
+  const ts = typescript;
+  const kind = /\.tsx$/.test(file) ? ts.ScriptKind.TSX : ts.ScriptKind.JSX;
+  const source = ts.createSourceFile(file, text2, ts.ScriptTarget.Latest, true, kind);
+  const parseDiagnostics = source.parseDiagnostics;
+  if (!Array.isArray(parseDiagnostics))
+    throw new CliError(
+      `This TypeScript does not report syntax errors on a parsed file, so a file that does not parse could be called clean. Install TypeScript 5 or 6 in this project (${INSTALL_TYPESCRIPT}).`,
+      1,
+      { code: "ERR_TYPESCRIPT_UNUSABLE" }
     );
-  if (!dense) lines.push("", detail.description, "");
-  if (detail.props.length > 0) {
-    lines.push("Props:");
-    for (const prop of detail.props) lines.push(...propLine(prop, dense));
+  if (parseDiagnostics.length > 0) {
+    const ordered = [...parseDiagnostics].sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
+    const shown = ordered.slice(0, MAX_SYNTAX_ERRORS);
+    return {
+      file,
+      status: "not_evaluated",
+      limitations: [],
+      findings: shown.map((diagnostic, index) => {
+        const { line, character } = source.getLineAndCharacterOfPosition(diagnostic.start ?? 0);
+        const more = ordered.length - shown.length;
+        return {
+          code: "SYNTAX_ERROR",
+          severity: "error",
+          file,
+          line: line + 1,
+          column: character + 1,
+          message: `${ts.flattenDiagnosticMessageText(diagnostic.messageText, " ")} (TS${diagnostic.code})` + (index === shown.length - 1 && more > 0 ? ` ${more} more syntax error${more === 1 ? "" : "s"} in this file not shown.` : "")
+        };
+      })
+    };
   }
-  for (const [slot, { type, required }] of Object.entries(detail.slots ?? {}))
-    lines.push(
-      `${slot === "children" ? "Children" : `Slot ${slot}`}: ${type}${required ? ", required" : ""}`
-    );
-  if (detail.parts.length > 0) lines.push(`Parts: ${detail.parts.join(", ")}`);
-  if (detail.allowed_children !== void 0)
-    lines.push(`Takes directly inside: ${detail.allowed_children.join(", ")}`);
-  if (detail.composable_with.length > 0)
-    lines.push(`Goes inside: ${detail.composable_with.join(", ")}`);
-  if (detail.never_inside.length > 0) lines.push(`Never inside: ${detail.never_inside.join(", ")}`);
-  lines.push(
-    detail.example.includes("\n") ? `Example:
-${detail.example.split("\n").map((line) => `  ${line}`).join("\n")}` : `Example: ${detail.example}`
-  );
-  return `${lines.join("\n")}
-`;
-}
-function search(contract2, registry2, query, limit = 10) {
-  const wanted = words(query);
-  if (wanted.length === 0) return [];
-  const whole = squash(query);
-  const scores = /* @__PURE__ */ new Map();
-  const add = (name, points, why) => {
-    const before = scores.get(name) ?? { score: 0 };
-    scores.set(name, {
-      score: before.score + points,
-      ...before.why !== void 0 ? { why: before.why } : why !== void 0 ? { why } : {}
-    });
-  };
-  for (const [name, component] of Object.entries(contract2.components)) {
-    const guide = contract2.guidance.components[name] ?? {};
-    const plain = squash(name);
-    if (plain === whole) add(name, 100);
-    else if (wanted.some((word) => word.length >= 3 && plain.includes(word))) add(name, 15);
-    else if (wanted.some((word) => word.length >= 4 && distance(word, plain) <= 1)) add(name, 12);
-    for (const phrase of guide.use_for ?? []) {
-      const hits = matched(wanted, phrase);
-      if (hits > 0) add(name, 12 * hits + (hits === wanted.length ? 40 : 0));
-    }
-    for (const { need, use } of guide.not_for ?? []) {
-      const hits = matched(wanted, need);
-      if (hits > 0 && hits >= Math.ceil(wanted.length * 0.6))
-        add(use, 10 * hits + (hits === wanted.length ? 15 : 0), `${name} is not for this: ${need}`);
-    }
-    const inDescription = matched(wanted, component.description);
-    if (inDescription > 0) add(name, 2 * inDescription);
-  }
-  const results = [];
-  for (const [name, { score, why }] of scores) {
-    const guide = contract2.guidance.components[name] ?? {};
-    results.push({
-      kind: "component",
-      name,
-      purpose: guide.part_of === void 0 ? (guide.use_for ?? []).join("; ") : `a part of ${guide.part_of}`,
-      score,
-      ...why === void 0 ? {} : { why },
-      next: `oprt component ${name}`
-    });
-  }
-  for (const entry of registry2.entries.filter(({ kind }) => kind === "recipe")) {
-    const recipe = contract2.patterns?.[entry.name];
-    const plain = squash(entry.name);
-    const inName = plain === whole ? 100 : wanted.some((word) => word.length >= 3 && plain.includes(word)) ? 15 : 0;
-    const hits = matched(wanted, entry.description);
-    const score = inName + (hits > 0 ? 10 * hits + (hits === wanted.length ? 15 : 0) : 0);
-    if (score > 0)
-      results.push({
-        kind: "recipe",
-        name: entry.name,
-        purpose: firstSentence(entry.description),
-        score,
-        next: recipe?.install ?? `oprt add ${entry.slug}`
-      });
-  }
-  results.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
-  const floor = Math.max(4, (results[0]?.score ?? 0) * 0.15);
-  return results.filter(({ score }) => score >= floor).slice(0, limit);
-}
-var squash, firstSentence, partsOf, STOP, words, matched;
-var init_lookup = __esm({
-  "src/lookup.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_types();
-    squash = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
-    firstSentence = (text2) => /^.*?[.!?](?=\s|$)/.exec(text2)?.[0] ?? text2;
-    partsOf = (contract2, name) => Object.keys(contract2.components).filter(
-      (part) => contract2.guidance.components[part]?.part_of === name
-    );
-    STOP = new Set(
-      "a an the to of for in on at with and or i we need want that which is are it its my some from by".split(
-        " "
-      )
-    );
-    words = (text2) => (text2.toLowerCase().match(/[a-z0-9]+/g) ?? []).filter((word) => !STOP.has(word)).map((word) => word.length > 4 ? word.replace(/(?:ing|ed|es|s)$/, "") : word);
-    matched = (query, text2) => {
-      const present = new Set(words(text2));
-      return query.filter((word) => present.has(word)).length;
-    };
-  }
-});
-
-// src/check.ts
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3, statSync } from "fs";
-import { createRequire } from "module";
-import { basename, extname, join as join2, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-function allowedChildren2(rules, name) {
-  for (const [parent, rule] of Object.entries(rules ?? {})) {
-    if (parent === name) return rule.allowed_children;
-    const nested = allowedChildren2(rule.children, name);
-    if (nested !== void 0) return nested;
-  }
-  return void 0;
-}
-function checkSource(typescript, contract2, file, text2) {
-  const ts = typescript;
-  const kind = /\.tsx$/.test(file) ? ts.ScriptKind.TSX : ts.ScriptKind.JSX;
-  const source = ts.createSourceFile(file, text2, ts.ScriptTarget.Latest, true, kind);
   const findings = [];
+  const limitations = [];
+  const limit = (node, limitation) => {
+    const { line, character } = source.getLineAndCharacterOfPosition(node.getStart(source));
+    limitations.push({ ...limitation, file, line: line + 1, column: character + 1 });
+  };
   const report = (node, finding) => {
     const { line, character } = source.getLineAndCharacterOfPosition(node.getStart(source));
     findings.push({
@@ -705,6 +593,31 @@ function checkSource(typescript, contract2, file, text2) {
     return [];
   };
   const valueOf = (attribute) => attribute.initializer === void 0 ? void 0 : ts.isJsxExpression(attribute.initializer) ? attribute.initializer.expression : attribute.initializer;
+  const optionValue = (expression) => {
+    const read = [];
+    const unread = [];
+    const walk = (node) => {
+      if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+        read.push(node.text);
+      else if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isNonNullExpression(node) || ts.isTypeAssertionExpression(node) || typeof ts.isSatisfiesExpression === "function" && ts.isSatisfiesExpression(node))
+        walk(node.expression);
+      else if (ts.isConditionalExpression(node)) {
+        walk(node.whenTrue);
+        walk(node.whenFalse);
+      } else if (ts.isBinaryExpression(node)) {
+        const operator = node.operatorToken.kind;
+        if (operator === ts.SyntaxKind.QuestionQuestionToken || operator === ts.SyntaxKind.BarBarToken) {
+          walk(node.left);
+          walk(node.right);
+        } else if (operator === ts.SyntaxKind.AmpersandAmpersandToken) walk(node.right);
+        else unread.push(node);
+      } else if (!// No value: the component's default applies.
+      (ts.isIdentifier(node) && node.text === "undefined" || node.kind === ts.SyntaxKind.NullKeyword))
+        unread.push(node);
+    };
+    if (expression) walk(expression);
+    return { literals: read, unread };
+  };
   const classText = (expression) => {
     if (!expression) return "";
     if (ts.isTemplateExpression(expression))
@@ -777,6 +690,13 @@ function checkSource(typescript, contract2, file, text2) {
     if (component === null) return null;
     const definition = contract2.components[component];
     const spread = attributes.some((attribute) => ts.isJsxSpreadAttribute(attribute));
+    for (const attribute of attributes)
+      if (ts.isJsxSpreadAttribute(attribute))
+        limit(attribute, {
+          code: "UNRESOLVED_SPREAD",
+          component,
+          message: `Props spread into <${component}> (${quote(attribute.getText(source))}) were not read: option values and required props that arrive through them were not checked.`
+        });
     const given = /* @__PURE__ */ new Set();
     for (const attribute of attributes) {
       if (!ts.isJsxAttribute(attribute)) continue;
@@ -785,18 +705,26 @@ function checkSource(typescript, contract2, file, text2) {
       const known = Object.hasOwn(definition.props, prop) ? definition.props[prop] : void 0;
       if (known === void 0) {
         if (nativeAttribute(prop) || Object.hasOwn(definition.slots ?? {}, prop)) continue;
-        const names = Object.keys(definition.props);
+        const names2 = Object.keys(definition.props);
         report(attribute, {
           code: "UNKNOWN_PROP",
           severity: "warning",
           component,
           prop,
-          message: `${component} has no prop ${prop}.` + (names.length === 0 ? " It takes no props of its own." : ` Its props: ${names.slice(0, 14).join(", ")}${names.length > 14 ? ", \u2026" : ""}.`)
+          message: `${component} has no prop ${prop}.` + (names2.length === 0 ? " It takes no props of its own." : ` Its props: ${names2.slice(0, 14).join(", ")}${names2.length > 14 ? ", \u2026" : ""}.`)
         });
         continue;
       }
       if (known.type !== "enum" || known.values === void 0) continue;
-      for (const literal of literals(valueOf(attribute))) {
+      const { literals: options, unread } = optionValue(valueOf(attribute));
+      for (const expression of unread)
+        limit(attribute, {
+          code: "UNRESOLVED_VALUE",
+          component,
+          prop,
+          message: `${component} ${prop} is set from an expression (${quote(expression.getText(source))}) whose value is not in the source, so it was not compared with the options.`
+        });
+      for (const literal of options) {
         if (known.values.includes(literal)) continue;
         const elsewhere = Object.entries(contract2.components).filter(([, other]) => other.props[prop]?.values?.includes(literal)).map(([name]) => name);
         report(attribute, {
@@ -866,94 +794,949 @@ function checkSource(typescript, contract2, file, text2) {
     ts.forEachChild(node, (child) => visit(child, ancestors, parent));
   };
   visit(source, [], null);
-  return findings.sort((a, b) => a.line - b.line || a.column - b.column);
+  const byPlace = (a, b) => a.line - b.line || a.column - b.column;
+  return {
+    file,
+    status: limitations.length > 0 ? "partial" : "evaluated",
+    findings: findings.sort(byPlace),
+    limitations: limitations.sort(byPlace)
+  };
 }
 function* sources(path2) {
-  const name = basename(path2);
-  if (SKIPPED.has(name) || name.startsWith(".") && name !== "." && name !== "..") return;
+  if (excluded(basename(path2))) return;
   if (statSync(path2).isDirectory()) {
     for (const entry of readdirSync(path2).sort()) yield* sources(join2(path2, entry));
-  } else if (READ.has(extname(path2)) && !NOT_INTERFACE.test(name)) yield path2;
+  } else if (READ.has(extname(path2)) && !NOT_INTERFACE.test(basename(path2))) yield path2;
 }
-function findTypeScript(cwd) {
-  for (const from of [join2(cwd, "package.json"), fileURLToPath3(import.meta.url)]) {
-    try {
-      return createRequire(from)("typescript");
-    } catch {
-    }
+function whyNotRead(path2) {
+  const name = basename(path2);
+  if (excluded(name)) return "excluded_folder";
+  if (statSync(path2).isDirectory()) return null;
+  if (!READ.has(extname(path2))) return "unsupported_extension";
+  return NOT_INTERFACE.test(name) ? "test_or_story_file" : null;
+}
+function buildCheckReport(evaluations, context) {
+  const findings = evaluations.flatMap(({ findings: found }) => found);
+  const count = (status2) => evaluations.filter((evaluation) => evaluation.status === status2).length;
+  const partial = count("partial");
+  const notEvaluated = count("not_evaluated");
+  const evaluated = evaluations.length - notEvaluated;
+  const errors = findings.filter(({ severity }) => severity === "error").length;
+  const warnings = findings.length - errors;
+  let status;
+  if (evaluations.length === 0) status = "no_files_evaluated";
+  else if (evaluated === 0) status = "not_evaluated";
+  else if (partial > 0 || notEvaluated > 0) status = "partially_evaluated";
+  else status = findings.length > 0 ? "evaluated_with_findings" : "evaluated_clean";
+  return {
+    evaluation_status: status,
+    files: evaluations.length,
+    findings,
+    summary: { errors, warnings },
+    coverage: {
+      files_found: evaluations.length,
+      files_evaluated: evaluated,
+      files_partial: partial,
+      files_not_evaluated: notEvaluated
+    },
+    limitations: evaluations.flatMap(({ limitations }) => limitations),
+    skipped_inputs: context.skipped ?? [],
+    scope: { checked: [...SCOPE.checked], not_checked: [...SCOPE.not_checked] },
+    parser: context.parser
+  };
+}
+function checkExitCode(report, { strict }) {
+  if (report.evaluation_status === "no_files_evaluated") return 1;
+  if (report.summary.errors > 0 || report.coverage.files_not_evaluated > 0) return 1;
+  return strict && report.summary.warnings > 0 ? 1 : 0;
+}
+function resolveParser(cwd, provided, who) {
+  if (provided !== void 0 && provided !== null)
+    return { typescript: provided, parser: describeProvided(provided) };
+  const probe = provided === null ? null : probeTypeScript(cwd);
+  if (probe?.ready) {
+    const { name, version, source } = probe.resolution;
+    return { typescript: probe.typescript, parser: { name, version, source } };
   }
-  return null;
+  if (probe !== null && probe.reason === "typescript_unusable")
+    throw new CliError(`${who} cannot use the TypeScript it found: ${probe.detail}`, 1, {
+      code: "ERR_TYPESCRIPT_UNUSABLE"
+    });
+  throw new CliError(
+    `${who} reads code with the project's TypeScript, and found none. Install typescript in this project (${INSTALL_TYPESCRIPT}) and run it again. It looked from ${cwd}.`,
+    1,
+    { code: "ERR_TYPESCRIPT_MISSING" }
+  );
 }
 function checkPaths(paths, context) {
-  const root = resolve2(context.cwd);
+  const root = resolve(context.cwd);
   const files = [];
+  const skipped = [];
   for (const path2 of paths) {
-    const absolute = resolve2(root, path2);
-    if (!existsSync2(absolute))
+    const absolute = resolve(root, path2);
+    if (!existsSync(absolute))
       throw new CliError(`No such file or folder: ${path2}`, 2, { code: "ERR_PATH_NOT_FOUND" });
+    const reason = whyNotRead(absolute);
+    if (reason !== null) skipped.push({ path: path2, reason });
     files.push(...sources(absolute));
   }
-  const ts = context.typescript === void 0 ? findTypeScript(root) : context.typescript;
-  if (ts === null)
-    throw new CliError(
-      "oprt check reads code with the project's TypeScript, and found none. Install typescript in this project (npm install -D typescript) and run it again.",
-      1,
-      { code: "ERR_TYPESCRIPT_MISSING" }
-    );
-  const findings = [...new Set(files)].flatMap(
-    (file) => checkSource(
-      ts,
-      context.contract,
-      relative2(root, file).split(sep2).join("/"),
-      readFileSync3(file, "utf8")
+  const { typescript, parser } = resolveParser(root, context.typescript, "oprt check");
+  const evaluations = [...new Set(files)].map(
+    (file) => checkSource(
+      typescript,
+      context.contract,
+      relative(root, file).split(sep).join("/"),
+      readFileSync(file, "utf8")
+    )
+  );
+  return buildCheckReport(evaluations, { parser, skipped });
+}
+function renderCheckText(report) {
+  const lines = report.findings.map(
+    ({ file, line, column, severity, code, message }) => `${file}:${line}:${column}  ${severity}  ${code}  ${message}`
+  );
+  const shown = report.limitations.slice(0, MAX_LIMITS_SHOWN);
+  for (const { file, line, column, code, message } of shown)
+    lines.push(`${file}:${line}:${column}  limit  ${code}  ${message}`);
+  if (report.limitations.length > shown.length)
+    lines.push(
+      `  ...and ${plural(report.limitations.length - shown.length, "more limit")}; the JSON lists them all.`
+    );
+  const { coverage, evaluation_status: status } = report;
+  if (status === "no_files_evaluated") {
+    lines.push("No .tsx or .jsx file was read, so nothing was checked.");
+    const labels = {
+      unsupported_extension: "not a .tsx or .jsx file",
+      test_or_story_file: "a test, spec or story file, which is skipped",
+      excluded_folder: "a folder that is skipped (node_modules, dist, build, out, coverage, hidden)"
+    };
+    for (const { path: path2, reason } of report.skipped_inputs)
+      lines.push(`  ${path2}: ${labels[reason]}`);
+  } else if (coverage.files_not_evaluated > 0)
+    lines.push(
+      `${plural(coverage.files_not_evaluated, "file")} did not parse and ${coverage.files_not_evaluated === 1 ? "was" : "were"} not checked against the contract.`
+    );
+  else if (status === "evaluated_clean")
+    lines.push(
+      "Nothing found. Checked syntax, option values, nesting, required props and the house rules; types and rendering are not checked."
+    );
+  lines.push(
+    `${plural(report.summary.errors, "error")}, ${plural(report.summary.warnings, "warning")} in ${plural(report.files, "file")}. Status: ${status}.`
+  );
+  return `${lines.join("\n")}
+`;
+}
+var FINDING_CODES, LIMITATION_CODES, SCOPE, PACKAGE, NATIVE, NATIVE_ATTRIBUTES, nativeAttribute, RAW_COLOR_CLASS, RAW_COLOR_VALUE, ARBITRARY_SIZE, ROUNDED_CORNER, quote, MAX_SYNTAX_ERRORS, SKIPPED, READ, NOT_INTERFACE, excluded, describeProvided, plural, MAX_LIMITS_SHOWN;
+var init_check = __esm({
+  "src/check.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_lookup();
+    init_parser();
+    init_types();
+    init_parser();
+    FINDING_CODES = [
+      "INVALID_PROP_VALUE",
+      "UNKNOWN_EXPORT",
+      "DOT_NOTATION",
+      "INVALID_NESTING",
+      "INVALID_CHILD",
+      "MISSING_REQUIRED_PROP",
+      "UNKNOWN_PROP",
+      "RAW_COLOR",
+      "ARBITRARY_SIZE",
+      "ROUNDED_CORNER",
+      "NATIVE_CONTROL",
+      /** The file does not parse. It was not checked against the contract. */
+      "SYNTAX_ERROR"
+    ];
+    LIMITATION_CODES = ["UNRESOLVED_SPREAD", "UNRESOLVED_VALUE"];
+    SCOPE = {
+      checked: ["syntax", "contract", "house_rules"],
+      not_checked: ["types", "render"]
+    };
+    PACKAGE = "@oprt/react";
+    NATIVE = {
+      button: "Button",
+      input: "Input, or the control for its type (Checkbox, RadioGroup, NumberInput, Slider, DatePicker, FileUpload)",
+      select: "Select",
+      textarea: "Textarea",
+      table: "DataTable or DataGrid",
+      dialog: "Dialog",
+      progress: "Progress",
+      hr: "Divider"
+    };
+    NATIVE_ATTRIBUTES = new Set(
+      `key ref children className style id title role tabIndex hidden lang dir slot draggable spellCheck
+  translate inert accessKey autoCapitalize contentEditable enterKeyHint inputMode
+  dangerouslySetInnerHTML suppressHydrationWarning suppressContentEditableWarning htmlFor type name
+  value defaultValue checked defaultChecked disabled readOnly required placeholder autoComplete
+  autoFocus min max step minLength maxLength pattern multiple accept form formAction href target rel
+  download src alt width height loading rows cols wrap open colSpan rowSpan scope headers label list
+  size method action encType noValidate popover popoverTarget popoverTargetAction asChild`.split(
+        /\s+/
+      )
+    );
+    nativeAttribute = (name) => NATIVE_ATTRIBUTES.has(name) || /^(aria-|data-)/.test(name) || /^on[A-Z]/.test(name);
+    RAW_COLOR_CLASS = /\[(?:#[0-9a-fA-F]{3,8}\b|rgba?\(|hsla?\()/;
+    RAW_COLOR_VALUE = /^#[0-9a-fA-F]{3,8}$|^(?:rgb|hsl)a?\(/;
+    ARBITRARY_SIZE = /(?:^|[\s:])-?[a-z][a-z0-9-]*-\[-?\d*\.?\d+px\]/;
+    ROUNDED_CORNER = /(?:^|[\s:])rounded(?!-none(?:\s|$))(?:-[^\s]+)?(?=\s|$)/;
+    quote = (text2) => {
+      const flat = text2.replace(/\s+/g, " ").trim();
+      return flat.length > 48 ? `${flat.slice(0, 45)}...` : flat;
+    };
+    MAX_SYNTAX_ERRORS = 10;
+    SKIPPED = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", "coverage"]);
+    READ = /* @__PURE__ */ new Set([".tsx", ".jsx"]);
+    NOT_INTERFACE = /\.(?:test|spec|stories)\.[jt]sx$/;
+    excluded = (name) => SKIPPED.has(name) || name.startsWith(".");
+    describeProvided = (typescript) => ({
+      name: "typescript",
+      version: typescript.version ?? "unknown",
+      source: "provided"
+    });
+    plural = (amount, word) => `${amount} ${word}${amount === 1 ? "" : "s"}`;
+    MAX_LIMITS_SHOWN = 20;
+  }
+});
+
+// package.json
+var package_default;
+var init_package = __esm({
+  "package.json"() {
+    package_default = {
+      name: "@oprt/cli",
+      version: "0.3.0",
+      description: "The OPERATOR command line: copy components and recipes into your app as source, give coding agents the contract, and check their code against it. Includes an MCP server.",
+      keywords: [
+        "design-system",
+        "cli",
+        "coding-agents",
+        "mcp",
+        "model-context-protocol",
+        "code-check",
+        "components"
+      ],
+      homepage: "https://oprt.dev/docs/agents/cli",
+      type: "module",
+      main: "./dist/index.cjs",
+      module: "./dist/index.js",
+      types: "./dist/index.d.ts",
+      bin: {
+        oprt: "./dist/bin.js"
+      },
+      engines: {
+        node: ">=22"
+      },
+      exports: {
+        ".": {
+          import: {
+            types: "./dist/index.d.ts",
+            default: "./dist/index.js"
+          },
+          require: {
+            types: "./dist/index.d.cts",
+            default: "./dist/index.cjs"
+          }
+        },
+        "./read": {
+          import: {
+            types: "./dist/read.d.ts",
+            default: "./dist/read.js"
+          },
+          require: {
+            types: "./dist/read.d.cts",
+            default: "./dist/read.cjs"
+          }
+        }
+      },
+      files: [
+        "dist"
+      ],
+      scripts: {
+        clean: `node -e "require('node:fs').rmSync('dist',{recursive:true,force:true})"`,
+        build: "pnpm run clean && node scripts/build-registry.mjs && tsup",
+        dev: "pnpm run clean && node scripts/build-registry.mjs && tsup --watch",
+        test: "vitest run",
+        typecheck: "tsc --noEmit",
+        lint: "eslint src scripts"
+      },
+      devDependencies: {
+        "@modelcontextprotocol/sdk": "1.32.1",
+        tsup: "^8.3.0",
+        typescript: "^5.6.3",
+        vitest: "^2.1.3"
+      },
+      license: "MIT",
+      publishConfig: {
+        access: "public"
+      }
+    };
+  }
+});
+
+// src/identity.ts
+import { createHash } from "crypto";
+function contractDigest(contract2) {
+  let digest = digests.get(contract2);
+  if (digest === void 0) {
+    digest = `sha256:${createHash("sha256").update(JSON.stringify(contract2)).digest("hex")}`;
+    digests.set(contract2, digest);
+  }
+  return digest;
+}
+function identityOf(contract2) {
+  return {
+    cli_version: VERSION,
+    contract_version: contract2.version,
+    contract_digest: contractDigest(contract2),
+    schema_version: RESULT_SCHEMA_VERSION
+  };
+}
+var VERSION, RESULT_SCHEMA_VERSION, digests;
+var init_identity = __esm({
+  "src/identity.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_package();
+    VERSION = package_default.version;
+    RESULT_SCHEMA_VERSION = 1;
+    digests = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// src/results.ts
+function errorEnvelope(error, contract2) {
+  const known = error instanceof CliError ? error : void 0;
+  const identity = contract2 === void 0 ? { cli_version: VERSION, schema_version: RESULT_SCHEMA_VERSION } : (({ cli_version, schema_version, contract_version, contract_digest }) => ({
+    cli_version,
+    schema_version,
+    contract_version,
+    contract_digest
+  }))(identityOf(contract2));
+  return {
+    apiVersion: 1,
+    error: error instanceof Error ? error.message : String(error),
+    code: known?.code ?? "ERR_FAILED",
+    ...known?.suggestions === void 0 ? {} : { suggestions: known.suggestions },
+    identity
+  };
+}
+function componentData(detail, dense) {
+  if (!dense) return { ...detail, dense };
+  const { description: _description, ...rest } = detail;
+  return {
+    ...rest,
+    props: detail.props.map(
+      (prop) => prop.description === void 0 ? prop : { ...prop, description: firstSentence(prop.description) }
+    ),
+    dense
+  };
+}
+function instructionsData(contract2) {
+  return {
+    rules: contract2.guidance.rules.map(({ id, rule, wrong, right }) => ({
+      id,
+      rule,
+      ...wrong === void 0 ? {} : { wrong },
+      ...right === void 0 ? {} : { right }
+    })),
+    components: componentIndex(contract2),
+    recipes: Object.entries(contract2.patterns ?? {}).map(([name, { description, install: install2 }]) => ({
+      name,
+      description,
+      install: install2
+    }))
+  };
+}
+function bundle(root) {
+  const used = {};
+  const visit = (node) => {
+    if (Array.isArray(node)) node.forEach(visit);
+    else if (typeof node === "object" && node !== null) {
+      for (const [key, value] of Object.entries(node)) {
+        if (key === "$ref" && typeof value === "string") {
+          const name = value.replace("#/$defs/", "");
+          if (used[name] === void 0) {
+            used[name] = DEFS[name];
+            visit(DEFS[name]);
+          }
+        } else visit(value);
+      }
+    }
+  };
+  visit(root);
+  return { ...root, $defs: used };
+}
+function schemaFor(type) {
+  return bundle(type === "error" ? failure() : success(type));
+}
+function shareRepeats(schema) {
+  const count = /* @__PURE__ */ new Map();
+  const tally = (node) => {
+    if (Array.isArray(node)) node.forEach(tally);
+    else if (typeof node === "object" && node !== null) {
+      const text2 = JSON.stringify(node);
+      if (text2.length >= 30) count.set(text2, (count.get(text2) ?? 0) + 1);
+      Object.values(node).forEach(tally);
+    }
+  };
+  tally(schema);
+  const repeated = [...count].filter(([, times]) => times >= 3).map(([text2]) => text2);
+  if (repeated.length === 0) return schema;
+  const names2 = new Map(
+    repeated.map((text2, index) => [text2, index === 0 ? "strings" : `part${index}`])
+  );
+  const defs = {};
+  const rewrite = (node) => {
+    if (Array.isArray(node)) return node.map(rewrite);
+    if (typeof node !== "object" || node === null) return node;
+    const name = names2.get(JSON.stringify(node));
+    if (name !== void 0) {
+      defs[name] = node;
+      return { $ref: `#/$defs/${name}` };
+    }
+    return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, rewrite(value)]));
+  };
+  const rewritten = rewrite(schema);
+  return { ...rewritten, $defs: defs };
+}
+function outputSchemaFor(type) {
+  return shareRepeats({
+    type: "object",
+    properties: {
+      type: { const: type },
+      // The four versions and the digest; the docs name them, and so does every answer.
+      identity: { type: "object" },
+      data: SUMMARIES[type]
+    },
+    required: ["identity"],
+    anyOf: [{ required: ["data"] }, { required: ["error"] }]
+  });
+}
+var RESULT_TYPES, envelope, str, int, bool, arr, names, words2, ref, obj, scalar, DEFS, DATA, success, failure, S, I, B, list, shape, strings, SUMMARIES, RESULT_SCHEMAS;
+var init_results = __esm({
+  "src/results.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_check();
+    init_identity();
+    init_lookup();
+    init_types();
+    RESULT_TYPES = [
+      "check",
+      "search",
+      "component.detail",
+      "component.batch",
+      "component.list",
+      "init",
+      "doctor",
+      "add",
+      "list",
+      "instructions"
+    ];
+    envelope = (type, data, contract2) => ({
+      apiVersion: 1,
+      type,
+      identity: identityOf(contract2),
+      data
+    });
+    str = (extra = {}) => ({ type: "string", ...extra });
+    int = () => ({ type: "integer", minimum: 0 });
+    bool = () => ({ type: "boolean" });
+    arr = (items) => ({ type: "array", items });
+    names = () => arr(str());
+    words2 = (...values) => ({ type: "string", enum: [...values] });
+    ref = (name) => ({ $ref: `#/$defs/${name}` });
+    obj = (properties, optional = [], open = false) => ({
+      type: "object",
+      properties,
+      required: Object.keys(properties).filter((key) => !optional.includes(key)),
+      additionalProperties: open
+    });
+    scalar = { type: ["string", "number", "boolean"] };
+    DEFS = {
+      identity: obj({
+        cli_version: str(),
+        contract_version: str(),
+        contract_digest: str({ pattern: "^sha256:[0-9a-f]{64}$" }),
+        schema_version: { type: "integer", minimum: 1 }
+      }),
+      error_identity: obj(
+        {
+          cli_version: str(),
+          schema_version: { type: "integer", minimum: 1 },
+          contract_version: str(),
+          contract_digest: str({ pattern: "^sha256:[0-9a-f]{64}$" })
+        },
+        ["contract_version", "contract_digest"]
+      ),
+      finding: obj(
+        {
+          code: words2(...FINDING_CODES),
+          severity: words2("error", "warning"),
+          file: str(),
+          line: { type: "integer", minimum: 1 },
+          column: { type: "integer", minimum: 1 },
+          component: str(),
+          prop: str(),
+          message: str(),
+          valid_values: names(),
+          suggestions: names()
+        },
+        ["component", "prop", "valid_values", "suggestions"]
+      ),
+      limitation: obj(
+        {
+          code: words2(...LIMITATION_CODES),
+          file: str(),
+          line: { type: "integer", minimum: 1 },
+          column: { type: "integer", minimum: 1 },
+          component: str(),
+          prop: str(),
+          message: str()
+        },
+        ["prop"]
+      ),
+      skipped_input: obj({
+        path: str(),
+        reason: words2("unsupported_extension", "test_or_story_file", "excluded_folder")
+      }),
+      parser: obj({
+        name: words2("typescript"),
+        version: str(),
+        source: words2("project", "installer", "provided")
+      }),
+      check_data: obj({
+        evaluation_status: words2(
+          "evaluated_clean",
+          "evaluated_with_findings",
+          "partially_evaluated",
+          "not_evaluated",
+          "no_files_evaluated"
+        ),
+        files: int(),
+        findings: arr(ref("finding")),
+        summary: obj({ errors: int(), warnings: int() }),
+        coverage: obj({
+          files_found: int(),
+          files_evaluated: int(),
+          files_partial: int(),
+          files_not_evaluated: int()
+        }),
+        limitations: arr(ref("limitation")),
+        skipped_inputs: arr(ref("skipped_input")),
+        scope: obj({ checked: names(), not_checked: names() }),
+        parser: ref("parser")
+      }),
+      search_result: obj(
+        {
+          kind: words2("component", "recipe"),
+          name: str(),
+          purpose: str(),
+          score: { type: "number" },
+          why: str(),
+          next: str()
+        },
+        ["why"]
+      ),
+      search_data: obj({
+        query: str(),
+        limit: { type: "integer", minimum: 1 },
+        matchCount: int(),
+        results: arr(ref("search_result"))
+      }),
+      index_entry: obj({ name: str(), purpose: str(), parts: names() }),
+      component_list_data: obj({ components: arr(ref("index_entry")) }),
+      detail_prop: obj(
+        {
+          name: str(),
+          type: str(),
+          values: names(),
+          types: names(),
+          default: scalar,
+          required: bool(),
+          description: str(),
+          notes: { type: "object", additionalProperties: str() }
+        },
+        ["values", "types", "default", "required", "description", "notes"],
+        // The contract may describe a prop with more than these (an array's item type, for one).
+        true
+      ),
+      component_detail: obj(
+        {
+          name: str(),
+          description: str(),
+          use_for: names(),
+          not_for: arr(obj({ need: str(), use: str() })),
+          part_of: str(),
+          parts: names(),
+          props: arr(ref("detail_prop")),
+          slots: {
+            type: "object",
+            additionalProperties: obj({ type: str(), required: bool() }, ["required"])
+          },
+          composable_with: names(),
+          never_inside: names(),
+          allowed_children: names(),
+          example: str(),
+          dense: bool()
+        },
+        ["description", "part_of", "slots", "allowed_children"]
+      ),
+      component_batch_data: obj({ components: arr(ref("component_detail")) }),
+      doctor_check: obj(
+        { id: str(), status: words2("ok", "warn", "fail"), message: str(), fix: str() },
+        ["fix"]
+      ),
+      doctor_data: obj({
+        consumer_directory: str(),
+        operations: obj({
+          lookup: obj({ status: words2("ready"), message: str(), contract_version: str() }),
+          check_code: obj(
+            {
+              status: words2("ready", "blocked"),
+              message: str(),
+              reason: words2("typescript_missing", "typescript_unusable"),
+              fix: str(),
+              typescript: obj({
+                version: str(),
+                resolved_from: str(),
+                source: words2("project", "installer", "provided")
+              })
+            },
+            ["reason", "fix", "typescript"]
+          )
+        }),
+        checks: arr(ref("doctor_check")),
+        summary: obj({ ok: int(), warn: int(), fail: int() })
+      }),
+      init_data: obj({
+        version: str(),
+        dryRun: bool(),
+        files: arr(
+          obj({
+            path: str(),
+            action: words2("create", "append", "update", "unchanged", "remove", "delete", "absent")
+          })
+        )
+      }),
+      install_file: obj({
+        path: str(),
+        destination: str(),
+        action: words2("create", "overwrite", "skip")
+      }),
+      add_data: obj({
+        outputDirectory: str(),
+        entries: names(),
+        dependencies: names(),
+        devDependencies: names(),
+        ranges: { type: "object", additionalProperties: str() },
+        files: arr(ref("install_file")),
+        dryRun: bool(),
+        setup: ref("setup")
+      }),
+      setup: obj({
+        tailwind: str(),
+        packages: arr(obj({ name: str(), range: str(), dev: bool(), why: str() })),
+        stylesheet: arr(obj({ line: str(), why: str() })),
+        root_import: obj({ line: str(), note: str() }),
+        not_needed: arr(obj({ name: str(), why: str() }))
+      }),
+      list_data: obj({
+        version: str(),
+        entries: arr(
+          obj(
+            {
+              name: str(),
+              slug: str(),
+              kind: words2("component", "recipe"),
+              description: str(),
+              files: names(),
+              dependencies: names(),
+              devDependencies: names()
+            },
+            ["devDependencies"]
+          )
+        ),
+        ranges: { type: "object", additionalProperties: str() }
+      }),
+      instructions_data: obj({
+        rules: arr(obj({ id: str(), rule: str(), wrong: str(), right: str() }, ["wrong", "right"])),
+        components: arr(ref("index_entry")),
+        recipes: arr(obj({ name: str(), description: str(), install: str() }))
+      })
+    };
+    DATA = {
+      check: "check_data",
+      search: "search_data",
+      "component.detail": "component_detail",
+      "component.batch": "component_batch_data",
+      "component.list": "component_list_data",
+      init: "init_data",
+      doctor: "doctor_data",
+      add: "add_data",
+      list: "list_data",
+      instructions: "instructions_data"
+    };
+    success = (type) => obj({
+      apiVersion: { const: 1 },
+      type: { const: type },
+      identity: ref("identity"),
+      data: ref(DATA[type])
+    });
+    failure = () => obj(
+      {
+        apiVersion: { const: 1 },
+        error: str(),
+        code: str({ pattern: "^ERR_[A-Z_]+$" }),
+        suggestions: names(),
+        identity: ref("error_identity")
+      },
+      ["suggestions"]
+    );
+    S = { type: "string" };
+    I = { type: "integer" };
+    B = { type: "boolean" };
+    list = (items) => items === void 0 ? { type: "array" } : { type: "array", items };
+    shape = (properties, required) => ({
+      type: "object",
+      properties,
+      ...required === void 0 ? {} : { required }
+    });
+    strings = list(S);
+    SUMMARIES = {
+      check: shape(
+        {
+          evaluation_status: words2(
+            "evaluated_clean",
+            "evaluated_with_findings",
+            "partially_evaluated",
+            "not_evaluated",
+            "no_files_evaluated"
+          ),
+          findings: list(
+            shape({
+              code: S,
+              severity: words2("error", "warning"),
+              file: S,
+              line: I,
+              column: I,
+              message: S
+            })
+          ),
+          summary: shape({ errors: I, warnings: I }),
+          coverage: shape({ files_evaluated: I, files_partial: I, files_not_evaluated: I }),
+          limitations: list(shape({ code: S, file: S, line: I, column: I, message: S })),
+          skipped_inputs: list(),
+          scope: { type: "object" },
+          parser: { type: "object" }
+        },
+        ["evaluation_status", "findings", "summary", "coverage", "limitations"]
+      ),
+      search: shape(
+        {
+          matchCount: I,
+          results: list(
+            shape({ kind: words2("component", "recipe"), name: S, purpose: S, why: S, next: S })
+          )
+        },
+        ["results"]
+      ),
+      "component.detail": shape(
+        {
+          name: S,
+          description: S,
+          use_for: strings,
+          not_for: list(),
+          part_of: S,
+          parts: strings,
+          props: list(
+            shape({ name: S, type: S, values: strings, required: B, notes: { type: "object" } })
+          ),
+          slots: { type: "object" },
+          composable_with: strings,
+          never_inside: strings,
+          allowed_children: strings,
+          example: S,
+          dense: B
+        },
+        ["name", "props", "example", "dense"]
+      ),
+      "component.list": shape({ components: list() }, ["components"]),
+      "component.batch": shape({ components: list() }, ["components"]),
+      instructions: shape(
+        {
+          rules: list(),
+          components: list(),
+          recipes: list()
+        },
+        ["rules", "components", "recipes"]
+      ),
+      init: shape({ files: list() }),
+      doctor: shape({ operations: { type: "object" }, checks: list() }),
+      add: shape({ files: list(), setup: { type: "object" } }),
+      list: shape({ entries: list() })
+    };
+    RESULT_SCHEMAS = Object.freeze(
+      Object.fromEntries(
+        [...RESULT_TYPES, "error"].map((type) => [type, schemaFor(type)])
+      )
+    );
+  }
+});
+
+// src/contract.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { dirname, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function loadContract() {
+  const here = dirname(fileURLToPath3(import.meta.url));
+  const candidates = [join3(here, "contract.json"), join3(here, "../generated/contract.json")];
+  const found = candidates.find((candidate) => existsSync2(candidate));
+  if (found === void 0) {
+    throw new Error(
+      `contract.json is missing next to ${here}. Install @oprt/cli again: the contract ships beside the executable, and the executable cannot be copied without it.`
+    );
+  }
+  return JSON.parse(readFileSync2(found, "utf8"));
+}
+var init_contract = __esm({
+  "src/contract.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/installer.ts
+import {
+  constants,
+  closeSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync as readFileSync3,
+  realpathSync,
+  writeFileSync
+} from "fs";
+import { dirname as dirname2, isAbsolute, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
+function resolveEntries(names2, registry2) {
+  if (!names2.length) throw new CliError("add requires one or more names.", 2);
+  const selected = /* @__PURE__ */ new Map();
+  for (const name of names2) {
+    const normalized = name.toLowerCase();
+    const entry = registry2.entries.find(
+      (candidate) => candidate.slug === normalized || candidate.name.toLowerCase() === normalized
+    );
+    if (!entry)
+      throw new CliError(`Unknown component or recipe ${JSON.stringify(name)}. Run oprt list.`, 2);
+    selected.set(entry.name, entry);
+  }
+  return [...selected.values()];
+}
+function validateRelative(path2) {
+  if (!path2 || isAbsolute(path2) || /[\\:\0]/.test(path2) || path2.split("/").includes(".."))
+    throw new CliError(
+      `Unsafe path ${JSON.stringify(path2)}: use a nonempty relative path without traversal.`,
+      2
+    );
+}
+function stat(path2) {
+  try {
+    return lstatSync(path2);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function inspectPath(root, destination, directory = false) {
+  const path2 = relative2(root, destination);
+  if (path2 === ".." || path2.startsWith(`..${sep2}`) || isAbsolute(path2))
+    throw new CliError("Output path escapes the working directory.");
+  let cursor = root;
+  const segments = path2 ? path2.split(sep2) : [];
+  for (let i = 0; i < segments.length; i++) {
+    cursor = resolve2(cursor, segments[i]);
+    const info = stat(cursor);
+    if (!info) continue;
+    if (info.isSymbolicLink()) throw new CliError(`Refusing symlink in output path: ${cursor}`);
+    const needsDirectory = i < segments.length - 1 || directory;
+    if (needsDirectory && !info.isDirectory())
+      throw new CliError(`Output ancestor is not a directory: ${cursor}`);
+    if (!needsDirectory && !info.isFile())
+      throw new CliError(`Output target is not a regular file: ${cursor}`);
+  }
+  return stat(destination);
+}
+function installSources(options, context) {
+  const entries = resolveEntries(options.names, context.registry);
+  const out = options.out ?? DEFAULT_OUT;
+  validateRelative(out);
+  const root = realpathSync(context.cwd);
+  const outputDirectory = resolve2(root, out);
+  inspectPath(root, outputDirectory, true);
+  const paths = [...new Set(entries.flatMap((entry) => entry.files))].sort();
+  const files = paths.map((path2) => {
+    validateRelative(path2);
+    const content = context.registry.files[path2];
+    if (!Object.hasOwn(context.registry.files, path2) || typeof content !== "string")
+      throw new CliError(`Registry is missing source ${path2}.`);
+    const destination = resolve2(outputDirectory, path2);
+    const info = inspectPath(root, destination);
+    if (!info) return { path: path2, destination, action: "create" };
+    if (readFileSync3(destination, "utf8") === content) return { path: path2, destination, action: "skip" };
+    if (!options.overwrite)
+      throw new CliError(
+        `Refusing to overwrite modified file ${destination}. Use --overwrite to replace it explicitly.`
+      );
+    return { path: path2, destination, action: "overwrite" };
+  });
+  const dependencies = [...new Set(entries.flatMap((entry) => entry.dependencies))].sort();
+  const runtime = new Set(
+    entries.flatMap(
+      (entry) => entry.dependencies.filter((name) => !(entry.devDependencies ?? []).includes(name))
     )
   );
-  return {
-    files: new Set(files).size,
-    findings,
-    summary: {
-      errors: findings.filter(({ severity }) => severity === "error").length,
-      warnings: findings.filter(({ severity }) => severity === "warning").length
-    }
+  const result = {
+    outputDirectory,
+    entries: entries.map((entry) => entry.name),
+    dependencies,
+    devDependencies: dependencies.filter(
+      (name) => !runtime.has(name) && entries.some((entry) => (entry.devDependencies ?? []).includes(name))
+    ),
+    ranges: Object.fromEntries(
+      dependencies.flatMap((name) => {
+        const range = context.registry.ranges?.[name];
+        return range === void 0 ? [] : [[name, range]];
+      })
+    ),
+    files,
+    dryRun: options.dryRun ?? false
   };
+  if (result.dryRun) return result;
+  for (const file of files) {
+    if (file.action === "skip") continue;
+    inspectPath(root, file.destination);
+    const parent = dirname2(file.destination);
+    mkdirSync(parent, { recursive: true });
+    inspectPath(root, parent, true);
+    const flags = constants.O_WRONLY | constants.O_CREAT | (constants.O_NOFOLLOW ?? 0) | (file.action === "create" ? constants.O_EXCL : constants.O_TRUNC);
+    const descriptor = openSync(file.destination, flags, 420);
+    try {
+      writeFileSync(descriptor, context.registry.files[file.path]);
+    } finally {
+      closeSync(descriptor);
+    }
+  }
+  return result;
 }
-var PACKAGE, NATIVE, NATIVE_ATTRIBUTES, nativeAttribute, RAW_COLOR_CLASS, RAW_COLOR_VALUE, ARBITRARY_SIZE, ROUNDED_CORNER, SKIPPED, READ, NOT_INTERFACE;
-var init_check = __esm({
-  "src/check.ts"() {
+var init_installer = __esm({
+  "src/installer.ts"() {
     "use strict";
     init_esm_shims();
-    init_lookup();
+    init_args();
     init_types();
-    PACKAGE = "@oprt/react";
-    NATIVE = {
-      button: "Button",
-      input: "Input, or the control for its type (Checkbox, RadioGroup, NumberInput, Slider, DatePicker, FileUpload)",
-      select: "Select",
-      textarea: "Textarea",
-      table: "DataTable or DataGrid",
-      dialog: "Dialog",
-      progress: "Progress",
-      hr: "Divider"
-    };
-    NATIVE_ATTRIBUTES = new Set(
-      `key ref children className style id title role tabIndex hidden lang dir slot draggable spellCheck
-  translate inert accessKey autoCapitalize contentEditable enterKeyHint inputMode
-  dangerouslySetInnerHTML suppressHydrationWarning suppressContentEditableWarning htmlFor type name
-  value defaultValue checked defaultChecked disabled readOnly required placeholder autoComplete
-  autoFocus min max step minLength maxLength pattern multiple accept form formAction href target rel
-  download src alt width height loading rows cols wrap open colSpan rowSpan scope headers label list
-  size method action encType noValidate popover popoverTarget popoverTargetAction asChild`.split(
-        /\s+/
-      )
-    );
-    nativeAttribute = (name) => NATIVE_ATTRIBUTES.has(name) || /^(aria-|data-)/.test(name) || /^on[A-Z]/.test(name);
-    RAW_COLOR_CLASS = /\[(?:#[0-9a-fA-F]{3,8}\b|rgba?\(|hsla?\()/;
-    RAW_COLOR_VALUE = /^#[0-9a-fA-F]{3,8}$|^(?:rgb|hsl)a?\(/;
-    ARBITRARY_SIZE = /(?:^|[\s:])-?[a-z][a-z0-9-]*-\[-?\d*\.?\d+px\]/;
-    ROUNDED_CORNER = /(?:^|[\s:])rounded(?!-none(?:\s|$))(?:-[^\s]+)?(?=\s|$)/;
-    SKIPPED = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", "coverage"]);
-    READ = /* @__PURE__ */ new Set([".tsx", ".jsx"]);
-    NOT_INTERFACE = /\.(?:test|spec|stories)\.[jt]sx$/;
   }
 });
 
@@ -1039,16 +1822,20 @@ var init_agent_block = __esm({
 
 // src/doctor.ts
 import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname3, join as join3 } from "path";
+import { dirname as dirname3, join as join4 } from "path";
 function installedVersion(cwd, name) {
   for (let folder = cwd; ; folder = dirname3(folder)) {
-    const manifest = join3(folder, "node_modules", name, "package.json");
+    const manifest = join4(folder, "node_modules", name, "package.json");
     if (existsSync3(manifest))
       return JSON.parse(readFileSync4(manifest, "utf8")).version;
     if (dirname3(folder) === folder) return void 0;
   }
 }
-function doctor({ cwd, contract: contract2 }) {
+function doctor({
+  cwd,
+  contract: contract2,
+  parser = probeTypeScript(cwd)
+}) {
   const checks = [];
   for (const name of PACKAGES) {
     const version = installedVersion(cwd, name);
@@ -1070,7 +1857,7 @@ function doctor({ cwd, contract: contract2 }) {
     else checks.push({ id, status: "ok", message: `${name} ${version} is installed.` });
   }
   const written = INSTRUCTION_FILES.map((path2) => {
-    const file = join3(cwd, path2);
+    const file = join4(cwd, path2);
     return {
       path: path2,
       version: existsSync3(file) ? blockVersion(readFileSync4(file, "utf8")) : void 0
@@ -1097,8 +1884,55 @@ function doctor({ cwd, contract: contract2 }) {
       status: "ok",
       message: `${written.map(({ path: path2 }) => path2).join(", ")} carries the OPERATOR block (${contract2.version}).`
     });
+  const install2 = `${INSTALL_TYPESCRIPT} (or your package manager's equivalent), then run oprt doctor again. Lookups work without it.`;
+  let checkCode;
+  if (parser.ready) {
+    const { version, resolved_from, source } = parser.resolution;
+    checkCode = {
+      status: "ready",
+      message: `TypeScript ${version}, resolved from ${resolved_from}${source === "project" ? "" : " (beside oprt, not this project)"}.`,
+      typescript: { version, resolved_from, source }
+    };
+    checks.push(
+      source === "project" ? {
+        id: "typescript",
+        status: "ok",
+        message: `TypeScript ${version} is installed in this project (${resolved_from}).`
+      } : {
+        id: "typescript",
+        status: "warn",
+        message: `TypeScript ${version} is not in this project; the one beside oprt is used (${resolved_from}).`,
+        fix: `${INSTALL_TYPESCRIPT}, so checking reads code with a version installed in the project.`
+      }
+    );
+  } else {
+    checkCode = {
+      status: "blocked",
+      message: `${parser.reason}: ${parser.detail}`,
+      reason: parser.reason,
+      fix: install2
+    };
+    checks.push({
+      id: "typescript",
+      status: "fail",
+      message: `oprt check and the check_code tool cannot run (${parser.reason}): ${parser.detail}`,
+      fix: install2
+    });
+  }
   const count = (status) => checks.filter((check) => check.status === status).length;
-  return { checks, summary: { ok: count("ok"), warn: count("warn"), fail: count("fail") } };
+  return {
+    consumer_directory: cwd,
+    operations: {
+      lookup: {
+        status: "ready",
+        message: `search, component and list read the contract bundled with oprt (${contract2.version}): always available.`,
+        contract_version: contract2.version
+      },
+      check_code: checkCode
+    },
+    checks,
+    summary: { ok: count("ok"), warn: count("warn"), fail: count("fail") }
+  };
 }
 var PACKAGES, INSTRUCTION_FILES, minor;
 var init_doctor = __esm({
@@ -1106,6 +1940,7 @@ var init_doctor = __esm({
     "use strict";
     init_esm_shims();
     init_agent_block();
+    init_parser();
     PACKAGES = ["@oprt/react", "@oprt/tokens", "@oprt/tailwind"];
     INSTRUCTION_FILES = [
       "AGENTS.md",
@@ -1182,7 +2017,72 @@ var init_init = __esm({
   }
 });
 
+// src/setup.ts
+function setupFor(dependencies, contract2) {
+  const { setup } = contract2.guidance;
+  const scansPackage = dependencies.includes(setup.package_source.when);
+  return {
+    tailwind: setup.tailwind,
+    packages: setup.packages.map(({ name, range, dev, why }) => ({
+      name,
+      range: range ?? "latest",
+      dev,
+      why
+    })),
+    stylesheet: [
+      ...setup.stylesheet,
+      ...scansPackage ? [{ line: setup.package_source.line, why: setup.package_source.why }] : []
+    ],
+    root_import: { line: setup.root_import, note: setup.root_import_note },
+    not_needed: setup.not_needed
+  };
+}
+function renderSetup(setup, copiedPackageImports) {
+  const named = ({ name, range }) => range === "latest" ? name : `${name}@${range}`;
+  const runtime = setup.packages.filter(({ dev: dev2 }) => !dev2).map(named);
+  const dev = setup.packages.filter(({ dev: isDev }) => isDev).map(named);
+  return [
+    `Setup, once per project: ${setup.tailwind}`,
+    `  Install: ${runtime.join(", ")}; as dev dependencies: ${dev.join(", ")}.`,
+    "  In the stylesheet that imports tailwindcss, after the import:",
+    ...setup.stylesheet.map(({ line }) => `    ${line}`),
+    ...copiedPackageImports ? ["      (the @source path is relative to the stylesheet)"] : [
+      "      (source copied into the project is scanned by Tailwind 4 without an @source line)"
+    ],
+    `  At the application root, from JavaScript, before the stylesheet: ${setup.root_import.line}`,
+    ...setup.not_needed.map(({ name, why }) => `  Not needed: ${name}. ${why}`)
+  ];
+}
+var init_setup = __esm({
+  "src/setup.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
 // src/agent-commands.ts
+function renderInstall(result, setup) {
+  const lines = [
+    `${result.dryRun ? "Dry run" : "Installed"}: ${result.entries.join(", ")}`,
+    `Output: ${result.outputDirectory}`,
+    ...result.files.map((file) => `  ${file.action.padEnd(9)} ${file.path}`)
+  ];
+  const versioned = (name) => result.ranges[name] === void 0 ? name : `${name}@${result.ranges[name]}`;
+  const runtime = result.dependencies.filter((name) => !result.devDependencies.includes(name));
+  lines.push("", `Dependencies: ${runtime.map(versioned).join(", ")}`);
+  if (result.devDependencies.length > 0)
+    lines.push(
+      `Dev dependencies (types only): ${result.devDependencies.map(versioned).join(", ")}`
+    );
+  lines.push(
+    "",
+    ...renderSetup(setup, setup.stylesheet.length > 1),
+    "",
+    "Install what is missing yourself. No package configuration or stylesheet was changed."
+  );
+  return `${lines.join("\n")}
+`;
+}
 function runAgentCommand(command, context) {
   const { contract: contract2, registry: registry2, cwd } = context;
   switch (command.command) {
@@ -1194,14 +2094,15 @@ function runAgentCommand(command, context) {
             ({ name, purpose, parts }) => `${name}${parts.length > 0 ? ` (${parts.join(", ")})` : ""}: ${purpose}
 `
           ).join(""),
-          json: envelope("component.list", { components }),
+          json: envelope("component.list", { components }, contract2),
           exitCode: 0
         };
       }
       const details = command.names.map((name) => componentDetail(contract2, name));
+      const data = details.map((detail) => componentData(detail, command.dense));
       return {
         text: details.map((detail) => renderComponent(detail, { dense: command.dense })).join("\n"),
-        json: details.length === 1 ? envelope("component.detail", details[0]) : envelope("component.batch", { components: details }),
+        json: data.length === 1 ? envelope("component.detail", data[0], contract2) : envelope("component.batch", { components: data }, contract2),
         exitCode: 0
       };
     }
@@ -1214,7 +2115,11 @@ function runAgentCommand(command, context) {
   ${next}
 `
         ).join(""),
-        json: envelope("search", { query: command.query, matchCount: results.length, results }),
+        json: envelope(
+          "search",
+          { query: command.query, limit: command.limit, matchCount: results.length, results },
+          contract2
+        ),
         exitCode: 0
       };
     }
@@ -1225,55 +2130,195 @@ function runAgentCommand(command, context) {
         ...result.files.map(({ path: path2, action }) => `  ${action.padEnd(9)} ${path2}`),
         command.remove ? "The block was taken out; the rest of each file is as it was." : "Run oprt init again after an upgrade to refresh the block."
       ];
-      return { text: `${lines.join("\n")}
-`, json: envelope("init", result), exitCode: 0 };
+      return {
+        text: `${lines.join("\n")}
+`,
+        json: envelope("init", result, contract2),
+        exitCode: 0
+      };
     }
     case "check": {
       const report = checkPaths(command.paths, { cwd, contract: contract2 });
-      const { errors, warnings } = report.summary;
-      const lines = report.findings.map(
-        ({ file, line, column, severity, code, message }) => `${file}:${line}:${column}  ${severity}  ${code}  ${message}`
-      );
-      const count = (amount, word) => `${amount} ${word}${amount === 1 ? "" : "s"}`;
-      lines.push(
-        `${count(errors, "error")}, ${count(warnings, "warning")} in ${count(report.files, "file")}.`
-      );
       return {
-        text: `${lines.join("\n")}
-`,
-        json: envelope("check", report),
+        text: renderCheckText(report),
+        json: envelope("check", report, contract2),
         // Warnings fail the run only when asked to: they are house rules, or may be native attributes.
-        exitCode: errors > 0 || command.strict && warnings > 0 ? 1 : 0
+        exitCode: checkExitCode(report, { strict: command.strict })
       };
     }
     case "doctor": {
-      const report = doctor({ cwd, contract: contract2 });
-      const lines = report.checks.flatMap(({ status, message, fix }) => [
-        `[${status}] ${message}`,
-        ...fix === void 0 ? [] : [`       fix: ${fix}`]
-      ]);
+      const report = doctor({
+        cwd,
+        contract: contract2,
+        ...context.parser ? { parser: context.parser } : {}
+      });
+      const { lookup, check_code: checking } = report.operations;
+      const lines = [
+        "Readiness",
+        `  lookups        ${lookup.status.padEnd(8)} ${lookup.message}`,
+        `  code checking  ${checking.status.padEnd(8)} ${checking.message}`,
+        ...checking.fix === void 0 ? [] : [`                          fix: ${checking.fix}`],
+        "",
+        "Setup"
+      ];
+      lines.push(
+        ...report.checks.flatMap(({ status, message, fix }) => [
+          `[${status}] ${message}`,
+          ...fix === void 0 ? [] : [`       fix: ${fix}`]
+        ])
+      );
       lines.push(
         `${report.summary.ok} ok, ${report.summary.warn} to look at, ${report.summary.fail} failed.`
       );
       return {
         text: `${lines.join("\n")}
 `,
-        json: envelope("doctor", report),
+        json: envelope("doctor", report, contract2),
         exitCode: report.summary.fail > 0 ? 1 : 0
       };
     }
+    case "list": {
+      const lines = [`OPERATOR ${VERSION}`, ""];
+      for (const kind of ["component", "recipe"]) {
+        const entries = registry2.entries.filter((entry) => entry.kind === kind);
+        lines.push(`${kind === "component" ? "Components" : "Recipes"} (${entries.length})`);
+        for (const entry of entries) lines.push(`  ${entry.slug.padEnd(22)} ${entry.description}`);
+        lines.push("");
+      }
+      return {
+        text: `${lines.join("\n")}
+`,
+        json: envelope(
+          "list",
+          { version: VERSION, entries: registry2.entries, ranges: registry2.ranges ?? {} },
+          contract2
+        ),
+        exitCode: 0
+      };
+    }
+    case "add": {
+      const result = installSources(command, { cwd, registry: registry2 });
+      const setup = setupFor(result.dependencies, contract2);
+      return {
+        text: renderInstall(result, setup),
+        json: envelope("add", { ...result, setup }, contract2),
+        exitCode: 0
+      };
+    }
   }
 }
-var envelope;
 var init_agent_commands = __esm({
   "src/agent-commands.ts"() {
     "use strict";
     init_esm_shims();
     init_check();
     init_doctor();
+    init_identity();
     init_init();
+    init_installer();
     init_lookup();
-    envelope = (type, data) => ({ apiVersion: 1, type, data });
+    init_results();
+    init_setup();
+  }
+});
+
+// src/validate.ts
+function describeValue(value) {
+  if (typeof value === "string")
+    return `${JSON.stringify(value.length > 40 ? `${value.slice(0, 37)}...` : value)} (a string)`;
+  if (typeof value === "number") return Number.isNaN(value) ? "NaN" : String(value);
+  if (value === null || typeof value === "boolean" || value === void 0) return String(value);
+  return `${typeName(value)} (${JSON.stringify(value)?.slice(0, 40) ?? ""})`;
+}
+function expectation(schema) {
+  switch (schema.type) {
+    case "boolean":
+      return "true or false";
+    case "integer":
+    case "number": {
+      const noun = schema.type === "integer" ? "a whole number" : "a number";
+      if (schema.minimum !== void 0 && schema.maximum !== void 0)
+        return `${noun} from ${schema.minimum} to ${schema.maximum}`;
+      if (schema.minimum !== void 0) return `${noun} of at least ${schema.minimum}`;
+      if (schema.maximum !== void 0) return `${noun} of at most ${schema.maximum}`;
+      return noun;
+    }
+    case "string": {
+      if (schema.enum !== void 0) return `one of ${schema.enum.map(String).join(", ")}`;
+      const { minLength, maxLength } = schema;
+      if (minLength !== void 0 && maxLength !== void 0)
+        return `a string of ${minLength} to ${maxLength.toLocaleString("en-US")} characters`;
+      if (maxLength !== void 0)
+        return `a string of at most ${maxLength.toLocaleString("en-US")} characters`;
+      return "a string";
+    }
+  }
+}
+function accepts(schema, value) {
+  switch (schema.type) {
+    case "boolean":
+      return typeof value === "boolean";
+    case "string":
+      return typeof value === "string" && (schema.minLength === void 0 || value.length >= schema.minLength) && (schema.maxLength === void 0 || value.length <= schema.maxLength) && (schema.enum === void 0 || schema.enum.includes(value));
+    case "integer":
+    case "number":
+      return typeof value === "number" && Number.isFinite(value) && (schema.type === "number" || Number.isInteger(value)) && (schema.minimum === void 0 || value >= schema.minimum) && (schema.maximum === void 0 || value <= schema.maximum);
+  }
+}
+function validateArguments(tool, schema, args) {
+  for (const [field, property] of Object.entries(schema.properties))
+    for (const key of Object.keys(property))
+      if (!KNOWN.has(key))
+        throw new Error(`${tool}.${field}: the schema uses "${key}", which is not enforced.`);
+  if (typeof args !== "object" || args === null || Array.isArray(args))
+    return `${tool}: arguments must be an object.`;
+  const given = args;
+  const required = schema.required ?? [];
+  const blank = (value) => typeof value === "string" && value.trim() === "";
+  const missing = [];
+  const wrong = [];
+  const unknown = [];
+  for (const field of required)
+    if (given[field] === void 0 || blank(given[field])) missing.push(field);
+  for (const [field, value] of Object.entries(given)) {
+    const property = Object.hasOwn(schema.properties, field) ? schema.properties[field] : void 0;
+    if (property === void 0) unknown.push(field);
+    else if (value !== void 0 && !(required.includes(field) && blank(value))) {
+      if (!accepts(property, value))
+        wrong.push(`${field} must be ${expectation(property)}, but got ${describeValue(value)}`);
+    }
+  }
+  const reject = schema.additionalProperties === false ? unknown : [];
+  const names2 = Object.keys(schema.properties);
+  if (missing.length === 1 && wrong.length === 0 && reject.length === 0)
+    return `${tool} needs ${missing[0]}, ${expectation({ type: schema.properties[missing[0]].type })}.`;
+  const fragments = [
+    ...missing.map(
+      (field) => `${field} is required (${expectation({ type: schema.properties[field].type })})`
+    ),
+    ...wrong,
+    ...reject.map(
+      (field) => `unknown argument ${JSON.stringify(field)}. It takes${names2.length > 0 ? `: ${names2.join(", ")}` : " none"}`
+    )
+  ];
+  return fragments.length === 0 ? null : `${tool}: ${fragments.join("; ")}.`;
+}
+var KNOWN, typeName;
+var init_validate = __esm({
+  "src/validate.ts"() {
+    "use strict";
+    init_esm_shims();
+    KNOWN = /* @__PURE__ */ new Set([
+      "type",
+      "description",
+      "default",
+      "enum",
+      "minimum",
+      "maximum",
+      "minLength",
+      "maxLength"
+    ]);
+    typeName = (value) => value === null ? "null" : Array.isArray(value) ? "an array" : typeof value === "object" ? "an object" : typeof value === "number" ? "a number" : typeof value === "string" ? "a string" : typeof value === "boolean" ? "a boolean" : typeof value;
   }
 });
 
@@ -1281,75 +2326,88 @@ var init_agent_commands = __esm({
 import { createInterface } from "readline";
 function runTool(name, args, context) {
   const { contract: contract2, registry: registry2 } = context;
-  const required = (key) => {
-    const value = args[key];
-    if (typeof value !== "string" || value.trim() === "")
-      throw new Error(`${name} needs ${key}, a string.`);
-    return value;
-  };
+  const definition = TOOLS.find((tool) => tool.name === name);
+  if (definition === void 0) throw new UnknownTool(name);
+  const problem = validateArguments(name, definition.inputSchema, args);
+  if (problem !== null) throw new CliError(problem, 2, { code: "ERR_INVALID_ARGUMENT" });
   switch (name) {
     case "search": {
-      const query = required("query");
-      const results = search(
-        contract2,
-        registry2,
-        query,
-        typeof args.limit === "number" ? args.limit : 10
-      );
-      return results.length === 0 ? `Nothing matches ${JSON.stringify(query)}. Call list_components to see what there is.` : results.map(
-        ({ kind, name: found, purpose, why, next }) => `${found} (${kind}): ${purpose}${why === void 0 ? "" : ` [${why}]`}
+      const query = args["query"];
+      const limit = args["limit"] ?? SEARCH_LIMIT_DEFAULT;
+      const results = search(contract2, registry2, query, limit);
+      return {
+        text: results.length === 0 ? `Nothing matches ${JSON.stringify(query)}. Call list_components to see what there is.` : results.map(
+          ({ kind, name: found, purpose, why, next }) => `${found} (${kind}): ${purpose}${why === void 0 ? "" : ` [${why}]`}
   ${next}`
-      ).join("\n");
+        ).join("\n"),
+        structured: envelope(
+          "search",
+          { query, limit, matchCount: results.length, results },
+          contract2
+        )
+      };
+    }
+    case "get_component": {
+      const dense = args["dense"] ?? true;
+      const detail = componentDetail(contract2, args["name"]);
+      return {
+        text: renderComponent(detail, { dense }),
+        structured: envelope("component.detail", componentData(detail, dense), contract2)
+      };
+    }
+    case "list_components": {
+      const components = componentIndex(contract2);
+      return {
+        text: components.map(
+          ({ name: component, purpose, parts }) => `${component}${parts.length > 0 ? ` (${parts.join(", ")})` : ""}: ${purpose}`
+        ).join("\n"),
+        structured: envelope("component.list", { components }, contract2)
+      };
     }
-    case "get_component":
-      return renderComponent(componentDetail(contract2, required("name")), {
-        dense: args.dense !== false
-      });
-    case "list_components":
-      return componentIndex(contract2).map(
-        ({ name: component, purpose, parts }) => `${component}${parts.length > 0 ? ` (${parts.join(", ")})` : ""}: ${purpose}`
-      ).join("\n");
     case "get_instructions":
-      return renderAgentBlock(contract2).split("\n").filter((line) => line !== START && line !== END && !line.startsWith("<!-- Written by")).join("\n");
+      return {
+        text: renderAgentBlock(contract2).split("\n").filter((line) => line !== START && line !== END && !line.startsWith("<!-- Written by")).join("\n"),
+        structured: envelope("instructions", instructionsData(contract2), contract2)
+      };
     case "check_code": {
-      const code = required("code");
-      const ts = context.typescript === void 0 ? findTypeScript(context.cwd ?? process.cwd()) : context.typescript;
-      if (ts === null)
-        throw new Error("check_code reads code with TypeScript, and found none installed.");
-      const findings = checkSource(ts, contract2, "snippet.tsx", code);
-      if (findings.length === 0) return "No findings.";
-      const errors = findings.filter(({ severity }) => severity === "error").length;
-      const count = (amount, word) => `${amount} ${word}${amount === 1 ? "" : "s"}`;
-      return [
-        ...findings.map(
-          ({ line, column, severity, code: finding, message }) => `${line}:${column}  ${severity}  ${finding}  ${message}`
-        ),
-        `${count(errors, "error")}, ${count(findings.length - errors, "warning")}.`
-      ].join("\n");
+      const { typescript, parser } = resolveParser(
+        context.cwd ?? process.cwd(),
+        context.typescript,
+        "check_code"
+      );
+      const report = buildCheckReport(
+        [checkSource(typescript, contract2, "snippet.tsx", args["code"])],
+        { parser }
+      );
+      return { text: renderCheckText(report), structured: envelope("check", report, contract2) };
     }
     default:
       throw new UnknownTool(name);
   }
 }
 function handleMessage(raw, context) {
-  const failure = (id2, code, message) => ({
+  const failure2 = (id2, code, message) => ({
     jsonrpc: "2.0",
     id: id2 ?? null,
     error: { code, message }
   });
-  if (typeof raw !== "object" || raw === null) return failure(null, -32700, "Parse error");
+  if (typeof raw !== "object" || raw === null) return failure2(null, -32700, "Parse error");
   const { id, method, params } = raw;
-  if (typeof method !== "string") return failure(id, -32600, "Invalid request");
+  if (typeof method !== "string") return failure2(id, -32600, "Invalid request");
   if (id === void 0) return null;
   const result = (value) => ({ jsonrpc: "2.0", id, result: value });
   switch (method) {
     case "initialize": {
       const asked = params?.protocolVersion;
+      const identity = identityOf(context.contract);
       return result({
         protocolVersion: asked !== void 0 && VERSIONS.includes(asked) ? asked : VERSIONS[0],
         capabilities: { tools: {} },
-        serverInfo: { name: "oprt", version: context.contract.version },
-        instructions: "OPERATOR design system. Call get_instructions once, search for the component that answers a need, get_component before using one, and check_code before you finish."
+        // The program's version, not the contract's: the contract has its own, in `_meta` and in
+        // the identity of every result.
+        serverInfo: { name: "oprt", version: VERSION },
+        instructions: "OPERATOR design system. Call get_instructions once, search for the component that answers a need, get_component before using one, and check_code before you finish. check_code says how much it could read: only evaluated_clean means the code was read in full with nothing found.",
+        _meta: { "dev.oprt/identity": identity }
       });
     }
     case "ping":
@@ -1359,17 +2417,23 @@ function handleMessage(raw, context) {
     case "tools/call": {
       const { name, arguments: args } = params ?? {};
       try {
-        return result({ content: [text(runTool(String(name), args ?? {}, context))] });
+        const output = runTool(String(name), args ?? {}, context);
+        return result({
+          content: [text(output.text)],
+          structuredContent: output.structured
+        });
       } catch (error) {
-        if (error instanceof UnknownTool) return failure(id, -32602, error.message);
+        if (error instanceof UnknownTool) return failure2(id, -32602, error.message);
+        const failed = errorEnvelope(error, context.contract);
         return result({
-          content: [text(error instanceof Error ? error.message : String(error))],
+          content: [text(failed.error)],
+          structuredContent: failed,
           isError: true
         });
       }
     }
     default:
-      return failure(id, -32601, `Method not found: ${method}`);
+      return failure2(id, -32601, `Method not found: ${method}`);
   }
 }
 function serve(input, output, context) {
@@ -1388,64 +2452,108 @@ function serve(input, output, context) {
   });
   return new Promise((done) => lines.on("close", done));
 }
-var VERSIONS, text, string, TOOLS, UnknownTool;
+var VERSIONS, text, LIMITS, ANSWERS, readOnly, define, TOOLS, UnknownTool;
 var init_mcp = __esm({
   "src/mcp.ts"() {
     "use strict";
     init_esm_shims();
     init_agent_block();
     init_check();
+    init_identity();
     init_lookup();
+    init_results();
+    init_types();
+    init_validate();
     VERSIONS = ["2025-11-25", "2025-06-18", "2025-03-26", "2024-11-05"];
     text = (value) => ({ type: "text", text: value });
-    string = (description) => ({ type: "string", description });
+    LIMITS = { query: 500, name: 100, code: 2e5 };
+    ANSWERS = {
+      search: "search",
+      get_component: "component.detail",
+      list_components: "component.list",
+      get_instructions: "instructions",
+      check_code: "check"
+    };
+    readOnly = { readOnlyHint: true };
+    define = (tool) => ({
+      ...tool,
+      outputSchema: outputSchemaFor(ANSWERS[tool.name]),
+      annotations: readOnly
+    });
     TOOLS = [
-      {
+      define({
         name: "search",
-        description: "Find the OPERATOR component or recipe that answers a need, such as 'show a status' or 'table with selection'. Call this before writing interface code.",
+        description: "Find the OPERATOR component or recipe for a need, such as 'show a status' or 'table with selection'. Call before writing interface code.",
         inputSchema: {
           type: "object",
           properties: {
-            query: string("The need, in plain words."),
-            limit: { type: "number", description: "How many results to return. Default 10." }
+            query: {
+              type: "string",
+              minLength: 1,
+              maxLength: LIMITS.query,
+              description: "The need, in plain words."
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: SEARCH_LIMIT_MAX,
+              default: SEARCH_LIMIT_DEFAULT,
+              description: `Results to return, 1 to ${SEARCH_LIMIT_MAX}.`
+            }
           },
-          required: ["query"]
+          required: ["query"],
+          additionalProperties: false
         }
-      },
-      {
+      }),
+      define({
         name: "get_component",
-        description: "One OPERATOR component: what it is for, what to use instead, every prop and option value, its nesting rules and an example. Call this before using a component.",
+        description: "One component's contract: what it is for, what to use instead, every prop and option value, nesting rules, an example. Call before using a component.",
         inputSchema: {
           type: "object",
           properties: {
-            name: string("The component's name, such as Button or DataGrid."),
+            name: {
+              type: "string",
+              minLength: 1,
+              maxLength: LIMITS.name,
+              description: "Component name, such as Button."
+            },
             dense: {
               type: "boolean",
-              description: "The short form, which is the default. Pass false for full descriptions."
+              default: true,
+              description: "Compact form (every constraint, one sentence per prop). False: full prose."
             }
           },
-          required: ["name"]
+          required: ["name"],
+          additionalProperties: false
         }
-      },
-      {
+      }),
+      define({
         name: "list_components",
         description: "Every OPERATOR component in one line each, with its parts.",
-        inputSchema: { type: "object", properties: {} }
-      },
-      {
+        inputSchema: { type: "object", properties: {}, additionalProperties: false }
+      }),
+      define({
         name: "get_instructions",
-        description: "OPERATOR's house rules, its component index and its recipes: what to read once before building with it.",
-        inputSchema: { type: "object", properties: {} }
-      },
-      {
+        description: "OPERATOR's house rules, component index and recipes: read once before building.",
+        inputSchema: { type: "object", properties: {}, additionalProperties: false }
+      }),
+      define({
         name: "check_code",
-        description: "Check TSX code against OPERATOR's contract: option values, nesting, required props and the house rules. Call this on what you wrote before you finish.",
+        description: "Check TSX against OPERATOR's contract: option values, nesting, required props, house rules. Call before you finish. Read evaluation_status: only evaluated_clean means every file was read in full with nothing found. Types and rendering are not checked.",
         inputSchema: {
           type: "object",
-          properties: { code: string("The TSX source of one file.") },
-          required: ["code"]
+          properties: {
+            code: {
+              type: "string",
+              minLength: 1,
+              maxLength: LIMITS.code,
+              description: "The TSX source of one file."
+            }
+          },
+          required: ["code"],
+          additionalProperties: false
         }
-      }
+      })
     ];
     UnknownTool = class extends Error {
       constructor(name) {
@@ -1462,35 +2570,47 @@ var index_exports = {};
 __export(index_exports, {
   CliError: () => CliError,
   DEFAULT_OUT: () => DEFAULT_OUT,
+  RESULT_SCHEMAS: () => RESULT_SCHEMAS,
+  RESULT_SCHEMA_VERSION: () => RESULT_SCHEMA_VERSION,
+  RESULT_TYPES: () => RESULT_TYPES,
   TOOLS: () => TOOLS,
   VERSION: () => VERSION,
   applyBlock: () => applyBlock,
   blockVersion: () => blockVersion,
+  buildCheckReport: () => buildCheckReport,
+  checkExitCode: () => checkExitCode,
   checkPaths: () => checkPaths,
   checkSource: () => checkSource,
   componentDetail: () => componentDetail,
   componentIndex: () => componentIndex,
   contract: () => contract,
+  contractDigest: () => contractDigest,
   doctor: () => doctor,
+  envelope: () => envelope,
+  errorEnvelope: () => errorEnvelope,
   handleMessage: () => handleMessage,
+  identityOf: () => identityOf,
   init: () => init,
   install: () => install,
+  outputSchemaFor: () => outputSchemaFor,
   parseArgs: () => parseArgs,
   registry: () => registry,
   removeBlock: () => removeBlock,
   renderAgentBlock: () => renderAgentBlock,
+  renderCheckText: () => renderCheckText,
   renderComponent: () => renderComponent,
   resolveEntries: () => resolveEntries,
   runAgentCommand: () => runAgentCommand,
+  schemaFor: () => schemaFor,
   search: () => search,
   serve: () => serve
 });
 import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname5, join as join4 } from "path";
+import { dirname as dirname5, join as join5 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function loadRegistry() {
   const here = dirname5(fileURLToPath4(import.meta.url));
-  const candidates = [join4(here, "registry.json"), join4(here, "../generated/registry.json")];
+  const candidates = [join5(here, "registry.json"), join5(here, "../generated/registry.json")];
   const found = candidates.find((candidate) => existsSync5(candidate));
   if (found === void 0) {
     throw new Error(
@@ -1505,15 +2625,17 @@ function install(options, context = {}) {
     registry: context.registry ?? registry
   });
 }
-var VERSION, registry, loaded, contract;
+var registry, loaded, contract;
 var init_index = __esm({
   "src/index.ts"() {
     "use strict";
     init_esm_shims();
-    init_package();
     init_contract();
     init_installer();
+    init_identity();
     init_agent_commands();
+    init_identity();
+    init_results();
     init_agent_block();
     init_check();
     init_doctor();
@@ -1523,7 +2645,6 @@ var init_index = __esm({
     init_args();
     init_installer();
     init_types();
-    VERSION = package_default.version;
     registry = loadRegistry();
     contract = () => loaded ??= loadContract();
   }
@@ -1532,6 +2653,7 @@ var init_index = __esm({
 // src/bin.ts
 init_esm_shims();
 init_args();
+init_results();
 init_types();
 var helpText = (version) => `oprt ${version} \u2014 OPERATOR source installer
 
@@ -1551,11 +2673,19 @@ For coding agents (each takes --json):
   oprt component --list       Every component, one line each.
   oprt check <paths...> [--strict]
                                      Check written code against the contract: option values,
-                                     nesting, required props, house rules. Exits 1 on errors.
+                                     nesting, required props, house rules. Says how much it
+                                     read (evaluation_status); a file that does not parse is
+                                     not checked, and is never clean.
   oprt doctor                 Check this project's setup.
   oprt mcp                    Serve the lookups and the check to an agent over the
                                      Model Context Protocol (stdin and stdout).
 
+Exit codes: 0 success. check: 0 when every file read has no errors (no warnings either
+under --strict); limits it could not read are shown and do not fail the run. 1 when check
+finds an error, a file does not parse, or no .tsx or .jsx file was read; also for other
+failures (file conflicts, TypeScript missing). 2 for a usage error, an unknown name or a
+path that does not exist.
+
 Names accept PascalCase or kebab-case. Default output: src/components/operator.
 --dry-run    Preview all files and dependencies without creating anything.
 --overwrite  Replace different existing files; identical files are always skipped.
@@ -1571,83 +2701,30 @@ try {
   const major = Number(process.versions.node.split(".")[0]);
   if (major < 22) throw new CliError("oprt requires Node.js 22 or newer.");
   const command = parseArgs(process.argv.slice(2));
-  const { VERSION: VERSION2, contract: contract2, install: install2, registry: registry2, runAgentCommand: runAgentCommand2, serve: serve2 } = await Promise.resolve().then(() => (init_index(), index_exports));
+  const { VERSION: VERSION2, contract: contract2, registry: registry2, runAgentCommand: runAgentCommand2, serve: serve2 } = await Promise.resolve().then(() => (init_index(), index_exports));
   if (command.command === "mcp")
     await serve2(process.stdin, process.stdout, { contract: contract2(), registry: registry2 });
-  else if (command.command === "component" || command.command === "search" || command.command === "init" || command.command === "doctor" || command.command === "check") {
+  else if (command.command === "help") process.stdout.write(helpText(VERSION2));
+  else if (command.command === "version") process.stdout.write(`${VERSION2}
+`);
+  else {
     const answer = runAgentCommand2(command, { cwd: process.cwd(), contract: contract2(), registry: registry2 });
     process.stdout.write(command.json ? `${JSON.stringify(answer.json, null, 2)}
 ` : answer.text);
     process.exitCode = answer.exitCode;
-  } else if (command.command === "help") process.stdout.write(helpText(VERSION2));
-  else if (command.command === "version") process.stdout.write(`${VERSION2}
-`);
-  else if (command.command === "list") {
-    if (command.json)
-      process.stdout.write(
-        JSON.stringify(
-          { version: VERSION2, entries: registry2.entries, ranges: registry2.ranges ?? {} },
-          null,
-          2
-        ) + "\n"
-      );
-    else {
-      process.stdout.write(`OPERATOR ${VERSION2}
-
-`);
-      for (const kind of ["component", "recipe"]) {
-        const entries = registry2.entries.filter((entry) => entry.kind === kind);
-        process.stdout.write(
-          `${kind === "component" ? "Components" : "Recipes"} (${entries.length})
-`
-        );
-        for (const entry of entries)
-          process.stdout.write(`  ${entry.slug.padEnd(22)} ${entry.description}
-`);
-        process.stdout.write("\n");
-      }
-    }
-  } else {
-    const result = install2(command);
-    process.stdout.write(
-      `${result.dryRun ? "Dry run" : "Installed"}: ${result.entries.join(", ")}
-Output: ${result.outputDirectory}
-`
-    );
-    for (const file of result.files)
-      process.stdout.write(`  ${file.action.padEnd(9)} ${file.path}
-`);
-    const versioned = (name) => result.ranges[name] === void 0 ? name : `${name}@${result.ranges[name]}`;
-    const runtime = result.dependencies.filter((name) => !result.devDependencies.includes(name));
-    process.stdout.write(`
-Dependencies: ${runtime.map(versioned).join(", ")}
-`);
-    if (result.devDependencies.length > 0)
-      process.stdout.write(
-        `Dev dependencies (types only): ${result.devDependencies.map(versioned).join(", ")}
-`
-      );
-    process.stdout.write(
-      "Peer and style setup: react-dom, @oprt/tokens, @oprt/tailwind, tailwindcss.\nScan the output directory with Tailwind and load the OPERATOR token CSS.\nInstall any missing dependencies yourself; no package configuration was changed.\n"
-    );
   }
 } catch (error) {
   const message = error instanceof Error ? error.message : String(error);
-  if (process.argv.includes("--json"))
-    process.stdout.write(
-      `${JSON.stringify(
-        {
-          apiVersion: 1,
-          error: message,
-          code: error instanceof CliError ? error.code : "ERR_FAILED",
-          ...error instanceof CliError && error.suggestions !== void 0 ? { suggestions: error.suggestions } : {}
-        },
-        null,
-        2
-      )}
-`
-    );
-  else process.stderr.write(`oprt: ${message}
+  if (process.argv.includes("--json")) {
+    let loaded2;
+    try {
+      loaded2 = (await Promise.resolve().then(() => (init_index(), index_exports))).contract();
+    } catch {
+      loaded2 = void 0;
+    }
+    process.stdout.write(`${JSON.stringify(errorEnvelope(error, loaded2), null, 2)}
+`);
+  } else process.stderr.write(`oprt: ${message}
 `);
   process.exitCode = error instanceof CliError ? error.exitCode : 1;
 }