@lakutata/cli 3.0.0-beta.2 → 3.0.0-beta.4

package/README.md

@@ -212,6 +212,33 @@ files by paths which cannot be followed (`require(path.join(__dirname, name))`)
 maps, the TypeScript sources and the documentation of the packages are left out. The addons of
 the application itself (`require('./x.node')`, `createRequire(import.meta.url)('./x.node')`) are there too.
 
+The scripts the application runs on their own by their paths are not followed by the bundler: the scripts of its
+workers (`new Worker()`, the pools of workers given a file), of its child processes (`fork()`), the modules it loads by
+their paths (`require(path.join(__dirname, 'x.js'))`). A path to a script (a `.js` or `.cjs` file) given from its module
+is found wherever it is written, in the modules of the application and in the ones of its packages (the scripts of the
+pools of workers): the script is bundled on its own with what it loads (a CommonJS file, whatever the type of the
+project) into the native tree (`dist/<name>.native/.lakutata/workers/`, its directories as in the project, the packages
+linked from outside of it under `node_modules/`), and the expression rewritten to it. The paths followed:
+
+| Path | |
+|---|---|
+| `new URL('./worker.js', import.meta.url)` | the URL of the module (as Vite); `pathToFileURL(__filename)` too |
+| `import.meta.url + '/../worker.js'` | a text of the URL of the module |
+| `path.join(__dirname, 'worker.js')`, `path.resolve(__dirname, …)` | `import.meta.dirname`, `path.dirname(fileURLToPath(import.meta.url))` too |
+| `__dirname + '/worker.js'`, `` `${__dirname}/worker.js` `` | |
+| `require.resolve('./worker')`, `require.resolve(path.resolve(__dirname, '../lib/worker'))` | the extension found as node finds it |
+| `` path.join(__dirname, 'jobs', `${name}.js`) ``, `` new URL(`./jobs/${name}.js`, import.meta.url) `` | known in part: every script of the directory its pattern matches (an expression matches a part of a name), its expression kept |
+
+The code of tsc (`(0, node_path_1.join)(__dirname, 'worker.js')`) is followed. The paths to other files (a directory, a
+data file) are left as they are: they are resources (below). A script also imported by the application is warned of:
+it is bundled twice, its module apart in each (its state, its classes). The workers of node (`worker_threads`) whose
+scripts cannot be followed are warned of with their file and line, in the modules of the application (the packages start
+workers from the paths their users give): a path known at run time only (`new Worker(file)`, a variable or a property of
+a class holding one of the paths above is followed), or a path relative to the current directory of the process
+(`new Worker('./worker.js')`, which node reads from there, not from the module); their scripts are given from the
+directory of their module, or shipped as resources (`lakutata.resources`). The workers running a source (`eval: true`)
+need nothing.
+
 The resources of the application, the files it reads at run time (the built pages of a web application, templates,
 data), are declared by the `lakutata.resources` of its `package.json`, as the `extraResources` of electron-builder:
 
@@ -250,11 +277,14 @@ linux/arm64`, as the cross builds of the templates).
 | `--layout <file\|directory>` | one file (by default), or a directory: `dist/<name>/` holding the executable, its native addons (`native/`) and its resources (`resources/`), loaded from there without extraction (the installers, the images) |
 | `--entry`, `--no-minify`, `--external` | as `lakutata package bundle` |
 
-The native addons and the resources are embedded in the executable (`--layout file`): at its first run, it extracts them
-into its cache directory (`~/.cache/<name>`, `~/Library/Caches/<name>` on macOS, `%LOCALAPPDATA%\<name>\Cache` on Windows,
-or `LAKUTATA_NATIVE_DIR`; the temporary directory when it cannot be written), in a directory named after their content:
+The native addons, the scripts of the workers and the resources are embedded in the executable (`--layout file`): at its
+first run, it extracts them into its cache directory (`~/.cache/<name>`, `~/Library/Caches/<name>` on macOS,
+`%LOCALAPPDATA%\<name>\Cache` on Windows, or `LAKUTATA_NATIVE_DIR`; the temporary directory when it cannot be written),
+in a directory named after their content:
 the next runs load them from there, the versions of the program do not share it. The addons need the system libraries they were built for (the
-glibc version of the Linux prebuilt addons).
+glibc version of the Linux prebuilt addons). The child processes of an executable run it (`process.execPath`): started
+for one of its scripts (`fork(path.join(__dirname, 'child.js'))`, `spawn(process.execPath, [script])`), it runs the
+script as node does (its arguments, `require.main`), not the application.
 
 The executables of macOS are signed ad hoc. The ones of Windows made by Node.js keep the signature of `node.exe`, which
 does not match anymore: sign them before distributing them.

package/dist/esm/controllers/PackController.js

@@ -31,11 +31,16 @@ export class PackController extends Controller {
         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 });
         done(`${path.relative(process.cwd(), result.outfile)} (${megabytes(result.size)}): node ${path.relative(process.cwd(), result.outfile)}`);
-        //The native addons are next to the bundle, which is distributed with them
-        if (result.nativeDirectory)
-            done(`${path.relative(process.cwd(), result.nativeDirectory)}: the native addons (${result.native.modules.join(', ') || 'of the application'}), distributed with the bundle`);
+        //The native addons and the scripts of the workers are next to the bundle, which is distributed with them
+        if (result.nativeDirectory) {
+            const addons = !!result.native.modules.length || result.native.files.some((file) => file.path.endsWith('.node'));
+            const contents = [...addons ? [`the native addons (${result.native.modules.join(', ') || 'of the application'})`] : [], ...result.workers.length ? [`the scripts of the workers (${result.workers.join(', ')})`] : []];
+            done(`${path.relative(process.cwd(), result.nativeDirectory)}: ${contents.join(' and ')}, distributed with the bundle`);
+        }
         if (result.resourcesDirectory)
             done(`${path.relative(process.cwd(), result.resourcesDirectory)}: the resources (${result.resources.join(', ')}), distributed with the bundle`);
+        for (const warning of result.warnings)
+            warn(warning);
         return undefined;
     }
     async executable(input) {
@@ -46,6 +51,8 @@ export class PackController extends Controller {
             step(result.directory ? `Native addons next to the executable: ${result.native.join(', ')}` : `Native addons embedded, extracted at the first run: ${result.native.join(', ')}`);
         if (result.resources.length)
             step(result.directory ? `Resources next to the executable: ${result.resources.join(', ')}` : `Resources embedded, extracted at the first run: ${result.resources.join(', ')}`);
+        if (result.workers.length)
+            step(result.directory ? `Scripts of the workers next to the executable: ${result.workers.join(', ')}` : `Scripts of the workers embedded, extracted at the first run: ${result.workers.join(', ')}`);
         for (const warning of result.warnings)
             warn(warning);
         if (result.directory)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lakutata/cli",
-  "version": "3.0.0-beta.2",
+  "version": "3.0.0-beta.4",
   "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).",
   "type": "module",
   "bin": {
@@ -16,10 +16,10 @@
   "dependencies": {
     "@inquirer/prompts": "^8.7.2",
     "commander": "^15.0.0",
-    "lakutata": "3.0.0-beta.2"
+    "lakutata": "3.0.0-beta.4"
   },
   "peerDependencies": {
-    "@lakutata/builder": "3.0.0-beta.2"
+    "@lakutata/builder": "3.0.0-beta.4"
   },
   "peerDependenciesMeta": {
     "@lakutata/builder": {
@@ -27,7 +27,7 @@
     }
   },
   "devDependencies": {
-    "@lakutata/builder": "3.0.0-beta.2"
+    "@lakutata/builder": "3.0.0-beta.4"
   },
   "engines": {
     "node": ">=22.12"