@jointhedots/gear 1.1.18 → 1.2.2

package/esm/builder/build-app-bundle.d.ts

@@ -0,0 +1,28 @@
+import { Bundle, Library } from "../workspace/workspace.ts";
+import { StorageFiles, type IStorageZone } from "../workspace/storage.ts";
+import { BuildTarget } from "./build-target.ts";
+export type BuildBundleOptions = {
+    bundle: Bundle;
+    shelve: StorageFiles;
+    version: string;
+    devmode: boolean;
+    watch: boolean;
+    clean: boolean;
+};
+export declare enum PathStatus {
+    Unknown,
+    Internal = 1,
+    External = 2,
+    Dependency = 3,
+    ExternalBundle = 4
+}
+export declare function create_bundle_target(opts: {
+    bundle: Bundle;
+    library: Library;
+    storage: IStorageZone;
+    version: string;
+    devmode: boolean;
+    watch: boolean;
+    clean: boolean;
+}): BuildTarget;
+export declare function build_app_composable_bundle(opts: BuildBundleOptions): Promise<BuildTarget>;

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;
 }
@@ -197,4 +195,3 @@ export async function build_app_composable_bundle(opts) {
         bundle.log.info(`Prebuild bundle: ${opts.bundle.id}`);
     }
 }
-//# sourceMappingURL=build-app-bundle.js.map

package/esm/builder/build-app-host.d.ts

@@ -0,0 +1,28 @@
+import { Bundle, Workspace } from "../workspace/workspace.ts";
+import { BuildTarget } from "./build-target.ts";
+import { type BuildApplicationOptions } from "./build-application.ts";
+import { type BundleID } from "../workspace/component.ts";
+import { BuildTask } from "./helpers/task.ts";
+export declare class ShelveManifestTask extends BuildTask {
+    readonly target: BuildTarget;
+    readonly bundles: Bundle[];
+    constructor(target: BuildTarget, bundles: Bundle[]);
+    execute(): Promise<void>;
+}
+export declare function build_app_composable_host(opts: BuildApplicationOptions): Promise<void>;
+export declare class BundleSelector {
+    readonly workspace: Workspace;
+    readonly selected: Map<string, Bundle>;
+    readonly missing: BundleID[];
+    constructor(workspace: Workspace);
+    /** Add a bundle and recursively collect all its dependencies */
+    add(bundle: string | Bundle): this;
+    /** Check if the selector has any bundles */
+    get isEmpty(): boolean;
+    /** Get all selected bundles as an array in topological order (dependencies first) */
+    toArray(): Bundle[];
+    /** Get all selected bundle IDs */
+    getIds(): BundleID[];
+    /** Iterate over selected bundles */
+    [Symbol.iterator](): Iterator<Bundle>;
+}

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

@@ -214,4 +214,3 @@ export class BundleSelector {
         return this.toArray().values();
     }
 }
-//# sourceMappingURL=build-app-host.js.map

package/esm/builder/build-application.d.ts

@@ -0,0 +1,47 @@
+import Sharp from "sharp";
+import { type AppEntry, type ChromeAppManifest, type WebviewEntry } from "../workspace/workspace.ts";
+import { StorageFiles } from "../workspace/storage.ts";
+import { BuildTarget } from "./build-target.ts";
+import type { WebAppManifest } from "web-app-manifest";
+import { BuildTask } from "./helpers/task.ts";
+export type BuildApplicationOptions = {
+    app: AppEntry;
+    storage: StorageFiles;
+    version: string;
+    devmode?: boolean;
+    watch?: boolean;
+    clean?: boolean;
+    devserver?: string;
+};
+export declare function create_application_monolith_target(opts: {
+    app: AppEntry;
+    storage: StorageFiles;
+    version: string;
+    devmode: boolean;
+    devserver?: string;
+    watch: boolean;
+    clean: boolean;
+}): BuildTarget;
+export declare function build_app_monolith(opts: BuildApplicationOptions): Promise<void>;
+export declare function build_application(opts: BuildApplicationOptions): Promise<void>;
+export declare class WebviewTask extends BuildTask {
+    readonly name: string;
+    readonly title: string;
+    readonly desc: WebviewEntry;
+    readonly html_injects: string[];
+    constructor(target: BuildTarget, name: string, title: string, desc: WebviewEntry, html_injects: string[]);
+    execute(): Promise<void>;
+}
+export declare class ChromePackageTask extends BuildTask {
+    readonly app: AppEntry;
+    readonly version: string;
+    constructor(target: BuildTarget, app: AppEntry, version: string);
+    execute(): Promise<void>;
+    createIcons(base: Sharp.Sharp): Promise<ChromeAppManifest["icons"]>;
+}
+export declare class PWAPackageTask extends BuildTask {
+    readonly app: AppEntry;
+    constructor(target: BuildTarget, app: AppEntry);
+    execute(): Promise<void>;
+    createIcons(base: Sharp.Sharp): Promise<WebAppManifest["icons"]>;
+}

package/esm/builder/build-application.js

@@ -1,6 +1,6 @@
 import Path from "node:path";
 import Sharp from "sharp";
-import MIME from 'mime';
+import MIME from "mime";
 import { Library, matchComponentSelection } from "../workspace/workspace.js";
 import { StorageFiles } from "../workspace/storage.js";
 import { BuildTarget } from "./build-target.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;
 }
@@ -313,4 +312,3 @@ function createIcon(base, size, format) {
         .toFormat(format, { quality: 80 })
         .toBuffer();
 }
-//# sourceMappingURL=build-application.js.map

package/esm/builder/build-library.d.ts

@@ -0,0 +1,20 @@
+import { Library } from "../workspace/workspace.ts";
+import { StorageFiles } from "../workspace/storage.ts";
+import { BuildTarget } from "./build-target.ts";
+export type BuildLibraryOptions = {
+    library: Library;
+    storage: StorageFiles;
+    version: string;
+    devmode: boolean;
+    watch: boolean;
+    clean: boolean;
+};
+export declare function create_library_target(opts: {
+    library: Library;
+    storage: StorageFiles;
+    version: string;
+    devmode: boolean;
+    watch: boolean;
+    clean: boolean;
+}): BuildTarget;
+export declare function build_library(opts: BuildLibraryOptions, packageDir?: string): Promise<void>;

package/esm/builder/build-library.js

@@ -1,5 +1,5 @@
 import Path from "node:path";
-import ChildProcess from "child_process";
+import ChildProcess from "node:child_process";
 import { Library } from "../workspace/workspace.js";
 import { StorageFiles } from "../workspace/storage.js";
 import { BuildTarget } from "./build-target.js";
@@ -76,4 +76,3 @@ export async function build_library(opts, packageDir) {
         ChildProcess.execSync("npm pack --pack-destination " + packageDir, { cwd: target.storage.getBaseDirFS() });
     }
 }
-//# sourceMappingURL=build-library.js.map

package/esm/builder/build-target.d.ts

@@ -0,0 +1,27 @@
+import { type ComponentManifest } from "../workspace/component.ts";
+import { Library, Workspace } from "../workspace/workspace.ts";
+import type { Log } from "../workspace/helpers/logger.ts";
+import { ESModulesTask } from "./helpers/emit-esmodules.ts";
+import { type IStorageTransaction, type IStorageZone } from "../workspace/storage.ts";
+import { AssetsTask } from "./helpers/emit-static-assets.ts";
+import type { BuildTask } from "./helpers/task.ts";
+export declare class BuildTarget {
+    readonly name: string;
+    readonly storage: IStorageZone;
+    readonly workspace: Workspace;
+    readonly devmode: boolean;
+    readonly watch: boolean;
+    readonly clean: boolean;
+    components: Map<string, ComponentManifest>;
+    esmodules: ESModulesTask;
+    assets: AssetsTask;
+    tasks: BuildTask[];
+    transaction: IStorageTransaction;
+    readonly log: Log;
+    constructor(name: string, storage: IStorageZone, workspace: Workspace, devmode: boolean, watch: boolean, clean: boolean);
+    edit(): IStorageTransaction;
+    store(): Promise<void>;
+    add_component(descriptor: ComponentManifest, baseDir: string, library: Library): void;
+    private chrona;
+    build(): Promise<void>;
+}

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}`);
@@ -107,4 +107,3 @@ function createComponentDuplicateMessage(id, workspace) {
     }
     return `Component '${id}' declared multiple times: ${duplicates.join("")}\n> libraries:${libs.join("")}\n`;
 }
-//# sourceMappingURL=build-target.js.map

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

@@ -0,0 +1,9 @@
+import type { Bundle } from "../../workspace/workspace.ts";
+import { BuildTarget } from "../build-target.ts";
+import { BuildTask } from "./task.ts";
+export declare class BundleManifestTask extends BuildTask {
+    readonly target: BuildTarget;
+    readonly bundle: Bundle;
+    constructor(target: BuildTarget, bundle: Bundle);
+    execute(): Promise<void>;
+}

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

@@ -1,7 +1,7 @@
 import { makeComponentPublication } from "../../workspace/component.js";
 import { BuildTarget } from "../build-target.js";
 import { BuildTask } from "./task.js";
-import MIME from 'mime';
+import MIME from "mime";
 export class BundleManifestTask extends BuildTask {
     target;
     bundle;
@@ -26,4 +26,3 @@ export class BundleManifestTask extends BuildTask {
         await tx.commitFile(`bundle.manifest.json`, JSON.stringify(manifest, null, 2));
     }
 }
-//# sourceMappingURL=emit-bundle-manifest.js.map

package/esm/builder/helpers/emit-components-dts.d.ts

@@ -0,0 +1,9 @@
+import type { Bundle } from "../../workspace/workspace.ts";
+import { BuildTarget } from "../build-target.ts";
+import { BuildTask } from "./task.ts";
+export declare class ComponentsDtsTask extends BuildTask {
+    readonly target: BuildTarget;
+    readonly bundle: Bundle;
+    constructor(target: BuildTarget, bundle: Bundle);
+    execute(): Promise<void>;
+}

package/esm/builder/helpers/emit-components-dts.js

@@ -2,7 +2,7 @@ import { join } from "node:path";
 import { makeComponentPublication } from "../../workspace/component.js";
 import { BuildTarget } from "../build-target.js";
 import { BuildTask } from "./task.js";
-import MIME from 'mime';
+import MIME from "mime";
 export class ComponentsDtsTask extends BuildTask {
     target;
     bundle;
@@ -63,4 +63,3 @@ const components_dts_generators = {
     "view.react": generate_view_react,
     "commands": generate_commands,
 };
-//# sourceMappingURL=emit-components-dts.js.map

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

@@ -0,0 +1,61 @@
+import * as esbuild from "esbuild";
+import type { Log } from "../../workspace/helpers/logger.ts";
+import { Library } from "../../workspace/workspace.ts";
+import type { ResourceEntry } from "../../workspace/component.ts";
+import type { IStorageTransaction } from "../../workspace/storage.ts";
+import { BuildTask } from "./task.ts";
+export declare function StyleSheetPlugin(task: ESModulesTask): esbuild.Plugin;
+export declare function StoragePlugin(task: ESModulesTask, onReady?: () => void): esbuild.Plugin;
+export interface ESModuleResolverOptions {
+    task: ESModulesTask;
+    routeds?: Record<string, string>;
+    replaceds?: Record<string, string>;
+}
+/**
+ * Collects workspace libraries reachable from a root library (BFS).
+ * Index 0 = most dominant.
+ */
+export declare function collectLibraryGraph(rootLib: Library): Library[];
+/**
+ * Generic dependency deduplication plugin.
+ *
+ * For each npm package seen across multiple workspace libraries, forces resolution
+ * from the dominant library (first in BFS order) to guarantee a single version.
+ * Packages declaring `"singleton": true` in their package.json are always resolved
+ * from the root node_modules.
+ */
+export declare function DependencyDeduplicationPlugin(libraries: Library[], rootNodeModules: string, log: Log): esbuild.Plugin;
+/**
+ * Parses tsconfig.json compilerOptions (paths + baseUrl) and exposes resolved alias patterns.
+ * Looks for tsconfig.json in libraryPath first, then workspacePath as fallback.
+ */
+export declare class TSConfig {
+    readonly baseUrl: string | null;
+    readonly patterns: [string, string][];
+    readonly configFile: string | null;
+    readonly configData: any;
+    constructor(libraryPath: string, workspacePath: string);
+    get hasAliases(): boolean;
+    /** Resolve an import path against tsconfig path aliases. Returns the resolved file path or null. */
+    resolve(importPath: string, resolveFilePath: (importPath: string, baseDir: string) => string | null): string | null;
+}
+export declare function ESModuleResolverPlugin(opts: ESModuleResolverOptions, tsconfigPaths?: TSConfig): esbuild.Plugin;
+export declare class ESModulesTask extends BuildTask {
+    entries: {
+        [url: string]: string;
+    };
+    imports: {
+        [file: string]: string;
+    };
+    internals: Map<string, string>;
+    plugins: esbuild.Plugin[];
+    context: esbuild.BuildContext;
+    transaction: IStorageTransaction;
+    polyfilled: boolean;
+    rootPath: string;
+    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;
+    execute(): Promise<void>;
+}

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

@@ -1,10 +1,10 @@
 import Fs from "node:fs";
-import Path from 'node:path';
+import Path from "node:path";
 import Url from "node:url";
-import MIME from 'mime';
-import postcss from 'postcss';
-import * as esbuild from 'esbuild';
-import { sassPlugin } from 'esbuild-sass-plugin';
+import MIME from "mime";
+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 { computeNameHashID } from "../../utils/normalized-name.js";
@@ -619,4 +619,3 @@ export class ESModulesTask extends BuildTask {
         }
     }
 }
-//# sourceMappingURL=emit-esmodules.js.map

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

@@ -0,0 +1,9 @@
+import { BuildTask } from "./task.ts";
+import type { BuildTarget } from "../build-target.ts";
+import type { Library } from "../../workspace/workspace.ts";
+export declare class PackageManifestTask extends BuildTask {
+    readonly library: Library;
+    readonly version: string;
+    constructor(target: BuildTarget, library: Library, version: string);
+    execute(): Promise<void>;
+}

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

@@ -16,4 +16,3 @@ export class PackageManifestTask extends BuildTask {
         tx.commitFile("package.json", JSON.stringify(pkg, null, 2));
     }
 }
-//# sourceMappingURL=emit-package-manifest.js.map

package/esm/builder/helpers/emit-static-assets.d.ts

@@ -0,0 +1,14 @@
+import { type AssetsEntry, Library } from "../../workspace/workspace.ts";
+import { BuildTask } from "./task.ts";
+export type AssetMapping = {
+    from: string;
+    to: string;
+};
+export declare class AssetsTask extends BuildTask {
+    assets: AssetMapping[];
+    statics: Record<string, string>;
+    add_entry(entry: AssetsEntry, baseDir: string, library: Library): void;
+    add_static_text(name: string, data: string): void;
+    add_static_json(name: string, data: any): void;
+    execute(): Promise<any>;
+}

package/esm/builder/helpers/emit-static-assets.js

@@ -1,5 +1,5 @@
 import Path from "node:path";
-import MIME from 'mime';
+import MIME from "mime";
 import { Library } from "../../workspace/workspace.js";
 import { copyToStorageStream } from "../../workspace/storage.js";
 import { BuildTask } from "./task.js";
@@ -44,4 +44,3 @@ export class AssetsTask extends BuildTask {
         }
     }
 }
-//# sourceMappingURL=emit-static-assets.js.map

package/esm/builder/helpers/emit-typescript-definition.d.ts

@@ -0,0 +1,35 @@
+import Ts from "typescript";
+import { BuildTask } from "./task.ts";
+import { BuildTarget } from "../build-target.ts";
+import { Library } from "../../workspace/workspace.ts";
+import { type ExportEntries } from "../../workspace/helpers/create-manifests.ts";
+declare class TypescriptProject {
+    readonly baseDir: string;
+    readonly compilerOptions: Ts.CompilerOptions;
+    readonly dtsDir: string;
+    constructor(baseDir: string, tsconfig: string, outDir?: string);
+    /** Run tsgo to emit .d.ts files into dtsDir. Returns stderr output. */
+    emitWithTsgo(): Promise<void>;
+    /** Recursively collect all .d.ts files emitted by tsgo */
+    getEmittedDtsFiles(): string[];
+    /** Clean up temp directory */
+    cleanup(): void;
+}
+export declare function createTypescriptProject(baseDir: string, tsconfig: string, outDir?: string): TypescriptProject;
+export declare function generateTypescriptDefinition(options: {
+    project: TypescriptProject;
+    exclude: string[];
+    externs?: string[];
+    types?: string[];
+    exports: ExportEntries;
+    includes?: string[];
+    prefix: string;
+}): {
+    dts: string;
+};
+export declare class TypescriptDefinitionTask extends BuildTask {
+    readonly library: Library;
+    constructor(target: BuildTarget, library: Library);
+    execute(): Promise<void>;
+}
+export {};

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

@@ -1,9 +1,9 @@
-import Fs from 'fs';
-import Os from 'os';
-import Path from 'path';
-import Ts from 'typescript';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
+import Fs from "node:fs";
+import Os from "node:os";
+import Path from "node:path";
+import Ts from "typescript";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import { BuildTask } from "./task.js";
 import { BuildTarget } from "../build-target.js";
 import { Library } from "../../workspace/workspace.js";
@@ -288,4 +288,3 @@ export class TypescriptDefinitionTask extends BuildTask {
         }
     }
 }
-//# sourceMappingURL=emit-typescript-definition.js.map

package/esm/builder/helpers/path-helpers.d.ts

@@ -0,0 +1,9 @@
+export type PathNode<State> = Map<string, PathNode<State> | State>;
+export declare class PathQualifier<State> {
+    root: PathNode<State>;
+    set(path: string, state: State): boolean;
+    check(path: string): State | undefined;
+    match(path: string, update: (state: State, segments: string[], index: number) => State): State;
+    traverse(callback: (segments: string[], state: State) => void, _node?: PathNode<State>, _segments?: any[]): void;
+}
+export declare function createPathPrefixMatcher(prefixes: string[]): RegExp;

package/esm/builder/helpers/path-helpers.js

@@ -92,4 +92,3 @@ export function createPathPrefixMatcher(prefixes) {
     const pattern = '^/(' + sanitized.join('|') + ')(/|$)';
     return new RegExp(pattern);
 }
-//# sourceMappingURL=path-helpers.js.map

package/esm/builder/helpers/task.d.ts

@@ -0,0 +1,8 @@
+import type { BuildTarget } from "../build-target.ts";
+export declare abstract class BuildTask {
+    readonly target: BuildTarget;
+    constructor(target: BuildTarget);
+    get log(): import("../../workspace/helpers/logger.ts").Log;
+    init(): Promise<void>;
+    abstract execute(): Promise<void>;
+}

package/esm/builder/helpers/task.js

@@ -6,4 +6,3 @@ export class BuildTask {
     get log() { return this.target.log; }
     async init() { }
 }
-//# sourceMappingURL=task.js.map

package/esm/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/esm/cli.js

@@ -1,13 +1,12 @@
 #!/usr/bin/env node
 import Process from "node:process";
 import Yargs from "yargs";
-import { hideBin } from 'yargs/helpers';
+import { hideBin } from "yargs/helpers";
 import { command_run } from "./commands/run.js";
 import { command_init } from "./commands/init.js";
 import { command_install } from "./commands/install.js";
 import { command_make } from "./commands/make.js";
 import { command_serve } from "./commands/serve.js";
-import { command_publish } from "./commands/publish.js";
 function command_fail() {
     return {
         command: '*',
@@ -21,10 +20,8 @@ Yargs(hideBin(Process.argv)).scriptName("jointhedots-gear")
     .command(command_install())
     .command(command_make())
     .command(command_serve())
-    .command(command_publish())
     .command(command_run())
     .command(command_fail())
     .showHelpOnFail(true)
     .help()
     .parse();
-//# sourceMappingURL=cli.js.map

package/esm/commands/init.d.ts

@@ -0,0 +1,2 @@
+import { type CommandModule } from "yargs";
+export declare function command_init(): CommandModule<any, {}>;

package/esm/commands/init.js

@@ -54,4 +54,3 @@ export function command_init() {
         }
     };
 }
-//# sourceMappingURL=init.js.map

package/esm/commands/install.d.ts

@@ -0,0 +1,5 @@
+import { type CommandModule } from "yargs";
+export declare function command_install(): CommandModule<any, {
+    ws?: string;
+    dist?: string;
+}>;

package/esm/commands/install.js

@@ -1,5 +1,5 @@
-import Path from 'node:path';
-import Fs from 'node:fs';
+import Path from "node:path";
+import Fs from "node:fs";
 import {} from "yargs";
 import { open_workspace } from "../workspace/workspace.js";
 import { makeComponentPublication } from "../workspace/component.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(", ")}`);
@@ -64,4 +64,3 @@ export function command_install() {
         }
     };
 }
-//# sourceMappingURL=install.js.map

package/esm/commands/make.d.ts

@@ -0,0 +1,16 @@
+import { type CommandModule } from "yargs";
+type MakeOptions = {
+    watch?: boolean;
+    pack?: boolean;
+    versioned?: string;
+    devmode?: boolean;
+    clean?: boolean;
+    dist?: string;
+};
+export declare function command_make(): CommandModule<any, MakeOptions & {
+    apps?: string;
+    libs?: string;
+    bundles?: string;
+    ws?: string;
+}>;
+export {};