@jointhedots/gear 1.1.10 → 1.1.12

package/esm/builder/build-app-bundle.js

@@ -19,15 +19,16 @@ export function create_bundle_target(opts) {
     const lib = library;
     const target = new BuildTarget(bundle.id, storage, lib.workspace, opts.devmode == true, opts.watch == true, opts.clean == true);
     const manifs = create_manifests(lib, bundle, opts.version);
+    // Prepare esm setup
+    target.esmodules.set_root(lib.path);
     // Add bundle package.json
     target.assets.add_static_json("package.json", manifs.package);
     // Add bundle types.d.ts
     target.tasks.push(new TypescriptDefinitionTask(target, lib));
     // Add bundle exporteds
-    const { esmodules } = target;
     for (const exp_id in manifs.entries) {
         const exp = manifs.entries[exp_id];
-        esmodules.add_entry(exp.basename, exp.source);
+        target.esmodules.add_entry(exp.basename, exp.source);
     }
     // Add bundle content
     if (bundle) {

package/esm/builder/build-app-host.js

@@ -12,6 +12,8 @@ function create_application_composable_target(opts) {
     const bundle = lib.bundle;
     const ws = lib.workspace;
     const target = new BuildTarget(name, opts.storage, ws, opts.devmode == true, opts.watch == true, opts.clean == true);
+    // Prepare esm setup
+    target.esmodules.set_root(lib.path);
     // Generate hotreload assets
     const html_injects = [];
     if (opts.devserver) {

package/esm/builder/build-application.js

@@ -36,6 +36,8 @@ export function create_application_monolith_target(opts) {
     const target = new BuildTarget(name, opts.storage, ws, opts.devmode == true, opts.watch == true, opts.clean == true);
     const libs = collect_app_libraries(app);
     target.log.info(`+ 🧭 app-library-graph: ${libs.map(lib => `${lib.name}@${lib.descriptor.version}`).join(", ")}`);
+    // Prepare esm setup
+    target.esmodules.set_root(lib.path);
     // Generate hotreload assets
     const html_injects = [];
     if (opts.devserver) {

package/esm/builder/build-library.js

@@ -9,11 +9,12 @@ export function create_library_target(opts) {
     const lib = opts.library;
     const target = new BuildTarget(lib.name, opts.storage, lib.workspace, opts.devmode == true, opts.watch == true, opts.clean == true);
     const manifs = create_manifests(lib, lib.bundle, opts.version);
+    // Prepare esm setup
+    target.esmodules.set_root(lib.path);
     // Add bundle exporteds
-    const { esmodules } = target;
     for (const exp_id in manifs.entries) {
         const exp = manifs.entries[exp_id];
-        esmodules.add_entry(exp.basename, exp.source);
+        target.esmodules.add_entry(exp.basename, exp.source);
     }
     // Add library types.d.ts
     target.tasks.push(new TypescriptDefinitionTask(target, lib));

package/esm/builder/build-target.js

@@ -87,6 +87,10 @@ export class ESModulesTask extends BuildTask {
     context = null;
     transaction = null;
     polyfilled = true;
+    rootPath = null;
+    set_root(path) {
+        this.rootPath = path;
+    }
     add_entry(name, path) {
         this.entries[name] = path;
         this.imports[path] = name;
@@ -194,17 +198,28 @@ export class BuildTarget {
         }
         this.components.set(id, manifest);
     }
+    async chrona(task) {
+        const name = task.constructor.name;
+        const start = Date.now();
+        await task.execute();
+        const elapsed = (Date.now() - start) / 1000;
+        this.log.info(`⏱ ${name} completed in ${elapsed.toFixed(2)}s`);
+    }
     async build() {
+        const buildStartTime = Date.now();
         if (this.clean)
             this.storage.clean();
         // Make assets
-        await this.assets.execute();
+        await this.chrona(this.assets);
         // Make generic tasks
         for (const task of this.tasks) {
-            await task.execute();
+            await this.chrona(task);
         }
         // Make esmodules
-        await this.esmodules.execute();
+        await this.chrona(this.esmodules);
+        // Trace time
+        const buildTime = (Date.now() - buildStartTime) / 1000;
+        this.log.info(`Build completed in ${buildTime.toFixed(2)}s`);
         if (this.watch) {
             await new Promise((resolve) => {
                 process.on('SIGQUIT', () => resolve(null));

package/esm/builder/esbuild-plugins.js

@@ -9,6 +9,17 @@ import { ESModulesTask } from "./build-target.js";
 import { PackageRootDir } from "../utils/file.js";
 import { Library } from "../model/workspace.js";
 const VirtualOutDir = Path.normalize('X:/');
+function getEsbuildLogLevel(mode) {
+    switch (mode) {
+        case "verbose":
+            return "debug";
+        case "debug":
+            return "info";
+        case "normal":
+        default:
+            return "silent";
+    }
+}
 export async function create_esbuild_context(task, devmode) {
     const ws = task.target.workspace;
     // Define modules mapping - using @jspm/core polyfills (same as Vite)
@@ -40,6 +51,7 @@ export async function create_esbuild_context(task, devmode) {
         }
         return result;
     }
+    const tsconfig = new TSConfig(task.rootPath, ws.path);
     const modules_mapping = {
         task,
         routeds: {
@@ -74,13 +86,14 @@ export async function create_esbuild_context(task, devmode) {
         format: 'esm',
         target: 'es2022',
         platform: "browser",
+        tsconfig: tsconfig.configFile ?? undefined,
         sourcemap: devmode ? "linked" : false,
         minify: devmode ? false : true,
         bundle: true,
         splitting: true,
         treeShaking: true,
         write: false,
-        logLevel: process.env.ESBUILD_LOG_LEVEL || 'silent',
+        logLevel: getEsbuildLogLevel(ws.logger.mode),
         chunkNames: "chunk.[hash]",
         jsx: "automatic",
         jsxImportSource: "react",
@@ -94,8 +107,8 @@ export async function create_esbuild_context(task, devmode) {
             ...workspace_constants,
         },
         plugins: [
+            ESModuleResolverPlugin(modules_mapping, tsconfig),
             ...task.plugins,
-            ESModuleResolverPlugin(modules_mapping),
             StyleSheetPlugin(task),
             StoragePlugin(task),
         ],
@@ -245,11 +258,10 @@ export function StoragePlugin(task) {
     return {
         name: "dipatch-files",
         setup: (build) => {
-            var buildStartTime = 0;
+            let buildStartTime = 0;
             build.onStart(() => {
                 task.log.clear();
-                task.log.info("Build started...");
-                buildStartTime = performance.now();
+                buildStartTime = Date.now();
             });
             build.onEnd(async (result) => {
                 if (result.errors.length > 0) {
@@ -262,7 +274,7 @@ export function StoragePlugin(task) {
                     task.log.warn(warning);
                 }
                 if (result.outputFiles) {
-                    const storeStart = performance.now();
+                    const storeStart = Date.now();
                     const tx = task.target.edit();
                     for (const file of result.outputFiles) {
                         if (file.path.startsWith(VirtualOutDir)) {
@@ -275,9 +287,9 @@ export function StoragePlugin(task) {
                         }
                     }
                     task.target.store();
-                    const storeTime = (performance.now() - storeStart) / 1000;
-                    const buildTime = (performance.now() - buildStartTime) / 1000;
-                    task.log.info(`Build completed with ${result.outputFiles.length} file(s) in ${buildTime.toFixed(2)}s (store: ${storeTime.toFixed(2)}s)`);
+                    const storeTime = (Date.now() - storeStart) / 1000;
+                    const buildTime = (Date.now() - buildStartTime) / 1000;
+                    task.log.info(`Build ES modules in ${result.outputFiles.length} file(s) (compile: ${buildTime.toFixed(2)}s, store: ${storeTime.toFixed(2)}s)`);
                 }
                 return null;
             });
@@ -389,7 +401,7 @@ export function DependencyDeduplicationPlugin(libraries, rootNodeModules, log) {
                     const is = isSingletonPackage(result.path, pkg);
                     singletonCache.set(pkg, is);
                     if (is)
-                        log.info(`[dedup] singleton: ${pkg}`);
+                        log.debug(`[dedup] singleton: ${pkg}`);
                 }
                 // Singleton → force root resolution
                 if (singletonCache.get(pkg)) {
@@ -411,7 +423,65 @@ export function DependencyDeduplicationPlugin(libraries, rootNodeModules, log) {
         }
     };
 }
-export function ESModuleResolverPlugin(opts) {
+/**
+ * Parses tsconfig.json compilerOptions (paths + baseUrl) and exposes resolved alias patterns.
+ * Looks for tsconfig.json in libraryPath first, then workspacePath as fallback.
+ */
+export class TSConfig {
+    baseUrl = null;
+    patterns = [];
+    configFile = null;
+    configData = null;
+    constructor(libraryPath, workspacePath) {
+        const tsconfigFile = [libraryPath, workspacePath]
+            .filter(Boolean)
+            .map(dir => Path.join(dir, 'tsconfig.json'))
+            .find(f => Fs.existsSync(f));
+        if (!tsconfigFile)
+            return;
+        try {
+            const raw = Fs.readFileSync(tsconfigFile, 'utf-8');
+            const cleaned = raw.replace(/^\s*\/\/.*$/gm, '').replace(/,\s*([}\]])/g, '$1');
+            const tsconfig = JSON.parse(cleaned);
+            const opts = tsconfig.compilerOptions;
+            if (!opts?.paths)
+                return;
+            this.configData = tsconfig;
+            this.configFile = tsconfigFile;
+            this.baseUrl = Path.resolve(Path.dirname(tsconfigFile), opts.baseUrl || '.');
+            for (const [alias, targets] of Object.entries(opts.paths)) {
+                for (const target of targets) {
+                    const prefix = alias === '*' ? '' : alias.endsWith('/*') ? alias.slice(0, -2) : alias;
+                    const targetPath = target.endsWith('/*') ? target.slice(0, -2) : target;
+                    this.patterns.push([prefix, Path.resolve(this.baseUrl, targetPath)]);
+                }
+            }
+        }
+        catch { }
+    }
+    get hasAliases() {
+        return this.patterns.length > 0;
+    }
+    /** Resolve an import path against tsconfig path aliases. Returns the resolved file path or null. */
+    resolve(importPath, resolveFilePath) {
+        for (const [prefix, dir] of this.patterns) {
+            if (prefix === '') {
+                // Wildcard "*" pattern: try resolving the full import path under the target dir
+                const resolved = resolveFilePath('./' + importPath, dir);
+                if (resolved)
+                    return resolved;
+            }
+            else if (importPath === prefix || importPath.startsWith(prefix + '/')) {
+                const rest = importPath.slice(prefix.length);
+                const resolved = resolveFilePath('.' + rest, dir);
+                if (resolved)
+                    return resolved;
+            }
+        }
+        return null;
+    }
+}
+export function ESModuleResolverPlugin(opts, tsconfigPaths) {
     const internalLoaders = {
         ".ts": "ts", ".tsx": "tsx", ".js": "js", ".jsx": "jsx",
         ".json": "json", ".txt": "text", ".md": "text", ".css": "css",
@@ -481,6 +551,13 @@ export function ESModuleResolverPlugin(opts) {
                         return { path: resolved, namespace: "file" };
                     }
                 }
+                // 4. Resolve tsconfig path aliases (e.g. @app/* -> ./src/*)
+                if (tsconfigPaths?.hasAliases) {
+                    const resolved = tsconfigPaths.resolve(args.path, resolveFilePath);
+                    if (resolved) {
+                        return { path: resolved, namespace: "file" };
+                    }
+                }
             });
             // Loader for internal modules
             build.onLoad({ filter: /.*/, namespace: 'internal' }, (args) => {

package/esm/commands/init.js

@@ -36,6 +36,19 @@ export function command_init() {
                         ],
                         "url": "./node_modules/@jointhedots/gear/schemas/component.schema.json"
                     },
+                    {
+                        "fileMatch": [
+                            "declaration.json",
+                            "*.declaration.json",
+                            "declaration.yaml",
+                            "*.declaration.yaml",
+                            "declaration.yml",
+                            "*.declaration.yml",
+                            "declaration.toml",
+                            "*.declaration.toml",
+                        ],
+                        "url": "./node_modules/@jointhedots/gear/schemas/declaration.schema.json"
+                    },
                 ]
             });
         }

package/esm/commands/make.js

@@ -61,7 +61,11 @@ export function command_make() {
             default: "./dist",
         }),
         handler: async (argv) => {
-            const ws = await open_workspace(argv.ws, argv.devmode);
+            const ws = await open_workspace({
+                workspace_path: argv.ws,
+                devmode: argv.devmode,
+                ignored_directory: Path.resolve(argv.dist),
+            });
             if (argv.devmode)
                 ws.log.warn("Use devmode");
             let version = argv.versioned;

package/esm/commands/publish.js

@@ -25,7 +25,10 @@ export function command_publish() {
         }),
         handler: async (argv) => {
             const outputDir = Path.resolve(argv.dist);
-            const ws = await open_workspace(".", false);
+            const ws = await open_workspace({
+                workspace_path: ".",
+                devmode: false,
+            });
             await publish_aws_s3(argv.app, ws, argv.bucket, argv.region, outputDir);
         }
     };

package/esm/commands/serve.js

@@ -38,10 +38,13 @@ export function command_serve() {
             default: "./dist",
         }),
         handler: async (argv) => {
-            const ws = await open_workspace(argv.ws, argv.devmode);
+            const ws = await open_workspace({
+                workspace_path: argv.ws,
+                devmode: argv.devmode,
+            });
             const app = ws.get_application(argv.app);
             if (!app)
-                throw new Error(`Application '${argv.app}' not exists. Note: 'package.json' shall have "componentsContainer": true`);
+                throw new Error(`Application '${argv.app}' not exists.`);
             if (argv.devmode)
                 ws.log.warn("Use devmode");
             let version = argv.versioned;

package/esm/model/helpers/config-loader.js

@@ -67,7 +67,7 @@ export function readConfigFileSync(path) {
  * Find config files matching a base name (e.g. "bundle.component") in a directory.
  * Returns all matching paths across supported extensions.
  */
-export function findConfigFiles(dir, baseName, fnames) {
+export function findConfigFile(dir, baseName, fnames) {
     const results = [];
     for (const ext of config_extensions) {
         const fname = baseName + ext;
@@ -80,7 +80,12 @@ export function findConfigFiles(dir, baseName, fnames) {
             results.push(`${dir}/${fname}`);
         }
     }
-    return results;
+    if (results.length === 0)
+        return undefined;
+    if (results.length > 1) {
+        throw new Error(`Multiple config files found for '${baseName}': ${results.join(", ")}. Only one format is allowed.`);
+    }
+    return results[0];
 }
 /**
  * Read a singleton config file (exactly one format must exist).
@@ -88,13 +93,8 @@ export function findConfigFiles(dir, baseName, fnames) {
  * Returns `undefined` if no matching file exists.
  */
 export async function readSingletonConfigFile(dir, baseName, fnames) {
-    const paths = findConfigFiles(dir, baseName, fnames);
-    if (paths.length === 0)
-        return undefined;
-    if (paths.length > 1) {
-        throw new Error(`Multiple config files found for '${baseName}': ${paths.join(", ")}. Only one format is allowed.`);
-    }
-    const data = await readConfigFile(paths[0]);
-    return data !== undefined ? { data, path: paths[0] } : undefined;
+    const path = findConfigFile(dir, baseName, fnames);
+    const data = await readConfigFile(path);
+    return data !== undefined ? { data, path } : undefined;
 }
 //# sourceMappingURL=config-loader.js.map

package/esm/model/helpers/create-manifests.js

@@ -1,4 +1,19 @@
+import Path from "node:path";
 import { makeComponentPublication } from "../component.js";
+function add_export_entry(exports, lib, key, value, baseDir) {
+    const basename = key.startsWith("./") ? key.slice(2) : key;
+    const filename = lib.make_file_id("export", basename);
+    const source_ref = typeof value === "string" ? value : value?.import ?? value?.default ?? value?.require;
+    const entry = source_ref ? lib.resolve_entry_path(source_ref, baseDir) : null;
+    const id = `${lib.name}${basename === "." ? "" : "/" + basename}`;
+    exports[id] = {
+        id,
+        exported: key,
+        basename: filename,
+        filename: `${filename}.js`,
+        source: entry,
+    };
+}
 function create_export_map(lib, bun) {
     const exports = {};
     if (bun) {
@@ -13,19 +28,18 @@ function create_export_map(lib, bun) {
             };
         }
     }
-    for (const key in lib.descriptor.exports) {
+    for (const key in (lib.descriptor.exports || {})) {
         const exp = lib.descriptor.exports[key];
-        const basename = key.startsWith("./") ? key.slice(2) : key;
-        const filename = lib.make_file_id("export", basename);
-        const entry = lib.resolve_entry_path(typeof exp === "string" ? exp : exp?.import, lib.path);
-        const id = `${lib.name}${basename === "." ? "" : "/" + basename}`;
-        exports[id] = {
-            id,
-            exported: key,
-            basename: filename,
-            filename: `${filename}.js`,
-            source: entry,
-        };
+        add_export_entry(exports, lib, key, exp, lib.path);
+    }
+    for (const [decl_path, declaration] of lib.declarations) {
+        if (!declaration.exports)
+            continue;
+        const decl_base_dir = Path.dirname(decl_path);
+        for (const key in declaration.exports) {
+            const exp = declaration.exports[key];
+            add_export_entry(exports, lib, key, exp, decl_base_dir);
+        }
     }
     return exports;
 }

package/esm/model/helpers/discover-workspace.js

@@ -5,9 +5,18 @@ import { checkComponentManifest } from "../component.js";
 import { makeNormalizedName, NameStyle } from "../../utils/normalized-name.js";
 import { create_manifests } from "./create-manifests.js";
 import { Bundle, Library, Workspace } from "../workspace.js";
-import { make_canonical_path, make_normalized_dirname, make_normalized_path, make_relative_path } from "../../utils/file.js";
-import { is_config_filename, readConfigFile, readSingletonConfigFile } from "./config-loader.js";
-const exclude_dirs = ["node_modules"];
+import { file, make_canonical_path, make_normalized_dirname, make_normalized_path, make_relative_path } from "../../utils/file.js";
+import { findConfigFile, is_config_filename, readConfigFile, readSingletonConfigFile } from "./config-loader.js";
+const exclude_dirs = ["node_modules", ".git"];
+function is_ignored_dir(ws, path) {
+    const normalized_path = make_normalized_path(path);
+    for (const ignored of ws.ignored_directories) {
+        if (normalized_path === ignored || normalized_path.startsWith(ignored + "/")) {
+            return true;
+        }
+    }
+    return false;
+}
 function setup_library_bundle(lib, bundle_desc) {
     const manif = make_library_bundle_manifest(lib, bundle_desc);
     const ws = lib.workspace;
@@ -88,7 +97,9 @@ async function discover_library_components(lib, path, subdir = false) {
         const fstat = await Fsp.stat(fpath);
         if (fstat.isDirectory()) {
             if (!exclude_dirs.includes(fname)) {
-                await discover_library_components(lib, fpath, true);
+                if (await discover_library(lib.workspace, fpath, lib.installed) === Discovered.None) {
+                    await discover_library_components(lib, fpath, true);
+                }
             }
         }
         else if (fstat.isFile()) {
@@ -106,15 +117,6 @@ async function discover_library_components(lib, path, subdir = false) {
             }
         }
     }
-    // Analyze library deployment manifest (supports json/yaml/yml/toml, singleton)
-    const manifest_result = await readSingletonConfigFile(path, "bundle.manifest", fnames);
-    if (manifest_result) {
-        const manifest = manifest_result.data;
-        for (const pub of manifest.data.components) {
-            const fpath = path + "/" + (pub.ref ?? pub.id);
-            await discover_component(lib, fpath);
-        }
-    }
 }
 function make_library_bundle_manifest(lib, file_desc) {
     let $id = file_desc?.$id;
@@ -165,46 +167,71 @@ function make_library_bundle_manifest(lib, file_desc) {
     };
     return manifest;
 }
-async function discover_library(ws, location) {
+var Discovered;
+(function (Discovered) {
+    Discovered[Discovered["None"] = 0] = "None";
+    Discovered[Discovered["Ignored"] = 1] = "Ignored";
+    Discovered[Discovered["Registered"] = 2] = "Registered";
+})(Discovered || (Discovered = {}));
+async function discover_library(ws, location, installed) {
     const lib_path = make_canonical_path(ws.path, location);
+    if (is_ignored_dir(ws, lib_path))
+        return Discovered.Ignored;
+    const package_path = lib_path + "/package.json";
+    const manifest_path = findConfigFile(lib_path, "bundle.manifest");
+    if (!file.exists(package_path) && !file.exists(manifest_path))
+        return Discovered.None;
     const lib_not_exists = ws.libraries.reduce((r, lib) => r && lib.path !== lib_path, true);
-    if (lib_not_exists) {
-        const lib_desc = await readJsonFile(lib_path + "/package.json");
-        const bundle_result = await readSingletonConfigFile(lib_path, "bundle.component");
-        const bundle_desc = bundle_result?.data;
-        if (bundle_desc || lib_desc?.componentsContainer) {
-            const other = ws.get_library(lib_desc.name);
-            if (other) {
-                if (lib_path.includes(other.path)) {
-                    ws.log.info(`ignore library build at ${lib_path}`);
-                    return;
-                }
-                else {
-                    throw new Error(`library '${lib_desc.name}' declared multiple times\n - ${other.path}\n - ${lib_path}`);
-                }
+    if (!lib_not_exists)
+        return Discovered.Ignored;
+    const lib_desc = await readJsonFile(package_path);
+    if (!lib_desc?.name)
+        return Discovered.Ignored;
+    const manifest_desc = await readConfigFile(manifest_path);
+    if (manifest_desc || !installed) {
+        const other = ws.get_library(lib_desc.name);
+        if (other) {
+            if (lib_path.includes(other.path)) {
+                ws.log.info(`ignore library build at ${lib_path}`);
+                return Discovered.Ignored;
             }
-            const lib = new Library(lib_desc.name, lib_path, lib_desc, ws);
-            ws.libraries.push(lib);
-            if (bundle_desc) {
-                setup_library_bundle(lib, bundle_desc);
+            else {
+                throw new Error(`library '${lib_desc.name}' declared multiple times\n - ${other.path}\n - ${lib_path}`);
             }
-            const lib_search_path = lib_path + "/node_modules";
-            if (Fs.existsSync(lib_search_path)) {
-                lib.search_directories.push(lib_search_path);
+        }
+        const lib = new Library(lib_desc.name, lib_path, lib_desc, ws, installed);
+        ws.libraries.push(lib);
+        ws.log.info(`+ 📚 library: ${installed ? "⏬" : "🐣"} ${lib.get_id()} (${make_relative_path(ws.path, location)})`);
+        // Setup library infos from bundle manifest
+        if (manifest_desc) {
+            setup_library_bundle(lib, manifest_desc);
+            // Analyze library deployment manifest (supports json/yaml/yml/toml, singleton)
+            for (const pub of manifest_desc.data.components) {
+                const fpath = lib_path + "/" + (pub.ref ?? pub.id);
+                await discover_component(lib, fpath);
             }
-            await discover_library_components(lib, lib_path);
         }
+        // Setup node search directory
+        const lib_search_path = lib_path + "/node_modules";
+        if (Fs.existsSync(lib_search_path)) {
+            lib.search_directories.push(lib_search_path);
+        }
+        // Collect library declaration
+        await discover_library_components(lib, lib_path);
+        return Discovered.Registered;
     }
+    return Discovered.None;
 }
 async function discover_workspace_libraries(ws) {
     async function walk(dir) {
-        await discover_library(ws, dir);
-        for (const entry of Fs.readdirSync(dir, { withFileTypes: true })) {
-            if (entry.name === "node_modules")
-                continue;
-            const fullPath = dir + "/" + entry.name;
-            if (entry.isDirectory()) {
-                await walk(fullPath);
+        if (await discover_library(ws, dir, false) === Discovered.None) {
+            for (const entry of Fs.readdirSync(dir, { withFileTypes: true })) {
+                if (entry.name === "node_modules")
+                    continue;
+                const fullPath = dir + "/" + entry.name;
+                if (entry.isDirectory()) {
+                    await walk(fullPath);
+                }
             }
         }
     }
@@ -245,7 +272,7 @@ export async function discover_workspace(ws) {
     }
     await discover_workspace_libraries(ws);
     for (const location in package_lock.packages) {
-        await discover_library(ws, location);
+        await discover_library(ws, location, true);
     }
     for (const bun of ws.bundles) {
         if (bun.source) {

package/esm/model/helpers/logger.js

@@ -1,3 +1,4 @@
+import Process from "node:process";
 export class Log {
     id;
     entries = [];
@@ -41,7 +42,12 @@ export class Log {
 }
 export class Logger {
     loggers = new Map();
-    silentKinds = new Set(["trace", "debug"]);
+    mode;
+    silentKinds;
+    constructor(mode = getLogModeFromEnv()) {
+        this.mode = mode;
+        this.silentKinds = getSilentKinds(mode);
+    }
     get(id) {
         let logger = this.loggers.get(id);
         if (!logger) {
@@ -63,6 +69,24 @@ export class Logger {
         this.loggers.clear();
     }
 }
+function getLogModeFromEnv() {
+    const value = Process.env.JTDGEAR_LOG_MODE?.trim().toLowerCase();
+    if (value === "debug" || value === "verbose" || value === "normal") {
+        return value;
+    }
+    return "normal";
+}
+function getSilentKinds(mode) {
+    switch (mode) {
+        case "verbose":
+            return new Set();
+        case "debug":
+            return new Set(["trace"]);
+        case "normal":
+        default:
+            return new Set(["trace", "debug"]);
+    }
+}
 export function stringifyLocation(loc) {
     if (!loc)
         return "";