@lakutata/builder 3.1.3 → 3.1.6

package/README.md

@@ -6,7 +6,7 @@ The builder for lakutata applications. The `package bundle`, `package exe` and `
 `@lakutata/cli` use it, and a project's scripts can call it directly:
 
 ```js
-import {buildExecutable, buildInstaller, bundleProject} from '@lakutata/builder'
+import {buildExecutable, buildInstaller, buildNwjsApp, bundleProject} from '@lakutata/builder'
 
 //dist/<name>.cjs, run by node, with its native addons and its resources next to it
 await bundleProject({project: process.cwd()})
@@ -16,6 +16,8 @@ await buildExecutable({project: process.cwd(), runtime: 'node', layout: 'directo
 //dist/installer: the installers for the current platform (deb, rpm, apk, archlinux, tar.gz on Linux; pkg, tar.gz on
 //macOS; nsis, msi, zip on Windows), which also register the application's service when it declares one
 await buildInstaller({project: process.cwd()})
+//An NW.js application (its version in lakutata.nwjs): dist/nwjs/<name>-<build>, the runtime of NW.js named after it
+await buildNwjsApp({project: process.cwd()})
 ```
 
 The builder works on the compiled application: build the project with `tsc` first, since `tsc` emits the decorator
@@ -29,6 +31,27 @@ result. At run time, `resourcesPath()` from lakutata locates the application's r
 `lakutata package bundle`, `lakutata package exe` and `lakutata package installer` in the `@lakutata/cli`
 documentation.
 
+The NW.js applications run in the version of NW.js of their `lakutata.nwjs`. `nwjsReleases()` lists the releases of
+NW.js, `downloadNwjs()` downloads a runtime into the cache (checked against the checksums of its release), and
+`stageNwjsApp()` makes the application for NW.js: its bundle for the Node.js of that NW.js, its native addons made to
+load in it (built again for its architecture, or with its headers when they use the V8 API; on Windows, given the
+Node.js of NW.js), its resources and the manifest of NW.js. `buildNwjsApp()` puts it into the normal flavor of NW.js
+named after the application, and `buildInstaller()` makes its installers with `"runtime": "nwjs"` (the installers of a
+desktop application: dmg on macOS, nsis on Windows, deb on Linux by default).
+
+The mobile applications of React Native (Android, iOS, HarmonyOS) run in a libnode built from the sources of Node.js by
+lakutata/libnode. `downloadMobileNode()` downloads the libnode of a system from its releases once
+(`LAKUTATA_LIBNODE_MIRROR`: a mirror of them), checks it with their checksums and keeps it in the cache
+(`LAKUTATA_MOBILE_NODE_DIR`: a libnode of your own instead). `stageMobileApp()` makes the Node.js project of the
+application: the bundle for the Node.js of the libnode (Node.js 24.20.0, `MOBILE_NODE_VERSION`, without a libnode), the
+resources, the manifest and an entry that puts away `fetch()` without WebAssembly (HarmonyOS). It builds the native
+addons for the system from their sources, against the headers and the libraries of the libnode: a native tree per
+architecture of Android (node-gyp and the NDK), for iOS a framework per addon for each SDK (Xcode) in the directory the
+`frameworks` option gives, and for HarmonyOS a library per addon (the native SDK of DevEco Studio) in the libraries of
+the HAP the `libraries` option gives. The HAP of HarmonyOS leaves out of its resources the files whose names start with
+a dot: on HarmonyOS the native tree is packed into the project (`native.gz`, `native.json`) and extracted at its first
+run into the directory `LAKUTATA_NATIVE_DIR` gives.
+
 The Linux installers are tested in containers (Docker): `npm run test:installer` builds them on Debian and Alpine, then
 installs, upgrades and removes them on Debian and Fedora (systemd) and on Alpine (OpenRC). The macOS installers are
 installed in a macOS virtual machine (`npm run test:installer:mac`, with tart), and the Windows installers on Windows,

package/README.zh-CN.md

@@ -5,7 +5,7 @@
 lakutata 应用的打包工具。`@lakutata/cli` 的 `package bundle`、`package exe` 和 `package installer` 命令都靠它完成工作，项目的脚本也可以直接调用它：
 
 ```js
-import {buildExecutable, buildInstaller, bundleProject} from '@lakutata/builder'
+import {buildExecutable, buildInstaller, buildNwjsApp, bundleProject} from '@lakutata/builder'
 
 //dist/<name>.cjs，由 node 运行，原生插件和资源放在它旁边
 await bundleProject({project: process.cwd()})
@@ -15,10 +15,16 @@ await buildExecutable({project: process.cwd(), runtime: 'node', layout: 'directo
 //dist/installer：当前平台的安装包（Linux 上是 deb、rpm、apk、archlinux、tar.gz；macOS 上是 pkg、tar.gz；
 //Windows 上是 nsis、msi、zip），应用声明了服务时，安装包还会注册这个服务
 await buildInstaller({project: process.cwd()})
+//NW.js 应用（版本在 lakutata.nwjs 中）：dist/nwjs/<name>-<build>，以应用命名的 NW.js 运行时
+await buildNwjsApp({project: process.cwd()})
 ```
 
 打包工具处理的是编译后的应用：请先用 `tsc` 构建项目，因为装饰器的元数据是由 `tsc` 生成的。单文件包是一个 CommonJS 文件，由 esbuild 生成。原生插件不能打进单文件包，所以它们连同运行时加载的内容会一起收集到一个 native 目录树中。打包器跟踪不到应用按路径读取的文件，这些文件也放在这个目录树中：单独运行的脚本（worker、worker 池、`fork()`、`require(path.join(__dirname, 'x.js'))`）会各自打包，数据文件和目录则直接复制。打包工具会找出由模块位置构造的路径，并改写它们；无法一起发布的内容会列在结果的 `warnings` 中。运行时，lakutata 的 `resourcesPath()` 负责找到应用的资源，这些资源在应用 `package.json` 的 `lakutata.resources` 中声明。安装包则由同一个文件中的 `lakutata.installer` 配置。详见 `@lakutata/cli` 文档中的 `lakutata package bundle`、`lakutata package exe` 和 `lakutata package installer`。
 
+NW.js 应用运行在它 `lakutata.nwjs` 中指定的 NW.js 版本里。`nwjsReleases()` 列出 NW.js 的发布版本，`downloadNwjs()` 把一个运行时下载到缓存目录（按其发布版本的校验和核对），`stageNwjsApp()` 为 NW.js 准备应用：为这个 NW.js 的 Node.js 打包的代码、处理成能在其中加载的原生插件（为它的架构重新构建，使用 V8 API 的插件用它的头文件重新构建；在 Windows 上让插件加载 NW.js 的 Node.js）、资源和 NW.js 的清单。`buildNwjsApp()` 把应用放进以应用命名的 NW.js normal 版本中，`buildInstaller()` 在 `"runtime": "nwjs"` 时制作它的安装包（桌面应用的安装包：默认 macOS 上是 dmg，Windows 上是 nsis，Linux 上是 deb）。
+
+React Native 手机应用（Android、iOS、鸿蒙）运行在一个 libnode 中，它由 lakutata/libnode 从 Node.js 源码编译而成。`downloadMobileNode()` 从它的 Release 下载一个系统的 libnode，只下载一次（`LAKUTATA_LIBNODE_MIRROR` 指定镜像），用 Release 的校验和验证后保存在缓存中（设置 `LAKUTATA_MOBILE_NODE_DIR` 时改用自己编译的 libnode）。`stageMobileApp()` 生成应用的 Node.js 项目：面向 libnode 中的 Node.js 的单文件包（没有 libnode 时面向 Node.js 24.20.0，`MOBILE_NODE_VERSION`）、资源、清单，以及一个入口：没有 WebAssembly 时（鸿蒙）收起 `fetch()`。它还会用 libnode 的头文件和库，从源码为目标系统编译原生插件：Android 每种架构一棵原生树（node-gyp 和 NDK）；iOS 每个插件为每个 SDK 编成一个 framework（Xcode），放在 `frameworks` 指定的目录中；鸿蒙每个插件编成一个库（DevEco Studio 的原生 SDK），放在 `libraries` 指定的 HAP 库目录中。鸿蒙的 HAP 会把以点开头的文件从资源中去掉，所以鸿蒙上的原生树打包进项目（`native.gz`、`native.json`），第一次运行时解压到 `LAKUTATA_NATIVE_DIR` 指定的目录。
+
 Linux 安装包在容器（Docker）中测试：`npm run test:installer` 先在 Debian 和 Alpine 上制作安装包，再在 Debian、Fedora（systemd）和 Alpine（OpenRC）上安装、升级和卸载它们。macOS 安装包在 macOS 虚拟机中测试安装（`npm run test:installer:mac`，使用 tart），Windows 安装包则在 Windows 上以管理员身份测试安装（`LAKUTATA_WINDOWS_INSTALL=1 npm run test:installer:windows`）。
 
 ## 另见

package/dist/esm/index.js

@@ -11,3 +11,8 @@ export { INSTALLER_HOOKS, NATIVE_HOOKS } from './lib/Scripts.js';
 export { detectLibc } from './lib/Platform.js';
 export { WINDOWS_TARGETS } from './lib/win/Windows.js';
 export { MAC_TARGETS } from './lib/mac/Mac.js';
+export { downloadNwjs, nwjsPlatform, nwjsRelease, nwjsReleases } from './lib/nwjs/Runtime.js';
+export { stageNwjsApp } from './lib/nwjs/Stage.js';
+export { buildNwjsApp } from './lib/nwjs/Package.js';
+export { stageMobileApp } from './lib/mobile/Stage.js';
+export { downloadMobileNode, MOBILE_NODE_RELEASE, MOBILE_NODE_VERSION } from './lib/mobile/Node.js';

package/dist/esm/lib/Archive.js

@@ -1,5 +1,6 @@
-import { cp, rm, stat } from 'node:fs/promises';
+import { rm, stat } from 'node:fs/promises';
 import path from 'node:path';
+import { copyDirectory } from './Directories.js';
 import { runCommand } from './Processes.js';
 /**
  * The tar.gz archive of the directory of the executable (its native addons and its resources next to it), named after
@@ -12,7 +13,7 @@ import { runCommand } from './Processes.js';
 export async function archiveDirectory(plan, arch, work, outdir) {
     const base = `${plan.name}-${plan.version}-${process.platform}-${arch}`;
     await rm(path.join(work, base), { recursive: true, force: true });
-    await cp(plan.directory, path.join(work, base), { recursive: true, verbatimSymlinks: true });
+    await copyDirectory(plan.directory, path.join(work, base));
     const file = path.join(outdir, `${base}.tar.gz`);
     const archived = await runCommand('tar', ['-czf', file, base], work);
     if (archived.code !== 0)

package/dist/esm/lib/Bundle.js

@@ -25,6 +25,7 @@ const IMPORT_META_URL = '__lakutataImportMetaUrl';
  * arguments of the CommonJS modules: its file is the executable (as in the executables of Node.js), its require loads
  * the modules of node and the ones of a node_modules next to the executable (the ones left out of the bundle)
  */
+//node-compat: process.getBuiltinModule (Bun only)
 const BUN_PRELUDE = 'var __filename=process.execPath,__dirname=process.getBuiltinModule(\'node:path\').dirname(__filename),require=typeof require===\'function\'?require:process.getBuiltinModule(\'node:module\').createRequire(__filename);';
 /**
  * The files of the resources of an application, declared by the "lakutata.resources" of its package.json: their paths in
@@ -111,7 +112,7 @@ export async function bundleProject(options) {
             metafile: true,
             bundle: true,
             platform: 'node',
-            target: `node${process.versions.node.split('.')[0]}`,
+            target: `node${options.node?.replace(/^v/, '') ?? process.versions.node.split('.')[0]}`,
             format: 'cjs',
             minify: options.minify ?? true,
             //The names of the classes are the ones of the objects of the container and of the errors

package/dist/esm/lib/Directories.js

@@ -0,0 +1,18 @@
+import { cp, mkdir } from 'node:fs/promises';
+import path from 'node:path';
+import { runCommand } from './Processes.js';
+/**
+ * Copy a directory into another one, its links kept as they are: cp -a on macOS and Linux (the copy of Node.js turns
+ * the relative links into absolute ones before Node.js 18.17 and 20.2: its option verbatimSymlinks), the copy of Node.js
+ * on Windows (its directories have no links)
+ * @param source
+ * @param target
+ */
+export async function copyDirectory(source, target) {
+    if (process.platform === 'win32')
+        return await cp(source, target, { recursive: true });
+    await mkdir(target, { recursive: true });
+    const copied = await runCommand('cp', ['-a', `${source}/.`, target], path.dirname(target));
+    if (copied.code !== 0)
+        throw new Error(`${source} cannot be copied: ${copied.output.trim()}`);
+}

package/dist/esm/lib/Executable.js

@@ -76,14 +76,31 @@ async function writeIcon(work, icon) {
     return file;
 }
 /**
- * Embed a bundle in the Node.js binary running the tool (the single executable applications of Node.js)
+ * The node program embedded in an executable and its version: the one given, else the one running the tool. It must
+ * have the assets of the single executable applications (Node.js 20.12, 21.7 or later): node:sea and its getAsset.
+ * @param program
+ */
+async function nodeOfExecutable(program) {
+    const node = program ? path.resolve(program) : process.execPath;
+    //node-compat: node:sea (the probe, run by the node program, loads it in a try)
+    const probe = await runCommand(node, ['-e', "let assets=false;try{assets=typeof require('node:sea').getAsset==='function'}catch{}process.stdout.write(process.version+' '+assets)"], process.cwd()).catch((error) => ({ code: 1, output: error.message }));
+    const [version, assets] = probe.output.trim().split(' ');
+    if (probe.code !== 0 || !/^v\d+\.\d+\.\d+$/.test(version))
+        throw new Error(`${node} cannot be run as the node program of the executable: ${probe.output.trim()}`);
+    if (assets !== 'true')
+        throw new Error(`The executables of Node.js need the assets of its single executable applications (Node.js 20.12, 21.7 or later): ${node} is Node.js ${version}. Give a newer node program (nodeProgram, --node-program). Or make the executable with Bun (--runtime bun)`);
+    return { path: node, version: version };
+}
+/**
+ * Embed a bundle in a Node.js binary (the single executable applications of Node.js)
  * @param bundle
  * @param work
  * @param file
  * @param warnings
+ * @param node the node program embedded
  * @param icon the icon of the application (ico, Windows)
  */
-async function embedInNode(bundle, work, file, warnings, icon) {
+async function embedInNode(bundle, work, file, warnings, node, icon) {
     const assets = {};
     if (bundle.native) {
         //The files of the native packages, extracted by the executable at its first run
@@ -104,9 +121,9 @@ async function embedInNode(bundle, work, file, warnings, icon) {
         useSnapshot: false,
         assets: assets
     }));
-    await must(process.execPath, ['--experimental-sea-config', 'sea-config.json'], work);
+    await must(node.path, ['--experimental-sea-config', 'sea-config.json'], work);
     const { inject } = await import('postject');
-    await copyFile(process.execPath, file);
+    await copyFile(node.path, file);
     //The icon of the application replaces the one of node.exe, before the bundle is embedded
     if (icon)
         await setExecutableIcon(file, icon);
@@ -119,7 +136,7 @@ async function embedInNode(bundle, work, file, warnings, icon) {
     //The Authenticode signature of node.exe does not match the executable anymore
     if (process.platform === 'win32')
         warnings.push(`${path.basename(file)} has the signature of Node.js, which is not valid anymore: sign it (signtool) before distributing it`);
-    return `Node.js ${process.version}`;
+    return `Node.js ${node.version}`;
 }
 /**
  * Compile a bundle into an executable of Bun, in bytecode: the files of the native tree are embedded beside it, the
@@ -189,6 +206,8 @@ export async function buildExecutable(options) {
     const outdir = path.resolve(project, options.outdir ?? 'dist');
     //Bun is found before the application is bundled
     const bun = options.runtime === 'bun' ? await findBun(project) : undefined;
+    //The node program embedded, checked before the application is bundled
+    const node = bun ? undefined : await nodeOfExecutable(options.nodeProgram);
     const work = await mkdtemp(path.join(os.tmpdir(), 'lakutata-executable-'));
     try {
         const directory = options.layout === 'directory';
@@ -200,6 +219,8 @@ export async function buildExecutable(options) {
             await rm(target, { recursive: true, force: true });
         await mkdir(target, { recursive: true });
         const bundle = await bundleProject({
+            //The syntax of the node embedded
+            ...node ? { node: node.version } : {},
             ...options,
             outfile: path.join(work, 'main.cjs'),
             native: directory ? 'directory' : 'embedded',
@@ -225,7 +246,7 @@ export async function buildExecutable(options) {
         //The icon of the application: the one of the executables of Windows (the ones of macOS and Linux have none)
         const application = applicationIcon(project, manifest);
         const icon = application && process.platform === 'win32' ? icoFile(application.image) : undefined;
-        const runtime = bun ? await compileWithBun(bun, embedded, work, made, icon) : await embedInNode(embedded, work, made, warnings, icon);
+        const runtime = bun ? await compileWithBun(bun, embedded, work, made, icon) : await embedInNode(embedded, work, made, warnings, node, icon);
         await copyFile(made, file);
         await chmod(file, 0o755);
         return {

package/dist/esm/lib/Installer.js

@@ -3,6 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { programName } from './Bundle.js';
 import { buildElectronInstaller } from './electron/Electron.js';
+import { buildNwjsApp } from './nwjs/Package.js';
 import { buildExecutable } from './Executable.js';
 import { applicationIcon, icoFile } from './Icons.js';
 import { detectLibc } from './Platform.js';
@@ -51,10 +52,12 @@ export async function buildInstaller(options) {
     if (process.platform !== 'linux' && !mac && !windows)
         throw new Error(`The installers of ${process.platform} are not supported: the ones of Linux are made on Linux, the ones of macOS on macOS, the ones of Windows on Windows`);
     const libc = detectLibc();
+    //A desktop application (NW.js): its installers by default the ones of the desktop applications (as electron-builder)
+    const desktop = config.runtime === 'nwjs';
     const targets = options.targets?.length ? options.targets
-        : mac ? config.mac?.targets ?? ['pkg', 'tar.gz']
-            : windows ? config.win?.targets ?? ['nsis', 'msi', 'zip']
-                : config.linux?.targets ?? (libc === 'glibc' ? ['deb', 'rpm', 'tar.gz'] : ['apk', 'tar.gz']);
+        : mac ? config.mac?.targets ?? (desktop ? ['dmg'] : ['pkg', 'tar.gz'])
+            : windows ? config.win?.targets ?? (desktop ? ['nsis'] : ['nsis', 'msi', 'zip'])
+                : config.linux?.targets ?? (libc === 'glibc' ? (desktop ? ['deb'] : ['deb', 'rpm', 'tar.gz']) : desktop ? ['tar.gz'] : ['apk', 'tar.gz']);
     for (const target of targets) {
         if (mac) {
             if (!MAC_TARGETS.includes(target))
@@ -91,6 +94,8 @@ export async function buildInstaller(options) {
     if (!/^[A-Za-z0-9][A-Za-z0-9.-]*$/.test(appId))
         throw new Error(`The identifier of the application "${appId}" must be letters, digits, "." and "-" (lakutata.installer.appId)`);
     const service = config.service === true ? {} : config.service || undefined;
+    if (desktop && service)
+        throw new Error('A desktop application (lakutata.installer.runtime nwjs) has no service (lakutata.installer.service)');
     if (service?.name !== undefined && !/^[A-Za-z0-9_.@-]+$/.test(service.name))
         throw new Error(`The name of the service "${service.name}" must be letters, digits, "_", ".", "@" and "-"`);
     //A user of the system (Linux, macOS), an account of Windows (DOMAIN\user, NT SERVICE\name, a managed account ending in $)
@@ -108,35 +113,42 @@ export async function buildInstaller(options) {
             icon = path.join(work, 'icon.ico');
             await writeFile(icon, icoFile(application.image));
         }
-        const executable = await buildExecutable({
+        //The executable and what it loads; or the application of NW.js (its runtime, its executable named after it)
+        const nwjs = desktop ? await buildNwjsApp({ project: project, entry: options.entry, minify: options.minify, external: options.external, arch: options.arch, outdir: path.join(work, 'stage'), progress: options.progress }) : undefined;
+        const executable = nwjs ? undefined : await buildExecutable({
             project: project,
             entry: options.entry,
             minify: options.minify,
             external: options.external,
             runtime: config.runtime,
+            nodeProgram: options.nodeProgram,
             layout: 'directory',
             outdir: path.join(work, 'stage')
         });
-        warnings.push(...executable.warnings);
+        warnings.push(...executable?.warnings ?? nwjs.stage.bundle.warnings);
+        //The directory installed: the one of the bundle of macOS (/Applications/<product>.app), the one of the runtime of NW.js
+        const installed = nwjs ? (mac ? path.dirname(nwjs.directory) : nwjs.directory) : executable.directory;
+        const launcher = nwjs && path.basename(mac ? nwjs.directory : nwjs.executable);
         const plan = {
             name: name,
             appId: appId,
             productName: config.productName ?? (typeof manifest.productName === 'string' ? manifest.productName : name),
             program: program,
             version: version,
-            description: config.description ?? manifest.description ?? name,
+            //An empty description is none (the one of a project created without it): Windows Installer refuses it
+            description: config.description || manifest.description || name,
             maintainer: maintainer,
             homepage: config.homepage ?? (typeof manifest.homepage === 'string' ? manifest.homepage : undefined),
             license: config.license ?? (typeof manifest.license === 'string' ? manifest.license : undefined),
             vendor: config.vendor,
-            addToPath: config.addToPath ?? true,
+            addToPath: config.addToPath ?? !desktop,
             depends: config.linux?.depends ?? [],
             recommends: config.linux?.recommends ?? [],
             section: config.linux?.section,
             priority: config.linux?.priority,
             service: service && {
                 name: service.name ?? name,
-                description: service.description ?? config.description ?? manifest.description ?? name,
+                description: service.description || config.description || manifest.description || name,
                 args: service.args ?? [],
                 env: { MODE: 'production', ...service.env },
                 //The users of the services of macOS are hidden by their names (_www), the ones of Windows are virtual
@@ -144,17 +156,19 @@ export async function buildInstaller(options) {
                 restart: service.restart ?? 'on-failure',
                 autoStart: service.autoStart ?? true
             },
-            directory: executable.directory,
-            prefix: mac ? `/usr/local/lib/${name}` : windows ? `C:\\Program Files\\${name}` : `/opt/${name}`,
+            directory: installed,
+            prefix: mac ? (launcher ? `/Applications/${launcher}` : `/usr/local/lib/${name}`) : windows ? `C:\\Program Files\\${name}` : `/opt/${name}`,
             scripts: scripts,
-            icon: icon
+            icon: icon,
+            arch: nwjs ? nwjs.runtime.platform.slice(nwjs.runtime.platform.indexOf('-') + 1) : process.arch,
+            ...launcher ? { desktop: { executable: launcher, icon: application?.file } } : {}
         };
         const outdir = path.resolve(project, options.outdir ?? path.join('dist', 'installer'));
         await mkdir(outdir, { recursive: true });
         const files = mac ? await buildMacPackages(plan, targets, path.join(work, 'mac'), outdir)
-            : windows ? await buildWindowsPackages(plan, targets, path.join(work, 'win'), outdir)
-                : await buildLinuxPackages(plan, targets, path.join(work, 'linux'), outdir);
-        return { name: name, version: version, files: files, executable: executable, warnings: warnings };
+            : windows ? await buildWindowsPackages(plan, targets, path.join(work, 'win'), outdir, options.progress)
+                : await buildLinuxPackages(plan, targets, path.join(work, 'linux'), outdir, options.progress);
+        return { name: name, version: version, files: files, ...executable ? { executable: executable } : {}, ...nwjs ? { nwjs: nwjs } : {}, warnings: warnings };
     }
     finally {
         await rm(work, { recursive: true, force: true });

package/dist/esm/lib/NativeRuntime.js

@@ -30,8 +30,10 @@ export function lakutataNativeRequire(nodeRequire, config) {
     const fs = nodeRequire('node:fs');
     const os = nodeRequire('node:os');
     const { createRequire, isBuiltin } = nodeRequire('node:module');
+    //node-compat: node:sea (a type here; loaded below only where it exists)
     let sea;
     try {
+        //node-compat: node:sea
         sea = nodeRequire('node:sea');
     }
     catch {
@@ -80,13 +82,33 @@ export function lakutataNativeRequire(nodeRequire, config) {
                     fs.symlinkSync(path.relative(path.dirname(at), local(temporary, link.target)), at, 'dir');
             }
             fs.writeFileSync(path.join(temporary, '.complete'), '');
+            const complete = () => fs.existsSync(path.join(directory, '.complete'));
             try {
                 fs.renameSync(temporary, directory);
             }
             catch (error) {
                 //Another process extracted it
-                if (!fs.existsSync(path.join(directory, '.complete')))
+                if (complete())
+                    return directory;
+                if (!fs.existsSync(directory))
                     throw error;
+                //A tree left incomplete (a process stopped, a cleaning of the temporary files that keeps the directories):
+                //moved aside, removed, replaced
+                const stale = `${directory}.stale.${process.pid}.${Date.now()}`;
+                try {
+                    fs.renameSync(directory, stale);
+                }
+                catch {
+                    //Moved by another process
+                }
+                fs.rmSync(stale, { recursive: true, force: true });
+                try {
+                    fs.renameSync(temporary, directory);
+                }
+                catch (retry) {
+                    if (!complete())
+                        throw retry;
+                }
             }
         }
         finally {
@@ -112,10 +134,12 @@ export function lakutataNativeRequire(nodeRequire, config) {
             }
         }
         else {
-            //Next to the bundle, or in the resources of a packaged Electron application (outside of its archive)
+            //Next to the bundle, the tree of the architecture first (<directory>-arm64: a mobile application of Android holds
+            //one tree per architecture), or in the resources of a packaged Electron application (outside of its archive)
             const resources = process.resourcesPath;
             const local = path.join(__dirname, config.directory);
-            root = fs.existsSync(local) || !resources ? local : path.join(resources, config.directory);
+            const own = `${local}-${process.arch}`;
+            root = fs.existsSync(own) ? own : fs.existsSync(local) || !resources ? local : path.join(resources, config.directory);
         }
         return root;
     };

package/dist/esm/lib/Processes.js

@@ -27,11 +27,12 @@ export function spawnCommand(command, args, options) {
  * @param command
  * @param args
  * @param cwd
+ * @param env its environment, the one of the process by default
  * @return the exit code and the output
  */
-export function runCommand(command, args, cwd) {
+export function runCommand(command, args, cwd, env) {
     return new Promise((resolve, reject) => {
-        const child = spawnCommand(command, args, { cwd: cwd });
+        const child = spawnCommand(command, args, { cwd: cwd, env: env });
         let output = '';
         //Piped (the default stdio)
         child.stdout.on('data', (chunk) => output += chunk.toString());

package/dist/esm/lib/Tools.js

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
-import { chmod, mkdir, mkdtemp, rename, rm, writeFile } from 'node:fs/promises';
+import { chmod, mkdir, mkdtemp, open, rename, rm } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { runCommand } from './Processes.js';
@@ -54,13 +54,100 @@ const TOOLS = {
 export function cacheDirectory() {
     return process.env.LAKUTATA_CACHE_DIR ?? path.join(process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache'), 'lakutata');
 }
+/**
+ * Download a file, its sha256 computed while it is written. A connection receiving too little (one of the releases of
+ * GitHub can stay at some kilobytes a second while another one downloads the file at once) or broken is left for
+ * another one, which downloads the file again from its start
+ * @param url
+ * @param file
+ * @param options
+ */
+export async function downloadFile(url, file, options = {}) {
+    const interval = options.interval ?? 30000;
+    const minimum = options.minimum ?? 100 * 1024;
+    const attempts = options.attempts ?? 3;
+    const slow = `under ${minimum % 1024 === 0 ? `${minimum / 1024} KB` : `${minimum} bytes`} received in ${interval / 1000} s`;
+    for (let attempt = 1;; attempt++) {
+        const controller = new AbortController();
+        let received = 0;
+        let checked = 0;
+        //From the request: a connection waiting for its response receives nothing too
+        const timer = setInterval(() => {
+            if (received - checked < minimum)
+                controller.abort();
+            checked = received;
+        }, interval);
+        try {
+            const response = await fetch(url, { headers: options.headers, signal: controller.signal });
+            if (!response.ok || !response.body)
+                throw new Error(`${url} cannot be downloaded (${response.status})`);
+            const hash = createHash('sha256');
+            const handle = await open(file, 'w');
+            try {
+                for await (const chunk of response.body) {
+                    received += chunk.length;
+                    hash.update(chunk);
+                    await handle.write(chunk);
+                }
+            }
+            finally {
+                await handle.close();
+            }
+            return hash.digest('hex');
+        }
+        catch (error) {
+            //The connections broken fail with a TypeError (fetch failed, terminated); a file refused by the server, or
+            //which cannot be written, is not downloaded again
+            const cause = error.cause?.code;
+            const reason = controller.signal.aborted ? slow : error instanceof TypeError ? `${error.message}${cause ? ` (${cause})` : ''}` : undefined;
+            if (reason === undefined)
+                throw error;
+            if (attempt === attempts)
+                throw new Error(`${url} cannot be downloaded, ${attempts} connections tried: ${reason}`, { cause: error });
+            options.progress?.(`${path.basename(file)} again (${attempt + 1}/${attempts}): ${reason}`);
+        }
+        finally {
+            clearInterval(timer);
+        }
+    }
+}
+/**
+ * Move a directory written aside into its place in the cache. The one already there is kept when it is complete (put
+ * there by another build running at the same time), and replaced when it is not: left by a build that was stopped, or
+ * emptied by a cleaning of the temporary files that removes the files and keeps the directories (macOS cleans its
+ * temporary directory so)
+ * @param temporary The directory written, removed by the caller.
+ * @param target Its place in the cache.
+ * @param complete Whether the directory in its place is complete.
+ */
+export async function moveIntoCache(temporary, target, complete) {
+    try {
+        await rename(temporary, target);
+    }
+    catch (error) {
+        if (complete())
+            return;
+        if (!existsSync(target))
+            throw error;
+        //Moved aside before being removed: its place is free at once for this build and the others
+        const stale = `${target}.stale-${process.pid}-${Date.now()}`;
+        await rename(target, stale).catch(() => undefined);
+        await rm(stale, { recursive: true, force: true });
+        await rename(temporary, target).catch((retry) => {
+            //Put there by another build meanwhile
+            if (!complete())
+                throw retry;
+        });
+    }
+}
 /**
  * A tool of the builder: the one given by its environment variable (LAKUTATA_NFPM, LAKUTATA_WINSW, LAKUTATA_NSIS:
  * makensis.exe, LAKUTATA_WIX: candle.exe, next to light.exe), else the version of the builder, downloaded once into the
  * cache and checked with its sha256
  * @param name
+ * @param progress Called with what is being downloaded
  */
-export async function ensureTool(name) {
+export async function ensureTool(name, progress) {
     const given = process.env[`LAKUTATA_${name.toUpperCase()}`];
     if (given)
         return given;
@@ -73,21 +160,17 @@ export async function ensureTool(name) {
     const executable = path.join(directory, ...tool.executable.split('/'));
     if (existsSync(executable))
         return executable;
-    //SourceForge answers the browsers with its page, the tools with the file
-    const response = await fetch(tool.url(release.archive), { headers: { 'user-agent': 'Wget' } }).catch((error) => {
-        throw new Error(`${name} cannot be downloaded (${error.message}): give its executable (LAKUTATA_${name.toUpperCase()})`);
-    });
-    if (!response.ok)
-        throw new Error(`${name} cannot be downloaded (${tool.url(release.archive)}: ${response.status}): give its executable (LAKUTATA_${name.toUpperCase()})`);
-    const archive = Buffer.from(await response.arrayBuffer());
-    const sha256 = createHash('sha256').update(archive).digest('hex');
-    if (sha256 !== release.sha256)
-        throw new Error(`The archive of ${name} ${tool.version} downloaded is not the one of its release (sha256 ${sha256})`);
-    //Extracted aside, then renamed: the builds running together do not see it partly written
+    progress?.(`${release.archive} (${name} ${tool.version})`);
+    //Downloaded and extracted aside, then renamed: the builds running together do not see it partly written
     await mkdir(path.dirname(directory), { recursive: true });
     const temporary = await mkdtemp(`${directory}.`);
     try {
-        await writeFile(path.join(temporary, release.archive), archive);
+        //SourceForge answers the browsers with its page, the tools with the file
+        const sha256 = await downloadFile(tool.url(release.archive), path.join(temporary, release.archive), { headers: { 'user-agent': 'Wget' }, progress: progress }).catch((error) => {
+            throw new Error(`${error.message}: give the executable of ${name} (LAKUTATA_${name.toUpperCase()})`);
+        });
+        if (sha256 !== release.sha256)
+            throw new Error(`The archive of ${name} ${tool.version} downloaded is not the one of its release (sha256 ${sha256})`);
         //An archive (tar.gz, zip: the tar of Windows reads them), or the executable itself
         if (/\.(tar\.gz|zip)$/.test(release.archive)) {
             const extracted = await runCommand('tar', ['-xf', release.archive], temporary);
@@ -96,11 +179,7 @@ export async function ensureTool(name) {
             await rm(path.join(temporary, release.archive));
         }
         await chmod(path.join(temporary, ...tool.executable.split('/')), 0o755);
-        await rename(temporary, directory).catch((error) => {
-            //Extracted by another build
-            if (!existsSync(executable))
-                throw error;
-        });
+        await moveIntoCache(temporary, directory, () => existsSync(executable));
     }
     finally {
         await rm(temporary, { recursive: true, force: true });