@407dev/cms-astro 0.1.0

package/src/toolbar/icon.ts

@@ -0,0 +1,5 @@
+export const CMS_TOOLBAR_ICON = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <path d="M4 4h16c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6c0-1.1.9-2 2-2z"/>
+  <path d="M4 10h16"/>
+  <path d="M10 4v16"/>
+</svg>`;

package/src/toolbar/widgets.test.ts

@@ -0,0 +1,153 @@
+// @vitest-environment jsdom
+import { describe, expect, it, vi } from 'vitest';
+import {
+  extractImageSummary,
+  extractRichTextSummary,
+  isLightweightType,
+  resolveToolbarWidget,
+} from './widgets';
+
+describe('Toolbar widgets and resolution', () => {
+  describe('isLightweightType', () => {
+    it('returns true for text, number, toggle, select', () => {
+      expect(isLightweightType('text')).toBe(true);
+      expect(isLightweightType('TEXT')).toBe(true);
+      expect(isLightweightType('number')).toBe(true);
+      expect(isLightweightType('toggle')).toBe(true);
+      expect(isLightweightType('select')).toBe(true);
+    });
+
+    it('returns false for complex and unknown types', () => {
+      expect(isLightweightType('richtext')).toBe(false);
+      expect(isLightweightType('image')).toBe(false);
+      expect(isLightweightType('media.video')).toBe(false);
+      expect(isLightweightType('geo.location')).toBe(false);
+      expect(isLightweightType(null)).toBe(false);
+      expect(isLightweightType(undefined)).toBe(false);
+    });
+  });
+
+  describe('extractRichTextSummary', () => {
+    it('summarizes plain text string', () => {
+      expect(extractRichTextSummary('Hello world')).toBe('Hello world');
+      expect(extractRichTextSummary('<p>HTML text</p>')).toBe('HTML text');
+      expect(extractRichTextSummary('')).toBe('(empty)');
+    });
+
+    it('summarizes ProseMirror doc object with first text run and node count', () => {
+      const doc = {
+        type: 'doc',
+        content: [
+          {
+            type: 'paragraph',
+            content: [{ type: 'text', text: 'Welcome to our site' }],
+          },
+          {
+            type: 'paragraph',
+            content: [{ type: 'text', text: 'Second paragraph' }],
+          },
+        ],
+      };
+      const summary = extractRichTextSummary(doc);
+      expect(summary).toContain('Welcome to our site');
+      expect(summary).toContain('nodes');
+    });
+  });
+
+  describe('extractImageSummary', () => {
+    it('summarizes URL string', () => {
+      expect(extractImageSummary('https://cdn.example.com/assets/hero.png')).toBe('hero.png');
+      expect(extractImageSummary('')).toBe('(no image)');
+    });
+
+    it('summarizes image object with dimensions and alt', () => {
+      const img = {
+        url: 'https://cdn.example.com/images/banner.jpg',
+        width: 1200,
+        height: 630,
+        alt: 'Header banner',
+      };
+      const summary = extractImageSummary(img);
+      expect(summary).toContain('banner.jpg');
+      expect(summary).toContain('1200×630');
+      expect(summary).toContain('Header banner');
+    });
+  });
+
+  describe('resolveToolbarWidget', () => {
+    const baseCtx = {
+      key: 'test.field',
+      siteId: 'site-123',
+      routePath: '/about',
+      editorOrigin: 'http://localhost:5173',
+      onSave: vi.fn().mockResolvedValue({ ok: true }),
+    };
+
+    it('resolves text widget to text input form', () => {
+      const renderer = resolveToolbarWidget('text');
+      const el = renderer({ ...baseCtx, typeId: 'text', value: 'Hello' });
+      const input = el.querySelector('input[type="text"]') as HTMLInputElement;
+      expect(input).not.toBeNull();
+      expect(input.value).toBe('Hello');
+    });
+
+    it('resolves number widget to number input form', () => {
+      const renderer = resolveToolbarWidget('number');
+      const el = renderer({ ...baseCtx, typeId: 'number', value: 42 });
+      const input = el.querySelector('input[type="number"]') as HTMLInputElement;
+      expect(input).not.toBeNull();
+      expect(input.value).toBe('42');
+    });
+
+    it('resolves toggle widget to checkbox', () => {
+      const renderer = resolveToolbarWidget('toggle');
+      const el = renderer({ ...baseCtx, typeId: 'toggle', value: true });
+      const input = el.querySelector('input[type="checkbox"]') as HTMLInputElement;
+      expect(input).not.toBeNull();
+      expect(input.checked).toBe(true);
+    });
+
+    it('resolves select widget to select element with options', () => {
+      const renderer = resolveToolbarWidget('select');
+      const el = renderer({
+        ...baseCtx,
+        typeId: 'select',
+        value: 'opt2',
+        constraints: { options: ['opt1', 'opt2', 'opt3'] },
+      });
+      const select = el.querySelector('select') as HTMLSelectElement;
+      expect(select).not.toBeNull();
+      expect(select.value).toBe('opt2');
+    });
+
+    it('resolves richtext, image, and unknown types to summary with Open in Editor link', () => {
+      for (const typeId of ['richtext', 'image', 'custom.field', 'unknown']) {
+        const renderer = resolveToolbarWidget(typeId);
+        const el = renderer({ ...baseCtx, typeId, value: 'sample' });
+
+        // Must NOT render an editable input or textarea
+        expect(el.querySelector('input')).toBeNull();
+        expect(el.querySelector('textarea')).toBeNull();
+        expect(el.querySelector('select')).toBeNull();
+
+        // Must render Open in Editor deep link
+        const link = el.querySelector('a.cms-widget-editor-link') as HTMLAnchorElement;
+        expect(link).not.toBeNull();
+        expect(link.textContent).toContain('Open in Editor');
+        expect(link.href).toBe(
+          'http://localhost:5173/sites/site-123/editor?path=%2Fabout&field=test.field',
+        );
+      }
+    });
+
+    it('falls back to default editor origin when editorOrigin is omitted', () => {
+      const renderer = resolveToolbarWidget('richtext');
+      const el = renderer({ ...baseCtx, editorOrigin: '', typeId: 'richtext', value: 'sample' });
+      const link = el.querySelector('a.cms-widget-editor-link') as HTMLAnchorElement;
+      expect(link).not.toBeNull();
+      expect(link.href).toBe(
+        'https://web.localhost/sites/site-123/editor?path=%2Fabout&field=test.field',
+      );
+    });
+  });
+});

package/src/toolbar/widgets.ts

@@ -0,0 +1,365 @@
+import { DEFAULT_EDITOR_ORIGINS } from '../preview/origins';
+
+export const LIGHTWEIGHT_TYPE_IDS = ['text', 'number', 'toggle', 'select'] as const;
+
+export type LightweightTypeId = (typeof LIGHTWEIGHT_TYPE_IDS)[number];
+
+export interface ToolbarWidgetContext {
+  key: string;
+  typeId?: string;
+  value: unknown;
+  defaultValue?: unknown;
+  constraints?: Record<string, unknown>;
+  disabled?: boolean;
+  siteId: string;
+  routePath: string;
+  editorOrigin: string;
+  onSave?: (value: unknown) => Promise<{ ok: boolean; error?: string }>;
+}
+
+export type ToolbarWidgetRenderer = (ctx: ToolbarWidgetContext) => HTMLElement;
+
+export function isLightweightType(typeId?: string | null): boolean {
+  if (!typeId) return false;
+  return (LIGHTWEIGHT_TYPE_IDS as readonly string[]).includes(typeId.toLowerCase());
+}
+
+/**
+ * Extracts a concise summary string from a ProseMirror RichText object or string.
+ */
+export function extractRichTextSummary(value: unknown): string {
+  if (!value) return '(empty)';
+  if (typeof value === 'string') {
+    const trimmed = value.replace(/<[^>]*>/g, '').trim();
+    return trimmed ? (trimmed.length > 50 ? `${trimmed.slice(0, 47)}...` : trimmed) : '(empty)';
+  }
+
+  if (typeof value === 'object' && value !== null) {
+    const doc = value as { type?: string; content?: unknown[] };
+    let nodeCount = 0;
+    const textRuns: string[] = [];
+
+    function walk(node: unknown) {
+      if (!node || typeof node !== 'object') return;
+      nodeCount++;
+      const n = node as { type?: string; text?: string; content?: unknown[] };
+      if (typeof n.text === 'string' && n.text.trim()) {
+        textRuns.push(n.text.trim());
+      }
+      if (Array.isArray(n.content)) {
+        for (const child of n.content) {
+          walk(child);
+        }
+      }
+    }
+
+    walk(doc);
+
+    const firstRun = textRuns[0] || '';
+    const snippet = firstRun.length > 40 ? `${firstRun.slice(0, 37)}...` : firstRun;
+    return snippet
+      ? `"${snippet}" (${nodeCount} ${nodeCount === 1 ? 'node' : 'nodes'})`
+      : `(${nodeCount} ${nodeCount === 1 ? 'node' : 'nodes'})`;
+  }
+
+  return String(value);
+}
+
+/**
+ * Extracts a concise summary string from an Image object or string URL.
+ */
+export function extractImageSummary(value: unknown): string {
+  if (!value) return '(no image)';
+  if (typeof value === 'string') {
+    try {
+      const u = new URL(value, 'https://placeholder.local');
+      const filename = u.pathname.split('/').pop() || value;
+      return filename.length > 40 ? `${filename.slice(0, 37)}...` : filename;
+    } catch {
+      return value.length > 40 ? `${value.slice(0, 37)}...` : value;
+    }
+  }
+
+  if (typeof value === 'object' && value !== null) {
+    const img = value as { url?: string; alt?: string; width?: number; height?: number };
+    const name = img.url ? img.url.split('/').pop() || 'image' : 'image';
+    const dim = img.width && img.height ? ` (${img.width}×${img.height})` : '';
+    const alt = img.alt ? ` — "${img.alt}"` : '';
+    const combined = `${name}${dim}${alt}`;
+    return combined.length > 50 ? `${combined.slice(0, 47)}...` : combined;
+  }
+
+  return String(value);
+}
+
+function createTextWidget(ctx: ToolbarWidgetContext): HTMLElement {
+  const container = document.createElement('div');
+  container.className = 'cms-widget-container';
+
+  const form = document.createElement('form');
+  form.className = 'cms-widget-form';
+
+  const input = document.createElement('input');
+  input.type = 'text';
+  input.className = 'cms-widget-input';
+  input.value = ctx.value !== undefined && ctx.value !== null ? String(ctx.value) : '';
+  input.placeholder =
+    ctx.defaultValue !== undefined && ctx.defaultValue !== null ? String(ctx.defaultValue) : '';
+  input.disabled = Boolean(ctx.disabled);
+
+  const saveBtn = document.createElement('button');
+  saveBtn.type = 'submit';
+  saveBtn.className = 'cms-widget-save-btn';
+  saveBtn.textContent = 'Save';
+  saveBtn.disabled = Boolean(ctx.disabled);
+
+  const errorBox = document.createElement('div');
+  errorBox.className = 'cms-widget-error';
+  errorBox.style.display = 'none';
+
+  form.appendChild(input);
+  form.appendChild(saveBtn);
+  container.appendChild(form);
+  container.appendChild(errorBox);
+
+  form.addEventListener('submit', async (e) => {
+    e.preventDefault();
+    if (!ctx.onSave || ctx.disabled) return;
+
+    saveBtn.disabled = true;
+    saveBtn.textContent = 'Saving...';
+    errorBox.style.display = 'none';
+
+    try {
+      const res = await ctx.onSave(input.value);
+      if (!res.ok) {
+        errorBox.textContent = res.error || 'Failed to save field';
+        errorBox.style.display = 'block';
+      }
+    } finally {
+      saveBtn.disabled = Boolean(ctx.disabled);
+      saveBtn.textContent = 'Save';
+    }
+  });
+
+  return container;
+}
+
+function createNumberWidget(ctx: ToolbarWidgetContext): HTMLElement {
+  const container = document.createElement('div');
+  container.className = 'cms-widget-container';
+
+  const form = document.createElement('form');
+  form.className = 'cms-widget-form';
+
+  const input = document.createElement('input');
+  input.type = 'number';
+  input.className = 'cms-widget-input';
+  input.value = ctx.value !== undefined && ctx.value !== null ? String(ctx.value) : '';
+  input.placeholder =
+    ctx.defaultValue !== undefined && ctx.defaultValue !== null ? String(ctx.defaultValue) : '';
+  input.disabled = Boolean(ctx.disabled);
+
+  if (ctx.constraints?.min !== undefined) input.min = String(ctx.constraints.min);
+  if (ctx.constraints?.max !== undefined) input.max = String(ctx.constraints.max);
+  if (ctx.constraints?.step !== undefined) input.step = String(ctx.constraints.step);
+
+  const saveBtn = document.createElement('button');
+  saveBtn.type = 'submit';
+  saveBtn.className = 'cms-widget-save-btn';
+  saveBtn.textContent = 'Save';
+  saveBtn.disabled = Boolean(ctx.disabled);
+
+  const errorBox = document.createElement('div');
+  errorBox.className = 'cms-widget-error';
+  errorBox.style.display = 'none';
+
+  form.appendChild(input);
+  form.appendChild(saveBtn);
+  container.appendChild(form);
+  container.appendChild(errorBox);
+
+  form.addEventListener('submit', async (e) => {
+    e.preventDefault();
+    if (!ctx.onSave || ctx.disabled) return;
+
+    saveBtn.disabled = true;
+    saveBtn.textContent = 'Saving...';
+    errorBox.style.display = 'none';
+
+    const numVal = input.value === '' ? null : Number(input.value);
+
+    try {
+      const res = await ctx.onSave(numVal);
+      if (!res.ok) {
+        errorBox.textContent = res.error || 'Failed to save field';
+        errorBox.style.display = 'block';
+      }
+    } finally {
+      saveBtn.disabled = Boolean(ctx.disabled);
+      saveBtn.textContent = 'Save';
+    }
+  });
+
+  return container;
+}
+
+function createToggleWidget(ctx: ToolbarWidgetContext): HTMLElement {
+  const container = document.createElement('div');
+  container.className = 'cms-widget-container cms-widget-toggle-row';
+
+  const label = document.createElement('label');
+  label.className = 'cms-widget-toggle-label';
+
+  const input = document.createElement('input');
+  input.type = 'checkbox';
+  input.className = 'cms-widget-checkbox';
+  input.checked = Boolean(ctx.value ?? ctx.defaultValue ?? false);
+  input.disabled = Boolean(ctx.disabled);
+
+  const statusText = document.createElement('span');
+  statusText.className = 'cms-widget-toggle-text';
+  statusText.textContent = input.checked ? 'True' : 'False';
+
+  const errorBox = document.createElement('div');
+  errorBox.className = 'cms-widget-error';
+  errorBox.style.display = 'none';
+
+  label.appendChild(input);
+  label.appendChild(statusText);
+  container.appendChild(label);
+  container.appendChild(errorBox);
+
+  input.addEventListener('change', async () => {
+    statusText.textContent = input.checked ? 'True' : 'False';
+    if (!ctx.onSave || ctx.disabled) return;
+
+    input.disabled = true;
+    errorBox.style.display = 'none';
+
+    try {
+      const res = await ctx.onSave(input.checked);
+      if (!res.ok) {
+        errorBox.textContent = res.error || 'Failed to save field';
+        errorBox.style.display = 'block';
+        input.checked = !input.checked;
+        statusText.textContent = input.checked ? 'True' : 'False';
+      }
+    } finally {
+      input.disabled = Boolean(ctx.disabled);
+    }
+  });
+
+  return container;
+}
+
+function createSelectWidget(ctx: ToolbarWidgetContext): HTMLElement {
+  const container = document.createElement('div');
+  container.className = 'cms-widget-container';
+
+  const select = document.createElement('select');
+  select.className = 'cms-widget-select';
+  select.disabled = Boolean(ctx.disabled);
+
+  // Optional empty placeholder option
+  const emptyOpt = document.createElement('option');
+  emptyOpt.value = '';
+  emptyOpt.textContent = '(select value)';
+  select.appendChild(emptyOpt);
+
+  const rawOptions = ctx.constraints?.options;
+  if (Array.isArray(rawOptions)) {
+    for (const opt of rawOptions) {
+      const optEl = document.createElement('option');
+      if (typeof opt === 'string') {
+        optEl.value = opt;
+        optEl.textContent = opt;
+      } else if (typeof opt === 'object' && opt !== null) {
+        const o = opt as { label?: string; value?: string };
+        optEl.value = o.value || '';
+        optEl.textContent = o.label || o.value || '';
+      }
+      select.appendChild(optEl);
+    }
+  }
+
+  const currentVal = ctx.value !== undefined && ctx.value !== null ? String(ctx.value) : '';
+  select.value = currentVal;
+
+  const errorBox = document.createElement('div');
+  errorBox.className = 'cms-widget-error';
+  errorBox.style.display = 'none';
+
+  container.appendChild(select);
+  container.appendChild(errorBox);
+
+  select.addEventListener('change', async () => {
+    if (!ctx.onSave || ctx.disabled) return;
+
+    select.disabled = true;
+    errorBox.style.display = 'none';
+
+    try {
+      const res = await ctx.onSave(select.value);
+      if (!res.ok) {
+        errorBox.textContent = res.error || 'Failed to save field';
+        errorBox.style.display = 'block';
+        select.value = currentVal;
+      }
+    } finally {
+      select.disabled = Boolean(ctx.disabled);
+    }
+  });
+
+  return container;
+}
+
+function createSummaryWidget(ctx: ToolbarWidgetContext): HTMLElement {
+  const container = document.createElement('div');
+  container.className = 'cms-widget-summary-row';
+
+  const summary = document.createElement('div');
+  summary.className = 'cms-widget-summary-text';
+
+  const normType = (ctx.typeId || '').toLowerCase();
+  if (normType === 'richtext') {
+    summary.textContent = extractRichTextSummary(ctx.value ?? ctx.defaultValue);
+  } else if (normType === 'image') {
+    summary.textContent = extractImageSummary(ctx.value ?? ctx.defaultValue);
+  } else {
+    const v = ctx.value ?? ctx.defaultValue;
+    summary.textContent = v !== undefined && v !== null ? JSON.stringify(v) : '(no value)';
+  }
+
+  const cleanOrigin = (ctx.editorOrigin || DEFAULT_EDITOR_ORIGINS[0]).replace(/\/$/, '');
+  const editorUrl = `${cleanOrigin}/sites/${encodeURIComponent(ctx.siteId)}/editor?path=${encodeURIComponent(ctx.routePath || '/')}&field=${encodeURIComponent(ctx.key)}`;
+
+  const link = document.createElement('a');
+  link.href = editorUrl;
+  link.target = '_blank';
+  link.rel = 'noopener noreferrer';
+  link.className = 'cms-widget-editor-link';
+  link.innerHTML = 'Open in Editor ↗';
+
+  container.appendChild(summary);
+  container.appendChild(link);
+
+  return container;
+}
+
+const widgetRegistry = new Map<string, ToolbarWidgetRenderer>([
+  ['text', createTextWidget],
+  ['number', createNumberWidget],
+  ['toggle', createToggleWidget],
+  ['select', createSelectWidget],
+]);
+
+export function registerToolbarWidget(typeId: string, renderer: ToolbarWidgetRenderer) {
+  widgetRegistry.set(typeId.toLowerCase(), renderer);
+}
+
+export function resolveToolbarWidget(typeId?: string | null): ToolbarWidgetRenderer {
+  if (!typeId) return createSummaryWidget;
+  const normalized = typeId.toLowerCase();
+  return widgetRegistry.get(normalized) || createSummaryWidget;
+}

package/src/types.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, expectTypeOf, it } from 'vitest';
+import { type BoundGroupAccessor, type CollectionEntry, defineCollection, f, z } from './fields';
+import type { CmsClient, ContentBundle } from './types';
+
+describe('Astro SDK Type Invariants', () => {
+  it('correctly types ContentBundle shape', () => {
+    const bundle: ContentBundle = {
+      bundleVersion: 1,
+      site_id: 's1',
+      fields: { title: 'Test' },
+      collections: {
+        posts: {
+          presentation: 'visual',
+          orderable: true,
+          schema_version: 1,
+        },
+      },
+      entries: {
+        posts: [
+          {
+            slug: 'post-1',
+            content: { title: 'Post' },
+            status: 'published',
+          },
+        ],
+      },
+      routes: [{ path: '/', kind: 'static' }],
+      settings: {},
+      redirects: [],
+    };
+
+    expectTypeOf(bundle.bundleVersion).toEqualTypeOf<1>();
+    expectTypeOf(bundle.fields).toEqualTypeOf<Record<string, unknown>>();
+  });
+
+  it('correctly types CmsClient methods', () => {
+    expectTypeOf<CmsClient['getBundle']>().toBeFunction();
+    expectTypeOf<CmsClient['getFields']>().toBeFunction();
+    expectTypeOf<CmsClient['getCollections']>().toBeFunction();
+    expectTypeOf<CmsClient['getEntries']>().toBeFunction();
+  });
+
+  it('correctly types scope key composition and helpers', () => {
+    const reviews = f.scope('home.reviews');
+    expectTypeOf(reviews.key('title')).toEqualTypeOf<string>();
+    expectTypeOf(reviews('title')).toEqualTypeOf<string>();
+    expectTypeOf(reviews.text('title')).toEqualTypeOf<string>();
+    expectTypeOf(reviews.number('count')).toEqualTypeOf<number>();
+    expectTypeOf(reviews.toggle('enabled')).toEqualTypeOf<boolean>();
+  });
+
+  it('correctly types group definition and component prop drilling', () => {
+    const Hero = f.group('Hero', {
+      heading: f.text,
+      subheading: f.text,
+      image: f.img,
+    });
+
+    const hero = Hero('home.hero');
+    expectTypeOf(hero.attrs()).toEqualTypeOf<{ 'data-cms-group': string }>();
+    expectTypeOf(hero.heading('title')).toEqualTypeOf<string>();
+
+    interface HeroProps {
+      content: BoundGroupAccessor<{
+        heading: typeof f.text;
+        subheading: typeof f.text;
+        image: typeof f.img;
+      }>;
+    }
+
+    const testProps: HeroProps = { content: hero };
+    expectTypeOf(testProps.content.attrs).toBeFunction();
+  });
+
+  it('correctly infers Zod schema types on f.entries and f.entry', () => {
+    const postSchema = z.object({
+      title: z.string(),
+      views: z.number(),
+      tags: z.array(z.string()),
+    });
+
+    const posts = defineCollection({
+      key: 'posts',
+      schema: postSchema,
+      route: '/posts/[slug]',
+    });
+
+    type InferredPost = z.infer<typeof postSchema>;
+    const entries = f.entries(posts);
+    expectTypeOf(entries).toEqualTypeOf<Array<CollectionEntry<InferredPost>>>();
+
+    const entry = f.entry(posts, 'hello');
+    expectTypeOf(entry).toEqualTypeOf<CollectionEntry<InferredPost> | null>();
+  });
+
+  it('enforces CmsAsset and CmsImage type invariants', () => {
+    type ImageProps = {
+      src: import('./types').CmsAsset | string;
+      alt: string;
+      widths?: number[];
+    };
+    expectTypeOf<ImageProps['alt']>().toEqualTypeOf<string>();
+
+    const asset: import('./types').CmsAsset = {
+      id: 'a1',
+      url: 'https://example.com/asset.png',
+      alt: 'Sample',
+      focal_x: 0.5,
+      focal_y: 0.5,
+      mime_type: 'image/png',
+      filename: 'asset.png',
+      kind: 'image',
+      duration_ms: null,
+      renditions: {
+        hero: {
+          key: 'sites/s1/assets/a1/hero.12345678.mp4',
+          url: 'https://cdn.example.com/hero.mp4',
+        },
+      },
+      status: 'ready',
+    };
+    expectTypeOf(asset.kind).toEqualTypeOf<
+      'image' | 'video' | 'audio' | 'file' | string | undefined
+    >();
+  });
+
+  it('supports seed option on defineCollection and passes it through on the handle', () => {
+    const faqSchema = z.object({
+      question: z.string(),
+      answer: z.string(),
+    });
+
+    const faqs = defineCollection({
+      key: 'faqs',
+      schema: faqSchema,
+      seed: [
+        {
+          slug: 'free-estimates',
+          content: {
+            question: 'Do you offer free estimates?',
+            answer: 'Yes, we do.',
+          },
+        },
+      ],
+    });
+
+    expect(faqs.seed).toHaveLength(1);
+    expect(faqs.seed?.[0].slug).toBe('free-estimates');
+    expect(faqs.seed?.[0].content.question).toBe('Do you offer free estimates?');
+    expectTypeOf(faqs.seed).toEqualTypeOf<
+      Array<{ slug: string; content: { question: string; answer: string } }> | undefined
+    >();
+  });
+});