@gtkx/cli 2.0.0-beta.7 → 2.0.0-beta.9

package/src/deploy/run-deploy.ts

@@ -3,7 +3,9 @@ import { info, warn } from "@gtkx/utils";
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
 import type {
+    DeployArchName,
     DeployArtifact,
+    DeployConfig,
     DeployManifest,
     DeployPayload,
     DeploySettings,
@@ -29,10 +31,12 @@ import { extractMetadataMessages, localizeMetadata } from "./freedesktop/localiz
 import { renderMetainfo } from "./freedesktop/metainfo.js";
 import { renderMimePackage } from "./freedesktop/mime-package.js";
 import { validateDesktopEntry, validateMetainfo } from "./freedesktop/validate.js";
-import { resolveNodeRuntime } from "./node-runtime/index.js";
+import { resolveStagedAddon } from "./native-addon.js";
+import { assertPortableRuntimeSource, 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 { archesFor, hostArchName, isHostArch, parseArchList } from "./settings/arch.js";
 import { readBuildManifest } from "./settings/build-manifest.js";
 import { resolveDeploySettings } from "./settings/index.js";
 import { readPackageManifest } from "./settings/package-manifest.js";
@@ -62,31 +66,52 @@ type DeployOptions = {
     cwd: string;
     configFile?: string | undefined;
     targets?: string | undefined;
+    arches?: string | undefined;
     outDir?: string | undefined;
     shouldPrintManifests: boolean;
     shouldSkipBuild: boolean;
 };
 
-type PreflightRequest = {
+type LoadedDeployConfig = {
+    config: Config;
+    configFile: string;
+    root: string;
+    deploy: DeployConfig;
+};
+
+type DeployPlan = {
+    loaded: LoadedDeployConfig;
     targets: DeployTarget[];
-    settings: DeploySettings;
+    arches: [DeployArchName, ...DeployArchName[]];
     project: CatalogProject | null;
+};
+
+type PreflightRequest = {
+    plan: DeployPlan;
+    settings: DeploySettings;
     shouldPrintManifests: boolean;
     shouldSkipBuild: boolean;
 };
 
-type LoadedDeploySettings = {
-    config: Config;
-    configFile: string;
+type BuildApplicationRequest = {
+    options: DeployOptions;
+    plan: DeployPlan;
     settings: DeploySettings;
+    buildOutDir: string | null;
 };
 
 type BuildPayloadRequest = {
     options: DeployOptions;
-    loaded: LoadedDeploySettings;
-    targets: DeployTarget[];
-    project: CatalogProject | null;
-    buildOutDir: string | null;
+    plan: DeployPlan;
+    settings: DeploySettings;
+    metadata: StagedMetadata;
+};
+
+type ArchRunRequest = {
+    options: DeployOptions;
+    plan: DeployPlan;
+    arch: DeployArchName;
+    metadata: StagedMetadata;
 };
 
 const BUILD_MODE = "production";
@@ -229,17 +254,28 @@ 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_TARGET));
 
-const runtimeToolsFor = (targets: DeployTarget[], settings: DeploySettings): DeployTool[] => {
-    if (!isNodeRequired(targets, settings)) {
+const archiveToolsFor = (settings: DeploySettings): DeployTool[] =>
+    (settings.deploy.node?.source ?? "download") === "download" ? [TAR] : [];
+
+const stripToolsFor = (settings: DeploySettings, arches: DeployArchName[]): DeployTool[] => {
+    if (settings.deploy.node?.shouldStrip === false) {
         return [];
     }
 
-    const node = settings.deploy.node ?? {};
-    const archiveTools = (node.source ?? "download") === "download" ? [TAR] : [];
+    return arches.some((arch) => isHostArch(arch)) ? [STRIP] : [];
+};
+
+const runtimeToolsFor = (targets: DeployTarget[], settings: DeploySettings, arches: DeployArchName[]): DeployTool[] => {
+    if (!isNodeRequired(targets, settings)) {
+        return [];
+    }
 
-    return node.shouldStrip === false ? archiveTools : [...archiveTools, STRIP];
+    return [...archiveToolsFor(settings), ...stripToolsFor(settings, arches)];
 };
 
+const crossBuildToolsFor = (arches: DeployArchName[]): DeployTool[] =>
+    arches.every((arch) => isHostArch(arch)) ? [] : [TAR];
+
 const mutableCatalogTools = (project: CatalogProject): DeployTool[] => {
     if (project.catalogs.length === 0) {
         return [MSGGREP, XGETTEXT];
@@ -266,40 +302,77 @@ const catalogTools = (project: CatalogProject | null, shouldSkipBuild: boolean):
     return project.catalogs.length === 0 ? [] : [MSGFMT];
 };
 
-const preflight = ({
-    targets,
-    settings,
-    project,
-    shouldPrintManifests,
-    shouldSkipBuild,
-}: PreflightRequest): void => {
+const preflight = ({ plan, settings, shouldPrintManifests, shouldSkipBuild }: PreflightRequest): void => {
+    const { targets, arches, project } = plan;
+
     const packagerTools = shouldPrintManifests
         ? []
-        : [...runtimeToolsFor(targets, settings), ...targets.flatMap((target) => target.tools)];
+        : [...runtimeToolsFor(targets, settings, arches), ...targets.flatMap((target) => target.tools)];
 
     const required = [
         DESKTOP_FILE_VALIDATE,
         APPSTREAMCLI,
+        ...crossBuildToolsFor(arches),
         ...catalogTools(project, shouldSkipBuild),
         ...sourceModeTools(targets, settings),
     ];
 
     const report = probeTools([...required, ...packagerTools]);
     assertTools(report);
+
+    if (isNodeRequired(targets, settings)) {
+        assertPortableRuntimeSource(settings);
+    }
+
     warnMissingOptional(report);
     warnFlatpakPermissions(targets, settings);
     warnLibraryMinimums(targets, settings);
 };
 
-const resolveTargetNames = (options: DeployOptions, settings: DeploySettings): string[] => {
+const hostOnlyNames = (targets: DeployTarget[]): string[] =>
+    targets.filter((target) => target.isHostOnly).map((target) => target.name);
+
+const assertCrossBuild = (plan: DeployPlan): void => {
+    const foreign = plan.arches.filter((arch) => !isHostArch(arch));
+
+    if (foreign.length === 0) {
+        return;
+    }
+
+    const hostOnly = hostOnlyNames(plan.targets);
+
+    if (hostOnly.length > 0) {
+        throw new Error(
+            `Cannot build ${hostOnly.join(" and ")} for ${foreign.join(" and ")}: those targets package with ` +
+            `tooling that only runs on ${hostArchName()}. Deploy them in a separate run without --arch.`,
+        );
+    }
+
+    if ((plan.loaded.deploy.node?.source ?? "download") !== "download") {
+        throw new Error(
+            'Cannot deploy for another architecture with a `deploy.node.source` other than "download": ' +
+            `a host or path runtime is always ${hostArchName()}.`,
+        );
+    }
+};
+
+const resolveTargetNames = (options: DeployOptions, deploy: DeployConfig): string[] => {
     if (options.targets !== undefined) {
         return parseTargetList(options.targets);
     }
 
-    return settings.deploy.targets ?? DEFAULT_TARGETS;
+    return deploy.targets ?? DEFAULT_TARGETS;
 };
 
-const loadSettings = async (options: DeployOptions): Promise<LoadedDeploySettings> => {
+const resolveArchNames = (options: DeployOptions, deploy: DeployConfig): string[] => {
+    if (options.arches !== undefined) {
+        return parseArchList(options.arches);
+    }
+
+    return deploy.architectures ?? [hostArchName()];
+};
+
+const loadDeployConfig = async (options: DeployOptions): Promise<LoadedDeployConfig> => {
     const { config, configFile, root } = await loadConfig(options.cwd, {
         mode: BUILD_MODE,
         configFile: options.configFile,
@@ -309,15 +382,26 @@ const loadSettings = async (options: DeployOptions): Promise<LoadedDeploySetting
         throw missingDeployError(config.applicationId, readPackageManifest(root));
     }
 
+    return { config, configFile, root, deploy: config.deploy };
+};
+
+const settingsFor = (plan: DeployPlan, options: DeployOptions, arch: DeployArchName): DeploySettings =>
+    resolveDeploySettings({
+        root: plan.loaded.root,
+        config: plan.loaded.config,
+        configFile: plan.loaded.configFile,
+        outDirOverride: options.outDir,
+        arch,
+    });
+
+const planDeploy = async (options: DeployOptions): Promise<DeployPlan> => {
+    const loaded = await loadDeployConfig(options);
+
     return {
-        config,
-        configFile,
-        settings: resolveDeploySettings({
-            root,
-            config,
-            configFile,
-            outDirOverride: options.outDir,
-        }),
+        loaded,
+        targets: targetsFor(resolveTargetNames(options, loaded.deploy)),
+        arches: archesFor(resolveArchNames(options, loaded.deploy)),
+        project: resolveCatalogProject(loaded.root, loaded.config.applicationId),
     };
 };
 
@@ -347,46 +431,57 @@ const synchronizeMetadataCatalogs = async (
     }
 };
 
-const buildPayload = async ({
+const buildApplication = async ({
     options,
-    loaded,
-    targets,
-    project,
+    plan,
+    settings,
     buildOutDir,
-}: BuildPayloadRequest): Promise<DeployPayload> => {
-    const settings = loaded.settings;
+}: BuildApplicationRequest): Promise<StagedMetadata> => {
     const templates = renderMetadata(settings);
 
-    if (buildOutDir !== null) {
-        info(`Building ${options.entry}`);
-        using preparedOutput = prepareBuildOutDir(settings.paths.root, buildOutDir);
-
-        await buildApp({
-            entry: options.entry,
-            configFile: options.configFile,
-            vite: { root: options.cwd, build: { outDir: preparedOutput.path, emptyOutDir: false } },
-        });
+    if (buildOutDir === null) {
+        if (plan.project !== null) {
+            compileCatalogs(plan.project, join(settings.paths.dist, LOCALE_DIRNAME));
+        }
 
-        preparedOutput.commit();
-        await synchronizeMetadataCatalogs(settings, templates, project);
-    } else if (project !== null) {
-        compileCatalogs(project, join(settings.paths.dist, LOCALE_DIRNAME));
+        return localizeMetadata(templates, plan.project);
     }
 
-    const metadata = localizeMetadata(templates, project);
-    validateMetadata(settings, metadata, isFlathubSubmission(settings, targets));
-    const buildManifest = readBuildManifest(settings, loaded);
+    info(`Building ${options.entry}`);
+    using preparedOutput = prepareBuildOutDir(settings.paths.root, buildOutDir);
+
+    await buildApp({
+        entry: options.entry,
+        configFile: options.configFile,
+        vite: { root: options.cwd, build: { outDir: preparedOutput.path, emptyOutDir: false } },
+    });
+
+    preparedOutput.commit();
+    await synchronizeMetadataCatalogs(settings, templates, plan.project);
+
+    return localizeMetadata(templates, plan.project);
+};
+
+const buildArchPayload = async ({
+    options,
+    plan,
+    settings,
+    metadata,
+}: BuildPayloadRequest): Promise<DeployPayload> => {
+    validateMetadata(settings, metadata, isFlathubSubmission(settings, plan.targets));
+    const buildManifest = readBuildManifest(settings, plan.loaded);
 
     const builtSettings: DeploySettings = {
         ...settings,
         paths: { ...settings.paths, schemaFiles: buildManifest.schemaFiles },
     };
 
-    const node = options.shouldPrintManifests || !isNodeRequired(targets, builtSettings)
+    const node = options.shouldPrintManifests || !isNodeRequired(plan.targets, builtSettings)
         ? null
         : await resolveNodeRuntime(builtSettings);
 
-    const stage = stagePayload({ settings: builtSettings, node, metadata });
+    const addon = await resolveStagedAddon(builtSettings);
+    const stage = stagePayload({ settings: builtSettings, node, addon, metadata });
     info(`Staged ${String(stage.length)} files into ${displayPath(builtSettings, builtSettings.paths.stage)}`);
     const notices = collectNotices({ settings: builtSettings, node, packages: buildManifest.packages });
 
@@ -438,56 +533,76 @@ const packTargets = async (
     return artifacts;
 };
 
-const announce = (settings: DeploySettings, targets: DeployTarget[]): void => {
-    const names = targets.map((target) => target.name).join(", ");
+const announce = (settings: DeploySettings, plan: DeployPlan): void => {
+    const names = plan.targets.map((target) => target.name).join(", ");
     const version = `${settings.versions.packageVersion}-${settings.versions.debRevision}`;
-    info(`Deploying ${settings.name} ${version} as ${settings.binaryName} (${settings.arch.rpm}) to ${names}`);
+    const arches = plan.arches.join(", ");
+    info(`Deploying ${settings.name} ${version} as ${settings.binaryName} (${arches}) to ${names}`);
 };
 
-const runDeploy = async (options: DeployOptions): Promise<void> => {
-    let loaded = await loadSettings(options);
-    let settings = loaded.settings;
-    let project = resolveCatalogProject(settings.paths.root, settings.applicationId);
-    let targets = targetsFor(resolveTargetNames(options, settings));
-    let buildOutDir = options.shouldSkipBuild ? null : resolveBuildOutDir(settings.paths.root, settings.paths.dist);
-    announce(settings, targets);
+const deployArch = async (request: ArchRunRequest): Promise<DeployArtifact[]> => {
+    const { options, plan, arch, metadata } = request;
+    const settings = settingsFor(plan, options, arch);
+    const payload = await buildArchPayload({ options, plan, settings, metadata });
+    const rendered = renderTargetManifests(plan.targets, payload);
 
-    preflight({
-        targets,
-        settings,
-        project,
-        shouldPrintManifests: options.shouldPrintManifests,
-        shouldSkipBuild: options.shouldSkipBuild,
-    });
+    if (options.shouldPrintManifests) {
+        const count = rendered.values().toArray().flat().length;
+        info(`Wrote ${String(count)} manifests for ${arch}, 0 packages built`);
 
-    if (!options.shouldSkipBuild) {
-        await ensureGenerated(options.cwd, {
-            shouldAnnounce: true,
-            mode: BUILD_MODE,
-            configFile: options.configFile,
-        });
-
-        loaded = await loadSettings(options);
-        settings = loaded.settings;
-        project = resolveCatalogProject(settings.paths.root, settings.applicationId);
-        targets = targetsFor(resolveTargetNames(options, settings));
-        buildOutDir = resolveBuildOutDir(settings.paths.root, settings.paths.dist);
+        return [];
     }
 
-    prepareDeployOutDir(settings.paths.root, settings.paths.outDir);
-    const payload = await buildPayload({ options, loaded, targets, project, buildOutDir });
-    const rendered = renderTargetManifests(targets, payload);
+    return await packTargets(rendered, payload);
+};
 
-    if (options.shouldPrintManifests) {
-        const count = rendered.values().toArray().flat().length;
-        info(`Wrote ${String(count)} manifests, 0 packages built`);
+const regenerate = async (options: DeployOptions, plan: DeployPlan): Promise<DeployPlan> => {
+    if (options.shouldSkipBuild) {
+        return plan;
+    }
 
+    await ensureGenerated(options.cwd, {
+        shouldAnnounce: true,
+        mode: BUILD_MODE,
+        configFile: options.configFile,
+    });
+
+    return await planDeploy(options);
+};
+
+const finish = (options: DeployOptions, settings: DeploySettings, artifacts: DeployArtifact[]): void => {
+    if (options.shouldPrintManifests) {
         return;
     }
 
-    const artifacts = await packTargets(rendered, payload);
     const output = displayPath(settings, settings.paths.output);
     info(`Deploy complete: ${String(artifacts.length)} artifacts in ${output}`);
 };
 
+const runDeploy = async (options: DeployOptions): Promise<void> => {
+    const planned = await planDeploy(options);
+    assertCrossBuild(planned);
+    announce(settingsFor(planned, options, planned.arches[0]), planned);
+
+    preflight({
+        plan: planned,
+        settings: settingsFor(planned, options, planned.arches[0]),
+        shouldPrintManifests: options.shouldPrintManifests,
+        shouldSkipBuild: options.shouldSkipBuild,
+    });
+
+    const plan = await regenerate(options, planned);
+    const settings = settingsFor(plan, options, plan.arches[0]);
+    const buildOutDir = options.shouldSkipBuild ? null : resolveBuildOutDir(settings.paths.root, settings.paths.dist);
+    prepareDeployOutDir(settings.paths.root, settings.paths.outDir);
+    const metadata = await buildApplication({ options, plan, settings, buildOutDir });
+    const artifacts: DeployArtifact[] = [];
+
+    for (const arch of plan.arches) {
+        artifacts.push(...await deployArch({ options, plan, arch, metadata }));
+    }
+
+    finish(options, settings, artifacts);
+};
+
 export { runDeploy };

package/src/deploy/settings/arch.ts

@@ -1,18 +1,50 @@
-import type { DeployArch } from "../types.js";
+import { sortStrings } from "@gtkx/utils";
+import type { DeployArch, DeployArchName } from "../types.js";
 
-const ARCH_TABLE: Record<string, DeployArch> = {
+const EM_X86_64 = 62;
+const EM_AARCH64 = 183;
+
+const ARCH_TABLE: Record<DeployArchName, DeployArch> = {
     arm64: { deb: "arm64", rpm: "aarch64", flatpak: "aarch64", appimage: "aarch64", node: "arm64" },
     x64: { deb: "amd64", rpm: "x86_64", flatpak: "x86_64", appimage: "x86_64", node: "x64" },
 };
 
-const resolveArch = (arch: string = process.arch): DeployArch => {
-    const resolved = ARCH_TABLE[arch];
+const ELF_MACHINE_TABLE: Record<DeployArchName, number> = {
+    arm64: EM_AARCH64,
+    x64: EM_X86_64,
+};
+
+const KNOWN_ARCH_NAMES = sortStrings(Object.keys(ARCH_TABLE)).join(", ");
+
+const isArchName = (name: string): name is DeployArchName => Object.hasOwn(ARCH_TABLE, name);
+
+const assertKnownArch = (name: string): DeployArchName => {
+    if (!isArchName(name)) {
+        throw new Error(`Cannot deploy for ${name}: only ${KNOWN_ARCH_NAMES} are supported`);
+    }
+
+    return name;
+};
+
+const resolveArch = (name: DeployArchName): DeployArch => ARCH_TABLE[name];
+
+const hostArchName = (): DeployArchName => assertKnownArch(process.arch);
+
+const isHostArch = (name: DeployArchName): boolean => name === hostArchName();
+
+const elfMachineFor = (name: DeployArchName): number => ELF_MACHINE_TABLE[name];
+
+const parseArchList = (value: string): string[] => value.split(",").map((name) => name.trim()).filter(Boolean);
+
+const archesFor = (names: string[]): [DeployArchName, ...DeployArchName[]] => {
+    const requested = sortStrings(new Set(names.map((name) => assertKnownArch(name.trim()))));
+    const [first, ...rest] = requested.map((name) => assertKnownArch(name));
 
-    if (resolved === undefined) {
-        throw new Error(`Cannot deploy for ${arch}: only ${Object.keys(ARCH_TABLE).join(" and ")} are supported`);
+    if (first === undefined) {
+        throw new Error(`Cannot deploy without an architecture; choose from ${KNOWN_ARCH_NAMES}`);
     }
 
-    return resolved;
+    return [first, ...rest];
 };
 
-export { resolveArch };
+export { archesFor, elfMachineFor, hostArchName, isHostArch, KNOWN_ARCH_NAMES, parseArchList, resolveArch };

package/src/deploy/settings/index.ts

@@ -1,5 +1,6 @@
 import type { Config } from "@gtkx/config";
 import type {
+    DeployArchName,
     DeployConfig,
     DeployDesktopAction,
     DeployDeveloper,
@@ -32,6 +33,7 @@ type SettingsRequest = {
     root: string;
     config: Config;
     configFile: string;
+    arch: DeployArchName;
     outDirOverride?: string | undefined;
     now?: Date | undefined;
 };
@@ -181,13 +183,14 @@ const resolveDeploySettings = (request: SettingsRequest): DeploySettings => {
         ...desktopSlice(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/paths.ts

@@ -2,7 +2,7 @@ import type { Config } from "@gtkx/config";
 import { isPathInside } from "@gtkx/utils";
 import { lstatSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { join, relative, resolve, sep } from "node:path";
-import type { DeployConfig, DeployPaths } from "../types.js";
+import type { DeployArchName, DeployConfig, DeployPaths } from "../types.js";
 import { resolveApplicationIcon } from "../../internal/icon-path.js";
 import { prepareOutputDirectory, readRegularFile } from "../../internal/output-directory.js";
 
@@ -12,6 +12,7 @@ type PathsRequest = {
     applicationIcon: Config["applicationIcon"];
     applicationId: Config["applicationId"];
     outDirOverride: string | undefined;
+    arch: DeployArchName;
 };
 
 const DEFAULT_OUT_DIR = "build";
@@ -113,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),

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.25.0";
+const PNPM_VERSION = "11.26.0";
 const PNPM_MAJOR = 11;
-const PNPM_MINOR = 25;
+const PNPM_MINOR = 26;
 
-const PNPM_SHA512 = "5cde925b4f075f725eb71fbae18a42ffe784524789f19b61c731cb8721ec28aaee160e01a" +
-    "8d5af4fedb2a42cdbf300efe23db356b0d4a17b4d63e11f8ab7c956";
+const PNPM_SHA512 = "fc0e2bf890b9f983611f1ab68c0637bce914390653699f83c1a78b005ed25f2c81e77920c8" +
+    "fd8eee2ecf0b58b28cdcb00a84d97f69bcf7c56b2f344710238664";
 
 const PNPM_DIR = "flatpak-pnpm";
 const PNPM_COMMAND = "pnpm";

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

@@ -32,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 = {
@@ -170,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[]>;
@@ -177,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);