@jointhedots/gear 1.2.2 → 1.2.3

package/esm/builder/helpers/emit-bundle-manifest.d.ts

@@ -1,9 +1,19 @@
-import type { Bundle } from "../../workspace/workspace.ts";
+import { type BundleManifest } from "../../workspace/component.ts";
+import { type AppDescriptor, type Bundle } from "../../workspace/workspace.ts";
 import { BuildTarget } from "../build-target.ts";
 import { BuildTask } from "./task.ts";
-export declare class BundleManifestTask extends BuildTask {
+export declare abstract class BaseManifestTask extends BuildTask {
+    write_manifest(manifest: BundleManifest): Promise<void>;
+}
+export declare class BundleManifestTask extends BaseManifestTask {
     readonly target: BuildTarget;
     readonly bundle: Bundle;
     constructor(target: BuildTarget, bundle: Bundle);
     execute(): Promise<void>;
 }
+export declare class ApplicationManifestTask extends BaseManifestTask {
+    readonly target: BuildTarget;
+    readonly app: AppDescriptor;
+    constructor(target: BuildTarget, app: AppDescriptor);
+    execute(): Promise<void>;
+}

package/esm/builder/helpers/emit-bundle-manifest.js

@@ -1,8 +1,22 @@
 import { makeComponentPublication } from "../../workspace/component.js";
+import { Library } from "../../workspace/workspace.js";
 import { BuildTarget } from "../build-target.js";
 import { BuildTask } from "./task.js";
 import MIME from "mime";
-export class BundleManifestTask extends BuildTask {
+export class BaseManifestTask extends BuildTask {
+    async write_manifest(manifest) {
+        const tx = this.target.edit();
+        const pubs = [];
+        for (const manif of this.target.components.values()) {
+            const pub = makeComponentPublication(manif);
+            pub.ref = await tx.commitContent(JSON.stringify(manif, null, 2), MIME.getType(".json"));
+            pubs.push(pub);
+        }
+        manifest.data.components = pubs;
+        await tx.commitFile(`bundle.manifest.json`, JSON.stringify(manifest, null, 2));
+    }
+}
+export class BundleManifestTask extends BaseManifestTask {
     target;
     bundle;
     constructor(target, bundle) {
@@ -11,18 +25,27 @@ export class BundleManifestTask extends BuildTask {
         this.bundle = bundle;
     }
     async execute() {
-        const { target, bundle } = this;
-        const { manifest } = bundle;
-        const tx = this.target.edit();
-        // Emit static components manifest
-        const components = [];
-        for (const manif of target.components.values()) {
-            const pub = makeComponentPublication(manif);
-            pub.ref = await tx.commitContent(JSON.stringify(manif, null, 2), MIME.getType(".json"));
-            components.push(pub);
-        }
-        manifest.data.components = components;
-        // Emit bundle manifest
-        await tx.commitFile(`bundle.manifest.json`, JSON.stringify(manifest, null, 2));
+        const { bundle } = this;
+        await this.write_manifest(bundle.manifest);
+    }
+}
+export class ApplicationManifestTask extends BaseManifestTask {
+    target;
+    app;
+    constructor(target, app) {
+        super(target);
+        this.target = target;
+        this.app = app;
+    }
+    async execute() {
+        const { target, app } = this;
+        await this.write_manifest({
+            $id: target.name,
+            name: app.name,
+            icon: app.icon,
+            title: app.title,
+            description: app.description,
+            data: {},
+        });
     }
 }

package/esm/builder/helpers/emit-esmodules.d.ts

@@ -1,6 +1,6 @@
 import * as esbuild from "esbuild";
 import type { Log } from "../../workspace/helpers/logger.ts";
-import { Library } from "../../workspace/workspace.ts";
+import { Library, WorkspaceItem } from "../../workspace/workspace.ts";
 import type { ResourceEntry } from "../../workspace/component.ts";
 import type { IStorageTransaction } from "../../workspace/storage.ts";
 import { BuildTask } from "./task.ts";
@@ -56,6 +56,6 @@ export declare class ESModulesTask extends BuildTask {
     set_root(path: string): void;
     add_entry(name: string, path: string): void;
     add_entry_typescript(code: string, name?: string): string;
-    add_resource_entry(resource: ResourceEntry, baseDir: string, library: Library): ResourceEntry;
+    add_resource_entry(resource: ResourceEntry, baseDir: string, origin: WorkspaceItem): ResourceEntry;
     execute(): Promise<void>;
 }

package/esm/builder/helpers/emit-esmodules.js

@@ -6,7 +6,7 @@ import postcss from "postcss";
 import * as esbuild from "esbuild";
 import { sassPlugin } from "esbuild-sass-plugin";
 import { PackageRootDir, resolve_normalized_suffixed_path } from "../../utils/file.js";
-import { Library } from "../../workspace/workspace.js";
+import { Library, WorkspaceItem } from "../../workspace/workspace.js";
 import { computeNameHashID } from "../../utils/normalized-name.js";
 import { BuildTask } from "./task.js";
 const VirtualOutDir = process.platform === 'win32' ? 'X:\\' : '/_/';
@@ -22,7 +22,7 @@ function getEsbuildLogLevel(mode) {
     }
 }
 async function create_esbuild_context(task, devmode, onReady) {
-    const ws = task.target.workspace;
+    const { library } = task.target;
     // Define modules mapping - using @jspm/core polyfills (same as Vite)
     const jspmPolyfills = Path.resolve(PackageRootDir, "node_modules/@jspm/core/nodelibs/browser");
     // Side effects script that provides Node.js globals (like Buffer) for browser environment
@@ -52,7 +52,7 @@ async function create_esbuild_context(task, devmode, onReady) {
         }
         return result;
     }
-    const tsconfig = new TSConfig(task.rootPath, ws.path);
+    const tsconfig = new TSConfig(task.rootPath, library.path);
     const modules_mapping = {
         task,
         routeds: {
@@ -76,9 +76,9 @@ async function create_esbuild_context(task, devmode, onReady) {
         } : {}
     };
     // Define constants
-    const workspace_constants = Object.keys(ws.constants).reduce((prev, key) => {
+    const constants = Object.keys(library.constants).reduce((prev, key) => {
         const name = `constants.${key}`;
-        prev[name] = JSON.stringify(ws.constants[key]);
+        prev[name] = JSON.stringify(library.constants[key]);
         return prev;
     }, {});
     const options = {
@@ -94,7 +94,7 @@ async function create_esbuild_context(task, devmode, onReady) {
         splitting: true,
         treeShaking: true,
         write: false,
-        logLevel: getEsbuildLogLevel(ws.logger.mode),
+        logLevel: getEsbuildLogLevel(library.log.logger.mode),
         chunkNames: "chunk.[hash]",
         jsx: "automatic",
         jsxImportSource: "react",
@@ -105,7 +105,7 @@ async function create_esbuild_context(task, devmode, onReady) {
             'global': 'globalThis',
             "process.browser": "true",
             "process.env.NODE_ENV": JSON.stringify(devmode ? "development" : "production"),
-            ...workspace_constants,
+            ...constants,
         },
         plugins: [
             ESModuleResolverPlugin(modules_mapping, tsconfig),
@@ -205,8 +205,8 @@ function copyAssets(task) {
     };
 }
 export function StyleSheetPlugin(task) {
-    const workspacePath = task.target.workspace.path;
-    const useTailwind = hasTailwindConfig(workspacePath);
+    const rootPath = task.target.library.path;
+    const useTailwind = hasTailwindConfig(rootPath);
     if (useTailwind) {
         task.log.info(`+ 🎨 Tailwind CSS detected`);
     }
@@ -216,7 +216,7 @@ export function StyleSheetPlugin(task) {
             const plugins = [];
             if (useTailwind) {
                 const tailwindcss = (await import('@tailwindcss/postcss')).default;
-                plugins.push(tailwindcss({ base: workspacePath }));
+                plugins.push(tailwindcss({ base: rootPath }));
             }
             plugins.push(copyAssets(task));
             const { css } = await postcss(plugins)
@@ -495,7 +495,7 @@ export function ESModuleResolverPlugin(opts, tsconfigPaths) {
         name: 'esm-resolver',
         setup(build) {
             const { routeds = {}, replaceds = {}, task } = opts;
-            const workspaceRoot = task.target.workspace.path;
+            const rootPath = task.target.library.path;
             build.onResolve({ filter: /.*/ }, async (args) => {
                 // 0. Check for internal modules
                 if (task.internals.has(args.path)) {
@@ -526,7 +526,7 @@ export function ESModuleResolverPlugin(opts, tsconfigPaths) {
                 }
                 // 3. Handle relative/absolute file paths (entry points and local imports)
                 if (args.path.startsWith(".") || args.path.startsWith("/") || Path.isAbsolute(args.path)) {
-                    const baseDir = args.resolveDir || workspaceRoot;
+                    const baseDir = args.resolveDir || rootPath;
                     const resolved = resolve_normalized_suffixed_path(baseDir, args.path);
                     if (resolved) {
                         return { path: resolved, namespace: "file" };
@@ -550,7 +550,7 @@ export function ESModuleResolverPlugin(opts, tsconfigPaths) {
                 }
                 const ext = Path.extname(args.path) || ".ts";
                 const loader = internalLoaders[ext] ?? "ts";
-                return { contents, loader, resolveDir: workspaceRoot };
+                return { contents, loader, resolveDir: rootPath };
             });
         },
     };
@@ -579,20 +579,20 @@ export class ESModulesTask extends BuildTask {
         this.add_entry(name, id);
         return name;
     }
-    add_resource_entry(resource, baseDir, library) {
+    add_resource_entry(resource, baseDir, origin) {
         if (typeof resource === "string") {
             const parts = resource.split("#");
-            const file = library.resolve_entry_path(parts[0], baseDir);
+            const file = origin.resolve_entry_path(parts[0], baseDir);
             if (file) {
                 let named = this.imports[file];
                 if (!named) {
-                    named = library.make_file_id("lambda", file);
+                    named = origin.make_file_id("lambda", file);
                     this.add_entry(named, file);
                 }
                 return `./${named}.js#${parts[1] || "default"}`;
             }
             else {
-                throw new Error(`${library.name}: Cannot resolve file: ${parts[0]}`);
+                origin.log.error(`Cannot resolve build resource file at: ${parts[0]}`);
             }
         }
         else {

package/esm/builder/helpers/emit-package-manifest.js

@@ -11,7 +11,7 @@ export class PackageManifestTask extends BuildTask {
     }
     async execute() {
         const { library, version } = this;
-        const pkg = create_package_manifest(library, library.bundle, version);
+        const pkg = create_package_manifest(library, library.master, version);
         const tx = this.target.edit();
         tx.commitFile("package.json", JSON.stringify(pkg, null, 2));
     }

package/esm/builder/helpers/emit-typescript-definition.js

@@ -278,7 +278,7 @@ export class TypescriptDefinitionTask extends BuildTask {
                 project,
                 prefix: lib.name + ":",
                 exclude: ["node_modules/**/*"],
-                exports: create_export_map(lib, lib.bundle),
+                exports: create_export_map(lib, lib.master),
             });
             file.write.text(storage.getBaseDirFS() + "/types.d.ts", dts);
             project.cleanup();

package/esm/commands/install.js

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

package/esm/commands/make.d.ts

@@ -6,6 +6,7 @@ type MakeOptions = {
     devmode?: boolean;
     clean?: boolean;
     dist?: string;
+    artifactDir?: string;
 };
 export declare function command_make(): CommandModule<any, MakeOptions & {
     apps?: string;

package/esm/commands/make.js

@@ -59,6 +59,10 @@ export function command_make() {
             .option("dist", {
             type: "string",
             default: "./dist",
+        })
+            .option("artifact-dir", {
+            type: "string",
+            describe: "Directory to write output artifacts (npm if package.json, zip otherwise)",
         }),
         handler: async (argv) => {
             const ws = await open_workspace({
@@ -89,8 +93,8 @@ export function command_make() {
             const bundles = [];
             if (argv.bundles === "*") {
                 for (const lib of ws.libraries) {
-                    if (lib.bundle)
-                        bundles.push(lib.bundle);
+                    if (lib.master)
+                        bundles.push(lib.master);
                 }
             }
             else if (argv.bundles) {
@@ -112,6 +116,7 @@ export function command_make() {
                         ws.log.error(`application not found: ${appname}`);
                 }
             }
+            const artifactDir = argv.artifactDir ? Path.resolve(argv.artifactDir) : undefined;
             const pendings = [];
             if (bundles.length > 0) {
                 const shelve = new StorageFiles("shelve", Path.resolve(argv.dist, "shelve"));
@@ -123,6 +128,7 @@ export function command_make() {
                         devmode: argv.devmode,
                         watch: argv.watch,
                         clean: argv.clean || !argv.devmode,
+                        artifactDir,
                     }));
                 }
             }
@@ -137,6 +143,7 @@ export function command_make() {
                     devmode: argv.devmode,
                     watch: argv.watch,
                     clean: argv.clean || !argv.devmode,
+                    artifactDir,
                 }));
             }
             for (const lib of libraries) {
@@ -149,6 +156,7 @@ export function command_make() {
                     devmode: argv.devmode,
                     watch: argv.watch,
                     clean: argv.clean || !argv.devmode,
+                    artifactDir,
                 }, argv.pack ? Path.resolve(argv.dist) : null));
             }
             await Promise.all(pendings);

package/esm/commands/serve.js

@@ -54,22 +54,21 @@ export function command_serve() {
             }
             const outputDir = Path.resolve(argv.dist, makeNormalizedName(argv.app, NameStyle.WEBC));
             const storage = new StorageFiles(ws.name, outputDir);
+            let serverStarted = false;
             const building = build_application({
                 app,
                 storage,
                 version,
                 devmode: argv.devmode,
                 devserver: argv.port && `http://localhost:${argv.port}`,
+                onNotification(event) {
+                    if (event.type === "build-complete" && !serverStarted && argv.port) {
+                        serverStarted = true;
+                        serve(ws, argv.port, storage);
+                    }
+                },
             });
-            if (argv.port) {
-                await Promise.all([
-                    building,
-                    serve(ws, argv.port, storage)
-                ]);
-            }
-            else {
-                await building;
-            }
+            await building;
         }
     };
 }

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

@@ -20,8 +20,8 @@ export function create_export_map(lib, bun) {
     const exports = {};
     if (bun) {
         for (const id in bun.distribueds) {
-            const basename = lib.make_file_id("redist", id);
-            const entry = lib.resolve_entry_path(id, lib.path);
+            const basename = bun.make_file_id("redist", id);
+            const entry = bun.resolve_entry_path(id, lib.path);
             exports[id] = {
                 id,
                 basename: basename,
@@ -84,7 +84,7 @@ export function create_package_manifest(lib, bun, build_version) {
         optionalDependencies: undefined,
     };
     if (pkg_manif.dependencies) {
-        const resolved = lib.resolved_versions;
+        const resolved = lib.deps.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.d.ts

@@ -1,4 +1,4 @@
-import { Library, Workspace } from "../workspace.ts";
-export declare function discover_component(lib: Library, fpath: string): Promise<boolean>;
+import { Bundle, Library, Workspace } from "../workspace.ts";
+export declare function discover_component(bundle: Bundle, fpath: string): Promise<boolean>;
 export declare function discover_library_definitions(lib: Library, path: string, subdir?: boolean): Promise<void>;
 export declare function discover_workspace(ws: Workspace): Promise<Workspace>;

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

@@ -2,8 +2,6 @@ import Fs from "node:fs";
 import Fsp from "node:fs/promises";
 import { readJsonFile } from "../storage.js";
 import { checkComponentManifest } from "../component.js";
-import { makeNormalizedName, NameStyle } from "../../utils/normalized-name.js";
-import { create_bundle_manifest } from "./create-manifests.js";
 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";
@@ -20,8 +18,7 @@ function is_ignored_dir(ws, path) {
     }
     return false;
 }
-export async function discover_component(lib, fpath) {
-    const { bundle } = lib;
+export async function discover_component(bundle, fpath) {
     if (bundle.components.has(fpath)) {
         return true;
     }
@@ -35,18 +32,18 @@ export async function discover_component(lib, fpath) {
                 throw err;
             if (!desc.apis && desc["services"]) {
                 desc.apis = desc["services"]; // Migrate renaming 'services' -> 'apis'
-                lib.log.warn(`Component '${desc.$id}' manifest shall rename 'services' -> 'apis'`);
+                bundle.log.warn(`Component '${desc.$id}' manifest shall rename 'services' -> 'apis'`);
             }
             bundle.components.set(fpath, desc);
-            lib.log.info(`+ 🧩 component: ${desc.$id} ${desc.type ? `(${desc.type})` : ""}`);
+            bundle.log.info(`+ 🧩 component: ${desc.$id} ${desc.type ? `(${desc.type})` : ""}`);
             return true;
         }
         else if (bundle.path !== make_normalized_dirname(fpath)) {
-            lib.log.error(`invalid bundle component at ${fpath}`);
+            bundle.log.error(`invalid bundle component at ${fpath}`);
         }
     }
     catch (e) {
-        lib.log.error(`invalid component at ${fpath}: ${e?.message}`);
+        bundle.log.error(`invalid component at ${fpath}: ${e?.message}`);
     }
     return false;
 }
@@ -86,14 +83,12 @@ export async function discover_library_definitions(lib, path, subdir = false) {
         const fstat = await Fsp.stat(fpath);
         if (fstat.isDirectory()) {
             if (!exclude_dirs.includes(fname)) {
-                if (await discover_bundle(lib, fpath) === Discovered.None) {
-                    await discover_library_definitions(lib, fpath, true);
-                }
+                await discover_library_definitions(lib, fpath, true);
             }
         }
         else if (fstat.isFile()) {
             if (is_config_filename(fname, "component")) {
-                await discover_component(lib, fpath);
+                await discover_component(lib.master, fpath);
             }
             else if (is_config_filename(fname, "application")) {
                 await discover_application(lib, fpath);
@@ -145,7 +140,6 @@ async function discover_library(ws, location) {
     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;
     lib.constants = { ...ws.constants };
     for (let path = lib.path;;) {
         const package_json = await readJsonFile(path + "/package.json");
@@ -161,24 +155,20 @@ async function discover_library(ws, location) {
                 };
             }
         }
-        if (!lockfile) {
-            lockfile = await read_lockfile(path);
+        if (!lib.deps) {
+            lib.deps = await read_lockfile(path);
         }
         const next_path = make_normalized_dirname(path);
         if (next_path === path)
             break;
         path = next_path;
     }
-    // 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}'`);
+    if (!lib.deps)
+        throw new Error(`Lock file not found for '${lib.name}'`);
+    // Discover side bundles from lock file
+    for (const dep_id in lib.descriptor.dependencies) {
+        const dep_path = lib.deps.resolved_paths[dep_id];
+        await discover_bundle(lib, dep_path);
     }
     // Load library packager
     let packager = null;
@@ -217,15 +207,15 @@ async function discover_bundle(lib, location) {
             return Discovered.Ignored;
         }
     }
-    const bun = new Bundle(bun_manif, lib.path, lib.workspace);
-    lib.bundle = bun;
+    // Register bundle into library
+    const bun = new Bundle(bun_manif, lib.path, lib);
     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);
+            const fpath = bun_path + "/" + (pub.ref ?? pub.id);
+            await discover_component(bun, fpath);
         }
     }
     return Discovered.Registered;

package/esm/workspace/helpers/lockfile.d.ts

@@ -1,5 +1,5 @@
-export type LockFileInfo = {
+export type PackageDepsInfo = {
     resolved_versions: Record<string, string>;
-    installed_locations: string[];
+    resolved_paths: Record<string, string>;
 };
-export declare function read_lockfile(dir: string): Promise<LockFileInfo | null>;
+export declare function read_lockfile(dir: string): Promise<PackageDepsInfo | null>;

package/esm/workspace/helpers/lockfile.js

@@ -19,27 +19,27 @@ export async function read_lockfile(dir) {
 }
 function parse_npm_lockfile(lock) {
     const resolved_versions = {};
-    const installed_locations = [];
+    const resolved_paths = {};
     for (const location in lock.packages) {
         if (!location)
             continue;
-        installed_locations.push(location);
         if (location.startsWith("node_modules/")) {
             let pkg = lock.packages[location];
             if (pkg.link) {
                 pkg = lock.packages[pkg.resolved];
             }
             const name = location.replace(/^.*node_modules\//, "");
+            resolved_paths[name] = location;
             if (pkg?.version) {
                 resolved_versions[name] = pkg.version;
             }
         }
     }
-    return { resolved_versions, installed_locations };
+    return { resolved_versions, resolved_paths };
 }
 function parse_pnpm_lockfile(lock) {
     const resolved_versions = {};
-    const locations = new Set();
+    const resolved_paths = {};
     if (lock.packages) {
         for (const key in lock.packages) {
             const clean = key.startsWith("/") ? key.slice(1) : key;
@@ -49,7 +49,7 @@ function parse_pnpm_lockfile(lock) {
                 const version = clean.slice(atIdx + 1).split("(")[0];
                 if (name && version) {
                     resolved_versions[name] = version;
-                    locations.add("node_modules/" + name);
+                    resolved_paths[name] = "node_modules/" + name;
                 }
             }
         }
@@ -57,14 +57,14 @@ function parse_pnpm_lockfile(lock) {
     if (lock.importers) {
         for (const key in lock.importers) {
             if (key !== ".")
-                locations.add(key);
+                resolved_paths[key] = key;
         }
     }
-    return { resolved_versions, installed_locations: [...locations] };
+    return { resolved_versions, resolved_paths };
 }
 function parse_yarn_lockfile(text) {
     const resolved_versions = {};
-    const locations = new Set();
+    const resolved_paths = {};
     if (text.includes("__metadata:")) {
         const lock = YAML.parse(text);
         for (const key in lock) {
@@ -74,15 +74,15 @@ function parse_yarn_lockfile(text) {
                 const name = extract_package_name(key.split(",")[0].trim());
                 if (name) {
                     resolved_versions[name] = lock[key].version;
-                    locations.add("node_modules/" + name);
+                    resolved_paths[name] = "node_modules/" + name;
                 }
             }
         }
     }
     else {
-        parse_yarn_classic(text, resolved_versions, locations);
+        parse_yarn_classic(text, resolved_versions, resolved_paths);
     }
-    return { resolved_versions, installed_locations: [...locations] };
+    return { resolved_versions, resolved_paths };
 }
 function extract_package_name(entry) {
     entry = entry.replace(/^"|"$/g, "");
@@ -90,7 +90,7 @@ function extract_package_name(entry) {
     const at = entry.startsWith("@") ? entry.indexOf("@", 1) : entry.indexOf("@");
     return at > 0 ? entry.slice(0, at) : null;
 }
-function parse_yarn_classic(text, resolved_versions, locations) {
+function parse_yarn_classic(text, resolved_versions, resolved_paths) {
     let current_name = null;
     for (const line of text.split("\n")) {
         const trimmed = line.trim();
@@ -100,7 +100,7 @@ function parse_yarn_classic(text, resolved_versions, locations) {
         else if (current_name && trimmed.startsWith("version ")) {
             const version = trimmed.slice(8).replace(/^"|"$/g, "");
             resolved_versions[current_name] = version;
-            locations.add("node_modules/" + current_name);
+            resolved_paths[current_name] = "node_modules/" + current_name;
             current_name = null;
         }
     }

package/esm/workspace/helpers/logger.d.ts

@@ -35,8 +35,8 @@ export interface LogEntry {
 }
 export declare class Log {
     readonly id: string;
+    readonly logger: Logger;
     private entries;
-    private logger;
     constructor(id: string, logger: Logger);
     put(kind: LogKind, message: string | Error | Message): void;
     error(message: string | Error | Message): void;

package/esm/workspace/helpers/logger.js

@@ -1,8 +1,8 @@
 import Process from "node:process";
 export class Log {
     id;
-    entries = [];
     logger;
+    entries = [];
     constructor(id, logger) {
         this.id = id;
         this.logger = logger;

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

@@ -10,7 +10,7 @@ export class DefaultLibraryPackager {
         setup_library_bundle(lib);
         // Collect library declaration
         await discover_library_definitions(lib, lib.path);
-        return lib.bundle;
+        return lib.master;
     }
 }
 export function setup_library_bundle(lib) {
@@ -18,8 +18,8 @@ export function setup_library_bundle(lib) {
     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;
+        bun = new Bundle(manif, lib.path, lib, lib);
+        lib.master = bun;
         lib.shelve.push(bun);
         lib.log.info(`+ 📦 bundle: ${bun.id} 🐣`);
         return bun;