fimo 0.7.0-experimental.6 → 0.7.0-experimental.8

package/dist/scripts/cms/example-content.d.ts

@@ -1,7 +1,7 @@
 import type { CmsCollectionSchema } from './types.js';
 /**
  * Generate example content for a CMS schema WITHOUT connecting to the CMS. The
- * shapes match `api.createEntriesBatch`: media fields are omitted (a fake URL
+ * shapes match `api.importEntries`: media fields are omitted (a fake URL
  * would render a broken image), references point at the first example of the
  * target type (`<target>-example-1`) so they resolve against the co-seeded
  * data, and localized types get per-locale string variance so the per-language
@@ -15,7 +15,7 @@ export interface ExampleSeed {
     readonly localized: boolean;
     /** Entry data rows (slug lives inside data for collections). */
     readonly rows: Array<Record<string, unknown>>;
-    /** Reference descriptor for `createEntriesBatch`. */
+    /** Reference descriptor for `importEntries`. */
     readonly references: Record<string, {
         target?: string;
         targets?: string[];

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

@@ -1,6 +1,7 @@
 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) {
@@ -19,5 +20,6 @@ export function strapiConnector(frontendDir) {
                 warnings: ['No Strapi client directory detected — wire fimoStrapiFetch manually.'],
                 wired: false,
             },
+        detectTouchpoints: (cwd) => detectStrapiTouchpoints(cwd),
     };
 }

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

@@ -0,0 +1,31 @@
+export type StrapiCallReason = 'strapi-sdk-import' | 'env-ref' | 'uid-ref';
+export interface StrapiCallSite {
+    /** Path relative to the frontend directory. */
+    file: string;
+    line: number;
+    reason: StrapiCallReason;
+    snippet: string;
+}
+export interface StrapiTouchpoints {
+    /** Strapi SDK / client / generated-type packages still declared in package.json. */
+    dependencies: string[];
+    /** Source lines that still reach Strapi at runtime. */
+    callSites: StrapiCallSite[];
+    /** `STRAPI_*` keys still present in dotenv files (cleanup; low severity). */
+    envVars: string[];
+    /** No runtime Strapi coupling remains (no SDK deps, no call sites): the cutover is complete. */
+    clean: boolean;
+}
+/**
+ * Enumerate every remaining Strapi coupling in a wrapped frontend. This is the
+ * shared primitive behind both the unwire worklist (the agent's to-do) and the
+ * cutover gate (`clean === true`).
+ *
+ * `clean` is true when no runtime coupling remains — no Strapi SDK/client
+ * dependency and no source line that reaches Strapi — i.e. the site can no
+ * longer call Strapi. Detection keys on actual Strapi *references* (base-URL
+ * env, `api::` UID, SDK import), NOT filenames: a `lib/strapi.ts` the agent has
+ * rewritten to call Fimo has no Strapi references and therefore reads as clean.
+ * The `fimo/strapi` compat adapter is never counted.
+ */
+export declare function detectStrapiTouchpoints(frontendDir: string): StrapiTouchpoints;

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

@@ -0,0 +1,145 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+const SOURCE_EXT_RE = /\.(tsx?|jsx?|mjs|cjs|astro|vue|svelte)$/;
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.next',
+    '.nuxt',
+    '.svelte-kit',
+    '.turbo',
+    'dist',
+    'build',
+    'out',
+    'coverage',
+    '.vercel',
+    '.git',
+]);
+const MAX_FILES = 2000;
+/** A runtime reference to Strapi's base-URL / token env config. */
+const ENV_REF_RE = /\bSTRAPI[A-Z0-9_]*_URL\b|\bNEXT_PUBLIC_STRAPI[A-Z0-9_]*\b|\bSTRAPI[A-Z0-9_]*_TOKEN\b/;
+/** A Strapi content-type UID string (`api::article.article`). */
+const UID_REF_RE = /api::[a-z0-9-]+\.[a-z0-9-]+/;
+/** An import/require specifier — captured so a Strapi SDK can be told apart from `fimo/strapi`. */
+const IMPORT_RE = /(?:from\s+|require\(\s*|import\(\s*)['"`]([^'"`]+)['"`]/;
+/** A STRAPI env assignment in a dotenv file. */
+const ENV_KEY_RE = /^\s*([A-Z0-9_]*STRAPI[A-Z0-9_]*)\s*=/;
+function readDeps(dir) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+        return { ...pkg.dependencies, ...pkg.devDependencies };
+    }
+    catch {
+        return {};
+    }
+}
+function classifyLine(line) {
+    const importMatch = IMPORT_RE.exec(line);
+    // A Strapi SDK/client import — but NOT the `fimo/strapi` compat adapter.
+    if (importMatch && /strapi/i.test(importMatch[1]) && !/fimo/i.test(importMatch[1])) {
+        return 'strapi-sdk-import';
+    }
+    if (ENV_REF_RE.test(line)) {
+        return 'env-ref';
+    }
+    if (UID_REF_RE.test(line)) {
+        return 'uid-ref';
+    }
+    return null;
+}
+function scanCallSites(frontendDir) {
+    const sites = [];
+    let scanned = 0;
+    const walk = (dir) => {
+        if (scanned >= MAX_FILES) {
+            return;
+        }
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (scanned >= MAX_FILES) {
+                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;
+            const full = join(dir, entry.name);
+            let text;
+            try {
+                text = readFileSync(full, 'utf8');
+            }
+            catch {
+                continue;
+            }
+            const lines = text.split('\n');
+            for (let i = 0; i < lines.length; i += 1) {
+                const reason = classifyLine(lines[i]);
+                if (reason) {
+                    sites.push({
+                        file: relative(frontendDir, full),
+                        line: i + 1,
+                        reason,
+                        snippet: lines[i].trim().slice(0, 200),
+                    });
+                }
+            }
+        }
+    };
+    walk(frontendDir);
+    return sites;
+}
+function scanEnvKeys(frontendDir) {
+    const keys = new Set();
+    for (const name of ['.env', '.env.local', '.env.development', '.env.production']) {
+        const file = join(frontendDir, name);
+        if (!existsSync(file)) {
+            continue;
+        }
+        try {
+            for (const line of readFileSync(file, 'utf8').split('\n')) {
+                const match = ENV_KEY_RE.exec(line);
+                if (match) {
+                    keys.add(match[1]);
+                }
+            }
+        }
+        catch {
+            // unreadable — ignore
+        }
+    }
+    return [...keys];
+}
+/**
+ * Enumerate every remaining Strapi coupling in a wrapped frontend. This is the
+ * shared primitive behind both the unwire worklist (the agent's to-do) and the
+ * cutover gate (`clean === true`).
+ *
+ * `clean` is true when no runtime coupling remains — no Strapi SDK/client
+ * dependency and no source line that reaches Strapi — i.e. the site can no
+ * longer call Strapi. Detection keys on actual Strapi *references* (base-URL
+ * env, `api::` UID, SDK import), NOT filenames: a `lib/strapi.ts` the agent has
+ * rewritten to call Fimo has no Strapi references and therefore reads as clean.
+ * The `fimo/strapi` compat adapter is never counted.
+ */
+export function detectStrapiTouchpoints(frontendDir) {
+    const dependencies = Object.keys(readDeps(frontendDir)).filter((name) => /strapi/i.test(name));
+    const callSites = scanCallSites(frontendDir);
+    const envVars = scanEnvKeys(frontendDir);
+    return {
+        dependencies,
+        callSites,
+        envVars,
+        clean: dependencies.length === 0 && callSites.length === 0,
+    };
+}

package/dist/scripts/cms/strapi/touchpoints.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/cms/strapi/touchpoints.test.js

@@ -0,0 +1,62 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { detectStrapiTouchpoints } from './touchpoints.js';
+let dir;
+function frontend(files) {
+    dir = mkdtempSync(join(tmpdir(), 'strapi-touchpoints-'));
+    for (const [rel, content] of Object.entries(files)) {
+        const full = join(dir, rel);
+        mkdirSync(join(full, '..'), { recursive: true });
+        writeFileSync(full, content);
+    }
+    return dir;
+}
+afterEach(() => {
+    if (dir) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('detectStrapiTouchpoints', () => {
+    it('enumerates deps, call sites, and env for a still-wired frontend', () => {
+        const cwd = frontend({
+            'package.json': JSON.stringify({
+                dependencies: { '@strapi/client': '^1.0.0', next: '16.0.0' },
+                devDependencies: { '@repo/strapi-types': 'workspace:*' },
+            }),
+            'src/lib/strapi.ts': "import { strapi } from '@strapi/client';\nexport const client = strapi({ baseURL: process.env.STRAPI_URL });\n",
+            'src/app/page.tsx': "const data = await client.collection('api::article.article').find();\n",
+            '.env': 'STRAPI_URL=https://cms.example.com\nNEXT_PUBLIC_STRAPI_URL=https://cms.example.com\nOTHER=1\n',
+        });
+        const result = detectStrapiTouchpoints(cwd);
+        expect(result.dependencies.sort()).toEqual(['@repo/strapi-types', '@strapi/client']);
+        expect(result.envVars.sort()).toEqual(['NEXT_PUBLIC_STRAPI_URL', 'STRAPI_URL']);
+        expect(result.callSites.map((site) => site.reason).sort()).toEqual(['env-ref', 'strapi-sdk-import', 'uid-ref']);
+        expect(result.callSites.find((site) => site.reason === 'strapi-sdk-import')?.file).toBe('src/lib/strapi.ts');
+        expect(result.clean).toBe(false);
+    });
+    it('reads a rewired frontend as clean — a lib/strapi.ts calling Fimo is not a touchpoint', () => {
+        const cwd = frontend({
+            'package.json': JSON.stringify({ dependencies: { fimo: '0.7.0', next: '16.0.0' } }),
+            // Same filename, but now Fimo-backed: no Strapi references.
+            'src/lib/strapi.ts': "import { fimoStrapiFetch } from 'fimo/strapi';\nexport const client = fimoStrapiFetch;\n",
+            'src/app/page.tsx': "const data = await client('/articles');\n",
+        });
+        const result = detectStrapiTouchpoints(cwd);
+        expect(result.dependencies).toEqual([]);
+        expect(result.callSites).toEqual([]);
+        expect(result.clean).toBe(true);
+    });
+    it('flags a lingering STRAPI env reference in config even when deps are gone', () => {
+        const cwd = frontend({
+            'package.json': JSON.stringify({ dependencies: { next: '16.0.0' } }),
+            'next.config.mjs': 'export default { images: { domains: [process.env.STRAPI_MEDIA_URL] } };\n',
+        });
+        const result = detectStrapiTouchpoints(cwd);
+        expect(result.dependencies).toEqual([]);
+        expect(result.callSites).toHaveLength(1);
+        expect(result.callSites[0]).toMatchObject({ file: 'next.config.mjs', reason: 'env-ref' });
+        expect(result.clean).toBe(false);
+    });
+});

package/dist/scripts/cms/types.d.ts

@@ -33,7 +33,7 @@ export interface CmsCollectionSchema {
     readonly name: string;
     /** Human display label. */
     readonly label: string;
-    /** Strapi singleType → true; collectionType → false. */
+    /** A single-document type (e.g. a Strapi singleType) → true; a collection → false. */
     readonly isSingleton: boolean;
     /** The CMS marks this type as localized → seed per configured locale. */
     readonly localized: boolean;
@@ -86,9 +86,32 @@ export interface CmsConnector {
      * Fimo. Deterministic — no agent step.
      */
     wireClient?(cwd: string, schemas: CmsCollectionSchema[]): CmsWireResult;
+    /**
+     * Enumerate the frontend's remaining couplings to this CMS — the unwire
+     * worklist and the cutover gate (`clean`). Keys on actual CMS references, not
+     * filenames, so a client module rewritten to call Fimo reads as clean.
+     * Returns undefined for a connector without touchpoint detection.
+     */
+    detectTouchpoints?(cwd: string): CmsTouchpoints;
 }
 export interface CmsWireResult {
     changes: string[];
     warnings: string[];
     wired: boolean;
 }
+export interface CmsTouchpointSite {
+    file: string;
+    line: number;
+    reason: string;
+    snippet: string;
+}
+export interface CmsTouchpoints {
+    /** SDK/client/type packages still declared in the frontend's package.json. */
+    dependencies: string[];
+    /** Source lines that still reach the CMS at runtime. */
+    callSites: CmsTouchpointSite[];
+    /** CMS base-URL / token env keys still present in dotenv files. */
+    envVars: string[];
+    /** No runtime coupling remains — the cutover is complete. */
+    clean: boolean;
+}

package/dist/scripts/extract-translations.js

@@ -28,24 +28,71 @@ function findReactFiles(dir, files = []) {
     }
     return files;
 }
+const isFunctionLike = (node) => node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression';
+/**
+ * next-intl (and similar) scope a `t` to a namespace:
+ * `const t = useTranslations("plans.checkout")` makes every `t("buyNow")` in
+ * that component resolve to `plans.checkout.buyNow`. Collect those bindings from
+ * a function's direct body so the FULL key is recorded — otherwise the labels
+ * gate looks for the bare leaf (`buyNow`) and never finds it in the DB. Also
+ * handles `await getTranslations(ns)` (server components) and a root-scoped
+ * `useTranslations()` (namespace `""`, keys stay full).
+ */
+function collectScopedBindings(fnNode) {
+    const bindings = new Map();
+    const body = fnNode.body;
+    const statements = body && Array.isArray(body.body) ? body.body : [];
+    for (const stmt of statements) {
+        if (stmt?.type !== 'VariableDeclaration') {
+            continue;
+        }
+        for (const decl of stmt.declarations ?? []) {
+            if (decl?.id?.type !== 'Identifier') {
+                continue;
+            }
+            const init = decl.init?.type === 'AwaitExpression' ? decl.init.argument : decl.init;
+            if (init?.type === 'CallExpression' &&
+                init.callee?.type === 'Identifier' &&
+                (init.callee.name === 'useTranslations' || init.callee.name === 'getTranslations')) {
+                const nsArg = init.arguments?.[0];
+                const namespace = nsArg?.type === 'Literal' && typeof nsArg.value === 'string' ? nsArg.value : '';
+                bindings.set(decl.id.name, namespace);
+            }
+        }
+    }
+    return bindings;
+}
 function extractFromFile(filePath) {
     const declarations = [];
     try {
         const code = readFileSync(filePath, 'utf-8');
         const result = parseSync(filePath, code);
         const ast = result.program;
-        function visit(node) {
+        function visit(node, scopes) {
             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;
-                        declarations.push({ key, file: filePath });
+            // A function introduces a new scope layer with its `useTranslations`
+            // bindings; nested calls resolve innermost-first.
+            const childScopes = isFunctionLike(node) ? [...scopes, collectScopedBindings(node)] : scopes;
+            if (node.type === 'CallExpression' && node.callee?.type === 'Identifier') {
+                const name = node.callee.name;
+                const firstArg = (node.arguments ?? [])[0];
+                if (firstArg?.type === 'Literal' && typeof firstArg.value === 'string') {
+                    let namespace;
+                    for (let i = childScopes.length - 1; i >= 0; i -= 1) {
+                        if (childScopes[i].has(name)) {
+                            namespace = childScopes[i].get(name);
+                            break;
+                        }
+                    }
+                    if (namespace !== undefined) {
+                        // A namespace-scoped var (any name): prepend the namespace.
+                        declarations.push({ key: namespace ? `${namespace}.${firstArg.value}` : firstArg.value, file: filePath });
+                    }
+                    else if (name === 't') {
+                        // A bare `t(...)` — Fimo's label call, key already full.
+                        declarations.push({ key: firstArg.value, file: filePath });
                     }
                 }
             }
@@ -53,15 +100,15 @@ function extractFromFile(filePath) {
                 const child = node[key];
                 if (Array.isArray(child)) {
                     for (const item of child) {
-                        visit(item);
+                        visit(item, childScopes);
                     }
                 }
                 else if (typeof child === 'object' && child !== null) {
-                    visit(child);
+                    visit(child, childScopes);
                 }
             }
         }
-        visit(ast);
+        visit(ast, []);
     }
     catch (error) {
         console.error(`Failed to parse ${filePath}:`, error);

package/dist/scripts/extract-translations.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/extract-translations.test.js

@@ -0,0 +1,66 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { extractLabelKeys } from './extract-translations.js';
+let dir;
+function project(files) {
+    dir = mkdtempSync(join(tmpdir(), 'extract-tr-'));
+    for (const [rel, content] of Object.entries(files)) {
+        const full = join(dir, rel);
+        mkdirSync(join(full, '..'), { recursive: true });
+        writeFileSync(full, content);
+    }
+    return dir;
+}
+const keysOf = (cwd) => extractLabelKeys({ cwd }).map((declaration) => declaration.key);
+afterEach(() => {
+    if (dir) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('extractLabelKeys', () => {
+    it('extracts a bare Fimo t() key verbatim', () => {
+        const cwd = project({ 'src/a.tsx': "export function A() { return <b>{t('nav.home')}</b>; }" });
+        expect(keysOf(cwd)).toEqual(['nav.home']);
+    });
+    it('resolves next-intl useTranslations(namespace) into the full key', () => {
+        const cwd = project({
+            'src/checkout.tsx': `import { useTranslations } from 'next-intl';
+export function Checkout() {
+  const t = useTranslations('plans.pricingCheckoutModal');
+  return <button>{t('buyNow')}</button>;
+}`,
+        });
+        expect(keysOf(cwd)).toEqual(['plans.pricingCheckoutModal.buyNow']);
+    });
+    it('scopes per component — two useTranslations in one file do not cross-contaminate', () => {
+        const cwd = project({
+            'src/two.tsx': `import { useTranslations } from 'next-intl';
+export function A() { const t = useTranslations('a'); return <p>{t('x')}</p>; }
+export function B() { const t = useTranslations('b'); return <p>{t('x')}</p>; }`,
+        });
+        expect(keysOf(cwd)).toEqual(['a.x', 'b.x']);
+    });
+    it('handles a non-t binding and a root-scoped useTranslations()', () => {
+        const cwd = project({
+            'src/misc.tsx': `import { useTranslations } from 'next-intl';
+export function Nav() {
+  const tNav = useTranslations('nav');
+  const tRoot = useTranslations();
+  return <>{tNav('home')}{tRoot('global.title')}</>;
+}`,
+        });
+        expect(keysOf(cwd)).toEqual(['global.title', 'nav.home']);
+    });
+    it('resolves server getTranslations too', () => {
+        const cwd = project({
+            'src/page.tsx': `import { getTranslations } from 'next-intl/server';
+export default async function Page() {
+  const t = await getTranslations('home');
+  return <h1>{t('title')}</h1>;
+}`,
+        });
+        expect(keysOf(cwd)).toEqual(['home.title']);
+    });
+});

package/dist/scripts/frameworks/discover.d.ts

@@ -67,4 +67,4 @@ export interface WiringMarker {
  * wraps), parity (fallbacks render identically), nor seeding (DB-side)
  * notices — editability would ship silently broken.
  */
-export declare function frameworkWiringMarker(detection: Pick<FrameworkDetection, 'framework' | 'react' | 'appDir'>): WiringMarker | null;
+export declare function frameworkWiringMarker(detection: Pick<FrameworkDetection, 'framework' | 'react' | 'appDir'>, cwd?: string): WiringMarker | null;

package/dist/scripts/frameworks/discover.js

@@ -1,9 +1,9 @@
-import { join } from 'node:path';
+import { join, relative } from 'node:path';
 import { discoverAstroRoutes } from './astro/routes.js';
 import { astroTemplateWrapStyle } from './astro/template-style.js';
 import { rewireNextCollectionPages } from './next/rewire.js';
 import { discoverNextPagesRoutes, discoverNextRoutes } from './next/routes.js';
-import { ensureNextLayoutWiring } from './next/wiring.js';
+import { ensureNextLayoutWiring, nextRootLayoutFiles } from './next/wiring.js';
 import { discoverNuxtRoutes } from './nuxt/routes.js';
 import { nuxtTemplateWrapStyle } from './nuxt/template-style.js';
 import { discoverRemixRoutes } from './remix/routes.js';
@@ -128,9 +128,9 @@ export function frameworkCollectionRewire(detection) {
  * wraps), parity (fallbacks render identically), nor seeding (DB-side)
  * notices — editability would ship silently broken.
  */
-export function frameworkWiringMarker(detection) {
+export function frameworkWiringMarker(detection, cwd) {
     switch (detection.framework) {
-        case 'next':
+        case 'next': {
             if (!detection.appDir) {
                 return {
                     files: ['pages/_app.tsx', 'pages/_app.jsx', 'src/pages/_app.tsx', 'src/pages/_app.jsx'],
@@ -139,11 +139,18 @@ export function frameworkWiringMarker(detection) {
                     warnOnly: true,
                 };
             }
+            // Resolve the real root layout(s), including the next-intl `[locale]`
+            // segment; fall back to the direct path when nothing is on disk yet.
+            const resolved = cwd ? nextRootLayoutFiles(cwd, detection.appDir).map((file) => relative(cwd, file)) : [];
+            const files = resolved.length > 0
+                ? resolved
+                : [`${detection.appDir}/layout.tsx`, `${detection.appDir}/layout.jsx`, `${detection.appDir}/layout.js`];
             return {
-                files: [`${detection.appDir}/layout.tsx`, `${detection.appDir}/layout.jsx`, `${detection.appDir}/layout.js`],
+                files,
                 marker: /FimoNextProviders/,
                 hint: `mount FimoNextProviders + FimoNextScripts in ${detection.appDir}/layout (agent prompt section 0)`,
             };
+        }
         case 'vite':
             if (!detection.react) {
                 return null;

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

@@ -14,6 +14,13 @@ export interface RootWiringResult {
     /** True when the root wiring is in place (pre-existing or just applied). */
     wired: boolean;
 }
+/**
+ * Candidate app-router root-layout files: the direct `<appDir>/layout.*` plus,
+ * for i18n apps that place the `<html>` layout under a dynamic segment
+ * (next-intl's `app/[locale]/layout.tsx`), any `<appDir>/[segment]/layout.*`.
+ * Existing files only, in resolution order.
+ */
+export declare function nextRootLayoutFiles(cwd: string, appDir: string): string[];
 /**
  * Wire the app-router root layout deterministically: imports, async default
  * export, loader calls, `<FimoNextScripts />` in head, and `{children}`

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

@@ -62,6 +62,27 @@ function findFirst(node, predicate) {
     return null;
 }
 const jsxName = (element) => element?.openingElement?.name?.name;
+/**
+ * Candidate app-router root-layout files: the direct `<appDir>/layout.*` plus,
+ * for i18n apps that place the `<html>` layout under a dynamic segment
+ * (next-intl's `app/[locale]/layout.tsx`), any `<appDir>/[segment]/layout.*`.
+ * Existing files only, in resolution order.
+ */
+export function nextRootLayoutFiles(cwd, appDir) {
+    const names = ['layout.tsx', 'layout.jsx', 'layout.js'];
+    const dirs = [path.join(cwd, appDir)];
+    try {
+        for (const entry of fs.readdirSync(path.join(cwd, appDir), { withFileTypes: true })) {
+            if (entry.isDirectory() && entry.name.startsWith('[') && entry.name.endsWith(']')) {
+                dirs.push(path.join(cwd, appDir, entry.name));
+            }
+        }
+    }
+    catch {
+        // appDir missing — no candidates
+    }
+    return dirs.flatMap((dir) => names.map((name) => path.join(dir, name))).filter((file) => fs.existsSync(file));
+}
 /**
  * Wire the app-router root layout deterministically: imports, async default
  * export, loader calls, `<FimoNextScripts />` in head, and `{children}`
@@ -79,9 +100,14 @@ export function ensureNextLayoutWiring(cwd, detection) {
             wired: false,
         };
     }
-    const layoutFile = ['layout.tsx', 'layout.jsx', 'layout.js']
-        .map((candidate) => path.join(cwd, detection.appDir, candidate))
-        .find((candidate) => fs.existsSync(candidate));
+    const candidates = nextRootLayoutFiles(cwd, detection.appDir);
+    // Already wired anywhere — an agent may have mounted the [locale] layout by hand.
+    if (candidates.some((file) => fs.readFileSync(file, 'utf8').includes('FimoNextProviders'))) {
+        return { changes: [], warnings: [], wired: true };
+    }
+    // The real root layout is the one that returns <html> (next-intl puts it under
+    // app/[locale]/); fall back to the first candidate for the bail message.
+    const layoutFile = candidates.find((file) => fs.readFileSync(file, 'utf8').includes('<html')) ?? candidates[0];
     const rel = layoutFile ? path.relative(cwd, layoutFile) : `${detection.appDir}/layout.tsx`;
     const bail = (reason) => ({
         changes: [],
@@ -92,9 +118,6 @@ export function ensureNextLayoutWiring(cwd, detection) {
         return bail('no root layout file found');
     }
     const code = fs.readFileSync(layoutFile, 'utf8');
-    if (code.includes('FimoNextProviders')) {
-        return { changes: [], warnings: [], wired: true };
-    }
     let program;
     try {
         program = parseSync(layoutFile, code).program;

package/dist/scripts/frameworks/next/wiring.test.js

@@ -50,6 +50,34 @@ describe('ensureNextLayoutWiring', () => {
         expect(code.indexOf('<FimoNextScripts />')).toBeGreaterThan(code.indexOf('<html'));
         expect(code.indexOf('<FimoNextScripts />')).toBeLessThan(code.indexOf('<body'));
     });
+    it('wires the root layout under a [locale] segment (next-intl)', () => {
+        const root = project({ 'src/app/[locale]/layout.tsx': CREATE_NEXT_APP_LAYOUT });
+        const result = ensureNextLayoutWiring(root, { appDir: 'src/app' });
+        const code = readFileSync(join(root, 'src/app/[locale]/layout.tsx'), 'utf8');
+        expect(result.wired).toBe(true);
+        expect(result.changes).toEqual(['wired Fimo providers into src/app/[locale]/layout.tsx']);
+        expect(code).toContain('<FimoNextProviders config={config} labels={labels}>{children}</FimoNextProviders>');
+        expect(code).toContain('<FimoNextScripts />');
+    });
+    it('picks the <html> layout when a passthrough app/layout also exists', () => {
+        const root = project({
+            'src/app/layout.tsx': 'export default function Root({ children }) {\n  return children;\n}\n',
+            'src/app/[locale]/layout.tsx': CREATE_NEXT_APP_LAYOUT,
+        });
+        const result = ensureNextLayoutWiring(root, { appDir: 'src/app' });
+        expect(result.wired).toBe(true);
+        expect(result.changes).toEqual(['wired Fimo providers into src/app/[locale]/layout.tsx']);
+        // the passthrough root layout stays untouched
+        expect(readFileSync(join(root, 'src/app/layout.tsx'), 'utf8')).not.toContain('FimoNextProviders');
+    });
+    it('treats a [locale] layout already wired by hand as a no-op', () => {
+        const root = project({
+            'src/app/[locale]/layout.tsx': CREATE_NEXT_APP_LAYOUT.replace('{children}', '<FimoNextProviders config={config} labels={labels}>{children}</FimoNextProviders>'),
+        });
+        const result = ensureNextLayoutWiring(root, { appDir: 'src/app' });
+        expect(result.wired).toBe(true);
+        expect(result.changes).toEqual([]);
+    });
     it('reuses an existing <head> element and keeps an async layout async', () => {
         const root = project({
             'src/app/layout.jsx': `export default async function Layout({ children }) {