@astryxdesign/cli 0.6.3-canary.e59d786 → 0.6.3-canary.e78c3ce

package/api/docs/detail/section/section.mjs

@@ -4,9 +4,9 @@
  * @file docs.detail.section leaf — load a single section of a topic.
  *
  * @input A topic name, a section query, and optional {lang, zh, dense}. Resolves
- *   the topic via the shared adapter, finds the section in its lowered compiled
- *   node by its stable key, then by exact title, then by a title that contains
- *   the query, and links only that section.
+ *   the topic via the shared adapter, keeps the 0.6.x first title-substring
+ *   match, then falls back to a stable key or normalized title key, and links
+ *   only that section.
  * @output { type: 'docs.detail.section', data: ReferenceSection } with any
  *   token-ref blocks inlined — matching `astryx --json docs <topic> <section>`.
  *   Throws ERR_UNKNOWN_SECTION when nothing matches, or when the query matches
@@ -17,10 +17,7 @@
 
 import {AstryxError} from '../../../error.mjs';
 import {ERROR_CODES} from '../../../../foundation/response/error-codes.mjs';
-import {
-  findDocSection,
-  sectionKey,
-} from '../../../../foundation/discovery/docs-section-key.mjs';
+import {findDocSection} from '../../../../foundation/discovery/docs-section-key.mjs';
 import {linkReferenceSection} from '../../../../foundation/doc-compiler/compile.mjs';
 import {
   readerSections,
@@ -52,16 +49,13 @@ export async function section(topic, sectionName, options = {}) {
 
   const {catalog, node, lang} = await resolveTopicDocs(topic, options);
   const sections = readerSections(node);
-  const {section: match, candidates} = findDocSection(sections, sectionName);
+  const {section: match} = findDocSection(sections, sectionName);
   if (!match) {
-    const ambiguous = candidates.length > 1;
     throw new AstryxError(
-      ambiguous
-        ? `Section "${sectionName}" matches ${candidates.length} sections in "${topic}". Read one by its key.`
-        : `Section "${sectionName}" not found in "${topic}"`,
-      (ambiguous ? candidates : sections).map(s => ({
-        name: sectionKey(s),
-        reason: s.title,
+      `Section "${sectionName}" not found in "${topic}"`,
+      sections.map(s => ({
+        name: s.title,
+        reason: 'available section',
       })),
       ERROR_CODES.ERR_UNKNOWN_SECTION,
     );

package/api/docs/detail/section/section.test.mjs

@@ -30,6 +30,17 @@ describe('docs.detail.section leaf', () => {
     }
     expect(err).toBeInstanceOf(AstryxError);
     expect(err.code).toBe('ERR_UNKNOWN_SECTION');
+    expect(err.suggestions).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          name: expect.any(String),
+          reason: 'available section',
+        }),
+      ]),
+    );
+    expect(err.suggestions.some(suggestion => /\s/u.test(suggestion.name))).toBe(
+      true,
+    );
   }, SLOW);
 
   it('does not return the first section for an empty section name', async () => {
@@ -50,12 +61,10 @@ describe('docs.detail.section leaf', () => {
     expect(res.data.id).toBe(target.id);
   }, SLOW);
 
-  it('refuses a query that matches more than one section', async () => {
-    const err = await section('theme', 'e').catch(e => e);
-    expect(err).toBeInstanceOf(AstryxError);
-    expect(err.code).toBe('ERR_UNKNOWN_SECTION');
-    expect(err.message).toMatch(/matches \d+ sections/);
-    expect(err.suggestions.length).toBeGreaterThan(1);
+  it('keeps a previously accepted ambiguous query on its first match', async () => {
+    const res = await section('theme', 'e');
+    expect(res.type).toBe('docs.detail.section');
+    expect(res.data).toBeDefined();
   }, SLOW);
 
   it.each([null, 'zh', 'dense'])(

package/api/doctor/doctor.mjs

@@ -994,7 +994,7 @@ export async function checkDocsProgressiveDisclosure(ctx) {
     return {
       id,
       label,
-      status: 'fail',
+      status: 'warn',
       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.',
     };

package/api/doctor/doctor.test.mjs

@@ -391,7 +391,7 @@ describe('checkDocsProgressiveDisclosure', () => {
     expect(c.message).toMatch(/^\d+ topics: /);
   }, SLOW);
 
-  it('fails on an invalid doc an integration contributed', async () => {
+  it('warns on an invalid doc an integration contributed', async () => {
     const c = await checkDocsProgressiveDisclosure({
       docsCatalogIssues: [
         {
@@ -402,13 +402,13 @@ describe('checkDocsProgressiveDisclosure', () => {
         },
       ],
     });
-    expect(c.status).toBe('fail');
+    expect(c.status).toBe('warn');
     expect(c.message).toBe('@acme/widgets: bad.doc.mjs exports no doc');
   });
 
-  it('fails when the docs catalog cannot be built', async () => {
+  it('warns when the docs catalog cannot be built', async () => {
     const c = await checkDocsProgressiveDisclosure({docsCatalogError: 'boom'});
-    expect(c.status).toBe('fail');
+    expect(c.status).toBe('warn');
     expect(c.message).toContain('boom');
   });
 
@@ -436,7 +436,7 @@ describe('checkDocsProgressiveDisclosure', () => {
       }),
       docsCatalogIssues: [],
     });
-    expect(c.status).toBe('fail');
+    expect(c.status).toBe('warn');
     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: ');
@@ -812,7 +812,7 @@ describe('checkDocsProgressiveDisclosure languages', () => {
       docsCatalog: DocsCatalog.fromBuiltins({deploying: path.join(dir, 'deploying.doc.mjs')}),
       docsCatalogIssues: [],
     });
-    expect(c.status).toBe('fail');
+    expect(c.status).toBe('warn');
     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/assets/codemods/transforms/next/__tests__/migrate-native-picker-to-presentation.test.mjs

@@ -0,0 +1,63 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import {describe, expect, it} from 'vitest';
+import transform from '../migrate-native-picker-to-presentation.mjs';
+
+async function applyTransform(source) {
+  const jscodeshift = (await import('jscodeshift')).default;
+  const j = jscodeshift.withParser('tsx');
+  const api = {jscodeshift: j, stats: () => {}, report: () => {}};
+  return transform({source, path: 'test.tsx'}, api) ?? source;
+}
+
+describe('migrate-native-picker-to-presentation', () => {
+  it('maps DateInput and DateTimeInput values (FR3)', async () => {
+    const output =
+      await applyTransform(`import {DateInput, DateTimeInput} from '@astryxdesign/core';
+const a = <DateInput label="d" nativePicker="touch" />;
+const b = <DateInput label="d" nativePicker="always" />;
+const c = <DateTimeInput label="dt" nativePicker="never" />;`);
+
+    expect(output).toContain("presentation='adaptive-native'");
+    expect(output).toContain("presentation='native'");
+    expect(output).toContain("presentation='adaptive-bottom-sheet'");
+    expect(output).not.toContain('nativePicker');
+  });
+
+  it('maps TimeInput never to text-input (FR3)', async () => {
+    const output =
+      await applyTransform(`import {TimeInput} from '@astryxdesign/core';
+const a = <TimeInput label="t" nativePicker="never" />;
+const b = <TimeInput label="t" nativePicker={'touch'} />;`);
+
+    expect(output).toContain("presentation='text-input'");
+    expect(output).toContain("presentation={'adaptive-native'}");
+  });
+
+  it('drops nativePicker when presentation is already set (FR4)', async () => {
+    const output =
+      await applyTransform(`import {DateInput} from '@astryxdesign/core';
+const a = <DateInput label="d" presentation="popover" nativePicker="always" />;`);
+
+    expect(output).toContain('presentation="popover"');
+    expect(output).not.toContain('nativePicker');
+  });
+
+  it('leaves dynamic values and unrelated components unchanged', async () => {
+    const source = `import {DateInput, Selector} from '@astryxdesign/core';
+const a = <DateInput label="d" nativePicker={mode} />;
+const b = <Selector nativePicker="never" />;`;
+    expect(await applyTransform(source)).toBe(source);
+  });
+
+  it('leaves a mixed static/dynamic conditional byte-identical when a sibling migrates', async () => {
+    const output =
+      await applyTransform(`import {TimeInput} from '@astryxdesign/core';
+const a = <TimeInput label="t" nativePicker="touch" />;
+const b = <TimeInput label="t" nativePicker={flag ? 'always' : mode} />;`);
+
+    expect(output).toContain("presentation='adaptive-native'");
+    expect(output).toContain("nativePicker={flag ? 'always' : mode}");
+    expect(output).not.toContain("'native'");
+  });
+});

package/assets/codemods/transforms/next/__tests__/migrate-theme-catalog-to-descriptors.test.mjs

@@ -81,6 +81,7 @@ describe('migrate-theme-catalog-to-descriptors', () => {
   it('is staged for the next release as a project codemod', () => {
     expect(manifest.map(t => [t.name, t.meta.codemodType])).toEqual([
       ['migrate-theme-catalog-to-descriptors', 'project'],
+      ['migrate-native-picker-to-presentation', undefined],
     ]);
   });
 
@@ -135,6 +136,9 @@ describe('migrate-theme-catalog-to-descriptors', () => {
 
   it('previews without writing, even with no source folder', async () => {
     writeKit([entry('ocean')]);
+    // A staged code codemod (migrate-native-picker-to-presentation) requires
+    // the source folder to exist; an empty one exercises the same preview.
+    fs.mkdirSync(path.join(root, 'src'), {recursive: true});
 
     const result = await run(false, path.join(root, 'src'));
 

package/assets/codemods/transforms/next/index.mjs

@@ -10,6 +10,9 @@
 import migrateThemeCatalogToDescriptors, {
   meta as migrateThemeCatalogToDescriptorsMeta,
 } from './migrate-theme-catalog-to-descriptors.mjs';
+import migrateNativePickerToPresentation, {
+  meta as migrateNativePickerToPresentationMeta,
+} from './migrate-native-picker-to-presentation.mjs';
 
 export default [
   {
@@ -17,4 +20,9 @@ export default [
     transform: migrateThemeCatalogToDescriptors,
     meta: migrateThemeCatalogToDescriptorsMeta,
   },
+  {
+    name: 'migrate-native-picker-to-presentation',
+    transform: migrateNativePickerToPresentation,
+    meta: migrateNativePickerToPresentationMeta,
+  },
 ];

package/assets/codemods/transforms/next/migrate-native-picker-to-presentation.mjs

@@ -0,0 +1,148 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Codemod: migrate nativePicker to presentation on date/time inputs
+ *
+ * `spec:AST-043` FR3 mapping, applied only to static literals written
+ * directly on imported `DateInput`, `DateTimeInput`, and `TimeInput`
+ * elements: the prop is renamed to `presentation` and its value mapped.
+ * When the element already sets `presentation`, the deprecated prop is
+ * removed (presentation wins, FR4). Dynamic values are left unchanged —
+ * the deprecated prop keeps working, so an unmigrated callsite is still
+ * correct, and guessing at an expression's values would not be.
+ */
+
+import {transformProp} from '../../transform-prop.mjs';
+
+export const meta = {
+  title: 'Migrate nativePicker to presentation',
+  description:
+    'Renames `nativePicker` to `presentation` on DateInput, DateTimeInput, ' +
+    'and TimeInput, mapping touch→adaptive-native, always→native, and ' +
+    'never→adaptive-bottom-sheet (text-input for TimeInput). Dynamic ' +
+    'values are left for manual migration; the deprecated prop still works.',
+};
+
+const CORE_IMPORT_RE = /^@(astryxdesign|xds)\/core(?:\/|$)/;
+
+const COMPONENT_PROPS = new Map([
+  ['DateInput', new Set(['nativePicker'])],
+  ['DateTimeInput', new Set(['nativePicker'])],
+  ['TimeInput', new Set(['nativePicker'])],
+]);
+
+/** @param {string} component @param {string} value */
+function mapValue(component, value) {
+  switch (value) {
+    case 'touch':
+      return 'adaptive-native';
+    case 'always':
+      return 'native';
+    case 'never':
+      return component === 'TimeInput' ? 'text-input' : 'adaptive-bottom-sheet';
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Collect the string-literal leaves of a value expression without mutating
+ * anything. Returns false for any dynamic or non-string node.
+ * @param {any} node
+ * @param {any[]} leaves
+ * @returns {boolean}
+ */
+function collectStaticLeaves(node, leaves) {
+  if (!node) return false;
+  if (
+    node.type === 'TSAsExpression' ||
+    node.type === 'TSSatisfiesExpression' ||
+    node.type === 'TypeCastExpression' ||
+    node.type === 'ParenthesizedExpression'
+  ) {
+    return collectStaticLeaves(node.expression, leaves);
+  }
+  if (node.type === 'ConditionalExpression') {
+    return (
+      collectStaticLeaves(node.consequent, leaves) &&
+      collectStaticLeaves(node.alternate, leaves)
+    );
+  }
+  if (
+    (node.type !== 'StringLiteral' && node.type !== 'Literal') ||
+    typeof node.value !== 'string'
+  ) {
+    return false;
+  }
+  leaves.push(node);
+  return true;
+}
+
+/**
+ * Map every leaf, or none of them: a mixed static/dynamic conditional must
+ * stay byte-identical, never half-migrated.
+ * @param {any} node
+ * @param {string} component
+ */
+function mapStaticValue(node, component) {
+  /** @type {any[]} */
+  const leaves = [];
+  if (!collectStaticLeaves(node, leaves)) return false;
+  if (leaves.some(leaf => mapValue(component, leaf.value) === undefined)) {
+    return false;
+  }
+  for (const leaf of leaves) {
+    leaf.value = mapValue(component, leaf.value);
+    if (leaf.raw) leaf.raw = undefined;
+  }
+  return true;
+}
+
+/**
+ * @param {import('../../../../authoring/codemod/type').AstryxCodemodFile} file
+ * @param {import('../../../../authoring/codemod/type').CodemodTransformApi} api
+ * @returns {string | null | undefined}
+ */
+export default function transformer(file, api) {
+  if (!file.source.includes('nativePicker')) return undefined;
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  let hasChanges = false;
+
+  transformProp(
+    root,
+    j,
+    {
+      matchesImport: source => CORE_IMPORT_RE.test(source),
+      components: COMPONENT_PROPS,
+    },
+    (propPath, {component}) => {
+      const opening = propPath.parent?.node;
+      const attributes = opening?.attributes ?? [];
+      const hasPresentation = attributes.some(
+        (/** @type {any} */ attribute) =>
+          attribute.type === 'JSXAttribute' &&
+          attribute.name?.name === 'presentation',
+      );
+      const prop = propPath.node;
+      if (hasPresentation) {
+        // FR4: presentation wins; drop the deprecated prop.
+        opening.attributes = attributes.filter(
+          (/** @type {any} */ attribute) => attribute !== prop,
+        );
+        hasChanges = true;
+        return;
+      }
+      const value =
+        prop.value?.type === 'JSXExpressionContainer'
+          ? prop.value.expression
+          : prop.value;
+      if (!mapStaticValue(value, component)) return;
+      prop.name.name = 'presentation';
+      hasChanges = true;
+    },
+  );
+
+  if (!hasChanges) return undefined;
+  return root.toSource({quote: 'single'});
+}

package/assets/templates/blocks/components/DateInput/DateInputDateRange.tsx

@@ -41,7 +41,7 @@ export default function DateInputDateRange() {
         max={max}
         description={description}
         placeholder="Select a booking date"
-        nativePicker="never"
+        presentation="adaptive-bottom-sheet"
         value={value}
         onChange={setValue}
       />

package/assets/templates/blocks/components/TimeInput/TimeInputConstrained.tsx

@@ -17,6 +17,7 @@ export default function TimeInputConstrained() {
         max={'22:00' as never}
         description="Evening seating: 5 PM – 10 PM"
         placeholder="Select reservation time"
+        presentation="adaptive-bottom-sheet"
         value={evening as never}
         onChange={setEvening as never}
         hasClear

package/authoring/doctypes/_schema.d.mts

@@ -25,7 +25,7 @@ export namespace AuthoredDocGraphFields {
         internal: "internal";
     }>>;
 }
-/** Runtime schema for every existing and V1 semantic content block. */
+/** Runtime schema for the stable content-block union published in 0.6.x. */
 export const ReferenceContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"prose">;
     text: z.ZodString;
@@ -55,6 +55,74 @@ export const ReferenceContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"token-ref">;
     topic: z.ZodString;
     section: z.ZodString;
+}, z.core.$strict>], "type">;
+/** Runtime schema for graph-only blocks used by NamespaceDoc. */
+export const GraphContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"workflow">;
+    title: z.ZodOptional<z.ZodString>;
+    steps: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        references: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"collection">;
+    title: z.ZodOptional<z.ZodString>;
+    source: z.ZodObject<{
+        slot: z.ZodString;
+    }, z.core.$strict>;
+    presentation: z.ZodOptional<z.ZodEnum<{
+        list: "list";
+        cards: "cards";
+        compact: "compact";
+    }>>;
+    whenEmpty: z.ZodOptional<z.ZodEnum<{
+        show: "show";
+        omit: "omit";
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"reference">;
+    target: z.ZodString;
+    projection: z.ZodOptional<z.ZodObject<{
+        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    presentation: z.ZodOptional<z.ZodEnum<{
+        compact: "compact";
+        summary: "summary";
+        full: "full";
+    }>>;
+}, z.core.$strict>], "type">;
+/** Namespace content accepts both stable reference blocks and graph-only blocks. */
+export const NamespaceContentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"prose">;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"heading">;
+    level: z.ZodUnion<readonly [z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>, z.ZodLiteral<6>]>;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"code">;
+    lang: z.ZodString;
+    code: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"table">;
+    headers: z.ZodArray<z.ZodString>;
+    rows: z.ZodArray<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"list">;
+    style: z.ZodEnum<{
+        ordered: "ordered";
+        unordered: "unordered";
+        do: "do";
+        dont: "dont";
+    }>;
+    items: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"token-ref">;
+    topic: z.ZodString;
+    section: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"workflow">;
     title: z.ZodOptional<z.ZodString>;
@@ -235,41 +303,6 @@ export const GenericDocKindSchema: z.ZodObject<{
             type: z.ZodLiteral<"token-ref">;
             topic: z.ZodString;
             section: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"workflow">;
-            title: z.ZodOptional<z.ZodString>;
-            steps: z.ZodArray<z.ZodObject<{
-                title: z.ZodString;
-                description: z.ZodOptional<z.ZodString>;
-                references: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"collection">;
-            title: z.ZodOptional<z.ZodString>;
-            source: z.ZodObject<{
-                slot: z.ZodString;
-            }, z.core.$strict>;
-            presentation: z.ZodOptional<z.ZodEnum<{
-                list: "list";
-                cards: "cards";
-                compact: "compact";
-            }>>;
-            whenEmpty: z.ZodOptional<z.ZodEnum<{
-                show: "show";
-                omit: "omit";
-            }>>;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"reference">;
-            target: z.ZodString;
-            projection: z.ZodOptional<z.ZodObject<{
-                fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>>;
-            presentation: z.ZodOptional<z.ZodEnum<{
-                compact: "compact";
-                summary: "summary";
-                full: "full";
-            }>>;
         }, z.core.$strict>], "type">>;
         previewType: z.ZodOptional<z.ZodEnum<{
             swatch: "swatch";
@@ -351,41 +384,6 @@ export const SchemaDocKindSchema: z.ZodObject<{
         type: z.ZodLiteral<"token-ref">;
         topic: z.ZodString;
         section: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        type: z.ZodLiteral<"workflow">;
-        title: z.ZodOptional<z.ZodString>;
-        steps: z.ZodArray<z.ZodObject<{
-            title: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-            references: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>, z.ZodObject<{
-        type: z.ZodLiteral<"collection">;
-        title: z.ZodOptional<z.ZodString>;
-        source: z.ZodObject<{
-            slot: z.ZodString;
-        }, z.core.$strict>;
-        presentation: z.ZodOptional<z.ZodEnum<{
-            list: "list";
-            cards: "cards";
-            compact: "compact";
-        }>>;
-        whenEmpty: z.ZodOptional<z.ZodEnum<{
-            show: "show";
-            omit: "omit";
-        }>>;
-    }, z.core.$strict>, z.ZodObject<{
-        type: z.ZodLiteral<"reference">;
-        target: z.ZodString;
-        projection: z.ZodOptional<z.ZodObject<{
-            fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>;
-        presentation: z.ZodOptional<z.ZodEnum<{
-            compact: "compact";
-            summary: "summary";
-            full: "full";
-        }>>;
     }, z.core.$strict>], "type">>>;
     placement: z.ZodOptional<z.ZodObject<{
         parent: z.ZodString;
@@ -470,41 +468,6 @@ export const CommandDocKindSchema: z.ZodObject<{
         type: z.ZodLiteral<"token-ref">;
         topic: z.ZodString;
         section: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        type: z.ZodLiteral<"workflow">;
-        title: z.ZodOptional<z.ZodString>;
-        steps: z.ZodArray<z.ZodObject<{
-            title: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-            references: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>, z.ZodObject<{
-        type: z.ZodLiteral<"collection">;
-        title: z.ZodOptional<z.ZodString>;
-        source: z.ZodObject<{
-            slot: z.ZodString;
-        }, z.core.$strict>;
-        presentation: z.ZodOptional<z.ZodEnum<{
-            list: "list";
-            cards: "cards";
-            compact: "compact";
-        }>>;
-        whenEmpty: z.ZodOptional<z.ZodEnum<{
-            show: "show";
-            omit: "omit";
-        }>>;
-    }, z.core.$strict>, z.ZodObject<{
-        type: z.ZodLiteral<"reference">;
-        target: z.ZodString;
-        projection: z.ZodOptional<z.ZodObject<{
-            fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>;
-        presentation: z.ZodOptional<z.ZodEnum<{
-            compact: "compact";
-            summary: "summary";
-            full: "full";
-        }>>;
     }, z.core.$strict>], "type">>>;
     placement: z.ZodOptional<z.ZodObject<{
         parent: z.ZodString;
@@ -877,41 +840,6 @@ export const LegacyDocSchema: z.ZodUnion<readonly [z.ZodObject<{
             type: z.ZodLiteral<"token-ref">;
             topic: z.ZodString;
             section: z.ZodString;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"workflow">;
-            title: z.ZodOptional<z.ZodString>;
-            steps: z.ZodArray<z.ZodObject<{
-                title: z.ZodString;
-                description: z.ZodOptional<z.ZodString>;
-                references: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"collection">;
-            title: z.ZodOptional<z.ZodString>;
-            source: z.ZodObject<{
-                slot: z.ZodString;
-            }, z.core.$strict>;
-            presentation: z.ZodOptional<z.ZodEnum<{
-                list: "list";
-                cards: "cards";
-                compact: "compact";
-            }>>;
-            whenEmpty: z.ZodOptional<z.ZodEnum<{
-                show: "show";
-                omit: "omit";
-            }>>;
-        }, z.core.$strict>, z.ZodObject<{
-            type: z.ZodLiteral<"reference">;
-            target: z.ZodString;
-            projection: z.ZodOptional<z.ZodObject<{
-                fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>>;
-            presentation: z.ZodOptional<z.ZodEnum<{
-                compact: "compact";
-                summary: "summary";
-                full: "full";
-            }>>;
         }, z.core.$strict>], "type">>;
         previewType: z.ZodOptional<z.ZodEnum<{
             swatch: "swatch";
@@ -933,6 +861,7 @@ export type AuthoredDocGraphFieldsType = import("./base/type.js").AuthoredDocGra
 export type AuthoredDocKind = import("./base/type.js").AuthoredDocKind;
 export type NamespaceDoc = import("./namespace/type.js").NamespaceDoc;
 export type ReferenceContentBlock = import("./reference/type.js").ReferenceContentBlock;
+export type GraphContentBlock = import("./reference/type.js").GraphContentBlock;
 export type ReferenceDoc = import("./reference/type.js").ReferenceDoc;
 export type SingleComponentDoc = import("./component/type.js").SingleComponentDoc;
 export type ComponentPropDoc = import("./base/type.js").ComponentPropDoc;
@@ -944,6 +873,7 @@ export type EnumDoc = import("./enum/type.js").EnumDoc;
 export type _AuthoredDocKindDriftLock = import("../_shared/contract.js").Expect<import("../_shared/contract.js").Equal<z.infer<typeof AuthoredDocKindSchema>, AuthoredDocKind>>;
 export type _AuthoredDocGraphDriftLock = import("../_shared/contract.js").Expect<import("../_shared/contract.js").MutuallyAssignable<z.infer<typeof _AuthoredDocGraphSchema>, AuthoredDocGraphFieldsType>>;
 export type _ReferenceContentBlockDriftLock = import("../_shared/contract.js").Expect<import("../_shared/contract.js").Equal<z.infer<typeof ReferenceContentBlockSchema>, ReferenceContentBlock>>;
+export type _GraphContentBlockDriftLock = import("../_shared/contract.js").Expect<import("../_shared/contract.js").Equal<z.infer<typeof GraphContentBlockSchema>, GraphContentBlock>>;
 /**
  * A stamped component doc as it loads. The loader accepts what the unstamped
  * format always accepted, so stamping an existing doc never breaks it: