@gtkx/cli 1.0.0 → 1.2.0

package/src/deploy/run-deploy.ts

@@ -0,0 +1,241 @@
+import { loadConfig } from "@gtkx/config";
+import { info, warn } from "@gtkx/utils";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import type {
+    DeployArtifact,
+    DeployManifest,
+    DeployPayload,
+    DeploySettings,
+    DeployTarget,
+    DeployTool,
+} from "./types.js";
+import { build as buildApp } from "../builder.js";
+import { ensureGenerated } from "../codegen/run-codegen.js";
+import { renderDesktopEntry } from "./freedesktop/desktop-entry.js";
+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 { type StagedMetadata, stageOverlays, stagePayload } from "./payload/stage.js";
+import { DEFAULT_TARGETS, parseTargetList, targetsFor } from "./registry.js";
+import { resolveDeploySettings } from "./settings/index.js";
+import { readPackageManifest } from "./settings/package-manifest.js";
+import { missingDeployError } from "./settings/starter.js";
+import { detectPackageManager } from "./targets/flatpak-sources.js";
+import {
+    APPSTREAMCLI,
+    assertTools,
+    DESKTOP_FILE_VALIDATE,
+    FLATPAK_NODE_GENERATOR,
+    FLATPAK_NODE_GENERATOR_PNPM,
+    probeTools,
+    STRIP,
+    TAR,
+    warnMissingOptional,
+} from "./tools.js";
+
+type DeployOptions = {
+    entry: string;
+    cwd: string;
+    targets?: string | undefined;
+    outDir?: string | undefined;
+    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 displayPath = (settings: DeploySettings, path: string): string => relative(settings.paths.root, path);
+const megabytes = (size: number): string => (size / BYTES_PER_MIB).toFixed(1);
+
+const writeManifest = (manifest: DeployManifest): void => {
+    mkdirSync(dirname(manifest.path), { recursive: true });
+    writeFileSync(manifest.path, manifest.contents);
+};
+
+const renderMetadata = (settings: DeploySettings): StagedMetadata => ({
+    desktopEntry: renderDesktopEntry(settings),
+    metainfo: renderMetainfo(settings),
+    mimePackage: renderMimePackage(settings),
+});
+
+const isFlathubSubmission = (settings: DeploySettings, targets: DeployTarget[]): boolean =>
+    settings.deploy.flatpak?.mode === "source" && targets.some((target) => target.name === "flatpak");
+
+const validateMetadata = (settings: DeploySettings, metadata: StagedMetadata, areWarningsFatal: boolean): void => {
+    const dir = settings.paths.metadata;
+    mkdirSync(dir, { recursive: true });
+    const desktopPath = join(dir, `${settings.applicationId}.desktop`);
+    const metainfoPath = join(dir, `${settings.applicationId}.metainfo.xml`);
+    writeFileSync(desktopPath, metadata.desktopEntry);
+    writeFileSync(metainfoPath, metadata.metainfo);
+    validateDesktopEntry(desktopPath);
+    validateMetainfo(metainfoPath, areWarningsFatal);
+    info("Validated the desktop entry and the metainfo");
+};
+
+const warnMissingNetwork = (settings: DeploySettings): void => {
+    const finishArgs = settings.deploy.flatpak?.finishArgs;
+
+    if (finishArgs === undefined || finishArgs.includes(NETWORK_ARG)) {
+        return;
+    }
+
+    if (!settings.libraries.includes(WEBKIT_LIBRARY)) {
+        return;
+    }
+
+    warn(`This app declares ${WEBKIT_LIBRARY} but its flatpak permissions omit ${NETWORK_ARG}, so pages will not load`);
+};
+
+const sourceModeTools = (targets: DeployTarget[], settings: DeploySettings): DeployTool[] => {
+    const isFlatpakSource = settings.deploy.flatpak?.mode === "source";
+
+    if (!isFlatpakSource || targets.every((target) => target.name !== "flatpak")) {
+        return [];
+    }
+
+    return detectPackageManager(settings) === "pnpm" ? [FLATPAK_NODE_GENERATOR_PNPM] : [FLATPAK_NODE_GENERATOR];
+};
+
+const isNodeRequired = (targets: DeployTarget[], settings: DeploySettings): boolean =>
+    !(settings.deploy.flatpak?.mode === "source" && targets.every((target) => target.name === "flatpak"));
+
+const runtimeToolsFor = (targets: DeployTarget[], settings: DeploySettings): DeployTool[] => {
+    if (!isNodeRequired(targets, settings)) {
+        return [];
+    }
+
+    const node = settings.deploy.node ?? {};
+    const archiveTools = (node.source ?? "download") === "download" ? [TAR] : [];
+
+    return node.shouldStrip === false ? archiveTools : [...archiveTools, STRIP];
+};
+
+const preflight = (targets: DeployTarget[], settings: DeploySettings, shouldPrintManifests: boolean): void => {
+    const packagerTools = shouldPrintManifests
+        ? []
+        : [...runtimeToolsFor(targets, settings), ...targets.flatMap((target) => target.tools)];
+
+    const required = [DESKTOP_FILE_VALIDATE, APPSTREAMCLI, ...sourceModeTools(targets, settings)];
+    const report = probeTools([...required, ...packagerTools]);
+    assertTools(report);
+    warnMissingOptional(report);
+    warnMissingNetwork(settings);
+};
+
+const resolveTargetNames = (options: DeployOptions, settings: DeploySettings): string[] => {
+    if (options.targets !== undefined) {
+        return parseTargetList(options.targets);
+    }
+
+    return settings.deploy.targets ?? DEFAULT_TARGETS;
+};
+
+const loadSettings = async (options: DeployOptions): Promise<DeploySettings> => {
+    const { config, root } = await loadConfig(options.cwd, { mode: BUILD_MODE });
+
+    if (config.deploy === undefined) {
+        throw missingDeployError(config.applicationId, readPackageManifest(root));
+    }
+
+    return resolveDeploySettings({ root, config, outDirOverride: options.outDir });
+};
+
+const buildPayload = async (
+    options: DeployOptions,
+    settings: DeploySettings,
+    targets: DeployTarget[],
+): Promise<DeployPayload> => {
+    const metadata = renderMetadata(settings);
+    validateMetadata(settings, metadata, isFlathubSubmission(settings, targets));
+
+    if (!options.shouldSkipBuild) {
+        info(`Building ${options.entry}`);
+        await buildApp({ entry: options.entry, vite: { root: options.cwd } });
+    }
+
+    const node = options.shouldPrintManifests || !isNodeRequired(targets, settings)
+        ? null
+        : await resolveNodeRuntime(settings);
+
+    const stage = stagePayload({ settings, node, metadata });
+    info(`Staged ${String(stage.length)} files into ${displayPath(settings, settings.paths.stage)}`);
+
+    return { settings, node, stage, overlays: stageOverlays(settings) };
+};
+
+const renderTargetManifests = (
+    targets: DeployTarget[],
+    payload: DeployPayload,
+): Map<DeployTarget, DeployManifest[]> => {
+    const rendered: Map<DeployTarget, DeployManifest[]> = new Map();
+
+    for (const target of targets) {
+        const manifests = target.render(payload);
+
+        for (const manifest of manifests) {
+            writeManifest(manifest);
+            info(`Wrote ${displayPath(payload.settings, manifest.path)}`);
+        }
+
+        rendered.set(target, manifests);
+    }
+
+    return rendered;
+};
+
+const packTargets = async (
+    rendered: Map<DeployTarget, DeployManifest[]>,
+    payload: DeployPayload,
+): Promise<DeployArtifact[]> => {
+    const artifacts: DeployArtifact[] = [];
+
+    for (const [target, manifests] of rendered) {
+        const built = await target.pack(payload, manifests);
+
+        for (const artifact of built) {
+            info(`Built ${displayPath(payload.settings, artifact.path)} (${megabytes(artifact.size)} MiB)`);
+        }
+
+        artifacts.push(...built);
+    }
+
+    return artifacts;
+};
+
+const announce = (settings: DeploySettings, targets: DeployTarget[]): void => {
+    const names = 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 runDeploy = async (options: DeployOptions): Promise<void> => {
+    if (!options.shouldSkipBuild) {
+        await ensureGenerated(options.cwd, { shouldAnnounce: true, mode: BUILD_MODE });
+    }
+
+    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 rendered = renderTargetManifests(targets, payload);
+
+    if (options.shouldPrintManifests) {
+        const count = rendered.values().toArray().flat().length;
+        info(`Wrote ${String(count)} manifests, 0 packages built`);
+
+        return;
+    }
+
+    const artifacts = await packTargets(rendered, payload);
+    const output = displayPath(settings, settings.paths.output);
+    info(`Deploy complete: ${String(artifacts.length)} artifacts in ${output}`);
+};
+
+export { runDeploy };

package/src/deploy/settings/arch.ts

@@ -0,0 +1,18 @@
+import type { DeployArch } from "../types.js";
+
+const ARCH_TABLE: Record<string, 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];
+
+    if (resolved === undefined) {
+        throw new Error(`Cannot deploy for ${arch}: only ${Object.keys(ARCH_TABLE).join(" and ")} are supported`);
+    }
+
+    return resolved;
+};
+
+export { resolveArch };

package/src/deploy/settings/categories.ts

@@ -0,0 +1,39 @@
+type CategoryMapping = {
+    section: string;
+    group: string;
+};
+
+const DEFAULT_MAPPING: CategoryMapping = { section: "misc", group: "Applications/System" };
+
+const MAPPING_BY_CATEGORY: Record<string, CategoryMapping> = {
+    Audio: { section: "sound", group: "Applications/Multimedia" },
+    AudioVideo: { section: "sound", group: "Applications/Multimedia" },
+    Development: { section: "devel", group: "Development/Tools" },
+    Education: { section: "education", group: "Applications/Education" },
+    Game: { section: "games", group: "Amusements/Games" },
+    Graphics: { section: "graphics", group: "Applications/Multimedia" },
+    Network: { section: "net", group: "Applications/Internet" },
+    Office: { section: "gnome", group: "Applications/Productivity" },
+    Science: { section: "science", group: "Applications/Engineering" },
+    Settings: { section: "gnome", group: "Applications/System" },
+    System: { section: "admin", group: "Applications/System" },
+    Utility: { section: "utils", group: "Applications/Utilities" },
+    Video: { section: "video", group: "Applications/Multimedia" },
+};
+
+const mappingForCategories = (categories: string[]): CategoryMapping => {
+    for (const category of categories) {
+        const mapping = MAPPING_BY_CATEGORY[category];
+
+        if (mapping !== undefined) {
+            return mapping;
+        }
+    }
+
+    return DEFAULT_MAPPING;
+};
+
+const sectionForCategories = (categories: string[]): string => mappingForCategories(categories).section;
+const groupForCategories = (categories: string[]): string => mappingForCategories(categories).group;
+
+export { groupForCategories, sectionForCategories };

package/src/deploy/settings/exec.ts

@@ -0,0 +1,29 @@
+import type { DeployConfig, DeployFileAssociation } from "../types.js";
+
+const SCHEME_HANDLER_PREFIX = "x-scheme-handler/";
+
+const resolveFileAssociations = (deploy: DeployConfig): DeployFileAssociation[] =>
+    (deploy.fileAssociations ?? []).map((entry) => ({
+        extension: entry.extension,
+        mimeType: entry.mimeType,
+        description: entry.description ?? null,
+    }));
+
+const resolveMimeTypes = (deploy: DeployConfig): string[] => {
+    const fromAssociations = (deploy.fileAssociations ?? []).map((entry) => entry.mimeType);
+    const fromProtocols = (deploy.protocols ?? []).map((scheme) => `${SCHEME_HANDLER_PREFIX}${scheme}`);
+
+    return [...new Set([...(deploy.mimeTypes ?? []), ...fromAssociations, ...fromProtocols])];
+};
+
+const resolveExecToken = (deploy: DeployConfig): string | null => {
+    const mimeTypes = resolveMimeTypes(deploy);
+
+    if (mimeTypes.length === 0) {
+        return null;
+    }
+
+    return mimeTypes.some((mimeType) => mimeType.startsWith(SCHEME_HANDLER_PREFIX)) ? "%U" : "%F";
+};
+
+export { resolveExecToken, resolveFileAssociations, resolveMimeTypes };

package/src/deploy/settings/identity.ts

@@ -0,0 +1,133 @@
+import type { DeployConfig, DeployDeveloper } from "../types.js";
+import type { PackageManifest } from "./package-manifest.js";
+
+type IdentityRequest = {
+    applicationId: string;
+    deploy: DeployConfig;
+    manifest: PackageManifest;
+};
+
+const DEFAULT_METADATA_LICENSE = "CC0-1.0";
+const NAME_SEPARATORS = /[_-]+/;
+const NON_NAME_CHARACTERS = /[^a-z\d]+/;
+const SCOPE_PREFIX = /^@[^/]+\//;
+const BINARY_NAME_PATTERN = /^[a-z\d][a-z\d+.-]+$/;
+
+const lastSegment = (applicationId: string): string => applicationId.split(".").at(-1) ?? applicationId;
+
+const titleCase = (value: string): string =>
+    value
+        .split(NAME_SEPARATORS)
+        .filter((word) => word.length > 0)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(" ");
+
+const normalizePackageName = (value: string): string =>
+    value
+        .replace(SCOPE_PREFIX, "")
+        .toLowerCase()
+        .split(NON_NAME_CHARACTERS)
+        .filter((part) => part.length > 0)
+        .join("-");
+
+const resolveBinaryName = ({ applicationId, deploy, manifest }: IdentityRequest): string => {
+    const configured = deploy.binaryName;
+    const derived = normalizePackageName(configured ?? manifest.name ?? lastSegment(applicationId));
+
+    if (!BINARY_NAME_PATTERN.test(derived)) {
+        throw new Error(
+            `Cannot use "${derived}" as a package name: it must match ${String(BINARY_NAME_PATTERN)}. ` +
+            "Set `deploy.binaryName`.",
+        );
+    }
+
+    return derived;
+};
+
+const resolveName = ({ applicationId, deploy, manifest }: IdentityRequest): string =>
+    deploy.name ?? titleCase(manifest.name?.replace(SCOPE_PREFIX, "") ?? lastSegment(applicationId));
+
+const resolveSummary = ({ deploy, manifest }: IdentityRequest): string => {
+    const summary = deploy.summary ?? manifest.description?.split("\n", 1)[0];
+
+    if (summary === undefined) {
+        throw new Error(
+            "Cannot deploy without a summary: set `deploy.summary` in gtkx.config.ts, " +
+            "or `description` in package.json.",
+        );
+    }
+
+    return summary;
+};
+
+const resolveDescription = (request: IdentityRequest): string[] => {
+    const configured = request.deploy.description;
+
+    return configured === undefined || configured.length === 0 ? [resolveSummary(request)] : configured;
+};
+
+const resolveDeveloperId = (applicationId: string): string | null => {
+    const segments = applicationId.split(".");
+
+    return segments.length > 2 ? segments.slice(0, -1).join(".") : null;
+};
+
+const resolveDeveloper = ({ applicationId, deploy, manifest }: IdentityRequest): DeployDeveloper => {
+    const name = deploy.developer?.name ?? manifest.author.name;
+
+    if (name === null) {
+        throw new Error(
+            "Cannot deploy without a developer: set `deploy.developer.name` in gtkx.config.ts, " +
+            "or `author` in package.json.",
+        );
+    }
+
+    return {
+        id: deploy.developer?.id ?? resolveDeveloperId(applicationId),
+        name,
+        email: deploy.developer?.email ?? manifest.author.email,
+    };
+};
+
+const resolveLicense = ({ deploy, manifest }: IdentityRequest): string => {
+    const license = deploy.license ?? manifest.license;
+
+    if (license === null) {
+        throw new Error(
+            "Cannot deploy without a license: set `deploy.license` in gtkx.config.ts, or `license` in package.json.",
+        );
+    }
+
+    return license;
+};
+
+const resolveVersionString = ({ deploy, manifest }: IdentityRequest): string => {
+    const version = deploy.version ?? manifest.version;
+
+    if (version === null) {
+        throw new Error(
+            "Cannot deploy without a version: set `deploy.version` in gtkx.config.ts, or `version` in package.json.",
+        );
+    }
+
+    return version;
+};
+
+const resolveCopyright = (request: IdentityRequest, developer: DeployDeveloper, year: number): string =>
+    request.deploy.copyright ?? `Copyright © ${String(year)} ${developer.name}`;
+
+const resolveMetadataLicense = ({ deploy }: IdentityRequest): string =>
+    deploy.metadataLicense ?? DEFAULT_METADATA_LICENSE;
+
+export {
+    type IdentityRequest,
+    resolveBinaryName,
+    resolveCopyright,
+    resolveDescription,
+    resolveDeveloper,
+    resolveLicense,
+    resolveMetadataLicense,
+    resolveName,
+    resolveSummary,
+    resolveVersionString,
+};

package/src/deploy/settings/index.ts

@@ -0,0 +1,189 @@
+import type { Config } from "@gtkx/config";
+import type {
+    DeployConfig,
+    DeployDesktopAction,
+    DeployDeveloper,
+    DeployRelease,
+    DeploySettings,
+    DeployVersions,
+} from "../types.js";
+import { resolveArch } from "./arch.js";
+import { resolveExecToken, resolveFileAssociations, resolveMimeTypes } from "./exec.js";
+import {
+    type IdentityRequest,
+    resolveBinaryName,
+    resolveCopyright,
+    resolveDescription,
+    resolveDeveloper,
+    resolveLicense,
+    resolveMetadataLicense,
+    resolveName,
+    resolveSummary,
+    resolveVersionString,
+} from "./identity.js";
+import { readPackageManifest } from "./package-manifest.js";
+import { resolvePaths } from "./paths.js";
+import { resolveScreenshots } from "./screenshots.js";
+import { resolveVersions } from "./version.js";
+
+type SettingsRequest = {
+    root: string;
+    config: Config;
+    outDirOverride?: string | undefined;
+    now?: Date | undefined;
+};
+
+type ResolvedCore = {
+    identity: IdentityRequest;
+    developer: DeployDeveloper;
+    versions: DeployVersions;
+    date: string;
+};
+
+type IdentitySlice = Pick<
+    DeploySettings,
+    | "applicationId" |
+    "binaryName" |
+    "copyright" |
+    "description" |
+    "developer" |
+    "genericName" |
+    "homepage" |
+    "license" |
+    "metadataLicense" |
+    "name" |
+    "summary"
+>;
+
+type MetadataSlice = Pick<
+    DeploySettings,
+    "branding" | "categories" | "contentRating" | "keywords" | "mimeTypes" | "releases" | "screenshots" | "urls"
+>;
+
+type DesktopSlice = Pick<
+    DeploySettings,
+    | "desktopActions" |
+    "desktopEntry" |
+    "execArgs" |
+    "execToken" |
+    "fileAssociations" |
+    "isDbusActivatable" |
+    "protocols"
+>;
+
+const ISO_DATE_LENGTH = 10;
+const MILLISECONDS_PER_SECOND = 1000;
+
+const reproducibleDate = (epoch: string | undefined): Date | null => {
+    if (epoch === undefined || epoch.trim().length === 0) {
+        return null;
+    }
+
+    const seconds = Number(epoch);
+
+    return Number.isFinite(seconds) ? new Date(seconds * MILLISECONDS_PER_SECOND) : null;
+};
+
+const buildDate = (now: Date): string => {
+    const stamp = reproducibleDate(process.env.SOURCE_DATE_EPOCH) ?? now;
+
+    return stamp.toISOString().slice(0, ISO_DATE_LENGTH);
+};
+
+const newestFirst = (a: DeployRelease, b: DeployRelease): number => Number(a.date < b.date) - Number(a.date > b.date);
+
+const resolveReleases = (deploy: DeployConfig, version: string, date: string): DeployRelease[] =>
+    (deploy.releases ?? [{ version, date }])
+        .map((entry) => ({
+            version: entry.version,
+            date: entry.date,
+            type: entry.type ?? null,
+            urgency: entry.urgency ?? null,
+            notes: entry.notes ?? [],
+            url: entry.url ?? null,
+        }))
+        .toSorted(newestFirst);
+
+const resolveDesktopActions = (deploy: DeployConfig): DeployDesktopAction[] =>
+    Object.entries(deploy.desktopActions ?? {}).map(([id, action]) => ({
+        id,
+        name: action.name,
+        args: action.args ?? [],
+        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),
+    name: resolveName(identity),
+    genericName: identity.deploy.genericName ?? null,
+    summary: resolveSummary(identity),
+    description: resolveDescription(identity),
+    developer,
+    license: resolveLicense(identity),
+    metadataLicense: resolveMetadataLicense(identity),
+    copyright: resolveCopyright(identity, developer, new Date(date).getUTCFullYear()),
+    homepage: identity.deploy.homepage ?? identity.manifest.homepage,
+});
+
+const metadataSlice = (root: string, { identity, versions, date }: ResolvedCore): MetadataSlice => {
+    const deploy = identity.deploy;
+
+    return {
+        keywords: deploy.keywords ?? [],
+        categories: deploy.categories ?? [],
+        mimeTypes: resolveMimeTypes(deploy),
+        urls: deploy.urls ?? {},
+        screenshots: resolveScreenshots({ root, deploy }),
+        branding: deploy.branding ?? null,
+        contentRating: deploy.contentRating ?? {},
+        releases: resolveReleases(deploy, versions.packageVersion, date),
+    };
+};
+
+const desktopSlice = (deploy: DeployConfig): DesktopSlice => ({
+    execArgs: deploy.execArgs ?? [],
+    execToken: resolveExecToken(deploy),
+    fileAssociations: resolveFileAssociations(deploy),
+    protocols: deploy.protocols ?? [],
+    desktopActions: resolveDesktopActions(deploy),
+    desktopEntry: deploy.desktopEntry ?? {},
+    isDbusActivatable: deploy.isDbusActivatable ?? false,
+});
+
+const resolveCore = (request: SettingsRequest): ResolvedCore => {
+    const identity: IdentityRequest = {
+        applicationId: request.config.applicationId,
+        deploy: request.config.deploy ?? {},
+        manifest: readPackageManifest(request.root),
+    };
+
+    const versions = resolveVersions({
+        version: resolveVersionString(identity),
+        release: identity.deploy.release,
+        epoch: identity.deploy.epoch,
+    });
+
+    return { identity, developer: resolveDeveloper(identity), versions, date: buildDate(request.now ?? new Date()) };
+};
+
+const resolveDeploySettings = (request: SettingsRequest): DeploySettings => {
+    const core = resolveCore(request);
+    const deploy = core.identity.deploy;
+
+    return {
+        ...identitySlice(core),
+        ...metadataSlice(request.root, core),
+        ...desktopSlice(deploy),
+        extraFiles: deploy.extraFiles ?? {},
+        versions: core.versions,
+        arch: resolveArch(),
+        paths: resolvePaths({ root: request.root, deploy, outDirOverride: request.outDirOverride }),
+        libraries: resolveLibraries(request.config),
+        deploy,
+    };
+};
+
+export { resolveDeploySettings };