@jointhedots/gear 1.2.0 → 1.2.3

package/esm/builder/build-target.js

@@ -1,29 +1,32 @@
 import {} from "../workspace/component.js";
-import { Library, Workspace } from "../workspace/workspace.js";
+import { Bundle, Library } from "../workspace/workspace.js";
 import { ESModulesTask } from "./helpers/emit-esmodules.js";
 import {} from "../workspace/storage.js";
 import { AssetsTask } from "./helpers/emit-static-assets.js";
 export class BuildTarget {
     name;
     storage;
-    workspace;
+    library;
     devmode;
     watch;
     clean;
+    onNotification;
     components = new Map();
     esmodules = new ESModulesTask(this);
     assets = new AssetsTask(this);
     tasks = [];
+    finalTasks = [];
     transaction = null;
     log;
-    constructor(name, storage, workspace, devmode, watch, clean) {
+    constructor(name, storage, library, devmode, watch, clean, onNotification) {
         this.name = name;
         this.storage = storage;
-        this.workspace = workspace;
+        this.library = library;
         this.devmode = devmode;
         this.watch = watch;
         this.clean = clean;
-        this.log = workspace.logger.get(`build:${name}`);
+        this.onNotification = onNotification;
+        this.log = library.log.logger.get(`build:${name}`);
     }
     edit() {
         if (!this.transaction)
@@ -36,10 +39,11 @@ export class BuildTarget {
             this.transaction = null;
         }
     }
-    add_component(descriptor, baseDir, library) {
+    add_component(descriptor, baseDir, origin) {
         const id = descriptor.$id;
         if (this.components.has(id)) {
-            throw new Error(createComponentDuplicateMessage(id, library));
+            this.log.error(createComponentDuplicateMessage(id, origin));
+            return false;
         }
         const manifest = {
             ...descriptor,
@@ -50,16 +54,17 @@ export class BuildTarget {
         if (descriptor.apis) {
             manifest.apis = {};
             for (const name in descriptor.apis) {
-                manifest.apis[name] = this.esmodules.add_resource_entry(descriptor.apis[name], baseDir, library);
+                manifest.apis[name] = this.esmodules.add_resource_entry(descriptor.apis[name], baseDir, origin);
             }
         }
         if (descriptor.resources) {
             manifest.resources = {};
             for (const name in descriptor.resources) {
-                manifest.resources[name] = this.esmodules.add_resource_entry(descriptor.resources[name], baseDir, library);
+                manifest.resources[name] = this.esmodules.add_resource_entry(descriptor.resources[name], baseDir, origin);
             }
         }
         this.components.set(id, manifest);
+        return true;
     }
     async chrona(task) {
         const name = task.constructor.name;
@@ -84,6 +89,7 @@ export class BuildTarget {
         // Trace time
         const buildTime = (Date.now() - buildStartTime) / 1000;
         this.log.info(`Build completed in ${buildTime.toFixed(2)}s`);
+        this.onNotification?.({ type: "build-complete", target: this.name, elapsed: buildTime });
         if (this.watch) {
             await new Promise((resolve) => {
                 process.on('SIGQUIT', () => resolve(null));
@@ -91,13 +97,16 @@ export class BuildTarget {
         }
         else {
             await this.store();
+            for (const task of this.finalTasks) {
+                await this.chrona(task);
+            }
         }
     }
 }
-function createComponentDuplicateMessage(id, library) {
+function createComponentDuplicateMessage(id, origin) {
     const duplicates = [];
     const libs = [];
-    for (const bun of library.shelve) {
+    for (const bun of origin.library.shelve) {
         for (const [cpath, cmanifest] of bun.components.entries()) {
             if (cmanifest.$id === id) {
                 duplicates.push(`\n - ${cpath}`);
@@ -107,4 +116,3 @@ function createComponentDuplicateMessage(id, library) {
     }
     return `Component '${id}' declared multiple times: ${duplicates.join("")}\n> libraries:${libs.join("")}\n`;
 }
-//# sourceMappingURL=build-target.js.map

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

@@ -0,0 +1,13 @@
+import { BuildTask } from "./task.ts";
+import type { BuildTarget } from "../build-target.ts";
+export declare class ArtifactNpmTask extends BuildTask {
+    readonly outputDir: string;
+    constructor(target: BuildTarget, outputDir: string);
+    execute(): Promise<void>;
+}
+export declare class ArtifactZipTask extends BuildTask {
+    readonly outputDir: string;
+    readonly name: string;
+    constructor(target: BuildTarget, outputDir: string, name: string);
+    execute(): Promise<void>;
+}

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

@@ -0,0 +1,40 @@
+import Path from "node:path";
+import FS from "node:fs";
+import ChildProcess from "node:child_process";
+import { BuildTask } from "./task.js";
+export class ArtifactNpmTask extends BuildTask {
+    outputDir;
+    constructor(target, outputDir) {
+        super(target);
+        this.outputDir = outputDir;
+    }
+    async execute() {
+        const sourceDir = this.target.storage.getBaseDirFS();
+        FS.mkdirSync(this.outputDir, { recursive: true });
+        this.log.info(`📦 npm pack → ${this.outputDir}`);
+        ChildProcess.execSync("npm pack --pack-destination " + JSON.stringify(this.outputDir), { cwd: sourceDir });
+    }
+}
+export class ArtifactZipTask extends BuildTask {
+    outputDir;
+    name;
+    constructor(target, outputDir, name) {
+        super(target);
+        this.outputDir = outputDir;
+        this.name = name;
+    }
+    async execute() {
+        const sourceDir = this.target.storage.getBaseDirFS();
+        FS.mkdirSync(this.outputDir, { recursive: true });
+        const outPath = Path.join(this.outputDir, `${this.name}.zip`);
+        this.log.info(`📦 zip → ${outPath}`);
+        const parent = Path.dirname(sourceDir);
+        const base = Path.basename(sourceDir);
+        if (process.platform === 'win32') {
+            ChildProcess.execSync(`powershell -NoProfile -Command "Compress-Archive -Path '${base}\\*' -DestinationPath '${outPath}' -Force"`, { cwd: parent });
+        }
+        else {
+            ChildProcess.execSync(`zip -r ${JSON.stringify(outPath)} ${JSON.stringify(base)}`, { cwd: parent });
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+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 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 {
+import MIME from "mime";
+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,19 +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: {},
+        });
     }
 }
-//# 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, WorkspaceItem } 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, origin: WorkspaceItem): ResourceEntry;
+    execute(): Promise<void>;
+}

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

@@ -1,12 +1,12 @@
 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 { 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 {
@@ -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

@@ -11,9 +11,8 @@ 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));
     }
 }
-//# 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";
@@ -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();
@@ -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, {}>;