@lakutata/builder 3.1.3 → 3.1.5

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;
+}

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

@@ -0,0 +1,149 @@
+import { existsSync } from 'node:fs';
+import { cp, mkdir, mkdtemp, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { programName } from '../Bundle.js';
+import { applicationIcon, icnsFile, icoFile, setExecutableIcon } from '../Icons.js';
+import { runCommand } from '../Processes.js';
+import { downloadNwjs } from './Runtime.js';
+import { stageNwjsApp } from './Stage.js';
+/**
+ * Run a command which must succeed
+ * @param command
+ * @param args
+ * @param cwd
+ * @param what
+ */
+async function must(command, args, cwd, what) {
+    const result = await runCommand(command, args, cwd);
+    if (result.code !== 0)
+        throw new Error(`${what}: ${result.output.trim()}`);
+}
+/**
+ * Give the files of an application to every user: readable, its directories and its programs runnable. The archives of
+ * the older releases of NW.js (0.72) give their files to their owner only: installed by root (/opt, /Applications), the
+ * application would run for root only. The files of Windows have no modes
+ * @param directory
+ */
+async function shareFiles(directory) {
+    if (process.platform !== 'win32')
+        await must('chmod', ['-R', 'a+rX', directory], directory, 'The files of the application cannot be given to every user');
+}
+/**
+ * The four numbers of a version of Windows (1.2.3 → 1.2.3.0)
+ * @param version
+ */
+function windowsVersion(version) {
+    const parts = version.split(/[.+-]/).slice(0, 3).map((part) => Math.min(parseInt(part, 10) || 0, 65535));
+    return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0, 0];
+}
+/**
+ * Give the executable of NW.js of Windows the identity of the application: its icon, and the names and the version of its
+ * version information (the ones the task manager and the properties of the file show)
+ * @param file
+ * @param identity
+ */
+async function windowsIdentity(file, identity) {
+    if (identity.ico)
+        await setExecutableIcon(file, identity.ico);
+    const { NtExecutable, NtExecutableResource, Resource } = await import('resedit');
+    const executable = NtExecutable.from(await readFile(file), { ignoreCert: true });
+    const resource = NtExecutableResource.from(executable);
+    const information = Resource.VersionInfo.fromEntries(resource.entries)[0] ?? Resource.VersionInfo.createEmpty();
+    const numbers = windowsVersion(identity.version);
+    information.setFileVersion(...numbers);
+    information.setProductVersion(...numbers);
+    const languages = information.getAllLanguagesForStringValues();
+    for (const language of languages.length ? languages : [{ lang: 1033, codepage: 1200 }]) {
+        information.setStringValues(language, {
+            FileDescription: identity.productName,
+            ProductName: identity.productName,
+            CompanyName: identity.company,
+            InternalName: identity.program,
+            OriginalFilename: `${identity.program}.exe`,
+            FileVersion: identity.version,
+            ProductVersion: identity.version
+        });
+    }
+    information.outputToResourceEntries(resource.entries);
+    resource.outputResource(executable);
+    await writeFile(file, Buffer.from(executable.generate()));
+}
+/**
+ * Make the application of NW.js of a project for this system: the runtime of NW.js (normal) with the application
+ * (stageNwjsApp: its bundle, its native addons made to load in NW.js, its resources, its manifest), named after it.
+ * On Windows and Linux, the files of the application are next to its executable (nw.exe, nw renamed after its program:
+ * the name of its installers, lakutata.installer.name, else the program of its package; on Windows, its icon and its
+ * version information are the ones of the application); on macOS, they are in the bundle
+ * (<product>.app/Contents/Resources/app.nw), whose Info.plist gives its name, its identifier (the appId of the
+ * installer), its version and its icon, signed again (ad hoc). The icon is lakutata.icon. Its files are readable by
+ * every user, its programs runnable (once installed by root, the application runs for the users)
+ * @param options
+ * @example
+ * import {buildNwjsApp} from '@lakutata/builder'
+ *
+ * //dist/nwjs/desk-osx-arm64/Desk.app on a Mac with Apple silicon
+ * const app = await buildNwjsApp({})
+ * console.log(app.directory, app.runtime.version)
+ */
+export async function buildNwjsApp(options) {
+    const project = path.resolve(options.project ?? process.cwd());
+    const manifest = JSON.parse(await readFile(path.join(project, 'package.json'), 'utf8'));
+    //The program is named after the package of its installers, else after the program of the package (the package of an
+    //application of a workspace is often named app)
+    const program = String(manifest.lakutata?.installer?.name ?? programName(manifest));
+    const productName = String(manifest.productName ?? manifest.lakutata?.installer?.productName ?? program);
+    const work = await mkdtemp(path.join(os.tmpdir(), 'lakutata-nwjs-app-'));
+    try {
+        const stage = await stageNwjsApp({ ...options, project: project, outdir: path.join(work, 'app'), minify: options.minify ?? true });
+        const runtime = await downloadNwjs({ version: stage.release.version, flavor: 'normal', platform: options.platform, arch: options.arch });
+        const directory = path.join(path.resolve(project, options.outdir ?? path.join('dist', 'nwjs')), `${program}-${runtime.platform}`);
+        await rm(directory, { recursive: true, force: true });
+        await mkdir(directory, { recursive: true });
+        const icon = applicationIcon(project, manifest);
+        const version = String(manifest.version ?? '0.0.0');
+        if (runtime.platform.startsWith('osx-')) {
+            //ditto keeps the links of the frameworks and the signatures of the helpers
+            const bundle = path.join(directory, `${productName}.app`);
+            await must('ditto', [path.join(runtime.directory, 'nwjs.app'), bundle], directory, 'The bundle of macOS cannot be copied');
+            await must('ditto', [stage.directory, path.join(bundle, 'Contents', 'Resources', 'app.nw')], directory, 'The application cannot be copied into the bundle');
+            const plist = path.join(bundle, 'Contents', 'Info.plist');
+            const appId = String(manifest.lakutata?.installer?.appId ?? `com.${program}.app`);
+            for (const [key, value] of Object.entries({ CFBundleName: productName, CFBundleDisplayName: productName, CFBundleIdentifier: appId, CFBundleShortVersionString: version, CFBundleVersion: version })) {
+                await must('plutil', ['-replace', key, '-string', value, plist], directory, `${key} cannot be written into the Info.plist`);
+            }
+            if (icon)
+                await writeFile(path.join(bundle, 'Contents', 'Resources', 'app.icns'), icnsFile(icon.image));
+            await shareFiles(bundle);
+            //Its files changed, the bundle is signed again (ad hoc: the signature of a developer is given by its installer)
+            await must('codesign', ['--force', '--deep', '--sign', '-', bundle], directory, 'The bundle cannot be signed');
+            return { directory: bundle, executable: path.join(bundle, 'Contents', 'MacOS', 'nwjs'), program: program, productName: productName, runtime: runtime, stage: stage };
+        }
+        //The links of the runtime of Linux kept as they are (cp -a); the runtime of Windows has none
+        for (const source of [runtime.directory, stage.directory]) {
+            if (process.platform === 'win32')
+                await cp(source, directory, { recursive: true });
+            else
+                await must('cp', ['-a', `${source}/.`, directory], directory, 'The application cannot be copied');
+        }
+        const windows = runtime.platform.startsWith('win-');
+        const executable = path.join(directory, windows ? `${program}.exe` : program);
+        await rename(path.join(directory, windows ? 'nw.exe' : 'nw'), executable);
+        if (windows) {
+            await windowsIdentity(executable, {
+                productName: productName,
+                program: program,
+                version: version,
+                company: String(manifest.lakutata?.installer?.vendor ?? (typeof manifest.author === 'string' ? manifest.author : manifest.author?.name) ?? productName),
+                ico: icon && icoFile(icon.image)
+            });
+        }
+        if (!existsSync(executable))
+            throw new Error(`The executable of NW.js ${runtime.version} (${runtime.platform}) is missing`);
+        await shareFiles(directory);
+        return { directory: directory, executable: executable, program: program, productName: productName, runtime: runtime, stage: stage };
+    }
+    finally {
+        await rm(work, { recursive: true, force: true });
+    }
+}

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

@@ -0,0 +1,214 @@
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { mkdir, mkdtemp, open, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { runCommand } from '../Processes.js';
+import { cacheDirectory } from '../Tools.js';
+/**
+ * The oldest Node.js lakutata runs on: the releases of NW.js embedding an older one are refused
+ */
+const OLDEST_NODE = '18.10.0';
+/**
+ * The aliases of the versions
+ */
+const ALIASES = { win7: '0.72.0' };
+/**
+ * The releases are read again after a day
+ */
+const RELEASES_TTL = 24 * 60 * 60 * 1000;
+/**
+ * Where the releases are downloaded from: LAKUTATA_NWJS_MIRROR (a mirror of dl.nwjs.io), else dl.nwjs.io
+ */
+function mirror() {
+    return (process.env.LAKUTATA_NWJS_MIRROR ?? 'https://dl.nwjs.io').replace(/\/+$/, '');
+}
+/**
+ * Compare two versions (1.2.3)
+ * @param left
+ * @param right
+ */
+export function compareVersions(left, right) {
+    const parts = (version) => version.replace(/^v/, '').split('.').map((part) => parseInt(part, 10) || 0);
+    const [a, b] = [parts(left), parts(right)];
+    for (let index = 0; index < Math.max(a.length, b.length); index++) {
+        const difference = (a[index] ?? 0) - (b[index] ?? 0);
+        if (difference)
+            return difference;
+    }
+    return 0;
+}
+/**
+ * The releases of NW.js, newest first: the list of nwjs.io (LAKUTATA_NWJS_VERSIONS), kept a day in the cache; the
+ * cached one when it cannot be read
+ * @example
+ * import {nwjsReleases} from '@lakutata/builder'
+ *
+ * for (const release of (await nwjsReleases()).slice(0, 3)) console.log(release.version, release.node, release.chromium)
+ */
+export async function nwjsReleases() {
+    const cache = path.join(cacheDirectory(), 'nwjs', 'versions.json');
+    const fresh = existsSync(cache) && Date.now() - (await stat(cache)).mtimeMs < RELEASES_TTL;
+    let list;
+    if (!fresh) {
+        try {
+            const response = await fetch(process.env.LAKUTATA_NWJS_VERSIONS ?? 'https://nwjs.io/versions.json');
+            if (!response.ok)
+                throw new Error(`${response.status}`);
+            list = await response.json();
+            await mkdir(path.dirname(cache), { recursive: true });
+            await writeFile(cache, JSON.stringify(list));
+        }
+        catch (error) {
+            if (!existsSync(cache))
+                throw new Error(`The releases of NW.js cannot be read (${error.message}): LAKUTATA_NWJS_VERSIONS gives another list`, { cause: error });
+        }
+    }
+    list ??= JSON.parse(await readFile(cache, 'utf8'));
+    const versions = list.versions ?? [];
+    return versions.map((entry) => ({
+        version: String(entry.version).replace(/^v/, ''),
+        date: String(entry.date ?? ''),
+        node: String(entry.components?.node ?? ''),
+        chromium: String(entry.components?.chromium ?? ''),
+        platforms: (entry.files ?? []).map((file) => String(file).replace(/-symbol$/, '')).filter((file) => /^(win|osx|linux)-/.test(file))
+    })).sort((a, b) => compareVersions(b.version, a.version));
+}
+/**
+ * A release of NW.js: a version, latest (the latest release) or win7 (0.72.0, the last one running on Windows 7, 8
+ * and 8.1). Refused when it embeds a Node.js older than the one lakutata runs on (18.10)
+ * @param version
+ * @example
+ * import {nwjsRelease} from '@lakutata/builder'
+ *
+ * const release = await nwjsRelease('win7')
+ * console.log(release.version, release.node, release.chromium) //0.72.0 19.3.0 109.0.5414.87
+ */
+export async function nwjsRelease(version) {
+    const releases = await nwjsReleases();
+    const wanted = ALIASES[version] ?? version.replace(/^v/, '');
+    const release = wanted === 'latest' ? releases[0] : releases.find((item) => item.version === wanted);
+    if (!release)
+        throw new Error(`NW.js ${version} is not a release of NW.js (the latest: ${releases[0]?.version})`);
+    if (compareVersions(release.node, OLDEST_NODE) < 0)
+        throw new Error(`NW.js ${release.version} embeds Node.js ${release.node}: lakutata runs on Node.js ${OLDEST_NODE} or later (NW.js 0.70.0 or later)`);
+    return release;
+}
+/**
+ * The system and the architecture of a release as NW.js names them (osx-arm64), the x64 build on a Mac with Apple
+ * silicon when the release has no arm64 one
+ * @param release
+ * @param platform
+ * @param arch
+ */
+export function nwjsPlatform(release, platform = process.platform, arch = process.arch) {
+    const system = { win32: 'win', darwin: 'osx', linux: 'linux' }[platform];
+    if (!system)
+        throw new Error(`NW.js has no build for ${platform}`);
+    const name = `${system}-${arch}`;
+    if (release.platforms.includes(name))
+        return name;
+    if (system === 'osx' && arch === 'arm64' && release.platforms.includes('osx-x64'))
+        return 'osx-x64';
+    throw new Error(`NW.js ${release.version} has no build for ${name} (${release.platforms.join(', ')})`);
+}
+/**
+ * The sha256 of the files of a release, from its SHASUMS256.txt
+ * @param version
+ */
+async function checksums(version) {
+    const url = `${mirror()}/v${version}/SHASUMS256.txt`;
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`The checksums of NW.js ${version} cannot be read (${url}: ${response.status})`);
+    const sums = new Map();
+    for (const line of (await response.text()).split('\n')) {
+        const match = line.trim().match(/^([0-9a-f]{64})\s+\*?(.+)$/);
+        if (match)
+            sums.set(match[2], match[1]);
+    }
+    return sums;
+}
+/**
+ * Download a file, its sha256 computed while it is written
+ * @param url
+ * @param file
+ */
+async function download(url, file) {
+    const response = await fetch(url);
+    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) {
+            hash.update(chunk);
+            await handle.write(chunk);
+        }
+    }
+    finally {
+        await handle.close();
+    }
+    return hash.digest('hex');
+}
+/**
+ * The executable of a runtime in its directory
+ * @param platform
+ */
+function executableOf(platform) {
+    if (platform.startsWith('win-'))
+        return 'nw.exe';
+    if (platform.startsWith('osx-'))
+        return path.join('nwjs.app', 'Contents', 'MacOS', 'nwjs');
+    return 'nw';
+}
+/**
+ * A runtime of NW.js for a system, downloaded once into the cache (~/.cache/lakutata/nwjs, LAKUTATA_CACHE_DIR) from
+ * dl.nwjs.io (LAKUTATA_NWJS_MIRROR: a mirror of it) and checked with the SHASUMS256.txt of its release
+ * @param options
+ * @example
+ * import {downloadNwjs} from '@lakutata/builder'
+ *
+ * //The NW.js of the development (its developer tools), for the machine
+ * const runtime = await downloadNwjs({version: 'latest', flavor: 'sdk'})
+ * console.log(runtime.executable, runtime.node)
+ */
+export async function downloadNwjs(options) {
+    const release = await nwjsRelease(options.version);
+    const flavor = options.flavor ?? 'normal';
+    const platform = nwjsPlatform(release, options.platform, options.arch);
+    const name = `nwjs${flavor === 'sdk' ? '-sdk' : ''}-v${release.version}-${platform}`;
+    const archive = `${name}.${platform.startsWith('linux-') ? 'tar.gz' : 'zip'}`;
+    const target = path.join(cacheDirectory(), 'nwjs', name);
+    const runtime = { ...release, flavor: flavor, platform: platform, directory: target, executable: path.join(target, executableOf(platform)) };
+    if (existsSync(runtime.executable))
+        return runtime;
+    const sum = (await checksums(release.version)).get(archive);
+    if (!sum)
+        throw new Error(`NW.js ${release.version} has no ${archive} in its checksums`);
+    //Extracted aside, then renamed: the builds running together do not see it partly written
+    await mkdir(path.dirname(target), { recursive: true });
+    const temporary = await mkdtemp(`${target}.`);
+    try {
+        const file = path.join(temporary, archive);
+        const downloaded = await download(`${mirror()}/v${release.version}/${archive}`, file);
+        if (downloaded !== sum)
+            throw new Error(`The ${archive} downloaded is not the one of NW.js ${release.version} (sha256 ${downloaded}, ${sum} expected)`);
+        //ditto keeps the links of the frameworks of macOS; the tar of Windows reads the zip archives
+        const extracted = process.platform === 'darwin' && archive.endsWith('.zip')
+            ? await runCommand('ditto', ['-x', '-k', archive, '.'], temporary)
+            : await runCommand('tar', ['-xf', archive], temporary);
+        if (extracted.code !== 0)
+            throw new Error(`${archive} cannot be extracted: ${extracted.output.trim()}`);
+        if (!existsSync(path.join(temporary, name, executableOf(platform))))
+            throw new Error(`${archive} has no ${name}/${executableOf(platform).split(path.sep).join('/')}`);
+        await rename(path.join(temporary, name), target).catch((error) => {
+            //Extracted by another build
+            if (!existsSync(runtime.executable))
+                throw error;
+        });
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+    return runtime;
+}