fimo 0.6.0 → 0.7.0-experimental.10

package/dist/scripts/scan-wrappable.test.d.ts

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

package/dist/scripts/scan-wrappable.test.js

@@ -0,0 +1,521 @@
+import { describe, expect, it } from 'vitest';
+import { annotateCandidateReferences, scanDataJson, scanWrappableFile } from './scan-wrappable.js';
+const scan = (code) => scanWrappableFile('/test/page.tsx', code, 'app/page.tsx');
+describe('scanWrappableFile', () => {
+    it('records next-intl t() keys with their useTranslations namespace once i18n is Fimo-wired', () => {
+        const code = `import { useTranslations } from 'next-intl';
+export function Checkout() {
+  const t = useTranslations('plans.pricingCheckoutModal');
+  return <button aria-label={t('buyNow')}>{t('cancel')}</button>;
+}`;
+        // Foreign-but-Fimo-wired: the t() calls count as wrapped, and the recorded
+        // key must be the FULL namespaced form (matching the ingested DB label),
+        // not the bare leaf — the seeding gate compares against these.
+        const wired = scanWrappableFile('/x/checkout.tsx', code, 'app/checkout.tsx', { i18nFimoWired: true });
+        expect(wired.wrappedIds.labels.sort()).toEqual([
+            'plans.pricingCheckoutModal.buyNow',
+            'plans.pricingCheckoutModal.cancel',
+        ]);
+        // Not yet wired: still foreign, counted separately, not claimed as coverage.
+        const foreign = scanWrappableFile('/x/checkout.tsx', code, 'app/checkout.tsx');
+        expect(foreign.wrappedIds.labels).toEqual([]);
+        expect(foreign.foreignI18n).toBe(2);
+    });
+    it('finds hardcoded JSX text with its line', () => {
+        const { items } = scan(`export default function Page() {
+  return (
+    <div>
+      <h1>Ship your site in hours</h1>
+    </div>
+  );
+}`);
+        expect(items).toMatchObject([{ kind: 'text', file: 'app/page.tsx', line: 4, preview: 'Ship your site in hours' }]);
+        expect(items[0].span).toMatchObject({ parentTag: 'h1' });
+    });
+    it('skips whitespace and short fragments', () => {
+        const { items } = scan(`const x = <div> {'a'} <span>ok</span> </div>;`);
+        expect(items.filter((i) => i.kind === 'text')).toEqual([]);
+    });
+    it('finds images, videos, file links, and attribute strings', () => {
+        const { items } = scan(`const x = (
+  <div>
+    <img src="/images/hero.png" alt="Hero" />
+    <video src="/demo.mp4" />
+    <a href="/whitepaper.pdf">Download</a>
+    <input placeholder="Your work email" />
+  </div>
+);`);
+        expect(items.map((i) => i.kind).sort()).toEqual(['attribute', 'file-link', 'image', 'text', 'video']);
+        expect(items.find((i) => i.kind === 'attribute')?.preview).toBe('placeholder: Your work email');
+    });
+    it('treats content inside Fimo wrappers as wrapped', () => {
+        const { items, wrapped } = scan(`const x = (
+  <div>
+    <FimoText id="home.hero.title">Ship your site in hours</FimoText>
+    <FimoMediaImage id="home.hero.image" src="/images/hero.png" alt="Hero" />
+  </div>
+);`);
+        expect(items).toEqual([]);
+        expect(wrapped).toBe(2);
+    });
+    it('collects wrapped ids grouped by kind', () => {
+        const { wrappedIds } = scan(`const x = (
+  <div>
+    <FimoText id="home.hero.title">Title</FimoText>
+    <FimoRichTextBlock id="home.hero.body">Body</FimoRichTextBlock>
+    <FimoMediaImage id="home.hero.image" src="/a.png" />
+    <FimoFileLink id="home.hero.pdf" href="/a.pdf">PDF</FimoFileLink>
+    <input placeholder={String(t('home.hero.email', 'Email'))} />
+  </div>
+);`);
+        expect(wrappedIds).toEqual({
+            labels: ['home.hero.title', 'home.hero.email'],
+            media: ['home.hero.image'],
+            richText: ['home.hero.body'],
+            files: ['home.hero.pdf'],
+        });
+    });
+    it('counts t() calls as wrapped and skips regular links', () => {
+        const { items, wrapped } = scan(`const x = <input placeholder={String(t('home.email', 'Your email'))} />;
+const y = <a href="/about">About</a>;`);
+        expect(items.filter((i) => i.kind === 'attribute')).toEqual([]);
+        expect(items.filter((i) => i.kind === 'file-link')).toEqual([]);
+        expect(wrapped).toBe(1);
+    });
+});
+describe('collection candidates', () => {
+    it('detects array literals of same-shaped objects with copy fields', () => {
+        const { collections } = scan(`const focusItems = [
+  { key: "Product", title: "Product Engineering Services", body: "I plan, build, and ship products." },
+  { key: "OSS", title: "Open Source and Dev Tooling", body: "I create reusable components." },
+] as const;
+export function X() { return <div>{focusItems.map((i) => <p key={i.key}>{i.title}</p>)}</div>; }`);
+        expect(collections).toMatchObject([
+            { name: 'focusItems', count: 2, fields: ['body', 'key', 'title'], file: 'app/page.tsx' },
+        ]);
+    });
+    it('ignores config arrays without copy and short lists', () => {
+        const { collections } = scan(`const sizes = [{ w: "sm" }, { w: "lg" }];
+const single = [{ title: "Only one entry here" }];
+export function X() { return null; }`);
+        expect(collections).toEqual([]);
+    });
+});
+describe('reference detection across collection candidates', () => {
+    const postsAndCategories = (postsExtra = '') => `
+const categories = [
+  { slug: "tools", title: "Great tools to use" },
+  { slug: "react", title: "React patterns explained" },
+  { slug: "career", title: "Career growth advice" },
+];
+const authors = [
+  { slug: "jane-doe", name: "Jane Doe", bio: "Writes about frontend things" },
+  { slug: "sam-lee", name: "Sam Lee", bio: "Backend and infra columns" },
+];
+const posts = [
+  { title: "Picking your stack wisely", category: "tools", author: "jane-doe", tags: ["tools", "react"]${postsExtra} },
+  { title: "Hooks beyond the basics", category: "react", author: "sam-lee", tags: ["react"]${postsExtra} },
+  { title: "Negotiating your next role", category: "career", author: "jane-doe", tags: ["career", "tools"]${postsExtra} },
+];
+export default function Page() {
+  return <div>{posts.map((p) => <span>{p.title}</span>)}</div>;
+}`;
+    it('flags fixed and many references by identity-value overlap', () => {
+        const result = scanWrappableFile('/x/page.tsx', postsAndCategories(), 'app/blog/page.tsx');
+        annotateCandidateReferences(result.collections);
+        const posts = result.collections.find((candidate) => candidate.name === 'posts');
+        expect(posts?.references).toEqual([
+            { field: 'category', targets: ['categories'], many: false },
+            { field: 'author', targets: ['authors'], many: false },
+            { field: 'tags', targets: ['categories'], many: true },
+        ]);
+        const categories = result.collections.find((candidate) => candidate.name === 'categories');
+        expect(categories?.references).toBeUndefined();
+    });
+    it('still detects a reference when dangling sentinels dilute distinct coverage (the camp9 miss)', () => {
+        // 4 real authors + 3 distinct dangling values: raw distinct coverage is
+        // 4/7 ≈ 0.57 (< 0.8), but every unmatched value is dangling — the
+        // dangling-adjusted coverage is 4/4 = 1.0.
+        const code = `
+const authors = [
+  { slug: "jane-doe", name: "Jane Doe", bio: "Writes about frontend things" },
+  { slug: "sam-lee", name: "Sam Lee", bio: "Backend and infra columns" },
+  { slug: "ana-ruiz", name: "Ana Ruiz", bio: "Design systems and tokens" },
+  { slug: "kit-tran", name: "Kit Tran", bio: "Performance budgets and CWV" },
+];
+const posts = [
+  { title: "Stack wisdom", author: "jane-doe" },
+  { title: "Hooks again", author: "sam-lee" },
+  { title: "Tokens talk", author: "ana-ruiz" },
+  { title: "Budget lines", author: "kit-tran" },
+  { title: "Orphan one", author: "missing-authors-101" },
+  { title: "Orphan two", author: "missing-authors-202" },
+  { title: "Orphan three", author: "missing-authors-303" },
+];
+export default function Page() {
+  return <div>{posts.map((p) => <span>{p.title}</span>)}</div>;
+}`;
+        const result = scanWrappableFile('/x/page.tsx', code, 'app/blog/page.tsx');
+        annotateCandidateReferences(result.collections);
+        const posts = result.collections.find((candidate) => candidate.name === 'posts');
+        expect(posts?.references).toEqual([{ field: 'author', targets: ['authors'], many: false }]);
+    });
+    it('detects references across LARGE collections (identity sets are not window-capped)', () => {
+        // 1,500 authors referenced by 3,000 posts (+10% dangling): the old
+        // 100-value window saw ~7% of the identity space and dropped the
+        // relation entirely at this scale (the camp9/camp10 miss).
+        const authors = Array.from({ length: 1500 }, (_, index) => ({
+            slug: `author-${index}`,
+            name: `Author Number ${index}`,
+            bio: `Writes the column number ${index} about harbors`,
+        }));
+        const posts = Array.from({ length: 3000 }, (_, index) => ({
+            slug: `post-${index}`,
+            title: `Post number ${index} about the tide`,
+            author: index % 10 === 9 ? `missing-authors-${index}` : `author-${index % 1500}`,
+        }));
+        const result = scanDataJson('src/data/authors.json', JSON.stringify(authors));
+        const postsScan = scanDataJson('src/data/posts.json', JSON.stringify(posts));
+        const matchables = [
+            { name: 'authors', fieldValues: result.collections[0].fieldValues, manyFields: [] },
+            { name: 'posts', fieldValues: postsScan.collections[0].fieldValues, manyFields: [] },
+        ];
+        annotateCandidateReferences(matchables);
+        expect(matchables[1].references).toEqual([
+            { field: 'author', targets: ['authors'], many: false },
+        ]);
+    });
+    it('does not promote a field whose values mostly match nothing (coincidence guard)', () => {
+        const code = `
+const authors = [
+  { slug: "red", name: "Red Woods", bio: "Writes the forest column" },
+  { slug: "blue", name: "Blue Lake", bio: "Covers the waterline" },
+  { slug: "jane-doe", name: "Jane Doe", bio: "Writes about frontend" },
+];
+const cards = [
+  { label: "One", color: "red" },
+  { label: "Two", color: "blue" },
+  { label: "Three", color: "crimson" },
+  { label: "Four", color: "teal" },
+  { label: "Five", color: "amber" },
+];
+export default function Page() {
+  return <div>{cards.map((c) => <span>{c.label}</span>)}</div>;
+}`;
+        const result = scanWrappableFile('/x/page.tsx', code, 'app/page.tsx');
+        annotateCandidateReferences(result.collections);
+        const cards = result.collections.find((candidate) => candidate.name === 'cards');
+        expect(cards?.references).toBeUndefined();
+    });
+    it('flags polymorphic references when values split across two candidates', () => {
+        const code = `
+const articles = [
+  { slug: "intro-post", title: "An introduction post" },
+  { slug: "deep-dive", title: "A deep dive article" },
+];
+const videos = [
+  { slug: "launch-video", title: "The launch keynote video" },
+  { slug: "demo-video", title: "A recorded product demo" },
+];
+const featured = [
+  { label: "First featured slot", item: "intro-post" },
+  { label: "Second featured slot", item: "launch-video" },
+  { label: "Third featured slot", item: "deep-dive" },
+  { label: "Fourth featured slot", item: "demo-video" },
+];
+export default function Page() {
+  return <div>{featured.map((f) => <span>{f.label}</span>)}</div>;
+}`;
+        const result = scanWrappableFile('/x/page.tsx', code, 'app/page.tsx');
+        annotateCandidateReferences(result.collections);
+        const featured = result.collections.find((candidate) => candidate.name === 'featured');
+        expect(featured?.references).toEqual([{ field: 'item', targets: ['articles', 'videos'], many: false }]);
+    });
+    it('annotates across files and strips internal value sets at scan level', async () => {
+        const { mkdtempSync, mkdirSync, writeFileSync, rmSync } = await import('node:fs');
+        const { tmpdir } = await import('node:os');
+        const { join } = await import('node:path');
+        const { scanWrappable } = await import('./scan-wrappable.js');
+        const root = mkdtempSync(join(tmpdir(), 'ref-scan-'));
+        try {
+            mkdirSync(join(root, 'app'), { recursive: true });
+            writeFileSync(join(root, 'app', 'categories.ts'), `export const categories = [
+  { slug: "tools", title: "Great tools to use" },
+  { slug: "react", title: "React patterns explained" },
+];\n`);
+            writeFileSync(join(root, 'app', 'page.tsx'), `const posts = [
+  { title: "Picking your stack wisely", category: "tools" },
+  { title: "Hooks beyond the basics", category: "react" },
+];
+export default function Page() {
+  return <div>{posts.map((p) => <span>{p.title}</span>)}</div>;
+}\n`);
+            const result = scanWrappable(root, { dirs: ['app'] });
+            const posts = result.collections.find((candidate) => candidate.name === 'posts');
+            expect(posts?.references).toEqual([{ field: 'category', targets: ['categories'], many: false }]);
+            for (const candidate of result.collections) {
+                expect(candidate.fieldValues).toBeUndefined();
+            }
+        }
+        finally {
+            rmSync(root, { recursive: true, force: true });
+        }
+    });
+});
+describe('data-file copy detection', () => {
+    it('flags a config-driven copy file with collection shapes, skipping identifiers and URLs', () => {
+        const detected = scanDataJson('src/data/landing.json', JSON.stringify({
+            meta: { title: 'Luna Landing your perfect landing page', lang: 'en', url: 'https://x.dev' },
+            hero: { title: 'Open Your Mind to the Universe', primaryCta: 'Github Repo', icon: 'DevIcon' },
+            services: [
+                { title: 'Professional Templates', icon: 'DevIcon', description: 'Crafted by experienced designers' },
+                { title: 'Code Quality', icon: 'CheckIcon', description: 'Readable and maintainable output' },
+            ],
+        }));
+        expect(detected).not.toBeNull();
+        expect(detected.strings).toBeGreaterThanOrEqual(5);
+        expect(detected.collections).toHaveLength(1);
+        expect(detected.collections[0]).toMatchObject({
+            path: 'services',
+            length: 2,
+            copyFields: ['title', 'description'],
+        });
+    });
+    it('parses YAML data files (Nuxt Content index.yml) with the same walker', () => {
+        const detected = scanDataJson('content/index.yml', [
+            'title: "Observe less. Understand more."',
+            'description: Map your entire system in real-time and surface anomalies.',
+            'hero:',
+            '  headline: "v2.0 — Now with predictive alerting"',
+            '  links:',
+            '    - label: Start for free',
+            '      to: "#"',
+            '    - label: View the demo now',
+            '      to: "#"',
+        ].join('\n'));
+        expect(detected).not.toBeNull();
+        expect(detected.strings).toBeGreaterThanOrEqual(3);
+    });
+    it('ignores GeoJSON payloads whose name properties read like prose', () => {
+        const detected = scanDataJson('src/lib/world.json', JSON.stringify({
+            type: 'FeatureCollection',
+            features: [
+                { type: 'Feature', properties: { name: 'Bosnia and Herzegovina' }, geometry: {} },
+                { type: 'Feature', properties: { name: 'United Arab Emirates' }, geometry: {} },
+                { type: 'Feature', properties: { name: 'Papua New Guinea' }, geometry: {} },
+            ],
+        }));
+        expect(detected).toBeNull();
+    });
+    it('ignores non-copy json (identifiers, paths, short tokens)', () => {
+        const detected = scanDataJson('src/data/routes.json', JSON.stringify({
+            routes: [
+                { id: 'a', href: '/a' },
+                { id: 'b', href: '/b' },
+            ],
+            theme: 'dark',
+        }));
+        expect(detected).toBeNull();
+    });
+});
+describe('markdown prose triage', () => {
+    it('groups md/mdx documents per directory into dataFiles', async () => {
+        const { mkdtempSync, mkdirSync, writeFileSync, rmSync } = await import('node:fs');
+        const { tmpdir } = await import('node:os');
+        const { join } = await import('node:path');
+        const { scanWrappable } = await import('./scan-wrappable.js');
+        const root = mkdtempSync(join(tmpdir(), 'md-scan-'));
+        try {
+            mkdirSync(join(root, 'src', 'posts'), { recursive: true });
+            const prose = Array.from({ length: 4 }, (_, i) => `This is a long enough prose paragraph number ${i} for the post.`).join('\n');
+            writeFileSync(join(root, 'src', 'posts', 'one.md'), `---\ntitle: One\n---\n${prose}\n`);
+            writeFileSync(join(root, 'src', 'posts', 'two.mdx'), `${prose}\n`);
+            writeFileSync(join(root, 'src', 'README.md'), `${prose}\n`);
+            const result = scanWrappable(root, { dirs: ['src'] });
+            const groups = result.dataFiles.filter((f) => f.kind === 'markdown');
+            expect(groups).toHaveLength(1);
+            expect(groups[0]).toMatchObject({ file: 'src/posts/*.md', count: 2 });
+        }
+        finally {
+            rmSync(root, { recursive: true, force: true });
+        }
+    });
+});
+describe('scanExternalSources', () => {
+    it('records API base URLs declared as constants in plain script files', async () => {
+        const { mkdtempSync, mkdirSync, writeFileSync, rmSync } = await import('node:fs');
+        const { tmpdir } = await import('node:os');
+        const { join } = await import('node:path');
+        const { scanWrappable } = await import('./scan-wrappable.js');
+        const root = mkdtempSync(join(tmpdir(), 'ext-src-'));
+        try {
+            mkdirSync(join(root, 'server'), { recursive: true });
+            writeFileSync(join(root, 'server', 'constants.ts'), "export const API = 'https://data.example-api.dev/v0';\n");
+            mkdirSync(join(root, 'app'), { recursive: true });
+            writeFileSync(join(root, 'app', 'page.tsx'), 'export const links = <a href="https://github.com/x">gh</a>;\n');
+            const result = scanWrappable(root, { dirs: ['app', 'server'] });
+            const hosts = result.externalSources.map((source) => source.host);
+            expect(hosts).toContain('data.example-api.dev');
+            expect(hosts).not.toContain('github.com');
+        }
+        finally {
+            rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('finds third-party fetches by host, ignoring internal ones', 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(), 'ext-src-'));
+        try {
+            mkdirSync(join(dir, 'src/lib'), { recursive: true });
+            writeFileSync(join(dir, 'src/lib/data.ts'), 'export async function x(u: string) {\n' +
+                '  await fetch("https://api.example.com/articles");\n' +
+                '  await fetch(`https://cdn.example.net/users/${u}/repos`);\n' +
+                '  await fetch("http://localhost:3000/api/labels");\n' +
+                '  await fetch("/api/relative");\n' +
+                '}\n');
+            const { scanExternalSources } = await import('./scan-wrappable.js');
+            const sources = scanExternalSources(dir, ['src']);
+            expect(sources.map((source) => source.host)).toEqual(['api.example.com', 'cdn.example.net']);
+            expect(sources[0].files).toEqual(['src/lib/data.ts']);
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe('CMS SDK detection', () => {
+    // Any entry of the CMS_SDKS list works here — the LIST is the contract,
+    // no vendor is special-cased.
+    it('flags headless-CMS dependencies as cms sources', 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(), 'cms-'));
+        try {
+            mkdirSync(join(dir, 'src'), { recursive: true });
+            writeFileSync(join(dir, 'package.json'), JSON.stringify({ dependencies: { contentful: '^11.0.0', next: '^16' } }));
+            writeFileSync(join(dir, 'src/a.tsx'), 'export const x = 1;');
+            const { scanExternalSources } = await import('./scan-wrappable.js');
+            const sources = scanExternalSources(dir, ['src']);
+            expect(sources).toMatchObject([{ host: 'Contentful', kind: 'cms', files: ['package.json'] }]);
+        }
+        finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+describe('template scanning (.astro/.vue/.svelte)', () => {
+    it('counts raw text as items and t()/data-fimo-source as wrapped', () => {
+        const astro = scanWrappableFile('/x/page.astro', `---\nimport { loadFimoT } from 'fimo/astro/server';\nconst t = await loadFimoT();\n---\n<h1>{t('home.title', 'Hello')}</h1>\n<p>Raw hardcoded copy here</p>`, 'src/pages/index.astro');
+        expect(astro.wrapped).toBeGreaterThanOrEqual(1);
+        expect(astro.wrappedIds.labels).toContain('home.title');
+        expect(astro.items.map((i) => i.preview)).toContain('Raw hardcoded copy here');
+        const vue = scanWrappableFile('/x/index.vue', `<template>\n  <h1>{{ t('a.b', 'Hi') }}</h1>\n  <p>Plain vue text content</p>\n</template>\n<script setup>const x = 1;</script>`, 'pages/index.vue');
+        expect(vue.wrappedIds.labels).toContain('a.b');
+        expect(vue.items.map((i) => i.preview)).toContain('Plain vue text content');
+        const svelte = scanWrappableFile('/x/+page.svelte', `<script>let n = 1;</script>\n<h1 data-fimo-source="__labels.en.k.value">Val</h1>\n<p>Svelte hardcoded words</p>`, 'src/routes/+page.svelte');
+        expect(svelte.wrapped).toBeGreaterThanOrEqual(1);
+        expect(svelte.items.map((i) => i.preview)).toContain('Svelte hardcoded words');
+    });
+    it('never reports astro <script>/<style> bodies or nested {expressions} as copy', () => {
+        const astro = scanWrappableFile('/x/page.astro', [
+            '---',
+            'const { title, body } = Astro.props;',
+            '---',
+            '<script>',
+            '  import { timeline } from "motion";',
+            '  const sequence = [loaderAnimation];',
+            '</script>',
+            '<style>',
+            '  @font-face { font-family: X; } body { color: red; }',
+            '</style>',
+            '{title && <h2 class="text-xl">{title}</h2>}',
+            '{body && <p>{body}</p>}',
+            '<p>Actual astro copy stays visible</p>',
+        ].join('\n'), 'src/components/Content.astro');
+        expect(astro.items.map((i) => i.preview)).toEqual(['Actual astro copy stays visible']);
+        const copy = astro.items[0];
+        expect(copy.line).toBe(13);
+    });
+    it('strips HTML comments, including ones with apostrophes', () => {
+        const astro = scanWrappableFile('/x/Layout.astro', `---\n---\n<!-- Basic OG tags for sharing your website's content -->\n<p>Layout visible copy</p>`, 'src/layouts/Layout.astro');
+        expect(astro.items.map((i) => i.preview)).toEqual(['Layout visible copy']);
+    });
+    it('handles > inside quoted attributes (v-if="page > 1")', () => {
+        const vue = scanWrappableFile('/x/Nav.vue', `<template>\n<a v-if="page > 1" :to="\`/\${feed}/\${page - 1}\`">&lt; prev</a>\n<span>Real nav copy</span>\n</template>`, 'components/Nav.vue');
+        expect(vue.items.map((i) => i.preview)).toEqual(['&lt; prev', 'Real nav copy']);
+    });
+    it('skips inline-svg <title> inside vue templates', () => {
+        const vue = scanWrappableFile('/x/Navbar.vue', `<template>\n<svg><title>Menu</title><path d="M0 0"/></svg>\n<p>Visible vue nav copy</p>\n</template>`, 'components/Navbar.vue');
+        expect(vue.items.map((i) => i.preview)).toEqual(['Visible vue nav copy']);
+    });
+    it('skips <title> head metadata (svelte:head and astro layouts)', () => {
+        const svelte = scanWrappableFile('/x/+page.svelte', `<svelte:head>\n  <title>Home page name</title>\n</svelte:head>\n<p>Visible svelte body copy</p>`, 'src/routes/+page.svelte');
+        expect(svelte.items.map((i) => i.preview)).toEqual(['Visible svelte body copy']);
+    });
+    it('detects collection candidates inside SFC script blocks (pricing tiers in script setup)', () => {
+        const vue = scanWrappableFile('/x/pricing.vue', [
+            '<script setup>',
+            'const pricing = [',
+            '  { name: "Personal", price: "Free tier", button: "Get Started" },',
+            '  { name: "Startup", price: "$19 monthly", button: "Try free" },',
+            '];',
+            '</script>',
+            '<template><div v-for="tier in pricing">{{ tier.name }}</div></template>',
+        ].join('\n'), 'pages/pricing.vue');
+        expect(vue.collections).toHaveLength(1);
+        expect(vue.collections[0]).toMatchObject({ name: 'pricing', count: 2, file: 'pages/pricing.vue', line: 2 });
+    });
+    it('handles CRLF astro frontmatter fences', () => {
+        const astro = scanWrappableFile('/x/page.astro', "---\r\nimport Layout from '../layouts/Default.astro'\r\n---\r\n<p>Windows checkout copy</p>\r\n", 'src/pages/index.astro');
+        expect(astro.items.map((i) => i.preview)).toEqual(['Windows checkout copy']);
+    });
+    it('counts t() inside astro template <script> blocks as wrapped', () => {
+        const astro = scanWrappableFile('/x/page.astro', `---\n---\n<script>\n  const label = t('nav.home', 'Home');\n</script>\n<h1>Hi there friend</h1>`, 'src/pages/index.astro');
+        expect(astro.wrappedIds.labels).toContain('nav.home');
+    });
+});
+describe('foreign i18n coverage (the next-intl false-positive)', () => {
+    it('does NOT count t() as wrapped when t is bound from next-intl', () => {
+        const { wrapped, wrappedIds } = scan(`import { useTranslations } from 'next-intl';
+export default function Page() {
+  const t = useTranslations('home');
+  return <div><h1>{t('title')}</h1><p>{t('subtitle')}</p></div>;
+}`);
+        expect(wrapped).toBe(0);
+        expect(wrappedIds.labels).toEqual([]);
+    });
+    it('DOES count t() as wrapped when t is Fimo (useLabels)', () => {
+        const { wrapped, wrappedIds } = scan(`import { useLabels } from 'fimo/next';
+export default function Page() {
+  const { t } = useLabels();
+  return <div><h1>{t('home.title', 'Title')}</h1></div>;
+}`);
+        expect(wrapped).toBe(1);
+        expect(wrappedIds.labels).toEqual(['home.title']);
+    });
+    it('reports the foreign i18n count at the scan level', async () => {
+        const { mkdtempSync, mkdirSync, writeFileSync, rmSync } = await import('node:fs');
+        const { tmpdir } = await import('node:os');
+        const { join } = await import('node:path');
+        const { scanWrappable } = await import('./scan-wrappable.js');
+        const root = mkdtempSync(join(tmpdir(), 'foreign-i18n-'));
+        try {
+            mkdirSync(join(root, 'app'), { recursive: true });
+            writeFileSync(join(root, 'package.json'), JSON.stringify({ name: 't', dependencies: { next: '^15.0.0' } }));
+            writeFileSync(join(root, 'app', 'page.tsx'), `import { useTranslations } from 'next-intl';
+export default function Page() {
+  const t = useTranslations();
+  return <div>{t('a')} {t('b')} {t('c')}</div>;
+}`);
+            const result = scanWrappable(root);
+            expect(result.foreignI18nCount).toBe(3);
+            expect(result.wrappedCount).toBe(0);
+        }
+        finally {
+            rmSync(root, { recursive: true, force: true });
+        }
+    });
+});

package/dist/scripts/validate-route-metadata.js

@@ -31,6 +31,17 @@ export function validateRouteMetadata(options = {}) {
     const srcDir = path.resolve(cwd, 'src');
     const routesFilePath = path.resolve(srcDir, 'routes.ts');
     const errors = [];
+    // Everything below the i18n checks cross-validates React Router's
+    // src/routes.ts. Adopted (wrapped) projects on another framework declare it
+    // in fimo-config.json — their routes come from framework scans, so only the
+    // framework-neutral config checks apply.
+    const earlyConfig = readJson(configFilePath);
+    const framework = typeof earlyConfig.framework === 'string' ? earlyConfig.framework : 'react-router';
+    if (framework !== 'react-router') {
+        const i18n = validateI18nConfig(earlyConfig);
+        const configRoutes = loadConfigRoutes(earlyConfig);
+        return { errors: i18n.errors, routesChecked: configRoutes.length };
+    }
     // Parse routes from src/routes.ts (file → path mapping)
     let fileRoutes = [];
     if (!fs.existsSync(routesFilePath)) {