@jointhedots/gear 1.1.17 → 1.2.0

package/esm/utils/normalized-name.js

@@ -50,15 +50,9 @@ export function isNormalizedName(name, expectedStyle) {
     const style = expectedStyle ?? detectNormalizedNameStyle(name);
     return check_name_regexes[style].test(name);
 }
-export function makeNormalizedKey(key, targetStyle) {
-    const seps = NormalizedNameSeparators[targetStyle];
-    const parts = key.replace(/[^a-z0-9\s\t\n:._-]/g, "").split(/[\s\t\n:._-]/g);
-    return parts.filter(x => !!x).join(seps.key);
-}
-export function makeNormalizedName(name, targetStyle, fromStyle) {
+export function getNormalizedKeys(name, fromStyle) {
     if (!name || typeof name !== "string")
-        return name;
-    const seps = NormalizedNameSeparators[targetStyle];
+        return [];
     // Split into lowercase keys
     let keys;
     name = name.toLowerCase();
@@ -81,8 +75,16 @@ export function makeNormalizedName(name, targetStyle, fromStyle) {
     }
     // Normalize keys
     for (let i = 0; i < keys.length; i++) {
-        keys[i] = makeNormalizedKey(keys[i], targetStyle);
+        keys[i] = keys[i].replace(/[^a-z0-9\s\t\n:._-]/g, "");
     }
+    return keys;
+}
+export function makeNormalizedName(name, targetStyle, fromStyle) {
+    if (!name || typeof name !== "string")
+        return name;
+    const seps = NormalizedNameSeparators[targetStyle];
+    // Split into lowercase keys
+    const keys = getNormalizedKeys(name, fromStyle);
     // Reform name, filtering out empty keys
     return keys.filter(x => !!x).join(seps.namespace);
 }

package/esm/{model → workspace}/helpers/create-manifests.js

@@ -1,6 +1,7 @@
 import Path from "node:path";
 import { makeComponentPublication } from "../component.js";
 import { resolve_normalized_suffixed_path } from "../../utils/file.js";
+import { getNormalizedKeys } from "../../utils/normalized-name.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);
@@ -49,13 +50,18 @@ export function create_bundle_manifest(lib, bun) {
         return null;
     const entries = create_export_map(lib, bun);
     const bundle_manif = bun.manifest;
+    const namespaces = new Set();
     const components = [];
     for (const comp of bun.components.values()) {
+        const ns = getNormalizedKeys(comp.$id)[0];
+        if (ns)
+            namespaces.add(ns);
         components.push(makeComponentPublication(comp));
     }
     bundle_manif.data = {
         baseline: bun.id + "-v0",
         components: components,
+        namespaces: Array.from(namespaces),
         exports: {},
     };
     for (const id in entries) {
@@ -78,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/{model → workspace}/helpers/discover-workspace.js

@@ -8,6 +8,8 @@ import { Bundle, Library, Workspace } from "../workspace.js";
 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";
 import { read_lockfile } from "./lockfile.js";
+import { LoadLibraryPackager } from "../packager.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);
@@ -18,26 +20,8 @@ function is_ignored_dir(ws, path) {
     }
     return false;
 }
-function setup_library_bundle(lib, bundle_desc) {
-    const ws = lib.workspace;
-    const manif = make_library_bundle_manifest(lib, bundle_desc);
-    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`);
-    }
-}
-async function discover_component(lib, fpath) {
-    let bundle = lib.bundle;
-    if (!bundle) {
-        bundle = setup_library_bundle(lib);
-    }
+export async function discover_component(lib, fpath) {
+    const { bundle } = lib;
     if (bundle.components.has(fpath)) {
         return true;
     }
@@ -90,7 +74,7 @@ async function discover_application(lib, fpath) {
         lib.log.error(`invalid application at ${fpath}: ${e?.message}`);
     }
 }
-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")) {
@@ -102,8 +86,8 @@ 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);
                 }
             }
         }
@@ -123,152 +107,57 @@ 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, file_desc) {
-    let $id = file_desc?.$id;
-    if ($id) {
-        $id = makeNormalizedName($id, NameStyle.OBJECT);
-        if ($id !== file_desc.$id) {
-            lib.log.warn(`Bundle '${file_desc.$id}' is normalized into '${$id}'`);
-        }
-    }
-    else {
-        $id = makeNormalizedName(lib.name, NameStyle.OBJECT);
-        lib.log.info(`Bundle '${$id}' named from library '${lib.name}'`);
-    }
-    const 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", {}),
-    };
-    if (file_desc?.data) {
-        data.alias = file_desc.data.alias ?? data.alias;
-        if (file_desc.data.distribueds) {
-            Object.assign(data.distribueds, file_desc.data.distribueds);
-        }
-        if (Array.isArray(file_desc.data.namespaces)) {
-            data.namespaces.push(...file_desc.data.namespaces);
-        }
-        if (Array.isArray(file_desc.data.dependencies)) {
-            data.dependencies.push(...file_desc.data.dependencies);
-        }
-    }
-    const manifest = {
-        $id,
-        type: file_desc?.type,
-        name: file_desc?.name ?? lib.name,
-        icon: file_desc?.icon,
-        title: file_desc?.title,
-        tags: file_desc?.tags,
-        keywords: file_desc?.keywords,
-        description: file_desc?.description ?? lib.descriptor?.description,
-        selectors: file_desc?.selectors,
-        data,
-    };
-    return manifest;
-}
 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 manifest_path = findConfigFile(lib_path, "bundle.manifest");
-    if (!file.exists(package_path) && !file.exists(manifest_path))
+    const has_package_manifest = file.exists(package_path);
+    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;
-    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;
-            }
-            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 library infos from bundle manifest
-        setup_library_bundle(lib, manifest_desc);
-        // Analyze library deployment manifest (supports json/yaml/yml/toml, singleton)
-        if (manifest_desc?.data?.components) {
-            for (const pub of manifest_desc.data.components) {
-                const fpath = lib_path + "/" + (pub.ref ?? pub.id);
-                await discover_component(lib, fpath);
-            }
-        }
-        // 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);
+    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;
         }
-        // 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) {
-        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);
-                }
-            }
+        else {
+            throw new Error(`library '${lib_manifest.name}' declared multiple times\n - ${other.path}\n - ${lib_path}`);
         }
     }
-    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,
                 };
             }
         }
@@ -280,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;
+        }
+    }
+    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(", ")})`);
+            }
+        }
     }
-    for (const bun of ws.bundles) {
-        if (bun.source) {
-            bun.manifest = create_bundle_manifest(bun.source, bun);
+}
+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/packager.js

@@ -0,0 +1,53 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import ChildProcess from "child_process";
+function parseSpecifier(specifier) {
+    let raw = specifier.startsWith("npm:") ? specifier.slice(4) : specifier;
+    let exportName;
+    const hashIndex = raw.indexOf("#");
+    if (hashIndex >= 0) {
+        exportName = raw.slice(hashIndex + 1);
+        raw = raw.slice(0, hashIndex);
+    }
+    let packageName;
+    if (raw.startsWith("@")) {
+        const parts = raw.split("/");
+        packageName = parts.slice(0, 2).join("/");
+    }
+    else {
+        packageName = raw.split("/")[0];
+    }
+    return { importPath: raw, packageName, exportName };
+}
+const validPackageName = /^(@[a-z0-9\-~][a-z0-9\-._~]*\/)?[a-z0-9\-~][a-z0-9\-._~]*$/;
+function resolveExport(mod, exportName) {
+    if (exportName) {
+        if (!(exportName in mod)) {
+            throw new Error(`Export '${exportName}' not found in module`);
+        }
+        return mod[exportName];
+    }
+    return mod.default ?? mod;
+}
+export async function LoadLibraryPackager(specifier) {
+    const { importPath, packageName, exportName } = parseSpecifier(specifier);
+    try {
+        const mod = await import(__rewriteRelativeImportExtension(importPath));
+        return resolveExport(mod, exportName);
+    }
+    catch {
+        if (!validPackageName.test(packageName)) {
+            throw new Error(`Invalid package name: ${packageName}`);
+        }
+        ChildProcess.execSync(`npm install ${packageName}`, { stdio: "inherit" });
+        const mod = await import(__rewriteRelativeImportExtension(importPath));
+        return resolveExport(mod, exportName);
+    }
+}
+//# sourceMappingURL=packager.js.map

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

@@ -0,0 +1,64 @@
+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_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_definitions(lib, lib.path);
+        return lib.bundle;
+    }
+}
+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/{model → 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/{model → 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;
     }