@oprt/cli 0.1.0 → 0.4.0

package/dist/index.js

@@ -3,75 +3,6 @@ import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
 import { dirname as dirname5, join as join4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
-// package.json
-var package_default = {
-  name: "@oprt/cli",
-  version: "0.1.0",
-  description: "The OPERATOR command line: copy components and recipes into your app as source, give coding agents the contract, and check their code against it. Includes an MCP server.",
-  keywords: [
-    "design-system",
-    "cli",
-    "coding-agents",
-    "mcp",
-    "model-context-protocol",
-    "code-check",
-    "components"
-  ],
-  homepage: "https://oprt.dev/docs/agents/cli",
-  type: "module",
-  main: "./dist/index.cjs",
-  module: "./dist/index.js",
-  types: "./dist/index.d.ts",
-  bin: {
-    oprt: "./dist/bin.js"
-  },
-  engines: {
-    node: ">=22"
-  },
-  exports: {
-    ".": {
-      import: {
-        types: "./dist/index.d.ts",
-        default: "./dist/index.js"
-      },
-      require: {
-        types: "./dist/index.d.cts",
-        default: "./dist/index.cjs"
-      }
-    },
-    "./read": {
-      import: {
-        types: "./dist/read.d.ts",
-        default: "./dist/read.js"
-      },
-      require: {
-        types: "./dist/read.d.cts",
-        default: "./dist/read.cjs"
-      }
-    }
-  },
-  files: [
-    "dist"
-  ],
-  scripts: {
-    clean: `node -e "require('node:fs').rmSync('dist',{recursive:true,force:true})"`,
-    build: "pnpm run clean && node scripts/build-registry.mjs && tsup",
-    dev: "pnpm run clean && node scripts/build-registry.mjs && tsup --watch",
-    test: "vitest run",
-    typecheck: "tsc --noEmit",
-    lint: "eslint src scripts"
-  },
-  devDependencies: {
-    tsup: "^8.3.0",
-    typescript: "^5.6.3",
-    vitest: "^2.1.3"
-  },
-  license: "MIT",
-  publishConfig: {
-    access: "public"
-  }
-};
-
 // src/contract.ts
 import { existsSync, readFileSync } from "fs";
 import { dirname, join } from "path";
@@ -115,6 +46,197 @@ var CliError = class extends Error {
   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) {
@@ -170,9 +292,10 @@ var AGENT_COMMANDS = {
       "--json": "flag"
     });
     if (positional.length === 0) throw new CliError("Usage: oprt search <need> [--limit <n>]", 2);
-    const limit = value("--limit") === void 0 ? 10 : Number(value("--limit"));
-    if (!Number.isInteger(limit) || limit < 1)
-      throw new CliError("--limit takes a whole number above zero.", 2);
+    const given = value("--limit");
+    const limit = given === void 0 ? SEARCH_LIMIT_DEFAULT : Number(given);
+    if (!Number.isInteger(limit) || limit < 1 || limit > SEARCH_LIMIT_MAX)
+      throw new CliError(`--limit takes a whole number from 1 to ${SEARCH_LIMIT_MAX}.`, 2);
     return { command: "search", query: positional.join(" "), limit, json: has("--json") };
   },
   init(rest) {
@@ -235,7 +358,8 @@ function parseArgs(args) {
     names: [],
     out: DEFAULT_OUT,
     dryRun: false,
-    overwrite: false
+    overwrite: false,
+    json: false
   };
   const seen = /* @__PURE__ */ new Set();
   for (let i = 0; i < rest.length; i++) {
@@ -244,7 +368,7 @@ function parseArgs(args) {
       parsed.names.push(token);
       continue;
     }
-    if (!["--out", "--dry-run", "--overwrite"].includes(token))
+    if (!["--out", "--dry-run", "--overwrite", "--json"].includes(token))
       throw new CliError(`Unknown option ${JSON.stringify(token)}. Run oprt --help.`, 2);
     if (seen.has(token)) throw new CliError(`Duplicate option ${token}.`, 2);
     seen.add(token);
@@ -254,6 +378,7 @@ function parseArgs(args) {
         throw new CliError("--out requires a relative directory.", 2);
       parsed.out = value;
     } else if (token === "--dry-run") parsed.dryRun = true;
+    else if (token === "--json") parsed.json = true;
     else parsed.overwrite = true;
   }
   if (!parsed.names.length)
@@ -262,10 +387,10 @@ function parseArgs(args) {
 }
 
 // src/installer.ts
-function resolveEntries(names, registry2) {
-  if (!names.length) throw new CliError("add requires one or more names.", 2);
+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 names) {
+  for (const name of names2) {
     const normalized = name.toLowerCase();
     const entry = registry2.entries.find(
       (candidate) => candidate.slug === normalized || candidate.name.toLowerCase() === normalized
@@ -373,202 +498,362 @@ function installSources(options, context) {
   return result;
 }
 
-// src/check.ts
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3, statSync } from "fs";
-import { createRequire } from "module";
-import { basename, extname, join as join2, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+// src/identity.ts
+import { createHash } from "crypto";
 
-// src/lookup.ts
-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;
+// package.json
+var package_default = {
+  name: "@oprt/cli",
+  version: "0.4.0",
+  description: "The OPERATOR command line: copy components and recipes into your app as source, give coding agents the contract, and check their code against it. Includes an MCP server.",
+  keywords: [
+    "design-system",
+    "cli",
+    "coding-agents",
+    "mcp",
+    "model-context-protocol",
+    "code-check",
+    "components"
+  ],
+  homepage: "https://oprt.dev/docs/agents/cli",
+  type: "module",
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  bin: {
+    oprt: "./dist/bin.js"
+  },
+  engines: {
+    node: ">=22"
+  },
+  exports: {
+    ".": {
+      import: {
+        types: "./dist/index.d.ts",
+        default: "./dist/index.js"
+      },
+      require: {
+        types: "./dist/index.d.cts",
+        default: "./dist/index.cjs"
+      }
+    },
+    "./read": {
+      import: {
+        types: "./dist/read.d.ts",
+        default: "./dist/read.js"
+      },
+      require: {
+        types: "./dist/read.d.cts",
+        default: "./dist/read.cjs"
+      }
     }
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    clean: `node -e "require('node:fs').rmSync('dist',{recursive:true,force:true})"`,
+    build: "pnpm run clean && node scripts/build-registry.mjs && tsup",
+    dev: "pnpm run clean && node scripts/build-registry.mjs && tsup --watch",
+    test: "vitest run",
+    typecheck: "tsc --noEmit",
+    lint: "eslint src scripts"
+  },
+  devDependencies: {
+    "@babel/parser": "8.0.8",
+    "@babel/types": "8.0.8",
+    "@modelcontextprotocol/sdk": "1.32.1",
+    tsup: "^8.3.0",
+    typescript: "^5.6.3",
+    vitest: "^2.1.3"
+  },
+  license: "MIT",
+  publishConfig: {
+    access: "public"
   }
-  return row[b.length];
-}
-function nearest(wanted, names, limit = 5) {
-  const target = squash(wanted);
-  return names.map((name) => {
-    const candidate = squash(name);
-    const apart = distance(target, candidate);
-    const close = apart <= 2 || target.length >= 3 && (candidate.includes(target) || target.includes(candidate));
-    return { name, apart, close };
-  }).filter(({ close }) => close).sort((a, b) => a.apart - b.apart || a.name.localeCompare(b.name)).slice(0, limit).map(({ name }) => name);
-}
-function resolveComponent(contract2, wanted) {
-  const names = Object.keys(contract2.components);
-  const found = names.find((name) => name === wanted) ?? names.find((name) => squash(name) === squash(wanted));
-  if (found !== void 0) return found;
-  const suggestions = nearest(wanted, names);
-  throw new CliError(
-    `Unknown component ${JSON.stringify(wanted)}.` + (suggestions.length > 0 ? ` Did you mean ${suggestions.join(", ")}?` : "") + " Run oprt component --list.",
-    2,
-    { code: "ERR_UNKNOWN_COMPONENT", suggestions }
-  );
-}
-function allowedChildren(rules, name) {
-  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;
+};
+
+// src/identity.ts
+var VERSION = package_default.version;
+var RESULT_SCHEMA_VERSION = 2;
+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 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)
-  }));
+  return digest;
 }
-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);
+function identityOf(contract2) {
   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
+    cli_version: VERSION,
+    contract_version: contract2.version,
+    contract_digest: contractDigest(contract2),
+    schema_version: RESULT_SCHEMA_VERSION
   };
 }
-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}` : ""}`
+
+// src/check.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3, statSync } from "fs";
+import { basename, extname, join as join2, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
+
+// src/parser.ts
+import { createRequire } from "module";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// ../../node_modules/.pnpm/@babel+parser@8.0.8/node_modules/@babel/parser/package.json
+var version = "8.0.8";
+
+// src/parser.ts
+var PARSER = {
+  name: "@babel/parser",
+  version,
+  source: "bundled"
+};
+function optionsFor(file) {
+  const typed = /\.tsx$/.test(file);
+  const plugins = [
+    "jsx",
+    ...typed ? ["typescript"] : [],
+    "decorators",
+    "decoratorAutoAccessors",
+    "deferredImportEvaluation",
+    "sourcePhaseImports"
   ];
-  for (const [value, note] of Object.entries(prop.notes ?? {})) lines.push(`    ${value}: ${note}`);
-  return lines;
+  return {
+    sourceType: "module",
+    plugins,
+    // Recoverable errors are returned beside the tree, instead of the first one being thrown.
+    errorRecovery: true,
+    attachComment: false,
+    allowReturnOutsideFunction: true,
+    allowUndeclaredExports: true,
+    allowSuperOutsideMethod: true,
+    allowNewTargetOutsideFunction: true
+  };
 }
-function 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("; ")}`
+var FILE = "babel-parser.cjs";
+var REINSTALL = "Install @oprt/cli again: the parser ships beside the executable in dist.";
+var loaded;
+function loadBabel() {
+  if (loaded !== void 0) return loaded;
+  const fromSource = /\.[cm]?tsx?$/.test(fileURLToPath2(import.meta.url));
+  try {
+    const require2 = createRequire(import.meta.url);
+    loaded = fromSource ? require2("@babel/parser") : require2("./babel-parser.cjs");
+  } catch (error) {
+    throw new CliError(
+      `Code checking cannot load its parser (${FILE}): ${error instanceof Error ? error.message : String(error)} ${REINSTALL}`,
+      1,
+      { code: "ERR_PARSER_MISSING" }
     );
-  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")}
-`;
+  return loaded;
 }
-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;
+var rejects = (babel, code) => {
+  try {
+    return babel.parse(code, optionsFor("probe.tsx")).errors.length > 0;
+  } catch {
+    return true;
+  }
 };
-function search(contract2, registry2, query, limit = 10) {
-  const wanted = words(query);
-  if (wanted.length === 0) return [];
-  const whole = squash(query);
-  const scores = /* @__PURE__ */ new Map();
-  const add = (name, points, why) => {
-    const before = scores.get(name) ?? { score: 0 };
-    scores.set(name, {
-      score: before.score + points,
-      ...before.why !== void 0 ? { why: before.why } : why !== void 0 ? { why } : {}
-    });
-  };
-  for (const [name, component] of Object.entries(contract2.components)) {
-    const guide = contract2.guidance.components[name] ?? {};
-    const plain = squash(name);
-    if (plain === whole) add(name, 100);
-    else if (wanted.some((word) => word.length >= 3 && plain.includes(word))) add(name, 15);
-    else if (wanted.some((word) => word.length >= 4 && distance(word, plain) <= 1)) add(name, 12);
-    for (const phrase of guide.use_for ?? []) {
-      const hits = matched(wanted, phrase);
-      if (hits > 0) add(name, 12 * hits + (hits === wanted.length ? 40 : 0));
-    }
-    for (const { need, use } of guide.not_for ?? []) {
-      const hits = matched(wanted, need);
-      if (hits > 0 && hits >= Math.ceil(wanted.length * 0.6))
-        add(use, 10 * hits + (hits === wanted.length ? 15 : 0), `${name} is not for this: ${need}`);
-    }
-    const inDescription = matched(wanted, component.description);
-    if (inDescription > 0) add(name, 2 * inDescription);
+function probeParser(load = loadBabel) {
+  let babel;
+  try {
+    babel = load();
+  } catch (error) {
+    return {
+      ready: false,
+      reason: "parser_missing",
+      detail: error instanceof Error ? error.message : String(error)
+    };
   }
-  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}`
+  if (rejects(babel, "export const a = <a b={1 as number} />;"))
+    return {
+      ready: false,
+      reason: "parser_unusable",
+      detail: "it rejected valid code in a probe parse"
+    };
+  if (!rejects(babel, "export const a = <a>;"))
+    return {
+      ready: false,
+      reason: "parser_unusable",
+      detail: "it did not report a syntax error in code that has one"
+    };
+  return { ready: true, parser: PARSER };
+}
+
+// src/syntax.ts
+var attempt = (babel, text2, file) => {
+  try {
+    const tree = babel.parse(text2, optionsFor(file));
+    return { tree, errors: tree.errors };
+  } catch (error) {
+    return { tree: null, fatal: error };
+  }
+};
+var sentence = (message) => message.replace(/\s*\(\d+:\d+\)$/, "");
+var problemOf = (failure2) => ({
+  line: failure2.loc.line,
+  column: failure2.loc.column + 1,
+  message: sentence(failure2.message),
+  code: failure2.reasonCode ?? "SyntaxError",
+  position: failure2.pos
+});
+var tagName = (name) => {
+  if (name === void 0) return "";
+  if (name.type === "JSXIdentifier") return name.name;
+  if (name.type === "JSXMemberExpression")
+    return `${tagName(name.object)}.${name.property.name}`;
+  return `${name.namespace.name}:${name.name.name}`;
+};
+var NOT_NODES = /* @__PURE__ */ new Set(["loc", "extra", "errors", "tokens", "comments"]);
+function* childNodes(node) {
+  for (const [key, value] of Object.entries(node)) {
+    if (NOT_NODES.has(key) || typeof value !== "object" || value === null) continue;
+    if (Array.isArray(value)) {
+      for (const item of value)
+        if (typeof item === "object" && item !== null && typeof item.type === "string")
+          yield item;
+    } else if (typeof value.type === "string") yield value;
+  }
+}
+var walk = (node, ancestors, visit) => {
+  visit(node, ancestors);
+  ancestors.push(node);
+  for (const child of childNodes(node)) walk(child, ancestors, visit);
+  ancestors.pop();
+};
+var unclosed = (element) => {
+  const name = element.openingElement.name;
+  return {
+    line: name.loc?.start.line ?? 1,
+    column: (name.loc?.start.column ?? 0) + 1,
+    message: `JSX element '${tagName(name)}' has no corresponding closing tag.`,
+    code: "UnclosedJsxElement",
+    position: name.start ?? 0
+  };
+};
+function problemsOf(tree, errors, limit, consumed) {
+  const mismatched = /* @__PURE__ */ new Map();
+  walk(tree.program, [], (node, ancestors) => {
+    if (node.type === "JSXElement" && node.closingElement && (node.closingElement.start ?? 0) < limit && tagName(node.openingElement.name) !== tagName(node.closingElement.name))
+      mismatched.set(node.closingElement.start ?? 0, { element: node, ancestors: [...ancestors] });
+  });
+  const problems = [];
+  for (const error of errors) {
+    if (error.pos >= limit) continue;
+    const entry = error.reasonCode === "MissingClosingTagElement" && mismatched.get(error.pos);
+    if (entry) {
+      const closing = tagName(entry.element.closingElement?.name);
+      const outer = [...entry.ancestors].reverse().find(
+        (ancestor) => ancestor.type === "JSXElement" && tagName(ancestor.openingElement.name) === closing && !consumed.has(ancestor)
+      );
+      if (outer !== void 0) {
+        consumed.add(outer);
+        problems.push(unclosed(entry.element));
+        continue;
+      }
+    }
+    problems.push(problemOf(error));
+  }
+  return problems;
+}
+var TYPE_ARGUMENTS = /(?<=[\w$\])])<(?:[^<>()]|<(?:[^<>()]|<[^<>()]*>)*>)*>(?=\()/g;
+var LINE_BREAKS = new RegExp(`[^\\r\\n${String.fromCharCode(8232, 8233)}]`, "g");
+var blankedOut = (match) => match.replace(LINE_BREAKS, " ");
+var CLOSING_TAG = "</_>";
+var COMPLETIONS = [CLOSING_TAG, ")", "}", "]"];
+var MAX_COMPLETIONS = 24;
+function complete(babel, prefix, file) {
+  let text2 = prefix;
+  let first = null;
+  for (let step = 0; step <= MAX_COMPLETIONS; step++) {
+    const tried = attempt(babel, text2, file);
+    if (tried.tree !== null) return { tree: tried.tree, errors: tried.errors, first };
+    const wantsMore = tried.fatal.reasonCode === "UnterminatedJsxContent" || tried.fatal.pos >= text2.length;
+    if (!wantsMore) return null;
+    const next = COMPLETIONS.find((piece) => {
+      const extended = attempt(babel, text2 + piece, file);
+      return extended.tree !== null || extended.fatal.reasonCode === "UnterminatedJsxContent" || extended.fatal.pos >= text2.length + piece.length;
     });
+    if (next === void 0) return null;
+    first ??= next;
+    text2 += next;
   }
-  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}`
-      });
+  return null;
+}
+function shutByCompletion(tree, limit) {
+  const shut = [];
+  walk(tree.program, [], (node) => {
+    if (node.type === "JSXElement" && node.closingElement && (node.closingElement.start ?? 0) >= limit)
+      shut.push(node);
+  });
+  return shut.sort((a, b) => (a.closingElement?.start ?? 0) - (b.closingElement?.start ?? 0));
+}
+var byPlace = (a, b) => a.position - b.position;
+var MAX_EXPLAINED = 2e5;
+function readSyntax(file, text2, babel = loadBabel()) {
+  const first = attempt(babel, text2, file);
+  if (first.tree !== null) {
+    const problems = problemsOf(first.tree, first.errors, Infinity, /* @__PURE__ */ new Set());
+    return problems.length === 0 ? { tree: first.tree, problems: [] } : { tree: null, problems: problems.sort(byPlace) };
   }
-  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);
+  let fatal = first.fatal;
+  if (text2.length > MAX_EXPLAINED) return { tree: null, problems: [problemOf(fatal)] };
+  if (/\.tsx$/.test(file) && fatal.reasonCode !== "UnterminatedJsxContent") {
+    const plain = text2.replace(TYPE_ARGUMENTS, blankedOut);
+    if (plain !== text2) {
+      const again = attempt(babel, plain, file);
+      if (again.tree === null && again.fatal.pos > fatal.pos) fatal = again.fatal;
+    }
+  }
+  try {
+    const finished = complete(babel, text2.slice(0, fatal.pos), file);
+    if (finished !== null) {
+      const limit = fatal.pos;
+      const consumed = /* @__PURE__ */ new Set();
+      const problems = problemsOf(finished.tree, finished.errors, limit, consumed);
+      const open = shutByCompletion(finished.tree, limit).filter(
+        (element) => !consumed.has(element)
+      );
+      const atEnd = fatal.reasonCode === "UnterminatedJsxContent" || fatal.pos >= text2.length;
+      const hints = (atEnd ? open : finished.first === CLOSING_TAG ? open.slice(0, 1) : []).map(
+        unclosed
+      );
+      const explained = [...problems, ...hints].some(({ code }) => code === "UnclosedJsxElement");
+      problems.push(...hints);
+      if (!(explained && fatal.reasonCode === "UnterminatedJsxContent"))
+        problems.push(problemOf(fatal));
+      return { tree: null, problems: problems.sort(byPlace) };
+    }
+  } catch {
+  }
+  return { tree: null, problems: [problemOf(fatal)] };
 }
 
 // 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",
@@ -604,19 +889,48 @@ function allowedChildren2(rules, name) {
   }
   return void 0;
 }
-function checkSource(typescript, contract2, file, text2) {
-  const ts = typescript;
-  const kind = /\.tsx$/.test(file) ? ts.ScriptKind.TSX : ts.ScriptKind.JSX;
-  const source = ts.createSourceFile(file, text2, ts.ScriptTarget.Latest, true, kind);
+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(contract2, file, text2) {
+  const reading = readSyntax(file, text2);
+  if (reading.tree === null) {
+    const shown = reading.problems.slice(0, MAX_SYNTAX_ERRORS);
+    const more = reading.problems.length - shown.length;
+    return {
+      file,
+      status: "not_evaluated",
+      limitations: [],
+      findings: shown.map(
+        ({ line, column, message, code }, index) => ({
+          code: "SYNTAX_ERROR",
+          severity: "error",
+          file,
+          line,
+          column,
+          message: `${message} (${code})` + (index === shown.length - 1 && more > 0 ? ` ${more} more syntax error${more === 1 ? "" : "s"} in this file not shown.` : "")
+        })
+      )
+    };
+  }
   const findings = [];
+  const limitations = [];
+  const place = (node) => ({
+    line: node.loc?.start.line ?? 1,
+    column: (node.loc?.start.column ?? 0) + 1
+  });
+  const textOf = (node) => text2.slice(node.start ?? 0, node.end ?? 0);
+  const limit = (node, limitation) => {
+    limitations.push({ ...limitation, file, ...place(node) });
+  };
   const report = (node, finding) => {
-    const { line, character } = source.getLineAndCharacterOfPosition(node.getStart(source));
     findings.push({
       code: finding.code,
       severity: finding.severity,
       file,
-      line: line + 1,
-      column: character + 1,
+      ...place(node),
       ...finding.component === void 0 ? {} : { component: finding.component },
       ...finding.prop === void 0 ? {} : { prop: finding.prop },
       message: finding.message,
@@ -627,21 +941,18 @@ function checkSource(typescript, contract2, file, text2) {
   const isComponent = (name) => Object.hasOwn(contract2.components, name);
   const named = /* @__PURE__ */ new Map();
   const namespaces = /* @__PURE__ */ new Set();
-  for (const statement of source.statements) {
-    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
-      continue;
-    const from = statement.moduleSpecifier.text;
-    const clause = statement.importClause;
-    if (!clause || clause.isTypeOnly || !clause.namedBindings) continue;
+  for (const statement of reading.tree.program.body) {
+    if (statement.type !== "ImportDeclaration" || statement.importKind === "type") continue;
+    const from = statement.source.value;
     const copied = from !== PACKAGE && /[./@]/.test(from[0] ?? "") && isComponent(basename(from));
     if (from !== PACKAGE && !copied) continue;
-    if (ts.isNamespaceImport(clause.namedBindings)) {
-      if (from === PACKAGE) namespaces.add(clause.namedBindings.name.text);
-      continue;
-    }
-    for (const element2 of clause.namedBindings.elements) {
-      if (element2.isTypeOnly) continue;
-      const exported = (element2.propertyName ?? element2.name).text;
+    for (const element2 of statement.specifiers) {
+      if (element2.type === "ImportNamespaceSpecifier") {
+        if (from === PACKAGE) namespaces.add(element2.local.name);
+        continue;
+      }
+      if (element2.type !== "ImportSpecifier" || element2.importKind === "type") continue;
+      const exported = element2.imported.type === "Identifier" ? element2.imported.name : element2.imported.value;
       if (from === PACKAGE && !contract2.exports.includes(exported)) {
         let suggestions = nearest(exported, Object.keys(contract2.components));
         if (suggestions.length === 0) suggestions = nearest(exported, contract2.exports);
@@ -666,26 +977,55 @@ function checkSource(typescript, contract2, file, text2) {
         });
         continue;
       }
-      if (isComponent(exported)) named.set(element2.name.text, exported);
+      if (isComponent(exported)) named.set(element2.local.name, exported);
     }
   }
+  const isString = (node) => node.type === "StringLiteral";
+  const plainTemplate = (node) => node.type === "TemplateLiteral" && node.expressions.length === 0 ? node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw : void 0;
   const literals = (expression) => {
     if (!expression) return [];
-    if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression))
-      return [expression.text];
-    if (ts.isParenthesizedExpression(expression)) return literals(expression.expression);
-    if (ts.isConditionalExpression(expression))
-      return [...literals(expression.whenTrue), ...literals(expression.whenFalse)];
+    if (isString(expression)) return [expression.value];
+    const template = plainTemplate(expression);
+    if (template !== void 0) return [template];
+    if (expression.type === "ConditionalExpression")
+      return [...literals(expression.consequent), ...literals(expression.alternate)];
     return [];
   };
-  const valueOf = (attribute) => attribute.initializer === void 0 ? void 0 : ts.isJsxExpression(attribute.initializer) ? attribute.initializer.expression : attribute.initializer;
+  const valueOf = (attribute) => {
+    const value = attribute.value;
+    if (value === null || value === void 0) return void 0;
+    if (value.type === "JSXExpressionContainer")
+      return value.expression.type === "JSXEmptyExpression" ? void 0 : value.expression;
+    return value;
+  };
+  const optionValue = (expression) => {
+    const read = [];
+    const unread = [];
+    const walk2 = (node) => {
+      const template = plainTemplate(node);
+      if (isString(node)) read.push(node.value);
+      else if (template !== void 0) read.push(template);
+      else if (node.type === "TSAsExpression" || node.type === "TSNonNullExpression" || node.type === "TSTypeAssertion" || node.type === "TSSatisfiesExpression")
+        walk2(node.expression);
+      else if (node.type === "ConditionalExpression") {
+        walk2(node.consequent);
+        walk2(node.alternate);
+      } else if (node.type === "LogicalExpression") {
+        if (node.operator === "??" || node.operator === "||") {
+          walk2(node.left);
+          walk2(node.right);
+        } else walk2(node.right);
+      } else if (!// No value: the component's default applies.
+      (node.type === "Identifier" && node.name === "undefined" || node.type === "NullLiteral"))
+        unread.push(node);
+    };
+    if (expression) walk2(expression);
+    return { literals: read, unread };
+  };
   const classText = (expression) => {
     if (!expression) return "";
-    if (ts.isTemplateExpression(expression))
-      return [
-        expression.head.text,
-        ...expression.templateSpans.map((span) => span.literal.text)
-      ].join(" ");
+    if (expression.type === "TemplateLiteral" && expression.expressions.length > 0)
+      return expression.quasis.map((span) => span.value.cooked ?? span.value.raw).join(" ");
     return literals(expression).join(" ");
   };
   const houseRules = (attribute, name) => {
@@ -711,9 +1051,9 @@ function checkSource(typescript, contract2, file, text2) {
           message: "A rounded corner. The radius is 0 everywhere in OPERATOR."
         });
     }
-    if (name === "style" && value && ts.isObjectLiteralExpression(value)) {
+    if (name === "style" && value && value.type === "ObjectExpression") {
       for (const property of value.properties)
-        if (ts.isPropertyAssignment(property) && literals(property.initializer).some((literal) => RAW_COLOR_VALUE.test(literal)))
+        if (property.type === "ObjectProperty" && literals(property.value).some((literal) => RAW_COLOR_VALUE.test(literal)))
           report(attribute, {
             code: "RAW_COLOR",
             severity: "warning",
@@ -721,56 +1061,73 @@ function checkSource(typescript, contract2, file, text2) {
           });
     }
   };
+  const attributeName = (attribute) => attribute.name.type === "JSXIdentifier" ? attribute.name.name : textOf(attribute.name);
   const element = (opening, ancestors, parent, hasChildren, renderedAs) => {
-    const tag = opening.tagName;
+    const tag = opening.name;
     let component = null;
-    if (ts.isIdentifier(tag)) {
-      component = named.get(tag.text) ?? null;
-      if (component === null && !renderedAs && Object.hasOwn(NATIVE, tag.text))
+    if (tag.type === "JSXIdentifier") {
+      component = named.get(tag.name) ?? null;
+      if (component === null && !renderedAs && Object.hasOwn(NATIVE, tag.name))
         report(opening, {
           code: "NATIVE_CONTROL",
           severity: "warning",
-          message: `A native <${tag.text}>: use ${NATIVE[tag.text]}.`
+          message: `A native <${tag.name}>: use ${NATIVE[tag.name]}.`
         });
-    } else if (ts.isPropertyAccessExpression(tag) && ts.isIdentifier(tag.expression)) {
-      const owner = tag.expression.text;
-      if (namespaces.has(owner) && isComponent(tag.name.text)) component = tag.name.text;
+    } else if (tag.type === "JSXMemberExpression" && tag.object.type === "JSXIdentifier") {
+      const owner = tag.object.name;
+      const member = tag.property.name;
+      if (namespaces.has(owner) && isComponent(member)) component = member;
       else if (named.has(owner)) {
-        const joined = `${named.get(owner)}${tag.name.text}`;
+        const joined = `${named.get(owner)}${member}`;
         report(opening, {
           code: "DOT_NOTATION",
           severity: "error",
-          message: `${owner}.${tag.name.text} is not a component.` + (isComponent(joined) ? ` Use <${joined}>.` : " OPERATOR's parts are components of their own, imported by name.")
+          message: `${owner}.${member} is not a component.` + (isComponent(joined) ? ` Use <${joined}>.` : " OPERATOR's parts are components of their own, imported by name.")
         });
       }
     }
-    const attributes = opening.attributes.properties;
+    const attributes = opening.attributes;
     for (const attribute of attributes)
-      if (ts.isJsxAttribute(attribute) && ts.isIdentifier(attribute.name))
-        houseRules(attribute, attribute.name.text);
+      if (attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier")
+        houseRules(attribute, attribute.name.name);
     if (component === null) return null;
     const definition = contract2.components[component];
-    const spread = attributes.some((attribute) => ts.isJsxSpreadAttribute(attribute));
+    const spread = attributes.some((attribute) => attribute.type === "JSXSpreadAttribute");
+    for (const attribute of attributes)
+      if (attribute.type === "JSXSpreadAttribute")
+        limit(attribute, {
+          code: "UNRESOLVED_SPREAD",
+          component,
+          message: `Props spread into <${component}> (${quote(textOf(attribute))}) were not read: option values and required props that arrive through them were not checked.`
+        });
     const given = /* @__PURE__ */ new Set();
     for (const attribute of attributes) {
-      if (!ts.isJsxAttribute(attribute)) continue;
-      const prop = ts.isIdentifier(attribute.name) ? attribute.name.text : attribute.name.getText(source);
+      if (attribute.type !== "JSXAttribute") continue;
+      const prop = attributeName(attribute);
       given.add(prop);
       const known = Object.hasOwn(definition.props, prop) ? definition.props[prop] : void 0;
       if (known === void 0) {
         if (nativeAttribute(prop) || Object.hasOwn(definition.slots ?? {}, prop)) continue;
-        const names = Object.keys(definition.props);
+        const names2 = Object.keys(definition.props);
         report(attribute, {
           code: "UNKNOWN_PROP",
           severity: "warning",
           component,
           prop,
-          message: `${component} has no prop ${prop}.` + (names.length === 0 ? " It takes no props of its own." : ` Its props: ${names.slice(0, 14).join(", ")}${names.length > 14 ? ", \u2026" : ""}.`)
+          message: `${component} has no prop ${prop}.` + (names2.length === 0 ? " It takes no props of its own." : ` Its props: ${names2.slice(0, 14).join(", ")}${names2.length > 14 ? ", \u2026" : ""}.`)
         });
         continue;
       }
       if (known.type !== "enum" || known.values === void 0) continue;
-      for (const literal of literals(valueOf(attribute))) {
+      const { literals: options, unread } = optionValue(valueOf(attribute));
+      for (const expression of unread)
+        limit(attribute, {
+          code: "UNRESOLVED_VALUE",
+          component,
+          prop,
+          message: `${component} ${prop} is set from an expression (${quote(textOf(expression))}) whose value is not in the source, so it was not compared with the options.`
+        });
+      for (const literal of options) {
         if (known.values.includes(literal)) continue;
         const elsewhere = Object.entries(contract2.components).filter(([, other]) => other.props[prop]?.values?.includes(literal)).map(([name]) => name);
         report(attribute, {
@@ -817,82 +1174,146 @@ function checkSource(typescript, contract2, file, text2) {
     return component;
   };
   const visit = (node, ancestors, parent, renderedAs = false) => {
-    if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) {
-      const opening = ts.isJsxElement(node) ? node.openingElement : node;
-      const hasChildren = ts.isJsxElement(node) && node.children.some(
-        (child) => !(ts.isJsxText(child) && child.containsOnlyTriviaWhiteSpaces)
+    if (node.type === "JSXElement") {
+      const opening = node.openingElement;
+      const hasChildren = node.children.some(
+        (child) => !(child.type === "JSXText" && /^\s*$/.test(text2.slice(child.start ?? 0, child.end ?? 0)))
       );
       const component = element(opening, ancestors, parent, hasChildren, renderedAs);
-      const asChild = component !== null && opening.attributes.properties.some(
-        (attribute) => ts.isJsxAttribute(attribute) && attribute.name.getText(source) === "asChild"
+      const asChild = component !== null && opening.attributes.some(
+        (attribute) => attribute.type === "JSXAttribute" && attributeName(attribute) === "asChild"
       );
-      for (const attribute of opening.attributes.properties) visit(attribute, [], null);
-      if (ts.isJsxElement(node))
-        for (const child of node.children)
-          visit(
-            child,
-            component === null ? ancestors : [...ancestors, component],
-            component,
-            asChild
-          );
+      for (const attribute of opening.attributes) visit(attribute, [], null);
+      for (const child of node.children)
+        visit(
+          child,
+          component === null ? ancestors : [...ancestors, component],
+          component,
+          asChild
+        );
       return;
     }
-    ts.forEachChild(node, (child) => visit(child, ancestors, parent));
+    for (const child of childNodes(node)) visit(child, ancestors, parent);
+  };
+  visit(reading.tree.program, [], null);
+  const byPlace2 = (a, b) => a.line - b.line || a.column - b.column;
+  return {
+    file,
+    status: limitations.length > 0 ? "partial" : "evaluated",
+    findings: findings.sort(byPlace2),
+    limitations: limitations.sort(byPlace2)
   };
-  visit(source, [], null);
-  return findings.sort((a, b) => a.line - b.line || a.column - b.column);
 }
 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) {
-  const name = basename(path);
-  if (SKIPPED.has(name) || name.startsWith(".") && name !== "." && name !== "..") return;
+  if (excluded(basename(path))) return;
   if (statSync(path).isDirectory()) {
     for (const entry of readdirSync(path).sort()) yield* sources(join2(path, entry));
-  } else if (READ.has(extname(path)) && !NOT_INTERFACE.test(name)) yield path;
+  } else if (READ.has(extname(path)) && !NOT_INTERFACE.test(basename(path))) yield path;
 }
-function findTypeScript(cwd) {
-  for (const from of [join2(cwd, "package.json"), fileURLToPath2(import.meta.url)]) {
-    try {
-      return createRequire(from)("typescript");
-    } catch {
-    }
-  }
-  return null;
+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 ?? PARSER
+  };
+}
+function checkExitCode(report, { strict }) {
+  if (report.evaluation_status === "no_files_evaluated") return 1;
+  if (report.summary.errors > 0 || report.coverage.files_not_evaluated > 0) return 1;
+  return strict && report.summary.warnings > 0 ? 1 : 0;
 }
 function checkPaths(paths, context) {
   const root = 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 ts = context.typescript === void 0 ? findTypeScript(root) : context.typescript;
-  if (ts === null)
-    throw new CliError(
-      "oprt check reads code with the project's TypeScript, and found none. Install typescript in this project (npm install -D typescript) and run it again.",
-      1,
-      { code: "ERR_TYPESCRIPT_MISSING" }
-    );
-  const findings = [...new Set(files)].flatMap(
+  loadBabel();
+  const evaluations = [...new Set(files)].map(
     (file) => checkSource(
-      ts,
       context.contract,
       relative2(root, file).split(sep2).join("/"),
       readFileSync3(file, "utf8")
     )
   );
-  return {
-    files: new Set(files).size,
-    findings,
-    summary: {
-      errors: findings.filter(({ severity }) => severity === "error").length,
-      warnings: findings.filter(({ severity }) => severity === "warning").length
-    }
-  };
+  return buildCheckReport(evaluations, { 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
@@ -979,7 +1400,7 @@ var INSTRUCTION_FILES = [
   ".claude/CLAUDE.md",
   ".cursor/rules/operator.mdc"
 ];
-var minor = (version) => version.split(".").slice(0, 2).join(".");
+var minor = (version2) => version2.split(".").slice(0, 2).join(".");
 function installedVersion(cwd, name) {
   for (let folder = cwd; ; folder = dirname3(folder)) {
     const manifest = join3(folder, "node_modules", name, "package.json");
@@ -988,26 +1409,30 @@ function installedVersion(cwd, name) {
     if (dirname3(folder) === folder) return void 0;
   }
 }
-function doctor({ cwd, contract: contract2 }) {
+function doctor({
+  cwd,
+  contract: contract2,
+  parser = probeParser()
+}) {
   const checks = [];
   for (const name of PACKAGES) {
-    const version = installedVersion(cwd, name);
+    const version2 = installedVersion(cwd, name);
     const id = `package:${name}`;
-    if (version === void 0)
+    if (version2 === void 0)
       checks.push({
         id,
         status: "warn",
         message: `${name} is not installed.`,
         fix: `Install ${name}, or copy the sources you need with oprt add.`
       });
-    else if (minor(version) !== minor(contract2.version))
+    else if (minor(version2) !== minor(contract2.version))
       checks.push({
         id,
         status: "warn",
-        message: `${name} is ${version}; this installer describes ${contract2.version}.`,
+        message: `${name} is ${version2}; this installer describes ${contract2.version}.`,
         fix: "Install matching versions of the OPERATOR packages and @oprt/cli."
       });
-    else checks.push({ id, status: "ok", message: `${name} ${version} is installed.` });
+    else checks.push({ id, status: "ok", message: `${name} ${version2} is installed.` });
   }
   const written = INSTRUCTION_FILES.map((path) => {
     const file = join3(cwd, path);
@@ -1015,8 +1440,8 @@ function doctor({ cwd, contract: contract2 }) {
       path,
       version: existsSync3(file) ? blockVersion(readFileSync4(file, "utf8")) : void 0
     };
-  }).filter(({ version }) => version !== void 0);
-  const stale = written.find(({ version }) => version !== contract2.version);
+  }).filter(({ version: version2 }) => version2 !== void 0);
+  const stale = written.find(({ version: version2 }) => version2 !== contract2.version);
   if (written.length === 0)
     checks.push({
       id: "agent-instructions",
@@ -1037,8 +1462,48 @@ function doctor({ cwd, contract: contract2 }) {
       status: "ok",
       message: `${written.map(({ path }) => path).join(", ")} carries the OPERATOR block (${contract2.version}).`
     });
+  let checkCode;
+  if (parser.ready) {
+    const { name, version: version2 } = parser.parser;
+    checkCode = {
+      status: "ready",
+      message: `${name} ${version2}, bundled with oprt: nothing to install.`,
+      parser: parser.parser
+    };
+    checks.push({
+      id: "parser",
+      status: "ok",
+      message: `Code checking reads code with ${name} ${version2}, which ships inside oprt.`
+    });
+  } else {
+    const fix = "Install @oprt/cli again, then run oprt doctor again. Lookups work without it.";
+    checkCode = {
+      status: "blocked",
+      message: `${parser.reason}: ${parser.detail}`,
+      reason: parser.reason,
+      fix
+    };
+    checks.push({
+      id: "parser",
+      status: "fail",
+      message: `oprt check and the check_code tool cannot run (${parser.reason}): ${parser.detail}`,
+      fix
+    });
+  }
   const count = (status) => checks.filter((check) => check.status === status).length;
-  return { checks, summary: { ok: count("ok"), warn: count("warn"), fail: count("fail") } };
+  return {
+    consumer_directory: cwd,
+    operations: {
+      lookup: {
+        status: "ready",
+        message: `search, component and list read the contract bundled with oprt (${contract2.version}): always available.`,
+        contract_version: contract2.version
+      },
+      check_code: checkCode
+    },
+    checks,
+    summary: { ok: count("ok"), warn: count("warn"), fail: count("fail") }
+  };
 }
 
 // src/init.ts
@@ -1096,8 +1561,532 @@ function init(options, context) {
   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: RESULT_SCHEMA_VERSION,
+  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: RESULT_SCHEMA_VERSION,
+    error: error instanceof Error ? error.message : String(error),
+    code: known?.code ?? "ERR_FAILED",
+    ...known?.suggestions === void 0 ? {} : { suggestions: known.suggestions },
+    identity
+  };
+}
+function componentData(detail, dense) {
+  if (!dense) return { ...detail, dense };
+  const { description: _description, ...rest } = detail;
+  return {
+    ...rest,
+    props: detail.props.map(
+      (prop) => prop.description === void 0 ? prop : { ...prop, description: firstSentence(prop.description) }
+    ),
+    dense
+  };
+}
+function instructionsData(contract2) {
+  return {
+    rules: contract2.guidance.rules.map(({ id, rule, wrong, right }) => ({
+      id,
+      rule,
+      ...wrong === void 0 ? {} : { wrong },
+      ...right === void 0 ? {} : { right }
+    })),
+    components: componentIndex(contract2),
+    recipes: Object.entries(contract2.patterns ?? {}).map(([name, { description, install: install2 }]) => ({
+      name,
+      description,
+      install: install2
+    }))
+  };
+}
+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("@babel/parser"),
+    version: str(),
+    source: words2("bundled")
+  }),
+  check_data: obj({
+    evaluation_status: words2(
+      "evaluated_clean",
+      "evaluated_with_findings",
+      "partially_evaluated",
+      "not_evaluated",
+      "no_files_evaluated"
+    ),
+    files: int(),
+    findings: arr(ref("finding")),
+    summary: obj({ errors: int(), warnings: int() }),
+    coverage: obj({
+      files_found: int(),
+      files_evaluated: int(),
+      files_partial: int(),
+      files_not_evaluated: int()
+    }),
+    limitations: arr(ref("limitation")),
+    skipped_inputs: arr(ref("skipped_input")),
+    scope: obj({ checked: names(), not_checked: names() }),
+    parser: ref("parser")
+  }),
+  search_result: obj(
+    {
+      kind: words2("component", "recipe"),
+      name: str(),
+      purpose: str(),
+      score: { type: "number" },
+      why: str(),
+      next: str()
+    },
+    ["why"]
+  ),
+  search_data: obj({
+    query: str(),
+    limit: { type: "integer", minimum: 1 },
+    matchCount: int(),
+    results: arr(ref("search_result"))
+  }),
+  index_entry: obj({ name: str(), purpose: str(), parts: names() }),
+  component_list_data: obj({ components: arr(ref("index_entry")) }),
+  detail_prop: obj(
+    {
+      name: str(),
+      type: str(),
+      values: names(),
+      types: names(),
+      default: scalar,
+      required: bool(),
+      description: str(),
+      notes: { type: "object", additionalProperties: str() }
+    },
+    ["values", "types", "default", "required", "description", "notes"],
+    // The contract may describe a prop with more than these (an array's item type, for one).
+    true
+  ),
+  component_detail: obj(
+    {
+      name: str(),
+      description: str(),
+      use_for: names(),
+      not_for: arr(obj({ need: str(), use: str() })),
+      part_of: str(),
+      parts: names(),
+      props: arr(ref("detail_prop")),
+      slots: {
+        type: "object",
+        additionalProperties: obj({ type: str(), required: bool() }, ["required"])
+      },
+      composable_with: names(),
+      never_inside: names(),
+      allowed_children: names(),
+      example: str(),
+      dense: bool()
+    },
+    ["description", "part_of", "slots", "allowed_children"]
+  ),
+  component_batch_data: obj({ components: arr(ref("component_detail")) }),
+  doctor_check: obj(
+    { id: str(), status: words2("ok", "warn", "fail"), message: str(), fix: str() },
+    ["fix"]
+  ),
+  doctor_data: obj({
+    consumer_directory: str(),
+    operations: obj({
+      lookup: obj({ status: words2("ready"), message: str(), contract_version: str() }),
+      check_code: obj(
+        {
+          status: words2("ready", "blocked"),
+          message: str(),
+          reason: words2("parser_missing", "parser_unusable"),
+          fix: str(),
+          parser: ref("parser")
+        },
+        ["reason", "fix", "parser"]
+      )
+    }),
+    checks: arr(ref("doctor_check")),
+    summary: obj({ ok: int(), warn: int(), fail: int() })
+  }),
+  init_data: obj({
+    version: str(),
+    dryRun: bool(),
+    files: arr(
+      obj({
+        path: str(),
+        action: words2("create", "append", "update", "unchanged", "remove", "delete", "absent")
+      })
+    )
+  }),
+  install_file: obj({
+    path: str(),
+    destination: str(),
+    action: words2("create", "overwrite", "skip")
+  }),
+  add_data: obj({
+    outputDirectory: str(),
+    entries: names(),
+    dependencies: names(),
+    devDependencies: names(),
+    ranges: { type: "object", additionalProperties: str() },
+    files: arr(ref("install_file")),
+    dryRun: bool(),
+    setup: ref("setup")
+  }),
+  setup: obj({
+    tailwind: str(),
+    packages: arr(obj({ name: str(), range: str(), dev: bool(), why: str() })),
+    stylesheet: arr(obj({ line: str(), why: str() })),
+    root_import: obj({ line: str(), note: str() }),
+    not_needed: arr(obj({ name: str(), why: str() }))
+  }),
+  list_data: obj({
+    version: str(),
+    entries: arr(
+      obj(
+        {
+          name: str(),
+          slug: str(),
+          kind: words2("component", "recipe"),
+          description: str(),
+          files: names(),
+          dependencies: names(),
+          devDependencies: names()
+        },
+        ["devDependencies"]
+      )
+    ),
+    ranges: { type: "object", additionalProperties: str() }
+  }),
+  instructions_data: obj({
+    rules: arr(obj({ id: str(), rule: str(), wrong: str(), right: str() }, ["wrong", "right"])),
+    components: arr(ref("index_entry")),
+    recipes: arr(obj({ name: str(), description: str(), install: str() }))
+  })
+};
+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: RESULT_SCHEMA_VERSION },
+  type: { const: type },
+  identity: ref("identity"),
+  data: ref(DATA[type])
+});
+var failure = () => obj(
+  {
+    apiVersion: { const: RESULT_SCHEMA_VERSION },
+    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
-var envelope = (type, data) => ({ apiVersion: 1, type, data });
+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) {
@@ -1109,14 +2098,15 @@ function runAgentCommand(command, context) {
             ({ name, purpose, parts }) => `${name}${parts.length > 0 ? ` (${parts.join(", ")})` : ""}: ${purpose}
 `
           ).join(""),
-          json: envelope("component.list", { components }),
+          json: envelope("component.list", { components }, contract2),
           exitCode: 0
         };
       }
       const details = command.names.map((name) => componentDetail(contract2, name));
+      const data = details.map((detail) => componentData(detail, command.dense));
       return {
         text: details.map((detail) => renderComponent(detail, { dense: command.dense })).join("\n"),
-        json: details.length === 1 ? envelope("component.detail", details[0]) : envelope("component.batch", { components: details }),
+        json: data.length === 1 ? envelope("component.detail", data[0], contract2) : envelope("component.batch", { components: data }, contract2),
         exitCode: 0
       };
     }
@@ -1129,7 +2119,11 @@ function runAgentCommand(command, context) {
   ${next}
 `
         ).join(""),
-        json: envelope("search", { query: command.query, matchCount: results.length, results }),
+        json: envelope(
+          "search",
+          { query: command.query, limit: command.limit, matchCount: results.length, results },
+          contract2
+        ),
         exitCode: 0
       };
     }
@@ -1140,146 +2134,322 @@ function runAgentCommand(command, context) {
         ...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), exitCode: 0 };
+      return {
+        text: `${lines.join("\n")}
+`,
+        json: envelope("init", result, contract2),
+        exitCode: 0
+      };
     }
     case "check": {
       const report = checkPaths(command.paths, { cwd, contract: contract2 });
-      const { errors, warnings } = report.summary;
-      const lines = report.findings.map(
-        ({ file, line, column, severity, code, message }) => `${file}:${line}:${column}  ${severity}  ${code}  ${message}`
-      );
-      const count = (amount, word) => `${amount} ${word}${amount === 1 ? "" : "s"}`;
-      lines.push(
-        `${count(errors, "error")}, ${count(warnings, "warning")} in ${count(report.files, "file")}.`
-      );
       return {
-        text: `${lines.join("\n")}
-`,
-        json: envelope("check", report),
+        text: renderCheckText(report),
+        json: envelope("check", report, contract2),
         // Warnings fail the run only when asked to: they are house rules, or may be native attributes.
-        exitCode: errors > 0 || command.strict && warnings > 0 ? 1 : 0
+        exitCode: checkExitCode(report, { strict: command.strict })
       };
     }
     case "doctor": {
-      const report = doctor({ cwd, contract: contract2 });
-      const lines = report.checks.flatMap(({ status, message, fix }) => [
-        `[${status}] ${message}`,
-        ...fix === void 0 ? [] : [`       fix: ${fix}`]
-      ]);
+      const report = doctor({
+        cwd,
+        contract: contract2,
+        ...context.parser ? { parser: context.parser } : {}
+      });
+      const { lookup, check_code: checking } = report.operations;
+      const lines = [
+        "Readiness",
+        `  lookups        ${lookup.status.padEnd(8)} ${lookup.message}`,
+        `  code checking  ${checking.status.padEnd(8)} ${checking.message}`,
+        ...checking.fix === void 0 ? [] : [`                          fix: ${checking.fix}`],
+        "",
+        "Setup"
+      ];
+      lines.push(
+        ...report.checks.flatMap(({ status, message, fix }) => [
+          `[${status}] ${message}`,
+          ...fix === void 0 ? [] : [`       fix: ${fix}`]
+        ])
+      );
       lines.push(
         `${report.summary.ok} ok, ${report.summary.warn} to look at, ${report.summary.fail} failed.`
       );
       return {
         text: `${lines.join("\n")}
 `,
-        json: envelope("doctor", report),
+        json: envelope("doctor", report, contract2),
         exitCode: report.summary.fail > 0 ? 1 : 0
       };
     }
+    case "list": {
+      const lines = [`OPERATOR ${VERSION}`, ""];
+      for (const kind of ["component", "recipe"]) {
+        const entries = registry2.entries.filter((entry) => entry.kind === kind);
+        lines.push(`${kind === "component" ? "Components" : "Recipes"} (${entries.length})`);
+        for (const entry of entries) lines.push(`  ${entry.slug.padEnd(22)} ${entry.description}`);
+        lines.push("");
+      }
+      return {
+        text: `${lines.join("\n")}
+`,
+        json: envelope(
+          "list",
+          { version: VERSION, entries: registry2.entries, ranges: registry2.ranges ?? {} },
+          contract2
+        ),
+        exitCode: 0
+      };
+    }
+    case "add": {
+      const result = installSources(command, { cwd, registry: registry2 });
+      const setup = setupFor(result.dependencies, contract2);
+      return {
+        text: renderInstall(result, setup),
+        json: envelope("add", { ...result, setup }, contract2),
+        exitCode: 0
+      };
+    }
   }
 }
 
 // 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 string = (description) => ({ type: "string", description });
+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 that answers a need, such as 'show a status' or 'table with selection'. Call this before writing interface code.",
+    description: "Find the OPERATOR component or recipe for a need, such as 'show a status' or 'table with selection'. Call before writing interface code.",
     inputSchema: {
       type: "object",
       properties: {
-        query: string("The need, in plain words."),
-        limit: { type: "number", description: "How many results to return. Default 10." }
+        query: {
+          type: "string",
+          minLength: 1,
+          maxLength: LIMITS.query,
+          description: "The need, in plain words."
+        },
+        limit: {
+          type: "integer",
+          minimum: 1,
+          maximum: SEARCH_LIMIT_MAX,
+          default: SEARCH_LIMIT_DEFAULT,
+          description: `Results to return, 1 to ${SEARCH_LIMIT_MAX}.`
+        }
       },
-      required: ["query"]
+      required: ["query"],
+      additionalProperties: false
     }
-  },
-  {
+  }),
+  define({
     name: "get_component",
-    description: "One OPERATOR component: what it is for, what to use instead, every prop and option value, its nesting rules and an example. Call this before using a component.",
+    description: "One component's contract: what it is for, what to use instead, every prop and option value, nesting rules, an example. Call before using a component.",
     inputSchema: {
       type: "object",
       properties: {
-        name: string("The component's name, such as Button or DataGrid."),
+        name: {
+          type: "string",
+          minLength: 1,
+          maxLength: LIMITS.name,
+          description: "Component name, such as Button."
+        },
         dense: {
           type: "boolean",
-          description: "The short form, which is the default. Pass false for full descriptions."
+          default: true,
+          description: "Compact form (every constraint, one sentence per prop). False: full prose."
         }
       },
-      required: ["name"]
+      required: ["name"],
+      additionalProperties: false
     }
-  },
-  {
+  }),
+  define({
     name: "list_components",
     description: "Every OPERATOR component in one line each, with its parts.",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
+    inputSchema: { type: "object", properties: {}, additionalProperties: false }
+  }),
+  define({
     name: "get_instructions",
-    description: "OPERATOR's house rules, its component index and its recipes: what to read once before building with it.",
-    inputSchema: { type: "object", properties: {} }
-  },
-  {
+    description: "OPERATOR's house rules, component index and recipes: read once before building.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false }
+  }),
+  define({
     name: "check_code",
-    description: "Check TSX code against OPERATOR's contract: option values, nesting, required props and the house rules. Call this on what you wrote before you finish.",
+    description: "Check TSX against OPERATOR's contract: option values, nesting, required props, house rules. Call before you finish. Read evaluation_status: only evaluated_clean means every file was read in full with nothing found. Types and rendering are not checked.",
     inputSchema: {
       type: "object",
-      properties: { code: string("The TSX source of one file.") },
-      required: ["code"]
+      properties: {
+        code: {
+          type: "string",
+          minLength: 1,
+          maxLength: LIMITS.code,
+          description: "The TSX source of one file."
+        }
+      },
+      required: ["code"],
+      additionalProperties: false
     }
-  }
+  })
 ];
 function runTool(name, args, context) {
   const { contract: contract2, registry: registry2 } = context;
-  const required = (key) => {
-    const value = args[key];
-    if (typeof value !== "string" || value.trim() === "")
-      throw new Error(`${name} needs ${key}, a string.`);
-    return value;
-  };
+  const definition = TOOLS.find((tool) => tool.name === name);
+  if (definition === void 0) throw new UnknownTool(name);
+  const problem = validateArguments(name, definition.inputSchema, args);
+  if (problem !== null) throw new CliError(problem, 2, { code: "ERR_INVALID_ARGUMENT" });
   switch (name) {
     case "search": {
-      const query = required("query");
-      const results = search(
-        contract2,
-        registry2,
-        query,
-        typeof args.limit === "number" ? args.limit : 10
-      );
-      return results.length === 0 ? `Nothing matches ${JSON.stringify(query)}. Call list_components to see what there is.` : results.map(
-        ({ kind, name: found, purpose, why, next }) => `${found} (${kind}): ${purpose}${why === void 0 ? "" : ` [${why}]`}
+      const query = args["query"];
+      const limit = args["limit"] ?? SEARCH_LIMIT_DEFAULT;
+      const results = search(contract2, registry2, query, limit);
+      return {
+        text: results.length === 0 ? `Nothing matches ${JSON.stringify(query)}. Call list_components to see what there is.` : results.map(
+          ({ kind, name: found, purpose, why, next }) => `${found} (${kind}): ${purpose}${why === void 0 ? "" : ` [${why}]`}
   ${next}`
-      ).join("\n");
+        ).join("\n"),
+        structured: envelope(
+          "search",
+          { query, limit, matchCount: results.length, results },
+          contract2
+        )
+      };
+    }
+    case "get_component": {
+      const dense = args["dense"] ?? true;
+      const detail = componentDetail(contract2, args["name"]);
+      return {
+        text: renderComponent(detail, { dense }),
+        structured: envelope("component.detail", componentData(detail, dense), contract2)
+      };
+    }
+    case "list_components": {
+      const components = componentIndex(contract2);
+      return {
+        text: components.map(
+          ({ name: component, purpose, parts }) => `${component}${parts.length > 0 ? ` (${parts.join(", ")})` : ""}: ${purpose}`
+        ).join("\n"),
+        structured: envelope("component.list", { components }, contract2)
+      };
     }
-    case "get_component":
-      return renderComponent(componentDetail(contract2, required("name")), {
-        dense: args.dense !== false
-      });
-    case "list_components":
-      return componentIndex(contract2).map(
-        ({ name: component, purpose, parts }) => `${component}${parts.length > 0 ? ` (${parts.join(", ")})` : ""}: ${purpose}`
-      ).join("\n");
     case "get_instructions":
-      return renderAgentBlock(contract2).split("\n").filter((line) => line !== START && line !== END && !line.startsWith("<!-- Written by")).join("\n");
+      return {
+        text: renderAgentBlock(contract2).split("\n").filter((line) => line !== START && line !== END && !line.startsWith("<!-- Written by")).join("\n"),
+        structured: envelope("instructions", instructionsData(contract2), contract2)
+      };
     case "check_code": {
-      const code = required("code");
-      const ts = context.typescript === void 0 ? findTypeScript(context.cwd ?? process.cwd()) : context.typescript;
-      if (ts === null)
-        throw new Error("check_code reads code with TypeScript, and found none installed.");
-      const findings = checkSource(ts, contract2, "snippet.tsx", code);
-      if (findings.length === 0) return "No findings.";
-      const errors = findings.filter(({ severity }) => severity === "error").length;
-      const count = (amount, word) => `${amount} ${word}${amount === 1 ? "" : "s"}`;
-      return [
-        ...findings.map(
-          ({ line, column, severity, code: finding, message }) => `${line}:${column}  ${severity}  ${finding}  ${message}`
-        ),
-        `${count(errors, "error")}, ${count(findings.length - errors, "warning")}.`
-      ].join("\n");
+      const report = buildCheckReport([
+        checkSource(contract2, "snippet.tsx", args["code"])
+      ]);
+      return { text: renderCheckText(report), structured: envelope("check", report, contract2) };
     }
     default:
       throw new UnknownTool(name);
@@ -1293,24 +2463,28 @@ var UnknownTool = class extends Error {
   }
 };
 function handleMessage(raw, context) {
-  const failure = (id2, code, message) => ({
+  const failure2 = (id2, code, message) => ({
     jsonrpc: "2.0",
     id: id2 ?? null,
     error: { code, message }
   });
-  if (typeof raw !== "object" || raw === null) return failure(null, -32700, "Parse error");
+  if (typeof raw !== "object" || raw === null) return failure2(null, -32700, "Parse error");
   const { id, method, params } = raw;
-  if (typeof method !== "string") return failure(id, -32600, "Invalid request");
+  if (typeof method !== "string") return failure2(id, -32600, "Invalid request");
   if (id === void 0) return null;
   const result = (value) => ({ jsonrpc: "2.0", id, result: value });
   switch (method) {
     case "initialize": {
       const asked = params?.protocolVersion;
+      const identity = identityOf(context.contract);
       return result({
         protocolVersion: asked !== void 0 && VERSIONS.includes(asked) ? asked : VERSIONS[0],
         capabilities: { tools: {} },
-        serverInfo: { name: "oprt", version: context.contract.version },
-        instructions: "OPERATOR design system. Call get_instructions once, search for the component that answers a need, get_component before using one, and check_code before you finish."
+        // The program's version, not the contract's: the contract has its own, in `_meta` and in
+        // the identity of every result.
+        serverInfo: { name: "oprt", version: VERSION },
+        instructions: "OPERATOR design system. Call get_instructions once, search for the component that answers a need, get_component before using one, and check_code before you finish. check_code says how much it could read: only evaluated_clean means the code was read in full with nothing found.",
+        _meta: { "dev.oprt/identity": identity }
       });
     }
     case "ping":
@@ -1320,17 +2494,23 @@ function handleMessage(raw, context) {
     case "tools/call": {
       const { name, arguments: args } = params ?? {};
       try {
-        return result({ content: [text(runTool(String(name), args ?? {}, context))] });
+        const output = runTool(String(name), args ?? {}, context);
+        return result({
+          content: [text(output.text)],
+          structuredContent: output.structured
+        });
       } catch (error) {
-        if (error instanceof UnknownTool) return failure(id, -32602, error.message);
+        if (error instanceof UnknownTool) return failure2(id, -32602, error.message);
+        const failed = errorEnvelope(error, context.contract);
         return result({
-          content: [text(error instanceof Error ? error.message : String(error))],
+          content: [text(failed.error)],
+          structuredContent: failed,
           isError: true
         });
       }
     }
     default:
-      return failure(id, -32601, `Method not found: ${method}`);
+      return failure2(id, -32601, `Method not found: ${method}`);
   }
 }
 function serve(input, output, context) {
@@ -1351,7 +2531,6 @@ function serve(input, output, context) {
 }
 
 // src/index.ts
-var VERSION = package_default.version;
 function loadRegistry() {
   const here = dirname5(fileURLToPath3(import.meta.url));
   const candidates = [join4(here, "registry.json"), join4(here, "../generated/registry.json")];
@@ -1364,8 +2543,8 @@ function loadRegistry() {
   return JSON.parse(readFileSync6(found, "utf8"));
 }
 var registry = loadRegistry();
-var loaded;
-var contract = () => loaded ??= loadContract();
+var loaded2;
+var contract = () => loaded2 ??= loadContract();
 function install(options, context = {}) {
   return installSources(options, {
     cwd: context.cwd ?? process.cwd(),
@@ -1375,26 +2554,38 @@ function install(options, context = {}) {
 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
 };