@gtkx/cli 1.4.0 → 1.6.0

package/src/deploy/freedesktop/localize.ts

@@ -0,0 +1,144 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import type { CatalogProject } from "../../i18n/catalogs.js";
+import type { StagedMetadata } from "../payload/stage.js";
+import { metadataTemplateFile, type MetadataTemplateKind } from "../../i18n/metadata-templates.js";
+import { runCliTool } from "../../internal/run-cli-tool.js";
+
+type MergeMode = "--desktop" | "--xml";
+
+type MergeRequest = {
+    mode: MergeMode;
+    stem: string;
+    extension: string;
+    template: string;
+};
+
+type MetadataTemplate = {
+    contents: string;
+    path: string;
+    relativePath: string;
+};
+
+const metadataTemplates = (project: CatalogProject, metadata: StagedMetadata): MetadataTemplate[] => {
+    const template = (kind: MetadataTemplateKind, contents: string): MetadataTemplate => {
+        const { path, relativePath } = metadataTemplateFile(project, kind);
+
+        return { contents, path, relativePath };
+    };
+
+    return [
+        template("desktop", metadata.desktopEntry),
+        template("metainfo.xml", metadata.metainfo),
+        ...(metadata.mimePackage === null ? [] : [template("mime.xml", metadata.mimePackage)]),
+    ];
+};
+
+const mergeCatalogs = (project: CatalogProject, workDir: string, request: MergeRequest): string => {
+    const { extension, mode, stem, template } = request;
+    let current = join(workDir, `${stem}-source${extension}`);
+    writeFileSync(current, template);
+
+    for (const [index, catalog] of project.catalogs.entries()) {
+        const output = join(workDir, `${stem}-${String(index)}${extension}`);
+
+        runCliTool({
+            tool: "msgfmt",
+            args: [
+                mode,
+                `--template=${current}`,
+                `--locale=${catalog.locale}`,
+                `--output-file=${output}`,
+                catalog.path,
+            ],
+            target: catalog.path,
+        });
+
+        current = output;
+    }
+
+    return readFileSync(current, "utf8");
+};
+
+const localizeMetadata = (metadata: StagedMetadata, project: CatalogProject | null): StagedMetadata => {
+    if (project === null || project.catalogs.length === 0) {
+        return metadata;
+    }
+
+    const workDir = mkdtempSync(join(tmpdir(), "gtkx-deploy-metadata-"));
+
+    try {
+        return {
+            desktopEntry: mergeCatalogs(project, workDir, {
+                mode: "--desktop",
+                stem: "application",
+                extension: ".desktop",
+                template: metadata.desktopEntry,
+            }),
+            metainfo: mergeCatalogs(project, workDir, {
+                mode: "--xml",
+                stem: "metainfo",
+                extension: ".metainfo.xml",
+                template: metadata.metainfo,
+            }),
+            mimePackage: metadata.mimePackage === null
+                ? null
+                : mergeCatalogs(project, workDir, {
+                        mode: "--xml",
+                        stem: "mime",
+                        extension: ".xml",
+                        template: metadata.mimePackage,
+                    }),
+        };
+    } finally {
+        rmSync(workDir, { recursive: true, force: true });
+    }
+};
+
+const extractMetadataMessages = (
+    metadata: StagedMetadata,
+    project: CatalogProject,
+    catalogTemplate?: string,
+): void => {
+    const potPath = catalogTemplate ?? join(project.poDir, `${project.domain}.pot`);
+
+    if (!existsSync(potPath)) {
+        throw new Error(`Cannot add the generated metadata to the missing catalog template: ${potPath}`);
+    }
+
+    const templates = metadataTemplates(project, metadata);
+    const firstTemplate = templates[0];
+
+    if (firstTemplate === undefined) {
+        throw new Error("Cannot extract metadata messages without a generated template");
+    }
+
+    const metadataDir = dirname(firstTemplate.path);
+    mkdirSync(metadataDir, { recursive: true });
+
+    try {
+        for (const template of templates) {
+            writeFileSync(template.path, template.contents);
+        }
+
+        runCliTool({
+            tool: "xgettext",
+            args: [
+                "--join-existing",
+                "--force-po",
+                "--from-code=UTF-8",
+                `--output=${potPath}`,
+                ...templates.map((template) => template.relativePath),
+            ],
+            target: potPath,
+            options: { cwd: project.root },
+        });
+    } finally {
+        for (const template of templates) {
+            rmSync(template.path, { force: true });
+        }
+    }
+};
+
+export { extractMetadataMessages, localizeMetadata };

package/src/deploy/install-hints.ts

@@ -43,8 +43,13 @@ const PACKAGE_FOR_TOOL: Record<string, FamilyPackages> = {
         fedora: "flatpak-builder",
         suse: "flatpak-builder",
     },
+    msgfmt: { arch: "gettext", debian: "gettext", fedora: "gettext", suse: "gettext-tools" },
+    msginit: { arch: "gettext", debian: "gettext", fedora: "gettext", suse: "gettext-tools" },
+    msggrep: { arch: "gettext", debian: "gettext", fedora: "gettext", suse: "gettext-tools" },
+    msgmerge: { arch: "gettext", debian: "gettext", fedora: "gettext", suse: "gettext-tools" },
     strip: { arch: "binutils", debian: "binutils", fedora: "binutils", suse: "binutils" },
     tar: { arch: "tar", debian: "tar", fedora: "tar", suse: "tar" },
+    xgettext: { arch: "gettext", debian: "gettext", fedora: "gettext", suse: "gettext-tools" },
 };
 
 const GENERATOR_SOURCE = "git+https://github.com/flatpak/flatpak-builder-tools.git#subdirectory=node";

package/src/deploy/notices/gtkx.ts

@@ -44,7 +44,7 @@ const summaryFor = (settings: DeploySettings, packages: BundledPackage[]): strin
         "Section 3.2(a) asks that whoever receives an executable form be told how to obtain the source code,",
         "which is what the source pointer below is for: it leads to the release these files were built from.",
         `The addon also statically links Rust crates GTKX did not write, so ${lib}/${NATIVE_FILENAME} is not`,
-        `${LICENSE_NAME} alone. The second notice below names the licenses those crates carry; it does not`,
+        `${LICENSE_NAME} alone. The crates notice below names the licenses those crates carry; it does not`,
         `reproduce their texts, and ${CRATES_MANIFEST} in the source pointed at records which crates went in`,
         "and at which versions.",
         ...modulesLine(packages),

package/src/deploy/notices/libraries.ts

@@ -36,7 +36,8 @@ const SUMMARY = [
     "their own terms; this package does not distribute them at all.",
     "The GTKX native addon does link GLib, GObject and GIO dynamically against the copies already installed",
     "on the system, which makes the addon a work that uses those libraries, and section 6 of the LGPL asks",
-    "such a work to carry three things. This is the notice it asks for. The license itself is published at",
+    "such a work to carry a notice, the license, and the copyright notices. This is the notice it asks for,",
+    "and the license itself is published at",
     `${LGPL_URL},`,
     "and the copyright notice of each library is published with its sources, at the address listed beside",
     "it below. Linking against an installed shared library is the mechanism section 6(b) allows, so the",

package/src/deploy/payload/launcher.ts

@@ -18,6 +18,8 @@ const renderLauncher = (settings: DeploySettings): string => {
         "set -e",
         'self=$(readlink -f "$0")',
         'prefix=$(dirname "$(dirname "$self")")',
+        'GTKX_LOCALE_DIR="$prefix/share/locale"',
+        "export GTKX_LOCALE_DIR",
         ...(shouldUseCompileCache ? compileCacheLines(settings.binaryName) : []),
         `exec "${libDir}/${NODE_FILENAME}" "${libDir}/${BUNDLE_FILENAME}" "$@"`,
         "",

package/src/deploy/payload/stage.ts

@@ -2,12 +2,12 @@ import { sortStringsBy } from "@gtkx/utils";
 import { existsSync, rmSync } from "node:fs";
 import { join, resolve } from "node:path";
 import type { DeploySettings, DeployTargetName, NodeRuntime, NoticeSection, StagedFile } from "../types.js";
+import { LOCALE_DIRNAME } from "../../i18n/catalogs.js";
 import { BUILD_MANIFEST_FILENAME } from "../../internal/build-manifest.js";
 import { listFilesRecursive } from "../../internal/list-files.js";
 import { BUNDLE_FILENAME } from "../../vite-plugins/esm-extension.js";
 import { renderCopyright } from "../freedesktop/copyright.js";
 import { renderDbusService } from "../freedesktop/dbus-service.js";
-import { renderDesktopEntry } from "../freedesktop/desktop-entry.js";
 import { renderNotices } from "../notices/render.js";
 import { copyInto, EXECUTABLE_MODE, executableModeFor, writeInto } from "./copy-tree.js";
 import { stageIcons } from "./icons.js";
@@ -36,6 +36,7 @@ const SHARE_MIME_PACKAGES = "share/mime/packages";
 const SHARE_DOC = "share/doc";
 const SHARE_LICENSES = "share/licenses";
 const SHARE_DBUS_SERVICES = "share/dbus-1/services";
+const SHARE_LOCALE = `share/${LOCALE_DIRNAME}`;
 
 const PREFIX_FOR: Record<DeployTargetName, string> = {
     appimage: "/usr",
@@ -53,6 +54,8 @@ const isIconAsset = (rel: string): boolean => rel === DIST_ICONS_DIR || rel.star
 const isBuildMetadata = (rel: string): boolean =>
     rel === BUILD_MANIFEST_FILENAME || rel === LEGACY_PACKAGES_MANIFEST_FILENAME;
 
+const isLocaleAsset = (rel: string): boolean => rel === LOCALE_DIRNAME || rel.startsWith(`${LOCALE_DIRNAME}/`);
+
 const nodeLicenseDestination = (settings: DeploySettings): string =>
     `${licenseDirFor(settings)}/${NODE_FILENAME}/${NODE_LICENSE_FILENAME}`;
 
@@ -64,10 +67,14 @@ const stageRuntimeFiles = (settings: DeploySettings, root: string): StagedFile[]
     }
 
     return listFilesRecursive(dist)
-        .filter((file) => !isIconAsset(file.rel) && !isBuildMetadata(file.rel))
+        .filter((file) => !isIconAsset(file.rel) && !isBuildMetadata(file.rel) && !isLocaleAsset(file.rel))
         .map((file) => copyInto(root, join(libDirFor(settings), file.rel), file.absPath));
 };
 
+const stageCatalogs = (settings: DeploySettings, root: string): StagedFile[] =>
+    listFilesRecursive(join(settings.paths.dist, LOCALE_DIRNAME))
+        .map((file) => copyInto(root, join(SHARE_LOCALE, file.rel), file.absPath));
+
 const stageNodeBinary = (settings: DeploySettings, root: string, node: NodeRuntime | null): StagedFile[] =>
     node === null ? [] : [copyInto(root, join(libDirFor(settings), NODE_FILENAME), node.path, EXECUTABLE_MODE)];
 
@@ -104,6 +111,7 @@ const stagePayload = ({ settings, node, metadata }: StageRequest): StagedFile[]
         writeInto(root, join("bin", settings.binaryName), renderLauncher(settings), EXECUTABLE_MODE),
         ...stageNodeBinary(settings, root, node),
         ...stageRuntimeFiles(settings, root),
+        ...stageCatalogs(settings, root),
         ...stageMetadata(settings, root, metadata),
         ...stageIcons(settings, root),
         ...stageSchemas(settings, root),
@@ -111,7 +119,18 @@ const stagePayload = ({ settings, node, metadata }: StageRequest): StagedFile[]
     ]);
 };
 
-const stageActivation = (settings: DeploySettings, root: string, target: DeployTargetName): StagedFile[] => {
+const withoutDbusActivation = (desktopEntry: string): string =>
+    desktopEntry
+        .split("\n")
+        .filter((line) => line !== "DBusActivatable=true")
+        .join("\n");
+
+const stageActivation = (
+    settings: DeploySettings,
+    root: string,
+    target: DeployTargetName,
+    metadata: StagedMetadata,
+): StagedFile[] => {
     if (!settings.isDbusActivatable) {
         return [];
     }
@@ -120,7 +139,7 @@ const stageActivation = (settings: DeploySettings, root: string, target: DeployT
         return [writeInto(
             root,
             join(SHARE_APPLICATIONS, `${settings.applicationId}.desktop`),
-            renderDesktopEntry({ ...settings, isDbusActivatable: false }),
+            withoutDbusActivation(metadata.desktopEntry),
         )];
     }
 
@@ -131,11 +150,16 @@ const stageActivation = (settings: DeploySettings, root: string, target: DeployT
     )];
 };
 
-const stageOverlay = (settings: DeploySettings, target: DeployTargetName, notices: NoticeSection[]): StagedFile[] => {
+const stageOverlay = (
+    settings: DeploySettings,
+    target: DeployTargetName,
+    notices: NoticeSection[],
+    metadata: StagedMetadata,
+): StagedFile[] => {
     const root = join(settings.paths.overlay, target);
     rmSync(root, { recursive: true, force: true, maxRetries: 5 });
     const licenseFile = settings.paths.licenseFile;
-    const activation = stageActivation(settings, root, target);
+    const activation = stageActivation(settings, root, target, metadata);
 
     if (target === "deb") {
         return [
@@ -154,11 +178,12 @@ const stageOverlay = (settings: DeploySettings, target: DeployTargetName, notice
 const stageOverlays = (
     settings: DeploySettings,
     notices: NoticeSection[],
+    metadata: StagedMetadata,
 ): Record<DeployTargetName, StagedFile[]> => ({
-    appimage: stageOverlay(settings, "appimage", notices),
-    deb: stageOverlay(settings, "deb", notices),
-    flatpak: stageOverlay(settings, "flatpak", notices),
-    rpm: stageOverlay(settings, "rpm", notices),
+    appimage: stageOverlay(settings, "appimage", notices, metadata),
+    deb: stageOverlay(settings, "deb", notices, metadata),
+    flatpak: stageOverlay(settings, "flatpak", notices, metadata),
+    rpm: stageOverlay(settings, "rpm", notices, metadata),
 });
 
 export {

package/src/deploy/run-deploy.ts

@@ -1,6 +1,6 @@
 import { loadConfig } from "@gtkx/config";
 import { info, warn } from "@gtkx/utils";
-import { mkdirSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
 import type {
     DeployArtifact,
@@ -12,7 +12,19 @@ import type {
 } from "./types.js";
 import { build as buildApp } from "../builder.js";
 import { ensureGenerated } from "../codegen/run-codegen.js";
+import { replaceCatalogTemplate } from "../i18n/catalog-template.js";
+import {
+    type CatalogProject,
+    compileCatalogs,
+    LOCALE_DIRNAME,
+    requiresCatalogInitialization,
+    resolveCatalogProject,
+    synchronizeCatalogs,
+} from "../i18n/catalogs.js";
+import { extractSourceCatalogTo } from "../i18n/source-messages.js";
+import { discoverSourceFiles } from "../internal/source-imports.js";
 import { renderDesktopEntry } from "./freedesktop/desktop-entry.js";
+import { extractMetadataMessages, localizeMetadata } from "./freedesktop/localize.js";
 import { renderMetainfo } from "./freedesktop/metainfo.js";
 import { renderMimePackage } from "./freedesktop/mime-package.js";
 import { validateDesktopEntry, validateMetainfo } from "./freedesktop/validate.js";
@@ -32,10 +44,15 @@ import {
     DESKTOP_FILE_VALIDATE,
     FLATPAK_NODE_GENERATOR,
     FLATPAK_NODE_GENERATOR_PNPM,
+    MSGFMT,
+    MSGGREP,
+    MSGINIT,
+    MSGMERGE,
     probeTools,
     STRIP,
     TAR,
     warnMissingOptional,
+    XGETTEXT,
 } from "./tools.js";
 
 type DeployOptions = {
@@ -47,6 +64,14 @@ type DeployOptions = {
     shouldSkipBuild: boolean;
 };
 
+type PreflightRequest = {
+    targets: DeployTarget[];
+    settings: DeploySettings;
+    project: CatalogProject | null;
+    shouldPrintManifests: boolean;
+    shouldSkipBuild: boolean;
+};
+
 const BUILD_MODE = "production";
 const BYTES_PER_MIB = 1024 * 1024;
 const WEBKIT_LIBRARY = "WebKit-6.0";
@@ -198,12 +223,50 @@ const runtimeToolsFor = (targets: DeployTarget[], settings: DeploySettings): Dep
     return node.shouldStrip === false ? archiveTools : [...archiveTools, STRIP];
 };
 
-const preflight = (targets: DeployTarget[], settings: DeploySettings, shouldPrintManifests: boolean): void => {
+const mutableCatalogTools = (project: CatalogProject): DeployTool[] => {
+    if (project.catalogs.length === 0) {
+        return [MSGGREP, XGETTEXT];
+    }
+
+    return [
+        MSGFMT,
+        MSGGREP,
+        ...(requiresCatalogInitialization(project) ? [MSGINIT] : []),
+        MSGMERGE,
+        XGETTEXT,
+    ];
+};
+
+const catalogTools = (project: CatalogProject | null, shouldSkipBuild: boolean): DeployTool[] => {
+    if (project === null) {
+        return [];
+    }
+
+    if (!shouldSkipBuild) {
+        return mutableCatalogTools(project);
+    }
+
+    return project.catalogs.length === 0 ? [] : [MSGFMT];
+};
+
+const preflight = ({
+    targets,
+    settings,
+    project,
+    shouldPrintManifests,
+    shouldSkipBuild,
+}: PreflightRequest): void => {
     const packagerTools = shouldPrintManifests
         ? []
         : [...runtimeToolsFor(targets, settings), ...targets.flatMap((target) => target.tools)];
 
-    const required = [DESKTOP_FILE_VALIDATE, APPSTREAMCLI, ...sourceModeTools(targets, settings)];
+    const required = [
+        DESKTOP_FILE_VALIDATE,
+        APPSTREAMCLI,
+        ...catalogTools(project, shouldSkipBuild),
+        ...sourceModeTools(targets, settings),
+    ];
+
     const report = probeTools([...required, ...packagerTools]);
     assertTools(report);
     warnMissingOptional(report);
@@ -229,19 +292,55 @@ const loadSettings = async (options: DeployOptions): Promise<DeploySettings> =>
     return resolveDeploySettings({ root, config, outDirOverride: options.outDir });
 };
 
+const synchronizeMetadataCatalogs = async (
+    settings: DeploySettings,
+    templates: StagedMetadata,
+    project: CatalogProject | null,
+): Promise<void> => {
+    if (project === null) {
+        return;
+    }
+
+    const srcDir = join(project.root, "src");
+    const sourceFiles = discoverSourceFiles(existsSync(srcDir) ? srcDir : project.root);
+    const stagingDir = mkdtempSync(join(project.poDir, ".gtkx-deploy-i18n-"));
+    const stagedTemplate = join(stagingDir, `${project.domain}.pot`);
+    const template = join(project.poDir, `${project.domain}.pot`);
+
+    try {
+        await extractSourceCatalogTo(project, sourceFiles, stagedTemplate);
+        extractMetadataMessages(templates, project, stagedTemplate);
+        replaceCatalogTemplate(stagedTemplate, template);
+        synchronizeCatalogs(project);
+        compileCatalogs(project, join(settings.paths.dist, LOCALE_DIRNAME));
+    } finally {
+        rmSync(stagingDir, { recursive: true, force: true });
+    }
+};
+
 const buildPayload = async (
     options: DeployOptions,
     settings: DeploySettings,
     targets: DeployTarget[],
+    project: CatalogProject | null,
 ): Promise<DeployPayload> => {
-    const metadata = renderMetadata(settings);
-    validateMetadata(settings, metadata, isFlathubSubmission(settings, targets));
+    const templates = renderMetadata(settings);
 
     if (!options.shouldSkipBuild) {
         info(`Building ${options.entry}`);
-        await buildApp({ entry: options.entry, vite: { root: options.cwd } });
+
+        await buildApp({
+            entry: options.entry,
+            vite: { root: options.cwd },
+        });
+
+        await synchronizeMetadataCatalogs(settings, templates, project);
+    } else if (project !== null) {
+        compileCatalogs(project, join(settings.paths.dist, LOCALE_DIRNAME));
     }
 
+    const metadata = localizeMetadata(templates, project);
+    validateMetadata(settings, metadata, isFlathubSubmission(settings, targets));
     const buildManifest = readBuildManifest(settings);
 
     const builtSettings: DeploySettings = {
@@ -262,7 +361,7 @@ const buildPayload = async (
         node,
         stage,
         notices,
-        overlays: stageOverlays(builtSettings, notices),
+        overlays: stageOverlays(builtSettings, notices, metadata),
     };
 };
 
@@ -312,15 +411,31 @@ const announce = (settings: DeploySettings, targets: DeployTarget[]): void => {
 };
 
 const runDeploy = async (options: DeployOptions): Promise<void> => {
+    let settings = await loadSettings(options);
+    let project = resolveCatalogProject(settings.paths.root, settings.applicationId);
+    let targets = targetsFor(resolveTargetNames(options, settings));
+    announce(settings, targets);
+
+    preflight({
+        targets,
+        settings,
+        project,
+        shouldPrintManifests: options.shouldPrintManifests,
+        shouldSkipBuild: options.shouldSkipBuild,
+    });
+
     if (!options.shouldSkipBuild) {
-        await ensureGenerated(options.cwd, { shouldAnnounce: true, mode: BUILD_MODE });
+        await ensureGenerated(options.cwd, {
+            shouldAnnounce: true,
+            mode: BUILD_MODE,
+        });
+
+        settings = await loadSettings(options);
+        project = resolveCatalogProject(settings.paths.root, settings.applicationId);
+        targets = targetsFor(resolveTargetNames(options, settings));
     }
 
-    const settings = await loadSettings(options);
-    const targets = targetsFor(resolveTargetNames(options, settings));
-    announce(settings, targets);
-    preflight(targets, settings, options.shouldPrintManifests);
-    const payload = await buildPayload(options, settings, targets);
+    const payload = await buildPayload(options, settings, targets, project);
     const rendered = renderTargetManifests(targets, payload);
 
     if (options.shouldPrintManifests) {

package/src/deploy/settings/libraries.ts

@@ -6,15 +6,13 @@ import {
     resolveGirPath,
     resolveStore,
 } from "@gtkx/codegen";
+import { resolveFuture } from "@gtkx/config/internal";
 
 type ResolvedLibraries = {
     libraries: string[];
     minimumLibraryVersions: Record<string, string>;
 };
 
-const DEFAULT_LIBRARY = "Gtk-4.0";
-const DEFAULT_LIBRARY_PREFIX = "Gtk-";
-
 const generatedLibraries = (root: string): GeneratedLibraries | null => {
     try {
         return readGeneratedLibraries(resolveStore(root).gi.storeDir);
@@ -23,24 +21,23 @@ const generatedLibraries = (root: string): GeneratedLibraries | null => {
     }
 };
 
-const discoveredLibraries = (config: Config): string[] | null => {
+const discoveredLibraries = (config: Config, isAdwaitaDefault: boolean): string[] | null => {
     try {
-        return expandLibraries(config.libraries, resolveGirPath(config.girPath));
+        return expandLibraries(config.libraries, resolveGirPath(config.girPath), isAdwaitaDefault);
     } catch {
         return null;
     }
 };
 
 const configLibraries = (config: Config): string[] => {
+    const { isAdwaitaDefault } = resolveFuture(config.future);
     const libraries = config.libraries;
 
-    if (!Array.isArray(libraries)) {
-        return discoveredLibraries(config) ?? [DEFAULT_LIBRARY];
+    if (Array.isArray(libraries)) {
+        return expandLibraries(libraries, [], isAdwaitaDefault);
     }
 
-    return libraries.some((library) => library.startsWith(DEFAULT_LIBRARY_PREFIX))
-        ? [...libraries]
-        : [DEFAULT_LIBRARY, ...libraries];
+    return discoveredLibraries(config, isAdwaitaDefault) ?? expandLibraries(undefined, [], isAdwaitaDefault);
 };
 
 const resolveLibraries = (root: string, config: Config): ResolvedLibraries => {

package/src/deploy/targets/flatpak-source.ts

@@ -1,12 +1,10 @@
-import { existsSync, realpathSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { posix, relative, resolve } from "node:path";
 import type { DeployPayload, DeploySettings } from "../types.js";
+import { LOCALE_DIRNAME } from "../../i18n/catalogs.js";
 import { listFilesRecursive } from "../../internal/list-files.js";
 import { BUNDLE_FILENAME } from "../../vite-plugins/esm-extension.js";
 import { renderDbusService } from "../freedesktop/dbus-service.js";
-import { renderDesktopEntry } from "../freedesktop/desktop-entry.js";
-import { renderMetainfo } from "../freedesktop/metainfo.js";
-import { renderMimePackage } from "../freedesktop/mime-package.js";
 import { optional } from "../nfpm/optional.js";
 import { renderNotices } from "../notices/render.js";
 import { executableModeFor } from "../payload/copy-tree.js";
@@ -60,6 +58,7 @@ const installCommand = (source: string, destination: string, mode: string): stri
 
 const runtimeInstallCommands = (settings: DeploySettings, nodeExtensionPath: string): string[] => {
     const lib = `${DESTINATION}/lib/${settings.binaryName}`;
+    const locale = `${DESTINATION}/share/${LOCALE_DIRNAME}`;
 
     return [
         installCommand(`${nodeExtensionPath}/bin/node`, `${lib}/node`, "m755"),
@@ -69,6 +68,7 @@ const runtimeInstallCommands = (settings: DeploySettings, nodeExtensionPath: str
         "test ! -f dist/gschemas.compiled || " +
         installCommand("dist/gschemas.compiled", `${lib}/gschemas.compiled`, "m644"),
         `test ! -d dist/assets || cp -a dist/assets ${lib}/assets`,
+        `test ! -d dist/${LOCALE_DIRNAME} || { mkdir -p ${locale} && cp -a dist/${LOCALE_DIRNAME}/. ${locale}/; }`,
         installCommand(LAUNCHER_FILENAME, `${DESTINATION}/bin/${settings.binaryName}`, "m755"),
     ];
 };
@@ -87,10 +87,35 @@ const activationInstallCommands = (settings: DeploySettings): string[] =>
             )]
         : [];
 
-const mimeSources = (settings: DeploySettings): FlatpakModule[] => {
-    const contents = renderMimePackage(settings);
+const stagedContents = (payload: DeployPayload, destination: string): string => {
+    const file = payload.stage.find((candidate) => candidate.rel === destination);
 
-    return contents === null ? [] : [inlineSource(`${settings.applicationId}.xml`, contents)];
+    if (file === undefined) {
+        throw new Error(`Cannot render the source Flatpak: ${destination} was not staged`);
+    }
+
+    return readFileSync(file.abs, "utf8");
+};
+
+const stagedMetadataSources = (payload: DeployPayload): FlatpakModule[] => {
+    const settings = payload.settings;
+
+    return [
+        inlineSource(
+            `${settings.applicationId}.desktop`,
+            stagedContents(payload, posix.join("share", "applications", `${settings.applicationId}.desktop`)),
+        ),
+        inlineSource(
+            `${settings.applicationId}.metainfo.xml`,
+            stagedContents(payload, posix.join("share", "metainfo", `${settings.applicationId}.metainfo.xml`)),
+        ),
+        ...(settings.fileAssociations.length === 0
+            ? []
+            : [inlineSource(
+                    `${settings.applicationId}.xml`,
+                    stagedContents(payload, posix.join("share", "mime", "packages", `${settings.applicationId}.xml`)),
+                )]),
+    ];
 };
 
 const mimeInstallCommands = (settings: DeploySettings): string[] =>
@@ -239,9 +264,7 @@ const flatpakSourceModule = (payload: DeployPayload): FlatpakModule => {
             resolveGitSource(settings),
             ...(pin === null ? [] : pnpmSources(pin, moduleDirFor(settings))),
             GENERATED_SOURCES,
-            inlineSource(`${settings.applicationId}.desktop`, renderDesktopEntry(settings)),
-            inlineSource(`${settings.applicationId}.metainfo.xml`, renderMetainfo(settings)),
-            ...mimeSources(settings),
+            ...stagedMetadataSources(payload),
             inlineSource(LAUNCHER_FILENAME, renderLauncher(settings)),
             inlineSource(NOTICES_FILENAME, renderNotices(settings, payload.notices)),
             ...activationSource(settings),