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

package/foundation/discovery/docs-section-key.mjs

@@ -34,7 +34,10 @@ const SOURCE_TITLE = Symbol('astryx.docs.sourceTitle');
  * @returns {T}
  */
 export function withSourceTitle(section, title) {
-  Object.defineProperty(section, SOURCE_TITLE, {value: title, configurable: true});
+  Object.defineProperty(section, SOURCE_TITLE, {
+    value: title,
+    configurable: true,
+  });
   return section;
 }
 
@@ -77,9 +80,77 @@ export function sectionKey(section) {
 }
 
 /**
- * Problems with the keys of a topic's sections: an authored id that is not a
- * stable key, a title no key derives from, and two sections sharing a key.
- * Keys are never suffixed to make them unique, because readers link to them.
+ * The first section the 0.6.x title-substring lookup would return for a query.
+ * @param {any[]} sections
+ * @param {string} query
+ * @returns {number}
+ */
+function legacyTitleMatchIndex(sections, query) {
+  const lower = query.toLowerCase();
+  return sections.findIndex(section => {
+    const title = sourceTitle(section);
+    return typeof title === 'string' && title.toLowerCase().includes(lower);
+  });
+}
+
+/**
+ * A name as a docs-tree route segment: lowercase words joined by hyphens, so
+ * `integrationPackCheck` and `integration pack` both read naturally.
+ * @param {string} name
+ * @returns {string}
+ */
+export function routeSegment(name) {
+  return String(name)
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+/**
+ * Fatal key problems: only an explicitly authored `id` can make a previously
+ * readable topic invalid. Derived-key collisions and titles with no Latin
+ * letters or digits are handled by {@link withSectionKeys} for 0.6.x
+ * compatibility.
+ * @param {any[]} sections
+ * @returns {string[]}
+ */
+export function sectionKeyErrors(sections) {
+  /** @type {string[]} */
+  const problems = [];
+  /** @type {Map<string, number>} */
+  const seen = new Map();
+  sections.forEach((section, s) => {
+    if (section?.id == null) return;
+    const at = `sections[${s}]`;
+    if (typeof section.id !== 'string' || !SECTION_KEY_RE.test(section.id)) {
+      problems.push(
+        `${at}.id: ${JSON.stringify(section.id)} is not a stable key. Use lowercase letters and digits joined by single hyphens.`,
+      );
+      return;
+    }
+    const first = seen.get(section.id);
+    if (first != null) {
+      problems.push(
+        `${at}: the key "${section.id}" is already used by sections[${first}]. Give one of them a distinct id.`,
+      );
+      return;
+    }
+    const legacyOwner = legacyTitleMatchIndex(sections, section.id);
+    if (legacyOwner !== -1 && legacyOwner !== s) {
+      problems.push(
+        `${at}.id: the key "${section.id}" is already a legacy title query for sections[${legacyOwner}]. Choose an id that resolves to this section.`,
+      );
+      return;
+    }
+    seen.set(section.id, s);
+  });
+  return problems;
+}
+
+/**
+ * Compatibility notices for section keys. These inputs loaded in 0.6.x, so
+ * readers keep accepting them and assign deterministic fallback keys.
  * @param {any[]} sections
  * @returns {string[]}
  */
@@ -90,7 +161,6 @@ export function sectionKeyProblems(sections) {
   const seen = new Map();
   sections.forEach((section, s) => {
     const at = `sections[${s}]`;
-    // A missing title is reported where titles are checked; no key to judge.
     if (
       section?.id == null &&
       (typeof section?.title !== 'string' || section.title === '')
@@ -109,14 +179,14 @@ export function sectionKeyProblems(sections) {
     const key = sectionKey(section);
     if (key === '') {
       problems.push(
-        `${at}: no key derives from the title ${JSON.stringify(section?.title)}. Give the section an id.`,
+        `${at}: no key derives from the title ${JSON.stringify(section?.title)}. A deterministic section-N compatibility key is used; add an explicit id.`,
       );
       return;
     }
     const first = seen.get(key);
     if (first != null) {
       problems.push(
-        `${at}: the key "${key}" is already used by sections[${first}]. Give one of them a distinct id or title.`,
+        `${at}: the key "${key}" is already used by sections[${first}]. A suffixed compatibility key is used for title-derived collisions; give one of them a distinct id or title.`,
       );
       return;
     }
@@ -133,48 +203,79 @@ export function sectionKeyProblems(sections) {
  * @returns {T}
  */
 export function withSectionKeys(doc) {
+  const reserved = new Set(
+    doc.sections
+      .map(section => section?.id)
+      .filter(id => typeof id === 'string' && SECTION_KEY_RE.test(id)),
+  );
+  const used = new Set();
   return {
     ...doc,
-    sections: doc.sections.map(section =>
-      section.id != null
-        ? section
-        : withSourceTitle(
-            {...section, id: sectionKey(section)},
-            sourceTitle(section),
-          ),
-    ),
+    sections: doc.sections.map((section, index) => {
+      if (section.id != null) {
+        used.add(section.id);
+        return section;
+      }
+      const base =
+        sectionTitleKey(sourceTitle(section)) || `section-${index + 1}`;
+      let key = base;
+      let suffix = 2;
+      while (
+        reserved.has(key) ||
+        used.has(key) ||
+        (legacyTitleMatchIndex(doc.sections, key) !== -1 &&
+          legacyTitleMatchIndex(doc.sections, key) !== index)
+      ) {
+        key = `${base}-${suffix}`;
+        suffix += 1;
+      }
+      used.add(key);
+      return withSourceTitle({...section, id: key}, sourceTitle(section));
+    }),
   };
 }
 
 /**
- * Find the section a reader asked for: by key, then by exact title (or the
- * key the query derives), then by a title that contains the query. More than
- * one match is refused rather than guessed.
+ * Find the section a reader asked for. The 0.6.x first-match title-substring
+ * lookup remains first in the authored-title view. In a localized view, an
+ * exact stable key resolves before translated title substrings because those
+ * translations cannot participate in language-stable key allocation. Generated
+ * keys avoid authored-title conflicts, and authored IDs that would shadow an
+ * authored legacy query are rejected.
  * @param {any[]} sections
  * @param {string} query
- * @returns {{section: any | null, candidates: any[]}} `candidates` lists the
- *   matches when the query is ambiguous, and is empty when nothing matches
+ * @returns {{section: any | null, candidates: any[]}} `candidates` lists every
+ *   legacy title match when the query is ambiguous
  */
 export function findDocSection(sections, query) {
   const wanted = query.trim();
   const byKey = sections.find(section => sectionKey(section) === wanted);
-  if (byKey) return {section: byKey, candidates: []};
+  const hasLocalizedTitles = sections.some(
+    section => sourceTitle(section) !== section.title,
+  );
+  if (byKey && hasLocalizedTitles) {
+    return {section: byKey, candidates: []};
+  }
 
   const lower = wanted.toLowerCase();
-  const derived = sectionTitleKey(wanted);
-  const exact = sections.filter(
-    section =>
-      section.title.toLowerCase() === lower ||
-      (derived !== '' && sectionTitleKey(sourceTitle(section)) === derived),
+  const legacy = sections.filter(section =>
+    section.title.toLowerCase().includes(lower),
   );
-  if (exact.length === 1) return {section: exact[0], candidates: []};
-  if (exact.length > 1) return {section: null, candidates: exact};
+  if (legacy.length > 0) {
+    return {section: legacy[0], candidates: legacy.length > 1 ? legacy : []};
+  }
 
-  const partial = sections.filter(section =>
-    section.title.toLowerCase().includes(lower),
+  const byFallbackKey = sections.find(
+    section => sectionKey(section) === wanted,
+  );
+  if (byFallbackKey) return {section: byFallbackKey, candidates: []};
+
+  const derived = sectionTitleKey(wanted);
+  const byDerivedKey = sections.find(
+    section =>
+      derived !== '' && sectionTitleKey(sourceTitle(section)) === derived,
   );
-  if (partial.length === 1) return {section: partial[0], candidates: []};
-  return {section: null, candidates: partial};
+  return {section: byDerivedKey ?? null, candidates: []};
 }
 
 /**
@@ -205,7 +306,7 @@ export function sectionSummary(section, max = SECTION_SUMMARY_MAX) {
  * The index a topic-only read returns: what the topic is, and one entry per
  * section with the key to read it by.
  * @param {{name: string, title: string, description: string, sections: any[]}} doc
- * @returns {import('../../api/docs/docs.type.mjs').DocsIndex}
+ * @returns {Omit<import('../../api/docs/docs.type.mjs').DocsIndex, 'links'>}
  */
 export function buildDocsIndexData(doc) {
   return {

package/foundation/discovery/docs-section-key.test.mjs

@@ -7,6 +7,7 @@ import {
   buildDocsIndexData,
   findDocSection,
   sectionKey,
+  sectionKeyErrors,
   sectionKeyProblems,
   sectionSummary,
   sectionTitleKey,
@@ -68,12 +69,17 @@ describe('sectionKeyProblems', () => {
       section('Quick-start'),
     ]);
     expect(problems).toHaveLength(1);
-    expect(problems[0]).toContain('"quick-start" is already used by sections[0]');
+    expect(problems[0]).toContain(
+      '"quick-start" is already used by sections[0]',
+    );
   });
 
   it('rejects an authored id that collides with a derived key', () => {
     expect(
-      sectionKeyProblems([section('Install'), section('Setup', {id: 'install'})]),
+      sectionKeyProblems([
+        section('Install'),
+        section('Setup', {id: 'install'}),
+      ]),
     ).toHaveLength(1);
   });
 
@@ -85,13 +91,13 @@ describe('sectionKeyProblems', () => {
     }
   });
 
-  it('rejects a title no key derives from', () => {
+  it('reports a title no key derives from', () => {
     expect(sectionKeyProblems([section('亮/暗模式')])[0]).toContain(
-      'Give the section an id',
-    );
-    expect(sectionKeyProblems([section('亮/暗模式', {id: 'light-dark'})])).toEqual(
-      [],
+      'compatibility key is used',
     );
+    expect(
+      sectionKeyProblems([section('亮/暗模式', {id: 'light-dark'})]),
+    ).toEqual([]);
   });
 
   it('leaves a missing title to the title check', () => {
@@ -107,12 +113,21 @@ describe('withSectionKeys', () => {
     expect(doc.sections.map(s => s.id)).toEqual(['quick-start', 'use']);
   });
 
-  it('keeps the authored title of a translated section', () => {
+  it('keeps authored titles and keys stable for translated sections', () => {
     const doc = withSectionKeys({
-      sections: [withSourceTitle(section('快速开始'), 'Quick Start')],
+      sections: [
+        withSourceTitle(section('高级安装'), 'Install advanced'),
+        withSourceTitle(section('安装'), 'Install'),
+      ],
     });
-    expect(doc.sections[0].id).toBe('quick-start');
-    expect(sourceTitle(doc.sections[0])).toBe('Quick Start');
+    expect(doc.sections.map(s => s.id)).toEqual([
+      'install-advanced',
+      'install-2',
+    ]);
+    for (const target of doc.sections) {
+      expect(findDocSection(doc.sections, target.id).section).toBe(target);
+    }
+    expect(sourceTitle(doc.sections[0])).toBe('Install advanced');
   });
 });
 
@@ -127,7 +142,14 @@ describe('findDocSection', () => {
     ],
   }).sections;
 
-  it('finds a section by key first', () => {
+  it('finds every emitted key without changing a legacy query', () => {
+    const colliding = withSectionKeys({
+      sections: [section('Install advanced'), section('Install')],
+    }).sections;
+    expect(findDocSection(colliding, 'install').section).toBe(colliding[0]);
+    for (const target of colliding) {
+      expect(findDocSection(colliding, target.id).section).toBe(target);
+    }
     expect(findDocSection(sections, 'tokens').section.title).toBe(
       'Theme Tokens',
     );
@@ -149,15 +171,15 @@ describe('findDocSection', () => {
     expect(findDocSection(sections, 'props').section.id).toBe('theme-props');
   });
 
-  it('refuses an ambiguous exact title and lists the candidates', () => {
+  it('keeps the first ambiguous exact-title match and lists the candidates', () => {
     const {section: match, candidates} = findDocSection(sections, 'Overview');
-    expect(match).toBeNull();
+    expect(match?.id).toBe('overview-a');
     expect(candidates.map(s => s.id)).toEqual(['overview-a', 'overview-b']);
   });
 
-  it('refuses an ambiguous partial title', () => {
+  it('keeps the first ambiguous partial-title match', () => {
     const {section: match, candidates} = findDocSection(sections, 'theme');
-    expect(match).toBeNull();
+    expect(match?.id).toBe('theme-props');
     expect(candidates.map(s => s.id)).toEqual(['theme-props', 'tokens']);
   });
 
@@ -185,9 +207,9 @@ describe('sectionSummary', () => {
   });
 
   it('is empty when the section has no text', () => {
-    expect(sectionSummary({content: [{type: 'table', headers: [], rows: []}]})).toBe(
-      '',
-    );
+    expect(
+      sectionSummary({content: [{type: 'table', headers: [], rows: []}]}),
+    ).toBe('');
   });
 
   it('cuts a long summary at a word boundary', () => {

package/foundation/discovery/template-adapter.d.mts

@@ -11,11 +11,39 @@ export function pkgOf(t: {
     package?: string;
 }): string;
 /**
- * Replace demo asset references with a placeholder so scaffolded pages
- * render with zero setup. Images get a self-contained data URI; videos
- * (which have no equivalent inline placeholder — see VIDEO_EXTENSIONS) are
- * stripped to an empty src instead of being mis-replaced with image data.
- * Builders drop in their own media either way.
+ * Every id that should resolve to a discovered template. Replacements keep
+ * their own integration id and also own the Core id they replace.
+ * @param {{dirName: string, replaces?: string}} template
+ * @returns {string[]}
+ */
+export function templateLookupIds(template: {
+    dirName: string;
+    replaces?: string;
+}): string[];
+/**
+ * Remove entries shadowed in the default discovery view while retaining them in
+ * package-scoped views. An active replacement owns its target id. A rejected
+ * same-id declaration falls back to Core when a Core template of the same kind
+ * owns that id; otherwise the integration template remains available by kind.
+ * @param {DiscoveredTemplate[]} templates
+ * @returns {DiscoveredTemplate[]}
+ */
+export function effectiveTemplateDiscovery(templates: DiscoveredTemplate[]): DiscoveredTemplate[];
+/**
+ * Replace each Astryx template fixture reference with a placeholder so
+ * scaffolded pages render with zero setup. Images get a self-contained data
+ * URI; videos (which have no equivalent inline placeholder — see
+ * VIDEO_EXTENSIONS) are stripped to an empty src instead of being
+ * mis-replaced with image data. Builders drop in their own media either way.
+ *
+ * A reference is a URL token that resolves to a root-relative path under
+ * FIXTURE_SEGMENT. It is replaced whole, query and fragment included, and
+ * classified by the suffix of its last path segment. A reference that cannot
+ * be replaced safely throws with its path rather than being guessed at or
+ * left behind. Prose is left as written: in text (JSX text, a word inside a
+ * longer string) trailing punctuation is not part of a path and a path with
+ * no suffix, such as the bare directory, is a mention; inside a comment
+ * nothing throws.
  *
  * @param {string} source - Template source code.
  * @returns {string} Source with demo asset references replaced.
@@ -28,6 +56,13 @@ export function stripTemplateAssetRefs(source: string): string;
  * @returns {string[]}
  */
 export function listTemplates(): string[];
+/**
+ * Resolve the template-spec file for a core page directory: the first existing
+ * metadata file in {@link ALL_TEMPLATE_SUFFIXES} precedence, or null.
+ * @param {string} dirPath
+ * @returns {string | null}
+ */
+export function findPageDocFile(dirPath: string): string | null;
 /**
  * Discover only the templates built into @astryxdesign/core. Integration
  * authoring checks use this narrower surface so a broken project config or a
@@ -35,22 +70,54 @@ export function listTemplates(): string[];
  * @returns {Promise<DiscoveredTemplate[]>}
  */
 export function discoverCoreTemplates(): Promise<DiscoveredTemplate[]>;
+/**
+ * Apply valid integration replacements to a raw template set.
+ *
+ * One declaration owns its Core target. When different configured packages
+ * replace the same target, the later package wins and discovery returns a
+ * warning, matching integration-doc replacement order. Multiple declarations
+ * inside one package are invalid and fail closed. Missing targets and kind
+ * mismatches also fail closed: Core stays selected and every integration
+ * template remains addressable by its own id.
+ *
+ * @param {DiscoveredTemplate[]} templates
+ * @param {TemplateDiscoveryError[]} [declarationErrors]
+ * @returns {{templates: DiscoveredTemplate[], errors: TemplateReplacementError[]}}
+ */
+export function applyTemplateReplacements(templates: DiscoveredTemplate[], declarationErrors?: TemplateDiscoveryError[]): {
+    templates: DiscoveredTemplate[];
+    errors: TemplateReplacementError[];
+};
+/**
+ * Discover every template without hiding replaced Core originals. Internal
+ * package-qualified selection uses this view.
+ * @param {string} [cwd]
+ * @returns {Promise<DiscoveredTemplate[]>}
+ */
+export function discoverAllUnresolved(cwd?: string): Promise<DiscoveredTemplate[]>;
+/**
+ * Discover the resolved catalog before default-view shadowing. Internal
+ * package-qualified selection uses this view.
+ * @param {string} [cwd]
+ * @returns {Promise<DiscoveredTemplate[]>}
+ */
+export function discoverAllResolved(cwd?: string): Promise<DiscoveredTemplate[]>;
 /**
  * @param {string} [cwd]
  * @returns {Promise<DiscoveredTemplate[]>}
  */
 export function discoverAll(cwd?: string): Promise<DiscoveredTemplate[]>;
 /**
- * Like {@link discoverAll} but also returns integration-template discovery
- * errors (missing same-stem source, missing `type`, load failure). Use this
- * when the caller wants to warn about malformed integration templates.
+ * Like {@link discoverAll} but also returns integration-template discovery and
+ * replacement-declaration errors. Use this when the caller wants to warn about
+ * malformed integration templates or inactive replacement declarations.
  *
  * @param {string} [cwd]
- * @returns {Promise<{templates: DiscoveredTemplate[], errors: TemplateDiscoveryError[]}>}
+ * @returns {Promise<{templates: DiscoveredTemplate[], errors: Array<TemplateDiscoveryError | TemplateReplacementError>}>}
  */
 export function discoverAllWithErrors(cwd?: string): Promise<{
     templates: DiscoveredTemplate[];
-    errors: TemplateDiscoveryError[];
+    errors: Array<TemplateDiscoveryError | TemplateReplacementError>;
 }>;
 /**
  * Discover the templates contributed by a SINGLE integration. Same per-template
@@ -58,12 +125,13 @@ export function discoverAllWithErrors(cwd?: string): Promise<{
  * page|block type required); broken templates are recorded in `errors` rather
  * than thrown. Exposed for `doctor integration validate` and template authoring checks.
  *
- * @param {{name?: string, __spec?: string, templates?: string}} integration
+ * @param {{name?: string, __spec?: string, __autolinked?: boolean, templates?: string}} integration
  * @returns {Promise<{templates: DiscoveredTemplate[], errors: TemplateDiscoveryError[]}>}
  */
 export function discoverIntegrationTemplatesForOne(integration: {
     name?: string;
     __spec?: string;
+    __autolinked?: boolean;
     templates?: string;
 }): Promise<{
     templates: DiscoveredTemplate[];
@@ -117,6 +185,23 @@ export type DiscoveredTemplate = {
     filePath: string;
     docPath: string;
     package?: string | undefined;
+    /**
+     * whether the owning integration was discovered
+     * from package.json rather than named in astryx.config
+     */
+    autolinked?: boolean | undefined;
+    /**
+     * active Core template id this integration template replaces
+     */
+    replaces?: string | undefined;
+    /**
+     * whether an invalid declaration was disabled
+     */
+    replacementRejected?: boolean | undefined;
+    /**
+     * disabled declaration target
+     */
+    replacementTarget?: string | undefined;
 };
 /**
  * An integration-template discovery error.
@@ -125,6 +210,23 @@ export type TemplateDiscoveryError = {
     package: string;
     template?: string | undefined;
     message: string;
+    code?: string | undefined;
+    severity?: "error" | "warning" | undefined;
+    /**
+     * Core target whose replacement set is invalid
+     */
+    replacementTarget?: string | undefined;
+    /**
+     * whether the declaration came from an autolinked integration
+     */
+    autolinked?: boolean | undefined;
+};
+/**
+ * A semantic error in an integration template replacement declaration.
+ */
+export type TemplateReplacementError = TemplateDiscoveryError & {
+    code: "missing_template_replacement_target" | "ambiguous_template_replacement" | "invalid_template_replacement";
+    severity: "warning" | "error";
 };
 /**
  * The loaded metadata object from a template spec (loose — authored shape).