@gtkx/cli 1.3.0 → 1.5.0

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";
@@ -20,10 +32,11 @@ import { resolveNodeRuntime } from "./node-runtime/index.js";
 import { collectNotices } from "./notices/collect.js";
 import { type StagedMetadata, stageOverlays, stagePayload } from "./payload/stage.js";
 import { DEFAULT_TARGETS, parseTargetList, targetsFor } from "./registry.js";
+import { readBuildManifest } from "./settings/build-manifest.js";
 import { resolveDeploySettings } from "./settings/index.js";
 import { readPackageManifest } from "./settings/package-manifest.js";
 import { missingDeployError } from "./settings/starter.js";
-import { finishArgsFor, hasDisplaySocket } from "./targets/flatpak-manifest.js";
+import { finishArgsFor, hasDisplaySocket, runtimeLabelFor } from "./targets/flatpak-manifest.js";
 import { detectPackageManager } from "./targets/flatpak-sources.js";
 import {
     APPSTREAMCLI,
@@ -31,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 = {
@@ -46,10 +64,20 @@ 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";
 const NETWORK_ARG = "--share=network";
+const APPIMAGE_TARGET = "appimage";
+const FLATPAK_TARGET = "flatpak";
 
 const displayPath = (settings: DeploySettings, path: string): string => relative(settings.paths.root, path);
 const megabytes = (size: number): string => (size / BYTES_PER_MIB).toFixed(1);
@@ -66,7 +94,7 @@ const renderMetadata = (settings: DeploySettings): StagedMetadata => ({
 });
 
 const isFlathubSubmission = (settings: DeploySettings, targets: DeployTarget[]): boolean =>
-    settings.deploy.flatpak?.mode === "source" && targets.some((target) => target.name === "flatpak");
+    settings.deploy.flatpak?.mode === "source" && targets.some((target) => target.name === FLATPAK_TARGET);
 
 const validateMetadata = (settings: DeploySettings, metadata: StagedMetadata, areWarningsFatal: boolean): void => {
     const dir = settings.paths.metadata;
@@ -104,7 +132,7 @@ const warnMissingNetwork = (settings: DeploySettings, finishArgs: string[]): voi
 };
 
 const warnFlatpakPermissions = (targets: DeployTarget[], settings: DeploySettings): void => {
-    if (targets.every((target) => target.name !== "flatpak")) {
+    if (targets.every((target) => target.name !== FLATPAK_TARGET)) {
         return;
     }
 
@@ -113,10 +141,68 @@ const warnFlatpakPermissions = (targets: DeployTarget[], settings: DeploySetting
     warnMissingNetwork(settings, finishArgs);
 };
 
+const minimumSummary = (settings: DeploySettings): string =>
+    settings.libraries
+        .filter((library) => settings.minimumLibraryVersions[library] !== undefined)
+        .map((library) => `${library} >= ${String(settings.minimumLibraryVersions[library])}`)
+        .join(", ");
+
+const warnAppImageMinimums = (settings: DeploySettings, summary: string): void => {
+    warn(
+        `An AppImage cannot declare a dependency, so nothing stops ${settings.name} from starting on a host ` +
+        `whose libraries are older than the ones its bindings were generated against (${summary}). ` +
+        "Publish that requirement alongside the AppImage, or build on the oldest host you support.",
+    );
+};
+
+const warnFlatpakMinimums = (settings: DeploySettings, summary: string): void => {
+    warn(
+        `The flatpak bundles binaries built against ${summary}, but runs them on ` +
+        `${runtimeLabelFor(settings)}, whose libraries are whatever that runtime ships. ` +
+        'Set `deploy.flatpak.mode: "source"` to build inside the runtime instead.',
+    );
+};
+
+const warnUnusedMinimums = (settings: DeploySettings): void => {
+    const minimums = settings.deploy.minimumLibraryVersions;
+
+    if (minimums === undefined) {
+        return;
+    }
+
+    const unused = Object.keys(minimums).filter((library) => !settings.libraries.includes(library));
+
+    if (unused.length === 0) {
+        return;
+    }
+
+    warn(
+        `\`deploy.minimumLibraryVersions\` names ${unused.join(", ")}, which this project generates no bindings for, ` +
+        "so those minimums change nothing.",
+    );
+};
+
+const isPrebuiltFlatpak = (targets: DeployTarget[], settings: DeploySettings): boolean =>
+    targets.some((target) => target.name === FLATPAK_TARGET) && settings.deploy.flatpak?.mode !== "source";
+
+const warnLibraryMinimums = (targets: DeployTarget[], settings: DeploySettings): void => {
+    const summary = minimumSummary(settings);
+
+    if (summary.length > 0 && targets.some((target) => target.name === APPIMAGE_TARGET)) {
+        warnAppImageMinimums(settings, summary);
+    }
+
+    if (summary.length > 0 && isPrebuiltFlatpak(targets, settings)) {
+        warnFlatpakMinimums(settings, summary);
+    }
+
+    warnUnusedMinimums(settings);
+};
+
 const sourceModeTools = (targets: DeployTarget[], settings: DeploySettings): DeployTool[] => {
     const isFlatpakSource = settings.deploy.flatpak?.mode === "source";
 
-    if (!isFlatpakSource || targets.every((target) => target.name !== "flatpak")) {
+    if (!isFlatpakSource || targets.every((target) => target.name !== FLATPAK_TARGET)) {
         return [];
     }
 
@@ -124,7 +210,7 @@ const sourceModeTools = (targets: DeployTarget[], settings: DeploySettings): Dep
 };
 
 const isNodeRequired = (targets: DeployTarget[], settings: DeploySettings): boolean =>
-    !(settings.deploy.flatpak?.mode === "source" && targets.every((target) => target.name === "flatpak"));
+    !(settings.deploy.flatpak?.mode === "source" && targets.every((target) => target.name === FLATPAK_TARGET));
 
 const runtimeToolsFor = (targets: DeployTarget[], settings: DeploySettings): DeployTool[] => {
     if (!isNodeRequired(targets, settings)) {
@@ -137,16 +223,55 @@ 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);
     warnFlatpakPermissions(targets, settings);
+    warnLibraryMinimums(targets, settings);
 };
 
 const resolveTargetNames = (options: DeployOptions, settings: DeploySettings): string[] => {
@@ -167,28 +292,77 @@ 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 node = options.shouldPrintManifests || !isNodeRequired(targets, settings)
-        ? null
-        : await resolveNodeRuntime(settings);
+    const metadata = localizeMetadata(templates, project);
+    validateMetadata(settings, metadata, isFlathubSubmission(settings, targets));
+    const buildManifest = readBuildManifest(settings);
 
-    const stage = stagePayload({ settings, node, metadata });
-    info(`Staged ${String(stage.length)} files into ${displayPath(settings, settings.paths.stage)}`);
-    const notices = collectNotices({ settings, node });
+    const builtSettings: DeploySettings = {
+        ...settings,
+        paths: { ...settings.paths, schemaFiles: buildManifest.schemaFiles },
+    };
 
-    return { settings, node, stage, notices, overlays: stageOverlays(settings, notices) };
+    const node = options.shouldPrintManifests || !isNodeRequired(targets, builtSettings)
+        ? null
+        : await resolveNodeRuntime(builtSettings);
+
+    const stage = stagePayload({ settings: builtSettings, node, metadata });
+    info(`Staged ${String(stage.length)} files into ${displayPath(builtSettings, builtSettings.paths.stage)}`);
+    const notices = collectNotices({ settings: builtSettings, node, packages: buildManifest.packages });
+
+    return {
+        settings: builtSettings,
+        node,
+        stage,
+        notices,
+        overlays: stageOverlays(builtSettings, notices, metadata),
+    };
 };
 
 const renderTargetManifests = (
@@ -237,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/build-manifest.ts

@@ -0,0 +1,122 @@
+import { isRecord, sortStrings } from "@gtkx/utils";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import type { DeploySettings } from "../types.js";
+import {
+    BUILD_MANIFEST_FILENAME,
+    BUILD_MANIFEST_FORMAT_VERSION,
+    BUILD_MANIFEST_GENERATOR,
+    type BuildManifest,
+    type RecordedPackage,
+} from "../../internal/build-manifest.js";
+import {
+    assertUniqueSchemaBasenames,
+    projectRelativeSchemaPath,
+    SCHEMA_SUFFIX,
+} from "../../settings/schema.js";
+
+type ResolvedBuildManifest = {
+    packages: RecordedPackage[];
+    schemaFiles: string[];
+};
+
+const invalidManifest = (path: string): Error =>
+    new Error(`Cannot deploy: ${path} is not a valid GTKX build manifest. Run \`gtkx build\` again.`);
+
+const recordedSchemas = (value: unknown[], path: string): string[] =>
+    value.map((entry) => {
+        if (typeof entry !== "string") {
+            throw invalidManifest(path);
+        }
+
+        return entry;
+    });
+
+const recordedPackage = (value: unknown, path: string): RecordedPackage => {
+    if (
+        !isRecord(value) ||
+        typeof value.name !== "string" ||
+        typeof value.dir !== "string" ||
+        isAbsolute(value.dir) ||
+        (value.version !== null && typeof value.version !== "string")
+    ) {
+        throw invalidManifest(path);
+    }
+
+    return { name: value.name, version: value.version, dir: value.dir };
+};
+
+const parseBuildManifest = (value: unknown, path: string): BuildManifest => {
+    if (
+        !isRecord(value) ||
+        value.generator !== BUILD_MANIFEST_GENERATOR ||
+        value.formatVersion !== BUILD_MANIFEST_FORMAT_VERSION ||
+        !Array.isArray(value.schemas) ||
+        !Array.isArray(value.packages)
+    ) {
+        throw invalidManifest(path);
+    }
+
+    const packages: unknown[] = value.packages;
+
+    return {
+        generator: BUILD_MANIFEST_GENERATOR,
+        formatVersion: BUILD_MANIFEST_FORMAT_VERSION,
+        schemas: recordedSchemas(value.schemas, path),
+        packages: packages.map((entry) => recordedPackage(entry, path)),
+    };
+};
+
+const isFile = (path: string): boolean => {
+    try {
+        return statSync(path, { throwIfNoEntry: false })?.isFile() === true;
+    } catch {
+        return false;
+    }
+};
+
+const isInsideProject = (root: string, filePath: string): boolean => {
+    const rel = relative(root, filePath);
+
+    return rel.length > 0 && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+};
+
+const resolveRecordedSchema = (root: string, manifestPath: string, entry: string): string => {
+    if (isAbsolute(entry) || !entry.endsWith(SCHEMA_SUFFIX)) {
+        throw new Error(`Cannot deploy: ${manifestPath} records an invalid GSettings schema path.`);
+    }
+
+    const filePath = resolve(root, entry);
+
+    if (!isInsideProject(root, filePath)) {
+        throw new Error(`Cannot deploy: ${manifestPath} records a GSettings schema outside the project.`);
+    }
+
+    if (!isFile(filePath)) {
+        throw new Error(`Cannot deploy: the recorded GSettings schema ${filePath} is missing.`);
+    }
+
+    if (projectRelativeSchemaPath(root, filePath) === null) {
+        throw new Error(`Cannot deploy: ${manifestPath} records a GSettings schema outside the project.`);
+    }
+
+    return filePath;
+};
+
+const readBuildManifest = (settings: DeploySettings): ResolvedBuildManifest => {
+    const manifestPath = join(settings.paths.dist, BUILD_MANIFEST_FILENAME);
+
+    if (!existsSync(manifestPath)) {
+        throw new Error(`Cannot deploy: ${manifestPath} is missing. Run \`gtkx build\` first.`);
+    }
+
+    const parsed: unknown = JSON.parse(readFileSync(manifestPath, "utf8"));
+    const manifest = parseBuildManifest(parsed, manifestPath);
+    const files = manifest.schemas.map((entry) => resolveRecordedSchema(settings.paths.root, manifestPath, entry));
+    const unique = sortStrings(new Set(files));
+    assertUniqueSchemaBasenames(unique);
+
+    return { packages: manifest.packages, schemaFiles: unique };
+};
+
+export { readBuildManifest };

package/src/deploy/settings/index.ts

@@ -22,6 +22,7 @@ import {
     resolveSummary,
     resolveVersionString,
 } from "./identity.js";
+import { resolveLibraries } from "./libraries.js";
 import { readPackageManifest } from "./package-manifest.js";
 import { resolvePaths } from "./paths.js";
 import { resolveScreenshots } from "./screenshots.js";
@@ -113,8 +114,6 @@ const resolveDesktopActions = (deploy: DeployConfig): DeployDesktopAction[] =>
         icon: action.icon ?? null,
     }));
 
-const resolveLibraries = (config: Config): string[] => (Array.isArray(config.libraries) ? config.libraries : []);
-
 const identitySlice = ({ identity, developer, date }: ResolvedCore): IdentitySlice => ({
     applicationId: identity.applicationId,
     binaryName: resolveBinaryName(identity),
@@ -181,8 +180,14 @@ const resolveDeploySettings = (request: SettingsRequest): DeploySettings => {
         extraFiles: resolveExtraFiles(deploy),
         versions: core.versions,
         arch: resolveArch(),
-        paths: resolvePaths({ root: request.root, deploy, outDirOverride: request.outDirOverride }),
-        libraries: resolveLibraries(request.config),
+        paths: resolvePaths({
+            root: request.root,
+            deploy,
+            applicationIcon: request.config.applicationIcon,
+            applicationId: request.config.applicationId,
+            outDirOverride: request.outDirOverride,
+        }),
+        ...resolveLibraries(request.root, request.config),
         deploy,
     };
 };

package/src/deploy/settings/libraries.ts

@@ -0,0 +1,57 @@
+import type { Config } from "@gtkx/config";
+import {
+    resolveLibraries as expandLibraries,
+    type GeneratedLibraries,
+    readGeneratedLibraries,
+    resolveGirPath,
+    resolveStore,
+} from "@gtkx/codegen";
+
+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);
+    } catch {
+        return null;
+    }
+};
+
+const discoveredLibraries = (config: Config): string[] | null => {
+    try {
+        return expandLibraries(config.libraries, resolveGirPath(config.girPath));
+    } catch {
+        return null;
+    }
+};
+
+const configLibraries = (config: Config): string[] => {
+    const libraries = config.libraries;
+
+    if (!Array.isArray(libraries)) {
+        return discoveredLibraries(config) ?? [DEFAULT_LIBRARY];
+    }
+
+    return libraries.some((library) => library.startsWith(DEFAULT_LIBRARY_PREFIX))
+        ? [...libraries]
+        : [DEFAULT_LIBRARY, ...libraries];
+};
+
+const resolveLibraries = (root: string, config: Config): ResolvedLibraries => {
+    const generated = generatedLibraries(root);
+    const libraries = generated?.libraries ?? configLibraries(config);
+    const deploy = config.deploy ?? {};
+
+    return {
+        libraries,
+        minimumLibraryVersions: deploy.minimumLibraryVersions ?? {},
+    };
+};
+
+export { resolveLibraries };

package/src/deploy/settings/paths.ts

@@ -1,23 +1,19 @@
-import { type Stats, statSync } from "node:fs";
+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 { resolveDataDir } from "../../internal/data-dir.js";
-import { findSchemaFiles } from "../../settings/schema.js";
+import { resolveApplicationIcon } from "../../internal/icon-path.js";
 
 type PathsRequest = {
     root: string;
     deploy: DeployConfig;
+    applicationIcon: Config["applicationIcon"];
+    applicationId: Config["applicationId"];
     outDirOverride: string | undefined;
 };
 
-type ResolvedIcons = {
-    iconsDir: string | null;
-    iconFile: string | null;
-};
-
 const DEFAULT_OUT_DIR = "build";
 const DIST_DIR = "dist";
-const ICONS_DIR = "icons";
 const LICENSE_CANDIDATES = ["LICENSE", "LICENSE.md", "LICENSE.txt", "COPYING", "COPYING.md"];
 
 const isInside = (parent: string, candidate: string): boolean => {
@@ -37,17 +33,14 @@ const resolveOutDir = ({ root, deploy, outDirOverride }: PathsRequest): string =
     return outDir;
 };
 
-const getStats = (path: string): Stats | undefined => {
+const existingFile = (path: string): string | null => {
     try {
-        return statSync(path, { throwIfNoEntry: false });
+        return statSync(path, { throwIfNoEntry: false })?.isFile() === true ? path : null;
     } catch {
-        return undefined;
+        return null;
     }
 };
 
-const existingFile = (path: string): string | null => (getStats(path)?.isFile() === true ? path : null);
-const existingDir = (path: string): string | null => (getStats(path)?.isDirectory() === true ? path : null);
-
 const resolveLicenseFile = (root: string, configured: string | undefined): string | null => {
     if (configured !== undefined) {
         const path = resolve(root, configured);
@@ -62,37 +55,9 @@ const resolveLicenseFile = (root: string, configured: string | undefined): strin
     return LICENSE_CANDIDATES.map((name) => existingFile(join(root, name))).find((path) => path !== null) ?? null;
 };
 
-const configuredIcons = (root: string, configured: string): ResolvedIcons => {
-    const path = resolve(root, configured);
-
-    if (!isInside(root, path)) {
-        throw new Error(`Cannot use "${configured}" as the icon path: it is outside ${root}`);
-    }
-
-    if (existingDir(path) !== null) {
-        return { iconsDir: path, iconFile: null };
-    }
-
-    if (existingFile(path) === null) {
-        throw new Error(`Cannot read the icon path "${configured}": no such file or directory under ${root}`);
-    }
-
-    return { iconsDir: null, iconFile: path };
-};
-
-const defaultIcons = (root: string, dataDir: string | null): ResolvedIcons => ({
-    iconsDir: dataDir === null ? null : existingDir(join(root, dataDir, ICONS_DIR)),
-    iconFile: null,
-});
-
-const resolveIcons = (root: string, dataDir: string | null, configured: string | undefined): ResolvedIcons =>
-    configured === undefined ? defaultIcons(root, dataDir) : configuredIcons(root, configured);
-
 const resolvePaths = (request: PathsRequest): DeployPaths => {
     const { root, deploy } = request;
     const outDir = resolveOutDir(request);
-    const dataDir = resolveDataDir(root);
-    const { iconsDir, iconFile } = resolveIcons(root, dataDir, deploy.icons);
 
     return {
         root,
@@ -104,11 +69,9 @@ const resolvePaths = (request: PathsRequest): DeployPaths => {
         overlay: join(outDir, "overlay"),
         targets: join(outDir, "targets"),
         output: join(outDir, "out"),
-        dataDir,
-        iconsDir,
-        iconFile,
+        applicationIcon: resolveApplicationIcon(root, request.applicationId, request.applicationIcon),
         licenseFile: resolveLicenseFile(root, deploy.licenseFile),
-        schemaFiles: dataDir === null ? [] : findSchemaFiles(join(root, dataDir)),
+        schemaFiles: [],
     };
 };