@lakutata/builder 3.1.1 → 3.1.5

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,14 @@ 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 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,14 @@ 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）。
+
 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,6 @@ 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';

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
@@ -98,7 +99,7 @@ export async function bundleProject(options) {
         throw new Error(`The entry ${path.relative(process.cwd(), entry) || entry} does not exist: build the project first`);
     const outfile = path.resolve(project, options.outfile ?? path.join('dist', `${name}.cjs`));
     const collector = new NativeCollector(project, options.runtime);
-    const files = new FileCollector(project);
+    const files = new FileCollector(project, { packageOf: (file) => collector.addonPackageOf(file), nativeFilesOf: (root, directory) => collector.nativeFilesOf(root, directory) });
     //esbuild is loaded by the commands which need it
     const { build } = await import('esbuild');
     //The application, and each script of its workers (the bundler does not follow new Worker()): their native packages
@@ -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
@@ -147,9 +148,15 @@ export async function bundleProject(options) {
     const resourcesDirectory = path.resolve(path.dirname(outfile), options.directories?.resources ?? `${base}.resources`);
     //The scripts of the workers, until the ones they start are bundled too
     const scripts = new Map();
+    //The files of every bundle, the application's and its workers'
+    const inputs = new Set(application.inputs);
     for (let pending = [...files.scripts]; pending.length; pending = [...files.scripts].filter(([at]) => !scripts.has(at))) {
-        for (const [at, script] of pending)
-            scripts.set(at, (await bundle(script, path.join(nativeDirectory, ...at.split('/')))).code);
+        for (const [at, script] of pending) {
+            const bundled = await bundle(script, path.join(nativeDirectory, ...at.split('/')));
+            scripts.set(at, bundled.code);
+            for (const input of bundled.inputs)
+                inputs.add(input);
+        }
     }
     files.warnBundled(application.inputs);
     const embedded = options.native === 'embedded';
@@ -221,6 +228,6 @@ export async function bundleProject(options) {
         resourcesDirectory: resources.files.length && !embedded ? resourcesDirectory : undefined,
         workers: [...new Set([...scripts.keys()].map((at) => files.nameOf(files.scripts.get(at))))].sort(),
         files: [...files.roots].filter((root) => !files.scriptPaths().has(root)).map((root) => files.nameOf(root)).sort(),
-        warnings: files.warnings
+        warnings: [...files.warnings, ...collector.unshippedAddons(inputs, files.files.values())]
     };
 }

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/Files.js

@@ -291,8 +291,10 @@ export class FileCollector {
     /**
      * @param project The directory of the project: the scripts are named from it (as the modules the bundler gives, its
      * real path)
+     * @param addons The packages sharing the framework and holding addons
      */
-    constructor(project) {
+    constructor(project, addons) {
+        this.addons = addons;
         /**
          * The scripts: their paths in the native tree, and their files
          */
@@ -354,6 +356,7 @@ export class FileCollector {
         const directory = path.resolve(path.join(found.base ?? path.dirname(file), prefix.slice(0, cut + 1)));
         const rest = [...prefix.slice(cut + 1) ? [{ text: prefix.slice(cut + 1) }] : [], ...found.parts.slice(leading.length)];
         const targets = { directory: directory, rest: rest, scripts: [], files: [], roots: [] };
+        const addons = this.addons?.packageOf(file);
         //A file: bundled when it is a script, copied otherwise; a directory of data: its files copied
         const take = (at, strict) => {
             const stats = statSync(at);
@@ -362,8 +365,19 @@ export class FileCollector {
                 targets.roots.push(at);
             }
             else if (stats.isDirectory()) {
-                //A directory holding the module (the application, its packages), or holding code: not shipped
-                if ((file + path.sep).startsWith(at + path.sep)) {
+                //A directory of the package of addons of the module, bundled with the application: its native files
+                //(its addons found from it, as node-gyp-build finds them)
+                if (addons && (at + path.sep).startsWith(addons + path.sep)) {
+                    targets.files.push(...this.addons.nativeFilesOf(addons, at));
+                    targets.roots.push(at);
+                    //The directory named exactly (the package above the module): the files are named from it
+                    if (strict) {
+                        targets.directory = at;
+                        targets.rest = [];
+                    }
+                }
+                else if ((file + path.sep).startsWith(at + path.sep)) {
+                    //A directory holding the module (the application, its packages), or holding code: not shipped
                     if (strict)
                         targets.refused = 'ancestor';
                 }
@@ -452,8 +466,29 @@ export class FileCollector {
         const members = new Map();
         const constructors = new Set();
         const namespaces = new Set();
+        //The names of the properties (a.__dirname, {__dirname: a}, {__dirname}), which are not to be rewritten; whether the
+        //module declares a __dirname of its own (a variable, a parameter: the name is not the directory of the module)
+        const properties = new Set();
+        let declaresDirname = false;
+        const names = (pattern) => {
+            let found = false;
+            walk(pattern, (node) => {
+                if (node.type === 'Identifier' && node.name === '__dirname')
+                    found = true;
+            });
+            return found;
+        };
         const remember = (values, name, value) => values.set(name, values.has(name) ? null : value);
         walk(program, (node) => {
+            if (node.type === 'MemberExpression' && !node.computed)
+                properties.add(node.property);
+            if (node.type === 'Property' && !node.computed) {
+                properties.add(node.key);
+                if (node.shorthand)
+                    properties.add(node.value);
+            }
+            if ((node.type === 'VariableDeclarator' && names(node.id)) || (node.type === 'CatchClause' && node.param && names(node.param)) || (/Function/.test(node.type) && node.params.some(names)))
+                declaresDirname = true;
             if (node.type === 'ImportDeclaration' && WORKER_THREADS.has(node.source.value)) {
                 for (const specifier of node.specifiers) {
                     if (specifier.type === 'ImportSpecifier' && (specifier.imported.name ?? specifier.imported.value) === 'Worker')
@@ -484,11 +519,15 @@ export class FileCollector {
             if (node.type === 'AssignmentExpression' && node.operator === '=' && node.left.type === 'MemberExpression' && node.left.object.type === 'ThisExpression' && !node.left.computed)
                 remember(members, node.left.property.name, node.right);
         });
-        //The paths to files, wherever they are written
+        //The paths to files, wherever they are written. In a module of a package of addons bundled with the application,
+        //the directory of the module itself too (given to node-gyp-build): the native files of the package are there, in
+        //the tree (a __dirname the module declares is its own: the value it is given, rewritten when it is the directory)
+        const ownDirectory = !!this.addons?.packageOf(file);
+        const isOwnDirectory = (node) => ownDirectory && isDirname(node) && !properties.has(node) && !(node.type === 'Identifier' && declaresDirname);
         const edits = [];
         const followed = new Set();
         walk(program, (node) => {
-            const found = scriptPathOf(node, source, file);
+            const found = scriptPathOf(node, source, file) ?? (isOwnDirectory(node) ? { kind: 'path', parts: [] } : undefined);
             if (!found)
                 return true;
             const targets = this.targetsOf(found, file);

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') }) : 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 };
+        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/Native.js

@@ -227,7 +227,7 @@ export class NativeCollector {
     }
     /**
      * Whether a package is left out of the bundle: it holds addons, or one of its dependencies does (it loads them,
-     * with computed paths often), and it is not the project
+     * with computed paths often), and it is neither the project nor a package sharing the framework
      * @param root
      */
     isNative(root) {
@@ -236,14 +236,68 @@ export class NativeCollector {
         const info = this.package(root);
         if (!info)
             return false;
-        if (info.addons)
-            return true;
         //A package of the framework, or built on it, shares it with the application: bundled with it (one copy of its
-        //classes, its container), its native dependencies loaded by their names, which the bundler follows
+        //classes, its container), its native dependencies loaded by their names, which the bundler follows, and its own
+        //addons loaded from the tree (a require of the addon, or a path from its module: the bundler follows both)
         if (sharesFramework(info.manifest))
             return false;
+        if (info.addons)
+            return true;
         return this.dependencies(root).some(({ root: dependency }) => !!this.package(dependency)?.addons);
     }
+    /**
+     * The package sharing the framework and holding addons a file belongs to: bundled with the application, the paths
+     * to its own directories ship their native files (its addons, its manifest, its data)
+     * @param file
+     * @returns its directory, undefined for a file of another package
+     */
+    addonPackageOf(file) {
+        const root = this.packageRoot(file);
+        if (!root || root === this.project)
+            return undefined;
+        const info = this.package(root);
+        return info?.addons && sharesFramework(info.manifest) ? root : undefined;
+    }
+    /**
+     * The native files of a directory of a package holding addons: the files node loads at run time (its addons, its
+     * libraries, its manifest, its data), without its scripts (bundled) and what node never loads
+     * @param root the directory of the package
+     * @param directory
+     */
+    nativeFilesOf(root, directory) {
+        const cargo = existsSync(path.join(root, 'Cargo.toml'));
+        return packageFiles(directory).filter((file) => {
+            const relative = path.relative(root, file).split(path.sep).join('/');
+            return !SCRIPT.test(file) && !UNUSED.test(file) && !BUILD_FILES.test(relative) && !(cargo && relative.startsWith('target/'));
+        });
+    }
+    /**
+     * The addons of the packages sharing the framework bundled with the application which are not shipped: none of
+     * their addons is loaded by a require or a path the bundler follows (they would not be found at run time)
+     * @param inputs the files bundled
+     * @param shipped the files of the tree (the addons loaded by a require, the files read by a path from a module)
+     * @returns the warnings, one by package
+     */
+    unshippedAddons(inputs, shipped) {
+        const files = new Set([...shipped, ...this.addons.values()]);
+        const roots = new Set();
+        for (const input of inputs) {
+            const root = this.packageRoot(input);
+            if (root && root !== this.project)
+                roots.add(root);
+        }
+        const warnings = [];
+        for (const root of [...roots].sort()) {
+            const info = this.package(root);
+            if (!info?.addons || !sharesFramework(info.manifest))
+                continue;
+            const addons = packageFiles(root).filter((file) => ADDON.test(file));
+            if (addons.some((addon) => files.has(addon)))
+                continue;
+            warnings.push(`${info.name}: its native addon (${addons.map((addon) => path.relative(root, addon).split(path.sep).join('/')).join(', ')}) is not shipped: the bundler does not follow how it is loaded. A package built on the framework is bundled with the application: load its addon by a require (require('./build/Release/addon.node')) or by a path from its module (path.join(__dirname, 'prebuilds', \`\${process.platform}-\${process.arch}\`, 'addon.node'), new URL('./addon.node', import.meta.url))`);
+        }
+        return warnings;
+    }
     /**
      * Resolve an import as esbuild does
      * @param build

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 {