@gtkx/cli 1.0.0 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/cli",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Command-line tool and Vite plugin stack that scaffolds, develops, builds, and documents GTKX applications",
   "keywords": [
     "gtkx",
@@ -30,10 +30,6 @@
   "type": "module",
   "exports": {
     "./env": "./env.d.ts",
-    "./internal": {
-      "types": "./dist/internal.d.ts",
-      "default": "./dist/internal.js"
-    },
     "./package.json": "./package.json",
     "./refresh-runtime": {
       "types": "./dist/refresh-runtime.d.ts",
@@ -54,6 +50,16 @@
     "env.d.ts",
     "src"
   ],
+  "nx": {
+    "targets": {
+      "lint": {
+        "options": {
+          "cwd": ".",
+          "command": "eslint {projectRoot}"
+        }
+      }
+    }
+  },
   "engines": {
     "node": ">=24"
   },
@@ -66,19 +72,20 @@
     "fast-xml-parser": "^5.10.1",
     "react-refresh": "^0.18.0",
     "vite": "^8.2.1",
-    "@gtkx/config": "1.0.0",
-    "@gtkx/codegen": "1.0.0",
-    "@gtkx/mcp": "1.0.0",
-    "@gtkx/runtime": "1.0.0",
-    "@gtkx/utils": "1.0.0",
-    "@gtkx/vitest": "1.0.0",
-    "create-gtkx": "1.0.0"
+    "yaml": "^2.9.0",
+    "@gtkx/codegen": "1.2.0",
+    "@gtkx/config": "1.2.0",
+    "@gtkx/utils": "1.2.0",
+    "@gtkx/runtime": "1.2.0",
+    "@gtkx/mcp": "1.2.0",
+    "@gtkx/vitest": "1.2.0",
+    "create-gtkx": "1.2.0"
   },
   "devDependencies": {
     "@types/babel__core": "^7.20.5",
     "@types/react-refresh": "^0.14.7",
     "vitest": "^4.1.10",
-    "@gtkx/testing": "1.0.0"
+    "@gtkx/testing": "1.2.0"
   },
   "peerDependencies": {
     "react": "^19"

package/src/builder.ts

@@ -1,7 +1,10 @@
+import { join, posix } from "node:path";
 import { type InlineConfig, mergeConfig, build as viteBuild } from "vite";
 import { gtkxBuiltUrl } from "./vite-plugins/built-url.js";
+import { BUNDLE_FILENAME, ESM_EXTENSION } from "./vite-plugins/esm-extension.js";
 import { gtkxVitePlugins } from "./vite-plugins/index.js";
 import { gtkxNative } from "./vite-plugins/native.js";
+import { gtkxSelfContained } from "./vite-plugins/self-contained.js";
 import { gtkxWorker } from "./vite-plugins/worker.js";
 
 type BuildOptions = {
@@ -11,11 +14,15 @@ type BuildOptions = {
 };
 
 const BUILD_MODE = "production";
+const CHUNK_STEM = "[name]-[hash]";
+const DEFAULT_OUT_DIR = "dist";
+const DEFAULT_ASSETS_DIR = "assets";
+const ENTRY_FILE_NAMES = BUNDLE_FILENAME;
 
 const buildDefaults: InlineConfig = {
     build: {
         ssrEmitAssets: true,
-        outDir: "dist",
+        outDir: DEFAULT_OUT_DIR,
         minify: true,
         cssMinify: false,
     },
@@ -24,18 +31,27 @@ const buildDefaults: InlineConfig = {
     },
 };
 
-const build = async (options: BuildOptions): Promise<void> => {
+const build = async (options: BuildOptions): Promise<string> => {
     const { entry, assetBase, vite: viteConfig } = options;
     const root = viteConfig?.root ?? process.cwd();
+    const assetsDir = viteConfig?.build?.assetsDir ?? DEFAULT_ASSETS_DIR;
 
     const forced: InlineConfig = {
-        plugins: [...gtkxVitePlugins(BUILD_MODE), gtkxWorker(), gtkxBuiltUrl(assetBase), gtkxNative(root)],
+        plugins: [
+            ...gtkxVitePlugins(BUILD_MODE),
+            gtkxWorker(),
+            gtkxBuiltUrl(assetBase),
+            gtkxNative(root),
+            gtkxSelfContained(),
+        ],
         build: {
             ssr: entry,
             assetsInlineLimit: 0,
             rolldownOptions: {
                 output: {
-                    entryFileNames: "bundle.js",
+                    entryFileNames: ENTRY_FILE_NAMES,
+                    chunkFileNames: posix.join(assetsDir, CHUNK_STEM + ESM_EXTENSION),
+                    keepNames: true,
                 },
             },
         },
@@ -43,6 +59,8 @@ const build = async (options: BuildOptions): Promise<void> => {
 
     const merged: InlineConfig = mergeConfig(mergeConfig(buildDefaults, viteConfig ?? {}), forced);
     await viteBuild({ ...merged, ssr: { ...merged.ssr, noExternal: true } });
+
+    return join(merged.build?.outDir ?? DEFAULT_OUT_DIR, ENTRY_FILE_NAMES);
 };
 
 export { build };

package/src/cli.ts

@@ -1,9 +1,9 @@
-import { packageVersion } from "@gtkx/utils";
 import { defineCommand, runMain } from "citty";
+import packageManifest from "../package.json" with { type: "json" };
 import { splitApplicationArgs } from "./internal/application-args.js";
 import { withErrorBoundary } from "./internal/errors.js";
 
-const version = packageVersion(import.meta.url, "../package.json");
+const version = packageManifest.version;
 const { cliArgs } = splitApplicationArgs(process.argv.slice(2));
 
 const main = defineCommand({
@@ -23,6 +23,11 @@ const main = defineCommand({
 
             return withErrorBoundary(build);
         },
+        deploy: async () => {
+            const { deploy } = await import("./commands/deploy.js");
+
+            return withErrorBoundary(deploy);
+        },
         codegen: async () => {
             const { codegen } = await import("./commands/codegen.js");
 

package/src/codegen/freshness.ts

@@ -30,7 +30,7 @@ const namespaceBarrelPath = (giStoreDir: string, library: string): string => {
 const hasManifest = (storeDir: string): boolean => existsSync(join(storeDir, "package.json"));
 
 const isGiStoreStale = (store: CodegenStore, libraries: string[]): boolean => {
-    if (!existsSync(store.giLinkDir) || !hasManifest(store.giStoreDir)) {
+    if (!hasManifest(store.giStoreDir)) {
         return true;
     }
 
@@ -42,7 +42,7 @@ const isReactStoreStale = (store: CodegenStore): boolean => {
         return false;
     }
 
-    if (!existsSync(store.jsxLinkDir) || !hasManifest(store.jsxStoreDir)) {
+    if (!hasManifest(store.jsxStoreDir)) {
         return true;
     }
 

package/src/codegen/report.ts

@@ -17,6 +17,10 @@ const formatCodegenResult = (result: RunCodegenResult, totalMs: number): string[
         details.push(`girPath=${result.girPath.join(":")}`);
     }
 
+    if (result.future && result.future.length > 0) {
+        details.push(`future=${result.future.join(", ")}`);
+    }
+
     details.push(
         `${String(result.namespaces)} namespaces, ${String(result.intrinsicElements)} intrinsic elements ` +
         `in ${String(result.duration)}ms (total ${String(totalMs)}ms)`,

package/src/codegen/run-codegen.ts

@@ -1,4 +1,5 @@
 import { runCodegen as runCodegenCore } from "@gtkx/codegen";
+import { getShadowingStorePaths, sweepProjectStaging } from "@gtkx/codegen/internal";
 import { type Config, loadConfig } from "@gtkx/config";
 import {
     resolveElementComponents,
@@ -12,7 +13,7 @@ import { resolve } from "node:path";
 import { resolveDataDir } from "../internal/data-dir.js";
 import { emitSchemaEnv } from "../settings/schema.js";
 import { type CodegenInputs, isCodegenStale, resolveCodegenInputs } from "./freshness.js";
-import { type CodegenStore, resolveCodegenContext } from "./store-resolver.js";
+import { type CodegenContext, type CodegenStore, resolveCodegenContext } from "./store-resolver.js";
 
 type RunCodegenOptions = {
     cwd?: string;
@@ -35,6 +36,7 @@ type RunCodegenResult = {
     girPath?: string[] | undefined;
     configFile?: string | undefined;
     libraries?: string[] | undefined;
+    future?: string[] | undefined;
 };
 
 type CodegenOptionsInput = {
@@ -42,9 +44,11 @@ type CodegenOptionsInput = {
     libraries: string[];
     girPath: string[];
     elements: Config["elements"];
+    isByteArrayTyped: boolean;
 };
 
 type PreparedCodegen = CodegenInputs & { isForced: boolean };
+type EnsureGeneratedOptions = { shouldAnnounce?: boolean; mode?: string };
 
 type RunOptionsInput = {
     root: string;
@@ -58,20 +62,21 @@ const GIR_PATH_MISSING_MESSAGE =
     "(Linux: `sudo dnf install gobject-introspection-devel` or `sudo apt install libgirepository1.0-dev`), " +
     "or set `girPath` in gtkx.config.ts.";
 
-const removeSharedStoreShadow = (cwd: string): void => {
-    for (const path of [
-        resolve(cwd, "node_modules/.gtkx/gi"),
-        resolve(cwd, "node_modules/.gtkx/jsx"),
-        resolve(cwd, "node_modules/@gtkx/gi"),
-        resolve(cwd, "node_modules/@gtkx/jsx"),
-    ]) {
+const removeStores = (paths: string[]): void => {
+    for (const path of paths) {
         rmSync(path, { recursive: true, force: true });
     }
 };
 
-const codegenOptions = ({ store, libraries, girPath, elements }: CodegenOptionsInput) => ({
+const removeShadowingStores = (cwd: string): void => {
+    sweepProjectStaging(cwd);
+    removeStores(getShadowingStorePaths(cwd));
+};
+
+const codegenOptions = ({ store, libraries, girPath, elements, isByteArrayTyped }: CodegenOptionsInput) => ({
     libraries,
     girPath,
+    isByteArrayTyped,
     gi: {
         storeDir: store.giStoreDir,
         linkDir: store.giLinkDir,
@@ -92,6 +97,11 @@ const codegenOptions = ({ store, libraries, girPath, elements }: CodegenOptionsI
     userOmittedProps: resolveOmittedProps(elements),
 });
 
+const enabledFutureFlags = (config: Config): string[] =>
+    Object.entries(config.future ?? {})
+        .filter(([, value]) => value === true)
+        .map(([name]) => name);
+
 const disabledCodegenResult = (configFile: string): RunCodegenResult => ({
     isRegenerated: false,
     namespaces: 0,
@@ -102,10 +112,16 @@ const disabledCodegenResult = (configFile: string): RunCodegenResult => ({
     libraries: [],
 });
 
-const clearGeneratedStores = (store: CodegenStore): void => {
-    for (const path of [store.giStoreDir, store.giLinkDir, store.jsxStoreDir, store.jsxLinkDir]) {
-        rmSync(path, { recursive: true, force: true });
+const regeneratedStorePaths = (store: CodegenStore): string[] => {
+    if (store.react === null) {
+        return [store.giStoreDir, store.giLinkDir];
     }
+
+    return [store.giStoreDir, store.giLinkDir, store.jsxStoreDir, store.jsxLinkDir];
+};
+
+const clearGeneratedStores = (store: CodegenStore): void => {
+    removeStores(regeneratedStorePaths(store));
 };
 
 const resolveLoadedConfig = async (options: RunCodegenOptions, cwd: string): Promise<LoadedConfig> =>
@@ -128,7 +144,7 @@ const runCodegen = async (options: RunCodegenOptions = {}): Promise<RunCodegenRe
     const { config, configFile } = await resolveLoadedConfig(options, cwd);
 
     if (config.codegen === false) {
-        removeSharedStoreShadow(cwd);
+        removeShadowingStores(cwd);
 
         return disabledCodegenResult(configFile);
     }
@@ -145,6 +161,7 @@ const runCodegen = async (options: RunCodegenOptions = {}): Promise<RunCodegenRe
             libraries,
             girPath,
             elements: config.elements,
+            isByteArrayTyped: config.future?.v2ByteArrays === true,
         }),
         isForced,
     });
@@ -157,6 +174,7 @@ const runCodegen = async (options: RunCodegenOptions = {}): Promise<RunCodegenRe
         girPath,
         configFile,
         libraries,
+        future: enabledFutureFlags(config),
     };
 };
 
@@ -200,20 +218,15 @@ const getRunOptions = ({ root, mode, inputs, resolved }: RunOptionsInput): RunCo
     return { cwd: root, mode, inputs, resolved };
 };
 
-/* eslint-disable-next-line unicorn/consistent-boolean-name -- the boolean reports whether codegen ran */
-const ensureGenerated = async (
-    cwd: string,
-    options: { shouldAnnounce?: boolean; mode?: string } = {},
-): Promise<boolean> => {
-    if (options.shouldAnnounce && process.env.GTKX_DISABLE_PREFLIGHT === "1") {
-        return false;
-    }
+const isPreflightSkipped = (options: EnsureGeneratedOptions): boolean =>
+    options.shouldAnnounce === true && process.env.GTKX_DISABLE_PREFLIGHT === "1";
 
-    const context = await resolveCodegenContext(cwd, options.mode);
-    syncSchemaEnv(cwd);
+/* eslint-disable-next-line unicorn/consistent-boolean-name -- the boolean reports whether codegen ran */
+const generate = async (context: CodegenContext, options: EnsureGeneratedOptions): Promise<boolean> => {
+    syncSchemaEnv(context.root);
 
     if (context.config.codegen === false) {
-        removeSharedStoreShadow(context.root);
+        removeShadowingStores(context.root);
 
         return false;
     }
@@ -226,6 +239,16 @@ const ensureGenerated = async (
     return result.isRegenerated;
 };
 
+/* eslint-disable-next-line unicorn/consistent-boolean-name -- the boolean reports whether codegen ran */
+const ensureGeneratedIn = async (
+    context: CodegenContext,
+    options: EnsureGeneratedOptions = {},
+): Promise<boolean> => (isPreflightSkipped(options) ? false : generate(context, options));
+
+/* eslint-disable-next-line unicorn/consistent-boolean-name -- the boolean reports whether codegen ran */
+const ensureGenerated = async (cwd: string, options: EnsureGeneratedOptions = {}): Promise<boolean> =>
+    isPreflightSkipped(options) ? false : generate(await resolveCodegenContext(cwd, options.mode), options);
+
 const resolveConfigWatch = async (
     cwd: string,
     mode?: string,
@@ -245,6 +268,7 @@ export {
     isCodegenDisabled,
     syncSchemaEnv,
     ensureGenerated,
+    ensureGeneratedIn,
     resolveConfigWatch,
     type RunCodegenResult,
 };

package/src/codegen/store-resolver.ts

@@ -83,4 +83,4 @@ const resolveCodegenContext = async (cwd: string, mode?: string): Promise<Codege
     return { root: cwd, config, configFile };
 };
 
-export { resolveCodegenStore, resolveCodegenContext, type CodegenStore };
+export { resolveCodegenStore, resolveCodegenContext, type CodegenContext, type CodegenStore };

package/src/commands/build.ts

@@ -1,8 +1,8 @@
 import { info } from "@gtkx/utils";
 import { defineCommand } from "citty";
 import { build as buildApp } from "../builder.js";
-import { ensureGenerated } from "../codegen/run-codegen.js";
-import { entryArg, resolveEntry } from "../internal/entry-arg.js";
+import { entryArg } from "../internal/entry-arg.js";
+import { prepareProject } from "../internal/prepare-project.js";
 
 const BUILD_MODE = "production";
 
@@ -19,11 +19,10 @@ const build = defineCommand({
         },
     },
     async run({ args }) {
-        const { cwd, entry } = resolveEntry(args);
+        const { cwd, entry } = await prepareProject(args, BUILD_MODE);
         info(`Building ${entry}`);
-        await ensureGenerated(cwd, { shouldAnnounce: true, mode: BUILD_MODE });
 
-        await buildApp({
+        const bundlePath = await buildApp({
             entry,
             assetBase: args["asset-base"],
             vite: {
@@ -31,7 +30,7 @@ const build = defineCommand({
             },
         });
 
-        info("Build complete: dist/bundle.js");
+        info(`Build complete: ${bundlePath}`);
     },
 });
 

package/src/commands/codegen.ts

@@ -4,6 +4,11 @@ import { formatCodegenResult } from "../codegen/report.js";
 import { ensureGenerated, isCodegenDisabled, runCodegen, syncSchemaEnv } from "../codegen/run-codegen.js";
 import { cwdArg, resolveCwd } from "../internal/entry-arg.js";
 
+const FORCED_WHILE_DISABLED_MESSAGE =
+    "codegen is disabled for this project, so --force has no store to regenerate here. " +
+    "Remove `codegen: false` from gtkx.config.ts, or run `gtkx codegen --force` where the installed " +
+    "binding store is generated.";
+
 const codegen = defineCommand({
     meta: {
         name: "codegen",
@@ -19,8 +24,10 @@ const codegen = defineCommand({
     },
     async run({ args }) {
         const cwd = resolveCwd(args);
+        const isDisabled = await isCodegenDisabled(cwd);
+        checkForce(isDisabled, args.force);
 
-        if (await isCodegenDisabled(cwd)) {
+        if (isDisabled) {
             await runCodegen({ cwd });
             syncSchemaEnv(cwd);
             info("codegen: disabled for this project; reusing an installed binding store");
@@ -46,4 +53,10 @@ const codegen = defineCommand({
     },
 });
 
+const checkForce = (isDisabled: boolean, isForced: boolean): void => {
+    if (isDisabled && isForced) {
+        throw new Error(FORCED_WHILE_DISABLED_MESSAGE);
+    }
+};
+
 export { codegen };

package/src/commands/deploy.ts

@@ -0,0 +1,47 @@
+import { defineCommand } from "citty";
+import { KNOWN_NAMES } from "../deploy/registry.js";
+import { runDeploy } from "../deploy/run-deploy.js";
+import { entryArg } from "../internal/entry-arg.js";
+import { resolveProject } from "../internal/prepare-project.js";
+
+const DEPLOY_MODE = "production";
+
+const deploy = defineCommand({
+    meta: {
+        name: "deploy",
+        description: "Package the application for distribution",
+    },
+    args: {
+        ...entryArg,
+        target: {
+            type: "string",
+            description: `Comma-separated package formats to build (${KNOWN_NAMES})`,
+        },
+        out: {
+            type: "string",
+            description: "Output directory relative to the project root (default: build)",
+        },
+        "print-manifests": {
+            type: "boolean",
+            description: "Write the generated manifests and metadata, then stop without packaging",
+        },
+        "skip-build": {
+            type: "boolean",
+            description: "Package what is already in dist/ instead of rebuilding",
+        },
+    },
+    async run({ args }) {
+        const { cwd, entry } = await resolveProject(args, DEPLOY_MODE);
+
+        await runDeploy({
+            entry,
+            cwd,
+            targets: args.target,
+            outDir: args.out,
+            shouldPrintManifests: args["print-manifests"] === true,
+            shouldSkipBuild: args["skip-build"] === true,
+        });
+    },
+});
+
+export { deploy };

package/src/commands/dev.ts

@@ -1,8 +1,9 @@
 import { defineCommand } from "citty";
-import { ensureGenerated, resolveConfigWatch } from "../codegen/run-codegen.js";
+import { resolveConfigWatch } from "../codegen/run-codegen.js";
 import { type DevWatch, runDevSupervisor } from "../dev/supervisor.js";
 import { splitApplicationArgs } from "../internal/application-args.js";
-import { entryArg, resolveEntry } from "../internal/entry-arg.js";
+import { entryArg } from "../internal/entry-arg.js";
+import { prepareProject } from "../internal/prepare-project.js";
 
 const DEV_MODE = "development";
 
@@ -15,8 +16,7 @@ const dev = defineCommand({
         ...entryArg,
     },
     async run({ args }) {
-        const { cwd, entry: entryPath } = resolveEntry(args);
-        await ensureGenerated(cwd, { shouldAnnounce: true, mode: DEV_MODE });
+        const { cwd, entry: entryPath } = await prepareProject(args, DEV_MODE);
         const watch: DevWatch | undefined = await resolveConfigWatch(cwd, DEV_MODE);
         const { applicationArgs } = splitApplicationArgs(process.argv.slice(2));
         await runDevSupervisor({ entryPath, cwd, args: applicationArgs, watch });

package/src/commands/docs.ts

@@ -13,7 +13,7 @@ import { resolveOmittedProps } from "@gtkx/config/internal";
 import { info } from "@gtkx/utils";
 import { defineCommand } from "citty";
 import { existsSync } from "node:fs";
-import { resolve } from "node:path";
+import { isAbsolute, relative, resolve, sep } from "node:path";
 import { cwdArg, resolveCwd } from "../internal/entry-arg.js";
 
 const docs = defineCommand({
@@ -25,7 +25,9 @@ const docs = defineCommand({
     args: {
         out: {
             type: "string",
-            description: "Output directory for the generated markdown pages, relative to the project root",
+            description:
+                "Output directory for the generated markdown pages, below the project root. It must be empty " +
+                "or hold an earlier `gtkx docs` run, whose pages are replaced",
             default: "docs/reference",
         },
         "base-path": {
@@ -35,7 +37,9 @@ const docs = defineCommand({
         },
         force: {
             type: "boolean",
-            description: "Regenerate even when the pages are up to date with the GIR libraries",
+            description:
+                "Regenerate even when the pages are up to date with the GIR libraries, the base path, " +
+                "and the element props the project configures",
             default: false,
         },
         ...cwdArg,
@@ -63,7 +67,7 @@ const docs = defineCommand({
 
         const libraries = resolveLibraries(config.libraries, girPath);
         const startedAt = Date.now();
-        const outDir = resolve(cwd, args.out);
+        const outDir = resolveOutDir(cwd, args.out);
         const builtin = await resolveDocsElements(cwd);
 
         const { isRegenerated, namespaces } = writeDocs({
@@ -74,6 +78,7 @@ const docs = defineCommand({
             props: builtin.props,
             omittedProps: mergeOmittedProps(builtin.omittedProps, resolveOmittedProps(config.elements)),
             isForced: args.force,
+            isByteArrayTyped: config.future?.v2ByteArrays === true,
         });
 
         if (!isRegenerated) {
@@ -91,6 +96,37 @@ const docs = defineCommand({
     },
 });
 
+const isBelow = (parent: string, child: string): boolean => {
+    const path = relative(parent, child);
+
+    return path !== "" && path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path);
+};
+
+const outDirReason = (cwd: string, out: string, outDir: string): string => {
+    if (out.trim() === "") {
+        return "it was empty, which names the project root itself";
+    }
+
+    if (outDir === cwd) {
+        return "it names the project root itself";
+    }
+
+    return `${outDir} is outside it`;
+};
+
+const resolveOutDir = (cwd: string, out: string): string => {
+    const outDir = out.trim() === "" ? cwd : resolve(cwd, out);
+
+    if (isBelow(cwd, outDir)) {
+        return outDir;
+    }
+
+    throw new Error(
+        `--out must name a directory below the project root ${cwd}, and ${outDirReason(cwd, out, outDir)}. ` +
+        "Pass a path such as --out=docs/reference.",
+    );
+};
+
 const resolveDocsElements = async (cwd: string): Promise<{ props: ElementProps; omittedProps: OmittedProps }> => {
     const { gi, reactSubexports } = resolveStore(cwd);
 

package/src/deploy/depends.ts

@@ -0,0 +1,42 @@
+import type { DeployConfig } from "./types.js";
+
+type Relations = {
+    deb: string[];
+    rpm: string[];
+};
+
+const GLES_SONAME = "libGLESv2.so.2()(64bit)";
+
+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 libraryDepends = (libraries: string[]): Relations => ({
+    deb: libraries.flatMap((library) => DEPENDS_BY_LIBRARY[library]?.deb ?? []),
+    rpm: libraries.flatMap((library) => DEPENDS_BY_LIBRARY[library]?.rpm ?? []),
+});
+
+const glibcDepends = (glibcFloor: string | null): Relations =>
+    glibcFloor === null ? { deb: [], rpm: [] } : { deb: [`libc6 (>= ${glibcFloor})`], rpm: [`glibc >= ${glibcFloor}`] };
+
+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);
+
+    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 ?? [])]),
+    };
+};
+
+export { resolveDepends };