@gtkx/cli 1.4.0 → 1.5.0

package/src/i18n/types.ts

@@ -0,0 +1,154 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { SourceMessage } from "./source-messages.js";
+
+type I18nTypesResult = {
+    isWritten: boolean;
+    path: string;
+};
+
+const I18N_TYPES_FILENAME = "i18n.d.ts";
+const INTERPOLATION_PATTERN = /\{\{[^{}]+\}\}/u;
+
+const stringType = (values: string[]): string =>
+    [...new Set(values)].map((value) => JSON.stringify(value)).join(" | ");
+
+const contextField = (context: string | null): string =>
+    context === null ? "" : ` context: ${JSON.stringify(context)};`;
+
+const hasInterpolation = (values: string[]): boolean => values.some((value) => INTERPOLATION_PATTERN.test(value));
+
+const pointVariant = (message: SourceMessage): string => {
+    const isRequired = message.context !== null || hasInterpolation([message.msgid]);
+    const isInterpolated = hasInterpolation([message.msgid]);
+
+    return (
+        `{${contextField(message.context)} interpolated: ${String(isInterpolated)}; kind: "point"; ` +
+        `required: ${String(isRequired)}; value: ${JSON.stringify(message.msgid)} }`
+    );
+};
+
+const defaultVariant = (message: SourceMessage): string => {
+    const values = [message.singular];
+    const isInterpolated = hasInterpolation(values);
+    const isRequired = message.context !== null || isInterpolated;
+
+    return (
+        `{${contextField(message.context)} defaultValue: ${JSON.stringify(message.singular)}; ` +
+        `interpolated: ${String(isInterpolated)}; kind: "default"; required: ${String(isRequired)}; ` +
+        `value: ${stringType(values)} }`
+    );
+};
+
+const requirePlural = (message: SourceMessage): string => {
+    if (message.plural === null) {
+        throw new Error("Plural translation metadata requires a plural source string");
+    }
+
+    return message.plural;
+};
+
+const pluralVariant = (message: SourceMessage): string => {
+    const plural = requirePlural(message);
+    const values = [message.singular, plural];
+    const isInterpolated = hasInterpolation(values);
+
+    return (
+        `{${contextField(message.context)} defaultValue: ${JSON.stringify(plural)}; ` +
+        `interpolated: ${String(isInterpolated)}; kind: "plural"; required: true; ` +
+        `value: ${stringType(values)} }`
+    );
+};
+
+const pluralDefaultsVariant = (message: SourceMessage): string => {
+    const plural = requirePlural(message);
+    const values = [message.singular, plural];
+    const isInterpolated = hasInterpolation(values);
+
+    return (
+        `{${contextField(message.context)} defaultValueOne: ${JSON.stringify(message.singular)}; ` +
+        `defaultValueOther: ${JSON.stringify(plural)}; interpolated: ${String(isInterpolated)}; ` +
+        `kind: "pluralDefaults"; required: true; value: ${stringType(values)} }`
+    );
+};
+
+const variantsFor = (message: SourceMessage): string[] => {
+    if (message.kind === "plural") {
+        return [pluralVariant(message)];
+    }
+
+    if (message.kind === "pluralDefaults") {
+        return [pluralDefaultsVariant(message)];
+    }
+
+    return message.kind === "default" ? [defaultVariant(message)] : [pointVariant(message)];
+};
+
+const renderRegistry = (messages: SourceMessage[]): string[] => {
+    const entries: Map<string, Set<string>> = new Map();
+
+    for (const message of messages) {
+        const variants = entries.get(message.msgid) ?? new Set<string>();
+
+        for (const variant of variantsFor(message)) {
+            variants.add(variant);
+        }
+
+        entries.set(message.msgid, variants);
+    }
+
+    return [...entries]
+        .toSorted(([left], [right]) => left.localeCompare(right))
+        .map(([msgid, variants]) => `        ${JSON.stringify(msgid)}: ${[...variants].join(" | ")};`);
+};
+
+const generatedHeader = (): string[] => [
+    "/**",
+    " * Translation declarations generated by GTKX. Regenerated by",
+    " * `gtkx codegen`, `gtkx dev`, and `gtkx build`; do not edit.",
+    " */",
+];
+
+const renderI18nTypes = (messages: SourceMessage[], isEnabled = true): string => {
+    if (!isEnabled) {
+        return [...generatedHeader(), "export {};", ""].join("\n");
+    }
+
+    return [
+        ...generatedHeader(),
+        'import "@gtkx/i18n";',
+        "",
+        'declare module "@gtkx/i18n" {',
+        "    interface TranslationRegistry {",
+        ...renderRegistry(messages),
+        "    }",
+        "}",
+        "",
+    ].join("\n");
+};
+
+const i18nTypesPath = (root: string): string => join(root, "node_modules", ".gtkx", I18N_TYPES_FILENAME);
+
+const readFileOrNull = (path: string): string | null => {
+    try {
+        return readFileSync(path, "utf8");
+    } catch {
+        return null;
+    }
+};
+
+const emitI18nTypes = (root: string, messages: SourceMessage[], isEnabled = true): I18nTypesResult => {
+    const path = i18nTypesPath(root);
+    const content = renderI18nTypes(messages, isEnabled);
+
+    if (readFileOrNull(path) === content) {
+        return { isWritten: false, path };
+    }
+
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content);
+
+    return { isWritten: true, path };
+};
+
+export { I18N_TYPES_FILENAME, emitI18nTypes, i18nTypesPath };

package/src/internal/source-imports.ts

@@ -1,8 +1,8 @@
-import type { ParseResult, ParserOptions } from "vite";
-import { isRecord, sortStringsBy } from "@gtkx/utils";
+import type { ESTree, ParseResult, ParserOptions } from "vite";
+import { sortStringsBy } from "@gtkx/utils";
 import { type Dirent, readdirSync, readFileSync } from "node:fs";
 import { extname, join } from "node:path";
-import { parseSync } from "vite";
+import { parseSync, Visitor } from "vite";
 
 type SourceImport = {
     importer: string;
@@ -71,6 +71,13 @@ const sourceFilesIn = (dir: string, found: string[]): void => {
     }
 };
 
+const discoverSourceFiles = (dir: string): string[] => {
+    const files: string[] = [];
+    sourceFilesIn(dir, files);
+
+    return sortStringsBy(files, (path) => path);
+};
+
 const staticImportSources = (module: ParsedModule): string[] => [
     ...module.staticImports.map((statement) => statement.moduleRequest.value),
     ...module.staticExports.flatMap((statement) =>
@@ -92,65 +99,30 @@ const staticRuntimeImportSources = (module: ParsedModule): string[] => [
     ),
 ];
 
-const templateImportSource = (node: Record<string, unknown>): string | null => {
-    if (!Array.isArray(node.expressions) || node.expressions.length > 0 || !Array.isArray(node.quasis)) {
-        return null;
-    }
+const templateImportSource = (node: ESTree.TemplateLiteral): string | null => {
+    const [quasi] = node.quasis;
 
-    const quasis: unknown[] = node.quasis;
-    const first: unknown = quasis[0];
-
-    if (!isRecord(first) || !isRecord(first.value)) {
-        return null;
-    }
-
-    return typeof first.value.cooked === "string" ? first.value.cooked : null;
+    return quasi === undefined || node.expressions.length > 0 ? null : quasi.value.cooked;
 };
 
-const literalImportSource = (node: unknown): string | null => {
-    if (!isRecord(node)) {
-        return null;
-    }
-
-    if (node.type === "Literal") {
-        return typeof node.value === "string" ? node.value : null;
+const literalImportSource = (node: ESTree.Expression): string | null => {
+    if (node.type === "TemplateLiteral") {
+        return templateImportSource(node);
     }
 
-    return node.type === "TemplateLiteral" ? templateImportSource(node) : null;
-};
-
-const collectDynamicImportArray = (nodes: unknown[], found: string[]): void => {
-    for (const child of nodes) {
-        collectDynamicImportSources(child, found);
-    }
+    return node.type === "Literal" && typeof node.value === "string" ? node.value : null;
 };
 
-const collectDynamicImportRecord = (node: Record<string, unknown>, found: string[]): void => {
-    if (node.type === "ImportExpression") {
-        const source = literalImportSource(node.source);
+const collectDynamicImportSources = (program: ESTree.Program, found: string[]): void => {
+    new Visitor({
+        ImportExpression: (node) => {
+            const source = literalImportSource(node.source);
 
-        if (source !== null) {
-            found.push(source);
-        }
-
-        return;
-    }
-
-    collectDynamicImportArray(Object.values(node), found);
-};
-
-const collectDynamicImportSources = (node: unknown, found: string[]): void => {
-    if (Array.isArray(node)) {
-        collectDynamicImportArray(node, found);
-
-        return;
-    }
-
-    if (!isRecord(node)) {
-        return;
-    }
-
-    collectDynamicImportRecord(node, found);
+            if (source !== null) {
+                found.push(source);
+            }
+        },
+    }).visit(program);
 };
 
 const parseImportsInWith = (
@@ -190,11 +162,10 @@ const importsIn = (path: string): SourceImport[] => parseImportsIn(path) ?? [];
 const importKey = (entry: SourceImport): string => `${entry.importer}\0${entry.source}`;
 
 const discoverSourceImports = (dir: string): SourceImport[] => {
-    const files: string[] = [];
-    sourceFilesIn(dir, files);
+    const files = discoverSourceFiles(dir);
     const imports = files.flatMap((path) => importsIn(path));
 
     return sortStringsBy(imports, importKey);
 };
 
-export { discoverSourceImports, parseRuntimeImportsIn, type SourceImport };
+export { discoverSourceFiles, discoverSourceImports, parseRuntimeImportsIn, type SourceImport, sourceLanguage };

package/src/mcp/client.ts

@@ -1,7 +1,13 @@
 import * as Gio from "@gtkx/gi/gio";
 import * as Gtk from "@gtkx/gi/gtk";
-import { DEFAULT_SOCKET_PATH, ErrorCode, ProtocolConnection, ProtocolError, type Request } from "@gtkx/mcp/internal";
-import { error, errorMessage, info, normalizeError, warn } from "@gtkx/utils";
+import {
+    DEFAULT_SOCKET_PATH,
+    isConnectionClosedError,
+    type JSONRPCRequest,
+    ProtocolConnection,
+    type Result,
+} from "@gtkx/mcp/internal";
+import { error, errorMessage, info, normalizeError } from "@gtkx/utils";
 import * as net from "node:net";
 import { dispatch } from "./handlers.js";
 import { WidgetRegistry } from "./widget-registry.js";
@@ -25,11 +31,6 @@ const RECONNECT_DELAY_MS = 2000;
 const REGISTER_TIMEOUT_MS = 30_000;
 const DISCONNECT_ERROR_CODES: Set<string> = new Set(["ENOENT", "ECONNREFUSED", "EPIPE", "ECONNRESET"]);
 
-const toResponseError = (error: unknown): { code: number; message: string; data?: unknown } =>
-    error instanceof ProtocolError
-        ? error.toErrorObject()
-        : { code: ErrorCode.INTERNAL_ERROR, message: errorMessage(error) };
-
 const connectSettler = (callbacks: ConnectCallbacks): ConnectSettler => {
     let isSettled = false;
 
@@ -82,7 +83,7 @@ class McpClient {
     private handleSocketError(socketError: Error): void {
         const code = (socketError as NodeJS.ErrnoException).code;
 
-        if (code !== undefined && DISCONNECT_ERROR_CODES.has(code)) {
+        if (isConnectionClosedError(socketError) || (code !== undefined && DISCONNECT_ERROR_CODES.has(code))) {
             this.scheduleReconnect();
         } else {
             error("Socket error:", socketError.message);
@@ -119,14 +120,7 @@ class McpClient {
             },
         });
 
-        connection.on("request", (request) => {
-            void this.handleRequest(request);
-        });
-
-        connection.on("invalid", ({ error: parseError }) => {
-            warn(`Received invalid JSON from MCP server: ${parseError.message}`);
-        });
-
+        connection.fallbackRequestHandler = (request) => this.handleRequest(request);
         this.socket = socket;
         this.connection = connection;
     }
@@ -158,35 +152,16 @@ class McpClient {
         );
     }
 
-    private async respondToRequest(request: Request): Promise<void> {
-        const { id, method, params } = request;
-        const connection = this.connection;
+    private handleRequest(request: JSONRPCRequest): Promise<Result> {
+        const defaultApp = Gio.Application.getDefault();
 
-        if (!connection) {
-            return;
+        if (!(defaultApp instanceof Gtk.Application)) {
+            throw new TypeError("Application not initialized");
         }
 
-        try {
-            const defaultApp = Gio.Application.getDefault();
-
-            if (!(defaultApp instanceof Gtk.Application)) {
-                throw new TypeError("Application not initialized");
-            }
+        this.registry.refresh();
 
-            this.registry.refresh();
-            const result = await dispatch(method, params, { app: defaultApp, registry: this.registry });
-            connection.write({ id, result });
-        } catch (dispatchError) {
-            connection.write({ id, error: toResponseError(dispatchError) });
-        }
-    }
-
-    private async handleRequest(request: Request): Promise<void> {
-        try {
-            await this.respondToRequest(request);
-        } catch (requestError) {
-            error("Error handling request:", requestError);
-        }
+        return dispatch(request.method, request.params, { app: defaultApp, registry: this.registry });
     }
 
     async connect(): Promise<void> {
@@ -219,10 +194,8 @@ class McpClient {
             this.reconnectTimer = null;
         }
 
-        this.connection?.rejectPending(new Error("Client disconnected"));
-
         if (this.socket) {
-            this.connection?.write({ id: crypto.randomUUID(), method: "app.unregister" });
+            void Promise.allSettled([this.connection?.send("app.unregister")]);
             this.socket.destroy();
             this.socket = null;
         }

package/src/mcp/handlers.ts

@@ -3,6 +3,7 @@ import {
     invalidRequestError,
     methodNotFoundError,
     type ParamsSchema,
+    type Result,
     type ServerInitiatedMethod,
     type ServerRequestParams,
     ServerRequestParamsSchemas,
@@ -18,10 +19,10 @@ type HandlerContext = {
     registry: WidgetRegistry;
 };
 
-type ValidatedHandler = (ctx: HandlerContext, params: unknown) => Promise<unknown>;
+type ValidatedHandler = (ctx: HandlerContext, params: unknown) => Promise<Result>;
 type WidgetTarget = { testing: TestingModule; widget: Gtk.Widget };
 type WidgetParams = { widgetId?: string | undefined };
-type TargetedHandler<Params> = (ctx: HandlerContext, target: WidgetTarget, params: Params) => Promise<unknown>;
+type TargetedHandler<Params> = (ctx: HandlerContext, target: WidgetTarget, params: Params) => Promise<Result>;
 type QueryParams = ServerRequestParams<"widget.query">;
 type QueryBy = QueryParams["by"];
 type QueryRunner = (testing: TestingModule, app: Gtk.Application, params: QueryParams) => Promise<Gtk.Widget[]>;
@@ -110,7 +111,7 @@ const SEARCHED_BY: Record<QueryBy, string> = {
 
 function validated<Params>(
     schema: ParamsSchema<Params>,
-    handler: (ctx: HandlerContext, params: Params) => Promise<unknown>,
+    handler: (ctx: HandlerContext, params: Params) => Promise<Result>,
 ): ValidatedHandler {
     return (ctx, params) => {
         const parsed = schema.safeParse(params ?? {});
@@ -229,7 +230,7 @@ const emptyQueryHint = (params: QueryParams): string =>
     "Call gtkx_get_widget_tree to see what is mounted; by:\"name\" is the widest match, and by:\"role\" accepts " +
     "options.name to match the accessible name of a known role.";
 
-async function handleQuery({ app, registry }: HandlerContext, params: QueryParams): Promise<unknown> {
+async function handleQuery({ app, registry }: HandlerContext, params: QueryParams): Promise<Result> {
     const testing = await loadTestingModule();
     const widgets = await QUERY_RUNNERS[params.by](testing, app, params);
     const resolveId = (widget: Gtk.Widget): string => registry.getOrCreateId(widget);
@@ -254,7 +255,7 @@ const defaultScreenshotTarget = (registry: WidgetRegistry): Gtk.Widget => {
 async function handleScreenshot(
     { registry }: HandlerContext,
     params: ServerRequestParams<"widget.screenshot">,
-): Promise<unknown> {
+): Promise<Result> {
     const testing = await loadTestingModule();
     const target = params.windowId ? requireWidget(registry, params.windowId) : defaultScreenshotTarget(registry);
     const result = await testing.screenshot(target, { path: params.path });
@@ -269,7 +270,7 @@ async function handleScreenshot(
 const isServerInitiatedMethod = (method: string): method is ServerInitiatedMethod =>
     Object.hasOwn(ServerRequestParamsSchemas, method);
 
-const dispatch = async (method: string, params: unknown, ctx: HandlerContext): Promise<unknown> => {
+const dispatch = async (method: string, params: unknown, ctx: HandlerContext): Promise<Result> => {
     if (!isServerInitiatedMethod(method)) {
         throw methodNotFoundError(method);
     }

package/src/settings/render.ts

@@ -13,6 +13,10 @@ type EnvAssetDeclarations = {
     resources: string[];
 };
 
+type EnvModuleOptions = {
+    references?: string[];
+};
+
 const GTKX_ENV_MODULE_HEADER = `/**
  * Project import declarations generated by GTKX. Regenerated by
  * \`gtkx codegen\`, \`gtkx dev\`, and \`gtkx build\`; do not edit.
@@ -226,6 +230,7 @@ const renderBlockedAssetModule = (specifier: string): string => [
 const renderEnvModule = (
     files: ParsedSchemaFile[],
     assetDeclarations?: EnvAssetDeclarations,
+    options: EnvModuleOptions = {},
 ): string => {
     const assets = assetDeclarations ?? { blocked: [], icons: [], legacy: [], resources: [] };
     const usedNames: Set<string> = new Set();
@@ -238,8 +243,17 @@ const renderEnvModule = (
     const icons = assets.icons.map((specifier) => renderIconModule(specifier));
     const legacy = assets.legacy.map((specifier) => renderLegacyAssetModule(specifier));
     const resources = assets.resources.map((specifier) => renderResourceModule(specifier));
-
-    return `${[GTKX_ENV_MODULE_HEADER, ...blocked, ...icons, ...legacy, ...resources, ...schemas].join("\n\n")}\n`;
+    const references = (options.references ?? []).map((path) => `/// <reference path=${JSON.stringify(path)} />`);
+
+    return `${[
+        GTKX_ENV_MODULE_HEADER,
+        ...references,
+        ...blocked,
+        ...icons,
+        ...legacy,
+        ...resources,
+        ...schemas,
+    ].join("\n\n")}\n`;
 };
 
 export { renderRuntimeModule, renderEnvModule };

package/src/settings/schema.ts

@@ -13,6 +13,7 @@ import {
 } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { I18N_TYPES_FILENAME, i18nTypesPath } from "../i18n/types.js";
 import { DATA_IMPORT_PREFIX } from "../internal/data-dir.js";
 import { discoverSourceImports, type SourceImport } from "../internal/source-imports.js";
 import { removeTempDir } from "../internal/staging-dir.js";
@@ -323,7 +324,8 @@ const emitSchemaEnv = (
     assertUniqueSchemaBasenames(importedFiles);
     const imported = parseProjectSchemas(importedFiles, getRelativeModuleSpecifier);
     const assets = findAssetModuleSpecifiers(imports, isV2ResourceImports);
-    const content = renderEnvModule([...legacy, ...imported], assets);
+    const references = existsSync(i18nTypesPath(rootDir)) ? [`./${I18N_TYPES_FILENAME}`] : [];
+    const content = renderEnvModule([...legacy, ...imported], assets, { references });
     const path = schemaEnvPath(rootDir);
     const isWritten = didWriteChanges(path, content);
 

package/src/vite-plugins/asset-imports.ts

@@ -1,8 +1,8 @@
 import type { ConfigLoader } from "@gtkx/config";
-import type { ParseResult, ParserOptions, Plugin, UserConfig } from "vite";
+import type { ParseResult, Plugin, UserConfig } from "vite";
 import { createConfigLoader } from "@gtkx/config/internal";
-import { extname } from "node:path";
 import { parseSync } from "vite";
+import { sourceLanguage } from "../internal/source-imports.js";
 import { ASSET_MENTION_RE } from "./asset-extensions.js";
 import {
     DATA_PREFIX,
@@ -15,7 +15,6 @@ import {
 import { RESOURCE_PATH_EXPORT } from "./resource-shared.js";
 import { stripQuery } from "./strip-query.js";
 
-type SourceLanguage = NonNullable<ParserOptions["lang"]>;
 type ParsedModule = ParseResult["module"];
 type ImportStatement = ParsedModule["staticImports"][number];
 type ExportStatement = ParsedModule["staticExports"][number];
@@ -24,17 +23,6 @@ type BindingEntry = { importName: { name: string | null }; isType: boolean };
 type NamedBinding = { name: string; source: string };
 type PluginState = { isV2: boolean };
 
-const SOURCE_LANGUAGES: Map<string, SourceLanguage> = new Map([
-    [".cjs", "jsx"],
-    [".cts", "ts"],
-    [".js", "jsx"],
-    [".jsx", "jsx"],
-    [".mjs", "jsx"],
-    [".mts", "ts"],
-    [".ts", "ts"],
-    [".tsx", "tsx"],
-]);
-
 const NODE_MODULES = /(?:^|\/)node_modules\//;
 const VIRTUAL_PREFIX = "\0";
 const DEFAULT_BINDING = "default";
@@ -135,7 +123,7 @@ const hasCheckedAssetMention = (code: string): boolean => ASSET_MENTION_RE.test(
 
 const checkAssetImports = (code: string, id: string, isV2: boolean): void => {
     const path = stripQuery(id);
-    const lang = SOURCE_LANGUAGES.get(extname(path).toLowerCase());
+    const lang = sourceLanguage(path);
 
     if (lang === undefined || !isCheckedSource(path) || !hasCheckedAssetMention(code)) {
         return;

package/src/vite-plugins/i18n.ts

@@ -0,0 +1,146 @@
+import type { ConfigLoader } from "@gtkx/config";
+import type { Plugin, ResolvedConfig } from "vite";
+import { createConfigLoader } from "@gtkx/config/internal";
+import { existsSync, mkdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, posix, relative, resolve } from "node:path";
+import {
+    type CatalogProject,
+    compileCatalogs,
+    LOCALE_DIRNAME,
+    resolveCatalogProject,
+    synchronizeCatalogs,
+} from "../i18n/catalogs.js";
+import { extractSourceCatalog } from "../i18n/source-messages.js";
+import { discoverSourceFiles } from "../internal/source-imports.js";
+import { stripQuery } from "./strip-query.js";
+
+type I18nState = {
+    entryPath: string;
+    i18nRoot: string;
+    outDir: string;
+    project: CatalogProject | null;
+};
+
+const BOOTSTRAP_SPECIFIER = "@gtkx/i18n/bootstrap";
+const LOCALE_URL_PLACEHOLDER = "__GTKX_BUNDLE_LOCALE_DIR__";
+const LOCALE_MODULE_PATHS = new Set(["dist/locale.js", "src/locale.ts"]);
+const LOCALE_URL_PATTERN = /new URL\((["'])locale\1,\s*import\.meta\.url\)/;
+
+const isI18nLocaleModule = (state: I18nState, id: string): boolean => {
+    if (state.i18nRoot.length === 0) {
+        return false;
+    }
+
+    const path = relative(state.i18nRoot, stripQuery(id)).replaceAll("\\", "/");
+
+    return LOCALE_MODULE_PATHS.has(path);
+};
+
+const markLocaleUrl = (code: string): string =>
+    code.replace(
+        LOCALE_URL_PATTERN,
+        () => `new URL(${JSON.stringify(LOCALE_URL_PLACEHOLDER)}, import.meta.url)`,
+    );
+
+const localeUrlForChunk = (fileName: string): string => {
+    const path = posix.relative(posix.dirname(fileName), LOCALE_DIRNAME);
+
+    return path.length === 0 ? "." : path;
+};
+
+const rebaseLocaleUrl = (state: I18nState, code: string, fileName: string, moduleIds: string[]): string | null => {
+    if (moduleIds.every((id) => !isI18nLocaleModule(state, id))) {
+        return null;
+    }
+
+    const placeholder = JSON.stringify(LOCALE_URL_PLACEHOLDER);
+
+    if (!code.includes(placeholder)) {
+        throw new Error(`Unable to locate the @gtkx/i18n locale fallback in ${fileName}`);
+    }
+
+    return code.replace(placeholder, () => JSON.stringify(localeUrlForChunk(fileName)));
+};
+
+const applyResolvedConfig = async (
+    state: I18nState,
+    config: ResolvedConfig,
+    loadConfig: ConfigLoader,
+): Promise<void> => {
+    state.entryPath = resolve(config.root, state.entryPath);
+    state.outDir = resolve(config.root, config.build.outDir);
+    const application = await loadConfig.resolve(config.root);
+    state.project = resolveCatalogProject(config.root, application.applicationId);
+
+    if (state.project !== null) {
+        const projectRequire = createRequire(resolve(config.root, "package.json"));
+        state.i18nRoot = dirname(projectRequire.resolve("@gtkx/i18n/package.json"));
+    }
+};
+
+const buildCatalogs = (state: I18nState): void => {
+    const project = state.project;
+
+    if (project === null) {
+        return;
+    }
+
+    mkdirSync(state.outDir, { recursive: true });
+    compileCatalogs(project, resolve(state.outDir, LOCALE_DIRNAME));
+};
+
+const extractProjectMessages = async (
+    state: I18nState,
+    shouldPreserveMetadataMessages: boolean,
+): Promise<void> => {
+    const project = state.project;
+
+    if (project === null) {
+        return;
+    }
+
+    const srcDir = join(project.root, "src");
+    const sourceFiles = discoverSourceFiles(existsSync(srcDir) ? srcDir : project.root);
+    await extractSourceCatalog(project, sourceFiles, shouldPreserveMetadataMessages);
+    synchronizeCatalogs(project);
+};
+
+const gtkxI18n = (
+    entryPath: string,
+    loadConfig: ConfigLoader = createConfigLoader(),
+    shouldPreserveMetadataMessages = true,
+): Plugin => {
+    const state: I18nState = { entryPath, i18nRoot: "", outDir: "", project: null };
+
+    return {
+        name: "gtkx:i18n",
+        enforce: "pre",
+
+        configResolved: (config) => applyResolvedConfig(state, config, loadConfig),
+
+        buildStart: () => extractProjectMessages(state, shouldPreserveMetadataMessages),
+
+        transform(code, id) {
+            if (isI18nLocaleModule(state, id)) {
+                return markLocaleUrl(code);
+            }
+
+            if (state.project === null || resolve(stripQuery(id)) !== state.entryPath) {
+                return;
+            }
+
+            return `import ${JSON.stringify(BOOTSTRAP_SPECIFIER)};\n${code}`;
+        },
+
+        renderChunk(code, chunk) {
+            return rebaseLocaleUrl(state, code, chunk.fileName, chunk.moduleIds);
+        },
+
+        generateBundle() {
+            buildCatalogs(state);
+        },
+    };
+};
+
+export { gtkxI18n };