@astryxdesign/cli 0.7.2 → 0.7.3-canary.02f5fe4

package/api/discover/_adapter.mjs

@@ -25,6 +25,8 @@ import {
   availableComputerIntegrations,
 } from '../../foundation/config/project.mjs';
 import {isOutsideProject} from '../../foundation/env/project-scope.mjs';
+import {projectAddCommand} from '../../foundation/release/notices.mjs';
+import {hostedRun} from '../../foundation/runtime/package-root.mjs';
 import {
   scanAllPackages,
   findComponentInPackages,
@@ -242,6 +244,7 @@ export async function describeInstalled(project, scanned) {
  * @returns {boolean}
  */
 export function hasSources(project) {
+  if (doorSources().length > 0) return true;
   if (project == null) return false;
   if (typeof project.config?.discover === 'function') return true;
   return project.loadedIntegrations.some(
@@ -249,6 +252,19 @@ export function hasSources(project) {
   );
 }
 
+/** Where a discover source a host passed comes from (spec AST-081 FR1). */
+const DOOR_SOURCE = 'the host';
+
+/**
+ * The discover sources the host that started this run passed, if any.
+ * @returns {readonly DiscoverSource[]}
+ */
+function doorSources() {
+  return /** @type {readonly DiscoverSource[]} */ (
+    hostedRun()?.discoverSources ?? []
+  );
+}
+
 /** The source name of a package installed for the computer. */
 const COMPUTER_SOURCE = 'installed for this computer';
 
@@ -259,17 +275,14 @@ const COMPUTER_SOURCE = 'installed for this computer';
  * @param {Project | undefined} project
  * @param {Array<{name: string}>} installed
  * @param {Set<string>} declared
- * @param {(name: string, version?: string) => string} add
  * @returns {Promise<import('./discover.type.mjs').DiscoverAvailableEntry[]>}
  */
-export async function computerAvailableEntries(
-  project,
-  installed,
-  declared,
-  add,
-) {
+export async function computerAvailableEntries(project, installed, declared) {
   const cwd = project?.cwd ?? process.cwd();
   if (isOutsideProject(cwd)) return [];
+  // The same command doctor names: in the project spec:AST-040 FR9 defines,
+  // and none where FR9 finds no project.
+  const add = projectAddCommand(cwd);
   const have = new Set([...installed.map(pkg => pkg.name), ...declared]);
   return (await availableComputerIntegrations(cwd, have)).map(c => ({
     name: c.name,
@@ -277,7 +290,7 @@ export async function computerAvailableEntries(
     ...(c.version ? {version: c.version} : {}),
     ...(c.description ? {description: c.description} : {}),
     source: COMPUTER_SOURCE,
-    install: add(c.name),
+    ...(add ? {install: add(c.name)} : {}),
   }));
 }
 
@@ -479,7 +492,8 @@ export function defaultCacheDir() {
 
 /**
  * @param {string} cacheDir
- * @param {string} from
+ * @param {string} from the source's key: its `from` label, with the host for
+ *   a host's source
  * @param {{package?: string, version?: string}} request
  */
 function savedCopyPath(cacheDir, from, request) {
@@ -557,8 +571,9 @@ async function callSource(source, request, label, timeoutMs) {
 }
 
 /**
- * Call the project's own discover sources — the project's `discover` first,
- * then each integration's in load order — once per distinct function. A source that
+ * Call the discover sources — the project's `discover` first, then each
+ * integration's in load order, then each a host passed, named as the host's
+ * (spec AST-081 FR1, AST-051 FR6) — once per distinct function. A source that
  * throws, times out, or returns an invalid catalog falls back to its saved copy;
  * with none, it is reported and adds nothing. The others always count.
  *
@@ -572,20 +587,30 @@ async function callOwnSources(project, request = {}, options = {}) {
   const {cacheDir = defaultCacheDir(), timeoutMs = SOURCE_TIMEOUT_MS} = options;
   /** @type {CatalogResult} */
   const result = {sources: [], packages: []};
-  if (project == null) return result;
+  const fromDoor = doorSources();
+  if (project == null && fromDoor.length === 0) return result;
 
-  /** @type {Array<{from: string, source?: DiscoverSource, error?: string}>} */
+  /** @type {Array<{from: string, key?: string, source?: DiscoverSource, error?: string}>} */
   const origins = [];
-  if (typeof project.config?.discover === 'function') {
+  if (typeof project?.config?.discover === 'function') {
     origins.push({from: 'astryx.config', source: project.config.discover});
   }
-  for (const integration of project.loadedIntegrations) {
+  for (const integration of project?.loadedIntegrations ?? []) {
     if (integration.__discoverError) {
       origins.push({from: integration.name, error: integration.__discoverError});
     } else if (integration.__discover) {
       origins.push({from: integration.name, source: integration.__discover});
     }
   }
+  // Every tool that carries the CLI reports its sources as the host's, so
+  // their saved copies are kept per host, by the root that holds its CLI
+  // (spec:AST-051 FR8).
+  const host = hostedRun()?.startingRoot ?? '';
+  fromDoor.forEach((source, index) => {
+    const from =
+      fromDoor.length === 1 ? DOOR_SOURCE : `${DOOR_SOURCE} (${index + 1})`;
+    origins.push({from, key: `${from}\n${host}`, source});
+  });
 
   /** @type {Set<unknown>} */
   const called = new Set();
@@ -594,7 +619,7 @@ async function callOwnSources(project, request = {}, options = {}) {
   const ask = request.package
     ? {package: request.package, ...(request.version ? {version: request.version} : {})}
     : {};
-  for (const {from, source, error} of origins) {
+  for (const {from, key = from, source, error} of origins) {
     if (source == null) {
       result.sources.push({name: from, from, status: 'failed', error});
       continue;
@@ -603,7 +628,7 @@ async function callOwnSources(project, request = {}, options = {}) {
     called.add(source);
 
     const label = `the discover source from ${from}`;
-    const file = savedCopyPath(cacheDir, from, ask);
+    const file = savedCopyPath(cacheDir, key, ask);
     /** @type {import('../../authoring/discover/type').DiscoverCatalog} */
     let catalog;
     try {

package/api/discover/_adapter.test.mjs

@@ -21,6 +21,10 @@ import {
   withDeclaredOfficial,
 } from './_adapter.mjs';
 import {parseDiscoverCatalog} from '../../authoring/discover/parse.mjs';
+import {
+  _resetHostedRun,
+  activateHostedRun,
+} from '../../foundation/runtime/package-root.mjs';
 
 /** No official packages, so a test sees only its own sources after it. */
 const NO_OFFICIAL = {packages: []};
@@ -230,6 +234,44 @@ describe('callSources', () => {
     expect(otherRequest.sources[0].status).toBe('failed');
   });
 
+  it("keeps a host's saved copies per host, so one tool never answers with another's", async () => {
+    let online = true;
+    const source = async () => {
+      if (!online) throw new Error('offline');
+      return catalog('Acme catalog', [pkg('@acme/one')]);
+    };
+    const options = {cacheDir, official: NO_OFFICIAL};
+    try {
+      activateHostedRun({
+        discoverSources: [source],
+        startingRoot: '/tools/acme',
+      });
+      await callSources(undefined, {}, options);
+      online = false;
+      const sameHost = await callSources(undefined, {}, options);
+      expect(sameHost.sources[0]).toMatchObject({
+        name: 'Acme catalog',
+        from: 'the host',
+        status: 'saved',
+      });
+
+      _resetHostedRun();
+      activateHostedRun({
+        discoverSources: [source],
+        startingRoot: '/tools/other',
+      });
+      const otherHost = await callSources(undefined, {}, options);
+      expect(otherHost.sources[0]).toMatchObject({
+        from: 'the host',
+        status: 'failed',
+        error: 'offline',
+      });
+      expect(otherHost.packages).toEqual([]);
+    } finally {
+      _resetHostedRun();
+    }
+  });
+
   it('keeps the saved copy in the cache directory, not in the project', async () => {
     await callSources(
       project({

package/api/discover/discover.mjs

@@ -223,7 +223,6 @@ export async function discover(query, options = {}) {
       project,
       packages,
       declared,
-      add,
     );
     const fromSources = officialFirst(
       availableEntries(catalog, packages, declared, {

package/api/docs/_adapter.d.mts

@@ -226,7 +226,7 @@ export function topicUp(entry: import("../../foundation/discovery/docs-discovery
 export function placeLinks(tree: DocsTree, node: TreeNode): import("./docs.type.mjs").DocsLinks;
 /**
  * The moves a topic read offers: from its place in the tree, where a guide
- * sits in its namespace and a flat topic in the Unorganized level.
+ * sits in its namespace and a flat topic in its topic level.
  * @param {DocsCatalog} catalog
  * @param {import('../../foundation/discovery/docs-discovery.mjs').DocsTopicEntry} entry
  * @returns {Promise<import('./docs.type.mjs').DocsLinks>}
@@ -290,7 +290,7 @@ export function holdsOwnName(tree: DocsTree, catalog: DocsCatalog, entry: import
 /**
  * The doc that took a flat topic's route in the docs tree, when it is not
  * that topic (spec:AST-046 FR11): the CLI keeps its routes, such as `cli`
- * and `unorganized`, and a namespace keeps its route over a topic of the same
+ * and `guides`, and a namespace keeps its route over a topic of the same
  * name. Null when the topic owns its route, or the tree has no node there.
  * @param {DocsTree} tree
  * @param {import('../../foundation/discovery/docs-discovery.mjs').DocsTopicEntry} entry

package/api/docs/_adapter.mjs

@@ -52,6 +52,7 @@ import {
   cliDocSection,
 } from '../../foundation/discovery/cli-self-docs.mjs';
 import {
+  AUTHORING_REFERENCE_ROUTE,
   loadAuthoringSelfDocs,
   schemaFieldTable,
   selfDocSection,
@@ -70,6 +71,7 @@ import {
 import {findCoreDir} from '../../foundation/fs/paths.mjs';
 import {AstryxError} from '../error.mjs';
 import {ERROR_CODES} from '../../foundation/response/error-codes.mjs';
+import {orderRouteSuggestions} from '../../foundation/text/suggest-order.mjs';
 import {formatCliCommand} from '../../foundation/env/package-manager.mjs';
 
 export {OVERLAY_LANGUAGES, overlayLanguages};
@@ -385,7 +387,7 @@ export function projectTree(catalog, {fresh = false} = {}) {
 let cliTreeInputs;
 
 /**
- * Every flat topic in the catalog, as the tree's Unorganized level reads it.
+ * Every flat topic in the catalog, as the tree's topic levels read it.
  * @param {DocsCatalog} catalog
  * @returns {Promise<import('../../foundation/doc-compiler/tree.mjs').TreeTopicInput[]>}
  */
@@ -394,12 +396,13 @@ async function flatTopicInputs(catalog) {
   const topics = [];
   for (const entry of catalog.entries()) {
     const aliases = catalog.aliasesOf(entry);
-    let {title, description} = entry;
-    if (title == null || description == null) {
+    let {title, description, category} = entry;
+    if (title == null || description == null || category === undefined) {
       try {
         const file = await loadTopicFile(entry.path, null);
         title ??= file.doc?.title;
         description ??= file.doc?.description;
+        category ??= file.doc?.category;
       } catch {
         // A topic that does not load is reported where it is read.
       }
@@ -410,6 +413,7 @@ async function flatTopicInputs(catalog) {
       name: entry.name,
       title: title ?? entry.name,
       summary: description ?? '',
+      category: category ?? null,
       source: `${entry.package}:${entry.name}`,
       ...(aliases.length > 0 ? {aliases} : {}),
     });
@@ -419,7 +423,7 @@ async function flatTopicInputs(catalog) {
 
 /**
  * The CLI's tree, each configured integration's namespaces and guides, and
- * every flat topic in the generated Unorganized level.
+ * every flat topic in the generated level for its category.
  * @param {DocsCatalog} catalog
  * @param {boolean} fresh
  * @returns {Promise<DocsTree>}
@@ -509,23 +513,22 @@ function identitiesOf(tree) {
 }
 
 /**
- * The CLI's authoring docs, by kind and name. `astryx docs authoring` reads
- * each as one section keyed by its name, so a link to one opens that section.
- * Loaded once per process, like the CLI's tree files.
+ * The CLI's authoring docs, by kind and name. The field reference under
+ * `astryx docs authoring` reads each as one section keyed by its name, so a
+ * link to one opens that section. Loaded once per process, like the CLI's
+ * tree files.
  * @type {Promise<Map<string, any>> | undefined}
  */
 let authoringDocs;
 
 /**
- * The CLI authoring doc a link names, while `astryx docs authoring` is the
- * CLI's own topic.
- * @param {DocsCatalog} catalog
+ * The CLI authoring doc a link names. The `authoring` namespace is the CLI's
+ * own, so no integration can take its route.
  * @param {string} kind
  * @param {string} name
  * @returns {Promise<any | null>}
  */
-async function authoringDoc(catalog, kind, name) {
-  if (catalog.resolve('authoring')?.package !== CLI_PROVIDER_ID) return null;
+async function authoringDoc(kind, name) {
   authoringDocs ??= loadAuthoringSelfDocs().then(
     ({loaded}) =>
       new Map(loaded.map(({doc}) => [`${doc.type}\u0000${doc.name}`, doc])),
@@ -611,14 +614,14 @@ function docFinderOver(catalog, tree, fromProvider, summaries = true) {
     }
     const authored =
       provider === CLI_PROVIDER_ID
-        ? await authoringDoc(catalog, parsed.kind, parsed.name)
+        ? await authoringDoc(parsed.kind, parsed.name)
         : null;
     if (authored) {
       return {
         link: {
           target,
           id: createDocId(provider, authored.type, authored.name),
-          route: 'authoring',
+          route: AUTHORING_REFERENCE_ROUTE,
           title: authored.displayName ?? authored.name,
           summary: authored.description ?? '',
           command: `astryx docs authoring ${authored.name}`,
@@ -1146,6 +1149,14 @@ function packageCatalog(integration, discovered) {
  * @returns {Promise<Array<{severity: 'warning', message: string}>>}
  */
 export async function packageComponentLinkProblems(integration, discovered) {
+  // A package with no provider id (its manifest's, else its name) links
+  // nothing, as on the read path: its text reads as written, so there is
+  // nothing to report.
+  try {
+    normalizeProviderId(integration.providerId ?? integration.name);
+  } catch {
+    return [];
+  }
   const catalog = packageCatalog(integration, discovered);
   return (await componentLinkProblems(catalog, integration.name)).map(
     message => ({severity: /** @type {const} */ ('warning'), message}),
@@ -1176,11 +1187,15 @@ async function componentLinkProblems(catalog, owner) {
       // The components check reports a doc that does not load.
       continue;
     }
-    const linked = await linkComponentDoc(
-      catalog,
-      componentLinkProvider(record.package, record.providerId),
-      doc,
-    );
+    let provider;
+    try {
+      provider = componentLinkProvider(record.package, record.providerId);
+    } catch {
+      // An owner that is not a provider id links nothing (as on the read
+      // path); its text reads as written.
+      continue;
+    }
+    const linked = await linkComponentDoc(catalog, provider, doc);
     const name = typeof doc?.name === 'string' ? doc.name : record.name;
     for (const problem of linked.problems) {
       problems.push(
@@ -1416,7 +1431,7 @@ export function placeLinks(tree, node) {
 
 /**
  * The moves a topic read offers: from its place in the tree, where a guide
- * sits in its namespace and a flat topic in the Unorganized level.
+ * sits in its namespace and a flat topic in its topic level.
  * @param {DocsCatalog} catalog
  * @param {import('../../foundation/discovery/docs-discovery.mjs').DocsTopicEntry} entry
  * @returns {Promise<import('./docs.type.mjs').DocsLinks>}
@@ -1514,7 +1529,7 @@ function treeArgument(catalog, tree, node) {
 /**
  * The doc that took a flat topic's route in the docs tree, when it is not
  * that topic (spec:AST-046 FR11): the CLI keeps its routes, such as `cli`
- * and `unorganized`, and a namespace keeps its route over a topic of the same
+ * and `guides`, and a namespace keeps its route over a topic of the same
  * name. Null when the topic owns its route, or the tree has no node there.
  * @param {DocsTree} tree
  * @param {import('../../foundation/discovery/docs-discovery.mjs').DocsTopicEntry} entry
@@ -1528,6 +1543,35 @@ export function routeOwner(tree, entry) {
     : node;
 }
 
+/**
+ * Routes that moved, old prefix first: the integration guides moved from
+ * `cli/integrations` (and, before that, the `cli-integrations` topic) into
+ * `authoring`, the one home for integration authors.
+ * Only the not-found error reads this, to name where a doc went; an old route
+ * opens nothing.
+ */
+const MOVED_ROUTES = [
+  ['cli/integrations', 'authoring'],
+  ['cli-integrations', 'authoring'],
+];
+
+/**
+ * The node an old route moved to, or null.
+ * @param {unknown} topic
+ * @param {DocsTree} tree
+ * @returns {TreeNode | null}
+ */
+function movedRoute(topic, tree) {
+  if (typeof topic !== 'string') return null;
+  const wanted = topic.toLowerCase();
+  for (const [from, to] of MOVED_ROUTES) {
+    if (wanted !== from && !wanted.startsWith(`${from}/`)) continue;
+    const node = tree.getFolded(`${to}${wanted.slice(from.length)}`);
+    if (node) return node;
+  }
+  return null;
+}
+
 /**
  * The error for a docs argument that names nothing. For a route, it suggests
  * the children of the deepest namespace the route reaches; otherwise, every
@@ -1560,8 +1604,7 @@ export async function unknownTopicError(topic, catalog) {
   }
   if (suggestions.length === 0 && typeof topic === 'string') {
     // The docs whose own name it is (`doctor` is cli/commands/doctor), or whose
-    // route it spells with hyphens (`cli-integrations`, the guide's name before
-    // it moved to cli/integrations).
+    // route it spells with hyphens (`cli-host-entry` is cli/host-entry).
     const wanted = topic.toLowerCase();
     suggestions = [...tree.nodes.values()]
       .filter(
@@ -1580,6 +1623,22 @@ export async function unknownTopicError(topic, catalog) {
       ...catalog.names().map(name => ({name, reason: 'available topic'})),
     ];
   }
+  if (typeof topic === 'string') {
+    suggestions = orderRouteSuggestions(topic, suggestions);
+  }
+  // A route that moved names where it went, ahead of the usual suggestions
+  // (spec:AST-046 FR9, FR6).
+  const moved = movedRoute(topic, tree);
+  if (moved) {
+    return new AstryxError(
+      `Unknown topic "${String(topic)}". It moved to "${moved.route}"${notLoaded(catalog)}`,
+      [
+        {name: moved.route, reason: moved.summary},
+        ...suggestions.filter(entry => entry.name !== moved.route),
+      ],
+      ERROR_CODES.ERR_UNKNOWN_TOPIC,
+    );
+  }
   return new AstryxError(
     `Unknown topic "${String(topic)}"${notLoaded(catalog)}`,
     suggestions,

package/api/docs/docs-homes.test.mjs

@@ -0,0 +1,127 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Every Core doc has a named home in the docs tree (spec:AST-046 FR12).
+ *
+ * A reader sees a doc's home in its path (`Guides › Getting started`) and in
+ * its Up move. A flat Core topic sits in Guides or Foundations by the
+ * category it declares, so a new topic with no category, or one the levels
+ * do not know, fails here instead of landing in a catch-all. The integration
+ * guides and their field reference live under `authoring`, and the routes
+ * they left name where they went.
+ */
+
+import {describe, expect, it} from 'vitest';
+import {docs} from './docs.mjs';
+import {TOPIC_LEVELS} from '../../foundation/doc-compiler/tree.mjs';
+
+const CLI = '@astryxdesign/cli';
+const SLOW = 60_000;
+
+describe('every Core doc has a named home', () => {
+  it(
+    'puts each flat Core topic in Guides or Foundations by its category',
+    async () => {
+      const list = await docs();
+      const core = list.data.filter(topic => topic.package === CLI);
+      expect(core.length).toBeGreaterThan(10);
+      /** @type {string[]} */
+      const unfiled = [];
+      for (const topic of core) {
+        const read = await docs(topic.topic);
+        const {category} = read.data;
+        if (category !== 'guide' && category !== 'foundations') {
+          unfiled.push(`${topic.topic} (category ${String(category)})`);
+          continue;
+        }
+        const level =
+          category === 'foundations'
+            ? TOPIC_LEVELS.foundations
+            : TOPIC_LEVELS.guides;
+        expect(read.data.links.up, topic.topic).toBe(
+          `astryx docs ${level.route}`,
+        );
+      }
+      expect(unfiled, 'Core topics with no home: give each a category').toEqual(
+        [],
+      );
+    },
+    SLOW,
+  );
+
+  it(
+    'lists each level under a plain name, and no catch-all',
+    async () => {
+      const list = await docs();
+      const roots = (list.meta.namespaces ?? []).map(entry => entry.topic);
+      expect(roots).toEqual(expect.arrayContaining(['guides', 'foundations']));
+      expect(roots).not.toContain('unorganized');
+      const guides = await docs('guides');
+      expect(guides.data).toMatchObject({route: 'guides', title: 'Guides'});
+      expect(guides.data.slots[0].children.map(child => child.route)).toEqual(
+        expect.arrayContaining(['getting-started', 'principles', 'theme']),
+      );
+      const foundations = await docs('foundations');
+      expect(foundations.data.title).toBe('Foundations');
+      expect(
+        foundations.data.slots[0].children.map(child => child.route),
+      ).toEqual(expect.arrayContaining(['color', 'icons', 'spacing']));
+      await expect(docs('unorganized')).rejects.toMatchObject({
+        code: 'ERR_UNKNOWN_TOPIC',
+      });
+    },
+    SLOW,
+  );
+
+  it(
+    'keeps everything for integration authors under authoring, and names where an old route went',
+    async () => {
+      const authoring = await docs('authoring');
+      expect(authoring.data).toMatchObject({
+        route: 'authoring',
+        kind: 'namespace',
+        breadcrumb: [],
+        links: {up: 'astryx docs'},
+      });
+      const children = authoring.data.slots.flatMap(slot =>
+        slot.children.map(child => child.route),
+      );
+      expect(children).toEqual(
+        expect.arrayContaining([
+          'authoring/quick-start',
+          'authoring/building-blocks',
+          'authoring/ship',
+          'authoring/help',
+          'authoring/field-reference',
+        ]),
+      );
+      // Every field reference section still opens from the namespace by its
+      // key, as `astryx docs authoring <name>` did on the topic (FR13).
+      const reference = await docs('authoring/field-reference', undefined, {
+        index: true,
+      });
+      const keys = reference.data.sections.map(section => section.id);
+      expect(keys.length).toBeGreaterThan(15);
+      for (const key of keys) {
+        const section = await docs('authoring', key);
+        expect(section.type, key).toBe('docs.detail.section');
+        expect(section.data.id, key).toBe(key);
+      }
+      for (const [old, now] of [
+        ['cli/integrations', 'authoring'],
+        ['cli/integrations/quick-start', 'authoring/quick-start'],
+        ['cli/integrations/ship/publishing', 'authoring/ship/publishing'],
+      ]) {
+        const error = await docs(old).catch(e => e);
+        expect(error).toMatchObject({
+          code: 'ERR_UNKNOWN_TOPIC',
+          message: expect.stringContaining(`It moved to "${now}"`),
+        });
+        // The new route comes first, ahead of the suggestions any unknown
+        // route gets (FR6).
+        expect(error.suggestions[0]).toMatchObject({name: now});
+      }
+    },
+    SLOW,
+  );
+});

package/api/docs/docs.doc.mjs

@@ -28,7 +28,7 @@ export const doc = {
     '`cli/api` returns its children one level down (`depth` reads as many ' +
     'levels as asked, and `detail` how much of each doc below), a typed doc such as ' +
     "`cli/api/functions/search` returns its content, and a guide the tree " +
-    'places (`cli/integrations/quick-start`) reads like any topic. ' +
+    'places (`authoring/quick-start`) reads like any topic. ' +
     'Every read but the list carries `links`, the commands that move from it: ' +
     '`up` to the level it sits in, `previous` and `next` to its neighbors, and, ' +
     'for a typed doc, `related` to the docs it names (its command or function, ' +
@@ -162,12 +162,12 @@ export const doc = {
     },
     {
       label: 'A namespace and everything below it, in full',
-      code: "await docs('cli/integrations', undefined, {depth: 'all', detail: 'full'});",
+      code: "await docs('authoring', undefined, {depth: 'all', detail: 'full'});",
     },
     {label: 'One API function', code: "await docs('cli/api/functions/search');"},
     {
       label: 'A whole guide from the docs tree',
-      code: "await docs('cli/integrations/quick-start');",
+      code: "await docs('authoring/quick-start');",
     },
     {label: 'One section by key', code: "await docs('spacing', 'scale');"},
   ],