@gtkx/cli 2.0.0-beta.1 → 2.0.0-beta.10

package/src/codegen/run-codegen.ts

@@ -2,6 +2,7 @@ import { runCodegen as runCodegenCore } from "@gtkx/codegen";
 import { getShadowingStorePaths, sweepProjectStaging } from "@gtkx/codegen/internal";
 import { type Config, loadConfig } from "@gtkx/config";
 import {
+    configDependenciesFor,
     isAgentRulesEnabled,
     resolveElementComponents,
     resolveElementProps,
@@ -10,13 +11,14 @@ import {
 } from "@gtkx/config/internal";
 import { info } from "@gtkx/utils";
 import { existsSync, rmSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { join, relative, resolve } from "node:path";
 import { resolveCatalogProject, synchronizeCatalogs } from "../i18n/catalogs.js";
 import { extractSourceCatalog } from "../i18n/source-messages.js";
 import { clearI18nTypes, emitI18nTypes } from "../i18n/types.js";
 import { upsertAgentRules } from "../internal/agent-rules.js";
 import { discoverSourceFiles } from "../internal/source-imports.js";
 import { emitSchemaEnv } from "../settings/schema.js";
+import { resolveConfigDependencies } from "./config-dependencies.js";
 import { type CodegenInputs, isCodegenStale, resolveCodegenInputs } from "./freshness.js";
 import { type ReferenceResult, writeReference } from "./reference.js";
 import { type CodegenContext, type CodegenStore, resolveCodegenContext } from "./store-resolver.js";
@@ -24,6 +26,7 @@ import { type CodegenContext, type CodegenStore, resolveCodegenContext } from ".
 type RunCodegenOptions = {
     cwd?: string;
     mode?: string | undefined;
+    configFile?: string | undefined;
     isForced?: boolean;
     inputs?: CodegenInputs;
     resolved?: LoadedConfig;
@@ -58,6 +61,7 @@ type PreparedCodegen = CodegenInputs & { isForced: boolean };
 type EnsureGeneratedOptions = {
     shouldAnnounce?: boolean;
     mode?: string;
+    configFile?: string | undefined;
     shouldPreserveI18nMetadata?: boolean | undefined;
 };
 
@@ -84,6 +88,7 @@ const codegenOptions = ({ store, libraries, girPath, elements }: CodegenOptionsI
         storeDir: store.giStoreDir,
         linkDir: store.giLinkDir,
         version: store.runtimeVersion,
+        owner: store.owner,
     },
     jsx:
         store.react === null
@@ -92,6 +97,7 @@ const codegenOptions = ({ store, libraries, girPath, elements }: CodegenOptionsI
                     storeDir: store.jsxStoreDir,
                     linkDir: store.jsxLinkDir,
                     version: store.react.version,
+                    owner: store.owner,
                 },
     userComponents: resolveElementComponents(elements),
     userProps: resolveElementProps(elements),
@@ -109,14 +115,6 @@ const disabledCodegenResult = (configFile: string): RunCodegenResult => ({
     libraries: [],
 });
 
-const clearGeneratedStores = (store: CodegenStore): void => {
-    removeStores(
-        store.react === null
-            ? [store.giStoreDir, store.giLinkDir]
-            : [store.giStoreDir, store.giLinkDir, store.jsxStoreDir, store.jsxLinkDir],
-    );
-};
-
 const prepareCodegen = (options: RunCodegenOptions, cwd: string, config: Config): PreparedCodegen => {
     const { girPath, libraries, store } = options.inputs ?? resolveCodegenInputs(cwd, config);
 
@@ -131,7 +129,10 @@ const prepareCodegen = (options: RunCodegenOptions, cwd: string, config: Config)
 
 const runCodegen = async (options: RunCodegenOptions = {}): Promise<RunCodegenResult> => {
     const cwd = options.cwd ?? process.cwd();
-    const { config, configFile } = options.resolved ?? (await loadConfig(cwd, { mode: options.mode }));
+    const { config, configFile } = options.resolved ?? (await loadConfig(cwd, {
+        mode: options.mode,
+        configFile: options.configFile,
+    }));
     await syncI18n(cwd, config.applicationId, options.shouldPreserveI18nMetadata);
     emitSchemaEnv(cwd);
 
@@ -143,10 +144,6 @@ const runCodegen = async (options: RunCodegenOptions = {}): Promise<RunCodegenRe
 
     const { girPath, libraries, store, isForced } = prepareCodegen(options, cwd, config);
 
-    if (options.isForced) {
-        clearGeneratedStores(store);
-    }
-
     const result = await runCodegenCore({
         ...codegenOptions({ store, libraries, girPath, elements: config.elements }),
         isForced,
@@ -190,9 +187,9 @@ const syncI18n = async (
     await emitI18nTypes(root);
 };
 
-const isCodegenDisabled = async (cwd: string, mode?: string): Promise<boolean> => {
+const isCodegenDisabled = async (cwd: string, mode?: string, configFile?: string): Promise<boolean> => {
     try {
-        const { config } = await loadConfig(cwd, { mode });
+        const { config } = await loadConfig(cwd, { mode, configFile });
 
         return config.codegen === false;
     } catch {
@@ -257,18 +254,51 @@ const ensureGeneratedIn = async (
 
 /* 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);
+    isPreflightSkipped(options)
+        ? false
+        : generate(await resolveCodegenContext(cwd, options.mode, options.configFile), options);
 
 const resolveConfigWatch = async (
     cwd: string,
     mode?: string,
-): Promise<{ paths: string[]; regenerate: () => Promise<void> }> => {
-    const { configFile, root } = await loadConfig(cwd, { mode });
+    configFile?: string,
+    initialDependencies: string[] = [],
+): Promise<{ paths: string[]; resolvePaths: () => string[]; regenerate: () => Promise<string[]> }> => {
+    let selectedConfigFile: string;
+
+    if (configFile === undefined) {
+        const loaded = await loadConfig(cwd, { mode });
+        selectedConfigFile = loaded.configFile;
+    } else {
+        selectedConfigFile = resolve(cwd, configFile);
+    }
+
+    let knownDependencies = initialDependencies;
+    const selectedConfigName = relative(cwd, selectedConfigFile);
+    const resolvePaths = (): string[] => [
+        ...new Set(
+            [selectedConfigFile, ...knownDependencies]
+                .flatMap((path) => resolveConfigDependencies(path, selectedConfigName, cwd)),
+        ),
+    ];
 
     return {
-        paths: [resolve(root, configFile)],
+        paths: resolvePaths(),
+        resolvePaths,
         regenerate: async () => {
-            await runCodegen({ cwd: root, mode });
+            let loaded: Awaited<ReturnType<typeof loadConfig>>;
+
+            try {
+                loaded = await loadConfig(cwd, { mode, configFile: selectedConfigFile });
+            } catch (error) {
+                knownDependencies = [...new Set([...knownDependencies, ...configDependenciesFor(error)])];
+                throw error;
+            }
+
+            knownDependencies = configDependenciesFor(loaded);
+            await runCodegen({ cwd, mode, resolved: loaded });
+
+            return resolvePaths();
         },
     };
 };

package/src/codegen/store-resolver.ts

@@ -1,6 +1,7 @@
 import { resolveStore } from "@gtkx/codegen";
 import { type Config, loadConfig } from "@gtkx/config";
-import { existsSync } from "node:fs";
+import { configDependenciesFor } from "@gtkx/config/internal";
+import { existsSync, realpathSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -11,6 +12,7 @@ type CodegenStore = {
     jsxStoreDir: string;
     jsxLinkDir: string;
     runtimeVersion: string;
+    owner: string;
     react: CodegenReactPackage | null;
 };
 
@@ -22,6 +24,7 @@ type CodegenContext = {
     root: string;
     config: Config;
     configFile: string;
+    configDependencies: string[];
 };
 
 const hasPackage = (require: NodeJS.Require, dir: string, packageName: string): boolean => {
@@ -54,6 +57,7 @@ const resolveCodegenStore = (dir: string): CodegenStore => {
         jsxStoreDir: store.jsx?.storeDir ?? siblingStore(store.gi.storeDir),
         jsxLinkDir: store.jsx?.linkDir ?? siblingStore(store.gi.linkDir),
         runtimeVersion: store.gi.version,
+        owner: store.gi.owner ?? realpathSync(dir),
         react:
             hasReactRuntime && store.jsx !== null
                 ? { version: store.jsx.version }
@@ -61,10 +65,11 @@ const resolveCodegenStore = (dir: string): CodegenStore => {
     };
 };
 
-const resolveCodegenContext = async (cwd: string, mode?: string): Promise<CodegenContext> => {
-    const { config, configFile } = await loadConfig(cwd, { mode });
+const resolveCodegenContext = async (cwd: string, mode?: string, selectedConfig?: string): Promise<CodegenContext> => {
+    const loaded = await loadConfig(cwd, { mode, configFile: selectedConfig });
+    const { config, configFile } = loaded;
 
-    return { root: cwd, config, configFile };
+    return { root: cwd, config, configFile, configDependencies: configDependenciesFor(loaded) };
 };
 
 export { resolveCodegenStore, resolveCodegenContext, type CodegenContext, type CodegenStore };

package/src/commands/build.ts

@@ -1,7 +1,8 @@
 import { info } from "@gtkx/utils";
 import { defineCommand } from "citty";
 import { build as buildApp } from "../builder.js";
-import { entryArg } from "../internal/entry-arg.js";
+import { prepareBuildOutDir, resolveBuildOutDir } from "../internal/build-output.js";
+import { configArg, entryArg } from "../internal/entry-arg.js";
 import { prepareProject } from "../internal/prepare-project.js";
 
 const BUILD_MODE = "production";
@@ -13,18 +14,28 @@ const build = defineCommand({
     },
     args: {
         ...entryArg,
+        ...configArg,
+        out: {
+            type: "string",
+            description: "Output directory below the project root (default: dist)",
+        },
     },
     async run({ args }) {
-        const { cwd, entry } = await prepareProject(args, BUILD_MODE);
+        const { cwd, entry, configFile } = await prepareProject(args, BUILD_MODE);
+        const outDir = resolveBuildOutDir(cwd, args.out);
+        using preparedOutput = prepareBuildOutDir(cwd, outDir);
         info(`Building ${entry}`);
 
         const bundlePath = await buildApp({
             entry,
+            configFile,
             vite: {
                 root: cwd,
+                build: { outDir: preparedOutput.path, emptyOutDir: false },
             },
         });
 
+        preparedOutput.commit();
         info(`Build complete: ${bundlePath}`);
     },
 });

package/src/commands/cleanup.ts

@@ -0,0 +1,48 @@
+import { info } from "@gtkx/utils";
+import { findStaleHeadlessDisplays, reapStaleHeadlessDisplays } from "@gtkx/vitest/headless";
+import { defineCommand } from "citty";
+import { findStaleCompileCaches, reapStaleCompileCaches } from "../internal/compile-cache-store.js";
+import { cwdArg } from "../internal/entry-arg.js";
+
+const DISPLAY_LABEL = "stale headless runtime directories";
+const COMPILE_CACHE_LABEL = "stale compile cache directories";
+
+const report = (paths: string[]): void => {
+    for (const path of paths) {
+        info(`cleanup: ${path}`);
+    }
+};
+
+const cleanup = defineCommand({
+    meta: {
+        name: "cleanup",
+        description: "Remove stale GTKX headless runtime and compile cache directories",
+    },
+    args: {
+        "dry-run": {
+            type: "boolean",
+            description: "List stale directories without removing them",
+        },
+        ...cwdArg,
+    },
+    run({ args }) {
+        const displays = findStaleHeadlessDisplays();
+        const compileCaches = findStaleCompileCaches();
+        report(displays.map((candidate) => candidate.runtimeDir));
+        report(compileCaches);
+
+        if (args["dry-run"] === true) {
+            info(`cleanup: found ${String(displays.length)} ${DISPLAY_LABEL}`);
+            info(`cleanup: found ${String(compileCaches.length)} ${COMPILE_CACHE_LABEL}`);
+
+            return;
+        }
+
+        const removedDisplays = reapStaleHeadlessDisplays(displays);
+        const removedCaches = reapStaleCompileCaches(compileCaches);
+        info(`cleanup: removed ${String(removedDisplays.length)} ${DISPLAY_LABEL}`);
+        info(`cleanup: removed ${String(removedCaches.length)} ${COMPILE_CACHE_LABEL}`);
+    },
+});
+
+export { cleanup };

package/src/commands/codegen.ts

@@ -2,7 +2,7 @@ import { info } from "@gtkx/utils";
 import { defineCommand } from "citty";
 import { formatCodegenResult } from "../codegen/report.js";
 import { ensureGenerated, isCodegenDisabled, runCodegen } from "../codegen/run-codegen.js";
-import { cwdArg, resolveCwd } from "../internal/entry-arg.js";
+import { configArg, 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. " +
@@ -20,29 +20,30 @@ const codegen = defineCommand({
             description: "Wipe the generated store and regenerate unconditionally (recover a corrupted store)",
             default: false,
         },
+        ...configArg,
         ...cwdArg,
     },
     async run({ args }) {
         const cwd = resolveCwd(args);
-        const isDisabled = await isCodegenDisabled(cwd);
+        const isDisabled = await isCodegenDisabled(cwd, undefined, args.config);
         checkForce(isDisabled, args.force);
 
         if (isDisabled) {
-            await runCodegen({ cwd });
+            await runCodegen({ cwd, configFile: args.config });
             info("codegen: disabled for this project; reusing an installed binding store");
 
             return;
         }
 
         if (!args.force) {
-            const isRan = await ensureGenerated(cwd);
+            const isRan = await ensureGenerated(cwd, { configFile: args.config });
             info(isRan ? "codegen: regenerated stale bindings" : "codegen: bindings up to date");
 
             return;
         }
 
         const startedAt = Date.now();
-        const result = await runCodegen({ cwd, isForced: true });
+        const result = await runCodegen({ cwd, configFile: args.config, isForced: true });
         const lines = formatCodegenResult(result, Date.now() - startedAt);
 
         for (const line of lines) {

package/src/commands/deploy.ts

@@ -1,7 +1,8 @@
 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 { KNOWN_ARCH_NAMES } from "../deploy/settings/arch.js";
+import { configArg, entryArg } from "../internal/entry-arg.js";
 import { resolveProject } from "../internal/prepare-project.js";
 
 const DEPLOY_MODE = "production";
@@ -13,10 +14,15 @@ const deploy = defineCommand({
     },
     args: {
         ...entryArg,
+        ...configArg,
         target: {
             type: "string",
             description: `Comma-separated package formats to build (${KNOWN_NAMES})`,
         },
+        arch: {
+            type: "string",
+            description: `Comma-separated architectures to build (${KNOWN_ARCH_NAMES}; default: the host)`,
+        },
         out: {
             type: "string",
             description: "Output directory relative to the project root (default: build)",
@@ -31,12 +37,14 @@ const deploy = defineCommand({
         },
     },
     async run({ args }) {
-        const { cwd, entry } = await resolveProject(args, DEPLOY_MODE);
+        const { cwd, entry, configFile } = await resolveProject(args, DEPLOY_MODE);
 
         await runDeploy({
             entry,
             cwd,
+            configFile,
             targets: args.target,
+            arches: args.arch,
             outDir: args.out,
             shouldPrintManifests: args["print-manifests"] === true,
             shouldSkipBuild: args["skip-build"] === true,

package/src/commands/dev.ts

@@ -1,8 +1,12 @@
+import { armParentDeath } from "@gtkx/native/internal";
+import { reapStaleHeadlessDisplaysAtStartup } from "@gtkx/vitest/headless";
 import { defineCommand } from "citty";
 import { resolveConfigWatch } from "../codegen/run-codegen.js";
+import { startHeadlessDevDisplay } from "../dev/headless.js";
 import { type DevWatch, runDevSupervisor } from "../dev/supervisor.js";
 import { splitApplicationArgs } from "../internal/application-args.js";
-import { entryArg } from "../internal/entry-arg.js";
+import { configArg, entryArg } from "../internal/entry-arg.js";
+import { getInitialProcessGroupOwner, initialParentId } from "../internal/parent-process.js";
 import { prepareProject } from "../internal/prepare-project.js";
 
 const DEV_MODE = "development";
@@ -14,12 +18,49 @@ const dev = defineCommand({
     },
     args: {
         ...entryArg,
+        ...configArg,
+        headless: {
+            type: "boolean",
+            description: "Run on an isolated headless Wayland display",
+        },
+        size: {
+            type: "string",
+            description: "Headless display size as WIDTHxHEIGHT",
+        },
     },
     async run({ args }) {
-        const { cwd, entry: entryPath } = await prepareProject(args, DEV_MODE);
-        const watch: DevWatch | undefined = await resolveConfigWatch(cwd, DEV_MODE);
+        reapStaleHeadlessDisplaysAtStartup();
+        const initialProcessGroupOwner = getInitialProcessGroupOwner();
+
+        if (
+            !armParentDeath(
+                initialParentId,
+                initialProcessGroupOwner?.pid,
+                initialProcessGroupOwner?.startTime,
+            )
+        ) {
+            throw new Error("The process that launched gtkx dev exited during startup");
+        }
+
+        if (args.size !== undefined && !args.headless) {
+            throw new Error("--size requires --headless");
+        }
+
+        const { cwd, entry: entryPath, configFile, configDependencies } = await prepareProject(args, DEV_MODE);
+        const watch: DevWatch | undefined = await resolveConfigWatch(
+            cwd,
+            DEV_MODE,
+            configFile,
+            configDependencies,
+        );
         const { applicationArgs } = splitApplicationArgs(process.argv.slice(2));
-        await runDevSupervisor({ entryPath, cwd, args: applicationArgs, watch });
+        const stopHeadless = args.headless ? await startHeadlessDevDisplay(args.size) : undefined;
+
+        try {
+            await runDevSupervisor({ entryPath, cwd, configFile, args: applicationArgs, watch });
+        } finally {
+            stopHeadless?.();
+        }
     },
 });
 

package/src/commands/docs.ts

@@ -68,6 +68,7 @@ const docs = defineCommand({
             outDir,
             basePath: args["base-path"],
             props: builtin.props,
+            acceptedChildTypes: builtin.acceptedChildTypes,
             omittedProps: mergeOmittedProps(builtin.omittedProps, resolveOmittedProps(config.elements)),
             isForced: args.force,
         });

package/src/deploy/depends.ts

@@ -1,13 +1,17 @@
 import type { DeploySettings } from "./types.js";
+import { PACKAGED_SONAMES, type PackagedSoname } from "./node-runtime/sonames.js";
 
 type Relations = {
     deb: string[];
     rpm: string[];
 };
 
-type LibraryPackages = {
+type PackageNames = {
     deb: string;
     rpm: string;
+};
+
+type LibraryPackages = PackageNames & {
     extra: Relations;
 };
 
@@ -25,6 +29,17 @@ const DEPENDS_BY_LIBRARY: Record<string, LibraryPackages> = {
     "Gtk-4.0": { deb: "libgtk-4-1", rpm: "gtk4", extra: { deb: [], rpm: [GLES_SONAME] } },
 };
 
+const RUNTIME_PACKAGES: Record<PackagedSoname, PackageNames> = {
+    "libatomic.so.1": { deb: "libatomic1", rpm: `libatomic.so.1${SONAME_SUFFIX}` },
+    "libgcc_s.so.1": { deb: "libgcc-s1", rpm: `libgcc_s.so.1${SONAME_SUFFIX}` },
+    "libstdc++.so.6": { deb: "libstdc++6", rpm: `libstdc++.so.6${SONAME_SUFFIX}` },
+};
+
+const RUNTIME_DEPENDS: Relations = {
+    deb: PACKAGED_SONAMES.map((soname) => RUNTIME_PACKAGES[soname].deb),
+    rpm: PACKAGED_SONAMES.map((soname) => RUNTIME_PACKAGES[soname].rpm),
+};
+
 const debRelation = (name: string, minimum: string | undefined): string =>
     minimum === undefined ? name : `${name} (>= ${minimum})`;
 
@@ -63,8 +78,20 @@ const resolveDepends = (settings: DeploySettings, glibcMinimum: string | null):
     const extra = settings.deploy.depends ?? {};
 
     return {
-        deb: dedupe([...fromLibraries.deb, ...BASE_DEPENDS.deb, ...fromGlibc.deb, ...(extra.deb ?? [])]),
-        rpm: dedupe([...fromLibraries.rpm, ...BASE_DEPENDS.rpm, ...fromGlibc.rpm, ...(extra.rpm ?? [])]),
+        deb: dedupe([
+            ...fromLibraries.deb,
+            ...BASE_DEPENDS.deb,
+            ...fromGlibc.deb,
+            ...RUNTIME_DEPENDS.deb,
+            ...(extra.deb ?? []),
+        ]),
+        rpm: dedupe([
+            ...fromLibraries.rpm,
+            ...BASE_DEPENDS.rpm,
+            ...fromGlibc.rpm,
+            ...RUNTIME_DEPENDS.rpm,
+            ...(extra.rpm ?? []),
+        ]),
     };
 };
 

package/src/deploy/download.ts

@@ -1,8 +1,8 @@
 import { info, warn } from "@gtkx/utils";
 import { createHash } from "node:crypto";
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
+import { cacheRoot } from "../internal/cache-root.js";
 
 type DigestRequest = {
     url: string;
@@ -11,22 +11,21 @@ type DigestRequest = {
     subject: string;
 };
 
+type DigestAlgorithm = "sha256" | "sha512";
+
 type DownloadRequest = {
     url: string;
     dest: string;
     label: string;
-    sha256: string;
-    freshSha256?: (() => Promise<string>) | undefined;
+    digest: string;
+    algorithm?: DigestAlgorithm | undefined;
+    freshDigest?: (() => Promise<string>) | undefined;
     mode?: number | undefined;
 };
 
-const CACHE_NAMESPACE = "gtkx";
-const DIGEST_PATTERN = /^[\da-f]{64}$/;
-
-const cacheRoot = (): string => {
-    const base = process.env.XDG_CACHE_HOME;
-
-    return join(base !== undefined && base.length > 0 ? base : join(homedir(), ".cache"), CACHE_NAMESPACE);
+const DIGEST_PATTERN: Record<DigestAlgorithm, RegExp> = {
+    sha256: /^[\da-f]{64}$/,
+    sha512: /^[\da-f]{128}$/,
 };
 
 const cacheDir = (segments: string[]): string => {
@@ -36,10 +35,11 @@ const cacheDir = (segments: string[]): string => {
     return dir;
 };
 
-const getDigest = (contents: Buffer): string => createHash("sha256").update(contents).digest("hex");
+const getDigest = (contents: Buffer, algorithm: DigestAlgorithm): string =>
+    createHash(algorithm).update(contents).digest("hex");
 
-const assertDigest = (url: string, contents: Buffer, expected: string): void => {
-    const actual = getDigest(contents);
+const assertDigest = (url: string, contents: Buffer, expected: string, algorithm: DigestAlgorithm): void => {
+    const actual = getDigest(contents, algorithm);
 
     if (actual !== expected) {
         throw new Error(`Checksum mismatch for ${url}\n  expected ${expected}\n  received ${actual}`);
@@ -62,11 +62,11 @@ const fetchText = async (url: string): Promise<string> => {
     return bytes.toString("utf8");
 };
 
-const readCachedDigest = (dest: string): string | undefined => {
+const readCachedDigest = (dest: string, algorithm: DigestAlgorithm): string | undefined => {
     try {
         const cached = readFileSync(dest, "utf8").trim();
 
-        return DIGEST_PATTERN.test(cached) ? cached : undefined;
+        return DIGEST_PATTERN[algorithm].test(cached) ? cached : undefined;
     } catch {
         return undefined;
     }
@@ -82,7 +82,7 @@ const publishedDigest = async (request: DigestRequest): Promise<string> => {
     const checksums = await fetchText(request.url);
     const digest = digestFromChecksums(checksums, request.assetName, request.subject);
 
-    if (!DIGEST_PATTERN.test(digest)) {
+    if (!DIGEST_PATTERN.sha256.test(digest)) {
         throw new Error(`${request.subject} published a malformed checksum for ${request.assetName}: "${digest}"`);
     }
 
@@ -92,17 +92,17 @@ const publishedDigest = async (request: DigestRequest): Promise<string> => {
 };
 
 const cachedDigest = async (request: DigestRequest): Promise<string> => {
-    const cached = readCachedDigest(request.dest);
+    const cached = readCachedDigest(request.dest, "sha256");
 
     return cached ?? publishedDigest(request);
 };
 
-const isCacheUsable = (dest: string, sha256: string): boolean => {
+const isCacheUsable = (dest: string, digest: string, algorithm: DigestAlgorithm): boolean => {
     if (!existsSync(dest)) {
         return false;
     }
 
-    if (getDigest(readFileSync(dest)) === sha256) {
+    if (getDigest(readFileSync(dest), algorithm) === digest) {
         return true;
     }
 
@@ -112,16 +112,17 @@ const isCacheUsable = (dest: string, sha256: string): boolean => {
 };
 
 const downloadFile = async (request: DownloadRequest): Promise<string> => {
-    const { url, dest, label, sha256, mode } = request;
+    const { url, dest, label, digest, mode } = request;
+    const algorithm = request.algorithm ?? "sha256";
 
-    if (isCacheUsable(dest, sha256)) {
+    if (isCacheUsable(dest, digest, algorithm)) {
         return dest;
     }
 
     info(`Downloading ${label}`);
-    const expected = request.freshSha256 === undefined ? sha256 : await request.freshSha256();
+    const expected = request.freshDigest === undefined ? digest : await request.freshDigest();
     const contents = await fetchBytes(url);
-    assertDigest(url, contents, expected);
+    assertDigest(url, contents, expected, algorithm);
     const staging = `${dest}.partial`;
     writeFileSync(staging, contents);
 
@@ -145,4 +146,12 @@ const digestFromChecksums = (checksums: string, assetName: string, subject: stri
     return digest;
 };
 
-export { cacheDir, cachedDigest, type DigestRequest, downloadFile, publishedDigest };
+export {
+    cacheDir,
+    cachedDigest,
+    type DigestRequest,
+    downloadFile,
+    publishedDigest,
+    readCachedDigest,
+    writeAtomically,
+};