@inlang/paraglide-js 2.26.0 → 2.28.0

package/dist/compiler/compile-project.test.js

@@ -1,4 +1,5 @@
 import { expect, test, describe, vi, beforeEach } from "vitest";
+import vm from "node:vm";
 import { createProject as typescriptProject, ts, } from "@ts-morph/bootstrap";
 import { Declaration, insertBundleNested, loadProjectInMemory, newProject, Pattern, VariableReference, } from "@inlang/sdk";
 import { compileProject, getFallbackMap } from "./compile-project.js";
@@ -24,6 +25,35 @@ function hasFallbackCycle(fallbackMap, start) {
     }
     return false;
 }
+test("locale-modules retain language-grouped static text helpers", async () => {
+    const project = await loadProjectInMemory({
+        blob: await newProject({
+            settings: { baseLocale: "en", locales: ["en", "de"] },
+        }),
+    });
+    await insertBundleNested(project.db, createBundleNested({
+        id: "literal_layout",
+        declarations: [],
+        messages: ["en", "de"].map((locale) => ({
+            locale,
+            variants: [
+                {
+                    pattern: [
+                        { type: "text", value: `layout text ${locale}` },
+                    ],
+                },
+            ],
+        })),
+    }));
+    const output = await compileProject({
+        project,
+        compilerOptions: { outputStructure: "locale-modules" },
+    });
+    expect(output["messages/_index.js"]).toContain("return __de.literal_layout(inputs)");
+    expect(output["messages/_index.js"]).not.toContain('return /** @type {LocalizedString} */ ("layout text de")');
+    expect(output["messages/de.js"]).toContain("export const literal_layout =");
+    await project.close();
+});
 test("emitGitignore", async () => {
     const project = await loadProjectInMemory({
         blob: await newProject({
@@ -87,6 +117,70 @@ test("marks tree-shakeable generated message layouts as side-effect-free", async
         sideEffects: false,
     });
 });
+test("inlines static text and retains only fallback helpers under strict checkJs", async () => {
+    const project = await loadProjectInMemory({
+        blob: await newProject({
+            settings: {
+                baseLocale: "en",
+                locales: ["en", "de", "de-AT"],
+            },
+        }),
+    });
+    await insertBundleNested(project.db, createBundleNested({
+        id: "plain_greeting",
+        messages: [
+            {
+                locale: "en",
+                variants: [{ pattern: [{ type: "text", value: "Hello" }] }],
+            },
+            {
+                locale: "de",
+                variants: [{ pattern: [{ type: "text", value: "Hallo" }] }],
+            },
+        ],
+    }));
+    const output = await compileProject({
+        project,
+        compilerOptions: { outputStructure: "message-modules" },
+    });
+    const messageModule = output["messages/plain_greeting.js"];
+    // The base locale is returned inline, while de-AT's missing-locale alias
+    // still needs the de message function.
+    expect(messageModule).not.toContain("const en_plain_greeting =");
+    expect(messageModule).toContain("const de_plain_greeting =");
+    expect(messageModule).toMatch(/const de_at\d*_plain_greeting = de_plain_greeting;/);
+    const tsProject = await typescriptProject({
+        useInMemoryFileSystem: true,
+        compilerOptions: {
+            outDir: "dist",
+            declaration: true,
+            allowJs: true,
+            checkJs: true,
+            noImplicitAny: true,
+            noUnusedLocals: true,
+            noUnusedParameters: true,
+            noImplicitReturns: true,
+            noImplicitThis: true,
+            noUncheckedIndexedAccess: true,
+            noPropertyAccessFromIndexSignature: true,
+            module: ts.ModuleKind.Node16,
+            strict: true,
+        },
+    });
+    for (const [fileName, code] of Object.entries(output)) {
+        if (fileName.endsWith(".js") || fileName.endsWith(".ts")) {
+            tsProject.createSourceFile(fileName, code);
+        }
+    }
+    const diagnostics = ts
+        .getPreEmitDiagnostics(tsProject.createProgram())
+        .filter((d) => !d.messageText.toString().includes("Cannot find module 'async_hooks'"));
+    expect(diagnostics).toEqual([]);
+    const { m } = await importCode(await bundleCode(output, `export * as m from "./paraglide/messages.js"`));
+    expect(m.plain_greeting({}, { locale: "en" })).toBe("Hello");
+    expect(m.plain_greeting({}, { locale: "de" })).toBe("Hallo");
+    expect(m.plain_greeting({}, { locale: "de-AT" })).toBe("Hallo");
+});
 test("emitPrettierIgnore", async () => {
     const project = await loadProjectInMemory({
         blob: await newProject({
@@ -163,6 +257,8 @@ test("emitReadme includes project path", async () => {
     expect(output["README.md"]).toContain(projectPath);
     expect(output["README.md"]).toContain("Compiled from:");
     expect(output["README.md"]).toContain("Paraglide JS");
+    expect(output["README.md"]).toContain(`npx @inlang/paraglide-js compile --project ${projectPath}`);
+    expect(output["README.md"]).toContain("npx @inlang/cli check");
 });
 test("throws during compile for invalid routeStrategies match patterns", async () => {
     const project = await loadProjectInMemory({
@@ -1143,7 +1239,7 @@ describe.each([
             project: projectWithPatternAnnotation,
             compilerOptions,
         });
-        expect(Object.values(output).join("\n")).toContain('registry.number("en", i?.count, { maximumFractionDigits: 1 })');
+        expect(Object.values(output).join("\n")).toContain('registry.number("en", i?.count, { maximumFractionDigits: 1 }, true)');
         const tsProject = await typescriptProject({
             useInMemoryFileSystem: true,
             compilerOptions: superStrictRuleOutAnyErrorTsSettings,
@@ -1250,179 +1346,1143 @@ describe.each([
         }
         expect(diagnostics.length).toEqual(0);
     });
-});
-async function bundleCode(output, file) {
-    output["runtime.js"] = output["runtime.js"].replace('import "@inlang/paraglide-js/urlpattern-polyfill";', "/** @type {any} */const URLPattern = {};").replace('const { AsyncLocalStorage } = await import("async_hooks");', "const AsyncLocalStorage = class {};");
-    const bundle = await rolldown({
-        input: ["main.js"],
-        plugins: [
-            // @ts-expect-error - rollup types are not up to date
-            virtual({
-                ...Object.fromEntries(Object.entries(output).map(([fileName, code]) => [
-                    "paraglide/" + fileName,
-                    code,
-                ])),
-                "main.js": file,
+    test("ICU exact number aliases select numerically and pass checkJs", async () => {
+        const icuProject = await loadProjectInMemory({
+            blob: await newProject({
+                settings: { baseLocale: "en", locales: ["en", "fr"] },
             }),
-        ],
-    });
-    const compiled = await bundle.generate({ format: "esm" });
-    const code = compiled.output[0].code;
-    return code;
-}
-async function importCode(code) {
-    // The random comment ensures that each code is a unique module
-    // and state is not shared between imports
-    const randomComment = `// ${Math.random()}`;
-    const codeWithComment = `${randomComment}\n${code}`;
-    return await import(`data:application/javascript;base64,${Buffer.from(codeWithComment, "utf8").toString("base64")}`);
-}
-const project = await loadProjectInMemory({
-    blob: await newProject({
-        settings: {
-            baseLocale: "en",
-            locales: ["en", "de", "en-US"],
-        },
-    }),
-});
-const mockBundles = [
-    createBundleNested({
-        id: "sad_penguin_bundle",
-        messages: [
-            {
-                locale: "en",
-                variants: [{ pattern: [{ type: "text", value: "A simple message." }] }],
-            },
-            {
-                locale: "de",
-                variants: [
-                    { pattern: [{ type: "text", value: "Eine einfache Nachricht." }] },
-                ],
-            },
-        ],
-    }),
-    createBundleNested({
-        id: "Sad_penguin_bundle",
-        messages: [
-            {
-                locale: "en",
-                variants: [
-                    { pattern: [{ type: "text", value: "Capital Sad penguin" }] },
-                ],
-            },
-            {
-                locale: "de",
-                variants: [
-                    {
-                        pattern: [
-                            { type: "text", value: "Grossgeschriebenes Sad penguin" },
-                        ],
-                    },
-                ],
-            },
-        ],
-    }),
-    {
-        id: "depressed_dog",
-        declarations: [
+        });
+        const countPluralExact = (value) => value === undefined
+            ? { type: "catchall-match", key: "countPluralExact" }
+            : {
+                type: "literal-match",
+                key: "countPluralExact",
+                value,
+            };
+        const countPlural = (value) => value === undefined
+            ? { type: "catchall-match", key: "countPlural" }
+            : { type: "literal-match", key: "countPlural", value };
+        const withCount = (suffix) => [
             {
-                type: "input-variable",
-                name: "name",
+                type: "expression",
+                arg: { type: "variable-reference", name: "count" },
             },
-        ],
-        messages: [
-            {
-                id: "depressed_dog_en",
-                bundleId: "depressed_dog",
-                locale: "en",
-                selectors: [],
-                variants: [
-                    {
-                        id: "depressed_dog_en_variant_one",
-                        messageId: "depressed_dog_en",
-                        matches: [],
-                        pattern: [
-                            { type: "text", value: "Good morning " },
-                            {
-                                type: "expression",
-                                arg: { type: "variable-reference", name: "name" },
-                            },
-                            { type: "text", value: "!" },
-                        ],
+            { type: "text", value: suffix },
+        ];
+        // the shape the ICU1 plugin imports {count, plural, =0 {…} one {…} other {…}} as
+        await insertBundleNested(icuProject.db, createBundleNested({
+            id: "item_count",
+            declarations: [
+                { type: "input-variable", name: "count" },
+                {
+                    type: "local-variable",
+                    name: "countPluralExact",
+                    value: {
+                        type: "expression",
+                        arg: { type: "variable-reference", name: "count" },
                     },
-                ],
-            },
-            {
-                id: "depressed_dog_de",
-                bundleId: "depressed_dog",
-                locale: "de",
-                selectors: [],
-                variants: [
-                    {
-                        id: "depressed_dog_de_variant_one",
-                        messageId: "depressed_dog_de",
-                        matches: [],
-                        pattern: [
-                            { type: "text", value: "Guten Morgen " },
-                            {
-                                type: "expression",
-                                arg: { type: "variable-reference", name: "name" },
-                            },
-                            { type: "text", value: "!" },
-                        ],
+                },
+                {
+                    type: "local-variable",
+                    name: "countPlural",
+                    value: {
+                        type: "expression",
+                        arg: { type: "variable-reference", name: "count" },
+                        annotation: {
+                            type: "function-reference",
+                            name: "plural",
+                            options: [],
+                        },
                     },
-                ],
-            },
-        ],
-    },
-    {
-        id: "insane_cats",
-        declarations: [
-            {
-                type: "input-variable",
-                name: "name",
-            },
-            {
-                type: "input-variable",
-                name: "count",
-            },
-        ],
-        messages: [
-            {
-                id: "insane_cats_en",
-                bundleId: "insane_cats",
-                locale: "en",
-                selectors: [],
-                variants: [
-                    {
-                        id: "insane_cats_en_variant_one",
-                        messageId: "insane_cats_en",
-                        matches: [],
-                        pattern: [
-                            { type: "text", value: "Hello " },
-                            {
-                                type: "expression",
-                                arg: { type: "variable-reference", name: "name" },
-                            },
-                            { type: "text", value: "! You have " },
-                            {
-                                type: "expression",
-                                arg: { type: "variable-reference", name: "count" },
-                            },
-                            { type: "text", value: " messages." },
-                        ],
+                },
+            ],
+            messages: [
+                {
+                    locale: "en",
+                    selectors: [
+                        { type: "variable-reference", name: "countPluralExact" },
+                        { type: "variable-reference", name: "countPlural" },
+                    ],
+                    variants: [
+                        {
+                            matches: [countPluralExact("0"), countPlural()],
+                            pattern: [{ type: "text", value: "No items" }],
+                        },
+                        {
+                            matches: [countPluralExact(), countPlural("one")],
+                            pattern: withCount(" item"),
+                        },
+                        {
+                            matches: [countPluralExact(), countPlural()],
+                            pattern: withCount(" items"),
+                        },
+                    ],
+                },
+                {
+                    locale: "fr",
+                    selectors: [
+                        { type: "variable-reference", name: "countPluralExact" },
+                        { type: "variable-reference", name: "countPlural" },
+                    ],
+                    // an editor appends the exact variant last
+                    variants: [
+                        {
+                            matches: [countPluralExact(), countPlural("one")],
+                            pattern: withCount(" élément"),
+                        },
+                        {
+                            matches: [countPluralExact(), countPlural()],
+                            pattern: withCount(" éléments"),
+                        },
+                        {
+                            matches: [countPluralExact("0"), countPlural()],
+                            pattern: [{ type: "text", value: "Aucun élément" }],
+                        },
+                    ],
+                },
+            ],
+        }));
+        // en narrows `status` by a direct match, fr matches through an alias
+        // with a catchall, so any status is accepted
+        await insertBundleNested(icuProject.db, createBundleNested({
+            id: "status_message",
+            declarations: [
+                { type: "input-variable", name: "status" },
+                {
+                    type: "local-variable",
+                    name: "statusExact",
+                    value: {
+                        type: "expression",
+                        arg: { type: "variable-reference", name: "status" },
                     },
-                ],
-            },
-            {
+                },
+            ],
+            messages: [
+                {
+                    locale: "en",
+                    selectors: [{ type: "variable-reference", name: "status" }],
+                    variants: [
+                        {
+                            matches: [
+                                { type: "literal-match", key: "status", value: "active" },
+                            ],
+                            // reads statusExact: unused bundle locals fail noUnusedLocals
+                            pattern: [
+                                { type: "text", value: "Active: " },
+                                {
+                                    type: "expression",
+                                    arg: { type: "variable-reference", name: "statusExact" },
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    locale: "fr",
+                    selectors: [{ type: "variable-reference", name: "statusExact" }],
+                    variants: [
+                        {
+                            matches: [
+                                { type: "literal-match", key: "statusExact", value: "0" },
+                            ],
+                            pattern: [{ type: "text", value: "Zéro" }],
+                        },
+                        {
+                            matches: [{ type: "catchall-match", key: "statusExact" }],
+                            pattern: [{ type: "text", value: "Autre" }],
+                        },
+                    ],
+                },
+            ],
+        }));
+        const output = await compileProject({
+            project: icuProject,
+            compilerOptions,
+        });
+        const tsProject = await typescriptProject({
+            useInMemoryFileSystem: true,
+            compilerOptions: superStrictRuleOutAnyErrorTsSettings,
+        });
+        for (const [fileName, code] of Object.entries(output)) {
+            if (fileName.endsWith(".js") || fileName.endsWith(".ts")) {
+                tsProject.createSourceFile(fileName, code);
+            }
+        }
+        tsProject.createSourceFile("test.ts", `
+				import * as m from "./messages.js"
+
+				m.item_count({ count: 0 }) satisfies string
+				m.item_count({ count: "0" }) satisfies string
+				m.status_message({ status: "active" }) satisfies string
+				m.status_message({ status: "inactive" }) satisfies string
+				`);
+        const program = tsProject.createProgram();
+        const diagnostics = ts.getPreEmitDiagnostics(program).filter((d) => {
+            return !d.messageText
+                .toString()
+                .includes("Cannot find module 'async_hooks'");
+        });
+        for (const diagnostic of diagnostics) {
+            console.error(diagnostic.messageText, diagnostic.file?.fileName);
+        }
+        expect(diagnostics.length).toEqual(0);
+        const { m } = await importCode(await bundleCode(output, `export * as m from "./paraglide/messages.js"`));
+        const render = (locale) => [0, 1, 2, 5, 21, "0"].map((count) => m.item_count({ count }, { locale }));
+        expect(render("en")).toEqual([
+            "No items",
+            "1 item",
+            "2 items",
+            "5 items",
+            "21 items",
+            "No items",
+        ]);
+        expect(render("fr")).toEqual([
+            "Aucun élément",
+            "1 élément",
+            "2 éléments",
+            "5 éléments",
+            "21 éléments",
+            "Aucun élément",
+        ]);
+        expect(m.status_message({ status: "inactive" }, { locale: "fr" })).toBe("Autre");
+    });
+    test("emits only the locals a locale reads, in dependency order, and supports plural offsets under checkJs", async () => {
+        const localsProject = await loadProjectInMemory({
+            blob: await newProject({
+                settings: { baseLocale: "en", locales: ["en", "fr"] },
+            }),
+        });
+        const ref = (name) => ({ type: "variable-reference", name });
+        const literal = (key, value) => ({ type: "literal-match", key, value });
+        const catchall = (key) => ({ type: "catchall-match", key });
+        const text = (value) => [{ type: "text", value }];
+        // en never reads statusExact, fr only reads it
+        await insertBundleNested(localsProject.db, createBundleNested({
+            id: "status_label",
+            declarations: [
+                { type: "input-variable", name: "status" },
+                {
+                    type: "local-variable",
+                    name: "statusExact",
+                    value: { type: "expression", arg: ref("status") },
+                },
+            ],
+            messages: [
+                {
+                    locale: "en",
+                    selectors: [ref("status")],
+                    variants: [
+                        {
+                            matches: [literal("status", "active")],
+                            pattern: text("Active"),
+                        },
+                        { matches: [catchall("status")], pattern: text("Other") },
+                    ],
+                },
+                {
+                    locale: "fr",
+                    selectors: [ref("statusExact")],
+                    variants: [
+                        {
+                            matches: [literal("statusExact", "0")],
+                            pattern: text("Zéro"),
+                        },
+                        { matches: [catchall("statusExact")], pattern: text("Autre") },
+                    ],
+                },
+            ],
+        }));
+        // the shape the ICU1 plugin imports
+        // {count, plural, offset:1 =0 {…} =1 {…} one {…} other {…}} as
+        await insertBundleNested(localsProject.db, createBundleNested({
+            id: "guest_list",
+            declarations: [
+                { type: "input-variable", name: "count" },
+                {
+                    type: "local-variable",
+                    name: "countPluralOffset1",
+                    value: {
+                        type: "expression",
+                        arg: ref("count"),
+                        annotation: {
+                            type: "function-reference",
+                            name: "plural",
+                            options: [
+                                { name: "offset", value: { type: "literal", value: "1" } },
+                            ],
+                        },
+                    },
+                },
+                {
+                    type: "local-variable",
+                    name: "countPluralOffset1Exact",
+                    value: { type: "expression", arg: ref("count") },
+                },
+            ],
+            messages: [
+                {
+                    locale: "en",
+                    selectors: [
+                        ref("countPluralOffset1Exact"),
+                        ref("countPluralOffset1"),
+                    ],
+                    variants: [
+                        {
+                            matches: [
+                                literal("countPluralOffset1Exact", "0"),
+                                catchall("countPluralOffset1"),
+                            ],
+                            pattern: text("Nobody"),
+                        },
+                        {
+                            matches: [
+                                literal("countPluralOffset1Exact", "1"),
+                                catchall("countPluralOffset1"),
+                            ],
+                            pattern: text("Only you"),
+                        },
+                        {
+                            matches: [
+                                catchall("countPluralOffset1Exact"),
+                                literal("countPluralOffset1", "one"),
+                            ],
+                            pattern: text("You and one other"),
+                        },
+                        {
+                            matches: [
+                                catchall("countPluralOffset1Exact"),
+                                catchall("countPluralOffset1"),
+                            ],
+                            pattern: text("You and others"),
+                        },
+                    ],
+                },
+                {
+                    // fr does not translate the exact cases: countPluralOffset1Exact
+                    // is not read
+                    locale: "fr",
+                    selectors: [ref("countPluralOffset1")],
+                    variants: [
+                        {
+                            matches: [literal("countPluralOffset1", "one")],
+                            pattern: text("Vous et un autre"),
+                        },
+                        {
+                            matches: [catchall("countPluralOffset1")],
+                            pattern: text("Vous et d'autres"),
+                        },
+                    ],
+                },
+            ],
+        }));
+        // fr reads no variable at all
+        await insertBundleNested(localsProject.db, createBundleNested({
+            id: "greeting_label",
+            declarations: [
+                { type: "input-variable", name: "name" },
+                {
+                    type: "local-variable",
+                    name: "nameValue",
+                    value: { type: "expression", arg: ref("name") },
+                },
+            ],
+            messages: [
+                {
+                    locale: "en",
+                    selectors: [],
+                    variants: [
+                        {
+                            matches: [],
+                            pattern: [
+                                { type: "text", value: "Hello " },
+                                { type: "expression", arg: ref("nameValue") },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    locale: "fr",
+                    selectors: [],
+                    variants: [{ matches: [], pattern: text("Bonjour") }],
+                },
+            ],
+        }));
+        // a local declared before the local it reads
+        await insertBundleNested(localsProject.db, createBundleNested({
+            id: "reordered_locals",
+            declarations: [
+                { type: "input-variable", name: "count" },
+                {
+                    type: "local-variable",
+                    name: "countPlural",
+                    value: {
+                        type: "expression",
+                        arg: ref("countValue"),
+                        annotation: {
+                            type: "function-reference",
+                            name: "plural",
+                            options: [],
+                        },
+                    },
+                },
+                {
+                    type: "local-variable",
+                    name: "countValue",
+                    value: { type: "expression", arg: ref("count") },
+                },
+            ],
+            messages: [
+                {
+                    locale: "en",
+                    selectors: [ref("countPlural")],
+                    variants: [
+                        {
+                            matches: [literal("countPlural", "one")],
+                            pattern: text("one"),
+                        },
+                        { matches: [catchall("countPlural")], pattern: text("other") },
+                    ],
+                },
+            ],
+        }));
+        const output = await compileProject({
+            project: localsProject,
+            compilerOptions,
+        });
+        const tsProject = await typescriptProject({
+            useInMemoryFileSystem: true,
+            compilerOptions: superStrictRuleOutAnyErrorTsSettings,
+        });
+        for (const [fileName, code] of Object.entries(output)) {
+            if (fileName.endsWith(".js") || fileName.endsWith(".ts")) {
+                tsProject.createSourceFile(fileName, code);
+            }
+        }
+        tsProject.createSourceFile("test.ts", `
+				import * as m from "./messages.js"
+
+				m.status_label({ status: "active" }) satisfies string
+				m.guest_list({ count: 0 }) satisfies string
+				m.reordered_locals({ count: 1 }) satisfies string
+				m.greeting_label({ name: "Ada" }) satisfies string
+				`);
+        const program = tsProject.createProgram();
+        const diagnostics = ts.getPreEmitDiagnostics(program).filter((d) => {
+            return !d.messageText
+                .toString()
+                .includes("Cannot find module 'async_hooks'");
+        });
+        for (const diagnostic of diagnostics) {
+            console.error(diagnostic.messageText, diagnostic.file?.fileName);
+        }
+        expect(diagnostics.length).toEqual(0);
+        const { m } = await importCode(await bundleCode(output, `export * as m from "./paraglide/messages.js"`));
+        expect(["active", "inactive"].map((status) => m.status_label({ status }, { locale: "en" }))).toEqual(["Active", "Other"]);
+        expect([0, "0", 1].map((status) => m.status_label({ status }, { locale: "fr" }))).toEqual(["Zéro", "Zéro", "Autre"]);
+        const guests = (locale) => [0, 1, 2, 3, 22, "1", "2"].map((count) => m.guest_list({ count }, { locale }));
+        expect(guests("en")).toEqual([
+            "Nobody",
+            "Only you",
+            "You and one other",
+            "You and others",
+            "You and others",
+            "Only you",
+            "You and one other",
+        ]);
+        // French "one" covers 0 and 1 (and -1 for 0 guests), so 1 and 2 guests
+        // (0 and 1 others) select "one"
+        expect(guests("fr")).toEqual([
+            "Vous et un autre",
+            "Vous et un autre",
+            "Vous et un autre",
+            "Vous et d'autres",
+            "Vous et d'autres",
+            "Vous et un autre",
+            "Vous et un autre",
+        ]);
+        expect([1, 2].map((count) => m.reordered_locals({ count }, { locale: "en" }))).toEqual(["one", "other"]);
+        expect(m.greeting_label({ name: "Ada" }, { locale: "en" })).toBe("Hello Ada");
+        expect(m.greeting_label({ name: "Ada" }, { locale: "fr" })).toBe("Bonjour");
+    });
+    test("imports the registry only where a message calls it, and formats ICU # with offset under checkJs", async () => {
+        const compileChecked = async (bundles) => {
+            const icuProject = await loadProjectInMemory({
+                blob: await newProject({
+                    settings: { baseLocale: "en", locales: ["en", "de"] },
+                }),
+            });
+            for (const bundle of bundles) {
+                await insertBundleNested(icuProject.db, createBundleNested(bundle));
+            }
+            const output = await compileProject({
+                project: icuProject,
+                compilerOptions,
+            });
+            const tsProject = await typescriptProject({
+                useInMemoryFileSystem: true,
+                compilerOptions: superStrictRuleOutAnyErrorTsSettings,
+            });
+            for (const [fileName, code] of Object.entries(output)) {
+                if (fileName.endsWith(".js") || fileName.endsWith(".ts")) {
+                    tsProject.createSourceFile(fileName, code);
+                }
+            }
+            const diagnostics = ts
+                .getPreEmitDiagnostics(tsProject.createProgram())
+                .filter((d) => !d.messageText
+                .toString()
+                .includes("Cannot find module 'async_hooks'"));
+            for (const diagnostic of diagnostics) {
+                console.error(diagnostic.messageText, diagnostic.file?.fileName);
+            }
+            expect(diagnostics.length).toEqual(0);
+            return output;
+        };
+        const ref = (name) => ({ type: "variable-reference", name });
+        const literal = (key, value) => ({ type: "literal-match", key, value });
+        const catchall = (key) => ({ type: "catchall-match", key });
+        const text = (value) => ({ type: "text", value });
+        const pound = (offset) => ({
+            type: "expression",
+            arg: ref("count"),
+            annotation: {
+                type: "function-reference",
+                name: "icu:pound",
+                options: offset === undefined
+                    ? []
+                    : [
+                        {
+                            name: "offset",
+                            value: { type: "literal", value: offset },
+                        },
+                    ],
+            },
+        });
+        // message text that contains "registry." must not import the registry
+        const textOnly = await compileChecked([
+            {
+                id: "registry_text",
+                declarations: [],
+                messages: [
+                    {
+                        locale: "en",
+                        selectors: [],
+                        variants: [
+                            { matches: [], pattern: [text("Open the registry. Now.")] },
+                        ],
+                    },
+                    {
+                        locale: "de",
+                        selectors: [],
+                        variants: [
+                            {
+                                matches: [],
+                                pattern: [text("Öffne die registry. Jetzt.")],
+                            },
+                        ],
+                    },
+                ],
+            },
+            // an unknown formatter on a local interpolates the raw value
+            {
+                id: "custom_local",
+                declarations: [
+                    { type: "input-variable", name: "amount" },
+                    {
+                        type: "local-variable",
+                        name: "formatted",
+                        value: {
+                            type: "expression",
+                            arg: ref("amount"),
+                            annotation: {
+                                type: "function-reference",
+                                name: "customLocalFormatter",
+                                options: [],
+                            },
+                        },
+                    },
+                ],
+                messages: [
+                    {
+                        locale: "en",
+                        selectors: [],
+                        variants: [
+                            {
+                                matches: [],
+                                pattern: [
+                                    text("Total: "),
+                                    { type: "expression", arg: ref("formatted") },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+        ]);
+        for (const [fileName, code] of Object.entries(textOnly)) {
+            if (fileName.startsWith("messages/")) {
+                expect(code).not.toContain("import * as registry");
+            }
+        }
+        const { m: textMessages } = await importCode(await bundleCode(textOnly, `export * as m from "./paraglide/messages.js"`));
+        expect(textMessages.registry_text({}, { locale: "en" })).toBe("Open the registry. Now.");
+        expect(textMessages.custom_local({ amount: 1234 }, { locale: "en" })).toBe("Total: 1234");
+        // {count, plural, offset:1 =0 {Nobody} =1 {You} one {You and # other} other {You and # others}}
+        // as the ICU1 plugin imports it, and `#` without an offset
+        const output = await compileChecked([
+            {
+                id: "guest_count",
+                declarations: [
+                    { type: "input-variable", name: "count" },
+                    {
+                        type: "local-variable",
+                        name: "countPluralOffset1",
+                        value: {
+                            type: "expression",
+                            arg: ref("count"),
+                            annotation: {
+                                type: "function-reference",
+                                name: "plural",
+                                options: [
+                                    { name: "offset", value: { type: "literal", value: "1" } },
+                                ],
+                            },
+                        },
+                    },
+                    {
+                        type: "local-variable",
+                        name: "countPluralOffset1Exact",
+                        value: { type: "expression", arg: ref("count") },
+                    },
+                ],
+                messages: [
+                    {
+                        locale: "en",
+                        selectors: [
+                            ref("countPluralOffset1Exact"),
+                            ref("countPluralOffset1"),
+                        ],
+                        variants: [
+                            {
+                                matches: [
+                                    literal("countPluralOffset1Exact", "0"),
+                                    catchall("countPluralOffset1"),
+                                ],
+                                pattern: [text("Nobody")],
+                            },
+                            {
+                                matches: [
+                                    literal("countPluralOffset1Exact", "1"),
+                                    catchall("countPluralOffset1"),
+                                ],
+                                pattern: [text("You")],
+                            },
+                            {
+                                matches: [
+                                    catchall("countPluralOffset1Exact"),
+                                    literal("countPluralOffset1", "one"),
+                                ],
+                                pattern: [text("You and "), pound("1"), text(" other")],
+                            },
+                            {
+                                matches: [
+                                    catchall("countPluralOffset1Exact"),
+                                    catchall("countPluralOffset1"),
+                                ],
+                                pattern: [text("You and "), pound("1"), text(" others")],
+                            },
+                        ],
+                    },
+                ],
+            },
+            {
+                id: "item_total",
+                declarations: [
+                    { type: "input-variable", name: "count" },
+                    {
+                        type: "local-variable",
+                        name: "countPlural",
+                        value: {
+                            type: "expression",
+                            arg: ref("count"),
+                            annotation: {
+                                type: "function-reference",
+                                name: "plural",
+                                options: [],
+                            },
+                        },
+                    },
+                ],
+                messages: [
+                    {
+                        locale: "en",
+                        selectors: [ref("countPlural")],
+                        variants: [
+                            {
+                                matches: [literal("countPlural", "one")],
+                                pattern: [pound(), text(" item")],
+                            },
+                            {
+                                matches: [catchall("countPlural")],
+                                pattern: [pound(), text(" items")],
+                            },
+                        ],
+                    },
+                    {
+                        locale: "de",
+                        selectors: [ref("countPlural")],
+                        variants: [
+                            {
+                                matches: [literal("countPlural", "one")],
+                                pattern: [pound(), text(" Artikel")],
+                            },
+                            {
+                                matches: [catchall("countPlural")],
+                                pattern: [pound(), text(" Artikel")],
+                            },
+                        ],
+                    },
+                ],
+            },
+            {
+                id: "variable_offset",
+                declarations: [
+                    { type: "input-variable", name: "count" },
+                    { type: "input-variable", name: "off" },
+                    {
+                        type: "local-variable",
+                        name: "countPlural",
+                        value: {
+                            type: "expression",
+                            arg: ref("count"),
+                            annotation: {
+                                type: "function-reference",
+                                name: "plural",
+                                options: [{ name: "offset", value: ref("off") }],
+                            },
+                        },
+                    },
+                ],
+                messages: [
+                    {
+                        locale: "en",
+                        selectors: [ref("countPlural")],
+                        variants: [
+                            {
+                                matches: [literal("countPlural", "one")],
+                                pattern: [
+                                    text("one: "),
+                                    {
+                                        type: "expression",
+                                        arg: ref("count"),
+                                        annotation: {
+                                            type: "function-reference",
+                                            name: "icu:pound",
+                                            options: [{ name: "offset", value: ref("off") }],
+                                        },
+                                    },
+                                ],
+                            },
+                            {
+                                matches: [catchall("countPlural")],
+                                pattern: [text("other")],
+                            },
+                        ],
+                    },
+                ],
+            },
+        ]);
+        const { m } = await importCode(await bundleCode(output, `export * as m from "./paraglide/messages.js"`));
+        // offsets from variables type-check and are converted with Number()
+        expect(m.variable_offset({ count: 3, off: 2 }, { locale: "en" })).toBe("one: 1");
+        expect(m.variable_offset({ count: 3, off: "2" }, { locale: "en" })).toBe("one: 1");
+        expect([0, 1, 2, 3, 1234].map((count) => m.guest_count({ count }, { locale: "en" }))).toEqual([
+            "Nobody",
+            "You",
+            "You and 1 other",
+            "You and 2 others",
+            "You and 1,233 others",
+        ]);
+        expect([1, 2, 1234].map((count) => m.item_total({ count }, { locale: "en" }))).toEqual(["1 item", "2 items", "1,234 items"]);
+        expect(m.item_total({ count: 1234 }, { locale: "de" })).toBe("1.234 Artikel");
+    });
+});
+describe.each([
+    { outputStructure: "locale-modules" },
+    { outputStructure: "message-modules" },
+])("markup messages with fallbacks ($outputStructure)", ({ outputStructure }) => {
+    test(".parts() type-checks under strict checkJs and renders", async () => {
+        const markupProject = await loadProjectInMemory({
+            blob: await newProject({
+                settings: { baseLocale: "en", locales: ["en", "de"] },
+            }),
+        });
+        const bold = (value) => [
+            { type: "markup-start", name: "b" },
+            { type: "text", value },
+            { type: "markup-end", name: "b" },
+        ];
+        const bundles = [
+            // de falls back to en
+            {
+                id: "markup_fallback",
+                messages: [{ locale: "en", variants: [{ pattern: bold("Hello") }] }],
+            },
+            // en has no markup, de has
+            {
+                id: "markup_mixed",
+                messages: [
+                    {
+                        locale: "en",
+                        variants: [{ pattern: [{ type: "text", value: "Hello" }] }],
+                    },
+                    { locale: "de", variants: [{ pattern: bold("Hallo") }] },
+                ],
+            },
+            // en (the base locale) has no message and no fallback
+            {
+                id: "markup_missing_base",
+                messages: [{ locale: "de", variants: [{ pattern: bold("Hallo") }] }],
+            },
+        ];
+        for (const bundle of bundles) {
+            await insertBundleNested(markupProject.db, createBundleNested(bundle));
+        }
+        const output = await compileProject({
+            project: markupProject,
+            compilerOptions: {
+                outputStructure,
+                strategy: ["globalVariable", "baseLocale"],
+            },
+        });
+        const tsProject = await typescriptProject({
+            useInMemoryFileSystem: true,
+            compilerOptions: {
+                outDir: "dist",
+                declaration: true,
+                allowJs: true,
+                checkJs: true,
+                noImplicitAny: true,
+                noUnusedLocals: true,
+                noUnusedParameters: true,
+                noImplicitReturns: true,
+                noImplicitThis: true,
+                noUncheckedIndexedAccess: true,
+                noPropertyAccessFromIndexSignature: true,
+                module: ts.ModuleKind.Node16,
+                strict: true,
+            },
+        });
+        for (const [fileName, code] of Object.entries(output)) {
+            if (fileName.endsWith(".js") || fileName.endsWith(".ts")) {
+                tsProject.createSourceFile(fileName, code);
+            }
+        }
+        const diagnostics = ts
+            .getPreEmitDiagnostics(tsProject.createProgram())
+            .filter((d) => !d.messageText
+            .toString()
+            .includes("Cannot find module 'async_hooks'"));
+        for (const diagnostic of diagnostics) {
+            console.error(diagnostic.messageText, diagnostic.file?.fileName);
+        }
+        expect(diagnostics.length).toEqual(0);
+        const { m } = await importCode(await bundleCode(output, `export * as m from "./paraglide/messages.js"`));
+        const boldParts = (value) => [
+            { type: "markup-start", name: "b", options: {}, attributes: {} },
+            { type: "text", value },
+            { type: "markup-end", name: "b", options: {}, attributes: {} },
+        ];
+        expect(m.markup_fallback.parts({}, { locale: "de" })).toEqual(boldParts("Hello"));
+        expect(m.markup_mixed.parts({}, { locale: "en" })).toEqual([
+            { type: "text", value: "Hello" },
+        ]);
+        expect(m.markup_mixed.parts({}, { locale: "de" })).toEqual(boldParts("Hallo"));
+        expect(m.markup_missing_base.parts({}, { locale: "en" })).toEqual([
+            { type: "text", value: "markup_missing_base" },
+        ]);
+    });
+});
+test("messages injected by the middleware in experimentalMiddlewareLocaleSplitting mode can call the registry", async () => {
+    const splitProject = await loadProjectInMemory({
+        blob: await newProject({
+            settings: { baseLocale: "en", locales: ["en", "de"] },
+        }),
+    });
+    const ref = (name) => ({ type: "variable-reference", name });
+    // {count, plural, =0 {No items} other {# items}} as the ICU1 plugin imports it
+    await insertBundleNested(splitProject.db, createBundleNested({
+        id: "item_count",
+        declarations: [
+            { type: "input-variable", name: "count" },
+            {
+                type: "local-variable",
+                name: "countPluralExact",
+                value: { type: "expression", arg: ref("count") },
+            },
+            {
+                type: "local-variable",
+                name: "countPlural",
+                value: {
+                    type: "expression",
+                    arg: ref("count"),
+                    annotation: {
+                        type: "function-reference",
+                        name: "plural",
+                        options: [],
+                    },
+                },
+            },
+        ],
+        messages: [
+            {
+                locale: "en",
+                selectors: [ref("countPluralExact"), ref("countPlural")],
+                variants: [
+                    {
+                        matches: [
+                            { type: "literal-match", key: "countPluralExact", value: "0" },
+                            { type: "catchall-match", key: "countPlural" },
+                        ],
+                        pattern: [{ type: "text", value: "No items" }],
+                    },
+                    {
+                        matches: [
+                            { type: "catchall-match", key: "countPluralExact" },
+                            { type: "catchall-match", key: "countPlural" },
+                        ],
+                        pattern: [
+                            {
+                                type: "expression",
+                                arg: ref("count"),
+                                annotation: {
+                                    type: "function-reference",
+                                    name: "icu:pound",
+                                    options: [],
+                                },
+                            },
+                            { type: "text", value: " items" },
+                        ],
+                    },
+                ],
+            },
+        ],
+    }));
+    await insertBundleNested(splitProject.db, createBundleNested({
+        id: "plain_text",
+        messages: [
+            {
+                locale: "en",
+                variants: [{ pattern: [{ type: "text", value: "Hello" }] }],
+            },
+        ],
+    }));
+    const output = await compileProject({
+        project: splitProject,
+        compilerOptions: {
+            strategy: ["baseLocale"],
+            experimentalMiddlewareLocaleSplitting: true,
+            disableAsyncLocalStorage: true,
+        },
+    });
+    const { m, paraglideMiddleware } = await importCode(await bundleCode(output, `export * as m from "./paraglide/messages.js"
+			export { paraglideMiddleware } from "./paraglide/server.js"`));
+    const render = async (messages) => {
+        const response = await paraglideMiddleware(new Request("https://example.com/", {
+            headers: { "Sec-Fetch-Dest": "document" },
+        }), () => new Response(`<html><head></head><body>${messages(m)}</body></html>`, {
+            headers: { "Content-Type": "text/html" },
+        }));
+        const html = await response.text();
+        const script = html.match(/<script[^>]*>([\s\S]*?)<\/script>/)?.[1];
+        expect(script).toBeDefined();
+        // the client evaluates the script without registry.js
+        const context = {};
+        vm.runInNewContext(script, context);
+        return { html, ssr: context.__paraglide.ssr };
+    };
+    const withRegistry = await render((m) => m.item_count({ count: 5 }));
+    expect(withRegistry.html).toContain("<body>5 items</body>");
+    expect(withRegistry.ssr.item_count({ count: 5 })).toBe("5 items");
+    expect(withRegistry.ssr.item_count({ count: 1234 })).toBe("1,234 items");
+    expect(withRegistry.ssr.item_count({ count: 0 })).toBe("No items");
+    // messages that don't call the registry get no registry code
+    const withoutRegistry = await render((m) => m.plain_text());
+    expect(withoutRegistry.ssr.plain_text()).toBe("Hello");
+    expect(withoutRegistry.html).not.toContain("const registry");
+});
+async function bundleCode(output, file) {
+    output["runtime.js"] = output["runtime.js"].replace('import "@inlang/paraglide-js/urlpattern-polyfill";', "/** @type {any} */const URLPattern = {};").replace('const { AsyncLocalStorage } = await import("async_hooks");', "const AsyncLocalStorage = class {};");
+    const bundle = await rolldown({
+        input: ["main.js"],
+        plugins: [
+            // @ts-expect-error - rollup types are not up to date
+            virtual({
+                ...Object.fromEntries(Object.entries(output).map(([fileName, code]) => [
+                    "paraglide/" + fileName,
+                    code,
+                ])),
+                "main.js": file,
+            }),
+        ],
+    });
+    const compiled = await bundle.generate({ format: "esm" });
+    const code = compiled.output[0].code;
+    return code;
+}
+async function importCode(code) {
+    // The random comment ensures that each code is a unique module
+    // and state is not shared between imports
+    const randomComment = `// ${Math.random()}`;
+    const codeWithComment = `${randomComment}\n${code}`;
+    return await import(`data:application/javascript;base64,${Buffer.from(codeWithComment, "utf8").toString("base64")}`);
+}
+const project = await loadProjectInMemory({
+    blob: await newProject({
+        settings: {
+            baseLocale: "en",
+            locales: ["en", "de", "en-US"],
+        },
+    }),
+});
+const mockBundles = [
+    createBundleNested({
+        id: "sad_penguin_bundle",
+        messages: [
+            {
+                locale: "en",
+                variants: [{ pattern: [{ type: "text", value: "A simple message." }] }],
+            },
+            {
+                locale: "de",
+                variants: [
+                    { pattern: [{ type: "text", value: "Eine einfache Nachricht." }] },
+                ],
+            },
+        ],
+    }),
+    createBundleNested({
+        id: "Sad_penguin_bundle",
+        messages: [
+            {
+                locale: "en",
+                variants: [
+                    { pattern: [{ type: "text", value: "Capital Sad penguin" }] },
+                ],
+            },
+            {
+                locale: "de",
+                variants: [
+                    {
+                        pattern: [
+                            { type: "text", value: "Grossgeschriebenes Sad penguin" },
+                        ],
+                    },
+                ],
+            },
+        ],
+    }),
+    {
+        id: "depressed_dog",
+        declarations: [
+            {
+                type: "input-variable",
+                name: "name",
+            },
+        ],
+        messages: [
+            {
+                id: "depressed_dog_en",
+                bundle_id: "depressed_dog",
+                locale: "en",
+                selectors: [],
+                variants: [
+                    {
+                        id: "depressed_dog_en_variant_one",
+                        message_id: "depressed_dog_en",
+                        matches: [],
+                        pattern: [
+                            { type: "text", value: "Good morning " },
+                            {
+                                type: "expression",
+                                arg: { type: "variable-reference", name: "name" },
+                            },
+                            { type: "text", value: "!" },
+                        ],
+                    },
+                ],
+            },
+            {
+                id: "depressed_dog_de",
+                bundle_id: "depressed_dog",
+                locale: "de",
+                selectors: [],
+                variants: [
+                    {
+                        id: "depressed_dog_de_variant_one",
+                        message_id: "depressed_dog_de",
+                        matches: [],
+                        pattern: [
+                            { type: "text", value: "Guten Morgen " },
+                            {
+                                type: "expression",
+                                arg: { type: "variable-reference", name: "name" },
+                            },
+                            { type: "text", value: "!" },
+                        ],
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        id: "insane_cats",
+        declarations: [
+            {
+                type: "input-variable",
+                name: "name",
+            },
+            {
+                type: "input-variable",
+                name: "count",
+            },
+        ],
+        messages: [
+            {
+                id: "insane_cats_en",
+                bundle_id: "insane_cats",
+                locale: "en",
+                selectors: [],
+                variants: [
+                    {
+                        id: "insane_cats_en_variant_one",
+                        message_id: "insane_cats_en",
+                        matches: [],
+                        pattern: [
+                            { type: "text", value: "Hello " },
+                            {
+                                type: "expression",
+                                arg: { type: "variable-reference", name: "name" },
+                            },
+                            { type: "text", value: "! You have " },
+                            {
+                                type: "expression",
+                                arg: { type: "variable-reference", name: "count" },
+                            },
+                            { type: "text", value: " messages." },
+                        ],
+                    },
+                ],
+            },
+            {
                 id: "insane_cats_de",
-                bundleId: "insane_cats",
+                bundle_id: "insane_cats",
                 locale: "de",
                 selectors: [],
                 variants: [
                     {
                         id: "insane_cats_de_variant_one",
-                        messageId: "insane_cats_de",
+                        message_id: "insane_cats_de",
                         matches: [],
                         pattern: [
                             { type: "text", value: "Hallo " },
@@ -1586,13 +2646,13 @@ const mockBundles = [
         messages: [
             {
                 id: "auth_password_error_en",
-                bundleId: "auth_password_error",
+                bundle_id: "auth_password_error",
                 locale: "en",
                 selectors: [],
                 variants: [
                     {
                         id: "auth_password_error_en_variant_invalid",
-                        messageId: "auth_password_error_en",
+                        message_id: "auth_password_error_en",
                         matches: [{ type: "literal-match", key: "type", value: "invalid" }],
                         pattern: [
                             {
@@ -1603,7 +2663,7 @@ const mockBundles = [
                     },
                     {
                         id: "auth_password_error_en_variant_empty",
-                        messageId: "auth_password_error_en",
+                        message_id: "auth_password_error_en",
                         matches: [{ type: "literal-match", key: "type", value: "empty" }],
                         pattern: [
                             {
@@ -1614,7 +2674,7 @@ const mockBundles = [
                     },
                     {
                         id: "auth_password_error_en_variant_min",
-                        messageId: "auth_password_error_en",
+                        message_id: "auth_password_error_en",
                         matches: [
                             {
                                 type: "literal-match",
@@ -1631,7 +2691,7 @@ const mockBundles = [
                     },
                     {
                         id: "auth_password_error_en_variant_secure",
-                        messageId: "auth_password_error_en",
+                        message_id: "auth_password_error_en",
                         matches: [{ type: "literal-match", key: "type", value: "secure" }],
                         pattern: [
                             {
@@ -1655,13 +2715,13 @@ const mockBundles = [
         messages: [
             {
                 id: "error_with_dash_en",
-                bundleId: "error_with_dash",
+                bundle_id: "error_with_dash",
                 locale: "en",
                 selectors: [],
                 variants: [
                     {
                         id: "error_with_dash_en_variant_network",
-                        messageId: "error_with_dash_en",
+                        message_id: "error_with_dash_en",
                         matches: [
                             { type: "literal-match", key: "error-type", value: "network" },
                         ],
@@ -1669,7 +2729,7 @@ const mockBundles = [
                     },
                     {
                         id: "error_with_dash_en_variant_timeout",
-                        messageId: "error_with_dash_en",
+                        message_id: "error_with_dash_en",
                         matches: [
                             {
                                 type: "literal-match",
@@ -1694,13 +2754,13 @@ const mockBundles = [
         messages: [
             {
                 id: "auth_password_error_catchall_en",
-                bundleId: "auth_password_error_catchall",
+                bundle_id: "auth_password_error_catchall",
                 locale: "en",
                 selectors: [],
                 variants: [
                     {
                         id: "auth_password_error_catchall_en_variant_invalid",
-                        messageId: "auth_password_error_catchall_en",
+                        message_id: "auth_password_error_catchall_en",
                         matches: [{ type: "literal-match", key: "type", value: "invalid" }],
                         pattern: [
                             {
@@ -1711,7 +2771,7 @@ const mockBundles = [
                     },
                     {
                         id: "auth_password_error_catchall_en_variant_catchall",
-                        messageId: "auth_password_error_catchall_en",
+                        message_id: "auth_password_error_catchall_en",
                         matches: [{ type: "catchall-match", key: "type" }],
                         pattern: [
                             {
@@ -1739,13 +2799,13 @@ const mockBundles = [
         messages: [
             {
                 id: "multi_key_status_type_en",
-                bundleId: "multi_key_status_type",
+                bundle_id: "multi_key_status_type",
                 locale: "en",
                 selectors: [],
                 variants: [
                     {
                         id: "multi_key_status_type_en_variant_ready_invalid",
-                        messageId: "multi_key_status_type_en",
+                        message_id: "multi_key_status_type_en",
                         matches: [
                             { type: "literal-match", key: "type", value: "invalid" },
                             { type: "literal-match", key: "status", value: "ready" },
@@ -1754,7 +2814,7 @@ const mockBundles = [
                     },
                     {
                         id: "multi_key_status_type_en_variant_done_empty",
-                        messageId: "multi_key_status_type_en",
+                        message_id: "multi_key_status_type_en",
                         matches: [
                             { type: "literal-match", key: "type", value: "empty" },
                             { type: "literal-match", key: "status", value: "done" },
@@ -1763,7 +2823,7 @@ const mockBundles = [
                     },
                     {
                         id: "multi_key_status_type_en_variant_failed_secure",
-                        messageId: "multi_key_status_type_en",
+                        message_id: "multi_key_status_type_en",
                         matches: [
                             { type: "literal-match", key: "type", value: "secure" },
                             { type: "literal-match", key: "status", value: "failed" },
@@ -1785,19 +2845,19 @@ const mockBundles = [
         messages: [
             {
                 id: "empty_matches_catchall_en",
-                bundleId: "empty_matches_catchall",
+                bundle_id: "empty_matches_catchall",
                 locale: "en",
                 selectors: [],
                 variants: [
                     {
                         id: "empty_matches_catchall_en_variant_invalid",
-                        messageId: "empty_matches_catchall_en",
+                        message_id: "empty_matches_catchall_en",
                         matches: [{ type: "literal-match", key: "type", value: "invalid" }],
                         pattern: [{ type: "text", value: "Invalid" }],
                     },
                     {
                         id: "empty_matches_catchall_en_variant_any",
-                        messageId: "empty_matches_catchall_en",
+                        message_id: "empty_matches_catchall_en",
                         matches: [],
                         pattern: [{ type: "text", value: "Any" }],
                     },
@@ -1816,19 +2876,19 @@ const mockBundles = [
         messages: [
             {
                 id: "numeric_input_match_en",
-                bundleId: "numeric_input_match",
+                bundle_id: "numeric_input_match",
                 locale: "en",
                 selectors: [],
                 variants: [
                     {
                         id: "numeric_input_match_en_variant_1",
-                        messageId: "numeric_input_match_en",
+                        message_id: "numeric_input_match_en",
                         matches: [{ type: "literal-match", key: "input", value: "1" }],
                         pattern: [{ type: "text", value: "Thing 1" }],
                     },
                     {
                         id: "numeric_input_match_en_variant_2",
-                        messageId: "numeric_input_match_en",
+                        message_id: "numeric_input_match_en",
                         matches: [{ type: "literal-match", key: "input", value: "2" }],
                         pattern: [{ type: "text", value: "Thing 2" }],
                     },
@@ -1846,7 +2906,7 @@ function createBundleNested(args) {
         declarations: args.declarations ?? [],
         messages: args.messages.map((message) => ({
             id: args.id + "_" + message.locale,
-            bundleId: args.id,
+            bundle_id: args.id,
             locale: message.locale,
             selectors: message.selectors ?? [],
             variants: message.variants.map((variant) => ({
@@ -1855,11 +2915,26 @@ function createBundleNested(args) {
                     message.locale +
                     "_" +
                     Math.random().toString(36).slice(2),
-                messageId: args.id,
+                message_id: args.id,
                 matches: variant.matches ?? [],
                 pattern: variant.pattern,
             })),
         })),
     };
 }
+test("emitReadme only claims the output is git-ignored when a .gitignore is emitted", async () => {
+    const project = await loadProjectInMemory({
+        blob: await newProject({
+            settings: { locales: ["en"], baseLocale: "en" },
+        }),
+    });
+    const withGitignore = await compileProject({ project });
+    const withoutGitignore = await compileProject({
+        project,
+        compilerOptions: { emitGitIgnore: false },
+    });
+    expect(withGitignore["README.md"]).toContain("git-ignored");
+    expect(withoutGitignore).not.toHaveProperty(".gitignore");
+    expect(withoutGitignore["README.md"]).not.toContain("git-ignored");
+});
 //# sourceMappingURL=compile-project.test.js.map