@oprt/cli 0.0.0-stage → 0.3.0

package/dist/index.js

@@ -0,0 +1,2473 @@
+// src/index.ts
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname5, join as join5 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/contract.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function loadContract() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [join(here, "contract.json"), join(here, "../generated/contract.json")];
+  const found = candidates.find((candidate) => existsSync(candidate));
+  if (found === void 0) {
+    throw new Error(
+      `contract.json is missing next to ${here}. Install @oprt/cli again: the contract ships beside the executable, and the executable cannot be copied without it.`
+    );
+  }
+  return JSON.parse(readFileSync(found, "utf8"));
+}
+
+// src/installer.ts
+import {
+  constants,
+  closeSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync as readFileSync2,
+  realpathSync,
+  writeFileSync
+} from "fs";
+import { dirname as dirname2, isAbsolute, relative, resolve, sep } from "path";
+
+// src/types.ts
+var 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
+var SEARCH_LIMIT_MAX = 50;
+var SEARCH_LIMIT_DEFAULT = 10;
+var squash = (name) => name.toLowerCase().replace(/[^a-z0-9]/g, "");
+var firstSentence = (text2) => /^.*?[.!?](?=\s|$)/.exec(text2)?.[0] ?? text2;
+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;
+}
+var partsOf = (contract2, name) => Object.keys(contract2.components).filter(
+  (part) => contract2.guidance.components[part]?.part_of === name
+);
+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")}
+`;
+}
+var 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(
+    " "
+  )
+);
+var 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);
+var matched = (query, text2) => {
+  const present = new Set(words(text2));
+  return query.filter((word) => present.has(word)).length;
+};
+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);
+}
+
+// src/args.ts
+var DEFAULT_OUT = "src/components/operator";
+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
+  };
+}
+var 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 path = value("--path");
+    if (positional.length > 0 || agent !== void 0 && path !== void 0)
+      throw new CliError(
+        "Usage: oprt init [--agent <name> | --path <file>] [--remove] [--dry-run]",
+        2
+      );
+    return {
+      command: "init",
+      ...agent === void 0 ? {} : { agent },
+      ...path === void 0 ? {} : { path },
+      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") };
+  }
+};
+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;
+}
+
+// src/installer.ts
+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(path) {
+  if (!path || isAbsolute(path) || /[\\:\0]/.test(path) || path.split("/").includes(".."))
+    throw new CliError(
+      `Unsafe path ${JSON.stringify(path)}: use a nonempty relative path without traversal.`,
+      2
+    );
+}
+function stat(path) {
+  try {
+    return lstatSync(path);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function inspectPath(root, destination, directory = false) {
+  const path = relative(root, destination);
+  if (path === ".." || path.startsWith(`..${sep}`) || isAbsolute(path))
+    throw new CliError("Output path escapes the working directory.");
+  let cursor = root;
+  const segments = path ? path.split(sep) : [];
+  for (let i = 0; i < segments.length; i++) {
+    cursor = resolve(cursor, segments[i]);
+    const info = stat(cursor);
+    if (!info) continue;
+    if (info.isSymbolicLink()) throw new CliError(`Refusing symlink in output path: ${cursor}`);
+    const needsDirectory = i < segments.length - 1 || directory;
+    if (needsDirectory && !info.isDirectory())
+      throw new CliError(`Output ancestor is not a directory: ${cursor}`);
+    if (!needsDirectory && !info.isFile())
+      throw new CliError(`Output target is not a regular file: ${cursor}`);
+  }
+  return 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 = resolve(root, out);
+  inspectPath(root, outputDirectory, true);
+  const paths = [...new Set(entries.flatMap((entry) => entry.files))].sort();
+  const files = paths.map((path) => {
+    validateRelative(path);
+    const content = context.registry.files[path];
+    if (!Object.hasOwn(context.registry.files, path) || typeof content !== "string")
+      throw new CliError(`Registry is missing source ${path}.`);
+    const destination = resolve(outputDirectory, path);
+    const info = inspectPath(root, destination);
+    if (!info) return { path, destination, action: "create" };
+    if (readFileSync2(destination, "utf8") === content) return { path, destination, action: "skip" };
+    if (!options.overwrite)
+      throw new CliError(
+        `Refusing to overwrite modified file ${destination}. Use --overwrite to replace it explicitly.`
+      );
+    return { path, 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;
+}
+
+// src/identity.ts
+import { createHash } from "crypto";
+
+// package.json
+var 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
+var VERSION = package_default.version;
+var RESULT_SCHEMA_VERSION = 1;
+var digests = /* @__PURE__ */ new WeakMap();
+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
+  };
+}
+
+// src/check.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3, statSync } from "fs";
+import { basename, extname, join as join3, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
+
+// src/parser.ts
+import { createRequire } from "module";
+import { join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var SUPPORTED_TYPESCRIPT = "TypeScript 5 or 6";
+var INSTALL_TYPESCRIPT = "npm install -D typescript@6";
+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;
+}
+var packageFolder = (file) => /^(.*[\\/]node_modules[\\/]typescript)[\\/]/.exec(file)?.[1] ?? file;
+function probeTypeScript(cwd, options = {}) {
+  const places = [
+    { from: join2(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"}.`
+  };
+}
+
+// src/check.ts
+var 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"
+];
+var LIMITATION_CODES = ["UNRESOLVED_SPREAD", "UNRESOLVED_VALUE"];
+var SCOPE = {
+  checked: ["syntax", "contract", "house_rules"],
+  not_checked: ["types", "render"]
+};
+var PACKAGE = "@oprt/react";
+var 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"
+};
+var 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+/
+  )
+);
+var nativeAttribute = (name) => NATIVE_ATTRIBUTES.has(name) || /^(aria-|data-)/.test(name) || /^on[A-Z]/.test(name);
+var RAW_COLOR_CLASS = /\[(?:#[0-9a-fA-F]{3,8}\b|rgba?\(|hsla?\()/;
+var RAW_COLOR_VALUE = /^#[0-9a-fA-F]{3,8}$|^(?:rgb|hsl)a?\(/;
+var ARBITRARY_SIZE = /(?:^|[\s:])-?[a-z][a-z0-9-]*-\[-?\d*\.?\d+px\]/;
+var ROUNDED_CORNER = /(?:^|[\s:])rounded(?!-none(?:\s|$))(?:-[^\s]+)?(?=\s|$)/;
+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;
+}
+var quote = (text2) => {
+  const flat = text2.replace(/\s+/g, " ").trim();
+  return flat.length > 48 ? `${flat.slice(0, 45)}...` : flat;
+};
+var MAX_SYNTAX_ERRORS = 10;
+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)
+  };
+}
+var SKIPPED = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", "coverage"]);
+var READ = /* @__PURE__ */ new Set([".tsx", ".jsx"]);
+var NOT_INTERFACE = /\.(?:test|spec|stories)\.[jt]sx$/;
+var excluded = (name) => SKIPPED.has(name) || name.startsWith(".");
+function* sources(path) {
+  if (excluded(basename(path))) return;
+  if (statSync(path).isDirectory()) {
+    for (const entry of readdirSync(path).sort()) yield* sources(join3(path, entry));
+  } else if (READ.has(extname(path)) && !NOT_INTERFACE.test(basename(path))) yield path;
+}
+function whyNotRead(path) {
+  const name = basename(path);
+  if (excluded(name)) return "excluded_folder";
+  if (statSync(path).isDirectory()) return null;
+  if (!READ.has(extname(path))) 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;
+}
+var describeProvided = (typescript) => ({
+  name: "typescript",
+  version: typescript.version ?? "unknown",
+  source: "provided"
+});
+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 = resolve2(context.cwd);
+  const files = [];
+  const skipped = [];
+  for (const path of paths) {
+    const absolute = resolve2(root, path);
+    if (!existsSync2(absolute))
+      throw new CliError(`No such file or folder: ${path}`, 2, { code: "ERR_PATH_NOT_FOUND" });
+    const reason = whyNotRead(absolute);
+    if (reason !== null) skipped.push({ path, 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,
+      relative2(root, file).split(sep2).join("/"),
+      readFileSync3(file, "utf8")
+    )
+  );
+  return buildCheckReport(evaluations, { parser, skipped });
+}
+var plural = (amount, word) => `${amount} ${word}${amount === 1 ? "" : "s"}`;
+var MAX_LIMITS_SHOWN = 20;
+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, reason } of report.skipped_inputs)
+      lines.push(`  ${path}: ${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")}
+`;
+}
+
+// src/doctor.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname3, join as join4 } from "path";
+
+// src/agent-block.ts
+var START = "<!-- OPERATOR:START -->";
+var END = "<!-- OPERATOR:END -->";
+var firstSentence2 = (text2) => /^.*?[.!?](?=\s|$)/.exec(text2)?.[0] ?? text2;
+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
+  };
+}
+
+// src/doctor.ts
+var PACKAGES = ["@oprt/react", "@oprt/tokens", "@oprt/tailwind"];
+var INSTRUCTION_FILES = [
+  "AGENTS.md",
+  "CLAUDE.md",
+  ".claude/CLAUDE.md",
+  ".cursor/rules/operator.mdc"
+];
+var minor = (version) => version.split(".").slice(0, 2).join(".");
+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((path) => {
+    const file = join4(cwd, path);
+    return {
+      path,
+      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 }) => path).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") }
+  };
+}
+
+// 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";
+var AGENT_FILES = {
+  claude: ["CLAUDE.md"],
+  cursor: [".cursor/rules/operator.mdc"],
+  codex: ["AGENTS.md"],
+  all: ["AGENTS.md", "CLAUDE.md", ".cursor/rules/operator.mdc"]
+};
+var DEFAULT_FILES = ["AGENTS.md"];
+var CURSOR_FRONT_MATTER = "---\nalwaysApply: true\n---\n\n";
+function targets({ agent, path }) {
+  if (path !== void 0) return [path];
+  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;
+}
+var withoutFrontMatter = (text2) => text2.replace(/^---\n[\s\S]*?\n---\n?/, "");
+function init(options, context) {
+  const root = realpathSync2(context.cwd);
+  const block = renderAgentBlock(context.contract);
+  const dryRun = options.dryRun ?? false;
+  const files = targets(options).map((path) => {
+    validateRelative(path);
+    const destination = resolve3(root, path);
+    inspectPath(root, destination);
+    const existing = existsSync4(destination) ? readFileSync5(destination, "utf8") : null;
+    if (options.remove) {
+      if (existing === null) return { path, action: "absent" };
+      const { text: text3, found } = removeBlock(existing);
+      if (!found) return { path, action: "absent" };
+      const empty = withoutFrontMatter(text3).trim() === "";
+      if (!dryRun) {
+        if (empty) rmSync(destination);
+        else writeFileSync2(destination, text3);
+      }
+      return { path, action: empty ? "delete" : "remove" };
+    }
+    const fresh = existing === null && path.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, action: existing === null ? "create" : action };
+  });
+  return { version: context.contract.version, dryRun, files };
+}
+
+// src/results.ts
+var RESULT_TYPES = [
+  "check",
+  "search",
+  "component.detail",
+  "component.batch",
+  "component.list",
+  "init",
+  "doctor",
+  "add",
+  "list",
+  "instructions"
+];
+var envelope = (type, data, contract2) => ({
+  apiVersion: 1,
+  type,
+  identity: identityOf(contract2),
+  data
+});
+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
+    }))
+  };
+}
+var str = (extra = {}) => ({ type: "string", ...extra });
+var int = () => ({ type: "integer", minimum: 0 });
+var bool = () => ({ type: "boolean" });
+var arr = (items) => ({ type: "array", items });
+var names = () => arr(str());
+var words2 = (...values) => ({ type: "string", enum: [...values] });
+var ref = (name) => ({ $ref: `#/$defs/${name}` });
+var obj = (properties, optional = [], open = false) => ({
+  type: "object",
+  properties,
+  required: Object.keys(properties).filter((key) => !optional.includes(key)),
+  additionalProperties: open
+});
+var scalar = { type: ["string", "number", "boolean"] };
+var 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() }))
+  })
+};
+var 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"
+};
+var success = (type) => obj({
+  apiVersion: { const: 1 },
+  type: { const: type },
+  identity: ref("identity"),
+  data: ref(DATA[type])
+});
+var failure = () => obj(
+  {
+    apiVersion: { const: 1 },
+    error: str(),
+    code: str({ pattern: "^ERR_[A-Z_]+$" }),
+    suggestions: names(),
+    identity: ref("error_identity")
+  },
+  ["suggestions"]
+);
+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));
+}
+var S = { type: "string" };
+var I = { type: "integer" };
+var B = { type: "boolean" };
+var list = (items) => items === void 0 ? { type: "array" } : { type: "array", items };
+var shape = (properties, required) => ({
+  type: "object",
+  properties,
+  ...required === void 0 ? {} : { required }
+});
+var strings = list(S);
+var 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() })
+};
+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_SCHEMAS = Object.freeze(
+  Object.fromEntries(
+    [...RESULT_TYPES, "error"].map((type) => [type, schemaFor(type)])
+  )
+);
+
+// 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}`)
+  ];
+}
+
+// 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, action }) => `  ${action.padEnd(9)} ${path}`),
+        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
+      };
+    }
+  }
+}
+
+// src/mcp.ts
+import { createInterface } from "readline";
+
+// src/validate.ts
+var KNOWN = /* @__PURE__ */ new Set([
+  "type",
+  "description",
+  "default",
+  "enum",
+  "minimum",
+  "maximum",
+  "minLength",
+  "maxLength"
+]);
+var 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;
+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("; ")}.`;
+}
+
+// src/mcp.ts
+var VERSIONS = ["2025-11-25", "2025-06-18", "2025-03-26", "2024-11-05"];
+var text = (value) => ({ type: "text", text: value });
+var LIMITS = { query: 500, name: 100, code: 2e5 };
+var ANSWERS = {
+  search: "search",
+  get_component: "component.detail",
+  list_components: "component.list",
+  get_instructions: "instructions",
+  check_code: "check"
+};
+var readOnly = { readOnlyHint: true };
+var define = (tool) => ({
+  ...tool,
+  outputSchema: outputSchemaFor(ANSWERS[tool.name]),
+  annotations: readOnly
+});
+var 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
+    }
+  })
+];
+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);
+  }
+}
+var UnknownTool = class extends Error {
+  constructor(name) {
+    super(
+      `Unknown tool ${JSON.stringify(name)}. Its tools: ${TOOLS.map((tool) => tool.name).join(", ")}.`
+    );
+  }
+};
+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));
+}
+
+// src/index.ts
+function loadRegistry() {
+  const here = dirname5(fileURLToPath3(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"));
+}
+var registry = loadRegistry();
+var loaded;
+var contract = () => loaded ??= loadContract();
+function install(options, context = {}) {
+  return installSources(options, {
+    cwd: context.cwd ?? process.cwd(),
+    registry: context.registry ?? registry
+  });
+}
+export {
+  CliError,
+  DEFAULT_OUT,
+  RESULT_SCHEMAS,
+  RESULT_SCHEMA_VERSION,
+  RESULT_TYPES,
+  TOOLS,
+  VERSION,
+  applyBlock,
+  blockVersion,
+  buildCheckReport,
+  checkExitCode,
+  checkPaths,
+  checkSource,
+  componentDetail,
+  componentIndex,
+  contract,
+  contractDigest,
+  doctor,
+  envelope,
+  errorEnvelope,
+  handleMessage,
+  identityOf,
+  init,
+  install,
+  outputSchemaFor,
+  parseArgs,
+  registry,
+  removeBlock,
+  renderAgentBlock,
+  renderCheckText,
+  renderComponent,
+  resolveEntries,
+  runAgentCommand,
+  schemaFor,
+  search,
+  serve
+};