@lakutata/builder 3.0.0-beta.6 → 3.1.0

package/README.md

@@ -1,31 +1,40 @@
 # @lakutata/builder
 
-The builder of the applications of the lakutata framework, used by the `bundle` and `executable` commands of
-`@lakutata/cli`, and usable from the scripts of a project:
+English | [中文](README.zh-CN.md)
+
+The builder for lakutata applications. The `package bundle`, `package exe` and `package installer` commands of
+`@lakutata/cli` use it, and a project's scripts can call it directly:
 
 ```js
 import {buildExecutable, buildInstaller, bundleProject} from '@lakutata/builder'
 
-//dist/<name>.cjs, run by node, its native addons and its resources next to it
+//dist/<name>.cjs, run by node, with its native addons and its resources next to it
 await bundleProject({project: process.cwd()})
-//dist/<name>, which runs without Node.js: Node.js (by default) or Bun embedded, one file or a directory
+//An executable that runs without Node.js installed, with Node.js (the default) or Bun embedded. With layout
+//'directory': dist/<name>/<name>, its native addons and resources next to it; with 'file' (the default): dist/<name>
 await buildExecutable({project: process.cwd(), runtime: 'node', layout: 'directory'})
-//dist/installer: the installers of the platform (deb, rpm, apk, archlinux, tar.gz on Linux; pkg, tar.gz on macOS;
-//nsis, msi, zip on Windows), its service registered
+//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()})
 ```
 
-The application is compiled first (`tsc`, which emits the metadata of the decorators). The bundle is one CommonJS file
-(esbuild); the native addons, which cannot be bundled, are gathered with what they load at run time into a native tree,
-with the files the application reads by their paths, which the bundler does not follow (the scripts it runs on their
-own: the workers, the pools of workers, `fork()`, `require(path.join(__dirname, 'x.js'))`, bundled; its data files and
-directories, copied: the paths given from their modules are found and rewritten; what cannot be shipped is in the
-`warnings` of the result);
-the resources of the application (the `lakutata.resources` of its `package.json`) are found at run time by
-`resourcesPath()` of lakutata. The installers are configured by the `lakutata.installer` of the `package.json`. See the
-documentation of `lakutata package bundle`, `lakutata package exe` and `lakutata package installer` in `@lakutata/cli`.
-
-The installers of Linux are tested in containers (Docker): `npm run test:installer` makes them on Debian and Alpine,
-installs, upgrades and removes them on Debian and Fedora (systemd) and Alpine (OpenRC). The ones of macOS are installed
-in a virtual machine of macOS (`npm run test:installer:mac`, tart), the ones of Windows on Windows as an administrator
-(`LAKUTATA_WINDOWS_INSTALL=1 npm run test:installer:windows`).
+The builder works on the compiled application: build the project with `tsc` first, since `tsc` emits the decorator
+metadata. The bundle is one CommonJS file, made by esbuild. Native addons cannot be bundled, so they are gathered, with
+what they load at run time, into a native tree. The tree also holds the files that the application reads by path,
+which the bundler does not follow: the scripts it runs on their own (workers, worker pools, `fork()`,
+`require(path.join(__dirname, 'x.js'))`) are bundled, and its data files and directories are copied. The builder finds
+the paths built from a module's location and rewrites them; whatever it cannot ship is listed in the `warnings` of the
+result. At run time, `resourcesPath()` from lakutata locates the application's resources, declared by
+`lakutata.resources` in its `package.json`. The installers are configured by `lakutata.installer` in the same file. See
+`lakutata package bundle`, `lakutata package exe` and `lakutata package installer` in the `@lakutata/cli`
+documentation.
+
+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,
+as an administrator (`LAKUTATA_WINDOWS_INSTALL=1 npm run test:installer:windows`).
+
+## See also
+
+- The guides on the website: [Packaging](https://lakutata.com/guide/Packaging) and
+  [Installers](https://lakutata.com/guide/Installers).

package/README.zh-CN.md

@@ -0,0 +1,26 @@
+# @lakutata/builder
+
+[English](README.md) | 中文
+
+lakutata 应用的打包工具。`@lakutata/cli` 的 `package bundle`、`package exe` 和 `package installer` 命令都靠它完成工作，项目的脚本也可以直接调用它：
+
+```js
+import {buildExecutable, buildInstaller, bundleProject} from '@lakutata/builder'
+
+//dist/<name>.cjs，由 node 运行，原生插件和资源放在它旁边
+await bundleProject({project: process.cwd()})
+//不需要安装 Node.js 就能运行的可执行文件，内嵌 Node.js（默认）或 Bun。
+//layout 为 'directory' 时：dist/<name>/<name>，原生插件和资源放在它旁边；为 'file'（默认）时：dist/<name>
+await buildExecutable({project: process.cwd(), runtime: 'node', layout: 'directory'})
+//dist/installer：当前平台的安装包（Linux 上是 deb、rpm、apk、archlinux、tar.gz；macOS 上是 pkg、tar.gz；
+//Windows 上是 nsis、msi、zip），应用声明了服务时，安装包还会注册这个服务
+await buildInstaller({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`。
+
+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`）。
+
+## 另见
+
+- 网站上的指南：[打包](https://lakutata.com/zh/guide/Packaging)、[安装包](https://lakutata.com/zh/guide/Installers)。

package/dist/esm/lib/Bundle.js

@@ -180,17 +180,22 @@ export async function bundleProject(options) {
         const embeddedFiles = [...native?.files ?? [], ...resources.files.map((file) => ({ ...file, path: `${EMBEDDED_RESOURCES}/${file.path}` }))];
         native = { modules: native?.modules ?? [], files: embeddedFiles, links: native?.links ?? [], hash: hashNativeTree(embeddedFiles, native?.links ?? []) };
     }
-    if (native && embedded) {
+    const executable = embedded || !!options.executable;
+    if (native && executable) {
         //An executable runs the scripts of its tree it is started for (fork()) instead of the application
         const hashbang = /^#![^\n]*\n/.exec(code)?.[0] ?? '';
         code = `${hashbang}if (!require.lakutataScript()) {\n${code.slice(hashbang.length)}\n}\n`;
     }
     if (native) {
         //The require loading the native packages is the first code, after the hashbang
-        code = prepend(code, nativeBanner({ name: name, hash: native.hash, directory: path.basename(nativeDirectory), modules: native.modules, embedded: embedded }));
+        code = prepend(code, nativeBanner({ name: name, hash: native.hash, directory: path.basename(nativeDirectory), modules: native.modules, embedded: embedded, executable: executable }));
         if (!embedded)
             await writeNativeTree(native, nativeDirectory);
     }
+    else if (executable && options.runtime !== 'bun') {
+        //Without tree, an executable of Node.js still loads the modules left out of the bundle from next to it
+        code = prepend(code, nativeBanner({ name: name, hash: '', directory: '', modules: [], embedded: false, executable: true }));
+    }
     if (!embedded) {
         for (const file of resources.files) {
             const target = path.join(resourcesDirectory, ...file.path.split('/'));

package/dist/esm/lib/Executable.js

@@ -157,6 +157,26 @@ async function compileWithBun(bun, bundle, work, file, icon) {
     ], work);
     return `Bun ${bun.version}`;
 }
+/**
+ * The packages of a native tree whose addons are built on the V8 API of Node.js (they export
+ * node_register_module_v<ABI>), not on Node-API (napi_register_module_v1): Bun may not load them (better-sqlite3)
+ * @param files The files of the native tree.
+ * @returns The names of the packages (or of the addons of the application itself), sorted.
+ */
+export function v8Addons(files) {
+    const names = new Set();
+    for (const file of files) {
+        if (!file.path.endsWith('.node'))
+            continue;
+        const content = file.content ?? readFileSync(file.source);
+        if (!content.includes('node_register_module_v') || content.includes('napi_register_module_v1'))
+            continue;
+        const at = file.path.lastIndexOf('node_modules/');
+        const parts = at < 0 ? [path.posix.basename(file.path)] : file.path.slice(at + 'node_modules/'.length).split('/');
+        names.add(parts[0].startsWith('@') ? parts.slice(0, 2).join('/') : parts[0]);
+    }
+    return [...names].sort();
+}
 /**
  * Make the executable of the application for the platform it is made on, which runs without Node.js installed: its bundle
  * embedded in the Node.js binary running the tool (the single executable applications of Node.js), or compiled by Bun.
@@ -183,6 +203,7 @@ export async function buildExecutable(options) {
             ...options,
             outfile: path.join(work, 'main.cjs'),
             native: directory ? 'directory' : 'embedded',
+            executable: true,
             directories: { native: path.join(target, 'native'), resources: path.join(target, 'resources') }
         });
         //The executables of Node.js do not load the native addons on musl (postject rewrites their symbols): the ones of Bun do
@@ -197,6 +218,10 @@ export async function buildExecutable(options) {
         const made = path.join(work, 'executable', path.basename(file));
         await mkdir(path.dirname(made), { recursive: true });
         const warnings = [...bundle.warnings];
+        //Bun loads the addons of Node-API; an addon built on the V8 API of Node.js may fail when it is loaded
+        if (bun)
+            for (const name of v8Addons(bundle.native?.files ?? []))
+                warnings.push(`${name}: its addon is built on the V8 API of Node.js, not on Node-API, and Bun may not load it (the executable then fails when it loads the package): make the executable with Node.js (--runtime node)`);
         //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;

package/dist/esm/lib/Installer.js

@@ -93,6 +93,10 @@ export async function buildInstaller(options) {
     const service = config.service === true ? {} : config.service || undefined;
     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 $)
+    if (service?.user !== undefined && !(windows ? /^[A-Za-z0-9_][A-Za-z0-9_. @-]*(\\[A-Za-z0-9_][A-Za-z0-9_. @-]*)?\$?$/ : /^[A-Za-z_][A-Za-z0-9_.-]*$/).test(service.user)) {
+        throw new Error(`The user of the service "${service.user}" must be ${windows ? 'an account of Windows (LocalService, NetworkService, LocalSystem, DOMAIN\\user)' : 'a name of user: letters, digits, "_", "." and "-"'} (lakutata.installer.service.user)`);
+    }
     const platform = mac ? 'mac' : windows ? 'win' : 'linux';
     const scripts = resolveScripts(project, platform, config[platform], targets, warnings);
     const application = applicationIcon(project, manifest);

package/dist/esm/lib/Native.js

@@ -29,9 +29,14 @@ const LIBRARY = /\.(node|dylib|dll|so)$|\.so\.\d+(\.\d+)*$/;
 const RESOLVING = 'lakutataNativeResolving';
 /**
  * The files of the packages node never loads: their types, their source maps, their sources in TypeScript, their
- * documentation
+ * documentation, the sources and the objects of their addons in C and C++ (better-sqlite3 holds the source of SQLite)
  */
-const UNUSED = /\.(d\.[cm]?ts|[cm]?ts|map|md|markdown)$/i;
+const UNUSED = /\.(d\.[cm]?ts|[cm]?ts|map|md|markdown|c|cc|cpp|cxx|h|hh|hpp|hxx|o|obj|a|lib|exp|pdb|ilk)$/i;
+/**
+ * The files of the builds of the addons in build/ (node-gyp, CMake), which node never loads: their makefiles, their
+ * configurations, their objects and their dependency files; the addons and their libraries are kept
+ */
+const BUILD_FILES = /^build\/(?:.*\/)?(?:\.deps|obj|obj\.target|CMakeFiles)\/|^build\/(?:.*\/)?(?:Makefile|[^/]+\.mk|config\.gypi|gyp-(?:mac|win)-tool|CMakeCache\.txt|cmake_install\.cmake|build\.ninja|\.ninja_deps|\.ninja_log|compile_commands\.json|[^/]+\.(?:vcxproj|vcxproj\.filters|sln|tlog))$/;
 /**
  * The JavaScript files, which a package keeps when they are loaded (traced)
  */
@@ -502,7 +507,12 @@ export class NativeCollector {
      * @param root
      */
     packageFiles(root) {
-        const files = packageFiles(root).filter((file) => !UNUSED.test(file));
+        //The builds of cargo (the Rust addons) are in target/
+        const cargo = existsSync(path.join(root, 'Cargo.toml'));
+        const files = packageFiles(root).filter((file) => {
+            const relative = path.relative(root, file).split(path.sep).join('/');
+            return !UNUSED.test(file) && !BUILD_FILES.test(relative) && !(cargo && relative.startsWith('target/'));
+        });
         const loaded = this.loaded.get(root);
         if (!loaded || this.whole.has(root) || this.package(root)?.libraries)
             return files;

package/dist/esm/lib/NativeRuntime.js

@@ -29,7 +29,7 @@ export function lakutataNativeRequire(nodeRequire, config) {
     const path = nodeRequire('node:path');
     const fs = nodeRequire('node:fs');
     const os = nodeRequire('node:os');
-    const { createRequire } = nodeRequire('node:module');
+    const { createRequire, isBuiltin } = nodeRequire('node:module');
     let sea;
     try {
         sea = nodeRequire('node:sea');
@@ -124,10 +124,14 @@ export function lakutataNativeRequire(nodeRequire, config) {
         return modules.has(id.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0]);
     };
     const tree = () => treeRequire ??= createRequire(path.join(locate(), 'index.js'));
+    //The modules left out of the bundle (--external), next to an executable of Node.js: the require of its single
+    //executable application loads the modules of node only (the one of a bundle run by node loads them)
+    const disk = sea?.isSea() ? createRequire(process.execPath) : undefined;
+    const outside = (id) => disk && !isBuiltin(id) ? disk : nodeRequire;
     //The files loaded by their paths (the scripts of the tree): the require of an executable of Node.js loads the modules of
     //node only
-    const require = ((id) => fromTree(id) ? tree()(id) : path.isAbsolute(id) ? createRequire(id)(id) : nodeRequire(id));
-    require.resolve = ((id, options) => fromTree(id) ? tree().resolve(id, options) : nodeRequire.resolve(id, options));
+    const require = ((id) => fromTree(id) ? tree()(id) : path.isAbsolute(id) ? createRequire(id)(id) : outside(id)(id));
+    require.resolve = ((id, options) => fromTree(id) ? tree().resolve(id, options) : outside(id).resolve(id, options));
     require.cache = nodeRequire.cache;
     require.main = nodeRequire.main;
     require.extensions = nodeRequire.extensions;
@@ -144,7 +148,7 @@ export function lakutataNativeRequire(nodeRequire, config) {
     //An executable started to run a script of its tree (fork(), spawn(process.execPath, [script]): process.execPath is the
     //executable): it runs the script as node runs it, the application not started
     require.lakutataScript = () => {
-        if (!config.embedded || config.root !== undefined)
+        if (!(config.embedded || config.executable) || config.root !== undefined)
             return false;
         const scripts = path.join(locate(), '.lakutata', 'files') + path.sep;
         const at = [1, 2].find((index) => !!process.argv[index] && path.resolve(process.argv[index]).startsWith(scripts)) ?? -1;

package/dist/esm/lib/Scripts.js

@@ -11,6 +11,10 @@ export const INSTALLER_HOOKS = ['preinstall', 'postinstall', 'preremove', 'postr
  * of dpkg, of rpm, of apk, of pacman); the upgrades of apk and pacman have their own ones
  */
 export const NATIVE_HOOKS = ['preinstall', 'postinstall', 'preremove', 'postremove', 'preupgrade', 'postupgrade'];
+/**
+ * The options of a platform which are not the ones of an installer
+ */
+const PLATFORM_OPTIONS = ['targets', 'scripts', 'depends', 'recommends', 'section', 'priority'];
 /**
  * The installers which run no script (archives, copied by their users)
  */
@@ -63,7 +67,7 @@ function installerHooks(project, scripts, where, windows) {
  * The scripts of the installers made on a platform: the ones of the platform (lakutata.installer.<platform>.scripts),
  * replaced by the ones of each installer (lakutata.installer.<platform>.<installer>.scripts), the native ones of the
  * packages of Linux (nativeScripts), the file of NSIS included by its installer (win.nsis.include). The ones an
- * installer does not run are told (warnings)
+ * installer does not run are told (warnings); the options of the installers not made are checked too
  * @param project
  * @param platform its name in the configuration: linux, mac or win
  * @param config its configuration
@@ -78,7 +82,8 @@ export function resolveScripts(project, platform, config, targets, warnings, hoo
     const common = installerHooks(project, config?.scripts, `${where}.scripts`, windows);
     const resolved = {};
     const unrun = [];
-    for (const target of targets) {
+    const configured = Object.keys(config ?? {}).filter((key) => !PLATFORM_OPTIONS.includes(key) && !targets.includes(key));
+    for (const target of [...targets, ...configured]) {
         const options = config?.[target];
         if (options !== undefined && (!options || typeof options !== 'object' || Array.isArray(options)))
             throw new Error(`${where}.${target} must be an object`);
@@ -86,7 +91,7 @@ export function resolveScripts(project, platform, config, targets, warnings, hoo
         const scripts = { hooks: { ...common, ...installerHooks(project, own.scripts, `${where}.${target}.scripts`, windows) }, native: {} };
         if (own.nativeScripts !== undefined) {
             if (!native || platform !== 'linux' || ARCHIVES.includes(target))
-                throw new Error(`${where}.${target}.nativeScripts: the native scripts are the ones of the packages of Linux lakutata makes (deb, rpm, apk, archlinux), not the ones of Electron`);
+                throw new Error(`${where}.${target}.nativeScripts: the native scripts are the ones of the packages of Linux lakutata makes (deb, rpm, apk, archlinux)${native ? '' : ', not the ones of Electron'}`);
             if (!own.nativeScripts || typeof own.nativeScripts !== 'object' || Array.isArray(own.nativeScripts))
                 throw new Error(`${where}.${target}.nativeScripts must be {"<script>": "<file>"}`);
             //The upgrades of deb and rpm run their scripts of the installation and of the removal
@@ -104,6 +109,9 @@ export function resolveScripts(project, platform, config, targets, warnings, hoo
                 throw new Error(`${where}.nsis.include (${own.include}) must be a file of NSIS (.nsh)`);
             scripts.include = read(project, own.include, `${where}.nsis.include`);
         }
+        //Checked only: not made
+        if (!targets.includes(target))
+            continue;
         //The ones the installer does not run
         const run = hooks(target);
         const skipped = INSTALLER_HOOKS.filter((hook) => !!scripts.hooks[hook] && !run.includes(hook));

package/dist/esm/lib/electron/Electron.js

@@ -228,13 +228,16 @@ export async function buildElectronInstaller(project, manifest, config, options)
     try {
         //The application of electron-builder: its main process, its package.json; its native addons and its resources next to it
         const application = path.join(work, 'app');
+        //The directory of the native addons and of the resources, copied into the resources of Electron: electron-builder
+        //leaves out the node_modules at the root of a directory it copies, the packages of the native tree
+        const extra = path.join(work, 'extra');
         const bundle = await bundleProject({
             project: project,
             entry: options.entry,
             minify: options.minify,
             external: ['electron', ...options.external ?? []],
             outfile: path.join(application, 'main.cjs'),
-            directories: { native: path.join(work, 'main.native'), resources: path.join(work, 'main.resources') }
+            directories: { native: path.join(extra, 'main.native'), resources: path.join(extra, 'main.resources') }
         });
         warnings.push(...bundle.warnings);
         const maintainer = platform === 'linux' ? packageMaintainer(author, name, warnings) : author ?? name;
@@ -303,10 +306,7 @@ export async function buildElectronInstaller(project, manifest, config, options)
             ...existsSync(electronDist) ? { electronDist: electronDist } : {},
             directories: { app: 'app', output: outdir },
             files: ['main.cjs', 'package.json'],
-            extraResources: [
-                ...bundle.nativeDirectory ? [{ from: bundle.nativeDirectory, to: path.basename(bundle.nativeDirectory) }] : [],
-                ...bundle.resourcesDirectory ? [{ from: bundle.resourcesDirectory, to: path.basename(bundle.resourcesDirectory) }] : []
-            ],
+            extraResources: bundle.nativeDirectory || bundle.resourcesDirectory ? [{ from: extra }] : [],
             //The dependencies are bundled
             npmRebuild: false,
             ...platform === 'linux' ? { linux: { maintainer: maintainer, ...config.vendor ? { vendor: config.vendor } : {} } } : {},

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

@@ -1,4 +1,4 @@
-import { chmod, cp, mkdir, rm, stat, symlink, writeFile } from 'node:fs/promises';
+import { chmod, cp, mkdir, readFile, rm, stat, symlink, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { archiveDirectory } from '../Archive.js';
 import { runCommand } from '../Processes.js';
@@ -66,7 +66,7 @@ ${service.user === 'root' ? '' : `    <key>UserName</key>
 `}    <key>WorkingDirectory</key>
     <string>${xml(paths.data)}</string>
     <key>RunAtLoad</key>
-    ${service.autoStart ? '<true/>' : '<false/>'}
+    <true/>
     <key>KeepAlive</key>
     ${keepAlive}
     <key>ThrottleInterval</key>
@@ -94,8 +94,8 @@ function installerHooks(plan) {
  */
 const ACTION_FILE = '"$INSTALLER_TEMP/lakutata-action"';
 /**
- * The script run before the installation (and the upgrades), when the application has scripts: what the installation
- * does (an upgrade replaces the program installed), the preinstall script of the application
+ * The script run before the installation (and the upgrades), when the application has scripts or a service: what the
+ * installation does (an upgrade replaces the program installed), the preinstall script of the application
  * @param plan
  */
 function preInstall(plan) {
@@ -122,11 +122,9 @@ function postInstall(plan) {
         '#!/bin/sh',
         'set -e',
         ...service ? serviceInstallation(plan, service) : [],
-        ...hooks.postinstall ? [
-            `lakutata_action="$(cat ${ACTION_FILE} 2>/dev/null || echo install)"`,
-            ...embeddedShell(hooks.postinstall, plan.prefix, '"$lakutata_action"')
-        ] : [],
-        ...service ? serviceStart(plan) : [],
+        `lakutata_action="$(cat ${ACTION_FILE} 2>/dev/null || echo install)"`,
+        ...hooks.postinstall ? embeddedShell(hooks.postinstall, plan.prefix, '"$lakutata_action"') : [],
+        ...service ? serviceStart(plan, service) : [],
         ''
     ].join('\n');
 }
@@ -175,19 +173,32 @@ function serviceInstallation(plan, service) {
     ];
 }
 /**
- * The service loaded again: started (RunAtLoad), or stopped by the upgrade
+ * The service started: enabled, loaded again (started by RunAtLoad, the one of the version replaced stopped first). A
+ * service which does not start with the system (autoStart false) is disabled by its installation (launchd would load
+ * it when the system starts, and run it), and restarted by the upgrades when it runs, as systemd does
  * @param plan
+ * @param service
  */
-function serviceStart(plan) {
+function serviceStart(plan, service) {
     const paths = installPaths(plan);
-    return [
-        //Loaded again: started (RunAtLoad), or stopped by the upgrade; bootout returns before the job of the version
-        //replaced is unloaded (the application ending gracefully, ExitTimeOut): bootstrap fails until it is
+    const load = [
+        //bootout returns before the job of the version replaced is unloaded (the application ending gracefully,
+        //ExitTimeOut): bootstrap fails until it is
         `launchctl bootout system/${plan.appId} 2>/dev/null || true`,
         'waited=0',
         `while launchctl print system/${plan.appId} >/dev/null 2>&1 && [ "$waited" -lt 70 ]; do sleep 0.5; waited=$((waited + 1)); done`,
         `launchctl bootstrap system ${paths.daemon}`
     ];
+    if (service.autoStart)
+        return [`launchctl enable system/${plan.appId}`, ...load];
+    return [
+        `if launchctl print system/${plan.appId} >/dev/null 2>&1; then`,
+        ...load.map((line) => `    ${line}`),
+        'elif [ "$lakutata_action" = install ]; then',
+        //Started by its administrator: sudo launchctl enable system/<appId>, then sudo launchctl bootstrap system <plist>
+        `    launchctl disable system/${plan.appId}`,
+        'fi'
+    ];
 }
 /**
  * The script removing the application (the packages of macOS are not removed by the system): its service stopped, the
@@ -247,7 +258,7 @@ export async function buildMacPackages(plan, targets, work, outdir) {
             await writeFile(path.join(root, 'Library', 'LaunchDaemons', `${plan.appId}.plist`), launchDaemon(plan, plan.service), { mode: 0o644 });
         }
         const hooks = installerHooks(plan);
-        if (hooks.preinstall || hooks.postinstall) {
+        if (hooks.preinstall || hooks.postinstall || plan.service) {
             await writeFile(path.join(scripts, 'preinstall'), preInstall(plan));
             await chmod(path.join(scripts, 'preinstall'), 0o755);
         }
@@ -261,7 +272,15 @@ export async function buildMacPackages(plan, targets, work, outdir) {
             throw new Error(`The pkg package cannot be made: ${built.output.trim()}`);
         const file = path.join(outdir, `${plan.name}-${plan.version}-${packageArch()}.pkg`);
         await rm(file, { force: true });
-        const product = await runCommand('productbuild', ['--identifier', plan.appId, '--version', plan.version, '--package', component, file], work);
+        //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'}"`;
+        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);
         if (product.code !== 0)
             throw new Error(`The pkg package cannot be made: ${product.output.trim()}`);
         files.push({ target: target, file: file, size: (await stat(file)).size });

package/dist/types/lib/Bundle.d.ts

@@ -32,6 +32,11 @@ export type BundleOptions = {
      * The runtime running the bundle: node (by default), or bun (the executables of Bun, which bundle it again)
      */
     runtime?: 'node' | 'bun';
+    /**
+     * Whether the bundle is the one of an executable (buildExecutable): it runs the scripts of its tree it is started
+     * for, in both layouts, and on Node.js it loads the modules left out of it from next to the executable
+     */
+    executable?: boolean;
     /**
      * The directories of the native tree and of the resources (when they are not embedded), next to the bundle by
      * default (<name>.native and <name>.resources): the bundle loads them by their names from its directory

package/dist/types/lib/Executable.d.ts

@@ -1,4 +1,5 @@
 import { type BundleOptions } from './Bundle.js';
+import { type NativeFile } from './Native.js';
 export type ExecutableOptions = Omit<BundleOptions, 'outfile' | 'native' | 'directories'> & {
     /**
      * The directory of the executable, dist by default
@@ -49,6 +50,13 @@ export type ExecutableResult = {
      */
     warnings: string[];
 };
+/**
+ * The packages of a native tree whose addons are built on the V8 API of Node.js (they export
+ * node_register_module_v<ABI>), not on Node-API (napi_register_module_v1): Bun may not load them (better-sqlite3)
+ * @param files The files of the native tree.
+ * @returns The names of the packages (or of the addons of the application itself), sorted.
+ */
+export declare function v8Addons(files: NativeFile[]): string[];
 /**
  * Make the executable of the application for the platform it is made on, which runs without Node.js installed: its bundle
  * embedded in the Node.js binary running the tool (the single executable applications of Node.js), or compiled by Bun.

package/dist/types/lib/NativeRuntime.d.ts

@@ -29,6 +29,12 @@ export type NativeRuntimeConfig = {
      * .lakutata/workers): the tree is not looked for (nor extracted)
      */
     root?: string;
+    /**
+     * Whether the bundle is the one of an executable, which its process.execPath runs (in both layouts): it runs the
+     * scripts of its tree it is started for (fork()), and an executable of Node.js loads the modules left out of the
+     * bundle (--external) from next to it
+     */
+    executable?: boolean;
 };
 /**
  * The global symbol of the packed applications giving the directory of their resources (resourcesPath of lakutata)

package/dist/types/lib/Scripts.d.ts

@@ -48,7 +48,7 @@ export type PlatformScripts = {
  * The scripts of the installers made on a platform: the ones of the platform (lakutata.installer.<platform>.scripts),
  * replaced by the ones of each installer (lakutata.installer.<platform>.<installer>.scripts), the native ones of the
  * packages of Linux (nativeScripts), the file of NSIS included by its installer (win.nsis.include). The ones an
- * installer does not run are told (warnings)
+ * installer does not run are told (warnings); the options of the installers not made are checked too
  * @param project
  * @param platform its name in the configuration: linux, mac or win
  * @param config its configuration

package/package.json

@@ -1,7 +1,30 @@
 {
   "name": "@lakutata/builder",
-  "version": "3.0.0-beta.6",
+  "version": "3.1.0",
   "description": "The builder of the applications of the lakutata framework: their bundles, their executables (Node.js, Bun) with their native addons and their resources.",
+  "keywords": [
+    "lakutata",
+    "bundler",
+    "esbuild",
+    "executable",
+    "single-executable-application",
+    "bun",
+    "native-addons",
+    "electron-builder",
+    "installer",
+    "typescript"
+  ],
+  "homepage": "https://lakutata.com/packages/builder",
+  "bugs": {
+    "url": "https://github.com/lakutata/lakutata/issues",
+    "email": "admin@lakutata.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lakutata/lakutata.git",
+    "directory": "packages/builder"
+  },
+  "author": "alex.ma",
   "type": "module",
   "main": "./dist/esm/index.js",
   "types": "./dist/types/index.d.ts",
@@ -37,7 +60,7 @@
     }
   },
   "engines": {
-    "node": ">=22.12"
+    "node": "^22.13.0 || >=24.11.0"
   },
   "license": "MIT",
   "files": [