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

package/dist/scripts/draft-rows.test.js

@@ -0,0 +1,113 @@
+import { existsSync, 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 { writeRowsStaging } from './draft-rows.js';
+import { writeSchemaDrafts } from './draft-schemas.js';
+import { scanWrappable } from './scan-wrappable.js';
+let dir;
+const project = (files) => {
+    dir = mkdtempSync(join(tmpdir(), 'draft-rows-'));
+    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('writeRowsStaging', () => {
+    it('stages data-file rows with media envelopes, richtext docs, and a reference descriptor', () => {
+        const root = project({
+            'src/data/authors.json': JSON.stringify([
+                { slug: 'author-1', name: 'Maë Falk', bio: 'Keeps the berths in order at dawn.' },
+                { slug: 'author-2', name: 'Idris Kade', bio: 'Maps the tide tables by hand.' },
+                { slug: 'author-3', name: 'Sol Ferry', bio: 'Counts the lanterns every night.' },
+            ]),
+            'src/data/posts.json': JSON.stringify([
+                {
+                    slug: 'post-1',
+                    title: 'Charting the bay together',
+                    body: 'First paragraph of prose.\n\nSecond paragraph of prose.',
+                    coverImage: '/images/bay.png',
+                    author: 'author-1',
+                },
+                {
+                    slug: 'post-2',
+                    title: 'Berth songs for the crew',
+                    body: 'Another body paragraph.\n\nAnd its second half.',
+                    coverImage: '/images/berth.png',
+                    author: 'author-2',
+                },
+                {
+                    slug: 'post-3',
+                    title: 'Lanterns over the reef',
+                    body: 'Prose again in two parts.\n\nHere is the second.',
+                    coverImage: '/images/reef.png',
+                    author: 'author-3',
+                },
+            ]),
+        });
+        const scan = scanWrappable(root, { keepInternal: true });
+        const drafts = writeSchemaDrafts(root, scan);
+        const written = writeRowsStaging(root, scan, drafts);
+        expect(written).toBe(2);
+        const posts = JSON.parse(readFileSync(join(root, '.fimo/migration/rows/Post.rows.json'), 'utf8'));
+        expect(posts.draftUid).toBe('Post');
+        expect(posts.references.author).toEqual({ target: 'Author', by: 'slug' });
+        expect(posts.rows).toHaveLength(3);
+        // Media enveloped, richtext converted, reference kept as SOURCE value.
+        expect(posts.rows[0].coverImage).toEqual({ source: 'local', url: '/images/bay.png', alt: '' });
+        expect(posts.rows[0].body.type).toBe('doc');
+        expect(posts.rows[0].body.content).toHaveLength(2);
+        expect(posts.rows[0].author).toBe('author-1');
+    });
+    it('stages a markdown group: verbatim body + typed frontmatter, one row per doc', () => {
+        const md = (title, body) => `---\ntitle: ${title}\ndate: 2026-03-01\n---\n\n${body}\n`;
+        const root = project({
+            'src/updates/first-release.md': md('First release', 'We shipped **the harbor** at last.\n\nMore detail here.'),
+            'src/updates/second-release.md': md('Second release', 'The north pier reopened.\n\nWith new lanterns.'),
+        });
+        const scan = scanWrappable(root, { keepInternal: true });
+        const drafts = writeSchemaDrafts(root, scan);
+        const written = writeRowsStaging(root, scan, drafts);
+        expect(written).toBe(1);
+        const update = JSON.parse(readFileSync(join(root, '.fimo/migration/rows/Update.rows.json'), 'utf8'));
+        expect(update.draftUid).toBe('Update');
+        expect(update.rows).toHaveLength(2);
+        // Slug from the filename stem; body is the raw markdown, verbatim.
+        expect(update.rows[0].slug).toBe('first-release');
+        expect(update.rows[0].title).toBe('First release');
+        expect(update.rows[0].body).toBe('We shipped **the harbor** at last.\n\nMore detail here.');
+        expect(typeof update.rows[0].body).toBe('string');
+    });
+    it('stages in-code candidates from their typed rows', () => {
+        const root = project({
+            'src/pages/team.tsx': `const teamMembers = [
+  { name: 'Maë Falk', bio: 'Keeps the berths in order.', headshot: '/images/mae.png', boats: 3 },
+  { name: 'Idris Kade', bio: 'Maps every tide table.', headshot: '/images/idris.png', boats: 5 },
+];
+export default function Team() {
+  return <ul>{teamMembers.map((m) => (<li key={m.name}>{m.name} {m.bio}</li>))}</ul>;
+}
+`,
+        });
+        const scan = scanWrappable(root, { keepInternal: true });
+        const drafts = writeSchemaDrafts(root, scan);
+        const written = writeRowsStaging(root, scan, drafts);
+        expect(written).toBe(1);
+        const team = JSON.parse(readFileSync(join(root, '.fimo/migration/rows/TeamMember.rows.json'), 'utf8'));
+        expect(team.rows).toHaveLength(2);
+        expect(team.rows[1]).toEqual({
+            name: 'Idris Kade',
+            bio: 'Maps every tide table.',
+            headshot: { source: 'local', url: '/images/idris.png', alt: '' },
+            boats: 5,
+        });
+        expect(existsSync(join(root, '.fimo/migration/rows'))).toBe(true);
+    });
+});

package/dist/scripts/draft-schemas.d.ts

@@ -0,0 +1,27 @@
+import type { WrapScanResult } from './scan-wrappable.js';
+/**
+ * Machine-typed schema DRAFTS for every detected collection. The forensic
+ * timeline of a real 43-minute agent migration showed ~26 minutes spent
+ * deliberating and re-probing type behavior before the first schema file
+ * appeared — while the scanner already knew every field, its sampled values,
+ * and the reference targets. This module turns that knowledge into pushable
+ * draft files so the agent's job collapses to what only an agent can do:
+ * CLASSIFY the candidate and NAME the type. Names emitted here are
+ * PROVISIONAL by contract (mechanical singular/PascalCase of the source
+ * name); the drafts never touch src/schemas — the agent reviews, renames,
+ * copies, pushes.
+ */
+export interface SchemaDraft {
+    file: string;
+    uid: string;
+    /** Original candidate/source name (pre-rename), for cross-artifact maps. */
+    sourceName: string;
+    source: string;
+    fields: Record<string, unknown>;
+}
+/**
+ * Write `.fimo/migration/schema-drafts/<Provisional>.json` (exact pushable
+ * shape) for every detected collection, plus a README stating the contract.
+ * Regenerated on every run — drafts are machine output, never hand-edited.
+ */
+export declare function writeSchemaDrafts(rootDir: string, scan: WrapScanResult): SchemaDraft[];

package/dist/scripts/draft-schemas.js

@@ -0,0 +1,188 @@
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}([T ].*)?$/;
+const MEDIA_PATH = /^\/(images|img|videos|video|media|assets|files|docs|documents)\//i;
+const MEDIA_EXT = /\.(png|jpe?g|gif|webp|avif|svg|mp4|webm|mov|mp3|wav|pdf|zip|docx?)$/i;
+function singularPascal(name) {
+    const base = name
+        .replace(/[^a-zA-Z0-9]+(.)/g, (_, c) => c.toUpperCase())
+        .replace(/^(.)/, (c) => c.toUpperCase());
+    if (/ies$/i.test(base)) {
+        return base.replace(/ies$/i, 'y');
+    }
+    if (/[^aeiou](ses|xes|zes)$/i.test(base) || /(ches|shes)$/i.test(base)) {
+        // Classes -> Class, Boxes -> Box — but vowel+ses words (Releases,
+        // Cases) are plain plurals and only drop the trailing s below.
+        return base.replace(/es$/i, '');
+    }
+    if (/s$/i.test(base) && !/ss$/i.test(base)) {
+        return base.replace(/s$/i, '');
+    }
+    return base;
+}
+function inferScalarType(sampleValue, stringValues) {
+    if (typeof sampleValue === 'boolean') {
+        return { type: 'boolean' };
+    }
+    if (typeof sampleValue === 'number') {
+        return { type: 'number' };
+    }
+    const values = stringValues.length > 0 ? stringValues : typeof sampleValue === 'string' ? [sampleValue] : [];
+    if (values.length > 0) {
+        const nonEmpty = values.filter(Boolean);
+        if (nonEmpty.length > 0 && nonEmpty.every((value) => ISO_DATE.test(value))) {
+            return { type: 'date' };
+        }
+        if (nonEmpty.length > 0 && nonEmpty.every((value) => MEDIA_PATH.test(value) || MEDIA_EXT.test(value))) {
+            return { type: 'media' };
+        }
+        // Multi-paragraph prose reads as rich text; single lines stay strings.
+        if (nonEmpty.some((value) => value.includes('\n\n'))) {
+            return { type: 'richtext' };
+        }
+    }
+    return { type: 'string' };
+}
+function referenceField(reference, provisionalNames) {
+    const targets = reference.targets.map((target) => provisionalNames.get(target) ?? singularPascal(target));
+    const base = targets.length > 1 ? { type: 'reference', targets } : { type: 'reference', target: targets[0] };
+    return reference.many ? { ...base, many: true } : base;
+}
+function collectSources(scan) {
+    const sources = [];
+    for (const candidate of scan.collections) {
+        sources.push({
+            sourceName: candidate.name,
+            sourceLabel: `${candidate.file}:${candidate.line}`,
+            rowCount: candidate.count,
+            fields: candidate.fields,
+            typedSample: candidate.typedSample ?? {},
+            fieldValues: candidate.fieldValues ?? {},
+            references: candidate.references ?? [],
+            manyFields: candidate.manyFields ?? [],
+            verbatimFields: [],
+        });
+    }
+    for (const dataFile of scan.dataFiles) {
+        for (const collection of dataFile.collections) {
+            const stem = dataFile.file.replace(/^.*\//, '').replace(/\.[a-z]+$/i, '');
+            const pathName = (collection.path ?? '').replace(/^\$\.?/, '').replace(/^\.+$/, '');
+            const name = pathName || stem;
+            sources.push({
+                sourceName: name,
+                sourceLabel: dataFile.file,
+                rowCount: collection.length,
+                fields: Object.keys(collection.typedSample ?? {}),
+                typedSample: collection.typedSample ?? {},
+                fieldValues: collection.fieldValues ?? {},
+                references: collection.references ?? [],
+                manyFields: collection.manyFields ?? [],
+                verbatimFields: collection.verbatimFields ?? [],
+            });
+        }
+    }
+    return sources;
+}
+/** Compact per-field preview so classification/naming never needs the
+ *  source files: one representative value, long strings truncated. */
+function sampleFor(typedSample) {
+    const sample = {};
+    for (const [field, value] of Object.entries(typedSample)) {
+        if (typeof value === 'string' && value.length > 80) {
+            sample[field] = `${value.slice(0, 77)}…`;
+        }
+        else if (Array.isArray(value)) {
+            sample[field] = value.slice(0, 3);
+        }
+        else {
+            sample[field] = value;
+        }
+    }
+    return sample;
+}
+/**
+ * Write `.fimo/migration/schema-drafts/<Provisional>.json` (exact pushable
+ * shape) for every detected collection, plus a README stating the contract.
+ * Regenerated on every run — drafts are machine output, never hand-edited.
+ */
+export function writeSchemaDrafts(rootDir, scan) {
+    const sources = collectSources(scan);
+    const draftsDir = join(rootDir, '.fimo', 'migration', 'schema-drafts');
+    rmSync(draftsDir, { recursive: true, force: true });
+    if (sources.length === 0) {
+        return [];
+    }
+    mkdirSync(draftsDir, { recursive: true });
+    const provisionalNames = new Map();
+    for (const source of sources) {
+        provisionalNames.set(source.sourceName, singularPascal(source.sourceName));
+    }
+    const drafts = [];
+    for (const source of sources) {
+        const uid = provisionalNames.get(source.sourceName);
+        const referenceByField = new Map(source.references.map((reference) => [reference.field, reference]));
+        const fields = {};
+        // candidate.fields only lists STRING fields; booleans and numbers live
+        // in the typed sample — union both so no field is dropped.
+        const fieldNames = [...new Set([...source.fields, ...Object.keys(source.typedSample)])];
+        for (const field of fieldNames) {
+            if (field === 'slug') {
+                continue; // reserved entry metadata: set inside data on create
+            }
+            const reference = referenceByField.get(field);
+            if (reference) {
+                fields[field] = referenceField(reference, provisionalNames);
+                continue;
+            }
+            if (source.verbatimFields.includes(field)) {
+                // Markdown/MDX body: keep the raw source string so the user's own
+                // renderer still handles it — never reshape to richtext.
+                fields[field] = { type: 'string' };
+                continue;
+            }
+            if (source.manyFields.includes(field)) {
+                // String array with no reference target (a free tag list): `many` is
+                // reference-only on the server, so model it as json — the array
+                // round-trips verbatim and stays editable.
+                fields[field] = { type: 'json' };
+                continue;
+            }
+            fields[field] = inferScalarType(source.typedSample[field], source.fieldValues[field] ?? []);
+        }
+        // `source`, `rowCount`, and `sample` exist so the classify/name decision
+        // can be made from this file ALONE; adopt-drafts strips them on copy
+        // (only uid/name/fields are pushed).
+        const draft = {
+            uid,
+            name: uid,
+            source: source.sourceLabel,
+            rowCount: source.rowCount,
+            sample: sampleFor(source.typedSample),
+            fields,
+        };
+        const file = join(draftsDir, `${uid}.json`);
+        writeFileSync(file, `${JSON.stringify(draft, null, 2)}\n`);
+        drafts.push({ file, uid, sourceName: source.sourceName, source: source.sourceLabel, fields });
+    }
+    writeFileSync(join(draftsDir, 'README.md'), [
+        '# Machine-typed schema drafts (regenerated by `fimo migrate`)',
+        '',
+        'Field TYPES here are inferred from the actual source values (dates,',
+        'booleans, numbers, media paths, prose, reference targets) and are',
+        'reliable. Each draft carries its `source`, `rowCount`, and a `sample`',
+        'row — everything needed to classify and name WITHOUT opening the',
+        'source files. The NAMES are PROVISIONAL mechanical guesses — that',
+        'judgment is yours, and it is TWO commands total:',
+        '',
+        '1. `npx fimo schemas adopt-drafts --rename "Prov=Final,…" --drop "Junk,…"`',
+        '   (copies kept drafts to src/schemas, rewrites reference targets and',
+        '   staged rows files through the renames, and pushes in dependency order).',
+        '2. `npx fimo migrate seed` (seeds every staged rows file in reference',
+        '   order; the server resolves reference slugs to documentIds).',
+        '',
+        'Do not edit files in this directory: they are overwritten on every',
+        '`fimo migrate` run.',
+        '',
+    ].join('\n'));
+    return drafts;
+}

package/dist/scripts/draft-schemas.test.d.ts

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

package/dist/scripts/draft-schemas.test.js

@@ -0,0 +1,152 @@
+import { existsSync, 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';
+let dir;
+const project = (files) => {
+    dir = mkdtempSync(join(tmpdir(), 'draft-schemas-'));
+    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('writeSchemaDrafts', () => {
+    it('infers deep field types from an in-code candidate and names it singular PascalCase', () => {
+        const root = project({
+            'src/pages/team.tsx': `const teamMembers = [
+  { name: 'Maë Falk', bio: 'Keeps the berths in order.', headshot: '/images/mae.png', startedAt: '2019-04-02', active: true, boats: 3 },
+  { name: 'Idris Kade', bio: 'Maps every tide table.', headshot: '/images/idris.png', startedAt: '2021-11-20', active: false, boats: 5 },
+];
+export default function Team() {
+  return <ul>{teamMembers.map((m) => (<li key={m.name}>{m.name} {m.bio}</li>))}</ul>;
+}
+`,
+        });
+        const scan = scanWrappable(root, { keepInternal: true });
+        const drafts = writeSchemaDrafts(root, scan);
+        expect(drafts.map((draft) => draft.uid)).toEqual(['TeamMember']);
+        const draft = JSON.parse(readFileSync(join(root, '.fimo/migration/schema-drafts/TeamMember.json'), 'utf8'));
+        expect(draft.uid).toBe('TeamMember');
+        // Classification context so the agent never reopens the source files.
+        expect(draft.source).toContain('src/pages/team.tsx');
+        expect(draft.rowCount).toBe(2);
+        expect(draft.sample.name).toBe('Maë Falk');
+        expect(draft.fields.name).toEqual({ type: 'string' });
+        expect(draft.fields.headshot).toEqual({ type: 'media' });
+        expect(draft.fields.startedAt).toEqual({ type: 'date' });
+        expect(draft.fields.active).toEqual({ type: 'boolean' });
+        expect(draft.fields.boats).toEqual({ type: 'number' });
+        expect(existsSync(join(root, '.fimo/migration/schema-drafts/README.md'))).toBe(true);
+    });
+    it('maps detected references to reference fields with provisional target names', () => {
+        const root = project({
+            'src/pages/board.tsx': `const authors = [
+  { slug: 'author-1', name: 'Maë Falk', role: 'Writer of long tides' },
+  { slug: 'author-2', name: 'Idris Kade', role: 'Editor of every chart' },
+  { slug: 'author-3', name: 'Sol Ferry', role: 'Keeper of the lanterns' },
+];
+const posts = [
+  { slug: 'post-1', title: 'Charting the bay together', author: 'author-1', tags: ['tag-a', 'tag-b'] },
+  { slug: 'post-2', title: 'Berth songs for the crew', author: 'author-2', tags: ['tag-a'] },
+  { slug: 'post-3', title: 'Lanterns over the reef', author: 'author-3', tags: ['tag-b'] },
+];
+export default function Board() {
+  return (
+    <div>
+      <ul>{authors.map((a) => (<li key={a.slug}>{a.name} {a.role}</li>))}</ul>
+      <ol>{posts.map((p) => (<li key={p.slug}>{p.title}</li>))}</ol>
+    </div>
+  );
+}
+`,
+        });
+        const scan = scanWrappable(root, { keepInternal: true });
+        const drafts = writeSchemaDrafts(root, scan);
+        const post = JSON.parse(readFileSync(join(root, '.fimo/migration/schema-drafts/Post.json'), 'utf8'));
+        expect(post.fields.author).toEqual({ type: 'reference', target: 'Author' });
+        expect(post.fields.slug).toBeUndefined();
+        expect(drafts.some((draft) => draft.uid === 'Author')).toBe(true);
+    });
+    it('drafts data-file collections with prose as richtext', () => {
+        const root = project({
+            'src/data/caseStudies.json': JSON.stringify([
+                {
+                    slug: 'case-1',
+                    title: 'Rebuilding the north pier',
+                    challenge: 'First paragraph of the challenge.\n\nSecond paragraph with detail.',
+                    publishedAt: '2025-03-14',
+                    coverImage: '/images/pier.png',
+                },
+                {
+                    slug: 'case-2',
+                    title: 'Charting the shallows',
+                    challenge: 'Another two-paragraph body.\n\nSecond part here.',
+                    publishedAt: '2025-06-02',
+                    coverImage: '/images/shallows.png',
+                },
+                {
+                    slug: 'case-3',
+                    title: 'The lantern census',
+                    challenge: 'More prose in paragraphs.\n\nStill more prose.',
+                    publishedAt: '2025-08-19',
+                    coverImage: '/images/lanterns.png',
+                },
+            ]),
+        });
+        const scan = scanWrappable(root, { keepInternal: true });
+        writeSchemaDrafts(root, scan);
+        const draft = JSON.parse(readFileSync(join(root, '.fimo/migration/schema-drafts/CaseStudy.json'), 'utf8'));
+        expect(draft.uid).toBe('CaseStudy');
+        expect(draft.fields.challenge).toEqual({ type: 'richtext' });
+        expect(draft.fields.publishedAt).toEqual({ type: 'date' });
+        expect(draft.fields.coverImage).toEqual({ type: 'media' });
+    });
+});
+describe('markdown group staging (Tier 1b)', () => {
+    const post = (title, author, date, body) => `---\ntitle: ${title}\nauthor: ${author}\ndate: ${date}\nfeatured: true\n---\n\n${body}\n`;
+    it('drafts a markdown blog as a collection: typed frontmatter, verbatim body, reference', () => {
+        const root = project({
+            'src/authors/authors.json': JSON.stringify([
+                { slug: 'mae-falk', name: 'Maë Falk', bio: 'Keeps the berths in order at dawn each day.' },
+                { slug: 'idris-kade', name: 'Idris Kade', bio: 'Maps every tide table by hand and by heart.' },
+            ]),
+            'src/posts/charting-the-bay.md': post('Charting the bay', 'mae-falk', '2026-01-12', '# Charting the bay\n\nFirst paragraph with **bold** markdown.\n\nSecond paragraph here.'),
+            'src/posts/berth-songs.md': post('Berth songs', 'idris-kade', '2026-02-03', '## Berth songs\n\nAnother body with a [link](https://x.test).\n\nAnd its second half.'),
+        });
+        const scan = scanWrappable(root, { keepInternal: true });
+        const drafts = writeSchemaDrafts(root, scan);
+        expect(drafts.map((draft) => draft.uid).sort()).toEqual(['Author', 'Post']);
+        const post_ = JSON.parse(readFileSync(join(root, '.fimo/migration/schema-drafts/Post.json'), 'utf8'));
+        // Body stays a verbatim string (NOT richtext) so the user's md renderer works.
+        expect(post_.fields.body).toEqual({ type: 'string' });
+        expect(post_.fields.title).toEqual({ type: 'string' });
+        expect(post_.fields.date).toEqual({ type: 'date' });
+        expect(post_.fields.featured).toEqual({ type: 'boolean' });
+        // Frontmatter author matching authors.json → a reference, not a string.
+        expect(post_.fields.author).toEqual({ type: 'reference', target: 'Author' });
+        expect(post_.fields.slug).toBeUndefined();
+    });
+});
+describe('singularPascal edge cases', () => {
+    it('keeps vowel+ses plurals whole (the PressReleas bug)', () => {
+        const root = project({
+            'src/data/pressReleases.json': JSON.stringify([
+                { slug: 'pr-1', title: 'Harbor opens the north pier to night traffic' },
+                { slug: 'pr-2', title: 'New tide charts published for every berth' },
+                { slug: 'pr-3', title: 'Lantern census completes its tenth year' },
+            ]),
+        });
+        const scan = scanWrappable(root, { keepInternal: true });
+        const drafts = writeSchemaDrafts(root, scan);
+        expect(drafts.map((draft) => draft.uid)).toContain('PressRelease');
+    });
+});

package/dist/scripts/extract-translations.js

@@ -8,6 +8,7 @@
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { parseSync } from 'oxc-parser';
+import { collectScopedBindings, isFunctionLike, resolveScopedKey } from './i18n-namespace.js';
 function findReactFiles(dir, files = []) {
     if (!existsSync(dir)) {
         return files;
@@ -34,17 +35,21 @@ function extractFromFile(filePath) {
         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;
+            // 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') {
+                    const { key, scoped } = resolveScopedKey(name, firstArg.value, childScopes);
+                    // A namespace-scoped var (any name) OR a bare Fimo `t(...)` — record the
+                    // resolved key (scoped prepends the namespace; unscoped `t` is the leaf).
+                    if (scoped || name === 't') {
                         declarations.push({ key, file: filePath });
                     }
                 }
@@ -53,15 +58,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/astro/routes.d.ts

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