@contentful/experience-design-system-cli 2.37.1-dev-build-25425992.0 → 2.37.1-dev-build-c5c89a0c.0

package/dist/app.js

@@ -821,6 +821,16 @@ var init_parse_map_token_prop_tool_calls = __esm({
 
 // packages/experience-design-system-backend-pipeline/dist/src/agents/services/run-agent.js
 import { spawn } from "node:child_process";
+function killProcessTree(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+  } catch {
+    try {
+      process.kill(pid, signal);
+    } catch {
+    }
+  }
+}
 async function runAgent(options) {
   const { agent, prompt, timeoutMs, model, onOutput, promptViaStdin, onDebugEvent } = options;
   const bedrock = options.bedrock ?? process.env.EDS_BEDROCK === "1";
@@ -837,10 +847,11 @@ async function runAgent(options) {
     promptLen: prompt.length,
     promptHead: prompt.slice(0, 500)
   });
-  return new Promise((resolve28) => {
+  return new Promise((resolve29) => {
     const bedrockEnv = bedrock ? BEDROCK_ENV_BY_AGENT[agent] : void 0;
     const child = spawn(binary, args, {
       stdio: ["pipe", "pipe", "pipe"],
+      detached: true,
       ...bedrockEnv ? { env: { ...process.env, ...bedrockEnv } } : {}
     });
     if (useStdin2 && child.stdin) {
@@ -852,50 +863,87 @@ async function runAgent(options) {
     } else {
       child.stdin?.end();
     }
-    let stdout = "";
-    let stderr = "";
+    const stdoutChunks = [];
+    const stderrChunks = [];
     let timedOut = false;
-    const timer = setTimeout(() => {
+    let settled = false;
+    const pid = child.pid;
+    const settle = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(softTimer);
+      clearTimeout(hardTimer);
+      onDebugEvent?.("run.end", {
+        agent,
+        model,
+        durationMs: Date.now() - startedAt,
+        exitCode: result.exitCode,
+        timedOut: result.timedOut,
+        stdoutLen: result.stdout.length,
+        stderrLen: result.stderr.length,
+        stderrTail: result.stderr.slice(-1e3)
+      });
+      resolve29(result);
+    };
+    const softTimer = setTimeout(() => {
       timedOut = true;
-      child.kill("SIGTERM");
+      if (pid)
+        killProcessTree(pid, "SIGTERM");
     }, timeoutMs);
+    const hardTimer = setTimeout(() => {
+      if (settled)
+        return;
+      if (pid)
+        killProcessTree(pid, "SIGKILL");
+      try {
+        child.stdout?.destroy();
+        child.stderr?.destroy();
+        child.stdin?.destroy();
+      } catch {
+      }
+      settle({
+        exitCode: 1,
+        stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf8"),
+        timedOut: true
+      });
+    }, timeoutMs + WATCHDOG_GRACE_MS);
     child.stdout?.on("data", (chunk) => {
-      const text = chunk.toString();
-      stdout += text;
-      onOutput?.(text);
+      stdoutChunks.push(chunk);
+      if (onOutput)
+        onOutput(chunk.toString("utf8"));
     });
     child.stderr?.on("data", (chunk) => {
-      stderr += chunk.toString();
+      stderrChunks.push(chunk);
+    });
+    child.on("error", (err) => {
+      settle({
+        exitCode: 1,
+        stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+        stderr: `${err instanceof Error ? err.message : String(err)}
+${Buffer.concat(stderrChunks).toString("utf8")}`,
+        timedOut
+      });
     });
     child.on("close", (code, signal) => {
-      clearTimeout(timer);
-      const result = {
+      settle({
         exitCode: signal ? 1 : code ?? 1,
-        stdout,
-        stderr,
+        stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf8"),
         timedOut
-      };
-      onDebugEvent?.("run.end", {
-        agent,
-        model,
-        durationMs: Date.now() - startedAt,
-        exitCode: result.exitCode,
-        signal,
-        timedOut,
-        stdoutLen: stdout.length,
-        stderrLen: stderr.length,
-        stderrTail: stderr.slice(-1e3)
       });
-      resolve28(result);
     });
   });
 }
+var WATCHDOG_GRACE_MS;
 var init_run_agent = __esm({
   "packages/experience-design-system-backend-pipeline/dist/src/agents/services/run-agent.js"() {
     "use strict";
     init_bedrock();
     init_build_agent_args();
     init_resolve_binary();
+    WATCHDOG_GRACE_MS = 10 * 1e3;
   }
 });
 
@@ -908,7 +956,7 @@ async function checkAgentAuth(agent) {
     return "not-found";
   if (agent !== "claude")
     return "ok";
-  return new Promise((resolve28) => {
+  return new Promise((resolve29) => {
     const child = spawn2(binary, ["auth", "status", "--json"], { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let done = false;
@@ -917,7 +965,7 @@ async function checkAgentAuth(agent) {
         return;
       done = true;
       child.kill("SIGTERM");
-      resolve28("unauthenticated");
+      resolve29("unauthenticated");
     }, 5e3);
     child.stdout?.on("data", (chunk) => {
       stdout += chunk.toString();
@@ -928,14 +976,14 @@ async function checkAgentAuth(agent) {
       done = true;
       clearTimeout(timer);
       if (code !== 0) {
-        resolve28("unauthenticated");
+        resolve29("unauthenticated");
         return;
       }
       try {
         const status = JSON.parse(stdout);
-        resolve28(status.loggedIn ? "ok" : "unauthenticated");
+        resolve29(status.loggedIn ? "ok" : "unauthenticated");
       } catch {
-        resolve28("unauthenticated");
+        resolve29("unauthenticated");
       }
     });
   });
@@ -945,9 +993,9 @@ async function binaryIsOnPath(binary) {
     const fs = await import("node:fs/promises");
     return fs.access(binary).then(() => true, () => false);
   }
-  return new Promise((resolve28) => {
+  return new Promise((resolve29) => {
     const child = spawn2(process.platform === "win32" ? "where" : "which", [binary], { stdio: "ignore" });
-    child.on("close", (code) => resolve28(code === 0));
+    child.on("close", (code) => resolve29(code === 0));
   });
 }
 var init_check_agent_auth = __esm({
@@ -1584,7 +1632,8 @@ var init_infer_fence_lang = __esm({
       sass: "scss",
       css: "css",
       json: "json",
-      json5: "json"
+      json5: "json",
+      html: "html"
     };
   }
 });
@@ -2083,22 +2132,22 @@ var init_cache_keys = __esm({
 
 // packages/experience-design-system-types/dist/src/config/index.js
 import { randomBytes as randomBytes4 } from "node:crypto";
-import { mkdir as mkdir6, readFile as readFile18, rename as rename2, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir6, readFile as readFile20, rename as rename2, writeFile as writeFile6 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname13, join as join16 } from "node:path";
+import { dirname as dirname14, join as join16 } from "node:path";
 function configRoot2() {
   return process.env["EDS_HOME"] || join16(homedir3(), ".contentful", "experience-design-system-cli");
 }
 async function readSettings2() {
   try {
-    return JSON.parse(await readFile18(configFilePath2(), "utf8"));
+    return JSON.parse(await readFile20(configFilePath2(), "utf8"));
   } catch {
     return {};
   }
 }
 async function writeSettings2(settings) {
   const path5 = configFilePath2();
-  await mkdir6(dirname13(path5), { recursive: true });
+  await mkdir6(dirname14(path5), { recursive: true });
   const tmp = `${path5}.${process.pid}.${randomBytes4(4).toString("hex")}.tmp`;
   await writeFile6(tmp, `${JSON.stringify(settings, null, 2)}
 `, { mode: 384 });
@@ -2142,7 +2191,7 @@ var init_debug_mode_store = __esm({
 
 // packages/experience-design-system-cli/src/tui/debug-prune.ts
 import { readdir as readdir2, rm, rmdir, stat as stat4 } from "node:fs/promises";
-import { dirname as dirname16, join as join23 } from "node:path";
+import { dirname as dirname17, join as join23 } from "node:path";
 async function logFilesIn(dir) {
   const entries = await readdir2(dir, { withFileTypes: true });
   const nested = await Promise.all(
@@ -2165,7 +2214,7 @@ async function removeEmptyFolders(from, stop) {
     }
     removed += 1;
     if (dir === stop) return removed;
-    dir = dirname16(dir);
+    dir = dirname17(dir);
   }
 }
 async function pruneExpiredLogs(base, retentionDays, now = Date.now()) {
@@ -2181,7 +2230,7 @@ async function pruneExpiredLogs(base, retentionDays, now = Date.now()) {
           if ((await stat4(file)).mtimeMs >= cutoff) continue;
           await rm(file);
           result.logs += 1;
-          result.folders += await removeEmptyFolders(dirname16(file), join23(contentfulDir, session));
+          result.folders += await removeEmptyFolders(dirname17(file), join23(contentfulDir, session));
         } catch {
         }
       }
@@ -2211,7 +2260,7 @@ __export(debug_store_exports, {
 });
 import { mkdir as mkdir9, writeFile as writeFile8 } from "node:fs/promises";
 import { existsSync as existsSync9, readdirSync as readdirSync4 } from "node:fs";
-import { join as join24, resolve as resolve26 } from "node:path";
+import { join as join24, resolve as resolve27 } from "node:path";
 function generateRunId() {
   const now = /* @__PURE__ */ new Date();
   const pad = (n) => String(n).padStart(2, "0");
@@ -2227,7 +2276,7 @@ function slugify(value) {
 async function readBaseDir() {
   try {
     const dir = (await readSettings2())["contentfulBaseDir"];
-    return typeof dir === "string" && dir !== "" ? resolve26(dir) : void 0;
+    return typeof dir === "string" && dir !== "" ? resolve27(dir) : void 0;
   } catch {
     return void 0;
   }
@@ -2256,7 +2305,7 @@ function currentSessionDir() {
 async function startDebugSessionIn(base, { replace = false } = {}) {
   try {
     if (!await isDebugModeEnabled()) return;
-    await mkdir9(join24(startSession(resolve26(base), { replace }), "debug"), { recursive: true });
+    await mkdir9(join24(startSession(resolve27(base), { replace }), "debug"), { recursive: true });
   } catch {
   }
 }
@@ -2270,7 +2319,7 @@ function nextImportRunDir(session) {
 }
 async function startImportRun(projectPath) {
   await startDebugSessionIn(projectPath);
-  if (!sessionDir) return join24(resolve26(projectPath), ".contentful");
+  if (!sessionDir) return join24(resolve27(projectPath), ".contentful");
   const dir = nextImportRunDir(sessionDir);
   await mkdir9(dir, { recursive: true });
   return dir;
@@ -11982,6 +12031,690 @@ function mergeSlots2(fromSnippetProps, fromTemplate) {
   return { slots: [...byName.values()], mixedWarning: mixed };
 }
 
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/extract-angular-components.js
+import { readFile as readFile8 } from "node:fs/promises";
+import { ModuleKind as ModuleKind2, Project as Project7, ScriptTarget as ScriptTarget2 } from "ts-morph";
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/find-component-decorator.js
+import { Node as Node10 } from "ts-morph";
+function resolveToObjectLiteral(expr, depth = 0) {
+  if (!expr || depth > 3)
+    return null;
+  if (Node10.isObjectLiteralExpression(expr))
+    return expr;
+  if (Node10.isIdentifier(expr)) {
+    const defs = expr.getDefinitions();
+    for (const def of defs) {
+      const node = def.getDeclarationNode();
+      if (node && Node10.isVariableDeclaration(node)) {
+        const init = node.getInitializer();
+        const resolved = resolveToObjectLiteral(init, depth + 1);
+        if (resolved)
+          return resolved;
+      }
+    }
+  }
+  return null;
+}
+function findComponentDecorator(cls) {
+  const decorator = cls.getDecorator("Component");
+  if (!decorator)
+    return null;
+  const [arg] = decorator.getArguments();
+  return resolveToObjectLiteral(arg);
+}
+function hasComponentDecorator(cls) {
+  return cls.getDecorator("Component") !== void 0;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/props/extract-decorator-input.js
+import { Node as Node12 } from "ts-morph";
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/props/resolve-prop-type.js
+import { Node as Node11 } from "ts-morph";
+function resolvePropType(typeNode) {
+  if (!typeNode) {
+    return { text: "any", allowedValues: null, isTemplateRef: false };
+  }
+  const text = typeNode.getText();
+  const members = extractStringLiteralUnion(typeNode);
+  const isTemplateRef = containsTemplateRef(typeNode);
+  return {
+    text,
+    allowedValues: members.length > 0 ? members : null,
+    isTemplateRef
+  };
+}
+function extractStringLiteralUnion(typeNode) {
+  if (Node11.isLiteralTypeNode(typeNode)) {
+    const lit = typeNode.getLiteral();
+    if (Node11.isStringLiteral(lit) || Node11.isNoSubstitutionTemplateLiteral(lit)) {
+      return [lit.getLiteralText()];
+    }
+    return [];
+  }
+  if (Node11.isUnionTypeNode(typeNode)) {
+    const out = [];
+    for (const member of typeNode.getTypeNodes()) {
+      const sub = extractStringLiteralUnion(member);
+      if (sub.length === 0 && !isNullOrUndefinedLiteral(member)) {
+        return [];
+      }
+      out.push(...sub);
+    }
+    return out;
+  }
+  return [];
+}
+function isNullOrUndefinedLiteral(typeNode) {
+  if (Node11.isLiteralTypeNode(typeNode)) {
+    const lit = typeNode.getLiteral();
+    if (Node11.isNullLiteral(lit))
+      return true;
+  }
+  const t = typeNode.getText();
+  return t === "null" || t === "undefined";
+}
+function containsTemplateRef(typeNode) {
+  const text = typeNode.getText();
+  return /\bTemplateRef\b/.test(text);
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/props/extract-decorator-input.js
+function extractDecoratorInput(field) {
+  const decorator = field.getDecorator("Input");
+  if (!decorator)
+    return null;
+  const fieldName = field.getName();
+  const args = decorator.getArguments();
+  let alias = null;
+  let required = false;
+  let transformIsBoolean = false;
+  let transformIsNumber = false;
+  if (args.length === 1) {
+    const arg = args[0];
+    if (Node12.isStringLiteral(arg) || Node12.isNoSubstitutionTemplateLiteral(arg)) {
+      alias = arg.getLiteralText();
+    } else if (Node12.isObjectLiteralExpression(arg)) {
+      const aliasProp = arg.getProperty("alias");
+      if (aliasProp && Node12.isPropertyAssignment(aliasProp)) {
+        const init = aliasProp.getInitializer();
+        if (init && (Node12.isStringLiteral(init) || Node12.isNoSubstitutionTemplateLiteral(init))) {
+          alias = init.getLiteralText();
+        }
+      }
+      const requiredProp = arg.getProperty("required");
+      if (requiredProp && Node12.isPropertyAssignment(requiredProp)) {
+        const init = requiredProp.getInitializer();
+        if (init?.getText() === "true")
+          required = true;
+      }
+      const transformProp = arg.getProperty("transform");
+      if (transformProp && Node12.isPropertyAssignment(transformProp)) {
+        const transformText = transformProp.getInitializer()?.getText() ?? "";
+        if (/\bbooleanAttribute\b/.test(transformText))
+          transformIsBoolean = true;
+        if (/\bnumberAttribute\b/.test(transformText))
+          transformIsNumber = true;
+      }
+    }
+  }
+  let typeNode;
+  let defaultValue;
+  if (Node12.isSetAccessorDeclaration(field)) {
+    const param = field.getParameters()[0];
+    typeNode = param?.getTypeNode();
+  } else if (Node12.isGetAccessorDeclaration(field)) {
+    const parent = field.getParent();
+    const companionSetter = parent && Node12.isClassDeclaration(parent) ? parent.getSetAccessor(fieldName) : void 0;
+    if (companionSetter) {
+      typeNode = companionSetter.getParameters()[0]?.getTypeNode();
+    }
+    if (!typeNode)
+      typeNode = field.getReturnTypeNode();
+  } else {
+    typeNode = field.getTypeNode();
+    const initializer = field.getInitializer();
+    if (initializer)
+      defaultValue = initializer.getText();
+  }
+  const resolved = resolvePropType(typeNode);
+  const typeText = transformIsBoolean ? "boolean" : transformIsNumber ? "number" : resolved.text;
+  const name = alias ?? fieldName;
+  const prop = {
+    name,
+    type: typeText,
+    required,
+    sourceStartLine: field.getStartLineNumber(),
+    sourceEndLine: field.getEndLineNumber()
+  };
+  if (defaultValue !== void 0)
+    prop.defaultValue = defaultValue;
+  if (resolved.allowedValues && !transformIsBoolean && !transformIsNumber) {
+    prop.allowedValues = resolved.allowedValues;
+  }
+  return prop;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/props/extract-signal-input.js
+import { Node as Node13 } from "ts-morph";
+function extractSignalInput(field) {
+  const init = field.getInitializer();
+  if (!init || !Node13.isCallExpression(init))
+    return null;
+  const callee = init.getExpression();
+  let required = false;
+  if (Node13.isIdentifier(callee)) {
+    if (callee.getText() !== "input")
+      return null;
+  } else if (Node13.isPropertyAccessExpression(callee)) {
+    const left = callee.getExpression();
+    const right = callee.getName();
+    if (!Node13.isIdentifier(left) || left.getText() !== "input" || right !== "required")
+      return null;
+    required = true;
+  } else {
+    return null;
+  }
+  const fieldName = field.getName();
+  const args = init.getArguments();
+  let defaultValue;
+  let configArg;
+  if (required) {
+    configArg = args[0];
+  } else {
+    const first = args[0];
+    if (first) {
+      defaultValue = first.getText();
+      configArg = args[1];
+    }
+  }
+  let alias = null;
+  let transformIsBoolean = false;
+  let transformIsNumber = false;
+  if (configArg && Node13.isObjectLiteralExpression(configArg)) {
+    const aliasProp = configArg.getProperty("alias");
+    if (aliasProp && Node13.isPropertyAssignment(aliasProp)) {
+      const aliasInit = aliasProp.getInitializer();
+      if (aliasInit && (Node13.isStringLiteral(aliasInit) || Node13.isNoSubstitutionTemplateLiteral(aliasInit))) {
+        alias = aliasInit.getLiteralText();
+      }
+    }
+    const transformProp = configArg.getProperty("transform");
+    if (transformProp && Node13.isPropertyAssignment(transformProp)) {
+      const transformText = transformProp.getInitializer()?.getText() ?? "";
+      if (/\bbooleanAttribute\b/.test(transformText))
+        transformIsBoolean = true;
+      if (/\bnumberAttribute\b/.test(transformText))
+        transformIsNumber = true;
+    }
+  }
+  const typeArg = init.getTypeArguments()[0];
+  const resolved = resolvePropType(typeArg);
+  const typeText = transformIsBoolean ? "boolean" : transformIsNumber ? "number" : resolved.text;
+  const name = alias ?? fieldName;
+  const prop = {
+    name,
+    type: typeText,
+    required,
+    sourceStartLine: field.getStartLineNumber(),
+    sourceEndLine: field.getEndLineNumber()
+  };
+  if (defaultValue !== void 0)
+    prop.defaultValue = defaultValue;
+  if (resolved.allowedValues && !transformIsBoolean && !transformIsNumber) {
+    prop.allowedValues = resolved.allowedValues;
+  }
+  return prop;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/props/parse-inputs-array-entry.js
+function parseInputsArrayEntry(entry) {
+  const trimmed = entry.trim();
+  if (!trimmed)
+    return null;
+  const parts = trimmed.split(":");
+  if (parts.length === 1) {
+    return { fieldName: parts[0].trim(), alias: null };
+  }
+  if (parts.length === 2) {
+    const field = parts[0].trim();
+    const alias = parts[1].trim();
+    if (!field || !alias)
+      return null;
+    return { fieldName: field, alias };
+  }
+  return null;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/props/extract-props.js
+var MAX_BASE_CHAIN = 10;
+function collectClassChain(cls) {
+  const chain = [cls];
+  const seen = /* @__PURE__ */ new Set([cls]);
+  let current = cls;
+  for (let i = 0; i < MAX_BASE_CHAIN; i++) {
+    let base;
+    try {
+      base = current.getBaseClass();
+    } catch {
+      break;
+    }
+    if (!base || seen.has(base))
+      break;
+    chain.push(base);
+    seen.add(base);
+    current = base;
+  }
+  return chain;
+}
+function extractProps2(cls, meta) {
+  const byName = /* @__PURE__ */ new Map();
+  const chain = collectClassChain(cls);
+  for (const klass of chain) {
+    for (const field of klass.getProperties()) {
+      const prop = extractDecoratorInput(field);
+      if (prop && !byName.has(prop.name))
+        byName.set(prop.name, prop);
+    }
+    for (const setter of klass.getSetAccessors()) {
+      const prop = extractDecoratorInput(setter);
+      if (prop && !byName.has(prop.name))
+        byName.set(prop.name, prop);
+    }
+    for (const getter of klass.getGetAccessors()) {
+      const prop = extractDecoratorInput(getter);
+      if (prop && !byName.has(prop.name))
+        byName.set(prop.name, prop);
+    }
+    for (const field of klass.getProperties()) {
+      const prop = extractSignalInput(field);
+      if (prop && !byName.has(prop.name))
+        byName.set(prop.name, prop);
+    }
+  }
+  for (const entry of meta.inputsArray) {
+    const parsed = parseInputsArrayEntry(entry);
+    if (!parsed)
+      continue;
+    const name = parsed.alias ?? parsed.fieldName;
+    if (byName.has(name))
+      continue;
+    byName.set(name, { name, type: "any", required: false });
+  }
+  return [...byName.values()];
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/read-component-metadata.js
+import { dirname as dirname10, resolve as resolve12 } from "node:path";
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/resolution/normalize-component-name.js
+var SUFFIXES = ["Component", "Directive"];
+function normalizeComponentName2(className) {
+  for (const suffix of SUFFIXES) {
+    if (className.endsWith(suffix) && className.length > suffix.length) {
+      return className.slice(0, -suffix.length);
+    }
+  }
+  return className;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/read-decorator-string.js
+import { Node as Node14 } from "ts-morph";
+function readDecoratorString(obj, propName) {
+  const prop = obj.getProperty(propName);
+  if (!prop || !Node14.isPropertyAssignment(prop))
+    return null;
+  const init = prop.getInitializer();
+  if (!init)
+    return null;
+  if (Node14.isStringLiteral(init) || Node14.isNoSubstitutionTemplateLiteral(init)) {
+    return init.getLiteralText();
+  }
+  return null;
+}
+function readDecoratorStringArray(obj, propName) {
+  const prop = obj.getProperty(propName);
+  if (!prop || !Node14.isPropertyAssignment(prop))
+    return [];
+  const init = prop.getInitializer();
+  if (!init || !Node14.isArrayLiteralExpression(init))
+    return [];
+  const out = [];
+  for (const el of init.getElements()) {
+    if (Node14.isStringLiteral(el) || Node14.isNoSubstitutionTemplateLiteral(el)) {
+      out.push(el.getLiteralText());
+    }
+  }
+  return out;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/read-component-metadata.js
+function readComponentMetadata(cls, sourceFilePath) {
+  const obj = findComponentDecorator(cls);
+  if (!obj)
+    return null;
+  const className = cls.getName();
+  if (!className)
+    return null;
+  const rawSelector = readDecoratorString(obj, "selector");
+  const inlineTemplate = readDecoratorString(obj, "template");
+  const templateUrlRel = readDecoratorString(obj, "templateUrl");
+  const inputsArray = readDecoratorStringArray(obj, "inputs");
+  const templatePath = templateUrlRel ? resolve12(dirname10(sourceFilePath), templateUrlRel) : null;
+  const decorator = cls.getDecorator("Component");
+  const decoratorLine = decorator?.getStartLineNumber() ?? cls.getStartLineNumber();
+  return {
+    className,
+    normalizedName: normalizeComponentName2(className),
+    rawSelector,
+    inlineTemplate,
+    templatePath,
+    inputsArray,
+    decoratorLine
+  };
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/template/parse-ng-content-elements.js
+function parseNgContentElements(templateHtml) {
+  const out = [];
+  const tagRe = /<ng-content\b([^>]*?)\/?>/gi;
+  for (const match2 of templateHtml.matchAll(tagRe)) {
+    const attrs = match2[1] ?? "";
+    const selectMatch = attrs.match(/\bselect\s*=\s*(?:"([^"]*)"|'([^']*)')/);
+    const rawSelect = selectMatch ? selectMatch[1] ?? selectMatch[2] ?? null : null;
+    const sourceLine = countLines(templateHtml, match2.index ?? 0);
+    out.push({ rawSelect, sourceLine });
+  }
+  return out;
+}
+function countLines(text, offset) {
+  let line = 1;
+  for (let i = 0; i < offset && i < text.length; i++) {
+    if (text.charCodeAt(i) === 10)
+      line++;
+  }
+  return line;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/template/resolve-template-source.js
+import { readFile as readFile7 } from "node:fs/promises";
+async function resolveTemplateSource(meta) {
+  if (meta.inlineTemplate !== null)
+    return meta.inlineTemplate;
+  if (meta.templatePath === null)
+    return null;
+  try {
+    return await readFile7(meta.templatePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/resolution/strip-library-prefix.js
+var KNOWN_PREFIXES = ["Mat", "Cdk", "Nz", "Cds", "Ibm", "Clr", "Hlm", "Brn", "Tui", "Nb", "Fd", "P", "Ng"];
+function stripLibraryPrefix(name) {
+  for (const prefix of KNOWN_PREFIXES) {
+    if (name.startsWith(prefix) && name.length > prefix.length) {
+      const rest = name.slice(prefix.length);
+      if (rest[0] && rest[0] === rest[0].toUpperCase()) {
+        return rest;
+      }
+    }
+  }
+  return name;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/slots/derive-slot-name.js
+function deriveSlotName(rawSelect, parentNormalizedName) {
+  if (!rawSelect || rawSelect.trim() === "")
+    return "children";
+  if (rawSelect.includes(",")) {
+    const first = rawSelect.split(",")[0].trim();
+    return deriveSingleSelectorName(first, parentNormalizedName);
+  }
+  return deriveSingleSelectorName(rawSelect.trim(), parentNormalizedName);
+}
+function deriveSingleSelectorName(sel, parentNormalizedName) {
+  const slotAttrMatch = sel.match(/^\[\s*slot\s*=\s*['"]?([^'"\]]+)['"]?\s*\]$/);
+  if (slotAttrMatch)
+    return slotAttrMatch[1].trim();
+  if (sel.startsWith(".")) {
+    const last = sel.slice(1).split("-").pop() ?? sel.slice(1);
+    return kebabToCamel2(last);
+  }
+  const attrMatch = sel.match(/^\[([^=\]]+)\]$/);
+  if (attrMatch) {
+    const attr = attrMatch[1].trim();
+    const stripped = tryStripSubComponentOrLibraryPrefix(attr, parentNormalizedName);
+    return stripped || kebabToCamel2(attr);
+  }
+  const elMatch = sel.match(/^([a-zA-Z][a-zA-Z0-9-]*)/);
+  if (elMatch) {
+    const tag = elMatch[1];
+    const stripped = tryStripSubComponentOrLibraryPrefix(tag, parentNormalizedName);
+    return stripped || kebabToCamel2(tag);
+  }
+  return sel.replace(/\s+/g, "");
+}
+function tryStripSubComponentOrLibraryPrefix(ident, parentNormalizedName) {
+  const parentKebab = pascalToKebab(parentNormalizedName);
+  if (parentKebab && ident.startsWith(`${parentKebab}-`)) {
+    return kebabToCamel2(ident.slice(parentKebab.length + 1));
+  }
+  const asPascal = kebabToPascal2(ident);
+  const stripped = stripLibraryPrefix(asPascal);
+  if (stripped !== asPascal) {
+    return stripped.charAt(0).toLowerCase() + stripped.slice(1);
+  }
+  return null;
+}
+function kebabToCamel2(s) {
+  return s.replace(/-([a-z])/g, (_, c2) => c2.toUpperCase());
+}
+function kebabToPascal2(s) {
+  const camel = kebabToCamel2(s);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function pascalToKebab(s) {
+  return s.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/slots/extract-content-child-queries.js
+import { Node as Node15 } from "ts-morph";
+function extractContentChildQueries(cls) {
+  const out = [];
+  for (const field of cls.getProperties()) {
+    const fieldName = field.getName();
+    const init = field.getInitializer();
+    if (init && Node15.isCallExpression(init)) {
+      const callee = init.getExpression();
+      if (Node15.isIdentifier(callee)) {
+        const name = callee.getText();
+        if (name === "contentChild" || name === "contentChildren") {
+          const first = init.getArguments()[0];
+          const allowed = resolveClassIdentifierArg(first);
+          out.push(buildSlot(fieldName, allowed));
+          continue;
+        }
+      }
+    }
+    for (const decName of ["ContentChild", "ContentChildren"]) {
+      const dec = field.getDecorator(decName);
+      if (dec) {
+        const first = dec.getArguments()[0];
+        const allowed = resolveClassIdentifierArg(first);
+        out.push(buildSlot(fieldName, allowed));
+        break;
+      }
+    }
+  }
+  return out;
+}
+function resolveClassIdentifierArg(arg) {
+  if (!arg)
+    return [];
+  if (Node15.isStringLiteral(arg) || Node15.isNoSubstitutionTemplateLiteral(arg))
+    return [];
+  if (Node15.isIdentifier(arg))
+    return [arg.getText()];
+  return [];
+}
+function buildSlot(name, allowed) {
+  const slot = {
+    name,
+    isDefault: false
+  };
+  if (allowed.length > 0)
+    slot.allowedComponents = allowed;
+  return slot;
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/slots/extract-template-ref-slots.js
+function extractTemplateRefSlots(props) {
+  const nextProps = [];
+  const slots = [];
+  for (const prop of props) {
+    const type = prop.type;
+    const hasTemplateRef = /\bTemplateRef\b/.test(type);
+    if (!hasTemplateRef) {
+      nextProps.push(prop);
+      continue;
+    }
+    const isPureTemplateRef = /^\s*TemplateRef<[^>]*>\s*(\|\s*(null|undefined)\s*)*$/.test(type);
+    if (!isPureTemplateRef) {
+      nextProps.push(prop);
+    }
+    slots.push({ name: prop.name, isDefault: false });
+  }
+  return { props: nextProps, slots };
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/slots/extract-slots.js
+async function extractSlots3(cls, meta, props) {
+  const byName = /* @__PURE__ */ new Map();
+  const template = await resolveTemplateSource(meta);
+  if (template) {
+    for (const el of parseNgContentElements(template)) {
+      const name = deriveSlotName(el.rawSelect, meta.normalizedName);
+      if (byName.has(name))
+        continue;
+      byName.set(name, {
+        name,
+        isDefault: el.rawSelect === null
+      });
+    }
+  }
+  for (const slot of extractContentChildQueries(cls)) {
+    if (!byName.has(slot.name))
+      byName.set(slot.name, slot);
+  }
+  const split = extractTemplateRefSlots(props);
+  for (const slot of split.slots) {
+    if (!byName.has(slot.name))
+      byName.set(slot.name, slot);
+  }
+  return { props: split.props, slots: [...byName.values()] };
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/extract-angular-components.js
+async function extractAngularComponents(filePaths, onProgress, _opts) {
+  const components = [];
+  const warnings = [];
+  let filesProcessed = 0;
+  const project = new Project7({
+    useInMemoryFileSystem: false,
+    skipAddingFilesFromTsConfig: true,
+    compilerOptions: {
+      target: ScriptTarget2.ES2022,
+      module: ModuleKind2.ESNext,
+      experimentalDecorators: true,
+      emitDecoratorMetadata: false,
+      allowJs: false
+    }
+  });
+  for (const filePath of filePaths) {
+    try {
+      const source = await readFile8(filePath, "utf8");
+      const sourceFile = project.createSourceFile(filePath, source, { overwrite: true });
+      for (const cls of sourceFile.getClasses()) {
+        if (!hasComponentDecorator(cls))
+          continue;
+        if (!findComponentDecorator(cls)) {
+          warnings.push(`${filePath}: ${cls.getName() ?? "<anonymous>"} has @Component with a non-literal argument; skipped.`);
+          continue;
+        }
+        const meta = readComponentMetadata(cls, filePath);
+        if (!meta)
+          continue;
+        const propsOnly = extractProps2(cls, meta);
+        const { props, slots } = await extractSlots3(cls, meta, propsOnly);
+        const partial = {
+          name: meta.className,
+          source: filePath,
+          framework: "angular",
+          props,
+          slots: normalizeSlots(slots),
+          sourcePath: filePath
+        };
+        const score = computeExtractionScore(partial);
+        partial.extractionConfidence = score.confidence;
+        partial.reviewReasons = score.reasons;
+        partial.needsReview = deriveNeedsReview(score.confidence);
+        components.push(partial);
+      }
+      sourceFile.forget();
+    } catch (err) {
+      warnings.push(`${filePath}: Angular extractor failed \u2014 ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      filesProcessed++;
+      if (onProgress)
+        onProgress({ filesProcessed, componentsFound: components.length });
+    }
+  }
+  return {
+    components: components.sort((a, b) => a.name.localeCompare(b.name)),
+    warnings
+  };
+}
+function normalizeSlots(slots) {
+  let fallbackIndex = 0;
+  return slots.map((slot) => {
+    if (slot.name.trim())
+      return slot;
+    const name = fallbackIndex === 0 ? "children" : `slot_${fallbackIndex}`;
+    fallbackIndex++;
+    return { ...slot, name };
+  });
+}
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/is-angular-source-file.js
+import { openSync, readSync, closeSync, statSync as statSync4 } from "node:fs";
+var HEAD_BYTES = 32 * 1024;
+var buffer = Buffer.alloc(HEAD_BYTES);
+function isAngularSourceFile(filePath) {
+  if (!/\.[cm]?ts$/.test(filePath))
+    return false;
+  if (filePath.endsWith(".d.ts"))
+    return false;
+  try {
+    const stats = statSync4(filePath);
+    const toRead = Math.min(HEAD_BYTES, stats.size);
+    if (toRead === 0)
+      return false;
+    const fd = openSync(filePath, "r");
+    try {
+      const bytesRead = readSync(fd, buffer, 0, toRead, 0);
+      const head = buffer.subarray(0, bytesRead).toString("utf8");
+      return head.includes("@angular/core");
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return false;
+  }
+}
+
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/services/run-extraction-service.js
 var extractors = [
   {
@@ -12009,6 +12742,13 @@ var extractors = [
     fileFilter: (f) => f.endsWith(".astro"),
     extract: extractAstroComponents
   },
+  {
+    // Must run BEFORE web-components (both claim bare .ts). The sniff reads
+    // the file head looking for `@angular/core` so we only claim real Angular files.
+    name: "angular",
+    fileFilter: (f) => isAngularSourceFile(f),
+    extract: extractAngularComponents
+  },
   {
     name: "web-components",
     fileFilter: (f) => /\.[jt]s$/.test(f) && !/\.[jt]sx$/.test(f) && !f.endsWith(".d.ts"),
@@ -12484,16 +13224,16 @@ function applyCompositionEdges(components, edges) {
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/composition/src/helpers/prompt/prompt-loader.js
 import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
-import { dirname as dirname10, join as join10, resolve as resolve12 } from "node:path";
+import { dirname as dirname11, join as join10, resolve as resolve13 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolvePromptPath(fileName) {
-  const thisDir = dirname10(fileURLToPath3(import.meta.url));
+  const thisDir = dirname11(fileURLToPath3(import.meta.url));
   let dir = thisDir;
   for (; ; ) {
     const candidate = join10(dir, "prompts");
     if (existsSync7(candidate))
       return join10(candidate, fileName);
-    const parent = resolve12(dir, "..");
+    const parent = resolve13(dir, "..");
     if (parent === dir) {
       throw new Error(`prompt file missing from package installation (could not locate prompts/ directory from: ${thisDir})`);
     }
@@ -12573,14 +13313,31 @@ ${f.content}`).join("\n\n");
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/composition/src/constants/candidate-files.js
-var CANDIDATE_NAME_PATTERNS = [/mapping/i, /meta/i, /registry/i, /schema/i, /composition/i];
+var CANDIDATE_NAME_PATTERNS = [
+  /mapping/i,
+  /meta/i,
+  /registry/i,
+  /schema/i,
+  /composition/i,
+  /\.module\.ts$/i,
+  /\.component\.ts$/i,
+  /public[-_]api\.ts$/i,
+  /^index\.ts$/i
+];
 var CANDIDATE_CONTENT_MARKERS = [
   "requiredParent",
   "withParentType",
   "allowedTagNames",
   "createContext",
   "MappingContext",
-  "allowedComponents"
+  "allowedComponents",
+  "TemplateRef",
+  "NG_VALUE_ACCESSOR",
+  "ContentChild",
+  "contentChild",
+  "ng-content",
+  "@NgModule",
+  "standalone: true"
 ];
 var PROMPT_CANDIDATE_TOKEN_BUDGET = 8e4;
 
@@ -12641,8 +13398,8 @@ ${fileDigest}`);
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/composition/src/helpers/edges/manifest-doc-evidence.js
-import { dirname as dirname11 } from "node:path";
-function kebabToPascal2(name) {
+import { dirname as dirname12 } from "node:path";
+function kebabToPascal3(name) {
   return name.split("-").filter(Boolean).map((seg) => seg.charAt(0).toUpperCase() + seg.slice(1)).join("");
 }
 function collectManifestEdges(files, componentNames) {
@@ -12664,7 +13421,7 @@ function collectManifestEdges(files, componentNames) {
     const rawParentName = typeof component === "object" && component !== null && typeof component.name === "string" ? component.name : void 0;
     if (!rawParentName)
       continue;
-    const parent = kebabToPascal2(rawParentName);
+    const parent = kebabToPascal3(rawParentName);
     if (!componentNames.has(parent))
       continue;
     const variantsMeta = root.variantsMeta;
@@ -12684,7 +13441,7 @@ function collectManifestEdges(files, componentNames) {
         const rawChildName = value.name;
         if (typeof rawChildName !== "string")
           continue;
-        const child = kebabToPascal2(rawChildName);
+        const child = kebabToPascal3(rawChildName);
         if (!componentNames.has(child) || child === parent)
           continue;
         const key = `${parent}::${child}`;
@@ -12705,8 +13462,8 @@ function collectAgentsDocEdges(files, components, componentNames) {
   for (const file of files) {
     if (!file.path.endsWith("AGENTS.md"))
       continue;
-    const docDir = dirname11(file.path);
-    const parent = components.find((c2) => c2.sourcePath && dirname11(c2.sourcePath) === docDir)?.name;
+    const docDir = dirname12(file.path);
+    const parent = components.find((c2) => c2.sourcePath && dirname12(c2.sourcePath) === docDir)?.name;
     if (!parent || !componentNames.has(parent))
       continue;
     for (const line of file.content.split("\n")) {
@@ -12715,7 +13472,7 @@ function collectAgentsDocEdges(files, components, componentNames) {
         continue;
       for (const match2 of line.matchAll(BOLD_BACKTICK)) {
         const raw = match2[1];
-        const candidate = componentNames.has(raw) ? raw : kebabToPascal2(raw);
+        const candidate = componentNames.has(raw) ? raw : kebabToPascal3(raw);
         if (!componentNames.has(candidate) || candidate === parent)
           continue;
         const key = `${parent}::${candidate}`;
@@ -13031,7 +13788,7 @@ function validateExtractedComponents(components) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/helpers/load-review-input.js
-import { resolve as resolve14 } from "node:path";
+import { resolve as resolve15 } from "node:path";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/helpers/create-component-id.js
 import { createHash as createHash7 } from "node:crypto";
@@ -13042,7 +13799,7 @@ function createComponentId(name, resolvedSourcePath) {
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/helpers/resolve-component-source-path.js
 import { access } from "node:fs/promises";
-import { isAbsolute, relative, resolve as resolve13 } from "node:path";
+import { isAbsolute, relative, resolve as resolve14 } from "node:path";
 async function resolveComponentSourcePath(source, reviewRoot) {
   if (isAbsolute(source)) {
     try {
@@ -13052,7 +13809,7 @@ async function resolveComponentSourcePath(source, reviewRoot) {
       throw new Error(`Unable to access component source at ${source}`);
     }
   }
-  const candidate = resolve13(reviewRoot, source);
+  const candidate = resolve14(reviewRoot, source);
   const relativeToRoot = relative(reviewRoot, candidate);
   if (relativeToRoot.startsWith("..") || relativeToRoot === ".." || isAbsolute(relativeToRoot)) {
     throw new Error(`Resolved component source is outside the review root: ${source}. Pass --project-root <path> to set the correct base.`);
@@ -13067,7 +13824,7 @@ async function resolveComponentSourcePath(source, reviewRoot) {
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/helpers/load-review-input.js
 async function loadReviewInput(components, options = {}) {
-  const reviewRoot = resolve14(options.reviewRoot ?? process.cwd());
+  const reviewRoot = resolve15(options.reviewRoot ?? process.cwd());
   const records = await Promise.all(components.map(async (component) => {
     let resolvedSourcePath;
     try {
@@ -13102,19 +13859,19 @@ async function loadAndValidateForReview(sessionId, projectRoot) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/selection/src/controller/review/merge-preview-validation-errors-into-review-session.js
-import { access as access3, readFile as readFile8 } from "node:fs/promises";
+import { access as access3, readFile as readFile10 } from "node:fs/promises";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/ensure-review-session.js
-import { access as access2, mkdir, readFile as readFile7, writeFile } from "node:fs/promises";
+import { access as access2, mkdir, readFile as readFile9, writeFile } from "node:fs/promises";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/review-session-paths.js
-import { resolve as resolve15 } from "node:path";
+import { resolve as resolve16 } from "node:path";
 async function getRefineSessionPaths(sessionId, artifactsRoot) {
-  const sessionDir2 = resolve15(artifactsRoot, sessionId);
+  const sessionDir2 = resolve16(artifactsRoot, sessionId);
   return {
     sessionDir: sessionDir2,
-    eventsPath: resolve15(sessionDir2, "events.jsonl"),
-    statePath: resolve15(sessionDir2, "current-review-state.json")
+    eventsPath: resolve16(sessionDir2, "events.jsonl"),
+    statePath: resolve16(sessionDir2, "current-review-state.json")
   };
 }
 
@@ -13124,7 +13881,7 @@ async function ensureRefineSession(sessionId, artifactsRoot, initialSnapshot) {
   await mkdir(paths.sessionDir, { recursive: true });
   try {
     await access2(paths.statePath);
-    const savedState = await readFile7(paths.statePath, "utf8");
+    const savedState = await readFile9(paths.statePath, "utf8");
     return JSON.parse(savedState);
   } catch {
     await writeFile(paths.statePath, JSON.stringify(initialSnapshot, null, 2), "utf8");
@@ -13134,12 +13891,12 @@ async function ensureRefineSession(sessionId, artifactsRoot, initialSnapshot) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/review-artifacts-root.js
-import { resolve as resolve16 } from "node:path";
+import { resolve as resolve17 } from "node:path";
 function getRefineArtifactsRoot() {
   if (process.env["EDS_REVIEW_ARTIFACTS_DIR"]) {
-    return resolve16(process.env["EDS_REVIEW_ARTIFACTS_DIR"]);
+    return resolve17(process.env["EDS_REVIEW_ARTIFACTS_DIR"]);
   }
-  return resolve16(configRoot(), "reviews");
+  return resolve17(configRoot(), "reviews");
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/save-review-state.js
@@ -13155,7 +13912,7 @@ async function mergePreviewValidationErrorsIntoReviewSession(sessionId, errors,
   let snapshot;
   try {
     await access3(paths.statePath);
-    snapshot = JSON.parse(await readFile8(paths.statePath, "utf8"));
+    snapshot = JSON.parse(await readFile10(paths.statePath, "utf8"));
   } catch {
     snapshot = await loadAndValidateForReview(sessionId, void 0);
     snapshot = await ensureRefineSession(sessionId, artifactsRoot, snapshot);
@@ -13193,7 +13950,7 @@ async function mergePreviewValidationErrorsIntoReviewSession(sessionId, errors,
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/selection/src/controller/review/reject-components-by-name.js
-import { readFile as readFile9 } from "node:fs/promises";
+import { readFile as readFile11 } from "node:fs/promises";
 async function rejectComponentsByName(sessionId, names, opts = {}) {
   if (names.length === 0)
     return;
@@ -13209,7 +13966,7 @@ async function rejectComponentsByName(sessionId, names, opts = {}) {
   const nameSet = new Set(names);
   let snapshot;
   try {
-    snapshot = JSON.parse(await readFile9(paths.statePath, "utf8"));
+    snapshot = JSON.parse(await readFile11(paths.statePath, "utf8"));
   } catch {
     return;
   }
@@ -13218,7 +13975,7 @@ async function rejectComponentsByName(sessionId, names, opts = {}) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/helpers/collect-files/collect-files.js
-import { statSync as statSync4 } from "node:fs";
+import { statSync as statSync5 } from "node:fs";
 import path4 from "node:path";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/helpers/collect-files/build-scan-warnings.js
@@ -13273,7 +14030,9 @@ var EXCLUDED_SUFFIXES = [
   ".spec.ts",
   ".spec.tsx",
   ".test.ts",
-  ".test.tsx"
+  ".test.tsx",
+  ".harness.ts",
+  ".harness.tsx"
 ];
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
   ".changeset",
@@ -13291,9 +14050,12 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "dist",
   "example",
   "examples",
+  "harness",
+  "harnesses",
   "node_modules",
   "out",
-  "storybook-static"
+  "storybook-static",
+  "testing"
 ]);
 var DENYLISTED_EXACT_FILE_NAMES = /* @__PURE__ */ new Set([
   "package.json",
@@ -13405,7 +14167,7 @@ function collectFiles(root, options = {}) {
   const resolved = path4.resolve(root);
   let stat5;
   try {
-    stat5 = statSync4(resolved);
+    stat5 = statSync5(resolved);
   } catch (err) {
     return { ok: false, failure: classifyStatError(err.code), rootPath: resolved };
   }
@@ -13461,7 +14223,7 @@ function generateUlid(now = Date.now()) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/repositories/read-runs-file.js
-import { readFile as readFile10 } from "node:fs/promises";
+import { readFile as readFile12 } from "node:fs/promises";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/helpers/migrate-record.js
 function migrateRecord(rec) {
@@ -13480,7 +14242,7 @@ var READABLE_VERSIONS = /* @__PURE__ */ new Set([1, 2, 3]);
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/repositories/read-runs-file.js
 async function readRunsFileMaybe() {
   try {
-    const raw = await readFile10(runsFilePath(), "utf8");
+    const raw = await readFile12(runsFilePath(), "utf8");
     const parsed = JSON.parse(raw);
     if (!READABLE_VERSIONS.has(parsed.version)) {
       throw new Error(`runs.json version mismatch: file is v${parsed.version}, this CLI expects v${RUNS_FILE_VERSION} (also reads: ${[...READABLE_VERSIONS].join(", ")}). Back up and remove the file to start fresh.`);
@@ -13497,9 +14259,9 @@ async function readRunsFileMaybe() {
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/repositories/write-runs-file.js
 import { mkdir as mkdir2, rename, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname12 } from "node:path";
+import { dirname as dirname13 } from "node:path";
 async function writeRunsFileAtomic(file) {
-  await mkdir2(dirname12(runsFilePath()), { recursive: true });
+  await mkdir2(dirname13(runsFilePath()), { recursive: true });
   const body = JSON.stringify(file, null, 2) + "\n";
   const tmp = `${runsFilePath()}.${process.pid}.${Date.now()}.tmp`;
   await writeFile3(tmp, body, { mode: 384 });
@@ -13539,8 +14301,8 @@ async function updateRun(id, patch) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/services/build-source-fingerprint.js
-import { readFile as readFile11, stat } from "node:fs/promises";
-import { resolve as resolve17 } from "node:path";
+import { readFile as readFile13, stat } from "node:fs/promises";
+import { resolve as resolve18 } from "node:path";
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/runs/helpers/sha256-hex.js
 import { createHash as createHash8 } from "node:crypto";
@@ -13562,7 +14324,7 @@ async function buildSourceFingerprint(opts) {
     const name = rowField(row, "name");
     if (!sourcePath)
       continue;
-    const abs = resolve17(sourcePath);
+    const abs = resolve18(sourcePath);
     if (seen.has(abs))
       continue;
     seen.add(abs);
@@ -13579,10 +14341,10 @@ async function buildSourceFingerprint(opts) {
   let rawTokensMtime = null;
   let rawTokensContentHash = null;
   if (opts.rawTokensPath) {
-    const abs = resolve17(opts.rawTokensPath);
+    const abs = resolve18(opts.rawTokensPath);
     rawTokensPath = abs;
     try {
-      const [st, buf] = await Promise.all([stat(abs), readFile11(abs)]);
+      const [st, buf] = await Promise.all([stat(abs), readFile13(abs)]);
       rawTokensMtime = st.mtime.toISOString();
       rawTokensContentHash = sha256Hex(buf);
     } catch {
@@ -13664,12 +14426,12 @@ async function writeScopeDecisionsSnapshot(db, sessionId, decisions) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/load-accepted-names.js
-import { readFile as readFile12 } from "node:fs/promises";
+import { readFile as readFile14 } from "node:fs/promises";
 async function loadAcceptedNames(sessionId) {
   try {
     const artifactsRoot = getRefineArtifactsRoot();
     const paths = await getRefineSessionPaths(sessionId, artifactsRoot);
-    const raw = await readFile12(paths.statePath, "utf8");
+    const raw = await readFile14(paths.statePath, "utf8");
     const snapshot = JSON.parse(raw);
     const accepted = snapshot.components.filter((c2) => c2.status === "accepted").map((c2) => c2.name);
     if (accepted.length === 0)
@@ -14367,7 +15129,7 @@ function errorMessage(error) {
   return error instanceof Error && error.message ? error.message : String(error);
 }
 function defaultSleep(delayMs) {
-  return new Promise((resolve28) => setTimeout(resolve28, delayMs));
+  return new Promise((resolve29) => setTimeout(resolve29, delayMs));
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/apply/src/helpers/sanitize-preview.js
@@ -14608,7 +15370,7 @@ var ApiClient = class {
         const progress = maxAttempts > 1 ? attempt / (maxAttempts - 1) : 0;
         const baseDelay = intervalMs + (maxIntervalMs - intervalMs) * progress;
         const jitter = Math.random() * baseDelay * 0.15;
-        await new Promise((resolve28) => setTimeout(resolve28, baseDelay + jitter));
+        await new Promise((resolve29) => setTimeout(resolve29, baseDelay + jitter));
       }
     }
     throw new Error(`Operation ${operationId} timed out after ${maxAttempts} attempts`);
@@ -14995,7 +15757,7 @@ function formatApiError2(request) {
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/apply/src/helpers/tokens/read-tokens-from-path.js
 init_shared();
-import { readFile as readFile13, stat as stat3 } from "node:fs/promises";
+import { readFile as readFile15, stat as stat3 } from "node:fs/promises";
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/apply/src/helpers/tokens/collect-json-files.js
 import { readdir, stat as stat2 } from "node:fs/promises";
@@ -15054,7 +15816,7 @@ async function readMergedFromDir(flag, dir) {
   const merged = {};
   for (const file of files.sort()) {
     try {
-      const text = await readFile13(file, "utf8");
+      const text = await readFile15(file, "utf8");
       const parsed = JSON.parse(text);
       if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
         Object.assign(merged, parsed);
@@ -15068,7 +15830,7 @@ async function readMergedFromDir(flag, dir) {
 async function readSingleFile(flag, p) {
   let text;
   try {
-    text = await readFile13(p, "utf8");
+    text = await readFile15(p, "utf8");
   } catch {
     throw new Error(`file not found: ${p} (from ${flag})`);
   }
@@ -15159,12 +15921,12 @@ async function fetchAndPersistExistingContentfulEntities(request) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/controller/existing-entities/read-from-session.js
-import { readFile as readFile14 } from "node:fs/promises";
+import { readFile as readFile16 } from "node:fs/promises";
 async function readExistingContentfulEntitiesFromSession(request) {
   if (!request.path)
     return void 0;
   try {
-    const raw = await readFile14(request.path, "utf8");
+    const raw = await readFile16(request.path, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.components) || !Array.isArray(parsed.tokens))
       return void 0;
@@ -15504,7 +16266,7 @@ init_describe_agent_failure();
 init_resolve_binary();
 init_resolve_skill_path();
 init_parse_map_token_prop_tool_calls();
-import { resolve as resolve18 } from "node:path";
+import { resolve as resolve19 } from "node:path";
 init_cache_keys();
 
 // packages/experience-design-system-backend-pipeline/dist/src/agents/helpers/resolution/binary-exists.js
@@ -15559,6 +16321,7 @@ function analyticsEnabled() {
 import { Analytics } from "@segment/analytics-node";
 var DEFAULT_WRITE_KEY = "6DmxiEPN3SV1vbRTTMcNqDzCvkfwT06N";
 var analyticsClient = null;
+var flushChain = Promise.resolve();
 function resolveWriteKey() {
   const key = (process.env["SEGMENT_WRITE_KEY"] ?? "").trim();
   return key.length > 0 ? key : DEFAULT_WRITE_KEY;
@@ -15593,14 +16356,17 @@ async function trackEvent(event, properties, anonymousId, options) {
   }
 }
 async function flushAnalytics() {
-  if (!analyticsClient)
-    return;
-  try {
-    await analyticsClient.closeAndFlush();
-  } catch {
-  } finally {
+  flushChain = flushChain.then(async () => {
+    const client2 = analyticsClient;
+    if (!client2)
+      return;
     analyticsClient = null;
-  }
+    try {
+      await client2.closeAndFlush();
+    } catch {
+    }
+  });
+  return flushChain;
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/analytics/constants.js
@@ -15809,7 +16575,7 @@ async function runMapTokens(request) {
       outDir: process.cwd(),
       existingTokensInline: request.existingEntitiesInline,
       ...request.skillContentOverride !== void 0 ? { skillContentOverride: request.skillContentOverride } : {},
-      ...request.skillContentOverride === void 0 && request.skillPathOverride ? { skillPathOverride: resolve18(request.skillPathOverride) } : {}
+      ...request.skillContentOverride === void 0 && request.skillPathOverride ? { skillPathOverride: resolve19(request.skillPathOverride) } : {}
     });
     if (request.printPrompt) {
       const prompt2 = await buildMapPrompt();
@@ -15925,7 +16691,7 @@ function hasNoAuthoringSurface(component) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/helpers/evidence/source-inspection.js
-import { readFile as readFile15 } from "node:fs/promises";
+import { readFile as readFile17 } from "node:fs/promises";
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/constants/review-reasons.js
 var HIGH_CONFIDENCE_DATA_FETCH_WRAPPER_REASON = "data-fetch-wrapper";
@@ -15997,7 +16763,14 @@ function hasSiblingForwardRender(sourceText, siblingImports) {
   });
 }
 function hasVisibleUiRender(sourceText) {
-  return /return\s*(?:\(|<)/.test(sourceText) && VISIBLE_UI_TAG_PATTERN.test(sourceText);
+  if (/return\s*(?:\(|<)/.test(sourceText) && VISIBLE_UI_TAG_PATTERN.test(sourceText))
+    return true;
+  if (/template\s*:\s*[`'"][\s\S]*?[`'"]/.test(sourceText)) {
+    const inlineMatch = sourceText.match(/template\s*:\s*[`'"]([\s\S]*?)[`'"]/);
+    if (inlineMatch && VISIBLE_UI_TAG_PATTERN.test(inlineMatch[1]))
+      return true;
+  }
+  return /templateUrl\s*:\s*['"]/.test(sourceText);
 }
 function infraPropNames(component) {
   const props = component.props.map((prop) => prop.name);
@@ -16020,7 +16793,7 @@ function dedupeReasons(reasons) {
 async function inspectComponentSource(component) {
   let sourceText = "";
   try {
-    sourceText = await readFile15(component.source, "utf8");
+    sourceText = await readFile17(component.source, "utf8");
   } catch {
     return {
       wrapperConfidence: 0,
@@ -16427,7 +17200,7 @@ async function retryDatabaseWrite(operation, attempts = 8) {
       const message = error instanceof Error ? error.message : String(error);
       if (!/database is locked|database is busy/i.test(message) || attempt >= attempts)
         throw error;
-      await new Promise((resolve28) => setTimeout(resolve28, Math.min(250 * attempt, 2e3)));
+      await new Promise((resolve29) => setTimeout(resolve29, Math.min(250 * attempt, 2e3)));
     }
   }
 }
@@ -16459,7 +17232,7 @@ function resolveCompositionAgentName(flagValue) {
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-extract-and-compose-session/helpers/read-candidate-files.js
-import { readFile as readFile16 } from "node:fs/promises";
+import { readFile as readFile18 } from "node:fs/promises";
 async function readCandidateFiles(components, extraFiles = []) {
   const paths = new Set(extraFiles);
   for (const c2 of components) {
@@ -16469,7 +17242,7 @@ async function readCandidateFiles(components, extraFiles = []) {
   const out = [];
   await Promise.all([...paths].map(async (p) => {
     try {
-      const content = await readFile16(p, "utf8");
+      const content = await readFile18(p, "utf8");
       out.push({ path: p, content });
     } catch {
     }
@@ -16640,7 +17413,7 @@ init_build_prompt();
 init_create_local_cli_agent_invoker();
 init_invoke_agent_with_output();
 init_parse_token_tool_calls();
-import { readFile as readFile17 } from "node:fs/promises";
+import { readFile as readFile19 } from "node:fs/promises";
 import { basename as basename5, resolve as pathResolve } from "node:path";
 init_cache_keys();
 init_parse_prompt_overrides();
@@ -16673,7 +17446,7 @@ async function runGenerateTokensSession(request) {
     throw new Error(`Prompt override error(s): ${promptErrors.join("; ")}`);
   const tokensOverride = overridesMap.get("tokens");
   const skillContentOverride = tokensOverride ? await resolvePromptOverride(tokensOverride) : void 0;
-  const rawTokensInline = await readFile17(pathResolve(rawTokensPath), "utf8");
+  const rawTokensInline = await readFile19(pathResolve(rawTokensPath), "utf8");
   const tokenInputHash = hashTokenContent(rawTokensInline);
   const db = openPipelineDb();
   try {
@@ -16790,7 +17563,7 @@ async function readExistingEntities(request) {
 // packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/helpers/resolve-generate-prompt.js
 init_parse_prompt_overrides();
 init_resolve_prompt_override();
-import { resolve as resolve19 } from "node:path";
+import { resolve as resolve20 } from "node:path";
 async function resolveGeneratePrompt(overrides) {
   const { overrides: parsed, errors } = parsePromptOverrides(overrides);
   if (errors.length > 0)
@@ -16801,7 +17574,7 @@ async function resolveGeneratePrompt(overrides) {
   const text = await resolvePromptOverride(entry);
   if (entry.kind === "text")
     return { text };
-  return { path: resolve19(entry.value), text };
+  return { path: resolve20(entry.value), text };
 }
 
 // packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/helpers/run-one-generate-component.js
@@ -17709,19 +18482,19 @@ import { useEffect as useEffect5, useRef as useRef3, useState as useState10 } fr
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/run.ts
 import { mkdir as mkdir7 } from "node:fs/promises";
-import { join as join18, resolve as resolve22 } from "node:path";
+import { join as join18, resolve as resolve23 } from "node:path";
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/find-skill-path.ts
 import { existsSync as existsSync8 } from "node:fs";
-import { dirname as dirname14, join as join17, resolve as resolve20 } from "node:path";
+import { dirname as dirname15, join as join17, resolve as resolve21 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function findSkillPath(fileName) {
-  const thisDir = dirname14(fileURLToPath4(import.meta.url));
+  const thisDir = dirname15(fileURLToPath4(import.meta.url));
   let dir = thisDir;
   for (; ; ) {
     const candidate = join17(dir, "skills", fileName);
     if (existsSync8(candidate)) return candidate;
-    const parent = resolve20(dir, "..");
+    const parent = resolve21(dir, "..");
     if (parent === dir) {
       throw new Error(`skill file not found (looked for skills/${fileName} from ${thisDir})`);
     }
@@ -17730,11 +18503,11 @@ function findSkillPath(fileName) {
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/selection.ts
-import { resolve as resolve21 } from "node:path";
+import { resolve as resolve22 } from "node:path";
 var SELECT_SKILL_PATH = findSkillPath("select-components.md");
 var DEFAULT_TIMEOUT_MS5 = Number(process.env.EDS_AGENT_TIMEOUT_MS ?? 5 * 60 * 1e3);
 async function hashSelectPrompt(options) {
-  const promptHash = options.promptText ? hashContent(options.promptText) : options.promptPath ? await hashFile(resolve21(options.promptPath)) : await hashFile(SELECT_SKILL_PATH);
+  const promptHash = options.promptText ? hashContent(options.promptText) : options.promptPath ? await hashFile(resolve22(options.promptPath)) : await hashFile(SELECT_SKILL_PATH);
   return hashContent(`${promptHash}|${options.agent}|${options.model ?? ""}`);
 }
 async function runSelection(options) {
@@ -17829,7 +18602,7 @@ var realDeps = {
 var fail = (step, message) => ({ ok: false, step, message });
 var errorMessage2 = (error) => error instanceof Error ? error.message : String(error);
 async function runExtraction(input, onProgress, deps = realDeps) {
-  const outDir = input.outDir ?? join18(resolve22(input.projectPath), ".contentful");
+  const outDir = input.outDir ?? join18(resolve23(input.projectPath), ".contentful");
   let progress = initialProgress({
     hasCredentials: input.credentials !== null,
     hasRawTokens: input.rawTokensPath !== ""
@@ -17953,7 +18726,7 @@ async function resolveSelectionPrompt(overrides) {
   if (select?.kind === "text") return { promptText: select.value };
   if (select?.kind === "path") {
     await resolvePromptOverride(select);
-    return { promptPath: resolve22(select.value) };
+    return { promptPath: resolve23(select.value) };
   }
   return {};
 }
@@ -20912,7 +21685,7 @@ function GenerationScreen({
 import { useEffect as useEffect10, useRef as useRef8, useState as useState17 } from "react";
 
 // packages/experience-design-system-cli/src/tui/import/steps/08-generation/run.ts
-import { resolve as resolve23 } from "node:path";
+import { resolve as resolve24 } from "node:path";
 
 // packages/experience-design-system-cli/src/tui/import/steps/08-generation/map-tokens.ts
 async function prepareMapTokens(input, generatedSessionId) {
@@ -21047,7 +21820,7 @@ async function buildMapTokensOptions(input) {
   if (mapOverride?.kind === "text") prompt.skillContentOverride = mapOverride.value;
   if (mapOverride?.kind === "path") {
     await resolvePromptOverride(mapOverride);
-    prompt.skillPathOverride = resolve23(mapOverride.value);
+    prompt.skillPathOverride = resolve24(mapOverride.value);
   }
   if (input.existingEntitiesPath) {
     const entities = await readExistingContentfulEntitiesFromSession({ path: input.existingEntitiesPath });
@@ -26852,10 +27625,10 @@ function DoneStep({
 import { useState as useState27 } from "react";
 import { Box as Box41, Text as Text43 } from "ink";
 import { readdirSync as readdirSync3 } from "node:fs";
-import { dirname as dirname15, basename as basename6, join as join20 } from "node:path";
+import { dirname as dirname16, basename as basename6, join as join20 } from "node:path";
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/support/path-utils.ts
-import { resolve as resolve24 } from "node:path";
+import { resolve as resolve25 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 function expandTilde(input) {
   if (input === "~" || input.startsWith("~/") || input.startsWith("~\\")) {
@@ -26869,7 +27642,7 @@ function normalizePath(input) {
     p = p.slice(1, -1);
   }
   p = expandTilde(p);
-  return resolve24(p);
+  return resolve25(p);
 }
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/support/use-blinking-cursor.ts
@@ -26888,7 +27661,7 @@ import { jsx as jsx51, jsxs as jsxs41 } from "react/jsx-runtime";
 function autocomplete(partial) {
   if (!partial) return null;
   const normalized = normalizePath(partial);
-  const dir = dirname15(normalized);
+  const dir = dirname16(normalized);
   const base = basename6(normalized);
   let entries;
   try {
@@ -27652,7 +28425,7 @@ import { useEffect as useEffect21, useRef as useRef14, useSyncExternalStore } fr
 import { appendFileSync, writeFileSync } from "node:fs";
 import { mkdir as mkdir8 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join22, resolve as resolve25 } from "node:path";
+import { join as join22, resolve as resolve26 } from "node:path";
 
 // packages/experience-design-system-cli/src/tui/import/steps/10-flow/support/wizard-state-transitions.ts
 function shouldBypassPreview(state2) {
@@ -28026,7 +28799,7 @@ var realSaveDeps = () => ({
   writeFile: (path5, contents) => writeFile7(path5, contents),
   appendRun,
   buildSourceFingerprint,
-  sleep: (ms) => new Promise((resolve28) => setTimeout(resolve28, ms)),
+  sleep: (ms) => new Promise((resolve29) => setTimeout(resolve29, ms)),
   warn: (message) => process.stderr.write(message)
 });
 async function runPrintFiles(input, deps, onPatch) {
@@ -28365,7 +29138,7 @@ function createFlowController(start, deps) {
     },
     async submitPath(submitted) {
       await deps.mkdir(submitted);
-      if (resolve25(submitted) !== resolve25(state2.outDir) && await deps.detectSaveConflict(submitted)) {
+      if (resolve26(submitted) !== resolve26(state2.outDir) && await deps.detectSaveConflict(submitted)) {
         const subdir = deps.buildTimestampedSubdir(submitted);
         await deps.mkdir(subdir);
         await proceedToWrite(subdir);
@@ -28423,7 +29196,7 @@ init_debug_mode_store();
 init_version();
 
 // packages/experience-design-system-cli/src/tui/help/file-locations.ts
-import { join as join25, resolve as resolve27 } from "node:path";
+import { join as join25, resolve as resolve28 } from "node:path";
 function describeFileLocations({
   contentfulBaseDir,
   debugModeEnabled,
@@ -28435,7 +29208,7 @@ function describeFileLocations({
       importFiles: `${join25("<project>", ".contentful")}/ (tokens.json, components.json)`
     };
   }
-  const base = contentfulBaseDir ? resolve27(contentfulBaseDir) : "<project>";
+  const base = contentfulBaseDir ? resolve28(contentfulBaseDir) : "<project>";
   const session = currentSessionDir2 ?? join25(base, ".contentful", "<date>-session-<n>");
   return {
     debugLogs: join25(session, "debug"),
@@ -28656,20 +29429,20 @@ function resolveOnPath(binary) {
       () => null
     );
   }
-  return new Promise((resolve28) => {
+  return new Promise((resolve29) => {
     execFile2(
       process.platform === "win32" ? "where" : "which",
       [binary],
-      (error, stdout) => resolve28(error ? null : stdout.split("\n")[0]?.trim() ?? null)
+      (error, stdout) => resolve29(error ? null : stdout.split("\n")[0]?.trim() ?? null)
     );
   });
 }
 function readVersion(binary) {
-  return new Promise((resolve28) => {
+  return new Promise((resolve29) => {
     execFile2(binary, ["--version"], { timeout: VERSION_TIMEOUT_MS }, (error, stdout) => {
       const line = stdout.split("\n")[0]?.trim() ?? "";
-      if (!error && line) resolve28(pass("version", line));
-      else resolve28(fail3("version", "runs, but did not report a version"));
+      if (!error && line) resolve29(pass("version", line));
+      else resolve29(fail3("version", "runs, but did not report a version"));
     });
   });
 }