@lakutata/cli 3.1.4 → 3.1.5

package/README.md

@@ -26,7 +26,7 @@ both the features and the confirmation).
 | `--path <directory>` | the directory in which the project directory is created, by default the current one |
 | `--init` | create the project in the `--path` directory itself, which must exist and may hold files: the files it already has are kept (a warning lists those that the template also has, to merge by hand), and only the files the tool writes are filled with the information of the project |
 | `--description`, `--author`, `--license` | information about the application |
-| `--with <features>` | the optional features of the template to enable, separated by commas (listed by `lakutata templates`): `i18n`, `installer`. In a terminal, without `--with` or `--yes`, you choose them from a list |
+| `--with <features>` | the optional features of the template to enable, separated by commas (listed by `lakutata templates`): `i18n`, `installer`, `win7`. In a terminal, without `--with` or `--yes`, you choose them from a list |
 | `--package-manager <npm\|pnpm\|yarn\|none>` | the package manager that installs the dependencies (`none` installs nothing): npm by default, or pnpm or yarn when one of them started the tool |
 | `--no-git` | do not initialize a git repository |
 | `--yes` | create the project without asking for the features or for a confirmation |
@@ -38,11 +38,13 @@ lakutata create --name my-service --template service --with i18n --yes
 
 Every official template has the `i18n` feature: the messages of the application in several languages
 (`lakutata/com/i18n`), in `src/locales` (`en.json`, `zh-CN.json`) and bundled with the code. Each request is answered in
-its own language, including its validation errors (command line tools and Electron applications use the language of the
+its own language, including its validation errors (command line tools and desktop applications use the language of the
 environment). The feature also adds the `i18n:check` and `i18n:types` scripts. The `cli`, `service` and `web-*`
 templates also have the `installer` feature: the `lakutata.installer` configuration of the application and the scripts
 that make its installers (on the machine, and for Linux in Docker), and, in the `service` and `web-*` templates, a
-system service.
+system service. The `nwjs-*` templates have the `win7` feature: NW.js 0.72.0, the last release running on Windows 7, 8
+and 8.1, instead of the release the template was published with, and the script that makes the installers of 32-bit
+Windows.
 
 ### `lakutata templates`
 
@@ -408,12 +410,12 @@ platforms (the Linux ones can be made in a container). They are configured by th
 | `productName` | the name shown to users (in the installers, and in the list of programs on Windows), by default the `productName` of the `package.json`, else the name |
 | `description`, `maintainer`, `homepage`, `license` | by default those of the `package.json` (the maintainer is its author) |
 | `vendor` | its vendor, none by default (on Windows, the publisher is the vendor, else the maintainer) |
-| `runtime` | the runtime of the executable: `node` (the default) or `bun`; `electron` for an Electron application (below) |
-| `addToPath` | put the program in the PATH (`/usr/bin/<program>`, `/usr/local/bin/<program>` on macOS; on Windows, the PATH of the machine), `true` by default |
+| `runtime` | the runtime of the executable: `node` (the default) or `bun`; `electron` for an Electron application, `nwjs` for an NW.js application (below) |
+| `addToPath` | put the program in the PATH (`/usr/bin/<program>`, `/usr/local/bin/<program>` on macOS; on Windows, the PATH of the machine), `true` by default (`false` for an NW.js application) |
 | `service` | `true` or the options of the service (below), none by default |
 | `linux.targets` | `deb`, `rpm`, `archlinux`, `tar.gz` on glibc systems (`deb`, `rpm`, `tar.gz` by default); `apk`, `tar.gz` on Alpine (musl) |
 | `linux.depends`, `linux.recommends`, `linux.section`, `linux.priority` | the system packages it needs and recommends, its section and its priority (deb) |
-| `mac.targets` | `pkg`, `tar.gz` (both by default) |
+| `mac.targets` | `pkg`, `tar.gz` (both by default); `dmg` for an NW.js application |
 | `win.targets` | `nsis`, `msi`, `zip` (all by default) |
 | `electron` | the electron-builder configuration of an Electron application, merged over the one made from these options |
 
@@ -527,11 +529,56 @@ one electron-builder downloads is built for x64. On Windows arm64, the NSIS inst
 the BCJ filter (`ELECTRON_BUILDER_7Z_FILTER`), because they cannot extract files compressed with the ARM64 filter,
 which 7-Zip would choose.
 
+The installers of an NW.js application (`"runtime": "nwjs"`) hold the normal flavor of its NW.js (`lakutata nwjs use`,
+below), named after the application, with the application in it: its bundle for the Node.js of that NW.js, its native
+addons made to load in it, its resources and the manifest of NW.js. On Windows, the executable is `<name>.exe`, with
+the icon and the version information of the application; on macOS, the bundle is `<productName>.app`, whose
+`Info.plist` gives its name, its `appId`, its version and its icon (signed again ad hoc). Its installers are those of a
+desktop application, by default `deb` on Linux, `dmg` on macOS and `nsis` on Windows: the Windows installers (`nsis`,
+`msi`) add it to the start menu and to the desktop, the `dmg` disk image holds it beside a link to /Applications and
+the `pkg` package installs it there, and the Linux packages (`deb`, `rpm`) add its desktop entry and its icons and
+depend on the libraries of Chromium. `--arch` makes them for another architecture than the one of the machine (`ia32`:
+32-bit Windows). An NW.js application is not a service; its scripts run as for the other applications (on macOS, it is
+removed by deleting it, without a removal script).
+
 | Command option | |
 |---|---|
 | `--target <targets...>` | the installers to make, by default those of the configuration |
 | `--outdir <directory>` | the directory of the installers, `dist/installer` by default |
 | `--entry`, `--no-minify`, `--external` | as for `lakutata package exe` |
+| `--arch <arch>` | the architecture of an NW.js application (`x64`, `ia32`, `arm64`), the one of the machine by default |
+
+## NW.js
+
+An NW.js application (the `nwjs-react` and `nwjs-vue` templates) runs in the version of NW.js of its `package.json`,
+`"lakutata": {"nwjs": {"version": "0.119.2"}}`. The runtimes of NW.js are downloaded once into the cache of lakutata
+(from `https://dl.nwjs.io`, or the mirror of `LAKUTATA_NWJS_MIRROR`) and checked against the checksums of their release.
+lakutata runs on the releases whose Node.js is 18.10 or later.
+
+### `lakutata nwjs versions`
+
+List the releases of NW.js lakutata runs on, newest first: their date, their Node.js, their Chromium and their builds,
+the latest and the last one running on Windows 7 (`win7`, 0.72.0) marked. It lists the ten latest and the one of
+Windows 7, every release with `--all`. The list of the releases (`https://nwjs.io/versions.json`, or the one of
+`LAKUTATA_NWJS_VERSIONS`) is cached for a day.
+
+### `lakutata nwjs use <version>`
+
+Give the application of the current directory its version of NW.js: a version (`0.119.2`), `latest` or `win7`, written
+as a version into the `lakutata.nwjs` of its `package.json`. It writes `nwjs.json` too, the version with its Node.js and
+its Chromium, which the templates' build of the user interface reads to target that Chromium, and tells the systems the
+release runs on. `--download` downloads its sdk flavor for the machine at once.
+
+### `lakutata nwjs run [args...]`
+
+Run the compiled application of the current directory in NW.js: it is bundled into `.nwjs/app` for the Node.js of its
+NW.js, with its resources and its native addons made to load in it, then run with the arguments given after `--`
+(`lakutata nwjs run -- --ui=http://localhost:5173`). The command ends with NW.js, and stops it when it is stopped.
+
+| Option | |
+|---|---|
+| `--release <version>` | the release of NW.js run (a version, `latest`, `win7`), the one of `lakutata.nwjs` by default |
+| `--flavor <sdk\|normal>` | `sdk` (the default: with the DevTools) or `normal` (the one the installers hold) |
 
 ## Migrations
 
@@ -604,6 +651,8 @@ matches. The names of the commands and options, and the other results and errors
 | `LAKUTATA_NPM_REGISTRY` | the npm registry of the templates (by default `npm_config_registry`, else `https://registry.npmjs.org`) |
 | `LAKUTATA_GITHUB_DOWNLOAD` | a GitHub mirror for the `github:` templates (`https://github.com` by default) |
 | `LAKUTATA_CACHE_DIR` | the cache directory (by default `$XDG_CACHE_HOME/lakutata`, else `~/.cache/lakutata`) |
+| `LAKUTATA_NWJS_MIRROR` | where the runtimes of NW.js are downloaded from (`https://dl.nwjs.io` by default) |
+| `LAKUTATA_NWJS_VERSIONS` | the list of the releases of NW.js (`https://nwjs.io/versions.json` by default) |
 | `LAKUTATA_LANG` | the language of the tool (`zh-CN`, `zh-TW`, `en`), by default that of the environment |
 
 The tool is itself a lakutata application: its commands are the CLI actions of its controllers, served by the

package/README.zh-CN.md

@@ -24,7 +24,7 @@ lakutata create --name my-app
 | `--path <directory>` | 在哪个目录中创建项目目录，默认是当前目录 |
 | `--init` | 直接在 `--path` 目录中创建项目。这个目录必须已经存在，里面可以有文件：已有的文件会保留（模板中也有的那些会在警告中列出，需要手动合并），只有新写入的文件会填入项目的信息 |
 | `--description`、`--author`、`--license` | 应用的信息 |
-| `--with <features>` | 要启用的模板可选功能，用逗号分隔（`lakutata templates` 会列出）：`i18n`、`installer`。在终端里，如果没有给出 `--with` 或 `--yes`，会让你从列表中选择 |
+| `--with <features>` | 要启用的模板可选功能，用逗号分隔（`lakutata templates` 会列出）：`i18n`、`installer`、`win7`。在终端里，如果没有给出 `--with` 或 `--yes`，会让你从列表中选择 |
 | `--package-manager <npm\|pnpm\|yarn\|none>` | 安装依赖所用的包管理器（`none` 表示不安装）：默认是 npm，由 pnpm 或 yarn 启动工具时用对应的那个 |
 | `--no-git` | 不初始化 git 仓库 |
 | `--yes` | 直接创建项目，不询问可选功能，也不要求确认 |
@@ -34,7 +34,7 @@ lakutata create --name my-service --template service --package-manager pnpm --ye
 lakutata create --name my-service --template service --with i18n --yes
 ```
 
-每个官方模板都有 `i18n` 功能：应用的多语言消息（`lakutata/com/i18n`），放在 `src/locales` 中（`en.json`、`zh-CN.json`），并随代码一起打包。应用按每个请求的语言回复，校验错误也一样（命令行工具和 Electron 应用使用运行环境的语言）。这个功能还会加上 `i18n:check` 和 `i18n:types` 脚本。`cli`、`service` 和 `web-*` 模板还有 `installer` 功能：应用的 `lakutata.installer` 配置，以及制作安装包的脚本（在本机制作，以及在 Docker 中制作 Linux 的安装包）；在 `service` 和 `web-*` 模板中，这个功能还包括一个系统服务。
+每个官方模板都有 `i18n` 功能：应用的多语言消息（`lakutata/com/i18n`），放在 `src/locales` 中（`en.json`、`zh-CN.json`），并随代码一起打包。应用按每个请求的语言回复，校验错误也一样（命令行工具和桌面应用使用运行环境的语言）。这个功能还会加上 `i18n:check` 和 `i18n:types` 脚本。`cli`、`service` 和 `web-*` 模板还有 `installer` 功能：应用的 `lakutata.installer` 配置，以及制作安装包的脚本（在本机制作，以及在 Docker 中制作 Linux 的安装包）；在 `service` 和 `web-*` 模板中，这个功能还包括一个系统服务。`nwjs-*` 模板有 `win7` 功能：用 NW.js 0.72.0（最后一个能在 Windows 7、8 和 8.1 上运行的版本）代替模板发布时的版本，并加上制作 32 位 Windows 安装包的脚本。
 
 ### `lakutata templates`
 
@@ -242,12 +242,12 @@ macOS 的可执行文件使用临时签名（ad hoc）。用 Node.js 制作的 W
 | `productName` | 显示给用户的名称（在安装程序中，以及 Windows 的程序列表中），默认取 `package.json` 的 `productName`，没有时取名称 |
 | `description`、`maintainer`、`homepage`、`license` | 默认取自 `package.json`（维护者是它的作者） |
 | `vendor` | 供应商，默认没有（在 Windows 上，发布者是供应商，没有时是维护者） |
-| `runtime` | 可执行文件的运行时：`node`（默认）或 `bun`；Electron 应用用 `electron`（见下文） |
-| `addToPath` | 把程序加入 PATH（`/usr/bin/<program>`，macOS 上是 `/usr/local/bin/<program>`；Windows 上是机器的 PATH），默认 `true` |
+| `runtime` | 可执行文件的运行时：`node`（默认）或 `bun`；Electron 应用用 `electron`，NW.js 应用用 `nwjs`（见下文） |
+| `addToPath` | 把程序加入 PATH（`/usr/bin/<program>`，macOS 上是 `/usr/local/bin/<program>`；Windows 上是机器的 PATH），默认 `true`（NW.js 应用默认 `false`） |
 | `service` | `true` 或服务的选项（见下文），默认没有 |
 | `linux.targets` | glibc 系统上可以是 `deb`、`rpm`、`archlinux`、`tar.gz`（默认 `deb`、`rpm`、`tar.gz`）；Alpine（musl）上是 `apk`、`tar.gz` |
 | `linux.depends`、`linux.recommends`、`linux.section`、`linux.priority` | 依赖和推荐的系统软件包、分类和优先级（deb） |
-| `mac.targets` | `pkg`、`tar.gz`（默认两种都制作） |
+| `mac.targets` | `pkg`、`tar.gz`（默认两种都制作）；NW.js 应用还可以用 `dmg` |
 | `win.targets` | `nsis`、`msi`、`zip`（默认全部制作） |
 | `electron` | Electron 应用的 electron-builder 配置，合并到由这些选项生成的配置之上 |
 
@@ -313,11 +313,35 @@ Electron 应用（`"runtime": "electron"`）的安装包由 electron-builder 制
 
 在 Linux arm64 上，fpm 软件包需要系统中的 fpm（`gem install fpm`、`USE_SYSTEM_FPM=true`），因为 electron-builder 下载的那个是为 x64 构建的。在 Windows arm64 上，NSIS 安装程序用 BCJ 过滤器压缩可执行文件（`ELECTRON_BUILDER_7Z_FILTER`），因为 7-Zip 默认会选用 ARM64 过滤器，而 NSIS 安装程序无法解压用它压缩的文件。
 
+NW.js 应用（`"runtime": "nwjs"`）的安装包里是它所用 NW.js（`lakutata nwjs use`，见下文）的 normal 版本，以应用的名字命名，应用放在其中：为这个 NW.js 的 Node.js 打包的代码、处理成能在其中加载的原生插件、资源和 NW.js 的清单。Windows 上的可执行文件是 `<name>.exe`，带有应用的图标和版本信息；macOS 上的应用包是 `<productName>.app`，它的 `Info.plist` 给出应用的名称、`appId`、版本和图标（并重新做临时签名）。它的安装包是桌面应用的安装包，默认 Linux 上是 `deb`，macOS 上是 `dmg`，Windows 上是 `nsis`：Windows 的安装程序（`nsis`、`msi`）把应用加到开始菜单和桌面，`dmg` 磁盘映像里是应用和一个指向 /Applications 的链接，`pkg` 安装包把应用装到那里，Linux 的软件包（`deb`、`rpm`）添加应用的桌面入口和图标，并依赖 Chromium 所需的库。`--arch` 为本机以外的架构制作安装包（`ia32`：32 位 Windows）。NW.js 应用不是服务；它的脚本和其他应用一样执行（macOS 上的应用是直接删除的，没有卸载脚本）。
+
 | 命令选项 | |
 |---|---|
 | `--target <targets...>` | 要制作的安装包，默认是配置中的那些 |
 | `--outdir <directory>` | 安装包的输出目录，默认 `dist/installer` |
 | `--entry`、`--no-minify`、`--external` | 与 `lakutata package exe` 相同 |
+| `--arch <arch>` | NW.js 应用的架构（`x64`、`ia32`、`arm64`），默认是本机的架构 |
+
+## NW.js
+
+NW.js 应用（`nwjs-react` 和 `nwjs-vue` 模板）运行在它 `package.json` 中指定的 NW.js 版本里：`"lakutata": {"nwjs": {"version": "0.119.2"}}`。NW.js 的运行时只下载一次到 lakutata 的缓存目录（从 `https://dl.nwjs.io` 下载，或者从 `LAKUTATA_NWJS_MIRROR` 指定的镜像下载），并按其发布版本的校验和核对。lakutata 支持内置 Node.js 为 18.10 或更高版本的 NW.js。
+
+### `lakutata nwjs versions`
+
+列出 lakutata 支持的 NW.js 版本，从新到旧：发布日期、内置的 Node.js 和 Chromium、提供的构建，并标出最新版本和最后一个能在 Windows 7 上运行的版本（`win7`，0.72.0）。默认列出最新的十个版本和 Windows 7 的那个版本，`--all` 列出全部。版本列表（`https://nwjs.io/versions.json`，或者 `LAKUTATA_NWJS_VERSIONS` 指定的列表）缓存一天。
+
+### `lakutata nwjs use <version>`
+
+为当前目录的应用设置 NW.js 版本：某个版本（`0.119.2`）、`latest` 或 `win7`，以具体的版本号写进 `package.json` 的 `lakutata.nwjs`。它同时写入 `nwjs.json`，即这个版本及其内置的 Node.js 和 Chromium，模板里用户界面的构建会读取它，以这个 Chromium 为目标；命令还会给出这个版本能运行的系统。`--download` 立即为本机下载它的 sdk 版本。
+
+### `lakutata nwjs run [args...]`
+
+在 NW.js 中运行当前目录下编译好的应用：应用先被打包到 `.nwjs/app`，以这个 NW.js 的 Node.js 为目标，带上资源和处理成能在其中加载的原生插件，然后带着 `--` 之后的参数运行（`lakutata nwjs run -- --ui=http://localhost:5173`）。NW.js 退出时命令结束；命令被终止时，NW.js 也会随之结束。
+
+| 选项 | |
+|---|---|
+| `--release <version>` | 运行的 NW.js 版本（某个版本、`latest`、`win7`），默认是 `lakutata.nwjs` 中的版本 |
+| `--flavor <sdk\|normal>` | `sdk`（默认：带 DevTools）或 `normal`（安装包中的版本） |
 
 ## 迁移
 
@@ -367,6 +391,8 @@ Electron 应用（`"runtime": "electron"`）的安装包由 electron-builder 制
 | `LAKUTATA_NPM_REGISTRY` | 下载模板的 npm 仓库（默认取 `npm_config_registry`，否则为 `https://registry.npmjs.org`） |
 | `LAKUTATA_GITHUB_DOWNLOAD` | 下载 `github:` 模板所用的 GitHub 镜像（默认 `https://github.com`） |
 | `LAKUTATA_CACHE_DIR` | 缓存目录（默认 `$XDG_CACHE_HOME/lakutata`，否则为 `~/.cache/lakutata`） |
+| `LAKUTATA_NWJS_MIRROR` | NW.js 运行时的下载地址（默认 `https://dl.nwjs.io`） |
+| `LAKUTATA_NWJS_VERSIONS` | NW.js 的发布版本列表（默认 `https://nwjs.io/versions.json`） |
 | `LAKUTATA_LANG` | 工具的语言（`zh-CN`、`zh-TW`、`en`），默认取环境的语言 |
 
 这个工具本身也是一个 lakutata 应用：它的命令就是其控制器的命令行动作，由入口的 commander 适配器提供。

package/dist/esm/Config.js

@@ -1,21 +1,21 @@
+import { readFileSync } from 'node:fs';
 import { buildEntrypoints } from 'lakutata/com/entrypoint';
 import { commanderCLIEntrypoint } from 'lakutata/adapter/commander';
 import { buildI18nOptions, commanderTranslator } from 'lakutata/com/i18n';
-import zhCN from './locales/zh-CN.json' with { type: 'json' };
-import zhTW from './locales/zh-TW.json' with { type: 'json' };
 import { CommandLineController } from './controllers/CommandLineController.js';
 import { WorkspaceController } from './controllers/WorkspaceController.js';
 import { PackController } from './controllers/PackController.js';
 import { MigrationController } from './controllers/MigrationController.js';
 import { NativeController } from './controllers/NativeController.js';
 import { FFIController } from './controllers/FFIController.js';
+import { NwjsController } from './controllers/NwjsController.js';
 import { I18nController } from './controllers/I18nController.js';
 import { LANGUAGE_VARIABLE, LanguageMiddleware } from './lib/Language.js';
 import { toolPackage } from './lib/Versions.js';
 /**
  * The controllers of the commands of the tool
  */
-export const CONTROLLERS = [CommandLineController, WorkspaceController, PackController, MigrationController, NativeController, FFIController, I18nController];
+export const CONTROLLERS = [CommandLineController, WorkspaceController, PackController, MigrationController, NativeController, FFIController, NwjsController, I18nController];
 /**
  * The messages of the tool in the languages besides English (its texts in the code): its help, its prompts
  */
@@ -24,9 +24,18 @@ export const CONTROLLERS = [CommandLineController, WorkspaceController, PackCont
  */
 export const COMMAND_GROUPS = {
     package: 'Package the compiled application: into one JavaScript file, an executable or its installers',
-    ffi: 'Generate the classes of the native libraries of @lakutata/ffi from their C headers'
+    ffi: 'Generate the classes of the native libraries of @lakutata/ffi from their C headers',
+    nwjs: 'Give the application its version of NW.js, run it in NW.js, list the releases of NW.js'
 };
-export const MESSAGES = { 'zh-CN': zhCN, 'zh-TW': zhTW };
+/**
+ * The messages of a language, read from its file of the locales (an import of JSON needs the import attributes, which
+ * Node.js 18.10 does not read)
+ * @param language
+ */
+function messagesOf(language) {
+    return JSON.parse(readFileSync(new URL(`./locales/${language}.json`, import.meta.url), 'utf8'));
+}
+export const MESSAGES = { 'zh-CN': messagesOf('zh-CN'), 'zh-TW': messagesOf('zh-TW') };
 /**
  * The application of the tool
  */

package/dist/esm/controllers/NwjsController.js

@@ -0,0 +1,128 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { spawn } from 'node:child_process';
+import { readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { Controller } from 'lakutata/com/entrypoint';
+import { CLIAction } from 'lakutata/decorator/ctrl';
+import { NwjsRunDTO } from '../dtos/NwjsRunDTO.js';
+import { NwjsUseDTO } from '../dtos/NwjsUseDTO.js';
+import { NwjsVersionsDTO } from '../dtos/NwjsVersionsDTO.js';
+import { loadBuilder } from '../lib/Builder.js';
+import { done, step } from '../lib/Output.js';
+/**
+ * The last release of NW.js running on Windows 7, 8 and 8.1 (Chromium 109)
+ */
+const WINDOWS_7 = '0.72.0';
+/**
+ * Whether a version of NW.js is at most another one
+ * @param version
+ * @param other
+ */
+function atMost(version, other) {
+    const parts = (value) => value.split('.').map((part) => parseInt(part, 10) || 0);
+    const [a, b] = [parts(version), parts(other)];
+    for (let index = 0; index < 3; index++)
+        if (a[index] !== b[index])
+            return (a[index] ?? 0) < (b[index] ?? 0);
+    return true;
+}
+/**
+ * The systems a release of NW.js runs on, as its users see them
+ * @param release
+ */
+function systemsOf(release) {
+    const windows = atMost(release.version, WINDOWS_7) ? 'Windows 7 or later' : 'Windows 10 or later';
+    const mac = release.platforms.includes('osx-arm64') ? 'macOS (Intel, Apple silicon)' : 'macOS (Intel; Apple silicon through Rosetta)';
+    const linux = `Linux (${release.platforms.filter((platform) => platform.startsWith('linux-')).map((platform) => platform.slice(6)).join(', ')})`;
+    return `${windows}, ${mac}, ${linux}`;
+}
+/**
+ * The commands of the applications of NW.js: its releases, the one of the application, the run of the development
+ */
+export class NwjsController extends Controller {
+    async versions(input) {
+        const { nwjsReleases } = await loadBuilder(process.cwd());
+        const releases = (await nwjsReleases()).filter((release) => !atMost(release.node, '18.9.99'));
+        const shown = input.all ? releases : releases.filter((release, index) => index < 10 || release.version === WINDOWS_7);
+        for (const release of shown) {
+            const marks = [release === releases[0] ? 'latest' : '', release.version === WINDOWS_7 ? 'win7: the last one running on Windows 7, 8 and 8.1' : ''].filter(Boolean).join(', ');
+            step(`${release.version.padEnd(9)} ${release.date.padEnd(11)} Node.js ${release.node.padEnd(8)} Chromium ${release.chromium.split('.')[0]}  ${release.platforms.join(' ')}${marks ? `  (${marks})` : ''}`);
+        }
+        return undefined;
+    }
+    async use(input) {
+        const { nwjsRelease, downloadNwjs } = await loadBuilder(process.cwd());
+        const release = await nwjsRelease(input.version);
+        const file = path.join(process.cwd(), 'package.json');
+        const manifest = JSON.parse(readFileSync(file, 'utf8'));
+        manifest.lakutata = { ...manifest.lakutata, nwjs: { ...manifest.lakutata?.nwjs, version: release.version } };
+        writeFileSync(file, `${JSON.stringify(manifest, null, 2)}\n`);
+        //What the builds of the user interface and of the application are made for
+        writeFileSync(path.join(process.cwd(), 'nwjs.json'), `${JSON.stringify({ version: release.version, node: release.node, chromium: release.chromium }, null, 2)}\n`);
+        done(`NW.js ${release.version}: Node.js ${release.node}, Chromium ${release.chromium}`);
+        step(`Runs on ${systemsOf(release)}`);
+        if (input.download) {
+            const runtime = await downloadNwjs({ version: release.version, flavor: 'sdk' });
+            done(`Downloaded NW.js ${runtime.version} (sdk, ${runtime.platform})`);
+        }
+        return undefined;
+    }
+    async run(input) {
+        const { stageNwjsApp, downloadNwjs } = await loadBuilder(process.cwd());
+        const stage = await stageNwjsApp({ project: process.cwd(), outdir: path.join('.nwjs', 'app'), version: input.release });
+        if (stage.addons.rebuilt.length)
+            step(`Native addons built for NW.js ${stage.release.version} (${stage.platform}): ${stage.addons.rebuilt.join(', ')}`);
+        if (stage.addons.renamed.length)
+            step(`Native addons loading the Node.js of NW.js (node.dll): ${stage.addons.renamed.join(', ')}`);
+        const runtime = await downloadNwjs({ version: stage.release.version, flavor: input.flavor });
+        step(`NW.js ${runtime.version} (${runtime.flavor}, ${runtime.platform}): Node.js ${runtime.node}, Chromium ${runtime.chromium.split('.')[0]}`);
+        const code = await new Promise((resolve, reject) => {
+            const child = spawn(runtime.executable, [stage.directory, ...input.args ?? []], { stdio: 'inherit' });
+            //NW.js ends with the command: at once when the command is stopped by a signal sent to it only (a runner of the
+            //scripts), the run then done
+            const stop = () => {
+                if (child.exitCode === null && child.signalCode === null)
+                    child.kill();
+            };
+            const events = ['exit', 'SIGINT', 'SIGTERM', 'SIGHUP'];
+            for (const event of events)
+                process.once(event, stop);
+            child.once('error', reject);
+            //Stopped by a signal (Ctrl-C in the terminal): a normal end of the run
+            child.once('exit', (exitCode, signal) => {
+                for (const event of events)
+                    process.off(event, stop);
+                resolve(signal ? 0 : exitCode ?? 1);
+            });
+        });
+        if (code !== 0)
+            throw new Error(`NW.js exited with ${code}`);
+        return undefined;
+    }
+}
+__decorate([
+    CLIAction('nwjs versions', NwjsVersionsDTO, { description: 'List the releases of NW.js lakutata runs on: their Node.js, their Chromium, their systems' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [NwjsVersionsDTO]),
+    __metadata("design:returntype", Promise)
+], NwjsController.prototype, "versions", null);
+__decorate([
+    CLIAction('nwjs use <version>', NwjsUseDTO, { description: 'Give the application of the current directory its version of NW.js (lakutata.nwjs), and write its Node.js and its Chromium into nwjs.json' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [NwjsUseDTO]),
+    __metadata("design:returntype", Promise)
+], NwjsController.prototype, "use", null);
+__decorate([
+    CLIAction('nwjs run [args...]', NwjsRunDTO, { description: 'Run the compiled application of the current directory in NW.js (the build with its developer tools, by default)' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [NwjsRunDTO]),
+    __metadata("design:returntype", Promise)
+], NwjsController.prototype, "run", null);

package/dist/esm/controllers/PackController.js

@@ -29,7 +29,7 @@ function megabytes(size) {
 export class PackController extends Controller {
     async bundle(input) {
         const { bundleProject } = await loadBuilder(process.cwd());
-        const result = await bundleProject({ project: process.cwd(), entry: input.entry, outfile: input.outfile, minify: input.minify, external: input.external });
+        const result = await bundleProject({ project: process.cwd(), entry: input.entry, outfile: input.outfile, minify: input.minify, external: input.external, node: input.node });
         done(`${path.relative(process.cwd(), result.outfile)} (${megabytes(result.size)}): node ${path.relative(process.cwd(), result.outfile)}`);
         //The native addons and the scripts of the workers are next to the bundle, which is distributed with them
         if (result.nativeDirectory) {
@@ -49,7 +49,7 @@ export class PackController extends Controller {
     }
     async executable(input) {
         const { buildExecutable } = await loadBuilder(process.cwd());
-        const result = await buildExecutable({ project: process.cwd(), entry: input.entry, outdir: input.outdir, minify: input.minify, external: input.external, runtime: input.runtime, layout: input.layout });
+        const result = await buildExecutable({ project: process.cwd(), entry: input.entry, outdir: input.outdir, minify: input.minify, external: input.external, runtime: input.runtime, layout: input.layout, nodeProgram: input.nodeProgram });
         step(`${result.runtime} embedded`);
         if (result.native.length)
             step(result.directory ? `Native addons next to the executable: ${result.native.join(', ')}` : `Native addons embedded, extracted at the first run: ${result.native.join(', ')}`);
@@ -68,12 +68,21 @@ export class PackController extends Controller {
     }
     async installer(input) {
         const { buildInstaller } = await loadBuilder(process.cwd());
-        const result = await buildInstaller({ project: process.cwd(), targets: input.target, outdir: input.outdir, entry: input.entry, minify: input.minify, external: input.external });
-        step(`${result.executable.runtime} embedded`);
-        if (result.executable.native.length)
-            step(`Native addons: ${result.executable.native.join(', ')}`);
-        if (result.executable.resources.length)
-            step(`Resources: ${result.executable.resources.join(', ')}`);
+        const result = await buildInstaller({ project: process.cwd(), targets: input.target, outdir: input.outdir, entry: input.entry, minify: input.minify, external: input.external, nodeProgram: input.nodeProgram, arch: input.arch });
+        if (result.nwjs) {
+            step(`NW.js ${result.nwjs.runtime.version} (${result.nwjs.runtime.platform}): ${path.basename(result.nwjs.directory)}`);
+            if (result.nwjs.stage.addons.rebuilt.length)
+                step(`Native addons built for NW.js: ${result.nwjs.stage.addons.rebuilt.join(', ')}`);
+            if (result.nwjs.stage.addons.renamed.length)
+                step(`Native addons loading the Node.js of NW.js (node.dll): ${result.nwjs.stage.addons.renamed.join(', ')}`);
+        }
+        if (result.executable) {
+            step(`${result.executable.runtime} embedded`);
+            if (result.executable.native.length)
+                step(`Native addons: ${result.executable.native.join(', ')}`);
+            if (result.executable.resources.length)
+                step(`Resources: ${result.executable.resources.join(', ')}`);
+        }
         for (const warning of result.warnings)
             warn(warning);
         for (const file of result.files)

package/dist/esm/dtos/BundleDTO.js

@@ -27,3 +27,7 @@ __decorate([
     Expect(DTO.Array(DTO.String()).optional().description('The modules left out of the bundle, loaded at run time from a node_modules next to it (the native addons are handled)')),
     __metadata("design:type", Array)
 ], BundleDTO.prototype, "external", void 0);
+__decorate([
+    Expect(DTO.String().pattern(/^v?\d+(\.\d+){0,2}$/).optional().description('The version of Node.js running the bundle, whose syntax it is written in (18.10 for NW.js 0.70; the version running the command by default)')),
+    __metadata("design:type", String)
+], BundleDTO.prototype, "node", void 0);

package/dist/esm/dtos/ExecutableDTO.js

@@ -35,3 +35,7 @@ __decorate([
     Expect(DTO.String().valid('file', 'directory').optional().default('file').description('One file, its native addons and its resources embedded (file, by default), or a directory: the executable and its native addons and resources next to it (directory)')),
     __metadata("design:type", String)
 ], ExecutableDTO.prototype, "layout", void 0);
+__decorate([
+    Expect(DTO.String().optional().description('The node program embedded in the executable (Node.js 20.12, 21.7 or later): another Node.js than the one running the command, to make the executable from an older Node.js (the bundle is written in the syntax of the node program)')),
+    __metadata("design:type", String)
+], ExecutableDTO.prototype, "nodeProgram", void 0);

package/dist/esm/dtos/InstallerDTO.js

@@ -12,7 +12,7 @@ import { Expect } from 'lakutata/decorator/dto';
 export class InstallerDTO extends DTO {
 }
 __decorate([
-    Expect(DTO.Array(DTO.String()).optional().description('The installers made: deb, rpm, apk, archlinux, tar.gz on Linux, pkg, tar.gz on macOS, nsis, msi, zip on Windows (the lakutata.installer of the package.json by default)')),
+    Expect(DTO.Array(DTO.String()).optional().description('The installers made: deb, rpm, apk, archlinux, tar.gz on Linux, pkg, dmg (the applications of NW.js), tar.gz on macOS, nsis, msi, zip on Windows (the lakutata.installer of the package.json by default)')),
     __metadata("design:type", Array)
 ], InstallerDTO.prototype, "target", void 0);
 __decorate([
@@ -31,3 +31,11 @@ __decorate([
     Expect(DTO.Array(DTO.String()).optional().description('The modules left out of the bundle')),
     __metadata("design:type", Array)
 ], InstallerDTO.prototype, "external", void 0);
+__decorate([
+    Expect(DTO.String().optional().description('The node program embedded in the executable (Node.js 20.12, 21.7 or later): another Node.js than the one running the command, to make the executable from an older Node.js (the bundle is written in the syntax of the node program)')),
+    __metadata("design:type", String)
+], InstallerDTO.prototype, "nodeProgram", void 0);
+__decorate([
+    Expect(DTO.String().valid('x64', 'ia32', 'arm64').optional().description('The architecture of an application of NW.js (the one of this machine by default): ia32 for the 32-bit systems of Windows (Windows 7)')),
+    __metadata("design:type", String)
+], InstallerDTO.prototype, "arch", void 0);

package/dist/esm/dtos/NwjsRunDTO.js

@@ -0,0 +1,25 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from 'lakutata';
+import { Expect } from 'lakutata/decorator/dto';
+export class NwjsRunDTO extends DTO {
+}
+__decorate([
+    Expect(DTO.Array(DTO.String()).optional().description('The arguments given to the application, after -- (lakutata nwjs run -- --ui=http://localhost:5173)')),
+    __metadata("design:type", Array)
+], NwjsRunDTO.prototype, "args", void 0);
+__decorate([
+    Expect(DTO.String().optional().description('The release of NW.js run: a version, latest or win7 (the version of lakutata.nwjs by default)')),
+    __metadata("design:type", String)
+], NwjsRunDTO.prototype, "release", void 0);
+__decorate([
+    Expect(DTO.String().valid('sdk', 'normal').optional().default('sdk').description('The flavor of NW.js: sdk (with its developer tools, by default) or normal (the one shipped to the users)')),
+    __metadata("design:type", String)
+], NwjsRunDTO.prototype, "flavor", void 0);

package/dist/esm/dtos/NwjsUseDTO.js

@@ -0,0 +1,21 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from 'lakutata';
+import { Expect } from 'lakutata/decorator/dto';
+export class NwjsUseDTO extends DTO {
+}
+__decorate([
+    Expect(DTO.String().required().description('The version of NW.js: a version (0.119.2), latest, or win7 (0.72.0, the last one running on Windows 7, 8 and 8.1)')),
+    __metadata("design:type", String)
+], NwjsUseDTO.prototype, "version", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(false).description('Download the development build of NW.js (with its developer tools) for this machine now')),
+    __metadata("design:type", Boolean)
+], NwjsUseDTO.prototype, "download", void 0);

package/dist/esm/dtos/NwjsVersionsDTO.js

@@ -0,0 +1,17 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { DTO } from 'lakutata';
+import { Expect } from 'lakutata/decorator/dto';
+export class NwjsVersionsDTO extends DTO {
+}
+__decorate([
+    Expect(DTO.Boolean().optional().default(false).description('List every release lakutata runs on (the latest ten and the one of Windows 7 by default)')),
+    __metadata("design:type", Boolean)
+], NwjsVersionsDTO.prototype, "all", void 0);

package/dist/esm/lib/AddPackage.js

@@ -383,7 +383,9 @@ function nativeFiles(name, version, build, packageManager) {
             name: name,
             version: version,
             private: true,
-            type: 'module',
+            //CommonJS: the bundles of the applications are CommonJS and require it, which loads an ES module only on
+            //Node.js 20.19, 22.12 and later
+            type: 'commonjs',
             main: 'dist/index.js',
             types: 'dist/index.d.ts',
             exports: { '.': { types: './dist/index.d.ts', default: './dist/index.js' } },
@@ -406,7 +408,6 @@ function nativeFiles(name, version, build, packageManager) {
         ...chosen.files,
         'src/index.ts': `import {createRequire} from 'node:module'
 import path from 'node:path'
-import {fileURLToPath} from 'node:url'
 
 /**
  * The functions of the addon
@@ -418,7 +419,7 @@ type Binding = {
 /**
  * The addon built into build/Release, loaded from the directory of the package
  */
-const binding: Binding = createRequire(import.meta.url)('node-gyp-build')(path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..'))
+const binding: Binding = createRequire(__filename)('node-gyp-build')(path.resolve(__dirname, '..'))
 
 /**
  * Greet someone, in ${build === 'rust' ? 'Rust' : 'C++'}

package/dist/esm/lib/Output.js

@@ -1,11 +1,20 @@
-import { styleText } from 'node:util';
+import util from 'node:util';
+/**
+ * The styles of the output, and their codes of the terminals (where util.styleText is missing: before Node.js 20.12)
+ */
+const STYLES = { bold: [1, 22], red: [31, 39], green: [32, 39], yellow: [33, 39], blue: [34, 39], magenta: [35, 39], cyan: [36, 39] };
 /**
  * A text in a style, when the output is a terminal
  * @param style
  * @param text
  */
 export function styled(style, text) {
-    return process.stdout.isTTY && !process.env.NO_COLOR ? styleText(style, text) : text;
+    if (!process.stdout.isTTY || process.env.NO_COLOR)
+        return text;
+    //node-compat: util.styleText
+    if (typeof util.styleText === 'function')
+        return util.styleText(style, text);
+    return `\u001b[${STYLES[style][0]}m${text}\u001b[${STYLES[style][1]}m`;
 }
 /**
  * Print a step done

package/dist/esm/lib/TemplateCatalog.js

@@ -32,7 +32,9 @@ export const BUILTIN_TEMPLATES = [
     { name: 'web-vue', description: 'An HTTP API serving a Vue single-page application (Vite)', package: '@lakutata/template-web-vue', features: ['i18n', 'installer'] },
     { name: 'web-nuxt', description: 'An HTTP API serving a Nuxt application from the same process', package: '@lakutata/template-web-nuxt', features: ['i18n', 'installer'] },
     { name: 'electron-react', description: 'A desktop application: Electron, its main process serving a React renderer over IPC', package: '@lakutata/template-electron-react', features: ['i18n'] },
-    { name: 'electron-vue', description: 'A desktop application: Electron, its main process serving a Vue renderer over IPC', package: '@lakutata/template-electron-vue', features: ['i18n'] }
+    { name: 'electron-vue', description: 'A desktop application: Electron, its main process serving a Vue renderer over IPC', package: '@lakutata/template-electron-vue', features: ['i18n'] },
+    { name: 'nwjs-react', description: 'A desktop application: NW.js, its background script serving a React user interface isolated in a webview', package: '@lakutata/template-nwjs-react', features: ['i18n', 'win7'] },
+    { name: 'nwjs-vue', description: 'A desktop application: NW.js, its background script serving a Vue user interface isolated in a webview', package: '@lakutata/template-nwjs-vue', features: ['i18n', 'win7'] }
 ];
 /**
  * How long the catalog is kept, 1 day

package/dist/esm/lib/workspace/Run.js

@@ -66,7 +66,8 @@ export async function runScript(workspace, script, options = {}) {
                 dependencies.delete(name);
         return [pkg.name, dependencies];
     }));
-    const concurrency = options.parallel ? Math.max(1, selected.length) : Math.max(1, options.concurrency ?? os.availableParallelism());
+    //node-compat: os.availableParallelism
+    const concurrency = options.parallel ? Math.max(1, selected.length) : Math.max(1, options.concurrency ?? (typeof os.availableParallelism === 'function' ? os.availableParallelism() : os.cpus().length));
     const width = Math.max(0, ...selected.map((pkg) => pkg.name.length));
     const done = new Set();
     //The packages depending on a failed package, not run

package/dist/esm/locales/zh-CN.json

@@ -78,7 +78,8 @@
                         "entry": "应用编译后的入口（默认是 package.json 的 main）",
                         "outfile": "打包输出的文件（默认 dist/<名称>.cjs）",
                         "minify": "压缩打包结果",
-                        "external": "不打进包里的模块，运行时从旁边的 node_modules 加载（原生插件会自动处理）"
+                        "external": "不打进包里的模块，运行时从旁边的 node_modules 加载（原生插件会自动处理）",
+                        "node": "运行打包结果的 Node.js 版本，打包结果用这个版本支持的语法生成（NW.js 0.70 是 18.10；默认是运行本命令的版本）"
                     }
                 },
                 "exe": {
@@ -89,17 +90,20 @@
                         "minify": "压缩嵌入可执行文件的包",
                         "external": "不打进包里的模块（它们不在可执行文件中，而是从旁边的 node_modules 加载）",
                         "runtime": "嵌入可执行文件的运行时：node（Node.js 的单可执行应用，默认）或 bun（Bun，安装在项目中或系统上）",
-                        "layout": "单个文件，原生插件和资源嵌入其中（file，默认）；或一个目录：可执行文件及其旁边的原生插件和资源（directory）"
+                        "layout": "单个文件，原生插件和资源嵌入其中（file，默认）；或一个目录：可执行文件及其旁边的原生插件和资源（directory）",
+                        "nodeProgram": "嵌入可执行文件的 node 程序（Node.js 20.12、21.7 或更高版本）：用另一个 Node.js 代替运行本命令的那个，这样在较旧的 Node.js 上也能生成可执行文件"
                     }
                 },
                 "installer": {
                     "description": "为当前平台生成编译后应用的安装包：安装可执行文件、原生插件和资源，把程序加入 PATH，并注册系统服务",
                     "options": {
-                        "target": "要生成的安装包：Linux 上为 deb、rpm、apk、archlinux、tar.gz，macOS 上为 pkg、tar.gz，Windows 上为 nsis、msi、zip（默认取 package.json 的 lakutata.installer）",
+                        "target": "要生成的安装包：Linux 上为 deb、rpm、apk、archlinux、tar.gz，macOS 上为 pkg、dmg（NW.js 应用）、tar.gz，Windows 上为 nsis、msi、zip（默认取 package.json 的 lakutata.installer）",
                         "outdir": "安装包所在的目录（默认 dist/installer）",
                         "entry": "应用编译后的入口（默认是 package.json 的 main）",
                         "minify": "压缩嵌入可执行文件的包",
-                        "external": "不打进包里的模块"
+                        "external": "不打进包里的模块",
+                        "nodeProgram": "嵌入可执行文件的 node 程序（Node.js 20.12、21.7 或更高版本）：用另一个 Node.js 代替运行本命令的那个，这样在较旧的 Node.js 上也能生成可执行文件",
+                        "arch": "NW.js 应用的架构（默认是本机的架构）：32 位 Windows（Windows 7）用 ia32"
                     }
                 }
             },
@@ -152,6 +156,34 @@
                     }
                 }
             },
+            "nwjs": {
+                "description": "为应用指定 NW.js 版本、在 NW.js 里运行应用、列出 NW.js 的版本",
+                "versions": {
+                    "description": "列出 lakutata 能运行的 NW.js 版本：各自的 Node.js、Chromium 和支持的系统",
+                    "options": {
+                        "all": "列出所有能运行 lakutata 的版本（默认只列最新的十个和支持 Windows 7 的那个）"
+                    }
+                },
+                "use": {
+                    "description": "给当前目录的应用指定 NW.js 版本（lakutata.nwjs），并把它的 Node.js 和 Chromium 版本写入 nwjs.json",
+                    "arguments": {
+                        "version": "NW.js 版本：具体的版本号（0.119.2）、latest，或 win7（0.72.0，最后一个能在 Windows 7、8、8.1 上运行的版本）"
+                    },
+                    "options": {
+                        "download": "现在就为本机下载开发用的 NW.js（带开发者工具）"
+                    }
+                },
+                "run": {
+                    "description": "在 NW.js 里运行当前目录下编译好的应用（默认带开发者工具）",
+                    "arguments": {
+                        "args": "传给应用的参数，写在 -- 之后（lakutata nwjs run -- --ui=http://localhost:5173）"
+                    },
+                    "options": {
+                        "release": "运行的 NW.js 版本：具体的版本号、latest 或 win7（默认是 lakutata.nwjs 里的版本）",
+                        "flavor": "NW.js 的类型：sdk（带开发者工具，默认）或 normal（发布给用户的）"
+                    }
+                }
+            },
             "i18n": {
                 "description": "检查各语言的翻译、声明键名的类型，或添加一种语言",
                 "arguments": {

package/dist/esm/locales/zh-TW.json

@@ -78,7 +78,8 @@
                         "entry": "應用程式編譯後的入口（預設是 package.json 的 main）",
                         "outfile": "打包輸出的檔案（預設 dist/<名稱>.cjs）",
                         "minify": "壓縮打包結果",
-                        "external": "不打包進去的模組，執行時從旁邊的 node_modules 載入（原生外掛會自動處理）"
+                        "external": "不打包進去的模組，執行時從旁邊的 node_modules 載入（原生外掛會自動處理）",
+                        "node": "執行打包結果的 Node.js 版本，打包結果用這個版本支援的語法產生（NW.js 0.70 是 18.10；預設是執行本命令的版本）"
                     }
                 },
                 "exe": {
@@ -89,17 +90,20 @@
                         "minify": "壓縮嵌入可執行檔的打包結果",
                         "external": "不打包進去的模組（它們不在可執行檔中，而是從旁邊的 node_modules 載入）",
                         "runtime": "嵌入可執行檔的執行環境：node（Node.js 的單一可執行應用程式，預設）或 bun（Bun，安裝在專案中或系統上）",
-                        "layout": "單一檔案，原生外掛程式和資源嵌入其中（file，預設）；或一個目錄：可執行檔及其旁邊的原生外掛程式和資源（directory）"
+                        "layout": "單一檔案，原生外掛程式和資源嵌入其中（file，預設）；或一個目錄：可執行檔及其旁邊的原生外掛程式和資源（directory）",
+                        "nodeProgram": "嵌入可執行檔的 node 程式（Node.js 20.12、21.7 或更新版本）：用另一個 Node.js 代替執行本命令的那個，這樣在較舊的 Node.js 上也能產生可執行檔"
                     }
                 },
                 "installer": {
                     "description": "為目前平台產生編譯後應用程式的安裝套件：安裝可執行檔、原生外掛程式和資源，把程式加入 PATH，並註冊系統服務",
                     "options": {
-                        "target": "要產生的安裝套件：Linux 上為 deb、rpm、apk、archlinux、tar.gz，macOS 上為 pkg、tar.gz，Windows 上為 nsis、msi、zip（預設取 package.json 的 lakutata.installer）",
+                        "target": "要產生的安裝套件：Linux 上為 deb、rpm、apk、archlinux、tar.gz，macOS 上為 pkg、dmg（NW.js 應用程式）、tar.gz，Windows 上為 nsis、msi、zip（預設取 package.json 的 lakutata.installer）",
                         "outdir": "安裝套件所在的目錄（預設 dist/installer）",
                         "entry": "應用程式編譯後的入口（預設是 package.json 的 main）",
                         "minify": "壓縮嵌入可執行檔的打包結果",
-                        "external": "不打包進去的模組"
+                        "external": "不打包進去的模組",
+                        "nodeProgram": "嵌入可執行檔的 node 程式（Node.js 20.12、21.7 或更新版本）：用另一個 Node.js 代替執行本命令的那個，這樣在較舊的 Node.js 上也能產生可執行檔",
+                        "arch": "NW.js 應用程式的架構（預設是本機的架構）：32 位元 Windows（Windows 7）用 ia32"
                     }
                 }
             },
@@ -152,6 +156,34 @@
                     }
                 }
             },
+            "nwjs": {
+                "description": "為應用程式指定 NW.js 版本、在 NW.js 裡執行應用程式、列出 NW.js 的版本",
+                "versions": {
+                    "description": "列出 lakutata 能執行的 NW.js 版本：各自的 Node.js、Chromium 和支援的系統",
+                    "options": {
+                        "all": "列出所有能執行 lakutata 的版本（預設只列最新的十個和支援 Windows 7 的那個）"
+                    }
+                },
+                "use": {
+                    "description": "為目前目錄的應用程式指定 NW.js 版本（lakutata.nwjs），並把它的 Node.js 和 Chromium 版本寫入 nwjs.json",
+                    "arguments": {
+                        "version": "NW.js 版本：具體的版本號（0.119.2）、latest，或 win7（0.72.0，最後一個能在 Windows 7、8、8.1 上執行的版本）"
+                    },
+                    "options": {
+                        "download": "現在就為本機下載開發用的 NW.js（帶開發者工具）"
+                    }
+                },
+                "run": {
+                    "description": "在 NW.js 裡執行目前目錄下編譯好的應用程式（預設帶開發者工具）",
+                    "arguments": {
+                        "args": "傳給應用程式的參數，寫在 -- 之後（lakutata nwjs run -- --ui=http://localhost:5173）"
+                    },
+                    "options": {
+                        "release": "執行的 NW.js 版本：具體的版本號、latest 或 win7（預設是 lakutata.nwjs 裡的版本）",
+                        "flavor": "NW.js 的類型：sdk（帶開發者工具，預設）或 normal（發佈給使用者的）"
+                    }
+                }
+            },
             "i18n": {
                 "description": "檢查各語言的翻譯、宣告鍵名的型別，或新增一種語言",
                 "arguments": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lakutata/cli",
-  "version": "3.1.4",
+  "version": "3.1.5",
   "description": "The command line tool of the lakutata framework: create the projects from the templates, run and version the packages of the workspaces, bundle the applications and make their executables (with @lakutata/builder).",
   "keywords": [
     "lakutata",
@@ -37,13 +37,13 @@
     "test:unit": "npm run compile && node --import ./dist/esm/tests/support/English.js --test \"dist/esm/tests/*.spec.js\""
   },
   "dependencies": {
-    "@inquirer/prompts": "^8.7.2",
-    "commander": "^15.0.0",
-    "lakutata": "3.1.4"
+    "@inquirer/prompts": "^7.10.1",
+    "commander": "^13.1.0",
+    "lakutata": "3.1.5"
   },
   "peerDependencies": {
-    "@lakutata/builder": "~3.1.3",
-    "@lakutata/ffi": "~3.1.2"
+    "@lakutata/builder": "~3.1.5",
+    "@lakutata/ffi": "~3.1.5"
   },
   "peerDependenciesMeta": {
     "@lakutata/builder": {
@@ -54,11 +54,11 @@
     }
   },
   "devDependencies": {
-    "@lakutata/builder": "~3.1.3",
-    "@lakutata/ffi": "~3.1.2"
+    "@lakutata/builder": "~3.1.5",
+    "@lakutata/ffi": "~3.1.5"
   },
   "engines": {
-    "node": "^22.13.0 || >=24.11.0"
+    "node": ">=18.10.0"
   },
   "license": "MIT",
   "files": [