crossbind 2.0.0-beta.65 → 2.0.0-beta.67

package/src/app/index.js

@@ -0,0 +1,245 @@
+// What an app's host does for its page: the dialogs that pick files or show a message, opening an address or a file
+// outside the app, the app's folders, quitting, its menus, its tray icon and notifications, the events of the app's
+// native code and a desktop app's updates. Each call goes to the host of an app (target.runtimeEnv: 'app'); in any
+// other build it rejects, or events.on throws. The app's native code calls the same through <crossbind/app.h>, but for
+// the menus, the tray, notifications and events.on.
+
+const OPEN = { title: 'string', defaultPath: 'string', filters: 'filters', directory: 'boolean', multiple: 'boolean' };
+const SAVE = { title: 'string', defaultPath: 'string', defaultName: 'string', filters: 'filters' };
+const MESSAGE = { message: 'string', detail: 'string', kind: 'string', buttons: 'buttons' };
+const MESSAGE_KINDS = ['info', 'warning', 'error'];
+// Android's dialogs take three buttons at most.
+const MAX_BUTTONS = 3;
+
+// The app's crossbind.js, which initNative() loads, hands the calls to the host.
+function hostOf(member, name) {
+    const host = globalThis.Crossbind?.[member];
+    if (host) return host;
+    if (globalThis.Crossbind) throw new Error(`crossbind: this app's host is older than crossbind/app; update @crossbind/core-app-host to call ${name}`);
+    if (globalThis.__crossbind_token) throw new Error(`crossbind: ${name} works once the page has called initNative()`);
+    throw new Error(`crossbind: ${name} works in an app alone, whose crossbind.config.js sets target.runtimeEnv: 'app'`);
+}
+
+const call = (name, options) => hostOf('app', name)(name, options);
+
+const isFilters = (value) => Array.isArray(value) && value.every((filter) => typeof filter?.name === 'string'
+    && Array.isArray(filter.extensions) && filter.extensions.every((extension) => typeof extension === 'string'));
+
+// Spread reads a hole as undefined, which every() skips.
+const isButtons = (value) => Array.isArray(value) && value.length >= 1 && value.length <= MAX_BUTTONS
+    && [...value].every((label) => typeof label === 'string' && label !== '');
+
+// The lists an option may be, beside what typeof tells: how each is checked, and what it is called.
+const LISTS = {
+    filters: { isFitting: isFilters, name: 'list of { name, extensions }' },
+    buttons: { isFitting: isButtons, name: 'list of one to three labels' },
+    list: { isFitting: Array.isArray, name: 'list' },
+};
+
+// The options as the host takes them, so a misspelt or mistyped one fails here, saying which.
+function checked(name, options, kinds) {
+    const keys = Object.keys(kinds).join(', ');
+    if (options === null || typeof options !== 'object' || Array.isArray(options)) {
+        throw new TypeError(`crossbind: ${name} takes an object of ${keys}.`);
+    }
+    for (const [key, value] of Object.entries(options)) {
+        if (!Object.hasOwn(kinds, key)) throw new TypeError(`crossbind: ${name} takes ${keys}; ${key} is none of them.`);
+        const list = LISTS[kinds[key]];
+        if (value !== undefined && !(list ? list.isFitting(value) : typeof value === kinds[key])) {
+            throw new TypeError(`crossbind: ${name}'s ${key} is no ${list ? list.name : kinds[key]}.`);
+        }
+    }
+    return options;
+}
+
+function checkedMessage(options) {
+    checked('dialog.message', options, MESSAGE);
+    if (!options.message) throw new TypeError('crossbind: dialog.message takes a message.');
+    if (options.kind !== undefined && !MESSAGE_KINDS.includes(options.kind)) {
+        throw new TypeError(`crossbind: dialog.message's kind is info, warning or error, not ${JSON.stringify(options.kind)}.`);
+    }
+    return options;
+}
+
+function checkedPath(name, path) {
+    if (typeof path !== 'string' || !path) throw new TypeError(`crossbind: ${name} takes a path.`);
+    return { path };
+}
+
+// A menu of the bar is { label, items } or a standard one by its role. An item is { label, id, accelerator, enabled,
+// checked }, a submenu { label, items }, { type: 'separator' }, or a standard item by its role, which a label may
+// rename and, but for an editing one, which keeps the platform's keys, an accelerator change.
+const MENU_ROLES = ['editMenu', 'windowMenu'];
+const EDITING_ROLES = ['undo', 'redo', 'cut', 'copy', 'paste', 'selectAll'];
+const ITEM_ROLES = [...EDITING_ROLES, 'minimize', 'close', 'quit'];
+const ITEM_KINDS = {
+    label: 'string', id: 'string', accelerator: 'string', enabled: 'boolean', checked: 'boolean', items: 'list', role: 'string', type: 'string',
+};
+const MODIFIERS = ['CmdOrCtrl', 'Ctrl', 'Alt', 'Shift'];
+const KEY = /^([A-Z0-9]|F([1-9]|1[0-2])|Enter|Escape|Tab|Space|Backspace|Delete|Up|Down|Left|Right|Home|End|PageUp|PageDown|Plus|Minus|Comma|Period)$/;
+
+// Typing uses neither a key with CmdOrCtrl, Ctrl or Alt nor a function key.
+function checkAccelerator(accelerator, where) {
+    const modifiers = accelerator.split('+');
+    const key = modifiers.pop();
+    const isKnown = KEY.test(key) && modifiers.every((modifier) => MODIFIERS.includes(modifier)) && new Set(modifiers).size === modifiers.length;
+    if (!isKnown || !(/^F\d+$/.test(key) || modifiers.some((modifier) => modifier !== 'Shift'))) {
+        throw new TypeError(`crossbind: menu.set's ${where}.accelerator ${JSON.stringify(accelerator)} is none, which is a key with CmdOrCtrl, Ctrl or Alt and maybe Shift, joined by +, as CmdOrCtrl+Shift+O is, or F1 to F12, alone or with any of them.`);
+    }
+}
+
+function checkMenuItem(item, where, isMenu) {
+    if (item === null || typeof item !== 'object' || Array.isArray(item)) throw new TypeError(`crossbind: menu.set's ${where} is no object.`);
+    for (const [key, value] of Object.entries(item)) {
+        if (!Object.hasOwn(ITEM_KINDS, key)) throw new TypeError(`crossbind: menu.set's ${where} takes ${Object.keys(ITEM_KINDS).join(', ')}; ${key} is none of them.`);
+        const kind = ITEM_KINDS[key];
+        if (value !== undefined && !(kind === 'list' ? Array.isArray(value) : typeof value === kind)) {
+            throw new TypeError(`crossbind: menu.set's ${where}.${key} is no ${kind}.`);
+        }
+    }
+    const has = (...keys) => keys.filter((key) => item[key] !== undefined);
+    const refuse = (what) => {
+        throw new TypeError(`crossbind: menu.set's ${where} ${what}.`);
+    };
+    if (item.type !== undefined) {
+        if (item.type !== 'separator' || isMenu || has(...Object.keys(ITEM_KINDS)).length > 1) refuse("is no separator, which is { type: 'separator' } alone, inside a menu");
+    } else if (item.role !== undefined) {
+        const roles = isMenu ? MENU_ROLES : [...ITEM_ROLES, ...MENU_ROLES];
+        if (!roles.includes(item.role)) refuse(`has no role ${JSON.stringify(item.role)}, which is one of ${roles.join(', ')}`);
+        if (MENU_ROLES.includes(item.role) && has('id', 'accelerator', 'enabled', 'checked', 'items').length > 0) refuse('is a standard menu, which takes a label alone');
+        if (EDITING_ROLES.includes(item.role) && item.accelerator !== undefined) refuse("is an editing item, which keeps the platform's keys and takes a label alone");
+        if (has('id', 'enabled', 'checked', 'items').length > 0) refuse('has a role, which takes a label and an accelerator alone');
+    } else if (!item.label) {
+        refuse('has no label');
+    } else if (item.items !== undefined) {
+        if (has('id', 'accelerator', 'enabled', 'checked').length > 0) refuse('is a menu, which takes a label and items alone');
+        // entries() reads a hole as undefined, which forEach skips.
+        for (const [index, child] of item.items.entries()) checkMenuItem(child, `${where}.items[${index}]`, false);
+    } else if (isMenu) {
+        refuse('is a menu, which takes a label and items, or the role editMenu or windowMenu');
+    }
+    if (item.accelerator !== undefined) checkAccelerator(item.accelerator, where);
+}
+
+function checkedMenus(menus) {
+    if (!Array.isArray(menus)) throw new TypeError('crossbind: menu.set takes a list of menus.');
+    for (const [index, item] of menus.entries()) checkMenuItem(item, `menus[${index}]`, true);
+    return { menus };
+}
+
+// A tray item is { label, id, enabled, checked }, a submenu { label, items } or { type: 'separator' }: a tray's menu has
+// no keys, and no standard item.
+const TRAY = { tooltip: 'string', menu: 'list' };
+const TRAY_ITEM = { label: 'string', id: 'string', enabled: 'boolean', checked: 'boolean', items: 'list', type: 'string' };
+const NOTIFICATION = { title: 'string', body: 'string' };
+
+function checkTrayItem(item, where) {
+    const refuse = (what) => {
+        throw new TypeError(`crossbind: tray.set's ${where} ${what}.`);
+    };
+    if (item === null || typeof item !== 'object' || Array.isArray(item)) refuse('is no object');
+    for (const [key, value] of Object.entries(item)) {
+        if (!Object.hasOwn(TRAY_ITEM, key)) refuse(`takes ${Object.keys(TRAY_ITEM).join(', ')}; ${key} is none of them`);
+        const kind = TRAY_ITEM[key];
+        if (value !== undefined && !(kind === 'list' ? Array.isArray(value) : typeof value === kind)) refuse(`.${key} is no ${kind}`);
+    }
+    const others = Object.keys(item).filter((key) => key !== 'type' && item[key] !== undefined);
+    if (item.type !== undefined) {
+        if (item.type !== 'separator' || others.length > 0) refuse("is no separator, which is { type: 'separator' } alone");
+    } else if (!item.label) {
+        refuse('has no label');
+    } else if (item.items !== undefined) {
+        if (others.some((key) => key !== 'label' && key !== 'items')) refuse('is a menu, which takes a label and items alone');
+        // entries() reads a hole as undefined, which forEach skips.
+        for (const [index, child] of item.items.entries()) checkTrayItem(child, `${where}.items[${index}]`);
+    }
+}
+
+function checkedTray(options) {
+    checked('tray.set', options, TRAY);
+    for (const [index, item] of (options.menu ?? []).entries()) checkTrayItem(item, `menu[${index}]`);
+    return options;
+}
+
+function checkedNotification(options) {
+    checked('notification.show', options, NOTIFICATION);
+    if (!options.title) throw new TypeError('crossbind: notification.show takes a title.');
+    return options;
+}
+
+export const dialog = {
+    // The paths of the files or folders the user picked, or null when they cancelled.
+    open: async (options = {}) => call('dialog.open', checked('dialog.open', options, OPEN)),
+    // The path the user chose to save to, or null when they cancelled.
+    save: async (options = {}) => call('dialog.save', checked('dialog.save', options, SAVE)),
+    // The index of the button the user clicked: Return gives the first, and Escape or closing the dialog the last.
+    message: async (options) => call('dialog.message', checkedMessage(options)),
+};
+
+export const shell = {
+    // An http, https or mailto address in the default browser or mail app.
+    openExternal: async (url) => {
+        if (typeof url !== 'string' && !(url instanceof URL)) throw new TypeError('crossbind: shell.openExternal takes an address.');
+        return call('shell.openExternal', { url: String(url) });
+    },
+    // A file in the app the system opens its kind with. Opening a program runs it, and a script in the page could ask for
+    // any path, so the host opens files where app.openPath in crossbind.config.js lets it alone; native code opens any.
+    openPath: async (path) => call('shell.openPath', checkedPath('shell.openPath', path)),
+    // A file, selected, in the system's file manager: one in the app's folders, or one a dialog picked during this run.
+    revealInFolder: async (path) => call('shell.revealInFolder', checkedPath('shell.revealInFolder', path)),
+    // A file or folder moved to the system's trash, where its user can take it back: one in the app's folders, not one of
+    // them itself, or one a dialog picked during this run. Where the system has no trash, nothing moves.
+    trash: async (path) => call('shell.trash', checkedPath('shell.trash', path)),
+};
+
+export const app = {
+    // The app's own folders, made when first asked for: { data, cache, logs }.
+    paths: async () => call('app.paths', {}),
+    // Ends the app as closing its window does.
+    quit: async () => call('app.quit', {}),
+    // Ends the app as quit() does, then opens it again, with no link.
+    relaunch: async () => call('app.relaunch', {}),
+    // The links of app.urlSchemes that opened the app and have not reached the page yet, the one it was launched with
+    // among them; later ones come as the event open-url. Listening first, then asking, misses none.
+    launchUrls: async () => call('app.launchUrls', {}),
+};
+
+export const menu = {
+    // Sets the app's menus: on macOS after its app menu, which the app keeps, and on Windows and Linux in a bar of its
+    // window. A click of an item with an id is an event, menu, of { id }, and of { id, checked } for an item it checked
+    // or unchecked; a standard item does what its role says.
+    set: async (menus) => call('menu.set', checkedMenus(menus)),
+};
+
+export const tray = {
+    // The app's icon in the macOS menu bar, the Windows notification area or a Linux desktop's status tray, with its
+    // tooltip and the menu a click opens. A click of an item with an id is the event menu, as one of menu.set's is, and a
+    // click of the icon the event tray where it opens no menu. Set again, it changes the icon that shows.
+    set: async (options = {}) => call('tray.set', checkedTray(options)),
+    // Takes the icon away.
+    remove: async () => call('tray.remove', {}),
+};
+
+export const notification = {
+    // A notification of the system's, with a title and a body; a click on it is the event notification.
+    show: async (options) => call('notification.show', checkedNotification(options)),
+};
+
+export const events = {
+    // Calls listener with the value of each event of this name the app's native code emits from now on, until the
+    // function it returns is called.
+    on: (name, listener) => {
+        if (typeof name !== 'string' || !name) throw new TypeError('crossbind: events.on takes the name of an event.');
+        if (typeof listener !== 'function') throw new TypeError('crossbind: events.on takes a function to call.');
+        return hostOf('on', 'events.on')(name, listener);
+    },
+};
+
+// One check or install runs at a time, and another rejects meanwhile.
+export const updater = {
+    // The version app.updater.url in crossbind.config.js offers when it is newer than the app's, as { version }, or null.
+    check: async () => call('updater.check', {}),
+    // Downloads that version, checks that the key of app.updater.publicKey signed it and installs it in place of the app,
+    // which then quits and opens the new version. It rejects when that fails.
+    install: async () => call('updater.install', {}),
+};

package/src/assets/toolchain-digests.json

@@ -1,55 +1,55 @@
 {
-    "version": "1.0.15",
+    "version": "1.0.18",
     "registry": "ghcr.io/crossbind",
     "toolchains": {
         "rust": "1.99.1"
     },
     "images": {
         "rust-sysroot": {
-            "index": "sha256:720469aca3cff3f1abe69374882d2c48399864be3778225e7754e94036e3be7a",
+            "index": "sha256:31a213289c4dc1125b462ef006cc27b84ee7eca4e3ef0a93259bd698d56c7359",
             "platforms": {
-                "linux/arm64": "sha256:3aa68ad3736491de26c6ca9b52a49c80e6291228cc17a05caba4c060ea68913c",
-                "linux/amd64": "sha256:e77357a8c763244a5a5b4086fb771e81bec385526432ec6e77fb316f39158c53"
+                "linux/arm64": "sha256:e82b9a4b9661356238b264a9d5b6921d364cbc81c54ec8426349527144b91bbc",
+                "linux/amd64": "sha256:33c63cb3ed60a6d771f079a60c97dfa1f183f215d4087bb655ff4deca2366d9a"
             }
         },
         "base": {
-            "index": "sha256:a7c9342c50a493c990f8c26f1bec7e3919ad6010ce8a6cdfaa772487a1040989",
+            "index": "sha256:ca5b17d648e797193d7f3c67635e1e73e56b58d02699a55ea61a35eb5ca8d0c8",
             "platforms": {
-                "linux/arm64": "sha256:c9152c3ff4854ba898df1b9fe89e8a94fd29aa5832e8cc5a4bd5fa2e06cee10f",
-                "linux/amd64": "sha256:817fc177f488b975bbbd196d9ec9d1d3effbf2c59d1ed82e979fcf5124c4c1aa"
+                "linux/arm64": "sha256:48666c55a2f943d8be029080fab985839bc50231b8556a00100bc3702a7bcc51",
+                "linux/amd64": "sha256:847f3c686dc8a846b05ee76d38a79b9ac68fb293ca014d56967ee12859849f1f"
             }
         },
         "web": {
-            "index": "sha256:143c2e79a950f732913726f32559f7c70323accf2727b34a12f332df91b765ef",
+            "index": "sha256:72cdc6f5b41d946edc7ca8cd5e1bcf7314f03dfc71be9067994b38130f965711",
             "platforms": {
-                "linux/arm64": "sha256:ebd0dbeee77a5fde4659b5f129713e5006cc205c629f837b56478e3691e85b9c",
-                "linux/amd64": "sha256:14429be7ee52afa0bd9c94248db3a84f90e74c29700a3f5f34da2989d7161431"
+                "linux/arm64": "sha256:6d1756fa994e5d939ac5696ebe32012f56c95d0428a8bc7b3775d53acbff8735",
+                "linux/amd64": "sha256:14aa215c2157e485ce6d664e0077a3cf6938733855b8146e97830e48fda13875"
             }
         },
         "android": {
-            "index": "sha256:249bdfda25dcd394c1e4955f3cd3e63140264697e9a543fbae1dce2ec3d80c38",
+            "index": "sha256:7cbd98594a1fb1f48fe156a21c6c5256cd535d2ffd152c1f80f2860d4dc5b6f0",
             "platforms": {
-                "linux/amd64": "sha256:725375a79e64c93a7cc7e35f4708e36511f6a36212e0a3aaf44f6b5ec1057724"
+                "linux/amd64": "sha256:a6e99a0a66e038fd0e6d1154df6c7c58d68acd9def896b63f542d810d923bd87"
             }
         },
         "android-app": {
-            "index": "sha256:d739c6b72e1545b086f38fe5613b58f52877a36e14c2ffd763acdd0296802802",
+            "index": "sha256:5cfd1df40ae28730d592f76ade7e08e628f0002d73979015308d50727f021f3e",
             "platforms": {
-                "linux/amd64": "sha256:a7124034f1ba3d888b3cd32c18051f87498c47ec515eac809b7440394c54ecb7"
+                "linux/amd64": "sha256:98d035dfaeb27095d0a4edce83299ebbb3ffa8e360a4cb925db7cd0b0b8a4666"
             }
         },
         "linux": {
-            "index": "sha256:433af720cf95a99c4e007c0cfc98ab358c6ddc61fecca75a0b844f598d750b1b",
+            "index": "sha256:9114bdc0e6b2c1b753d2ba154181566c320e9a901030a14c707f174b7e4849f5",
             "platforms": {
-                "linux/arm64": "sha256:0cf32948302c1a23294d28d20dd3b784790c7789b9e99bc8be56888bddb6aeb7",
-                "linux/amd64": "sha256:6da084ff433e792381aadd280b769aa1b09ba593e3e21ea4580f4736776e3cb9"
+                "linux/arm64": "sha256:47e104db909dc78a995733d3d27db94e135f1044e1f0860bb201930a65273af0",
+                "linux/amd64": "sha256:cd13e6b3f5c5303a583da5267531a83839fe8cf7979890463fc45a914a6d5d3f"
             }
         },
         "windows": {
-            "index": "sha256:c1fb594cb245f6b0414f04cb7413881532438b204c7ce06f78f6deaea2d3cb24",
+            "index": "sha256:46e6da18313f4fd3b599fb2505383aa34f32ffe7ceb659426fa3fb71e6f1e8e7",
             "platforms": {
-                "linux/amd64": "sha256:3ee3a4f9c565b0d2adedc3c699871bf8de4c2d7034b2b7a24309f4a6c4d0e64c",
-                "linux/arm64": "sha256:44702d741848f96d71dfb0a5322c37c9c248f7a38fe9e7c09b7d307ce000cc3f"
+                "linux/arm64": "sha256:b6457367be5c6863f8d336ce426b9dba7fdfa192308876e4bc390d82a6e18474",
+                "linux/amd64": "sha256:fd5bdc1f34d64bb9aebae1e1d44fc380c1dd815bd6686349e428d4551732f6e0"
             }
         }
     }

package/src/bin.js

@@ -16,6 +16,7 @@ import buildNode, { addonsInPackages, bundleNodeLoader, publishNodeData } from '
 import buildNativeCommand from './actions/buildNativeCommand.js';
 import buildApp, { appOutputPath, assertAppRunner, publishApp } from './actions/buildApp.js';
 import { releaseSigning } from './actions/androidGradle.js';
+import { UPDATER_KEY, newUpdaterKey } from './actions/appUpdate.js';
 import buildExternal from './actions/buildExternal.js';
 import buildPackageTypes from './actions/buildTypes.js';
 import buildLib from './actions/buildLib.js';
@@ -140,6 +141,14 @@ const commandApp = program.command('app').description('build the project as an a
         vite.on('exit', (code, signal) => process.exit(code ?? 128 + os.constants.signals[signal]));
     }));
 
+commandApp.command('updater-key')
+    .description("make the key pair that signs a desktop app's updates")
+    .action(() => {
+        const { publicKey, privateKey } = newUpdaterKey();
+        console.log(`crossbind: app.updater.publicKey in crossbind.config.js: ${publicKey}`);
+        console.log(`crossbind: ${UPDATER_KEY}, kept secret where the app is built: ${privateKey}`);
+    });
+
 program.command('licenses')
     .description('list bundled native dependencies with SPDX license, versions and source URL')
     .option('--notices [file]', 'write a THIRD-PARTY-NOTICES markdown file (default: THIRD-PARTY-NOTICES.md)')

package/src/index.js

@@ -6,8 +6,9 @@ export { default as buildWasm } from './actions/buildWasm.js';
 export {
     default as buildApp, buildProjectApp, publishApp, appLayout, appOutputName, appTargetParams,
 } from './actions/buildApp.js';
+export { checkInstaller } from './actions/appInstaller.js';
 export { default as openInSimulator, buildForSimulator } from './actions/iosSimulator.js';
-export { default as openOnDevice } from './actions/androidDevice.js';
+export { default as openOnDevice, adbPath } from './actions/androidDevice.js';
 export { buildApk } from './actions/androidGradle.js';
 export { default as isSourceNewer } from './actions/isSourceNewer.js';
 export { default as getData } from './actions/getData.js';

package/src/state/loadConfig.js

@@ -133,7 +133,7 @@ export function getFilledConfig(config, options = { isDepend: false }) {
         targetSpecs: config.targetSpecs || [],
         build: config.build || {},
         target: config.target || {},
-        // An app's identity: its bundle id, and on iOS the Apple team that signs it.
+        // An app's identity: its bundle id, on iOS the Apple team that signs it, the name it shows and its desktop window.
         app: config.app || {},
         extensions: config.extensions || [],
         package: null,

package/src/utils/appApiHeader.js

@@ -0,0 +1,29 @@
+// <crossbind/app.h>, which an app's own code includes for the host's functions (docs/api/app.md).
+
+import fs from 'node:fs';
+import state from '../state/index.js';
+import resolveAppHostRoot from './resolveAppHost.js';
+import { runtimeEnvsOf } from './targets.js';
+
+// An app project's native code compiles against the header, with CROSSBIND_APP defined, on every platform an app runs
+// on, and in every flavour of that platform's archives, which share one build. A library and an app's web build get
+// neither.
+export function compilesAsApp(target) {
+    return state.config.target?.runtimeEnv === 'app' && runtimeEnvsOf(target.platform).includes('app');
+}
+
+export function appApiHeader() {
+    const header = `${resolveAppHostRoot()}/cpp/include/crossbind/app.h`;
+    if (!fs.existsSync(header)) {
+        throw new Error('crossbind: this @crossbind/core-app-host has no <crossbind/app.h>; update it to the version of crossbind.');
+    }
+    return header;
+}
+
+// The app host can lie outside the docker mount, so the header is copied into the build tree first; returns the
+// include dir.
+export function stageAppApiInclude(dir) {
+    fs.mkdirSync(`${dir}/include/crossbind`, { recursive: true });
+    fs.copyFileSync(appApiHeader(), `${dir}/include/crossbind/app.h`);
+    return `${dir}/include`;
+}

package/src/utils/appIcon.js

@@ -0,0 +1,174 @@
+// An app's icon: app.icon in crossbind.config.js, one square PNG the build makes each platform's icons from. Every size
+// is resampled with a three-lobed Lanczos filter on premultiplied colors, as Tauri resizes icons.
+import fs from 'node:fs';
+import path from 'node:path';
+import { PNG } from 'pngjs';
+import { getContentHash } from './hash.js';
+
+// A macOS .icns: each kind of entry and the size of the PNG it holds.
+const ICNS_ENTRIES = [['icp4', 16], ['icp5', 32], ['ic11', 32], ['ic12', 64], ['ic07', 128], ['ic13', 256], ['ic08', 256],
+    ['ic14', 512], ['ic09', 512], ['ic10', 1024]];
+// A Windows .ico's sizes, each a PNG.
+const ICO_SIZES = [16, 24, 32, 48, 64, 256];
+const LINUX_SIZE = 512;
+// Xcode makes an iOS app's every size from this one.
+const IOS_SIZE = 1024;
+// An Android launcher icon's foreground at each density is 108 dp, of which the launcher's mask shows the middle 72.
+const ANDROID_FOREGROUNDS = { mdpi: 108, hdpi: 162, xhdpi: 216, xxhdpi: 324, xxxhdpi: 432 };
+const ANDROID_SHOWN = 72 / 108;
+const WHITE = { red: 255, green: 255, blue: 255 };
+
+// The app's icon, read and checked; none without app.icon.
+export function readAppIcon(config) {
+    const { icon } = config.app;
+    if (icon === undefined) return null;
+    if (typeof icon !== 'string' || !icon) {
+        throw new Error(`crossbind: app.icon ${JSON.stringify(icon)} is no path to a PNG file, as 'icon.png' is.`);
+    }
+    const file = path.resolve(config.paths.project, icon);
+    if (!fs.existsSync(file)) throw new Error(`crossbind: app.icon names ${file}, which does not exist.`);
+    let bytes;
+    let image;
+    try {
+        bytes = fs.readFileSync(file);
+        image = PNG.sync.read(bytes);
+    } catch (error) {
+        throw new Error(`crossbind: app.icon ${file} is no PNG image: ${error.message}.`, { cause: error });
+    }
+    if (image.width !== image.height) {
+        throw new Error(`crossbind: app.icon ${file} is ${image.width} × ${image.height} pixels; an app's icon is square, at best 1024 × 1024.`);
+    }
+    return { file, hash: getContentHash(bytes), image: { width: image.width, height: image.height, data: image.data } };
+}
+
+function lanczos3(x) {
+    if (x === 0) return 1;
+    if (x <= -3 || x >= 3) return 0;
+    const px = Math.PI * x;
+    return (3 * Math.sin(px) * Math.sin(px / 3)) / (px * px);
+}
+
+// For each pixel along one axis of the resized image, the first pixel of the original it takes and their weights.
+function contributions(from, to) {
+    const scale = from / to;
+    // Shrinking widens the filter, so every pixel of the original counts.
+    const stretch = Math.max(scale, 1);
+    return Array.from({ length: to }, (_, index) => {
+        const center = (index + 0.5) * scale;
+        const first = Math.max(0, Math.ceil(center - 3 * stretch - 0.5));
+        const last = Math.min(from - 1, Math.floor(center + 3 * stretch - 0.5));
+        const weights = Array.from({ length: last - first + 1 }, (__, k) => lanczos3((first + k + 0.5 - center) / stretch));
+        const total = weights.reduce((sum, weight) => sum + weight, 0);
+        return { first, weights: weights.map((weight) => weight / total) };
+    });
+}
+
+// One pass along x: each row of `width` pixels becomes `size` pixels, written to the output transposed, so the second
+// pass along y is the same pass again.
+function pass(source, width, height, size) {
+    const out = new Float32Array(size * height * 4);
+    contributions(width, size).forEach(({ first, weights }, x) => {
+        for (let y = 0; y < height; y++) {
+            const row = y * width;
+            const at = (x * height + y) * 4;
+            for (let k = 0; k < weights.length; k++) {
+                const from = (row + first + k) * 4;
+                out[at] += weights[k] * source[from];
+                out[at + 1] += weights[k] * source[from + 1];
+                out[at + 2] += weights[k] * source[from + 2];
+                out[at + 3] += weights[k] * source[from + 3];
+            }
+        }
+    });
+    return out;
+}
+
+export function resize(image, size) {
+    if (image.width === size) return image;
+    const { width, height, data } = image;
+    // Premultiplied, so the color of a transparent pixel does not bleed into its neighbors.
+    const source = new Float32Array(width * height * 4);
+    for (let i = 0; i < data.length; i += 4) {
+        const alpha = data[i + 3] / 255;
+        source[i] = data[i] * alpha;
+        source[i + 1] = data[i + 1] * alpha;
+        source[i + 2] = data[i + 2] * alpha;
+        source[i + 3] = data[i + 3];
+    }
+    const resized = pass(pass(source, width, height, size), height, size, size);
+    const out = Buffer.alloc(size * size * 4);
+    const clamp = (value) => Math.min(255, Math.max(0, Math.round(value)));
+    for (let i = 0; i < out.length; i += 4) {
+        // The filter overshoots now and then; the colors divide by what it gave, the alpha is clamped.
+        const alpha = resized[i + 3];
+        out[i + 3] = clamp(alpha);
+        if (out[i + 3] === 0) continue;
+        out[i] = clamp((resized[i] * 255) / alpha);
+        out[i + 1] = clamp((resized[i + 1] * 255) / alpha);
+        out[i + 2] = clamp((resized[i + 2] * 255) / alpha);
+    }
+    return { width: size, height: size, data: out };
+}
+
+// The image at `size` in the middle of a transparent square of `canvas`.
+function centered(image, canvas, size) {
+    const inner = resize(image, size);
+    const out = Buffer.alloc(canvas * canvas * 4);
+    const offset = Math.floor((canvas - size) / 2);
+    for (let y = 0; y < size; y++) inner.data.copy(out, ((y + offset) * canvas + offset) * 4, y * size * 4, (y + 1) * size * 4);
+    return { width: canvas, height: canvas, data: out };
+}
+
+const png = (image, options) => PNG.sync.write(image, options);
+
+// A macOS app's icon file, which its Info.plist names.
+export function macIcon(icon) {
+    const pngs = new Map();
+    const entries = ICNS_ENTRIES.map(([type, size]) => {
+        if (!pngs.has(size)) pngs.set(size, png(resize(icon.image, size)));
+        return chunk(type, pngs.get(size));
+    });
+    return chunk('icns', Buffer.concat(entries));
+}
+
+// An .icns chunk: its type, its length with these eight bytes, and what it holds.
+function chunk(type, data) {
+    const header = Buffer.alloc(8);
+    header.write(type, 0, 'latin1');
+    header.writeUInt32BE(data.length + 8, 4);
+    return Buffer.concat([header, data]);
+}
+
+// A Windows app's icon, which its executable carries.
+export function windowsIcon(icon) {
+    const images = ICO_SIZES.map((size) => png(resize(icon.image, size)));
+    const header = Buffer.alloc(6 + 16 * images.length);
+    header.writeUInt16LE(1, 2);
+    header.writeUInt16LE(images.length, 4);
+    let offset = header.length;
+    images.forEach((image, index) => {
+        const at = 6 + 16 * index;
+        // A width and height of 0 stand for 256.
+        header.writeUInt8(ICO_SIZES[index] % 256, at);
+        header.writeUInt8(ICO_SIZES[index] % 256, at + 1);
+        header.writeUInt16LE(1, at + 4);
+        header.writeUInt16LE(32, at + 6);
+        header.writeUInt32LE(image.length, at + 8);
+        header.writeUInt32LE(offset, at + 12);
+        offset += image.length;
+    });
+    return Buffer.concat([header, ...images]);
+}
+
+// A Linux app's window icon.
+export const linuxIcon = (icon) => png(resize(icon.image, LINUX_SIZE));
+
+// The one image an iOS app's asset catalog holds, on white and without an alpha channel, which the App Store refuses
+// even when every pixel is opaque.
+export const iosIcon = (icon) => png(resize(icon.image, IOS_SIZE), { colorType: 2, bgColor: WHITE });
+
+// An Android app's adaptive icon: its foreground at each density, with the whole icon in what the mask shows; its
+// background is white.
+export const androidIcons = (icon) => Object.fromEntries(Object.entries(ANDROID_FOREGROUNDS).map(([density, size]) => [
+    `mipmap-${density}/ic_launcher_foreground.png`, png(centered(icon.image, size, Math.round(size * ANDROID_SHOWN))),
+]));