@astryxdesign/cli 0.6.4-canary.ed2e54e → 0.6.4

package/api/doctor/doctor.test.mjs

@@ -354,31 +354,16 @@ describe('checkImplicitIntegrations', () => {
   });
 
   it('names the package, the field, and what it contributes', () => {
-    // Roots count only when they exist, so this one gives them real folders.
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'astryx-implicit-'));
-    try {
-      const dir = name => {
-        fs.mkdirSync(path.join(root, name));
-        return path.join(root, name);
-      };
-      const c = checkImplicitIntegrations({
-        integrations: [
-          autolinked({
-            components: dir('components'),
-            templates: dir('templates'),
-            themes: dir('themes'),
-          }),
-        ],
-      });
-      expect(c.message).toContain('@acme/widgets@1.0.0');
-      expect(c.message).toContain('from dependencies');
-      expect(c.message).toContain(
-        'contributing components, templates, themes',
-      );
-      expect(c.message).not.toContain('missing on disk');
-    } finally {
-      fs.rmSync(root, {recursive: true, force: true});
-    }
+    const c = checkImplicitIntegrations({
+      integrations: [
+        autolinked({templates: '/abs/templates', themes: '/abs/themes'}),
+      ],
+    });
+    expect(c.message).toContain('@acme/widgets@1.0.0');
+    expect(c.message).toContain('from dependencies');
+    expect(c.message).toContain(
+      'contributing components, templates, themes',
+    );
   });
 
   it('names the declared key too when an npm alias makes them differ', () => {
@@ -921,100 +906,3 @@ describe('checkDocsProgressiveDisclosure languages', () => {
     expect(c.message).not.toMatch(/deploying overview:/);
   });
 });
-
-describe('doctor says what it could not check', () => {
-  const CORE = {
-    'node_modules/@astryxdesign/core/package.json': JSON.stringify({
-      name: '@astryxdesign/core',
-      version: '0.6.3',
-    }),
-  };
-
-  /** Installed dependency whose manifest declares roots that do not exist. */
-  const dangling = {
-    'node_modules/@acme/dangling/package.json': JSON.stringify({
-      name: '@acme/dangling',
-      version: '2.0.0',
-    }),
-    'node_modules/@acme/dangling/astryx.integration.mjs':
-      "export default {providerId: 'acme-dangling', components: './components', templates: './templates', docs: './docs'};\n",
-  };
-
-  /** Installed dependency whose manifest cannot be parsed at all. */
-  const broken = {
-    'node_modules/@acme/broken/package.json': JSON.stringify({
-      name: '@acme/broken',
-      version: '1.0.0',
-    }),
-    'node_modules/@acme/broken/astryx.integration.mjs':
-      'export default {  this is not valid javascript ((\n',
-  };
-
-  /** @param {Record<string, string>} extra @param {string[]} deps */
-  const project = (extra, deps) =>
-    mkProject({
-      'package.json': JSON.stringify({
-        name: 'consumer',
-        version: '1.0.0',
-        dependencies: Object.fromEntries(
-          ['@astryxdesign/core', ...deps].map(d => [d, '1.0.0']),
-        ),
-      }),
-      ...CORE,
-      ...extra,
-    });
-
-  // An unparseable manifest is kept out of the loaded set on purpose, and
-  // doctor used to report that no installed dependency ships a manifest.
-  it('names an installed dependency whose manifest cannot be loaded', async () => {
-    const report = (await doctor({cwd: project(broken, ['@acme/broken'])})).data;
-    const check = report.checks.find(c => c.id === 'implicit-integrations');
-
-    expect(check.status).toBe('info');
-    expect(check.message).toContain('@acme/broken');
-    expect(check.message).toContain('could not be loaded');
-    expect(check.message).not.toContain('no installed dependency ships');
-    expect(report.summary.fail).toBe(0);
-  }, SLOW);
-
-  it('does not claim contributions from roots that are missing on disk', async () => {
-    const report = (await doctor({cwd: project(dangling, ['@acme/dangling'])}))
-      .data;
-    const implicit = report.checks.find(c => c.id === 'implicit-integrations');
-    const issues = report.checks.find(c => c.id === 'integration-issues');
-
-    expect(implicit.message).toContain('contributing nothing');
-    expect(implicit.message).toContain('missing on disk');
-    expect(implicit.message).not.toContain('contributing components');
-    expect(issues.status).toBe('warn');
-    expect(issues.message).toContain('@acme/dangling');
-  }, SLOW);
-
-  it('still says no dependency ships a manifest when none does', async () => {
-    const report = (await doctor({cwd: project({}, [])})).data;
-    const check = report.checks.find(c => c.id === 'implicit-integrations');
-
-    expect(check.message).toBe(
-      'None — no installed dependency ships an astryx.integration.* manifest.',
-    );
-  }, SLOW);
-
-  it('says how many integrations could not be read, rather than counting silently', () => {
-    /** @type {any} */
-    const ctx = {
-      cwd: '/x',
-      nodeVersion: process.versions.node,
-      coreDir: null,
-      configPath: null,
-      configTheme: null,
-      integrations: [
-        {name: '@acme/ok', __spec: '@acme/ok', providerId: 'ok'},
-        {name: '@acme/bad', __spec: '@acme/bad', __loadError: 'boom'},
-      ],
-    };
-    const check = checkProviderIdentity(ctx);
-
-    expect(check.message).toContain('1 loaded integration has its own provider ID.');
-    expect(check.message).toContain('could not be read');
-  });
-});

package/api/index.d.mts

@@ -18,7 +18,6 @@ export { integrationAddTheme } from "./integration/add-theme.mjs";
 export { integrationPackCheck } from "./integration/pack-check.mjs";
 export { AstryxError } from "./error.mjs";
 export { logger } from "./logger.mjs";
-export * from "../foundation/response/batch.type.mjs";
 export * from "./component/component.type.mjs";
 export * from "./docs/docs.type.mjs";
 export * from "./blog/blog.type.mjs";
@@ -33,12 +32,14 @@ export * from "./gap-report/gap-report.type.mjs";
 export * from "./upgrade/upgrade.type.mjs";
 export * from "./init/init.type.mjs";
 export * from "./doctor/doctor.type.mjs";
+export * from "./layout/layout.type.mjs";
 export * from "./integration/integration-authoring.type.mjs";
 export * from "./integration/pack-check.type.mjs";
 export * from "./integration/validate-integration.type.mjs";
 export * from "./integration/authoring-checks.type.mjs";
 export type Logger = import("./logger.mjs").Logger;
 export { themeBuild, themeAdd, themeTemplate, themeList, themeListAvailable, themeTargets, themePaletteGenerate, generateTonalPalette, listThemes } from "./theme/theme.mjs";
+export { layoutExpand, layoutCheck, layoutGrammar } from "./layout/layout.mjs";
 export { integrationAdd, integrationAddAgentDoc, integrationAddCodemod, integrationAddComponent, integrationAddDoc, integrationAddTemplate } from "./integration/add-contribution.mjs";
 export { validateIntegration, summarizeIssues } from "./integration/validate-integration.mjs";
 export { integrationTemplateConflicts, integrationComponentConflicts, integrationDocConflicts } from "./integration/authoring-checks.mjs";

package/api/index.mjs

@@ -44,6 +44,7 @@ export {gapReport} from './gap-report/gap-report.mjs';
 export {upgrade} from './upgrade/upgrade.mjs';
 export {init} from './init/init.mjs';
 export {doctor} from './doctor/doctor.mjs';
+export {layoutExpand, layoutCheck, layoutGrammar} from './layout/layout.mjs';
 export {
   integrationAdd,
   integrationAddAgentDoc,
@@ -72,12 +73,10 @@ export {logger} from './logger.mjs';
  * @typedef {import('./logger.mjs').Logger} Logger
  */
 
-// ── Types (re-exported from the shared response foundation and each command's
-// colocated `.type.mjs`) ──────────────────────────────────────────────────
+// ── Types (re-exported from each command's colocated `.type.mjs`) ─────
 // Runtime no-ops (the .type.mjs files are `export {}`); tsc carries these
 // through to the generated api/index.d.mts so the public type surface exposes
-// the shared receipt vocabulary and every command's Options + response types.
-export * from '../foundation/response/batch.type.mjs';
+// every command's Options + response types by name.
 export * from './component/component.type.mjs';
 export * from './docs/docs.type.mjs';
 export * from './blog/blog.type.mjs';
@@ -92,6 +91,7 @@ export * from './gap-report/gap-report.type.mjs';
 export * from './upgrade/upgrade.type.mjs';
 export * from './init/init.type.mjs';
 export * from './doctor/doctor.type.mjs';
+export * from './layout/layout.type.mjs';
 export * from './integration/integration-authoring.type.mjs';
 export * from './integration/pack-check.type.mjs';
 export * from './integration/validate-integration.type.mjs';

package/api/integration/add-helpers.d.mts

@@ -8,7 +8,7 @@ export function findPackageDir(startDir: string): string;
 /**
  * @typedef {object} WritePlan
  * @property {string} path
- * @property {string | Buffer} contents a Buffer is written byte for byte
+ * @property {string} contents
  * @property {boolean} createOnly
  * @property {Buffer} [expectedOriginal] bytes captured before validation;
  *   a different current file is a concurrent edit and must never be overwritten
@@ -56,10 +56,7 @@ export function packageJsonUpdate(packageFile: string, rootPath: string, manifes
 export function applyWrites(plans: WritePlan[]): () => void;
 export type WritePlan = {
     path: string;
-    /**
-     * a Buffer is written byte for byte
-     */
-    contents: string | Buffer;
+    contents: string;
     createOnly: boolean;
     /**
      * bytes captured before validation;

package/api/integration/add-helpers.mjs

@@ -5,8 +5,7 @@
  *
  * Hosts the atomic staged-write transaction, package.json files-array
  * maintenance, package-dir resolution, and project-path normalization that
- * every `integration add <kind>` command needs. `theme add` and `theme build`
- * write through the same transaction. Stateless and side-effect-free
+ * every `integration add <kind>` command needs. Stateless and side-effect-free
  * outside of {@link applyWrites}.
  */
 
@@ -41,7 +40,7 @@ export function findPackageDir(startDir) {
 /**
  * @typedef {object} WritePlan
  * @property {string} path
- * @property {string | Buffer} contents a Buffer is written byte for byte
+ * @property {string} contents
  * @property {boolean} createOnly
  * @property {Buffer} [expectedOriginal] bytes captured before validation;
  *   a different current file is a concurrent edit and must never be overwritten
@@ -193,29 +192,21 @@ export function packageJsonUpdate(
 
 // ── Atomic staged-write transaction ─────────────────────────────────
 
-/**
- * @param {string} file
- * @returns {boolean} false when the file is still there
- */
+/** @param {string} file */
 function removeTemporary(file) {
   try {
     fs.rmSync(file, {force: true});
-    return true;
   } catch {
     // Best effort. The transaction error remains the actionable failure.
-    return false;
   }
 }
 
 /**
  * Restore writes that already published.  Best-effort so callers preserve
- * the original actionable error; returns every path it could not put back.
+ * the original actionable error.
  * @param {Array<WritePlan & {temporary: string, original: Buffer|null, mode: number}>} published
- * @returns {string[]}
  */
 function rollbackWrites(published) {
-  /** @type {string[]} */
-  const unrestored = [];
   for (const plan of [...published].reverse()) {
     let restore = null;
     try {
@@ -234,18 +225,12 @@ function rollbackWrites(published) {
         fs.renameSync(restore, plan.path);
         restore = null;
       }
-    } catch (error) {
-      // A created file that is already gone needs nothing. Any other failure
-      // leaves this call's bytes, or no bytes, where the original was.
-      const gone =
-        error instanceof Error &&
-        /** @type {NodeJS.ErrnoException} */ (error).code === 'ENOENT';
-      if (!(gone && plan.original == null)) unrestored.push(plan.path);
+    } catch {
+      // Best effort. A concurrent edit belongs to its writer, not this rollback.
     } finally {
       if (restore != null) removeTemporary(restore);
     }
   }
-  return unrestored;
 }
 
 /** @param {string} file */
@@ -340,22 +325,10 @@ export function applyWrites(plans) {
       }
       published.push(plan);
     }
-    return () => {
-      rollbackWrites(published);
-    };
+    return () => rollbackWrites(published);
   } catch (error) {
-    const leftovers = staged
-      .filter(plan => !removeTemporary(plan.temporary))
-      .map(plan => plan.temporary);
-    const unrestored = rollbackWrites(published);
-    if (error instanceof Error) {
-      if (unrestored.length > 0) {
-        error.message += ` Could not restore: ${unrestored.join(', ')}.`;
-      }
-      if (leftovers.length > 0) {
-        error.message += ` Could not remove temporary files: ${leftovers.join(', ')}.`;
-      }
-    }
+    for (const plan of staged) removeTemporary(plan.temporary);
+    rollbackWrites(published);
     throw error;
   }
 }

package/api/integration/pack-check.mjs

@@ -162,22 +162,6 @@ export function parseNpmPackOutput(output) {
   };
 }
 
-/**
- * Summarize the JSON error npm prints on stdout when `--json` pack fails.
- * @param {string} output
- * @returns {string}
- */
-function npmPackErrorDetail(output) {
-  try {
-    const error = JSON.parse(output)?.error;
-    return [error?.summary, error?.detail]
-      .filter(part => typeof part === 'string' && part.trim() !== '')
-      .join(': ');
-  } catch {
-    return (output || '').trim();
-  }
-}
-
 /**
  * Run `npm pack --json` with output directed to `destDir` so no preexisting
  * tgz is overwritten. This intentionally runs the package lifecycle, matching
@@ -191,25 +175,16 @@ function npmPackErrorDetail(output) {
 function runNpmPack(packageDir, destDir) {
   const result = spawnSync(
     'npm',
-    [
-      'pack',
-      '--json',
-      '--silent',
-      // Lifecycle scripts still run; background mode keeps their output off
-      // the stdout that carries the JSON result.
-      '--foreground-scripts=false',
-      `--pack-destination=${destDir}`,
-    ],
+    ['pack', '--json', '--silent', `--pack-destination=${destDir}`],
     {cwd: packageDir, encoding: 'utf-8', timeout: 60_000},
   );
   if (result.error) {
     throw new Error(`Could not start npm pack: ${result.error.message}`);
   }
   if (result.status !== 0) {
-    const detail =
-      (result.stderr || '').trim() || npmPackErrorDetail(result.stdout);
+    const stderr = (result.stderr || '').trim();
     throw new Error(
-      `npm pack failed (exit ${result.status})${detail ? `: ${detail}` : ''}.`,
+      `npm pack failed (exit ${result.status})${stderr ? `: ${stderr}` : ''}.`,
     );
   }
   return parseNpmPackOutput(result.stdout);

package/api/json/index.ts

@@ -26,6 +26,7 @@ export type * from '../gap-report/gap-report.type.mjs';
 export type * from '../upgrade/upgrade.type.mjs';
 export type * from '../init/init.type.mjs';
 export type * from '../doctor/doctor.type.mjs';
+export type * from '../layout/layout.type.mjs';
 export type * from '../integration/validate-integration.type.mjs';
 export type * from '../integration/authoring-checks.type.mjs';
 export type * from '../integration/pack-check.type.mjs';

package/api/layout/_adapter.d.mts

@@ -0,0 +1,34 @@
+// @generated by scripts/sync-api-types.mjs from the JSDoc in api/**/*.mjs.
+// DO NOT EDIT — run `pnpm sync:api-types` to regenerate.
+
+/** @param {import('../../foundation/xle/xle-ast').RawIssue} issue */
+export function formatIssue(issue: import("../../foundation/xle/xle-ast").RawIssue): string;
+/**
+ * Parse + validate, throwing structured XDSErrors on failure.
+ * Returns {doc, registry, blocks, warnings}.
+ *
+ * @param {string} expression
+ * @param {{form?: 'compact'|'outline'|'auto', loose?: boolean, cwd?: string}} [options]
+ */
+export function analyze(expression: string, { form, loose, cwd }?: {
+    form?: "compact" | "outline" | "auto";
+    loose?: boolean;
+    cwd?: string;
+}): Promise<{
+    doc: import("../../foundation/xle/xle-ast").XLEDoc;
+    registry: import("../../foundation/xle/xle-ast").Registry;
+    blocks: LayoutBlock[];
+    errors: import("../../foundation/xle/xle-ast").RawIssue[];
+    warnings: import("../../foundation/xle/xle-ast").RawIssue[];
+}>;
+export type LayoutBlock = {
+    dirName: string;
+    name: string;
+    kind: "template" | "component";
+    type?: string | undefined;
+    description?: string | undefined;
+    category?: string | undefined;
+    importPath?: string | undefined;
+    filePath?: string | undefined;
+    isDefault?: boolean | undefined;
+};

package/api/layout/_adapter.mjs

@@ -0,0 +1,148 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Shared analysis layer for the `layout` command's expand/check leaves.
+ *
+ * Loads the block catalog (template blocks + app-registered components), builds
+ * the branch registry, and parses+validates a layout expression into a doc +
+ * issues. Both the expand and check leaves sit on `analyze`; neither parses or
+ * validates directly. (The grammar leaf needs none of this — it only reads the
+ * registry alias table.)
+ *
+ * @input  expression string (+ options)
+ * @output analyze() -> {doc, registry, blocks, errors, warnings}; formatIssue()
+ * @position api — shared core over lib/xle; leaves in expand/ + check/ project it
+ */
+
+import {AstryxError} from '../error.mjs';
+import {ERROR_CODES} from '../../foundation/response/error-codes.mjs';
+import {parse, XLEParseError} from '../../foundation/xle/parse.mjs';
+import {validate} from '../../foundation/xle/validate.mjs';
+import {buildRegistry} from '../../foundation/xle/registry.mjs';
+import {discoverTemplates} from '../template/template.mjs';
+import {Project} from '../../foundation/config/project.mjs';
+
+/**
+ * @typedef {object} LayoutBlock
+ * @property {string} dirName
+ * @property {string} name
+ * @property {'template'|'component'} kind
+ * @property {string} [type]
+ * @property {string} [description]
+ * @property {string} [category]
+ * @property {string} [importPath]
+ * @property {string} [filePath]
+ * @property {boolean} [isDefault]
+ */
+
+/**
+ * The catalog a `{hint}` can resolve to: template blocks (spliced inline) plus
+ * any app-registered local components from astryx.config.mjs
+ * `experimental.xle.components` (imported by name). App components are how XLE
+ * reaches domain pieces — the KpiCard/chart/drawer set that the
+ * @astryxdesign/core registry can't see.
+ *
+ * @param {string} cwd
+ * @returns {Promise<LayoutBlock[]>}
+ */
+async function loadBlocks(cwd) {
+  /** @type {LayoutBlock[]} */
+  const blocks = [];
+  try {
+    const all = await discoverTemplates(cwd);
+    const templates = all.filter(template => template.type === 'block');
+    /** @type {Map<string, import('../../foundation/discovery/template-adapter.mjs').DiscoveredTemplate>} */
+    const byId = new Map();
+    // Exact ids are the fallback. Active replacement aliases override them in a
+    // second pass, matching template() regardless of discovery/display order.
+    for (const template of templates) byId.set(template.dirName, template);
+    for (const template of templates) {
+      if (template.replaces != null) byId.set(template.replaces, template);
+    }
+    for (const [id, template] of byId) {
+      blocks.push({...template, dirName: id, kind: 'template'});
+    }
+  } catch {
+    // discovery is best-effort
+  }
+  try {
+    const project = await Project.load(cwd);
+    /** @type {Record<string, {from?: string, description?: string, default?: boolean}>} */
+    const components = project.config.experimental?.xle?.components ?? {};
+    for (const [name, spec] of Object.entries(components)) {
+      const importPath = spec.from;
+      if (!importPath) continue;
+      blocks.push({
+        type: 'block',
+        kind: 'component',
+        dirName: name,
+        name,
+        description: spec.description ?? '',
+        category: 'app',
+        importPath,
+        isDefault: Boolean(spec.default),
+      });
+    }
+  } catch {
+    // config is optional
+  }
+  return blocks;
+}
+
+/** @param {import('../../foundation/xle/xle-ast').RawIssue} issue */
+export function formatIssue(issue) {
+  const where = issue.line != null ? `line ${issue.line}: ` : '';
+  return `${where}${issue.message}`;
+}
+
+/**
+ * Parse + validate, throwing structured XDSErrors on failure.
+ * Returns {doc, registry, blocks, warnings}.
+ *
+ * @param {string} expression
+ * @param {{form?: 'compact'|'outline'|'auto', loose?: boolean, cwd?: string}} [options]
+ */
+export async function analyze(
+  expression,
+  {form = 'auto', loose = false, cwd = process.cwd()} = {},
+) {
+  // Validate inputs in the API (not just the CLI): an empty expression or an
+  // unknown --form must error, not silently parse as an empty/compact layout.
+  if (typeof expression !== 'string' || expression.trim() === '') {
+    throw new AstryxError(
+      'Layout expression is empty.',
+      undefined,
+      ERROR_CODES.ERR_INVALID_ARGUMENT,
+    );
+  }
+  if (form !== 'compact' && form !== 'outline' && form !== 'auto') {
+    throw new AstryxError(
+      `Invalid form "${form}". Must be one of: compact, outline, auto.`,
+      undefined,
+      ERROR_CODES.ERR_INVALID_OPTION,
+    );
+  }
+  const registry =
+    /** @type {import('../../foundation/xle/xle-ast').Registry} */ (
+      /** @type {unknown} */ (await buildRegistry({cwd}))
+    );
+  const blocks = await loadBlocks(cwd);
+
+  /** @type {import('../../foundation/xle/xle-ast').XLEDoc} */
+  let doc;
+  try {
+    doc = parse(expression, {form});
+  } catch (e) {
+    if (e instanceof XLEParseError) {
+      throw new AstryxError(
+        `Layout expression syntax error at line ${e.line}, col ${e.col}: ${e.message}`,
+        undefined,
+        ERROR_CODES.ERR_LAYOUT_PARSE,
+      );
+    }
+    throw e;
+  }
+
+  const {errors, warnings} = validate(doc, registry, blocks, {loose});
+  return {doc, registry, blocks, errors, warnings};
+}

package/api/layout/check/check.d.mts

@@ -0,0 +1,16 @@
+// @generated by scripts/sync-api-types.mjs from the JSDoc in api/**/*.mjs.
+// DO NOT EDIT — run `pnpm sync:api-types` to regenerate.
+
+/**
+ * `astryx layout check "<expr>" [--form compact|outline]`
+ * Validates without expanding; echoes both canonical surfaces.
+ *
+ * @param {string} expression
+ * @param {{form?: 'compact'|'outline'|'auto', loose?: boolean, cwd?: string}} [options]
+ * @returns {Promise<import('../layout.type.mjs').LayoutCheckResponse>}
+ */
+export function layoutCheck(expression: string, options?: {
+    form?: "compact" | "outline" | "auto";
+    loose?: boolean;
+    cwd?: string;
+}): Promise<import("../layout.type.mjs").LayoutCheckResponse>;

package/api/layout/check/check.mjs

@@ -0,0 +1,40 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file `astryx layout check` leaf — validate a layout expression without
+ * expanding, echoing both canonical surfaces (compact + outline). Resolution +
+ * validation come from ../_adapter.mjs (analyze); this leaf projects the
+ * `layout.check` envelope.
+ *
+ * @input  expression string (+ options)
+ * @output {type:'layout.check', data}
+ * @position api — leaf over ../_adapter.mjs + lib/xle/print
+ */
+
+import {toCompact, toOutline} from '../../../foundation/xle/print.mjs';
+import {analyze, formatIssue} from '../_adapter.mjs';
+
+/**
+ * `astryx layout check "<expr>" [--form compact|outline]`
+ * Validates without expanding; echoes both canonical surfaces.
+ *
+ * @param {string} expression
+ * @param {{form?: 'compact'|'outline'|'auto', loose?: boolean, cwd?: string}} [options]
+ * @returns {Promise<import('../layout.type.mjs').LayoutCheckResponse>}
+ */
+export async function layoutCheck(expression, options = {}) {
+  const {form = 'auto', loose = false, cwd = process.cwd()} = options;
+  const {doc, errors, warnings} = await analyze(expression, {form, loose, cwd});
+
+  return {
+    type: 'layout.check',
+    data: {
+      valid: errors.length === 0,
+      form: doc.form,
+      errors: errors.map(e => ({...e, formatted: formatIssue(e)})),
+      warnings: warnings.map(formatIssue),
+      compact: toCompact(doc),
+      outline: toOutline(doc),
+    },
+  };
+}

package/api/layout/expand/expand.d.mts

@@ -0,0 +1,22 @@
+// @generated by scripts/sync-api-types.mjs from the JSDoc in api/**/*.mjs.
+// DO NOT EDIT — run `pnpm sync:api-types` to regenerate.
+
+/**
+ * `astryx layout expand "<expr>" [path]`
+ *
+ * @param {string} expression
+ * @param {object} [options]
+ * @param {string} [options.targetPath] - write TSX here (validated against cwd)
+ * @param {'compact'|'outline'|'auto'} [options.form]
+ * @param {boolean} [options.loose] - downgrade unknown {hints} to TODO warnings
+ * @param {string} [options.name] - generated component name
+ * @param {string} [options.cwd]
+ * @returns {Promise<import('../layout.type.mjs').LayoutExpandResponse>}
+ */
+export function layoutExpand(expression: string, options?: {
+    targetPath?: string | undefined;
+    form?: "compact" | "auto" | "outline" | undefined;
+    loose?: boolean | undefined;
+    name?: string | undefined;
+    cwd?: string | undefined;
+}): Promise<import("../layout.type.mjs").LayoutExpandResponse>;