fimo 0.7.0-experimental.2 → 0.7.0-experimental.4

package/dist/build/vite/plugins/content-sync.test.js

@@ -0,0 +1,64 @@
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import contentSyncPlugin from './content-sync';
+let scratch = null;
+const pluginContext = {
+    addWatchFile: vi.fn(),
+    meta: {},
+    error: (error) => {
+        throw error;
+    },
+    info: () => undefined,
+    warn: () => undefined,
+    debug: () => undefined,
+};
+afterEach(() => {
+    if (scratch) {
+        rmSync(scratch, { recursive: true, force: true });
+        scratch = null;
+    }
+    vi.clearAllMocks();
+});
+function createProjectRoot() {
+    scratch = mkdtempSync(join(tmpdir(), 'fimo-content-sync-plugin-'));
+    mkdirSync(join(scratch, 'src/schemas'), { recursive: true });
+    return scratch;
+}
+function configurePlugin(plugin, root) {
+    if (typeof plugin.configResolved === 'function') {
+        plugin.configResolved.call(pluginContext, { root });
+    }
+}
+describe('contentSyncPlugin', () => {
+    it('does not mutate generated files during a production build', () => {
+        const plugin = contentSyncPlugin();
+        expect(plugin.buildStart).toBeUndefined();
+        expect(plugin.generateBundle).toBeUndefined();
+        expect(plugin.writeBundle).toBeUndefined();
+    });
+    it('regenerates schema clients after a schema changes in dev', () => {
+        const root = createProjectRoot();
+        const schemaPath = join(root, 'src/schemas/Post.json');
+        writeFileSync(schemaPath, JSON.stringify({ uid: 'Post', name: 'Posts', fields: { title: { type: 'string' } } }, null, 2));
+        const listeners = new Map();
+        const server = {
+            watcher: {
+                add: vi.fn(),
+                on: vi.fn((event, listener) => {
+                    listeners.set(event, listener);
+                }),
+            },
+        };
+        const plugin = contentSyncPlugin();
+        configurePlugin(plugin, root);
+        if (typeof plugin.configureServer !== 'function') {
+            throw new Error('Expected configureServer hook');
+        }
+        plugin.configureServer.call(pluginContext, server);
+        listeners.get('change')?.(schemaPath);
+        expect(readFileSync(join(root, 'src/schemas/Post.ts'), 'utf8')).toContain('from "./Post.types";');
+        expect(readFileSync(join(root, 'src/schemas/Post.types.ts'), 'utf8')).toContain('export interface Post');
+    });
+});

package/dist/build/vite/plugins/data-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-id.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/data-id.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAOnC,MAAM,CAAC,OAAO,UAAU,YAAY,IAAI,MAAM,CA2F7C"}

package/dist/build/vite/plugins/fimo-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fimo-config.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/fimo-config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAKnC;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,UAAU,gBAAgB,IAAI,MAAM,CA6CjD"}

package/dist/build/vite/plugins/fimo-config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fimo-config.test.d.ts.map

package/dist/build/vite/plugins/fimo-config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fimo-config.test.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/fimo-config.test.ts"],"names":[],"mappings":""}

package/dist/build/vite/plugins/fimo-config.test.js

@@ -0,0 +1,46 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import fimoConfigPlugin from './fimo-config';
+let scratch = null;
+const pluginContext = {
+    meta: {},
+    error: (error) => {
+        throw error;
+    },
+    info: () => undefined,
+    warn: () => undefined,
+    debug: () => undefined,
+};
+afterEach(() => {
+    if (scratch) {
+        rmSync(scratch, { recursive: true, force: true });
+        scratch = null;
+    }
+});
+function createPluginWithConfig(config) {
+    scratch = mkdtempSync(join(tmpdir(), 'fimo-config-plugin-'));
+    writeFileSync(join(scratch, 'fimo-config.json'), JSON.stringify(config, null, 2));
+    const plugin = fimoConfigPlugin();
+    if (typeof plugin.config === 'function') {
+        plugin.config.call(pluginContext, { root: scratch }, { command: 'build', mode: 'production' });
+    }
+    return plugin;
+}
+function transformHtml(plugin, html) {
+    if (typeof plugin.transformIndexHtml !== 'function') {
+        throw new Error('Expected transformIndexHtml function');
+    }
+    return plugin.transformIndexHtml.call(pluginContext, html, {});
+}
+describe('fimoConfigPlugin', () => {
+    it('sets html lang from i18n.defaultLocale', () => {
+        const plugin = createPluginWithConfig({ seo: { locale: 'es_ES' }, i18n: { defaultLocale: 'fr' } });
+        expect(transformHtml(plugin, '<html><head></head><body></body></html>')).toContain('<html lang="fr">');
+    });
+    it('falls back to en when i18n.defaultLocale is absent', () => {
+        const plugin = createPluginWithConfig({ seo: { locale: 'es_ES' } });
+        expect(transformHtml(plugin, '<html lang="fr"><head></head><body></body></html>')).toContain('<html lang="en">');
+    });
+});

package/dist/build/vite/plugins/overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/overlay.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAoEnC,MAAM,CAAC,OAAO,UAAU,aAAa,IAAI,MAAM,CA+E9C"}

package/dist/build/vite/plugins/robots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"robots.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/robots.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AA6BnC;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,IAAI,MAAM,CAuB7C"}

package/dist/build/vite/plugins/seo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seo.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/seo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AA2BnC,MAAM,CAAC,OAAO,UAAU,SAAS,IAAI,MAAM,CA2G1C"}

package/dist/build/vite/plugins/server-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-config.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/server-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAEnC,MAAM,CAAC,OAAO,UAAU,kBAAkB,IAAI,MAAM,CAsBnD"}

package/dist/build/vite/plugins/sitemap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sitemap.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/sitemap.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAkDnC,MAAM,CAAC,OAAO,UAAU,aAAa,IAAI,MAAM,CA8B9C"}

package/dist/build/vite/plugins/translations.d.ts

@@ -1,11 +1,5 @@
 import type { Plugin } from 'vite';
-interface LabelBundle {
-    dictionaries: Record<string, Record<string, string>>;
-    defaultLocale: string;
-    locales: string[];
-    updatedAt: string | null;
-}
+import { loadLabelBundle } from '../../../runtime/shared/labels-fetch.server.js';
 export default function translationsPlugin(): Plugin;
-export declare function loadLabelBundle(rootDir: string): Promise<LabelBundle>;
-export {};
+export { loadLabelBundle };
 //# sourceMappingURL=translations.d.ts.map

package/dist/build/vite/plugins/translations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translations.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/translations.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAiB,MAAM,MAAM,CAAC;AAElD,OAAO,EAIL,eAAe,EAIhB,MAAM,gDAAgD,CAAC;AA2CxD,MAAM,CAAC,OAAO,UAAU,kBAAkB,IAAI,MAAM,CAmOnD;AA4CD,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/build/vite/plugins/translations.js

@@ -1,10 +1,8 @@
 import { createHash } from 'node:crypto';
-import { Buffer } from 'node:buffer';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { getFimoDefaultLocale, getFimoLocales } from '../../../runtime/i18n/locale.js';
-import { getConfigServer } from '../../../runtime/shared/fimo-config.server.js';
+import { emptyLabelBundle, labelSignature, loadLabelBundle, readProjectEnv, resolveTenantApiUrl, serializeBundle, } from '../../../runtime/shared/labels-fetch.server.js';
 const VIRTUAL_ID = 'virtual:translations';
 const RESOLVED_ID = '\0' + VIRTUAL_ID;
 export default function translationsPlugin() {
@@ -145,7 +143,7 @@ export default function translationsPlugin() {
     };
     async function connectLabelEvents(root, onLabelsChanged) {
         const env = await readProjectEnv(root);
-        const apiUrl = env.VITE_API_URL;
+        const apiUrl = resolveTenantApiUrl(env);
         if (!apiUrl) {
             return [];
         }
@@ -229,24 +227,6 @@ function parseContentChangePayload(payload) {
         updatedAt: typeof source.updatedAt === 'string' ? source.updatedAt : undefined,
     };
 }
-function serializeBundle(bundle) {
-    return JSON.stringify({
-        dictionaries: bundle.dictionaries,
-        defaultLocale: bundle.defaultLocale,
-        locales: bundle.locales,
-    });
-}
-function emptyLabelBundle(rootDir) {
-    const config = getConfigServer(rootDir);
-    const defaultLocale = getFimoDefaultLocale(config);
-    const locales = getFimoLocales(config);
-    return {
-        dictionaries: Object.fromEntries(locales.map((locale) => [locale, {}])),
-        defaultLocale,
-        locales,
-        updatedAt: null,
-    };
-}
 function findVirtualTranslationModules(server) {
     const direct = server.moduleGraph.getModuleById(RESOLVED_ID);
     const matches = new Set(direct ? [direct] : []);
@@ -257,73 +237,13 @@ function findVirtualTranslationModules(server) {
     }
     return [...matches];
 }
-function labelSignature(bundle) {
-    return Buffer.from(serializeBundle(bundle)).toString('base64');
-}
 function labelUpdatePayload(bundle) {
     return {
         ...bundle,
         signature: labelSignature(bundle),
     };
 }
-export async function loadLabelBundle(rootDir) {
-    const config = getConfigServer(rootDir);
-    const defaultLocale = getFimoDefaultLocale(config);
-    const locales = getFimoLocales(config);
-    const env = await readProjectEnv(rootDir);
-    const apiUrl = env.VITE_API_URL;
-    if (!apiUrl) {
-        return {
-            dictionaries: Object.fromEntries(locales.map((locale) => [locale, {}])),
-            defaultLocale,
-            locales,
-            updatedAt: null,
-        };
-    }
-    try {
-        const loaded = await Promise.all(locales.map((locale) => fetchLabelDictionary(apiUrl, locale).catch(() => ({ locale, labels: {}, updatedAt: null }))));
-        const updatedAt = loaded
-            .map((entry) => entry.updatedAt)
-            .filter((value) => typeof value === 'string')
-            .sort()
-            .at(-1);
-        return {
-            dictionaries: Object.fromEntries(loaded.map((entry) => [entry.locale, entry.labels])),
-            defaultLocale,
-            locales,
-            updatedAt: updatedAt ?? null,
-        };
-    }
-    catch {
-        return {
-            dictionaries: Object.fromEntries(locales.map((locale) => [locale, {}])),
-            defaultLocale,
-            locales,
-            updatedAt: null,
-        };
-    }
-}
-async function fetchLabelDictionary(apiUrl, locale) {
-    const url = new URL('/labels', apiUrl);
-    url.searchParams.set('locale', locale);
-    const response = await fetchWithTimeout(url, 4000);
-    if (!response.ok) {
-        return { locale, labels: {}, updatedAt: null };
-    }
-    const body = (await response.json());
-    if (Array.isArray(body.data)) {
-        return {
-            locale,
-            labels: Object.fromEntries(body.data.map((row) => [row.key, row.value ?? row.defaultValue ?? ''])),
-            updatedAt: null,
-        };
-    }
-    return {
-        locale,
-        labels: body.data?.labels ?? {},
-        updatedAt: body.data?.updatedAt ?? null,
-    };
-}
+export { loadLabelBundle };
 async function loadRuntimeConfig(apiUrl) {
     try {
         const response = await fetchWithTimeout(new URL('/runtime-config', apiUrl), 2000);
@@ -358,44 +278,6 @@ async function fetchWithTimeout(url, timeoutMs) {
         clearTimeout(timeout);
     }
 }
-async function readProjectEnv(rootDir) {
-    const values = {
-        ...(await readEnvFile(join(rootDir, '.env'))),
-        ...(await readEnvFile(join(rootDir, '.env.local'))),
-    };
-    for (const key of ['VITE_API_URL']) {
-        if (process.env[key]) {
-            values[key] = process.env[key];
-        }
-    }
-    return values;
-}
-async function readEnvFile(filePath) {
-    try {
-        const content = await readFile(filePath, 'utf8');
-        const values = {};
-        for (const line of content.split(/\r?\n/)) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith('#')) {
-                continue;
-            }
-            const index = trimmed.indexOf('=');
-            if (index === -1) {
-                continue;
-            }
-            const key = trimmed.slice(0, index).trim();
-            const value = trimmed
-                .slice(index + 1)
-                .trim()
-                .replace(/^['"]|['"]$/g, '');
-            values[key] = value;
-        }
-        return values;
-    }
-    catch {
-        return {};
-    }
-}
 async function readProjectSettings(rootDir) {
     try {
         const raw = await readFile(join(rootDir, '.fimo.settings.json'), 'utf8');

package/dist/build/vite/plugins/translations.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=translations.test.d.ts.map

package/dist/build/vite/plugins/translations.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translations.test.d.ts","sourceRoot":"","sources":["../../../../src/build/vite/plugins/translations.test.ts"],"names":[],"mappings":""}

package/dist/build/vite/plugins/translations.test.js

@@ -0,0 +1,266 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import translationsPlugin from './translations';
+let scratch = null;
+let activePlugin = null;
+const originalFimoApiToken = process.env.FIMO_API_TOKEN;
+const pluginContext = {
+    addWatchFile: vi.fn(),
+    meta: {},
+    error: (error) => {
+        throw error;
+    },
+    info: () => undefined,
+    warn: () => undefined,
+    debug: () => undefined,
+};
+afterEach(() => {
+    if (activePlugin && typeof activePlugin.closeBundle === 'function') {
+        activePlugin.closeBundle.call(pluginContext);
+        activePlugin = null;
+    }
+    if (scratch) {
+        rmSync(scratch, { recursive: true, force: true });
+        scratch = null;
+    }
+    if (originalFimoApiToken === undefined) {
+        delete process.env.FIMO_API_TOKEN;
+    }
+    else {
+        process.env.FIMO_API_TOKEN = originalFimoApiToken;
+    }
+    vi.unstubAllGlobals();
+    vi.clearAllMocks();
+});
+function createProjectRoot() {
+    scratch = mkdtempSync(join(tmpdir(), 'fimo-translations-plugin-'));
+    writeFileSync(join(scratch, 'fimo-config.json'), JSON.stringify({ i18n: { defaultLocale: 'es', locales: ['es'] } }, null, 2));
+    writeFileSync(join(scratch, '.env'), 'VITE_API_URL=https://tenant.example.test\n');
+    return scratch;
+}
+function createPlugin(root, command) {
+    const plugin = translationsPlugin();
+    activePlugin = plugin;
+    if (typeof plugin.configResolved === 'function') {
+        plugin.configResolved.call(pluginContext, { root, command });
+    }
+    return plugin;
+}
+async function buildStart(plugin) {
+    if (typeof plugin.buildStart !== 'function') {
+        throw new Error('Expected buildStart hook');
+    }
+    await plugin.buildStart.call(pluginContext, {});
+}
+async function loadTranslations(plugin) {
+    if (typeof plugin.resolveId !== 'function' || typeof plugin.load !== 'function') {
+        throw new Error('Expected resolveId/load hooks');
+    }
+    const id = await plugin.resolveId.call(pluginContext, 'virtual:translations', undefined, {});
+    if (typeof id !== 'string') {
+        throw new Error('Expected virtual translations module id');
+    }
+    const result = await plugin.load.call(pluginContext, id, {});
+    if (typeof result !== 'string') {
+        throw new Error('Expected virtual translations source');
+    }
+    return result;
+}
+function createDevServer() {
+    return {
+        watcher: { add: vi.fn() },
+        moduleGraph: {
+            getModuleById: vi.fn(() => null),
+            idToModuleMap: new Map(),
+        },
+        ws: { send: vi.fn() },
+    };
+}
+function mockLabels(labels) {
+    const fetchMock = vi.fn(async () => jsonResponse({ data: { labels, updatedAt: '2026-06-24T00:00:00.000Z' } }));
+    vi.stubGlobal('fetch', fetchMock);
+    return fetchMock;
+}
+function jsonResponse(body) {
+    return {
+        ok: true,
+        json: async () => body,
+    };
+}
+async function waitFor(condition) {
+    const deadline = Date.now() + 1000;
+    while (Date.now() < deadline) {
+        if (condition()) {
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    throw new Error('Timed out waiting for condition');
+}
+describe('translationsPlugin', () => {
+    it('does not block dev startup on the initial label fetch', async () => {
+        const root = createProjectRoot();
+        const fetchMock = mockLabels({ headline: 'Hola' });
+        const plugin = createPlugin(root, 'serve');
+        await buildStart(plugin);
+        expect(fetchMock).not.toHaveBeenCalled();
+        const source = await loadTranslations(plugin);
+        expect(source).toContain('export const translations = {};');
+        expect(source).toContain('export const defaultLocale = "es";');
+    });
+    it('pushes updated labels over custom HMR without a full page reload', async () => {
+        const root = createProjectRoot();
+        mockLabels({ headline: 'Hola' });
+        const plugin = createPlugin(root, 'serve');
+        await buildStart(plugin);
+        const server = createDevServer();
+        if (typeof plugin.configureServer !== 'function') {
+            throw new Error('Expected configureServer hook');
+        }
+        plugin.configureServer.call(pluginContext, server);
+        await waitFor(() => server.ws.send.mock.calls.length > 0);
+        expect(server.ws.send).toHaveBeenCalledWith({
+            type: 'custom',
+            event: 'fimo:labels-updated',
+            data: expect.objectContaining({
+                defaultLocale: 'es',
+                dictionaries: { es: { headline: 'Hola' } },
+                locales: ['es'],
+                signature: expect.any(String),
+                updatedAt: '2026-06-24T00:00:00.000Z',
+            }),
+        });
+        expect(server.ws.send).not.toHaveBeenCalledWith({ type: 'full-reload', path: '*' });
+        const source = await loadTranslations(plugin);
+        expect(source).toContain('"headline":"Hola"');
+    });
+    it('discovers the events URL from tenant runtime config when env is absent', async () => {
+        const root = createProjectRoot();
+        const projectId = '11111111-1111-4111-8111-111111111111';
+        writeFileSync(join(root, '.fimo.settings.json'), JSON.stringify({ projectId, apiUrl: 'https://api.example.test' }));
+        process.env.FIMO_API_TOKEN = 'test-api-token';
+        const socketUrls = [];
+        vi.stubGlobal('WebSocket', class {
+            onopen = null;
+            onmessage = null;
+            onclose = null;
+            onerror = null;
+            constructor(url) {
+                socketUrls.push(url);
+            }
+            close() { }
+        });
+        const fetchMock = vi.fn(async (input, init) => {
+            const url = new URL(input.toString());
+            if (url.pathname === '/labels') {
+                return jsonResponse({ data: { labels: {}, updatedAt: null } });
+            }
+            if (url.pathname === '/runtime-config') {
+                return jsonResponse({ data: { eventsServerUrl: 'https://events.example.test' } });
+            }
+            if (url.pathname === '/api/auth/one-time-token/generate') {
+                expect(init?.method).toBe('GET');
+                return jsonResponse({ token: 'event-token' });
+            }
+            return { ok: false, json: async () => ({}) };
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const plugin = createPlugin(root, 'serve');
+        await buildStart(plugin);
+        const server = createDevServer();
+        if (typeof plugin.configureServer !== 'function') {
+            throw new Error('Expected configureServer hook');
+        }
+        plugin.configureServer.call(pluginContext, server);
+        await waitFor(() => socketUrls.length > 0);
+        expect(socketUrls[0]).toContain(`wss://events.example.test/parties/events/${projectId}`);
+        expect(socketUrls[0]).toContain('authToken=event-token');
+    });
+    it('forwards content changes over custom HMR without a full page reload', async () => {
+        const root = createProjectRoot();
+        const projectId = '11111111-1111-4111-8111-111111111111';
+        writeFileSync(join(root, '.fimo.settings.json'), JSON.stringify({ projectId, apiUrl: 'https://api.example.test' }));
+        process.env.FIMO_API_TOKEN = 'test-api-token';
+        const sockets = [];
+        vi.stubGlobal('WebSocket', class {
+            onopen = null;
+            onmessage = null;
+            onclose = null;
+            onerror = null;
+            constructor(_url) {
+                sockets.push(this);
+            }
+            close() { }
+        });
+        vi.stubGlobal('fetch', vi.fn(async (input) => {
+            const url = new URL(input.toString());
+            if (url.pathname === '/labels') {
+                return jsonResponse({ data: { labels: {}, updatedAt: null } });
+            }
+            if (url.pathname === '/runtime-config') {
+                return jsonResponse({ data: { eventsServerUrl: 'https://events.example.test' } });
+            }
+            if (url.pathname === '/api/auth/one-time-token/generate') {
+                return jsonResponse({ data: { token: 'event-token' } });
+            }
+            return { ok: false, json: async () => ({}) };
+        }));
+        const plugin = createPlugin(root, 'serve');
+        await buildStart(plugin);
+        const server = createDevServer();
+        if (typeof plugin.configureServer !== 'function') {
+            throw new Error('Expected configureServer hook');
+        }
+        plugin.configureServer.call(pluginContext, server);
+        await waitFor(() => sockets.length > 0);
+        sockets[0].onmessage?.({
+            data: JSON.stringify({
+                type: 'content:changed',
+                payload: {
+                    changes: [{ action: 'update', contentType: 'LiveNote', id: 'entry-1', locale: 'en' }],
+                    updatedAt: '2026-06-24T00:00:00.000Z',
+                },
+            }),
+        });
+        expect(server.ws.send).toHaveBeenCalledWith({
+            type: 'custom',
+            event: 'fimo:content-updated',
+            data: {
+                changes: [{ action: 'update', contentType: 'LiveNote', id: 'entry-1', locale: 'en' }],
+                updatedAt: '2026-06-24T00:00:00.000Z',
+            },
+        });
+        expect(server.ws.send).not.toHaveBeenCalledWith({ type: 'full-reload', path: '*' });
+    });
+    it('still waits for labels during production builds', async () => {
+        const root = createProjectRoot();
+        const fetchMock = mockLabels({ headline: 'Hola' });
+        const plugin = createPlugin(root, 'build');
+        await buildStart(plugin);
+        expect(fetchMock).toHaveBeenCalled();
+        const source = await loadTranslations(plugin);
+        expect(source).toContain('"headline":"Hola"');
+    });
+    it('loads one dictionary per configured locale', async () => {
+        const root = createProjectRoot();
+        writeFileSync(join(root, 'fimo-config.json'), JSON.stringify({ i18n: { defaultLocale: 'en', locales: ['en', 'es'] } }, null, 2));
+        vi.stubGlobal('fetch', vi.fn(async (input) => {
+            const url = new URL(input.toString());
+            const locale = url.searchParams.get('locale');
+            return jsonResponse({
+                data: {
+                    labels: locale === 'es' ? { headline: 'Hola' } : { headline: 'Hello' },
+                    updatedAt: `2026-06-24T00:00:0${locale === 'es' ? '2' : '1'}.000Z`,
+                },
+            });
+        }));
+        const plugin = createPlugin(root, 'build');
+        await buildStart(plugin);
+        const source = await loadTranslations(plugin);
+        expect(source).toContain('export const dictionaries = {"en":{"headline":"Hello"},"es":{"headline":"Hola"}};');
+        expect(source).toContain('export const translations = {"headline":"Hello"};');
+        expect(source).toContain('export const updatedAt = "2026-06-24T00:00:02.000Z";');
+    });
+});

package/dist/cli/bundle.json

@@ -1,11 +1,10 @@
 {
   "bundled": true,
   "bundler": "esbuild",
-  "bundledAt": "2026-07-16T16:23:22.068Z",
+  "bundledAt": "2026-07-21T08:12:39.698Z",
   "cliVersion": "0.6.0",
   "external": [
     "oxc-parser",
-    "fsevents",
-    "zod"
+    "fsevents"
   ]
 }