fimo 0.9.0-experimental.4 → 0.9.0-experimental.6

package/dist/runtime/core/BuiltWithBadge.d.ts

@@ -0,0 +1,2 @@
+export declare function BuiltWithBadge(): import("react").ReactPortal | null;
+//# sourceMappingURL=BuiltWithBadge.d.ts.map

package/dist/runtime/core/BuiltWithBadge.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { createPortal } from 'react-dom';
+const STORAGE_KEY = 'fimoBadgeDismissed';
+export function BuiltWithBadge() {
+    const hideFimoBadge = __FIMO_HIDE_BADGE__;
+    const [visible, setVisible] = useState(false);
+    useEffect(() => {
+        try {
+            const dismissed = sessionStorage.getItem(STORAGE_KEY) === 'true';
+            setVisible(!dismissed);
+        }
+        catch {
+            setVisible(true);
+        }
+    }, []);
+    if (hideFimoBadge) {
+        return null;
+    } // hide fimo badge config
+    // @ts-ignore
+    if (!import.meta.env.PROD) {
+        return null;
+    } // only show in prod
+    if (!visible) {
+        return null;
+    }
+    if (typeof document === 'undefined') {
+        return null;
+    }
+    return createPortal(_jsx("div", { style: {
+            position: 'fixed',
+            right: '16px',
+            bottom: '16px',
+            zIndex: 100000,
+            margin: 0,
+        }, children: _jsxs("div", { style: {
+                display: 'flex',
+                alignItems: 'center',
+                gap: '8px',
+                borderRadius: '9999px',
+                color: '#fff',
+                boxShadow: '0 12px 30px rgba(0, 0, 0, 0.35)',
+                padding: '8px 12px',
+                fontSize: '12px',
+                lineHeight: 1.2,
+                backgroundColor: 'rgba(0, 0, 0, 0.9)',
+                fontFamily: 'ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, Helvetica, Arial, sans-serif',
+            }, children: [_jsxs("a", { href: "https://fimo.ai", target: "_blank", rel: "noopener noreferrer", style: {
+                        display: 'inline-flex',
+                        alignItems: 'center',
+                        gap: '8px',
+                        color: '#fff',
+                        textDecoration: 'none',
+                    }, children: [_jsx("svg", { xmlns: "http://www.w3.org/2000/svg", width: "18", height: "18", viewBox: "0 0 24 12", fill: "none", children: _jsx("path", { d: "M22.8569 4.85715H14.9866L15.9132 3.58186C16.5027 2.77062 17.4534 2.28627 18.4561 2.28627H22.8569C23.4882 2.28627 23.9999 1.7745 23.9999 1.14328C23.9999 0.512061 23.4884 0 22.8569 0H18.4561C16.7239 0 15.082 0.836671 14.0639 2.23798L12.1611 4.85715H6.9979C5.2657 4.85715 3.62379 5.69382 2.60567 7.09513L0.360255 10.1852C-0.0109321 10.6958 0.10251 11.4108 0.613142 11.7817C0.816023 11.9291 1.05119 12 1.28408 12C1.63755 12 1.98616 11.8366 2.20962 11.5288L4.45474 8.43872C5.04424 7.62748 5.99493 7.14314 6.99762 7.14314H10.5L8.28977 10.1852C7.91858 10.6958 8.03203 11.4108 8.54266 11.7817C8.74554 11.9291 8.98071 12 9.2136 12C9.56707 12 9.91568 11.8366 10.1391 11.5288L12.3843 8.43872C12.9738 7.62748 13.9244 7.14314 14.9271 7.14314H22.8566C23.4879 7.14314 23.9996 6.63136 23.9996 6.00014C23.9996 5.36893 23.4879 4.85715 22.8566 4.85715H22.8569Z", fill: "white" }) }), _jsx("span", { style: { fontWeight: 600 }, children: "Built with Fimo" })] }), _jsx("button", { "aria-label": "Dismiss badge", style: {
+                        color: '#ddd',
+                        background: 'transparent',
+                        cursor: 'pointer',
+                        border: 'none',
+                        padding: 0,
+                        lineHeight: 0,
+                    }, onClick: () => {
+                        try {
+                            sessionStorage.setItem(STORAGE_KEY, 'true');
+                        }
+                        catch { }
+                        setVisible(false);
+                    }, type: "button", children: _jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: 14, height: 14, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: 2, strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": true, children: [_jsx("path", { d: "M18 6 6 18" }), _jsx("path", { d: "m6 6 12 12" })] }) })] }) }), document.body);
+}

package/dist/runtime/seo/neutral.d.ts

@@ -0,0 +1,22 @@
+import type { FimoSEO } from '../shared/fimo-config.types.js';
+/**
+ * The framework-neutral `fimo/seo` surface: pure per-page SEO resolution over
+ * the page registry (`fimo-config.json#routes`), with no framework adapter,
+ * no vite virtual module, and no React. Every framework's injection recipe
+ * (Next `generateMetadata`, an Astro head component, a SvelteKit load) calls
+ * `getFimoSeoForPath` server-side and maps the result to its own head API.
+ * SEO stays wired only when the project owner explicitly opted into
+ * Fimo-managed SEO — the migration never wires it by default.
+ */
+export { resolveSeoForPath } from './resolver.js';
+export type { FimoSEO, RouteSEO } from '../shared/fimo-config.types.js';
+export interface GetFimoSeoOptions {
+    /** Project root holding fimo-config.json (default: process.cwd()). */
+    rootDir?: string;
+    /** Instance data for `{{variable}}` templates in route-level SEO (e.g. the
+     *  entry rendered by a dynamic page: `{ "blog-post": entry }`). */
+    routeData?: Record<string, unknown>;
+}
+/** Resolve the SEO values for one page path from the page registry on disk. */
+export declare function getFimoSeoForPath(pathname: string, options?: GetFimoSeoOptions): FimoSEO | undefined;
+//# sourceMappingURL=neutral.d.ts.map

package/dist/runtime/seo/neutral.js

@@ -0,0 +1,17 @@
+import { getConfigServer } from '../shared/fimo-config.server.js';
+import { resolveSeoForPath } from './resolver.js';
+/**
+ * The framework-neutral `fimo/seo` surface: pure per-page SEO resolution over
+ * the page registry (`fimo-config.json#routes`), with no framework adapter,
+ * no vite virtual module, and no React. Every framework's injection recipe
+ * (Next `generateMetadata`, an Astro head component, a SvelteKit load) calls
+ * `getFimoSeoForPath` server-side and maps the result to its own head API.
+ * SEO stays wired only when the project owner explicitly opted into
+ * Fimo-managed SEO — the migration never wires it by default.
+ */
+export { resolveSeoForPath } from './resolver.js';
+/** Resolve the SEO values for one page path from the page registry on disk. */
+export function getFimoSeoForPath(pathname, options = {}) {
+    const config = getConfigServer(options.rootDir ?? process.cwd());
+    return resolveSeoForPath(pathname, config, options.routeData);
+}

package/dist/runtime/strapi/client.js

@@ -57,15 +57,40 @@ export function parseStrapiUrl(rawUrl, apiPrefix = '/api') {
         where: Object.keys(where).length > 0 ? where : undefined,
     };
 }
+const isDev = () => typeof process !== 'undefined' && process.env != null && process.env.NODE_ENV !== 'production';
 /** Build a `fetch`-compatible function that serves scaffolded content from Fimo. */
 export function createFimoStrapiFetch(options, realFetch = fetch) {
     const singletons = new Set(options.singletons ?? []);
     const read = { apiUrl: options.apiUrl, rootDir: options.rootDir };
+    // Lowercased type-name index, used only to flag a *near-miss* fallthrough: a
+    // path segment that looks like a scaffolded type but doesn't match a TYPES key
+    // (the classic singular-vs-plural keying bug). Genuinely foreign paths
+    // (`/api/upload/files`) don't match and stay silent.
+    const typeNamesLower = new Set(Object.values(options.types).map((name) => name.toLowerCase()));
+    const warnedPaths = new Set();
+    const warnNearMiss = (segment) => {
+        if (!isDev() || warnedPaths.has(segment)) {
+            return;
+        }
+        const seg = segment.toLowerCase();
+        const nearMiss = typeNamesLower.has(seg) ||
+            typeNamesLower.has(seg.replace(/s$/, '')) ||
+            typeNamesLower.has(seg.replace(/ies$/, 'y'));
+        if (nearMiss) {
+            warnedPaths.add(segment);
+            console.warn(`[fimo/strapi] /api/${segment} looks like a scaffolded type but is not in the type map — ` +
+                `this read fell through to the live CMS. If a single type reads empty, its map key is likely ` +
+                `plural where the fetch is singular (regenerate with \`fimo migrate --scaffold-cms\`).`);
+        }
+    };
     return (async (input, init) => {
         const rawUrl = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
         const parsed = parseStrapiUrl(rawUrl ?? '', options.apiPrefix);
         const typeName = parsed ? options.types[parsed.pluralName] : undefined;
         if (!parsed || !typeName) {
+            if (parsed) {
+                warnNearMiss(parsed.pluralName);
+            }
             return realFetch(input, init); // not a mapped content read → real CMS
         }
         const entries = await fetchEntries(typeName, {
@@ -73,11 +98,29 @@ export function createFimoStrapiFetch(options, realFetch = fetch) {
             ...(parsed.where ? { where: parsed.where } : {}),
             ...(parsed.pageSize ? { limit: parsed.pageSize } : {}),
         });
+        const shapes = options.fieldShapes?.[typeName];
+        const single = Boolean(parsed.documentId) || singletons.has(typeName);
         if (entries.length === 0) {
+            // A FILTERED miss on a type Fimo owns (it has entries) answers with the
+            // honest empty envelope — the document just doesn't exist. Falling
+            // through here would leak every unknown-slug read (404s included) to the
+            // old CMS: dead-CMS timeouts, and content resurrection when it's alive.
+            if (parsed.where || parsed.documentId) {
+                const any = await fetchEntries(typeName, { ...read, limit: 1 });
+                if (any.length > 0) {
+                    // Canonical Strapi shapes: collection miss → 200 `{data: []}`,
+                    // document miss → 404 with the Strapi error body.
+                    const empty = single
+                        ? { data: null, error: { status: 404, name: 'NotFoundError', message: 'Not Found', details: {} } }
+                        : fimoEntriesToStrapiList([], { pageSize: parsed.pageSize, total: 0, shapes });
+                    return new Response(JSON.stringify(empty), {
+                        status: single ? 404 : 200,
+                        headers: { 'content-type': 'application/json' },
+                    });
+                }
+            }
             return realFetch(input, init); // nothing scaffolded → fall back to the CMS
         }
-        const shapes = options.fieldShapes?.[typeName];
-        const single = Boolean(parsed.documentId) || singletons.has(typeName);
         const payload = single
             ? fimoEntryToStrapiSingle(parsed.documentId ? (entries.find((e) => e.id === parsed.documentId) ?? entries[0]) : entries[0], shapes)
             : fimoEntriesToStrapiList(entries, { pageSize: parsed.pageSize, total: entries.length, shapes });

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

@@ -100,7 +100,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

@@ -57,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' };
@@ -184,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/frameworks/next/rewire.d.ts

@@ -17,11 +17,24 @@ import type { WrapScanResult } from '../../scan-wrappable.js';
  * Uids are the PROVISIONAL draft names; `schemas adopt-drafts` rewrites the
  * call sites through its renames.
  */
+export interface RewiredPage {
+    file: string;
+    /** Collection uid the page reads through `wrapCollection` (provisional until
+     *  `adopt-drafts` renames it). */
+    uid: string;
+    /** The page's registry route path (`:param` normalized), null when the file
+     *  sits in a non-routable location. Joins the page back to the page registry
+     *  as binding evidence. */
+    routePath: string | null;
+}
 export interface CollectionRewireResult {
     changes: string[];
     warnings: string[];
     /** Pages successfully rewired. */
     rewired: number;
+    /** Every page known to read a collection through `wrapCollection` — rewired
+     *  this run or found already wired on a re-run. */
+    pages: RewiredPage[];
 }
 export declare function rewireNextCollectionPages(cwd: string, detection: Pick<FrameworkDetection, 'appDir'>, scan: WrapScanResult, drafts: Array<{
     uid: string;

package/dist/scripts/frameworks/next/rewire.js

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { parseSync } from 'oxc-parser';
 import { ensureFimoImport } from '../../apply-wrap.js';
+import { routePathForAppPage } from './routes.js';
 function applyEdits(code, edits) {
     let next = code;
     for (const edit of [...edits].sort((a, b) => b.start - a.start)) {
@@ -85,9 +86,10 @@ function pageFilesUnder(dir) {
 export function rewireNextCollectionPages(cwd, detection, scan, drafts) {
     const changes = [];
     const warnings = [];
+    const pages = [];
     let rewired = 0;
     if (!detection.appDir) {
-        return { changes, warnings: ['Collection pages not rewired: pages-router project.'], rewired };
+        return { changes, warnings: ['Collection pages not rewired: pages-router project.'], rewired, pages };
     }
     const appDirAbs = path.join(cwd, detection.appDir);
     const uidBySourceName = new Map(drafts.map((draft) => [draft.sourceName, draft.uid]));
@@ -100,6 +102,24 @@ export function rewireNextCollectionPages(cwd, detection, scan, drafts) {
     const bail = (page, reason) => {
         warnings.push(`Page not rewired (${page}): ${reason} — wire it with wrapCollection per the prompt recipe.`);
     };
+    const recordPage = (fileAbs, uid) => {
+        pages.push({ file: path.relative(cwd, fileAbs), uid, routePath: routePathForAppPage(appDirAbs, fileAbs) });
+    };
+    // Pages wired on a PREVIOUS run still carry binding evidence (the uid in the
+    // call site is final once `adopt-drafts` renamed it) — collect them before
+    // rewiring so re-runs keep feeding the page registry.
+    for (const pageAbs of pageFilesUnder(appDirAbs)) {
+        let code;
+        try {
+            code = fs.readFileSync(pageAbs, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        for (const match of code.matchAll(/wrapCollection\(\s*['"]([^'"]+)['"]/g)) {
+            recordPage(pageAbs, match[1]);
+        }
+    }
     // ── In-code array literals: extract to src/data/<name>.json + wire ──
     for (const candidate of scan.collections) {
         const pageAbs = path.join(cwd, candidate.file);
@@ -173,6 +193,7 @@ export function rewireNextCollectionPages(cwd, detection, scan, drafts) {
         next = ensureFimoImport(next, ['wrapCollection'], 'fimo/next/server');
         fs.writeFileSync(pageAbs, next);
         rewired += 1;
+        recordPage(pageAbs, uid);
         changes.push(`rewired ${candidate.file}: \`${candidate.name}\` extracted to src/data/${candidate.name}.json and read through wrapCollection('${uid}')`);
     }
     // ── Data-file default imports: wire the importing pages ──
@@ -251,8 +272,11 @@ export function rewireNextCollectionPages(cwd, detection, scan, drafts) {
             next = ensureFimoImport(next, ['wrapCollection'], 'fimo/next/server');
             fs.writeFileSync(pageAbs, next);
             rewired += 1;
+            for (const target of targets) {
+                recordPage(pageAbs, target.uid);
+            }
             changes.push(`rewired ${rel}: ${targets.map((target) => `wrapCollection('${target.uid}')`).join(', ')} over the imported source rows`);
         }
     }
-    return { changes, warnings, rewired };
+    return { changes, warnings, rewired, pages };
 }

package/dist/scripts/frameworks/next/routes.d.ts

@@ -3,6 +3,12 @@ export interface DiscoveredRoute {
     path: string;
     label: string;
 }
+/**
+ * Route path for ONE app-router page file, using the same segment
+ * normalization as discovery — so a rewired page can be joined back to its
+ * registry route. Returns null for non-routable locations (`@slot`, `_lib`).
+ */
+export declare function routePathForAppPage(appDir: string, pageFile: string): string | null;
 /**
  * Discover page routes of a Next.js app-router directory (`app/` or
  * `src/app/`). Returns display routes for `fimo-config.json#routes` so the

package/dist/scripts/frameworks/next/routes.js

@@ -1,5 +1,5 @@
 import { readdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, relative, sep } from 'node:path';
 const PAGE_FILES = new Set(['page.tsx', 'page.jsx', 'page.ts', 'page.js', 'page.mdx']);
 const titleCase = (seg) => seg
     .replace(/[_\-]+/g, ' ')
@@ -27,6 +27,29 @@ function segmentToPath(segment) {
     }
     return segment;
 }
+/**
+ * Route path for ONE app-router page file, using the same segment
+ * normalization as discovery — so a rewired page can be joined back to its
+ * registry route. Returns null for non-routable locations (`@slot`, `_lib`).
+ */
+export function routePathForAppPage(appDir, pageFile) {
+    const rel = relative(appDir, pageFile);
+    if (rel.startsWith('..')) {
+        return null;
+    }
+    const segments = rel.split(sep).slice(0, -1);
+    const parts = [];
+    for (const segment of segments) {
+        const mapped = segmentToPath(segment);
+        if (mapped === null) {
+            return null;
+        }
+        if (mapped.length > 0) {
+            parts.push(mapped);
+        }
+    }
+    return `/${parts.join('/')}`.replace(/\/+/g, '/');
+}
 /**
  * Discover page routes of a Next.js app-router directory (`app/` or
  * `src/app/`). Returns display routes for `fimo-config.json#routes` so the

package/dist/scripts/inject-translations.d.ts

@@ -0,0 +1,6 @@
+export interface InjectTranslationsResult {
+    updated: number;
+}
+export declare function injectTranslations(options?: {
+    cwd?: string;
+}): InjectTranslationsResult;

package/dist/scripts/inject-translations.js

@@ -0,0 +1,168 @@
+/**
+ * Inject translation values from translations/en.json back into code.
+ *
+ * Reads `translations/en.json` (treated as authoritative input — typically
+ * written by the backend after a dashboard editor edits an English string)
+ * and rewrites the second argument of every matching `t('key', 'default')`
+ * call in `src/` to match. Idempotent.
+ *
+ * Exposed as `fimo scripts inject-translations` (hidden namespace). The
+ * backend's bidirectional-sync flow will eventually invoke this command in
+ * the sandbox instead of the legacy `node .fimo/i18n/scripts/...` path.
+ */
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseSync } from 'oxc-parser';
+function findReactFiles(dir, files = []) {
+    if (!existsSync(dir)) {
+        return files;
+    }
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+        const fullPath = join(dir, entry);
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+            if (entry === 'ui' || entry === 'node_modules') {
+                continue;
+            }
+            findReactFiles(fullPath, files);
+        }
+        else if (/\.(ts|tsx|js|jsx)$/.test(entry)) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function findTCalls(filePath, code) {
+    const locations = [];
+    try {
+        const result = parseSync(filePath, code);
+        const ast = result.program;
+        function visit(node) {
+            if (!node || typeof node !== 'object') {
+                return;
+            }
+            if (node.type === 'CallExpression') {
+                const callee = node.callee;
+                if (callee?.type === 'Identifier' && callee?.name === 't') {
+                    const args = node.arguments || [];
+                    const firstArg = args[0];
+                    if (firstArg?.type === 'Literal' && typeof firstArg.value === 'string') {
+                        const key = firstArg.value;
+                        const secondArg = args[1];
+                        if (secondArg?.type === 'Literal' && typeof secondArg.value === 'string') {
+                            locations.push({
+                                file: filePath,
+                                key,
+                                currentDefault: secondArg.value,
+                                secondArgStart: secondArg.start,
+                                secondArgEnd: secondArg.end,
+                                hasSecondArg: true,
+                                firstArgEnd: firstArg.end,
+                            });
+                        }
+                        else if (!secondArg) {
+                            locations.push({
+                                file: filePath,
+                                key,
+                                currentDefault: '',
+                                secondArgStart: 0,
+                                secondArgEnd: 0,
+                                hasSecondArg: false,
+                                firstArgEnd: firstArg.end,
+                            });
+                        }
+                    }
+                }
+            }
+            for (const k of Object.keys(node)) {
+                const child = node[k];
+                if (Array.isArray(child)) {
+                    for (const item of child) {
+                        visit(item);
+                    }
+                }
+                else if (typeof child === 'object' && child !== null) {
+                    visit(child);
+                }
+            }
+        }
+        visit(ast);
+    }
+    catch (error) {
+        console.error(`Failed to parse ${filePath}:`, error);
+    }
+    return locations;
+}
+function escapeString(str) {
+    return str
+        .replace(/\\/g, '\\\\')
+        .replace(/'/g, "\\'")
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/\t/g, '\\t');
+}
+export function injectTranslations(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const translationsFile = join(cwd, 'translations', 'en.json');
+    if (!existsSync(translationsFile)) {
+        return { updated: 0 };
+    }
+    let translations;
+    try {
+        translations = JSON.parse(readFileSync(translationsFile, 'utf-8'));
+    }
+    catch {
+        throw new Error(`Failed to parse ${translationsFile}`);
+    }
+    const srcDir = join(cwd, 'src');
+    const files = findReactFiles(srcDir);
+    const fileContents = new Map();
+    const fileLocations = new Map();
+    for (const file of files) {
+        const code = readFileSync(file, 'utf-8');
+        fileContents.set(file, code);
+        const locations = findTCalls(file, code);
+        if (locations.length > 0) {
+            fileLocations.set(file, locations);
+        }
+    }
+    let totalUpdates = 0;
+    for (const [file, locations] of fileLocations) {
+        let code = fileContents.get(file);
+        let offset = 0;
+        let fileModified = false;
+        const sortedLocations = [...locations].sort((a, b) => a.secondArgStart - b.secondArgStart);
+        for (const loc of sortedLocations) {
+            const expectedValue = translations[loc.key];
+            if (expectedValue === undefined) {
+                continue;
+            }
+            if (loc.hasSecondArg) {
+                if (loc.currentDefault !== expectedValue) {
+                    const newLiteral = `'${escapeString(expectedValue)}'`;
+                    const before = code.slice(0, loc.secondArgStart + offset);
+                    const after = code.slice(loc.secondArgEnd + offset);
+                    code = before + newLiteral + after;
+                    offset += newLiteral.length - (loc.secondArgEnd - loc.secondArgStart);
+                    fileModified = true;
+                    totalUpdates++;
+                }
+            }
+            else {
+                if (expectedValue !== '') {
+                    const newArg = `, '${escapeString(expectedValue)}'`;
+                    const insertPos = loc.firstArgEnd + offset;
+                    code = code.slice(0, insertPos) + newArg + code.slice(insertPos);
+                    offset += newArg.length;
+                    fileModified = true;
+                    totalUpdates++;
+                }
+            }
+        }
+        if (fileModified) {
+            writeFileSync(file, code, 'utf-8');
+        }
+    }
+    return { updated: totalUpdates };
+}

package/dist/scripts/lib/discover-next-routes.d.ts

@@ -0,0 +1,17 @@
+export interface DiscoveredRoute {
+    id: string;
+    path: string;
+    label: string;
+}
+/**
+ * Discover page routes of a Next.js app-router directory (`app/` or
+ * `src/app/`). Returns display routes for `fimo-config.json#routes` so the
+ * Studio page switcher can enumerate a wrapped site's pages.
+ */
+export declare function discoverNextRoutes(appDir: string): DiscoveredRoute[];
+/**
+ * Pages-router discovery (`pages/` or `src/pages/`): every module is a route
+ * except `_app`/`_document`/`_error` and `api/`. `[param]` segments map to
+ * `:param` (the parity capture skips dynamic routes, same as app router).
+ */
+export declare function discoverNextPagesRoutes(pagesDir: string): DiscoveredRoute[];