@astryxdesign/cli 0.6.4-canary.ed2e54e → 0.6.4

package/api/theme/add/add.staging.test.mjs

@@ -6,15 +6,14 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import {themeAdd} from './add.mjs';
 import {listThemes} from '../_adapter.mjs';
+import {isErrorCode} from '../../../foundation/response/error-codes.mjs';
 
 let tmpDir;
 let outsideDir;
 
 beforeEach(() => {
   tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'astryx-themeadd-staging-'));
-  outsideDir = fs.mkdtempSync(
-    path.join(os.tmpdir(), 'astryx-themeadd-outside-'),
-  );
+  outsideDir = fs.mkdtempSync(path.join(os.tmpdir(), 'astryx-themeadd-outside-'));
 });
 
 afterEach(() => {
@@ -23,61 +22,45 @@ afterEach(() => {
 });
 
 /**
- * Where `theme add` writes the first file of `slug`.
+ * Put a symlink where `theme add` stages the first file of `slug`.
  * @param {string} slug
+ * @param {string} target
  */
-function firstDestination(slug) {
+function plantStagingLink(slug, target) {
   const theme = listThemes().find(entry => entry.slug === slug);
   if (!theme) throw new Error(`missing bundled theme ${slug}`);
-  const dest = path.join(tmpDir, 'src', 'themes', slug, theme.files[0]);
+  const first = theme.files[0];
+  const dest = path.join(tmpDir, 'src', 'themes', slug, first);
   fs.mkdirSync(path.dirname(dest), {recursive: true});
+  fs.symlinkSync(target, `${dest}.${process.pid}.tmp`);
   return dest;
 }
 
-// Staging names are unpredictable and created exclusively, so an entry planted
-// at a predictable name beside the destination is never written through.
 describe('themeAdd staging writes stay inside the project', () => {
-  it('never writes through a link planted at a predictable staging name', async () => {
+  it('refuses a staging path that links outside the project', async () => {
     const victim = path.join(outsideDir, 'victim.txt');
     fs.writeFileSync(victim, 'outside\n');
-    const dest = firstDestination('stone');
-    fs.symlinkSync(victim, `${dest}.${process.pid}.tmp`);
-
-    await themeAdd('stone', {cwd: tmpDir});
+    const dest = plantStagingLink('stone', victim);
 
+    await expect(themeAdd('stone', {cwd: tmpDir})).rejects.toMatchObject({
+      code: 'ERR_PATH_TRAVERSAL',
+    });
     expect(fs.readFileSync(victim, 'utf-8')).toBe('outside\n');
-    expect(fs.lstatSync(dest).isFile()).toBe(true);
+    expect(fs.existsSync(dest)).toBe(false);
   });
 
-  it('never creates a file through a dangling link at a predictable staging name', async () => {
+  it('never creates a file through a dangling staging link', async () => {
     const victim = path.join(outsideDir, 'created.txt');
-    fs.symlinkSync(victim, `${firstDestination('stone')}.${process.pid}.tmp`);
-
-    await themeAdd('stone', {cwd: tmpDir});
-
-    expect(fs.existsSync(victim)).toBe(false);
-  });
-
-  it('refuses to replace a destination that links outside the project', async () => {
-    const victim = path.join(outsideDir, 'victim.txt');
-    fs.writeFileSync(victim, 'outside\n');
-    const dest = firstDestination('stone');
-    fs.symlinkSync(victim, dest);
+    plantStagingLink('stone', victim);
 
-    await expect(
-      themeAdd('stone', {cwd: tmpDir, overwrite: true}),
-    ).rejects.toMatchObject({code: 'ERR_PATH_TRAVERSAL'});
-    expect(fs.readFileSync(victim, 'utf-8')).toBe('outside\n');
-    expect(fs.lstatSync(dest).isSymbolicLink()).toBe(true);
-  });
+    let error;
+    try {
+      await themeAdd('stone', {cwd: tmpDir});
+    } catch (caught) {
+      error = caught;
+    }
 
-  it('never creates a file through a dangling destination link', async () => {
-    const victim = path.join(outsideDir, 'created.txt');
-    fs.symlinkSync(victim, firstDestination('stone'));
-
-    await expect(themeAdd('stone', {cwd: tmpDir})).rejects.toMatchObject({
-      code: 'ERR_PATH_TRAVERSAL',
-    });
+    expect(isErrorCode(error?.code)).toBe(true);
     expect(fs.existsSync(victim)).toBe(false);
   });
 });

package/api/theme/build/build.family.test.mjs

@@ -251,18 +251,23 @@ describe('themeBuildFamily()', () => {
     const dir = makeDir();
     const files = writeFamily(dir);
     const outputDir = path.join(dir, 'themes');
-    // A directory where the JS output goes fails its staging after the CSS
-    // output was already staged.
-    fs.mkdirSync(path.join(outputDir, `${FAMILY_KEY}.js`));
+    const blockedTmp = path.join(
+      outputDir,
+      `${FAMILY_KEY}.js.${process.pid}.tmp`,
+    );
+    fs.mkdirSync(blockedTmp);
 
     await expect(build(dir, files)).rejects.toThrow(
       /Failed to write theme outputs/,
     );
-    expect(fs.existsSync(path.join(outputDir, `${FAMILY_KEY}.css`))).toBe(false);
-    expect(fs.existsSync(path.join(outputDir, `${FAMILY_KEY}.d.ts`))).toBe(false);
+    for (const output of OUTPUTS) {
+      expect(fs.existsSync(path.join(outputDir, output))).toBe(false);
+    }
     expect(
-      fs.readdirSync(outputDir).filter(name => name.includes('.tmp-')),
-    ).toEqual([]);
+      fs.existsSync(
+        path.join(outputDir, `${FAMILY_KEY}.css.${process.pid}.tmp`),
+      ),
+    ).toBe(false);
   });
 
   it('rejects invalid graphs and keys before touching an existing trio', async () => {

package/api/theme/build/build.mjs

@@ -53,7 +53,6 @@ import {
 } from '../../../foundation/fs/path-safety.mjs';
 import {ERROR_CODES} from '../../../foundation/response/error-codes.mjs';
 import {AstryxError} from '../../error.mjs';
-import {applyWrites} from '../../integration/add-helpers.mjs';
 import {logger} from '../../logger.mjs';
 import {loadComponentDoc} from '../../../foundation/discovery/component-loader.mjs';
 import {
@@ -225,15 +224,26 @@ function staleBuildOutputs(writes, cwd) {
 /** @param {Array<{dest: string, content: string}>} writes */
 function writeBuildOutputs(writes) {
   if (writes.length === 0) return;
+  /** @type {Array<{tmp: string, dest: string}>} */
+  const staged = [];
   try {
-    applyWrites(
-      writes.map(write => ({
-        path: write.dest,
-        contents: write.content,
-        createOnly: false,
-      })),
-    );
+    fs.mkdirSync(path.dirname(writes[0].dest), {recursive: true});
+    for (const write of writes) {
+      const tmp = `${write.dest}.${process.pid}.tmp`;
+      fs.writeFileSync(tmp, write.content);
+      staged.push({tmp, dest: write.dest});
+    }
+    for (const stagedWrite of staged) {
+      fs.renameSync(stagedWrite.tmp, stagedWrite.dest);
+    }
   } catch (error) {
+    for (const stagedWrite of staged) {
+      try {
+        fs.rmSync(stagedWrite.tmp, {force: true});
+      } catch {
+        // Best effort: the command still fails and never reports success.
+      }
+    }
     const message = `Failed to write theme outputs: ${/** @type {Error} */ (error).message}`;
     throw new AstryxError(message, undefined, ERROR_CODES.ERR_WRITE_FAILED);
   }

package/api/upgrade/run/run.mjs

@@ -114,7 +114,7 @@ export async function run(options = {}, {cwd = process.cwd()} = {}) {
   // Resolve the source dir against the API's cwd (not process.cwd()) so a
   // programmatic caller in another directory scans the right tree. Confine it to
   // cwd: --apply rewrites files in place, so a `..`-escaping or out-of-tree
-  // absolute --path must be rejected (parity with template/theme/swizzle,
+  // absolute --path must be rejected (parity with template/theme/swizzle/layout,
   // and this is the most destructive command). allowAbsolute permits an absolute
   // path that still resolves inside cwd.
   let path_;
@@ -437,11 +437,9 @@ export async function run(options = {}, {cwd = process.cwd()} = {}) {
 
   const registryResult = await reconcileCompositions();
 
-  // A file a core codemod AND an integration codemod both changed is one file.
-  const mergedFilesChanged = new Set([
-    ...(coreResult?.changedFiles ?? []),
-    ...(integrationResult?.changedFiles ?? []),
-  ]).size;
+  const mergedFilesChanged =
+    (coreResult?.totalFilesChanged ?? 0) +
+    (integrationResult?.totalFilesChanged ?? 0);
   const mergedTransformsApplied =
     (coreResult?.totalTransformsApplied ?? 0) +
     (integrationResult?.totalTransformsApplied ?? 0);

package/api/upgrade/upgrade.type.mjs

@@ -119,11 +119,11 @@
  * @property {RegistryCompositionSummary} [data.registryCompositions]
  * @property {boolean} [data.complete] False when protected required changes remain.
  * @property {'ERR_CODEMOD_PROTECTED'} [data.errorCode] Stable incomplete-result code when complete is false.
- * @property {number} [data.filesChanged] Distinct files changed across core + integration codemods (apply mode). One file that four codemods each changed counts once.
+ * @property {number} [data.filesChanged] Total files changed across core + integration codemods (apply mode).
  * @property {string[]} [data.modifiedFiles] Project-relative files changed or previewed.
  * @property {ProtectedCodemodFile[]} [data.protectedFiles] Protected files that still require a codemod change after regeneration.
  * @property {Array<{file: string, location?: string, reason: string}>} [data.declinedCandidates] Candidates left unchanged because proof was insufficient.
- * @property {number} [data.transformsApplied] Total codemod changes. A code or config codemod counts once for each file it changed, so one file changed by four of them counts four times; a project codemod counts once, however many files it writes.
+ * @property {number} [data.transformsApplied] Total transforms that reported a change.
  * @property {Array<{file: string, codemod: string, error: string}>} [data.errors] Per-codemod errors, when any codemod failed.
  */
 

package/assets/codemods/__tests__/runner.test.mjs

@@ -46,9 +46,7 @@ describe('runCodemods — ordered dry-run state', () => {
       silent: true,
     });
 
-    // One file that two transforms changed is one file and two changes.
-    expect(preview.totalFilesChanged).toBe(1);
-    expect(preview.totalTransformsApplied).toBe(2);
+    expect(preview.totalFilesChanged).toBe(2);
     expect(preview.changedFiles).toEqual([
       path.join(srcDir, 'a.ts'),
       path.join(srcDir, 'a.ts'),

package/assets/codemods/integration-runner.mjs

@@ -67,6 +67,7 @@ export function runIntegrationCodemods(
   /** In-memory pipeline state keeps ordered dry-runs equivalent to apply. */
   const virtualContents = new Map(providedContents ?? []);
 
+  let totalFilesChanged = 0;
   let totalTransformsApplied = 0;
   /** @type {string[]} */
   const changedFiles = [];
@@ -114,6 +115,7 @@ export function runIntegrationCodemods(
       protection,
       contents: virtualContents,
     });
+    totalFilesChanged += r.filesChanged;
     totalTransformsApplied += r.filesChanged;
     changedFiles.push(...r.changedFiles);
     writtenFiles.push(...r.writtenFiles);
@@ -143,6 +145,7 @@ export function runIntegrationCodemods(
         protection,
         contents: virtualContents,
       });
+      totalFilesChanged += r.filesChanged;
       totalTransformsApplied += r.filesChanged;
       changedFiles.push(...r.changedFiles);
       writtenFiles.push(...r.writtenFiles);
@@ -151,9 +154,6 @@ export function runIntegrationCodemods(
     }
   }
 
-  // A file several codemods changed is one file; transforms count each change.
-  const totalFilesChanged = new Set(changedFiles).size;
-
   return {
     totalFilesChanged,
     totalTransformsApplied,

package/assets/codemods/runner.mjs

@@ -486,6 +486,7 @@ export async function runCodemods(
       (await import('jscodeshift')).default
     );
 
+  let totalFilesChanged = 0;
   let totalTransformsApplied = 0;
   let totalValidationBlocked = 0;
   /** @type {Array<{file: string, codemod: string, error: string}>} */
@@ -553,6 +554,7 @@ export async function runCodemods(
           protectionWriteCount = writtenFiles.length;
         }
         if (result.filesChanged > 0) {
+          totalFilesChanged += result.filesChanged;
           totalTransformsApplied += 1;
         }
         continue;
@@ -575,6 +577,7 @@ export async function runCodemods(
         changedFiles.push(...result.changedFiles);
         writtenFiles.push(...result.writtenFiles);
         if (result.filesChanged > 0) {
+          totalFilesChanged += result.filesChanged;
           totalTransformsApplied += result.filesChanged;
         }
         continue;
@@ -589,6 +592,7 @@ export async function runCodemods(
       protectedFiles.push(...result.protectedFiles);
       changedFiles.push(...result.changedFiles);
       writtenFiles.push(...result.writtenFiles);
+      totalFilesChanged += result.filesChanged;
       totalTransformsApplied += result.filesChanged;
       totalValidationBlocked += result.errors.filter(
         error =>
@@ -626,11 +630,6 @@ export async function runCodemods(
     );
   }
 
-  // A file several codemods changed is one file. `totalTransformsApplied` is
-  // unchanged: a code or config codemod counts each file it changed, and a
-  // project codemod counts once. The two answer different questions.
-  const totalFilesChanged = new Set(changedFiles).size;
-
   if (protectedFiles.length > 0) {
     const files = [...new Set(protectedFiles.map(item => item.file))];
     log.warn(

package/assets/docs/internationalization.doc.mjs

@@ -41,17 +41,15 @@ function App() {
           lang: 'tsx',
           label: 'Load an astryx locale catalog',
           code: `import {InternationalizationProvider} from '@astryxdesign/core/i18n';
-import frFR from '@astryxdesign/core/locales/fr-FR.generated.js';
+import fr from '@astryxdesign/core/locales/fr.json';
 
-<InternationalizationProvider
-  locale="fr-FR"
-  messages={{'fr-FR': frFR}}>
+<InternationalizationProvider locale="fr" messages={{fr}}>
   <App />
 </InternationalizationProvider>;`,
         },
         {
           type: 'prose',
-          text: 'Astryx ships English and first-party translations for supported locales. Compact runtime modules from `@astryxdesign/core/locales/*.generated.js` contain only the messages apps need; the existing `@astryxdesign/core/locales/*.json` files retain translator context. Until a locale is available, apps can pass a local catalog in either shape. Missing keys fall back through the locale chain to English (for example, `pt-BR` walks to `pt`, then to shipped `en`).',
+          text: 'Astryx ships English today, with first-party translations for other locales on the roadmap. Until a locale is available from `@astryxdesign/core/locales/*`, apps can pass a local catalog with the same shape. See `@astryxdesign/core/locales/en.json` for the current key inventory. Missing keys fall back through the locale chain to English (for example, `pt-BR` walks to `pt`, then to shipped `en`).',
         },
         {
           type: 'prose',
@@ -292,7 +290,7 @@ export default function App() {
         },
         {
           type: 'prose',
-          text: '`Catalog` types the rich `{defaultMessage, description?}` authoring shape. `RuntimeCatalog` types the generated key-to-message string map. `ProviderMessagesByLocale` accepts either shape for the provider, while `MessagesByLocale` keeps the original rich-only context shape.',
+          text: '`Catalog` types a single locale file; `MessagesByLocale` types the map passed to `messages`. A catalog entry uses the same `{defaultMessage, description?}` shape as `@astryxdesign/core/locales/en.json`.',
         },
       ],
     },
@@ -309,7 +307,7 @@ export default function App() {
           lang: 'tsx',
           label: 'Turn on pseudo-localization',
           code: `import {InternationalizationProvider} from '@astryxdesign/core/i18n';
-import pseudo from '@astryxdesign/core/locales/pseudo.generated.js';
+import pseudo from '@astryxdesign/core/locales/pseudo.json';
 
 <InternationalizationProvider locale="pseudo" messages={{pseudo}}>
   <App />

package/assets/docs/tree/integrations.doc.mjs

@@ -440,25 +440,6 @@ export const docs = {
         },
       ],
     },
-    {
-      title: 'Discover source',
-      category: 'guide',
-      content: [
-        {
-          type: 'prose',
-          text: '`astryx discover` lists the integrations an app has and, through discover sources, the ones it could add, with every version and what each one adds. An integration can supply a source by exporting an async function named `discover` from its integration module. Like `debug`, it is a named export, not a manifest field, so a CLI that predates it simply does not read it.',
-        },
-        {
-          type: 'code',
-          lang: 'typescript',
-          code: "// astryx.integration.ts\nimport type {DiscoverSource} from '@astryxdesign/cli/authoring';\n\nexport const discover: DiscoverSource = async ({signal, package: name, version}) => {\n  // Every package you know about, each with every version and what the\n  // requested (else latest) version adds.\n  return readCatalog({signal, name, version});\n};\n\nexport default {\n  components: './components',\n};",
-        },
-        {
-          type: 'prose',
-          text: 'A project can set the same function as `discover` in `astryx.config`. Discover calls every source, the project one first and then each integration in load order, and one that throws, runs past 30 seconds, or returns an invalid catalog never hides the others. It keeps the last good answer from each source in the per-user cache and uses it, with its date, when the source cannot be reached. Discover only reads: it prints the command that adds a package and never runs it. `astryx docs authoring discover-source` has the catalog shape.',
-        },
-      ],
-    },
     {
       title: 'How It Works',
       category: 'guide',
@@ -469,7 +450,7 @@ export const docs = {
         },
         {
           type: 'prose',
-          text: 'Runtime integration features — `debug`, `gapReport`, and `discover` — use named exports from the integration module rather than fields in the default manifest. The CLI discovers them alongside the manifest but loads them through the composition rules in `spec:AST-031`: every configured handler runs additively, each in isolation with its own copy of the event.',
+          text: 'Runtime integration features — `debug` and `gapReport` — use named exports from the integration module rather than fields in the default manifest. The CLI discovers them alongside the manifest but loads them through the composition rules in `spec:AST-031`: every configured handler runs additively, each in isolation with its own copy of the event.',
         },
         {
           type: 'prose',

package/assets/templates/blocks/components/InternationalizationProvider/InternationalizationProvider01ShippedLocale.tsx

@@ -4,7 +4,7 @@
 
 import {useState} from 'react';
 import {InternationalizationProvider} from '@astryxdesign/core/i18n';
-import frFR from '@astryxdesign/core/locales/fr-FR.generated.js';
+import frFR from '@astryxdesign/core/locales/fr-FR.json';
 import {Stack} from '@astryxdesign/core/Layout';
 import {
   SegmentedControl,

package/authoring/config/config.doc.mjs

@@ -60,14 +60,6 @@ export const doc = {
       example:
         "{ audience: 'internal', async handle(report, {signal}) { return sendGap(report, {signal}); } }",
     },
-    {
-      name: 'discover',
-      type: 'DiscoverSource',
-      description:
-        'Tell `astryx discover` which integrations this project could add: an async function that returns a catalog. An integration can provide one too, as a `discover` named export from its manifest. Discover calls every source, yours first, and one that fails never hides the others. Discover only reads; your package manager installs.',
-      example:
-        "async ({signal, package: name, version}) => fetchCatalog({signal, name, version})",
-    },
     {
       name: 'experimental',
       type: '{ xle?: { components?: Record<string, XleComponent> } }',
@@ -77,7 +69,7 @@ export const doc = {
           name: 'experimental.xle.components',
           type: 'Record<string, XleComponent>',
           description:
-            'No effect. Its only reader was the removed `layout` command. The key is still accepted so existing configs keep loading; delete it.',
+            'Custom components the layout expander (XLE) may emit, keyed by tag.',
         },
       ],
     },

package/authoring/config/parse.d.mts

@@ -30,7 +30,6 @@ export type XleComponent = import("./type.js").XleComponent;
 export type DebugConfig = import("./type.js").DebugConfig;
 export type DebugEventHandler = import("../debug/type.js").DebugEventHandler;
 export type GapReportHandler = import("../gap-report/type.js").GapReportHandler;
-export type DiscoverSource = import("../discover/type.js").DiscoverSource;
 import { z } from 'zod';
 declare const configSchema: z.ZodObject<{
     integrations: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -49,7 +48,6 @@ declare const configSchema: z.ZodObject<{
     }, z.core.$strict>>;
     debug: z.ZodOptional<z.ZodType<import("../debug/type.js").DebugEventHandler, any, z.core.$ZodTypeInternals<import("../debug/type.js").DebugEventHandler, any>>>;
     gapReport: z.ZodOptional<z.ZodType<import("../gap-report/type.js").GapReportHandler, any, z.core.$ZodTypeInternals<import("../gap-report/type.js").GapReportHandler, any>>>;
-    discover: z.ZodOptional<z.ZodType<import("../discover/type.js").DiscoverSource, any, z.core.$ZodTypeInternals<import("../discover/type.js").DiscoverSource, any>>>;
     experimental: z.ZodOptional<z.ZodObject<{
         xle: z.ZodOptional<z.ZodObject<{
             components: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{

package/authoring/config/parse.mjs

@@ -12,7 +12,6 @@
 import {z} from 'zod';
 import {formatZodError} from '../_shared/errors.mjs';
 import {parseGapReportHandler} from '../gap-report/parse.mjs';
-import {parseDiscoverSource} from '../discover/parse.mjs';
 
 /** @typedef {import('./type.js').AstryxConfig} AstryxConfig */
 /** @typedef {import('./type.js').PostCodemodHook} PostCodemodHook */
@@ -20,7 +19,6 @@ import {parseDiscoverSource} from '../discover/parse.mjs';
 /** @typedef {import('./type.js').DebugConfig} DebugConfig */
 /** @typedef {import('../debug/type.js').DebugEventHandler} DebugEventHandler */
 /** @typedef {import('../gap-report/type.js').GapReportHandler} GapReportHandler */
-/** @typedef {import('../discover/type.js').DiscoverSource} DiscoverSource */
 
 // Typed `z.custom` so `z.infer` reproduces the real function type (not `unknown`).
 const buildCommand = /** @type {z.ZodType<PostCodemodHook['buildCommand']>} */ (
@@ -68,22 +66,6 @@ const gapReportHandlerSchema = /** @type {z.ZodType<GapReportHandler>} */ (
   )
 );
 
-// The same check an integration's `discover` named export passes. Typed
-// z.custom preserves the public function type.
-const discoverSourceSchema = /** @type {z.ZodType<DiscoverSource>} */ (
-  z.custom(
-    value => {
-      try {
-        parseDiscoverSource(value, 'discover');
-        return true;
-      } catch {
-        return false;
-      }
-    },
-    {message: 'Expected a discover source function'},
-  )
-);
-
 const configSchema = z
   .object({
     integrations: z.array(z.string()).optional(),
@@ -94,7 +76,6 @@ const configSchema = z
       .optional(),
     debug: debugSchema.optional(),
     gapReport: gapReportHandlerSchema.optional(),
-    discover: discoverSourceSchema.optional(),
     experimental: z
       .object({
         xle: z

package/authoring/config/parse.test.mjs

@@ -63,14 +63,6 @@ describe('parseConfig (load boundary)', () => {
     ).toEqual({audience: 'internal', handle});
   });
 
-  it('accepts a discover source function and refuses anything else', () => {
-    const discover = async () => ({});
-    expect(parseConfig({discover}).discover).toBe(discover);
-    expect(reason({discover: 'https://example.com/catalog.json'})).toContain(
-      'discover',
-    );
-  });
-
   it('rejects obsolete or extended gap-report handler shapes', () => {
     expect(reason({gapReport: {command: './report.mjs'}})).toContain(
       'gapReport',

package/authoring/config/type.ts

@@ -11,7 +11,6 @@
 
 import type {DebugEventHandler} from '../debug/type.js';
 import type {GapReportHandler} from '../gap-report/type.js';
-import type {DiscoverSource} from '../discover/type.js';
 
 /**
  * A command to run as part of a post-codemod hook. Returned by a hook's
@@ -97,16 +96,6 @@ export interface AstryxConfig {
   debug?: DebugConfig;
   /** Route gap reports through a project-owned handler. See {@link GapReportHandler}. */
   gapReport?: GapReportHandler;
-  /**
-   * Tell `astryx discover` about integrations this project could add. See
-   * {@link DiscoverSource}.
-   *
-   * An integration can provide a source too, as a `discover` named export from
-   * its `astryx.integration.*` module. Discover calls every source: this one
-   * first, then each integration's in load order, and one that fails never
-   * hides the others.
-   */
-  discover?: DiscoverSource;
   /**
    * EXPERIMENTAL — shape may change and is not part of the stable config
    * contract. Provisional home for features still being proven out.
@@ -115,8 +104,8 @@ export interface AstryxConfig {
     /** Experimental XLE (layout expression) configuration. */
     xle?: {
       /**
-       * No effect. Its only reader was the removed `layout` command. Still
-       * accepted so existing configs keep loading; delete it.
+       * Register app-local components so XLE layout expressions can
+       * reference them by name via {hint}. Keyed by component name.
        */
       components?: Record<string, XleComponent>;
     };

package/authoring/doctypes/command/command.doc.mjs

@@ -151,7 +151,7 @@ export const doc = {
       name: 'subcommands',
       type: 'string[]',
       description:
-        'Subcommand names (for command groups like `theme`).',
+        'Subcommand names (for command groups like `theme` / `layout`).',
     },
     {
       name: 'examples',

package/authoring/doctypes/command/type.ts

@@ -75,7 +75,7 @@ export interface CommandDoc extends AuthoredDocGraphFields {
   args?: CommandArgDoc[];
   /** Flags/options. */
   options?: CommandOptionDoc[];
-  /** Subcommand names (for command groups like `theme`). */
+  /** Subcommand names (for command groups like `theme` / `layout`). */
   subcommands?: string[];
   /** Terminal examples. */
   examples?: CommandExampleDoc[];

package/authoring/index.d.mts

@@ -3,7 +3,6 @@
 
 export { parseConfig } from "./config/parse.mjs";
 export { parseIntegration } from "./integration/parse.mjs";
-export { parseDiscoverCatalog } from "./discover/parse.mjs";
 export { parseCodemod } from "./codemod/parse.mjs";
 export { parseDebugEvent } from "./debug/parse.mjs";
 export { parseDoc } from "./doctypes/parse.mjs";

package/authoring/index.d.ts

@@ -44,15 +44,6 @@ export type {
   GapReportTarget,
   GapReportHandlerReceipt,
 } from './gap-report/type.js'; // gap-report handler contract
-export type {
-  DiscoverSource,
-  DiscoverSourceContext,
-  DiscoverCatalog,
-  DiscoverPackage,
-  DiscoverVersion,
-  DiscoverContribution,
-  DiscoverKind,
-} from './discover/type.js'; // discover source contract
 export type {AstryxCodemod, AstryxConfigCodemod} from './codemod/type.js'; // codemods/*
 
 // ═══════════════════════════════════════════════════════════════════════
@@ -76,7 +67,6 @@ export {
   parseGapReportHandler,
   parseGapReportReceipt,
 } from './gap-report/parse.mjs';
-export {parseDiscoverCatalog} from './discover/parse.mjs';
 export {parseCodemod} from './codemod/parse.mjs';
 export {parseDebugEvent} from './debug/parse.mjs';
 

package/authoring/index.mjs

@@ -20,7 +20,6 @@ export {
   parseGapReportHandler,
   parseGapReportReceipt,
 } from './gap-report/parse.mjs';
-export {parseDiscoverCatalog} from './discover/parse.mjs';
 export {parseCodemod} from './codemod/parse.mjs';
 export {parseDebugEvent} from './debug/parse.mjs';
 export {parseDoc} from './doctypes/parse.mjs';

package/clients/cli/command-result-coverage.test.mjs

@@ -29,17 +29,17 @@ import {program} from './index.mjs';
 import {reportsResult, reportsResultVia} from './lib/define-command.mjs';
 
 /**
- * Commands with no action of their own: a group that prints its subcommand
- * list and does nothing else has no run to report on.
+ * Commands with no action of their own: bare `astryx layout` prints its
+ * subcommand list and does nothing else, so there is no run to report on.
  *
  * Pinned as a SET rather than skipped silently — if a command joins this list,
  * that is a real change to what the CLI does and it should be read, not
- * absorbed. Every group ships an action today: `theme`, for instance, HAS one
- * — the one that rejects an unknown subcommand — so it goes through the
- * converter like any other. Its bare form prints help and never returns from
- * that action, which the recorder covers where help is recorded, not here.
+ * absorbed. (`theme` is deliberately NOT here: it HAS an action — the one that
+ * rejects an unknown subcommand — so it goes through the converter like any
+ * other. Its bare form prints help and never returns from that action, which
+ * the recorder covers where help is recorded, not here.)
  */
-const NO_ACTION_OF_THEIR_OWN = [];
+const NO_ACTION_OF_THEIR_OWN = ['layout'];
 
 /**
  * Commands that record for themselves instead of returning a descriptor.