@astryxdesign/cli 0.6.3-canary.ea2f048 → 0.6.3-canary.ebaebc4

package/api/doctor/doctor.mjs

@@ -27,6 +27,15 @@ import {MIN_NODE_VERSION, isNodeVersionSupported} from '../../foundation/env/nod
 import {CLI_ROOT, findCoreDir, findInstalledPackage} from '../../foundation/fs/paths.mjs';
 import {explainPackageManager, getCliInvocation} from '../../foundation/env/package-manager.mjs';
 import {findConfigPath, Project} from '../../foundation/config/project.mjs';
+import {DocsCatalog} from '../../foundation/discovery/docs-discovery.mjs';
+import {buildDocsIndexData} from '../../foundation/discovery/docs-section-key.mjs';
+import {
+  DOC_OUTPUT_BUDGET_BYTES,
+  docsIndexBytes,
+  oversizedDocSections,
+} from '../../foundation/discovery/docs-output-budget.mjs';
+import {compileTopic, overlayLanguages} from '../docs/_adapter.mjs';
+import {detailView} from '../../foundation/doc-compiler/lenses.mjs';
 import {semverCompare, isValidSemver, satisfiesRange} from '../../foundation/env/semver.mjs';
 
 /**
@@ -52,6 +61,11 @@ import {semverCompare, isValidSemver, satisfiesRange} from '../../foundation/env
  * @property {import('../../foundation/integrations/integrations.mjs').LoadedIntegration[]|null} [integrations]
  *   Every integration the project loaded, or null when the project could not be
  *   read at all.
+ * @property {DocsCatalog|null} [docsCatalog] - The topics a docs read sees.
+ * @property {Array<{package?: string, code: string, message: string}>} [docsCatalogIssues]
+ *   `invalid_doc` issues from the project's contributed docs.
+ * @property {string|null} [docsCatalogError] - Why the project's docs catalog
+ *   could not be built, when it could not.
  * @property {Error|null} [configError] - Error thrown while resolving the config
  *   path (e.g. multiple config files present), surfaced by checkConfig as a FAIL.
  */
@@ -627,6 +641,201 @@ export function checkPackageManager(ctx) {
   };
 }
 
+/**
+ * Check 6b — every contributing integration owns its provider identity.
+ *
+ * Artifact and document IDs are provider-scoped, so a package that claims a
+ * provider ID an earlier-loaded package already holds is loaded inert: its
+ * components, templates, themes, docs, and codemods are withdrawn while the
+ * earlier package keeps contributing. That can be a deliberate transition
+ * (a renamed package installed beside its predecessor), so it warns rather
+ * than fails, but it is never allowed to happen quietly.
+ *
+ * @param {DoctorContext} ctx
+ * @returns {DoctorCheck}
+ */
+export function checkProviderIdentity(ctx) {
+  const id = 'provider-identity';
+  const label = 'Integration provider identity';
+
+  if (ctx.integrations == null) {
+    return {
+      id,
+      label,
+      status: 'info',
+      message: 'Skipped — the project configuration could not be read.',
+    };
+  }
+
+  const conflicts = ctx.integrations.filter(
+    integration => integration.__providerConflict,
+  );
+  if (conflicts.length > 0) {
+    return {
+      id,
+      label,
+      status: 'warn',
+      message: conflicts
+        .map(integration => integration.__providerConflict?.message)
+        .join(' '),
+      fix:
+        'Give each integration its own `providerId` in astryx.integration.*. ' +
+        "A renamed package may keep its predecessor's ID only when the " +
+        'predecessor is no longer installed.',
+    };
+  }
+
+  const count = ctx.integrations.filter(
+    integration =>
+      integration.providerId != null && integration.__loadError == null,
+  ).length;
+  if (count === 0) {
+    return {
+      id,
+      label,
+      status: 'info',
+      message: 'None — no loaded integration has a provider identity.',
+    };
+  }
+  return {
+    id,
+    label,
+    status: 'pass',
+    message:
+      count === 1
+        ? '1 loaded integration has its own provider ID.'
+        : `${count} loaded integrations each have their own provider ID.`,
+  };
+}
+
+/** @param {number} bytes */
+const kilobytes = bytes => `${Math.ceil(bytes / 1024)} KB`;
+
+/**
+ * @param {string[]} problems
+ * @returns {string}
+ */
+function joinProblems(problems) {
+  return problems.length === 1
+    ? problems[0]
+    : `${problems.length} problems: ${problems.join('; ')}`;
+}
+
+/**
+ * Every authoring self-doc is reachable from `astryx docs authoring`, loads,
+ * and fits in one read. The audit is imported here, inside the try, so a
+ * malformed self-doc is reported rather than taking Doctor down.
+ * @param {DoctorContext} [_ctx]
+ * @returns {Promise<DoctorCheck>}
+ */
+export async function checkAuthoringDocs(_ctx) {
+  const id = 'authoring-docs';
+  const label = 'Authoring docs';
+  try {
+    const {auditAuthoringSelfDocs} = await import(
+      '../../foundation/discovery/authoring-self-docs.mjs'
+    );
+    const audit = await auditAuthoringSelfDocs();
+    const problems = [
+      ...audit.unreachable.map(
+        source => `${source} is not in \`astryx docs authoring\``,
+      ),
+      ...audit.failed.map(({source, error}) => `${source} failed to load: ${error}`),
+      ...audit.oversized.map(
+        ({key, bytes}) =>
+          `authoring section "${key}" is ${kilobytes(bytes)}, over the ${kilobytes(DOC_OUTPUT_BUDGET_BYTES)} one read may return`,
+      ),
+    ];
+    if (problems.length > 0) {
+      return {
+        id,
+        label,
+        status: 'fail',
+        message: joinProblems(problems),
+        fix: 'List every authoring self-doc in AUTHORING_SELF_DOCS, fix the one that fails to load, and split a section that is too large.',
+      };
+    }
+    return {
+      id,
+      label,
+      status: 'pass',
+      message: `All ${audit.sections} authoring schemas are readable in \`astryx docs authoring\`.`,
+    };
+  } catch (err) {
+    return {
+      id,
+      label,
+      status: 'fail',
+      message: `The authoring docs could not be audited: ${err instanceof Error ? err.message : String(err)}`,
+      fix: 'Reinstall @astryxdesign/cli.',
+    };
+  }
+}
+
+/**
+ * Every topic reads progressively, in every language it ships: it loads, its
+ * section index and each of its sections fit in one read, and no contributed
+ * doc is invalid.
+ * @param {DoctorContext | Partial<DoctorContext>} ctx
+ * @returns {Promise<DoctorCheck>}
+ */
+export async function checkDocsProgressiveDisclosure(ctx) {
+  const id = 'docs-progressive-disclosure';
+  const label = 'Documentation navigation and size';
+  const budget = kilobytes(DOC_OUTPUT_BUDGET_BYTES);
+  /** @type {string[]} */
+  const problems = [];
+  if (ctx.docsCatalogError) {
+    problems.push(`The docs catalog could not be built: ${ctx.docsCatalogError}`);
+  }
+  for (const issue of ctx.docsCatalogIssues ?? []) {
+    problems.push(`${issue.package ?? 'a contributed doc'}: ${issue.message}`);
+  }
+  let topics = 0;
+  const catalog = ctx.docsCatalog;
+  if (catalog) {
+    for (const entry of catalog.entries()) {
+      for (const lang of [null, ...overlayLanguages(entry)]) {
+        const where = lang ? `${entry.name} [${lang}]` : entry.name;
+        try {
+          const doc = detailView(await compileTopic(catalog, entry, lang));
+          if (lang == null) topics += 1;
+          const indexBytes = docsIndexBytes(buildDocsIndexData(doc));
+          if (indexBytes > DOC_OUTPUT_BUDGET_BYTES) {
+            problems.push(
+              `${where}: its section index is ${kilobytes(indexBytes)}, over the ${budget} one read may return`,
+            );
+          }
+          for (const over of oversizedDocSections(doc.sections)) {
+            problems.push(
+              `${where} ${over.key}: ${kilobytes(over.bytes)}, over the ${budget} one read may return`,
+            );
+          }
+        } catch (err) {
+          problems.push(
+            `${where}: ${err instanceof Error ? err.message : String(err)}`,
+          );
+        }
+      }
+    }
+  }
+  if (problems.length > 0) {
+    return {
+      id,
+      label,
+      status: 'fail',
+      message: joinProblems(problems),
+      fix: 'Fix the doc each problem names; split a section that is too large into smaller ones, each with its own key.',
+    };
+  }
+  return {
+    id,
+    label,
+    status: 'pass',
+    message: `${topics} topics: every section index and section fits in one ${budget} read.`,
+  };
+}
+
 /**
  * Ordered list of synchronous check functions. Append here to add a check.
  * (checkConfig is async and is awaited separately by {@link runChecks}.)
@@ -638,6 +847,7 @@ export const SYNC_CHECKS = [
   checkVersionAlignment,
   checkThemes,
   checkImplicitIntegrations,
+  checkProviderIdentity,
   checkAgentDocs,
   checkPeerDeps,
   checkPackageManager,
@@ -669,11 +879,28 @@ export async function runChecks(options = {}) {
   let configTheme = null;
   /** @type {import('../../foundation/integrations/integrations.mjs').LoadedIntegration[]|null} */
   let integrations = null;
+  // A docs read falls back to the built-in topics when the project cannot be
+  // read, so the docs checks do too; the config check reports the config.
+  /** @type {DocsCatalog|null} */
+  let docsCatalog = DocsCatalog.fromBuiltins();
+  /** @type {Array<{package?: string, code: string, message: string}>} */
+  let docsCatalogIssues = [];
+  /** @type {string|null} */
+  let docsCatalogError = null;
   try {
     const project = await Project.load(cwd);
     configTheme =
       /** @type {{theme?: string}} */ (project.config ?? {}).theme ?? null;
     integrations = project.loadedIntegrations;
+    try {
+      docsCatalog = await project.docs();
+      docsCatalogIssues = (await project.issues()).filter(
+        issue => issue.code === 'invalid_doc',
+      );
+    } catch (err) {
+      docsCatalog = null;
+      docsCatalogError = err instanceof Error ? err.message : String(err);
+    }
   } catch {
     // Best-effort: a missing/invalid config leaves configTheme null.
   }
@@ -686,6 +913,9 @@ export async function runChecks(options = {}) {
     configPath,
     configTheme,
     integrations,
+    docsCatalog,
+    docsCatalogIssues,
+    docsCatalogError,
     configError,
   };
 
@@ -698,6 +928,8 @@ export async function runChecks(options = {}) {
       checks.push(await checkConfig(ctx));
     }
   }
+  checks.push(await checkAuthoringDocs(ctx));
+  checks.push(await checkDocsProgressiveDisclosure(ctx));
 
   const summary = {pass: 0, warn: 0, fail: 0, info: 0};
   for (const c of checks) summary[c.status] += 1;

package/api/doctor/doctor.test.mjs

@@ -11,9 +11,13 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import {fileURLToPath} from 'node:url';
+import {DocsCatalog} from '../../foundation/discovery/docs-discovery.mjs';
 import {
   doctor,
+  checkAuthoringDocs,
+  checkDocsProgressiveDisclosure,
   checkImplicitIntegrations,
+  checkProviderIdentity,
   checkVersionAlignment,
   checkPackageManager,
 } from './doctor.mjs';
@@ -214,6 +218,77 @@ describe('checkPackageManager', () => {
   });
 });
 
+describe('checkProviderIdentity', () => {
+  /** @param {object} [fields] */
+  const loaded = (fields = {}) => ({
+    name: '@acme/widgets',
+    providerId: '@acme/widgets',
+    version: '1.0.0',
+    __spec: '@acme/widgets',
+    __packageDir: '/abs/node_modules/@acme/widgets',
+    __manifestFile: '/abs/node_modules/@acme/widgets/astryx.integration.mjs',
+    ...fields,
+  });
+
+  it('skips when the project could not be read', () => {
+    expect(checkProviderIdentity({integrations: null}).status).toBe('info');
+  });
+
+  it('reports none when nothing is loaded', () => {
+    const c = checkProviderIdentity({integrations: []});
+    expect(c.status).toBe('info');
+    expect(c.message).toContain('None');
+  });
+
+  it('passes when each loaded integration has its own provider ID', () => {
+    const c = checkProviderIdentity({
+      integrations: [
+        loaded(),
+        loaded({
+          name: '@acme/charts',
+          providerId: '@acme/charts',
+          __spec: '@acme/charts',
+        }),
+      ],
+    });
+    expect(c.status).toBe('pass');
+    expect(c.message).toContain('2 loaded integrations');
+  });
+
+  it('warns and names both packages when a later claimant is set aside', () => {
+    const message =
+      '@acme/renamed@2.0.0 and @acme/widgets@1.0.0 both claim provider ID ' +
+      '"@acme/widgets". @acme/widgets@1.0.0 loads first and is used; ' +
+      '@acme/renamed@2.0.0 contributes nothing until one package changes ' +
+      'its providerId.';
+    const c = checkProviderIdentity({
+      integrations: [
+        loaded(),
+        loaded({
+          name: '@acme/renamed',
+          version: '2.0.0',
+          __spec: '@acme/renamed',
+          __providerConflict: {
+            providerId: '@acme/widgets',
+            claimedBy: '@acme/widgets',
+            message,
+          },
+        }),
+      ],
+    });
+    expect(c.status).toBe('warn');
+    expect(c.message).toBe(message);
+    expect(c.fix).toContain('providerId');
+  });
+
+  it('is part of the report doctor returns', async () => {
+    const r = await doctor({cwd});
+    expect(r.data.checks.map(check => check.id)).toContain(
+      'provider-identity',
+    );
+  }, SLOW);
+});
+
 describe('checkImplicitIntegrations', () => {
   /** @param {object} [fields] */
   const autolinked = (fields = {}) => ({
@@ -297,3 +372,124 @@ describe('checkImplicitIntegrations', () => {
     expect(r.data.checks.map(c => c.id)).toContain('implicit-integrations');
   }, SLOW);
 });
+
+describe('checkDocsProgressiveDisclosure', () => {
+  it('passes when every topic index and section fits one read', async () => {
+    const c = await checkDocsProgressiveDisclosure({
+      docsCatalog: DocsCatalog.fromBuiltins(),
+      docsCatalogIssues: [],
+    });
+    expect(c).toMatchObject({id: 'docs-progressive-disclosure', status: 'pass'});
+    expect(c.message).toMatch(/^\d+ topics: /);
+  }, SLOW);
+
+  it('fails on an invalid doc an integration contributed', async () => {
+    const c = await checkDocsProgressiveDisclosure({
+      docsCatalogIssues: [
+        {
+          package: '@acme/widgets',
+          code: 'invalid_doc',
+          severity: 'error',
+          message: 'bad.doc.mjs exports no doc',
+        },
+      ],
+    });
+    expect(c.status).toBe('fail');
+    expect(c.message).toBe('@acme/widgets: bad.doc.mjs exports no doc');
+  });
+
+  it('fails when the docs catalog cannot be built', async () => {
+    const c = await checkDocsProgressiveDisclosure({docsCatalogError: 'boom'});
+    expect(c.status).toBe('fail');
+    expect(c.message).toContain('boom');
+  });
+
+  it('names a section over the budget and a topic that fails to load', async () => {
+    const dir = fs.mkdtempSync(path.join(process.cwd(), '.astryx-doctor-docs-'));
+    tmpDirs.push(dir);
+    const huge = {
+      name: 'huge',
+      title: 'Huge',
+      description: 'Too big for one read.',
+      sections: [
+        {title: 'Small', content: [{type: 'prose', text: 'Fits.'}]},
+        {title: 'Everything', content: [{type: 'prose', text: 'x'.repeat(40 * 1024)}]},
+      ],
+    };
+    fs.writeFileSync(
+      path.join(dir, 'huge.doc.mjs'),
+      `export const docs = ${JSON.stringify(huge)};\n`,
+    );
+    fs.writeFileSync(path.join(dir, 'broken.doc.mjs'), 'export const docs = {;\n');
+    const c = await checkDocsProgressiveDisclosure({
+      docsCatalog: DocsCatalog.fromBuiltins({
+        huge: path.join(dir, 'huge.doc.mjs'),
+        broken: path.join(dir, 'broken.doc.mjs'),
+      }),
+      docsCatalogIssues: [],
+    });
+    expect(c.status).toBe('fail');
+    expect(c.message).toMatch(/^2 problems: /);
+    expect(c.message).toContain('huge everything: 41 KB, over the 32 KB one read may return');
+    expect(c.message).toContain('broken: ');
+    expect(c.message).not.toContain('huge small');
+  });
+});
+
+describe('checkAuthoringDocs', () => {
+  it('passes when every authoring self-doc is reachable and fits one read', async () => {
+    const c = await checkAuthoringDocs();
+    expect(c).toMatchObject({id: 'authoring-docs', status: 'pass'});
+    expect(c.message).toContain('astryx docs authoring');
+  }, SLOW);
+});
+
+describe('doctor docs checks', () => {
+  it('runs both docs checks and they pass on the repo', async () => {
+    const r = await doctor({cwd});
+    const byId = Object.fromEntries(r.data.checks.map(c => [c.id, c.status]));
+    expect(byId['authoring-docs']).toBe('pass');
+    expect(byId['docs-progressive-disclosure']).toBe('pass');
+  }, SLOW);
+});
+
+describe('checkDocsProgressiveDisclosure languages', () => {
+  it('checks every overlay a topic ships, not only English', async () => {
+    const dir = fs.mkdtempSync(path.join(process.cwd(), '.astryx-doctor-lang-'));
+    tmpDirs.push(dir);
+    const deploying = {
+      name: 'deploying',
+      title: 'Deploying',
+      description: 'Ship it.',
+      sections: [{title: 'Overview', content: [{type: 'prose', text: 'Push the button.'}]}],
+    };
+    fs.writeFileSync(
+      path.join(dir, 'deploying.doc.mjs'),
+      `export const docs = ${JSON.stringify(deploying)};\n`,
+    );
+    fs.writeFileSync(
+      path.join(dir, 'deploying.doc.zh.mjs'),
+      "throw new Error('zh overlay broken');\n",
+    );
+    fs.writeFileSync(
+      path.join(dir, 'deploying.doc.dense.mjs'),
+      `export const docsDense = ${JSON.stringify({
+        sections: [
+          {
+            section: 'Overview',
+            title: 'Overview',
+            content: [{type: 'prose', text: 'x'.repeat(40 * 1024)}],
+          },
+        ],
+      })};\n`,
+    );
+    const c = await checkDocsProgressiveDisclosure({
+      docsCatalog: DocsCatalog.fromBuiltins({deploying: path.join(dir, 'deploying.doc.mjs')}),
+      docsCatalogIssues: [],
+    });
+    expect(c.status).toBe('fail');
+    expect(c.message).toContain('deploying [zh]: zh overlay broken');
+    expect(c.message).toContain('deploying [dense] overview: 41 KB');
+    expect(c.message).not.toMatch(/deploying overview:/);
+  });
+});

package/api/hook/hook.type.d.mts

@@ -4,7 +4,7 @@
 export type HookDoc = import("@astryxdesign/cli/authoring").HookDoc;
 export type HookParamDoc = import("@astryxdesign/cli/authoring").HookParamDoc;
 /**
- * xds --json hook [--list] [--category X] [--detail names|compact|full]
+ * astryx --json hook [--list] [--category X] [--detail names|compact|full]
  *
  * The list view emits ONE `hook.list` type across all three detail levels; the
  * depth is carried in `data.detail` and `data.components` holds the grouped map
@@ -39,14 +39,14 @@ export type HookBriefEntry = {
     import: string;
 };
 /**
- * xds --json hook <name>
+ * astryx --json hook <name>
  */
 export type HookDetailResponse = {
     type: "hook.detail";
     data: HookDoc;
 };
 /**
- * xds --json hook <name> --params
+ * astryx --json hook <name> --params
  */
 export type HookDetailParamsResponse = {
     type: "hook.detail.params";

package/api/hook/hook.type.mjs

@@ -11,14 +11,14 @@
  *
  * Invocation                                 -> type discriminator
  * ------------------------------------------------------------------
- * xds --json hook                           -> hook.list (data.detail='names')
- * xds --json hook --list                    -> hook.list (data.detail='names')
- * xds --json hook --category State          -> hook.list (filtered)
- * xds --json hook --list --detail compact   -> hook.list (data.detail='compact')
- * xds --json hook --list --detail full      -> hook.list (data.detail='full')
- * xds --json hook useMediaQuery             -> hook.detail
- * xds --json hook useMediaQuery --params    -> hook.detail.params
- * (not found)                               -> CLIError
+ * astryx --json hook                         -> hook.list (data.detail='names')
+ * astryx --json hook --list                  -> hook.list (data.detail='names')
+ * astryx --json hook --category State        -> hook.list (filtered)
+ * astryx --json hook --list --detail compact -> hook.list (data.detail='compact')
+ * astryx --json hook --list --detail full    -> hook.list (data.detail='full')
+ * astryx --json hook useMediaQuery           -> hook.detail
+ * astryx --json hook useMediaQuery --params  -> hook.detail.params
+ * (not found)                                -> CLIError
  */
 
 // Re-export the authored-doc types from core so the hook leaves reference these
@@ -28,7 +28,7 @@
 /** @typedef {import('@astryxdesign/cli/authoring').HookParamDoc} HookParamDoc */
 
 /**
- * xds --json hook [--list] [--category X] [--detail names|compact|full]
+ * astryx --json hook [--list] [--category X] [--detail names|compact|full]
  *
  * The list view emits ONE `hook.list` type across all three detail levels; the
  * depth is carried in `data.detail` and `data.components` holds the grouped map
@@ -56,14 +56,14 @@
  */
 
 /**
- * xds --json hook <name>
+ * astryx --json hook <name>
  * @typedef {object} HookDetailResponse
  * @property {'hook.detail'} type
  * @property {HookDoc} data
  */
 
 /**
- * xds --json hook <name> --params
+ * astryx --json hook <name> --params
  * @typedef {object} HookDetailParamsResponse
  * @property {'hook.detail.params'} type
  * @property {HookParamDoc[]} data

package/api/hook/list/list.d.mts

@@ -13,7 +13,7 @@
 export function list({ cwd, category, detail, zh, lang }?: {
     cwd?: string | undefined;
     category?: string | undefined;
-    detail?: "names" | "compact" | "full" | "brief" | undefined;
+    detail?: "compact" | "full" | "names" | "brief" | undefined;
     zh?: boolean | undefined;
     lang?: string | null | undefined;
 }): Promise<import("../hook.type.mjs").HookListResponse>;

package/api/integration/add-contribution.mjs

@@ -250,7 +250,8 @@ async function addComponent(name, options) {
   }
 
   const sourcePath = projectPath(path.relative(packageDir, sourceFile));
-  const importSpecifier = `${owner}/${sourcePath}`;
+  const extensionlessPath = sourcePath.replace(/\.tsx?$/u, '');
+  const importSpecifier = `${owner}/${extensionlessPath}`;
   const docContents = `export default {\n  type: 'component',\n  name: '${name}',\n  import: ${JSON.stringify(importSpecifier)},\n  description: '${name} component.',\n  props: [],\n};\n`;
   const sourceContents = `export function ${name}() {\n  return <div>${name}</div>;\n}\n`;
 
@@ -263,7 +264,7 @@ async function addComponent(name, options) {
     packageFile,
     rootPath,
     path.basename(manifestFile),
-    [{subpath: sourcePath, target: sourcePath}],
+    [{subpath: extensionlessPath, target: sourcePath}],
   );
   if (pkgUpdate != null) {
     plans.push({
@@ -576,6 +577,7 @@ async function addTemplate(name, options) {
 
   const pascalName = kebabToPascal(name);
   const sourcePath = projectPath(path.relative(packageDir, sourceFile));
+  const extensionlessPath = sourcePath.replace(/\.tsx?$/u, '');
   const specContents = `export default {\n  type: '${templateType}',\n  name: '${name}',\n  description: '${kebabToTitle(name)} template.',\n};\n`;
   const sourceContents = `export default function ${pascalName}() {\n  return <div>${kebabToTitle(name)}</div>;\n}\n`;
 
@@ -588,7 +590,7 @@ async function addTemplate(name, options) {
     packageFile,
     rootPath,
     path.basename(manifestFile),
-    [{subpath: sourcePath, target: sourcePath}],
+    [{subpath: extensionlessPath, target: sourcePath}],
   );
   if (pkgUpdate != null) {
     plans.push({

package/api/integration/add-contribution.test.mjs

@@ -118,14 +118,14 @@ describe('integrationAdd component', () => {
     );
     expect(pkg.exports).toEqual({
       '.': './index.mjs',
-      './components/MyWidget.tsx': './components/MyWidget.tsx',
+      './components/MyWidget': './components/MyWidget.tsx',
     });
     expect(
       fs.readFileSync(
         path.join(tmpDir, 'components/MyWidget.doc.mjs'),
         'utf-8',
       ),
-    ).toContain('import: "@acme/integration/components/MyWidget.tsx"');
+    ).toContain('import: "@acme/integration/components/MyWidget"');
   });
 
   it('does not create exports when the package has no exports map', async () => {
@@ -143,7 +143,7 @@ describe('integrationAdd component', () => {
     setup({
       exports: {
         '.': './index.mjs',
-        './components/MyWidget.tsx': './different.tsx',
+        './components/MyWidget': './different.tsx',
       },
     });
 
@@ -421,7 +421,7 @@ describe('integrationAdd template', () => {
     );
     expect(pkg.exports).toEqual({
       '.': './index.mjs',
-      './templates/my-widget.tsx': './templates/my-widget.tsx',
+      './templates/my-widget': './templates/my-widget.tsx',
     });
   });
 

package/api/integration/integration-authoring.type.d.mts

@@ -26,7 +26,7 @@ export type IntegrationAddThemeOptions = IntegrationAddBaseOptions;
 export type IntegrationAddOptions = {
     cwd?: string | undefined;
     dryRun?: boolean | undefined;
-    templateType?: "block" | "page" | undefined;
+    templateType?: "page" | "block" | undefined;
     replaces?: string | undefined;
     extends?: string | undefined;
     to?: string | undefined;