@jointhedots/gear 1.2.0 → 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

@@ -195,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";
@@ -312,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

@@ -107,4 +107,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-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";
@@ -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 {};

package/esm/commands/make.js

@@ -1,11 +1,11 @@
-import Path from 'node:path';
+import Path from "node:path";
 import {} from "yargs";
 import { StorageFiles } from "../workspace/storage.js";
 import { Bundle, Library, open_workspace } from "../workspace/workspace.js";
 import { build_application } from "../builder/build-application.js";
 import { build_app_composable_bundle } from "../builder/build-app-bundle.js";
 import { build_library } from "../builder/build-library.js";
-import { makeNormalizedName, NameStyle } from '../utils/normalized-name.js';
+import { makeNormalizedName, NameStyle } from "../utils/normalized-name.js";
 import { resolvePackageVersion } from "../workspace/helpers/package-npm.js";
 export function command_make() {
     return {
@@ -155,4 +155,3 @@ export function command_make() {
         }
     };
 }
-//# sourceMappingURL=make.js.map

package/esm/commands/run.d.ts

@@ -0,0 +1,8 @@
+import { type CommandModule } from "yargs";
+export declare function command_run(): CommandModule<any, {
+    dir?: string;
+    entry?: string;
+    inspect?: number;
+    break?: boolean;
+    "--"?: string[];
+}>;

package/esm/commands/run.js

@@ -1,8 +1,8 @@
-import NodeWatch from "node-watch";
-import Process from 'process';
-import Path from 'path';
-import ChildProcess from 'child_process';
-import { createRequire } from "module";
+import Fs from "node:fs";
+import Process from "node:process";
+import Path from "node:path";
+import ChildProcess from "node:child_process";
+import { createRequire } from "node:module";
 import {} from "yargs";
 const restart_always_on_change = true;
 const require = createRequire(import.meta.url);
@@ -101,10 +101,9 @@ export function command_run() {
             Process.stdin.setRawMode(true);
             Process.stdin.resume();
             Process.stdin.on('data', onKeyPress);
-            const watcher = NodeWatch(argv.dir, { recursive: true });
+            const watcher = Fs.watch(argv.dir, { recursive: true });
             watcher.on('change', () => restart());
             start();
         }
     };
 }
-//# sourceMappingURL=run.js.map

package/esm/commands/serve.d.ts

@@ -0,0 +1,9 @@
+import { type CommandModule } from "yargs";
+export declare function command_serve(): CommandModule<any, {
+    app?: string;
+    port?: number;
+    versioned?: string;
+    devmode?: boolean;
+    ws?: string;
+    dist?: string;
+}>;

package/esm/commands/serve.js

@@ -1,10 +1,10 @@
-import Path from 'node:path';
+import Path from "node:path";
 import {} from "yargs";
 import { StorageFiles } from "../workspace/storage.js";
 import { open_workspace, Workspace } from "../workspace/workspace.js";
 import { build_application } from "../builder/build-application.js";
-import { makeNormalizedName, NameStyle } from '../utils/normalized-name.js';
-import Express from 'express';
+import { makeNormalizedName, NameStyle } from "../utils/normalized-name.js";
+import Express from "express";
 import { resolvePackageVersion } from "../workspace/helpers/package-npm.js";
 export function command_serve() {
     return {
@@ -90,4 +90,3 @@ async function serve(ws, port, storage) {
         process.on('SIGQUIT', () => resolve(null));
     });
 }
-//# sourceMappingURL=serve.js.map