fimo 0.8.0 → 0.9.0-experimental.1

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

@@ -0,0 +1,186 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+/**
+ * Detect a Strapi backend behind a wrapped frontend. Strapi is consumed via a
+ * hand-rolled fetch client against an env-var base URL (no SDK, no hardcoded
+ * URL), so the generic external-source scanner misses it entirely — detection
+ * keys on the distinctive local signals instead:
+ *   - a dependency whose name mentions strapi (`@repo/strapi-types`,
+ *     `@strapi/client`, generated types packages);
+ *   - a `strapi`-named client module under `src/lib`/`src`;
+ *   - Strapi's `api::x.y` content-type UID strings in the source;
+ *   - a `STRAPI`-flavored base-URL env var.
+ * The co-located Strapi app (monorepo) is located by walking up to the
+ * workspace root and finding the sibling that depends on `@strapi/strapi`; its
+ * path drives schema import. A decoupled Strapi (no co-located app) still
+ * surfaces as a source for the keep-live decision, with `appDir: null`.
+ */
+const UID_RE = /["'`]api::[a-z0-9-]+\.[a-z0-9-]+["'`]/;
+const STRAPI_ENV_RE = /STRAPI[A-Z0-9_]*_URL|NEXT_PUBLIC_STRAPI/;
+const SOURCE_EXT_RE = /\.(tsx?|jsx?|mjs|cjs)$/;
+const SKIP_DIRS = new Set(['node_modules', '.next', '.turbo', 'dist', 'build', '.git', 'coverage']);
+const MAX_FILES_SCANNED = 400;
+function safeReaddir(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+function readDeps(dir) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+        return { ...pkg.dependencies, ...pkg.devDependencies };
+    }
+    catch {
+        return {};
+    }
+}
+function strapiDependency(deps) {
+    for (const name of Object.keys(deps)) {
+        if (/strapi/i.test(name)) {
+            return name;
+        }
+    }
+    return null;
+}
+/** Shallow look for a `strapi`-named client module under src/lib or src. */
+function strapiLibModule(frontendDir) {
+    for (const base of [join(frontendDir, 'src', 'lib'), join(frontendDir, 'src'), join(frontendDir, 'lib')]) {
+        if (!existsSync(base)) {
+            continue;
+        }
+        try {
+            for (const entry of readdirSync(base, { withFileTypes: true })) {
+                if (/strapi/i.test(entry.name)) {
+                    return join(base, entry.name);
+                }
+            }
+        }
+        catch {
+            // unreadable dir — ignore
+        }
+    }
+    return null;
+}
+/** Bounded source scan for `api::x.y` UID strings or a STRAPI base-URL env. */
+function scanSourceSignals(frontendDir) {
+    const root = existsSync(join(frontendDir, 'src')) ? join(frontendDir, 'src') : frontendDir;
+    let scanned = 0;
+    let uid = false;
+    let env = false;
+    const walk = (dir) => {
+        if (scanned >= MAX_FILES_SCANNED || (uid && env)) {
+            return;
+        }
+        for (const entry of safeReaddir(dir)) {
+            if (scanned >= MAX_FILES_SCANNED || (uid && env)) {
+                return;
+            }
+            if (entry.isDirectory()) {
+                if (!SKIP_DIRS.has(entry.name) && !entry.name.startsWith('.')) {
+                    walk(join(dir, entry.name));
+                }
+                continue;
+            }
+            if (!SOURCE_EXT_RE.test(entry.name)) {
+                continue;
+            }
+            scanned += 1;
+            try {
+                const text = readFileSync(join(dir, entry.name), 'utf8');
+                if (!uid && UID_RE.test(text)) {
+                    uid = true;
+                }
+                if (!env && STRAPI_ENV_RE.test(text)) {
+                    env = true;
+                }
+            }
+            catch {
+                // unreadable file — ignore
+            }
+        }
+    };
+    walk(root);
+    return { uid, env };
+}
+function findWorkspaceRoot(startDir) {
+    let dir = startDir;
+    for (let depth = 0; depth < 6; depth += 1) {
+        if (existsSync(join(dir, 'pnpm-workspace.yaml')) ||
+            existsSync(join(dir, 'turbo.json')) ||
+            existsSync(join(dir, 'lerna.json'))) {
+            return dir;
+        }
+        const parent = dirname(dir);
+        if (parent === dir) {
+            break;
+        }
+        dir = parent;
+    }
+    return null;
+}
+/** Find the sibling app that depends on `@strapi/strapi` (the CMS app). */
+function findStrapiApp(frontendDir) {
+    const root = findWorkspaceRoot(frontendDir);
+    if (!root) {
+        return null;
+    }
+    const searchRoots = [join(root, 'apps'), root, join(root, 'packages')];
+    for (const searchRoot of searchRoots) {
+        if (!existsSync(searchRoot)) {
+            continue;
+        }
+        for (const entry of safeReaddir(searchRoot)) {
+            if (!entry.isDirectory() || SKIP_DIRS.has(entry.name)) {
+                continue;
+            }
+            const candidate = join(searchRoot, entry.name);
+            const deps = readDeps(candidate);
+            if (deps['@strapi/strapi'] && existsSync(join(candidate, 'src', 'api'))) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+export function detectStrapi(frontendDir) {
+    if (!existsSync(frontendDir) || !statSync(frontendDir).isDirectory()) {
+        return null;
+    }
+    const evidence = [];
+    const dep = strapiDependency(readDeps(frontendDir));
+    if (dep) {
+        evidence.push(`dependency ${dep}`);
+    }
+    const libModule = strapiLibModule(frontendDir);
+    if (libModule) {
+        evidence.push(`client module ${libModule.slice(frontendDir.length + 1)}`);
+    }
+    // Only pay for the source scan when the cheap signals are inconclusive.
+    if (evidence.length === 0) {
+        const signals = scanSourceSignals(frontendDir);
+        if (signals.uid) {
+            evidence.push('api::* content-type UIDs in source');
+        }
+        if (signals.env) {
+            evidence.push('STRAPI base-URL env var');
+        }
+    }
+    if (evidence.length === 0) {
+        return null;
+    }
+    const appDir = findStrapiApp(frontendDir);
+    if (appDir) {
+        evidence.push(`schemas in ${appDir.slice(findWorkspaceRoot(frontendDir).length + 1)}`);
+    }
+    return {
+        cms: 'Strapi',
+        host: 'Strapi',
+        appDir,
+        clientDir: libModule,
+        evidence,
+        locales: [],
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { CmsConnector } from '../types.js';
+/** Assemble the Strapi connector for a wrapped frontend, or null if no Strapi. */
+export declare function strapiConnector(frontendDir: string): CmsConnector | null;

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

@@ -0,0 +1,25 @@
+import { detectStrapi } from './detect.js';
+import { renderStrapiListSource } from './list-source.js';
+import { readStrapiSchemas } from './schema-map.js';
+import { detectStrapiTouchpoints } from './touchpoints.js';
+import { wireStrapiClient } from './wire-client.js';
+/** Assemble the Strapi connector for a wrapped frontend, or null if no Strapi. */
+export function strapiConnector(frontendDir) {
+    const detection = detectStrapi(frontendDir);
+    if (!detection) {
+        return null;
+    }
+    return {
+        detection,
+        readSchemas: () => (detection.appDir ? readStrapiSchemas(detection.appDir) : []),
+        renderListSource: (schemas, serverImport) => schemas.length > 0 ? renderStrapiListSource(schemas, serverImport) : null,
+        wireClient: (cwd, schemas) => detection.clientDir
+            ? wireStrapiClient(cwd, detection.clientDir, schemas)
+            : {
+                changes: [],
+                warnings: ['No Strapi client directory detected — wire fimoStrapiFetch manually.'],
+                wired: false,
+            },
+        detectTouchpoints: (cwd) => detectStrapiTouchpoints(cwd),
+    };
+}

package/dist/scripts/cms/strapi/list-source.d.ts

@@ -0,0 +1,17 @@
+import type { CmsCollectionSchema } from '../types.js';
+/**
+ * Emit a GENERIC Strapi-list read helper as source text. The scaffold pushes a
+ * CMS model + example content into Fimo; this helper lets a site's LIST views
+ * render that example content from Fimo (detail views + dynamic zones stay on
+ * the CMS). It is intentionally best-effort and site-neutral — the agent drops
+ * it in and wires the site's list fetchers to it (the non-deterministic last
+ * mile the machine can't own).
+ *
+ * The reshape is grounded in the Fimo runtime contract (`fetchEntries` →
+ * `{ id, data }`, media fields `{ url, ... }`, richtext fields a ProseMirror
+ * doc): richtext docs are flattened to plain text (so list helpers like a
+ * read-time estimate that expect a string don't choke), media and scalars pass
+ * through, and an empty Fimo result returns null so the caller falls back to
+ * the live CMS.
+ */
+export declare function renderStrapiListSource(schemas: CmsCollectionSchema[], serverImport: string): string;

package/dist/scripts/cms/strapi/list-source.js

@@ -0,0 +1,90 @@
+/**
+ * Emit a GENERIC Strapi-list read helper as source text. The scaffold pushes a
+ * CMS model + example content into Fimo; this helper lets a site's LIST views
+ * render that example content from Fimo (detail views + dynamic zones stay on
+ * the CMS). It is intentionally best-effort and site-neutral — the agent drops
+ * it in and wires the site's list fetchers to it (the non-deterministic last
+ * mile the machine can't own).
+ *
+ * The reshape is grounded in the Fimo runtime contract (`fetchEntries` →
+ * `{ id, data }`, media fields `{ url, ... }`, richtext fields a ProseMirror
+ * doc): richtext docs are flattened to plain text (so list helpers like a
+ * read-time estimate that expect a string don't choke), media and scalars pass
+ * through, and an empty Fimo result returns null so the caller falls back to
+ * the live CMS.
+ */
+export function renderStrapiListSource(schemas, serverImport) {
+    const entries = schemas
+        .filter((schema) => !schema.isSingleton)
+        .map((schema) => `  '${schema.sourceUid}': '${schema.name}',`)
+        .join('\n');
+    return `// AUTO-GENERATED by \`fimo migrate --scaffold-cms\`. Renders the CMS collections
+// scaffolded into Fimo (EXAMPLE content) for LIST views, so pages show the fake
+// content from Fimo while detail views and dynamic zones stay on your CMS.
+//
+// Wire your CMS client's list methods to this (see the migration prompt), e.g.
+// inside fetchMany/fetchAll:  const fimo = await fimoCmsList(uid, { limit });
+//                             if (fimo) return fimo;
+// Best-effort and generic by design — adjust per component as needed.
+import { fetchEntries } from '${serverImport}';
+
+// Strapi content-type UID -> Fimo type name (from the scaffold).
+const FIMO_TYPES: Record<string, string> = {
+${entries}
+};
+
+function docToText(node: unknown): string {
+  if (!node || typeof node !== 'object') {
+    return '';
+  }
+  const record = node as { text?: unknown; content?: unknown };
+  if (typeof record.text === 'string') {
+    return record.text;
+  }
+  if (Array.isArray(record.content)) {
+    return record.content.map(docToText).join(' ');
+  }
+  return '';
+}
+
+function reshapeValue(value: unknown): unknown {
+  // Richtext is a ProseMirror doc -> flatten to plain text so string consumers
+  // (excerpts, read-time) are safe. Media { url, ... } and scalars pass through.
+  if (value && typeof value === 'object' && (value as { type?: unknown }).type === 'doc') {
+    return docToText(value);
+  }
+  return value;
+}
+
+function reshape(data: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(data)) {
+    out[key] = reshapeValue(value);
+  }
+  return out;
+}
+
+/**
+ * A Strapi-v5-shaped list envelope built from the scaffolded Fimo content, or
+ * null when nothing was scaffolded for this UID (fall back to the live CMS).
+ */
+export async function fimoCmsList(
+  uid: string,
+  options: { limit?: number } = {}
+): Promise<{ data: Record<string, unknown>[]; meta: { pagination: Record<string, number> } } | null> {
+  const typeName = FIMO_TYPES[uid];
+  if (!typeName) {
+    return null;
+  }
+  const entries = await fetchEntries(typeName, options.limit ? { limit: options.limit } : {});
+  if (entries.length === 0) {
+    return null;
+  }
+  const data = entries.map((entry) => ({ id: entry.id, documentId: entry.id, ...reshape(entry.data) }));
+  return {
+    data,
+    meta: { pagination: { page: 1, pageSize: data.length, pageCount: 1, total: data.length } },
+  };
+}
+`;
+}

package/dist/scripts/cms/strapi/schema-map.d.ts

@@ -0,0 +1,9 @@
+import type { CmsCollectionSchema } from '../types.js';
+/** `blog-post` / `blog_posts` / `Blog Post` → `BlogPost`. */
+export declare function pascalCase(name: string): string;
+/**
+ * Read every local Strapi content-type schema into the Fimo schema shape.
+ * Two passes: first name every type (so relation targets resolve to Fimo
+ * names), then map fields (resolving components into editable blocks).
+ */
+export declare function readStrapiSchemas(strapiAppDir: string): CmsCollectionSchema[];

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

@@ -0,0 +1,277 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Strapi content-type schema → Fimo schema mapping. Strapi keeps every content
+ * type as `apps/strapi/src/api/<api>/content-types/<ct>/schema.json` and every
+ * component as `apps/strapi/src/components/<category>/<name>.json` — local,
+ * declarative sources of truth — so the Fimo schemas can be derived without ever
+ * contacting the CMS. All Strapi specifics live here (and in `detect.ts`).
+ *
+ * Structural content maps to Fimo **blocks** (Studio-editable ordered content):
+ * a dynamic zone → a `oneOf` union of one variant per allowed component; a
+ * single or repeatable component → a fixed `{ fields }` block. Each dynamic-zone
+ * variant carries the original Strapi component id as a hidden, defaulted
+ * `__component` field, so the served block is losslessly reversible to the
+ * frontend's `block.__component` shape without a runtime lookup.
+ */
+// Mirrors MAX_BLOCK_VARIANTS in @fimo/api-contracts — a `oneOf` beyond this
+// fails schema validation, so we cap and report rather than push an invalid set.
+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;
+// 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']);
+const COMPONENT_DISCRIMINATOR = '__component';
+const TO_MANY = new Set(['oneToMany', 'manyToMany']);
+/** `blog-post` / `blog_posts` / `Blog Post` → `BlogPost`. */
+export function pascalCase(name) {
+    return name
+        .replace(/[^a-zA-Z0-9]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+        .replace(/^(.)/, (c) => c.toUpperCase());
+}
+/** Strapi component uid (`sections.hero`) → a valid Fimo block variant uid
+ *  (`SectionsHero`, matching `CONTENT_TYPE_NAME_PATTERN` /^[A-Za-z]\w*$/). */
+function variantUid(componentUid) {
+    const pascal = pascalCase(componentUid);
+    return /^[A-Za-z]/.test(pascal) ? pascal : `Block${pascal}`;
+}
+/**
+ * Map one Strapi attribute to a Fimo field. Returns `null` for fields Fimo does
+ * not model as content (the slug uid, passwords). Relations to imported types
+ * become references; components and dynamic zones become blocks; relations to
+ * non-imported targets (users, plugins) fall back to `json`.
+ */
+function mapAttribute(field, attr, ctx) {
+    if (field === 'slug') {
+        // Fimo reserves `slug` as entry metadata (set inside the row data).
+        return null;
+    }
+    switch (attr.type) {
+        case 'password':
+            return null;
+        case 'string':
+        case 'text':
+        case 'email':
+        case 'uid':
+        case 'enumeration':
+            return { type: 'string' };
+        case 'richtext':
+        case 'blocks':
+            return { type: 'richtext' };
+        case 'integer':
+        case 'biginteger':
+        case 'decimal':
+        case 'float':
+            return { type: 'number' };
+        case 'boolean':
+            return { type: 'boolean' };
+        case 'date':
+        case 'datetime':
+        case 'time':
+        case 'timestamp':
+            return { type: 'date' };
+        case 'media':
+            return { type: 'media' };
+        case 'component':
+            return mapComponentAttribute(attr, ctx);
+        case 'dynamiczone':
+            return mapDynamicZone(attr, ctx);
+        case 'json':
+            return { type: 'json' };
+        case 'relation': {
+            const targetName = attr.target ? ctx.uidToName.get(attr.target) : undefined;
+            if (!targetName) {
+                // Relation to a non-imported target (users-permissions, other plugins).
+                return { type: 'json' };
+            }
+            const many = attr.relation ? TO_MANY.has(attr.relation) : false;
+            return many ? { type: 'reference', target: targetName, many: true } : { type: 'reference', target: targetName };
+        }
+        default:
+            // Unknown/custom attribute — never crash; keep the value verbatim.
+            return { type: 'json' };
+    }
+}
+/** Recursively map a component's attributes to a Fimo block-fields record.
+ *  Returns null on a missing component, a cycle, or past the depth cap. */
+function componentFields(componentUid, ctx) {
+    if (!componentUid || ctx.depth > MAX_COMPONENT_DEPTH || ctx.visiting.has(componentUid)) {
+        return null;
+    }
+    const component = ctx.components.get(componentUid);
+    if (!component) {
+        return null;
+    }
+    const childCtx = {
+        ...ctx,
+        depth: ctx.depth + 1,
+        visiting: new Set(ctx.visiting).add(componentUid),
+    };
+    const fields = {};
+    for (const [name, attr] of Object.entries(component.attributes ?? {})) {
+        if (!FIELD_NAME_PATTERN.test(name) || RESERVED_BLOCK_FIELD_NAMES.has(name) || name === COMPONENT_DISCRIMINATOR) {
+            continue;
+        }
+        const mapped = mapAttribute(name, attr, childCtx);
+        if (mapped) {
+            fields[name] = mapped;
+        }
+    }
+    return fields;
+}
+/** A single/repeatable Strapi component → a fixed `{ fields }` blocks field.
+ *  Single (non-repeatable) is capped to one item; repeatable is unbounded. A
+ *  component that can't resolve (missing/cyclic/too deep) falls back to json. */
+function mapComponentAttribute(attr, ctx) {
+    const fields = componentFields(attr.component, ctx);
+    if (!fields) {
+        return { type: 'json' };
+    }
+    const schema = { fields };
+    return attr.repeatable ? { type: 'blocks', schema } : { type: 'blocks', schema, max: 1 };
+}
+/** A Strapi dynamic zone → a `oneOf` blocks field, one variant per allowed
+ *  component. Each variant bakes a hidden, defaulted `__component` so the stored
+ *  block reverses losslessly to the frontend's `block.__component` shape. */
+function mapDynamicZone(attr, ctx) {
+    const componentUids = attr.components ?? [];
+    if (componentUids.length > MAX_BLOCK_VARIANTS) {
+        console.warn(`[migration] dynamic zone has ${componentUids.length} components; Fimo blocks allow at most ` +
+            `${MAX_BLOCK_VARIANTS} variants — mapping the first ${MAX_BLOCK_VARIANTS}, dropping ` +
+            `${componentUids.length - MAX_BLOCK_VARIANTS}.`);
+    }
+    const seenUids = new Set();
+    const variants = [];
+    for (const componentUid of componentUids.slice(0, MAX_BLOCK_VARIANTS)) {
+        const fields = componentFields(componentUid, ctx);
+        if (!fields) {
+            continue;
+        }
+        // Dedupe pascalCase collisions (`a.hero` + `a_hero` → `AHero`); the baked
+        // `__component` still carries each variant's true source id.
+        let uid = variantUid(componentUid);
+        for (let n = 2; seenUids.has(uid); n += 1) {
+            uid = `${variantUid(componentUid)}${n}`;
+        }
+        seenUids.add(uid);
+        const component = ctx.components.get(componentUid);
+        variants.push({
+            uid,
+            label: component?.info?.displayName ?? uid,
+            fields: {
+                [COMPONENT_DISCRIMINATOR]: { type: 'string', default: componentUid, editable: false },
+                ...fields,
+            },
+        });
+    }
+    if (variants.length === 0) {
+        return { type: 'json' };
+    }
+    return { type: 'blocks', schema: { oneOf: variants } };
+}
+function mapSchema(raw, uidToName, components) {
+    const info = raw.schema.info ?? {};
+    const name = uidToName.get(raw.uid);
+    const fields = {};
+    const ctx = { uidToName, components, visiting: new Set(), depth: 0 };
+    for (const [field, attr] of Object.entries(raw.schema.attributes ?? {})) {
+        const mapped = mapAttribute(field, attr, ctx);
+        if (mapped) {
+            fields[field] = mapped;
+        }
+    }
+    return {
+        name,
+        label: info.displayName || name,
+        isSingleton: raw.schema.kind === 'singleType',
+        localized: raw.schema.pluginOptions?.i18n?.localized === true,
+        fields,
+        sourceUid: raw.uid,
+        sourcePath: `/${info.pluralName ?? raw.contentTypeName}`,
+    };
+}
+/** Walk `<strapiAppDir>/src/api/<api>/content-types/<ct>/schema.json`. */
+function collectRawSchemas(strapiAppDir) {
+    const apiDir = join(strapiAppDir, 'src', 'api');
+    if (!existsSync(apiDir)) {
+        return [];
+    }
+    const raws = [];
+    for (const apiEntry of readdirSync(apiDir, { withFileTypes: true })) {
+        if (!apiEntry.isDirectory()) {
+            continue;
+        }
+        const ctRoot = join(apiDir, apiEntry.name, 'content-types');
+        if (!existsSync(ctRoot)) {
+            continue;
+        }
+        for (const ctEntry of readdirSync(ctRoot, { withFileTypes: true })) {
+            if (!ctEntry.isDirectory()) {
+                continue;
+            }
+            const schemaPath = join(ctRoot, ctEntry.name, 'schema.json');
+            if (!existsSync(schemaPath)) {
+                continue;
+            }
+            try {
+                const schema = JSON.parse(readFileSync(schemaPath, 'utf8'));
+                raws.push({
+                    uid: `api::${apiEntry.name}.${ctEntry.name}`,
+                    apiName: apiEntry.name,
+                    contentTypeName: ctEntry.name,
+                    schema,
+                });
+            }
+            catch {
+                // Malformed schema.json — skip, never abort the whole import.
+            }
+        }
+    }
+    return raws;
+}
+/** Walk `<strapiAppDir>/src/components/<category>/<name>.json` into a uid→schema
+ *  map. Strapi component uids are `<category>.<name>` (the dir + filename). */
+function collectComponents(strapiAppDir) {
+    const components = new Map();
+    const componentsDir = join(strapiAppDir, 'src', 'components');
+    if (!existsSync(componentsDir)) {
+        return components;
+    }
+    for (const categoryEntry of readdirSync(componentsDir, { withFileTypes: true })) {
+        if (!categoryEntry.isDirectory()) {
+            continue;
+        }
+        const categoryDir = join(componentsDir, categoryEntry.name);
+        for (const fileEntry of readdirSync(categoryDir, { withFileTypes: true })) {
+            if (!fileEntry.isFile() || !fileEntry.name.endsWith('.json')) {
+                continue;
+            }
+            const uid = `${categoryEntry.name}.${fileEntry.name.slice(0, -'.json'.length)}`;
+            try {
+                const parsed = JSON.parse(readFileSync(join(categoryDir, fileEntry.name), 'utf8'));
+                components.set(uid, { ...parsed, uid });
+            }
+            catch {
+                // Malformed component json — skip, never abort the whole import.
+            }
+        }
+    }
+    return components;
+}
+/**
+ * Read every local Strapi content-type schema into the Fimo schema shape.
+ * Two passes: first name every type (so relation targets resolve to Fimo
+ * names), then map fields (resolving components into editable blocks).
+ */
+export function readStrapiSchemas(strapiAppDir) {
+    const raws = collectRawSchemas(strapiAppDir);
+    const components = collectComponents(strapiAppDir);
+    const uidToName = new Map();
+    for (const raw of raws) {
+        const singular = raw.schema.info?.singularName ?? raw.contentTypeName;
+        uidToName.set(raw.uid, pascalCase(singular));
+    }
+    return raws.map((raw) => mapSchema(raw, uidToName, components)).sort((a, b) => a.name.localeCompare(b.name));
+}

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

@@ -0,0 +1,23 @@
+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.
+ *
+ * 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';
+    fields?: FieldShapes;
+    variants?: Record<string, FieldShapes>;
+}
+export type FieldShapes = Record<string, BlockFieldShape>;
+/** Per-type structural manifest, keyed by Fimo type name. Types with no blocks
+ *  fields are omitted (the reshape falls back to pure value-inspection). */
+export declare function computeFieldShapes(schemas: CmsCollectionSchema[]): Record<string, FieldShapes>;

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

@@ -0,0 +1,38 @@
+function shapesFrom(fields) {
+    const shapes = {};
+    for (const [name, def] of Object.entries(fields)) {
+        if (def.type !== 'blocks') {
+            continue; // leaves are value-inspected by the runtime reshape
+        }
+        if ('oneOf' in def.schema) {
+            const variants = {};
+            for (const variant of def.schema.oneOf) {
+                const nested = shapesFrom(variant.fields);
+                if (Object.keys(nested).length > 0) {
+                    variants[variant.uid] = nested;
+                }
+            }
+            shapes[name] = { kind: 'list', ...(Object.keys(variants).length > 0 ? { variants } : {}) };
+        }
+        else {
+            const nested = shapesFrom(def.schema.fields);
+            shapes[name] = {
+                kind: def.max === 1 ? 'single' : 'list',
+                ...(Object.keys(nested).length > 0 ? { fields: nested } : {}),
+            };
+        }
+    }
+    return shapes;
+}
+/** Per-type structural manifest, keyed by Fimo type name. Types with no blocks
+ *  fields are omitted (the reshape falls back to pure value-inspection). */
+export function computeFieldShapes(schemas) {
+    const byType = {};
+    for (const schema of schemas) {
+        const shapes = shapesFrom(schema.fields);
+        if (Object.keys(shapes).length > 0) {
+            byType[schema.name] = shapes;
+        }
+    }
+    return byType;
+}