@lakutata/cli 3.0.0-beta.3 → 3.0.0-beta.5

package/README.md

@@ -212,6 +212,44 @@ 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 files the application reads by their paths are not followed by the bundler: the scripts it runs on their own (its
+workers, `new Worker()`, the pools of workers given a file; its child processes, `fork()`; the modules it loads by their
+paths, `require(path.join(__dirname, 'x.js'))`), its data (`fs.readFileSync(path.join(__dirname, 'defaults.json'))`, a
+directory of schemas). And the bundle is not where its modules were: `path.resolve(__dirname, '../../schema')` of a
+module of `build/config/` is the `schema/` of the project, not once bundled in `dist/`. A path to a file given from its
+module is found wherever it is written, in the modules of the application and in the ones of its packages, and the
+expression rewritten to the file in the native tree (`dist/<name>.native/.lakutata/files/`, the directories as in the
+project, the packages linked from outside of it under `node_modules/`):
+
+| The path names | |
+|---|---|
+| a script (`.js`, `.cjs`) | bundled on its own with what it loads (a CommonJS file, whatever the type of the project) |
+| another file | copied (a `package.json` its type CommonJS, as the scripts next to it) |
+| a directory of data | its files copied |
+| a directory holding the module (`path.join(__dirname, '..')`: the application, its packages) | not shipped, warned of: its files are declared as resources (`lakutata.resources`, below) |
+| a directory holding scripts or packages (`package.json`, `node_modules`) | not shipped, warned of: its scripts need their packages at run time |
+| nothing yet (a directory the application creates) | left as it is |
+
+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, 'locales', `${lang}.json`) ``, `` new URL(`./jobs/${name}.js`, import.meta.url) `` | known in part: every file and 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. 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. The workers running a source
+(`eval: true`) need nothing. The warnings name the modules of the application only, with their file and line.
+
 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 +288,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 files read by their paths 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,20 @@ 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 run on their own (${result.workers.join(', ')})`] : [],
+                ...result.files.length ? [`the files read by their paths (${result.files.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 +55,10 @@ 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 run on their own next to the executable: ${result.workers.join(', ')}` : `Scripts run on their own embedded, extracted at the first run: ${result.workers.join(', ')}`);
+        if (result.files.length)
+            step(result.directory ? `Files read by their paths next to the executable: ${result.files.join(', ')}` : `Files read by their paths embedded, extracted at the first run: ${result.files.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.3",
+  "version": "3.0.0-beta.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).",
   "type": "module",
   "bin": {
@@ -16,10 +16,10 @@
   "dependencies": {
     "@inquirer/prompts": "^8.7.2",
     "commander": "^15.0.0",
-    "lakutata": "3.0.0-beta.3"
+    "lakutata": "3.0.0-beta.5"
   },
   "peerDependencies": {
-    "@lakutata/builder": "3.0.0-beta.3"
+    "@lakutata/builder": "3.0.0-beta.5"
   },
   "peerDependenciesMeta": {
     "@lakutata/builder": {
@@ -27,7 +27,7 @@
     }
   },
   "devDependencies": {
-    "@lakutata/builder": "3.0.0-beta.3"
+    "@lakutata/builder": "3.0.0-beta.5"
   },
   "engines": {
     "node": ">=22.12"