fimo 0.9.0-experimental.1 → 0.9.0-experimental.11

package/dist/runtime/wrapped/content-fetch.pure.d.ts

@@ -0,0 +1,20 @@
+import type { WrappedMediaEntry, WrappedRichTextEntry } from './WrappedContentContext.js';
+export interface WrappedEntryRow {
+    id: string;
+    data: Record<string, unknown>;
+}
+/** Every published row of a content type, paginated to the end. Returns []
+ *  when the API is unreachable so wrapped sites keep their fallbacks. */
+export declare function fetchAllWrappedRows(apiUrl: string, typeName: string): Promise<WrappedEntryRow[]>;
+/** WrappedMedia rows → key → media entry (the FimoMediaImage/Video id map). */
+export declare function mapWrappedMedia(rows: WrappedEntryRow[]): Record<string, WrappedMediaEntry>;
+/** WrappedRichText rows → key → TipTap content (the FimoRichTextBlock map). */
+export declare function mapWrappedRichText(rows: WrappedEntryRow[]): Record<string, WrappedRichTextEntry>;
+export interface WrappedContent {
+    media: Record<string, WrappedMediaEntry>;
+    richText: Record<string, WrappedRichTextEntry>;
+}
+/** Both plumbing maps in one round: what a client-rendered wrapped app needs
+ *  so Studio edits to rich text and media are LIVE, not fallback-only. */
+export declare function fetchWrappedContent(apiUrl: string): Promise<WrappedContent>;
+//# sourceMappingURL=content-fetch.pure.d.ts.map

package/dist/runtime/wrapped/content-fetch.pure.js

@@ -0,0 +1,106 @@
+// Wrapped-content fetching, PURE core: fetch/URL/AbortController only — no
+// node builtins, importable from client-bundled code (the SPA provider) and
+// from the server loaders alike. The plumbing types (WrappedRichText,
+// WrappedMedia) hold ALL of a site's wrapped rich text and media, so the
+// fetch PAGINATES to the end — the tenant API caps limit at 100 and a real
+// site exceeds it (the Fimo site carries 147 rich-text entries).
+import { fetchWithTimeout } from '../shared/labels-fetch.pure.js';
+const PAGE_LIMIT = 100;
+const MAX_ROWS = 5000;
+function readString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function readNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+/** Every published row of a content type, paginated to the end. Returns []
+ *  when the API is unreachable so wrapped sites keep their fallbacks. */
+export async function fetchAllWrappedRows(apiUrl, typeName) {
+    const rows = [];
+    try {
+        for (let offset = 0; offset < MAX_ROWS; offset += PAGE_LIMIT) {
+            const url = new URL(`/entries/${typeName}`, apiUrl);
+            url.searchParams.set('limit', String(PAGE_LIMIT));
+            url.searchParams.set('offset', String(offset));
+            const response = await fetchWithTimeout(url, 4000);
+            if (!response.ok) {
+                break;
+            }
+            const body = (await response.json());
+            const page = Array.isArray(body.data) ? body.data : [];
+            for (const row of page) {
+                if (!row || typeof row !== 'object') {
+                    continue;
+                }
+                const record = row;
+                const id = String(record.id ?? record.documentId ?? '');
+                if (id.length === 0) {
+                    continue;
+                }
+                rows.push({
+                    id,
+                    data: (record.data && typeof record.data === 'object' ? record.data : record),
+                });
+            }
+            const hasMore = body.meta?.hasMore === true || page.length === PAGE_LIMIT;
+            if (!hasMore) {
+                break;
+            }
+        }
+    }
+    catch {
+        // Unreachable API mid-pagination: return what we have (possibly []).
+    }
+    return rows;
+}
+/** WrappedMedia rows → key → media entry (the FimoMediaImage/Video id map). */
+export function mapWrappedMedia(rows) {
+    const map = {};
+    for (const entry of rows) {
+        const key = readString(entry.data.key) ?? readString(entry.data.slug);
+        const asset = entry.data.image;
+        if (!key || !asset || typeof asset !== 'object') {
+            continue;
+        }
+        const assetRecord = asset;
+        const url = readString(assetRecord.url);
+        if (!url) {
+            continue;
+        }
+        map[key] = {
+            url,
+            alt: readString(assetRecord.alt) ?? readString(entry.data.alt),
+            name: readString(assetRecord.name),
+            mime: readString(assetRecord.mime) ?? readString(assetRecord.mimeType),
+            width: readNumber(assetRecord.width),
+            height: readNumber(assetRecord.height),
+            source: `WrappedMedia.${entry.id}.image`,
+        };
+    }
+    return map;
+}
+/** WrappedRichText rows → key → TipTap content (the FimoRichTextBlock map). */
+export function mapWrappedRichText(rows) {
+    const map = {};
+    for (const entry of rows) {
+        const key = readString(entry.data.key) ?? readString(entry.data.slug);
+        const body = entry.data.body;
+        if (!key || !body || typeof body !== 'object') {
+            continue;
+        }
+        map[key] = {
+            content: body,
+            source: `WrappedRichText.${entry.id}.body`,
+        };
+    }
+    return map;
+}
+/** Both plumbing maps in one round: what a client-rendered wrapped app needs
+ *  so Studio edits to rich text and media are LIVE, not fallback-only. */
+export async function fetchWrappedContent(apiUrl) {
+    const [mediaRows, richTextRows] = await Promise.all([
+        fetchAllWrappedRows(apiUrl, 'WrappedMedia'),
+        fetchAllWrappedRows(apiUrl, 'WrappedRichText'),
+    ]);
+    return { media: mapWrappedMedia(mediaRows), richText: mapWrappedRichText(richTextRows) };
+}

package/dist/runtime/wrapped/server.d.ts

@@ -39,12 +39,15 @@ export declare function fetchEntries(typeName: string, options?: FimoServerOptio
 /**
  * Load the WrappedMedia entries (key → media) seeded by the wrap migration.
  * Each entry has a `key` (the FimoMediaImage/Video/FileLink id) and an
- * asset-typed `image` field.
+ * asset-typed `image` field. Paginates to the end — a site's wrapped media
+ * routinely exceeds one API page.
  */
 export declare function loadWrappedMedia(options?: FimoServerOptions): Promise<Record<string, WrappedMediaEntry>>;
 /**
  * Load the WrappedRichText entries (key → TipTap JSON) seeded by the wrap
- * migration for formatted text (bold/italic/underline/links).
+ * migration for formatted text (bold/italic/underline/links). Paginates to
+ * the end — the Fimo site alone carries 147 entries against a 20-row API
+ * default page.
  */
 export declare function loadWrappedRichText(options?: FimoServerOptions): Promise<Record<string, WrappedRichTextEntry>>;
 /**

package/dist/runtime/wrapped/server.js

@@ -5,6 +5,7 @@
 import { getConfigServer } from '../shared/fimo-config.server.js';
 import { deepMergeMessages, unflattenMessages } from '../shared/i18n-messages.js';
 import { fetchLabelDictionary, fetchWithTimeout, labelSignature, loadLabelBundle, readProjectEnv, resolveTenantApiUrl, } from '../shared/labels-fetch.server.js';
+import { fetchAllWrappedRows, mapWrappedMedia, mapWrappedRichText } from './content-fetch.pure.js';
 export function loadFimoConfig(rootDir = process.cwd()) {
     return getConfigServer(rootDir);
 }
@@ -72,62 +73,31 @@ export async function fetchEntries(typeName, options = {}) {
         return [];
     }
 }
-function readString(value) {
-    return typeof value === 'string' && value.length > 0 ? value : undefined;
-}
-function readNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
-}
 /**
  * Load the WrappedMedia entries (key → media) seeded by the wrap migration.
  * Each entry has a `key` (the FimoMediaImage/Video/FileLink id) and an
- * asset-typed `image` field.
+ * asset-typed `image` field. Paginates to the end — a site's wrapped media
+ * routinely exceeds one API page.
  */
 export async function loadWrappedMedia(options = {}) {
-    const entries = await fetchEntries('WrappedMedia', options);
-    const map = {};
-    for (const entry of entries) {
-        const key = readString(entry.data.key) ?? readString(entry.data.slug);
-        const asset = entry.data.image;
-        if (!key || !asset || typeof asset !== 'object') {
-            continue;
-        }
-        const assetRecord = asset;
-        const url = readString(assetRecord.url);
-        if (!url) {
-            continue;
-        }
-        map[key] = {
-            url,
-            alt: readString(assetRecord.alt) ?? readString(entry.data.alt),
-            name: readString(assetRecord.name),
-            mime: readString(assetRecord.mime) ?? readString(assetRecord.mimeType),
-            width: readNumber(assetRecord.width),
-            height: readNumber(assetRecord.height),
-            source: `WrappedMedia.${entry.id}.image`,
-        };
-    }
-    return map;
+    const apiUrl = await resolveApiUrl(options);
+    if (!apiUrl) {
+        return {};
+    }
+    return mapWrappedMedia(await fetchAllWrappedRows(apiUrl, 'WrappedMedia'));
 }
 /**
  * Load the WrappedRichText entries (key → TipTap JSON) seeded by the wrap
- * migration for formatted text (bold/italic/underline/links).
+ * migration for formatted text (bold/italic/underline/links). Paginates to
+ * the end — the Fimo site alone carries 147 entries against a 20-row API
+ * default page.
  */
 export async function loadWrappedRichText(options = {}) {
-    const entries = await fetchEntries('WrappedRichText', options);
-    const map = {};
-    for (const entry of entries) {
-        const key = readString(entry.data.key) ?? readString(entry.data.slug);
-        const body = entry.data.body;
-        if (!key || !body || typeof body !== 'object') {
-            continue;
-        }
-        map[key] = {
-            content: body,
-            source: `WrappedRichText.${entry.id}.body`,
-        };
+    const apiUrl = await resolveApiUrl(options);
+    if (!apiUrl) {
+        return {};
     }
-    return map;
+    return mapWrappedRichText(await fetchAllWrappedRows(apiUrl, 'WrappedRichText'));
 }
 /** Key fields tried, in order, to align a source row with its Fimo entry. */
 const COLLECTION_KEY_FIELDS = ['slug', 'id', 'key', 'name', 'title', 'question'];

package/dist/scripts/apply-wrap-templates.js

@@ -1,6 +1,6 @@
 import { readFileSync, writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
-import { decodeJsxEntities, KeyAllocator, slugify } from './apply-wrap.js';
+import { decodeJsxEntities, KeyAllocator, readApplyExemptions, reusableStagedLabels, slugify, } from './apply-wrap.js';
 import { scanWrappable } from './scan-wrappable.js';
 /**
  * Shared injection helper for SFC-style templates: first instance script,
@@ -66,11 +66,12 @@ export function applyTemplateWrapToFile(code, style, items, allocator) {
             continue;
         }
         const collapsed = match[2].replace(/\s+/g, ' ').trim();
-        const id = allocator.allocate(scope || 'shared', slugify(collapsed));
+        const value = decodeJsxEntities(collapsed);
+        const id = allocator.allocate(scope || 'shared', slugify(value), value);
         const escaped = collapsed.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
         const replacement = `>${match[1]}${style.open}"${id}", "${escaped}"${style.close}${match[3]}<`;
         next = next.slice(0, match.index) + replacement + next.slice(match.index + match[0].length);
-        labels[id] = decodeJsxEntities(collapsed);
+        labels[id] = value;
         applied.push({ kind: 'text', file: item.file, line: item.line, id, preview: item.preview });
     }
     if (applied.length > 0 && !style.headMarker.test(next)) {
@@ -95,11 +96,15 @@ export function applyTemplateWrap(rootDir, opts) {
             return {};
         }
     })();
-    const allocator = new KeyAllocator([...Object.keys(existingLabels), ...scan.wrappedIds.labels]);
+    // Honor recorded exemptions — same contract as the JSX codemod: --apply
+    // must never wrap an item the user deliberately kept out.
+    const exemptions = readApplyExemptions(rootDir);
+    const isExempt = (item) => exemptions.some((exemption) => exemption.file === item.file && exemption.kind === item.kind && exemption.preview === item.preview);
+    const allocator = new KeyAllocator([...Object.keys(existingLabels), ...scan.wrappedIds.labels], reusableStagedLabels(existingLabels, scan.wrappedIds.labels));
     const result = { applied: [], skipped: [], labels: {}, filesChanged: [] };
     const byFile = new Map();
     for (const item of scan.items) {
-        if (!item.file.endsWith(style.ext)) {
+        if (!item.file.endsWith(style.ext) || isExempt(item)) {
             continue;
         }
         const list = byFile.get(item.file) ?? [];

package/dist/scripts/apply-wrap.d.ts

@@ -16,14 +16,27 @@ export interface ApplyWrapResult {
     filesChanged: string[];
 }
 export declare function decodeJsxEntities(text: string): string;
+/** Conservative markdown detection: bold pairs, inline code, links, and a
+ *  leading heading marker — not lone `*`/`[` characters in ordinary copy. */
+export declare function looksLikeMarkdown(text: string): boolean;
 /** Deterministic scope from the file path: app/about/page.tsx -> about. */
 export declare function keyScope(file: string): string;
 export declare function slugify(text: string): string;
 export declare class KeyAllocator {
     private readonly used;
-    constructor(existing: Iterable<string>);
-    allocate(scope: string, slug: string): string;
+    private readonly reusable;
+    /**
+     * `reusable` maps staged keys that no longer appear in code (a wrap the
+     * user reverted) to their staged value: re-applying the codemod over the
+     * same text reclaims the ORIGINAL key instead of minting a `-N` duplicate
+     * that orphans the old label (and its seeded row).
+     */
+    constructor(existing: Iterable<string>, reusable?: ReadonlyMap<string, string>);
+    allocate(scope: string, slug: string, value?: string): string;
 }
+/** Staged keys absent from the current code scan, with their staged values —
+ *  the KeyAllocator's reuse pool. */
+export declare function reusableStagedLabels(existingLabels: Record<string, string>, wrappedInCode: Iterable<string>): Map<string, string>;
 /**
  * Merge the fimo/next import with an existing one, or insert a new one AFTER
  * the last import statement — positioned via the AST, never line matching
@@ -40,6 +53,20 @@ export declare function applyWrapToFile(code: string, items: WrappableItem[], al
     }>;
     labels: Record<string, string>;
 };
+/**
+ * Apply the safe transforms across the project. Mutates source files and
+ * merges generated labels into `.fimo/migration/labels.json` (never
+ * overwriting existing keys).
+ */
+/** Recorded coverage exemptions the codemod must NOT wrap — items the user
+ *  deliberately kept out (dev-only UI, OG-image markup, …). Matched by the
+ *  same (file, kind, preview) triple the coverage gate uses, so "record the
+ *  exemption first, then --apply auto-wraps the rest" holds. */
+export declare function readApplyExemptions(rootDir: string): Array<{
+    file: string;
+    kind: string;
+    preview: string;
+}>;
 export declare function applyWrap(rootDir: string, opts?: {
     excludePrefixes?: string[];
     importModule?: string;

package/dist/scripts/apply-wrap.js

@@ -33,13 +33,36 @@ const JSX_ENTITIES = {
     ''': "'",
     ' ': ' ',
     '©': '©',
+    '®': '®',
+    '™': '™',
+    '°': '°',
+    '·': '·',
+    '•': '•',
+    '…': '…',
+    '—': '—',
+    '–': '–',
+    '‘': '‘',
+    '’': '’',
+    '“': '“',
+    '”': '”',
+    '«': '«',
+    '»': '»',
+    '×': '×',
+    '→': '→',
+    '←': '←',
 };
 export function decodeJsxEntities(text) {
     return text
-        .replace(/&(amp|lt|gt|quot|apos|nbsp|copy);/g, (entity) => JSX_ENTITIES[entity] ?? entity)
+        .replace(/&(amp|lt|gt|quot|apos|nbsp|copy|reg|trade|deg|middot|bull|hellip|mdash|ndash|lsquo|rsquo|ldquo|rdquo|laquo|raquo|times|rarr|larr);/g, (entity) => JSX_ENTITIES[entity] ?? entity)
         .replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code)))
         .replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCodePoint(parseInt(code, 16)));
 }
+const MARKDOWN_SYNTAX = [/\*\*[^*]+\*\*/, /(?<!`)`[^`]+`/, /\[[^\]]+\]\([^)]+\)/, /^#{1,6}\s/];
+/** Conservative markdown detection: bold pairs, inline code, links, and a
+ *  leading heading marker — not lone `*`/`[` characters in ordinary copy. */
+export function looksLikeMarkdown(text) {
+    return MARKDOWN_SYNTAX.some((pattern) => pattern.test(text));
+}
 /** Deterministic scope from the file path: app/about/page.tsx -> about. */
 export function keyScope(file) {
     const normalized = file.replace(/\\/g, '/');
@@ -62,7 +85,12 @@ export function keyScope(file) {
     return slugify(stem) || 'shared';
 }
 export function slugify(text) {
+    // camelCase boundaries become segments BEFORE lowercasing, so component
+    // file names keep their word structure (AgentStrip.tsx → agent-strip.*)
+    // and every humanized display of the key reads like the component name.
     return collapse(text)
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
         .toLowerCase()
         .normalize('NFD')
         .replace(/[̀-ͯ]/g, '')
@@ -74,22 +102,44 @@ export function slugify(text) {
 }
 export class KeyAllocator {
     used = new Set();
-    constructor(existing) {
+    reusable = new Map();
+    /**
+     * `reusable` maps staged keys that no longer appear in code (a wrap the
+     * user reverted) to their staged value: re-applying the codemod over the
+     * same text reclaims the ORIGINAL key instead of minting a `-N` duplicate
+     * that orphans the old label (and its seeded row).
+     */
+    constructor(existing, reusable) {
         for (const key of existing) {
             this.used.add(key);
         }
+        if (reusable) {
+            for (const [key, value] of reusable) {
+                this.reusable.set(key, value);
+            }
+        }
     }
-    allocate(scope, slug) {
+    allocate(scope, slug, value) {
         const base = `${scope}.${slug || 'item'}`;
         let candidate = base;
         let counter = 2;
         while (this.used.has(candidate)) {
+            if (value !== undefined && this.reusable.get(candidate) === value) {
+                this.reusable.delete(candidate);
+                return candidate;
+            }
             candidate = `${base}-${counter++}`;
         }
         this.used.add(candidate);
         return candidate;
     }
 }
+/** Staged keys absent from the current code scan, with their staged values —
+ *  the KeyAllocator's reuse pool. */
+export function reusableStagedLabels(existingLabels, wrappedInCode) {
+    const inCode = new Set(wrappedInCode);
+    return new Map(Object.entries(existingLabels).filter(([key]) => !inCode.has(key)));
+}
 /**
  * Merge the fimo/next import with an existing one, or insert a new one AFTER
  * the last import statement — positioned via the AST, never line matching
@@ -152,16 +202,28 @@ export function applyWrapToFile(code, items, allocator, importModule = 'fimo/nex
                 skipped.push({ item, reason: 'whitespace only' });
                 continue;
             }
+            if (looksLikeMarkdown(core)) {
+                // A parent that pipes its string child through a markdown renderer
+                // receives a React element after wrapping — the pipeline stops
+                // parsing and the **markers** render literally (a real parity break
+                // a dogfood gate caught). Text carrying markdown syntax stays agent
+                // work; syntax-free text renders identically either way.
+                skipped.push({ item, reason: 'markdown syntax in text — wrapping could break a markdown pipeline' });
+                continue;
+            }
             const lead = raw.slice(0, raw.indexOf(core));
             const trail = raw.slice(raw.indexOf(core) + core.length);
-            const id = allocator.allocate(scope, slugify(core));
+            // Slug from the DECODED text — "&apos;" must never leak "apos" into a
+            // key ("today-apos-s-total" read "Today Apos S Total" in the Studio).
+            const value = decodeJsxEntities(collapse(core));
+            const id = allocator.allocate(scope, slugify(decodeJsxEntities(core)), value);
             edits.push({
                 start: span.start,
                 end: span.end,
                 replacement: `${lead}<FimoText id="${id}">${core}</FimoText>${trail}`,
             });
             specifiers.add('FimoText');
-            labels[id] = decodeJsxEntities(collapse(core));
+            labels[id] = value;
             applied.push({ kind: 'text', file: item.file, line: item.line, id, preview: item.preview });
             continue;
         }
@@ -215,7 +277,7 @@ export function applyWrapToFile(code, items, allocator, importModule = 'fimo/nex
  *  deliberately kept out (dev-only UI, OG-image markup, …). Matched by the
  *  same (file, kind, preview) triple the coverage gate uses, so "record the
  *  exemption first, then --apply auto-wraps the rest" holds. */
-function readApplyExemptions(rootDir) {
+export function readApplyExemptions(rootDir) {
     try {
         const manifest = JSON.parse(readFileSync(join(rootDir, '.fimo', 'migration', 'manifest.json'), 'utf8'));
         const raw = manifest?.wrap?.exemptions;
@@ -244,7 +306,7 @@ export function applyWrap(rootDir, opts = {}) {
     // an item the user just exempted and the gate would flag the drift.
     const exemptions = readApplyExemptions(rootDir);
     const isExempt = (item) => exemptions.some((exemption) => exemption.file === item.file && exemption.kind === item.kind && exemption.preview === item.preview);
-    const allocator = new KeyAllocator([...Object.keys(existingLabels), ...scan.wrappedIds.labels]);
+    const allocator = new KeyAllocator([...Object.keys(existingLabels), ...scan.wrappedIds.labels], reusableStagedLabels(existingLabels, scan.wrappedIds.labels));
     const byFile = new Map();
     for (const item of scan.items) {
         if (isExempt(item)) {

package/dist/scripts/cms/example-content.js

@@ -1,12 +1,14 @@
+import { humanizeSegment } from '../lib/humanize.js';
 const DEFAULT_COUNT = 3;
 /** Variants seeded per dynamic-zone (`oneOf`) field — a representative page, not
  *  all N components. Real content (the pull) exercises the rest. */
 const EXAMPLE_BLOCK_VARIANTS = 5;
 /** Items seeded for a repeatable fixed-shape block. */
 const EXAMPLE_REPEATABLE_ITEMS = 2;
-/** Recursion cap for nested blocks — the schema is already depth-bounded; this
- *  keeps generation finite even for pathological nesting. */
-const MAX_FILL_DEPTH = 3;
+/** Recursion cap for nested blocks — fill to the schema's real nesting so deep
+ *  page-builders render, matching the blocks-depth limit (7) in api-contracts.
+ *  The schema is already depth-bounded, so generation stays finite. */
+const MAX_FILL_DEPTH = 6;
 function kebabCase(name) {
     return name
         .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
@@ -14,12 +16,6 @@ function kebabCase(name) {
         .toLowerCase()
         .replace(/^-+|-+$/g, '');
 }
-function humanize(field) {
-    return field
-        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
-        .replace(/[_-]+/g, ' ')
-        .replace(/^\w/, (c) => c.toUpperCase());
-}
 function richTextDoc(text) {
     return {
         type: 'doc',
@@ -66,9 +62,9 @@ function fillFieldValue(field, def, ctx) {
     }
     switch (def.type) {
         case 'string':
-            return `${humanize(field)} example ${ctx.index}${ctx.localeSuffix}`;
+            return `${humanizeSegment(field)} example ${ctx.index}${ctx.localeSuffix}`;
         case 'richtext':
-            return richTextDoc(`Example ${humanize(ctx.schemaName).toLowerCase()} content ${ctx.index}${ctx.localeSuffix}.`);
+            return richTextDoc(`Example ${humanizeSegment(ctx.schemaName).toLowerCase()} content ${ctx.index}${ctx.localeSuffix}.`);
         case 'number':
             return ctx.index;
         case 'boolean':
@@ -78,7 +74,7 @@ function fillFieldValue(field, def, ctx) {
         case 'json':
             return {};
         case 'media':
-            return placeholderMedia(humanize(field));
+            return placeholderMedia(humanizeSegment(field));
         case 'blocks':
             return fillBlocks(def, ctx);
         default:
@@ -99,7 +95,14 @@ function fillBlocks(def, ctx) {
     const childCtx = { ...ctx, depth: ctx.depth + 1 };
     const schema = def.schema;
     if ('oneOf' in schema) {
-        return schema.oneOf.slice(0, EXAMPLE_BLOCK_VARIANTS).map((variant) => ({
+        // Rotate the variant window by row index so example entries render
+        // DIFFERENT block sets (entry 1 → variants 0-4, entry 2 → 5-9, …) —
+        // distinct-looking pages, and collectively more of the page builder
+        // exercised than the first five variants over and over.
+        const total = schema.oneOf.length;
+        const take = Math.min(EXAMPLE_BLOCK_VARIANTS, total);
+        const offset = total > 0 ? ((ctx.index - 1) * take) % total : 0;
+        return Array.from({ length: take }, (_, k) => schema.oneOf[(offset + k) % total]).map((variant) => ({
             _type: variant.uid,
             ...fillItem(variant.fields, childCtx),
         }));

package/dist/scripts/cms/strapi/schema-map.js

@@ -19,7 +19,9 @@ import { join } from 'node:path';
 const MAX_BLOCK_VARIANTS = 40;
 // Bound recursion into nested components; beyond this a nested component falls
 // back to `json` (still round-trips, just not granularly editable that deep).
-const MAX_COMPONENT_DEPTH = 5;
+// Kept one below MAX_STRUCTURED_CONTENT_DEPTH (7) in @fimo/api-contracts so the
+// deepest blocks we emit still pass the server's structured-content-depth gate.
+const MAX_COMPONENT_DEPTH = 6;
 // Field-name + type-name contracts from @fimo/api-contracts (content-fields.ts).
 const FIELD_NAME_PATTERN = /^[A-Za-z_]\w*$/;
 const RESERVED_BLOCK_FIELD_NAMES = new Set(['_key', '_type']);
@@ -55,8 +57,15 @@ function mapAttribute(field, attr, ctx) {
         case 'text':
         case 'email':
         case 'uid':
-        case 'enumeration':
             return { type: 'string' };
+        case 'enumeration': {
+            // Enum values drive rendering switches (link types, section variants) —
+            // an invalid member makes components filter the item out entirely. Bake
+            // the schema's declared default (else the first member) so generated
+            // content always carries a valid value; the field stays editable.
+            const value = attr.default ?? (Array.isArray(attr.enum) ? attr.enum[0] : undefined);
+            return { type: 'string', ...(value !== undefined ? { default: value } : {}) };
+        }
         case 'richtext':
         case 'blocks':
             return { type: 'richtext' };
@@ -182,14 +191,17 @@ function mapSchema(raw, uidToName, components) {
             fields[field] = mapped;
         }
     }
+    const isSingleton = raw.schema.kind === 'singleType';
     return {
         name,
         label: info.displayName || name,
-        isSingleton: raw.schema.kind === 'singleType',
+        isSingleton,
         localized: raw.schema.pluginOptions?.i18n?.localized === true,
         fields,
         sourceUid: raw.uid,
-        sourcePath: `/${info.pluralName ?? raw.contentTypeName}`,
+        // Strapi single types are fetched by SINGULAR name (`/api/global`), collections
+        // by plural (`/api/pages`); the wiring keys its type map off this path.
+        sourcePath: `/${isSingleton ? (info.singularName ?? raw.contentTypeName) : (info.pluralName ?? raw.contentTypeName)}`,
     };
 }
 /** Walk `<strapiAppDir>/src/api/<api>/content-types/<ct>/schema.json`. */

package/dist/scripts/cms/strapi/shapes.d.ts

@@ -3,17 +3,19 @@ import type { CmsCollectionSchema } from '../types.js';
  * Field-shape manifest for the `fimo/strapi` reshape. A Fimo blocks value is
  * always an array, but a Strapi single component reads as an object — so the
  * reshape needs to know, per structural field, whether to unwrap the one-item
- * array (`single`) or keep it (`list`), plus the nested shapes inside. Leaf
- * fields (scalars, media, richtext, references) are omitted — the runtime
- * reshapes those by value-inspection. Derived from the Strapi source at scaffold
- * time and baked into the generated module, so nothing is inferred at runtime.
+ * array (`single`) or keep it (`list`), plus the nested shapes inside.
+ * To-many relations are baked as `many-ref` so the reshape can coerce them to
+ * arrays invariantly. Other leaf fields (scalars, media, richtext, single
+ * references) are omitted — the runtime reshapes those by value-inspection.
+ * Derived from the Strapi source at scaffold time and baked into the
+ * generated module, so nothing is inferred at runtime.
  *
  * This mirrors `BlockFieldShape` in `runtime/strapi/reshape.ts` (the composite
  * boundary forbids sharing the type across `scripts`/`runtime`); the
  * `shapes.test.ts` round-trip guards their agreement.
  */
 export interface BlockFieldShape {
-    kind: 'single' | 'list';
+    kind: 'single' | 'list' | 'many-ref';
     fields?: FieldShapes;
     variants?: Record<string, FieldShapes>;
 }

package/dist/scripts/cms/strapi/shapes.js

@@ -1,6 +1,16 @@
 function shapesFrom(fields) {
     const shapes = {};
     for (const [name, def] of Object.entries(fields)) {
+        if (def.type === 'reference') {
+            // Many-relations are baked as 'many-ref' so the reshape can hold the
+            // array invariant — value-inspection alone cannot tell a stray single
+            // handle from a legitimate object, and a Strapi frontend iterating a
+            // oneToMany 500s the moment one arrives as an object.
+            if (def.many) {
+                shapes[name] = { kind: 'many-ref' };
+            }
+            continue;
+        }
         if (def.type !== 'blocks') {
             continue; // leaves are value-inspected by the runtime reshape
         }

package/dist/scripts/cms/strapi/wiring.js

@@ -35,7 +35,7 @@ const SINGLETONS = [${singletons.map((name) => `'${name}'`).join(', ')}];
 
 // Structural field shapes (single components read as objects; block items and
 // dynamic zones reshape into the Strapi shape the components expect).
-const FIELD_SHAPES = ${fieldShapes};
+const FIELD_SHAPES = ${fieldShapes} as const;
 
 export const fimoStrapiFetch = createFimoStrapiFetch({
   types: TYPES,

package/dist/scripts/detect-framework.js

@@ -18,6 +18,12 @@ export function detectFramework(cwd) {
         return { framework: null };
     }
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    // A CMS backend is never an adoptable frontend — Strapi 5 ships vite+react
+    // devDeps for its admin panel, which the bare-vite fallback would match
+    // (the sandbox/website monorepo suggested `fimo init apps/strapi`).
+    if (deps['@strapi/strapi']) {
+        return { framework: null };
+    }
     if (deps.next) {
         const appDir = ['app', 'src/app'].find((dir) => existsSync(join(cwd, dir)));
         const pagesDir = ['pages', 'src/pages'].find((dir) => existsSync(join(cwd, dir)));