@raystack/chronicle 0.5.4 → 0.6.0

package/src/cli/commands/init.test.ts

@@ -0,0 +1,77 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { parse } from 'yaml'
+import { chronicleConfigSchema } from '@/types'
+import { runInit } from './init'
+
+let tmp: string
+
+beforeEach(() => {
+  tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'chronicle-init-'))
+})
+
+afterEach(() => {
+  fs.rmSync(tmp, { recursive: true, force: true })
+})
+
+describe('runInit', () => {
+  test('scaffolds content/<dir>/, chronicle.yaml and .gitignore from empty', () => {
+    const events = runInit(tmp)
+    const created = events.filter(e => e.type === 'created').map(e => e.path)
+    expect(created).toContain(path.join(tmp, 'content/docs'))
+    expect(created).toContain(path.join(tmp, 'chronicle.yaml'))
+    expect(created).toContain(path.join(tmp, 'content/docs/index.mdx'))
+    expect(created).toContain(path.join(tmp, '.gitignore'))
+  })
+
+  test('emitted chronicle.yaml passes the schema', () => {
+    runInit(tmp)
+    const raw = fs.readFileSync(path.join(tmp, 'chronicle.yaml'), 'utf-8')
+    const parsed = chronicleConfigSchema.parse(parse(raw))
+    expect(parsed.site.title).toBe('My Documentation')
+    expect(parsed.content).toEqual([{ dir: 'docs', label: 'Docs' }])
+  })
+
+  test('skips chronicle.yaml when it already exists', () => {
+    fs.writeFileSync(path.join(tmp, 'chronicle.yaml'), 'site:\n  title: Mine\n')
+    const events = runInit(tmp)
+    const yamlEvent = events.find(e => e.path.endsWith('chronicle.yaml'))
+    expect(yamlEvent?.type).toBe('skipped')
+    const raw = fs.readFileSync(path.join(tmp, 'chronicle.yaml'), 'utf-8')
+    expect(raw).toBe('site:\n  title: Mine\n')
+  })
+
+  test('does not overwrite an index.mdx already present in content/docs', () => {
+    fs.mkdirSync(path.join(tmp, 'content/docs'), { recursive: true })
+    const existing = '---\ntitle: Keep\n---\n# Keep\n'
+    fs.writeFileSync(path.join(tmp, 'content/docs/index.mdx'), existing)
+    runInit(tmp)
+    const contents = fs.readFileSync(
+      path.join(tmp, 'content/docs/index.mdx'),
+      'utf-8',
+    )
+    expect(contents).toBe(existing)
+  })
+
+  test('appends missing entries to an existing .gitignore', () => {
+    fs.writeFileSync(path.join(tmp, '.gitignore'), 'node_modules\n')
+    const events = runInit(tmp)
+    const gitignoreEvent = events.find(e => e.path.endsWith('.gitignore'))
+    expect(gitignoreEvent?.type).toBe('updated')
+    const contents = fs.readFileSync(path.join(tmp, '.gitignore'), 'utf-8')
+    expect(contents).toContain('dist')
+    expect(contents).toContain('.output')
+  })
+
+  test('matches .gitignore entries by line, not substring', () => {
+    fs.writeFileSync(path.join(tmp, '.gitignore'), 'distribution\n')
+    runInit(tmp)
+    const contents = fs.readFileSync(path.join(tmp, '.gitignore'), 'utf-8')
+    // `distribution` must not satisfy the `dist` requirement
+    const lines = contents.split(/\r?\n/).map(l => l.trim()).filter(Boolean)
+    expect(lines).toContain('distribution')
+    expect(lines).toContain('dist')
+  })
+})

package/src/cli/commands/init.ts

@@ -5,9 +5,12 @@ import { Command } from 'commander';
 import { stringify } from 'yaml';
 import type { ChronicleConfig } from '@/types';
 
-const defaultConfig: ChronicleConfig = {
-  title: 'My Documentation',
-  description: 'Documentation powered by Chronicle',
+export const defaultInitConfig: ChronicleConfig = {
+  site: {
+    title: 'My Documentation',
+    description: 'Documentation powered by Chronicle',
+  },
+  content: [{ dir: 'docs', label: 'Docs' }],
   theme: { name: 'default' },
   search: { enabled: true, placeholder: 'Search documentation...' }
 };
@@ -23,47 +26,77 @@ order: 1
 This is your documentation home page.
 `;
 
-export const initCommand = new Command('init')
-  .description('Initialize a new Chronicle project')
-  .option('-c, --content <path>', 'Content directory name', 'content')
-  .action(options => {
-    const projectDir = process.cwd();
-    const contentDir = path.join(projectDir, options.content);
+const GITIGNORE_ENTRIES = ['node_modules', 'dist', '.output'];
 
-    if (!fs.existsSync(contentDir)) {
-      fs.mkdirSync(contentDir, { recursive: true });
-      console.log(chalk.green('\u2713'), 'Created', contentDir);
-    }
+export interface InitEvent {
+  type: 'created' | 'skipped' | 'updated';
+  path: string;
+  detail?: string;
+}
 
-    const configPath = path.join(projectDir, 'chronicle.yaml');
-    if (!fs.existsSync(configPath)) {
-      fs.writeFileSync(configPath, stringify(defaultConfig));
-      console.log(chalk.green('\u2713'), 'Created', configPath);
-    } else {
-      console.log(chalk.yellow('\u26a0'), configPath, 'already exists');
-    }
+export function runInit(projectDir: string): InitEvent[] {
+  const events: InitEvent[] = [];
+  const defaultDir = defaultInitConfig.content[0].dir;
+  const contentDir = path.join(projectDir, 'content', defaultDir);
 
-    const contentFiles = fs.readdirSync(contentDir);
-    if (contentFiles.length === 0) {
-      const indexPath = path.join(contentDir, 'index.mdx');
-      fs.writeFileSync(indexPath, sampleMdx);
-      console.log(chalk.green('\u2713'), 'Created', indexPath);
-    }
+  if (!fs.existsSync(contentDir)) {
+    fs.mkdirSync(contentDir, { recursive: true });
+    events.push({ type: 'created', path: contentDir });
+  }
+
+  const configPath = path.join(projectDir, 'chronicle.yaml');
+  if (!fs.existsSync(configPath)) {
+    fs.writeFileSync(configPath, stringify(defaultInitConfig));
+    events.push({ type: 'created', path: configPath });
+  } else {
+    events.push({ type: 'skipped', path: configPath, detail: 'already exists' });
+  }
 
-    const gitignorePath = path.join(projectDir, '.gitignore');
-    const gitignoreEntries = ['node_modules', 'dist', '.output'];
-    if (fs.existsSync(gitignorePath)) {
-      const existing = fs.readFileSync(gitignorePath, 'utf-8');
-      const missing = gitignoreEntries.filter(e => !existing.includes(e));
-      if (missing.length > 0) {
-        fs.appendFileSync(gitignorePath, `\n${missing.join('\n')}\n`);
-        console.log(chalk.green('\u2713'), 'Added', missing.join(', '), 'to .gitignore');
-      }
-    } else {
-      fs.writeFileSync(gitignorePath, `${gitignoreEntries.join('\n')}\n`);
-      console.log(chalk.green('\u2713'), 'Created .gitignore');
+  const contentFiles = fs.readdirSync(contentDir);
+  if (contentFiles.length === 0) {
+    const indexPath = path.join(contentDir, 'index.mdx');
+    fs.writeFileSync(indexPath, sampleMdx);
+    events.push({ type: 'created', path: indexPath });
+  }
+
+  const gitignorePath = path.join(projectDir, '.gitignore');
+  if (fs.existsSync(gitignorePath)) {
+    const existing = fs.readFileSync(gitignorePath, 'utf-8');
+    const existingLines = new Set(
+      existing.split(/\r?\n/).map(l => l.trim()).filter(Boolean),
+    );
+    const missing = GITIGNORE_ENTRIES.filter(e => !existingLines.has(e));
+    if (missing.length > 0) {
+      fs.appendFileSync(gitignorePath, `\n${missing.join('\n')}\n`);
+      events.push({ type: 'updated', path: gitignorePath, detail: missing.join(', ') });
     }
+  } else {
+    fs.writeFileSync(gitignorePath, `${GITIGNORE_ENTRIES.join('\n')}\n`);
+    events.push({ type: 'created', path: gitignorePath });
+  }
+
+  return events;
+}
+
+function formatEvent(e: InitEvent): string {
+  if (e.type === 'skipped') {
+    return `${chalk.yellow('⚠')} ${e.path}${e.detail ? ` ${e.detail}` : ''}`;
+  }
+  if (e.type === 'updated') {
+    return `${chalk.green('✓')} Updated ${e.path}${e.detail ? ` (+${e.detail})` : ''}`;
+  }
+  return `${chalk.green('✓')} Created ${e.path}`;
+}
 
-    console.log(chalk.green('\n\u2713 Chronicle initialized!'));
-    console.log('\nRun', chalk.cyan('chronicle dev'), 'to start development server');
+export const initCommand = new Command('init')
+  .description('Initialize a new Chronicle project')
+  .action(() => {
+    const events = runInit(process.cwd());
+    for (const e of events) console.log(formatEvent(e));
+    console.log(chalk.green('\n✓ Chronicle initialized!'));
+    console.log(
+      '\nRun',
+      chalk.cyan('chronicle dev'),
+      'to start development server',
+    );
   });

package/src/cli/commands/serve.ts

@@ -7,7 +7,6 @@ import { linkContent } from '@/cli/utils/scaffold';
 export const serveCommand = new Command('serve')
   .description('Build and start production server')
   .option('-p, --port <port>', 'Port number', '3000')
-  .option('--content <path>', 'Content directory')
   .option('--config <path>', 'Path to chronicle.yaml')
   .option('--host <host>', 'Host address', 'localhost')
   .option(
@@ -15,30 +14,28 @@ export const serveCommand = new Command('serve')
     'Deploy preset (vercel, cloudflare, node-server)'
   )
   .action(async options => {
-    const { contentDir, configPath, preset } = await loadCLIConfig(options.config, {
-      content: options.content,
+    const { config, projectRoot, configPath, preset } = await loadCLIConfig(options.config, {
       preset: options.preset,
     });
     const port = parseInt(options.port, 10);
-    await linkContent(contentDir);
+    await linkContent(projectRoot, config);
 
     const { build, preview } = await import('vite');
     const { createViteConfig } = await import('@/server/vite-config');
 
-    const config = await createViteConfig({
+    const viteConfig = await createViteConfig({
       packageRoot: PACKAGE_ROOT,
-      projectRoot: process.cwd(),
-      contentDir,
+      projectRoot,
       configPath,
       preset
     });
 
     console.log(chalk.cyan('Building for production...'));
-    await build(config);
+    await build(viteConfig);
 
     console.log(chalk.cyan('Starting production server...'));
     const server = await preview({
-      ...config,
+      ...viteConfig,
       preview: { port, host: options.host }
     });
 

package/src/cli/commands/start.ts

@@ -7,21 +7,21 @@ import { linkContent } from '@/cli/utils/scaffold';
 export const startCommand = new Command('start')
   .description('Start production server')
   .option('-p, --port <port>', 'Port number', '3000')
-  .option('--content <path>', 'Content directory')
+  .option('--config <path>', 'Path to chronicle.yaml')
   .option('--host <host>', 'Host address', 'localhost')
   .action(async options => {
-    const { contentDir, configPath } = await loadCLIConfig(undefined, { content: options.content });
+    const { config, projectRoot, configPath } = await loadCLIConfig(options.config);
     const port = parseInt(options.port, 10);
-    await linkContent(contentDir);
+    await linkContent(projectRoot, config);
 
     console.log(chalk.cyan('Starting production server...'));
 
     const { preview } = await import('vite');
     const { createViteConfig } = await import('@/server/vite-config');
 
-    const config = await createViteConfig({ packageRoot: PACKAGE_ROOT, projectRoot: process.cwd(), contentDir, configPath });
+    const viteConfig = await createViteConfig({ packageRoot: PACKAGE_ROOT, projectRoot, configPath });
     const server = await preview({
-      ...config,
+      ...viteConfig,
       preview: { port, host: options.host }
     });
 

package/src/cli/utils/config.ts

@@ -7,7 +7,7 @@ import { chronicleConfigSchema, type ChronicleConfig } from '@/types';
 export interface CLIConfig {
   config: ChronicleConfig;
   configPath: string;
-  contentDir: string;
+  projectRoot: string;
   preset?: string;
 }
 
@@ -36,8 +36,8 @@ function validateConfig(raw: string, configPath: string): ChronicleConfig {
   if (!result.success) {
     console.log(chalk.red(`Error: Invalid chronicle.yaml at '${configPath}'`));
     for (const issue of result.error.issues) {
-      const path = issue.path.join('.');
-      console.log(chalk.gray(`  ${path ? `${path}: ` : ''}${issue.message}`));
+      const issuePath = issue.path.join('.');
+      console.log(chalk.gray(`  ${issuePath ? `${issuePath}: ` : ''}${issue.message}`));
     }
     process.exit(1);
   }
@@ -45,27 +45,21 @@ function validateConfig(raw: string, configPath: string): ChronicleConfig {
   return result.data;
 }
 
-export function resolveContentDir(config: ChronicleConfig, configPath: string, contentFlag?: string): string {
-  if (contentFlag) return path.resolve(contentFlag);
-  if (config.content) return path.resolve(path.dirname(configPath), config.content);
-  return path.resolve('content');
-}
-
 export function resolvePreset(config: ChronicleConfig, presetFlag?: string): string | undefined {
   return presetFlag ?? config.preset;
 }
 
 export async function loadCLIConfig(
   configPath?: string,
-  options?: { content?: string; preset?: string }
+  options?: { preset?: string }
 ): Promise<CLIConfig> {
   const resolvedConfigPath = resolveConfigPath(configPath)
     ?? path.join(process.cwd(), 'chronicle.yaml');
 
   const raw = await readConfig(resolvedConfigPath);
   const config = validateConfig(raw, resolvedConfigPath);
-  const contentDir = resolveContentDir(config, resolvedConfigPath, options?.content);
+  const projectRoot = path.dirname(resolvedConfigPath);
   const preset = resolvePreset(config, options?.preset);
 
-  return { config, configPath: resolvedConfigPath, contentDir, preset };
+  return { config, configPath: resolvedConfigPath, projectRoot, preset };
 }

package/src/cli/utils/scaffold.test.ts

@@ -0,0 +1,179 @@
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { chronicleConfigSchema } from '@/types'
+import { buildContentMirror } from './scaffold'
+
+let tmp: string
+let projectRoot: string
+let mirrorRoot: string
+
+async function seedContent(relPath: string, file = 'index.mdx'): Promise<void> {
+  const dir = path.join(projectRoot, relPath)
+  await fs.mkdir(dir, { recursive: true })
+  await fs.writeFile(path.join(dir, file), `---\ntitle: ${relPath}\n---\n`)
+}
+
+async function isDir(p: string): Promise<boolean> {
+  return (await fs.lstat(p)).isDirectory()
+}
+
+async function fileSymlinkTarget(p: string): Promise<string> {
+  const st = await fs.lstat(p)
+  expect(st.isSymbolicLink()).toBe(true)
+  return fs.readlink(p)
+}
+
+beforeEach(async () => {
+  tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'chronicle-scaffold-'))
+  projectRoot = path.join(tmp, 'project')
+  mirrorRoot = path.join(tmp, 'mirror')
+  await fs.mkdir(projectRoot, { recursive: true })
+})
+
+afterEach(async () => {
+  await fs.rm(tmp, { recursive: true, force: true })
+})
+
+describe('buildContentMirror', () => {
+  test('single-content latest: mirrors as real dirs with per-file symlinks', async () => {
+    await seedContent('content/docs', 'index.mdx')
+    await seedContent('content/docs', 'guide.mdx')
+    const config = chronicleConfigSchema.parse({
+      site: { title: 'x' },
+      content: [{ dir: 'docs', label: 'Docs' }],
+    })
+
+    await buildContentMirror(mirrorRoot, projectRoot, config)
+
+    expect(await isDir(path.join(mirrorRoot, 'docs'))).toBe(true)
+    expect(await fileSymlinkTarget(path.join(mirrorRoot, 'docs/index.mdx'))).toBe(
+      path.join(projectRoot, 'content/docs/index.mdx'),
+    )
+    expect(await fileSymlinkTarget(path.join(mirrorRoot, 'docs/guide.mdx'))).toBe(
+      path.join(projectRoot, 'content/docs/guide.mdx'),
+    )
+  })
+
+  test('preserves nested subdirectories via recursive mirror', async () => {
+    await seedContent('content/docs/guides', 'install.mdx')
+    const config = chronicleConfigSchema.parse({
+      site: { title: 'x' },
+      content: [{ dir: 'docs', label: 'Docs' }],
+    })
+
+    await buildContentMirror(mirrorRoot, projectRoot, config)
+
+    const nested = path.join(mirrorRoot, 'docs/guides/install.mdx')
+    expect(await fileSymlinkTarget(nested)).toBe(
+      path.join(projectRoot, 'content/docs/guides/install.mdx'),
+    )
+    expect(await isDir(path.join(mirrorRoot, 'docs/guides'))).toBe(true)
+  })
+
+  test('multi-content latest produces one real dir per content entry', async () => {
+    await seedContent('content/docs', 'index.mdx')
+    await seedContent('content/dev', 'index.mdx')
+    const config = chronicleConfigSchema.parse({
+      site: { title: 'x' },
+      content: [
+        { dir: 'docs', label: 'Docs' },
+        { dir: 'dev', label: 'Dev' },
+      ],
+    })
+
+    await buildContentMirror(mirrorRoot, projectRoot, config)
+
+    expect(await isDir(path.join(mirrorRoot, 'docs'))).toBe(true)
+    expect(await isDir(path.join(mirrorRoot, 'dev'))).toBe(true)
+    expect(
+      await fileSymlinkTarget(path.join(mirrorRoot, 'dev/index.mdx')),
+    ).toBe(path.join(projectRoot, 'content/dev/index.mdx'))
+  })
+
+  test('versioned mirror nests version dir then content dir', async () => {
+    await seedContent('content/docs', 'index.mdx')
+    await seedContent('versions/v1/docs', 'index.mdx')
+    await seedContent('versions/v1/dev', 'api.mdx')
+    const config = chronicleConfigSchema.parse({
+      site: { title: 'x' },
+      content: [{ dir: 'docs', label: 'Docs' }],
+      latest: { label: '2.0' },
+      versions: [
+        {
+          dir: 'v1',
+          label: '1.0',
+          content: [
+            { dir: 'docs', label: 'Docs' },
+            { dir: 'dev', label: 'Dev' },
+          ],
+        },
+      ],
+    })
+
+    await buildContentMirror(mirrorRoot, projectRoot, config)
+
+    expect(await isDir(path.join(mirrorRoot, 'v1/docs'))).toBe(true)
+    expect(
+      await fileSymlinkTarget(path.join(mirrorRoot, 'v1/docs/index.mdx')),
+    ).toBe(path.join(projectRoot, 'versions/v1/docs/index.mdx'))
+    expect(
+      await fileSymlinkTarget(path.join(mirrorRoot, 'v1/dev/api.mdx')),
+    ).toBe(path.join(projectRoot, 'versions/v1/dev/api.mdx'))
+  })
+
+  test('is idempotent — re-running yields the same tree', async () => {
+    await seedContent('content/docs', 'index.mdx')
+    const config = chronicleConfigSchema.parse({
+      site: { title: 'x' },
+      content: [{ dir: 'docs', label: 'Docs' }],
+    })
+
+    await buildContentMirror(mirrorRoot, projectRoot, config)
+    await buildContentMirror(mirrorRoot, projectRoot, config)
+
+    expect(
+      await fileSymlinkTarget(path.join(mirrorRoot, 'docs/index.mdx')),
+    ).toBe(path.join(projectRoot, 'content/docs/index.mdx'))
+  })
+
+  test('wipes stale entries when config shrinks', async () => {
+    await seedContent('content/docs', 'index.mdx')
+    await seedContent('content/dev', 'index.mdx')
+    const before = chronicleConfigSchema.parse({
+      site: { title: 'x' },
+      content: [
+        { dir: 'docs', label: 'Docs' },
+        { dir: 'dev', label: 'Dev' },
+      ],
+    })
+
+    await buildContentMirror(mirrorRoot, projectRoot, before)
+    expect((await fs.readdir(mirrorRoot)).sort()).toEqual(['dev', 'docs'])
+
+    const after = chronicleConfigSchema.parse({
+      site: { title: 'x' },
+      content: [{ dir: 'docs', label: 'Docs' }],
+    })
+    await buildContentMirror(mirrorRoot, projectRoot, after)
+
+    expect(await fs.readdir(mirrorRoot)).toEqual(['docs'])
+  })
+
+  test('replaces a legacy single-symlink mirror', async () => {
+    await seedContent('content/docs', 'index.mdx')
+    await fs.symlink(path.join(projectRoot, 'content/docs'), mirrorRoot)
+
+    const config = chronicleConfigSchema.parse({
+      site: { title: 'x' },
+      content: [{ dir: 'docs', label: 'Docs' }],
+    })
+    await buildContentMirror(mirrorRoot, projectRoot, config)
+
+    expect(await isDir(mirrorRoot)).toBe(true)
+    expect(
+      await fileSymlinkTarget(path.join(mirrorRoot, 'docs/index.mdx')),
+    ).toBe(path.join(projectRoot, 'content/docs/index.mdx'))
+  })
+})

package/src/cli/utils/scaffold.ts

@@ -1,18 +1,79 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import type { ChronicleConfig } from '@/types';
+import { getLatestContentRoots, getVersionContentRoots } from '@/lib/config';
 import { PACKAGE_ROOT } from './resolve';
 
-export async function linkContent(contentDir: string): Promise<void> {
-  const linkPath = path.join(PACKAGE_ROOT, '.content');
-  const target = path.resolve(contentDir);
+export async function buildContentMirror(
+  mirrorRoot: string,
+  projectRoot: string,
+  config: ChronicleConfig,
+): Promise<void> {
+  await removeMirror(mirrorRoot);
+  await fs.mkdir(mirrorRoot, { recursive: true });
 
+  for (const root of getLatestContentRoots(config)) {
+    const source = path.resolve(projectRoot, root.fsPath);
+    const dest = path.join(mirrorRoot, root.contentDir);
+    await mirrorTree(source, dest);
+  }
+
+  for (const version of config.versions ?? []) {
+    const versionMirror = path.join(mirrorRoot, version.dir);
+    await fs.mkdir(versionMirror, { recursive: true });
+
+    for (const root of getVersionContentRoots(config, version.dir)) {
+      const source = path.resolve(projectRoot, root.fsPath);
+      const dest = path.join(versionMirror, root.contentDir);
+      await mirrorTree(source, dest);
+    }
+  }
+}
+
+export function linkContent(
+  projectRoot: string,
+  config: ChronicleConfig,
+): Promise<void> {
+  return buildContentMirror(
+    path.join(PACKAGE_ROOT, '.content'),
+    projectRoot,
+    config,
+  );
+}
+
+async function mirrorTree(source: string, dest: string): Promise<void> {
+  let entries: import('node:fs').Dirent[];
   try {
-    const existing = await fs.readlink(linkPath);
-    if (existing === target) return;
-    await fs.unlink(linkPath);
-  } catch {
-    // link doesn't exist
+    entries = await fs.readdir(source, { withFileTypes: true });
+  } catch (error) {
+    const err = error as NodeJS.ErrnoException;
+    if (err.code === 'ENOENT') {
+      throw new Error(`Content directory not found: ${source}`);
+    }
+    throw error;
+  }
+  await fs.mkdir(dest, { recursive: true });
+  for (const entry of entries) {
+    const sourcePath = path.join(source, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await mirrorTree(sourcePath, destPath);
+    } else if (entry.isFile() || entry.isSymbolicLink()) {
+      await fs.symlink(sourcePath, destPath);
+    }
   }
+}
 
-  await fs.symlink(target, linkPath);
+async function removeMirror(mirrorRoot: string): Promise<void> {
+  try {
+    const stat = await fs.lstat(mirrorRoot);
+    if (stat.isSymbolicLink() || stat.isFile()) {
+      await fs.unlink(mirrorRoot);
+    } else if (stat.isDirectory()) {
+      await fs.rm(mirrorRoot, { recursive: true, force: true });
+    }
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return;
+    throw error;
+  }
 }

package/src/components/api/field-row.tsx

@@ -30,7 +30,7 @@ export function FieldRow({ field, location, editable, value, onChange }: FieldRo
     const objValue = (value ?? {}) as Record<string, unknown>
     return (
       <div className={styles.row}>
-        <Accordion collapsible className={styles.accordion}>
+        <Accordion className={styles.accordion}>
           <Accordion.Item value={field.name}>
             <Accordion.Trigger className={styles.trigger}>{label}</Accordion.Trigger>
             <Accordion.Content>

package/src/components/api/field-section.tsx

@@ -57,8 +57,8 @@ export function FieldSection({
         <div className={styles.separator} />
         <Tabs defaultValue="fields" className={styles.tabs}>
           <Tabs.List>
-            <Tabs.Trigger value="fields">Fields</Tabs.Trigger>
-            <Tabs.Trigger value="json">JSON</Tabs.Trigger>
+            <Tabs.Tab value="fields">Fields</Tabs.Tab>
+            <Tabs.Tab value="json">JSON</Tabs.Tab>
           </Tabs.List>
           <Tabs.Content value="fields">
             {fieldsContent}

package/src/components/mdx/index.tsx

@@ -20,7 +20,7 @@ function MdxTabs(props: ComponentProps<typeof Tabs>) {
   return <ClientOnly><Tabs {...props} /></ClientOnly>
 }
 MdxTabs.List = Tabs.List
-MdxTabs.Trigger = Tabs.Trigger
+MdxTabs.Tab = Tabs.Tab
 MdxTabs.Content = Tabs.Content
 
 export const mdxComponents: MDXComponents = {