@gtkx/cli 1.6.0 → 2.0.0-beta.10

package/src/deploy/settings/index.ts

@@ -1,5 +1,6 @@
 import type { Config } from "@gtkx/config";
 import type {
+    DeployArchName,
     DeployConfig,
     DeployDesktopAction,
     DeployDeveloper,
@@ -31,6 +32,8 @@ import { resolveVersions } from "./version.js";
 type SettingsRequest = {
     root: string;
     config: Config;
+    configFile: string;
+    arch: DeployArchName;
     outDirOverride?: string | undefined;
     now?: Date | undefined;
 };
@@ -174,18 +177,20 @@ const resolveDeploySettings = (request: SettingsRequest): DeploySettings => {
     const deploy = core.identity.deploy;
 
     return {
+        configFile: request.configFile,
         ...identitySlice(core),
         ...metadataSlice(request.root, core),
         ...desktopSlice(deploy),
-        extraFiles: resolveExtraFiles(deploy),
+        extraFiles: resolveExtraFiles(request.root, deploy),
         versions: core.versions,
-        arch: resolveArch(),
+        arch: resolveArch(request.arch),
         paths: resolvePaths({
             root: request.root,
             deploy,
             applicationIcon: request.config.applicationIcon,
             applicationId: request.config.applicationId,
             outDirOverride: request.outDirOverride,
+            arch: request.arch,
         }),
         ...resolveLibraries(request.root, request.config),
         deploy,

package/src/deploy/settings/libraries.ts

@@ -3,10 +3,9 @@ import {
     resolveLibraries as expandLibraries,
     type GeneratedLibraries,
     readGeneratedLibraries,
-    resolveGirPath,
     resolveStore,
 } from "@gtkx/codegen";
-import { resolveFuture } from "@gtkx/config/internal";
+import { resolveBoundLibraries } from "@gtkx/codegen/internal";
 
 type ResolvedLibraries = {
     libraries: string[];
@@ -21,28 +20,9 @@ const generatedLibraries = (root: string): GeneratedLibraries | null => {
     }
 };
 
-const discoveredLibraries = (config: Config, isAdwaitaDefault: boolean): string[] | null => {
-    try {
-        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 expandLibraries(libraries, [], isAdwaitaDefault);
-    }
-
-    return discoveredLibraries(config, isAdwaitaDefault) ?? expandLibraries(undefined, [], isAdwaitaDefault);
-};
-
 const resolveLibraries = (root: string, config: Config): ResolvedLibraries => {
     const generated = generatedLibraries(root);
-    const libraries = generated?.libraries ?? configLibraries(config);
+    const libraries = resolveBoundLibraries(generated?.libraries ?? expandLibraries(config.libraries));
     const deploy = config.deploy ?? {};
 
     return {

package/src/deploy/settings/paths.ts

@@ -1,8 +1,11 @@
 import type { Config } from "@gtkx/config";
-import { statSync } from "node:fs";
-import { isAbsolute, join, relative, resolve } from "node:path";
-import type { DeployConfig, DeployPaths } from "../types.js";
+import { isPathInside } from "@gtkx/utils";
+import { lstatSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+import type { DeployArchName, DeployConfig, DeployPaths } from "../types.js";
+import { DEFAULT_DEPLOY_OUT_DIR } from "../../internal/deploy-out-dir.js";
 import { resolveApplicationIcon } from "../../internal/icon-path.js";
+import { prepareOutputDirectory, readRegularFile } from "../../internal/output-directory.js";
 
 type PathsRequest = {
     root: string;
@@ -10,37 +13,90 @@ type PathsRequest = {
     applicationIcon: Config["applicationIcon"];
     applicationId: Config["applicationId"];
     outDirOverride: string | undefined;
+    arch: DeployArchName;
 };
 
-const DEFAULT_OUT_DIR = "build";
 const DIST_DIR = "dist";
+const DEPLOY_MARKER_FILENAME = ".gtkx-deploy.json";
+const DEPLOY_MARKER = `${JSON.stringify({ generator: "gtkx-deploy", formatVersion: 1 })}\n`;
 const LICENSE_CANDIDATES = ["LICENSE", "LICENSE.md", "LICENSE.txt", "COPYING", "COPYING.md"];
 
-const isInside = (parent: string, candidate: string): boolean => {
-    const rel = relative(parent, candidate);
+const hasSymlinkComponent = (root: string, target: string): boolean => {
+    let current = root;
 
-    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel);
+    for (const segment of relative(root, target).split(sep)) {
+        current = join(current, segment);
+
+        if (lstatSync(current, { throwIfNoEntry: false })?.isSymbolicLink() === true) {
+            return true;
+        }
+    }
+
+    return false;
+};
+
+const isDeployMarker = (path: string): boolean => {
+    return readRegularFile(path) === DEPLOY_MARKER;
+};
+
+const isReusableDeployDirectory = (path: string): boolean => {
+    const entry = lstatSync(path, { throwIfNoEntry: false });
+
+    if (entry === undefined) {
+        return true;
+    }
+
+    return entry.isDirectory() &&
+        (readdirSync(path).length === 0 || isDeployMarker(join(path, DEPLOY_MARKER_FILENAME)));
+};
+
+const deployOutputError = (root: string, configured: string): Error =>
+    new Error(
+        `Cannot use "${configured}" as the deploy output directory: choose an empty directory or an ` +
+        `earlier GTKX deploy directory below ${root}`,
+    );
+
+const assertSafeDeployOutDir = (root: string, outDir: string, configured: string): void => {
+    const dist = join(root, DIST_DIR);
+
+    if (
+        outDir === dist ||
+        !isPathInside(root, outDir) ||
+        isPathInside(dist, outDir) ||
+        hasSymlinkComponent(root, outDir)
+    ) {
+        throw deployOutputError(root, configured);
+    }
 };
 
 const resolveOutDir = ({ root, deploy, outDirOverride }: PathsRequest): string => {
-    const configured = outDirOverride ?? deploy.outDir ?? DEFAULT_OUT_DIR;
+    const configured = outDirOverride ?? deploy.outDir ?? DEFAULT_DEPLOY_OUT_DIR;
     const outDir = resolve(root, configured);
+    assertSafeDeployOutDir(root, outDir, configured);
 
-    if (!isInside(root, outDir)) {
-        throw new Error(`Cannot use "${configured}" as the deploy output directory: it is outside ${root}`);
+    if (!isReusableDeployDirectory(outDir)) {
+        throw deployOutputError(root, configured);
     }
 
     return outDir;
 };
 
-const existingFile = (path: string): string | null => {
-    try {
-        return statSync(path, { throwIfNoEntry: false })?.isFile() === true ? path : null;
-    } catch {
-        return null;
+const prepareDeployOutDir = (root: string, outDir: string): void => {
+    assertSafeDeployOutDir(root, outDir, outDir);
+    const prepared = prepareOutputDirectory(root, outDir, isReusableDeployDirectory);
+
+    if (prepared.status === "unsafe") {
+        throw deployOutputError(root, outDir);
     }
+
+    using transaction = prepared.transaction;
+    transaction.commit();
+    writeFileSync(join(outDir, DEPLOY_MARKER_FILENAME), DEPLOY_MARKER, { flag: "wx" });
 };
 
+const existingFile = (path: string): string | null =>
+    statSync(path, { throwIfNoEntry: false })?.isFile() === true ? path : null;
+
 const resolveLicenseFile = (root: string, configured: string | undefined): string | null => {
     if (configured !== undefined) {
         const path = resolve(root, configured);
@@ -58,16 +114,17 @@ const resolveLicenseFile = (root: string, configured: string | undefined): strin
 const resolvePaths = (request: PathsRequest): DeployPaths => {
     const { root, deploy } = request;
     const outDir = resolveOutDir(request);
+    const archDir = join(outDir, request.arch);
 
     return {
         root,
         dist: join(root, DIST_DIR),
         outDir,
-        metadata: join(outDir, "metadata"),
-        runtime: join(outDir, "runtime"),
-        stage: join(outDir, "stage"),
-        overlay: join(outDir, "overlay"),
-        targets: join(outDir, "targets"),
+        metadata: join(archDir, "metadata"),
+        runtime: join(archDir, "runtime"),
+        stage: join(archDir, "stage"),
+        overlay: join(archDir, "overlay"),
+        targets: join(archDir, "targets"),
         output: join(outDir, "out"),
         applicationIcon: resolveApplicationIcon(root, request.applicationId, request.applicationIcon),
         licenseFile: resolveLicenseFile(root, deploy.licenseFile),
@@ -75,4 +132,4 @@ const resolvePaths = (request: PathsRequest): DeployPaths => {
     };
 };
 
-export { isInside, resolvePaths };
+export { prepareDeployOutDir, resolvePaths };

package/src/deploy/settings/screenshots.ts

@@ -1,3 +1,4 @@
+import hostedGitInfo from "hosted-git-info";
 import type { DeployConfig, DeployScreenshot } from "../types.js";
 import { gitRemoteUrl, runGit } from "../git.js";
 
@@ -6,23 +7,9 @@ type ScreenshotRequest = {
     deploy: DeployConfig;
 };
 
-type RemoteParts = {
-    host: string;
-    owner: string;
-    repo: string;
-};
-
 const DEFAULT_BRANCH = "main";
-const GIT_SUFFIX = ".git";
-const PORTED_HOST = /^([^/]*):\d+(?=\/|$)/;
-const SCHEME_SEPARATOR = "://";
 const TRAILING_SLASH = "/";
 
-const RAW_BASE_BY_HOST: Record<string, (owner: string, repo: string, branch: string) => string> = {
-    "github.com": (owner, repo, branch) => `https://raw.githubusercontent.com/${owner}/${repo}/${branch}`,
-    "gitlab.com": (owner, repo, branch) => `https://gitlab.com/${owner}/${repo}/-/raw/${branch}`,
-};
-
 const readRepositoryPrefix = (root: string): string =>
     trimTrailingSlash(runGit(root, ["rev-parse", "--show-prefix"]) ?? "");
 
@@ -35,29 +22,6 @@ const trimLeadingSlash = (value: string): string => {
     return withoutDot.startsWith(TRAILING_SLASH) ? withoutDot.slice(1) : withoutDot;
 };
 
-const afterMarker = (value: string, marker: string): string => {
-    const index = value.indexOf(marker);
-
-    return index === -1 ? value : value.slice(index + marker.length);
-};
-
-const normalizeLocation = (trimmed: string): string => {
-    const location = afterMarker(afterMarker(trimmed, SCHEME_SEPARATOR), "@");
-
-    return trimmed.includes(SCHEME_SEPARATOR) ? location.replace(PORTED_HOST, "$1") : location.replace(":", "/");
-};
-
-const parseRemote = (remote: string): RemoteParts | null => {
-    const trimmed = remote.endsWith(GIT_SUFFIX) ? remote.slice(0, -GIT_SUFFIX.length) : remote;
-    const [host, owner, repo, ...extra] = normalizeLocation(trimmed).split("/");
-
-    if (repo === undefined || extra.length > 0) {
-        return null;
-    }
-
-    return { host: host ?? "", owner: owner ?? "", repo };
-};
-
 const readDefaultBranch = (root: string): string => {
     const head = runGit(root, ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
 
@@ -70,16 +34,16 @@ const readDefaultBranch = (root: string): string => {
     return separator === -1 ? head : head.slice(separator + 1);
 };
 
-const baseForRemote = (remote: string, branch: string): string | null => {
-    const parts = parseRemote(remote);
+const baseForRemote = (root: string, remote: string): string | null => {
+    const repository = hostedGitInfo.fromUrl(remote);
 
-    if (parts === null) {
+    if (repository === undefined || (repository.type !== "github" && repository.type !== "gitlab")) {
         return null;
     }
 
-    const build = RAW_BASE_BY_HOST[parts.host];
-
-    return build === undefined ? null : build(parts.owner, parts.repo, branch);
+    return trimTrailingSlash(
+        repository.file(readRepositoryPrefix(root), { committish: readDefaultBranch(root) }),
+    );
 };
 
 const resolveScreenshotBaseUrl = ({ root, deploy }: ScreenshotRequest): string | null => {
@@ -88,10 +52,8 @@ const resolveScreenshotBaseUrl = ({ root, deploy }: ScreenshotRequest): string |
     }
 
     const remote = gitRemoteUrl(root);
-    const base = remote === null ? null : baseForRemote(remote, readDefaultBranch(root));
-    const prefix = base === null ? "" : readRepositoryPrefix(root);
 
-    return base === null || prefix.length === 0 ? base : `${base}/${prefix}`;
+    return remote === null ? null : baseForRemote(root, remote);
 };
 
 const urlForScreenshot = (file: string, baseUrl: string | null): string => {

package/src/deploy/targets/appimage.ts

@@ -29,6 +29,7 @@ const EXTRACT_AND_RUN = "APPIMAGE_EXTRACT_AND_RUN";
 const appimageTarget: DeployTarget = {
     name: "appimage",
     prefix: PREFIX,
+    isHostOnly: true,
     tools: [FILE_TOOL],
     render: (payload) => renderManifests(payload),
     pack: (payload) => packAppImage(payload),

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

@@ -9,12 +9,12 @@ type PnpmPin = {
     sha512: string;
 };
 
-const PNPM_VERSION = "11.22.0";
+const PNPM_VERSION = "11.26.0";
 const PNPM_MAJOR = 11;
-const PNPM_MINOR = 22;
+const PNPM_MINOR = 26;
 
-const PNPM_SHA512 = "1ff870c4c6133dfd88fb2afc46dd13d47f09c9794b438c6fdb47ca98caf3bc16381ee0be9" +
-    "3a091b8e3824cf01f889f46d7d9e20910fb0be1ab0fb5baa80dd621";
+const PNPM_SHA512 = "fc0e2bf890b9f983611f1ab68c0637bce914390653699f83c1a78b005ed25f2c81e77920c8" +
+    "fd8eee2ecf0b58b28cdcb00a84d97f69bcf7c56b2f344710238664";
 
 const PNPM_DIR = "flatpak-pnpm";
 const PNPM_COMMAND = "pnpm";

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

@@ -1,7 +1,9 @@
+import { isPathInside, toPosixPath } from "@gtkx/utils";
 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 { FONTS_DIR } from "../../internal/font-path.js";
 import { listFilesRecursive } from "../../internal/list-files.js";
 import { BUNDLE_FILENAME } from "../../vite-plugins/esm-extension.js";
 import { renderDbusService } from "../freedesktop/dbus-service.js";
@@ -11,7 +13,6 @@ import { executableModeFor } from "../payload/copy-tree.js";
 import { iconPathFor } from "../payload/icons.js";
 import { renderLauncher } from "../payload/launcher.js";
 import { licenseDestination, nodeLicenseDestination, NOTICES_FILENAME, noticesDestination } from "../payload/stage.js";
-import { isInside } from "../settings/paths.js";
 import { pnpmPathFor, type PnpmPin, pnpmSources } from "./flatpak-pnpm.js";
 import { DESTINATION, type FlatpakModule, postInstallCommands, validationCommands } from "./flatpak-prebuilt.js";
 import {
@@ -46,7 +47,7 @@ const inlineSource = (fileName: string, contents: string): FlatpakModule => ({
 });
 
 const projectRelative = (settings: DeploySettings, path: string): string =>
-    relative(settings.paths.root, path).replaceAll("\\", "/");
+    toPosixPath(relative(settings.paths.root, path));
 
 const shellArgument = (value: string): string =>
     PLAIN_ARGUMENT.test(value) ? value : `'${value.split("'").join(QUOTE_ESCAPE)}'`;
@@ -68,6 +69,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/${FONTS_DIR} || cp -a dist/${FONTS_DIR} ${lib}/${FONTS_DIR}`,
         `test ! -d dist/${LOCALE_DIRNAME} || { mkdir -p ${locale} && cp -a dist/${LOCALE_DIRNAME}/. ${locale}/; }`,
         installCommand(LAUNCHER_FILENAME, `${DESTINATION}/bin/${settings.binaryName}`, "m755"),
     ];
@@ -155,7 +157,7 @@ const schemaInstallCommands = (settings: DeploySettings): string[] =>
 const iconInstallCommand = (settings: DeploySettings, source: string, rel: string): string =>
     installCommand(
         projectRelative(settings, source),
-        `${DESTINATION}/share/icons/${shellArgument(rel.replaceAll("\\", "/"))}`,
+        `${DESTINATION}/share/icons/${shellArgument(toPosixPath(rel))}`,
         "m644",
     );
 
@@ -177,7 +179,7 @@ const assertInsideProject = (settings: DeploySettings, installed: InstalledFile)
     const { resolved } = installed;
     const target = existsSync(resolved) ? realpathSync(resolved) : resolved;
 
-    if (isInside(settings.paths.root, target)) {
+    if (isPathInside(settings.paths.root, target)) {
         return;
     }
 
@@ -244,6 +246,17 @@ const appendPathFor = (settings: DeploySettings, pin: PnpmPin | null, nodeExtens
         ? `${nodeExtensionPath}/bin`
         : `${pnpmPathFor(moduleDirFor(settings))}:${nodeExtensionPath}/bin`;
 
+const sourceBuildCommand = (settings: DeploySettings): string => {
+    const configFile = projectRelative(settings, settings.configFile);
+    assertInsideProject(settings, {
+        destination: "the Flatpak build configuration",
+        source: configFile,
+        resolved: settings.configFile,
+    });
+
+    return `npx gtkx build --config ${pathArgument(configFile)}`;
+};
+
 const flatpakSourceModule = (payload: DeployPayload): FlatpakModule => {
     const settings = payload.settings;
     const manager = detectPackageManager(settings);
@@ -271,14 +284,14 @@ const flatpakSourceModule = (payload: DeployPayload): FlatpakModule => {
         ],
         "build-commands": [
             installCommandFor(settings, manager),
-            "npx gtkx build",
+            sourceBuildCommand(settings),
             ...runtimeInstallCommands(settings, nodeExtensionPath),
+            ...extraFileInstallCommands(settings),
             ...metadataInstallCommands(settings),
             ...schemaInstallCommands(settings),
             ...iconInstallCommands(settings),
             ...licenseInstallCommands(settings),
             ...noticesInstallCommands(settings),
-            ...extraFileInstallCommands(settings),
             ...(settings.deploy.flatpak?.buildCommands ?? []),
             ...validationCommands(settings),
         ],

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

@@ -26,7 +26,7 @@ type GitRevision = {
 const GENERATED_SOURCES = "generated-sources.json";
 const COMMIT_PEEL = "^{commit}";
 const FETCHABLE_URL = /^https?:\/\//;
-const DEFAULT_NODE_EXTENSION = "org.freedesktop.Sdk.Extension.node24";
+const DEFAULT_NODE_EXTENSION = "org.freedesktop.Sdk.Extension.node26";
 const NODE_EXTENSION_PREFIX = "org.freedesktop.Sdk.Extension.";
 const SDK_EXTENSION_ROOT = "/usr/lib/sdk";
 

package/src/deploy/targets/flatpak.ts

@@ -21,6 +21,7 @@ const BUILDER_REF = "org.flatpak.Builder";
 const flatpakTarget: DeployTarget = {
     name: "flatpak",
     prefix: PREFIX,
+    isHostOnly: true,
     tools: [FLATPAK, FLATPAK_BUILDER, DESKTOP_FILE_VALIDATE, APPSTREAMCLI],
     render: (payload) => renderManifests(payload),
     pack: (payload) => Promise.try(() => packFlatpak(payload)),

package/src/deploy/targets/nfpm-target.ts

@@ -1,7 +1,8 @@
+import { info } from "@gtkx/utils";
 import { join } from "node:path";
 import { stringify } from "yaml";
 import type { DeployArtifact, DeployManifest, DeployPayload, DeployTarget } from "../types.js";
-import { type NfpmPackager, renderNfpmConfig } from "../nfpm/config.js";
+import { glibcMinimumForPackage, type NfpmPackager, renderNfpmConfig } from "../nfpm/config.js";
 import { packWithNfpm } from "../nfpm/pack.js";
 import { TAR } from "../tools.js";
 
@@ -11,12 +12,18 @@ const PREFIX = "/usr";
 const manifestPathFor = (payload: DeployPayload, packager: NfpmPackager): string =>
     join(payload.settings.paths.targets, packager, MANIFEST_FILENAME);
 
-const renderManifests = (payload: DeployPayload, packager: NfpmPackager): DeployManifest[] => [
-    {
+const renderManifests = (payload: DeployPayload, packager: NfpmPackager): DeployManifest[] => {
+    const glibcMinimum = glibcMinimumForPackage(payload, packager);
+
+    if (glibcMinimum !== null) {
+        info(`${packager} package requires glibc >= ${glibcMinimum}`);
+    }
+
+    return [{
         path: manifestPathFor(payload, packager),
-        contents: stringify(renderNfpmConfig(payload, packager), { lineWidth: 0 }),
-    },
-];
+        contents: stringify(renderNfpmConfig(payload, packager, glibcMinimum), { lineWidth: 0 }),
+    }];
+};
 
 const packPackage = async (payload: DeployPayload, packager: NfpmPackager): Promise<DeployArtifact[]> => [
     await packWithNfpm(payload, packager, manifestPathFor(payload, packager)),
@@ -25,6 +32,7 @@ const packPackage = async (payload: DeployPayload, packager: NfpmPackager): Prom
 const nfpmTarget = (packager: NfpmPackager): DeployTarget => ({
     name: packager,
     prefix: PREFIX,
+    isHostOnly: false,
     tools: [TAR],
     render: (payload) => renderManifests(payload, packager),
     pack: (payload) => packPackage(payload, packager),

package/src/deploy/types.ts

@@ -2,6 +2,7 @@ import type { Config } from "@gtkx/config";
 import type { ResolvedApplicationIcon } from "../internal/icon-path.js";
 
 type DeployConfig = NonNullable<Config["deploy"]>;
+type DeployArchName = NonNullable<DeployConfig["architectures"]>[number];
 type DeployTargetName = NonNullable<DeployConfig["targets"]>[number];
 type PackageFamily = "arch" | "debian" | "fedora" | "suse" | "unknown";
 
@@ -94,7 +95,7 @@ type DeployArch = {
     rpm: string;
     flatpak: string;
     appimage: string;
-    node: string;
+    node: DeployArchName;
 };
 
 type DeployPaths = {
@@ -114,6 +115,7 @@ type DeployPaths = {
 
 type DeploySettings = {
     applicationId: string;
+    configFile: string;
     binaryName: string;
     name: string;
     genericName: string | null;
@@ -169,6 +171,7 @@ type DeployArtifact = {
 type DeployTarget = {
     name: DeployTargetName;
     prefix: string;
+    isHostOnly: boolean;
     tools: DeployTool[];
     render: (payload: DeployPayload) => DeployManifest[];
     pack: (payload: DeployPayload, manifests: DeployManifest[]) => Promise<DeployArtifact[]>;
@@ -176,6 +179,7 @@ type DeployTarget = {
 
 export type {
     DeployArch,
+    DeployArchName,
     DeployArtifact,
     DeployConfig,
     DeployDesktopAction,

package/src/deploy/vendored/appimagetool.ts

@@ -39,7 +39,7 @@ const resolveAppimageTooling = async (arch: string): Promise<AppimageTooling> =>
         url: `${APPIMAGETOOL_URL}/appimagetool-${arch}.AppImage`,
         dest: join(dir, `appimagetool-${arch}`),
         label: `appimagetool ${APPIMAGETOOL_VERSION}`,
-        sha256: digestFor(APPIMAGETOOL_DIGESTS, arch, "appimagetool"),
+        digest: digestFor(APPIMAGETOOL_DIGESTS, arch, "appimagetool"),
         mode: EXECUTABLE_MODE,
     });
 
@@ -47,7 +47,7 @@ const resolveAppimageTooling = async (arch: string): Promise<AppimageTooling> =>
         url: `${RUNTIME_URL}/runtime-${arch}`,
         dest: join(dir, `runtime-${arch}`),
         label: `the AppImage runtime ${RUNTIME_VERSION}`,
-        sha256: digestFor(RUNTIME_DIGESTS, arch, "the AppImage runtime"),
+        digest: digestFor(RUNTIME_DIGESTS, arch, "the AppImage runtime"),
         mode: EXECUTABLE_MODE,
     });
 

package/src/deploy/vendored/nfpm.ts

@@ -56,7 +56,7 @@ const downloadNfpm = async (dir: string, binary: string): Promise<string> => {
         url: `${NFPM_BASE_URL}/${assetName}`,
         dest: join(dir, assetName),
         label: `nfpm ${NFPM_VERSION}`,
-        sha256: digestFor(process.arch),
+        digest: digestFor(process.arch),
     });
 
     extractNfpm(archive, binary);

package/src/dev/catalog-writes.ts

@@ -0,0 +1,35 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import type { WrittenCatalog } from "../i18n/catalogs.js";
+
+type CatalogWrites = {
+    record: (catalogs: WrittenCatalog[]) => void;
+    hasWritten: (path: string) => boolean;
+};
+
+const hasContent = (path: string, content: Buffer): boolean => {
+    try {
+        return readFileSync(path).equals(content);
+    } catch {
+        return false;
+    }
+};
+
+const createCatalogWrites = (): CatalogWrites => {
+    const contents: Map<string, Buffer> = new Map();
+
+    return {
+        record: (catalogs) => {
+            for (const catalog of catalogs) {
+                contents.set(resolve(catalog.path), catalog.content);
+            }
+        },
+        hasWritten: (path) => {
+            const content = contents.get(resolve(path));
+
+            return content !== undefined && hasContent(path, content);
+        },
+    };
+};
+
+export { type CatalogWrites, createCatalogWrites };

package/src/dev/entry-env.ts

@@ -1,3 +1,4 @@
 const DEV_ENTRY_ENV = "GTKX_DEV_ENTRY";
+const DEV_CONFIG_ENV = "GTKX_DEV_CONFIG";
 
-export { DEV_ENTRY_ENV };
+export { DEV_CONFIG_ENV, DEV_ENTRY_ENV };

package/src/dev/font-dir.ts

@@ -0,0 +1,11 @@
+import { stageProjectFonts } from "../internal/font-staging.js";
+import { prependXdgDataDir } from "../internal/xdg-data-dirs.js";
+
+const prepareDevFontDir = (root: string): string => {
+    const shareDir = stageProjectFonts(root);
+    process.env.XDG_DATA_DIRS = prependXdgDataDir(shareDir, process.env.XDG_DATA_DIRS);
+
+    return shareDir;
+};
+
+export { prepareDevFontDir };

package/src/dev/headless.ts

@@ -0,0 +1,40 @@
+import { MCP_SOCKET_PATH_ENV, resolveMcpSocketPath } from "@gtkx/mcp/internal";
+import { resolveHeadlessOptions, startHeadlessDisplay } from "@gtkx/vitest/headless";
+
+const restoreEnvironment = (name: string, value: string | undefined): void => {
+    if (value === undefined) {
+        Reflect.deleteProperty(process.env, name);
+    } else {
+        process.env[name] = value;
+    }
+};
+
+const startHeadlessDevDisplay = async (size?: string): Promise<() => void> => {
+    const previousSocketPath = process.env[MCP_SOCKET_PATH_ENV];
+    process.env[MCP_SOCKET_PATH_ENV] = resolveMcpSocketPath();
+
+    try {
+        const stopDisplay = await startHeadlessDisplay(resolveHeadlessOptions({ ...(size !== undefined && { size }) }));
+        let isStopped = false;
+
+        const stop = (): void => {
+            if (isStopped) {
+                return;
+            }
+
+            isStopped = true;
+            process.removeListener("exit", stop);
+            stopDisplay();
+            restoreEnvironment(MCP_SOCKET_PATH_ENV, previousSocketPath);
+        };
+
+        process.once("exit", stop);
+
+        return stop;
+    } catch (error) {
+        restoreEnvironment(MCP_SOCKET_PATH_ENV, previousSocketPath);
+        throw error;
+    }
+};
+
+export { startHeadlessDevDisplay };