crossbind 2.0.0-beta.66 → 2.0.0-beta.67

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "crossbind",
-    "version": "2.0.0-beta.66",
+    "version": "2.0.0-beta.67",
     "license": "MIT",
     "homepage": "https://crossbind.dev",
     "repository": "https://github.com/crossbind/crossbind.git",

package/src/actions/appInstaller.js

@@ -6,7 +6,7 @@ import { appleSigning } from './appleSigning.js';
 import { updaterSigning } from './appUpdate.js';
 import { inWindowsImage, jsignScript, windowsSigning } from './windowsSigning.js';
 import state from '../state/index.js';
-import { appDisplayName, appId, appUrlSchemes } from '../utils/appOptions.js';
+import { appCategory, appDisplayName, appId, appUrlSchemes } from '../utils/appOptions.js';
 import { readAppIcon, windowsIcon } from '../utils/appIcon.js';
 import { imageRoleFor } from '../utils/pullDockerImage.js';
 import { isUnderBase } from '../utils/replaceBasePathForDocker.js';
@@ -61,12 +61,13 @@ export function debianControl({ name, version, arch, author, description, label
 
 // The desktop entry a Linux menu shows an app by. GTK names the app's window after the command that started it, and
 // GNOME on Wayland shows the icon of the entry whose file has that name.
-// A link of one of its schemes opens it with the link as its argument, %u.
-export function desktopEntry({ label, command, hasIcon, urlSchemes = [] }) {
+// A link of one of its schemes opens it with the link as its argument, %u. A menu shows it under its categories.
+export function desktopEntry({ label, command, hasIcon, urlSchemes = [], categories = null }) {
     const isLinked = urlSchemes.length > 0;
     return [
         '[Desktop Entry]', 'Type=Application', `Name=${label}`, `Exec=${command}${isLinked ? ' %u' : ''}`, ...(hasIcon ? [`Icon=${command}`] : []),
-        ...(isLinked ? [`MimeType=${urlSchemes.map((scheme) => `x-scheme-handler/${scheme};`).join('')}`] : []), 'Terminal=false', '',
+        ...(isLinked ? [`MimeType=${urlSchemes.map((scheme) => `x-scheme-handler/${scheme};`).join('')}`] : []),
+        ...(categories ? [`Categories=${categories};`] : []), 'Terminal=false', '',
     ].join('\n');
 }
 
@@ -106,7 +107,9 @@ function debianPackage(app, target) {
     const icon = `${app}/resources/icon.png`;
     const hasIcon = fs.existsSync(icon);
     if (hasIcon) fs.copyFileSync(icon, `${dir('usr/share/icons/hicolor/512x512/apps')}/${name}.png`);
-    fs.writeFileSync(`${dir('usr/share/applications')}/${name}.desktop`, desktopEntry({ label, command: name, hasIcon, urlSchemes: appUrlSchemes(state.config) }));
+    fs.writeFileSync(`${dir('usr/share/applications')}/${name}.desktop`, desktopEntry({
+        label, command: name, hasIcon, urlSchemes: appUrlSchemes(state.config), categories: appCategory(state.config)?.linux,
+    }));
     const { author, description } = state.config.package ?? {};
     fs.writeFileSync(`${dir('DEBIAN')}/control`, debianControl({ name, version: packageVersion(), arch: target.arch, author, description, label }));
     run(null, ['dpkg-deb', '--build', '--root-owner-group', root, `${app}.deb`], null, target);

package/src/actions/buildApp.js

@@ -30,7 +30,7 @@ import findFiles from '../utils/findFiles.js';
 import { getContentHash, getFilesFingerprint } from '../utils/hash.js';
 import { xmlPlist } from '../utils/plist.js';
 import {
-    appBackgroundColor, appDisplayName, appHeader, appId, appPermissions, appUrlSchemes, usageDescriptions,
+    appBackgroundColor, appCategory, appCopyright, appDisplayName, appHeader, appId, appPermissions, appUrlSchemes, usageDescriptions,
 } from '../utils/appOptions.js';
 import { androidIcons, iosIcon, linuxIcon, macIcon, readAppIcon, windowsIcon } from '../utils/appIcon.js';
 import writeIfChanged from '../utils/writeIfChanged.js';
@@ -195,9 +195,12 @@ const infoPlist = (name, version, hasIcon, urlSchemes) => xmlPlist({
     CFBundleShortVersionString: version,
     ...(urlSchemes.length > 0 ? { CFBundleURLTypes: [{ CFBundleURLName: appId(state.config), CFBundleURLSchemes: urlSchemes }] } : {}),
     CFBundleVersion: version,
+    ...(appCategory(state.config) ? { LSApplicationCategoryType: appCategory(state.config).darwin } : {}),
     LSMinimumSystemVersion: DARWIN_DEPLOYMENT_TARGET,
     NSPrincipalClass: 'NSApplication',
     NSHighResolutionCapable: true,
+    // The app menu's About item shows it.
+    ...(appCopyright(state.config) ? { NSHumanReadableCopyright: appCopyright(state.config) } : {}),
     ...usageDescriptions(state.config, 'darwin'),
 });
 

package/src/actions/buildExternal.js

@@ -7,6 +7,7 @@ import state from '../state/index.js';
 import buildLib from './buildLib.js';
 import buildBinTools from './buildBinTools.js';
 import { copyBundledLicenses } from '../utils/bundledLicenses.js';
+import { applyRecipePatches, refreshPatchedSource, writePatchedSourceStamp } from '../utils/recipePatches.js';
 
 export default async function buildExternal(targetParams, options = {}) {
     const version = state.config.package.nativeVersion;
@@ -14,9 +15,15 @@ export default async function buildExternal(targetParams, options = {}) {
         throw new Error(`crossbind: "${state.config.general?.name}" has a crossbind.build recipe but no "nativeVersion" in package.json — cannot build from source.`);
     }
 
-    const { sha256, replaceList, copyToSource, copyToDist } = state.config.build;
+    const { sha256, replaceList, copyToSource, copyToDist, patches } = state.config.build;
+    refreshPatchedSource(state.config.paths.build, patches);
     const isNewlyCreated = await downloadAndExtractFile(sourcesOf(state.config.build, version), state.config.paths.build, sha256);
     const sourcePath = `${state.config.paths.build}/source`;
+    // Upstream fixes are diffs against the source as released, so they go in before crossbind's own edits.
+    if (isNewlyCreated) {
+        applyRecipePatches(sourcePath, patches);
+        writePatchedSourceStamp(state.config.paths.build, patches);
+    }
     if (isNewlyCreated && replaceList) {
         replaceList.forEach(({ regex, replacement, paths }) => {
             replace({

package/src/app/index.d.ts

@@ -57,12 +57,16 @@ export declare const shell: {
     openPath(path: string): Promise<void>;
     /** A file, selected, in the system's file manager: one in the app's folders, or one a dialog picked during this run. */
     revealInFolder(path: string): Promise<void>;
+    /** 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 and it rejects. */
+    trash(path: string): Promise<void>;
 };
 
 export declare const app: {
     paths(): Promise<AppPaths>;
     /** Ends the app as closing its window does. */
     quit(): Promise<void>;
+    /** Ends the app as quit() does, then opens it again, with no link. */
+    relaunch(): Promise<void>;
     /** The links of app.urlSchemes in crossbind.config.js that opened the app and have not reached the page yet, the one it was launched with among them. Once the page has asked, each later link comes as the event open-url while it listens, so listening first, then asking, misses none. */
     launchUrls(): Promise<string[]>;
 };
@@ -93,6 +97,36 @@ export declare const menu: {
     set(menus: Menu[]): Promise<void>;
 };
 
+/** An item of the tray's menu: one the page handles, by its id, a submenu or a separator. */
+export type TrayItem =
+    | { label: string; id?: string; enabled?: boolean; checked?: boolean }
+    | { label: string; items: TrayItem[] }
+    | { type: 'separator' };
+
+export interface TrayOptions {
+    /** What the icon shows when the pointer rests on it. */
+    tooltip?: string;
+    /** The menu a click of the icon opens: a click on macOS, a right click on Windows, and on Linux the one its desktop takes. */
+    menu?: TrayItem[];
+}
+
+export declare const tray: {
+    /** The app's icon in the macOS menu bar, the Windows notification area or a Linux desktop's status tray. A click of an item with an id is the event menu, with a MenuClick, and a click of the icon the event tray where it opens no menu. Set again, it changes the icon that shows. */
+    set(options?: TrayOptions): Promise<void>;
+    /** Takes the icon away. */
+    remove(): Promise<void>;
+};
+
+export interface NotificationOptions {
+    title: string;
+    body?: string;
+}
+
+export declare const notification: {
+    /** A notification of the system's; a click on it is the event notification. macOS asks its user first. */
+    show(options: NotificationOptions): Promise<void>;
+};
+
 /** What the event second-instance carries: a later launch's arguments, the program's own left out, and the folder it was launched in. */
 export interface SecondInstance {
     args: string[];
@@ -105,12 +139,20 @@ export interface OpenUrl {
 }
 
 export declare const events: {
-    /** Calls listener with each click of an item with an id in the menus menu.set sets, until the function it returns is called. */
+    /** Calls listener with each click of an item with an id in the menus menu.set sets or in the tray's menu, until the function it returns is called. */
     on(name: 'menu', listener: (click: MenuClick) => void): () => void;
     /** Calls listener with each link of app.urlSchemes the system opens the app with once the page has called app.launchUrls(), until the function it returns is called. */
     on(name: 'open-url', listener: (open: OpenUrl) => void): () => void;
     /** Calls listener with each later launch of a desktop app that app.singleInstance keeps to one instance, which brings its window to the front as far as the system lets it, until the function it returns is called. */
     on(name: 'second-instance', listener: (launch: SecondInstance) => void): () => void;
+    /** Calls listener as the system of a desktop app goes to sleep, which it may do before the page has run, until the function it returns is called. */
+    on(name: 'suspend', listener: () => void): () => void;
+    /** Calls listener as the system of a desktop app wakes from sleep, until the function it returns is called. */
+    on(name: 'resume', listener: () => void): () => void;
+    /** Calls listener with each left or right click of the tray's icon that opens no menu, until the function it returns is called. */
+    on(name: 'tray', listener: () => void): () => void;
+    /** Calls listener with each click on a notification the app's notification.show showed while it runs, until the function it returns is called. */
+    on(name: 'notification', listener: () => void): () => void;
     /** 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: string, listener: (value: unknown) => void): () => void;
 };

package/src/app/index.js

@@ -1,7 +1,8 @@
 // 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, 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 and events.on.
+// 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' };
@@ -32,6 +33,7 @@ const isButtons = (value) => Array.isArray(value) && value.length >= 1 && value.
 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.
@@ -125,6 +127,46 @@ function checkedMenus(menus) {
     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)),
@@ -145,6 +187,9 @@ export const shell = {
     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 = {
@@ -152,6 +197,8 @@ export const app = {
     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', {}),
@@ -164,6 +211,20 @@ export const menu = {
     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.

package/src/assets/toolchain-digests.json

@@ -1,55 +1,55 @@
 {
-    "version": "1.0.16",
+    "version": "1.0.18",
     "registry": "ghcr.io/crossbind",
     "toolchains": {
         "rust": "1.99.1"
     },
     "images": {
         "rust-sysroot": {
-            "index": "sha256:b0745e62b7bc2d07acebf8dce8edef2e24a5f82f55bf37f51bacdbb67c393339",
+            "index": "sha256:31a213289c4dc1125b462ef006cc27b84ee7eca4e3ef0a93259bd698d56c7359",
             "platforms": {
-                "linux/amd64": "sha256:42e71c9f4b349e116fb25cf1fc357cb070ae9e294a6087bb111dad2346256594",
-                "linux/arm64": "sha256:7144a83fa33d2beaad105e88c0067fb6a44d9b9620e576f226758872962cca44"
+                "linux/arm64": "sha256:e82b9a4b9661356238b264a9d5b6921d364cbc81c54ec8426349527144b91bbc",
+                "linux/amd64": "sha256:33c63cb3ed60a6d771f079a60c97dfa1f183f215d4087bb655ff4deca2366d9a"
             }
         },
         "base": {
-            "index": "sha256:d1f2fee78a0238aebb70a2aaed3753212f8151afe0430144b4dfb522f1ccf2ac",
+            "index": "sha256:ca5b17d648e797193d7f3c67635e1e73e56b58d02699a55ea61a35eb5ca8d0c8",
             "platforms": {
-                "linux/arm64": "sha256:7faf80e5692ae636f4bc25af0849711c442275b2405b3d52f9e1943ed8089aa2",
-                "linux/amd64": "sha256:7d31882ed442c0425746fa1cbadf4bf1f6a5f035b2222cb907ad5006ef1af24d"
+                "linux/arm64": "sha256:48666c55a2f943d8be029080fab985839bc50231b8556a00100bc3702a7bcc51",
+                "linux/amd64": "sha256:847f3c686dc8a846b05ee76d38a79b9ac68fb293ca014d56967ee12859849f1f"
             }
         },
         "web": {
-            "index": "sha256:97d873ae67dac443a88d0dede3fee2893177f167e08e8c9096c29aebd95a3d0f",
+            "index": "sha256:72cdc6f5b41d946edc7ca8cd5e1bcf7314f03dfc71be9067994b38130f965711",
             "platforms": {
-                "linux/arm64": "sha256:a274755f6d2cc1702ff7681b75e44b5d1146b73b45ac2dab5e4b543554ad4b19",
-                "linux/amd64": "sha256:23414220cfd4839005d3a5c1e3b83cff4760a3e6eb23687c2a71a1187d0cd211"
+                "linux/arm64": "sha256:6d1756fa994e5d939ac5696ebe32012f56c95d0428a8bc7b3775d53acbff8735",
+                "linux/amd64": "sha256:14aa215c2157e485ce6d664e0077a3cf6938733855b8146e97830e48fda13875"
             }
         },
         "android": {
-            "index": "sha256:5cae71358e7619d5958dab6f38b5dad9582792dc3a49c07fdf8dbdbf157ab5bd",
+            "index": "sha256:7cbd98594a1fb1f48fe156a21c6c5256cd535d2ffd152c1f80f2860d4dc5b6f0",
             "platforms": {
-                "linux/amd64": "sha256:96ff7fa364b8fb109fd3f0257f591c3dc6315e2b1a810511bb129807940895bc"
+                "linux/amd64": "sha256:a6e99a0a66e038fd0e6d1154df6c7c58d68acd9def896b63f542d810d923bd87"
             }
         },
         "android-app": {
-            "index": "sha256:b225a3d04d771916c7a2cc0261990f09b71f6c8b5ae63bc0f3869c7cb5a00fb9",
+            "index": "sha256:5cfd1df40ae28730d592f76ade7e08e628f0002d73979015308d50727f021f3e",
             "platforms": {
-                "linux/amd64": "sha256:e18361ed3cee022767312cd9f63471f4fe4bf41fccb9c7dd53dafec2da67adc0"
+                "linux/amd64": "sha256:98d035dfaeb27095d0a4edce83299ebbb3ffa8e360a4cb925db7cd0b0b8a4666"
             }
         },
         "linux": {
-            "index": "sha256:6a642147d344f804f42241fc80c21b07bfe1eb40a9a364250959c3715a60700a",
+            "index": "sha256:9114bdc0e6b2c1b753d2ba154181566c320e9a901030a14c707f174b7e4849f5",
             "platforms": {
-                "linux/arm64": "sha256:2582d7cf143f876ad4a324174ccb0a1097c4ca2ce775c0216756415ca797cb93",
-                "linux/amd64": "sha256:a10f0efc028e8ba63a7a45dda475eb669d8a078bf1e2830ac0a8c026277afe92"
+                "linux/arm64": "sha256:47e104db909dc78a995733d3d27db94e135f1044e1f0860bb201930a65273af0",
+                "linux/amd64": "sha256:cd13e6b3f5c5303a583da5267531a83839fe8cf7979890463fc45a914a6d5d3f"
             }
         },
         "windows": {
-            "index": "sha256:c4c436763d559a5346f96369b444b79006d4298c5dfce78c15c06089cfdaaa33",
+            "index": "sha256:46e6da18313f4fd3b599fb2505383aa34f32ffe7ceb659426fa3fb71e6f1e8e7",
             "platforms": {
-                "linux/arm64": "sha256:6030741b223fcaccf301e165fb6dace4053dafaba966b067d48c376b7aedb290",
-                "linux/amd64": "sha256:b314de43f2ad7dec0e97e4f0d5033a8c53795118034d13220eb05c9ab885c7a5"
+                "linux/arm64": "sha256:b6457367be5c6863f8d336ce426b9dba7fdfa192308876e4bc390d82a6e18474",
+                "linux/amd64": "sha256:fd5bdc1f34d64bb9aebae1e1d44fc380c1dd815bd6686349e428d4551732f6e0"
             }
         }
     }

package/src/utils/appOptions.js

@@ -11,6 +11,16 @@ const WINDOWS_VERSION = /^(\d+(?:\.\d+){0,3})(?:[-+][0-9A-Za-z.+-]*)?$/;
 // What app.openPath can let the page's shell.openPath open: the app's folders as app.paths() names them, and what a
 // dialog picked during this run.
 const OPEN_PATH_PLACES = ['data', 'cache', 'logs', 'picked'];
+// Apple's app categories, which macOS shows an app under, each with the main categories of the freedesktop menu
+// specification a Linux menu shows it under. An audio or a video app is in AudioVideo as well, as the specification asks.
+const GAMES = ['', 'action-', 'adventure-', 'arcade-', 'board-', 'card-', 'casino-', 'dice-', 'educational-', 'family-', 'kids-', 'music-', 'puzzle-',
+    'racing-', 'role-playing-', 'simulation-', 'sports-', 'strategy-', 'trivia-', 'word-'].map((kind) => `${kind}games`);
+const APP_CATEGORIES = {
+    business: 'Office', 'developer-tools': 'Development', education: 'Education', entertainment: 'AudioVideo', finance: 'Office',
+    'graphics-design': 'Graphics', 'healthcare-fitness': 'Utility', lifestyle: 'Utility', medical: 'Science', music: 'Audio;AudioVideo', news: 'Network',
+    photography: 'Graphics', productivity: 'Office', reference: 'Education', 'social-networking': 'Network', sports: 'Utility', travel: 'Utility',
+    utilities: 'Utility', video: 'Video;AudioVideo', weather: 'Utility', ...Object.fromEntries(GAMES.map((category) => [category, 'Game'])),
+};
 
 // An app's bundle id, which also names its folders on the desktop: app.id, else one made from the project's name.
 export function appId(config) {
@@ -38,6 +48,28 @@ export function appDisplayName(config) {
     return name;
 }
 
+// The copyright line a macOS app's About panel and a Windows executable's details show: app.copyright, else none. The
+// host takes it as a C string and a Windows resource string, as it takes the name.
+export function appCopyright(config) {
+    const copyright = config.app.copyright;
+    if (copyright === undefined) return null;
+    if (typeof copyright !== 'string' || !copyright.trim() || /["\\\p{Cc}]/u.test(copyright)) {
+        throw new Error(`crossbind: app.copyright ${JSON.stringify(copyright)} is no copyright line, which is text without a quotation mark, a backslash or a control character, as '© 2026 Example Inc.' is.`);
+    }
+    return copyright;
+}
+
+// The category app.category names, under which macOS shows the app, and the ones a Linux menu shows it under; none
+// without app.category.
+export function appCategory(config) {
+    const category = config.app.category;
+    if (category === undefined) return null;
+    if (!Object.hasOwn(APP_CATEGORIES, category)) {
+        throw new Error(`crossbind: app.category ${JSON.stringify(category)} is none of Apple's app categories, which are ${Object.keys(APP_CATEGORIES).join(', ')}.`);
+    }
+    return { darwin: `public.app-category.${category}`, linux: APP_CATEGORIES[category] };
+}
+
 // The desktop window: the size of its page, the least it shrinks to and the most it grows to, whether it resizes and
 // whether it opens full screen. Its backgroundColor, which a phone takes as well, is appBackgroundColor's.
 export function appWindow(config) {
@@ -249,6 +281,10 @@ export function appHeader(config, platform) {
         ...PERMISSIONS.map((name) => `#define CROSSBIND_APP_PERMISSION_${name.toUpperCase()} ${name in permissions ? 1 : 0}`),
     ];
     if (!['darwin', 'linux', 'win32'].includes(platform)) return [comment, openPath, ...page, ''].join('\n');
+    // The category goes to the Info.plist and the desktop entry, which the build writes later; any desktop refuses a
+    // wrong one here.
+    const copyright = appCopyright(config);
+    appCategory(config);
     const lines = [
         comment,
         openPath,
@@ -277,6 +313,7 @@ export function appHeader(config, platform) {
     if (platform === 'win32') {
         const version = windowsVersion(config);
         lines.push(`#define CROSSBIND_APP_VERSION "${version.text}"`, `#define CROSSBIND_APP_VERSION_NUMBERS ${version.numbers}`);
+        if (copyright) lines.push(`#define CROSSBIND_APP_COPYRIGHT "${copyright}"`);
         // The build writes the icon beside this header.
         if (config.app.icon !== undefined) lines.push('#define CROSSBIND_APP_ICON 1');
     }

package/src/utils/embindArgumentGuards.js

@@ -26,8 +26,9 @@ const GUARDS = [
     },
 ];
 
-// The release glue spells the bigint conversion `typeof value=="number"`, the debug glue `typeof value == 'number'`.
-const BIGINT_FROM_NUMBER = /if\s*\(\s*typeof value\s*==\s*["']number["']\s*\)\s*\{\s*value\s*=\s*BigInt\(value\)\s*;?\s*\}/g;
+// The release glue spells the bigint conversion `typeof value=="number"`, the debug glue `typeof value == 'number'`;
+// emscripten 6.0.10 and later write `===`, and their release glue drops the braces.
+const BIGINT_FROM_NUMBER = /if\s*\(\s*typeof value\s*===?\s*["']number["']\s*\)\s*(?:\{\s*value\s*=\s*BigInt\(value\)\s*;?\s*\}|value\s*=\s*BigInt\(value\)\s*;?)/g;
 const SAFE_BIGINT_FROM_NUMBER = 'if(typeof value=="number"){if(!Number.isSafeInteger(value))throw new TypeError("a 64-bit integer parameter takes a BigInt or a safe integer Number, got "+value);value=BigInt(value)}';
 
 // Returns the rewritten glue and whether a bigint registration kept a conversion this rewrite does not recognise.
@@ -43,7 +44,7 @@ const DEBUG_GUARDS = [
     {
         registration: '__embind_register_integer',
         end: 'readValueFromPointer: integerReadValueFromPointer(',
-        from: /toWireType: \(destructors, value\) => \{(\s*)(?=if \(typeof value != ["']number["'])/,
+        from: /toWireType: \(destructors, value\) => \{(\s*)(?=if \(typeof value !==? ["']number["'])/,
         to: 'toWireType: (destructors, value) => {$1'
             + 'if (typeof value == "string" && size == 1 && value.length == 1) value = value.charCodeAt(0);$1'
             + 'if (value !== null && typeof value == "object" && typeof value.value == "number") value = value.value;$1',
@@ -72,9 +73,11 @@ function guardDebugRegistration(glue, { registration, end, from, to, applied })
     return { text: glue.slice(0, start) + rewritten + glue.slice(stop), missed: rewritten === code };
 }
 
-// Returns the rewritten glue and the registrations whose code no longer looks the way these rewrites expect.
+// Returns the rewritten glue and the registrations whose code no longer looks the way these rewrites expect. Emscripten
+// 6.0.10 and later write a registration the glue uses once into the wasm imports, as `name:(` rather than `name=(`; a
+// debug glue's wasm imports only name it (`name: __name`).
 export function guardEmbindArguments(glue) {
-    const missed = GUARDS.filter(({ registration, from, to }) => glue.includes(`${registration}=`) && !glue.includes(from) && !glue.includes(to))
+    const missed = GUARDS.filter(({ registration, from, to }) => new RegExp(`${registration}[=:]\\(`).test(glue) && !glue.includes(from) && !glue.includes(to))
         .map(({ registration }) => registration);
     const released = GUARDS.reduce((current, { from, to }) => current.split(from).join(to), glue);
     return DEBUG_GUARDS.reduce(({ text, missed: names }, guard) => {

package/src/utils/embindCallArguments.js

@@ -3,14 +3,14 @@
 // once it returns, or once its promise settles for an async (_JSPI) function, so a call started before
 // then overwrites them and the earlier call frees the later call's arguments instead of its own, which
 // leak: two pending calls of one _JSPI method, or a method called again from a JavaScript callback it
-// runs. Emscripten 6.0.9 builds it this way, as did upstream main on 2026-09-30; this rewrite declares
-// the three inside the invoker, so each call gets its own.
+// runs. Emscripten 6.0.9 and 6.0.13 build it this way, as did upstream main on 2026-09-30; this rewrite
+// declares the three inside the invoker, so each call gets its own.
 
 // The release glue spells it on one line, the debug glue one statement per line with an argument
-// count check first.
-const SHARED = /var argsWired\s*=\s*new Array\(expectedArgCount\);\s*var invokerFuncArgs\s*=\s*\[\];\s*var destructors\s*=\s*\[\];\s*var invokerFn\s*=\s*function\s*\(\.\.\.args\)\s*\{(\s*(?:checkArgCount\([^;]*\);\s*)?)destructors\.length\s*=\s*0;/g;
-const PER_CALL = 'var invokerFn=function(...args){$1var argsWired=new Array(expectedArgCount);var invokerFuncArgs=[];var destructors=[];';
-const SEPARATED = /var invokerFn\s*=\s*function\s*\(\.\.\.args\)\s*\{\s*(?:checkArgCount\([^;]*\);\s*)?var argsWired\s*=/;
+// count check first. Emscripten 6.0.10 and later hand the release invoker straight to createNamedFunction.
+const SHARED = /var argsWired\s*=\s*new Array\(expectedArgCount\);\s*var invokerFuncArgs\s*=\s*\[\];\s*var destructors\s*=\s*\[\];\s*((?:var invokerFn\s*=\s*|return createNamedFunction\(humanName,\s*)function\s*\(\.\.\.args\)\s*\{)(\s*(?:checkArgCount\([^;]*\);\s*)?)destructors\.length\s*=\s*0;/g;
+const PER_CALL = '$1$2var argsWired=new Array(expectedArgCount);var invokerFuncArgs=[];var destructors=[];';
+const SEPARATED = /(?:var invokerFn\s*=\s*|return createNamedFunction\(humanName,\s*)function\s*\(\.\.\.args\)\s*\{\s*(?:checkArgCount\([^;]*\);\s*)?var argsWired\s*=/;
 
 // Returns the rewritten glue and whether it still holds an invoker this rewrite does not recognise.
 export function separateCallArguments(glue) {

package/src/utils/overrideDependency.js

@@ -90,9 +90,12 @@ export function getOverrideKey(dep) {
         override,
         (key, value) => (typeof value === 'function' ? `fn:${value.toString()}` : value),
     );
+    // The package version too: a new release of the package can build the same upstream release differently, as one
+    // that adds a patch does, and the rebuild cached under the old one would keep linking the old build.
     const parts = [
         dep.general?.name || '',
         override.nativeVersion || dep.package?.nativeVersion || '',
+        dep.package?.version || '',
         serial,
     ];
     return getContentHash(parts.join(' '));

package/src/utils/recipePatches.js

@@ -0,0 +1,61 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { getContentHash } from './hash.js';
+
+const patchPath = (file) => (file instanceof URL ? fileURLToPath(file) : file);
+
+// Inside the tree, which every extraction replaces whole: a tree says it is patched only once its own patches went in,
+// so neither one a patch failed on nor one a stopped run left behind passes, whatever stamp an earlier tree had.
+const stampOf = (buildPath) => path.join(buildPath, 'source', '.crossbind-patches');
+
+export function recipePatchesFingerprint(patches) {
+    if (!patches?.length) return null;
+    return getContentHash(JSON.stringify(patches.map(({ file }) => fs.readFileSync(patchPath(file), 'utf8'))));
+}
+
+// downloadAndExtractFile keeps a tree whose archive still matches, so a tree patched under another set
+// would keep its old patches or miss the new ones: it is extracted again instead.
+export function refreshPatchedSource(buildPath, patches) {
+    const stamp = stampOf(buildPath);
+    const recorded = fs.existsSync(stamp) ? fs.readFileSync(stamp, 'utf8') : '';
+    if (recorded !== (recipePatchesFingerprint(patches) ?? '')) {
+        fs.rmSync(path.join(buildPath, 'source'), { recursive: true, force: true });
+    }
+}
+
+export function writePatchedSourceStamp(buildPath, patches) {
+    const fingerprint = recipePatchesFingerprint(patches);
+    if (fingerprint) fs.writeFileSync(stampOf(buildPath), fingerprint);
+    else fs.rmSync(stampOf(buildPath), { force: true });
+}
+
+// git apply is atomic and refuses a hunk whose context does not match, so a source the patch no longer
+// fits stops the build instead of shipping unpatched. It works on the files alone: a repository named in the
+// environment, as a git hook passes on, would make it skip every path, and one the downloaded tree carries could run
+// its filters on the host, so GIT_DIR names none. autocrlf, which Git for Windows sets, would give the patched files
+// CRLF endings.
+export function applyRecipePatches(sourcePath, patches) {
+    const env = {
+        ...Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith('GIT_'))),
+        GIT_DIR: `${sourcePath}.no-repository`,
+    };
+    for (const { file } of patches ?? []) {
+        const patch = patchPath(file);
+        try {
+            execFileSync('git', ['-c', 'core.autocrlf=false', 'apply', '--whitespace=nowarn', '--', patch], {
+                cwd: sourcePath,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env,
+            });
+        } catch (error) {
+            if (error.code === 'ENOENT') throw new Error(`crossbind: applying ${path.basename(patch)} needs git on the PATH.`, { cause: error });
+            throw new Error(
+                `crossbind: ${path.basename(patch)} does not apply to the extracted source. A recipe's patches are diffs against the release it pins: `
+                + `drop the patch once a release includes it.\n${String(error.stderr ?? error.message).trim()}`,
+                { cause: error },
+            );
+        }
+    }
+}

package/src/utils/sourceFingerprint.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import { getContentHash } from './hash.js';
+import { recipePatchesFingerprint } from './recipePatches.js';
 
 // The prebuilt-lib cache in buildLib is existence-only, so a nativeVersion or recipe-sha256 bump
 // would otherwise be served from the previous build - shipping the old upstream under the new
@@ -12,7 +13,13 @@ export function getSourceFingerprint(config, target) {
     // Local-source packages pin neither; buildLib checks their native source inventory instead.
     if (!nativeVersion && !sha256) return null;
     const sourceReplacements = target ? config?.build?.sourceReplaceList?.(target, config.allDependencyPaths?.[target.path] ?? {}) : undefined;
-    return getContentHash(JSON.stringify({ nativeVersion, sha256, ...(sourceReplacements?.length ? { sourceReplacements } : {}) }));
+    const patches = recipePatchesFingerprint(config?.build?.patches);
+    return getContentHash(JSON.stringify({
+        nativeVersion,
+        sha256,
+        ...(sourceReplacements?.length ? { sourceReplacements } : {}),
+        ...(patches ? { patches } : {}),
+    }));
 }
 
 export function isSourceFingerprintStale(libdir, fingerprint) {