@oprt/cli 0.1.0 → 0.4.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,456 +396,308 @@ var init_args = __esm({
   }
 });
 
-// package.json
-var package_default;
+// ../../node_modules/.pnpm/@babel+parser@8.0.8/node_modules/@babel/parser/package.json
+var version;
 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"
-      }
-    };
+  "../../node_modules/.pnpm/@babel+parser@8.0.8/node_modules/@babel/parser/package.json"() {
+    version = "8.0.8";
   }
 });
 
-// src/contract.ts
-import { existsSync, readFileSync } from "fs";
-import { dirname, join } from "path";
+// src/parser.ts
+import { createRequire } from "module";
 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.`
+function optionsFor(file) {
+  const typed = /\.tsx$/.test(file);
+  const plugins = [
+    "jsx",
+    ...typed ? ["typescript"] : [],
+    "decorators",
+    "decoratorAutoAccessors",
+    "deferredImportEvaluation",
+    "sourcePhaseImports"
+  ];
+  return {
+    sourceType: "module",
+    plugins,
+    // Recoverable errors are returned beside the tree, instead of the first one being thrown.
+    errorRecovery: true,
+    attachComment: false,
+    allowReturnOutsideFunction: true,
+    allowUndeclaredExports: true,
+    allowSuperOutsideMethod: true,
+    allowNewTargetOutsideFunction: true
+  };
+}
+function loadBabel() {
+  if (loaded !== void 0) return loaded;
+  const fromSource = /\.[cm]?tsx?$/.test(fileURLToPath2(import.meta.url));
+  try {
+    const require2 = createRequire(import.meta.url);
+    loaded = fromSource ? require2("@babel/parser") : require2("./babel-parser.cjs");
+  } catch (error) {
+    throw new CliError(
+      `Code checking cannot load its parser (${FILE}): ${error instanceof Error ? error.message : String(error)} ${REINSTALL}`,
+      1,
+      { code: "ERR_PARSER_MISSING" }
     );
   }
-  return JSON.parse(readFileSync(found, "utf8"));
+  return loaded;
 }
-var init_contract = __esm({
-  "src/contract.ts"() {
+function probeParser(load = loadBabel) {
+  let babel;
+  try {
+    babel = load();
+  } catch (error) {
+    return {
+      ready: false,
+      reason: "parser_missing",
+      detail: error instanceof Error ? error.message : String(error)
+    };
+  }
+  if (rejects(babel, "export const a = <a b={1 as number} />;"))
+    return {
+      ready: false,
+      reason: "parser_unusable",
+      detail: "it rejected valid code in a probe parse"
+    };
+  if (!rejects(babel, "export const a = <a>;"))
+    return {
+      ready: false,
+      reason: "parser_unusable",
+      detail: "it did not report a syntax error in code that has one"
+    };
+  return { ready: true, parser: PARSER };
+}
+var PARSER, FILE, REINSTALL, loaded, rejects;
+var init_parser = __esm({
+  "src/parser.ts"() {
     "use strict";
     init_esm_shims();
+    init_package();
+    init_types();
+    PARSER = {
+      name: "@babel/parser",
+      version,
+      source: "bundled"
+    };
+    FILE = "babel-parser.cjs";
+    REINSTALL = "Install @oprt/cli again: the parser ships beside the executable in dist.";
+    rejects = (babel, code) => {
+      try {
+        return babel.parse(code, optionsFor("probe.tsx")).errors.length > 0;
+      } catch {
+        return true;
+      }
+    };
   }
 });
 
-// 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);
+// src/syntax.ts
+function* childNodes(node) {
+  for (const [key, value] of Object.entries(node)) {
+    if (NOT_NODES.has(key) || typeof value !== "object" || value === null) continue;
+    if (Array.isArray(value)) {
+      for (const item of value)
+        if (typeof item === "object" && item !== null && typeof item.type === "string")
+          yield item;
+    } else if (typeof value.type === "string") yield value;
   }
-  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 problemsOf(tree, errors, limit, consumed) {
+  const mismatched = /* @__PURE__ */ new Map();
+  walk(tree.program, [], (node, ancestors) => {
+    if (node.type === "JSXElement" && node.closingElement && (node.closingElement.start ?? 0) < limit && tagName(node.openingElement.name) !== tagName(node.closingElement.name))
+      mismatched.set(node.closingElement.start ?? 0, { element: node, ancestors: [...ancestors] });
+  });
+  const problems = [];
+  for (const error of errors) {
+    if (error.pos >= limit) continue;
+    const entry = error.reasonCode === "MissingClosingTagElement" && mismatched.get(error.pos);
+    if (entry) {
+      const closing = tagName(entry.element.closingElement?.name);
+      const outer = [...entry.ancestors].reverse().find(
+        (ancestor) => ancestor.type === "JSXElement" && tagName(ancestor.openingElement.name) === closing && !consumed.has(ancestor)
+      );
+      if (outer !== void 0) {
+        consumed.add(outer);
+        problems.push(unclosed(entry.element));
+        continue;
+      }
+    }
+    problems.push(problemOf(error));
   }
+  return problems;
 }
-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}`);
+function complete(babel, prefix, file) {
+  let text2 = prefix;
+  let first = null;
+  for (let step = 0; step <= MAX_COMPLETIONS; step++) {
+    const tried = attempt(babel, text2, file);
+    if (tried.tree !== null) return { tree: tried.tree, errors: tried.errors, first };
+    const wantsMore = tried.fatal.reasonCode === "UnterminatedJsxContent" || tried.fatal.pos >= text2.length;
+    if (!wantsMore) return null;
+    const next = COMPLETIONS.find((piece) => {
+      const extended = attempt(babel, text2 + piece, file);
+      return extended.tree !== null || extended.fatal.reasonCode === "UnterminatedJsxContent" || extended.fatal.pos >= text2.length + piece.length;
+    });
+    if (next === void 0) return null;
+    first ??= next;
+    text2 += next;
   }
-  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" };
+function shutByCompletion(tree, limit) {
+  const shut = [];
+  walk(tree.program, [], (node) => {
+    if (node.type === "JSXElement" && node.closingElement && (node.closingElement.start ?? 0) >= limit)
+      shut.push(node);
   });
-  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);
-    try {
-      writeFileSync(descriptor, context.registry.files[file.path]);
-    } finally {
-      closeSync(descriptor);
+  return shut.sort((a, b) => (a.closingElement?.start ?? 0) - (b.closingElement?.start ?? 0));
+}
+function readSyntax(file, text2, babel = loadBabel()) {
+  const first = attempt(babel, text2, file);
+  if (first.tree !== null) {
+    const problems = problemsOf(first.tree, first.errors, Infinity, /* @__PURE__ */ new Set());
+    return problems.length === 0 ? { tree: first.tree, problems: [] } : { tree: null, problems: problems.sort(byPlace) };
+  }
+  let fatal = first.fatal;
+  if (text2.length > MAX_EXPLAINED) return { tree: null, problems: [problemOf(fatal)] };
+  if (/\.tsx$/.test(file) && fatal.reasonCode !== "UnterminatedJsxContent") {
+    const plain = text2.replace(TYPE_ARGUMENTS, blankedOut);
+    if (plain !== text2) {
+      const again = attempt(babel, plain, file);
+      if (again.tree === null && again.fatal.pos > fatal.pos) fatal = again.fatal;
     }
   }
-  return result;
+  try {
+    const finished = complete(babel, text2.slice(0, fatal.pos), file);
+    if (finished !== null) {
+      const limit = fatal.pos;
+      const consumed = /* @__PURE__ */ new Set();
+      const problems = problemsOf(finished.tree, finished.errors, limit, consumed);
+      const open = shutByCompletion(finished.tree, limit).filter(
+        (element) => !consumed.has(element)
+      );
+      const atEnd = fatal.reasonCode === "UnterminatedJsxContent" || fatal.pos >= text2.length;
+      const hints = (atEnd ? open : finished.first === CLOSING_TAG ? open.slice(0, 1) : []).map(
+        unclosed
+      );
+      const explained = [...problems, ...hints].some(({ code }) => code === "UnclosedJsxElement");
+      problems.push(...hints);
+      if (!(explained && fatal.reasonCode === "UnterminatedJsxContent"))
+        problems.push(problemOf(fatal));
+      return { tree: null, problems: problems.sort(byPlace) };
+    }
+  } catch {
+  }
+  return { tree: null, problems: [problemOf(fatal)] };
 }
-var init_installer = __esm({
-  "src/installer.ts"() {
+var attempt, sentence, problemOf, tagName, NOT_NODES, walk, unclosed, TYPE_ARGUMENTS, LINE_BREAKS, blankedOut, CLOSING_TAG, COMPLETIONS, MAX_COMPLETIONS, byPlace, MAX_EXPLAINED;
+var init_syntax = __esm({
+  "src/syntax.ts"() {
     "use strict";
     init_esm_shims();
-    init_args();
-    init_types();
+    init_parser();
+    attempt = (babel, text2, file) => {
+      try {
+        const tree = babel.parse(text2, optionsFor(file));
+        return { tree, errors: tree.errors };
+      } catch (error) {
+        return { tree: null, fatal: error };
+      }
+    };
+    sentence = (message) => message.replace(/\s*\(\d+:\d+\)$/, "");
+    problemOf = (failure2) => ({
+      line: failure2.loc.line,
+      column: failure2.loc.column + 1,
+      message: sentence(failure2.message),
+      code: failure2.reasonCode ?? "SyntaxError",
+      position: failure2.pos
+    });
+    tagName = (name) => {
+      if (name === void 0) return "";
+      if (name.type === "JSXIdentifier") return name.name;
+      if (name.type === "JSXMemberExpression")
+        return `${tagName(name.object)}.${name.property.name}`;
+      return `${name.namespace.name}:${name.name.name}`;
+    };
+    NOT_NODES = /* @__PURE__ */ new Set(["loc", "extra", "errors", "tokens", "comments"]);
+    walk = (node, ancestors, visit) => {
+      visit(node, ancestors);
+      ancestors.push(node);
+      for (const child of childNodes(node)) walk(child, ancestors, visit);
+      ancestors.pop();
+    };
+    unclosed = (element) => {
+      const name = element.openingElement.name;
+      return {
+        line: name.loc?.start.line ?? 1,
+        column: (name.loc?.start.column ?? 0) + 1,
+        message: `JSX element '${tagName(name)}' has no corresponding closing tag.`,
+        code: "UnclosedJsxElement",
+        position: name.start ?? 0
+      };
+    };
+    TYPE_ARGUMENTS = /(?<=[\w$\])])<(?:[^<>()]|<(?:[^<>()]|<[^<>()]*>)*>)*>(?=\()/g;
+    LINE_BREAKS = new RegExp(`[^\\r\\n${String.fromCharCode(8232, 8233)}]`, "g");
+    blankedOut = (match) => match.replace(LINE_BREAKS, " ");
+    CLOSING_TAG = "</_>";
+    COMPLETIONS = [CLOSING_TAG, ")", "}", "]"];
+    MAX_COMPLETIONS = 24;
+    byPlace = (a, b) => a.position - b.position;
+    MAX_EXPLAINED = 2e5;
   }
 });
 
-// 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, 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 } };
+function checkSource(contract2, file, text2) {
+  const reading = readSyntax(file, text2);
+  if (reading.tree === null) {
+    const shown = reading.problems.slice(0, MAX_SYNTAX_ERRORS);
+    const more = reading.problems.length - shown.length;
+    return {
+      file,
+      status: "not_evaluated",
+      limitations: [],
+      findings: shown.map(
+        ({ line, column, message, code }, index) => ({
+          code: "SYNTAX_ERROR",
+          severity: "error",
+          file,
+          line,
+          column,
+          message: `${message} (${code})` + (index === shown.length - 1 && more > 0 ? ` ${more} more syntax error${more === 1 ? "" : "s"} in this file not shown.` : "")
+        })
+      )
+    };
+  }
+  const findings = [];
+  const limitations = [];
+  const place = (node) => ({
+    line: node.loc?.start.line ?? 1,
+    column: (node.loc?.start.column ?? 0) + 1
   });
-  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
+  const textOf = (node) => text2.slice(node.start ?? 0, node.end ?? 0);
+  const limit = (node, limitation) => {
+    limitations.push({ ...limitation, file, ...place(node) });
   };
-}
-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 = 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 report = (node, finding) => {
-    const { line, character } = source.getLineAndCharacterOfPosition(node.getStart(source));
     findings.push({
       code: finding.code,
       severity: finding.severity,
       file,
-      line: line + 1,
-      column: character + 1,
+      ...place(node),
       ...finding.component === void 0 ? {} : { component: finding.component },
       ...finding.prop === void 0 ? {} : { prop: finding.prop },
       message: finding.message,
@@ -653,21 +708,18 @@ function checkSource(typescript, contract2, file, text2) {
   const isComponent = (name) => Object.hasOwn(contract2.components, name);
   const named = /* @__PURE__ */ new Map();
   const namespaces = /* @__PURE__ */ new Set();
-  for (const statement of source.statements) {
-    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
-      continue;
-    const from = statement.moduleSpecifier.text;
-    const clause = statement.importClause;
-    if (!clause || clause.isTypeOnly || !clause.namedBindings) continue;
+  for (const statement of reading.tree.program.body) {
+    if (statement.type !== "ImportDeclaration" || statement.importKind === "type") continue;
+    const from = statement.source.value;
     const copied = from !== PACKAGE && /[./@]/.test(from[0] ?? "") && isComponent(basename(from));
     if (from !== PACKAGE && !copied) continue;
-    if (ts.isNamespaceImport(clause.namedBindings)) {
-      if (from === PACKAGE) namespaces.add(clause.namedBindings.name.text);
-      continue;
-    }
-    for (const element2 of clause.namedBindings.elements) {
-      if (element2.isTypeOnly) continue;
-      const exported = (element2.propertyName ?? element2.name).text;
+    for (const element2 of statement.specifiers) {
+      if (element2.type === "ImportNamespaceSpecifier") {
+        if (from === PACKAGE) namespaces.add(element2.local.name);
+        continue;
+      }
+      if (element2.type !== "ImportSpecifier" || element2.importKind === "type") continue;
+      const exported = element2.imported.type === "Identifier" ? element2.imported.name : element2.imported.value;
       if (from === PACKAGE && !contract2.exports.includes(exported)) {
         let suggestions = nearest(exported, Object.keys(contract2.components));
         if (suggestions.length === 0) suggestions = nearest(exported, contract2.exports);
@@ -692,26 +744,55 @@ function checkSource(typescript, contract2, file, text2) {
         });
         continue;
       }
-      if (isComponent(exported)) named.set(element2.name.text, exported);
+      if (isComponent(exported)) named.set(element2.local.name, exported);
     }
   }
+  const isString = (node) => node.type === "StringLiteral";
+  const plainTemplate = (node) => node.type === "TemplateLiteral" && node.expressions.length === 0 ? node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw : void 0;
   const literals = (expression) => {
     if (!expression) return [];
-    if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression))
-      return [expression.text];
-    if (ts.isParenthesizedExpression(expression)) return literals(expression.expression);
-    if (ts.isConditionalExpression(expression))
-      return [...literals(expression.whenTrue), ...literals(expression.whenFalse)];
+    if (isString(expression)) return [expression.value];
+    const template = plainTemplate(expression);
+    if (template !== void 0) return [template];
+    if (expression.type === "ConditionalExpression")
+      return [...literals(expression.consequent), ...literals(expression.alternate)];
     return [];
   };
-  const valueOf = (attribute) => attribute.initializer === void 0 ? void 0 : ts.isJsxExpression(attribute.initializer) ? attribute.initializer.expression : attribute.initializer;
+  const valueOf = (attribute) => {
+    const value = attribute.value;
+    if (value === null || value === void 0) return void 0;
+    if (value.type === "JSXExpressionContainer")
+      return value.expression.type === "JSXEmptyExpression" ? void 0 : value.expression;
+    return value;
+  };
+  const optionValue = (expression) => {
+    const read = [];
+    const unread = [];
+    const walk2 = (node) => {
+      const template = plainTemplate(node);
+      if (isString(node)) read.push(node.value);
+      else if (template !== void 0) read.push(template);
+      else if (node.type === "TSAsExpression" || node.type === "TSNonNullExpression" || node.type === "TSTypeAssertion" || node.type === "TSSatisfiesExpression")
+        walk2(node.expression);
+      else if (node.type === "ConditionalExpression") {
+        walk2(node.consequent);
+        walk2(node.alternate);
+      } else if (node.type === "LogicalExpression") {
+        if (node.operator === "??" || node.operator === "||") {
+          walk2(node.left);
+          walk2(node.right);
+        } else walk2(node.right);
+      } else if (!// No value: the component's default applies.
+      (node.type === "Identifier" && node.name === "undefined" || node.type === "NullLiteral"))
+        unread.push(node);
+    };
+    if (expression) walk2(expression);
+    return { literals: read, unread };
+  };
   const classText = (expression) => {
     if (!expression) return "";
-    if (ts.isTemplateExpression(expression))
-      return [
-        expression.head.text,
-        ...expression.templateSpans.map((span) => span.literal.text)
-      ].join(" ");
+    if (expression.type === "TemplateLiteral" && expression.expressions.length > 0)
+      return expression.quasis.map((span) => span.value.cooked ?? span.value.raw).join(" ");
     return literals(expression).join(" ");
   };
   const houseRules = (attribute, name) => {
@@ -737,9 +818,9 @@ function checkSource(typescript, contract2, file, text2) {
           message: "A rounded corner. The radius is 0 everywhere in OPERATOR."
         });
     }
-    if (name === "style" && value && ts.isObjectLiteralExpression(value)) {
+    if (name === "style" && value && value.type === "ObjectExpression") {
       for (const property of value.properties)
-        if (ts.isPropertyAssignment(property) && literals(property.initializer).some((literal) => RAW_COLOR_VALUE.test(literal)))
+        if (property.type === "ObjectProperty" && literals(property.value).some((literal) => RAW_COLOR_VALUE.test(literal)))
           report(attribute, {
             code: "RAW_COLOR",
             severity: "warning",
@@ -747,56 +828,73 @@ function checkSource(typescript, contract2, file, text2) {
           });
     }
   };
+  const attributeName = (attribute) => attribute.name.type === "JSXIdentifier" ? attribute.name.name : textOf(attribute.name);
   const element = (opening, ancestors, parent, hasChildren, renderedAs) => {
-    const tag = opening.tagName;
+    const tag = opening.name;
     let component = null;
-    if (ts.isIdentifier(tag)) {
-      component = named.get(tag.text) ?? null;
-      if (component === null && !renderedAs && Object.hasOwn(NATIVE, tag.text))
+    if (tag.type === "JSXIdentifier") {
+      component = named.get(tag.name) ?? null;
+      if (component === null && !renderedAs && Object.hasOwn(NATIVE, tag.name))
         report(opening, {
           code: "NATIVE_CONTROL",
           severity: "warning",
-          message: `A native <${tag.text}>: use ${NATIVE[tag.text]}.`
+          message: `A native <${tag.name}>: use ${NATIVE[tag.name]}.`
         });
-    } else if (ts.isPropertyAccessExpression(tag) && ts.isIdentifier(tag.expression)) {
-      const owner = tag.expression.text;
-      if (namespaces.has(owner) && isComponent(tag.name.text)) component = tag.name.text;
+    } else if (tag.type === "JSXMemberExpression" && tag.object.type === "JSXIdentifier") {
+      const owner = tag.object.name;
+      const member = tag.property.name;
+      if (namespaces.has(owner) && isComponent(member)) component = member;
       else if (named.has(owner)) {
-        const joined = `${named.get(owner)}${tag.name.text}`;
+        const joined = `${named.get(owner)}${member}`;
         report(opening, {
           code: "DOT_NOTATION",
           severity: "error",
-          message: `${owner}.${tag.name.text} is not a component.` + (isComponent(joined) ? ` Use <${joined}>.` : " OPERATOR's parts are components of their own, imported by name.")
+          message: `${owner}.${member} is not a component.` + (isComponent(joined) ? ` Use <${joined}>.` : " OPERATOR's parts are components of their own, imported by name.")
         });
       }
     }
-    const attributes = opening.attributes.properties;
+    const attributes = opening.attributes;
     for (const attribute of attributes)
-      if (ts.isJsxAttribute(attribute) && ts.isIdentifier(attribute.name))
-        houseRules(attribute, attribute.name.text);
+      if (attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier")
+        houseRules(attribute, attribute.name.name);
     if (component === null) return null;
     const definition = contract2.components[component];
-    const spread = attributes.some((attribute) => ts.isJsxSpreadAttribute(attribute));
+    const spread = attributes.some((attribute) => attribute.type === "JSXSpreadAttribute");
+    for (const attribute of attributes)
+      if (attribute.type === "JSXSpreadAttribute")
+        limit(attribute, {
+          code: "UNRESOLVED_SPREAD",
+          component,
+          message: `Props spread into <${component}> (${quote(textOf(attribute))}) 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;
-      const prop = ts.isIdentifier(attribute.name) ? attribute.name.text : attribute.name.getText(source);
+      if (attribute.type !== "JSXAttribute") continue;
+      const prop = attributeName(attribute);
       given.add(prop);
       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(textOf(expression))}) 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, {
@@ -843,117 +941,945 @@ function checkSource(typescript, contract2, file, text2) {
     return component;
   };
   const visit = (node, ancestors, parent, renderedAs = false) => {
-    if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) {
-      const opening = ts.isJsxElement(node) ? node.openingElement : node;
-      const hasChildren = ts.isJsxElement(node) && node.children.some(
-        (child) => !(ts.isJsxText(child) && child.containsOnlyTriviaWhiteSpaces)
+    if (node.type === "JSXElement") {
+      const opening = node.openingElement;
+      const hasChildren = node.children.some(
+        (child) => !(child.type === "JSXText" && /^\s*$/.test(text2.slice(child.start ?? 0, child.end ?? 0)))
       );
       const component = element(opening, ancestors, parent, hasChildren, renderedAs);
-      const asChild = component !== null && opening.attributes.properties.some(
-        (attribute) => ts.isJsxAttribute(attribute) && attribute.name.getText(source) === "asChild"
+      const asChild = component !== null && opening.attributes.some(
+        (attribute) => attribute.type === "JSXAttribute" && attributeName(attribute) === "asChild"
+      );
+      for (const attribute of opening.attributes) visit(attribute, [], null);
+      for (const child of node.children)
+        visit(
+          child,
+          component === null ? ancestors : [...ancestors, component],
+          component,
+          asChild
+        );
+      return;
+    }
+    for (const child of childNodes(node)) visit(child, ancestors, parent);
+  };
+  visit(reading.tree.program, [], null);
+  const byPlace2 = (a, b) => a.line - b.line || a.column - b.column;
+  return {
+    file,
+    status: limitations.length > 0 ? "partial" : "evaluated",
+    findings: findings.sort(byPlace2),
+    limitations: limitations.sort(byPlace2)
+  };
+}
+function* sources(path2) {
+  if (excluded(basename(path2))) return;
+  if (statSync(path2).isDirectory()) {
+    for (const entry of readdirSync(path2).sort()) yield* sources(join(path2, entry));
+  } else if (READ.has(extname(path2)) && !NOT_INTERFACE.test(basename(path2))) yield path2;
+}
+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 ?? 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 checkPaths(paths, context) {
+  const root = resolve(context.cwd);
+  const files = [];
+  const skipped = [];
+  for (const path2 of paths) {
+    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));
+  }
+  loadBabel();
+  const evaluations = [...new Set(files)].map(
+    (file) => checkSource(
+      context.contract,
+      relative(root, file).split(sep).join("/"),
+      readFileSync(file, "utf8")
+    )
+  );
+  return buildCheckReport(evaluations, { 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, plural, MAX_LIMITS_SHOWN;
+var init_check = __esm({
+  "src/check.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_lookup();
+    init_parser();
+    init_syntax();
+    init_types();
+    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(".");
+    plural = (amount, word) => `${amount} ${word}${amount === 1 ? "" : "s"}`;
+    MAX_LIMITS_SHOWN = 20;
+  }
+});
+
+// package.json
+var package_default;
+var init_package2 = __esm({
+  "package.json"() {
+    package_default = {
+      name: "@oprt/cli",
+      version: "0.4.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: {
+        "@babel/parser": "8.0.8",
+        "@babel/types": "8.0.8",
+        "@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_package2();
+    VERSION = package_default.version;
+    RESULT_SCHEMA_VERSION = 2;
+    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: RESULT_SCHEMA_VERSION,
+    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: RESULT_SCHEMA_VERSION,
+      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("@babel/parser"),
+        version: str(),
+        source: words2("bundled")
+      }),
+      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("parser_missing", "parser_unusable"),
+              fix: str(),
+              parser: ref("parser")
+            },
+            ["reason", "fix", "parser"]
+          )
+        }),
+        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: RESULT_SCHEMA_VERSION },
+      type: { const: type },
+      identity: ref("identity"),
+      data: ref(DATA[type])
+    });
+    failure = () => obj(
+      {
+        apiVersion: { const: RESULT_SCHEMA_VERSION },
+        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 join2 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function loadContract() {
+  const here = dirname(fileURLToPath3(import.meta.url));
+  const candidates = [join2(here, "contract.json"), join2(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.`
       );
-      for (const attribute of opening.attributes.properties) visit(attribute, [], null);
-      if (ts.isJsxElement(node))
-        for (const child of node.children)
-          visit(
-            child,
-            component === null ? ancestors : [...ancestors, component],
-            component,
-            asChild
-          );
-      return;
-    }
-    ts.forEachChild(node, (child) => visit(child, ancestors, parent));
+    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
   };
-  visit(source, [], null);
-  return findings.sort((a, b) => a.line - b.line || a.column - b.column);
-}
-function* sources(path2) {
-  const name = basename(path2);
-  if (SKIPPED.has(name) || name.startsWith(".") && name !== "." && name !== "..") 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;
-}
-function findTypeScript(cwd) {
-  for (const from of [join2(cwd, "package.json"), fileURLToPath3(import.meta.url)]) {
+  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 {
-      return createRequire(from)("typescript");
-    } catch {
+      writeFileSync(descriptor, context.registry.files[file.path]);
+    } finally {
+      closeSync(descriptor);
     }
   }
-  return null;
-}
-function checkPaths(paths, context) {
-  const root = resolve2(context.cwd);
-  const files = [];
-  for (const path2 of paths) {
-    const absolute = resolve2(root, path2);
-    if (!existsSync2(absolute))
-      throw new CliError(`No such file or folder: ${path2}`, 2, { code: "ERR_PATH_NOT_FOUND" });
-    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")
-    )
-  );
-  return {
-    files: new Set(files).size,
-    findings,
-    summary: {
-      errors: findings.filter(({ severity }) => severity === "error").length,
-      warnings: findings.filter(({ severity }) => severity === "warning").length
-    }
-  };
+  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$/;
   }
 });
 
@@ -1048,26 +1974,30 @@ function installedVersion(cwd, name) {
     if (dirname3(folder) === folder) return void 0;
   }
 }
-function doctor({ cwd, contract: contract2 }) {
+function doctor({
+  cwd,
+  contract: contract2,
+  parser = probeParser()
+}) {
   const checks = [];
   for (const name of PACKAGES) {
-    const version = installedVersion(cwd, name);
+    const version2 = installedVersion(cwd, name);
     const id = `package:${name}`;
-    if (version === void 0)
+    if (version2 === void 0)
       checks.push({
         id,
         status: "warn",
         message: `${name} is not installed.`,
         fix: `Install ${name}, or copy the sources you need with oprt add.`
       });
-    else if (minor(version) !== minor(contract2.version))
+    else if (minor(version2) !== minor(contract2.version))
       checks.push({
         id,
         status: "warn",
-        message: `${name} is ${version}; this installer describes ${contract2.version}.`,
+        message: `${name} is ${version2}; this installer describes ${contract2.version}.`,
         fix: "Install matching versions of the OPERATOR packages and @oprt/cli."
       });
-    else checks.push({ id, status: "ok", message: `${name} ${version} is installed.` });
+    else checks.push({ id, status: "ok", message: `${name} ${version2} is installed.` });
   }
   const written = INSTRUCTION_FILES.map((path2) => {
     const file = join3(cwd, path2);
@@ -1075,8 +2005,8 @@ function doctor({ cwd, contract: contract2 }) {
       path: path2,
       version: existsSync3(file) ? blockVersion(readFileSync4(file, "utf8")) : void 0
     };
-  }).filter(({ version }) => version !== void 0);
-  const stale = written.find(({ version }) => version !== contract2.version);
+  }).filter(({ version: version2 }) => version2 !== void 0);
+  const stale = written.find(({ version: version2 }) => version2 !== contract2.version);
   if (written.length === 0)
     checks.push({
       id: "agent-instructions",
@@ -1097,8 +2027,48 @@ function doctor({ cwd, contract: contract2 }) {
       status: "ok",
       message: `${written.map(({ path: path2 }) => path2).join(", ")} carries the OPERATOR block (${contract2.version}).`
     });
+  let checkCode;
+  if (parser.ready) {
+    const { name, version: version2 } = parser.parser;
+    checkCode = {
+      status: "ready",
+      message: `${name} ${version2}, bundled with oprt: nothing to install.`,
+      parser: parser.parser
+    };
+    checks.push({
+      id: "parser",
+      status: "ok",
+      message: `Code checking reads code with ${name} ${version2}, which ships inside oprt.`
+    });
+  } else {
+    const fix = "Install @oprt/cli again, then run oprt doctor again. Lookups work without it.";
+    checkCode = {
+      status: "blocked",
+      message: `${parser.reason}: ${parser.detail}`,
+      reason: parser.reason,
+      fix
+    };
+    checks.push({
+      id: "parser",
+      status: "fail",
+      message: `oprt check and the check_code tool cannot run (${parser.reason}): ${parser.detail}`,
+      fix
+    });
+  }
   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 +2076,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",
@@ -1113,7 +2084,7 @@ var init_doctor = __esm({
       ".claude/CLAUDE.md",
       ".cursor/rules/operator.mdc"
     ];
-    minor = (version) => version.split(".").slice(0, 2).join(".");
+    minor = (version2) => version2.split(".").slice(0, 2).join(".");
   }
 });
 
@@ -1182,7 +2153,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 +2230,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 +2251,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 +2266,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 +2462,82 @@ 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 report = buildCheckReport([
+        checkSource(contract2, "snippet.tsx", args["code"])
+      ]);
+      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 +2547,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 +2582,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,26 +2700,38 @@ 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
 });
@@ -1505,15 +2755,17 @@ function install(options, context = {}) {
     registry: context.registry ?? registry
   });
 }
-var VERSION, registry, loaded, contract;
+var registry, loaded2, 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,17 +2775,17 @@ var init_index = __esm({
     init_args();
     init_installer();
     init_types();
-    VERSION = package_default.version;
     registry = loadRegistry();
-    contract = () => loaded ??= loadContract();
+    contract = () => loaded2 ??= loadContract();
   }
 });
 
 // src/bin.ts
 init_esm_shims();
 init_args();
+init_results();
 init_types();
-var helpText = (version) => `oprt ${version} \u2014 OPERATOR source installer
+var helpText = (version2) => `oprt ${version2} \u2014 OPERATOR source installer
 
 Usage:
   oprt list [--json]
@@ -1551,11 +2803,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, a parser that cannot be loaded). 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 +2831,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 loaded3;
+    try {
+      loaded3 = (await Promise.resolve().then(() => (init_index(), index_exports))).contract();
+    } catch {
+      loaded3 = void 0;
+    }
+    process.stdout.write(`${JSON.stringify(errorEnvelope(error, loaded3), null, 2)}
+`);
+  } else process.stderr.write(`oprt: ${message}
 `);
   process.exitCode = error instanceof CliError ? error.exitCode : 1;
 }