@gtkx/cli 1.3.0 → 1.5.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gtkx/cli",
-  "version": "1.3.0",
-  "description": "Command-line tool and Vite plugin stack that scaffolds, develops, builds, and documents GTKX applications",
+  "version": "1.5.0",
+  "description": "GTK app toolchain for React: scaffold, dev server, build, docs.",
   "keywords": [
     "gtkx",
     "gtk",
@@ -70,22 +70,23 @@
     "babel-plugin-react-compiler": "^1.0.0",
     "citty": "^0.2.2",
     "fast-xml-parser": "^5.11.0",
+    "i18next-cli": "1.71.3",
     "react-refresh": "^0.18.0",
     "vite": "^8.2.2",
     "yaml": "^2.9.0",
-    "@gtkx/config": "1.3.0",
-    "@gtkx/codegen": "1.3.0",
-    "@gtkx/runtime": "1.3.0",
-    "@gtkx/mcp": "1.3.0",
-    "@gtkx/utils": "1.3.0",
-    "@gtkx/vitest": "1.3.0",
-    "create-gtkx": "1.3.0"
+    "@gtkx/codegen": "1.5.0",
+    "@gtkx/mcp": "1.5.0",
+    "@gtkx/runtime": "1.5.0",
+    "@gtkx/config": "1.5.0",
+    "@gtkx/utils": "1.5.0",
+    "@gtkx/vitest": "1.5.0",
+    "create-gtkx": "1.5.0"
   },
   "devDependencies": {
     "@types/babel__core": "^7.20.5",
     "@types/react-refresh": "^0.14.7",
     "vitest": "^4.1.11",
-    "@gtkx/testing": "1.3.0"
+    "@gtkx/testing": "1.5.0"
   },
   "peerDependencies": {
     "react": "^19"

package/src/builder.ts

@@ -1,7 +1,7 @@
 import { join, posix } from "node:path";
 import { type InlineConfig, mergeConfig, build as viteBuild } from "vite";
-import { gtkxBuiltUrl } from "./vite-plugins/built-url.js";
-import { gtkxBundledPackages } from "./vite-plugins/bundled-packages.js";
+import { createBuildManifestCollector } from "./internal/build-manifest.js";
+import { gtkxBuildManifest } from "./vite-plugins/build-manifest.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";
@@ -10,7 +10,7 @@ import { gtkxWorker } from "./vite-plugins/worker.js";
 
 type BuildOptions = {
     entry: string;
-    assetBase?: string | undefined;
+    shouldPreserveI18nMetadata?: boolean | undefined;
     vite?: InlineConfig | undefined;
 };
 
@@ -33,17 +33,17 @@ const buildDefaults: InlineConfig = {
 };
 
 const build = async (options: BuildOptions): Promise<string> => {
-    const { entry, assetBase, vite: viteConfig } = options;
+    const { entry, shouldPreserveI18nMetadata = true, vite: viteConfig } = options;
     const root = viteConfig?.root ?? process.cwd();
     const assetsDir = viteConfig?.build?.assetsDir ?? DEFAULT_ASSETS_DIR;
+    const buildManifest = createBuildManifestCollector();
 
     const forced: InlineConfig = {
         plugins: [
-            ...gtkxVitePlugins(BUILD_MODE),
+            ...gtkxVitePlugins(BUILD_MODE, entry, buildManifest, shouldPreserveI18nMetadata),
             gtkxWorker(),
-            gtkxBuiltUrl(assetBase),
             gtkxNative(root),
-            gtkxBundledPackages(root),
+            gtkxBuildManifest(root, buildManifest),
             gtkxSelfContained(),
         ],
         build: {

package/src/codegen/run-codegen.ts

@@ -8,9 +8,13 @@ import {
     resolveOmittedProps,
 } from "@gtkx/config/internal";
 import { info, warn } from "@gtkx/utils";
-import { rmSync } from "node:fs";
-import { resolve } from "node:path";
+import { existsSync, rmSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { resolveCatalogProject, synchronizeCatalogs } from "../i18n/catalogs.js";
+import { extractSourceCatalog } from "../i18n/source-messages.js";
+import { emitI18nTypes } from "../i18n/types.js";
 import { resolveDataDir } from "../internal/data-dir.js";
+import { discoverSourceFiles } from "../internal/source-imports.js";
 import { emitSchemaEnv } from "../settings/schema.js";
 import { type CodegenInputs, isCodegenStale, resolveCodegenInputs } from "./freshness.js";
 import { type CodegenContext, type CodegenStore, resolveCodegenContext } from "./store-resolver.js";
@@ -21,6 +25,7 @@ type RunCodegenOptions = {
     isForced?: boolean;
     inputs?: CodegenInputs;
     resolved?: LoadedConfig;
+    shouldPreserveI18nMetadata?: boolean | undefined;
 };
 
 type LoadedConfig = {
@@ -52,13 +57,19 @@ type CodegenOptionsInput = {
 };
 
 type PreparedCodegen = CodegenInputs & { isForced: boolean };
-type EnsureGeneratedOptions = { shouldAnnounce?: boolean; mode?: string };
+
+type EnsureGeneratedOptions = {
+    shouldAnnounce?: boolean;
+    mode?: string;
+    shouldPreserveI18nMetadata?: boolean | undefined;
+};
 
 type RunOptionsInput = {
     root: string;
     mode: string | undefined;
     inputs: CodegenInputs | null;
     resolved: LoadedConfig;
+    shouldPreserveI18nMetadata: boolean | undefined;
 };
 
 const GIR_PATH_MISSING_MESSAGE =
@@ -156,6 +167,8 @@ const prepareCodegen = (options: RunCodegenOptions, cwd: string, config: Config)
 const runCodegen = async (options: RunCodegenOptions = {}): Promise<RunCodegenResult> => {
     const cwd = options.cwd ?? process.cwd();
     const { config, configFile } = await resolveLoadedConfig(options, cwd);
+    await syncI18n(cwd, config.applicationId, options.shouldPreserveI18nMetadata);
+    syncSchemaEnv(cwd, config.future?.v2ResourceImports === true);
 
     if (config.codegen === false) {
         removeShadowingStores(cwd);
@@ -198,6 +211,26 @@ const runCodegen = async (options: RunCodegenOptions = {}): Promise<RunCodegenRe
     };
 };
 
+const syncI18n = async (
+    root: string,
+    applicationId: string,
+    shouldPreserveMetadataMessages = true,
+): Promise<void> => {
+    const project = resolveCatalogProject(root, applicationId);
+
+    if (project === null) {
+        emitI18nTypes(root, [], false);
+
+        return;
+    }
+
+    const srcDir = join(root, "src");
+    const sourceFiles = discoverSourceFiles(existsSync(srcDir) ? srcDir : root);
+    const catalog = await extractSourceCatalog(project, sourceFiles, shouldPreserveMetadataMessages);
+    synchronizeCatalogs(project);
+    emitI18nTypes(root, catalog.messages);
+};
+
 const isCodegenDisabled = async (cwd: string, mode?: string): Promise<boolean> => {
     try {
         const { config } = await loadConfig(cwd, { mode });
@@ -208,8 +241,9 @@ const isCodegenDisabled = async (cwd: string, mode?: string): Promise<boolean> =
     }
 };
 
-const syncSchemaEnv = (cwd: string): void => {
-    emitSchemaEnv(cwd, resolveDataDir(cwd));
+const syncSchemaEnv = (cwd: string, isV2ResourceImports = false): void => {
+    const dataDir = isV2ResourceImports ? null : resolveDataDir(cwd);
+    emitSchemaEnv(cwd, dataDir, isV2ResourceImports);
 };
 
 const resolveInputsOrNull = (cwd: string, config: Config): CodegenInputs | null => {
@@ -230,12 +264,18 @@ const maybeAnnounceStale = (shouldAnnounce: boolean | undefined, inputs: Codegen
     }
 };
 
-const getRunOptions = ({ root, mode, inputs, resolved }: RunOptionsInput): RunCodegenOptions => {
+const getRunOptions = ({
+    root,
+    mode,
+    inputs,
+    resolved,
+    shouldPreserveI18nMetadata,
+}: RunOptionsInput): RunCodegenOptions => {
     if (inputs === null) {
-        return { cwd: root, mode, resolved };
+        return { cwd: root, mode, resolved, shouldPreserveI18nMetadata };
     }
 
-    return { cwd: root, mode, inputs, resolved };
+    return { cwd: root, mode, inputs, resolved, shouldPreserveI18nMetadata };
 };
 
 const isPreflightSkipped = (options: EnsureGeneratedOptions): boolean =>
@@ -243,18 +283,28 @@ const isPreflightSkipped = (options: EnsureGeneratedOptions): boolean =>
 
 /* 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) {
-        removeShadowingStores(context.root);
-
-        return false;
+        const result = await runCodegen({
+            cwd: context.root,
+            mode: options.mode,
+            resolved: { config: context.config, configFile: context.configFile },
+            shouldPreserveI18nMetadata: options.shouldPreserveI18nMetadata,
+        });
+
+        return result.isRegenerated;
     }
 
     const inputs = resolveInputsOrNull(context.root, context.config);
     maybeAnnounceStale(options.shouldAnnounce, inputs);
     const resolved = { config: context.config, configFile: context.configFile };
-    const result = await runCodegen(getRunOptions({ root: context.root, mode: options.mode, inputs, resolved }));
+
+    const result = await runCodegen(getRunOptions({
+        root: context.root,
+        mode: options.mode,
+        inputs,
+        resolved,
+        shouldPreserveI18nMetadata: options.shouldPreserveI18nMetadata,
+    }));
 
     return result.isRegenerated;
 };
@@ -286,7 +336,6 @@ const resolveConfigWatch = async (
 export {
     runCodegen,
     isCodegenDisabled,
-    syncSchemaEnv,
     ensureGenerated,
     ensureGeneratedIn,
     resolveConfigWatch,

package/src/commands/build.ts

@@ -13,10 +13,6 @@ const build = defineCommand({
     },
     args: {
         ...entryArg,
-        "asset-base": {
-            type: "string",
-            description: "Asset base path relative to executable directory (e.g., ../share/my-app)",
-        },
     },
     async run({ args }) {
         const { cwd, entry } = await prepareProject(args, BUILD_MODE);
@@ -24,7 +20,6 @@ const build = defineCommand({
 
         const bundlePath = await buildApp({
             entry,
-            assetBase: args["asset-base"],
             vite: {
                 root: cwd,
             },

package/src/commands/codegen.ts

@@ -1,7 +1,7 @@
 import { info } from "@gtkx/utils";
 import { defineCommand } from "citty";
 import { formatCodegenResult } from "../codegen/report.js";
-import { ensureGenerated, isCodegenDisabled, runCodegen, syncSchemaEnv } from "../codegen/run-codegen.js";
+import { ensureGenerated, isCodegenDisabled, runCodegen } from "../codegen/run-codegen.js";
 import { cwdArg, resolveCwd } from "../internal/entry-arg.js";
 
 const FORCED_WHILE_DISABLED_MESSAGE =
@@ -12,7 +12,7 @@ const FORCED_WHILE_DISABLED_MESSAGE =
 const codegen = defineCommand({
     meta: {
         name: "codegen",
-        description: "Generate TypeScript bindings for the GIR libraries declared in gtkx.config.ts",
+        description: "Generate project bindings, translation catalogs, and TypeScript declarations",
     },
     args: {
         force: {
@@ -29,7 +29,6 @@ const codegen = defineCommand({
 
         if (isDisabled) {
             await runCodegen({ cwd });
-            syncSchemaEnv(cwd);
             info("codegen: disabled for this project; reusing an installed binding store");
 
             return;
@@ -44,7 +43,6 @@ const codegen = defineCommand({
 
         const startedAt = Date.now();
         const result = await runCodegen({ cwd, isForced: true });
-        syncSchemaEnv(cwd);
         const lines = formatCodegenResult(result, Date.now() - startedAt);
 
         for (const line of lines) {

package/src/deploy/depends.ts

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

package/src/deploy/freedesktop/localize.ts

@@ -0,0 +1,144 @@
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import type { CatalogProject } from "../../i18n/catalogs.js";
+import type { StagedMetadata } from "../payload/stage.js";
+import { metadataTemplateFile, type MetadataTemplateKind } from "../../i18n/metadata-templates.js";
+import { runCliTool } from "../../internal/run-cli-tool.js";
+
+type MergeMode = "--desktop" | "--xml";
+
+type MergeRequest = {
+    mode: MergeMode;
+    stem: string;
+    extension: string;
+    template: string;
+};
+
+type MetadataTemplate = {
+    contents: string;
+    path: string;
+    relativePath: string;
+};
+
+const metadataTemplates = (project: CatalogProject, metadata: StagedMetadata): MetadataTemplate[] => {
+    const template = (kind: MetadataTemplateKind, contents: string): MetadataTemplate => {
+        const { path, relativePath } = metadataTemplateFile(project, kind);
+
+        return { contents, path, relativePath };
+    };
+
+    return [
+        template("desktop", metadata.desktopEntry),
+        template("metainfo.xml", metadata.metainfo),
+        ...(metadata.mimePackage === null ? [] : [template("mime.xml", metadata.mimePackage)]),
+    ];
+};
+
+const mergeCatalogs = (project: CatalogProject, workDir: string, request: MergeRequest): string => {
+    const { extension, mode, stem, template } = request;
+    let current = join(workDir, `${stem}-source${extension}`);
+    writeFileSync(current, template);
+
+    for (const [index, catalog] of project.catalogs.entries()) {
+        const output = join(workDir, `${stem}-${String(index)}${extension}`);
+
+        runCliTool({
+            tool: "msgfmt",
+            args: [
+                mode,
+                `--template=${current}`,
+                `--locale=${catalog.locale}`,
+                `--output-file=${output}`,
+                catalog.path,
+            ],
+            target: catalog.path,
+        });
+
+        current = output;
+    }
+
+    return readFileSync(current, "utf8");
+};
+
+const localizeMetadata = (metadata: StagedMetadata, project: CatalogProject | null): StagedMetadata => {
+    if (project === null || project.catalogs.length === 0) {
+        return metadata;
+    }
+
+    const workDir = mkdtempSync(join(tmpdir(), "gtkx-deploy-metadata-"));
+
+    try {
+        return {
+            desktopEntry: mergeCatalogs(project, workDir, {
+                mode: "--desktop",
+                stem: "application",
+                extension: ".desktop",
+                template: metadata.desktopEntry,
+            }),
+            metainfo: mergeCatalogs(project, workDir, {
+                mode: "--xml",
+                stem: "metainfo",
+                extension: ".metainfo.xml",
+                template: metadata.metainfo,
+            }),
+            mimePackage: metadata.mimePackage === null
+                ? null
+                : mergeCatalogs(project, workDir, {
+                        mode: "--xml",
+                        stem: "mime",
+                        extension: ".xml",
+                        template: metadata.mimePackage,
+                    }),
+        };
+    } finally {
+        rmSync(workDir, { recursive: true, force: true });
+    }
+};
+
+const extractMetadataMessages = (
+    metadata: StagedMetadata,
+    project: CatalogProject,
+    catalogTemplate?: string,
+): void => {
+    const potPath = catalogTemplate ?? join(project.poDir, `${project.domain}.pot`);
+
+    if (!existsSync(potPath)) {
+        throw new Error(`Cannot add the generated metadata to the missing catalog template: ${potPath}`);
+    }
+
+    const templates = metadataTemplates(project, metadata);
+    const firstTemplate = templates[0];
+
+    if (firstTemplate === undefined) {
+        throw new Error("Cannot extract metadata messages without a generated template");
+    }
+
+    const metadataDir = dirname(firstTemplate.path);
+    mkdirSync(metadataDir, { recursive: true });
+
+    try {
+        for (const template of templates) {
+            writeFileSync(template.path, template.contents);
+        }
+
+        runCliTool({
+            tool: "xgettext",
+            args: [
+                "--join-existing",
+                "--force-po",
+                "--from-code=UTF-8",
+                `--output=${potPath}`,
+                ...templates.map((template) => template.relativePath),
+            ],
+            target: potPath,
+            options: { cwd: project.root },
+        });
+    } finally {
+        for (const template of templates) {
+            rmSync(template.path, { force: true });
+        }
+    }
+};
+
+export { extractMetadataMessages, localizeMetadata };

package/src/deploy/install-hints.ts

@@ -43,8 +43,13 @@ const PACKAGE_FOR_TOOL: Record<string, FamilyPackages> = {
         fedora: "flatpak-builder",
         suse: "flatpak-builder",
     },
+    msgfmt: { arch: "gettext", debian: "gettext", fedora: "gettext", suse: "gettext-tools" },
+    msginit: { arch: "gettext", debian: "gettext", fedora: "gettext", suse: "gettext-tools" },
+    msggrep: { arch: "gettext", debian: "gettext", fedora: "gettext", suse: "gettext-tools" },
+    msgmerge: { arch: "gettext", debian: "gettext", fedora: "gettext", suse: "gettext-tools" },
     strip: { arch: "binutils", debian: "binutils", fedora: "binutils", suse: "binutils" },
     tar: { arch: "tar", debian: "tar", fedora: "tar", suse: "tar" },
+    xgettext: { arch: "gettext", debian: "gettext", fedora: "gettext", suse: "gettext-tools" },
 };
 
 const GENERATOR_SOURCE = "git+https://github.com/flatpak/flatpak-builder-tools.git#subdirectory=node";

package/src/deploy/nfpm/config.ts

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

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

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

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

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

package/src/deploy/notices/collect.ts

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