@lakutata/builder 3.0.0-beta.3 → 3.0.0-beta.4

package/README.md

@@ -16,7 +16,10 @@ await buildInstaller({project: process.cwd()})
 ```
 
 The application is compiled first (`tsc`, which emits the metadata of the decorators). The bundle is one CommonJS file
-(esbuild); the native addons, which cannot be bundled, are gathered with what they load at run time into a native tree;
+(esbuild); the native addons, which cannot be bundled, are gathered with what they load at run time into a native tree,
+with the scripts run on their own by their paths, which the bundler does not follow (the workers, the pools of workers,
+`fork()`, `require(path.join(__dirname, 'x.js'))`: the paths given from their modules are found, the scripts bundled,
+the paths rewritten; the workers whose scripts cannot be followed are in the `warnings` of the result);
 the resources of the application (the `lakutata.resources` of its `package.json`) are found at run time by
 `resourcesPath()` of lakutata. The installers are configured by the `lakutata.installer` of the `package.json`. See the
 documentation of `lakutata package bundle`, `lakutata package exe` and `lakutata package installer` in `@lakutata/cli`.

package/dist/esm/lib/Bundle.js

@@ -1,8 +1,9 @@
-import { existsSync, readdirSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { chmod, cp, mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { hashNativeTree, NativeCollector, writeNativeTree } from './Native.js';
 import { EMBEDDED_RESOURCES, nativeBanner, packagedBanner } from './NativeRuntime.js';
+import { WORKERS_DIRECTORY, WorkerCollector } from './Workers.js';
 /**
  * The name of the program of a package: its first bin, or the name of the package without its scope
  * @param manifest
@@ -85,43 +86,77 @@ 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 workers = new WorkerCollector(project);
     //esbuild is loaded by the commands which need it
     const { build } = await import('esbuild');
-    const result = await build({
-        entryPoints: [entry],
-        outfile: outfile,
-        write: false,
-        bundle: true,
-        platform: 'node',
-        target: `node${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
-        keepNames: true,
-        external: options.external ?? [],
-        //The dynamic imports of the modules left out are requires (the require of the bundle loads the native ones)
-        supported: { 'dynamic-import': false },
-        banner: { js: `var ${IMPORT_META_URL}=require('node:url').pathToFileURL(__filename).href;` },
-        define: {
-            'import.meta.url': IMPORT_META_URL,
-            //Bun replaces process.env.NODE_ENV with the mode of its build: the one of the run is read
-            ...options.runtime === 'bun' ? { 'process.env.NODE_ENV': 'globalThis.process.env.NODE_ENV' } : {}
-        },
-        plugins: [collector.plugin()],
-        logLevel: 'silent'
-    }).catch((error) => {
-        const messages = (error.errors ?? []).map(({ text, location }) => location ? `${location.file}:${location.line}: ${text}` : text);
-        //The bundles are CommonJS, which the executables of Node.js run
-        const hint = messages.some((message) => message.includes('Top-level await')) ? '\nThe bundles are CommonJS modules, without top-level await: await in an async function' : '';
-        throw new Error(`The bundle failed:\n  ${messages.length ? messages.join('\n  ') : error.message}${hint}`);
-    });
-    let code = result.outputFiles[0].text;
-    const embedded = options.native === 'embedded';
-    let native = await collector.collect();
-    const resources = resourceFiles(project, manifest);
+    //The application, and each script of its workers (the bundler does not follow new Worker()): their native packages
+    //gathered into one tree, the workers they start found too
+    const bundle = async (input, output) => {
+        const result = await build({
+            entryPoints: [input],
+            outfile: output,
+            write: false,
+            metafile: true,
+            bundle: true,
+            platform: 'node',
+            target: `node${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
+            keepNames: true,
+            external: options.external ?? [],
+            //The dynamic imports of the modules left out are requires (the require of the bundle loads the native ones)
+            supported: { 'dynamic-import': false },
+            banner: { js: `var ${IMPORT_META_URL}=require('node:url').pathToFileURL(__filename).href;` },
+            define: {
+                'import.meta.url': IMPORT_META_URL,
+                //Bun replaces process.env.NODE_ENV with the mode of its build: the one of the run is read
+                ...options.runtime === 'bun' ? { 'process.env.NODE_ENV': 'globalThis.process.env.NODE_ENV' } : {}
+            },
+            plugins: [collector.plugin([(source, file) => workers.transform(source, file)])],
+            logLevel: 'silent'
+        }).catch((error) => {
+            const messages = (error.errors ?? []).map(({ text, location }) => location ? `${location.file}:${location.line}: ${text}` : text);
+            //The bundles are CommonJS, which the executables of Node.js run
+            const hint = messages.some((message) => message.includes('Top-level await')) ? '\nThe bundles are CommonJS modules, without top-level await: await in an async function' : '';
+            throw new Error(`The bundle failed:\n  ${messages.length ? messages.join('\n  ') : error.message}${hint}`);
+        });
+        //The files bundled (their real paths; the modules of the plugins are in their namespaces)
+        const inputs = new Set(Object.keys(result.metafile.inputs).filter((input) => !/^[a-z-]+:/.test(input)).map((input) => {
+            const absolute = path.resolve(input);
+            return existsSync(absolute) ? realpathSync(absolute) : absolute;
+        }));
+        return { code: result.outputFiles[0].text, inputs: inputs };
+    };
+    const application = await bundle(entry, outfile);
+    let code = application.code;
     const base = path.basename(outfile, path.extname(outfile));
     const nativeDirectory = path.resolve(path.dirname(outfile), options.directories?.native ?? `${base}.native`);
     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();
+    for (let pending = [...workers.scripts]; pending.length; pending = [...workers.scripts].filter(([at]) => !scripts.has(at))) {
+        for (const [at, script] of pending)
+            scripts.set(at, (await bundle(script, path.join(nativeDirectory, ...at.split('/')))).code);
+    }
+    workers.warnBundled(application.inputs);
+    const embedded = options.native === 'embedded';
+    let native = await collector.collect();
+    const resources = resourceFiles(project, manifest);
+    if (scripts.size) {
+        //The scripts run from the tree: their require loads the native packages from it, their resources are the ones of
+        //the application (an executable gives them from the tree it extracted)
+        const modules = native?.modules ?? [];
+        const files = [{ path: `${WORKERS_DIRECTORY}/package.json`, source: manifestFile, mode: 0o644, content: Buffer.from('{"type": "commonjs"}\n') }];
+        for (const [at, script] of [...scripts].sort(([a], [b]) => a.localeCompare(b))) {
+            const directory = path.dirname(path.join(nativeDirectory, ...at.split('/')));
+            const banner = packagedBanner(path.relative(directory, resourcesDirectory).split(path.sep).join('/')) +
+                nativeBanner({ name: name, hash: '', directory: '', modules: modules, embedded: embedded, root: path.relative(directory, nativeDirectory).split(path.sep).join('/') });
+            files.push({ path: at, source: workers.scripts.get(at), mode: 0o644, content: Buffer.from(prepend(script, banner)) });
+        }
+        const all = [...native?.files ?? [], ...files];
+        native = { modules: modules, files: all, links: native?.links ?? [], hash: hashNativeTree(all, native?.links ?? []) };
+    }
     await rm(nativeDirectory, { recursive: true, force: true });
     await rm(resourcesDirectory, { recursive: true, force: true });
     //The resources of an executable are extracted with its native tree
@@ -129,6 +164,11 @@ export async function bundleProject(options) {
         const files = [...native?.files ?? [], ...resources.files.map((file) => ({ ...file, path: `${EMBEDDED_RESOURCES}/${file.path}` }))];
         native = { modules: native?.modules ?? [], files: files, links: native?.links ?? [], hash: hashNativeTree(files, native?.links ?? []) };
     }
+    if (native && embedded) {
+        //An executable runs the scripts of its tree it is started for (fork()) instead of the application
+        const hashbang = /^#![^\n]*\n/.exec(code)?.[0] ?? '';
+        code = `${hashbang}if (!require.lakutataScript()) {\n${code.slice(hashbang.length)}\n}\n`;
+    }
     if (native) {
         //The require loading the native packages is the first code, after the hashbang
         code = prepend(code, nativeBanner({ name: name, hash: native.hash, directory: path.basename(nativeDirectory), modules: native.modules, embedded: embedded }));
@@ -157,6 +197,8 @@ export async function bundleProject(options) {
         native: native,
         nativeDirectory: native && !embedded ? nativeDirectory : undefined,
         resources: resources.declared,
-        resourcesDirectory: resources.files.length && !embedded ? resourcesDirectory : undefined
+        resourcesDirectory: resources.files.length && !embedded ? resourcesDirectory : undefined,
+        workers: [...new Set([...scripts.keys()].map((at) => workers.nameOf(workers.scripts.get(at))))].sort(),
+        warnings: workers.warnings
     };
 }

package/dist/esm/lib/Executable.js

@@ -196,7 +196,7 @@ export async function buildExecutable(options) {
         //ignores the case), whose signature it writes beside the executable (_CodeSignature)
         const made = path.join(work, 'executable', path.basename(file));
         await mkdir(path.dirname(made), { recursive: true });
-        const warnings = [];
+        const warnings = [...bundle.warnings];
         //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;
@@ -209,6 +209,7 @@ export async function buildExecutable(options) {
             platform: `${process.platform === 'win32' ? 'win' : process.platform}-${process.arch}`,
             size: (await stat(file)).size,
             native: bundle.native?.modules ?? [],
+            workers: bundle.workers,
             resources: bundle.resources,
             directory: directory ? target : undefined,
             runtime: runtime,

package/dist/esm/lib/Native.js

@@ -4,6 +4,13 @@ import { mkdir, readFile, rm, symlink, writeFile } from 'node:fs/promises';
 import { createRequire, isBuiltin } from 'node:module';
 import path from 'node:path';
 import { gzipSync } from 'node:zlib';
+/**
+ * The content of a file of the native tree
+ * @param file
+ */
+function contentOf(file) {
+    return file.content ?? readFileSync(file.source);
+}
 /**
  * The shared libraries: the addons, and the libraries they are linked with (sharp and libvips)
  */
@@ -227,8 +234,10 @@ export class NativeCollector {
     }
     /**
      * The plugin of the bundle: the native packages are external, the addons of the application are loaded from the tree
+     * @param transforms the transformations of the sources of the modules (the paths of the workers), giving their new
+     * source or undefined
      */
-    plugin() {
+    plugin(transforms = []) {
         return {
             name: 'lakutata-native',
             setup: (build) => {
@@ -263,11 +272,21 @@ export class NativeCollector {
                 });
                 //The requires of the ES modules are the one of the bundle: esbuild follows what they load (the addons)
                 build.onLoad({ filter: /\.(c|m)?js$/ }, async (args) => {
-                    const source = await readFile(args.path, 'utf8');
-                    if (!MODULE_REQUIRE.test(source))
-                        return undefined;
-                    MODULE_REQUIRE.lastIndex = 0;
-                    return { contents: source.replace(MODULE_REQUIRE, 'require'), loader: 'js', resolveDir: path.dirname(args.path) };
+                    let source = await readFile(args.path, 'utf8');
+                    let changed = false;
+                    if (MODULE_REQUIRE.test(source)) {
+                        MODULE_REQUIRE.lastIndex = 0;
+                        source = source.replace(MODULE_REQUIRE, 'require');
+                        changed = true;
+                    }
+                    for (const transform of transforms) {
+                        const transformed = transform(source, args.path);
+                        if (transformed === undefined)
+                            continue;
+                        source = transformed;
+                        changed = true;
+                    }
+                    return changed ? { contents: source, loader: 'js', resolveDir: path.dirname(args.path) } : undefined;
                 });
                 //The addons of the application are loaded by the require of the bundle, from the extracted tree
                 build.onLoad({ filter: /.*/, namespace: 'lakutata-native' }, (args) => ({
@@ -487,7 +506,7 @@ export class NativeCollector {
 export function hashNativeTree(files, links) {
     const hash = createHash('sha256');
     for (const file of files)
-        hash.update(`${file.path}\0${file.mode}\0`).update(readFileSync(file.source));
+        hash.update(`${file.path}\0${file.mode}\0`).update(contentOf(file));
     for (const link of links)
         hash.update(`${link.path}\0${link.target}\0`);
     return hash.digest('hex').slice(0, 16);
@@ -502,7 +521,7 @@ export async function writeNativeTree(tree, directory) {
     for (const file of tree.files) {
         const target = path.join(directory, ...file.path.split('/'));
         await mkdir(path.dirname(target), { recursive: true });
-        await writeFile(target, readFileSync(file.source), { mode: file.mode });
+        await writeFile(target, contentOf(file), { mode: file.mode });
     }
     for (const link of tree.links) {
         const at = path.join(directory, ...link.path.split('/'));
@@ -524,7 +543,7 @@ export function packNativeTree(tree) {
     const files = [];
     let offset = 0;
     for (const file of tree.files) {
-        const content = readFileSync(file.source);
+        const content = contentOf(file);
         files.push({ path: file.path, offset: offset, size: content.length, mode: file.mode });
         chunks.push(content);
         offset += content.length;

package/dist/esm/lib/NativeRuntime.js

@@ -97,7 +97,10 @@ export function lakutataNativeRequire(nodeRequire, config) {
     const locate = () => {
         if (root)
             return root;
-        if (config.embedded) {
+        if (config.root !== undefined) {
+            root = path.resolve(__dirname, config.root);
+        }
+        else if (config.embedded) {
             try {
                 root = extract(cacheDirectory());
             }
@@ -121,7 +124,9 @@ export function lakutataNativeRequire(nodeRequire, config) {
         return modules.has(id.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0]);
     };
     const tree = () => treeRequire ??= createRequire(path.join(locate(), 'index.js'));
-    const require = ((id) => fromTree(id) ? tree()(id) : nodeRequire(id));
+    //The files loaded by their paths (the scripts of the tree): the require of an executable of Node.js loads the modules of
+    //node only
+    const require = ((id) => fromTree(id) ? tree()(id) : path.isAbsolute(id) ? createRequire(id)(id) : nodeRequire(id));
     require.resolve = ((id, options) => fromTree(id) ? tree().resolve(id, options) : nodeRequire.resolve(id, options));
     require.cache = nodeRequire.cache;
     require.main = nodeRequire.main;
@@ -132,6 +137,28 @@ export function lakutataNativeRequire(nodeRequire, config) {
         process.dlopen(addon, path.join(locate(), ...key.split('/')));
         return addon.exports;
     };
+    //The scripts of the workers of the application, bundled into the tree (WORKERS_DIRECTORY): the directory of a key, its URL
+    const workers = (key) => path.join(locate(), '.lakutata', 'workers', ...key.split('/'));
+    require.lakutataWorker = workers;
+    require.lakutataWorkerURL = (key) => nodeRequire('node:url').pathToFileURL(workers(key) + path.sep).href;
+    //An executable started to run a script of its tree (fork(), spawn(process.execPath, [script]): process.execPath is the
+    //executable): it runs the script as node runs it, the application not started
+    require.lakutataScript = () => {
+        if (!config.embedded || config.root !== undefined)
+            return false;
+        const scripts = path.join(locate(), '.lakutata', 'workers') + path.sep;
+        const at = [1, 2].find((index) => !!process.argv[index] && path.resolve(process.argv[index]).startsWith(scripts)) ?? -1;
+        if (at < 0)
+            return false;
+        const script = path.resolve(process.argv[at]);
+        process.argv.splice(1, at - 1);
+        //The main module of node (require.main); Bun loads it by a require (its Module._load does nothing)
+        if (process.versions.bun)
+            createRequire(script)(script);
+        else
+            nodeRequire('node:module')._load(script, null, true);
+        return true;
+    };
     //The resources of an executable are extracted with the tree (PACKAGED, EMBEDDED_RESOURCES)
     if (config.embedded)
         globalThis[Symbol.for('lakutata.packaged')] = { resources: () => path.join(locate(), '.lakutata', 'resources') };

package/dist/esm/lib/Workers.js

@@ -0,0 +1,476 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, realpathSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { parse } from 'acorn';
+/**
+ * The directory of the scripts run on their own in the native tree
+ */
+export const WORKERS_DIRECTORY = '.lakutata/workers';
+/**
+ * The scripts run on their own: the CommonJS scripts, which they are bundled as
+ */
+const SCRIPT = /\.c?js$/;
+/**
+ * The modules of the worker threads
+ */
+const WORKER_THREADS = new Set(['worker_threads', 'node:worker_threads']);
+/**
+ * The name of a function called: the identifier, the property (path.join, node_path_1.join), the last expression of a
+ * sequence (the calls of tsc: (0, node_path_1.join)(...))
+ * @param node
+ */
+function calleeName(node) {
+    if (node?.type === 'Identifier')
+        return node.name;
+    if (node?.type === 'MemberExpression')
+        return node.computed ? (typeof node.property.value === 'string' ? node.property.value : undefined) : node.property.name;
+    if (node?.type === 'SequenceExpression')
+        return calleeName(node.expressions[node.expressions.length - 1]);
+    return undefined;
+}
+/**
+ * Whether a node is import.meta.<name>
+ * @param node
+ * @param name
+ */
+function isImportMeta(node, name) {
+    return node?.type === 'MemberExpression' && !node.computed && node.object.type === 'MetaProperty' && node.object.meta.name === 'import' && node.property.name === name;
+}
+/**
+ * Whether a node is the URL of the file of the module: import.meta.url, pathToFileURL(__filename) (and its href)
+ * @param node
+ */
+function isFileURL(node) {
+    if (isImportMeta(node, 'url'))
+        return true;
+    if (node?.type === 'CallExpression' && calleeName(node.callee) === 'pathToFileURL')
+        return isFilename(node.arguments[0]);
+    if (node?.type === 'MemberExpression' && !node.computed && node.property.name === 'href')
+        return isFileURL(node.object);
+    return false;
+}
+/**
+ * Whether a node is the file of the module: __filename, import.meta.filename, fileURLToPath(import.meta.url)
+ * @param node
+ */
+function isFilename(node) {
+    if (node?.type === 'Identifier')
+        return node.name === '__filename';
+    if (isImportMeta(node, 'filename'))
+        return true;
+    return node?.type === 'CallExpression' && calleeName(node.callee) === 'fileURLToPath' && isImportMeta(node.arguments[0], 'url');
+}
+/**
+ * Whether a node is the directory of the module: __dirname, import.meta.dirname, dirname(<its file>),
+ * fileURLToPath(new URL('.', <its URL>))
+ * @param node
+ */
+function isDirname(node) {
+    if (node?.type === 'Identifier')
+        return node.name === '__dirname';
+    if (isImportMeta(node, 'dirname'))
+        return true;
+    if (node?.type !== 'CallExpression')
+        return false;
+    const name = calleeName(node.callee);
+    if (name === 'dirname')
+        return isFilename(node.arguments[0]);
+    if (name !== 'fileURLToPath')
+        return false;
+    const url = node.arguments[0];
+    return url?.type === 'NewExpression' && calleeName(url.callee) === 'URL' && url.arguments[0]?.type === 'Literal' && ['.', './'].includes(url.arguments[0].value) && isFileURL(url.arguments[1]);
+}
+/**
+ * Whether a node is require('<module>') of one of the modules
+ * @param node
+ * @param modules
+ */
+function isRequireOf(node, modules) {
+    return node?.type === 'CallExpression' && node.callee.type === 'Identifier' && node.callee.name === 'require' && node.arguments[0]?.type === 'Literal' && modules.has(node.arguments[0].value);
+}
+/**
+ * The pieces of a string expression: its literal texts, the expressions known at run time only
+ * @param node
+ * @param source
+ */
+function partsOf(node, source) {
+    if (node?.type === 'Literal')
+        return typeof node.value === 'string' ? [{ text: node.value }] : undefined;
+    if (node?.type === 'TemplateLiteral') {
+        const parts = [];
+        node.quasis.forEach((quasi, index) => {
+            if (quasi.value.cooked)
+                parts.push({ text: quasi.value.cooked });
+            if (index < node.expressions.length)
+                parts.push({ expression: source.slice(node.expressions[index].start, node.expressions[index].end) });
+        });
+        return parts;
+    }
+    if (node?.type === 'BinaryExpression' && node.operator === '+') {
+        const left = partsOf(node.left, source);
+        const right = partsOf(node.right, source);
+        return left && right ? [...left, ...right] : undefined;
+    }
+    if (node?.type === 'SpreadElement')
+        return undefined;
+    return [{ expression: source.slice(node.start, node.end) }];
+}
+/**
+ * The operands of a chain of concatenations, from the first one
+ * @param node
+ */
+function operandsOf(node) {
+    return node?.type === 'BinaryExpression' && node.operator === '+' ? [...operandsOf(node.left), node.right] : [node];
+}
+/**
+ * The parts of the operands following a base
+ * @param operands
+ * @param source
+ */
+function partsOfOperands(operands, source) {
+    const parts = [];
+    for (const operand of operands) {
+        const pieces = partsOf(operand, source);
+        if (!pieces)
+            return undefined;
+        parts.push(...pieces);
+    }
+    return parts;
+}
+/**
+ * The text of parts known when the application is bundled, undefined when one is known at run time only
+ * @param parts
+ */
+function textOf(parts) {
+    return parts.every((part) => 'text' in part) ? parts.map((part) => part.text).join('') : undefined;
+}
+/**
+ * The path to a script an expression gives from its module, undefined when it gives none
+ * @param node
+ * @param source
+ * @param file the module
+ */
+function scriptPathOf(node, source, file) {
+    //new URL('./worker.js', import.meta.url), new URL('./worker.js', pathToFileURL(__filename))
+    if (node?.type === 'NewExpression' && calleeName(node.callee) === 'URL' && node.arguments.length === 2 && isFileURL(node.arguments[1])) {
+        const parts = partsOf(node.arguments[0], source);
+        const first = parts?.[0];
+        //A path relative to the module
+        if (!parts || !first || !('text' in first) || /^([a-z][a-z0-9+.-]*:|\/)/i.test(first.text))
+            return undefined;
+        return { kind: 'url', parts: parts };
+    }
+    if (node?.type === 'CallExpression') {
+        const name = calleeName(node.callee);
+        //path.join(__dirname, 'worker.js'), path.resolve(__dirname, 'workers', `${name}.js`)
+        if ((name === 'join' || name === 'resolve') && isDirname(node.arguments[0])) {
+            const parts = [];
+            for (const argument of node.arguments.slice(1)) {
+                const pieces = partsOf(argument, source);
+                if (!pieces)
+                    return undefined;
+                parts.push({ text: '/' }, ...pieces);
+            }
+            return { kind: 'path', parts: parts };
+        }
+        //require.resolve('./worker'), require.resolve(path.resolve(__dirname, '../lib/worker')): the extension of node found
+        if (name === 'resolve' && node.callee.type === 'MemberExpression' && node.callee.object.type === 'Identifier' && node.callee.object.name === 'require' && node.arguments.length === 1) {
+            const argument = node.arguments[0];
+            let request;
+            if (argument.type === 'Literal' && typeof argument.value === 'string' && /^\.\.?\//.test(argument.value))
+                request = argument.value;
+            const inner = request === undefined ? scriptPathOf(argument, source, file) : undefined;
+            const text = inner?.kind === 'path' ? textOf(inner.parts) : undefined;
+            if (text !== undefined)
+                request = path.join(inner.base ?? path.dirname(file), text);
+            if (request === undefined)
+                return undefined;
+            try {
+                const resolved = createRequire(file).resolve(request);
+                return { kind: 'path', parts: [{ text: path.basename(resolved) }], base: path.dirname(resolved) };
+            }
+            catch {
+                return undefined;
+            }
+        }
+    }
+    if (node?.type === 'BinaryExpression' && node.operator === '+') {
+        const [base, ...rest] = operandsOf(node);
+        //__dirname + '/worker.js'
+        if (isDirname(base)) {
+            const parts = partsOfOperands(rest, source);
+            return parts ? { kind: 'path', parts: parts } : undefined;
+        }
+        //import.meta.url + '/../entry/worker.js': the URL of the module, as a directory
+        if (isFileURL(base)) {
+            const parts = partsOfOperands(rest, source);
+            const first = parts?.[0];
+            return parts && first && 'text' in first && first.text.startsWith('/') ? { kind: 'url-text', parts: parts, base: file } : undefined;
+        }
+        return undefined;
+    }
+    //`${__dirname}/worker.js`
+    if (node?.type === 'TemplateLiteral' && node.expressions.length && !node.quasis[0].value.cooked && isDirname(node.expressions[0])) {
+        const parts = [];
+        node.quasis.forEach((quasi, index) => {
+            if (quasi.value.cooked)
+                parts.push({ text: quasi.value.cooked });
+            if (index > 0 && index < node.expressions.length)
+                parts.push({ expression: source.slice(node.expressions[index].start, node.expressions[index].end) });
+        });
+        return { kind: 'path', parts: parts };
+    }
+    return undefined;
+}
+/**
+ * Visit the nodes of a syntax tree, depth first: the children of a node are not visited when the visitor returns false
+ * @param node
+ * @param visit
+ */
+function walk(node, visit) {
+    if (!node || typeof node.type !== 'string')
+        return;
+    if (visit(node) === false)
+        return;
+    for (const key of Object.keys(node)) {
+        const value = node[key];
+        if (Array.isArray(value))
+            for (const child of value)
+                walk(child, visit);
+        else if (value && typeof value === 'object' && typeof value.type === 'string')
+            walk(value, visit);
+    }
+}
+/**
+ * A text in a template literal
+ * @param text
+ */
+function templateText(text) {
+    return text.replace(/[`\\]|\$\{/g, (matched) => `\\${matched}`);
+}
+/**
+ * The scripts an application runs on its own, by their paths, which the bundler does not follow: 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'))), in its modules and in the ones of its packages. A path to a script
+ * given from its module, wherever it is written, is found when the module is bundled: the script is bundled on its own
+ * into the native tree (WORKERS_DIRECTORY, the directories mirrored), and the expression rewritten to it. A path known at
+ * run time only in part (a template, a concatenation, an argument of path.join: `${name}.js`) gives every script of its
+ * directory its pattern matches, the expression of the part kept. The scripts of the workers of node (worker_threads)
+ * whose paths cannot be followed are warned of, in the modules of the application (the packages start workers from the
+ * paths their users give)
+ */
+export class WorkerCollector {
+    /**
+     * @param project The directory of the project: the scripts are named from it (as the modules the bundler gives, its
+     * real path)
+     */
+    constructor(project) {
+        /**
+         * The scripts: their paths in the native tree, and their files
+         */
+        this.scripts = new Map();
+        this.warnings = [];
+        this.project = realpathSync(project);
+    }
+    /**
+     * The key of a directory in the tree ("/" separated): its path from the project; outside of the project (the
+     * packages of a workspace, linked), its path from the node_modules holding it, else a hash of its path (the paths of
+     * the machine bundling it are not shipped)
+     * @param directory
+     */
+    keyOf(directory) {
+        const relative = path.relative(this.project, directory);
+        if (!relative)
+            return '_';
+        if (!relative.startsWith('..'))
+            return relative.split(path.sep).join('/');
+        const segments = directory.split(path.sep);
+        const modules = segments.indexOf('node_modules');
+        return modules >= 0 ? segments.slice(modules).join('/') : `_outside/${createHash('sha256').update(directory).digest('hex').slice(0, 16)}`;
+    }
+    /**
+     * The name of a script: its path from the project ("/" separated), or from the node_modules holding it outside of the
+     * project (the packages of a workspace)
+     * @param script
+     */
+    nameOf(script) {
+        const relative = path.relative(this.project, script);
+        const segments = script.split(path.sep);
+        const modules = segments.indexOf('node_modules');
+        return relative.startsWith('..') && modules >= 0 ? segments.slice(modules).join('/') : relative.split(path.sep).join('/');
+    }
+    /**
+     * The scripts a path gives: the file, or the ones its pattern matches; their directory and the parts of their paths
+     * from it
+     * @param found
+     * @param file the module
+     */
+    scriptsOf(found, file) {
+        //The directory: the texts before the first expression, up to their last separator
+        const firstExpression = found.parts.findIndex((part) => 'expression' in part);
+        const leading = firstExpression < 0 ? found.parts : found.parts.slice(0, firstExpression);
+        const prefix = leading.map((part) => part.text).join('');
+        const cut = prefix.lastIndexOf('/');
+        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)];
+        if (firstExpression < 0) {
+            const script = path.join(directory, prefix.slice(cut + 1));
+            return { directory: directory, rest: rest, files: SCRIPT.test(script) && existsSync(script) && statSync(script).isFile() ? [script] : [] };
+        }
+        //The pattern: an expression matches a part of a segment
+        const pattern = new RegExp(`^${rest.map((part) => 'text' in part ? part.text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') : '[^/]*').join('')}$`);
+        const depth = rest.map((part) => 'text' in part ? part.text : '').join('').split('/').length;
+        const files = [];
+        const search = (at, relative, level) => {
+            if (level > depth || !existsSync(at))
+                return;
+            for (const entry of readdirSync(at, { withFileTypes: true })) {
+                const name = relative ? `${relative}/${entry.name}` : entry.name;
+                if (entry.isDirectory() && entry.name !== 'node_modules')
+                    search(path.join(at, entry.name), name, level + 1);
+                else if (entry.isFile() && SCRIPT.test(entry.name) && pattern.test(name))
+                    files.push(path.join(at, entry.name));
+            }
+        };
+        search(directory, '', 1);
+        return { directory: directory, rest: rest, files: files.sort() };
+    }
+    /**
+     * Warn of a worker in a module of the application
+     * @param file
+     * @param line
+     * @param message
+     */
+    warn(file, line, message) {
+        if (file.split(path.sep).includes('node_modules'))
+            return;
+        this.warnings.push(`${path.relative(this.project, file)}:${line}: ${message}`);
+    }
+    /**
+     * Warn of the scripts bundled with the application and run on their own too: two copies of their modules
+     * @param bundled the files of the bundle of the application (their real paths)
+     */
+    warnBundled(bundled) {
+        for (const script of new Set(this.scripts.values())) {
+            if (!bundled.has(script) || script.split(path.sep).includes('node_modules'))
+                continue;
+            this.warnings.push(`${path.relative(this.project, script)}: is bundled with the application and run on its own by its path (a worker, a child process, a module loaded by its path): two copies of its module, their state and their classes apart — load it by its path only, or import it only`);
+        }
+    }
+    /**
+     * The source of a module with its paths to scripts rewritten to the scripts in the native tree; undefined when it
+     * gives none
+     * @param source
+     * @param file
+     */
+    transform(source, file) {
+        if (!/__dirname|__filename|import\.meta|require\.resolve|\bWorker\b/.test(source))
+            return undefined;
+        let program;
+        for (const sourceType of ['module', 'script']) {
+            try {
+                program = parse(source, { ecmaVersion: 'latest', sourceType: sourceType, locations: true, allowHashBang: true, allowReturnOutsideFunction: true, allowAwaitOutsideFunction: true, allowImportExportEverywhere: true });
+                break;
+            }
+            catch {
+                program = undefined;
+            }
+        }
+        if (!program)
+            return undefined;
+        //The values of the variables (const script = ...) and of the properties of the classes (workerPath = ..., this.workerPath
+        //= ...) declared once; the constructors of the workers of node and their modules (Worker, worker_threads_1)
+        const constants = new Map();
+        const members = new Map();
+        const constructors = new Set();
+        const namespaces = new Set();
+        const remember = (values, name, value) => values.set(name, values.has(name) ? null : value);
+        walk(program, (node) => {
+            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')
+                        constructors.add(specifier.local.name);
+                    else if (specifier.type !== 'ImportSpecifier')
+                        namespaces.add(specifier.local.name);
+                }
+            }
+            if (node.type === 'VariableDeclaration') {
+                for (const declarator of node.declarations) {
+                    const init = declarator.init?.type === 'CallExpression' && isRequireOf(declarator.init.arguments[0], WORKER_THREADS) ? declarator.init.arguments[0] : declarator.init;
+                    if (declarator.id.type === 'Identifier') {
+                        remember(constants, declarator.id.name, declarator.init);
+                        if (isRequireOf(init, WORKER_THREADS))
+                            namespaces.add(declarator.id.name);
+                        if (init?.type === 'MemberExpression' && isRequireOf(init.object, WORKER_THREADS) && calleeName(init) === 'Worker')
+                            constructors.add(declarator.id.name);
+                    }
+                    else if (declarator.id.type === 'ObjectPattern' && isRequireOf(init, WORKER_THREADS)) {
+                        for (const property of declarator.id.properties)
+                            if (property.key?.name === 'Worker' && property.value?.type === 'Identifier')
+                                constructors.add(property.value.name);
+                    }
+                }
+            }
+            if (node.type === 'PropertyDefinition' && !node.computed && node.key && node.value)
+                remember(members, node.key.name, node.value);
+            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 scripts, wherever they are written
+        const edits = [];
+        const followed = new Set();
+        walk(program, (node) => {
+            const found = scriptPathOf(node, source, file);
+            if (!found)
+                return true;
+            const { directory, rest, files } = this.scriptsOf(found, file);
+            //A path to another file (a directory, a data file, a file not found): left as it is
+            if (!files.length)
+                return true;
+            const key = this.keyOf(directory);
+            for (const script of files)
+                this.scripts.set(`${WORKERS_DIRECTORY}/${key}/${path.relative(directory, script).split(path.sep).join('/')}`, script);
+            const relative = `\`${rest.map((part) => 'text' in part ? templateText(part.text) : `\${${part.expression}}`).join('')}\``;
+            const text = found.kind === 'url' ? `new URL(${relative}, require.lakutataWorkerURL(${JSON.stringify(key)}))` :
+                found.kind === 'url-text' ? `(require.lakutataWorkerURL(${JSON.stringify(key)}) + ${relative})` :
+                    `require("node:path").join(require.lakutataWorker(${JSON.stringify(key)}), ${relative})`;
+            followed.add(node);
+            edits.push({ start: node.start, end: node.end, text: text });
+            return false;
+        });
+        //The workers of node whose scripts are not followed
+        walk(program, (node) => {
+            if (node.type !== 'NewExpression' || !node.arguments.length)
+                return;
+            const callee = node.callee;
+            const isWorker = callee.type === 'Identifier' ? constructors.has(callee.name) :
+                calleeName(callee) === 'Worker' && callee.type === 'MemberExpression' && ((callee.object.type === 'Identifier' && namespaces.has(callee.object.name)) || isRequireOf(callee.object, WORKER_THREADS));
+            if (!isWorker)
+                return;
+            //A worker running a source (eval: true)
+            const options = node.arguments[1];
+            if (options?.type === 'ObjectExpression' && options.properties.some((property) => property.key?.name === 'eval' && property.value?.value === true))
+                return;
+            const argument = node.arguments[0];
+            const value = argument.type === 'Identifier' && constants.get(argument.name) ? constants.get(argument.name) :
+                argument.type === 'MemberExpression' && argument.object.type === 'ThisExpression' && !argument.computed && members.get(argument.property.name) ? members.get(argument.property.name) : argument;
+            if (followed.has(value))
+                return;
+            //As written: the warnings name it
+            const written = source.slice(argument.start, argument.end);
+            const line = node.loc.start.line;
+            if (scriptPathOf(value, source, file))
+                return this.warn(file, line, `the script of the worker (${written}) is not found: a .js or .cjs file from the module, built before the bundle`);
+            if (value.type === 'Literal' && typeof value.value === 'string')
+                return this.warn(file, line, `the script of the worker (${value.value}) is a path from the current directory of the process, not the bundle: give it from the directory of the module, path.join(__dirname, ${JSON.stringify(value.value)}) or new URL(${JSON.stringify(value.value)}, import.meta.url)`);
+            this.warn(file, line, `the script of the worker cannot be followed (${written}): give its path from the directory of the module (path.join(__dirname, 'worker.js'), new URL('./worker.js', import.meta.url)), or ship it as a resource (lakutata.resources)`);
+        });
+        if (!edits.length)
+            return undefined;
+        let result = source;
+        for (const edit of edits.sort((a, b) => b.start - a.start))
+            result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+        return result;
+    }
+}

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

@@ -236,6 +236,7 @@ export async function buildElectronInstaller(project, manifest, config, options)
             outfile: path.join(application, 'main.cjs'),
             directories: { native: path.join(work, 'main.native'), resources: path.join(work, 'main.resources') }
         });
+        warnings.push(...bundle.warnings);
         const maintainer = platform === 'linux' ? packageMaintainer(author, name, warnings) : author ?? name;
         //The packages of fpm need a homepage
         let homepage = config.homepage ?? (typeof manifest.homepage === 'string' ? manifest.homepage : undefined);
@@ -354,6 +355,7 @@ export async function buildElectronInstaller(project, manifest, config, options)
             platform: `${process.platform}-${process.arch}`,
             size: bundle.size,
             native: bundle.native?.modules ?? [],
+            workers: bundle.workers,
             resources: bundle.resources,
             runtime: `Electron v${electronVersion}`,
             warnings: []

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

@@ -70,6 +70,14 @@ export type BundleResult = {
      */
     resources: string[];
     resourcesDirectory?: string;
+    /**
+     * The scripts of the workers of the application (their files, from the project), bundled into the native tree
+     */
+    workers: string[];
+    /**
+     * What the bundle cannot follow: the scripts of the workers given by paths known at run time only
+     */
+    warnings: string[];
 };
 /**
  * The name of the program of a package: its first bin, or the name of the package without its scope

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

@@ -23,6 +23,10 @@ export type ExecutableResult = {
      * The packages of native addons embedded, extracted at the first run, or next to the executable
      */
     native: string[];
+    /**
+     * The scripts of the workers of the application (their files, from the project), with the native addons
+     */
+    workers: string[];
     /**
      * The resources of the application (their paths in the resources)
      */

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

@@ -1,11 +1,13 @@
 import type { Plugin, PluginBuild } from 'esbuild';
 /**
- * A file of the native tree: its path in the tree ("/" separated) and where it is read
+ * A file of the native tree: its path in the tree ("/" separated) and where it is read, or its content (a script of a
+ * worker, bundled)
  */
 export type NativeFile = {
     path: string;
     source: string;
     mode: number;
+    content?: Buffer;
 };
 /**
  * A link of the native tree to a directory of the tree, as the links of the node_modules (pnpm, the workspaces)
@@ -136,8 +138,10 @@ export declare class NativeCollector {
     }): Promise<string | undefined>;
     /**
      * The plugin of the bundle: the native packages are external, the addons of the application are loaded from the tree
+     * @param transforms the transformations of the sources of the modules (the paths of the workers), giving their new
+     * source or undefined
      */
-    plugin(): Plugin;
+    plugin(transforms?: ((source: string, file: string) => string | undefined)[]): Plugin;
     /**
      * The packages a native package loads at run time: the JavaScript it requires (followed by esbuild), the packages of
      * shared libraries it depends on (the libraries linked with its addons), and the native packages it loads

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

@@ -24,6 +24,11 @@ export type NativeRuntimeConfig = {
      * in its .lakutata/resources), or a directory next to the bundle
      */
     embedded: boolean;
+    /**
+     * The tree from the directory of the bundle, for the scripts of the workers, which run from the tree (its
+     * .lakutata/workers): the tree is not looked for (nor extracted)
+     */
+    root?: string;
 };
 /**
  * The global symbol of the packed applications giving the directory of their resources (resourcesPath of lakutata)

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

@@ -0,0 +1,96 @@
+/**
+ * The directory of the scripts run on their own in the native tree
+ */
+export declare const WORKERS_DIRECTORY: string;
+/**
+ * A piece of a path to a script: a text, or an expression known at run time only (the source of the expression)
+ */
+type Part = {
+    text: string;
+} | {
+    expression: string;
+};
+/**
+ * A path to a script given from a module: from its directory (path.join, path.resolve, a concatenation or a template of
+ * __dirname), a URL relative to its file (new URL('./x.js', import.meta.url)), a URL text from its file
+ * (import.meta.url + '/../x.js'), or a file resolved when the application is bundled (require.resolve)
+ */
+type ScriptPath = {
+    /**
+     * What the expression gives: a path, a URL, the text of a URL
+     */
+    kind: 'path' | 'url' | 'url-text';
+    parts: Part[];
+    /**
+     * The path the parts are joined to, the directory of the module by default
+     */
+    base?: string;
+};
+/**
+ * The scripts an application runs on its own, by their paths, which the bundler does not follow: 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'))), in its modules and in the ones of its packages. A path to a script
+ * given from its module, wherever it is written, is found when the module is bundled: the script is bundled on its own
+ * into the native tree (WORKERS_DIRECTORY, the directories mirrored), and the expression rewritten to it. A path known at
+ * run time only in part (a template, a concatenation, an argument of path.join: `${name}.js`) gives every script of its
+ * directory its pattern matches, the expression of the part kept. The scripts of the workers of node (worker_threads)
+ * whose paths cannot be followed are warned of, in the modules of the application (the packages start workers from the
+ * paths their users give)
+ */
+export declare class WorkerCollector {
+    /**
+     * The scripts: their paths in the native tree, and their files
+     */
+    readonly scripts: Map<string, string>;
+    readonly warnings: string[];
+    protected readonly project: string;
+    /**
+     * @param project The directory of the project: the scripts are named from it (as the modules the bundler gives, its
+     * real path)
+     */
+    constructor(project: string);
+    /**
+     * The key of a directory in the tree ("/" separated): its path from the project; outside of the project (the
+     * packages of a workspace, linked), its path from the node_modules holding it, else a hash of its path (the paths of
+     * the machine bundling it are not shipped)
+     * @param directory
+     */
+    protected keyOf(directory: string): string;
+    /**
+     * The name of a script: its path from the project ("/" separated), or from the node_modules holding it outside of the
+     * project (the packages of a workspace)
+     * @param script
+     */
+    nameOf(script: string): string;
+    /**
+     * The scripts a path gives: the file, or the ones its pattern matches; their directory and the parts of their paths
+     * from it
+     * @param found
+     * @param file the module
+     */
+    protected scriptsOf(found: ScriptPath, file: string): {
+        directory: string;
+        rest: Part[];
+        files: string[];
+    };
+    /**
+     * Warn of a worker in a module of the application
+     * @param file
+     * @param line
+     * @param message
+     */
+    protected warn(file: string, line: number, message: string): void;
+    /**
+     * Warn of the scripts bundled with the application and run on their own too: two copies of their modules
+     * @param bundled the files of the bundle of the application (their real paths)
+     */
+    warnBundled(bundled: Set<string>): void;
+    /**
+     * The source of a module with its paths to scripts rewritten to the scripts in the native tree; undefined when it
+     * gives none
+     * @param source
+     * @param file
+     */
+    transform(source: string, file: string): string | undefined;
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lakutata/builder",
-  "version": "3.0.0-beta.3",
+  "version": "3.0.0-beta.4",
   "description": "The builder of the applications of the lakutata framework: their bundles, their executables (Node.js, Bun) with their native addons and their resources.",
   "type": "module",
   "main": "./dist/esm/index.js",
@@ -23,6 +23,7 @@
     "test:installer:windows": "npm run compile && node --test dist/esm/tests/InstallerWindows.spec.js"
   },
   "dependencies": {
+    "acorn": "^8.19.0",
     "esbuild": "^0.28.2",
     "postject": "^1.0.0-alpha.6",
     "resedit": "^1.7.2"
@@ -47,5 +48,10 @@
     "*.md",
     "LICENSE",
     "package.json"
-  ]
+  ],
+  "devDependencies": {
+    "piscina": "^5.3.2",
+    "tinypool": "^2.2.0",
+    "workerpool": "^10.0.3"
+  }
 }