@jointhedots/gear 1.1.9 → 1.1.11

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

@@ -13,8 +13,8 @@ function collect_app_libraries(app) {
         const ws = lib.workspace;
         const deps = {
             ...lib.descriptor.dependencies,
-            ...lib.descriptor.devDependencies,
             ...lib.descriptor.peerDependencies,
+            ...lib.descriptor.optionalDependencies,
         };
         for (const depId in deps) {
             const lib = ws.get_library(depId);
@@ -35,6 +35,9 @@ export function create_application_monolith_target(opts) {
     const ws = lib.workspace;
     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) {
@@ -100,13 +103,36 @@ export function create_application_monolith_target(opts) {
         // Add bundle manifest
         target.tasks.push(new BundleManifestTask(target, bundle));
         // Add workspace components
+        const added_components = new Map();
         for (const lib of libs) {
             if (lib.bundle) {
                 for (const [path, desc] of lib.bundle.components) {
                     if (!matchComponentSelection(components, desc.selectors))
                         continue;
+                    const cid = desc.$id;
+                    const added = added_components.get(cid);
+                    if (added) {
+                        target.log.error({
+                            id: "duplicate-component-skip",
+                            text: `skip duplicate component '${cid}'`,
+                            notes: [
+                                {
+                                    title: "kept",
+                                    text: `${added.lib.name}@${added.lib.descriptor.version}`,
+                                    location: added.path,
+                                },
+                                {
+                                    title: "skipped",
+                                    text: `${lib.name}@${lib.descriptor.version}`,
+                                    location: path,
+                                },
+                            ],
+                        });
+                        continue;
+                    }
                     const baseDir = Path.dirname(path);
                     target.add_component(desc, baseDir, lib);
+                    added_components.set(cid, { lib, path });
                 }
             }
         }

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/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

@@ -8,6 +8,15 @@ 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"];
+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;
@@ -165,19 +174,23 @@ function make_library_bundle_manifest(lib, file_desc) {
     };
     return manifest;
 }
-async function discover_library(ws, location) {
+async function discover_library(ws, location, installed) {
     const lib_path = make_canonical_path(ws.path, location);
+    if (is_ignored_dir(ws, lib_path))
+        return false;
     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");
+        if (!lib_desc?.name)
+            return false;
         const bundle_result = await readSingletonConfigFile(lib_path, "bundle.component");
         const bundle_desc = bundle_result?.data;
-        if (bundle_desc || lib_desc?.componentsContainer) {
+        if (bundle_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;
+                    return false;
                 }
                 else {
                     throw new Error(`library '${lib_desc.name}' declared multiple times\n - ${other.path}\n - ${lib_path}`);
@@ -185,6 +198,7 @@ async function discover_library(ws, location) {
             }
             const lib = new Library(lib_desc.name, lib_path, lib_desc, ws);
             ws.libraries.push(lib);
+            ws.log.info(`+ 📚 library: ${lib.get_id()} (${make_relative_path(ws.path, location)})`);
             if (bundle_desc) {
                 setup_library_bundle(lib, bundle_desc);
             }
@@ -193,12 +207,14 @@ async function discover_library(ws, location) {
                 lib.search_directories.push(lib_search_path);
             }
             await discover_library_components(lib, lib_path);
+            return true;
         }
     }
+    return false;
 }
 async function discover_workspace_libraries(ws) {
     async function walk(dir) {
-        await discover_library(ws, dir);
+        await discover_library(ws, dir, false);
         for (const entry of Fs.readdirSync(dir, { withFileTypes: true })) {
             if (entry.name === "node_modules")
                 continue;
@@ -245,7 +261,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 "";
@@ -83,8 +107,12 @@ export function stringifyLogEntry(loggerId, entry) {
     const locStr = stringifyLocation(entry.message.location);
     lines.push(`${prefix}${locStr ? ` ${locStr}` : ""} ${entry.message.text}`);
     for (const note of entry.message.notes ?? []) {
+        const noteTitle = note.title || "note";
         const noteLocStr = stringifyLocation(note.location);
-        lines.push(`  note:${noteLocStr ? ` ${noteLocStr}` : ""} ${note.text}`);
+        lines.push(`  ${noteTitle}: ${note.text}`);
+        if (noteLocStr) {
+            lines.push(`    at ${noteLocStr}`);
+        }
     }
     return lines.join("\n");
 }
@@ -108,8 +136,12 @@ export function stringifyLogEntryPretty(loggerId, entry) {
         lines.push(`  ${dim}↪ ${locStr}${reset}`);
     }
     for (const note of entry.message.notes ?? []) {
+        const noteTitle = note.title || "note";
         const noteLocStr = stringifyLocation(note.location);
-        lines.push(`  ${dim}↳${reset} ${noteLocStr ? `${dim}${noteLocStr}${reset} ` : ""}${note.text}`);
+        lines.push(`  ${dim}↳${reset} ${bold}${noteTitle}:${reset} ${note.text}`);
+        if (noteLocStr) {
+            lines.push(`    ${dim}at ${noteLocStr}${reset}`);
+        }
     }
     return lines.join("\n");
 }

package/esm/model/workspace.js

@@ -109,6 +109,7 @@ export class Workspace {
     libraries = [];
     constants = {};
     search_directories = [];
+    ignored_directories = new Set();
     logger = new Logger();
     log;
     constructor(name, version, path, devmode) {
@@ -152,28 +153,32 @@ export class Workspace {
         return null;
     }
 }
-export async function open_workspace(workspace_path, devmode) {
-    workspace_path = Path.resolve(workspace_path);
+export async function open_workspace(options) {
+    const workspace_path = Path.resolve(options.workspace_path);
+    const { devmode } = options;
+    const parsed_env = load_env_from_cwd_parents();
     const package_json = await readJsonFile(workspace_path + "/package.json");
     if (!package_json)
         throw new Error(`No 'package.json' found at workspace path: ${workspace_path}`);
     const ws = new Workspace(package_json.name, package_json.version, workspace_path, devmode);
-    ws.constants = patch_constants_from_env(package_json.constants || {}, devmode);
+    if (options.ignored_directory) {
+        ws.ignored_directories.add(Path.resolve(options.ignored_directory).replace(/\\/g, "/"));
+    }
+    ws.constants = patch_constants_from_env(package_json.constants || {}, devmode, parsed_env);
     await discover_workspace(ws);
     return ws;
 }
-function patch_constants_from_env(constants, devmode) {
-    const env = DotEnv.config();
+function patch_constants_from_env(constants, devmode, parsedEnv) {
     for (const key in constants) {
         if (devmode) {
-            const dvalue = env.parsed["DCONST_" + key];
+            const dvalue = parsedEnv["DCONST_" + key];
             if (dvalue !== undefined) {
                 constants[key] = dvalue;
                 continue;
             }
         }
         {
-            const value = env.parsed["CONST_" + key];
+            const value = parsedEnv["CONST_" + key];
             if (value !== undefined) {
                 constants[key] = value;
                 continue;
@@ -182,6 +187,21 @@ function patch_constants_from_env(constants, devmode) {
     }
     return constants;
 }
+function load_env_from_cwd_parents() {
+    let currentPath = Process.cwd();
+    while (true) {
+        const envPath = Path.join(currentPath, ".env");
+        if (Fs.existsSync(envPath)) {
+            const env = DotEnv.config({ path: envPath });
+            return env.parsed || {};
+        }
+        const parentPath = Path.dirname(currentPath);
+        if (parentPath === currentPath)
+            break;
+        currentPath = parentPath;
+    }
+    return {};
+}
 export function matchComponentSelection(components, selectors) {
     if (components?.selectors) {
         if (!selectors)