@babelize/engine 0.1.0 → 0.1.3

package/dist/modules/finalization/django-finalize.js

@@ -37,11 +37,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveSettingsPath = resolveSettingsPath;
+exports.resolveDjangoLocaleDir = resolveDjangoLocaleDir;
+exports.parseLocalePaths = parseLocalePaths;
 exports.finalizeDjangoSettings = finalizeDjangoSettings;
 const path = __importStar(require("path"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const file_utils_1 = require("../../utils/file-utils");
 const logger_1 = require("../../utils/logger");
+const locale_names_1 = require("../../django/locale-names");
 /**
  * Django settings.py auto-configuration.
  *
@@ -134,7 +137,106 @@ async function resolveByGlob(workspacePath) {
     return path.join(workspacePath, shallowest);
 }
 async function resolveSettingsPath(workspacePath) {
-    return (await resolveViaManagePy(workspacePath)) ?? (await resolveByGlob(workspacePath));
+    const resolved = (await resolveViaManagePy(workspacePath)) ?? (await resolveByGlob(workspacePath));
+    if (!resolved)
+        return null;
+    // settings/dev.py with `from .base import *`: the shared settings live in base.py,
+    // and editing only dev.py would leave production without i18n.
+    const source = await (0, file_utils_1.readFile)(resolved).catch(() => '');
+    if (!/^MIDDLEWARE\s*=/m.test(source)) {
+        for (const m of source.matchAll(/^from\s+\.(\w+)\s+import\s+\*/gm)) {
+            const sibling = path.join(path.dirname(resolved), `${m[1]}.py`);
+            const siblingSource = await (0, file_utils_1.readFile)(sibling).catch(() => '');
+            if (/^MIDDLEWARE\s*=/m.test(siblingSource))
+                return sibling;
+        }
+    }
+    return resolved;
+}
+/**
+ * The locale directory Django reads (LOCALE_PATHS[0]), relative to the
+ * workspace, '/'-separated. Falls back to <BASE_DIR>/locale — what finalize
+ * adds — when LOCALE_PATHS is absent or not a plain BASE_DIR path.
+ */
+async function resolveDjangoLocaleDir(workspacePath, djangoRoot) {
+    const fallback = path.posix.join(djangoRoot, 'locale');
+    const settingsPath = await resolveSettingsPath(workspacePath);
+    if (!settingsPath)
+        return fallback;
+    const source = await (0, file_utils_1.readFile)(settingsPath).catch(() => '');
+    const rel = parseLocalePaths(source);
+    return rel ? path.posix.normalize(path.posix.join(djangoRoot, rel)) : fallback;
+}
+/** First LOCALE_PATHS entry as a path relative to BASE_DIR, if it is one. */
+function parseLocalePaths(source) {
+    const m = /^LOCALE_PATHS\s*=\s*[[(]/m.exec(source);
+    if (!m)
+        return null;
+    // First element of the list: up to the first comma outside brackets.
+    let depth = 0;
+    let first = '';
+    for (let i = m.index + m[0].length; i < source.length; i++) {
+        const ch = source[i];
+        if (ch === '(' || ch === '[')
+            depth++;
+        else if (ch === ')' || ch === ']') {
+            if (depth === 0)
+                break;
+            depth--;
+        }
+        else if (ch === ',' && depth === 0)
+            break;
+        first += ch;
+    }
+    first = first.trim();
+    const strings = (t) => [...t.matchAll(/['"]([^'"]+)['"]/g)].map((x) => x[1]);
+    // BASE_DIR / 'a' / 'b'   str(BASE_DIR / 'a')
+    if (/^(?:str\()?\s*BASE_DIR\s*\//.test(first))
+        return path.posix.join(...strings(first));
+    // os.path.join(BASE_DIR, 'a', 'b')   BASE_DIR.joinpath('a')   Path(BASE_DIR, 'a')
+    if (/^(?:os\.path\.join|Path)\(\s*BASE_DIR\s*,/.test(first) || /^BASE_DIR\.joinpath\(/.test(first)) {
+        const parts = strings(first);
+        return parts.length ? path.posix.join(...parts) : null;
+    }
+    return null;
+}
+/** LANGUAGES entries for the source and target locales: ('pt-br', 'Brazilian Portuguese'). */
+function languageEntries(locales) {
+    const seen = new Set();
+    const out = [];
+    for (const l of locales) {
+        const code = (0, locale_names_1.djangoLanguageCode)(l);
+        if (!l || seen.has(code))
+            continue;
+        seen.add(code);
+        out.push({ code, name: (0, locale_names_1.languageName)(l) });
+    }
+    return out;
+}
+/** Language codes listed in a LANGUAGES setting. */
+function listedLanguages(source) {
+    const m = /^LANGUAGES\s*=\s*[[(]/m.exec(source);
+    if (!m)
+        return null;
+    let depth = 0;
+    let end = -1;
+    for (let i = m.index + m[0].length - 1; i < source.length; i++) {
+        const ch = source[i];
+        if (ch === '[' || ch === '(')
+            depth++;
+        else if (ch === ']' || ch === ')') {
+            depth--;
+            if (depth === 0) {
+                end = i + 1;
+                break;
+            }
+        }
+    }
+    if (end === -1)
+        return null;
+    const body = source.slice(m.index, end);
+    const codes = [...body.matchAll(/[[(,]\s*\(\s*['"]([\w-]+)['"]\s*,/g)].map((x) => x[1].toLowerCase());
+    return { codes, start: m.index, end };
 }
 /**
  * Insert LocaleMiddleware into the MIDDLEWARE list.
@@ -166,7 +268,7 @@ function insertLocaleMiddleware(source) {
     const entryLine = lines.find((l) => l.trim().startsWith("'") || l.trim().startsWith('"'));
     const indent = entryLine?.match(/^(\s*)/)?.[1] ?? '    ';
     const quote = entryLine?.trim().startsWith('"') ? '"' : "'";
-    const newEntry = `${indent}${quote}${LOCALE_MIDDLEWARE}${quote},`;
+    const newEntry = `${indent}${quote}${LOCALE_MIDDLEWARE}${quote},${source.includes('\r\n') ? '\r' : ''}`;
     const sessionIdx = lines.findIndex((l) => l.includes(SESSION_MIDDLEWARE));
     const commonIdx = lines.findIndex((l) => l.includes(COMMON_MIDDLEWARE));
     let insertAt;
@@ -191,6 +293,8 @@ function insertLocaleMiddleware(source) {
 }
 async function finalizeDjangoSettings(workspacePath, options = {}) {
     const { targetLocales = [], sourceLocale = 'en', dryRun = false } = options;
+    const djangoRoot = options.djangoRoot ?? '.';
+    const localeRel = path.posix.relative(djangoRoot === '.' ? '' : djangoRoot, options.localeDir ?? path.posix.join(djangoRoot, 'locale')) || 'locale';
     const changes = [];
     const warnings = [];
     const settingsPath = await resolveSettingsPath(workspacePath);
@@ -204,12 +308,13 @@ async function finalizeDjangoSettings(workspacePath, options = {}) {
         return { settingsPath, changes, warnings };
     }
     let source = original;
+    const nl = original.includes('\r\n') ? '\r\n' : '\n';
     // ── USE_I18N ────────────────────────────────────────────────
     // Only flip an explicit False. Anything else the user wrote stays.
     if (hasSetting(source, 'USE_I18N')) {
-        const falseMatch = source.match(/^USE_I18N\s*=\s*False\s*$/m);
-        if (falseMatch) {
-            source = source.replace(/^USE_I18N\s*=\s*False\s*$/m, 'USE_I18N = True');
+        const falseRe = /^USE_I18N[ \t]*=[ \t]*False\b/m;
+        if (falseRe.test(source)) {
+            source = source.replace(falseRe, 'USE_I18N = True');
             changes.push('Set USE_I18N = True (was False)');
         }
     }
@@ -227,24 +332,56 @@ async function finalizeDjangoSettings(workspacePath, options = {}) {
     // ── LOCALE_PATHS ────────────────────────────────────────────
     // Must match where the locale builder writes: <workspace>/locale/<lang>/LC_MESSAGES/
     if (!hasSetting(source, 'LOCALE_PATHS')) {
+        const segments = localeRel.split('/').filter(Boolean);
         const value = usesPathlibBaseDir(source)
-            ? "LOCALE_PATHS = [BASE_DIR / 'locale']"
-            : "LOCALE_PATHS = [os.path.join(BASE_DIR, 'locale')]";
-        source = appendSetting(source, value);
+            ? `LOCALE_PATHS = [BASE_DIR / ${segments.map((p) => `'${p}'`).join(' / ')}]`
+            : `LOCALE_PATHS = [os.path.join(BASE_DIR, ${segments.map((p) => `'${p}'`).join(', ')})]`;
+        source = appendSetting(source, value, nl);
         changes.push('Added LOCALE_PATHS');
     }
+    else {
+        const configured = parseLocalePaths(source);
+        if (configured === null) {
+            warnings.push(`LOCALE_PATHS in ${path.basename(settingsPath)} isn't a plain BASE_DIR path — make sure it includes ${localeRel}/ (where the .po files were written).`);
+        }
+    }
     // ── LANGUAGE_CODE ───────────────────────────────────────────
     // Only added when missing; an existing value is a deliberate choice.
     if (!hasSetting(source, 'LANGUAGE_CODE')) {
-        source = appendSetting(source, `LANGUAGE_CODE = '${sourceLocale}'`);
-        changes.push(`Added LANGUAGE_CODE = '${sourceLocale}'`);
+        source = appendSetting(source, `LANGUAGE_CODE = '${(0, locale_names_1.djangoLanguageCode)(sourceLocale)}'`, nl);
+        changes.push(`Added LANGUAGE_CODE = '${(0, locale_names_1.djangoLanguageCode)(sourceLocale)}'`);
     }
     // ── LANGUAGES ───────────────────────────────────────────────
-    if (!hasSetting(source, 'LANGUAGES') && targetLocales.length > 0) {
-        const all = [sourceLocale, ...targetLocales].filter((l, i, arr) => l && arr.indexOf(l) === i);
-        const entries = all.map((l) => `    ('${l}', '${l}'),`).join('\n');
-        source = appendSetting(source, `LANGUAGES = [\n${entries}\n]`);
-        changes.push(`Added LANGUAGES (${all.length} locales)`);
+    // Django only activates languages listed here. Ours live in the Babelize
+    // block and grow with new target locales; a list the user wrote is theirs —
+    // we only point out what it is missing.
+    const wanted = languageEntries([sourceLocale, ...targetLocales]);
+    const listed = listedLanguages(source);
+    if (!listed && targetLocales.length > 0) {
+        const entries = wanted.map((e) => `    ('${e.code}', '${e.name.replace(/'/g, "\\'")}'),`).join(nl);
+        source = appendSetting(source, `LANGUAGES = [${nl}${entries}${nl}]`, nl);
+        changes.push(`Added LANGUAGES (${wanted.length} locales)`);
+    }
+    else if (listed) {
+        const missing = wanted.filter((e) => !listed.codes.includes(e.code) && !listed.codes.includes(e.code.split('-')[0]));
+        const managedAt = source.indexOf(MANAGED_BLOCK_HEADER);
+        if (missing.length > 0 && managedAt !== -1 && listed.start > managedAt) {
+            const body = source.slice(listed.start, listed.end);
+            const close = body.lastIndexOf(']');
+            if (close !== -1) {
+                const indent = /\n([ \t]+)\(/.exec(body)?.[1] ?? '    ';
+                const before = body.slice(0, close).replace(/\s*$/, '');
+                const sep = before.endsWith(',') || before.endsWith('[') ? '' : ',';
+                const added = missing.map((e) => `${indent}('${e.code}', '${e.name.replace(/'/g, "\\'")}'),`).join(nl);
+                const next = `${before}${sep}${nl}${added}${nl}${body.slice(close)}`;
+                source = source.slice(0, listed.start) + next + source.slice(listed.end);
+                changes.push(`Added ${missing.map((e) => e.code).join(', ')} to LANGUAGES`);
+            }
+        }
+        else if (missing.length > 0) {
+            warnings.push(`LANGUAGES in ${path.basename(settingsPath)} doesn't list ${missing.map((e) => `'${e.code}'`).join(', ')} — ` +
+                'Django will not switch to those languages until you add them.');
+        }
     }
     if (changes.length === 0) {
         logger_1.engineLogger.info('Django settings already configured for i18n', { settingsPath });
@@ -258,7 +395,7 @@ async function finalizeDjangoSettings(workspacePath, options = {}) {
         changes,
         dryRun,
     });
-    return { settingsPath, changes, warnings };
+    return { settingsPath, changes, warnings, original, updated: source };
 }
 /**
  * Append a setting under a single Babelize block at the end of the file.
@@ -267,9 +404,9 @@ async function finalizeDjangoSettings(workspacePath, options = {}) {
  * alternative, inserting near related settings, means moving code around a file
  * we cannot parse.
  */
-function appendSetting(source, statement) {
+function appendSetting(source, statement, nl = '\n') {
     const withBlock = source.includes(MANAGED_BLOCK_HEADER)
         ? source
-        : `${source.trimEnd()}\n\n${MANAGED_BLOCK_HEADER}\n`;
-    return `${withBlock.trimEnd()}\n${statement}\n`;
+        : `${source.trimEnd()}${nl}${nl}${MANAGED_BLOCK_HEADER}${nl}`;
+    return `${withBlock.trimEnd()}${nl}${statement}${nl}`;
 }

package/dist/modules/finalization/finalize.d.ts

@@ -1,4 +1,5 @@
 import type { WorkspaceInfo } from '../../runtime/types';
+import { type FinalizationChange } from './writes';
 interface PackageJson {
     dependencies?: Record<string, string>;
     devDependencies?: Record<string, string>;
@@ -21,6 +22,7 @@ export declare function finalizeProject(workspace: WorkspaceInfo, dryRun: boolea
         entryPointModified: boolean;
         packagesInstalled: boolean;
         warnings: string[];
+        changedFiles: FinalizationChange[];
     };
 }>;
 /**

package/dist/modules/finalization/finalize.js

@@ -44,6 +44,7 @@ const ast_helpers_1 = require("../../utils/ast-helpers");
 const static_runtime_1 = require("./static-runtime");
 const django_finalize_1 = require("./django-finalize");
 const nextjs_finalize_1 = require("./nextjs-finalize");
+const writes_1 = require("./writes");
 const i18next_icu_1 = require("../../utils/i18next-icu");
 const DEPENDENCIES_BY_FRAMEWORK = {
     react: {
@@ -235,6 +236,12 @@ async function finalizeProject(workspace, dryRun, options = {}) {
     let entryPointModified = false;
     let packagesInstalled = false;
     let userOwnsInit = false;
+    /**
+     * Every file finalization writes goes through this recorder, so hosts can
+     * ship all of them with the run (the PR, the ZIP, the CLI diff) — including
+     * files it creates.
+     */
+    const writer = new writes_1.FinalizationWriter(workspace.path, dryRun);
     // Coerced against FRAMEWORKS, not SUPPORTED_FRAMEWORKS. SUPPORTED_FRAMEWORKS
     // omits 'django', so a Django project used to collapse to 'unknown' here —
     // which made the two `framework === 'django'` branches below unreachable and
@@ -259,15 +266,19 @@ async function finalizeProject(workspace, dryRun, options = {}) {
                     requiredDeps = nextjs_finalize_1.NEXT_INTL_DEPENDENCIES;
                 const missingDeps = Object.keys(requiredDeps).filter((d) => !deps[d]);
                 if (missingDeps.length > 0) {
+                    pkg.dependencies = pkg.dependencies || {};
+                    for (const dep of missingDeps) {
+                        pkg.dependencies[dep] = requiredDeps[dep];
+                    }
+                    // Keep the user's key order (a sorted package.json is an unreviewable
+                    // diff); only the dependency map is sorted, as npm does.
+                    pkg.dependencies = Object.fromEntries(Object.entries(pkg.dependencies).sort(([a], [b]) => a.localeCompare(b)));
+                    await writer.write(packageJsonPath, `${JSON.stringify(pkg, null, 2)}\n`);
                     if (!dryRun) {
-                        pkg.dependencies = pkg.dependencies || {};
-                        for (const dep of missingDeps) {
-                            pkg.dependencies[dep] = requiredDeps[dep];
-                        }
-                        // Keep the user's key order (a sorted package.json is an unreviewable
-                        // diff); only the dependency map is sorted, as npm does.
-                        pkg.dependencies = Object.fromEntries(Object.entries(pkg.dependencies).sort(([a], [b]) => a.localeCompare(b)));
-                        await (0, file_utils_1.writeJsonFile)(packageJsonPath, pkg, false);
+                        // A committed lockfile must move with package.json, or `npm ci` /
+                        // `--frozen-lockfile` fails on the merged PR. Snapshot it so the
+                        // install's update is recorded (and shipped) like any other write.
+                        const lockfilesBefore = await readLockfiles(workspace.path);
                         if (options.installDependencies !== false) {
                             try {
                                 const pkgManager = detectPackageManager(workspace.path);
@@ -297,6 +308,17 @@ async function finalizeProject(workspace, dryRun, options = {}) {
                                 warnings.push(`Added dependencies to package.json but auto-install failed. Please run your package manager to install: ${missingDeps.join(', ')}`);
                             }
                         }
+                        const lockfilesAfter = await readLockfiles(workspace.path);
+                        for (const [name, before] of lockfilesBefore) {
+                            const after = lockfilesAfter.get(name);
+                            if (after !== undefined && after !== before) {
+                                writer.record(path.join(workspace.path, name), before, after);
+                            }
+                            else {
+                                warnings.push(`${name} was not updated for the new dependencies (${missingDeps.join(', ')}). ` +
+                                    `Run your package manager's install and commit ${name} before merging, or frozen-lockfile installs (npm ci) will fail.`);
+                            }
+                        }
                     }
                     dependenciesInvalid = true;
                     if (packagesInstalled) {
@@ -326,9 +348,7 @@ async function finalizeProject(workspace, dryRun, options = {}) {
                 sourceLocale: workspace.sourceDirs[0] || 'en',
                 targetLocales: workspace.existingLocales || [],
             });
-            if (!dryRun) {
-                await (0, file_utils_1.writeFile)(i18nJsPath, runtimeContent);
-            }
+            await writer.write(i18nJsPath, runtimeContent);
             configFileCreated = true;
             if (regenerationStatus === 'ours') {
                 warnings.push('Updated i18n.js (new version available).');
@@ -346,19 +366,24 @@ async function finalizeProject(workspace, dryRun, options = {}) {
             targetLocales: options.targetLocales,
             sourceLocale: options.sourceLocale,
             dryRun,
+            djangoRoot: workspace.djangoRoot,
+            localeDir: workspace.publicDir,
         });
         warnings.push(...django.warnings);
         if (django.changes.length > 0) {
             configFileCreated = true;
-            warnings.push(`Configured ${path.basename(django.settingsPath ?? 'settings.py')}: ${django.changes.join('; ')}.` +
-                ' Run `python manage.py compilemessages` to compile the .po files.');
+            warnings.push(`Configured ${path.basename(django.settingsPath ?? 'settings.py')}: ${django.changes.join('; ')}.`);
+            if (django.settingsPath && django.original !== undefined && django.updated !== undefined) {
+                // finalizeDjangoSettings writes settings.py itself (it needs the parse); record it here.
+                writer.record(django.settingsPath, django.original, django.updated);
+            }
         }
     }
     else if (useNextIntl) {
         const nextIntl = await (0, nextjs_finalize_1.finalizeNextIntl)(workspace, dryRun, {
             sourceLocale: options.sourceLocale,
             targetLocales: options.targetLocales,
-        });
+        }, writer);
         warnings.push(...nextIntl.warnings);
         configFileCreated = configFileCreated || nextIntl.configFileCreated;
         entryPointModified = entryPointModified || nextIntl.entryPointModified;
@@ -375,8 +400,7 @@ async function finalizeProject(workspace, dryRun, options = {}) {
             const content = await (0, file_utils_1.readFile)(abs);
             const updated = (0, i18next_icu_1.addIcuToGeneratedConfig)(content);
             if (updated !== content) {
-                if (!dryRun)
-                    await (0, file_utils_1.writeFile)(abs, updated);
+                await writer.write(abs, updated);
                 warnings.push(`Added i18next-icu to ${rel} (needed for messages with placeholders and plurals).`);
             }
         }
@@ -391,15 +415,13 @@ async function finalizeProject(workspace, dryRun, options = {}) {
                 (await (0, file_utils_1.pathExists)(path.join(workspace.path, 'tsconfig.json')));
             const targetPath = isTS ? i18nPath : i18nJsPath;
             const template = I18N_CONFIG_TEMPLATES[framework] || I18N_CONFIG_TEMPLATES['unknown'];
-            if (!dryRun)
-                await (0, file_utils_1.writeFile)(targetPath, template);
+            await writer.write(targetPath, template);
             configFileCreated = true;
         }
         if (framework === 'nextjs' && !userOwnsInit) {
             const providerPath = path.join(workspace.path, srcDir, 'I18nProvider.tsx');
             if (!(await (0, file_utils_1.pathExists)(providerPath))) {
-                if (!dryRun)
-                    await (0, file_utils_1.writeFile)(providerPath, I18N_PROVIDER_TEMPLATE);
+                await writer.write(providerPath, I18N_PROVIDER_TEMPLATE);
                 configFileCreated = true;
             }
         }
@@ -439,9 +461,7 @@ async function finalizeProject(workspace, dryRun, options = {}) {
                 }
                 const modified = modifyVueEntryPoint(content, relativeI18nPath);
                 if (modified !== null) {
-                    if (!dryRun) {
-                        await (0, file_utils_1.writeFile)(entryPath, modified);
-                    }
+                    await writer.write(entryPath, modified);
                     entryPointModified = true;
                 }
                 break;
@@ -464,8 +484,7 @@ async function finalizeProject(workspace, dryRun, options = {}) {
                 if (isNextLayout) {
                     const modified = modifyNextjsLayout(content, relativeI18nPath);
                     if (modified !== null) {
-                        if (!dryRun)
-                            await (0, file_utils_1.writeFile)(entryPath, modified);
+                        await writer.write(entryPath, modified);
                         entryPointModified = true;
                     }
                     break;
@@ -478,17 +497,15 @@ async function finalizeProject(workspace, dryRun, options = {}) {
                     content.includes(`import "${relativeI18nPath}.ts"`) ||
                     content.includes("import '@/i18n'");
                 if (!hasImport) {
-                    if (!dryRun) {
-                        const newContent = `import '${relativeI18nPath}';\n${content}`;
-                        await (0, file_utils_1.writeFile)(entryPath, newContent);
-                    }
+                    await writer.write(entryPath, `import '${relativeI18nPath}';\n${content}`);
                     entryPointModified = true;
                 }
                 break;
             }
         }
     }
-    return { finalization: { dependenciesInvalid, configFileCreated, entryPointModified, packagesInstalled, warnings } };
+    const changedFiles = writer.changes;
+    return { finalization: { dependenciesInvalid, configFileCreated, entryPointModified, packagesInstalled, warnings, changedFiles } };
 }
 /**
  * Wire Next.js App Router layouts through a client I18nProvider so i18n
@@ -687,6 +704,17 @@ function modifyVueEntryPoint(content, relativeI18nPath) {
         return `import i18n from '${relativeI18nPath}';\n${content}`;
     }
 }
+/** Text lockfiles a package manager rewrites on install (bun.lockb is binary and left to the user). */
+const TEXT_LOCKFILES = ['package-lock.json', 'npm-shrinkwrap.json', 'yarn.lock', 'pnpm-lock.yaml', 'bun.lock'];
+async function readLockfiles(workspacePath) {
+    const found = new Map();
+    for (const name of TEXT_LOCKFILES) {
+        const abs = path.join(workspacePath, name);
+        if (await (0, file_utils_1.pathExists)(abs))
+            found.set(name, await (0, file_utils_1.readFile)(abs));
+    }
+    return found;
+}
 function detectPackageManager(workspacePath) {
     if ((0, fs_1.existsSync)(path.join(workspacePath, 'bun.lock')))
         return 'bun';

package/dist/modules/finalization/nextjs-finalize.d.ts

@@ -1,3 +1,4 @@
+import { FinalizationWriter } from './writes';
 import type { WorkspaceInfo } from '../../runtime/types';
 /**
  * Next.js finalization for next-intl.
@@ -34,4 +35,6 @@ export declare function wrapRootLayout(content: string, typescript: boolean): st
 export declare function finalizeNextIntl(workspace: WorkspaceInfo, dryRun: boolean, options: {
     sourceLocale?: string;
     targetLocales?: string[];
-}): Promise<NextIntlFinalizeResult>;
+}, 
+/** Records every write so it ships with the run (finalizeProject passes its own). */
+writer?: FinalizationWriter): Promise<NextIntlFinalizeResult>;

package/dist/modules/finalization/nextjs-finalize.js

@@ -41,6 +41,7 @@ exports.finalizeNextIntl = finalizeNextIntl;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const file_utils_1 = require("../../utils/file-utils");
+const writes_1 = require("./writes");
 const ast_helpers_1 = require("../../utils/ast-helpers");
 /**
  * Next.js finalization for next-intl.
@@ -234,7 +235,9 @@ async function availableLocales(workspace, options) {
     const targets = (options.targetLocales ?? []).filter((l) => l !== source);
     return [...new Set([...targets, ...[...found].sort()])];
 }
-async function finalizeNextIntl(workspace, dryRun, options) {
+async function finalizeNextIntl(workspace, dryRun, options, 
+/** Records every write so it ships with the run (finalizeProject passes its own). */
+writer = new writes_1.FinalizationWriter(workspace.path, dryRun)) {
     const warnings = [];
     let configFileCreated = false;
     let entryPointModified = false;
@@ -278,8 +281,7 @@ async function finalizeNextIntl(workspace, dryRun, options) {
             typescript: requestIsTs,
         });
         if (content !== existingContent) {
-            if (!dryRun)
-                await (0, file_utils_1.writeFile)(requestFile, content);
+            await writer.write(requestFile, content);
             configFileCreated = true;
         }
     }
@@ -290,8 +292,7 @@ async function finalizeNextIntl(workspace, dryRun, options) {
         const created = `import createNextIntlPlugin from 'next-intl/plugin';\n\n` +
             `const withNextIntl = createNextIntlPlugin(${JSON.stringify(pluginPath)});\n\n` +
             `/** @type {import('next').NextConfig} */\nconst nextConfig = {};\n\nexport default withNextIntl(nextConfig);\n`;
-        if (!dryRun)
-            await (0, file_utils_1.writeFile)(path.join(root, 'next.config.mjs'), created);
+        await writer.write(path.join(root, 'next.config.mjs'), created);
         configFileCreated = true;
     }
     else {
@@ -302,8 +303,7 @@ async function finalizeNextIntl(workspace, dryRun, options) {
                 `createNextIntlPlugin(${JSON.stringify(pluginPath)}) from 'next-intl/plugin'.`);
         }
         else if (wrapped !== content) {
-            if (!dryRun)
-                await (0, file_utils_1.writeFile)(nextConfigPath, wrapped);
+            await writer.write(nextConfigPath, wrapped);
             configFileCreated = true;
         }
     }
@@ -320,8 +320,7 @@ async function finalizeNextIntl(workspace, dryRun, options) {
                 'wrap it in <NextIntlClientProvider> from next-intl so Client Components can translate.');
         }
         else if (wrapped !== content) {
-            if (!dryRun)
-                await (0, file_utils_1.writeFile)(layoutPath, wrapped);
+            await writer.write(layoutPath, wrapped);
             entryPointModified = true;
         }
     }

package/dist/modules/finalization/writes.d.ts

@@ -0,0 +1,29 @@
+/** A file finalization created or edited, relative to the workspace root (POSIX separators). */
+export interface FinalizationChange {
+    file: string;
+    /** '' when the file did not exist before the run. */
+    originalContent: string;
+    modifiedContent: string;
+    /** True when finalization created the file (it was not in the project before). */
+    created: boolean;
+}
+/**
+ * The single path every finalization write goes through.
+ *
+ * Hosts ship `changes` with the run (the GitHub PR, the ZIP, the CLI report),
+ * so a write that bypasses this recorder is a file the PR silently leaves out:
+ * `t()` calls merged without the dependency or the init code that makes them
+ * work. Records new files as well as edits, and folds repeated writes to one
+ * file into a single change (first original, last content).
+ */
+export declare class FinalizationWriter {
+    readonly root: string;
+    readonly dryRun: boolean;
+    private readonly byFile;
+    constructor(root: string, dryRun: boolean);
+    /** Write `content` to `absPath` (unless dry run) and record it. Returns false when the file already had that content. */
+    write(absPath: string, content: string): Promise<boolean>;
+    /** Record a write made elsewhere (e.g. by a package manager). `original` null = file was created. */
+    record(absPath: string, original: string | null, content: string): void;
+    get changes(): FinalizationChange[];
+}

package/dist/modules/finalization/writes.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FinalizationWriter = void 0;
+const path = __importStar(require("path"));
+const file_utils_1 = require("../../utils/file-utils");
+/**
+ * The single path every finalization write goes through.
+ *
+ * Hosts ship `changes` with the run (the GitHub PR, the ZIP, the CLI report),
+ * so a write that bypasses this recorder is a file the PR silently leaves out:
+ * `t()` calls merged without the dependency or the init code that makes them
+ * work. Records new files as well as edits, and folds repeated writes to one
+ * file into a single change (first original, last content).
+ */
+class FinalizationWriter {
+    constructor(root, dryRun) {
+        this.root = root;
+        this.dryRun = dryRun;
+        this.byFile = new Map();
+    }
+    /** Write `content` to `absPath` (unless dry run) and record it. Returns false when the file already had that content. */
+    async write(absPath, content) {
+        const original = (await (0, file_utils_1.pathExists)(absPath)) ? await (0, file_utils_1.readFile)(absPath) : null;
+        if (original === content)
+            return false;
+        if (!this.dryRun)
+            await (0, file_utils_1.writeFile)(absPath, content);
+        this.record(absPath, original, content);
+        return true;
+    }
+    /** Record a write made elsewhere (e.g. by a package manager). `original` null = file was created. */
+    record(absPath, original, content) {
+        const file = path.relative(this.root, path.resolve(absPath)).split(path.sep).join('/');
+        const prev = this.byFile.get(file);
+        if (prev) {
+            prev.modifiedContent = content;
+            return;
+        }
+        this.byFile.set(file, { file, originalContent: original ?? '', modifiedContent: content, created: original === null });
+    }
+    get changes() {
+        return [...this.byFile.values()];
+    }
+}
+exports.FinalizationWriter = FinalizationWriter;

package/dist/modules/format-injection/index.js

@@ -203,7 +203,8 @@ async function injectFormats(workspace, formatStrings, formatConfig, dryRun = fa
             if (!fileStrings || fileStrings.length === 0)
                 continue;
             try {
-                let content = await (0, file_utils_1.readFile)(filePath);
+                const originalContent = await (0, file_utils_1.readFile)(filePath);
+                let content = originalContent;
                 const injections = [];
                 for (const formatStr of fileStrings) {
                     if (!formatStr.detectedFormat)
@@ -234,7 +235,7 @@ async function injectFormats(workspace, formatStrings, formatConfig, dryRun = fa
                     await (0, file_utils_1.writeFile)(filePath, content);
                 modifiedFiles.push({
                     file: relativePath,
-                    originalContent: await (0, file_utils_1.readFile)(filePath).catch(() => ''),
+                    originalContent,
                     modifiedContent: content,
                     injections,
                     importAdded: false,