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

package/README.md

@@ -17,9 +17,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,
-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);
+with the files the application reads by their paths, which the bundler does not follow (the scripts it runs on their
+own: the workers, the pools of workers, `fork()`, `require(path.join(__dirname, 'x.js'))`, bundled; its data files and
+directories, copied: the paths given from their modules are found and rewritten; what cannot be shipped is 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,9 +1,9 @@
-import { existsSync, readdirSync, realpathSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync, 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';
+import { FILES_DIRECTORY, FileCollector } from './Files.js';
 /**
  * The name of the program of a package: its first bin, or the name of the package without its scope
  * @param manifest
@@ -58,6 +58,18 @@ export function resourceFiles(project, manifest) {
     }
     return { declared: declarations.map(({ to }) => to), files: files };
 }
+/**
+ * A package.json copied into the tree, its type CommonJS; undefined when it is not JSON (copied as it is)
+ * @param file
+ */
+function commonJSManifest(file) {
+    try {
+        return Buffer.from(`${JSON.stringify({ ...JSON.parse(readFileSync(file, 'utf8')), type: 'commonjs' }, null, 2)}\n`);
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * The code with a code before it, after its hashbang
  * @param code
@@ -86,7 +98,7 @@ export async function bundleProject(options) {
         throw new Error(`The entry ${path.relative(process.cwd(), entry) || entry} does not exist: build the project first`);
     const outfile = path.resolve(project, options.outfile ?? path.join('dist', `${name}.cjs`));
     const collector = new NativeCollector(project, options.runtime);
-    const workers = new WorkerCollector(project);
+    const files = new FileCollector(project);
     //esbuild is loaded by the commands which need it
     const { build } = await import('esbuild');
     //The application, and each script of its workers (the bundler does not follow new Worker()): their native packages
@@ -113,7 +125,7 @@ export async function bundleProject(options) {
                 //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)])],
+            plugins: [collector.plugin([(source, file) => files.transform(source, file)])],
             logLevel: 'silent'
         }).catch((error) => {
             const messages = (error.errors ?? []).map(({ text, location }) => location ? `${location.file}:${location.line}: ${text}` : text);
@@ -135,34 +147,38 @@ export async function bundleProject(options) {
     const resourcesDirectory = path.resolve(path.dirname(outfile), options.directories?.resources ?? `${base}.resources`);
     //The scripts of the workers, until the ones they start are bundled too
     const scripts = new Map();
-    for (let pending = [...workers.scripts]; pending.length; pending = [...workers.scripts].filter(([at]) => !scripts.has(at))) {
+    for (let pending = [...files.scripts]; pending.length; pending = [...files.scripts].filter(([at]) => !scripts.has(at))) {
         for (const [at, script] of pending)
             scripts.set(at, (await bundle(script, path.join(nativeDirectory, ...at.split('/')))).code);
     }
-    workers.warnBundled(application.inputs);
+    files.warnBundled(application.inputs);
     const embedded = options.native === 'embedded';
     let native = await collector.collect();
     const resources = resourceFiles(project, manifest);
-    if (scripts.size) {
+    if (scripts.size || files.files.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') }];
+        const tree = [{ path: `${FILES_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)) });
+            tree.push({ path: at, source: files.scripts.get(at), mode: 0o644, content: Buffer.from(prepend(script, banner)) });
         }
-        const all = [...native?.files ?? [], ...files];
+        //The other files the application reads by their paths, as they are; a package.json read by its package (its
+        //version) is of the CommonJS scripts of the tree next to it (its type would make them ES modules)
+        for (const [at, data] of files.files)
+            tree.push({ path: at, source: data, mode: statSync(data).mode & 0o777, content: path.basename(data) === 'package.json' ? commonJSManifest(data) : undefined });
+        const all = [...native?.files ?? [], ...tree];
         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
     if (embedded && resources.files.length) {
-        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 ?? []) };
+        const embeddedFiles = [...native?.files ?? [], ...resources.files.map((file) => ({ ...file, path: `${EMBEDDED_RESOURCES}/${file.path}` }))];
+        native = { modules: native?.modules ?? [], files: embeddedFiles, links: native?.links ?? [], hash: hashNativeTree(embeddedFiles, native?.links ?? []) };
     }
     if (native && embedded) {
         //An executable runs the scripts of its tree it is started for (fork()) instead of the application
@@ -198,7 +214,8 @@ export async function bundleProject(options) {
         nativeDirectory: native && !embedded ? nativeDirectory : undefined,
         resources: resources.declared,
         resourcesDirectory: resources.files.length && !embedded ? resourcesDirectory : undefined,
-        workers: [...new Set([...scripts.keys()].map((at) => workers.nameOf(workers.scripts.get(at))))].sort(),
-        warnings: workers.warnings
+        workers: [...new Set([...scripts.keys()].map((at) => files.nameOf(files.scripts.get(at))))].sort(),
+        files: [...files.roots].filter((root) => !files.scriptPaths().has(root)).map((root) => files.nameOf(root)).sort(),
+        warnings: files.warnings
     };
 }

package/dist/esm/lib/Executable.js

@@ -210,6 +210,7 @@ export async function buildExecutable(options) {
             size: (await stat(file)).size,
             native: bundle.native?.modules ?? [],
             workers: bundle.workers,
+            files: bundle.files,
             resources: bundle.resources,
             directory: directory ? target : undefined,
             runtime: runtime,

package/dist/esm/lib/{Workers.js → Files.js}

@@ -4,13 +4,40 @@ 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
+ * The directory of the files the application reads by their paths in the native tree: the scripts it runs on their own
+ * (bundled), the other files and the directories of data (copied), their directories as in the project
  */
-export const WORKERS_DIRECTORY = '.lakutata/workers';
+export const FILES_DIRECTORY = '.lakutata/files';
 /**
  * The scripts run on their own: the CommonJS scripts, which they are bundled as
  */
 const SCRIPT = /\.c?js$/;
+/**
+ * The code a directory of data must not hold: the scripts, which need their packages, and the packages
+ */
+const CODE = /\.(c|m)?js$|^package\.json$|^node_modules$/;
+/**
+ * The files of a directory, deep
+ * @param directory
+ */
+function filesOf(directory) {
+    const files = [];
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+        const at = path.join(directory, entry.name);
+        if (entry.isDirectory())
+            files.push(...filesOf(at));
+        else if (entry.isFile())
+            files.push(at);
+    }
+    return files;
+}
+/**
+ * Whether a directory holds code: scripts, packages
+ * @param directory
+ */
+function holdsCode(directory) {
+    return readdirSync(directory, { withFileTypes: true }).some((entry) => CODE.test(entry.name) || (entry.isDirectory() && holdsCode(path.join(directory, entry.name))));
+}
 /**
  * The modules of the worker threads
  */
@@ -254,13 +281,13 @@ function templateText(text) {
  * 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
+ * into the native tree (FILES_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 {
+export class FileCollector {
     /**
      * @param project The directory of the project: the scripts are named from it (as the modules the bundler gives, its
      * real path)
@@ -270,6 +297,14 @@ export class WorkerCollector {
          * The scripts: their paths in the native tree, and their files
          */
         this.scripts = new Map();
+        /**
+         * The other files: their paths in the native tree, and their files
+         */
+        this.files = new Map();
+        /**
+         * The files and the directories of data the paths name
+         */
+        this.roots = new Set();
         this.warnings = [];
         this.project = realpathSync(project);
     }
@@ -281,14 +316,18 @@ export class WorkerCollector {
      */
     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 files of the scripts
+     */
+    scriptPaths() {
+        return new Set(this.scripts.values());
+    }
     /**
      * 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)
@@ -301,12 +340,12 @@ export class WorkerCollector {
         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
+     * What a path gives: the file or the directory, or the ones its pattern matches (an expression matches a part of a
+     * name); the directory they are named from, the parts of their paths from it
      * @param found
      * @param file the module
      */
-    scriptsOf(found, file) {
+    targetsOf(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);
@@ -314,27 +353,55 @@ export class WorkerCollector {
         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)];
+        const targets = { directory: directory, rest: rest, scripts: [], files: [], roots: [] };
+        //A file: bundled when it is a script, copied otherwise; a directory of data: its files copied
+        const take = (at, strict) => {
+            const stats = statSync(at);
+            if (stats.isFile()) {
+                (SCRIPT.test(at) ? targets.scripts : targets.files).push(at);
+                targets.roots.push(at);
+            }
+            else if (stats.isDirectory()) {
+                //A directory holding the module (the application, its packages), or holding code: not shipped
+                if ((file + path.sep).startsWith(at + path.sep)) {
+                    if (strict)
+                        targets.refused = 'ancestor';
+                }
+                else if (holdsCode(at)) {
+                    if (strict)
+                        targets.refused = 'code';
+                }
+                else {
+                    targets.files.push(...filesOf(at));
+                    targets.roots.push(at);
+                }
+            }
+        };
         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] : [] };
+            const target = path.join(directory, prefix.slice(cut + 1));
+            if (existsSync(target))
+                take(target, true);
+            return targets;
         }
-        //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')
+                if (entry.name === 'node_modules')
+                    continue;
+                if (pattern.test(name) && (entry.isFile() || entry.isDirectory()))
+                    take(path.join(at, entry.name), false);
+                else if (entry.isDirectory())
                     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() };
+        targets.scripts.sort();
+        targets.files.sort();
+        return targets;
     }
     /**
      * Warn of a worker in a module of the application
@@ -417,24 +484,38 @@ export class WorkerCollector {
             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
+        //The paths to files, 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)
+            const targets = this.targetsOf(found, file);
+            const written = source.slice(node.start, node.end);
+            if (targets.refused === 'ancestor') {
+                this.warn(file, node.loc.start.line, `the path (${written}) is a directory holding the module, which is not where it is once bundled (the bundle is elsewhere, the code and the packages of the application are not shipped): declare the files it reads as resources (lakutata.resources) and read them from resourcesPath()`);
+                return false;
+            }
+            if (targets.refused === 'code') {
+                this.warn(file, node.loc.start.line, `the path (${written}) is a directory of scripts or of packages, which need their packages at run time: it is not shipped with the bundle — import its scripts, or declare it as a resource (lakutata.resources) with what it loads`);
+                return false;
+            }
+            //A path to nothing yet (a directory the application creates): left as it is
+            if (!targets.scripts.length && !targets.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})`;
+            const key = this.keyOf(targets.directory);
+            const at = (target) => [FILES_DIRECTORY, key, path.relative(targets.directory, target).split(path.sep).join('/')].filter(Boolean).join('/');
+            for (const script of targets.scripts)
+                this.scripts.set(at(script), script);
+            for (const data of targets.files)
+                this.files.set(at(data), data);
+            for (const root of targets.roots)
+                this.roots.add(root);
+            const relative = `\`${targets.rest.map((part) => 'text' in part ? templateText(part.text) : `\${${part.expression}}`).join('')}\``;
+            const text = found.kind === 'url' ? `new URL(${relative}, require.lakutataFilesURL(${JSON.stringify(key)}))` :
+                found.kind === 'url-text' ? `(require.lakutataFilesURL(${JSON.stringify(key)}) + ${relative})` :
+                    `require("node:path").join(require.lakutataFiles(${JSON.stringify(key)}), ${relative})`;
             followed.add(node);
             edits.push({ start: node.start, end: node.end, text: text });
             return false;

package/dist/esm/lib/Native.js

@@ -11,6 +11,16 @@ import { gzipSync } from 'node:zlib';
 function contentOf(file) {
     return file.content ?? readFileSync(file.source);
 }
+/**
+ * Whether a package is the framework, or built on it (it depends on it)
+ * @param manifest
+ */
+function sharesFramework(manifest) {
+    const name = String(manifest.name ?? '');
+    if (name === 'lakutata' || name.startsWith('@lakutata/'))
+        return true;
+    return ['dependencies', 'peerDependencies', 'optionalDependencies'].some((field) => !!manifest[field] && ('lakutata' in manifest[field] || '@lakutata/core' in manifest[field]));
+}
 /**
  * The shared libraries: the addons, and the libraries they are linked with (sharp and libvips)
  */
@@ -221,7 +231,13 @@ export class NativeCollector {
         const info = this.package(root);
         if (!info)
             return false;
-        return info.addons || this.dependencies(root).some(({ root: dependency }) => !!this.package(dependency)?.addons);
+        if (info.addons)
+            return true;
+        //A package of the framework, or built on it, shares it with the application: bundled with it (one copy of its
+        //classes, its container), its native dependencies loaded by their names, which the bundler follows
+        if (sharesFramework(info.manifest))
+            return false;
+        return this.dependencies(root).some(({ root: dependency }) => !!this.package(dependency)?.addons);
     }
     /**
      * Resolve an import as esbuild does
@@ -232,6 +248,18 @@ export class NativeCollector {
         const result = await build.resolve(args.path, { kind: args.kind, resolveDir: args.resolveDir, importer: args.importer, pluginData: { [RESOLVING]: true } });
         return result.errors.length || result.external || !result.path ? undefined : realpathSync(result.path);
     }
+    /**
+     * Whether a package is an optional dependency of the package of a module: an optional peer dependency
+     * (peerDependenciesMeta) or an optional dependency
+     * @param specifier
+     * @param importer
+     */
+    isOptionalOf(specifier, importer) {
+        const name = specifierPackage(specifier);
+        const root = name && importer ? this.packageRoot(existsSync(importer) ? realpathSync(importer) : importer) : undefined;
+        const manifest = root ? this.package(root)?.manifest : undefined;
+        return !!name && !!manifest && (!!manifest.peerDependenciesMeta?.[name]?.optional || !!manifest.optionalDependencies?.[name]);
+    }
     /**
      * 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
@@ -245,8 +273,10 @@ export class NativeCollector {
                     if (args.pluginData?.[RESOLVING] || isBuiltin(args.path) || args.kind === 'entry-point')
                         return undefined;
                     const file = await this.resolve(build, args);
+                    //An optional dependency of the package importing it, not installed: left out, it throws when it is
+                    //loaded at run time, as without the bundle (the drivers of the stores the application does not use)
                     if (!file)
-                        return undefined;
+                        return this.isOptionalOf(args.path, args.importer) ? { path: args.path, external: true } : undefined;
                     const root = this.packageRoot(file);
                     if (this.isNative(root)) {
                         const name = specifierPackage(args.path);

package/dist/esm/lib/NativeRuntime.js

@@ -137,16 +137,16 @@ 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;
+    //The files the application reads by their paths, in the tree (FILES_DIRECTORY): the directory of a key, its URL
+    const files = (key) => path.join(locate(), '.lakutata', 'files', ...key.split('/'));
+    require.lakutataFiles = files;
+    require.lakutataFilesURL = (key) => nodeRequire('node:url').pathToFileURL(files(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 scripts = path.join(locate(), '.lakutata', 'files') + path.sep;
         const at = [1, 2].find((index) => !!process.argv[index] && path.resolve(process.argv[index]).startsWith(scripts)) ?? -1;
         if (at < 0)
             return false;

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

@@ -356,6 +356,7 @@ export async function buildElectronInstaller(project, manifest, config, options)
             size: bundle.size,
             native: bundle.native?.modules ?? [],
             workers: bundle.workers,
+            files: bundle.files,
             resources: bundle.resources,
             runtime: `Electron v${electronVersion}`,
             warnings: []

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

@@ -75,7 +75,13 @@ export type BundleResult = {
      */
     workers: string[];
     /**
-     * What the bundle cannot follow: the scripts of the workers given by paths known at run time only
+     * The other files and the directories of data the application reads by their paths (from the project), copied into
+     * the native tree
+     */
+    files: string[];
+    /**
+     * What the bundle cannot follow: the scripts of the workers given by paths known at run time only, the directories
+     * which cannot be shipped (holding the modules, holding code), the scripts bundled twice
      */
     warnings: string[];
 };

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

@@ -27,6 +27,11 @@ export type ExecutableResult = {
      * The scripts of the workers of the application (their files, from the project), with the native addons
      */
     workers: string[];
+    /**
+     * The other files and the directories of data the application reads by their paths (from the project), with the
+     * native addons
+     */
+    files: string[];
     /**
      * The resources of the application (their paths in the resources)
      */

package/dist/types/lib/{Workers.d.ts → Files.d.ts}

@@ -1,7 +1,8 @@
 /**
- * The directory of the scripts run on their own in the native tree
+ * The directory of the files the application reads by their paths in the native tree: the scripts it runs on their own
+ * (bundled), the other files and the directories of data (copied), their directories as in the project
  */
-export declare const WORKERS_DIRECTORY: string;
+export declare const FILES_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)
  */
@@ -26,22 +27,45 @@ type ScriptPath = {
      */
     base?: string;
 };
+/**
+ * What a path from a module gives: the directory of its pattern, the parts from it, the scripts to bundle and the files
+ * to copy (the files of its directories of data), or why it cannot be shipped
+ */
+type Targets = {
+    directory: string;
+    rest: Part[];
+    scripts: string[];
+    files: string[];
+    /**
+     * The files and the directories it names (the roots of the files)
+     */
+    roots: string[];
+    refused?: 'ancestor' | 'code';
+};
 /**
  * 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
+ * into the native tree (FILES_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 {
+export declare class FileCollector {
     /**
      * The scripts: their paths in the native tree, and their files
      */
     readonly scripts: Map<string, string>;
+    /**
+     * The other files: their paths in the native tree, and their files
+     */
+    readonly files: Map<string, string>;
+    /**
+     * The files and the directories of data the paths name
+     */
+    readonly roots: Set<string>;
     readonly warnings: string[];
     protected readonly project: string;
     /**
@@ -56,6 +80,10 @@ export declare class WorkerCollector {
      * @param directory
      */
     protected keyOf(directory: string): string;
+    /**
+     * The files of the scripts
+     */
+    scriptPaths(): Set<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)
@@ -63,16 +91,12 @@ export declare class WorkerCollector {
      */
     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
+     * What a path gives: the file or the directory, or the ones its pattern matches (an expression matches a part of a
+     * name); the directory they are named from, 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[];
-    };
+    protected targetsOf(found: ScriptPath, file: string): Targets;
     /**
      * Warn of a worker in a module of the application
      * @param file

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

@@ -136,6 +136,13 @@ export declare class NativeCollector {
         resolveDir: string;
         importer: string;
     }): Promise<string | undefined>;
+    /**
+     * Whether a package is an optional dependency of the package of a module: an optional peer dependency
+     * (peerDependenciesMeta) or an optional dependency
+     * @param specifier
+     * @param importer
+     */
+    protected isOptionalOf(specifier: string, importer: string): boolean;
     /**
      * 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lakutata/builder",
-  "version": "3.0.0-beta.4",
+  "version": "3.0.0-beta.6",
   "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",