@contentful/experience-design-system-cli 2.37.1-dev-build-2be54904.0 → 2.37.1-dev-build-c299dd61.0

package/dist/index.js

@@ -1484,6 +1484,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";
@@ -1500,10 +1510,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) {
@@ -1515,50 +1526,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;
   }
 });
 
@@ -1571,7 +1619,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;
@@ -1580,7 +1628,7 @@ async function checkAgentAuth(agent) {
         return;
       done = true;
       child.kill("SIGTERM");
-      resolve28("unauthenticated");
+      resolve29("unauthenticated");
     }, 5e3);
     child.stdout?.on("data", (chunk) => {
       stdout += chunk.toString();
@@ -1591,14 +1639,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");
       }
     });
   });
@@ -1608,9 +1656,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({
@@ -2247,7 +2295,8 @@ var init_infer_fence_lang = __esm({
       sass: "scss",
       css: "css",
       json: "json",
-      json5: "json"
+      json5: "json",
+      html: "html"
     };
   }
 });
@@ -10986,6 +11035,797 @@ var init_extract_svelte_components = __esm({
   }
 });
 
+// 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;
+}
+var init_find_component_decorator = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/find-component-decorator.js"() {
+    "use strict";
+  }
+});
+
+// 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);
+}
+var init_resolve_prop_type = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/props/resolve-prop-type.js"() {
+    "use strict";
+  }
+});
+
+// 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";
+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;
+}
+var init_extract_decorator_input = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/props/extract-decorator-input.js"() {
+    "use strict";
+    init_resolve_prop_type();
+  }
+});
+
+// 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;
+}
+var init_extract_signal_input = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/props/extract-signal-input.js"() {
+    "use strict";
+    init_resolve_prop_type();
+  }
+});
+
+// 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;
+}
+var init_parse_inputs_array_entry = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/props/parse-inputs-array-entry.js"() {
+    "use strict";
+  }
+});
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/props/extract-props.js
+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()];
+}
+var MAX_BASE_CHAIN;
+var init_extract_props = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/props/extract-props.js"() {
+    "use strict";
+    init_extract_decorator_input();
+    init_extract_signal_input();
+    init_parse_inputs_array_entry();
+    MAX_BASE_CHAIN = 10;
+  }
+});
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/resolution/normalize-component-name.js
+function normalizeComponentName2(className) {
+  for (const suffix of SUFFIXES) {
+    if (className.endsWith(suffix) && className.length > suffix.length) {
+      return className.slice(0, -suffix.length);
+    }
+  }
+  return className;
+}
+var SUFFIXES;
+var init_normalize_component_name = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/resolution/normalize-component-name.js"() {
+    "use strict";
+    SUFFIXES = ["Component", "Directive"];
+  }
+});
+
+// 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;
+}
+var init_read_decorator_string = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/read-decorator-string.js"() {
+    "use strict";
+  }
+});
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/read-component-metadata.js
+import { dirname as dirname9, resolve as resolve11 } from "node:path";
+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 ? resolve11(dirname9(sourceFilePath), templateUrlRel) : null;
+  const decorator = cls.getDecorator("Component");
+  const decoratorLine = decorator?.getStartLineNumber() ?? cls.getStartLineNumber();
+  return {
+    className,
+    normalizedName: normalizeComponentName2(className),
+    rawSelector,
+    inlineTemplate,
+    templatePath,
+    inputsArray,
+    decoratorLine
+  };
+}
+var init_read_component_metadata = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/read-component-metadata.js"() {
+    "use strict";
+    init_find_component_decorator();
+    init_normalize_component_name();
+    init_read_decorator_string();
+  }
+});
+
+// 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;
+}
+var init_parse_ng_content_elements = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/template/parse-ng-content-elements.js"() {
+    "use strict";
+  }
+});
+
+// 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;
+  }
+}
+var init_resolve_template_source = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/template/resolve-template-source.js"() {
+    "use strict";
+  }
+});
+
+// packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/resolution/strip-library-prefix.js
+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;
+}
+var KNOWN_PREFIXES;
+var init_strip_library_prefix = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/resolution/strip-library-prefix.js"() {
+    "use strict";
+    KNOWN_PREFIXES = ["Mat", "Cdk", "Nz", "Cds", "Ibm", "Clr", "Hlm", "Brn", "Tui", "Nb", "Fd", "P", "Ng"];
+  }
+});
+
+// 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();
+}
+var init_derive_slot_name = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/slots/derive-slot-name.js"() {
+    "use strict";
+    init_strip_library_prefix();
+  }
+});
+
+// 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;
+}
+var init_extract_content_child_queries = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/slots/extract-content-child-queries.js"() {
+    "use strict";
+  }
+});
+
+// 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 };
+}
+var init_extract_template_ref_slots = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/slots/extract-template-ref-slots.js"() {
+    "use strict";
+  }
+});
+
+// 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()] };
+}
+var init_extract_slots = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/slots/extract-slots.js"() {
+    "use strict";
+    init_parse_ng_content_elements();
+    init_resolve_template_source();
+    init_derive_slot_name();
+    init_extract_content_child_queries();
+    init_extract_template_ref_slots();
+  }
+});
+
+// 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";
+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 };
+  });
+}
+var init_extract_angular_components = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/extract-angular-components.js"() {
+    "use strict";
+    init_scoring();
+    init_find_component_decorator();
+    init_extract_props();
+    init_read_component_metadata();
+    init_extract_slots();
+  }
+});
+
+// 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 statSync3 } from "node:fs";
+function isAngularSourceFile(filePath) {
+  if (!/\.[cm]?ts$/.test(filePath))
+    return false;
+  if (filePath.endsWith(".d.ts"))
+    return false;
+  try {
+    const stats = statSync3(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;
+  }
+}
+var HEAD_BYTES, buffer;
+var init_is_angular_source_file = __esm({
+  "packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/framework-adapters/angular/helpers/is-angular-source-file.js"() {
+    "use strict";
+    HEAD_BYTES = 32 * 1024;
+    buffer = Buffer.alloc(HEAD_BYTES);
+  }
+});
+
 // packages/experience-design-system-backend-pipeline/dist/src/steps/extraction/src/services/run-extraction-service.js
 function getPathPreferenceScore(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
@@ -11278,6 +12118,8 @@ var init_run_extraction_service = __esm({
     init_extract_astro_components();
     init_extract_web_components();
     init_extract_svelte_components();
+    init_extract_angular_components();
+    init_is_angular_source_file();
     extractors = [
       {
         name: "stencil",
@@ -11304,6 +12146,13 @@ var init_run_extraction_service = __esm({
         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"),
@@ -11532,16 +12381,16 @@ var init_apply_mapping = __esm({
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/composition/src/helpers/prompt/prompt-loader.js
 import { existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
-import { dirname as dirname9, join as join8, resolve as resolve11 } from "node:path";
+import { dirname as dirname10, join as join8, resolve as resolve12 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function resolvePromptPath(fileName) {
-  const thisDir = dirname9(fileURLToPath2(import.meta.url));
+  const thisDir = dirname10(fileURLToPath2(import.meta.url));
   let dir = thisDir;
   for (; ; ) {
     const candidate = join8(dir, "prompts");
     if (existsSync6(candidate))
       return join8(candidate, fileName);
-    const parent = resolve11(dir, "..");
+    const parent = resolve12(dir, "..");
     if (parent === dir) {
       throw new Error(`prompt file missing from package installation (could not locate prompts/ directory from: ${thisDir})`);
     }
@@ -11639,14 +12488,31 @@ var CANDIDATE_NAME_PATTERNS, CANDIDATE_CONTENT_MARKERS, PROMPT_CANDIDATE_TOKEN_B
 var init_candidate_files = __esm({
   "packages/experience-design-system-backend-pipeline/dist/src/steps/composition/src/constants/candidate-files.js"() {
     "use strict";
-    CANDIDATE_NAME_PATTERNS = [/mapping/i, /meta/i, /registry/i, /schema/i, /composition/i];
+    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
+    ];
     CANDIDATE_CONTENT_MARKERS = [
       "requiredParent",
       "withParentType",
       "allowedTagNames",
       "createContext",
       "MappingContext",
-      "allowedComponents"
+      "allowedComponents",
+      "TemplateRef",
+      "NG_VALUE_ACCESSOR",
+      "ContentChild",
+      "contentChild",
+      "ng-content",
+      "@NgModule",
+      "standalone: true"
     ];
     PROMPT_CANDIDATE_TOKEN_BUDGET = 8e4;
   }
@@ -11729,8 +12595,8 @@ var init_composition_cache_key = __esm({
 });
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/composition/src/helpers/edges/manifest-doc-evidence.js
-import { dirname as dirname10 } from "node:path";
-function kebabToPascal2(name) {
+import { dirname as dirname11 } 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) {
@@ -11752,7 +12618,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;
@@ -11772,7 +12638,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}`;
@@ -11791,8 +12657,8 @@ function collectAgentsDocEdges(files, components, componentNames) {
   for (const file of files) {
     if (!file.path.endsWith("AGENTS.md"))
       continue;
-    const docDir = dirname10(file.path);
-    const parent = components.find((c2) => c2.sourcePath && dirname10(c2.sourcePath) === docDir)?.name;
+    const docDir = dirname11(file.path);
+    const parent = components.find((c2) => c2.sourcePath && dirname11(c2.sourcePath) === docDir)?.name;
     if (!parent || !componentNames.has(parent))
       continue;
     for (const line of file.content.split("\n")) {
@@ -11801,7 +12667,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}`;
@@ -12439,7 +13305,7 @@ var init_create_component_id = __esm({
 
 // 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 resolve12 } from "node:path";
+import { isAbsolute, relative, resolve as resolve13 } from "node:path";
 async function resolveComponentSourcePath(source, reviewRoot) {
   if (isAbsolute(source)) {
     try {
@@ -12449,7 +13315,7 @@ async function resolveComponentSourcePath(source, reviewRoot) {
       throw new Error(`Unable to access component source at ${source}`);
     }
   }
-  const candidate = resolve12(reviewRoot, source);
+  const candidate = resolve13(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.`);
@@ -12468,9 +13334,9 @@ var init_resolve_component_source_path = __esm({
 });
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/helpers/load-review-input.js
-import { resolve as resolve13 } from "node:path";
+import { resolve as resolve14 } from "node:path";
 async function loadReviewInput(components, options = {}) {
-  const reviewRoot = resolve13(options.reviewRoot ?? process.cwd());
+  const reviewRoot = resolve14(options.reviewRoot ?? process.cwd());
   const records = await Promise.all(components.map(async (component) => {
     let resolvedSourcePath;
     try {
@@ -12521,13 +13387,13 @@ var init_load_and_validate_for_review = __esm({
 });
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/review-session-paths.js
-import { resolve as resolve14 } from "node:path";
+import { resolve as resolve15 } from "node:path";
 async function getRefineSessionPaths(sessionId, artifactsRoot) {
-  const sessionDir2 = resolve14(artifactsRoot, sessionId);
+  const sessionDir2 = resolve15(artifactsRoot, sessionId);
   return {
     sessionDir: sessionDir2,
-    eventsPath: resolve14(sessionDir2, "events.jsonl"),
-    statePath: resolve14(sessionDir2, "current-review-state.json")
+    eventsPath: resolve15(sessionDir2, "events.jsonl"),
+    statePath: resolve15(sessionDir2, "current-review-state.json")
   };
 }
 var init_review_session_paths = __esm({
@@ -12537,13 +13403,13 @@ var init_review_session_paths = __esm({
 });
 
 // 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";
 async function ensureRefineSession(sessionId, artifactsRoot, initialSnapshot) {
   const paths = await getRefineSessionPaths(sessionId, artifactsRoot);
   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");
@@ -12559,12 +13425,12 @@ var init_ensure_review_session = __esm({
 });
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/review-artifacts-root.js
-import { resolve as resolve15 } from "node:path";
+import { resolve as resolve16 } from "node:path";
 function getRefineArtifactsRoot() {
   if (process.env["EDS_REVIEW_ARTIFACTS_DIR"]) {
-    return resolve15(process.env["EDS_REVIEW_ARTIFACTS_DIR"]);
+    return resolve16(process.env["EDS_REVIEW_ARTIFACTS_DIR"]);
   }
-  return resolve15(configRoot(), "reviews");
+  return resolve16(configRoot(), "reviews");
 }
 var init_review_artifacts_root = __esm({
   "packages/experience-design-system-backend-pipeline/dist/src/persistence/src/review-session/repositories/review-artifacts-root.js"() {
@@ -12585,14 +13451,14 @@ var init_save_review_state = __esm({
 });
 
 // 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";
 async function mergePreviewValidationErrorsIntoReviewSession(sessionId, errors, opts = {}) {
   const artifactsRoot = opts.artifactsRoot ?? getRefineArtifactsRoot();
   const paths = await getRefineSessionPaths(sessionId, artifactsRoot);
   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);
@@ -12640,7 +13506,7 @@ var init_merge_preview_validation_errors_into_review_session = __esm({
 });
 
 // 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;
@@ -12656,7 +13522,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;
   }
@@ -12740,7 +13606,9 @@ var init_file_patterns = __esm({
       ".spec.ts",
       ".spec.tsx",
       ".test.ts",
-      ".test.tsx"
+      ".test.tsx",
+      ".harness.ts",
+      ".harness.tsx"
     ];
     IGNORED_DIRS = /* @__PURE__ */ new Set([
       ".changeset",
@@ -12758,9 +13626,12 @@ var init_file_patterns = __esm({
       "dist",
       "example",
       "examples",
+      "harness",
+      "harnesses",
       "node_modules",
       "out",
-      "storybook-static"
+      "storybook-static",
+      "testing"
     ]);
     DENYLISTED_EXACT_FILE_NAMES = /* @__PURE__ */ new Set([
       "package.json",
@@ -12907,13 +13778,13 @@ var init_walk_project_tree = __esm({
 });
 
 // packages/experience-design-system-backend-pipeline/dist/src/persistence/src/helpers/collect-files/collect-files.js
-import { statSync as statSync3 } from "node:fs";
+import { statSync as statSync4 } from "node:fs";
 import path4 from "node:path";
 function collectFiles(root, options = {}) {
   const resolved = path4.resolve(root);
   let stat5;
   try {
-    stat5 = statSync3(resolved);
+    stat5 = statSync4(resolved);
   } catch (err) {
     return { ok: false, failure: classifyStatError(err.code), rootPath: resolved };
   }
@@ -13017,10 +13888,10 @@ var init_run_record = __esm({
 });
 
 // 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";
 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.`);
@@ -13045,9 +13916,9 @@ var init_read_runs_file = __esm({
 
 // 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 dirname11 } from "node:path";
+import { dirname as dirname12 } from "node:path";
 async function writeRunsFileAtomic(file) {
-  await mkdir2(dirname11(runsFilePath()), { recursive: true });
+  await mkdir2(dirname12(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 });
@@ -13140,8 +14011,8 @@ var init_sha256_hex = __esm({
 });
 
 // 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 resolve16 } from "node:path";
+import { readFile as readFile13, stat } from "node:fs/promises";
+import { resolve as resolve17 } from "node:path";
 function rowField(row, key) {
   const v = row[key];
   return typeof v === "string" ? v : null;
@@ -13155,7 +14026,7 @@ async function buildSourceFingerprint(opts) {
     const name = rowField(row, "name");
     if (!sourcePath)
       continue;
-    const abs = resolve16(sourcePath);
+    const abs = resolve17(sourcePath);
     if (seen.has(abs))
       continue;
     seen.add(abs);
@@ -13172,10 +14043,10 @@ async function buildSourceFingerprint(opts) {
   let rawTokensMtime = null;
   let rawTokensContentHash = null;
   if (opts.rawTokensPath) {
-    const abs = resolve16(opts.rawTokensPath);
+    const abs = resolve17(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 {
@@ -13340,12 +14211,12 @@ var init_write_scope_decisions_snapshot = __esm({
 });
 
 // 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)
@@ -14333,7 +15204,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));
 }
 var MAX_RETRY_AFTER_MS;
 var init_http_utils = __esm({
@@ -14609,7 +15480,7 @@ var init_api_client = __esm({
             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`);
@@ -15296,7 +16167,7 @@ var init_collect_json_files = __esm({
 });
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/apply/src/helpers/tokens/read-tokens-from-path.js
-import { readFile as readFile13, stat as stat3 } from "node:fs/promises";
+import { readFile as readFile15, stat as stat3 } from "node:fs/promises";
 async function readTokensFromPath(flag, p) {
   let s;
   try {
@@ -15319,7 +16190,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);
@@ -15333,7 +16204,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})`);
   }
@@ -15439,12 +16310,12 @@ var init_fetch_and_persist = __esm({
 });
 
 // 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;
@@ -16023,22 +16894,26 @@ 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;
 }
-var DEFAULT_WRITE_KEY, analyticsClient;
+var DEFAULT_WRITE_KEY, analyticsClient, flushChain;
 var init_segment_client = __esm({
   "packages/experience-design-system-backend-pipeline/dist/src/analytics/client/segment-client.js"() {
     "use strict";
     init_opt_out();
     DEFAULT_WRITE_KEY = "6DmxiEPN3SV1vbRTTMcNqDzCvkfwT06N";
     analyticsClient = null;
+    flushChain = Promise.resolve();
   }
 });
 
@@ -16317,7 +17192,7 @@ var init_analytics = __esm({
 });
 
 // packages/experience-design-system-backend-pipeline/dist/src/steps/generation/src/controller/map-tokens/run-map-tokens.js
-import { resolve as resolve17 } from "node:path";
+import { resolve as resolve18 } from "node:path";
 async function runMapTokens(request) {
   const timeoutMs = request.agentTimeoutMs ?? DEFAULT_TIMEOUT_MS2;
   const db = openPipelineDb();
@@ -16368,7 +17243,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: resolve17(request.skillPathOverride) } : {}
+      ...request.skillContentOverride === void 0 && request.skillPathOverride ? { skillPathOverride: resolve18(request.skillPathOverride) } : {}
     });
     if (request.printPrompt) {
       const prompt2 = await buildMapPrompt();
@@ -16584,7 +17459,7 @@ var init_parse_imported_names = __esm({
 });
 
 // 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";
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -16617,7 +17492,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);
@@ -16640,7 +17522,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,
@@ -17096,7 +17978,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)));
     }
   }
 }
@@ -17144,7 +18026,7 @@ var init_resolve_composition_agent_name = __esm({
 });
 
 // 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) {
@@ -17154,7 +18036,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 {
     }
@@ -17393,7 +18275,7 @@ var init_write_tokens_file = __esm({
 });
 
 // packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-tokens-session/run-generate-tokens-session.js
-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";
 async function runGenerateTokensSession(request) {
   const { rawTokensPath, outDir, agent, agentModel, promptOverrides, skillPath, noCache, bedrock = false, onProgress, onSessionCreated } = request;
@@ -17402,7 +18284,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 {
@@ -17553,7 +18435,7 @@ var init_read_existing_entities = __esm({
 });
 
 // packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/helpers/resolve-generate-prompt.js
-import { resolve as resolve18 } from "node:path";
+import { resolve as resolve19 } from "node:path";
 async function resolveGeneratePrompt(overrides) {
   const { overrides: parsed, errors } = parsePromptOverrides(overrides);
   if (errors.length > 0)
@@ -17564,7 +18446,7 @@ async function resolveGeneratePrompt(overrides) {
   const text = await resolvePromptOverride(entry);
   if (entry.kind === "text")
     return { text };
-  return { path: resolve18(entry.value), text };
+  return { path: resolve19(entry.value), text };
 }
 var init_resolve_generate_prompt = __esm({
   "packages/experience-design-system-backend-pipeline/dist/src/orchestrators/run-generate-components-session/helpers/resolve-generate-prompt.js"() {
@@ -18067,10 +18949,10 @@ var init_src3 = __esm({
 
 // packages/experience-design-system-cli/src/tui/package-root.ts
 import { existsSync as existsSync7, readFileSync as readFileSync7 } from "node:fs";
-import { dirname as dirname12, join as join14 } from "node:path";
+import { dirname as dirname13, join as join14 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function findPackageRoot(startUrl, packageName) {
-  let dir = dirname12(fileURLToPath3(startUrl));
+  let dir = dirname13(fileURLToPath3(startUrl));
   let found;
   while (true) {
     const manifestPath = join14(dir, "package.json");
@@ -18078,7 +18960,7 @@ function findPackageRoot(startUrl, packageName) {
       const pkg2 = JSON.parse(readFileSync7(manifestPath, "utf8"));
       if (pkg2.name === packageName) found = dir;
     }
-    const parent = dirname12(dir);
+    const parent = dirname13(dir);
     if (parent === dir) return found ?? dir;
     dir = parent;
   }
@@ -18091,22 +18973,22 @@ var init_package_root = __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 homedir2 } 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(homedir2(), ".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 });
@@ -19207,7 +20089,7 @@ var init_controls5 = __esm({
 
 // packages/experience-design-system-cli/src/tui/import/resolve-user-path.ts
 import { homedir as homedir3 } from "node:os";
-import { resolve as resolve19 } from "node:path";
+import { resolve as resolve20 } from "node:path";
 function stripQuotes(value) {
   const quoted = value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'");
   return value.length >= 2 && quoted ? value.slice(1, -1) : value;
@@ -19216,7 +20098,7 @@ function expandHome(value) {
   return value === "~" || value.startsWith("~/") || value.startsWith("~\\") ? homedir3() + value.slice(1) : value;
 }
 function resolveUserPath(raw) {
-  return resolve19(expandHome(stripQuotes(raw.trim())));
+  return resolve20(expandHome(stripQuotes(raw.trim())));
 }
 var init_resolve_user_path = __esm({
   "packages/experience-design-system-cli/src/tui/import/resolve-user-path.ts"() {
@@ -19225,12 +20107,12 @@ var init_resolve_user_path = __esm({
 });
 
 // packages/experience-design-system-cli/src/tui/import/steps/02-token-input/validate-path.ts
-import { statSync as statSync4 } from "node:fs";
+import { statSync as statSync5 } from "node:fs";
 function validateTokenPath(rawPath) {
   const path5 = resolveUserPath(rawPath);
   let stats;
   try {
-    stats = statSync4(path5);
+    stats = statSync5(path5);
   } catch {
     return { ok: false, error: `Path not found: ${path5}`, resolvedPath: path5 };
   }
@@ -20098,15 +20980,15 @@ var init_steps = __esm({
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/find-skill-path.ts
 import { existsSync as existsSync9 } from "node:fs";
-import { dirname as dirname14, join as join18, resolve as resolve20 } from "node:path";
+import { dirname as dirname15, join as join18, 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 = join18(dir, "skills", fileName);
     if (existsSync9(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})`);
     }
@@ -20120,9 +21002,9 @@ var init_find_skill_path = __esm({
 });
 
 // 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";
 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) {
@@ -20217,9 +21099,9 @@ var init_selection2 = __esm({
 
 // packages/experience-design-system-cli/src/tui/import/steps/06-extraction/run.ts
 import { mkdir as mkdir7 } from "node:fs/promises";
-import { join as join19, resolve as resolve22 } from "node:path";
+import { join as join19, resolve as resolve23 } from "node:path";
 async function runExtraction(input, onProgress, deps = realDeps) {
-  const outDir = input.outDir ?? join19(resolve22(input.projectPath), ".contentful");
+  const outDir = input.outDir ?? join19(resolve23(input.projectPath), ".contentful");
   let progress = initialProgress({
     hasCredentials: input.credentials !== null,
     hasRawTokens: input.rawTokensPath !== ""
@@ -20343,7 +21225,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 {};
 }
@@ -23661,7 +24543,7 @@ var init_save_decisions = __esm({
 });
 
 // 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";
 async function runGeneration(input, onProgress, deps = realDeps4) {
   let progress = { components: null, mapTokens: "idle", mapTokensEligible: null };
   const update = (change) => {
@@ -23747,7 +24629,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 });
@@ -30028,7 +30910,7 @@ var init_DoneStep = __esm({
 });
 
 // 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("~\\")) {
@@ -30042,7 +30924,7 @@ function normalizePath(input) {
     p = p.slice(1, -1);
   }
   p = expandTilde(p);
-  return resolve24(p);
+  return resolve25(p);
 }
 var init_path_utils = __esm({
   "packages/experience-design-system-cli/src/tui/import/steps/10-flow/support/path-utils.ts"() {
@@ -30070,12 +30952,12 @@ var init_use_blinking_cursor = __esm({
 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 join21 } from "node:path";
+import { dirname as dirname16, basename as basename6, join as join21 } from "node:path";
 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 {
@@ -31389,7 +32271,7 @@ var init_save = __esm({
       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)
     });
   }
@@ -31411,7 +32293,7 @@ var init_types9 = __esm({
 import { appendFileSync, writeFileSync } from "node:fs";
 import { mkdir as mkdir8 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join23, resolve as resolve25 } from "node:path";
+import { join as join23, resolve as resolve26 } from "node:path";
 function appendWizardLog(entry) {
   appendFileSync(WIZARD_LOG, JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry }) + "\n");
 }
@@ -31664,7 +32546,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);
@@ -31759,7 +32641,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 join24 } from "node:path";
+import { dirname as dirname17, join as join24 } from "node:path";
 async function logFilesIn(dir) {
   const entries = await readdir2(dir, { withFileTypes: true });
   const nested = await Promise.all(
@@ -31782,7 +32664,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()) {
@@ -31798,7 +32680,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), join24(contentfulDir, session));
+          result.folders += await removeEmptyFolders(dirname17(file), join24(contentfulDir, session));
         } catch {
         }
       }
@@ -31828,7 +32710,7 @@ __export(debug_store_exports, {
 });
 import { mkdir as mkdir9, writeFile as writeFile8 } from "node:fs/promises";
 import { existsSync as existsSync10, readdirSync as readdirSync4 } from "node:fs";
-import { join as join25, resolve as resolve26 } from "node:path";
+import { join as join25, resolve as resolve27 } from "node:path";
 function generateRunId() {
   const now = /* @__PURE__ */ new Date();
   const pad = (n) => String(n).padStart(2, "0");
@@ -31844,7 +32726,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;
   }
@@ -31873,7 +32755,7 @@ function currentSessionDir() {
 async function startDebugSessionIn(base, { replace = false } = {}) {
   try {
     if (!await isDebugModeEnabled()) return;
-    await mkdir9(join25(startSession(resolve26(base), { replace }), "debug"), { recursive: true });
+    await mkdir9(join25(startSession(resolve27(base), { replace }), "debug"), { recursive: true });
   } catch {
   }
 }
@@ -31887,7 +32769,7 @@ function nextImportRunDir(session) {
 }
 async function startImportRun(projectPath) {
   await startDebugSessionIn(projectPath);
-  if (!sessionDir) return join25(resolve26(projectPath), ".contentful");
+  if (!sessionDir) return join25(resolve27(projectPath), ".contentful");
   const dir = nextImportRunDir(sessionDir);
   await mkdir9(dir, { recursive: true });
   return dir;
@@ -32029,7 +32911,7 @@ var init_debug_store = __esm({
 });
 
 // packages/experience-design-system-cli/src/tui/help/file-locations.ts
-import { join as join26, resolve as resolve27 } from "node:path";
+import { join as join26, resolve as resolve28 } from "node:path";
 function describeFileLocations({
   contentfulBaseDir,
   debugModeEnabled,
@@ -32041,7 +32923,7 @@ function describeFileLocations({
       importFiles: `${join26("<project>", ".contentful")}/ (tokens.json, components.json)`
     };
   }
-  const base = contentfulBaseDir ? resolve27(contentfulBaseDir) : "<project>";
+  const base = contentfulBaseDir ? resolve28(contentfulBaseDir) : "<project>";
   const session = currentSessionDir2 ?? join26(base, ".contentful", "<date>-session-<n>");
   return {
     debugLogs: join26(session, "debug"),
@@ -32273,20 +33155,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"));
     });
   });
 }
@@ -33711,14 +34593,14 @@ function runDevWatch(args) {
     process.stderr.write("--watch only works from a checkout of the repo (scripts/dev.mjs is not in the package).\n");
     return Promise.resolve(1);
   }
-  return new Promise((resolve28) => {
+  return new Promise((resolve29) => {
     const child = spawn3(process.execPath, [script, ...args], { stdio: "inherit" });
     process.on("SIGINT", () => void 0);
-    child.on("exit", (code) => resolve28(code ?? 0));
+    child.on("exit", (code) => resolve29(code ?? 0));
     child.on("error", (err) => {
       process.stderr.write(`${err.message}
 `);
-      resolve28(1);
+      resolve29(1);
     });
   });
 }
@@ -33789,12 +34671,12 @@ function createProgram() {
 init_config();
 init_package_root();
 import { existsSync as existsSync12 } from "node:fs";
-import { mkdir as mkdir10, readFile as readFile19, rename as rename3, rmdir as rmdir2, unlink } from "node:fs/promises";
-import { dirname as dirname17, join as join28 } from "node:path";
+import { mkdir as mkdir10, readFile as readFile21, rename as rename3, rmdir as rmdir2, unlink } from "node:fs/promises";
+import { dirname as dirname18, join as join28 } from "node:path";
 var PACKAGE_NAME3 = "@contentful/experience-design-system-cli";
 async function readJson(path5) {
   try {
-    return JSON.parse(await readFile19(path5, "utf8"));
+    return JSON.parse(await readFile21(path5, "utf8"));
   } catch {
     return void 0;
   }
@@ -33816,7 +34698,7 @@ async function migrateOldConfig() {
     if (Object.keys(migrated).length > 0) await updateSettings2({ ...migrated, ...await readSettings2() });
     if (existsSync12(oldRuns)) {
       if (!existsSync12(runsFilePath2())) {
-        await mkdir10(dirname17(runsFilePath2()), { recursive: true });
+        await mkdir10(dirname18(runsFilePath2()), { recursive: true });
         await rename3(oldRuns, runsFilePath2());
       } else {
         await unlink(oldRuns);