@jointhedots/gear 1.2.0 → 1.2.3

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

@@ -0,0 +1,29 @@
+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;
+    artifactDir?: string;
+};
+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

@@ -8,6 +8,7 @@ import { PathQualifier } from "./helpers/path-helpers.js";
 import { create_export_map } from "../workspace/helpers/create-manifests.js";
 import { DependencyDeduplicationPlugin, collectLibraryGraph } from "./helpers/emit-esmodules.js";
 import { BundleManifestTask } from "./helpers/emit-bundle-manifest.js";
+import { ArtifactNpmTask } from "./helpers/emit-artifact.js";
 export var PathStatus;
 (function (PathStatus) {
     PathStatus[PathStatus["Unknown"] = undefined] = "Unknown";
@@ -18,7 +19,7 @@ export var PathStatus;
 })(PathStatus || (PathStatus = {}));
 export function create_bundle_target(opts) {
     const { bundle, library: lib, storage } = opts;
-    const target = new BuildTarget(bundle.id, storage, lib.workspace, opts.devmode == true, opts.watch == true, opts.clean == true);
+    const target = new BuildTarget(bundle.id, storage, lib, opts.devmode == true, opts.watch == true, opts.clean == true);
     // Prepare esm setup
     target.esmodules.set_root(lib.path);
     // Add bundle package.json
@@ -26,7 +27,7 @@ export function create_bundle_target(opts) {
     // Add bundle types.d.ts
     target.tasks.push(new TypescriptDefinitionTask(target, lib));
     // Add bundle exporteds
-    const entries = create_export_map(lib, lib.bundle);
+    const entries = create_export_map(lib, lib.master);
     for (const exp_id in entries) {
         const exp = entries[exp_id];
         target.esmodules.add_entry(exp.basename, exp.source);
@@ -34,11 +35,11 @@ export function create_bundle_target(opts) {
     // Add bundle content
     if (bundle) {
         // Add bundle manifest
-        target.tasks.push(new BundleManifestTask(target, lib.bundle));
+        target.tasks.push(new BundleManifestTask(target, bundle));
         // Add bundle components
         for (const [path, desc] of bundle.components) {
             const baseDir = Path.dirname(path);
-            target.add_component(desc, baseDir, lib);
+            target.add_component(desc, baseDir, bundle);
         }
     }
     // Add declarations descriptors
@@ -158,7 +159,7 @@ export function create_bundle_target(opts) {
                 return {
                     contents,
                     loader: "js",
-                    resolveDir: target.workspace.path,
+                    resolveDir: lib.path,
                 };
             });
             // Handle imports from within the proxy modules - these should be truly external
@@ -187,6 +188,9 @@ export async function build_app_composable_bundle(opts) {
             watch: opts.watch,
             clean: opts.clean,
         });
+        if (opts.artifactDir) {
+            target.finalTasks.push(new ArtifactNpmTask(target, opts.artifactDir));
+        }
         target.log.info(`Build bundle: ${target.name}`);
         await target.build();
         return target;
@@ -195,4 +199,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

@@ -7,6 +7,7 @@ import { PWAPackageTask, WebviewTask } from "./build-application.js";
 import { makeComponentPublication } from "../workspace/component.js";
 import { topologicalSort } from "../utils/graph-ordering.js";
 import { BuildTask } from "./helpers/task.js";
+import { ArtifactZipTask } from "./helpers/emit-artifact.js";
 export class ShelveManifestTask extends BuildTask {
     target;
     bundles;
@@ -45,11 +46,9 @@ export class ShelveManifestTask extends BuildTask {
 }
 function create_application_composable_target(opts) {
     const { app, bundles, version } = opts;
-    const { type, name, webviews, modules, assets, components } = app.descriptor;
-    const lib = app.library;
-    const bundle = lib.bundle;
-    const ws = lib.workspace;
-    const target = new BuildTarget(name, opts.storage, ws, opts.devmode == true, opts.watch == true, opts.clean == true);
+    const { name, webviews, modules, components } = app.descriptor;
+    const { library: lib } = app;
+    const target = new BuildTarget(name, opts.storage, lib, opts.devmode == true, opts.watch == true, opts.clean == true, opts.onNotification);
     // Prepare esm setup
     target.esmodules.set_root(lib.path);
     // Generate hotreload assets
@@ -70,7 +69,7 @@ function create_application_composable_target(opts) {
         const entry_name = lib.make_file_id("webview", name);
         const webview = {
             ...webviews[name],
-            entry: `./${bundle.id}/${entry_name}.js`,
+            entry: `./${lib.master.id}/${entry_name}.js`,
             favicon: favicon ? app.library.resolve_entry_path(favicon, Path.dirname(app.baseDir)) : null,
         };
         target.tasks.push(new WebviewTask(target, name, title || name, webview, html_injects));
@@ -82,7 +81,7 @@ function create_application_composable_target(opts) {
     for (const name in modules) {
         if (name.endsWith(".js")) {
             const entry_name = lib.make_file_id("module", name.slice(0, -3));
-            target.esmodules.add_entry_typescript(`export * from "./${bundle.id}/${entry_name}.js"`, name.slice(0, -3));
+            target.esmodules.add_entry_typescript(`export * from "./${lib.master.id}/${entry_name}.js"`, name.slice(0, -3));
             if (opts.devserver) {
                 target.log.info(`+ 🔌 module: ${name} : ${opts.devserver}/${name}`);
             }
@@ -107,14 +106,14 @@ function create_application_composable_target(opts) {
        }
     }*/
     // Add workspace assets
-    for (const lib of ws.libraries) {
-        for (const [path, desc] of lib.declarations) {
+    for (const slib of lib.workspace.libraries) {
+        for (const [path, desc] of slib.declarations) {
             if (!matchComponentSelection(components, desc.selectors))
                 continue;
             if (desc.assets) {
                 const baseDir = Path.dirname(path);
                 for (const entry of desc.assets) {
-                    target.assets.add_entry(entry, baseDir, lib);
+                    target.assets.add_entry(entry, baseDir, slib);
                 }
             }
         }
@@ -123,12 +122,11 @@ function create_application_composable_target(opts) {
 }
 export async function build_app_composable_host(opts) {
     const { app, storage } = opts;
-    const ws = app.library.workspace;
+    const { library: lib } = app;
     opts.storage.clean();
-    const shelveBundles = new BundleSelector(ws);
-    const { bundle } = app.library;
-    if (bundle)
-        shelveBundles.add(bundle);
+    const shelveBundles = new BundleSelector(lib.workspace);
+    if (lib.master)
+        shelveBundles.add(lib.master);
     const shelvePendings = [];
     for (const bundle of shelveBundles) {
         shelvePendings.push(build_app_composable_bundle({
@@ -141,7 +139,7 @@ export async function build_app_composable_host(opts) {
         }));
     }
     if (shelveBundles.missing.length > 0) {
-        ws.log.warn(`Missing bundle dependencies: ${shelveBundles.missing.join(", ")}`);
+        lib.log.warn(`Missing bundle dependencies: ${shelveBundles.missing.join(", ")}`);
     }
     const target = create_application_composable_target({
         app,
@@ -152,7 +150,11 @@ export async function build_app_composable_host(opts) {
         devserver: opts.devserver,
         watch: opts.devserver ? true : opts.watch,
         clean: opts.clean,
+        onNotification: opts.onNotification,
     });
+    if (opts.artifactDir) {
+        target.finalTasks.push(new ArtifactZipTask(target, opts.artifactDir, target.name));
+    }
     target.log.info(`Build app: ${target.name}`);
     return target.build();
 }
@@ -187,8 +189,8 @@ export class BundleSelector {
         if (bun.source) {
             for (const depId in bun.source.descriptor?.dependencies) {
                 const lib = this.workspace.get_library(depId);
-                if (lib?.bundle)
-                    this.add(lib.bundle);
+                if (lib?.master)
+                    this.add(lib.master);
             }
         }
         return this;
@@ -214,4 +216,3 @@ export class BundleSelector {
         return this.toArray().values();
     }
 }
-//# sourceMappingURL=build-app-host.js.map

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

@@ -0,0 +1,51 @@
+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";
+import type { BuildNotification } from "./build-target.ts";
+export type BuildApplicationOptions = {
+    app: AppEntry;
+    storage: StorageFiles;
+    version: string;
+    devmode?: boolean;
+    watch?: boolean;
+    clean?: boolean;
+    devserver?: string;
+    artifactDir?: string;
+    onNotification?: (event: BuildNotification) => void;
+};
+export declare function create_application_monolith_target(opts: {
+    app: AppEntry;
+    storage: StorageFiles;
+    version: string;
+    devmode: boolean;
+    devserver?: string;
+    watch: boolean;
+    clean: boolean;
+    onNotification?: BuildApplicationOptions["onNotification"];
+}): 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,41 +1,20 @@
 import Path from "node:path";
 import Sharp from "sharp";
-import MIME from 'mime';
-import { Library, matchComponentSelection } from "../workspace/workspace.js";
+import MIME from "mime";
+import { Bundle, matchComponentSelection } from "../workspace/workspace.js";
 import { StorageFiles } from "../workspace/storage.js";
 import { BuildTarget } from "./build-target.js";
 import { build_app_composable_host } from "./build-app-host.js";
 import { DependencyDeduplicationPlugin } from "./helpers/emit-esmodules.js";
-import { BundleManifestTask } from "./helpers/emit-bundle-manifest.js";
+import { ApplicationManifestTask } from "./helpers/emit-bundle-manifest.js";
 import { BuildTask } from "./helpers/task.js";
-function collect_app_libraries(app) {
-    const libs = [app.library];
-    function collect_library_deps(lib) {
-        const ws = lib.workspace;
-        const deps = {
-            ...lib.descriptor.dependencies,
-            ...lib.descriptor.peerDependencies,
-            ...lib.descriptor.optionalDependencies,
-        };
-        for (const depId in deps) {
-            const lib = ws.get_library(depId);
-            if (lib && !libs.includes(lib)) {
-                libs.push(lib);
-            }
-        }
-    }
-    for (let i = 0; i < libs.length; i++) {
-        collect_library_deps(libs[i]);
-    }
-    return libs;
-}
+import { ArtifactZipTask } from "./helpers/emit-artifact.js";
 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 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(", ")}`);
+    const { library: lib } = app;
+    const target = new BuildTarget(name, opts.storage, lib, opts.devmode == true, opts.watch == true, opts.clean == true, opts.onNotification);
+    target.log.info(`+ 📚 shelve: ${lib.shelve.map(b => b.id).join(", ")}`);
     // Prepare esm setup
     target.esmodules.set_root(lib.path);
     // Generate hotreload assets
@@ -62,12 +41,12 @@ export function create_application_monolith_target(opts) {
     for (const name in webviews) {
         const { title, favicon, entry } = webviews[name];
         const entry_name = lib.make_file_id("webview", name);
-        const entry_path = app.library.resolve_entry_path(entry, app.baseDir);
+        const entry_path = lib.resolve_entry_path(entry, app.baseDir);
         target.esmodules.add_entry(entry_name, entry_path);
         const webview = {
             ...webviews[name],
             entry: `./${entry_name}.js`,
-            favicon: favicon ? app.library.resolve_entry_path(favicon, app.baseDir) : null,
+            favicon: favicon ? lib.resolve_entry_path(favicon, app.baseDir) : null,
         };
         target.tasks.push(new WebviewTask(target, name, title || name, webview, html_injects));
         if (opts.devserver) {
@@ -76,7 +55,7 @@ export function create_application_monolith_target(opts) {
     }
     // Add application modules
     for (const name in modules) {
-        const entry_path = app.library.resolve_entry_path(modules[name], app.baseDir);
+        const entry_path = lib.resolve_entry_path(modules[name], app.baseDir);
         if (!entry_path) {
             target.log.error(`Invalid module '${name}' path at ${entry_path}`);
         }
@@ -94,65 +73,62 @@ export function create_application_monolith_target(opts) {
     // Add application static assets
     if (Array.isArray(assets)) {
         for (const asset of assets) {
-            target.assets.add_entry(asset, app.baseDir, app.library);
+            target.assets.add_entry(asset, app.baseDir, lib);
         }
     }
-    // Add bundle content
-    const { bundle } = lib;
-    if (bundle) {
-        // Add bundle manifest
-        target.tasks.push(new BundleManifestTask(target, bundle));
-        // Add workspace components
-        const added_components = new Map();
-        for (const lib of libs) {
-            if (lib.bundle) {
-                for (const [path, desc] of lib.bundle.components) {
-                    if (!matchComponentSelection(components, desc.selectors))
-                        continue;
-                    const cid = desc.$id;
-                    const added = added_components.get(cid);
-                    if (added) {
-                        target.log.error({
-                            id: "duplicate-component-skip",
-                            text: `skip duplicate component '${cid}'`,
-                            notes: [
-                                {
-                                    title: "kept",
-                                    text: `${added.lib.name}@${added.lib.descriptor.version}`,
-                                    location: added.path,
-                                },
-                                {
-                                    title: "skipped",
-                                    text: `${lib.name}@${lib.descriptor.version}`,
-                                    location: path,
-                                },
-                            ],
-                        });
-                        continue;
-                    }
-                    const baseDir = Path.dirname(path);
-                    target.add_component(desc, baseDir, lib);
-                    added_components.set(cid, { lib, path });
-                }
+    // Add workspace components
+    const added_components = new Map();
+    for (const bundle of lib.shelve) {
+        for (const [path, desc] of bundle.components) {
+            if (!matchComponentSelection(components, desc.selectors))
+                continue;
+            const cid = desc.$id;
+            const added = added_components.get(cid);
+            if (added) {
+                target.log.error({
+                    id: "duplicate-component-skip",
+                    text: `skip duplicate component '${cid}'`,
+                    notes: [
+                        {
+                            title: "kept",
+                            text: `${added.bundle.id}`,
+                            location: added.path,
+                        },
+                        {
+                            title: "skipped",
+                            text: `${bundle.id}`,
+                            location: path,
+                        },
+                    ],
+                });
+                continue;
             }
+            const baseDir = Path.dirname(path);
+            target.add_component(desc, baseDir, bundle);
+            added_components.set(cid, { bundle, path });
         }
     }
+    // Add bundle manifest
+    target.tasks.push(new ApplicationManifestTask(target, app.descriptor));
     // Add workspace assets
-    for (const lib of libs) {
-        for (const [path, desc] of lib.declarations) {
+    for (const bundle of lib.shelve) {
+        if (!bundle.source)
+            continue;
+        for (const [path, desc] of bundle.source.declarations) {
             if (!matchComponentSelection(components, desc.selectors))
                 continue;
             if (desc.assets) {
                 const baseDir = Path.dirname(path);
                 for (const entry of desc.assets) {
-                    target.assets.add_entry(entry, baseDir, lib);
+                    target.assets.add_entry(entry, baseDir, bundle.source);
                 }
             }
         }
     }
     // Register esbuild plugin for dependency deduplication (graph-based + singleton)
+    const bundleLibs = lib.shelve.map(b => b.source).filter(Boolean);
     const rootNodeModules = lib.search_directories[0] || Path.join(lib.path, 'node_modules');
-    target.esmodules.plugins.push(DependencyDeduplicationPlugin(libs, rootNodeModules, target.log));
+    target.esmodules.plugins.push(DependencyDeduplicationPlugin(bundleLibs, rootNodeModules, target.log));
     return target;
 }
 export async function build_app_monolith(opts) {
@@ -166,7 +142,11 @@ export async function build_app_monolith(opts) {
         devserver: opts.devserver,
         watch: opts.devserver ? true : opts.watch,
         clean: opts.clean,
+        onNotification: opts.onNotification,
     });
+    if (opts.artifactDir) {
+        target.finalTasks.push(new ArtifactZipTask(target, opts.artifactDir, target.name));
+    }
     target.log.info(`Build app: ${target.name}`);
     return target.build();
 }
@@ -312,4 +292,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,21 @@
+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;
+    artifactDir?: string;
+};
+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";
@@ -8,13 +8,14 @@ import { PackageManifestTask } from "./helpers/emit-package-manifest.js";
 import { create_export_map } from "../workspace/helpers/create-manifests.js";
 import { BundleManifestTask } from "./helpers/emit-bundle-manifest.js";
 import { ComponentsDtsTask } from "./helpers/emit-components-dts.js";
+import { ArtifactNpmTask } from "./helpers/emit-artifact.js";
 export function create_library_target(opts) {
     const lib = opts.library;
-    const target = new BuildTarget(lib.name, opts.storage, lib.workspace, opts.devmode == true, opts.watch == true, opts.clean == true);
+    const target = new BuildTarget(lib.name, opts.storage, lib, opts.devmode == true, opts.watch == true, opts.clean == true);
     // Prepare esm setup
     target.esmodules.set_root(lib.path);
     // Add bundle exporteds
-    const entries = create_export_map(lib, lib.bundle);
+    const entries = create_export_map(lib, lib.master);
     for (const exp_id in entries) {
         const exp = entries[exp_id];
         target.esmodules.add_entry(exp.basename, exp.source);
@@ -23,16 +24,16 @@ export function create_library_target(opts) {
     target.tasks.push(new TypescriptDefinitionTask(target, lib));
     // Add library package.json
     target.tasks.push(new PackageManifestTask(target, lib, opts.version));
-    target.tasks.push(new ComponentsDtsTask(target, lib.bundle));
+    target.tasks.push(new ComponentsDtsTask(target, lib.master));
     // Add bundle content
-    const { bundle } = lib;
-    if (bundle) {
+    const { master } = lib;
+    if (master) {
         // Add bundle catalog
-        target.tasks.push(new BundleManifestTask(target, bundle));
+        target.tasks.push(new BundleManifestTask(target, master));
         // Add library components
-        for (const [path, desc] of bundle.components) {
+        for (const [path, desc] of master.components) {
             const baseDir = Path.dirname(path);
-            target.add_component(desc, baseDir, lib);
+            target.add_component(desc, baseDir, master);
         }
     }
     // Add declarations descriptors
@@ -70,10 +71,12 @@ export async function build_library(opts, packageDir) {
         watch: opts.watch,
         clean: opts.clean,
     });
+    if (opts.artifactDir) {
+        target.finalTasks.push(new ArtifactNpmTask(target, opts.artifactDir));
+    }
     target.log.info(`Build library: ${target.name}`);
     await target.build();
     if (!target.watch && 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,36 @@
+import { type ComponentManifest } from "../workspace/component.ts";
+import { Bundle, Library } 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 type BuildNotification = {
+    target?: string;
+    task?: string;
+} & ({
+    type: "build-complete";
+    elapsed: number;
+});
+export declare class BuildTarget {
+    readonly name: string;
+    readonly storage: IStorageZone;
+    readonly library: Library;
+    readonly devmode: boolean;
+    readonly watch: boolean;
+    readonly clean: boolean;
+    readonly onNotification?: (event: BuildNotification) => void;
+    components: Map<string, ComponentManifest>;
+    esmodules: ESModulesTask;
+    assets: AssetsTask;
+    tasks: BuildTask[];
+    finalTasks: BuildTask[];
+    transaction: IStorageTransaction;
+    readonly log: Log;
+    constructor(name: string, storage: IStorageZone, library: Library, devmode: boolean, watch: boolean, clean: boolean, onNotification?: (event: BuildNotification) => void);
+    edit(): IStorageTransaction;
+    store(): Promise<void>;
+    add_component(descriptor: ComponentManifest, baseDir: string, origin: Bundle): boolean;
+    private chrona;
+    build(): Promise<void>;
+}