fimo 0.7.0-experimental.3 → 0.7.0-experimental.5

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,26 @@
+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;
+}
+/**
+ * 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,163 @@
+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;
+/**
+ * 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 layoutFile = ['layout.tsx', 'layout.jsx', 'layout.js']
+        .map((candidate) => path.join(cwd, detection.appDir, candidate))
+        .find((candidate) => fs.existsSync(candidate));
+    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');
+    if (code.includes('FimoNextProviders')) {
+        return { changes: [], warnings: [], wired: true };
+    }
+    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 {};

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

@@ -0,0 +1,146 @@
+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 { ensureNextLayoutWiring, ensureNextWiring } from './wiring.js';
+let dir;
+const project = (files) => {
+    dir = mkdtempSync(join(tmpdir(), 'next-wiring-'));
+    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 CREATE_NEXT_APP_LAYOUT = `import type { Metadata } from 'next';
+import './globals.css';
+
+export const metadata: Metadata = { title: 'Harbor Docs' };
+
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en">
+      <body className="antialiased">{children}</body>
+    </html>
+  );
+}
+`;
+describe('ensureNextLayoutWiring', () => {
+    it('wires the create-next-app default layout end to end', () => {
+        const root = project({ 'app/layout.tsx': CREATE_NEXT_APP_LAYOUT });
+        const result = ensureNextLayoutWiring(root, { appDir: 'app' });
+        const code = readFileSync(join(root, 'app/layout.tsx'), 'utf8');
+        expect(result.wired).toBe(true);
+        expect(result.changes).toEqual(['wired Fimo providers into app/layout.tsx']);
+        expect(code).toContain('import { FimoNextProviders, FimoNextScripts } from "fimo/next";');
+        expect(code).toContain('import { loadFimoConfig, loadFimoLabels } from "fimo/next/server";');
+        expect(code).toContain('export default async function RootLayout');
+        expect(code).toContain('const config = loadFimoConfig();');
+        expect(code).toContain('const labels = await loadFimoLabels();');
+        expect(code).toContain('<body className="antialiased"><FimoNextProviders config={config} labels={labels}>{children}</FimoNextProviders></body>');
+        expect(code).toContain('<head>');
+        expect(code).toContain('<FimoNextScripts />');
+        // Head lands inside <html>, before <body>.
+        expect(code.indexOf('<FimoNextScripts />')).toBeGreaterThan(code.indexOf('<html'));
+        expect(code.indexOf('<FimoNextScripts />')).toBeLessThan(code.indexOf('<body'));
+    });
+    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 }) {
+  return (
+    <html>
+      <head>
+        <link rel="icon" href="/favicon.ico" />
+      </head>
+      <body>
+        <div id="shell">{children}</div>
+      </body>
+    </html>
+  );
+}
+`,
+        });
+        const result = ensureNextLayoutWiring(root, { appDir: 'src/app' });
+        const code = readFileSync(join(root, 'src/app/layout.jsx'), 'utf8');
+        expect(result.wired).toBe(true);
+        expect(code).not.toContain('async async');
+        expect(code).toContain('<head><FimoNextScripts />');
+        // children was NOT a direct body child — the nested container still wraps.
+        expect(code).toContain('<FimoNextProviders config={config} labels={labels}>{children}</FimoNextProviders>');
+        expect(code.match(/<head>/g)).toHaveLength(1);
+    });
+    it('is a no-op when the layout is already wired', () => {
+        const wired = CREATE_NEXT_APP_LAYOUT.replace('{children}', '<FimoNextProviders>{children}</FimoNextProviders>');
+        const root = project({ 'app/layout.tsx': wired });
+        const result = ensureNextLayoutWiring(root, { appDir: 'app' });
+        expect(result.wired).toBe(true);
+        expect(result.changes).toEqual([]);
+        expect(readFileSync(join(root, 'app/layout.tsx'), 'utf8')).toBe(wired);
+    });
+    it('bails on pages-router-only projects', () => {
+        const root = project({ 'pages/index.tsx': 'export default function Home() { return <p>hi</p>; }\n' });
+        const result = ensureNextLayoutWiring(root, { appDir: undefined });
+        expect(result.wired).toBe(false);
+        expect(result.warnings[0]).toContain('pages-router');
+    });
+    it('bails when the default export is not a plain function', () => {
+        const source = `const Layout = ({ children }) => <html><body>{children}</body></html>;
+export default Layout;
+`;
+        const root = project({ 'app/layout.tsx': source });
+        const result = ensureNextLayoutWiring(root, { appDir: 'app' });
+        expect(result.wired).toBe(false);
+        expect(result.warnings[0]).toContain('not a plain function declaration');
+        expect(readFileSync(join(root, 'app/layout.tsx'), 'utf8')).toBe(source);
+    });
+    it('bails when no {children} expression exists inside <body>', () => {
+        const root = project({
+            'app/layout.tsx': `export default function Layout(props) {
+  return (
+    <html>
+      <body>{props.children}</body>
+    </html>
+  );
+}
+`,
+        });
+        const result = ensureNextLayoutWiring(root, { appDir: 'app' });
+        expect(result.wired).toBe(false);
+        expect(result.warnings[0]).toContain('no {children} expression');
+    });
+});
+describe('ensureNextWiring config patch', () => {
+    it('patches the named nextConfig binding', () => {
+        const root = project({
+            'next.config.ts': `const nextConfig = {\n  reactStrictMode: true,\n};\nexport default nextConfig;\n`,
+        });
+        const result = ensureNextWiring(root);
+        expect(result.changes).toEqual(['added allowedDevOrigins to next.config.ts']);
+        expect(readFileSync(join(root, 'next.config.ts'), 'utf8')).toContain("allowedDevOrigins: ['*.preview.fimo.ai'],");
+    });
+    it('patches a direct export default object literal (.mjs)', () => {
+        const root = project({
+            'next.config.mjs': `/** @type {import('next').NextConfig} */\nexport default {};\n`,
+        });
+        const result = ensureNextWiring(root);
+        expect(result.changes).toEqual(['added allowedDevOrigins to next.config.mjs']);
+        const code = readFileSync(join(root, 'next.config.mjs'), 'utf8');
+        expect(code).toContain("allowedDevOrigins: ['*.preview.fimo.ai'],");
+        expect(code).toContain('export default {');
+    });
+    it('patches module.exports form and warns on unrecognized shapes', () => {
+        const cjs = project({ 'next.config.cjs': `module.exports = {\n  poweredByHeader: false,\n};\n` });
+        expect(ensureNextWiring(cjs).changes).toHaveLength(1);
+        rmSync(cjs, { recursive: true, force: true });
+        const weird = project({ 'next.config.js': `module.exports = buildConfig();\n` });
+        const result = ensureNextWiring(weird);
+        expect(result.changes).toEqual([]);
+        expect(result.warnings[0]).toContain('Could not patch next.config.js');
+    });
+});

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

@@ -0,0 +1,3 @@
+import type { DiscoveredRoute } from '../next/routes.js';
+/** Nuxt file-based routes under pages/ (index.vue maps to the dir path). */
+export declare function discoverNuxtRoutes(pagesDir: string): DiscoveredRoute[];

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

@@ -0,0 +1,54 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+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 pushRoute(routes, parts) {
+    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),
+    });
+}
+const toSegment = (name) => name.replace(/^\[\.\.\.(.+)\]$/, ':$1').replace(/^\[(.+)\]$/, ':$1');
+/** Nuxt file-based routes under pages/ (index.vue maps to the dir path). */
+export function discoverNuxtRoutes(pagesDir) {
+    const routes = [];
+    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) {
+                walk(full, [...segments, toSegment(entry)]);
+                continue;
+            }
+            if (!entry.endsWith('.vue')) {
+                continue;
+            }
+            const base = entry.replace(/\.vue$/, '');
+            pushRoute(routes, base === 'index' ? segments : [...segments, toSegment(base)]);
+        }
+    };
+    walk(pagesDir, []);
+    routes.sort((a, b) => a.path.localeCompare(b.path));
+    return routes;
+}

package/dist/scripts/frameworks/nuxt/template-style.d.ts

@@ -0,0 +1,9 @@
+import type { TemplateWrapStyle } from '../../apply-wrap-templates.js';
+/**
+ * Nuxt template wraps: the useFimoT composable is client-safe (fimo/nuxt
+ * never pulls server loaders into the bundle) and transfers the dictionary
+ * through the Nuxt payload, so a single `<script setup>` line wires a file.
+ * Options-API scripts have no safe injection point (top-level await needs
+ * setup) — those files stay agent work.
+ */
+export declare const nuxtTemplateWrapStyle: TemplateWrapStyle;

package/dist/scripts/frameworks/nuxt/template-style.js

@@ -0,0 +1,27 @@
+/**
+ * Nuxt template wraps: the useFimoT composable is client-safe (fimo/nuxt
+ * never pulls server loaders into the bundle) and transfers the dictionary
+ * through the Nuxt payload, so a single `<script setup>` line wires a file.
+ * Options-API scripts have no safe injection point (top-level await needs
+ * setup) — those files stay agent work.
+ */
+export const nuxtTemplateWrapStyle = {
+    ext: '.vue',
+    head: "import { useFimoT } from 'fimo/nuxt'\nconst t = await useFimoT()",
+    headMarker: /useFimoT/,
+    open: '{{ t(',
+    close: ') }}',
+    injectHead: (code, head) => {
+        // An SFC may carry BOTH <script> and <script setup>: target the setup
+        // block specifically (top-level await is only legal there).
+        const setup = code.match(/<script[^>]*\bsetup\b[^>]*>\r?\n?/);
+        if (setup && setup.index !== undefined) {
+            const at = setup.index + setup[0].length;
+            return `${code.slice(0, at)}${head}\n${code.slice(at)}`;
+        }
+        if (/<script\b/.test(code)) {
+            return null;
+        }
+        return `<script setup>\n${head}\n</script>\n\n${code}`;
+    },
+};

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

@@ -0,0 +1,3 @@
+import type { DiscoveredRoute } from '../next/routes.js';
+/** Remix v2 flat routes under app/routes: dots are slashes, $param is dynamic. */
+export declare function discoverRemixRoutes(routesDir: string): DiscoveredRoute[];