@lakutata/builder 3.1.1 → 3.1.5

package/dist/esm/lib/linux/Linux.js

@@ -1,7 +1,8 @@
 import { copyFileSync, lstatSync, mkdirSync, readdirSync, readlinkSync } from 'node:fs';
-import { stat, mkdir, writeFile, rm } from 'node:fs/promises';
+import { stat, mkdir, readFile, writeFile, rm } from 'node:fs/promises';
 import path from 'node:path';
 import { archiveDirectory } from '../Archive.js';
+import { decodePng, writeLinuxIcons } from '../Icons.js';
 import { runCommand } from '../Processes.js';
 import { ensureTool } from '../Tools.js';
 import { embeddedShell, INSTALLER_HOOKS, NATIVE_HOOKS } from '../Scripts.js';
@@ -18,11 +19,47 @@ const RUNTIME_DEPENDS = {
     apk: ['libstdc++', 'libgcc'],
     archlinux: ['gcc-libs']
 };
+/**
+ * The libraries of the system a desktop application of Chromium (NW.js) loads, by package: the deb ones of Electron, and
+ * the atomic operations the Node.js of NW.js loads (libnode.so needs libatomic.so.1, which only the compilers install)
+ */
+const DESKTOP_DEPENDS = {
+    deb: ['libgtk-3-0', 'libnotify4', 'libnss3', 'libxss1', 'libxtst6', 'xdg-utils', 'libatspi2.0-0', 'libuuid1', 'libsecret-1-0', 'libasound2', 'libgbm1', 'libatomic1'],
+    rpm: ['gtk3', 'libnotify', 'nss', 'libXScrnSaver', 'libXtst', 'xdg-utils', 'at-spi2-core', 'libuuid', 'libsecret', 'alsa-lib', 'mesa-libgbm', 'libatomic'],
+    apk: [],
+    archlinux: []
+};
+/**
+ * The desktop entry of a desktop application, which the menus of the desktops list
+ * @param plan
+ * @param executable
+ */
+function desktopEntry(plan, executable) {
+    return [
+        '[Desktop Entry]',
+        'Type=Application',
+        `Name=${plan.productName}`,
+        `Comment=${plan.description.replace(/\s+/g, ' ')}`,
+        `Exec="${plan.prefix}/${executable}" %U`,
+        `Icon=${plan.name}`,
+        'Terminal=false',
+        'Categories=Utility;',
+        ''
+    ].join('\n');
+}
+/**
+ * The lines refreshing the menus and the icons of the desktops after the installation and the removal of a desktop
+ * application, where their tools are installed
+ */
+const DESKTOP_REFRESH = [
+    'command -v update-desktop-database >/dev/null 2>&1 && update-desktop-database -q /usr/share/applications || true',
+    'command -v gtk-update-icon-cache >/dev/null 2>&1 && gtk-update-icon-cache -q -t -f /usr/share/icons/hicolor || true'
+];
 /**
  * The architecture of the packages (the one of Go, which nFPM translates for each package)
  */
-function packageArch() {
-    return { x64: 'amd64', arm64: 'arm64', ia32: '386', arm: 'arm7' }[process.arch] ?? process.arch;
+function packageArch(plan) {
+    return { x64: 'amd64', arm64: 'arm64', ia32: '386', arm: 'arm7' }[plan.arch] ?? plan.arch;
 }
 /**
  * The characters of the globs, which nFPM reads in the sources of the contents (the chunks of Turbopack are named
@@ -78,7 +115,7 @@ function packageFile(plan, target) {
     const arch = { x64: 'x86_64', arm64: 'aarch64' }[process.arch] ?? process.arch;
     switch (target) {
         case 'deb':
-            return `${plan.name}_${plan.version}_${packageArch()}.deb`;
+            return `${plan.name}_${plan.version}_${packageArch(plan)}.deb`;
         case 'rpm':
             return `${plan.name}-${plan.version}-1.${arch}.rpm`;
         case 'apk':
@@ -276,7 +313,8 @@ function packageScripts(plan, target) {
             //Not indented: the lines of the script are the ones of its file
             ...application ? [scriptAction(target, hook), 'if [ -n "$lakutata_action" ]; then', ...embeddedShell(application, plan.prefix, '"$lakutata_action"'), 'fi'] : [],
             ...native ? embeddedShell(native, plan.prefix, '"$@"') : [],
-            ...service.after[hook] ?? []
+            ...service.after[hook] ?? [],
+            ...plan.desktop && (hook === 'postinstall' || hook === 'postremove' || hook === 'postupgrade') ? DESKTOP_REFRESH : []
         ];
         if (lines.length)
             scripts[hook] = ['#!/bin/sh', 'set -e', ...lines, ''].join('\n');
@@ -297,7 +335,7 @@ export async function buildLinuxPackages(plan, targets, work, outdir) {
     const service = plan.service;
     for (const target of targets) {
         if (target === 'tar.gz') {
-            files.push(await archiveDirectory(plan, packageArch(), work, outdir));
+            files.push(await archiveDirectory(plan, packageArch(plan), work, outdir));
             continue;
         }
         const directory = path.join(work, target);
@@ -305,6 +343,17 @@ export async function buildLinuxPackages(plan, targets, work, outdir) {
         const contents = packageContents(plan.directory, plan.prefix, directory);
         if (plan.addToPath)
             contents.push({ src: `${plan.prefix}/${plan.program}`, dst: `/usr/bin/${plan.program}`, type: 'symlink' });
+        if (plan.desktop) {
+            //Its entry in the menus of the desktops, its icons in the theme hicolor
+            await writeFile(path.join(directory, 'desktop'), desktopEntry(plan, plan.desktop.executable));
+            contents.push({ src: path.join(directory, 'desktop'), dst: `/usr/share/applications/${plan.name}.desktop`, file_info: { mode: 0o644 } });
+            if (plan.desktop.icon) {
+                for (const icon of await writeLinuxIcons(decodePng(await readFile(plan.desktop.icon), plan.desktop.icon), path.join(directory, 'icons'))) {
+                    const size = path.basename(icon, '.png');
+                    contents.push({ src: icon, dst: `/usr/share/icons/hicolor/${size}/apps/${plan.name}.png`, file_info: { mode: 0o644 } });
+                }
+            }
+        }
         if (service) {
             await writeFile(path.join(directory, 'environment'), environmentFile(service));
             contents.push({ src: path.join(directory, 'environment'), dst: `/etc/${plan.name}/${plan.name}.env`, type: 'config|noreplace', file_info: { mode: 0o640 } });
@@ -331,7 +380,7 @@ export async function buildLinuxPackages(plan, targets, work, outdir) {
         }
         const config = {
             name: plan.name,
-            arch: packageArch(),
+            arch: packageArch(plan),
             platform: 'linux',
             version: plan.version,
             maintainer: plan.maintainer,
@@ -341,7 +390,7 @@ export async function buildLinuxPackages(plan, targets, work, outdir) {
             ...plan.license ? { license: plan.license } : {},
             ...plan.section ? { section: plan.section } : {},
             ...plan.priority ? { priority: plan.priority } : {},
-            depends: [...new Set([...RUNTIME_DEPENDS[target], ...plan.depends])],
+            depends: [...new Set([...RUNTIME_DEPENDS[target], ...plan.desktop ? DESKTOP_DEPENDS[target] : [], ...plan.depends])],
             ...plan.recommends.length ? { recommends: plan.recommends } : {},
             contents: contents,
             scripts: common,

package/dist/esm/lib/mac/Mac.js

@@ -1,17 +1,18 @@
-import { chmod, cp, mkdir, readFile, rm, stat, symlink, writeFile } from 'node:fs/promises';
+import { chmod, mkdir, readFile, rm, stat, symlink, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { archiveDirectory } from '../Archive.js';
+import { copyDirectory } from '../Directories.js';
 import { runCommand } from '../Processes.js';
 import { embeddedShell } from '../Scripts.js';
 /**
  * The installers of macOS: the package of its installer, and the archive of the directory of the executable
  */
-export const MAC_TARGETS = ['pkg', 'tar.gz'];
+export const MAC_TARGETS = ['pkg', 'dmg', 'tar.gz'];
 /**
  * The architecture of the packages
  */
-function packageArch() {
-    return process.arch;
+function packageArch(plan) {
+    return plan.arch;
 }
 /**
  * A text of a property list
@@ -103,7 +104,7 @@ function preInstall(plan) {
     return [
         '#!/bin/sh',
         'set -e',
-        `if [ -e ${doubleQuoted(`${plan.prefix}/${plan.program}`)} ]; then lakutata_action=upgrade; else lakutata_action=install; fi`,
+        `if [ -e ${doubleQuoted(plan.desktop ? plan.prefix : `${plan.prefix}/${plan.program}`)} ]; then lakutata_action=upgrade; else lakutata_action=install; fi`,
         `if [ -n "$INSTALLER_TEMP" ]; then echo "$lakutata_action" > ${ACTION_FILE}; fi`,
         ...hooks.preinstall ? embeddedShell(hooks.preinstall, plan.prefix, '"$lakutata_action"') : [],
         ''
@@ -223,6 +224,26 @@ function uninstall(plan) {
         ''
     ].join('\n');
 }
+/**
+ * The disk image of a desktop application (dmg): its bundle and a link to /Applications, where its user drags it
+ * @param plan
+ * @param work
+ * @param outdir
+ */
+async function diskImage(plan, work, outdir) {
+    if (!plan.desktop)
+        throw new Error('The disk images (dmg) are made for the desktop applications (NW.js): the other applications are installed by pkg');
+    const volume = path.join(work, 'dmg');
+    await rm(volume, { recursive: true, force: true });
+    await copyDirectory(path.join(plan.directory, plan.desktop.executable), path.join(volume, plan.desktop.executable));
+    await symlink('/Applications', path.join(volume, 'Applications'));
+    const file = path.join(outdir, `${plan.name}-${plan.version}-${packageArch(plan)}.dmg`);
+    await rm(file, { force: true });
+    const created = await runCommand('hdiutil', ['create', '-volname', plan.productName, '-srcfolder', volume, '-ov', '-format', 'UDZO', file], work);
+    if (created.code !== 0)
+        throw new Error(`The disk image cannot be made: ${created.output.trim()}`);
+    return { target: 'dmg', file: file, size: (await stat(file)).size };
+}
 /**
  * Make the installers of macOS of an application: the package installed by its installer (pkgbuild, productbuild), the
  * tar.gz archive of the directory of the executable
@@ -236,7 +257,11 @@ export async function buildMacPackages(plan, targets, work, outdir) {
     const files = [];
     for (const target of targets) {
         if (target === 'tar.gz') {
-            files.push(await archiveDirectory(plan, packageArch(), work, outdir));
+            files.push(await archiveDirectory(plan, packageArch(plan), work, outdir));
+            continue;
+        }
+        if (target === 'dmg') {
+            files.push(await diskImage(plan, work, outdir));
             continue;
         }
         //The files installed, from the root of the system
@@ -246,9 +271,11 @@ export async function buildMacPackages(plan, targets, work, outdir) {
         await rm(scripts, { recursive: true, force: true });
         const prefix = path.join(root, ...plan.prefix.split('/'));
         await mkdir(path.dirname(prefix), { recursive: true });
-        await cp(plan.directory, prefix, { recursive: true, verbatimSymlinks: true });
-        await writeFile(path.join(prefix, 'uninstall'), uninstall(plan), { mode: 0o755 });
-        if (plan.addToPath) {
+        //A desktop application: its bundle into /Applications (removed by its user, as the other applications)
+        await copyDirectory(plan.desktop ? path.join(plan.directory, plan.desktop.executable) : plan.directory, prefix);
+        if (!plan.desktop)
+            await writeFile(path.join(prefix, 'uninstall'), uninstall(plan), { mode: 0o755 });
+        if (plan.addToPath && !plan.desktop) {
             await mkdir(path.join(root, 'usr', 'local', 'bin'), { recursive: true });
             await symlink(path.posix.relative('/usr/local/bin', `${plan.prefix}/${plan.program}`), path.join(root, 'usr', 'local', 'bin', plan.program));
         }
@@ -270,14 +297,15 @@ export async function buildMacPackages(plan, targets, work, outdir) {
         const built = await runCommand('pkgbuild', ['--root', root, '--identifier', plan.appId, '--version', plan.version, '--install-location', '/', '--scripts', scripts, '--ownership', 'recommended', component], work);
         if (built.code !== 0)
             throw new Error(`The pkg package cannot be made: ${built.output.trim()}`);
-        const file = path.join(outdir, `${plan.name}-${plan.version}-${packageArch()}.pkg`);
+        const file = path.join(outdir, `${plan.name}-${plan.version}-${packageArch(plan)}.pkg`);
         await rm(file, { force: true });
         //Installed on the Macs of the architecture of the program only (productbuild gives both)
         const distribution = path.join(work, 'distribution.xml');
         const synthesized = await runCommand('productbuild', ['--synthesize', '--package', component, distribution], work);
         if (synthesized.code !== 0)
             throw new Error(`The pkg package cannot be made: ${synthesized.output.trim()}`);
-        const architectures = `hostArchitectures="${packageArch() === 'arm64' ? 'arm64' : 'x86_64'}"`;
+        //A desktop application of Intel runs on the Macs of Apple silicon too (Rosetta)
+        const architectures = `hostArchitectures="${packageArch(plan) === 'arm64' ? 'arm64' : plan.desktop ? 'x86_64,arm64' : 'x86_64'}"`;
         const options = await readFile(distribution, 'utf8');
         await writeFile(distribution, /hostArchitectures="[^"]*"/.test(options) ? options.replace(/hostArchitectures="[^"]*"/, architectures) : options.replace('<options ', `<options ${architectures} `));
         const product = await runCommand('productbuild', ['--distribution', distribution, '--package-path', work, '--identifier', plan.appId, '--version', plan.version, file], work);

package/dist/esm/lib/nwjs/Addons.js

@@ -0,0 +1,307 @@
+import { existsSync } from 'node:fs';
+import { cp, mkdir, mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+import { runCommand } from '../Processes.js';
+import { cacheDirectory } from '../Tools.js';
+import { compareVersions } from './Runtime.js';
+/**
+ * The name of the Node.js the addons of Windows import their functions from, as node-gyp links them (node.lib), and
+ * the library NW.js holds them in
+ */
+const HOST = 'node.exe';
+const NWJS_NODE = 'node.dll';
+/**
+ * The offset in the file of an address relative to the image, undefined outside the sections
+ * @param sections
+ * @param address
+ */
+function offsetOf(sections, address) {
+    const section = sections.find((item) => address >= item.address && address < item.address + item.size);
+    return section && address - section.address + section.offset;
+}
+/**
+ * The string ending with a zero at an offset of a file
+ * @param file
+ * @param offset
+ */
+function stringAt(file, offset) {
+    const end = file.indexOf(0, offset);
+    return file.toString('latin1', offset, end < 0 ? file.length : end);
+}
+/**
+ * Make an addon of Windows load in NW.js: the libraries it imports (imported or delay-loaded) named node.exe are named
+ * node.dll, the library of NW.js holding the functions of Node.js (Node-API). The delay-load hook of node-gyp gives an
+ * addon the executable when it loads node.exe, which in NW.js does not export them: the addon fails to load ("A dynamic
+ * link library (DLL) initialization routine failed"), or blocks NW.js. Named node.dll, the library is the one NW.js
+ * loaded. The addon is changed in place (its other bytes are kept); it then loads in NW.js only, not in Node.js.
+ * @param file the content of the addon (a .node file of Windows)
+ * @returns the names changed: 0 when it imports no node.exe (an addon built for NW.js, or loading Node.js otherwise)
+ * @internal
+ */
+export function nameNwjsNode(file) {
+    if (file.length < 64 || file.readUInt16LE(0) !== 0x5a4d)
+        throw new Error('Not a portable executable (no MZ header)');
+    const header = file.readUInt32LE(0x3c);
+    if (file.readUInt32LE(header) !== 0x4550)
+        throw new Error('Not a portable executable (no PE signature)');
+    const coff = header + 4;
+    const sectionCount = file.readUInt16LE(coff + 2);
+    const optionalSize = file.readUInt16LE(coff + 16);
+    const optional = coff + 20;
+    const magic = file.readUInt16LE(optional);
+    if (magic !== 0x10b && magic !== 0x20b)
+        throw new Error(`Not a portable executable (optional header ${magic.toString(16)})`);
+    //The data directories: after 96 bytes (PE32), 112 bytes (PE32+); the image base, for the old delay-load tables (addresses)
+    const directories = optional + (magic === 0x10b ? 96 : 112);
+    const imageBase = magic === 0x10b ? file.readUInt32LE(optional + 28) : Number(file.readBigUInt64LE(optional + 24));
+    const sections = [];
+    for (let index = 0, table = optional + optionalSize; index < sectionCount; index++, table += 40) {
+        sections.push({ address: file.readUInt32LE(table + 12), size: Math.max(file.readUInt32LE(table + 8), file.readUInt32LE(table + 16)), offset: file.readUInt32LE(table + 20) });
+    }
+    let changed = 0;
+    const rename = (address) => {
+        const offset = offsetOf(sections, address);
+        if (offset === undefined || stringAt(file, offset).toLowerCase() !== HOST)
+            return;
+        file.write(NWJS_NODE, offset, 'latin1');
+        changed++;
+    };
+    //The imports (directory 1): descriptors of 20 bytes, the name at 12, ending with an empty one
+    const imports = offsetOf(sections, file.readUInt32LE(directories + 8));
+    if (imports !== undefined && file.readUInt32LE(directories + 12)) {
+        for (let descriptor = imports; descriptor + 20 <= file.length && file.readUInt32LE(descriptor + 12); descriptor += 20)
+            rename(file.readUInt32LE(descriptor + 12));
+    }
+    //The delay-loaded imports (directory 13): descriptors of 32 bytes, the name at 4 (an address before the RVA attribute)
+    const delayed = offsetOf(sections, file.readUInt32LE(directories + 13 * 8));
+    if (delayed !== undefined && file.readUInt32LE(directories + 13 * 8 + 4)) {
+        for (let descriptor = delayed; descriptor + 32 <= file.length && file.readUInt32LE(descriptor + 4); descriptor += 32) {
+            const name = file.readUInt32LE(descriptor + 4);
+            rename(file.readUInt32LE(descriptor) & 1 ? name : name - imageBase);
+        }
+    }
+    return changed;
+}
+/**
+ * The architectures of a native binary (Mach-O, possibly universal; ELF; PE) as node names them: x64, ia32, arm64, arm
+ * @param file
+ * @internal
+ */
+export function binaryArchitectures(file) {
+    const names = { 0x01000007: 'x64', 0x0100000c: 'arm64', 7: 'ia32', 12: 'arm' };
+    if (file.length >= 8 && file.readUInt32BE(0) === 0xcafebabe) {
+        const count = file.readUInt32BE(4);
+        return Array.from({ length: count }, (_, index) => names[file.readUInt32BE(8 + index * 20)] ?? 'unknown');
+    }
+    if (file.length >= 8 && (file.readUInt32LE(0) === 0xfeedfacf || file.readUInt32LE(0) === 0xfeedface))
+        return [names[file.readUInt32LE(4)] ?? 'unknown'];
+    if (file.length >= 20 && file.readUInt32BE(0) === 0x7f454c46)
+        return [{ 62: 'x64', 183: 'arm64', 3: 'ia32', 40: 'arm' }[file.readUInt16LE(18)] ?? 'unknown'];
+    if (file.length >= 64 && file.readUInt16LE(0) === 0x5a4d) {
+        const machine = file.readUInt16LE(file.readUInt32LE(0x3c) + 4);
+        return [{ 0x8664: 'x64', 0x14c: 'ia32', 0xaa64: 'arm64' }[machine] ?? 'unknown'];
+    }
+    return ['unknown'];
+}
+/**
+ * Whether an addon uses the C++ API of V8 (NAN, v8.h) rather than Node-API: the names of the functions of V8 it imports
+ * (mangled by the Itanium ABI or by MSVC). Built for the V8 of Node.js, it does not run in the one of NW.js (Chromium)
+ * @param file
+ * @internal
+ */
+export function usesV8Api(file) {
+    return file.includes('_ZN2v8') || file.includes('@v8@@');
+}
+/**
+ * The first release of NW.js whose headers node-gyp builds the addons with (--target, --dist-url)
+ */
+const NODE_GYP_HEADERS = '0.111.3';
+/**
+ * The Node.js whose headers the addons of Node-API of 32-bit Windows are built with when the one of NW.js is later:
+ * Node.js 23 and later publish no library of 32-bit Windows (node.lib), and Node-API runs the addons built for an older
+ * Node.js
+ */
+const WINDOWS_32_NODE = '22.22.0';
+/**
+ * node-gyp: the one of the project, of the builder, else the one of npm
+ * @param project
+ */
+function nodeGyp(project) {
+    for (const base of [path.join(project, 'package.json'), import.meta.url]) {
+        try {
+            return createRequire(base).resolve('node-gyp/bin/node-gyp.js');
+        }
+        catch {
+            //Not installed there
+        }
+    }
+    //The node-gyp of npm, next to the node running the build
+    const prefix = process.platform === 'win32' ? path.dirname(process.execPath) : path.join(path.dirname(process.execPath), '..', 'lib');
+    const bundled = path.join(prefix, 'node_modules', 'npm', 'node_modules', 'node-gyp', 'bin', 'node-gyp.js');
+    if (existsSync(bundled))
+        return bundled;
+    throw new Error('node-gyp builds the addons for NW.js: install it in the project (npm install --save-dev node-gyp)');
+}
+/**
+ * The headers of a release of NW.js for node-gyp, in a directory of their own (--devdir) of the cache: downloaded once,
+ * their common.gypi without the linker of Chromium (lld, which the compilers of macOS and of the Linux systems do not
+ * have: the linker of the system links the addons as well)
+ * @param project
+ * @param release
+ * @returns the directory given to node-gyp (--devdir)
+ */
+async function nwjsHeaders(project, release) {
+    const devdir = path.join(cacheDirectory(), 'nwjs', 'node-gyp');
+    const common = path.join(devdir, release.version, 'common.gypi');
+    if (!existsSync(common)) {
+        const installed = await runCommand(process.execPath, [nodeGyp(project), 'install', `--target=${release.version}`, `--dist-url=${mirror()}`, `--devdir=${devdir}`], project);
+        if (installed.code !== 0 || !existsSync(common))
+            throw new Error(`The headers of NW.js ${release.version} cannot be downloaded: ${installed.output.trim().split('\n').slice(-3).join(' ')}`);
+    }
+    const content = await readFile(common, 'utf8');
+    const linked = content.replace(/,\s*'-fuse-ld=lld'/g, '').replace(/-fuse-ld=lld\s*/g, '');
+    if (linked !== content)
+        await writeFile(common, linked);
+    return devdir;
+}
+/**
+ * Where the releases of NW.js are downloaded from (LAKUTATA_NWJS_MIRROR, else dl.nwjs.io)
+ */
+function mirror() {
+    return (process.env.LAKUTATA_NWJS_MIRROR ?? 'https://dl.nwjs.io').replace(/\/+$/, '');
+}
+/**
+ * The directory of the package of a file (the one holding its package.json)
+ * @param file
+ */
+function packageOf(file) {
+    for (let directory = path.dirname(file); directory !== path.dirname(directory); directory = path.dirname(directory)) {
+        if (existsSync(path.join(directory, 'package.json')))
+            return directory;
+    }
+    return undefined;
+}
+/**
+ * The .node files under a directory
+ * @param directory
+ */
+async function nodeFiles(directory) {
+    if (!existsSync(directory))
+        return [];
+    const found = [];
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+        const file = path.join(directory, entry.name);
+        if (entry.isDirectory())
+            found.push(...await nodeFiles(file));
+        else if (entry.isFile() && entry.name.endsWith('.node'))
+            found.push(file);
+    }
+    return found;
+}
+/**
+ * The headers node-gyp builds the addons of a release of NW.js with: the ones of NW.js for the addons using V8, else the
+ * ones of its Node.js (the Node-API it has; a Node.js 22 on 32-bit Windows when its own one is later)
+ * @param project
+ * @param release
+ * @param platform
+ * @param v8
+ */
+async function headersOf(project, release, platform, v8) {
+    if (!v8)
+        return [`--target=${platform === 'win-ia32' && compareVersions(release.node, '23.0.0') >= 0 ? WINDOWS_32_NODE : release.node}`];
+    if (platform === 'win-ia32') {
+        //The library of 32-bit Windows (at the root of the release, as node-gyp looks for it): the releases since 0.111.3 have none
+        const library = await fetch(`${mirror()}/v${release.version}/node.lib`, { method: 'HEAD' });
+        if (!library.ok)
+            throw new Error(`NW.js ${release.version} publishes no library of 32-bit Windows (node.lib) to build the addons using V8 with: they run in its x64 build, or use a package of Node-API`);
+    }
+    return [`--target=${release.version}`, `--dist-url=${mirror()}`, `--devdir=${await nwjsHeaders(project, release)}`];
+}
+/**
+ * Build a package of addons again from its sources (a copy of it), its addons written into build/Release of its copy
+ * in the native tree
+ * @param project
+ * @param source the directory of the package, in the node_modules of the project
+ * @param target the directory of the package in the native tree
+ * @param arch
+ * @param headers the arguments giving node-gyp its headers (headersOf)
+ */
+async function rebuild(project, source, target, arch, headers) {
+    if (!existsSync(path.join(source, 'binding.gyp')))
+        throw new Error(`${path.basename(source)} has no sources to build its addons for NW.js (binding.gyp): its addons are not for ${arch}${headers.length > 1 ? ' or use V8' : ''}`);
+    const work = await mkdtemp(path.join(os.tmpdir(), 'lakutata-nwjs-addon-'));
+    try {
+        const copy = path.join(work, path.basename(source));
+        await cp(source, copy, { recursive: true, filter: (file) => path.relative(source, file) !== 'build' });
+        //The modules of its build (node-addon-api) found where the package is
+        const modules = (createRequire(path.join(source, 'package.json')).resolve.paths('x') ?? []);
+        const args = [nodeGyp(project), 'rebuild', `--arch=${arch}`, ...headers];
+        const previous = process.env.NODE_PATH;
+        process.env.NODE_PATH = [...modules, previous].filter(Boolean).join(path.delimiter);
+        try {
+            const built = await runCommand(process.execPath, args, copy);
+            if (built.code !== 0)
+                throw new Error(`The addons of ${path.basename(source)} cannot be built for NW.js (node-gyp ${args.slice(1).join(' ')}): ${built.output.trim().split('\n').slice(-5).join(' ')}`);
+        }
+        finally {
+            if (previous === undefined)
+                delete process.env.NODE_PATH;
+            else
+                process.env.NODE_PATH = previous;
+        }
+        await mkdir(path.join(target, 'build', 'Release'), { recursive: true });
+        for (const file of await nodeFiles(path.join(copy, 'build', 'Release')))
+            await cp(file, path.join(target, 'build', 'Release', path.basename(file)));
+    }
+    finally {
+        await rm(work, { recursive: true, force: true });
+    }
+}
+/**
+ * Make the addons of the native tree of an application of NW.js load in its runtime: the packages whose addons are not
+ * for the architecture of the runtime (built with the headers of its Node.js), or use V8 (NW.js 0.111.3 and later: the
+ * headers of NW.js), built again from their sources; on Windows, the node.exe they import named node.dll
+ * @param project
+ * @param directory the native tree
+ * @param files the files of the tree (their sources)
+ * @param release
+ * @param platform the build of NW.js (win-x64, osx-arm64…)
+ * @internal
+ */
+export async function prepareNwjsAddons(project, directory, files, release, platform) {
+    const arch = platform.slice(platform.indexOf('-') + 1);
+    const result = { renamed: [], rebuilt: [] };
+    const done = new Set();
+    for (const file of files.filter((item) => item.path.endsWith('.node'))) {
+        const target = path.join(directory, ...file.path.split('/'));
+        const content = await readFile(target);
+        const v8 = usesV8Api(content);
+        if (v8 && compareVersions(release.version, NODE_GYP_HEADERS) < 0)
+            throw new Error(`${file.path} uses the API of V8 (not Node-API): it runs in NW.js ${NODE_GYP_HEADERS} or later, built with its headers; NW.js ${release.version} needs a package of Node-API instead`);
+        if (!v8 && binaryArchitectures(content).includes(arch))
+            continue;
+        const source = packageOf(file.source);
+        if (!source)
+            throw new Error(`${file.path} is not for ${arch} and is not in a package: build it for NW.js ${release.version} (${platform})`);
+        const relative = path.relative(source, file.source).split(path.sep).join('/');
+        const packageTarget = path.join(directory, ...file.path.slice(0, file.path.length - relative.length).split('/'));
+        if (done.has(packageTarget))
+            continue;
+        done.add(packageTarget);
+        await rebuild(project, source, packageTarget, arch, await headersOf(project, release, platform, v8));
+        result.rebuilt.push(path.basename(source));
+    }
+    if (platform.startsWith('win-')) {
+        for (const file of await nodeFiles(directory)) {
+            const content = await readFile(file);
+            //The addons of Windows only (portable executables)
+            if (content.length > 64 && content.readUInt16LE(0) === 0x5a4d && nameNwjsNode(content)) {
+                await writeFile(file, content);
+                result.renamed.push(path.relative(directory, file).split(path.sep).join('/'));
+            }
+        }
+    }
+    return result;
+}