@gjsify/cli 0.64.16 → 0.64.17

package/lib/utils/credits.js

@@ -0,0 +1,275 @@
+// Contributor credits from git history, for `gjsify credits`.
+//
+// Names only: an e-mail address is read to recognise a bot or an AI co-author and
+// is dropped before anything is built, so no output can carry one.
+import { spawnSync } from 'node:child_process';
+import { posix } from 'node:path';
+/**
+ * Patterns for people who are not contributors. `*` is the only wildcard and a
+ * pattern must match the WHOLE name or the WHOLE e-mail, case-insensitively.
+ * Weblate commits as "Weblate (bot)" with the real translator in a trailer, so
+ * the bot is dropped and the trailer is what counts.
+ */
+export const DEFAULT_CREDITS_IGNORE = [
+    '*[bot]',
+    'github-actions',
+    'Weblate',
+    'Weblate (bot)',
+    'Hosted Weblate',
+    'Weblate Translation Memory',
+    'LibreTranslate',
+    'Claude',
+    '*@anthropic.com',
+    'noreply-mt-*@weblate.org',
+    'hosted@weblate.org',
+    '*[bot]@users.noreply.github.com',
+];
+const FIELD = '\x1f';
+const RECORD = '\x1e';
+const TRAILER_SEPARATOR = '\x1d';
+function globToRegExp(pattern) {
+    const source = pattern
+        .split('*')
+        .map((part) => part.replace(/[.+?^${}()|[\]\\]/g, '\\$&'))
+        .join('.*');
+    return new RegExp(`^${source}$`, 'i');
+}
+export function isIgnored(person, patterns) {
+    return patterns.some((pattern) => {
+        const re = globToRegExp(pattern);
+        return re.test(person.name) || (person.email !== '' && re.test(person.email));
+    });
+}
+/** `Name <mail>` → parts. A trailer without an address keeps the whole value as the name. */
+export function parsePerson(value) {
+    const match = /^(.*?)\s*<([^>]*)>\s*$/.exec(value.trim());
+    return match ? { name: match[1].trim(), email: match[2].trim() } : { name: value.trim(), email: '' };
+}
+const isTranslationFile = (file) => /\.pot?$/i.test(file);
+/** `po/pt_BR.po` → `pt_BR`; a `.pot` template names no language. Git prints `/` on every host. */
+function poLanguage(file) {
+    const base = posix.basename(file);
+    return /\.po$/i.test(base) ? base.slice(0, -3) : undefined;
+}
+function bump(map, name) {
+    map.set(name, (map.get(name) ?? 0) + 1);
+}
+/** Most commits first, then by name; code-point order so every host sorts alike. */
+function rank(counts) {
+    return [...counts.entries()].sort(([a, x], [b, y]) => y - x || (a < b ? -1 : a > b ? 1 : 0)).map(([name]) => name);
+}
+function appendUnseen(list, names, excluded) {
+    const seen = new Set(list);
+    for (const raw of names ?? []) {
+        const name = raw.trim();
+        if (name && !seen.has(name) && !excluded(name)) {
+            seen.add(name);
+            list.push(name);
+        }
+    }
+}
+export function buildCredits(commits, options = {}) {
+    const ignore = options.ignore ?? DEFAULT_CREDITS_IGNORE;
+    const overrides = options.overrides ?? {};
+    const excludePatterns = overrides.exclude ?? [];
+    const excluded = (name) => isIgnored({ name, email: '' }, excludePatterns);
+    const developers = new Map();
+    const translators = new Map();
+    const classified = commits.map((commit) => {
+        const names = new Set();
+        for (const person of [commit.author, ...commit.coAuthors]) {
+            if (person.name && !isIgnored(person, ignore) && !excluded(person.name))
+                names.add(person.name);
+        }
+        const languages = new Set();
+        let touchesCode = false;
+        for (const file of commit.files) {
+            if (!isTranslationFile(file))
+                touchesCode = true;
+            const language = poLanguage(file);
+            if (language)
+                languages.add(language);
+        }
+        return { names, languages, touchesCode };
+    });
+    // A Weblate squash merge lists every translator of the batch in one trailer block and touches
+    // all their languages, so it cannot say who translated what. Only a commit with one person and
+    // one language can; an ambiguous commit credits a person to the languages such commits pin
+    // them to, and falls back to all its languages only for someone nothing else pins.
+    const pinned = new Map();
+    for (const { names, languages } of classified) {
+        if (names.size !== 1 || languages.size !== 1)
+            continue;
+        const [name] = names;
+        const [language] = languages;
+        let set = pinned.get(name);
+        if (!set)
+            pinned.set(name, (set = new Set()));
+        set.add(language);
+    }
+    for (const { names, languages, touchesCode } of classified) {
+        const ambiguous = names.size > 1 || languages.size > 1;
+        for (const name of names) {
+            if (touchesCode)
+                bump(developers, name);
+            const own = pinned.get(name);
+            for (const language of languages) {
+                if (ambiguous && own && !own.has(language))
+                    continue;
+                let perLanguage = translators.get(language);
+                if (!perLanguage)
+                    translators.set(language, (perLanguage = new Map()));
+                bump(perLanguage, name);
+            }
+        }
+    }
+    const credits = { developers: rank(developers), translators: {}, supporters: [] };
+    const excludeTranslators = overrides.excludeTranslators ?? {};
+    for (const language of [...translators.keys()].sort()) {
+        const patterns = [...(excludeTranslators['*'] ?? []), ...(excludeTranslators[language] ?? [])];
+        const list = rank(translators.get(language)).filter((name) => !isIgnored({ name, email: '' }, patterns));
+        if (list.length)
+            credits.translators[language] = list;
+    }
+    appendUnseen(credits.developers, overrides.developers, excluded);
+    for (const language of Object.keys(overrides.translators ?? {}).sort()) {
+        const list = credits.translators[language] ?? [];
+        appendUnseen(list, overrides.translators[language], excluded);
+        if (list.length)
+            credits.translators[language] = list;
+    }
+    credits.translators = Object.fromEntries(Object.entries(credits.translators).sort(([a], [b]) => (a < b ? -1 : 1)));
+    appendUnseen(credits.supporters, overrides.supporters, excluded);
+    return credits;
+}
+/** The `git log` format `parseGitLog` reads: author, address, co-author trailers, then the file names. */
+export const GIT_LOG_ARGS = [
+    '-c',
+    'core.quotepath=off',
+    'log',
+    '--no-merges',
+    '--use-mailmap',
+    '--name-only',
+    `--format=${RECORD}%aN${FIELD}%aE${FIELD}%(trailers:key=Co-authored-by,valueonly,unfold,separator=%x1d)${FIELD}`,
+];
+/** Splits `git log` output into commits; co-author trailers are NOT mapped yet. */
+export function parseGitLog(output) {
+    const commits = [];
+    for (const record of output.split(RECORD)) {
+        if (!record.trim())
+            continue;
+        const [name = '', email = '', trailers = '', files = ''] = record.split(FIELD);
+        commits.push({
+            author: { name: name.trim(), email: email.trim() },
+            coAuthors: trailers
+                .split(TRAILER_SEPARATOR)
+                .map((value) => value.trim())
+                .filter(Boolean)
+                .map(parsePerson),
+            files: files
+                .split('\n')
+                .map((file) => file.trim())
+                .filter(Boolean),
+        });
+    }
+    return commits;
+}
+function git(cwd, args, input) {
+    const result = spawnSync('git', [...args], { cwd, encoding: 'utf8', input, maxBuffer: 1 << 30 });
+    if (result.error)
+        throw new Error(`cannot run git: ${result.error.message}`);
+    if (result.status !== 0)
+        throw new Error(`git ${args.join(' ')} failed: ${String(result.stderr).trim()}`);
+    return String(result.stdout);
+}
+/** Runs each trailer through `.mailmap`, so a co-author and the same person as an author merge. */
+function mapTrailers(cwd, commits) {
+    const contacts = new Set();
+    for (const commit of commits) {
+        for (const person of commit.coAuthors)
+            if (person.email)
+                contacts.add(`${person.name} <${person.email}>`);
+    }
+    if (contacts.size === 0)
+        return;
+    const asked = [...contacts];
+    const answered = git(cwd, ['check-mailmap', '--stdin'], asked.join('\n') + '\n')
+        .split('\n')
+        .filter(Boolean);
+    if (answered.length !== asked.length)
+        throw new Error('git check-mailmap answered a different number of lines');
+    const mapped = new Map(asked.map((contact, i) => [contact, parsePerson(answered[i])]));
+    for (const commit of commits) {
+        commit.coAuthors = commit.coAuthors.map((p) => (p.email ? mapped.get(`${p.name} <${p.email}>`) : p));
+    }
+}
+/** The repo's non-merge commits with `.mailmap` applied to authors and co-authors. */
+export function readCommits(cwd) {
+    // A shallow clone drops history, so the result would silently differ from a full one
+    // and `--check` would flag a perfectly current file as stale.
+    if (git(cwd, ['rev-parse', '--is-shallow-repository']).trim() === 'true') {
+        throw new Error('the repository is a shallow clone; fetch the full history first (git fetch --unshallow)');
+    }
+    const commits = parseGitLog(git(cwd, GIT_LOG_ARGS));
+    mapTrailers(cwd, commits);
+    return commits;
+}
+const STRING_LIST_KEYS = ['developers', 'supporters', 'exclude'];
+const LANGUAGE_MAP_KEYS = ['translators', 'excludeTranslators'];
+function asStringList(value, where) {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== 'string')) {
+        throw new Error(`${where} must be an array of strings`);
+    }
+    return value;
+}
+export function parseOverrides(text, where = 'overrides') {
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch (err) {
+        throw new Error(`${where} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+        throw new Error(`${where} must be a JSON object`);
+    }
+    const record = data;
+    const known = new Set([...STRING_LIST_KEYS, ...LANGUAGE_MAP_KEYS]);
+    for (const key of Object.keys(record)) {
+        if (!known.has(key))
+            throw new Error(`${where} has an unknown key "${key}" (known: ${[...known].join(', ')})`);
+    }
+    const overrides = {};
+    for (const key of STRING_LIST_KEYS) {
+        if (record[key] !== undefined)
+            overrides[key] = asStringList(record[key], `${where}.${key}`);
+    }
+    for (const key of LANGUAGE_MAP_KEYS) {
+        const raw = record[key];
+        if (raw === undefined)
+            continue;
+        if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+            throw new Error(`${where}.${key} must map a language to an array of names`);
+        }
+        const map = {};
+        for (const [language, names] of Object.entries(raw)) {
+            map[language] = asStringList(names, `${where}.${key}.${language}`);
+        }
+        overrides[key] = map;
+    }
+    return overrides;
+}
+export function serializeCredits(credits) {
+    return JSON.stringify(credits, null, 2) + '\n';
+}
+/** True when `existing` (the file on disk, or `null` when absent) is not what `credits` serializes to. */
+export function isStale(existing, credits) {
+    if (existing === null)
+        return true;
+    try {
+        return JSON.stringify(JSON.parse(existing)) !== JSON.stringify(credits);
+    }
+    catch {
+        return true;
+    }
+}

package/lib/utils/flatpak-runtime.d.ts

@@ -1,9 +1,9 @@
 /**
  * Default GNOME-Platform runtime version. Bumped per release window.
- * GNOME 50 = April 2026 stable; tracked in
+ * GNOME 51 = September 2026 stable (on Freedesktop 26.08); tracked in
  * https://docs.flathub.org/docs/for-app-authors/requirements.
  */
-export declare const DEFAULT_GNOME_RUNTIME_VERSION = "50";
+export declare const DEFAULT_GNOME_RUNTIME_VERSION = "51";
 /** Default Freedesktop-Platform runtime version (LTS-ish). */
 export declare const DEFAULT_FREEDESKTOP_RUNTIME_VERSION = "24.08";
 /** Permissive GUI defaults for GTK4 + Adwaita apps. */

package/lib/utils/flatpak-runtime.js

@@ -9,10 +9,10 @@
 // GNOME releases from the same `package.json`.
 /**
  * Default GNOME-Platform runtime version. Bumped per release window.
- * GNOME 50 = April 2026 stable; tracked in
+ * GNOME 51 = September 2026 stable (on Freedesktop 26.08); tracked in
  * https://docs.flathub.org/docs/for-app-authors/requirements.
  */
-export const DEFAULT_GNOME_RUNTIME_VERSION = '50';
+export const DEFAULT_GNOME_RUNTIME_VERSION = '51';
 /** Default Freedesktop-Platform runtime version (LTS-ish). */
 export const DEFAULT_FREEDESKTOP_RUNTIME_VERSION = '24.08';
 /** Permissive GUI defaults for GTK4 + Adwaita apps. */

package/lib/utils/ship/android-icons.d.ts

@@ -0,0 +1,109 @@
+/** Bump when the OUTPUT changes for the same inputs, so every project's `--check` goes stale once. */
+export declare const ANDROID_ICONS_GENERATOR_VERSION = 1;
+export declare const ANDROID_ICONS_STAMP = ".gjsify-android-icons.json";
+export declare const DEFAULT_RESOURCES_DIR = "App_Resources";
+export declare const DEFAULT_BACKGROUND = "#FFFFFF";
+export interface AndroidDensity {
+    name: 'ldpi' | 'mdpi' | 'hdpi' | 'xhdpi' | 'xxhdpi' | 'xxxhdpi';
+    /** Pixels per dp. */
+    scale: number;
+}
+/** Launcher icons have no ldpi bucket any more; the splash set keeps the template's. */
+export declare const LAUNCHER_DENSITIES: readonly AndroidDensity[];
+export declare const SPLASH_DENSITIES: readonly AndroidDensity[];
+/** Legacy launcher icon edge in dp, and the adaptive layers' (the visible window is the inner 72dp). */
+export declare const LEGACY_DP = 48;
+export declare const ADAPTIVE_DP = 108;
+/** The part of the adaptive canvas no launcher mask may cut. */
+export declare const SAFE_ZONE_DP = 66;
+/** The splash logo's edge in dp; the template's wordmark is 200dp wide, a square mark reads smaller. */
+export declare const SPLASH_DP = 96;
+/** How much of a round legacy icon's circle the picture fills. */
+export declare const ROUND_INNER_RATIO = 0.72;
+export type AndroidPngKind = 'legacy' | 'round' | 'foreground' | 'monochrome' | 'splash';
+export interface AndroidPngSpec {
+    /** Relative to the `res/` directory. */
+    path: string;
+    kind: AndroidPngKind;
+    /** Square edge in pixels. */
+    size: number;
+}
+export interface AndroidTextSpec {
+    path: string;
+    content: string;
+}
+export interface AndroidIconPlan {
+    png: AndroidPngSpec[];
+    text: AndroidTextSpec[];
+}
+/**
+ * Every file the generator owns, from two facts: the background colour and
+ * whether a monochrome layer exists. `<monochrome>` is omitted without a symbolic
+ * icon — a launcher with an empty one would theme the icon to nothing.
+ */
+export declare function planAndroidIcons(opts: {
+    background: string;
+    monochrome: boolean;
+}): AndroidIconPlan;
+export declare function backgroundXml(color: string): string;
+export declare function adaptiveIconXml(monochrome: boolean): string;
+/** A `#rgb` or `#rrggbb` colour as `#RRGGBB`, or null. */
+export declare function normalizeColor(value: string): string | null;
+/**
+ * The metainfo's primary brand colour for the LIGHT scheme: launchers draw the
+ * adaptive background in both themes, and the light one is the one that reads as
+ * "the" app colour. Falls back to an untagged primary colour, else null.
+ */
+export declare function parseMetainfoBranding(xml: string): string | null;
+/** `appResourcesPath` out of a `nativescript.config.ts`, read as text: evaluating it would need its imports. */
+export declare function parseAppResourcesPath(configText: string): string | null;
+export declare function resolveResourcesName(input: {
+    flag?: string;
+    configured?: string;
+    nativescriptConfig: string | null;
+}): string;
+export declare function resolveBackground(input: {
+    flag?: string;
+    configured?: string;
+    fromMetainfo: string | null;
+}): string;
+/**
+ * Which of the discovered icon files is the app icon and which the symbolic one.
+ * The `scalable/` SVG wins like in `resolveAppIcon`; a symbolic icon named for it
+ * (`<id>-symbolic.svg`) wins over a stranger.
+ */
+export declare function pickIconSources(files: readonly string[]): {
+    icon: string | null;
+    symbolic: string | null;
+};
+/** Where the hicolor theme keeps the symbolic twin of `…/scalable/apps/<id>.svg`. */
+export declare function symbolicSibling(iconPath: string): string;
+/**
+ * The SVG to rasterize for one kind. `legacy` and `splash` render the icon
+ * itself (a GNOME icon carries its own silhouette, so a legacy launcher entry
+ * needs no plate behind it); the others are a wrapper that embeds the icon as a
+ * data URI, because the rasterizer renders a whole document at a size and cannot
+ * place a picture inside a larger transparent canvas.
+ */
+export declare function wrapperSvg(kind: 'round' | 'foreground' | 'monochrome', icon: Uint8Array, background: string): string;
+export interface AndroidIconsStamp {
+    generator: number;
+    /** sha256 over the inputs. */
+    inputs: string;
+    /** Relative to the resources directory, posix. */
+    files: string[];
+}
+export declare function hashInputs(input: {
+    icon: Uint8Array;
+    symbolic: Uint8Array | null;
+    background: string;
+}): string;
+/** The stamp's paths are relative to the resources directory, so it survives a move of the project. */
+export declare function buildStamp(inputs: string, plan: AndroidIconPlan, resPrefix: string): AndroidIconsStamp;
+export type StampVerdict = {
+    current: true;
+} | {
+    current: false;
+    reason: string;
+};
+export declare function checkStamp(existing: string | null, expectedInputs: string, fileExists: (relativePath: string) => boolean): StampVerdict;

package/lib/utils/ship/android-icons.js

@@ -0,0 +1,215 @@
+// The Android launcher icon and splash logo, derived from the ONE app icon.
+//
+// A NativeScript app's `App_Resources/Android` ships the template's blue "N" until
+// someone hand-maintains five densities of `ic_launcher.png`, an adaptive-icon
+// foreground, a background colour and a splash logo. A GNOME app already declares
+// its icon once (`hicolor/scalable/apps/<id>.svg`, optionally `…-symbolic.svg`, and
+// the metainfo's `<branding>` colour), so this module holds the PURE half of
+// translating that into Android resources: geometry, XML text, the stamp. The
+// rasterizing (`rasterizeSvg`, librsvg in a child GJS — see icons.ts) is the
+// command's, so none of this needs a GJS to be tested.
+//
+// THE RASTER IS NEVER COMPARED. librsvg versions may antialias differently, so
+// `--check` reads a stamp (a hash of the INPUTS plus the files written) instead of
+// diffing PNG bytes — same reason icons.ts says the stage, not the raster, is the
+// reproducible thing.
+import { createHash } from 'node:crypto';
+import { basename, dirname, extname, join, posix } from 'node:path';
+import { isSymbolicIcon } from './icons.js';
+/** Bump when the OUTPUT changes for the same inputs, so every project's `--check` goes stale once. */
+export const ANDROID_ICONS_GENERATOR_VERSION = 1;
+export const ANDROID_ICONS_STAMP = '.gjsify-android-icons.json';
+export const DEFAULT_RESOURCES_DIR = 'App_Resources';
+export const DEFAULT_BACKGROUND = '#FFFFFF';
+/** Launcher icons have no ldpi bucket any more; the splash set keeps the template's. */
+export const LAUNCHER_DENSITIES = [
+    { name: 'mdpi', scale: 1 },
+    { name: 'hdpi', scale: 1.5 },
+    { name: 'xhdpi', scale: 2 },
+    { name: 'xxhdpi', scale: 3 },
+    { name: 'xxxhdpi', scale: 4 },
+];
+export const SPLASH_DENSITIES = [{ name: 'ldpi', scale: 0.75 }, ...LAUNCHER_DENSITIES];
+/** Legacy launcher icon edge in dp, and the adaptive layers' (the visible window is the inner 72dp). */
+export const LEGACY_DP = 48;
+export const ADAPTIVE_DP = 108;
+/** The part of the adaptive canvas no launcher mask may cut. */
+export const SAFE_ZONE_DP = 66;
+/** The splash logo's edge in dp; the template's wordmark is 200dp wide, a square mark reads smaller. */
+export const SPLASH_DP = 96;
+/** How much of a round legacy icon's circle the picture fills. */
+export const ROUND_INNER_RATIO = 0.72;
+function px(dp, scale) {
+    return Math.round(dp * scale);
+}
+/**
+ * Every file the generator owns, from two facts: the background colour and
+ * whether a monochrome layer exists. `<monochrome>` is omitted without a symbolic
+ * icon — a launcher with an empty one would theme the icon to nothing.
+ */
+export function planAndroidIcons(opts) {
+    const png = [];
+    for (const { name, scale } of LAUNCHER_DENSITIES) {
+        const dir = `mipmap-${name}`;
+        png.push({ path: `${dir}/ic_launcher.png`, kind: 'legacy', size: px(LEGACY_DP, scale) });
+        png.push({ path: `${dir}/ic_launcher_round.png`, kind: 'round', size: px(LEGACY_DP, scale) });
+        png.push({ path: `${dir}/ic_launcher_foreground.png`, kind: 'foreground', size: px(ADAPTIVE_DP, scale) });
+        if (opts.monochrome) {
+            png.push({ path: `${dir}/ic_launcher_monochrome.png`, kind: 'monochrome', size: px(ADAPTIVE_DP, scale) });
+        }
+    }
+    for (const { name, scale } of SPLASH_DENSITIES) {
+        png.push({ path: `drawable-${name}/logo.png`, kind: 'splash', size: px(SPLASH_DP, scale) });
+    }
+    const adaptive = adaptiveIconXml(opts.monochrome);
+    return {
+        png,
+        text: [
+            { path: 'values/ic_launcher_background.xml', content: backgroundXml(opts.background) },
+            { path: 'mipmap-anydpi-v26/ic_launcher.xml', content: adaptive },
+            { path: 'mipmap-anydpi-v26/ic_launcher_round.xml', content: adaptive },
+        ],
+    };
+}
+export function backgroundXml(color) {
+    return `<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="ic_launcher_background">${color}</color>
+</resources>
+`;
+}
+export function adaptiveIconXml(monochrome) {
+    return `<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/ic_launcher_background"/>
+    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+${monochrome ? '    <monochrome android:drawable="@mipmap/ic_launcher_monochrome"/>\n' : ''}</adaptive-icon>
+`;
+}
+/** A `#rgb` or `#rrggbb` colour as `#RRGGBB`, or null. */
+export function normalizeColor(value) {
+    const match = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(value.trim());
+    if (match === null)
+        return null;
+    const hex = match[1];
+    const full = hex.length === 3 ? [...hex].map((c) => c + c).join('') : hex;
+    return `#${full.toUpperCase()}`;
+}
+/**
+ * The metainfo's primary brand colour for the LIGHT scheme: launchers draw the
+ * adaptive background in both themes, and the light one is the one that reads as
+ * "the" app colour. Falls back to an untagged primary colour, else null.
+ */
+export function parseMetainfoBranding(xml) {
+    let untagged = null;
+    for (const match of xml.matchAll(/<color\b([^>]*)>\s*([^<\s]+)\s*<\/color>/g)) {
+        const attrs = match[1] ?? '';
+        if (!/type\s*=\s*["']primary["']/.test(attrs))
+            continue;
+        const color = normalizeColor(match[2] ?? '');
+        if (color === null)
+            continue;
+        const scheme = /scheme_preference\s*=\s*["']([^"']+)["']/.exec(attrs)?.[1];
+        if (scheme === 'light')
+            return color;
+        if (scheme === undefined && untagged === null)
+            untagged = color;
+    }
+    return untagged;
+}
+/** `appResourcesPath` out of a `nativescript.config.ts`, read as text: evaluating it would need its imports. */
+export function parseAppResourcesPath(configText) {
+    return /\bappResourcesPath\s*:\s*["'`]([^"'`]+)["'`]/.exec(configText)?.[1] ?? null;
+}
+export function resolveResourcesName(input) {
+    return (input.flag ??
+        input.configured ??
+        (input.nativescriptConfig === null ? null : parseAppResourcesPath(input.nativescriptConfig)) ??
+        DEFAULT_RESOURCES_DIR);
+}
+export function resolveBackground(input) {
+    const explicit = input.flag ?? input.configured;
+    if (explicit !== undefined) {
+        const color = normalizeColor(explicit);
+        if (color === null) {
+            throw new Error(`gjsify android-icons: \`${explicit}\` is not a colour — write it as #rrggbb.`);
+        }
+        return color;
+    }
+    return input.fromMetainfo ?? DEFAULT_BACKGROUND;
+}
+/**
+ * Which of the discovered icon files is the app icon and which the symbolic one.
+ * The `scalable/` SVG wins like in `resolveAppIcon`; a symbolic icon named for it
+ * (`<id>-symbolic.svg`) wins over a stranger.
+ */
+export function pickIconSources(files) {
+    const svgs = files.filter((file) => extname(file).toLowerCase() === '.svg');
+    const scalable = svgs.filter((file) => !isSymbolicIcon(file));
+    const icon = scalable.find((file) => /(?:^|[\\/])scalable[\\/]/.test(file)) ?? scalable[0] ?? null;
+    const symbolics = svgs.filter(isSymbolicIcon);
+    const stem = icon === null ? null : `${basename(icon, '.svg')}-symbolic`;
+    const symbolic = symbolics.find((file) => basename(file, '.svg') === stem) ?? symbolics[0] ?? null;
+    return { icon, symbolic };
+}
+/** Where the hicolor theme keeps the symbolic twin of `…/scalable/apps/<id>.svg`. */
+export function symbolicSibling(iconPath) {
+    return join(dirname(dirname(dirname(iconPath))), 'symbolic', 'apps', `${basename(iconPath, '.svg')}-symbolic.svg`);
+}
+function dataUri(svg) {
+    return `data:image/svg+xml;base64,${Buffer.from(svg).toString('base64')}`;
+}
+/**
+ * The SVG to rasterize for one kind. `legacy` and `splash` render the icon
+ * itself (a GNOME icon carries its own silhouette, so a legacy launcher entry
+ * needs no plate behind it); the others are a wrapper that embeds the icon as a
+ * data URI, because the rasterizer renders a whole document at a size and cannot
+ * place a picture inside a larger transparent canvas.
+ */
+export function wrapperSvg(kind, icon, background) {
+    const xmlns = 'xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"';
+    if (kind === 'round') {
+        const inner = 100 * ROUND_INNER_RATIO;
+        const offset = (100 - inner) / 2;
+        return (`<svg ${xmlns} width="100" height="100" viewBox="0 0 100 100">` +
+            `<circle cx="50" cy="50" r="50" fill="${background}"/>` +
+            `<image x="${offset}" y="${offset}" width="${inner}" height="${inner}" xlink:href="${dataUri(icon)}"/></svg>`);
+    }
+    const offset = (ADAPTIVE_DP - SAFE_ZONE_DP) / 2;
+    return (`<svg ${xmlns} width="${ADAPTIVE_DP}" height="${ADAPTIVE_DP}" viewBox="0 0 ${ADAPTIVE_DP} ${ADAPTIVE_DP}">` +
+        `<image x="${offset}" y="${offset}" width="${SAFE_ZONE_DP}" height="${SAFE_ZONE_DP}" xlink:href="${dataUri(icon)}"/></svg>`);
+}
+function sha256(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+export function hashInputs(input) {
+    return sha256(JSON.stringify({
+        generator: ANDROID_ICONS_GENERATOR_VERSION,
+        icon: sha256(input.icon),
+        symbolic: input.symbolic === null ? null : sha256(input.symbolic),
+        background: input.background,
+    }));
+}
+/** The stamp's paths are relative to the resources directory, so it survives a move of the project. */
+export function buildStamp(inputs, plan, resPrefix) {
+    const files = [...plan.png.map((p) => p.path), ...plan.text.map((t) => t.path)].map((p) => posix.join(resPrefix, p));
+    return { generator: ANDROID_ICONS_GENERATOR_VERSION, inputs, files: files.sort() };
+}
+export function checkStamp(existing, expectedInputs, fileExists) {
+    if (existing === null)
+        return { current: false, reason: 'was never generated' };
+    let stamp;
+    try {
+        stamp = JSON.parse(existing);
+    }
+    catch {
+        return { current: false, reason: 'has an unreadable stamp' };
+    }
+    if (stamp.generator !== ANDROID_ICONS_GENERATOR_VERSION || stamp.inputs !== expectedInputs) {
+        return { current: false, reason: 'is out of date with the icon, colour or generator' };
+    }
+    const missing = (stamp.files ?? []).find((file) => !fileExists(file));
+    if (missing !== undefined)
+        return { current: false, reason: `lacks ${missing}` };
+    return { current: true };
+}

package/lib/utils/ship/types.d.ts

@@ -69,7 +69,7 @@ export type FormatId = 'deb' | 'rpm' | 'flatpak' | 'appimage' | 'macos-app' | 'm
  * instead of being rediscovered per call site. A `.deb` says
  * `Depends: gir1.2-gtk-4.0`, an `.rpm` says `Requires: gtk4`, and both are
  * package names in a distribution's namespace. A Flatpak has no such field: it
- * declares ONE dependency, its runtime (`org.gnome.Platform//50`), in the
+ * declares ONE dependency, its runtime (`org.gnome.Platform//51`), in the
  * manifest — and inside that runtime a typelib is either present or nothing on
  * the system provides it, so there is no package to name and no gap a name
  * could close.