@oprt/cli 0.3.0 → 0.4.0

package/dist/bin.js

@@ -396,87 +396,263 @@ var init_args = __esm({
   }
 });
 
+// ../../node_modules/.pnpm/@babel+parser@8.0.8/node_modules/@babel/parser/package.json
+var version;
+var init_package = __esm({
+  "../../node_modules/.pnpm/@babel+parser@8.0.8/node_modules/@babel/parser/package.json"() {
+    version = "8.0.8";
+  }
+});
+
 // src/parser.ts
 import { createRequire } from "module";
-import { join } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-function usable(typescript) {
-  const ts = typescript;
-  if (typeof ts.createSourceFile !== "function" || ts.ScriptKind === void 0)
-    return `TypeScript ${ts.version ?? "(unknown version)"} has no JavaScript syntax API (createSourceFile), which oprt reads code with; ${SUPPORTED_TYPESCRIPT} has it`;
+function optionsFor(file) {
+  const typed = /\.tsx$/.test(file);
+  const plugins = [
+    "jsx",
+    ...typed ? ["typescript"] : [],
+    "decorators",
+    "decoratorAutoAccessors",
+    "deferredImportEvaluation",
+    "sourcePhaseImports"
+  ];
+  return {
+    sourceType: "module",
+    plugins,
+    // Recoverable errors are returned beside the tree, instead of the first one being thrown.
+    errorRecovery: true,
+    attachComment: false,
+    allowReturnOutsideFunction: true,
+    allowUndeclaredExports: true,
+    allowSuperOutsideMethod: true,
+    allowNewTargetOutsideFunction: true
+  };
+}
+function loadBabel() {
+  if (loaded !== void 0) return loaded;
+  const fromSource = /\.[cm]?tsx?$/.test(fileURLToPath2(import.meta.url));
   try {
-    const 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;
 }
-function probeTypeScript(cwd, options = {}) {
-  const places = [
-    { from: join(cwd, "package.json"), source: "project" },
-    ...options.installer === false ? [] : [{ from: fileURLToPath2(import.meta.url), source: "installer" }]
-  ];
-  let unusable;
-  for (const { from, source } of places) {
-    let file;
-    let loaded2;
-    try {
-      const require2 = createRequire(from);
-      file = require2.resolve("typescript");
-      loaded2 = require2("typescript");
-    } catch (error) {
-      if (error.code !== "MODULE_NOT_FOUND")
-        unusable ??= `typescript was found but failed to load: ${error instanceof Error ? error.message : String(error)}`;
-      continue;
-    }
-    const typescript = loaded2.default ?? loaded2;
-    const problem = usable(typescript);
-    if (problem !== null) {
-      unusable ??= `${problem} (at ${packageFolder(file)}).`;
-      continue;
-    }
+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 (unusable !== void 0)
-    return { ready: false, reason: "typescript_unusable", detail: unusable };
-  return {
-    ready: false,
-    reason: "typescript_missing",
-    detail: `typescript could not be resolved from ${cwd}${options.installer === false ? "" : " or from beside the installer"}.`
-  };
+  if (rejects(babel, "export const a = <a b={1 as number} />;"))
+    return {
+      ready: false,
+      reason: "parser_unusable",
+      detail: "it rejected valid code in a probe parse"
+    };
+  if (!rejects(babel, "export const a = <a>;"))
+    return {
+      ready: false,
+      reason: "parser_unusable",
+      detail: "it did not report a syntax error in code that has one"
+    };
+  return { ready: true, parser: PARSER };
 }
-var SUPPORTED_TYPESCRIPT, INSTALL_TYPESCRIPT, packageFolder;
+var PARSER, FILE, REINSTALL, loaded, rejects;
 var init_parser = __esm({
   "src/parser.ts"() {
     "use strict";
     init_esm_shims();
-    SUPPORTED_TYPESCRIPT = "TypeScript 5 or 6";
-    INSTALL_TYPESCRIPT = "npm install -D typescript@6";
-    packageFolder = (file) => /^(.*[\\/]node_modules[\\/]typescript)[\\/]/.exec(file)?.[1] ?? file;
+    init_package();
+    init_types();
+    PARSER = {
+      name: "@babel/parser",
+      version,
+      source: "bundled"
+    };
+    FILE = "babel-parser.cjs";
+    REINSTALL = "Install @oprt/cli again: the parser ships beside the executable in dist.";
+    rejects = (babel, code) => {
+      try {
+        return babel.parse(code, optionsFor("probe.tsx")).errors.length > 0;
+      } catch {
+        return true;
+      }
+    };
+  }
+});
+
+// src/syntax.ts
+function* childNodes(node) {
+  for (const [key, value] of Object.entries(node)) {
+    if (NOT_NODES.has(key) || typeof value !== "object" || value === null) continue;
+    if (Array.isArray(value)) {
+      for (const item of value)
+        if (typeof item === "object" && item !== null && typeof item.type === "string")
+          yield item;
+    } else if (typeof value.type === "string") yield value;
+  }
+}
+function problemsOf(tree, errors, limit, consumed) {
+  const mismatched = /* @__PURE__ */ new Map();
+  walk(tree.program, [], (node, ancestors) => {
+    if (node.type === "JSXElement" && node.closingElement && (node.closingElement.start ?? 0) < limit && tagName(node.openingElement.name) !== tagName(node.closingElement.name))
+      mismatched.set(node.closingElement.start ?? 0, { element: node, ancestors: [...ancestors] });
+  });
+  const problems = [];
+  for (const error of errors) {
+    if (error.pos >= limit) continue;
+    const entry = error.reasonCode === "MissingClosingTagElement" && mismatched.get(error.pos);
+    if (entry) {
+      const closing = tagName(entry.element.closingElement?.name);
+      const outer = [...entry.ancestors].reverse().find(
+        (ancestor) => ancestor.type === "JSXElement" && tagName(ancestor.openingElement.name) === closing && !consumed.has(ancestor)
+      );
+      if (outer !== void 0) {
+        consumed.add(outer);
+        problems.push(unclosed(entry.element));
+        continue;
+      }
+    }
+    problems.push(problemOf(error));
+  }
+  return problems;
+}
+function 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));
+}
+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)] };
+}
+var attempt, sentence, problemOf, tagName, NOT_NODES, walk, unclosed, TYPE_ARGUMENTS, LINE_BREAKS, blankedOut, CLOSING_TAG, COMPLETIONS, MAX_COMPLETIONS, byPlace, MAX_EXPLAINED;
+var init_syntax = __esm({
+  "src/syntax.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_parser();
+    attempt = (babel, text2, file) => {
+      try {
+        const tree = babel.parse(text2, optionsFor(file));
+        return { tree, errors: tree.errors };
+      } catch (error) {
+        return { tree: null, fatal: error };
+      }
+    };
+    sentence = (message) => message.replace(/\s*\(\d+:\d+\)$/, "");
+    problemOf = (failure2) => ({
+      line: failure2.loc.line,
+      column: failure2.loc.column + 1,
+      message: sentence(failure2.message),
+      code: failure2.reasonCode ?? "SyntaxError",
+      position: failure2.pos
+    });
+    tagName = (name) => {
+      if (name === void 0) return "";
+      if (name.type === "JSXIdentifier") return name.name;
+      if (name.type === "JSXMemberExpression")
+        return `${tagName(name.object)}.${name.property.name}`;
+      return `${name.namespace.name}:${name.name.name}`;
+    };
+    NOT_NODES = /* @__PURE__ */ new Set(["loc", "extra", "errors", "tokens", "comments"]);
+    walk = (node, ancestors, visit) => {
+      visit(node, ancestors);
+      ancestors.push(node);
+      for (const child of childNodes(node)) walk(child, ancestors, visit);
+      ancestors.pop();
+    };
+    unclosed = (element) => {
+      const name = element.openingElement.name;
+      return {
+        line: name.loc?.start.line ?? 1,
+        column: (name.loc?.start.column ?? 0) + 1,
+        message: `JSX element '${tagName(name)}' has no corresponding closing tag.`,
+        code: "UnclosedJsxElement",
+        position: name.start ?? 0
+      };
+    };
+    TYPE_ARGUMENTS = /(?<=[\w$\])])<(?:[^<>()]|<(?:[^<>()]|<[^<>()]*>)*>)*>(?=\()/g;
+    LINE_BREAKS = new RegExp(`[^\\r\\n${String.fromCharCode(8232, 8233)}]`, "g");
+    blankedOut = (match) => match.replace(LINE_BREAKS, " ");
+    CLOSING_TAG = "</_>";
+    COMPLETIONS = [CLOSING_TAG, ")", "}", "]"];
+    MAX_COMPLETIONS = 24;
+    byPlace = (a, b) => a.position - b.position;
+    MAX_EXPLAINED = 2e5;
   }
 });
 
 // src/check.ts
 import { existsSync, readdirSync, readFileSync, statSync } from "fs";
-import { basename, extname, join as join2, relative, resolve, sep } from "path";
+import { basename, extname, join, relative, resolve, sep } from "path";
 function allowedChildren2(rules, name) {
   for (const [parent, rule] of Object.entries(rules ?? {})) {
     if (parent === name) return rule.allowed_children;
@@ -485,52 +661,43 @@ 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);
-  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,
@@ -541,21 +708,18 @@ function checkSource(typescript, contract2, file, text2) {
   const isComponent = (name) => Object.hasOwn(contract2.components, name);
   const named = /* @__PURE__ */ new Map();
   const namespaces = /* @__PURE__ */ new Set();
-  for (const statement of source.statements) {
-    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
-      continue;
-    const from = statement.moduleSpecifier.text;
-    const clause = statement.importClause;
-    if (!clause || clause.isTypeOnly || !clause.namedBindings) continue;
+  for (const statement of reading.tree.program.body) {
+    if (statement.type !== "ImportDeclaration" || statement.importKind === "type") continue;
+    const from = statement.source.value;
     const copied = from !== PACKAGE && /[./@]/.test(from[0] ?? "") && isComponent(basename(from));
     if (from !== PACKAGE && !copied) continue;
-    if (ts.isNamespaceImport(clause.namedBindings)) {
-      if (from === PACKAGE) namespaces.add(clause.namedBindings.name.text);
-      continue;
-    }
-    for (const element2 of clause.namedBindings.elements) {
-      if (element2.isTypeOnly) continue;
-      const exported = (element2.propertyName ?? element2.name).text;
+    for (const element2 of statement.specifiers) {
+      if (element2.type === "ImportNamespaceSpecifier") {
+        if (from === PACKAGE) namespaces.add(element2.local.name);
+        continue;
+      }
+      if (element2.type !== "ImportSpecifier" || element2.importKind === "type") continue;
+      const exported = element2.imported.type === "Identifier" ? element2.imported.name : element2.imported.value;
       if (from === PACKAGE && !contract2.exports.includes(exported)) {
         let suggestions = nearest(exported, Object.keys(contract2.components));
         if (suggestions.length === 0) suggestions = nearest(exported, contract2.exports);
@@ -580,51 +744,55 @@ function checkSource(typescript, contract2, file, text2) {
         });
         continue;
       }
-      if (isComponent(exported)) named.set(element2.name.text, exported);
+      if (isComponent(exported)) named.set(element2.local.name, exported);
     }
   }
+  const isString = (node) => node.type === "StringLiteral";
+  const plainTemplate = (node) => node.type === "TemplateLiteral" && node.expressions.length === 0 ? node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw : void 0;
   const literals = (expression) => {
     if (!expression) return [];
-    if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression))
-      return [expression.text];
-    if (ts.isParenthesizedExpression(expression)) return literals(expression.expression);
-    if (ts.isConditionalExpression(expression))
-      return [...literals(expression.whenTrue), ...literals(expression.whenFalse)];
+    if (isString(expression)) return [expression.value];
+    const template = plainTemplate(expression);
+    if (template !== void 0) return [template];
+    if (expression.type === "ConditionalExpression")
+      return [...literals(expression.consequent), ...literals(expression.alternate)];
     return [];
   };
-  const valueOf = (attribute) => attribute.initializer === void 0 ? void 0 : ts.isJsxExpression(attribute.initializer) ? attribute.initializer.expression : attribute.initializer;
+  const valueOf = (attribute) => {
+    const value = attribute.value;
+    if (value === null || value === void 0) return void 0;
+    if (value.type === "JSXExpressionContainer")
+      return value.expression.type === "JSXEmptyExpression" ? void 0 : value.expression;
+    return value;
+  };
   const optionValue = (expression) => {
     const read = [];
     const unread = [];
-    const 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) => {
@@ -650,9 +818,9 @@ function checkSource(typescript, contract2, file, text2) {
           message: "A rounded corner. The radius is 0 everywhere in OPERATOR."
         });
     }
-    if (name === "style" && value && ts.isObjectLiteralExpression(value)) {
+    if (name === "style" && value && value.type === "ObjectExpression") {
       for (const property of value.properties)
-        if (ts.isPropertyAssignment(property) && literals(property.initializer).some((literal) => RAW_COLOR_VALUE.test(literal)))
+        if (property.type === "ObjectProperty" && literals(property.value).some((literal) => RAW_COLOR_VALUE.test(literal)))
           report(attribute, {
             code: "RAW_COLOR",
             severity: "warning",
@@ -660,47 +828,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) {
@@ -722,7 +892,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;
@@ -771,41 +941,40 @@ 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)
   };
 }
 function* sources(path2) {
   if (excluded(basename(path2))) return;
   if (statSync(path2).isDirectory()) {
-    for (const entry of readdirSync(path2).sort()) yield* sources(join2(path2, entry));
+    for (const entry of readdirSync(path2).sort()) yield* sources(join(path2, entry));
   } else if (READ.has(extname(path2)) && !NOT_INTERFACE.test(basename(path2))) yield path2;
 }
 function whyNotRead(path2) {
@@ -815,7 +984,7 @@ function whyNotRead(path2) {
   if (!READ.has(extname(path2))) 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");
@@ -842,7 +1011,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 }) {
@@ -850,24 +1019,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;
 }
-function resolveParser(cwd, provided, who) {
-  if (provided !== void 0 && provided !== null)
-    return { typescript: provided, parser: describeProvided(provided) };
-  const probe = provided === null ? null : probeTypeScript(cwd);
-  if (probe?.ready) {
-    const { name, version, source } = probe.resolution;
-    return { typescript: probe.typescript, parser: { name, version, source } };
-  }
-  if (probe !== null && probe.reason === "typescript_unusable")
-    throw new CliError(`${who} cannot use the TypeScript it found: ${probe.detail}`, 1, {
-      code: "ERR_TYPESCRIPT_UNUSABLE"
-    });
-  throw new CliError(
-    `${who} reads code with the project's TypeScript, and found none. Install typescript in this project (${INSTALL_TYPESCRIPT}) and run it again. It looked from ${cwd}.`,
-    1,
-    { code: "ERR_TYPESCRIPT_MISSING" }
-  );
-}
 function checkPaths(paths, context) {
   const root = resolve(context.cwd);
   const files = [];
@@ -880,16 +1031,15 @@ function checkPaths(paths, context) {
     if (reason !== null) skipped.push({ path: path2, 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,
       relative(root, file).split(sep).join("/"),
       readFileSync(file, "utf8")
     )
   );
-  return buildCheckReport(evaluations, { parser, skipped });
+  return buildCheckReport(evaluations, { skipped });
 }
 function renderCheckText(report) {
   const lines = report.findings.map(
@@ -926,15 +1076,15 @@ function renderCheckText(report) {
   return `${lines.join("\n")}
 `;
 }
-var FINDING_CODES, LIMITATION_CODES, SCOPE, PACKAGE, NATIVE, NATIVE_ATTRIBUTES, nativeAttribute, RAW_COLOR_CLASS, RAW_COLOR_VALUE, ARBITRARY_SIZE, ROUNDED_CORNER, quote, MAX_SYNTAX_ERRORS, SKIPPED, READ, NOT_INTERFACE, excluded, describeProvided, plural, MAX_LIMITS_SHOWN;
+var FINDING_CODES, LIMITATION_CODES, SCOPE, PACKAGE, NATIVE, NATIVE_ATTRIBUTES, nativeAttribute, RAW_COLOR_CLASS, RAW_COLOR_VALUE, ARBITRARY_SIZE, ROUNDED_CORNER, quote, MAX_SYNTAX_ERRORS, SKIPPED, READ, NOT_INTERFACE, excluded, plural, MAX_LIMITS_SHOWN;
 var init_check = __esm({
   "src/check.ts"() {
     "use strict";
     init_esm_shims();
     init_lookup();
     init_parser();
+    init_syntax();
     init_types();
-    init_parser();
     FINDING_CODES = [
       "INVALID_PROP_VALUE",
       "UNKNOWN_EXPORT",
@@ -991,11 +1141,6 @@ var init_check = __esm({
     READ = /* @__PURE__ */ new Set([".tsx", ".jsx"]);
     NOT_INTERFACE = /\.(?:test|spec|stories)\.[jt]sx$/;
     excluded = (name) => SKIPPED.has(name) || name.startsWith(".");
-    describeProvided = (typescript) => ({
-      name: "typescript",
-      version: typescript.version ?? "unknown",
-      source: "provided"
-    });
     plural = (amount, word) => `${amount} ${word}${amount === 1 ? "" : "s"}`;
     MAX_LIMITS_SHOWN = 20;
   }
@@ -1003,11 +1148,11 @@ var init_check = __esm({
 
 // package.json
 var package_default;
-var init_package = __esm({
+var init_package2 = __esm({
   "package.json"() {
     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",
@@ -1063,6 +1208,8 @@ var init_package = __esm({
         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",
@@ -1099,9 +1246,9 @@ var init_identity = __esm({
   "src/identity.ts"() {
     "use strict";
     init_esm_shims();
-    init_package();
+    init_package2();
     VERSION = package_default.version;
-    RESULT_SCHEMA_VERSION = 1;
+    RESULT_SCHEMA_VERSION = 2;
     digests = /* @__PURE__ */ new WeakMap();
   }
 });
@@ -1116,7 +1263,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 },
@@ -1237,7 +1384,7 @@ var init_results = __esm({
       "instructions"
     ];
     envelope = (type, data, contract2) => ({
-      apiVersion: 1,
+      apiVersion: RESULT_SCHEMA_VERSION,
       type,
       identity: identityOf(contract2),
       data
@@ -1304,9 +1451,9 @@ var init_results = __esm({
         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(
@@ -1398,15 +1545,11 @@ var init_results = __esm({
             {
               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")),
@@ -1481,14 +1624,14 @@ var init_results = __esm({
       instructions: "instructions_data"
     };
     success = (type) => obj({
-      apiVersion: { const: 1 },
+      apiVersion: { const: RESULT_SCHEMA_VERSION },
       type: { const: type },
       identity: ref("identity"),
       data: ref(DATA[type])
     });
     failure = () => obj(
       {
-        apiVersion: { const: 1 },
+        apiVersion: { const: RESULT_SCHEMA_VERSION },
         error: str(),
         code: str({ pattern: "^ERR_[A-Z_]+$" }),
         suggestions: names(),
@@ -1589,11 +1732,11 @@ var init_results = __esm({
 
 // src/contract.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { dirname, join as join3 } from "path";
+import { dirname, join as join2 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function loadContract() {
   const here = dirname(fileURLToPath3(import.meta.url));
-  const candidates = [join3(here, "contract.json"), join3(here, "../generated/contract.json")];
+  const candidates = [join2(here, "contract.json"), join2(here, "../generated/contract.json")];
   const found = candidates.find((candidate) => existsSync2(candidate));
   if (found === void 0) {
     throw new Error(
@@ -1822,10 +1965,10 @@ var init_agent_block = __esm({
 
 // 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";
 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;
@@ -1834,36 +1977,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((path2) => {
-    const file = join4(cwd, path2);
+    const file = join3(cwd, path2);
     return {
       path: path2,
       version: existsSync3(file) ? blockVersion(readFileSync4(file, "utf8")) : void 0
     };
-  }).filter(({ version }) => version !== void 0);
-  const stale = written.find(({ version }) => version !== contract2.version);
+  }).filter(({ version: version2 }) => version2 !== void 0);
+  const stale = written.find(({ version: version2 }) => version2 !== contract2.version);
   if (written.length === 0)
     checks.push({
       id: "agent-instructions",
@@ -1884,39 +2027,32 @@ function doctor({
       status: "ok",
       message: `${written.map(({ path: path2 }) => path2).join(", ")} carries the OPERATOR block (${contract2.version}).`
     });
-  const install2 = `${INSTALL_TYPESCRIPT} (or your package manager's equivalent), then run oprt doctor again. Lookups work without it.`;
   let checkCode;
   if (parser.ready) {
-    const { version, resolved_from, source } = parser.resolution;
+    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;
@@ -1948,7 +2084,7 @@ var init_doctor = __esm({
       ".claude/CLAUDE.md",
       ".cursor/rules/operator.mdc"
     ];
-    minor = (version) => version.split(".").slice(0, 2).join(".");
+    minor = (version2) => version2.split(".").slice(0, 2).join(".");
   }
 });
 
@@ -2370,15 +2506,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:
@@ -2606,11 +2736,11 @@ __export(index_exports, {
   serve: () => serve
 });
 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 fileURLToPath4 } from "url";
 function loadRegistry() {
   const here = dirname5(fileURLToPath4(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(
@@ -2625,7 +2755,7 @@ function install(options, context = {}) {
     registry: context.registry ?? registry
   });
 }
-var registry, loaded, contract;
+var registry, loaded2, contract;
 var init_index = __esm({
   "src/index.ts"() {
     "use strict";
@@ -2646,7 +2776,7 @@ var init_index = __esm({
     init_installer();
     init_types();
     registry = loadRegistry();
-    contract = () => loaded ??= loadContract();
+    contract = () => loaded2 ??= loadContract();
   }
 });
 
@@ -2655,7 +2785,7 @@ init_esm_shims();
 init_args();
 init_results();
 init_types();
-var helpText = (version) => `oprt ${version} \u2014 OPERATOR source installer
+var helpText = (version2) => `oprt ${version2} \u2014 OPERATOR source installer
 
 Usage:
   oprt list [--json]
@@ -2683,7 +2813,7 @@ For coding agents (each takes --json):
 Exit codes: 0 success. check: 0 when every file read has no errors (no warnings either
 under --strict); limits it could not read are shown and do not fail the run. 1 when check
 finds an error, a file does not parse, or no .tsx or .jsx file was read; also for other
-failures (file conflicts, TypeScript missing). 2 for a usage error, an unknown name or a
+failures (file conflicts, a parser that cannot be loaded). 2 for a usage error, an unknown name or a
 path that does not exist.
 
 Names accept PascalCase or kebab-case. Default output: src/components/operator.
@@ -2716,13 +2846,13 @@ try {
 } catch (error) {
   const message = error instanceof Error ? error.message : String(error);
   if (process.argv.includes("--json")) {
-    let loaded2;
+    let loaded3;
     try {
-      loaded2 = (await Promise.resolve().then(() => (init_index(), index_exports))).contract();
+      loaded3 = (await Promise.resolve().then(() => (init_index(), index_exports))).contract();
     } catch {
-      loaded2 = void 0;
+      loaded3 = void 0;
     }
-    process.stdout.write(`${JSON.stringify(errorEnvelope(error, loaded2), null, 2)}
+    process.stdout.write(`${JSON.stringify(errorEnvelope(error, loaded3), null, 2)}
 `);
   } else process.stderr.write(`oprt: ${message}
 `);