@astryxdesign/cli 0.6.3-canary.d0d49a4 → 0.6.3-canary.dea6813

package/clients/cli/commands/build-theme.path-safety.test.mjs

@@ -7,15 +7,21 @@
  *   - Theme name with `..` segments cannot escape the output directory.
  *   - Theme name with `/` is rejected with a clear error (vs. ENOENT).
  *   - Multi-file write is atomic: if one file fails, none are left behind.
+ *   - An `--out` escape, or an output directory that cannot be created, fails
+ *     with a registered error code.
  *
  * Runs the CLI in-process (shared runCli harness) against a tiny synthetic theme file.
  */
 
-import {describe, it, expect, beforeEach, afterEach} from 'vitest';
+import {describe, it, expect, beforeAll, beforeEach, afterEach} from 'vitest';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
+import {ensureCoreBuilt} from './ensure-core-built.mjs';
 import {runCli} from '../../../test-utils/run-cli.mjs';
+import {themeBuild} from '../../../api/theme/build/build.mjs';
+import {AstryxError} from '../../../api/error.mjs';
+import {ERROR_CODES} from '../../../foundation/response/error-codes.mjs';
 
 function writeTheme(dir, name) {
   fs.mkdirSync(dir, {recursive: true});
@@ -93,3 +99,82 @@ describe('theme build path safety', () => {
     expect(entries).toEqual(['theme.mjs']);
   });
 });
+
+describe('theme build output-path failures carry registered codes', () => {
+  // These reach the output-path step, which runs after CSS generation.
+  beforeAll(() => {
+    ensureCoreBuilt();
+  }, 200_000);
+
+  const registered = new Set(Object.values(ERROR_CODES));
+
+  /** @param {string[]} args @param {string} cwd */
+  async function buildJson(args, cwd) {
+    const result = await runCli(['--json', 'theme', 'build', ...args], cwd);
+    return {result, envelope: JSON.parse(result.stdout)};
+  }
+
+  it('reports an --out path outside the project as ERR_PATH_TRAVERSAL', async () => {
+    const project = path.join(tmpDir, 'project');
+    const themeFile = writeTheme(path.join(project, 'themes'), 'ocean');
+
+    const {result, envelope} = await buildJson(
+      [path.relative(project, themeFile), '--out', '../escaped.css'],
+      project,
+    );
+
+    expect(result.code).toBe(1);
+    expect(envelope.code).toBe(ERROR_CODES.ERR_PATH_TRAVERSAL);
+    expect(registered.has(envelope.code)).toBe(true);
+    expect(fs.existsSync(path.join(tmpDir, 'escaped.css'))).toBe(false);
+  });
+
+  it('reports an --out path that escapes through a symlink as ERR_PATH_TRAVERSAL', async () => {
+    const project = path.join(tmpDir, 'project');
+    const outside = path.join(tmpDir, 'outside');
+    fs.mkdirSync(outside, {recursive: true});
+    const themeFile = writeTheme(path.join(project, 'themes'), 'ocean');
+    fs.symlinkSync(outside, path.join(project, 'link'), 'dir');
+
+    const {result, envelope} = await buildJson(
+      [path.relative(project, themeFile), '--out', 'link/escaped.css'],
+      project,
+    );
+
+    expect(result.code).toBe(1);
+    expect(envelope.code).toBe(ERROR_CODES.ERR_PATH_TRAVERSAL);
+    expect(fs.readdirSync(outside)).toEqual([]);
+  });
+
+  it('reports an output directory that cannot be created as ERR_WRITE_FAILED', async () => {
+    const project = path.join(tmpDir, 'project');
+    const themeFile = writeTheme(path.join(project, 'themes'), 'ocean');
+    // A regular file where the output directory would have to be created.
+    fs.writeFileSync(path.join(project, 'blocker'), '');
+
+    const {result, envelope} = await buildJson(
+      [path.relative(project, themeFile), '--out', 'blocker/ocean.css'],
+      project,
+    );
+
+    expect(result.code).toBe(1);
+    expect(envelope.code).toBe(ERROR_CODES.ERR_WRITE_FAILED);
+    expect(registered.has(envelope.code)).toBe(true);
+  });
+
+  it('themeBuild() rejects an escaping out path with an AstryxError', async () => {
+    const project = path.join(tmpDir, 'project');
+    const themeFile = writeTheme(path.join(project, 'themes'), 'ocean');
+
+    const build = themeBuild(
+      path.relative(project, themeFile),
+      {out: '../escaped.css'},
+      {cwd: project},
+    );
+
+    await expect(build).rejects.toBeInstanceOf(AstryxError);
+    await expect(build).rejects.toMatchObject({
+      code: ERROR_CODES.ERR_PATH_TRAVERSAL,
+    });
+  });
+});

package/clients/cli/commands/build-theme.variants.test.mjs

@@ -324,6 +324,82 @@ describe('theme build custom-variant augmentations', () => {
     );
   });
 
+  it('rejects a custom Heading type whose only declaration is blank', async () => {
+    const themeFile = writeTheme(
+      tmpDir,
+      `export default {
+        name: 'variants-theme',
+        tokens: { '--color-bg': '#fff' },
+        components: { heading: { 'type:hero': { fontSize: '' } } },
+      };\n`,
+    );
+
+    const result = await runCli(
+      ['theme', 'build', path.relative(tmpDir, themeFile)],
+      tmpDir,
+    );
+
+    expect(result.code).toBe(1);
+    expect(result.stderr).toContain(
+      'Custom Heading type "hero" needs a non-empty standalone',
+    );
+    expect(fs.existsSync(path.join(tmpDir, 'variants-theme.css'))).toBe(false);
+  });
+
+  it('rejects a custom Heading type whose every declaration the compiler drops', async () => {
+    const themeFile = writeTheme(
+      tmpDir,
+      `export default {
+        name: 'variants-theme',
+        tokens: { '--color-bg': '#fff' },
+        components: {
+          heading: { 'type:hero': { color: 'red; } body { color: blue' } },
+        },
+      };\n`,
+    );
+
+    const result = await runCli(
+      ['--json', 'theme', 'build', path.relative(tmpDir, themeFile)],
+      tmpDir,
+    );
+
+    expect(result.code).toBe(1);
+    const envelope = JSON.parse(result.stdout);
+    expect(envelope.code).toBe('ERR_THEME_INVALID');
+    expect(envelope.error).toContain('Custom Heading type "hero"');
+    expect(fs.existsSync(path.join(tmpDir, 'variants-theme.css'))).toBe(false);
+    expect(
+      fs.existsSync(path.join(tmpDir, 'variants-theme.variants.d.ts')),
+    ).toBe(false);
+  });
+
+  it('builds a custom Heading type that keeps one valid declaration', async () => {
+    const themeFile = writeTheme(
+      tmpDir,
+      `export default {
+        name: 'variants-theme',
+        tokens: { '--color-bg': '#fff' },
+        components: {
+          heading: {
+            'type:hero': { fontSize: '80px', color: 'red; } body { color: blue' },
+          },
+        },
+      };\n`,
+    );
+
+    const result = await runCli(
+      ['--json', 'theme', 'build', path.relative(tmpDir, themeFile)],
+      tmpDir,
+    );
+
+    expect(result.code).toBe(0);
+    const envelope = JSON.parse(result.stdout);
+    expect(envelope.data.outputs.variantsDts).toBe(
+      'variants-theme.variants.d.ts',
+    );
+    expect(envelope.data.warnings.join('\n')).toContain('Declaration dropped');
+  });
+
   it('makes generated custom component prop values type-check through public subpaths', async () => {
     const themeFile = writeTheme(
       tmpDir,

package/clients/cli/commands/build.doc.mjs

@@ -44,7 +44,10 @@ export const doc = {
   ],
   exitCodes: [
     {code: 0, when: 'success (including zero matches)'},
-    {code: 1, when: 'invalid --type or a non-positive --limit'},
+    {
+      code: 1,
+      when: 'invalid --type, a non-positive --limit, or a query when @astryxdesign/core cannot be found (the playbook needs no core)',
+    },
   ],
   related: ['search', 'template', 'component', 'hook', 'init'],
 };

package/clients/cli/commands/build.exit-codes-doc.test.mjs

@@ -0,0 +1,50 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file `astryx build` documents that a query needs @astryxdesign/core while
+ * the playbook does not, and exits as documented without it.
+ */
+
+import {describe, it, expect, beforeEach, afterEach} from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import {runCli} from '../../../test-utils/run-cli.mjs';
+import {doc as buildDoc} from './build.doc.mjs';
+
+const SLOW = 30_000;
+
+/** @type {string} */
+let tmpDir;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'astryx-build-no-core-'));
+  fs.writeFileSync(path.join(tmpDir, 'package.json'), JSON.stringify({name: 'consumer'}));
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, {recursive: true, force: true});
+});
+
+/** @param {number} code */
+const exitWhen = code => buildDoc.exitCodes?.find(e => e.code === code)?.when ?? '';
+
+describe('astryx build without @astryxdesign/core', () => {
+  it('the CommandDoc lists a query without core under exit 1, and both modes exit 1', async () => {
+    expect(exitWhen(1)).toMatch(/a query when @astryxdesign\/core cannot be found/);
+
+    const text = await runCli(['build', 'dashboard'], tmpDir);
+    const json = await runCli(['--json', 'build', 'dashboard'], tmpDir);
+    expect(text.status).toBe(1);
+    expect(json.status).toBe(1);
+    expect(JSON.parse(json.stdout).error).toMatch(/@astryxdesign\/core/);
+  }, SLOW);
+
+  it('the CommandDoc says the playbook needs no core, and it exits 0', async () => {
+    expect(exitWhen(1)).toMatch(/the playbook needs no core/);
+
+    const {status, stdout} = await runCli(['--json', 'build'], tmpDir);
+    expect(status).toBe(0);
+    expect(JSON.parse(stdout).type).toBe('build.help');
+  }, SLOW);
+});

package/clients/cli/commands/build.mjs

@@ -22,9 +22,9 @@ import {
   emit,
   section,
   text,
+  list,
   record,
   records,
-  ARROW,
 } from '../formatters/index.mjs';
 import {cliError} from '../lib/cli-error.mjs';
 import {defineCommand} from '../lib/define-command.mjs';
@@ -33,46 +33,33 @@ import {doc as buildCommand} from './build.doc.mjs';
 import {doc as buildFn} from '../../../api/build/build.doc.mjs';
 
 /**
- * Emit the build playbook (shown when `build` is run with no query).
- * @param {string} run - The CLI invocation prefix (e.g. `npx astryx`).
+ * Playbook commands as records whose field names are the JSON keys, so a
+ * reader can grep `^command:`. The command is run with the caller's invocation.
+ * @type {import('../formatters/index.mjs').RecordOptions}
  */
-function printPlaybook(run) {
+const COMMAND_RECORDS = {
+  fields: ['command', 'purpose'],
+  format: {command: command => formatCliCommand(command)},
+};
+
+/**
+ * Emit the build playbook (shown when `build` is run with no query) — a
+ * projection of the `build.help` data, so text and JSON carry the same steps.
+ * @param {import('../../../api/build/build.type.mjs').BuildHelpResponse['data']} playbook
+ */
+function printPlaybook(playbook) {
   emit(
-    section('How to build a page with Astryx'),
-    text(
-      [
-        "1. Find a starting point for what you're building:",
-        `     ${run} build "<what you're building>"`,
-        `   ${ARROW} returns the closest [page] template, the [block]s that cover parts,`,
-        '     and the [component]s to fill the gaps, with a "Compose:" suggestion.',
-      ].join('\n'),
-    ),
-    text(
-      [
-        `2. If a [page] template matches ${ARROW} scaffold it and adapt:`,
-        `     ${run} template <name> [path]`,
-      ].join('\n'),
-    ),
-    text(
-      [
-        `3. If nothing matches exactly ${ARROW} compose:`,
-        `     ${run} template <name> --skeleton   # study a close page's layout`,
-        `     ${run} template <BlockName>         # drop in each block from the kit`,
-        `     ${run} component <Name>             # fill remaining gaps (read props)`,
-      ].join('\n'),
-    ),
-    text(
-      [
-        '4. Rules (keep it on-system):',
-        '   - No <div>/raw HTML for layout — use VStack/HStack/Grid/Stack/Card etc.',
-        `   - No style={{}} — use component props; design tokens via \`${run} docs tokens\`.`,
-        '   - Wrap the app in <Theme theme={...}> and import core reset.css + astryx.css.',
-      ].join('\n'),
-    ),
-    text(
-      `Tip: \`${run} build "<idea>"\` is the fastest way in. For a neutral ` +
-        `lookup of any component/doc/template, use \`${run} search <query>\`.`,
-    ),
+    section(playbook.title),
+    ...playbook.steps.flatMap((step, i) => [
+      section(`${i + 1}. ${step.title}`),
+      records(step.commands, COMMAND_RECORDS),
+      step.returns ? record({returns: step.returns}) : null,
+    ]),
+    section(`${playbook.steps.length + 1}. Rules (keep it on-system)`),
+    list(playbook.rules),
+    ...(playbook.related.length > 0
+      ? [section('Related'), records(playbook.related, COMMAND_RECORDS)]
+      : []),
   );
 }
 
@@ -91,7 +78,10 @@ export function registerBuild(program) {
 
       // No query → the playbook. Still routed through the API for the envelope.
       if (!query || !String(query).trim()) {
-        const result = await buildApi(undefined, {cwd: process.cwd()});
+        const result =
+          /** @type {import('../../../api/build/build.type.mjs').BuildHelpResponse} */ (
+            await buildApi(undefined, {cwd: process.cwd()})
+          );
         // The playbook is a document, not a lookup: one doc, always the same
         // one. Counting it as a result keeps "what did this run answer with"
         // true for the no-argument form too.
@@ -100,7 +90,7 @@ export function registerBuild(program) {
           jsonOut(result);
           return playbook;
         }
-        printPlaybook(run);
+        printPlaybook(result.data);
         return playbook;
       }
 
@@ -251,12 +241,7 @@ export function registerBuild(program) {
           'FRAME + FOUNDATION',
           'Always-available shell + layout/text/action primitives.',
         ),
-        record({
-          frame,
-          foundation,
-          setup:
-            'import "@astryxdesign/core/reset.css" + "astryx.css"; no <div>/style for layout — use Stack/Grid + tokens',
-        }),
+        record({frame, foundation}),
       );
 
       // Last, so it is the line the reader leaves with — and only when the kit

package/clients/cli/commands/build.playbook.test.mjs

@@ -0,0 +1,75 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file The no-query `build` playbook is data. `--json` carries every step,
+ * rule and command; the text output is rendered from those values and shows
+ * nothing the envelope lacks.
+ */
+
+import {describe, it, expect} from 'vitest';
+import * as path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {runCli} from '../../../test-utils/run-cli.mjs';
+import {program} from '../index.mjs';
+
+// Run against the monorepo root so @astryxdesign/core is discoverable.
+const REPO = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../..');
+const SLOW = 30_000;
+
+/** @param {string} s */
+const ascii = s => s.replace(/[\u2014\u2013]/g, '-');
+
+describe('build playbook: text is a projection of the JSON', () => {
+  it('prints exactly the commands, steps and rules the envelope carries', async () => {
+    const json = await runCli(['build', '--json'], REPO);
+    expect(json.status).toBe(0);
+    const {type, data} = JSON.parse(json.stdout);
+    expect(type).toBe('build.help');
+    expect(data.steps.length).toBeGreaterThan(0);
+    expect(data.rules.length).toBeGreaterThan(0);
+
+    const human = await runCli(['build'], REPO);
+    expect(human.status).toBe(0);
+    const out = human.stdout;
+
+    expect(out).toContain(ascii(data.title));
+    for (const step of data.steps) {
+      expect(out).toContain(ascii(step.title));
+      if (step.returns) expect(out).toContain(ascii(step.returns));
+    }
+    for (const rule of data.rules) expect(out).toContain(ascii(rule));
+
+    /** @type {Array<{command: string, purpose?: string}>} */
+    const commands = [
+      ...data.steps.flatMap((/** @type {any} */ s) => s.commands),
+      ...data.related,
+    ];
+    // Each command is one record whose field names are the JSON keys:
+    // `command:` (run with the caller's invocation), then `purpose:`.
+    const printed = out
+      .split('\n')
+      .filter(line => line.startsWith('command: '))
+      .map(line => line.slice('command: '.length).trim());
+    expect(printed).toHaveLength(commands.length);
+    commands.forEach(({command, purpose}, i) => {
+      expect(printed[i].endsWith(` ${command}`)).toBe(true);
+      if (purpose) expect(out).toContain(`purpose: ${ascii(purpose)}`);
+    });
+    // No column the handler drew itself.
+    expect(out).not.toMatch(/ {2,}# /);
+  }, SLOW);
+
+  it('names only commands this CLI registers', async () => {
+    const {stdout} = await runCli(['build', '--json'], REPO);
+    const {data} = JSON.parse(stdout);
+    const registered = new Set(program.commands.map(c => c.name()));
+    const commands = [
+      ...data.steps.flatMap((/** @type {any} */ s) => s.commands),
+      ...data.related,
+    ];
+    expect(commands.length).toBeGreaterThan(0);
+    for (const {command} of commands) {
+      expect(registered.has(command.split(' ')[0])).toBe(true);
+    }
+  }, SLOW);
+});

package/clients/cli/commands/build.text-fields.test.mjs

@@ -0,0 +1,40 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file `build "<idea>"` text output names only fields the `build.kit`
+ * envelope carries — on the kit itself or on its entries.
+ */
+
+import {describe, it, expect} from 'vitest';
+import * as path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {runCli} from '../../../test-utils/run-cli.mjs';
+
+// Run against the monorepo root so @astryxdesign/core is discoverable.
+const REPO = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../..');
+const SLOW = 60_000;
+
+describe('build kit text fields mirror the JSON keys', () => {
+  it('prints no field the envelope lacks', async () => {
+    const json = await runCli(['build', 'analytics dashboard', '--json', '--verbose'], REPO);
+    expect(json.status).toBe(0);
+    const {data} = JSON.parse(json.stdout);
+    const keys = new Set([
+      ...Object.keys(data),
+      ...[...data.pages, ...data.blocks, ...data.domain].flatMap(e => Object.keys(e)),
+    ]);
+
+    const human = await runCli(['build', 'analytics dashboard', '--verbose'], REPO);
+    expect(human.status).toBe(0);
+    const fields = [
+      ...new Set(
+        human.stdout
+          .split('\n')
+          .map(line => /^([A-Za-z]+):\s/.exec(line)?.[1])
+          .filter(Boolean),
+      ),
+    ];
+    expect(fields).toContain('frame');
+    for (const field of fields) expect(keys).toContain(field);
+  }, SLOW);
+});

package/clients/cli/commands/component/index.mjs

@@ -26,7 +26,6 @@ import {defineCommand} from '../../lib/define-command.mjs';
 import {resultSet} from '../../../../foundation/debug/index.mjs';
 import {ERROR_CODES} from '../../../../foundation/response/error-codes.mjs';
 import {component as componentApi} from '../../../../api/component/component.mjs';
-import {findRelatedBlocks} from '../../../../api/template/template.mjs';
 import {Project} from '../../../../foundation/config/project.mjs';
 import {warnOnIntegrationIssues} from '../../../../foundation/integrations/integration-warnings.mjs';
 import {doc as componentCommand} from '../component.doc.mjs';
@@ -235,18 +234,14 @@ export function registerComponent(program) {
         case 'component.detail': {
           const resolvedName = (name || '').replace(/^XDS/, '');
           const importHint = result.data.import;
+          if (result.data.parentDoc) emit(record(result.data, {fields: ['parentDoc']}));
           const doc =
             detail === 'brief'
               ? code(formatBrief(result.data, resolvedName, importHint, {themeData}))
               : detail === 'compact'
                 ? code(formatCompact(result.data, resolvedName, importHint))
                 : code(formatFull(result.data, {themeData, importHint}));
-          const related = await findRelatedBlocks(resolvedName);
-          emit(
-            doc,
-            related.length > 0 && section('Related block templates'),
-            related.length > 0 && records(related, {fields: ['dirName', 'description']}),
-          );
+          emit(doc);
           break;
         }
 

package/clients/cli/commands/component-package.test.mjs

@@ -120,4 +120,22 @@ describe('component() with --package option', () => {
     expect(result.data.source).toContain('ProfileCardShowcase');
     expect(result.data.aspectRatio).toBeCloseTo(16 / 9);
   });
+
+  // A legacy package ships docs only: --source and --blocks answer the same
+  // way scoped as unscoped, never falling back to the plain doc.
+  it('--package + --source reports the missing source, like the unscoped lookup', async () => {
+    await expect(
+      component('ProfileCard', {cwd: tmpDir, source: true}),
+    ).rejects.toMatchObject({code: 'ERR_NO_SOURCE'});
+    await expect(
+      component('ProfileCard', {cwd: tmpDir, package: '@test/ext', source: true}),
+    ).rejects.toMatchObject({code: 'ERR_NO_SOURCE'});
+  });
+
+  it('--package + --blocks returns the blocks, like the unscoped lookup', async () => {
+    const unscoped = await component('ProfileCard', {cwd: tmpDir, blocks: true});
+    const scoped = await component('ProfileCard', {cwd: tmpDir, package: '@test/ext', blocks: true});
+    expect(scoped.type).toBe('component.detail.blocks');
+    expect(scoped.data).toEqual(unscoped.data);
+  });
 });

package/clients/cli/commands/component-resolution.test.mjs

@@ -3,6 +3,7 @@
 import {describe, it, expect} from 'vitest';
 import {component} from '../../../api/component/component.mjs';
 import {findShowcase, findRelatedBlocks} from '../../../api/template/template.mjs';
+import {runCli} from '../../../test-utils/run-cli.mjs';
 
 const CWD = {cwd: '.'};
 
@@ -74,6 +75,26 @@ describe('component() sub-component scoping', () => {
     const result = await component('SideNav', CWD);
     expect(result.data.name).toBe('SideNav');
   });
+
+  // `parentDoc` is part of the component.detail schema: the text view
+  // projects it under the same key.
+  it('component("HStack") names its parent doc in JSON and text', async () => {
+    const result = await component('HStack', CWD);
+    expect(result.data.parentDoc).toBe('Stack');
+
+    const text = await runCli(['component', 'HStack'], process.cwd());
+    expect(text.code).toBe(0);
+    expect(text.stdout).toMatch(/^parentDoc: +Stack$/m);
+  });
+
+  it('component("Stack") carries no parentDoc in JSON or text', async () => {
+    const result = await component('Stack', CWD);
+    expect(result.data).not.toHaveProperty('parentDoc');
+
+    const text = await runCli(['component', 'Stack'], process.cwd());
+    expect(text.code).toBe(0);
+    expect(text.stdout).not.toMatch(/^parentDoc:/m);
+  });
 }, SCAN_TIMEOUT);
 
 // ─── Bug: findShowcase priority ─────────────────────────────────

package/clients/cli/commands/component.test.mjs

@@ -13,6 +13,9 @@ import {
   levenshteinDistance,
   findClosestComponents,
 } from './component/index.mjs';
+import {runCli} from '../../../test-utils/run-cli.mjs';
+
+const REPO_ROOT = path.resolve(import.meta.dirname, '../../../../..');
 
 let tmpDir;
 
@@ -591,3 +594,19 @@ describe('searchComponents', () => {
     expect(results.length).toBe(0);
   });
 });
+
+describe('component <Name> text output', () => {
+  // The text is a projection of the JSON envelope: it may show less, never
+  // data the envelope does not carry.
+  it('shows no related-block records that the JSON lacks', async () => {
+    const json = await runCli(['--json', 'component', 'Button'], REPO_ROOT);
+    expect(json.code).toBe(0);
+    expect(JSON.stringify(JSON.parse(json.stdout).data)).not.toContain('dirName');
+
+    const text = await runCli(['component', 'Button'], REPO_ROOT);
+    expect(text.code).toBe(0);
+    expect(text.stdout).toContain('# Button');
+    expect(text.stdout).not.toMatch(/^dirName:/m);
+    expect(text.stdout).not.toContain('Related block templates');
+  }, 30_000);
+});

package/clients/cli/commands/detail-levels.test.mjs

@@ -52,7 +52,7 @@ describe('--detail level ordering: component --list', () => {
 
   it('brief is names-only (no targets, import hints, or prose descriptions)', () => {
     expect(brief).not.toMatch(/Targets:/);
-    expect(brief).not.toMatch(/\u2190 from/);
+    expect(brief).not.toMatch(/<- from/);
     // Names only — should contain XDS component names but no " — " desc separator.
     expect(brief).toMatch(/Button/);
     expect(brief).not.toMatch(/ \u2014 /);
@@ -66,7 +66,7 @@ describe('--detail level ordering: component --list', () => {
 
   it('full has dense per-entry docs (props, targets, and import hints)', () => {
     expect(full).toMatch(/Targets:/);
-    expect(full).toMatch(/\u2190 from/);
+    expect(full).toMatch(/<- from/);
     // Prop name lists appear in the dense brief-all rendering.
     expect(full).toMatch(/children/);
   });