@oprt/cli 0.0.0-stage → 0.3.0

package/dist/bin.js

@@ -0,0 +1,2730 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.7.0_postcss@8.5.30_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.1_jiti@2.7.0_postcss@8.5.30_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/types.ts
+var CliError;
+var init_types = __esm({
+  "src/types.ts"() {
+    "use strict";
+    init_esm_shims();
+    CliError = class extends Error {
+      constructor(message, exitCode = 1, details = {}) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = "CliError";
+        this.code = details.code ?? (exitCode === 2 ? "ERR_USAGE" : "ERR_FAILED");
+        if (details.suggestions !== void 0) this.suggestions = details.suggestions;
+      }
+      exitCode;
+      code;
+      suggestions;
+    };
+  }
+});
+
+// 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();
+  const values = /* @__PURE__ */ new Map();
+  const positional = [];
+  for (let i = 0; i < rest.length; i++) {
+    const token = rest[i];
+    if (!token.startsWith("-")) {
+      positional.push(token);
+      continue;
+    }
+    const kind = spec[token];
+    if (kind === void 0)
+      throw new CliError(
+        `Unknown option ${JSON.stringify(token)} for ${command}. Run oprt --help.`,
+        2
+      );
+    if (flags.has(token) || values.has(token)) throw new CliError(`Duplicate option ${token}.`, 2);
+    if (kind === "flag") flags.add(token);
+    else {
+      const value = rest[++i];
+      if (!value || value.startsWith("-")) throw new CliError(`${token} requires a value.`, 2);
+      values.set(token, value);
+    }
+  }
+  return {
+    has: (flag) => flags.has(flag),
+    value: (name) => values.get(name),
+    positional
+  };
+}
+function parseArgs(args) {
+  if (!args.length || args.length === 1 && ["--help", "-h", "help"].includes(args[0]))
+    return { command: "help" };
+  if (args.length === 1 && ["--version", "-v"].includes(args[0])) return { command: "version" };
+  const [command, ...rest] = args;
+  if ([...Object.keys(AGENT_COMMANDS), "list", "add"].includes(command) && rest.length === 1 && ["--help", "-h"].includes(rest[0]))
+    return { command: "help" };
+  if (Object.hasOwn(AGENT_COMMANDS, command)) return AGENT_COMMANDS[command](rest);
+  if (command === "list") {
+    if (rest.length === 0) return { command, json: false };
+    if (rest.length === 1 && rest[0] === "--json") return { command, json: true };
+    throw new CliError("Usage: oprt list [--json]", 2);
+  }
+  if (command !== "add")
+    throw new CliError(`Unknown command ${JSON.stringify(command)}. Run oprt --help.`, 2);
+  const parsed = {
+    command,
+    names: [],
+    out: DEFAULT_OUT,
+    dryRun: false,
+    overwrite: false,
+    json: false
+  };
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < rest.length; i++) {
+    const token = rest[i];
+    if (!token.startsWith("-")) {
+      parsed.names.push(token);
+      continue;
+    }
+    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);
+    if (token === "--out") {
+      const value = rest[++i];
+      if (!value || value.startsWith("-"))
+        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)
+    throw new CliError("add requires one or more component or recipe names. Run oprt list.", 2);
+  return parsed;
+}
+var DEFAULT_OUT, AGENT_COMMANDS;
+var init_args = __esm({
+  "src/args.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_lookup();
+    init_types();
+    DEFAULT_OUT = "src/components/operator";
+    AGENT_COMMANDS = {
+      component(rest) {
+        const { has, positional } = split("component", rest, {
+          "--list": "flag",
+          "--dense": "flag",
+          "--json": "flag"
+        });
+        if (has("--list") ? positional.length > 0 : positional.length === 0)
+          throw new CliError("Usage: oprt component <Name...> [--dense], or component --list", 2);
+        return {
+          command: "component",
+          names: positional,
+          list: has("--list"),
+          dense: has("--dense"),
+          json: has("--json")
+        };
+      },
+      search(rest) {
+        const { has, value, positional } = split("search", rest, {
+          "--limit": "value",
+          "--json": "flag"
+        });
+        if (positional.length === 0) throw new CliError("Usage: oprt search <need> [--limit <n>]", 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) {
+        const { has, value, positional } = split("init", rest, {
+          "--agent": "value",
+          "--path": "value",
+          "--remove": "flag",
+          "--dry-run": "flag",
+          "--json": "flag"
+        });
+        const agent = value("--agent");
+        const path2 = value("--path");
+        if (positional.length > 0 || agent !== void 0 && path2 !== void 0)
+          throw new CliError(
+            "Usage: oprt init [--agent <name> | --path <file>] [--remove] [--dry-run]",
+            2
+          );
+        return {
+          command: "init",
+          ...agent === void 0 ? {} : { agent },
+          ...path2 === void 0 ? {} : { path: path2 },
+          remove: has("--remove"),
+          dryRun: has("--dry-run"),
+          json: has("--json")
+        };
+      },
+      check(rest) {
+        const { has, positional } = split("check", rest, { "--strict": "flag", "--json": "flag" });
+        if (positional.length === 0)
+          throw new CliError("Usage: oprt check <file or folder...> [--strict]", 2);
+        return { command: "check", paths: positional, strict: has("--strict"), json: has("--json") };
+      },
+      mcp(rest) {
+        if (rest.length > 0) throw new CliError("Usage: oprt mcp", 2);
+        return { command: "mcp" };
+      },
+      doctor(rest) {
+        const { has, positional } = split("doctor", rest, { "--json": "flag" });
+        if (positional.length > 0) throw new CliError("Usage: oprt doctor", 2);
+        return { command: "doctor", json: has("--json") };
+      }
+    };
+  }
+});
+
+// src/parser.ts
+import { createRequire } from "module";
+import { join } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function usable(typescript) {
+  const ts = typescript;
+  if (typeof ts.createSourceFile !== "function" || ts.ScriptKind === void 0)
+    return `TypeScript ${ts.version ?? "(unknown version)"} has no JavaScript syntax API (createSourceFile), which oprt reads code with; ${SUPPORTED_TYPESCRIPT} has it`;
+  try {
+    const probe = ts.createSourceFile(
+      "probe.tsx",
+      "<a>",
+      ts.ScriptTarget?.Latest ?? 99,
+      true,
+      ts.ScriptKind.TSX
+    );
+    const diagnostics = probe.parseDiagnostics;
+    if (!Array.isArray(diagnostics)) return "it does not report parse errors on a source file";
+    if (diagnostics.length === 0) return "it did not report a syntax error in code that has one";
+  } catch (error) {
+    return `it failed on a probe parse: ${error instanceof Error ? error.message : String(error)}`;
+  }
+  return null;
+}
+function probeTypeScript(cwd, options = {}) {
+  const places = [
+    { from: join(cwd, "package.json"), source: "project" },
+    ...options.installer === false ? [] : [{ from: fileURLToPath2(import.meta.url), source: "installer" }]
+  ];
+  let unusable;
+  for (const { from, source } of places) {
+    let file;
+    let loaded2;
+    try {
+      const require2 = createRequire(from);
+      file = require2.resolve("typescript");
+      loaded2 = require2("typescript");
+    } catch (error) {
+      if (error.code !== "MODULE_NOT_FOUND")
+        unusable ??= `typescript was found but failed to load: ${error instanceof Error ? error.message : String(error)}`;
+      continue;
+    }
+    const typescript = loaded2.default ?? loaded2;
+    const problem = usable(typescript);
+    if (problem !== null) {
+      unusable ??= `${problem} (at ${packageFolder(file)}).`;
+      continue;
+    }
+    return {
+      ready: true,
+      typescript,
+      resolution: {
+        name: "typescript",
+        version: typescript.version,
+        source,
+        resolved_from: packageFolder(file)
+      }
+    };
+  }
+  if (unusable !== void 0)
+    return { ready: false, reason: "typescript_unusable", detail: unusable };
+  return {
+    ready: false,
+    reason: "typescript_missing",
+    detail: `typescript could not be resolved from ${cwd}${options.installer === false ? "" : " or from beside the installer"}.`
+  };
+}
+var SUPPORTED_TYPESCRIPT, INSTALL_TYPESCRIPT, packageFolder;
+var init_parser = __esm({
+  "src/parser.ts"() {
+    "use strict";
+    init_esm_shims();
+    SUPPORTED_TYPESCRIPT = "TypeScript 5 or 6";
+    INSTALL_TYPESCRIPT = "npm install -D typescript@6";
+    packageFolder = (file) => /^(.*[\\/]node_modules[\\/]typescript)[\\/]/.exec(file)?.[1] ?? file;
+  }
+});
+
+// src/check.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { basename, extname, join as join2, relative, resolve, sep } from "path";
+function allowedChildren2(rules, name) {
+  for (const [parent, rule] of Object.entries(rules ?? {})) {
+    if (parent === name) return rule.allowed_children;
+    const nested = 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 parseDiagnostics = source.parseDiagnostics;
+  if (!Array.isArray(parseDiagnostics))
+    throw new CliError(
+      `This TypeScript does not report syntax errors on a parsed file, so a file that does not parse could be called clean. Install TypeScript 5 or 6 in this project (${INSTALL_TYPESCRIPT}).`,
+      1,
+      { code: "ERR_TYPESCRIPT_UNUSABLE" }
+    );
+  if (parseDiagnostics.length > 0) {
+    const ordered = [...parseDiagnostics].sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
+    const shown = ordered.slice(0, MAX_SYNTAX_ERRORS);
+    return {
+      file,
+      status: "not_evaluated",
+      limitations: [],
+      findings: shown.map((diagnostic, index) => {
+        const { line, character } = source.getLineAndCharacterOfPosition(diagnostic.start ?? 0);
+        const more = ordered.length - shown.length;
+        return {
+          code: "SYNTAX_ERROR",
+          severity: "error",
+          file,
+          line: line + 1,
+          column: character + 1,
+          message: `${ts.flattenDiagnosticMessageText(diagnostic.messageText, " ")} (TS${diagnostic.code})` + (index === shown.length - 1 && more > 0 ? ` ${more} more syntax error${more === 1 ? "" : "s"} in this file not shown.` : "")
+        };
+      })
+    };
+  }
+  const findings = [];
+  const limitations = [];
+  const limit = (node, limitation) => {
+    const { line, character } = source.getLineAndCharacterOfPosition(node.getStart(source));
+    limitations.push({ ...limitation, file, line: line + 1, column: character + 1 });
+  };
+  const report = (node, finding) => {
+    const { line, character } = source.getLineAndCharacterOfPosition(node.getStart(source));
+    findings.push({
+      code: finding.code,
+      severity: finding.severity,
+      file,
+      line: line + 1,
+      column: character + 1,
+      ...finding.component === void 0 ? {} : { component: finding.component },
+      ...finding.prop === void 0 ? {} : { prop: finding.prop },
+      message: finding.message,
+      ...finding.valid_values === void 0 ? {} : { valid_values: finding.valid_values },
+      ...finding.suggestions === void 0 ? {} : { suggestions: finding.suggestions }
+    });
+  };
+  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;
+    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;
+      if (from === PACKAGE && !contract2.exports.includes(exported)) {
+        let suggestions = nearest(exported, Object.keys(contract2.components));
+        if (suggestions.length === 0) suggestions = nearest(exported, contract2.exports);
+        let hint = suggestions.length > 0 ? ` Did you mean ${suggestions.join(", ")}?` : "";
+        if (suggestions.length === 0) {
+          const [byPurpose] = search(
+            contract2,
+            { version: contract2.version, entries: [], files: {} },
+            exported.replace(/([a-z0-9])([A-Z])/g, "$1 $2"),
+            1
+          );
+          if (byPurpose !== void 0) {
+            suggestions = [byPurpose.name];
+            hint = ` Closest by purpose: ${byPurpose.name} (${byPurpose.purpose}).`;
+          }
+        }
+        report(element2, {
+          code: "UNKNOWN_EXPORT",
+          severity: "error",
+          message: `${PACKAGE} has no export ${JSON.stringify(exported)}.${hint}`,
+          ...suggestions.length > 0 ? { suggestions } : {}
+        });
+        continue;
+      }
+      if (isComponent(exported)) named.set(element2.name.text, exported);
+    }
+  }
+  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)];
+    return [];
+  };
+  const valueOf = (attribute) => attribute.initializer === void 0 ? void 0 : ts.isJsxExpression(attribute.initializer) ? attribute.initializer.expression : attribute.initializer;
+  const optionValue = (expression) => {
+    const read = [];
+    const unread = [];
+    const walk = (node) => {
+      if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+        read.push(node.text);
+      else if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isNonNullExpression(node) || ts.isTypeAssertionExpression(node) || typeof ts.isSatisfiesExpression === "function" && ts.isSatisfiesExpression(node))
+        walk(node.expression);
+      else if (ts.isConditionalExpression(node)) {
+        walk(node.whenTrue);
+        walk(node.whenFalse);
+      } else if (ts.isBinaryExpression(node)) {
+        const operator = node.operatorToken.kind;
+        if (operator === ts.SyntaxKind.QuestionQuestionToken || operator === ts.SyntaxKind.BarBarToken) {
+          walk(node.left);
+          walk(node.right);
+        } else if (operator === ts.SyntaxKind.AmpersandAmpersandToken) walk(node.right);
+        else unread.push(node);
+      } else if (!// No value: the component's default applies.
+      (ts.isIdentifier(node) && node.text === "undefined" || node.kind === ts.SyntaxKind.NullKeyword))
+        unread.push(node);
+    };
+    if (expression) walk(expression);
+    return { literals: read, unread };
+  };
+  const classText = (expression) => {
+    if (!expression) return "";
+    if (ts.isTemplateExpression(expression))
+      return [
+        expression.head.text,
+        ...expression.templateSpans.map((span) => span.literal.text)
+      ].join(" ");
+    return literals(expression).join(" ");
+  };
+  const houseRules = (attribute, name) => {
+    const value = valueOf(attribute);
+    if (name === "className") {
+      const classes = classText(value);
+      if (RAW_COLOR_CLASS.test(classes))
+        report(attribute, {
+          code: "RAW_COLOR",
+          severity: "warning",
+          message: "A color written out by hand. Use an OPERATOR color token (bg-oprt-\u2026, text-oprt-\u2026)."
+        });
+      if (ARBITRARY_SIZE.test(classes))
+        report(attribute, {
+          code: "ARBITRARY_SIZE",
+          severity: "warning",
+          message: "A size in pixels written out by hand. Use the spacing scale (p-2u, gap-3u, h-oprt-md)."
+        });
+      if (ROUNDED_CORNER.test(classes))
+        report(attribute, {
+          code: "ROUNDED_CORNER",
+          severity: "warning",
+          message: "A rounded corner. The radius is 0 everywhere in OPERATOR."
+        });
+    }
+    if (name === "style" && value && ts.isObjectLiteralExpression(value)) {
+      for (const property of value.properties)
+        if (ts.isPropertyAssignment(property) && literals(property.initializer).some((literal) => RAW_COLOR_VALUE.test(literal)))
+          report(attribute, {
+            code: "RAW_COLOR",
+            severity: "warning",
+            message: "A color written out by hand. Use an OPERATOR color token (var(--oprt-\u2026))."
+          });
+    }
+  };
+  const element = (opening, ancestors, parent, hasChildren, renderedAs) => {
+    const tag = opening.tagName;
+    let component = null;
+    if (ts.isIdentifier(tag)) {
+      component = named.get(tag.text) ?? null;
+      if (component === null && !renderedAs && Object.hasOwn(NATIVE, tag.text))
+        report(opening, {
+          code: "NATIVE_CONTROL",
+          severity: "warning",
+          message: `A native <${tag.text}>: use ${NATIVE[tag.text]}.`
+        });
+    } 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 (named.has(owner)) {
+        const joined = `${named.get(owner)}${tag.name.text}`;
+        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.")
+        });
+      }
+    }
+    const attributes = opening.attributes.properties;
+    for (const attribute of attributes)
+      if (ts.isJsxAttribute(attribute) && ts.isIdentifier(attribute.name))
+        houseRules(attribute, attribute.name.text);
+    if (component === null) return null;
+    const definition = contract2.components[component];
+    const spread = attributes.some((attribute) => ts.isJsxSpreadAttribute(attribute));
+    for (const attribute of attributes)
+      if (ts.isJsxSpreadAttribute(attribute))
+        limit(attribute, {
+          code: "UNRESOLVED_SPREAD",
+          component,
+          message: `Props spread into <${component}> (${quote(attribute.getText(source))}) were not read: option values and required props that arrive through them were not checked.`
+        });
+    const given = /* @__PURE__ */ new Set();
+    for (const attribute of attributes) {
+      if (!ts.isJsxAttribute(attribute)) continue;
+      const prop = ts.isIdentifier(attribute.name) ? attribute.name.text : attribute.name.getText(source);
+      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 names2 = Object.keys(definition.props);
+        report(attribute, {
+          code: "UNKNOWN_PROP",
+          severity: "warning",
+          component,
+          prop,
+          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;
+      const { literals: options, unread } = optionValue(valueOf(attribute));
+      for (const expression of unread)
+        limit(attribute, {
+          code: "UNRESOLVED_VALUE",
+          component,
+          prop,
+          message: `${component} ${prop} is set from an expression (${quote(expression.getText(source))}) whose value is not in the source, so it was not compared with the options.`
+        });
+      for (const literal of options) {
+        if (known.values.includes(literal)) continue;
+        const elsewhere = Object.entries(contract2.components).filter(([, other]) => other.props[prop]?.values?.includes(literal)).map(([name]) => name);
+        report(attribute, {
+          code: "INVALID_PROP_VALUE",
+          severity: "error",
+          component,
+          prop,
+          message: `${component} ${prop}=${JSON.stringify(literal)} is not an option. Use one of: ${known.values.join(", ")}.` + (elsewhere.length > 0 ? ` ${JSON.stringify(literal)} is a ${elsewhere.slice(0, 3).join(" or ")} ${prop}.` : ""),
+          valid_values: known.values
+        });
+      }
+    }
+    if (!spread) {
+      const needed = [
+        ...Object.entries(definition.props),
+        ...Object.entries(definition.slots ?? {})
+      ].filter(([, { required }]) => required);
+      for (const [prop] of needed)
+        if (!given.has(prop) && !(prop === "children" && hasChildren))
+          report(opening, {
+            code: "MISSING_REQUIRED_PROP",
+            severity: "error",
+            component,
+            prop,
+            message: `${component} needs ${prop}.`
+          });
+    }
+    const banned = (definition.never_inside ?? []).find((name) => ancestors.includes(name));
+    if (banned !== void 0)
+      report(opening, {
+        code: "INVALID_NESTING",
+        severity: "error",
+        component,
+        message: `${component} must not be inside ${banned}.`
+      });
+    const allowed = parent === null ? void 0 : allowedChildren2(contract2.composition_rules, parent);
+    if (allowed !== void 0 && !allowed.includes("any") && !allowed.includes(component))
+      report(opening, {
+        code: "INVALID_CHILD",
+        severity: "error",
+        component,
+        message: `${parent} takes only ${allowed.filter((name) => name !== "text").join(", ")} directly inside it, not ${component}.`
+      });
+    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)
+      );
+      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"
+      );
+      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));
+  };
+  visit(source, [], null);
+  const byPlace = (a, b) => a.line - b.line || a.column - b.column;
+  return {
+    file,
+    status: limitations.length > 0 ? "partial" : "evaluated",
+    findings: findings.sort(byPlace),
+    limitations: limitations.sort(byPlace)
+  };
+}
+function* sources(path2) {
+  if (excluded(basename(path2))) return;
+  if (statSync(path2).isDirectory()) {
+    for (const entry of readdirSync(path2).sort()) yield* sources(join2(path2, entry));
+  } else if (READ.has(extname(path2)) && !NOT_INTERFACE.test(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
+  };
+}
+function checkExitCode(report, { strict }) {
+  if (report.evaluation_status === "no_files_evaluated") return 1;
+  if (report.summary.errors > 0 || report.coverage.files_not_evaluated > 0) return 1;
+  return strict && report.summary.warnings > 0 ? 1 : 0;
+}
+function resolveParser(cwd, provided, who) {
+  if (provided !== void 0 && provided !== null)
+    return { typescript: provided, parser: describeProvided(provided) };
+  const probe = provided === null ? null : probeTypeScript(cwd);
+  if (probe?.ready) {
+    const { name, version, source } = probe.resolution;
+    return { typescript: probe.typescript, parser: { name, version, source } };
+  }
+  if (probe !== null && probe.reason === "typescript_unusable")
+    throw new CliError(`${who} cannot use the TypeScript it found: ${probe.detail}`, 1, {
+      code: "ERR_TYPESCRIPT_UNUSABLE"
+    });
+  throw new CliError(
+    `${who} reads code with the project's TypeScript, and found none. Install typescript in this project (${INSTALL_TYPESCRIPT}) and run it again. It looked from ${cwd}.`,
+    1,
+    { code: "ERR_TYPESCRIPT_MISSING" }
+  );
+}
+function checkPaths(paths, context) {
+  const root = 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));
+  }
+  const { typescript, parser } = resolveParser(root, context.typescript, "oprt check");
+  const evaluations = [...new Set(files)].map(
+    (file) => checkSource(
+      typescript,
+      context.contract,
+      relative(root, file).split(sep).join("/"),
+      readFileSync(file, "utf8")
+    )
+  );
+  return buildCheckReport(evaluations, { parser, skipped });
+}
+function renderCheckText(report) {
+  const lines = report.findings.map(
+    ({ file, line, column, severity, code, message }) => `${file}:${line}:${column}  ${severity}  ${code}  ${message}`
+  );
+  const shown = report.limitations.slice(0, MAX_LIMITS_SHOWN);
+  for (const { file, line, column, code, message } of shown)
+    lines.push(`${file}:${line}:${column}  limit  ${code}  ${message}`);
+  if (report.limitations.length > shown.length)
+    lines.push(
+      `  ...and ${plural(report.limitations.length - shown.length, "more limit")}; the JSON lists them all.`
+    );
+  const { coverage, evaluation_status: status } = report;
+  if (status === "no_files_evaluated") {
+    lines.push("No .tsx or .jsx file was read, so nothing was checked.");
+    const labels = {
+      unsupported_extension: "not a .tsx or .jsx file",
+      test_or_story_file: "a test, spec or story file, which is skipped",
+      excluded_folder: "a folder that is skipped (node_modules, dist, build, out, coverage, hidden)"
+    };
+    for (const { path: path2, reason } of report.skipped_inputs)
+      lines.push(`  ${path2}: ${labels[reason]}`);
+  } else if (coverage.files_not_evaluated > 0)
+    lines.push(
+      `${plural(coverage.files_not_evaluated, "file")} did not parse and ${coverage.files_not_evaluated === 1 ? "was" : "were"} not checked against the contract.`
+    );
+  else if (status === "evaluated_clean")
+    lines.push(
+      "Nothing found. Checked syntax, option values, nesting, required props and the house rules; types and rendering are not checked."
+    );
+  lines.push(
+    `${plural(report.summary.errors, "error")}, ${plural(report.summary.warnings, "warning")} in ${plural(report.files, "file")}. Status: ${status}.`
+  );
+  return `${lines.join("\n")}
+`;
+}
+var FINDING_CODES, LIMITATION_CODES, SCOPE, PACKAGE, NATIVE, NATIVE_ATTRIBUTES, nativeAttribute, RAW_COLOR_CLASS, RAW_COLOR_VALUE, ARBITRARY_SIZE, ROUNDED_CORNER, quote, MAX_SYNTAX_ERRORS, SKIPPED, READ, NOT_INTERFACE, excluded, describeProvided, plural, MAX_LIMITS_SHOWN;
+var init_check = __esm({
+  "src/check.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_lookup();
+    init_parser();
+    init_types();
+    init_parser();
+    FINDING_CODES = [
+      "INVALID_PROP_VALUE",
+      "UNKNOWN_EXPORT",
+      "DOT_NOTATION",
+      "INVALID_NESTING",
+      "INVALID_CHILD",
+      "MISSING_REQUIRED_PROP",
+      "UNKNOWN_PROP",
+      "RAW_COLOR",
+      "ARBITRARY_SIZE",
+      "ROUNDED_CORNER",
+      "NATIVE_CONTROL",
+      /** The file does not parse. It was not checked against the contract. */
+      "SYNTAX_ERROR"
+    ];
+    LIMITATION_CODES = ["UNRESOLVED_SPREAD", "UNRESOLVED_VALUE"];
+    SCOPE = {
+      checked: ["syntax", "contract", "house_rules"],
+      not_checked: ["types", "render"]
+    };
+    PACKAGE = "@oprt/react";
+    NATIVE = {
+      button: "Button",
+      input: "Input, or the control for its type (Checkbox, RadioGroup, NumberInput, Slider, DatePicker, FileUpload)",
+      select: "Select",
+      textarea: "Textarea",
+      table: "DataTable or DataGrid",
+      dialog: "Dialog",
+      progress: "Progress",
+      hr: "Divider"
+    };
+    NATIVE_ATTRIBUTES = new Set(
+      `key ref children className style id title role tabIndex hidden lang dir slot draggable spellCheck
+  translate inert accessKey autoCapitalize contentEditable enterKeyHint inputMode
+  dangerouslySetInnerHTML suppressHydrationWarning suppressContentEditableWarning htmlFor type name
+  value defaultValue checked defaultChecked disabled readOnly required placeholder autoComplete
+  autoFocus min max step minLength maxLength pattern multiple accept form formAction href target rel
+  download src alt width height loading rows cols wrap open colSpan rowSpan scope headers label list
+  size method action encType noValidate popover popoverTarget popoverTargetAction asChild`.split(
+        /\s+/
+      )
+    );
+    nativeAttribute = (name) => NATIVE_ATTRIBUTES.has(name) || /^(aria-|data-)/.test(name) || /^on[A-Z]/.test(name);
+    RAW_COLOR_CLASS = /\[(?:#[0-9a-fA-F]{3,8}\b|rgba?\(|hsla?\()/;
+    RAW_COLOR_VALUE = /^#[0-9a-fA-F]{3,8}$|^(?:rgb|hsl)a?\(/;
+    ARBITRARY_SIZE = /(?:^|[\s:])-?[a-z][a-z0-9-]*-\[-?\d*\.?\d+px\]/;
+    ROUNDED_CORNER = /(?:^|[\s:])rounded(?!-none(?:\s|$))(?:-[^\s]+)?(?=\s|$)/;
+    quote = (text2) => {
+      const flat = text2.replace(/\s+/g, " ").trim();
+      return flat.length > 48 ? `${flat.slice(0, 45)}...` : flat;
+    };
+    MAX_SYNTAX_ERRORS = 10;
+    SKIPPED = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", "coverage"]);
+    READ = /* @__PURE__ */ new Set([".tsx", ".jsx"]);
+    NOT_INTERFACE = /\.(?:test|spec|stories)\.[jt]sx$/;
+    excluded = (name) => SKIPPED.has(name) || name.startsWith(".");
+    describeProvided = (typescript) => ({
+      name: "typescript",
+      version: typescript.version ?? "unknown",
+      source: "provided"
+    });
+    plural = (amount, word) => `${amount} ${word}${amount === 1 ? "" : "s"}`;
+    MAX_LIMITS_SHOWN = 20;
+  }
+});
+
+// package.json
+var package_default;
+var init_package = __esm({
+  "package.json"() {
+    package_default = {
+      name: "@oprt/cli",
+      version: "0.3.0",
+      description: "The OPERATOR command line: copy components and recipes into your app as source, give coding agents the contract, and check their code against it. Includes an MCP server.",
+      keywords: [
+        "design-system",
+        "cli",
+        "coding-agents",
+        "mcp",
+        "model-context-protocol",
+        "code-check",
+        "components"
+      ],
+      homepage: "https://oprt.dev/docs/agents/cli",
+      type: "module",
+      main: "./dist/index.cjs",
+      module: "./dist/index.js",
+      types: "./dist/index.d.ts",
+      bin: {
+        oprt: "./dist/bin.js"
+      },
+      engines: {
+        node: ">=22"
+      },
+      exports: {
+        ".": {
+          import: {
+            types: "./dist/index.d.ts",
+            default: "./dist/index.js"
+          },
+          require: {
+            types: "./dist/index.d.cts",
+            default: "./dist/index.cjs"
+          }
+        },
+        "./read": {
+          import: {
+            types: "./dist/read.d.ts",
+            default: "./dist/read.js"
+          },
+          require: {
+            types: "./dist/read.d.cts",
+            default: "./dist/read.cjs"
+          }
+        }
+      },
+      files: [
+        "dist"
+      ],
+      scripts: {
+        clean: `node -e "require('node:fs').rmSync('dist',{recursive:true,force:true})"`,
+        build: "pnpm run clean && node scripts/build-registry.mjs && tsup",
+        dev: "pnpm run clean && node scripts/build-registry.mjs && tsup --watch",
+        test: "vitest run",
+        typecheck: "tsc --noEmit",
+        lint: "eslint src scripts"
+      },
+      devDependencies: {
+        "@modelcontextprotocol/sdk": "1.32.1",
+        tsup: "^8.3.0",
+        typescript: "^5.6.3",
+        vitest: "^2.1.3"
+      },
+      license: "MIT",
+      publishConfig: {
+        access: "public"
+      }
+    };
+  }
+});
+
+// src/identity.ts
+import { createHash } from "crypto";
+function contractDigest(contract2) {
+  let digest = digests.get(contract2);
+  if (digest === void 0) {
+    digest = `sha256:${createHash("sha256").update(JSON.stringify(contract2)).digest("hex")}`;
+    digests.set(contract2, digest);
+  }
+  return digest;
+}
+function identityOf(contract2) {
+  return {
+    cli_version: VERSION,
+    contract_version: contract2.version,
+    contract_digest: contractDigest(contract2),
+    schema_version: RESULT_SCHEMA_VERSION
+  };
+}
+var VERSION, RESULT_SCHEMA_VERSION, digests;
+var init_identity = __esm({
+  "src/identity.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_package();
+    VERSION = package_default.version;
+    RESULT_SCHEMA_VERSION = 1;
+    digests = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// src/results.ts
+function errorEnvelope(error, contract2) {
+  const known = error instanceof CliError ? error : void 0;
+  const identity = contract2 === void 0 ? { cli_version: VERSION, schema_version: RESULT_SCHEMA_VERSION } : (({ cli_version, schema_version, contract_version, contract_digest }) => ({
+    cli_version,
+    schema_version,
+    contract_version,
+    contract_digest
+  }))(identityOf(contract2));
+  return {
+    apiVersion: 1,
+    error: error instanceof Error ? error.message : String(error),
+    code: known?.code ?? "ERR_FAILED",
+    ...known?.suggestions === void 0 ? {} : { suggestions: known.suggestions },
+    identity
+  };
+}
+function componentData(detail, dense) {
+  if (!dense) return { ...detail, dense };
+  const { description: _description, ...rest } = detail;
+  return {
+    ...rest,
+    props: detail.props.map(
+      (prop) => prop.description === void 0 ? prop : { ...prop, description: firstSentence(prop.description) }
+    ),
+    dense
+  };
+}
+function instructionsData(contract2) {
+  return {
+    rules: contract2.guidance.rules.map(({ id, rule, wrong, right }) => ({
+      id,
+      rule,
+      ...wrong === void 0 ? {} : { wrong },
+      ...right === void 0 ? {} : { right }
+    })),
+    components: componentIndex(contract2),
+    recipes: Object.entries(contract2.patterns ?? {}).map(([name, { description, install: install2 }]) => ({
+      name,
+      description,
+      install: install2
+    }))
+  };
+}
+function bundle(root) {
+  const used = {};
+  const visit = (node) => {
+    if (Array.isArray(node)) node.forEach(visit);
+    else if (typeof node === "object" && node !== null) {
+      for (const [key, value] of Object.entries(node)) {
+        if (key === "$ref" && typeof value === "string") {
+          const name = value.replace("#/$defs/", "");
+          if (used[name] === void 0) {
+            used[name] = DEFS[name];
+            visit(DEFS[name]);
+          }
+        } else visit(value);
+      }
+    }
+  };
+  visit(root);
+  return { ...root, $defs: used };
+}
+function schemaFor(type) {
+  return bundle(type === "error" ? failure() : success(type));
+}
+function shareRepeats(schema) {
+  const count = /* @__PURE__ */ new Map();
+  const tally = (node) => {
+    if (Array.isArray(node)) node.forEach(tally);
+    else if (typeof node === "object" && node !== null) {
+      const text2 = JSON.stringify(node);
+      if (text2.length >= 30) count.set(text2, (count.get(text2) ?? 0) + 1);
+      Object.values(node).forEach(tally);
+    }
+  };
+  tally(schema);
+  const repeated = [...count].filter(([, times]) => times >= 3).map(([text2]) => text2);
+  if (repeated.length === 0) return schema;
+  const names2 = new Map(
+    repeated.map((text2, index) => [text2, index === 0 ? "strings" : `part${index}`])
+  );
+  const defs = {};
+  const rewrite = (node) => {
+    if (Array.isArray(node)) return node.map(rewrite);
+    if (typeof node !== "object" || node === null) return node;
+    const name = names2.get(JSON.stringify(node));
+    if (name !== void 0) {
+      defs[name] = node;
+      return { $ref: `#/$defs/${name}` };
+    }
+    return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, rewrite(value)]));
+  };
+  const rewritten = rewrite(schema);
+  return { ...rewritten, $defs: defs };
+}
+function outputSchemaFor(type) {
+  return shareRepeats({
+    type: "object",
+    properties: {
+      type: { const: type },
+      // The four versions and the digest; the docs name them, and so does every answer.
+      identity: { type: "object" },
+      data: SUMMARIES[type]
+    },
+    required: ["identity"],
+    anyOf: [{ required: ["data"] }, { required: ["error"] }]
+  });
+}
+var RESULT_TYPES, envelope, str, int, bool, arr, names, words2, ref, obj, scalar, DEFS, DATA, success, failure, S, I, B, list, shape, strings, SUMMARIES, RESULT_SCHEMAS;
+var init_results = __esm({
+  "src/results.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_check();
+    init_identity();
+    init_lookup();
+    init_types();
+    RESULT_TYPES = [
+      "check",
+      "search",
+      "component.detail",
+      "component.batch",
+      "component.list",
+      "init",
+      "doctor",
+      "add",
+      "list",
+      "instructions"
+    ];
+    envelope = (type, data, contract2) => ({
+      apiVersion: 1,
+      type,
+      identity: identityOf(contract2),
+      data
+    });
+    str = (extra = {}) => ({ type: "string", ...extra });
+    int = () => ({ type: "integer", minimum: 0 });
+    bool = () => ({ type: "boolean" });
+    arr = (items) => ({ type: "array", items });
+    names = () => arr(str());
+    words2 = (...values) => ({ type: "string", enum: [...values] });
+    ref = (name) => ({ $ref: `#/$defs/${name}` });
+    obj = (properties, optional = [], open = false) => ({
+      type: "object",
+      properties,
+      required: Object.keys(properties).filter((key) => !optional.includes(key)),
+      additionalProperties: open
+    });
+    scalar = { type: ["string", "number", "boolean"] };
+    DEFS = {
+      identity: obj({
+        cli_version: str(),
+        contract_version: str(),
+        contract_digest: str({ pattern: "^sha256:[0-9a-f]{64}$" }),
+        schema_version: { type: "integer", minimum: 1 }
+      }),
+      error_identity: obj(
+        {
+          cli_version: str(),
+          schema_version: { type: "integer", minimum: 1 },
+          contract_version: str(),
+          contract_digest: str({ pattern: "^sha256:[0-9a-f]{64}$" })
+        },
+        ["contract_version", "contract_digest"]
+      ),
+      finding: obj(
+        {
+          code: words2(...FINDING_CODES),
+          severity: words2("error", "warning"),
+          file: str(),
+          line: { type: "integer", minimum: 1 },
+          column: { type: "integer", minimum: 1 },
+          component: str(),
+          prop: str(),
+          message: str(),
+          valid_values: names(),
+          suggestions: names()
+        },
+        ["component", "prop", "valid_values", "suggestions"]
+      ),
+      limitation: obj(
+        {
+          code: words2(...LIMITATION_CODES),
+          file: str(),
+          line: { type: "integer", minimum: 1 },
+          column: { type: "integer", minimum: 1 },
+          component: str(),
+          prop: str(),
+          message: str()
+        },
+        ["prop"]
+      ),
+      skipped_input: obj({
+        path: str(),
+        reason: words2("unsupported_extension", "test_or_story_file", "excluded_folder")
+      }),
+      parser: obj({
+        name: words2("typescript"),
+        version: str(),
+        source: words2("project", "installer", "provided")
+      }),
+      check_data: obj({
+        evaluation_status: words2(
+          "evaluated_clean",
+          "evaluated_with_findings",
+          "partially_evaluated",
+          "not_evaluated",
+          "no_files_evaluated"
+        ),
+        files: int(),
+        findings: arr(ref("finding")),
+        summary: obj({ errors: int(), warnings: int() }),
+        coverage: obj({
+          files_found: int(),
+          files_evaluated: int(),
+          files_partial: int(),
+          files_not_evaluated: int()
+        }),
+        limitations: arr(ref("limitation")),
+        skipped_inputs: arr(ref("skipped_input")),
+        scope: obj({ checked: names(), not_checked: names() }),
+        parser: ref("parser")
+      }),
+      search_result: obj(
+        {
+          kind: words2("component", "recipe"),
+          name: str(),
+          purpose: str(),
+          score: { type: "number" },
+          why: str(),
+          next: str()
+        },
+        ["why"]
+      ),
+      search_data: obj({
+        query: str(),
+        limit: { type: "integer", minimum: 1 },
+        matchCount: int(),
+        results: arr(ref("search_result"))
+      }),
+      index_entry: obj({ name: str(), purpose: str(), parts: names() }),
+      component_list_data: obj({ components: arr(ref("index_entry")) }),
+      detail_prop: obj(
+        {
+          name: str(),
+          type: str(),
+          values: names(),
+          types: names(),
+          default: scalar,
+          required: bool(),
+          description: str(),
+          notes: { type: "object", additionalProperties: str() }
+        },
+        ["values", "types", "default", "required", "description", "notes"],
+        // The contract may describe a prop with more than these (an array's item type, for one).
+        true
+      ),
+      component_detail: obj(
+        {
+          name: str(),
+          description: str(),
+          use_for: names(),
+          not_for: arr(obj({ need: str(), use: str() })),
+          part_of: str(),
+          parts: names(),
+          props: arr(ref("detail_prop")),
+          slots: {
+            type: "object",
+            additionalProperties: obj({ type: str(), required: bool() }, ["required"])
+          },
+          composable_with: names(),
+          never_inside: names(),
+          allowed_children: names(),
+          example: str(),
+          dense: bool()
+        },
+        ["description", "part_of", "slots", "allowed_children"]
+      ),
+      component_batch_data: obj({ components: arr(ref("component_detail")) }),
+      doctor_check: obj(
+        { id: str(), status: words2("ok", "warn", "fail"), message: str(), fix: str() },
+        ["fix"]
+      ),
+      doctor_data: obj({
+        consumer_directory: str(),
+        operations: obj({
+          lookup: obj({ status: words2("ready"), message: str(), contract_version: str() }),
+          check_code: obj(
+            {
+              status: words2("ready", "blocked"),
+              message: str(),
+              reason: words2("typescript_missing", "typescript_unusable"),
+              fix: str(),
+              typescript: obj({
+                version: str(),
+                resolved_from: str(),
+                source: words2("project", "installer", "provided")
+              })
+            },
+            ["reason", "fix", "typescript"]
+          )
+        }),
+        checks: arr(ref("doctor_check")),
+        summary: obj({ ok: int(), warn: int(), fail: int() })
+      }),
+      init_data: obj({
+        version: str(),
+        dryRun: bool(),
+        files: arr(
+          obj({
+            path: str(),
+            action: words2("create", "append", "update", "unchanged", "remove", "delete", "absent")
+          })
+        )
+      }),
+      install_file: obj({
+        path: str(),
+        destination: str(),
+        action: words2("create", "overwrite", "skip")
+      }),
+      add_data: obj({
+        outputDirectory: str(),
+        entries: names(),
+        dependencies: names(),
+        devDependencies: names(),
+        ranges: { type: "object", additionalProperties: str() },
+        files: arr(ref("install_file")),
+        dryRun: bool(),
+        setup: ref("setup")
+      }),
+      setup: obj({
+        tailwind: str(),
+        packages: arr(obj({ name: str(), range: str(), dev: bool(), why: str() })),
+        stylesheet: arr(obj({ line: str(), why: str() })),
+        root_import: obj({ line: str(), note: str() }),
+        not_needed: arr(obj({ name: str(), why: str() }))
+      }),
+      list_data: obj({
+        version: str(),
+        entries: arr(
+          obj(
+            {
+              name: str(),
+              slug: str(),
+              kind: words2("component", "recipe"),
+              description: str(),
+              files: names(),
+              dependencies: names(),
+              devDependencies: names()
+            },
+            ["devDependencies"]
+          )
+        ),
+        ranges: { type: "object", additionalProperties: str() }
+      }),
+      instructions_data: obj({
+        rules: arr(obj({ id: str(), rule: str(), wrong: str(), right: str() }, ["wrong", "right"])),
+        components: arr(ref("index_entry")),
+        recipes: arr(obj({ name: str(), description: str(), install: str() }))
+      })
+    };
+    DATA = {
+      check: "check_data",
+      search: "search_data",
+      "component.detail": "component_detail",
+      "component.batch": "component_batch_data",
+      "component.list": "component_list_data",
+      init: "init_data",
+      doctor: "doctor_data",
+      add: "add_data",
+      list: "list_data",
+      instructions: "instructions_data"
+    };
+    success = (type) => obj({
+      apiVersion: { const: 1 },
+      type: { const: type },
+      identity: ref("identity"),
+      data: ref(DATA[type])
+    });
+    failure = () => obj(
+      {
+        apiVersion: { const: 1 },
+        error: str(),
+        code: str({ pattern: "^ERR_[A-Z_]+$" }),
+        suggestions: names(),
+        identity: ref("error_identity")
+      },
+      ["suggestions"]
+    );
+    S = { type: "string" };
+    I = { type: "integer" };
+    B = { type: "boolean" };
+    list = (items) => items === void 0 ? { type: "array" } : { type: "array", items };
+    shape = (properties, required) => ({
+      type: "object",
+      properties,
+      ...required === void 0 ? {} : { required }
+    });
+    strings = list(S);
+    SUMMARIES = {
+      check: shape(
+        {
+          evaluation_status: words2(
+            "evaluated_clean",
+            "evaluated_with_findings",
+            "partially_evaluated",
+            "not_evaluated",
+            "no_files_evaluated"
+          ),
+          findings: list(
+            shape({
+              code: S,
+              severity: words2("error", "warning"),
+              file: S,
+              line: I,
+              column: I,
+              message: S
+            })
+          ),
+          summary: shape({ errors: I, warnings: I }),
+          coverage: shape({ files_evaluated: I, files_partial: I, files_not_evaluated: I }),
+          limitations: list(shape({ code: S, file: S, line: I, column: I, message: S })),
+          skipped_inputs: list(),
+          scope: { type: "object" },
+          parser: { type: "object" }
+        },
+        ["evaluation_status", "findings", "summary", "coverage", "limitations"]
+      ),
+      search: shape(
+        {
+          matchCount: I,
+          results: list(
+            shape({ kind: words2("component", "recipe"), name: S, purpose: S, why: S, next: S })
+          )
+        },
+        ["results"]
+      ),
+      "component.detail": shape(
+        {
+          name: S,
+          description: S,
+          use_for: strings,
+          not_for: list(),
+          part_of: S,
+          parts: strings,
+          props: list(
+            shape({ name: S, type: S, values: strings, required: B, notes: { type: "object" } })
+          ),
+          slots: { type: "object" },
+          composable_with: strings,
+          never_inside: strings,
+          allowed_children: strings,
+          example: S,
+          dense: B
+        },
+        ["name", "props", "example", "dense"]
+      ),
+      "component.list": shape({ components: list() }, ["components"]),
+      "component.batch": shape({ components: list() }, ["components"]),
+      instructions: shape(
+        {
+          rules: list(),
+          components: list(),
+          recipes: list()
+        },
+        ["rules", "components", "recipes"]
+      ),
+      init: shape({ files: list() }),
+      doctor: shape({ operations: { type: "object" }, checks: list() }),
+      add: shape({ files: list(), setup: { type: "object" } }),
+      list: shape({ entries: list() })
+    };
+    RESULT_SCHEMAS = Object.freeze(
+      Object.fromEntries(
+        [...RESULT_TYPES, "error"].map((type) => [type, schemaFor(type)])
+      )
+    );
+  }
+});
+
+// src/contract.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { dirname, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function loadContract() {
+  const here = dirname(fileURLToPath3(import.meta.url));
+  const candidates = [join3(here, "contract.json"), join3(here, "../generated/contract.json")];
+  const found = candidates.find((candidate) => existsSync2(candidate));
+  if (found === void 0) {
+    throw new Error(
+      `contract.json is missing next to ${here}. Install @oprt/cli again: the contract ships beside the executable, and the executable cannot be copied without it.`
+    );
+  }
+  return JSON.parse(readFileSync2(found, "utf8"));
+}
+var init_contract = __esm({
+  "src/contract.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/installer.ts
+import {
+  constants,
+  closeSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync as readFileSync3,
+  realpathSync,
+  writeFileSync
+} from "fs";
+import { dirname as dirname2, isAbsolute, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
+function resolveEntries(names2, registry2) {
+  if (!names2.length) throw new CliError("add requires one or more names.", 2);
+  const selected = /* @__PURE__ */ new Map();
+  for (const name of names2) {
+    const normalized = name.toLowerCase();
+    const entry = registry2.entries.find(
+      (candidate) => candidate.slug === normalized || candidate.name.toLowerCase() === normalized
+    );
+    if (!entry)
+      throw new CliError(`Unknown component or recipe ${JSON.stringify(name)}. Run oprt list.`, 2);
+    selected.set(entry.name, entry);
+  }
+  return [...selected.values()];
+}
+function validateRelative(path2) {
+  if (!path2 || isAbsolute(path2) || /[\\:\0]/.test(path2) || path2.split("/").includes(".."))
+    throw new CliError(
+      `Unsafe path ${JSON.stringify(path2)}: use a nonempty relative path without traversal.`,
+      2
+    );
+}
+function stat(path2) {
+  try {
+    return lstatSync(path2);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function inspectPath(root, destination, directory = false) {
+  const path2 = relative2(root, destination);
+  if (path2 === ".." || path2.startsWith(`..${sep2}`) || isAbsolute(path2))
+    throw new CliError("Output path escapes the working directory.");
+  let cursor = root;
+  const segments = path2 ? path2.split(sep2) : [];
+  for (let i = 0; i < segments.length; i++) {
+    cursor = resolve2(cursor, segments[i]);
+    const info = stat(cursor);
+    if (!info) continue;
+    if (info.isSymbolicLink()) throw new CliError(`Refusing symlink in output path: ${cursor}`);
+    const needsDirectory = i < segments.length - 1 || directory;
+    if (needsDirectory && !info.isDirectory())
+      throw new CliError(`Output ancestor is not a directory: ${cursor}`);
+    if (!needsDirectory && !info.isFile())
+      throw new CliError(`Output target is not a regular file: ${cursor}`);
+  }
+  return stat(destination);
+}
+function installSources(options, context) {
+  const entries = resolveEntries(options.names, context.registry);
+  const out = options.out ?? DEFAULT_OUT;
+  validateRelative(out);
+  const root = realpathSync(context.cwd);
+  const outputDirectory = resolve2(root, out);
+  inspectPath(root, outputDirectory, true);
+  const paths = [...new Set(entries.flatMap((entry) => entry.files))].sort();
+  const files = paths.map((path2) => {
+    validateRelative(path2);
+    const content = context.registry.files[path2];
+    if (!Object.hasOwn(context.registry.files, path2) || typeof content !== "string")
+      throw new CliError(`Registry is missing source ${path2}.`);
+    const destination = resolve2(outputDirectory, path2);
+    const info = inspectPath(root, destination);
+    if (!info) return { path: path2, destination, action: "create" };
+    if (readFileSync3(destination, "utf8") === content) return { path: path2, destination, action: "skip" };
+    if (!options.overwrite)
+      throw new CliError(
+        `Refusing to overwrite modified file ${destination}. Use --overwrite to replace it explicitly.`
+      );
+    return { path: path2, destination, action: "overwrite" };
+  });
+  const dependencies = [...new Set(entries.flatMap((entry) => entry.dependencies))].sort();
+  const runtime = new Set(
+    entries.flatMap(
+      (entry) => entry.dependencies.filter((name) => !(entry.devDependencies ?? []).includes(name))
+    )
+  );
+  const result = {
+    outputDirectory,
+    entries: entries.map((entry) => entry.name),
+    dependencies,
+    devDependencies: dependencies.filter(
+      (name) => !runtime.has(name) && entries.some((entry) => (entry.devDependencies ?? []).includes(name))
+    ),
+    ranges: Object.fromEntries(
+      dependencies.flatMap((name) => {
+        const range = context.registry.ranges?.[name];
+        return range === void 0 ? [] : [[name, range]];
+      })
+    ),
+    files,
+    dryRun: options.dryRun ?? false
+  };
+  if (result.dryRun) return result;
+  for (const file of files) {
+    if (file.action === "skip") continue;
+    inspectPath(root, file.destination);
+    const parent = dirname2(file.destination);
+    mkdirSync(parent, { recursive: true });
+    inspectPath(root, parent, true);
+    const flags = constants.O_WRONLY | constants.O_CREAT | (constants.O_NOFOLLOW ?? 0) | (file.action === "create" ? constants.O_EXCL : constants.O_TRUNC);
+    const descriptor = openSync(file.destination, flags, 420);
+    try {
+      writeFileSync(descriptor, context.registry.files[file.path]);
+    } finally {
+      closeSync(descriptor);
+    }
+  }
+  return result;
+}
+var init_installer = __esm({
+  "src/installer.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_args();
+    init_types();
+  }
+});
+
+// src/agent-block.ts
+function renderAgentBlock(contract2) {
+  const lines = [
+    START,
+    `<!-- Written by oprt ${contract2.version}. Do not edit between these markers: run \`oprt init\` to refresh. -->`,
+    "## OPERATOR design system",
+    "",
+    "This project builds its interface with OPERATOR (`@oprt/react`). Use its components, and look them up instead of guessing: these commands print the facts for the version installed here. Run them with the project's package runner (`npx oprt \u2026`, `pnpm exec oprt \u2026`).",
+    "",
+    "- `oprt search <need>`: which component or recipe answers a need",
+    "- `oprt component <Name>`: one component's options, nesting rules and example (`--dense` for the short form)",
+    "- `oprt add <recipe>`: copy a working screen into the project to adapt",
+    "- `oprt check <paths>`: check written code against the contract",
+    "",
+    "### Rules",
+    ""
+  ];
+  contract2.guidance.rules.forEach(({ rule, wrong, right }, index) => {
+    lines.push(`${index + 1}. ${rule}`);
+    if (wrong !== void 0) lines.push(`   Wrong: \`${wrong}\``);
+    if (right !== void 0) lines.push(`   Right: \`${right}\``);
+  });
+  lines.push("", "### Components", "");
+  for (const { name, purpose, parts } of componentIndex(contract2))
+    lines.push(`- ${name}${parts.length > 0 ? ` (${parts.join(", ")})` : ""}: ${purpose}`);
+  const recipes = Object.entries(contract2.patterns ?? {});
+  if (recipes.length > 0) {
+    lines.push("", "### Recipes (whole screens to start from)", "");
+    for (const [name, { description, install: install2 }] of recipes)
+      lines.push(`- ${name}: ${firstSentence2(description)} \`${install2}\``);
+  }
+  lines.push(END);
+  return `${lines.join("\n")}
+`;
+}
+function blockVersion(text2) {
+  const start = text2.indexOf(START);
+  if (start === -1) return void 0;
+  return /Written by oprt (\S+)\. Do not edit/.exec(text2.slice(start))?.[1];
+}
+function region(text2) {
+  const start = text2.indexOf(START);
+  if (start === -1) return void 0;
+  const end = text2.indexOf(END, start);
+  if (end === -1) return void 0;
+  const after = end + END.length;
+  return [start, text2[after] === "\n" ? after + 1 : after];
+}
+function applyBlock(existing, block) {
+  if (existing === null) return { text: block, action: "create" };
+  const found = region(existing);
+  if (found === void 0) {
+    const before = existing === "" || existing.endsWith("\n") ? existing : `${existing}
+`;
+    return { text: `${before}${before === "" ? "" : "\n"}${block}`, action: "append" };
+  }
+  const text2 = existing.slice(0, found[0]) + block + existing.slice(found[1]);
+  return { text: text2, action: text2 === existing ? "unchanged" : "update" };
+}
+function removeBlock(existing) {
+  const found = region(existing);
+  if (found === void 0) return { text: existing, found: false };
+  const before = existing.slice(0, found[0]);
+  return {
+    text: (before.endsWith("\n\n") ? before.slice(0, -1) : before) + existing.slice(found[1]),
+    found: true
+  };
+}
+var START, END, firstSentence2;
+var init_agent_block = __esm({
+  "src/agent-block.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_lookup();
+    START = "<!-- OPERATOR:START -->";
+    END = "<!-- OPERATOR:END -->";
+    firstSentence2 = (text2) => /^.*?[.!?](?=\s|$)/.exec(text2)?.[0] ?? text2;
+  }
+});
+
+// src/doctor.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname3, join as join4 } from "path";
+function installedVersion(cwd, name) {
+  for (let folder = cwd; ; folder = dirname3(folder)) {
+    const manifest = join4(folder, "node_modules", name, "package.json");
+    if (existsSync3(manifest))
+      return JSON.parse(readFileSync4(manifest, "utf8")).version;
+    if (dirname3(folder) === folder) return void 0;
+  }
+}
+function doctor({
+  cwd,
+  contract: contract2,
+  parser = probeTypeScript(cwd)
+}) {
+  const checks = [];
+  for (const name of PACKAGES) {
+    const version = installedVersion(cwd, name);
+    const id = `package:${name}`;
+    if (version === 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))
+      checks.push({
+        id,
+        status: "warn",
+        message: `${name} is ${version}; 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.` });
+  }
+  const written = INSTRUCTION_FILES.map((path2) => {
+    const file = join4(cwd, path2);
+    return {
+      path: path2,
+      version: existsSync3(file) ? blockVersion(readFileSync4(file, "utf8")) : void 0
+    };
+  }).filter(({ version }) => version !== void 0);
+  const stale = written.find(({ version }) => version !== contract2.version);
+  if (written.length === 0)
+    checks.push({
+      id: "agent-instructions",
+      status: "warn",
+      message: "No agent instruction file carries the OPERATOR block.",
+      fix: "oprt init"
+    });
+  else if (stale !== void 0)
+    checks.push({
+      id: "agent-instructions",
+      status: "warn",
+      message: `${stale.path} was written by oprt ${stale.version}; this is ${contract2.version}.`,
+      fix: "oprt init"
+    });
+  else
+    checks.push({
+      id: "agent-instructions",
+      status: "ok",
+      message: `${written.map(({ path: path2 }) => path2).join(", ")} carries the OPERATOR block (${contract2.version}).`
+    });
+  const install2 = `${INSTALL_TYPESCRIPT} (or your package manager's equivalent), then run oprt doctor again. Lookups work without it.`;
+  let checkCode;
+  if (parser.ready) {
+    const { version, resolved_from, source } = parser.resolution;
+    checkCode = {
+      status: "ready",
+      message: `TypeScript ${version}, resolved from ${resolved_from}${source === "project" ? "" : " (beside oprt, not this project)"}.`,
+      typescript: { version, resolved_from, source }
+    };
+    checks.push(
+      source === "project" ? {
+        id: "typescript",
+        status: "ok",
+        message: `TypeScript ${version} is installed in this project (${resolved_from}).`
+      } : {
+        id: "typescript",
+        status: "warn",
+        message: `TypeScript ${version} is not in this project; the one beside oprt is used (${resolved_from}).`,
+        fix: `${INSTALL_TYPESCRIPT}, so checking reads code with a version installed in the project.`
+      }
+    );
+  } else {
+    checkCode = {
+      status: "blocked",
+      message: `${parser.reason}: ${parser.detail}`,
+      reason: parser.reason,
+      fix: install2
+    };
+    checks.push({
+      id: "typescript",
+      status: "fail",
+      message: `oprt check and the check_code tool cannot run (${parser.reason}): ${parser.detail}`,
+      fix: install2
+    });
+  }
+  const count = (status) => checks.filter((check) => check.status === status).length;
+  return {
+    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({
+  "src/doctor.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_agent_block();
+    init_parser();
+    PACKAGES = ["@oprt/react", "@oprt/tokens", "@oprt/tailwind"];
+    INSTRUCTION_FILES = [
+      "AGENTS.md",
+      "CLAUDE.md",
+      ".claude/CLAUDE.md",
+      ".cursor/rules/operator.mdc"
+    ];
+    minor = (version) => version.split(".").slice(0, 2).join(".");
+  }
+});
+
+// src/init.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync5, realpathSync as realpathSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname4, resolve as resolve3 } from "path";
+function targets({ agent, path: path2 }) {
+  if (path2 !== void 0) return [path2];
+  if (agent === void 0) return DEFAULT_FILES;
+  const files = AGENT_FILES[agent];
+  if (files === void 0)
+    throw new CliError(
+      `Unknown agent ${JSON.stringify(agent)}. Use one of: ${Object.keys(AGENT_FILES).join(", ")}; or --path <file>.`,
+      2,
+      { code: "ERR_UNKNOWN_AGENT", suggestions: Object.keys(AGENT_FILES) }
+    );
+  return files;
+}
+function init(options, context) {
+  const root = realpathSync2(context.cwd);
+  const block = renderAgentBlock(context.contract);
+  const dryRun = options.dryRun ?? false;
+  const files = targets(options).map((path2) => {
+    validateRelative(path2);
+    const destination = resolve3(root, path2);
+    inspectPath(root, destination);
+    const existing = existsSync4(destination) ? readFileSync5(destination, "utf8") : null;
+    if (options.remove) {
+      if (existing === null) return { path: path2, action: "absent" };
+      const { text: text3, found } = removeBlock(existing);
+      if (!found) return { path: path2, action: "absent" };
+      const empty = withoutFrontMatter(text3).trim() === "";
+      if (!dryRun) {
+        if (empty) rmSync(destination);
+        else writeFileSync2(destination, text3);
+      }
+      return { path: path2, action: empty ? "delete" : "remove" };
+    }
+    const fresh = existing === null && path2.endsWith(".mdc") ? CURSOR_FRONT_MATTER : existing;
+    const { text: text2, action } = applyBlock(fresh, block);
+    if (action !== "unchanged" && !dryRun) {
+      mkdirSync2(dirname4(destination), { recursive: true });
+      writeFileSync2(destination, text2);
+    }
+    return { path: path2, action: existing === null ? "create" : action };
+  });
+  return { version: context.contract.version, dryRun, files };
+}
+var AGENT_FILES, DEFAULT_FILES, CURSOR_FRONT_MATTER, withoutFrontMatter;
+var init_init = __esm({
+  "src/init.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_agent_block();
+    init_installer();
+    init_types();
+    AGENT_FILES = {
+      claude: ["CLAUDE.md"],
+      cursor: [".cursor/rules/operator.mdc"],
+      codex: ["AGENTS.md"],
+      all: ["AGENTS.md", "CLAUDE.md", ".cursor/rules/operator.mdc"]
+    };
+    DEFAULT_FILES = ["AGENTS.md"];
+    CURSOR_FRONT_MATTER = "---\nalwaysApply: true\n---\n\n";
+    withoutFrontMatter = (text2) => text2.replace(/^---\n[\s\S]*?\n---\n?/, "");
+  }
+});
+
+// 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) {
+    case "component": {
+      if (command.list) {
+        const components = componentIndex(contract2);
+        return {
+          text: components.map(
+            ({ name, purpose, parts }) => `${name}${parts.length > 0 ? ` (${parts.join(", ")})` : ""}: ${purpose}
+`
+          ).join(""),
+          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: data.length === 1 ? envelope("component.detail", data[0], contract2) : envelope("component.batch", { components: data }, contract2),
+        exitCode: 0
+      };
+    }
+    case "search": {
+      const results = search(contract2, registry2, command.query, command.limit);
+      return {
+        text: results.length === 0 ? `Nothing matches ${JSON.stringify(command.query)}. Run oprt component --list to see what there is.
+` : results.map(
+          ({ kind, name, purpose, why, next }) => `${name} (${kind}): ${purpose}${why === void 0 ? "" : ` [${why}]`}
+  ${next}
+`
+        ).join(""),
+        json: envelope(
+          "search",
+          { query: command.query, limit: command.limit, matchCount: results.length, results },
+          contract2
+        ),
+        exitCode: 0
+      };
+    }
+    case "init": {
+      const result = init(command, { cwd, contract: contract2 });
+      const lines = [
+        `OPERATOR ${result.version} agent instructions${result.dryRun ? " (dry run)" : ""}`,
+        ...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, contract2),
+        exitCode: 0
+      };
+    }
+    case "check": {
+      const report = checkPaths(command.paths, { cwd, contract: contract2 });
+      return {
+        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: checkExitCode(report, { strict: command.strict })
+      };
+    }
+    case "doctor": {
+      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, 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 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();
+    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;
+  }
+});
+
+// src/mcp.ts
+import { createInterface } from "readline";
+function runTool(name, args, context) {
+  const { contract: contract2, registry: registry2 } = context;
+  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 = 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"),
+        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_instructions":
+      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 { typescript, parser } = resolveParser(
+        context.cwd ?? process.cwd(),
+        context.typescript,
+        "check_code"
+      );
+      const report = buildCheckReport(
+        [checkSource(typescript, contract2, "snippet.tsx", args["code"])],
+        { parser }
+      );
+      return { text: renderCheckText(report), structured: envelope("check", report, contract2) };
+    }
+    default:
+      throw new UnknownTool(name);
+  }
+}
+function handleMessage(raw, context) {
+  const failure2 = (id2, code, message) => ({
+    jsonrpc: "2.0",
+    id: id2 ?? null,
+    error: { code, message }
+  });
+  if (typeof raw !== "object" || raw === null) return failure2(null, -32700, "Parse error");
+  const { id, method, params } = raw;
+  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: {} },
+        // 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":
+      return result({});
+    case "tools/list":
+      return result({ tools: TOOLS });
+    case "tools/call": {
+      const { name, arguments: args } = params ?? {};
+      try {
+        const output = runTool(String(name), args ?? {}, context);
+        return result({
+          content: [text(output.text)],
+          structuredContent: output.structured
+        });
+      } catch (error) {
+        if (error instanceof UnknownTool) return failure2(id, -32602, error.message);
+        const failed = errorEnvelope(error, context.contract);
+        return result({
+          content: [text(failed.error)],
+          structuredContent: failed,
+          isError: true
+        });
+      }
+    }
+    default:
+      return failure2(id, -32601, `Method not found: ${method}`);
+  }
+}
+function serve(input, output, context) {
+  const lines = createInterface({ input, crlfDelay: Infinity });
+  lines.on("line", (line) => {
+    if (line.trim() === "") return;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      message = line;
+    }
+    const response = handleMessage(message, context);
+    if (response !== null) output.write(`${JSON.stringify(response)}
+`);
+  });
+  return new Promise((done) => lines.on("close", done));
+}
+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 });
+    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 for a need, such as 'show a status' or 'table with selection'. Call before writing interface code.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            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"],
+          additionalProperties: false
+        }
+      }),
+      define({
+        name: "get_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: {
+              type: "string",
+              minLength: 1,
+              maxLength: LIMITS.name,
+              description: "Component name, such as Button."
+            },
+            dense: {
+              type: "boolean",
+              default: true,
+              description: "Compact form (every constraint, one sentence per prop). False: full prose."
+            }
+          },
+          required: ["name"],
+          additionalProperties: false
+        }
+      }),
+      define({
+        name: "list_components",
+        description: "Every OPERATOR component in one line each, with its parts.",
+        inputSchema: { type: "object", properties: {}, additionalProperties: false }
+      }),
+      define({
+        name: "get_instructions",
+        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 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: {
+              type: "string",
+              minLength: 1,
+              maxLength: LIMITS.code,
+              description: "The TSX source of one file."
+            }
+          },
+          required: ["code"],
+          additionalProperties: false
+        }
+      })
+    ];
+    UnknownTool = class extends Error {
+      constructor(name) {
+        super(
+          `Unknown tool ${JSON.stringify(name)}. Its tools: ${TOOLS.map((tool) => tool.name).join(", ")}.`
+        );
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CliError: () => CliError,
+  DEFAULT_OUT: () => DEFAULT_OUT,
+  RESULT_SCHEMAS: () => RESULT_SCHEMAS,
+  RESULT_SCHEMA_VERSION: () => RESULT_SCHEMA_VERSION,
+  RESULT_TYPES: () => RESULT_TYPES,
+  TOOLS: () => TOOLS,
+  VERSION: () => VERSION,
+  applyBlock: () => applyBlock,
+  blockVersion: () => blockVersion,
+  buildCheckReport: () => buildCheckReport,
+  checkExitCode: () => checkExitCode,
+  checkPaths: () => checkPaths,
+  checkSource: () => checkSource,
+  componentDetail: () => componentDetail,
+  componentIndex: () => componentIndex,
+  contract: () => contract,
+  contractDigest: () => contractDigest,
+  doctor: () => doctor,
+  envelope: () => envelope,
+  errorEnvelope: () => errorEnvelope,
+  handleMessage: () => handleMessage,
+  identityOf: () => identityOf,
+  init: () => init,
+  install: () => install,
+  outputSchemaFor: () => outputSchemaFor,
+  parseArgs: () => parseArgs,
+  registry: () => registry,
+  removeBlock: () => removeBlock,
+  renderAgentBlock: () => renderAgentBlock,
+  renderCheckText: () => renderCheckText,
+  renderComponent: () => renderComponent,
+  resolveEntries: () => resolveEntries,
+  runAgentCommand: () => runAgentCommand,
+  schemaFor: () => schemaFor,
+  search: () => search,
+  serve: () => serve
+});
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname5, join as join5 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+function loadRegistry() {
+  const here = dirname5(fileURLToPath4(import.meta.url));
+  const candidates = [join5(here, "registry.json"), join5(here, "../generated/registry.json")];
+  const found = candidates.find((candidate) => existsSync5(candidate));
+  if (found === void 0) {
+    throw new Error(
+      `registry.json is missing next to ${here}. Install @oprt/cli again: the registry ships beside the executable, and the executable cannot be copied without it.`
+    );
+  }
+  return JSON.parse(readFileSync6(found, "utf8"));
+}
+function install(options, context = {}) {
+  return installSources(options, {
+    cwd: context.cwd ?? process.cwd(),
+    registry: context.registry ?? registry
+  });
+}
+var registry, loaded, contract;
+var init_index = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_contract();
+    init_installer();
+    init_identity();
+    init_agent_commands();
+    init_identity();
+    init_results();
+    init_agent_block();
+    init_check();
+    init_doctor();
+    init_mcp();
+    init_init();
+    init_lookup();
+    init_args();
+    init_installer();
+    init_types();
+    registry = loadRegistry();
+    contract = () => loaded ??= loadContract();
+  }
+});
+
+// src/bin.ts
+init_esm_shims();
+init_args();
+init_results();
+init_types();
+var helpText = (version) => `oprt ${version} \u2014 OPERATOR source installer
+
+Usage:
+  oprt list [--json]
+  oprt add <name...> [--out <relative directory>] [--dry-run] [--overwrite]
+  oprt --help
+  oprt --version
+
+For coding agents (each takes --json):
+  oprt init [--agent claude|cursor|codex|all | --path <file>] [--remove] [--dry-run]
+                                     Write the house rules and component index into the
+                                     agent's instruction file (AGENTS.md by default).
+  oprt search <need>          Which component or recipe answers a need.
+  oprt component <Name...> [--dense]
+                                     One component: options, nesting rules, example.
+  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. Says how much it
+                                     read (evaluation_status); a file that does not parse is
+                                     not checked, and is never clean.
+  oprt doctor                 Check this project's setup.
+  oprt mcp                    Serve the lookups and the check to an agent over the
+                                     Model Context Protocol (stdin and stdout).
+
+Exit codes: 0 success. check: 0 when every file read has no errors (no warnings either
+under --strict); limits it could not read are shown and do not fail the run. 1 when check
+finds an error, a file does not parse, or no .tsx or .jsx file was read; also for other
+failures (file conflicts, TypeScript missing). 2 for a usage error, an unknown name or a
+path that does not exist.
+
+Names accept PascalCase or kebab-case. Default output: src/components/operator.
+--dry-run    Preview all files and dependencies without creating anything.
+--overwrite  Replace different existing files; identical files are always skipped.
+
+Examples:
+  oprt add button filter-bar --out src/operator
+  oprt add asset-management --dry-run
+
+Run from the consumer project. Output must stay inside that working directory.
+Dependencies and Tailwind setup are reported; package configuration is never edited.
+`;
+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, 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 === "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;
+  }
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (process.argv.includes("--json")) {
+    let loaded2;
+    try {
+      loaded2 = (await Promise.resolve().then(() => (init_index(), index_exports))).contract();
+    } catch {
+      loaded2 = void 0;
+    }
+    process.stdout.write(`${JSON.stringify(errorEnvelope(error, loaded2), null, 2)}
+`);
+  } else process.stderr.write(`oprt: ${message}
+`);
+  process.exitCode = error instanceof CliError ? error.exitCode : 1;
+}