@oprt/cli 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
 import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname5, join as join5 } from "path";
+import { dirname as dirname5, join as join4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/contract.ts
@@ -504,7 +504,7 @@ import { createHash } from "crypto";
 // package.json
 var package_default = {
   name: "@oprt/cli",
-  version: "0.3.0",
+  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",
@@ -560,6 +560,8 @@ var package_default = {
     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",
@@ -573,7 +575,7 @@ var package_default = {
 
 // src/identity.ts
 var VERSION = package_default.version;
-var RESULT_SCHEMA_VERSION = 1;
+var RESULT_SCHEMA_VERSION = 2;
 var digests = /* @__PURE__ */ new WeakMap();
 function contractDigest(contract2) {
   let digest = digests.get(contract2);
@@ -594,77 +596,241 @@ function identityOf(contract2) {
 
 // src/check.ts
 import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3, statSync } from "fs";
-import { basename, extname, join as join3, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
+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 { join as join2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var SUPPORTED_TYPESCRIPT = "TypeScript 5 or 6";
-var INSTALL_TYPESCRIPT = "npm install -D typescript@6";
-function usable(typescript) {
-  const ts = typescript;
-  if (typeof ts.createSourceFile !== "function" || ts.ScriptKind === void 0)
-    return `TypeScript ${ts.version ?? "(unknown version)"} has no JavaScript syntax API (createSourceFile), which oprt reads code with; ${SUPPORTED_TYPESCRIPT} has it`;
+
+// ../../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"
+  ];
+  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
+  };
+}
+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 probe = ts.createSourceFile(
-      "probe.tsx",
-      "<a>",
-      ts.ScriptTarget?.Latest ?? 99,
-      true,
-      ts.ScriptKind.TSX
-    );
-    const diagnostics = probe.parseDiagnostics;
-    if (!Array.isArray(diagnostics)) return "it does not report parse errors on a source file";
-    if (diagnostics.length === 0) return "it did not report a syntax error in code that has one";
+    const require2 = createRequire(import.meta.url);
+    loaded = fromSource ? require2("@babel/parser") : require2("./babel-parser.cjs");
   } catch (error) {
-    return `it failed on a probe parse: ${error instanceof Error ? error.message : String(error)}`;
+    throw new CliError(
+      `Code checking cannot load its parser (${FILE}): ${error instanceof Error ? error.message : String(error)} ${REINSTALL}`,
+      1,
+      { code: "ERR_PARSER_MISSING" }
+    );
   }
-  return null;
+  return loaded;
 }
-var packageFolder = (file) => /^(.*[\\/]node_modules[\\/]typescript)[\\/]/.exec(file)?.[1] ?? file;
-function probeTypeScript(cwd, options = {}) {
-  const places = [
-    { from: join2(cwd, "package.json"), source: "project" },
-    ...options.installer === false ? [] : [{ from: fileURLToPath2(import.meta.url), source: "installer" }]
-  ];
-  let unusable;
-  for (const { from, source } of places) {
-    let file;
-    let loaded2;
-    try {
-      const require2 = createRequire(from);
-      file = require2.resolve("typescript");
-      loaded2 = require2("typescript");
-    } catch (error) {
-      if (error.code !== "MODULE_NOT_FOUND")
-        unusable ??= `typescript was found but failed to load: ${error instanceof Error ? error.message : String(error)}`;
-      continue;
-    }
-    const typescript = loaded2.default ?? loaded2;
-    const problem = usable(typescript);
-    if (problem !== null) {
-      unusable ??= `${problem} (at ${packageFolder(file)}).`;
-      continue;
-    }
+var rejects = (babel, code) => {
+  try {
+    return babel.parse(code, optionsFor("probe.tsx")).errors.length > 0;
+  } catch {
+    return true;
+  }
+};
+function probeParser(load = loadBabel) {
+  let babel;
+  try {
+    babel = load();
+  } catch (error) {
     return {
-      ready: true,
-      typescript,
-      resolution: {
-        name: "typescript",
-        version: typescript.version,
-        source,
-        resolved_from: packageFolder(file)
-      }
+      ready: false,
+      reason: "parser_missing",
+      detail: error instanceof Error ? error.message : String(error)
+    };
+  }
+  if (rejects(babel, "export const a = <a b={1 as number} />;"))
+    return {
+      ready: false,
+      reason: "parser_unusable",
+      detail: "it rejected valid code in a probe parse"
+    };
+  if (!rejects(babel, "export const a = <a>;"))
+    return {
+      ready: false,
+      reason: "parser_unusable",
+      detail: "it did not report a syntax error in code that has one"
     };
+  return { ready: true, parser: PARSER };
+}
+
+// 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;
   }
-  if (unusable !== void 0)
-    return { ready: false, reason: "typescript_unusable", detail: unusable };
+}
+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 {
-    ready: false,
-    reason: "typescript_missing",
-    detail: `typescript could not be resolved from ${cwd}${options.installer === false ? "" : " or from beside the installer"}.`
+    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;
+  }
+  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) };
+  }
+  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
@@ -728,52 +894,43 @@ var quote = (text2) => {
   return flat.length > 48 ? `${flat.slice(0, 45)}...` : flat;
 };
 var MAX_SYNTAX_ERRORS = 10;
-function checkSource(typescript, contract2, file, text2) {
-  const ts = typescript;
-  const kind = /\.tsx$/.test(file) ? ts.ScriptKind.TSX : ts.ScriptKind.JSX;
-  const source = ts.createSourceFile(file, text2, ts.ScriptTarget.Latest, true, kind);
-  const parseDiagnostics = source.parseDiagnostics;
-  if (!Array.isArray(parseDiagnostics))
-    throw new CliError(
-      `This TypeScript does not report syntax errors on a parsed file, so a file that does not parse could be called clean. Install TypeScript 5 or 6 in this project (${INSTALL_TYPESCRIPT}).`,
-      1,
-      { code: "ERR_TYPESCRIPT_UNUSABLE" }
-    );
-  if (parseDiagnostics.length > 0) {
-    const ordered = [...parseDiagnostics].sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
-    const shown = ordered.slice(0, MAX_SYNTAX_ERRORS);
+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((diagnostic, index) => {
-        const { line, character } = source.getLineAndCharacterOfPosition(diagnostic.start ?? 0);
-        const more = ordered.length - shown.length;
-        return {
+      findings: shown.map(
+        ({ line, column, message, code }, index) => ({
           code: "SYNTAX_ERROR",
           severity: "error",
           file,
-          line: line + 1,
-          column: character + 1,
-          message: `${ts.flattenDiagnosticMessageText(diagnostic.messageText, " ")} (TS${diagnostic.code})` + (index === shown.length - 1 && more > 0 ? ` ${more} more syntax error${more === 1 ? "" : "s"} in this file not shown.` : "")
-        };
-      })
+          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) => {
-    const { line, character } = source.getLineAndCharacterOfPosition(node.getStart(source));
-    limitations.push({ ...limitation, file, line: line + 1, column: character + 1 });
+    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,
@@ -784,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);
@@ -823,51 +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 walk = (node) => {
-      if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
-        read.push(node.text);
-      else if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isNonNullExpression(node) || ts.isTypeAssertionExpression(node) || typeof ts.isSatisfiesExpression === "function" && ts.isSatisfiesExpression(node))
-        walk(node.expression);
-      else if (ts.isConditionalExpression(node)) {
-        walk(node.whenTrue);
-        walk(node.whenFalse);
-      } else if (ts.isBinaryExpression(node)) {
-        const operator = node.operatorToken.kind;
-        if (operator === ts.SyntaxKind.QuestionQuestionToken || operator === ts.SyntaxKind.BarBarToken) {
-          walk(node.left);
-          walk(node.right);
-        } else if (operator === ts.SyntaxKind.AmpersandAmpersandToken) walk(node.right);
-        else unread.push(node);
+    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.
-      (ts.isIdentifier(node) && node.text === "undefined" || node.kind === ts.SyntaxKind.NullKeyword))
+      (node.type === "Identifier" && node.name === "undefined" || node.type === "NullLiteral"))
         unread.push(node);
     };
-    if (expression) walk(expression);
+    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) => {
@@ -893,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",
@@ -903,47 +1061,49 @@ 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 (ts.isJsxSpreadAttribute(attribute))
+      if (attribute.type === "JSXSpreadAttribute")
         limit(attribute, {
           code: "UNRESOLVED_SPREAD",
           component,
-          message: `Props spread into <${component}> (${quote(attribute.getText(source))}) were not read: option values and required props that arrive through them were not checked.`
+          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) {
@@ -965,7 +1125,7 @@ function checkSource(typescript, contract2, file, text2) {
           code: "UNRESOLVED_VALUE",
           component,
           prop,
-          message: `${component} ${prop} is set from an expression (${quote(expression.getText(source))}) whose value is not in the source, so it was not compared with the options.`
+          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;
@@ -1014,35 +1174,34 @@ 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(source, [], null);
-  const byPlace = (a, b) => a.line - b.line || a.column - b.column;
+  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(byPlace),
-    limitations: limitations.sort(byPlace)
+    findings: findings.sort(byPlace2),
+    limitations: limitations.sort(byPlace2)
   };
 }
 var SKIPPED = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", "coverage"]);
@@ -1052,7 +1211,7 @@ var excluded = (name) => SKIPPED.has(name) || name.startsWith(".");
 function* sources(path) {
   if (excluded(basename(path))) return;
   if (statSync(path).isDirectory()) {
-    for (const entry of readdirSync(path).sort()) yield* sources(join3(path, entry));
+    for (const entry of readdirSync(path).sort()) yield* sources(join2(path, entry));
   } else if (READ.has(extname(path)) && !NOT_INTERFACE.test(basename(path))) yield path;
 }
 function whyNotRead(path) {
@@ -1062,7 +1221,7 @@ function whyNotRead(path) {
   if (!READ.has(extname(path))) return "unsupported_extension";
   return NOT_INTERFACE.test(name) ? "test_or_story_file" : null;
 }
-function buildCheckReport(evaluations, context) {
+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");
@@ -1089,7 +1248,7 @@ function buildCheckReport(evaluations, context) {
     limitations: evaluations.flatMap(({ limitations }) => limitations),
     skipped_inputs: context.skipped ?? [],
     scope: { checked: [...SCOPE.checked], not_checked: [...SCOPE.not_checked] },
-    parser: context.parser
+    parser: context.parser ?? PARSER
   };
 }
 function checkExitCode(report, { strict }) {
@@ -1097,29 +1256,6 @@ function checkExitCode(report, { strict }) {
   if (report.summary.errors > 0 || report.coverage.files_not_evaluated > 0) return 1;
   return strict && report.summary.warnings > 0 ? 1 : 0;
 }
-var describeProvided = (typescript) => ({
-  name: "typescript",
-  version: typescript.version ?? "unknown",
-  source: "provided"
-});
-function resolveParser(cwd, provided, who) {
-  if (provided !== void 0 && provided !== null)
-    return { typescript: provided, parser: describeProvided(provided) };
-  const probe = provided === null ? null : probeTypeScript(cwd);
-  if (probe?.ready) {
-    const { name, version, source } = probe.resolution;
-    return { typescript: probe.typescript, parser: { name, version, source } };
-  }
-  if (probe !== null && probe.reason === "typescript_unusable")
-    throw new CliError(`${who} cannot use the TypeScript it found: ${probe.detail}`, 1, {
-      code: "ERR_TYPESCRIPT_UNUSABLE"
-    });
-  throw new CliError(
-    `${who} reads code with the project's TypeScript, and found none. Install typescript in this project (${INSTALL_TYPESCRIPT}) and run it again. It looked from ${cwd}.`,
-    1,
-    { code: "ERR_TYPESCRIPT_MISSING" }
-  );
-}
 function checkPaths(paths, context) {
   const root = resolve2(context.cwd);
   const files = [];
@@ -1132,16 +1268,15 @@ function checkPaths(paths, context) {
     if (reason !== null) skipped.push({ path, reason });
     files.push(...sources(absolute));
   }
-  const { typescript, parser } = resolveParser(root, context.typescript, "oprt check");
+  loadBabel();
   const evaluations = [...new Set(files)].map(
     (file) => checkSource(
-      typescript,
       context.contract,
       relative2(root, file).split(sep2).join("/"),
       readFileSync3(file, "utf8")
     )
   );
-  return buildCheckReport(evaluations, { parser, skipped });
+  return buildCheckReport(evaluations, { skipped });
 }
 var plural = (amount, word) => `${amount} ${word}${amount === 1 ? "" : "s"}`;
 var MAX_LIMITS_SHOWN = 20;
@@ -1183,7 +1318,7 @@ function renderCheckText(report) {
 
 // src/doctor.ts
 import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname3, join as join4 } from "path";
+import { dirname as dirname3, join as join3 } from "path";
 
 // src/agent-block.ts
 var START = "<!-- OPERATOR:START -->";
@@ -1265,10 +1400,10 @@ 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 = join4(folder, "node_modules", name, "package.json");
+    const manifest = join3(folder, "node_modules", name, "package.json");
     if (existsSync3(manifest))
       return JSON.parse(readFileSync4(manifest, "utf8")).version;
     if (dirname3(folder) === folder) return void 0;
@@ -1277,36 +1412,36 @@ function installedVersion(cwd, name) {
 function doctor({
   cwd,
   contract: contract2,
-  parser = probeTypeScript(cwd)
+  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 = join4(cwd, path);
+    const file = join3(cwd, path);
     return {
       path,
       version: existsSync3(file) ? blockVersion(readFileSync4(file, "utf8")) : void 0
     };
-  }).filter(({ version }) => version !== void 0);
-  const stale = written.find(({ version }) => version !== contract2.version);
+  }).filter(({ version: version2 }) => version2 !== void 0);
+  const stale = written.find(({ version: version2 }) => version2 !== contract2.version);
   if (written.length === 0)
     checks.push({
       id: "agent-instructions",
@@ -1327,39 +1462,32 @@ function doctor({
       status: "ok",
       message: `${written.map(({ path }) => path).join(", ")} carries the OPERATOR block (${contract2.version}).`
     });
-  const install2 = `${INSTALL_TYPESCRIPT} (or your package manager's equivalent), then run oprt doctor again. Lookups work without it.`;
   let checkCode;
   if (parser.ready) {
-    const { version, resolved_from, source } = parser.resolution;
+    const { name, version: version2 } = parser.parser;
     checkCode = {
       status: "ready",
-      message: `TypeScript ${version}, resolved from ${resolved_from}${source === "project" ? "" : " (beside oprt, not this project)"}.`,
-      typescript: { version, resolved_from, source }
+      message: `${name} ${version2}, bundled with oprt: nothing to install.`,
+      parser: parser.parser
     };
-    checks.push(
-      source === "project" ? {
-        id: "typescript",
-        status: "ok",
-        message: `TypeScript ${version} is installed in this project (${resolved_from}).`
-      } : {
-        id: "typescript",
-        status: "warn",
-        message: `TypeScript ${version} is not in this project; the one beside oprt is used (${resolved_from}).`,
-        fix: `${INSTALL_TYPESCRIPT}, so checking reads code with a version installed in the project.`
-      }
-    );
+    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: install2
+      fix
     };
     checks.push({
-      id: "typescript",
+      id: "parser",
       status: "fail",
       message: `oprt check and the check_code tool cannot run (${parser.reason}): ${parser.detail}`,
-      fix: install2
+      fix
     });
   }
   const count = (status) => checks.filter((check) => check.status === status).length;
@@ -1447,7 +1575,7 @@ var RESULT_TYPES = [
   "instructions"
 ];
 var envelope = (type, data, contract2) => ({
-  apiVersion: 1,
+  apiVersion: RESULT_SCHEMA_VERSION,
   type,
   identity: identityOf(contract2),
   data
@@ -1461,7 +1589,7 @@ function errorEnvelope(error, contract2) {
     contract_digest
   }))(identityOf(contract2));
   return {
-    apiVersion: 1,
+    apiVersion: RESULT_SCHEMA_VERSION,
     error: error instanceof Error ? error.message : String(error),
     code: known?.code ?? "ERR_FAILED",
     ...known?.suggestions === void 0 ? {} : { suggestions: known.suggestions },
@@ -1557,9 +1685,9 @@ var DEFS = {
     reason: words2("unsupported_extension", "test_or_story_file", "excluded_folder")
   }),
   parser: obj({
-    name: words2("typescript"),
+    name: words2("@babel/parser"),
     version: str(),
-    source: words2("project", "installer", "provided")
+    source: words2("bundled")
   }),
   check_data: obj({
     evaluation_status: words2(
@@ -1651,15 +1779,11 @@ var DEFS = {
         {
           status: words2("ready", "blocked"),
           message: str(),
-          reason: words2("typescript_missing", "typescript_unusable"),
+          reason: words2("parser_missing", "parser_unusable"),
           fix: str(),
-          typescript: obj({
-            version: str(),
-            resolved_from: str(),
-            source: words2("project", "installer", "provided")
-          })
+          parser: ref("parser")
         },
-        ["reason", "fix", "typescript"]
+        ["reason", "fix", "parser"]
       )
     }),
     checks: arr(ref("doctor_check")),
@@ -1734,14 +1858,14 @@ var DATA = {
   instructions: "instructions_data"
 };
 var success = (type) => obj({
-  apiVersion: { const: 1 },
+  apiVersion: { const: RESULT_SCHEMA_VERSION },
   type: { const: type },
   identity: ref("identity"),
   data: ref(DATA[type])
 });
 var failure = () => obj(
   {
-    apiVersion: { const: 1 },
+    apiVersion: { const: RESULT_SCHEMA_VERSION },
     error: str(),
     code: str({ pattern: "^ERR_[A-Z_]+$" }),
     suggestions: names(),
@@ -2322,15 +2446,9 @@ function runTool(name, args, context) {
         structured: envelope("instructions", instructionsData(contract2), contract2)
       };
     case "check_code": {
-      const { typescript, parser } = resolveParser(
-        context.cwd ?? process.cwd(),
-        context.typescript,
-        "check_code"
-      );
-      const report = buildCheckReport(
-        [checkSource(typescript, contract2, "snippet.tsx", args["code"])],
-        { parser }
-      );
+      const report = buildCheckReport([
+        checkSource(contract2, "snippet.tsx", args["code"])
+      ]);
       return { text: renderCheckText(report), structured: envelope("check", report, contract2) };
     }
     default:
@@ -2415,7 +2533,7 @@ function serve(input, output, context) {
 // src/index.ts
 function loadRegistry() {
   const here = dirname5(fileURLToPath3(import.meta.url));
-  const candidates = [join5(here, "registry.json"), join5(here, "../generated/registry.json")];
+  const candidates = [join4(here, "registry.json"), join4(here, "../generated/registry.json")];
   const found = candidates.find((candidate) => existsSync5(candidate));
   if (found === void 0) {
     throw new Error(
@@ -2425,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(),