@gtkx/cli 1.2.2 → 1.4.0

package/src/deploy/depends.ts

@@ -1,41 +1,70 @@
-import type { DeployConfig } from "./types.js";
+import type { DeploySettings } from "./types.js";
 
 type Relations = {
     deb: string[];
     rpm: string[];
 };
 
-const GLES_SONAME = "libGLESv2.so.2()(64bit)";
+type LibraryPackages = {
+    deb: string;
+    rpm: string;
+    extra: Relations;
+};
+
+const SONAME_SUFFIX = "()(64bit)";
+const GLES_SONAME = `libGLESv2.so.2${SONAME_SUFFIX}`;
+const NO_EXTRA: Relations = { deb: [], rpm: [] };
 
 const BASE_DEPENDS: Relations = {
     deb: ["hicolor-icon-theme", "adwaita-icon-theme", "gsettings-desktop-schemas"],
     rpm: ["hicolor-icon-theme", "adwaita-icon-theme", "gsettings-desktop-schemas"],
 };
 
-const DEPENDS_BY_LIBRARY: Record<string, Relations> = {
-    "Adw-1": { deb: ["libadwaita-1-0"], rpm: ["libadwaita"] },
-    "Gtk-4.0": { deb: ["libgtk-4-1"], rpm: ["gtk4", GLES_SONAME] },
-    "GtkSource-5": { deb: ["libgtksourceview-5-0"], rpm: ["gtksourceview5"] },
-    "WebKit-6.0": { deb: ["libwebkitgtk-6.0-4"], rpm: ["webkitgtk6.0"] },
+const DEPENDS_BY_LIBRARY: Record<string, LibraryPackages> = {
+    "Adw-1": { deb: "libadwaita-1-0", rpm: "libadwaita", extra: NO_EXTRA },
+    "Gtk-4.0": { deb: "libgtk-4-1", rpm: "gtk4", extra: { deb: [], rpm: [GLES_SONAME] } },
 };
 
-const libraryDepends = (libraries: string[]): Relations => ({
-    deb: libraries.flatMap((library) => DEPENDS_BY_LIBRARY[library]?.deb ?? []),
-    rpm: libraries.flatMap((library) => DEPENDS_BY_LIBRARY[library]?.rpm ?? []),
-});
+const debRelation = (name: string, minimum: string | undefined): string =>
+    minimum === undefined ? name : `${name} (>= ${minimum})`;
+
+const rpmRelation = (name: string, minimum: string | undefined): string =>
+    minimum === undefined ? name : `${name} >= ${minimum}`;
+
+const libraryDepends = (settings: DeploySettings): Relations => {
+    const deb: string[] = [];
+    const rpm: string[] = [];
+
+    for (const library of settings.libraries) {
+        const packages = DEPENDS_BY_LIBRARY[library];
+
+        if (packages === undefined) {
+            continue;
+        }
+
+        const minimum = settings.minimumLibraryVersions[library];
+        deb.push(debRelation(packages.deb, minimum), ...packages.extra.deb);
+        rpm.push(rpmRelation(packages.rpm, minimum), ...packages.extra.rpm);
+    }
+
+    return { deb, rpm };
+};
 
-const glibcDepends = (glibcFloor: string | null): Relations =>
-    glibcFloor === null ? { deb: [], rpm: [] } : { deb: [`libc6 (>= ${glibcFloor})`], rpm: [`glibc >= ${glibcFloor}`] };
+const glibcDepends = (glibcMinimum: string | null): Relations =>
+    glibcMinimum === null
+        ? { deb: [], rpm: [] }
+        : { deb: [debRelation("libc6", glibcMinimum)], rpm: [rpmRelation("glibc", glibcMinimum)] };
 
 const dedupe = (entries: string[]): string[] => [...new Set(entries)];
 
-const resolveDepends = (deploy: DeployConfig, libraries: string[], glibcFloor: string | null): Relations => {
-    const fromLibraries = libraryDepends(libraries);
-    const fromGlibc = glibcDepends(glibcFloor);
+const resolveDepends = (settings: DeploySettings, glibcMinimum: string | null): Relations => {
+    const fromLibraries = libraryDepends(settings);
+    const fromGlibc = glibcDepends(glibcMinimum);
+    const extra = settings.deploy.depends ?? {};
 
     return {
-        deb: dedupe([...fromLibraries.deb, ...BASE_DEPENDS.deb, ...fromGlibc.deb, ...(deploy.depends?.deb ?? [])]),
-        rpm: dedupe([...fromLibraries.rpm, ...BASE_DEPENDS.rpm, ...fromGlibc.rpm, ...(deploy.depends?.rpm ?? [])]),
+        deb: dedupe([...fromLibraries.deb, ...BASE_DEPENDS.deb, ...fromGlibc.deb, ...(extra.deb ?? [])]),
+        rpm: dedupe([...fromLibraries.rpm, ...BASE_DEPENDS.rpm, ...fromGlibc.rpm, ...(extra.rpm ?? [])]),
     };
 };
 

package/src/deploy/nfpm/config.ts

@@ -125,7 +125,7 @@ const descriptionFor = (settings: DeploySettings, packager: NfpmPackager): strin
 const renderNfpmConfig = (payload: DeployPayload, packager: NfpmPackager): NfpmConfig => {
     const settings = payload.settings;
     const isRpm = packager === "rpm";
-    const depends = resolveDepends(settings.deploy, settings.libraries, payload.node?.glibcFloor ?? null);
+    const depends = resolveDepends(settings, payload.node?.glibcMinimum ?? null);
 
     return {
         name: packageNameFor(settings, packager),

package/src/deploy/node-runtime/elf.ts

@@ -8,7 +8,7 @@ type ElfSection = {
 
 type ElfInfo = {
     needed: string[];
-    glibcFloor: string | null;
+    glibcMinimum: string | null;
 };
 
 type DynamicEntry = {
@@ -117,7 +117,7 @@ const highestVersion = (versions: number[][]): number[] | null => {
 const formatVersion = (version: number[] | null): string | null =>
     version === null ? null : `${String(version[0] ?? 0)}.${String(version[1] ?? 0)}`;
 
-const readGlibcFloor = (strings: Buffer): string | null => {
+const readGlibcMinimum = (strings: Buffer): string | null => {
     const found = strings
         .toString("latin1")
         .matchAll(GLIBC_VERSION)
@@ -138,7 +138,7 @@ const readElfInfo = (path: string): ElfInfo => {
 
     return {
         needed: readNeeded(buffer, sectionFor(sections, ".dynamic"), strings),
-        glibcFloor: readGlibcFloor(strings),
+        glibcMinimum: readGlibcMinimum(strings),
     };
 };
 

package/src/deploy/node-runtime/index.ts

@@ -78,9 +78,9 @@ const resolveNodeRuntime = async (settings: DeploySettings): Promise<NodeRuntime
     const staged = await stageFromSource(settings, version, source);
     const isStripped = node.shouldStrip === false ? false : didStripBinary(staged.path);
     const elf = readElfInfo(staged.path);
-    info(`Bundled Node.js v${version} (${megabytes(staged.path)} MiB, glibc >= ${elf.glibcFloor ?? "unknown"})`);
+    info(`Bundled Node.js v${version} (${megabytes(staged.path)} MiB, glibc >= ${elf.glibcMinimum ?? "unknown"})`);
 
-    return { ...staged, version, glibcFloor: elf.glibcFloor, isStripped };
+    return { ...staged, version, glibcMinimum: elf.glibcMinimum, isStripped };
 };
 
 export { resolveNodeRuntime, sourcePathFor };

package/src/deploy/notices/collect.ts

@@ -1,3 +1,4 @@
+import type { RecordedPackage } from "../../internal/build-manifest.js";
 import type { DeploySettings, NodeRuntime, NoticeSection } from "../types.js";
 import { dependencyNotices } from "./dependencies.js";
 import { gtkxNotices } from "./gtkx.js";
@@ -8,10 +9,11 @@ import { bundledPackages } from "./packages.js";
 type NoticeRequest = {
     settings: DeploySettings;
     node: NodeRuntime | null;
+    packages: RecordedPackage[];
 };
 
-const collectNotices = ({ settings, node }: NoticeRequest): NoticeSection[] => {
-    const packages = bundledPackages(settings);
+const collectNotices = ({ settings, node, packages: recordedPackages }: NoticeRequest): NoticeSection[] => {
+    const packages = bundledPackages(settings, recordedPackages);
 
     const sections = [
         nodeNotices(settings, node),

package/src/deploy/notices/packages.ts

@@ -1,17 +1,11 @@
-import { isRecord, sortStringsBy, warn } from "@gtkx/utils";
-import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { sortStringsBy, warn } from "@gtkx/utils";
+import { existsSync, realpathSync } from "node:fs";
 import { join, resolve } from "node:path";
+import type { RecordedPackage } from "../../internal/build-manifest.js";
 import type { DeploySettings } from "../types.js";
-import { BUNDLED_PACKAGES_FILENAME } from "../../vite-plugins/bundled-packages.js";
 import { type PackageManifest, readPackageManifest } from "../settings/package-manifest.js";
 import { copyrightLines, licenseTextIn } from "./text.js";
 
-type RecordedPackage = {
-    name: string;
-    version: string | null;
-    dir: string;
-};
-
 type BundledPackage = {
     name: string;
     version: string | null;
@@ -36,38 +30,6 @@ const realPath = (path: string): string => {
     }
 };
 
-const optionalString = (value: unknown): string | null => (typeof value === "string" ? value : null);
-
-const recordedPackage = (entry: unknown): RecordedPackage | null => {
-    if (!isRecord(entry) || typeof entry.name !== "string" || typeof entry.dir !== "string") {
-        return null;
-    }
-
-    return { name: entry.name, version: optionalString(entry.version), dir: entry.dir };
-};
-
-const recordedList = (value: unknown): RecordedPackage[] => {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-
-    const entries: unknown[] = value;
-
-    return entries.map((entry) => recordedPackage(entry)).filter((entry) => entry !== null);
-};
-
-const readRecordedPackages = (settings: DeploySettings): RecordedPackage[] => {
-    const path = join(settings.paths.dist, BUNDLED_PACKAGES_FILENAME);
-
-    if (!existsSync(path)) {
-        throw new Error(`Cannot deploy: ${path} is missing. Run \`gtkx build\` first.`);
-    }
-
-    const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
-
-    return recordedList(isRecord(parsed) ? parsed.packages : null);
-};
-
 const authorLine = (manifest: PackageManifest): string[] => {
     const { name, email } = manifest.author;
 
@@ -151,10 +113,10 @@ const warnMissing = (entries: BundledPackage[]): void => {
     );
 };
 
-const bundledPackages = (settings: DeploySettings): BundledPackage[] => {
+const bundledPackages = (settings: DeploySettings, recorded: RecordedPackage[]): BundledPackage[] => {
     const root = realPath(settings.paths.root);
 
-    const entries = readRecordedPackages(settings)
+    const entries = recorded
         .map((entry) => ({ entry, dir: resolve(settings.paths.dist, entry.dir) }))
         .filter(({ dir }) => realPath(dir) !== root)
         .map(({ entry, dir }) => packageIn(entry, dir));

package/src/deploy/payload/icons.ts

@@ -1,53 +1,82 @@
-import { basename, join } from "node:path";
+import { join } from "node:path";
 import type { DeploySettings, StagedFile } from "../types.js";
+import { relativeIconPath } from "../../internal/icon-path.js";
 import { listFilesRecursive } from "../../internal/list-files.js";
 import { copyInto } from "./copy-tree.js";
 
+type ApplicationIconVariant = {
+    effectivePixels: number;
+    scalable: boolean;
+};
+
 const ICON_EXTENSIONS = [".svg", ".png", ".xpm"];
 const SHARE_ICONS = "share/icons";
-const SCALABLE_DIR = "hicolor/scalable/apps";
-const SIZE_PATTERN = /^(?<width>[1-9]\d{0,3})x(?<height>[1-9]\d{0,3})$/;
-const SIZE_SEPARATORS = /[-_.]/;
-
-const isApplicationIcon = (settings: DeploySettings, rel: string): boolean =>
-    ICON_EXTENSIONS.some((extension) => basename(rel) === `${settings.applicationId}${extension}`);
+const SIZE_PATTERN = /^(?<width>[1-9]\d{0,3})x(?<height>[1-9]\d{0,3})(?:@(?<scale>[1-9]\d*))?$/;
 
-const getSquareSize = (token: string): number | null => {
+const getSquareSize = (token: string): { pixels: number; scale: number } | null => {
     const groups = SIZE_PATTERN.exec(token)?.groups;
 
     if (groups === undefined || groups.width !== groups.height) {
         return null;
     }
 
-    return Number(groups.width);
+    const pixels = Number(groups.width);
+    const scale = Number(groups.scale ?? "1");
+
+    return Number.isSafeInteger(pixels * scale) ? { pixels, scale } : null;
+};
+
+const isIconThemeSize = (segment: string | undefined): boolean =>
+    segment === "scalable" || segment === "symbolic" ||
+    (segment !== undefined && getSquareSize(segment) !== null);
+
+const iconExtension = (applicationId: string, filename: string | undefined): string | undefined =>
+    ICON_EXTENSIONS.find((candidate) => filename === `${applicationId}${candidate}`);
+
+const isApplicationIconLayout = (segments: (string | undefined)[]): boolean => {
+    const [share, icons, theme, size, context] = segments;
+
+    return share === "share" &&
+        icons === "icons" &&
+        theme === "hicolor" &&
+        context === "apps" &&
+        isIconThemeSize(size);
 };
 
-const firstSquareSize = (tokens: string[]): number | null =>
-    tokens.map((token) => getSquareSize(token)).find((size) => size !== null) ?? null;
+const classifyApplicationIcon = (applicationId: string, rel: string): ApplicationIconVariant | null => {
+    const segments = rel.split(/[\\/]/);
+
+    if (segments.length !== 6) {
+        return null;
+    }
 
-const getIconSize = (rel: string): number | null => firstSquareSize(rel.split("/").slice(0, -1));
+    const size = segments[3];
+    const filename = segments[5];
+    const extension = iconExtension(applicationId, filename);
 
-const themeDirFor = (file: string): string => {
-    if (file.endsWith(".svg")) {
-        return SCALABLE_DIR;
+    if (extension === undefined || !isApplicationIconLayout(segments)) {
+        return null;
     }
 
-    const size = firstSquareSize(basename(file).split(SIZE_SEPARATORS));
+    const square = size === undefined ? null : getSquareSize(size);
 
-    return size === null ? SCALABLE_DIR : `hicolor/${String(size)}x${String(size)}/apps`;
+    return {
+        effectivePixels: square === null ? 0 : square.pixels * square.scale,
+        scalable: extension === ".svg",
+    };
 };
 
-const stageIconTree = (root: string, iconsDir: string): StagedFile[] =>
-    listFilesRecursive(iconsDir).map((file) => copyInto(root, join(SHARE_ICONS, file.rel), file.absPath));
+const isApplicationIcon = (settings: DeploySettings, rel: string): boolean =>
+    classifyApplicationIcon(settings.applicationId, rel) !== null;
 
-const iconPathFor = (settings: DeploySettings, iconFile: string): string => {
-    const extension = ICON_EXTENSIONS.find((candidate) => iconFile.endsWith(candidate)) ?? ".png";
+const stageIconTree = (root: string, themePath: string): StagedFile[] =>
+    listFilesRecursive(themePath).map((file) => copyInto(root, join(SHARE_ICONS, file.rel), file.absPath));
 
-    return join(themeDirFor(iconFile), `${settings.applicationId}${extension}`);
-};
+const iconPathFor = (settings: DeploySettings, iconPath: string): string =>
+    relativeIconPath(settings.applicationId, iconPath);
 
-const stageIconFile = (settings: DeploySettings, root: string, iconFile: string): StagedFile[] =>
-    [copyInto(root, join(SHARE_ICONS, iconPathFor(settings, iconFile)), iconFile)];
+const stageIconFile = (settings: DeploySettings, root: string, iconPath: string): StagedFile[] =>
+    [copyInto(root, join(SHARE_ICONS, iconPathFor(settings, iconPath)), iconPath)];
 
 const assertApplicationIcon = (settings: DeploySettings, staged: StagedFile[]): void => {
     if (staged.some((file) => isApplicationIcon(settings, file.rel))) {
@@ -55,26 +84,27 @@ const assertApplicationIcon = (settings: DeploySettings, staged: StagedFile[]):
     }
 
     throw new Error(
-        `Cannot deploy without an application icon: no ${settings.applicationId}.svg or ` +
-        `${settings.applicationId}.png under ${settings.paths.iconsDir ?? "the project's icon directory"}. ` +
+        "Cannot deploy without a usable application icon: the configured theme must contain " +
+        `${settings.applicationId}.svg, ${settings.applicationId}.png, or ${settings.applicationId}.xpm ` +
+        "under hicolor/<size>/apps. " +
         "The desktop entry names " +
         `"${settings.applicationId}" as its icon, so the file has to match. ` +
-        `Add ${settings.paths.dataDir ?? "data"}/icons/hicolor/scalable/apps/${settings.applicationId}.svg, ` +
-        "or point `deploy.icons` at one.",
+        "Set `applicationIcon` to a theme directory containing " +
+        `hicolor/scalable/apps/${settings.applicationId}.svg, or point it at a single icon file.`,
     );
 };
 
 const stageIcons = (settings: DeploySettings, root: string): StagedFile[] => {
-    const { iconsDir, iconFile } = settings.paths;
+    const source = settings.paths.applicationIcon;
 
-    if (iconFile !== null) {
-        return stageIconFile(settings, root, iconFile);
+    if (source.kind === "file") {
+        return stageIconFile(settings, root, source.path);
     }
 
-    const staged = iconsDir === null ? [] : stageIconTree(root, iconsDir);
+    const staged = source.kind === "theme" ? stageIconTree(root, source.path) : [];
     assertApplicationIcon(settings, staged);
 
     return staged;
 };
 
-export { getIconSize, iconPathFor, stageIcons };
+export { classifyApplicationIcon, iconPathFor, stageIcons, type ApplicationIconVariant };

package/src/deploy/payload/stage.ts

@@ -2,8 +2,8 @@ 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 { BUILD_MANIFEST_FILENAME } from "../../internal/build-manifest.js";
 import { listFilesRecursive } from "../../internal/list-files.js";
-import { BUNDLED_PACKAGES_FILENAME } from "../../vite-plugins/bundled-packages.js";
 import { BUNDLE_FILENAME } from "../../vite-plugins/esm-extension.js";
 import { renderCopyright } from "../freedesktop/copyright.js";
 import { renderDbusService } from "../freedesktop/dbus-service.js";
@@ -27,6 +27,7 @@ type StagedMetadata = {
 };
 
 const DIST_ICONS_DIR = "icons";
+const LEGACY_PACKAGES_MANIFEST_FILENAME = "gtkx-packages.json";
 const NOTICES_FILENAME = "THIRD-PARTY-NOTICES";
 const NODE_LICENSE_FILENAME = "LICENSE";
 const SHARE_APPLICATIONS = "share/applications";
@@ -48,7 +49,9 @@ const licenseDirFor = (settings: DeploySettings): string => `${SHARE_LICENSES}/$
 const licenseDestination = (settings: DeploySettings): string => `${licenseDirFor(settings)}/LICENSE`;
 const noticesDestination = (settings: DeploySettings): string => `${licenseDirFor(settings)}/${NOTICES_FILENAME}`;
 const isIconAsset = (rel: string): boolean => rel === DIST_ICONS_DIR || rel.startsWith(`${DIST_ICONS_DIR}/`);
-const isBuildMetadata = (rel: string): boolean => rel === BUNDLED_PACKAGES_FILENAME;
+
+const isBuildMetadata = (rel: string): boolean =>
+    rel === BUILD_MANIFEST_FILENAME || rel === LEGACY_PACKAGES_MANIFEST_FILENAME;
 
 const nodeLicenseDestination = (settings: DeploySettings): string =>
     `${licenseDirFor(settings)}/${NODE_FILENAME}/${NODE_LICENSE_FILENAME}`;

package/src/deploy/run-deploy.ts

@@ -20,10 +20,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,
@@ -50,6 +51,8 @@ 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 +69,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 +107,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 +116,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 +185,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)) {
@@ -147,6 +208,7 @@ const preflight = (targets: DeployTarget[], settings: DeploySettings, shouldPrin
     assertTools(report);
     warnMissingOptional(report);
     warnFlatpakPermissions(targets, settings);
+    warnLibraryMinimums(targets, settings);
 };
 
 const resolveTargetNames = (options: DeployOptions, settings: DeploySettings): string[] => {
@@ -180,15 +242,28 @@ const buildPayload = async (
         await buildApp({ entry: options.entry, vite: { root: options.cwd } });
     }
 
-    const node = options.shouldPrintManifests || !isNodeRequired(targets, settings)
-        ? null
-        : await resolveNodeRuntime(settings);
+    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),
+    };
 };
 
 const renderTargetManifests = (