@jointhedots/gear 1.1.18 → 1.2.0

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

@@ -17,8 +17,7 @@ export var PathStatus;
     PathStatus[PathStatus["ExternalBundle"] = 4] = "ExternalBundle";
 })(PathStatus || (PathStatus = {}));
 export function create_bundle_target(opts) {
-    const { bundle, library, storage } = opts;
-    const lib = library;
+    const { bundle, library: lib, storage } = opts;
     const target = new BuildTarget(bundle.id, storage, lib.workspace, opts.devmode == true, opts.watch == true, opts.clean == true);
     // Prepare esm setup
     target.esmodules.set_root(lib.path);
@@ -84,7 +83,7 @@ export function create_bundle_target(opts) {
             paths_qualifier.set(dep, PathStatus.ExternalBundle);
         }
     }
-    for (const xbun of lib.workspace.bundles) {
+    for (const xbun of lib.shelve) {
         if (xbun !== bundle) {
             paths_qualifier.set(xbun.id, xbun);
             paths_qualifier.set(xbun.alias, xbun);
@@ -169,9 +168,8 @@ export function create_bundle_target(opts) {
         }
     });
     // Register esbuild plugin for dependency deduplication (graph-based + singleton)
-    const ws = library.workspace;
-    const rootNodeModules = ws.search_directories[0] || Path.join(ws.path, 'node_modules');
-    const libGraph = collectLibraryGraph(library);
+    const rootNodeModules = lib.search_directories[0] || Path.join(lib.path, 'node_modules');
+    const libGraph = collectLibraryGraph(lib);
     target.esmodules.plugins.push(DependencyDeduplicationPlugin(libGraph, rootNodeModules, target.log));
     return target;
 }

package/esm/builder/build-application.js

@@ -33,8 +33,7 @@ export function create_application_monolith_target(opts) {
     const { app, version } = opts;
     const { type, name, webviews, modules, assets, components } = app.descriptor;
     const lib = app.library;
-    const ws = lib.workspace;
-    const target = new BuildTarget(name, opts.storage, ws, opts.devmode == true, opts.watch == true, opts.clean == true);
+    const target = new BuildTarget(name, opts.storage, lib.workspace, 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
@@ -152,7 +151,7 @@ export function create_application_monolith_target(opts) {
         }
     }
     // Register esbuild plugin for dependency deduplication (graph-based + singleton)
-    const rootNodeModules = ws.search_directories[0] || Path.join(ws.path, 'node_modules');
+    const rootNodeModules = lib.search_directories[0] || Path.join(lib.path, 'node_modules');
     target.esmodules.plugins.push(DependencyDeduplicationPlugin(libs, rootNodeModules, target.log));
     return target;
 }

package/esm/builder/build-target.js

@@ -39,7 +39,7 @@ export class BuildTarget {
     add_component(descriptor, baseDir, library) {
         const id = descriptor.$id;
         if (this.components.has(id)) {
-            throw new Error(createComponentDuplicateMessage(id, this.workspace));
+            throw new Error(createComponentDuplicateMessage(id, library));
         }
         const manifest = {
             ...descriptor,
@@ -94,10 +94,10 @@ export class BuildTarget {
         }
     }
 }
-function createComponentDuplicateMessage(id, workspace) {
+function createComponentDuplicateMessage(id, library) {
     const duplicates = [];
     const libs = [];
-    for (const bun of workspace.bundles) {
+    for (const bun of library.shelve) {
         for (const [cpath, cmanifest] of bun.components.entries()) {
             if (cmanifest.$id === id) {
                 duplicates.push(`\n - ${cpath}`);

package/esm/commands/install.js

@@ -28,8 +28,8 @@ export function command_install() {
             });
             // Select all workspace bundles
             const selector = new BundleSelector(ws);
-            for (const bundle of ws.bundles) {
-                selector.add(bundle);
+            for (const lib of ws.libraries) {
+                selector.add(lib.bundle);
             }
             if (selector.missing.length > 0) {
                 ws.log.warn(`Missing bundle dependencies: ${selector.missing.join(", ")}`);

package/esm/commands/make.js

@@ -88,8 +88,9 @@ export function command_make() {
             }
             const bundles = [];
             if (argv.bundles === "*") {
-                for (const bundle of ws.bundles) {
-                    bundles.push(bundle);
+                for (const lib of ws.libraries) {
+                    if (lib.bundle)
+                        bundles.push(lib.bundle);
                 }
             }
             else if (argv.bundles) {

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

@@ -84,7 +84,7 @@ export function create_package_manifest(lib, bun, build_version) {
         optionalDependencies: undefined,
     };
     if (pkg_manif.dependencies) {
-        const resolved = lib.workspace.resolved_versions;
+        const resolved = lib.resolved_versions;
         for (const dep in pkg_manif.dependencies) {
             if (pkg_manif.dependencies[dep] === "*") {
                 const dep_resolved = resolved[dep];

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

@@ -9,7 +9,7 @@ import { file, make_canonical_path, make_normalized_dirname, make_normalized_pat
 import { findConfigFile, is_config_filename, readConfigFile, readSingletonConfigFile } from "./config-loader.js";
 import { read_lockfile } from "./lockfile.js";
 import { LoadLibraryPackager } from "../packager.js";
-import { BundledLibraryPackager, DefaultLibraryPackager } from "../packagers/packager-standard.js";
+import { DefaultLibraryPackager } from "../packagers/packager-standard.js";
 const exclude_dirs = ["node_modules", ".git"];
 function is_ignored_dir(ws, path) {
     const normalized_path = make_normalized_path(path);
@@ -20,26 +20,8 @@ function is_ignored_dir(ws, path) {
     }
     return false;
 }
-export function setup_library_bundle(lib) {
-    const ws = lib.workspace;
-    const manif = make_library_bundle_manifest(lib);
-    let bun = ws.get_bundle(manif.$id);
-    if (!bun) {
-        bun = new Bundle(manif, lib.path, ws, lib);
-        lib.bundle = bun;
-        ws.bundles.push(bun);
-        lib.log.info(`+ 📦 bundle: ${bun.id}`);
-        return bun;
-    }
-    else {
-        throw new Error(`Library '${lib.get_id()}' is associate to a bundle '${bun.id}' that is already associated`);
-    }
-}
 export async function discover_component(lib, fpath) {
-    let bundle = lib.bundle;
-    if (!bundle) {
-        bundle = setup_library_bundle(lib);
-    }
+    const { bundle } = lib;
     if (bundle.components.has(fpath)) {
         return true;
     }
@@ -92,7 +74,7 @@ async function discover_application(lib, fpath) {
         lib.log.error(`invalid application at ${fpath}: ${e?.message}`);
     }
 }
-export async function discover_library_components(lib, path, subdir = false) {
+export async function discover_library_definitions(lib, path, subdir = false) {
     // List names from directory
     const fnames = await Fsp.readdir(path);
     if (subdir && fnames.includes("package.json")) {
@@ -104,8 +86,8 @@ export async function discover_library_components(lib, path, subdir = false) {
         const fstat = await Fsp.stat(fpath);
         if (fstat.isDirectory()) {
             if (!exclude_dirs.includes(fname)) {
-                if (await discover_library(lib.workspace, fpath, lib.installed) === Discovered.None) {
-                    await discover_library_components(lib, fpath, true);
+                if (await discover_bundle(lib, fpath) === Discovered.None) {
+                    await discover_library_definitions(lib, fpath, true);
                 }
             }
         }
@@ -125,133 +107,57 @@ export async function discover_library_components(lib, path, subdir = false) {
         }
     }
 }
-export function collect_declarations_field(lib, key, value) {
-    for (const decl of lib.declarations.values()) {
-        if (typeof decl[key] === typeof value) {
-            if (Array.isArray(value))
-                value.push(...decl[key]);
-            else if (typeof value === "object")
-                Object.assign(value, decl[key]);
-            else
-                value = decl[key];
-        }
-    }
-    return value;
-}
-function make_library_bundle_manifest(lib) {
-    return {
-        $id: makeNormalizedName(collect_declarations_field(lib, "$id", lib.name), NameStyle.OBJECT),
-        type: "bundle",
-        name: lib.name,
-        icon: collect_declarations_field(lib, "icon", ""),
-        title: collect_declarations_field(lib, "title", lib.name),
-        tags: collect_declarations_field(lib, "tags", lib.descriptor?.tags),
-        keywords: collect_declarations_field(lib, "keywords", lib.descriptor?.keywords),
-        description: collect_declarations_field(lib, "description", lib.descriptor?.description),
-        selectors: collect_declarations_field(lib, "selectors", undefined),
-        data: {
-            package: lib.get_id(),
-            alias: collect_declarations_field(lib, "alias", lib.name),
-            namespaces: collect_declarations_field(lib, "namespaces", []),
-            dependencies: collect_declarations_field(lib, "dependencies", []),
-            distribueds: collect_declarations_field(lib, "distribueds", {}),
-        }
-    };
-}
 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) {
+async function discover_library(ws, location) {
     const lib_path = make_canonical_path(ws.path, location);
     if (is_ignored_dir(ws, lib_path))
         return Discovered.Ignored;
+    const has_bundle_manifest = file.exists(findConfigFile(lib_path, "bundle.manifest"));
+    if (has_bundle_manifest) {
+        // discover_bundle
+        return Discovered.Ignored;
+    }
     const package_path = lib_path + "/package.json";
     const has_package_manifest = file.exists(package_path);
-    const has_bundle_manifest = file.exists(findConfigFile(lib_path, "bundle.manifest"));
-    if (!has_package_manifest && !has_bundle_manifest)
+    if (!has_package_manifest)
         return Discovered.None;
-    const lib_not_exists = ws.libraries.reduce((r, lib) => r && lib.path !== lib_path, true);
-    if (!lib_not_exists)
-        return Discovered.Ignored;
-    const lib_desc = await readJsonFile(package_path);
-    if (!lib_desc?.name)
+    const lib_manifest = await readJsonFile(package_path);
+    if (!lib_manifest?.name)
         return Discovered.Ignored;
-    if (has_bundle_manifest || !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;
-            }
-            else {
-                throw new Error(`library '${lib_desc.name}' declared multiple times\n - ${other.path}\n - ${lib_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 node search directory
-        const lib_search_path = lib_path + "/node_modules";
-        if (Fs.existsSync(lib_search_path)) {
-            lib.search_directories.push(lib_search_path);
-        }
-        // Load library packager
-        let packager = null;
-        if (has_bundle_manifest) {
-            packager = new BundledLibraryPackager();
+    if (!lib_manifest?.dots)
+        return Discovered.None;
+    const other = ws.get_library(lib_manifest.name);
+    if (other) {
+        if (lib_path.includes(other.path)) {
+            ws.log.info(`ignore library build at ${lib_path}`);
+            return Discovered.Ignored;
         }
         else {
-            const declaration_config = await readSingletonConfigFile(lib_path, "declaration");
-            const packager_ref = declaration_config && declaration_config.data?.packager;
-            if (packager_ref) {
-                packager = await LoadLibraryPackager(packager_ref);
-            }
-            else {
-                packager = new DefaultLibraryPackager();
-            }
+            throw new Error(`library '${lib_manifest.name}' declared multiple times\n - ${other.path}\n - ${lib_path}`);
         }
-        // Discover library with packager
-        await packager.discover_library(lib);
-        return Discovered.Registered;
     }
-    return Discovered.None;
-}
-async function discover_workspace_libraries(ws) {
-    async function walk(dir) {
-        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);
-                }
-            }
-        }
-    }
-    await walk(ws.path);
-}
-function show_constants(ws) {
-    for (const name in ws.constants) {
-        ws.log.info(`+ 🔖 ${name} = ${ws.constants[name]}`);
-    }
-}
-export async function discover_workspace(ws) {
+    const lib = new Library(lib_manifest.name, lib_path, lib_manifest, ws);
+    ws.libraries.push(lib);
+    ws.log.info(`+ 📚 library: ${lib.get_id()} (${make_relative_path(ws.path, location)})`);
+    // Discover library-level search_directories, lockfile, and constants (walk up to workspace root)
     let lockfile = null;
-    for (let path = ws.path;;) {
+    lib.constants = { ...ws.constants };
+    for (let path = lib.path;;) {
         const package_json = await readJsonFile(path + "/package.json");
         if (package_json) {
             const search_path = path + "/node_modules";
             if (Fs.existsSync(search_path)) {
-                ws.search_directories.push(search_path);
+                lib.search_directories.push(search_path);
             }
             if (package_json.constants) {
-                ws.constants = {
+                lib.constants = {
                     ...package_json.constants,
-                    ...ws.constants,
+                    ...lib.constants,
                 };
             }
         }
@@ -263,19 +169,110 @@ export async function discover_workspace(ws) {
             break;
         path = next_path;
     }
-    if (!lockfile) {
+    // Analyze lock file
+    if (lockfile) {
+        lib.resolved_versions = lockfile.resolved_versions;
+        for (const dep_id in lockfile.resolved_versions) {
+            const dep_path = lib.resolved_versions[dep_id];
+            await discover_bundle(lib, dep_path);
+        }
+    }
+    else {
         throw new Error(`Lock file not found for '${ws.name}'`);
     }
-    ws.resolved_versions = lockfile.resolved_versions;
-    await discover_workspace_libraries(ws);
-    for (const location of lockfile.installed_locations) {
-        await discover_library(ws, location, true);
+    // Load library packager
+    let packager = null;
+    const declaration_config = await readSingletonConfigFile(lib_path, "declaration");
+    const packager_ref = declaration_config && declaration_config.data?.packager;
+    if (packager_ref) {
+        packager = await LoadLibraryPackager(packager_ref);
+    }
+    else {
+        packager = new DefaultLibraryPackager();
+    }
+    // Discover library with packager
+    await packager.discover_library(lib);
+    return Discovered.Registered;
+}
+async function discover_bundle(lib, location) {
+    const bun_path = make_canonical_path(lib.path, location);
+    if (is_ignored_dir(lib.workspace, bun_path))
+        return Discovered.Ignored;
+    const bun_manif_path = findConfigFile(bun_path, "bundle.manifest");
+    if (!bun_manif_path)
+        return Discovered.None;
+    const bun_manif = await readConfigFile(bun_manif_path);
+    if (!bun_manif) {
+        lib.log.error(`bundle manifest invalid at: ${bun_manif_path}`);
+        return Discovered.Ignored;
+    }
+    const other = lib.get_bundle(bun_manif.$id);
+    if (other) {
+        if (bun_path.includes(other.path)) {
+            lib.log.info(`ignore bundle at ${bun_path}`);
+            return Discovered.Ignored;
+        }
+        else {
+            lib.log.error(`bundle '${bun_manif.$id}' declared multiple times\n - ${other.path}\n - ${bun_path}`);
+            return Discovered.Ignored;
+        }
     }
-    for (const bun of ws.bundles) {
-        if (bun.source) {
-            bun.manifest = create_bundle_manifest(bun.source, bun);
+    const bun = new Bundle(bun_manif, lib.path, lib.workspace);
+    lib.bundle = bun;
+    lib.shelve.push(bun);
+    lib.log.info(`+ 📦 bundle: ${bun.id} ⏬`);
+    // Analyze library deployment manifest (supports json/yaml/yml/toml, singleton)
+    if (bun_manif?.data?.components) {
+        for (const pub of bun_manif.data.components) {
+            const fpath = lib.path + "/" + (pub.ref ?? pub.id);
+            await discover_component(lib, fpath);
         }
     }
+    return Discovered.Registered;
+}
+function show_constants(ws) {
+    // Collect all constant keys across libraries
+    const all_keys = new Set();
+    for (const lib of ws.libraries) {
+        for (const key in lib.constants)
+            all_keys.add(key);
+    }
+    for (const name of all_keys) {
+        const lib_values = new Map();
+        for (const lib of ws.libraries) {
+            if (name in lib.constants) {
+                const val = lib.constants[name];
+                const key = String(val);
+                if (!lib_values.has(val))
+                    lib_values.set(val, []);
+                lib_values.get(val).push(lib.name);
+            }
+        }
+        if (lib_values.size === 1) {
+            const [value] = lib_values.keys();
+            ws.log.info(`+ 🔖 ${name} = ${value}`);
+        }
+        else {
+            for (const [value, libs] of lib_values) {
+                ws.log.info(`+ 🔖 ${name} = ${value} (${libs.join(", ")})`);
+            }
+        }
+    }
+}
+export async function discover_workspace(ws) {
+    async function walk(dir) {
+        if (await discover_library(ws, dir) === 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);
+                }
+            }
+        }
+    }
+    await walk(ws.path);
     show_constants(ws);
     return ws;
 }

package/esm/workspace/packagers/packager-standard.js

@@ -2,38 +2,63 @@ import {} from "../component.js";
 import { Bundle, Library } from "../workspace.js";
 import { readSingletonConfigFile } from "../helpers/config-loader.js";
 import {} from "../packager.js";
-import { discover_component, discover_library_components, setup_library_bundle } from "../helpers/discover-workspace.js";
+import { discover_component, discover_library_definitions } from "../helpers/discover-workspace.js";
+import { makeNormalizedName, NameStyle } from "../../utils/normalized-name.js";
 export class DefaultLibraryPackager {
     async discover_library(lib) {
         // Setup library infos from bundle manifest
         setup_library_bundle(lib);
         // Collect library declaration
-        await discover_library_components(lib, lib.path);
+        await discover_library_definitions(lib, lib.path);
         return lib.bundle;
     }
 }
-export class BundledLibraryPackager {
-    async discover_library(lib) {
-        const { data: manif } = await readSingletonConfigFile(lib.path, "bundle.manifest");
-        const ws = lib.workspace;
-        let bun = ws.get_bundle(manif.$id);
-        if (!bun) {
-            bun = new Bundle(manif, lib.path, lib.workspace, lib);
-            lib.bundle = bun;
-            ws.bundles.push(bun);
-            lib.log.info(`+ 📦 bundle: ${bun.id}`);
-        }
-        else if (bun.source != lib) {
-            lib.log.warn(`Conflict between two prebuild library bundle`);
-        }
-        // Analyze library deployment manifest (supports json/yaml/yml/toml, singleton)
-        if (manif?.data?.components) {
-            for (const pub of manif.data.components) {
-                const fpath = lib.path + "/" + (pub.ref ?? pub.id);
-                await discover_component(lib, fpath);
-            }
-        }
+export function setup_library_bundle(lib) {
+    const ws = lib.workspace;
+    const manif = make_library_bundle_manifest(lib);
+    let bun = lib.get_bundle(manif.$id);
+    if (!bun) {
+        bun = new Bundle(manif, lib.path, ws, lib);
+        lib.bundle = bun;
+        lib.shelve.push(bun);
+        lib.log.info(`+ 📦 bundle: ${bun.id} 🐣`);
         return bun;
     }
+    else {
+        throw new Error(`Library '${lib.get_id()}' is associate to a bundle '${bun.id}' that is already associated`);
+    }
+}
+export function collect_declarations_field(lib, key, value) {
+    for (const decl of lib.declarations.values()) {
+        if (typeof decl[key] === typeof value) {
+            if (Array.isArray(value))
+                value.push(...decl[key]);
+            else if (typeof value === "object")
+                Object.assign(value, decl[key]);
+            else
+                value = decl[key];
+        }
+    }
+    return value;
+}
+function make_library_bundle_manifest(lib) {
+    return {
+        $id: makeNormalizedName(collect_declarations_field(lib, "$id", lib.name), NameStyle.OBJECT),
+        type: "bundle",
+        name: lib.name,
+        icon: collect_declarations_field(lib, "icon", ""),
+        title: collect_declarations_field(lib, "title", lib.name),
+        tags: collect_declarations_field(lib, "tags", lib.descriptor?.tags),
+        keywords: collect_declarations_field(lib, "keywords", lib.descriptor?.keywords),
+        description: collect_declarations_field(lib, "description", lib.descriptor?.description),
+        selectors: collect_declarations_field(lib, "selectors", undefined),
+        data: {
+            package: lib.get_id(),
+            alias: collect_declarations_field(lib, "alias", lib.name),
+            namespaces: collect_declarations_field(lib, "namespaces", []),
+            dependencies: collect_declarations_field(lib, "dependencies", []),
+            distribueds: collect_declarations_field(lib, "distribueds", {}),
+        }
+    };
 }
 //# sourceMappingURL=packager-standard.js.map

package/esm/workspace/storage.js

@@ -54,17 +54,22 @@ export class StorageTransaction {
         const { root, scratch, baseDir } = this;
         await Fsp.mkdir(baseDir, { recursive: true });
         const changes = { added: [], updated: [], changed: false };
-        const writes = [];
-        for (const [fpath, { data, hash }] of this.pending) {
-            const prev = root.cache.get(fpath);
-            if (prev !== hash) {
-                ;
-                (prev ? changes.updated : changes.added).push(Path.basename(fpath));
-                writes.push(Fsp.mkdir(Path.dirname(fpath), { recursive: true }).then(() => Fsp.writeFile(fpath, data)));
-            }
+        const pending_writes = [...this.pending].filter(([fpath, { hash }]) => root.cache.get(fpath) !== hash);
+        const write_channel = async () => {
+            const item = pending_writes.pop();
+            if (!item)
+                return;
+            const [fpath, { data, hash }] = item;
+            const changelist = root.cache.has(fpath) ? changes.updated : changes.added;
+            changelist.push(Path.basename(fpath));
             root.cache.set(fpath, hash);
-        }
-        await Promise.all(writes);
+            await Fsp.mkdir(Path.dirname(fpath), { recursive: true });
+            await Fsp.writeFile(fpath, data);
+            if (pending_writes.length > 0) {
+                return write_channel();
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(100, pending_writes.length) }, () => write_channel()));
         this.pending.clear();
         if (changes.updated.length > 0 || changes.added.length > 0) {
             root.on_changes.sendEventsToAll("change", changes);

package/esm/workspace/workspace.js

@@ -23,26 +23,37 @@ export class Library extends WorkspaceItem {
     path;
     descriptor;
     workspace;
-    installed;
     bundle = null;
     declarations = new Map();
     applications = new Map();
     externals = {};
-    search_directories = null;
-    constructor(name, path, descriptor, workspace, installed) {
+    resolved_versions = {};
+    search_directories = [];
+    constants = {};
+    shelve = [];
+    constructor(name, path, descriptor, workspace) {
         super(workspace, `lib:${name}`);
         this.name = name;
         this.path = path;
         this.descriptor = descriptor;
         this.workspace = workspace;
-        this.installed = installed;
-        this.search_directories = workspace.search_directories.slice();
         Object.assign(this.externals, descriptor.peerDependencies, descriptor.dependencies);
     }
     get_id() {
         const { name, version } = this.descriptor;
         return `${name}-${version}`;
     }
+    get_bundle(id) {
+        for (const bundle of this.shelve) {
+            if (bundle.id === id)
+                return bundle;
+        }
+        for (const bundle of this.shelve) {
+            if (bundle.alias === id)
+                return bundle;
+        }
+        return null;
+    }
     make_file_id(prefix, id) {
         const devmode = true;
         const base = devmode ? makeNormalizedName(id, NameStyle.OBJECT) : computeNameHashID(id);
@@ -104,11 +115,8 @@ export class Workspace {
     version;
     path;
     devmode;
-    bundles = [];
     libraries = [];
     constants = {};
-    resolved_versions = {};
-    search_directories = [];
     ignored_directories = new Set();
     logger = new Logger();
     log;
@@ -120,13 +128,14 @@ export class Workspace {
         this.log = this.logger.get(`workspace:${name}`);
     }
     get_bundle(id) {
-        for (const bundle of this.bundles) {
-            if (bundle.id === id)
-                return bundle;
+        for (const lib of this.libraries) {
+            if (lib.bundle.id === id)
+                return lib.bundle;
         }
-        for (const bundle of this.bundles) {
-            if (bundle.alias === id)
-                return bundle;
+        for (const lib of this.libraries) {
+            const bun = lib.get_bundle(id);
+            if (bun)
+                return bun;
         }
         return null;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@jointhedots/gear",
-   "version": "1.1.18",
+   "version": "1.2.0",
    "type": "module",
    "packageManager": "pnpm@10.30.3",
    "bin": {