@astryxdesign/cli 0.6.3 → 0.6.4-canary.0e1fbdb

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

@@ -0,0 +1,341 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Multi-selector component lookup contract: one ordered batch envelope,
+ * complete per-selector states, unchanged single-selector responses, and matching
+ * text/JSON exit behavior.
+ */
+
+import {describe, it, expect} from 'vitest';
+import * as path from 'node:path';
+import {
+  component,
+  COMPONENT_BATCH_SELECTOR_LIMIT,
+} from '../../../api/component/component.mjs';
+import {runCli} from '../../../test-utils/run-cli.mjs';
+
+const REPO_ROOT = path.resolve(import.meta.dirname, '../../../../..');
+const SLOW = 60_000;
+
+describe('component() batch lookup', () => {
+  it(
+    'keeps one found row per selector, in order, including duplicates',
+    async () => {
+      const result = await component(['Button', 'Badge', 'Button'], {
+        cwd: REPO_ROOT,
+        detail: 'brief',
+      });
+
+      expect(result.type).toBe('component.batch');
+      expect(result.data.count).toBe(3);
+      expect(result.data.results.map(row => row.selector)).toEqual([
+        'Button',
+        'Badge',
+        'Button',
+      ]);
+      expect(result.data.results.map(row => row.status)).toEqual([
+        'found',
+        'found',
+        'found',
+      ]);
+      expect(
+        result.data.results.map(row =>
+          row.status === 'found' ? row.result.type : null,
+        ),
+      ).toEqual(['component.detail', 'component.detail', 'component.detail']);
+    },
+    SLOW,
+  );
+
+  it(
+    'applies every focused projection to each found row',
+    async () => {
+      const projections = [
+        {options: {props: true}, expectedType: 'component.detail.props'},
+        {options: {source: true}, expectedType: 'component.detail.source'},
+        {options: {showcase: true}, expectedType: 'component.detail.showcase'},
+        {options: {blocks: true}, expectedType: 'component.detail.blocks'},
+      ];
+      for (const projection of projections) {
+        const result = await component(['Button', 'Card'], {
+          cwd: REPO_ROOT,
+          ...projection.options,
+        });
+        expect(result.type).toBe('component.batch');
+        expect(
+          result.data.results.map(row =>
+            row.status === 'found' ? row.result.type : null,
+          ),
+        ).toEqual([projection.expectedType, projection.expectedType]);
+      }
+    },
+    SLOW,
+  );
+
+  it(
+    'uses input shape to distinguish catalog, single, and batch calls',
+    async () => {
+      expect((await component(undefined, {cwd: REPO_ROOT})).type).toBe(
+        'component.list',
+      );
+      expect((await component('Button', {cwd: REPO_ROOT})).type).toBe(
+        'component.detail',
+      );
+
+      const emptyBatch = await component([], {cwd: REPO_ROOT});
+      expect(emptyBatch).toEqual({
+        type: 'component.batch',
+        data: {count: 0, results: []},
+      });
+      expect(
+        await component([], {
+          cwd: REPO_ROOT,
+          list: true,
+          category: 'Form',
+        }),
+      ).toEqual(emptyBatch);
+
+      const oneRowBatch = await component(['Button'], {
+        cwd: REPO_ROOT,
+        detail: 'brief',
+      });
+      expect(oneRowBatch).toMatchObject({
+        type: 'component.batch',
+        data: {
+          count: 1,
+          results: [
+            {
+              selector: 'Button',
+              status: 'found',
+              result: {type: 'component.detail'},
+            },
+          ],
+        },
+      });
+    },
+    SLOW,
+  );
+
+  it('rejects an oversized array before component resolution starts', async () => {
+    const selectors = Array.from(
+      {length: COMPONENT_BATCH_SELECTOR_LIMIT + 1},
+      () => 'Button',
+    );
+    await expect(
+      component(selectors, {
+        cwd: path.join(REPO_ROOT, 'missing-batch-cwd'),
+      }),
+    ).rejects.toMatchObject({
+      code: 'ERR_INVALID_ARGUMENT',
+      message: `Component batch accepts at most ${COMPONENT_BATCH_SELECTOR_LIMIT} selectors; received ${selectors.length}`,
+    });
+  });
+
+  it(
+    'keeps receipt invariants across a deterministic selector chaos matrix',
+    async () => {
+      const found = new Set(['Button', 'Card']);
+      const selectorCases = [
+        [],
+        ['Button'],
+        ['ZzzNope99'],
+        ['Button', 'Button'],
+        ['ZzzNope98', 'ZzzNope99'],
+        ['Button', 'ZzzNope99', 'Card'],
+        ['ZzzNope99', 'Button', 'ZzzNope99', 'Button'],
+        ['Card', 'Button', 'Card', 'ZzzNope98', 'Button'],
+      ];
+
+      for (const selectors of selectorCases) {
+        const result = await component(selectors, {
+          cwd: REPO_ROOT,
+          detail: 'brief',
+        });
+        expect(result.type).toBe('component.batch');
+        expect(result.data.count).toBe(selectors.length);
+        expect(result.data.results.map(row => row.selector)).toEqual(selectors);
+        expect(result.data.results.map(row => row.status)).toEqual(
+          selectors.map(selector =>
+            found.has(selector) ? 'found' : 'not_found',
+          ),
+        );
+        for (const row of result.data.results) {
+          if (row.status === 'found') {
+            expect(row.result.type).toBe('component.detail');
+          } else {
+            expect(row.code).toBe('ERR_UNKNOWN_COMPONENT');
+          }
+        }
+      }
+    },
+    SLOW,
+  );
+
+  it(
+    'composes every detail and language control over a batch',
+    async () => {
+      /** @type {Array<{detail?: 'full'|'compact'|'brief'; lang?: string; zh?: boolean; dense?: boolean}>} */
+      const controls = [
+        {detail: 'brief'},
+        {detail: 'compact'},
+        {detail: 'full'},
+        {lang: 'en'},
+        {lang: 'dense'},
+        {zh: true},
+        {dense: true},
+      ];
+      for (const control of controls) {
+        const result = await component(['Button', 'Card'], {
+          cwd: REPO_ROOT,
+          ...control,
+        });
+        expect(result.type).toBe('component.batch');
+        expect(result.data.results).toHaveLength(2);
+        expect(
+          result.data.results.every(
+            row =>
+              row.status === 'found' && row.result.type === 'component.detail',
+          ),
+        ).toBe(true);
+      }
+    },
+    SLOW,
+  );
+});
+
+describe('astryx component batch lookup', () => {
+  it('documents variadic selector grammar in --help', async () => {
+    const run = await runCli(['component', '--help'], REPO_ROOT);
+    expect(run.code).toBe(0);
+    expect(run.stdout).toContain(
+      'Usage: astryx component [options] [names...]',
+    );
+    expect(run.stdout).toContain('@scope/package@version/Name');
+    expect(run.stdout).toContain('Two or more return one ordered batch');
+    expect(run.stdout).toContain('At most 100 selectors');
+  });
+
+  it(
+    'keeps catalog and single-result CLI envelopes at zero and one selectors',
+    async () => {
+      const catalog = await runCli(['--json', 'component'], REPO_ROOT);
+      expect(catalog.code).toBe(0);
+      expect(JSON.parse(catalog.stdout).type).toBe('component.list');
+
+      const single = await runCli(
+        ['--json', '--detail', 'brief', 'component', 'Button'],
+        REPO_ROOT,
+      );
+      expect(single.code).toBe(0);
+      expect(JSON.parse(single.stdout).type).toBe('component.detail');
+    },
+    SLOW,
+  );
+
+  it(
+    'emits one component.batch JSON envelope for several found selectors',
+    async () => {
+      const run = await runCli(
+        ['--json', '--detail', 'brief', 'component', 'Button', 'Badge'],
+        REPO_ROOT,
+      );
+      expect(run.code).toBe(0);
+      const envelope = JSON.parse(run.stdout);
+      expect(envelope.type).toBe('component.batch');
+      expect(envelope.data.count).toBe(2);
+      expect(envelope.data.results.map(row => row.selector)).toEqual([
+        'Button',
+        'Badge',
+      ]);
+      expect(envelope.data.results.every(row => row.status === 'found')).toBe(
+        true,
+      );
+    },
+    SLOW,
+  );
+
+  it(
+    'rejects an oversized batch before emitting JSON or text results',
+    async () => {
+      const selectors = Array.from(
+        {length: COMPONENT_BATCH_SELECTOR_LIMIT + 1},
+        () => 'Button',
+      );
+      const json = await runCli(
+        ['--json', 'component', ...selectors],
+        REPO_ROOT,
+      );
+      expect(json.code).toBe(1);
+      expect(JSON.parse(json.stdout)).toMatchObject({
+        code: 'ERR_INVALID_ARGUMENT',
+        error: `Component batch accepts at most ${COMPONENT_BATCH_SELECTOR_LIMIT} selectors; received ${selectors.length}`,
+      });
+      expect(JSON.parse(json.stdout).type).toBeUndefined();
+
+      const text = await runCli(['component', ...selectors], REPO_ROOT);
+      expect(text.code).toBe(1);
+      expect(text.stdout + text.stderr).toContain(
+        `accepts at most ${COMPONENT_BATCH_SELECTOR_LIMIT} selectors`,
+      );
+    },
+    SLOW,
+  );
+
+  it(
+    'emits every row and exits 1 when one selector is not found',
+    async () => {
+      const run = await runCli(
+        ['--json', '--detail', 'brief', 'component', 'Button', 'ZzzNope99'],
+        REPO_ROOT,
+      );
+      expect(run.code).toBe(1);
+      const envelope = JSON.parse(run.stdout);
+      expect(envelope.type).toBe('component.batch');
+      expect(envelope.data.results).toMatchObject([
+        {selector: 'Button', status: 'found'},
+        {
+          selector: 'ZzzNope99',
+          status: 'not_found',
+          code: 'ERR_UNKNOWN_COMPONENT',
+        },
+      ]);
+    },
+    SLOW,
+  );
+
+  it(
+    'emits every failed row and exits 1 when no selector resolves',
+    async () => {
+      const run = await runCli(
+        ['--json', 'component', 'ZzzNope98', 'ZzzNope99'],
+        REPO_ROOT,
+      );
+      expect(run.code).toBe(1);
+      const envelope = JSON.parse(run.stdout);
+      expect(envelope.type).toBe('component.batch');
+      expect(envelope.data.count).toBe(2);
+      expect(envelope.data.results).toMatchObject([
+        {selector: 'ZzzNope98', status: 'not_found'},
+        {selector: 'ZzzNope99', status: 'not_found'},
+      ]);
+    },
+    SLOW,
+  );
+
+  it(
+    'projects every row in text and keeps the same failing exit status',
+    async () => {
+      const run = await runCli(
+        ['--detail', 'brief', 'component', 'Button', 'ZzzNope99'],
+        REPO_ROOT,
+      );
+      expect(run.code).toBe(1);
+      expect(run.stdout).toContain('count: 2');
+      expect(run.stdout).toMatch(/selector: Button\nstatus:\s+found/);
+      expect(run.stdout).toMatch(
+        /selector: ZzzNope99\nstatus:\s+not_found\ncode:\s+ERR_UNKNOWN_COMPONENT/,
+      );
+    },
+    SLOW,
+  );
+});

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

@@ -71,7 +71,7 @@ function createFixture({
   );
   fs.writeFileSync(
     path.join(compDir, 'MetaAppShell.doc.mjs'),
-    `export const docs = {\n  name: 'MetaAppShell',\n  usage: { description: 'Meta-flavored app shell.' },\n  props: [{ name: 'title', type: 'string', description: 'Header title' }],\n};\n`,
+    `export default {\n  type: 'component',\n  name: 'MetaAppShell',\n  usage: { description: 'Meta-flavored app shell.' },\n  props: [{ name: 'title', type: 'string', description: 'Header title' }],\n};\n`,
   );
   if (withSource) {
     fs.writeFileSync(
@@ -82,7 +82,7 @@ function createFixture({
   if (extraComponent) {
     fs.writeFileSync(
       path.join(compDir, `${extraComponent}.doc.mjs`),
-      `export const docs = {\n  name: '${extraComponent}',\n  usage: { description: '${extraComponent} from meta.' },\n};\n`,
+      `export default {\n  type: 'component',\n  name: '${extraComponent}',\n  usage: { description: '${extraComponent} from meta.' },\n  props: [],\n};\n`,
     );
     fs.writeFileSync(
       path.join(compDir, `${extraComponent}.tsx`),
@@ -100,7 +100,7 @@ function createFixture({
       : '';
     fs.writeFileSync(
       path.join(entryDir, `${entryPoint.component}.doc.mjs`),
-      `export const docs = {\n  name: '${entryPoint.component}',${ownSpecifier}\n  usage: { description: '${entryPoint.component} from an entry point.' },\n};\n`,
+      `export default {\n  type: 'component',\n  name: '${entryPoint.component}',${ownSpecifier}\n  usage: { description: '${entryPoint.component} from an entry point.' },\n  props: [],\n};\n`,
     );
   }
 
@@ -277,6 +277,95 @@ describe('component() — integration ownership via config', () => {
     expect(result.data.import).toBe(`${INTEGRATION_NAME}/Toolbar/Search`);
   });
 
+  it('reports every installed candidate for an ambiguous batch selector', async () => {
+    createFixture({extraComponent: 'AppShell'});
+    const result = await component(['MetaAppShell', 'AppShell'], {cwd: tmpDir});
+    expect(result.type).toBe('component.batch');
+    expect(result.data.results[0]).toMatchObject({
+      selector: 'MetaAppShell',
+      status: 'found',
+    });
+    expect(result.data.results[1]).toMatchObject({
+      selector: 'AppShell',
+      status: 'ambiguous',
+      code: 'ERR_UNKNOWN_COMPONENT',
+    });
+    expect(result.data.results[1].candidates).toEqual(
+      expect.arrayContaining([
+        {
+          package: CORE_PACKAGE,
+          component: 'AppShell',
+          kind: 'component',
+          installed: true,
+        },
+        {
+          package: INTEGRATION_NAME,
+          component: 'AppShell',
+          kind: 'component',
+          installed: true,
+        },
+      ]),
+    );
+  });
+
+  it('keeps the single-result envelope for one package-qualified selector', async () => {
+    createFixture();
+    const result = await component('@test/meta@1.2.3/MetaAppShell', {
+      cwd: tmpDir,
+    });
+    expect(result.type).toBe('component.detail');
+    expect(result.data).toMatchObject({
+      name: 'MetaAppShell',
+      package: INTEGRATION_NAME,
+    });
+  });
+
+  it('resolves an exact installed package version and refuses another version', async () => {
+    createFixture();
+    const result = await component(
+      [
+        '@test/meta@1.2.3/MetaAppShell',
+        '@test/meta@9.9.9/MetaAppShell',
+      ],
+      {cwd: tmpDir},
+    );
+    expect(result.type).toBe('component.batch');
+    expect(result.data.results[0]).toMatchObject({
+      selector: '@test/meta@1.2.3/MetaAppShell',
+      status: 'found',
+      result: {type: 'component.detail'},
+    });
+    expect(result.data.results[1]).toMatchObject({
+      selector: '@test/meta@9.9.9/MetaAppShell',
+      status: 'not_found',
+      code: 'ERR_UNKNOWN_PACKAGE',
+      suggestions: [
+        {
+          name: 'astryx discover @test/meta@9.9.9',
+          reason: 'look up this package version',
+        },
+      ],
+    });
+  });
+
+  it('reports a package-qualified selector that conflicts with --package', async () => {
+    createFixture();
+    const result = await component(
+      ['@test/meta/MetaAppShell', 'Button'],
+      {cwd: tmpDir, package: CORE_PACKAGE},
+    );
+    expect(result.type).toBe('component.batch');
+    expect(result.data.results[0]).toMatchObject({
+      selector: '@test/meta/MetaAppShell',
+      status: 'error',
+      code: 'ERR_INVALID_ARGUMENT',
+    });
+    expect(result.data.results[1]).toMatchObject({
+      selector: 'Button',
+      status: 'found',
+    });
+  });
+
   it('JSON list includes integration components as {name, package} objects', async () => {
     createFixture();
     const result = await component(undefined, {cwd: tmpDir, list: true});

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

@@ -5,6 +5,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
 import {component} from '../../../api/component/component.mjs';
+import {runCli} from '../../../test-utils/run-cli.mjs';
 
 // These tests create a minimal monorepo fixture with:
 // - packages/core (symlinked to real @astryxdesign/core for loadDocs compatibility)
@@ -120,4 +121,49 @@ 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);
+  });
+
+  // `cwd` is an explicit API input: --blocks must discover from it, as
+  // --showcase does, not from the process working directory.
+  it('--blocks discovers blocks from options.cwd, like --showcase', async () => {
+    const showcase = await component('ProfileCard', {cwd: tmpDir, showcase: true});
+    expect(showcase.data.source).toContain('ProfileCardShowcase');
+
+    const blocks = await component('ProfileCard', {cwd: tmpDir, blocks: true});
+    expect(blocks.type).toBe('component.detail.blocks');
+    expect(blocks.data.showcase?.name).toBe('ProfileCardShowcase');
+  });
+
+  // List and detail report one import for a legacy package component; the
+  // text list projects the JSON value instead of deriving a Core path.
+  it('the names list gives a legacy package component the import its detail reports', async () => {
+    const detail = await component('ProfileCard', {cwd: tmpDir});
+    const list = await component(undefined, {cwd: tmpDir, list: true});
+    const entry = Object.values(list.data.components)
+      .flat()
+      .find(e => e.name === 'ProfileCard' && e.package === '@test/ext');
+    expect(entry?.import).toBe(detail.data.import);
+
+    const text = await runCli(['component', '--list'], tmpDir);
+    expect(text.code).toBe(0);
+    expect(text.stdout).toContain(`name:   ProfileCard\nimport: ${detail.data.import}  [@test/ext]`);
+    expect(text.stdout).not.toMatch(/^import: +@astryxdesign\/core\S* +\[@test\/ext\]$/m);
+  });
 });

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.doc.mjs

@@ -13,24 +13,37 @@ export const doc = {
   type: 'command',
   name: 'component',
   displayName: 'astryx component',
-  namespace: 'cli',
+  namespace: 'cli/commands',
   summary: 'List components or print component docs',
   description:
-    'Resolves a component by name across core and integration packages and prints ' +
-    'its authored doc, or lists the catalog grouped by category. Boolean flags narrow ' +
-    'a single component to just its props, source, showcase, or example blocks.',
+    'Resolves one or several components by exact selector across core and integration ' +
+    'packages and prints each authored doc, or lists the catalog grouped by category. ' +
+    "Use 'Button', 'widgets/Button', '@acme/widgets/Button', or " +
+    "'@acme/widgets@1.2.3/Button'. A version applies to the package and must match the " +
+    'installed version. Boolean flags narrow every resolved component to just its props, ' +
+    'source, showcase, or example blocks.',
   fn: 'component',
-  args: [{name: 'name', param: 'name', required: false}],
+  args: [
+    {
+      name: 'names',
+      param: 'name',
+      description:
+        'One or more exact selectors. Use Name, package/Name, @scope/package/Name, or @scope/package@version/Name. Two or more return one ordered batch. At most 100 selectors are accepted.',
+      required: false,
+      variadic: true,
+    },
+  ],
   options: [
     {
       flag: '--list',
       param: 'options.list',
-      description: 'List all components grouped by category',
+      description: 'List every component (the same as giving no name)',
     },
     {
       flag: '--category <category>',
       param: 'options.category',
-      description: 'List components in a specific category',
+      description:
+        'List one component group, e.g. --category Layout or --category Avatar (an unknown group lists the valid ones)',
     },
     {
       flag: '--props',
@@ -55,21 +68,26 @@ export const doc = {
     {
       flag: '--package <name>',
       param: 'options.package',
-      description: 'Scope lookup to an external package (e.g. @acme/xds-widgets)',
+      description:
+        'Scope lookup to an external package (e.g. @acme/xds-widgets)',
     },
   ],
   examples: [
     {label: 'Browse the catalog', cli: 'astryx component --list'},
+    {
+      label: 'Look up several components',
+      cli: 'astryx component Button Badge Text',
+    },
     {
       label: 'Props table as JSON',
-      cli: 'astryx component XDSButton --props --json',
+      cli: 'astryx component Button --props --json',
     },
   ],
   exitCodes: [
     {code: 0, when: 'success'},
     {
       code: 1,
-      when: 'unknown component, category, or package, or @astryxdesign/core cannot be resolved',
+      when: 'unknown component, category, or package; more than 100 selectors; any batch row is unresolved; or @astryxdesign/core cannot be resolved',
     },
   ],
   related: ['search', 'hook', 'docs', 'template', 'swizzle'],

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/);
   });