fimo 0.7.0-experimental.1 → 0.7.0-experimental.10

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

@@ -0,0 +1,134 @@
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { writeSchemaDrafts } from '../../draft-schemas.js';
+import { scanWrappable } from '../../scan-wrappable.js';
+import { rewireNextCollectionPages } from './rewire.js';
+let dir;
+const project = (files) => {
+    dir = mkdtempSync(join(tmpdir(), 'next-rewire-'));
+    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 });
+    }
+});
+const run = (root) => {
+    const scan = scanWrappable(root, { keepInternal: true });
+    const drafts = writeSchemaDrafts(root, scan);
+    return rewireNextCollectionPages(root, { appDir: 'app' }, scan, drafts);
+};
+const DATA_PAGE = `import posts from '../../src/data/posts.json';
+
+export default function PostsPage() {
+  return (
+    <main>
+      <h1>Posts</h1>
+      <ul>
+        {posts.slice(0, 24).map((item: any, idx: number) => (
+          <li key={idx}><span>{item.title}</span> <span>{item.excerpt}</span></li>
+        ))}
+      </ul>
+    </main>
+  );
+}
+`;
+const POSTS_JSON = JSON.stringify([
+    { slug: 'post-1', title: 'Charting the bay', excerpt: 'First excerpt of the harbor.' },
+    { slug: 'post-2', title: 'Berth songs', excerpt: 'Second excerpt of the crew.' },
+    { slug: 'post-3', title: 'Lantern census', excerpt: 'Third excerpt of the reef.' },
+]);
+const INCODE_PAGE = `const clients = [
+  { "name": "Quay anchor Co", "slug": "client-0", "since": "2018-03-20" },
+  { "name": "Gull harbor Co", "slug": "client-1", "since": "2015-08-17" },
+  { "name": "Crane skiff Co", "slug": "client-2", "since": "2017-07-07" }
+];
+
+export default function ClientsPage() {
+  return (
+    <main>
+      <h1>Clients</h1>
+      <ul>
+        {clients.map((item, idx) => (
+          <li key={idx}><span>{item.name}</span> <span>{item.since}</span></li>
+        ))}
+      </ul>
+    </main>
+  );
+}
+`;
+describe('rewireNextCollectionPages', () => {
+    it('wires a data-file import page through wrapCollection', () => {
+        const root = project({
+            'src/data/posts.json': POSTS_JSON,
+            'app/posts/page.tsx': DATA_PAGE,
+        });
+        const result = run(root);
+        expect(result.rewired).toBe(1);
+        const page = readFileSync(join(root, 'app/posts/page.tsx'), 'utf8');
+        expect(page).toContain("import postsSource from '../../src/data/posts.json'");
+        expect(page).toContain('export default async function PostsPage()');
+        expect(page).toContain("const posts = await wrapCollection('Post', postsSource);");
+        expect(page).toContain('import { wrapCollection } from "fimo/next/server"');
+    });
+    it('extracts an in-code array to src/data and wires the page', () => {
+        const root = project({
+            'app/clients/page.tsx': INCODE_PAGE,
+        });
+        const result = run(root);
+        expect(result.rewired).toBe(1);
+        const extracted = JSON.parse(readFileSync(join(root, 'src/data/clients.json'), 'utf8'));
+        expect(extracted).toHaveLength(3);
+        expect(extracted[0]).toEqual({ name: 'Quay anchor Co', slug: 'client-0', since: '2018-03-20' });
+        const page = readFileSync(join(root, 'app/clients/page.tsx'), 'utf8');
+        expect(page).toContain("import clientsSource from '../../src/data/clients.json'");
+        expect(page).toContain('export default async function ClientsPage()');
+        expect(page).toContain("const clients = await wrapCollection('Client', clientsSource);");
+        expect(page).not.toContain('"Quay anchor Co"');
+    });
+    it('extracts an `as const` in-code array (the generator/create-next-app shape)', () => {
+        const root = project({
+            'app/clients/page.tsx': INCODE_PAGE.replace('\n];', '\n] as const;'),
+        });
+        const result = run(root);
+        expect(result.rewired).toBe(1);
+        const page = readFileSync(join(root, 'app/clients/page.tsx'), 'utf8');
+        expect(page).toContain("const clients = await wrapCollection('Client', clientsSource);");
+        expect(page).not.toContain('as const');
+    });
+    it('bails on client components with a reason', () => {
+        const root = project({
+            'src/data/posts.json': POSTS_JSON,
+            'app/posts/page.tsx': `'use client';\n${DATA_PAGE}`,
+        });
+        const result = run(root);
+        expect(result.rewired).toBe(0);
+        expect(result.warnings.some((warning) => warning.includes('client component'))).toBe(true);
+    });
+    it('bails when the collection is referenced outside the page component', () => {
+        const root = project({
+            'app/clients/page.tsx': `${INCODE_PAGE}\nexport const clientCount = clients.length;\n`,
+        });
+        const result = run(root);
+        expect(result.rewired).toBe(0);
+        expect(result.warnings.some((warning) => warning.includes('referenced outside'))).toBe(true);
+    });
+    it('is idempotent: an already-wired page is left untouched', () => {
+        const root = project({
+            'src/data/posts.json': POSTS_JSON,
+            'app/posts/page.tsx': DATA_PAGE,
+        });
+        run(root);
+        const once = readFileSync(join(root, 'app/posts/page.tsx'), 'utf8');
+        const again = run(root);
+        expect(readFileSync(join(root, 'app/posts/page.tsx'), 'utf8')).toBe(once);
+        expect(again.warnings.filter((warning) => warning.includes('app/posts'))).toHaveLength(0);
+    });
+});

package/dist/scripts/frameworks/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[];

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

@@ -0,0 +1,134 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+const PAGE_FILES = new Set(['page.tsx', 'page.jsx', 'page.ts', 'page.js', 'page.mdx']);
+const titleCase = (seg) => seg
+    .replace(/[_\-]+/g, ' ')
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+    .join(' ');
+function segmentToPath(segment) {
+    // Route groups `(marketing)` don't contribute URL segments. Parallel-route
+    // slots `@modal` and private folders `_lib` are not standalone pages.
+    if (segment.startsWith('(')) {
+        return '';
+    }
+    if (segment.startsWith('@') || segment.startsWith('_')) {
+        return null;
+    }
+    const catchAll = segment.match(/^\[\.\.\.(.+)\]$/) ?? segment.match(/^\[\[\.\.\.(.+)\]\]$/);
+    if (catchAll) {
+        return `:${catchAll[1]}*`;
+    }
+    const param = segment.match(/^\[(.+)\]$/);
+    if (param) {
+        return `:${param[1]}`;
+    }
+    return segment;
+}
+/**
+ * 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 function discoverNextRoutes(appDir) {
+    const routes = [];
+    const walk = (dir, segments) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        if (entries.some((entry) => PAGE_FILES.has(entry))) {
+            const parts = segments.filter((s) => s.length > 0);
+            const routePath = `/${parts.join('/')}`.replace(/\/+/g, '/');
+            const lastStatic = [...parts].reverse().find((p) => !p.startsWith(':'));
+            routes.push({
+                id: routePath === '/' ? 'home' : parts.map((p) => p.replace(/^:/, '')).join('-'),
+                path: routePath,
+                label: routePath === '/' ? 'Home' : titleCase(lastStatic ?? parts[parts.length - 1] ?? routePath),
+            });
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry);
+            let isDir = false;
+            try {
+                isDir = statSync(full).isDirectory();
+            }
+            catch {
+                continue;
+            }
+            if (!isDir) {
+                continue;
+            }
+            const mapped = segmentToPath(entry);
+            if (mapped === null) {
+                continue;
+            }
+            walk(full, [...segments, mapped]);
+        }
+    };
+    walk(appDir, []);
+    return routes.sort((a, b) => a.path.localeCompare(b.path));
+}
+const PAGES_EXTENSIONS = /\.(tsx|jsx|ts|js)$/;
+const PAGES_SKIP = new Set(['api']);
+/**
+ * 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 function discoverNextPagesRoutes(pagesDir) {
+    const routes = [];
+    const toSegment = (name) => name
+        .replace(/^\[\.\.\.(.+)\]$/, ':$1')
+        .replace(/^\[\[\.\.\.(.+)\]\]$/, ':$1')
+        .replace(/^\[(.+)\]$/, ':$1');
+    const walk = (dir, segments) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry);
+            let isDir = false;
+            try {
+                isDir = statSync(full).isDirectory();
+            }
+            catch {
+                continue;
+            }
+            if (isDir) {
+                // api/ is only special at the pages root.
+                if (!(segments.length === 0 && PAGES_SKIP.has(entry))) {
+                    walk(full, [...segments, toSegment(entry)]);
+                }
+                continue;
+            }
+            if (!PAGES_EXTENSIONS.test(entry)) {
+                continue;
+            }
+            const base = entry.replace(PAGES_EXTENSIONS, '');
+            if (base.startsWith('_')) {
+                continue;
+            }
+            const parts = base === 'index' ? segments : [...segments, toSegment(base)];
+            const routePath = `/${parts.join('/')}`.replace(/\/+/g, '/');
+            const lastStatic = [...parts].reverse().find((part) => !part.startsWith(':'));
+            routes.push({
+                id: routePath === '/' ? 'home' : parts.map((part) => part.replace(/^:/, '')).join('-'),
+                path: routePath,
+                label: routePath === '/' ? 'Home' : titleCase(lastStatic ?? parts[parts.length - 1] ?? routePath),
+            });
+        }
+    };
+    walk(pagesDir, []);
+    routes.sort((a, b) => a.path.localeCompare(b.path));
+    return routes;
+}

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

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

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

@@ -0,0 +1,64 @@
+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 { discoverNextRoutes } from './routes.js';
+let dir;
+const app = (pages) => {
+    dir = mkdtempSync(join(tmpdir(), 'next-routes-'));
+    for (const page of pages) {
+        const full = join(dir, page);
+        mkdirSync(join(full, '..'), { recursive: true });
+        writeFileSync(full, 'export default function Page() { return null }');
+    }
+    return dir;
+};
+afterEach(() => {
+    if (dir) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('discoverNextRoutes', () => {
+    it('discovers static routes', () => {
+        const routes = discoverNextRoutes(app(['page.tsx', 'about/page.tsx', 'pricing/page.tsx']));
+        expect(routes.map((r) => r.path)).toEqual(['/', '/about', '/pricing']);
+        expect(routes[0]).toEqual({ id: 'home', path: '/', label: 'Home' });
+        expect(routes[1]).toEqual({ id: 'about', path: '/about', label: 'About' });
+    });
+    it('maps dynamic and catch-all segments', () => {
+        const routes = discoverNextRoutes(app(['blog/[slug]/page.tsx', 'docs/[...path]/page.tsx']));
+        expect(routes.map((r) => r.path)).toEqual(['/blog/:slug', '/docs/:path*']);
+        expect(routes[0].label).toBe('Blog');
+    });
+    it('collapses route groups and skips private and parallel segments', () => {
+        const routes = discoverNextRoutes(app(['(marketing)/features/page.tsx', '_internal/secret/page.tsx', '@modal/photo/page.tsx']));
+        expect(routes.map((r) => r.path)).toEqual(['/features']);
+    });
+    it('returns [] for a missing directory', () => {
+        expect(discoverNextRoutes(join(tmpdir(), 'does-not-exist'))).toEqual([]);
+    });
+});
+describe('discoverNextPagesRoutes', () => {
+    it('maps pages-router modules to routes, skipping api and _ files', async () => {
+        const { mkdtempSync, mkdirSync, writeFileSync, rmSync } = await import('node:fs');
+        const { tmpdir } = await import('node:os');
+        const { join } = await import('node:path');
+        const dir = mkdtempSync(join(tmpdir(), 'pages-'));
+        try {
+            mkdirSync(join(dir, 'blog'), { recursive: true });
+            mkdirSync(join(dir, 'api'), { recursive: true });
+            writeFileSync(join(dir, 'index.tsx'), '');
+            writeFileSync(join(dir, 'about.tsx'), '');
+            writeFileSync(join(dir, '_app.tsx'), '');
+            writeFileSync(join(dir, '_document.tsx'), '');
+            writeFileSync(join(dir, 'api/hello.ts'), '');
+            writeFileSync(join(dir, 'blog/index.tsx'), '');
+            writeFileSync(join(dir, 'blog/[slug].tsx'), '');
+            const { discoverNextPagesRoutes } = await import('./routes.js');
+            expect(discoverNextPagesRoutes(dir).map((route) => route.path)).toEqual(['/', '/about', '/blog', '/blog/:slug']);
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});

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

@@ -0,0 +1,33 @@
+import type { FrameworkDetection } from '../../detect-framework.js';
+/**
+ * Next.js-side wrap wiring: everything the wrap migration must touch that is
+ * specific to this framework lives HERE, not in the generic flow. Mirror this
+ * module when adding a framework (see the fimo-framework-adapter skill).
+ */
+export declare function ensureNextWiring(cwd: string): {
+    changes: string[];
+    warnings: string[];
+};
+export interface RootWiringResult {
+    changes: string[];
+    warnings: string[];
+    /** 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}`
+ * wrapped in `<FimoNextProviders>`. Only the provably safe shape is touched —
+ * one default-exported function whose JSX returns `<html>…<body>` with a
+ * `{children}` expression somewhere inside body (create-next-app and its
+ * variants). Anything else bails with the reason, and the agent prompt keeps
+ * the manual recipe.
+ */
+export declare function ensureNextLayoutWiring(cwd: string, detection: Pick<FrameworkDetection, 'appDir'>): RootWiringResult;

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

@@ -0,0 +1,186 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseSync } from 'oxc-parser';
+import { ensureFimoImport } from '../../apply-wrap.js';
+/**
+ * Next.js-side wrap wiring: everything the wrap migration must touch that is
+ * specific to this framework lives HERE, not in the generic flow. Mirror this
+ * module when adding a framework (see the fimo-framework-adapter skill).
+ */
+export function ensureNextWiring(cwd) {
+    const changes = [];
+    const warnings = [];
+    const configFile = ['next.config.ts', 'next.config.mjs', 'next.config.js', 'next.config.cjs']
+        .map((candidate) => path.join(cwd, candidate))
+        .find((candidate) => fs.existsSync(candidate));
+    if (configFile) {
+        const source = fs.readFileSync(configFile, 'utf8');
+        if (!source.includes('allowedDevOrigins')) {
+            // The three mainstream config shapes: a named object binding, a direct
+            // `export default {` literal, and CJS `module.exports = {`.
+            let patched = source.replace(/(const\s+nextConfig[^=]*=\s*\{)/, `$1\n  allowedDevOrigins: ['*.preview.fimo.ai'],`);
+            if (patched === source) {
+                patched = source.replace(/((?:export\s+default|module\.exports\s*=)\s*\{)/, `$1\n  allowedDevOrigins: ['*.preview.fimo.ai'],\n`);
+            }
+            if (patched !== source) {
+                fs.writeFileSync(configFile, patched);
+                changes.push(`added allowedDevOrigins to ${path.basename(configFile)}`);
+            }
+            else {
+                warnings.push(`Could not patch ${path.basename(configFile)} automatically — add: allowedDevOrigins: ['*.preview.fimo.ai']`);
+            }
+        }
+    }
+    else {
+        warnings.push("No next.config found — create one with: allowedDevOrigins: ['*.preview.fimo.ai']");
+    }
+    return { changes, warnings };
+}
+function findFirst(node, predicate) {
+    if (!node || typeof node !== 'object') {
+        return null;
+    }
+    if (predicate(node)) {
+        return node;
+    }
+    for (const value of Object.values(node)) {
+        if (Array.isArray(value)) {
+            for (const entry of value) {
+                const found = findFirst(entry, predicate);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        else if (value && typeof value === 'object') {
+            const found = findFirst(value, predicate);
+            if (found) {
+                return found;
+            }
+        }
+    }
+    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}`
+ * wrapped in `<FimoNextProviders>`. Only the provably safe shape is touched —
+ * one default-exported function whose JSX returns `<html>…<body>` with a
+ * `{children}` expression somewhere inside body (create-next-app and its
+ * variants). Anything else bails with the reason, and the agent prompt keeps
+ * the manual recipe.
+ */
+export function ensureNextLayoutWiring(cwd, detection) {
+    if (!detection.appDir) {
+        return {
+            changes: [],
+            warnings: ['Root wiring not applied: pages-router project (no app directory) — wire pages/_app manually.'],
+            wired: false,
+        };
+    }
+    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: [],
+        warnings: [`Root wiring not applied: ${reason} — follow the layout recipe in the agent prompt (${rel}).`],
+        wired: false,
+    });
+    if (!layoutFile) {
+        return bail('no root layout file found');
+    }
+    const code = fs.readFileSync(layoutFile, 'utf8');
+    let program;
+    try {
+        program = parseSync(layoutFile, code).program;
+    }
+    catch {
+        return bail('root layout could not be parsed');
+    }
+    const exportDefault = (program.body ?? []).find((node) => node.type === 'ExportDefaultDeclaration');
+    if (!exportDefault || exportDefault.declaration?.type !== 'FunctionDeclaration') {
+        return bail('the default export is not a plain function declaration');
+    }
+    const layoutFn = exportDefault.declaration;
+    const body = layoutFn.body;
+    if (!body || (body.type !== 'FunctionBody' && body.type !== 'BlockStatement')) {
+        return bail('the layout function has no block body');
+    }
+    const html = findFirst(body, (node) => node?.type === 'JSXElement' && jsxName(node) === 'html');
+    if (!html) {
+        return bail('the layout does not return an <html> element');
+    }
+    const htmlBody = (html.children ?? []).find((child) => child?.type === 'JSXElement' && jsxName(child) === 'body');
+    if (!htmlBody) {
+        return bail('no <body> element found under <html>');
+    }
+    const childrenExpr = findFirst(htmlBody, (node) => node?.type === 'JSXExpressionContainer' &&
+        node.expression?.type === 'Identifier' &&
+        node.expression?.name === 'children');
+    if (!childrenExpr) {
+        return bail('no {children} expression found inside <body>');
+    }
+    const edits = [];
+    if (!layoutFn.async) {
+        edits.push({ start: layoutFn.start, end: layoutFn.start, replacement: 'async ' });
+    }
+    edits.push({
+        start: body.start + 1,
+        end: body.start + 1,
+        replacement: '\n  const config = loadFimoConfig();\n  const labels = await loadFimoLabels();\n',
+    });
+    edits.push({
+        start: childrenExpr.start,
+        end: childrenExpr.end,
+        replacement: `<FimoNextProviders config={config} labels={labels}>${code.slice(childrenExpr.start, childrenExpr.end)}</FimoNextProviders>`,
+    });
+    const head = (html.children ?? []).find((child) => child?.type === 'JSXElement' && jsxName(child) === 'head');
+    if (head) {
+        const at = head.openingElement.end;
+        edits.push({ start: at, end: at, replacement: '<FimoNextScripts />' });
+    }
+    else {
+        const at = html.openingElement.end;
+        edits.push({
+            start: at,
+            end: at,
+            replacement: '\n      <head>\n        <FimoNextScripts />\n      </head>',
+        });
+    }
+    let next = code;
+    for (const edit of edits.sort((a, b) => b.start - a.start)) {
+        next = next.slice(0, edit.start) + edit.replacement + next.slice(edit.end);
+    }
+    next = ensureFimoImport(next, ['FimoNextProviders', 'FimoNextScripts'], 'fimo/next');
+    next = ensureFimoImport(next, ['loadFimoConfig', 'loadFimoLabels'], 'fimo/next/server');
+    fs.writeFileSync(layoutFile, next);
+    return { changes: [`wired Fimo providers into ${rel}`], warnings: [], wired: true };
+}

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

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