next-tongue 0.9.2 → 0.9.4

package/README.md

@@ -37,10 +37,14 @@ export default withTongue({ cacheComponents: true });
 ```
 
 ```ts
-// proxy.ts
+// proxy.ts — locales + defaultLocale are required
 import { createProxy } from 'next-tongue/proxy';
 
-export const proxy = createProxy();
+export const proxy = createProxy({
+  locales: ['en', 'de'],
+  defaultLocale: 'en',
+  prefix: 'as-needed',
+});
 export const config = { matcher: ['/((?!api|_next|.*\\..*).*)'] };
 ```
 

package/dist/cli/init.d.ts

@@ -10,3 +10,10 @@ export type InitCliOptions = {
     quiet?: boolean;
 };
 export declare function cmdInit(opts: InitCliOptions): Promise<void>;
+/** Prefer src/app when present; otherwise app/. */
+export declare function detectAppRoot(cwd: string): Promise<'app' | 'src/app'>;
+/**
+ * Where to write proxy.ts. Returns null when the project already has proxy/middleware
+ * (caller should compose manually).
+ */
+export declare function detectProxyPath(cwd: string, appRoot: 'app' | 'src/app'): Promise<string | null>;

package/dist/cli/init.js

@@ -31,6 +31,9 @@ export async function cmdInit(opts) {
         process.exitCode = 2;
         return;
     }
+    const appRoot = await detectAppRoot(cwd);
+    const hasRootLayout = await hasFile(cwd, `${appRoot}/layout.tsx`, `${appRoot}/layout.ts`, `${appRoot}/layout.jsx`, `${appRoot}/layout.js`);
+    const proxyPath = await detectProxyPath(cwd, appRoot);
     const plans = [];
     plans.push({
         path: 'tongue.config.ts',
@@ -46,68 +49,38 @@ export default defineConfig({
 `,
     });
     for (const locale of locales) {
-        const sample = locale === defaultLocale
-            ? {
-                home: {
-                    title: 'Welcome, {name}!',
-                    body: 'Scaffolded by tongue init.',
-                },
-            }
-            : {
-                home: {
-                    title: 'Welcome, {name}!',
-                    body: 'Scaffolded by tongue init.',
-                },
-            };
+        const sample = {
+            home: {
+                title: 'Welcome, {name}!',
+                body: 'Scaffolded by tongue init.',
+            },
+        };
         plans.push({
             path: `messages/${locale}.json`,
             kind: 'create',
             content: `${JSON.stringify(sample, null, 2)}\n`,
         });
     }
+    if (proxyPath) {
+        plans.push({
+            path: proxyPath,
+            kind: 'create',
+            content: proxyScaffold(locales, defaultLocale, prefix),
+        });
+    }
+    else if (!opts.quiet) {
+        console.log('tongue init: existing proxy/middleware detected — compose createProxy({ locales, defaultLocale, … }) yourself (see docs/routing-and-proxy.md).');
+    }
+    const layoutPath = `${appRoot}/[locale]/layout.tsx`;
     plans.push({
-        path: 'proxy.ts',
+        path: layoutPath,
         kind: 'create',
-        content: `import { createProxy } from 'next-tongue/proxy';
-
-export const proxy = createProxy();
-export const config = {
-  matcher: ['/((?!api|_next|.*\\\\..*).*)'],
-};
-`,
+        content: hasRootLayout
+            ? nestedLocaleLayout()
+            : rootLocaleLayout(),
     });
     plans.push({
-        path: 'app/[locale]/layout.tsx',
-        kind: 'create',
-        content: `import { notFound } from 'next/navigation';
-import { TongueProvider } from 'next-tongue/client';
-import { getDir, isLocale, localeParams } from 'next-tongue/server';
-import { ensureTongue } from '#tongue/runtime';
-
-ensureTongue();
-export const generateStaticParams = localeParams;
-
-export default async function RootLayout({
-  children,
-  params,
-}: {
-  children: React.ReactNode;
-  params: Promise<{ locale: string }>;
-}) {
-  const { locale } = await params;
-  if (!isLocale(locale)) notFound();
-  return (
-    <html lang={locale} dir={getDir(locale)}>
-      <body>
-        <TongueProvider locale={locale}>{children}</TongueProvider>
-      </body>
-    </html>
-  );
-}
-`,
-    });
-    plans.push({
-        path: 'app/[locale]/page.tsx',
+        path: `${appRoot}/[locale]/page.tsx`,
         kind: 'create',
         content: `import { getT } from 'next-tongue/server';
 import { ensureTongue } from '#tongue/runtime';
@@ -160,7 +133,7 @@ export default withTongue(nextConfig);
 `,
         });
     }
-    // tsconfig include
+    // tsconfig: include + paths for #tongue/* (tsc does not resolve package.json imports)
     if (await exists(join(cwd, 'tsconfig.json'))) {
         const abs = join(cwd, 'tsconfig.json');
         const raw = await readFile(abs, 'utf8');
@@ -169,6 +142,12 @@ export default withTongue(nextConfig);
             const include = new Set(ts.include ?? ['**/*.ts', '**/*.tsx']);
             include.add('.tongue/types.d.ts');
             ts.include = [...include];
+            ts.compilerOptions = ts.compilerOptions ?? {};
+            const paths = { ...(ts.compilerOptions.paths ?? {}) };
+            if (!paths['#tongue/*']) {
+                paths['#tongue/*'] = ['./.tongue/*'];
+            }
+            ts.compilerOptions.paths = paths;
             const next = `${JSON.stringify(ts, null, 2)}\n`;
             if (next !== raw) {
                 plans.push({ path: 'tsconfig.json', kind: 'merge', content: next });
@@ -242,9 +221,114 @@ export default withTongue(nextConfig);
         }
     }
     if (!opts.quiet) {
+        if (hasRootLayout) {
+            console.log('tongue init: existing root layout detected — set <html lang={locale} dir={…}> on the root layout (or a client HtmlLang), not under [locale].');
+        }
         console.log('tongue init: done. Run `npx tongue build` (or start next) so `.tongue/` is generated.');
     }
 }
+function proxyScaffold(locales, defaultLocale, prefix) {
+    return `import { createProxy } from 'next-tongue/proxy';
+
+// locales/defaultLocale must match tongue.config.ts (or import from '#tongue/runtime' after \`tongue build\`).
+export const proxy = createProxy({
+  locales: ${JSON.stringify(locales)},
+  defaultLocale: ${JSON.stringify(defaultLocale)},
+  prefix: ${JSON.stringify(prefix)},
+});
+
+export const config = {
+  matcher: ['/((?!api|_next|.*\\\\..*).*)'],
+};
+`;
+}
+/** Greenfield: [locale] is the root layout and owns <html>. */
+function rootLocaleLayout() {
+    return `import { notFound } from 'next/navigation';
+import { TongueProvider } from 'next-tongue/client';
+import { getDir, isLocale, localeParams } from 'next-tongue/server';
+import { ensureTongue } from '#tongue/runtime';
+
+ensureTongue();
+export const generateStaticParams = localeParams;
+
+export default async function LocaleLayout({
+  children,
+  params,
+}: {
+  children: React.ReactNode;
+  params: Promise<{ locale: string }>;
+}) {
+  const { locale } = await params;
+  if (!isLocale(locale)) notFound();
+  return (
+    <html lang={locale} dir={getDir(locale)}>
+      <body>
+        <TongueProvider locale={locale}>{children}</TongueProvider>
+      </body>
+    </html>
+  );
+}
+`;
+}
+/**
+ * App already has app/layout.tsx — Next only allows <html> there.
+ * [locale] layout wraps children only.
+ */
+function nestedLocaleLayout() {
+    return `import { notFound } from 'next/navigation';
+import { TongueProvider } from 'next-tongue/client';
+import { isLocale, localeParams } from 'next-tongue/server';
+import { ensureTongue } from '#tongue/runtime';
+
+ensureTongue();
+export const generateStaticParams = localeParams;
+
+export default async function LocaleLayout({
+  children,
+  params,
+}: {
+  children: React.ReactNode;
+  params: Promise<{ locale: string }>;
+}) {
+  const { locale } = await params;
+  if (!isLocale(locale)) notFound();
+  // Keep html lang/dir on the root layout (or sync via a client helper).
+  return <TongueProvider locale={locale}>{children}</TongueProvider>;
+}
+`;
+}
+/** Prefer src/app when present; otherwise app/. */
+export async function detectAppRoot(cwd) {
+    if (await exists(join(cwd, 'src', 'app')))
+        return 'src/app';
+    if (await exists(join(cwd, 'app')))
+        return 'app';
+    if (await exists(join(cwd, 'src')))
+        return 'src/app';
+    return 'app';
+}
+/**
+ * Where to write proxy.ts. Returns null when the project already has proxy/middleware
+ * (caller should compose manually).
+ */
+export async function detectProxyPath(cwd, appRoot) {
+    const existing = [
+        'proxy.ts',
+        'proxy.js',
+        'src/proxy.ts',
+        'src/proxy.js',
+        'middleware.ts',
+        'middleware.js',
+        'src/middleware.ts',
+        'src/middleware.js',
+    ];
+    for (const p of existing) {
+        if (await exists(join(cwd, p)))
+            return null;
+    }
+    return appRoot.startsWith('src/') ? 'src/proxy.ts' : 'proxy.ts';
+}
 function wrapNextConfig(src, staticExport) {
     let out = src;
     if (!/withTongue/.test(out)) {
@@ -258,6 +342,13 @@ function wrapNextConfig(src, staticExport) {
     }
     return out;
 }
+async function hasFile(cwd, ...rels) {
+    for (const rel of rels) {
+        if (await exists(join(cwd, rel)))
+            return true;
+    }
+    return false;
+}
 async function exists(path) {
     try {
         await access(path);

package/dist/client/dev-registry.js

@@ -12,12 +12,15 @@ function store() {
             escapes: new Map(),
             rendered: [],
             listeners: new Set(),
+            snapshot: null,
         };
     }
     return g.__nextTongueDev;
 }
 function notify() {
-    for (const l of store().listeners)
+    const s = store();
+    s.snapshot = null;
+    for (const l of s.listeners)
         l();
 }
 export function tongueDevLoaded(namespace, key) {
@@ -74,13 +77,16 @@ export function subscribeTongueDev(listener) {
 }
 export function getTongueDevSnapshot() {
     const s = store();
-    return {
+    if (s.snapshot)
+        return s.snapshot;
+    s.snapshot = {
         loaded: [...s.loaded.values()],
         missing: [...s.missing.values()],
         fallbacks: [...s.fallbacks.values()],
         escapes: [...s.escapes.values()],
         rendered: [...s.rendered],
     };
+    return s.snapshot;
 }
 /** @internal test helper */
 export function __resetTongueDev() {

package/dist/client/index.js

@@ -68,8 +68,11 @@ export function useFormat() {
 export function useT(namespace) {
     const ns = (namespace ?? '_root');
     const { locale, loadNamespace } = useTongue();
+    // Literal `t('key')` is rewritten by the call-site loader to per-key imports;
+    // `useT()` itself must still be safe during SSR without loadNamespace.
+    // Invoking the returned `t` without a rewrite (dynamic/escaped) throws below.
     if (!loadNamespace) {
-        throw new TongueError('TONGUE_E_NO_PROVIDER', `useT('${String(ns)}') needs the call-site loader (or pass loadNamespace to TongueProvider). Prefer translating on the server with getT and passing strings.`);
+        return createLoaderStubT(locale, String(ns));
     }
     const messages = loadNamespace(ns);
     return createT({
@@ -78,6 +81,24 @@ export function useT(namespace) {
         loadNamespace,
     });
 }
+/**
+ * Stub used when the call-site loader owns message delivery. Calling the
+ * function (or .rich / .dynamic / .ns) means a key was not rewritten — usually
+ * a missing loader or a non-literal key without `t.dynamic({ from })`.
+ */
+function createLoaderStubT(locale, ns) {
+    const fail = () => {
+        throw new TongueError('TONGUE_E_NO_PROVIDER', `useT('${ns}') call was not rewritten to a per-key import. Ensure withTongue() is applied, or pass loadNamespace to TongueProvider. Prefer getT on the server for static copy; for dynamic keys use t.dynamic(key, { from: [...] }).`);
+    };
+    const t = Object.assign((..._args) => fail(), {
+        rich: fail,
+        has: () => false,
+        dynamic: fail,
+        ns: fail,
+    });
+    void locale;
+    return t;
+}
 export function getClientLocales() {
     return clientLocales;
 }

package/dist/compiler/scan-keys.d.ts

@@ -5,9 +5,18 @@ export type ReferencedKey = {
     file: string;
     line: number;
 };
+export type ScanResult = {
+    refs: ReferencedKey[];
+    /**
+     * Namespaces where `t(variable)` / `t.ns(...)` was seen — unused-key warnings
+     * for these namespaces are suppressed (dynamic / whole-ns usage).
+     */
+    dynamicNamespaces: Set<string>;
+};
 /**
  * Find `t('key')` / `t.rich('key')` under a known `useT`/`getT` namespace,
- * plus bare `useT('ns')` / `getT('ns')` for namespace awareness.
+ * plus `t.dynamic(..., { from })` declared keys and dynamic `t(var)` markers.
  */
 export declare function scanReferencedKeys(cwd: string, roots?: string[]): Promise<ReferencedKey[]>;
-export declare function extractFromSource(source: string, file: string): ReferencedKey[];
+export declare function scanKeys(cwd: string, roots?: string[]): Promise<ScanResult>;
+export declare function extractFromSource(source: string, file: string): ScanResult;

package/dist/compiler/scan-keys.js

@@ -12,9 +12,12 @@ const SKIP_DIRS = new Set([
 ]);
 /**
  * Find `t('key')` / `t.rich('key')` under a known `useT`/`getT` namespace,
- * plus bare `useT('ns')` / `getT('ns')` for namespace awareness.
+ * plus `t.dynamic(..., { from })` declared keys and dynamic `t(var)` markers.
  */
 export async function scanReferencedKeys(cwd, roots = ['app', 'src', 'components']) {
+    return (await scanKeys(cwd, roots)).refs;
+}
+export async function scanKeys(cwd, roots = ['app', 'src', 'components']) {
     const files = [];
     for (const root of roots) {
         const abs = join(cwd, root);
@@ -27,13 +30,17 @@ export async function scanReferencedKeys(cwd, roots = ['app', 'src', 'components
         }
         await walk(abs, files);
     }
-    const out = [];
+    const refs = [];
+    const dynamicNamespaces = new Set();
     for (const file of files) {
         const src = await readFile(file, 'utf8');
         const rel = relative(cwd, file);
-        out.push(...extractFromSource(src, rel));
+        const part = extractFromSource(src, rel);
+        refs.push(...part.refs);
+        for (const ns of part.dynamicNamespaces)
+            dynamicNamespaces.add(ns);
     }
-    return out;
+    return { refs, dynamicNamespaces };
 }
 async function walk(dir, out) {
     const entries = await readdir(dir, { withFileTypes: true });
@@ -57,6 +64,7 @@ function extname(name) {
 }
 export function extractFromSource(source, file) {
     const out = [];
+    const dynamicNamespaces = new Set();
     const translators = new Map(); // var → ns
     // useT('ns') | getT('ns') | getT(locale, 'ns')
     const declRe = /(?:const|let|var)\s+(\w+)\s*=\s*(?:await\s+)?(?:useT|getT)\s*\(\s*(?:[^'"\n,]+,\s*)?(['"])([^'"]*)\2\s*\)/g;
@@ -64,23 +72,65 @@ export function extractFromSource(source, file) {
     while ((m = declRe.exec(source)) !== null) {
         translators.set(m[1], m[3] || '_root');
     }
+    const push = (ns, key, index) => {
+        const fullKey = ns === '_root' || ns === '' ? key : `${ns}.${key}`;
+        out.push({
+            fullKey,
+            namespace: ns || '_root',
+            key,
+            file,
+            line: lineAt(source, index),
+        });
+    };
     for (const [varName, ns] of translators) {
+        // Literal t('key') / t.rich('key')
         const callRe = new RegExp(`\\b${escapeRegExp(varName)}(?:\\.rich)?\\s*\\(\\s*(['"])([^'"]+)\\1`, 'g');
         let cm;
         while ((cm = callRe.exec(source)) !== null) {
-            const key = cm[2];
-            const fullKey = ns === '_root' || ns === '' ? key : `${ns}.${key}`;
-            const line = lineAt(source, cm.index);
-            out.push({
-                fullKey,
-                namespace: ns || '_root',
-                key,
-                file,
-                line,
-            });
+            push(ns, cm[2], cm.index);
+        }
+        // t.dynamic(any, { from: ['a', 'b'] })
+        const dynRe = new RegExp(`\\b${escapeRegExp(varName)}\\.dynamic\\s*\\(`, 'g');
+        let dm;
+        while ((dm = dynRe.exec(source)) !== null) {
+            const tail = source.slice(dm.index, dm.index + 400);
+            const fromMatch = /from\s*:\s*\[([^\]]*)\]/.exec(tail);
+            if (fromMatch) {
+                const keys = fromMatch[1].match(/['"]([^'"]+)['"]/g) ?? [];
+                for (const raw of keys) {
+                    const key = raw.slice(1, -1);
+                    push(ns, key, dm.index);
+                }
+            }
+            dynamicNamespaces.add(ns || '_root');
+        }
+        // t.ns('other') — whole namespace marked dynamic
+        const nsRe = new RegExp(`\\b${escapeRegExp(varName)}\\.ns\\s*\\(\\s*(['"])([^'"]+)\\1`, 'g');
+        let nm;
+        while ((nm = nsRe.exec(source)) !== null) {
+            dynamicNamespaces.add(nm[2] || '_root');
+        }
+        // Non-literal t(var) / t.rich(var) — mark namespace dynamic + harvest nearby string arrays
+        const nonLitRe = new RegExp(`\\b${escapeRegExp(varName)}(?:\\.rich)?\\s*\\(\\s*(?!['"])([A-Za-z_$][\\w$]*)`, 'g');
+        let nl;
+        let sawNonLit = false;
+        while ((nl = nonLitRe.exec(source)) !== null) {
+            sawNonLit = true;
+            dynamicNamespaces.add(ns || '_root');
+        }
+        if (sawNonLit) {
+            // Keys listed in string arrays in this file (e.g. KEYS.map((k) => t(k)))
+            const arrayLitRe = /\[\s*((?:['"][^'"]+['"]\s*,?\s*)+)\]/g;
+            let am;
+            while ((am = arrayLitRe.exec(source)) !== null) {
+                const keys = am[1].match(/['"]([^'"]+)['"]/g) ?? [];
+                for (const raw of keys) {
+                    push(ns, raw.slice(1, -1), am.index);
+                }
+            }
         }
     }
-    return out;
+    return { refs: out, dynamicNamespaces };
 }
 function lineAt(source, index) {
     let line = 1;

package/dist/compiler/validate/a11y.d.ts

@@ -1,7 +1,12 @@
 import type { ResolvedTongueConfig } from '../../config/types.js';
 import type { CheckIssue } from '../../cli/check-types.js';
 /**
- * Static analysis: `[locale]` layout should set `<html lang={locale}>` and
- * `dir={getDir(locale)}` (or equivalent) for RTL locales.
+ * Static analysis: some layout in the tree should set `<html lang={locale}>`
+ * and `dir={getDir(locale)}` for RTL.
+ *
+ * Next.js only allows `<html>` on the **root** layout. When `app/layout` (or
+ * `src/app/layout`) exists beside `app/[locale]`, check the root layout for
+ * lang/dir (or any client sync of `document.documentElement.lang`). Otherwise
+ * check the `[locale]` layout (greenfield pattern).
  */
 export declare function validateA11y(config: ResolvedTongueConfig, cwd: string): Promise<CheckIssue[]>;

package/dist/compiler/validate/a11y.js

@@ -7,60 +7,116 @@ function severityFor(level) {
     return level === 'error' ? 'error' : 'warn';
 }
 /**
- * Static analysis: `[locale]` layout should set `<html lang={locale}>` and
- * `dir={getDir(locale)}` (or equivalent) for RTL locales.
+ * Static analysis: some layout in the tree should set `<html lang={locale}>`
+ * and `dir={getDir(locale)}` for RTL.
+ *
+ * Next.js only allows `<html>` on the **root** layout. When `app/layout` (or
+ * `src/app/layout`) exists beside `app/[locale]`, check the root layout for
+ * lang/dir (or any client sync of `document.documentElement.lang`). Otherwise
+ * check the `[locale]` layout (greenfield pattern).
  */
 export async function validateA11y(config, cwd) {
     const sev = severityFor(config.strict.a11y);
     if (!sev)
         return [];
-    const layouts = await findLocaleLayouts(cwd);
-    if (layouts.length === 0) {
+    const localeLayouts = await findLocaleLayouts(cwd);
+    if (localeLayouts.length === 0) {
         return [
             {
                 check: 'a11y',
                 severity: sev,
-                message: 'No app/[locale]/layout.* found — cannot verify <html lang> / dir',
+                message: 'No app/[locale]/layout.* (or src/app/[locale]/layout.*) found — cannot verify lang/dir',
             },
         ];
     }
-    const issues = [];
+    const rootLayouts = await findRootLayouts(cwd);
+    const checkFiles = rootLayouts.length > 0
+        ? [...rootLayouts, ...localeLayouts]
+        : localeLayouts;
     const rtlLocales = config.locales.filter((l) => getDir(l) === 'rtl');
-    for (const file of layouts) {
+    let anyLang = false;
+    let anyDir = false;
+    const sources = [];
+    for (const file of checkFiles) {
         const src = await readFile(file, 'utf8');
-        const hasLang = /<html[^>]*\blang=\{/.test(src) ||
-            /<html[^>]*\blang=["']/.test(src) ||
-            /\blang=\{locale\}/.test(src);
-        const hasDir = /<html[^>]*\bdir=\{/.test(src) ||
-            /<html[^>]*\bdir=["']/.test(src) ||
-            /\bdir=\{getDir\(/.test(src) ||
-            /\bdir=\{.*getDir/.test(src);
-        if (!hasLang) {
-            issues.push({
-                check: 'a11y',
-                severity: sev,
-                message: 'Root locale layout <html> is missing lang={locale} (or lang=…)',
-                file: file.replace(cwd + '/', '').replace(cwd + '\\', ''),
-            });
-        }
-        if (rtlLocales.length > 0 && !hasDir) {
-            issues.push({
-                check: 'a11y',
-                severity: sev,
-                message: `Root locale layout <html> is missing dir={getDir(locale)} (RTL locales: ${rtlLocales.join(', ')})`,
-                file: file.replace(cwd + '/', '').replace(cwd + '\\', ''),
-            });
-        }
+        sources.push(src);
+        if (hasLangHint(src))
+            anyLang = true;
+        if (hasDirHint(src))
+            anyDir = true;
+    }
+    const issues = [];
+    const rel = (rootLayouts[0] ?? localeLayouts[0] ?? '').replace(cwd + '/', '').replace(cwd + '\\', '') ||
+        'layout';
+    if (!anyLang) {
+        issues.push({
+            check: 'a11y',
+            severity: sev,
+            message: rootLayouts.length
+                ? 'Set <html lang={locale}> on the root layout (Next disallows <html> under [locale]), or sync document.documentElement.lang from the locale'
+                : 'Root locale layout <html> is missing lang={locale} (or lang=…)',
+            file: rel,
+        });
+    }
+    if (rtlLocales.length > 0 && !anyDir) {
+        issues.push({
+            check: 'a11y',
+            severity: sev,
+            message: rootLayouts.length
+                ? `Set <html dir={…}> on the root layout for RTL locales (${rtlLocales.join(', ')}), or sync document.documentElement.dir`
+                : `Root locale layout <html> is missing dir={getDir(locale)} (RTL locales: ${rtlLocales.join(', ')})`,
+            file: rel,
+        });
     }
     return issues;
 }
+function hasLangHint(src) {
+    return (/<html[^>]*\blang=\{/.test(src) ||
+        /<html[^>]*\blang=["']/.test(src) ||
+        /\blang=\{locale\}/.test(src) ||
+        /document\.documentElement\.lang/.test(src) ||
+        /\.lang\s*=/.test(src));
+}
+function hasDirHint(src) {
+    return (/<html[^>]*\bdir=\{/.test(src) ||
+        /<html[^>]*\bdir=["']/.test(src) ||
+        /\bdir=\{getDir\(/.test(src) ||
+        /\bdir=\{.*getDir/.test(src) ||
+        /document\.documentElement\.dir/.test(src));
+}
 async function findLocaleLayouts(cwd) {
-    const candidates = [
-        join(cwd, 'app', '[locale]'),
-        join(cwd, 'src', 'app', '[locale]'),
-    ];
+    return findLayoutsUnder(cwd, ['app/[locale]', 'src/app/[locale]']);
+}
+/** Root layouts that are siblings of [locale], not under it. */
+async function findRootLayouts(cwd) {
     const out = [];
-    for (const root of candidates) {
+    for (const dir of ['app', 'src/app']) {
+        const abs = join(cwd, dir);
+        try {
+            if (!(await stat(abs)).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        // Only treat as "existing root" when [locale] also lives under the same app dir
+        // (otherwise greenfield [locale]-as-root still owns <html>).
+        const hasLocale = await existsDir(join(abs, '[locale]'));
+        if (!hasLocale)
+            continue;
+        const entries = await readdir(abs);
+        for (const name of entries) {
+            if (/^layout\.(tsx|ts|jsx|js)$/.test(name)) {
+                out.push(join(abs, name));
+            }
+        }
+    }
+    return out;
+}
+async function findLayoutsUnder(cwd, roots) {
+    const out = [];
+    for (const rel of roots) {
+        const root = join(cwd, ...rel.split('/'));
         try {
             if (!(await stat(root)).isDirectory())
                 continue;
@@ -77,3 +133,11 @@ async function findLocaleLayouts(cwd) {
     }
     return out;
 }
+async function existsDir(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/compiler/validate/usage.js

@@ -1,5 +1,5 @@
 import { loadLocaleMessages } from '../load-messages.js';
-import { scanReferencedKeys } from '../scan-keys.js';
+import { scanKeys } from '../scan-keys.js';
 function severityFor(level, alwaysError = false) {
     if (alwaysError)
         return 'error';
@@ -7,6 +7,10 @@ function severityFor(level, alwaysError = false) {
         return null;
     return level === 'error' ? 'error' : 'warn';
 }
+function namespaceOf(fullKey) {
+    const i = fullKey.indexOf('.');
+    return i === -1 ? '_root' : fullKey.slice(0, i);
+}
 /** unused + undefined checks against scanned source references. */
 export async function validateUsage(config, cwd) {
     const issues = [];
@@ -20,7 +24,7 @@ export async function validateUsage(config, cwd) {
             defined.add(ns === '_root' ? key : `${ns}.${key}`);
         }
     }
-    const refs = await scanReferencedKeys(cwd);
+    const { refs, dynamicNamespaces } = await scanKeys(cwd);
     const used = new Set();
     for (const ref of refs) {
         used.add(ref.fullKey);
@@ -40,6 +44,9 @@ export async function validateUsage(config, cwd) {
         for (const fullKey of defined) {
             if (used.has(fullKey))
                 continue;
+            // Dynamic t(var) / t.ns / t.dynamic — do not false-flag catalog keys as unused
+            if (dynamicNamespaces.has(namespaceOf(fullKey)))
+                continue;
             issues.push({
                 check: 'unused',
                 severity: unusedSev,

package/dist/next/with-tongue.js

@@ -43,16 +43,19 @@ export function withTongue(nextConfig = {}, options = {}) {
             },
         ],
     };
+    const existingRules = input.turbopack?.rules ?? {};
     const turbopack = {
         ...(input.turbopack ?? {}),
         resolveAlias: {
             ...(input.turbopack?.resolveAlias ?? {}),
             '#tongue': outDir,
         },
+        // Appends the call-site loader onto any existing `*.tsx` / `*.jsx` rules
+        // (Next accepts a rule or an array of rules per glob).
         rules: {
-            ...(input.turbopack?.rules ?? {}),
-            '*.tsx': tongueLoaderRule,
-            '*.jsx': tongueLoaderRule,
+            ...existingRules,
+            '*.tsx': appendTurbopackRule(existingRules['*.tsx'], tongueLoaderRule),
+            '*.jsx': appendTurbopackRule(existingRules['*.jsx'], tongueLoaderRule),
         },
     };
     const userWebpack = input.webpack;
@@ -90,6 +93,12 @@ export function withTongue(nextConfig = {}, options = {}) {
         webpack,
     };
 }
+/** Merge a tongue loader rule with any pre-existing turbopack rule for the same glob. */
+function appendTurbopackRule(existing, rule) {
+    if (existing == null)
+        return rule;
+    return Array.isArray(existing) ? [...existing, rule] : [existing, rule];
+}
 /** Sync peek: `routing.rootParams: true` in tongue.config (ADR 0007 / #24). */
 function peekRootParamsFlag(cwd, configPath) {
     const candidates = configPath

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-tongue",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Compiler-first, type-safe i18n for the Next.js 16 App Router",
   "license": "MIT",
   "type": "module",