@jointhedots/gear 1.1.11 → 1.1.13

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

@@ -1,11 +1,13 @@
+import Path from "node:path";
 import { Bundle, Library } from "../model/workspace.js";
 import { StorageFiles } from "../model/storage.js";
-import { BuildTarget, BundleManifestTask } from "./build-target.js";
-import { TypescriptDefinitionTask } from "./emit-dts.js";
-import Path from "node:path";
+import { BuildTarget } from "./build-target.js";
+import { TypescriptDefinitionTask } from "./helpers/emit-typescript-definition.js";
+import { PackageManifestTask } from "./helpers/emit-package-manifest.js";
 import { PathQualifier } from "./helpers/path-helpers.js";
-import { create_manifests } from "../model/helpers/create-manifests.js";
-import { DependencyDeduplicationPlugin, collectLibraryGraph } from "./esbuild-plugins.js";
+import { create_export_map } from "../model/helpers/create-manifests.js";
+import { DependencyDeduplicationPlugin, collectLibraryGraph } from "./helpers/emit-esmodules.js";
+import { BundleManifestTask } from "./helpers/emit-bundle-manifest.js";
 export var PathStatus;
 (function (PathStatus) {
     PathStatus[PathStatus["Unknown"] = undefined] = "Unknown";
@@ -18,16 +20,16 @@ export function create_bundle_target(opts) {
     const { bundle, library, storage } = opts;
     const lib = library;
     const target = new BuildTarget(bundle.id, storage, lib.workspace, opts.devmode == true, opts.watch == true, opts.clean == true);
-    const manifs = create_manifests(lib, bundle, opts.version);
     // Prepare esm setup
     target.esmodules.set_root(lib.path);
     // Add bundle package.json
-    target.assets.add_static_json("package.json", manifs.package);
+    target.tasks.push(new PackageManifestTask(target, lib, opts.version));
     // Add bundle types.d.ts
     target.tasks.push(new TypescriptDefinitionTask(target, lib));
     // Add bundle exporteds
-    for (const exp_id in manifs.entries) {
-        const exp = manifs.entries[exp_id];
+    const entries = create_export_map(lib, lib.bundle);
+    for (const exp_id in entries) {
+        const exp = entries[exp_id];
         target.esmodules.add_entry(exp.basename, exp.source);
     }
     // Add bundle content

package/esm/builder/build-application.js

@@ -1,12 +1,13 @@
-import { Library, matchComponentSelection } from "../model/workspace.js";
-import { StorageFiles } from "../model/storage.js";
-import { BuildTarget, BuildTask, BundleManifestTask } from "./build-target.js";
 import Path from "node:path";
-import Fs from "node:fs";
 import Sharp from "sharp";
 import MIME from 'mime';
+import { Library, matchComponentSelection } from "../model/workspace.js";
+import { StorageFiles } from "../model/storage.js";
+import { BuildTarget } from "./build-target.js";
 import { build_app_composable_host } from "./build-app-host.js";
-import { DependencyDeduplicationPlugin } from "./esbuild-plugins.js";
+import { DependencyDeduplicationPlugin } from "./helpers/emit-esmodules.js";
+import { BundleManifestTask } 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) {

package/esm/builder/build-library.js

@@ -1,25 +1,27 @@
+import Path from "node:path";
+import ChildProcess from "child_process";
 import { Library } from "../model/workspace.js";
 import { StorageFiles } from "../model/storage.js";
-import ChildProcess from "child_process";
-import { BuildTarget, BundleManifestTask } from "./build-target.js";
-import { TypescriptDefinitionTask } from "./emit-dts.js";
-import Path from "node:path";
-import { create_manifests } from "../model/helpers/create-manifests.js";
+import { BuildTarget } from "./build-target.js";
+import { TypescriptDefinitionTask } from "./helpers/emit-typescript-definition.js";
+import { PackageManifestTask } from "./helpers/emit-package-manifest.js";
+import { create_export_map } from "../model/helpers/create-manifests.js";
+import { BundleManifestTask } from "./helpers/emit-bundle-manifest.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 manifs = create_manifests(lib, lib.bundle, opts.version);
     // Prepare esm setup
     target.esmodules.set_root(lib.path);
     // Add bundle exporteds
-    for (const exp_id in manifs.entries) {
-        const exp = manifs.entries[exp_id];
+    const entries = create_export_map(lib, lib.bundle);
+    for (const exp_id in entries) {
+        const exp = entries[exp_id];
         target.esmodules.add_entry(exp.basename, exp.source);
     }
     // Add library types.d.ts
     target.tasks.push(new TypescriptDefinitionTask(target, lib));
     // Add library package.json
-    target.assets.add_static_json("package.json", manifs.package);
+    target.tasks.push(new PackageManifestTask(target, lib, opts.version));
     // Add bundle content
     const { bundle } = lib;
     if (bundle) {

package/esm/builder/build-target.js

@@ -1,145 +1,8 @@
-import Path from "node:path";
-import MIME from 'mime';
-import { makeComponentPublication } from "../model/component.js";
-import { Bundle, Library, Workspace } from "../model/workspace.js";
-import { create_esbuild_context } from "../builder/esbuild-plugins.js";
-import { copyToStorageStream } from "../model/storage.js";
-import * as esbuild from 'esbuild';
-import { computeNameHashID } from "../utils/normalized-name.js";
-export class BuildTask {
-    target;
-    constructor(target) {
-        this.target = target;
-    }
-    get log() { return this.target.log; }
-    async init() { }
-}
-export class BundleManifestTask extends BuildTask {
-    target;
-    bundle;
-    constructor(target, bundle) {
-        super(target);
-        this.target = target;
-        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));
-    }
-}
-export class AssetsTask extends BuildTask {
-    assets = [];
-    statics = {};
-    add_entry(entry, baseDir, library) {
-        let asset = null;
-        if (typeof entry === "string") {
-            const from = library.resolve_entry_path(entry, baseDir);
-            if (!from)
-                throw new Error(`In '${baseDir}', cannot found asset from: '${entry}'`);
-            asset = { from, to: Path.basename(entry) };
-        }
-        else {
-            const from = library.resolve_entry_path(entry.from, baseDir);
-            if (!from)
-                throw new Error(`In '${baseDir}', cannot found asset from: '${entry.from}'`);
-            asset = { from, to: entry.to };
-        }
-        this.log.info(`+ 📎 assets '${library.name}': ${asset.from} -> ${asset.to}`);
-        this.assets.push(asset);
-    }
-    add_static_text(name, data) {
-        this.statics[name] = data;
-    }
-    add_static_json(name, data) {
-        this.statics[name] = JSON.stringify(data, null, 2);
-    }
-    async execute() {
-        const tx = this.target.edit();
-        for (const key in this.statics) {
-            tx.commitFile(key, this.statics[key], MIME.getType(key));
-        }
-        for (const asset of this.assets) {
-            if (typeof asset === "string") {
-                copyToStorageStream(tx, asset, asset);
-            }
-            else {
-                copyToStorageStream(tx, asset.to, asset.from);
-            }
-        }
-    }
-}
-export class ESModulesTask extends BuildTask {
-    entries = {};
-    imports = {};
-    internals = new Map();
-    plugins = [];
-    context = null;
-    transaction = null;
-    polyfilled = true;
-    rootPath = null;
-    set_root(path) {
-        this.rootPath = path;
-    }
-    add_entry(name, path) {
-        this.entries[name] = path;
-        this.imports[path] = name;
-    }
-    add_entry_typescript(code, name) {
-        const id = computeNameHashID(code);
-        if (!name)
-            name = id;
-        this.internals.set(id, code);
-        this.add_entry(name, id);
-        return name;
-    }
-    add_resource_entry(resource, baseDir, library) {
-        if (typeof resource === "string") {
-            const parts = resource.split("#");
-            const file = library.resolve_entry_path(parts[0], baseDir);
-            if (file) {
-                let named = this.imports[file];
-                if (!named) {
-                    named = library.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]}`);
-            }
-        }
-        else {
-            return resource;
-        }
-    }
-    async execute() {
-        if (this.context) {
-            const prev_ctx = this.context;
-            this.context = null;
-            await prev_ctx.dispose();
-        }
-        const { target } = this;
-        this.context = await create_esbuild_context(this, target.devmode);
-        if (target.watch) {
-            await this.context.watch();
-        }
-        else {
-            await this.context.rebuild();
-            await this.context.dispose();
-        }
-    }
-}
+import {} from "../model/component.js";
+import { Library, Workspace } from "../model/workspace.js";
+import { ESModulesTask } from "./helpers/emit-esmodules.js";
+import {} from "../model/storage.js";
+import { AssetsTask } from "./helpers/emit-static-assets.js";
 export class BuildTarget {
     name;
     storage;

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

@@ -0,0 +1,29 @@
+import { makeComponentPublication } from "../../model/component.js";
+import { BuildTarget } from "../build-target.js";
+import { BuildTask } from "./task.js";
+import MIME from 'mime';
+export class BundleManifestTask extends BuildTask {
+    target;
+    bundle;
+    constructor(target, bundle) {
+        super(target);
+        this.target = target;
+        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));
+    }
+}
+//# sourceMappingURL=emit-bundle-manifest.js.map

package/esm/builder/{esbuild-plugins.js → helpers/emit-esmodules.js}

@@ -5,9 +5,10 @@ import MIME from 'mime';
 import postcss from 'postcss';
 import * as esbuild from 'esbuild';
 import { sassPlugin } from 'esbuild-sass-plugin';
-import { ESModulesTask } from "./build-target.js";
-import { PackageRootDir } from "../utils/file.js";
-import { Library } from "../model/workspace.js";
+import { PackageRootDir, resolve_normalized_suffixed_path } from "../../utils/file.js";
+import { Library } from "../../model/workspace.js";
+import { computeNameHashID } from "../../utils/normalized-name.js";
+import { BuildTask } from "./task.js";
 const VirtualOutDir = Path.normalize('X:/');
 function getEsbuildLogLevel(mode) {
     switch (mode) {
@@ -486,30 +487,6 @@ export function ESModuleResolverPlugin(opts, tsconfigPaths) {
         ".ts": "ts", ".tsx": "tsx", ".js": "js", ".jsx": "jsx",
         ".json": "json", ".txt": "text", ".md": "text", ".css": "css",
     };
-    const FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.json'];
-    /** Resolve a file path with extension probing */
-    function resolveFilePath(importPath, baseDir) {
-        const resolved = Path.resolve(baseDir, importPath);
-        // Check if exact path exists
-        if (Fs.existsSync(resolved) && Fs.statSync(resolved).isFile()) {
-            return resolved;
-        }
-        // Try with common extensions
-        for (const ext of FILE_EXTENSIONS) {
-            const withExt = resolved + ext;
-            if (Fs.existsSync(withExt))
-                return withExt;
-        }
-        // Try index files in directory
-        if (Fs.existsSync(resolved) && Fs.statSync(resolved).isDirectory()) {
-            for (const ext of FILE_EXTENSIONS) {
-                const indexPath = Path.join(resolved, `index${ext}`);
-                if (Fs.existsSync(indexPath))
-                    return indexPath;
-            }
-        }
-        return null;
-    }
     return {
         name: 'esm-resolver',
         setup(build) {
@@ -546,14 +523,16 @@ 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 resolved = resolveFilePath(args.path, baseDir);
+                    const resolved = resolve_normalized_suffixed_path(baseDir, args.path);
                     if (resolved) {
                         return { path: resolved, namespace: "file" };
                     }
                 }
                 // 4. Resolve tsconfig path aliases (e.g. @app/* -> ./src/*)
                 if (tsconfigPaths?.hasAliases) {
-                    const resolved = tsconfigPaths.resolve(args.path, resolveFilePath);
+                    const resolved = tsconfigPaths.resolve(args.path, (importPath, baseDir) => {
+                        return resolve_normalized_suffixed_path(baseDir, importPath);
+                    });
                     if (resolved) {
                         return { path: resolved, namespace: "file" };
                     }
@@ -572,4 +551,65 @@ export function ESModuleResolverPlugin(opts, tsconfigPaths) {
         },
     };
 }
-//# sourceMappingURL=esbuild-plugins.js.map
+export class ESModulesTask extends BuildTask {
+    entries = {};
+    imports = {};
+    internals = new Map();
+    plugins = [];
+    context = null;
+    transaction = null;
+    polyfilled = true;
+    rootPath = null;
+    set_root(path) {
+        this.rootPath = path;
+    }
+    add_entry(name, path) {
+        this.entries[name] = path;
+        this.imports[path] = name;
+    }
+    add_entry_typescript(code, name) {
+        const id = computeNameHashID(code);
+        if (!name)
+            name = id;
+        this.internals.set(id, code);
+        this.add_entry(name, id);
+        return name;
+    }
+    add_resource_entry(resource, baseDir, library) {
+        if (typeof resource === "string") {
+            const parts = resource.split("#");
+            const file = library.resolve_entry_path(parts[0], baseDir);
+            if (file) {
+                let named = this.imports[file];
+                if (!named) {
+                    named = library.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]}`);
+            }
+        }
+        else {
+            return resource;
+        }
+    }
+    async execute() {
+        if (this.context) {
+            const prev_ctx = this.context;
+            this.context = null;
+            await prev_ctx.dispose();
+        }
+        const { target } = this;
+        this.context = await create_esbuild_context(this, target.devmode);
+        if (target.watch) {
+            await this.context.watch();
+        }
+        else {
+            await this.context.rebuild();
+            await this.context.dispose();
+        }
+    }
+}
+//# sourceMappingURL=emit-esmodules.js.map

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

@@ -0,0 +1,19 @@
+import { BuildTask } from "./task.js";
+import { create_export_map, create_package_manifest } from "../../model/helpers/create-manifests.js";
+import { console } from "node:inspector";
+export class PackageManifestTask extends BuildTask {
+    library;
+    version;
+    constructor(target, library, version) {
+        super(target);
+        this.library = library;
+        this.version = version;
+    }
+    async execute() {
+        const { library, version } = this;
+        const pkg = create_package_manifest(library, library.bundle, 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.js

@@ -0,0 +1,47 @@
+import Path from "node:path";
+import MIME from 'mime';
+import { Library } from "../../model/workspace.js";
+import { copyToStorageStream } from "../../model/storage.js";
+import { BuildTask } from "./task.js";
+export class AssetsTask extends BuildTask {
+    assets = [];
+    statics = {};
+    add_entry(entry, baseDir, library) {
+        let asset = null;
+        if (typeof entry === "string") {
+            const from = library.resolve_entry_path(entry, baseDir);
+            if (!from)
+                throw new Error(`In '${baseDir}', cannot found asset from: '${entry}'`);
+            asset = { from, to: Path.basename(entry) };
+        }
+        else {
+            const from = library.resolve_entry_path(entry.from, baseDir);
+            if (!from)
+                throw new Error(`In '${baseDir}', cannot found asset from: '${entry.from}'`);
+            asset = { from, to: entry.to };
+        }
+        this.log.info(`+ 📎 assets '${library.name}': ${asset.from} -> ${asset.to}`);
+        this.assets.push(asset);
+    }
+    add_static_text(name, data) {
+        this.statics[name] = data;
+    }
+    add_static_json(name, data) {
+        this.statics[name] = JSON.stringify(data, null, 2);
+    }
+    async execute() {
+        const tx = this.target.edit();
+        for (const key in this.statics) {
+            tx.commitFile(key, this.statics[key], MIME.getType(key));
+        }
+        for (const asset of this.assets) {
+            if (typeof asset === "string") {
+                copyToStorageStream(tx, asset, asset);
+            }
+            else {
+                copyToStorageStream(tx, asset.to, asset.from);
+            }
+        }
+    }
+}
+//# sourceMappingURL=emit-static-assets.js.map

package/esm/builder/{emit-dts.js → helpers/emit-typescript-definition.js}

@@ -2,9 +2,11 @@ import * as Glob from 'glob';
 import Os from 'os';
 import Path from 'path';
 import Ts from 'typescript';
-import { BuildTarget, BuildTask } from './build-target.js';
-import { Library } from '../model/workspace.js';
-import { file } from '../utils/file.js';
+import { BuildTask } from "./task.js";
+import { BuildTarget } from "../build-target.js";
+import { Library } from "../../model/workspace.js";
+import { file } from "../../utils/file.js";
+import { create_export_map } from "../../model/helpers/create-manifests.js";
 const eol = Os.EOL;
 const indent = "    ";
 const DTSLEN = '.d.ts'.length;
@@ -178,44 +180,42 @@ export function generateTypescriptDefinition(options) {
     const sourcesMap = {};
     const internalsMap = {};
     project.getSourceFiles().some(function (sourceFile) {
-        if (sourceFile.fileName.indexOf(normalizedBaseDir) !== 0)
+        const { fileName } = sourceFile;
+        if (fileName.indexOf(normalizedBaseDir) !== 0)
             return;
-        if (excludesMap[sourceFile.fileName])
+        if (excludesMap[fileName])
             return;
-        const shortName = sourceFile.fileName.slice(normalizedBaseDir.length);
-        const shortNameNoExt = shortName.slice(0, -Path.extname(sourceFile.fileName).length);
+        const shortName = fileName.slice(normalizedBaseDir.length);
+        const shortNameNoExt = shortName.slice(0, -Path.extname(fileName).length);
         const strippedShortName = stripBaseUrlPrefix(shortName);
         const strippedShortNameNoExt = stripBaseUrlPrefix(shortNameNoExt);
-        let moduleId = `${options.prefix}/${strippedShortNameNoExt}`;
+        const moduleId = `${options.prefix}/${strippedShortNameNoExt}`;
         internalsMap[shortName] = moduleId;
         internalsMap[shortNameNoExt] = moduleId;
         internalsMap[strippedShortName] = moduleId;
         internalsMap[strippedShortNameNoExt] = moduleId;
-        sourcesMap[sourceFile.fileName] = true;
+        sourcesMap[fileName] = true;
     });
     // Build reverse map from internal paths to export names
     // e.g., "src/Inputs" -> "./Inputs" means internal path "src/Inputs" exports as "prefix/Inputs"
     // Store as [internalPrefix, exportName] pairs for prefix matching
     if (options.exports) {
-        for (const [exportPath, value] of Object.entries(options.exports)) {
-            const exported = typeof value === 'string' ? value : (value.import || value.default || value.types || '');
-            if (!exported)
+        for (const entry of Object.values(options.exports)) {
+            const fileName = entry.source;
+            if (fileName.indexOf(normalizedBaseDir) !== 0)
                 continue;
-            let exportId = exportPath.replace(/^\.\//, '').replace(/\/$/, '');
-            if (exportId === '.')
-                exportId = options.prefix;
-            else
-                exportId = `${options.prefix}/${exportId}`;
-            // Normalize internal path: remove leading ./, strip extensions
-            const internalPath = normalizeFileName(exported);
-            let shortNameNoExt = internalPath.replace(/^\.\//, '').replace(/\.(ts|tsx|js|jsx)$/, '');
-            if (shortNameNoExt.endsWith('/index'))
-                shortNameNoExt = shortNameNoExt.slice(0, -6);
+            if (excludesMap[fileName])
+                continue;
+            const shortName = fileName.slice(normalizedBaseDir.length);
+            const shortNameNoExt = shortName.slice(0, -Path.extname(fileName).length);
+            const strippedShortName = stripBaseUrlPrefix(shortName);
             const strippedShortNameNoExt = stripBaseUrlPrefix(shortNameNoExt);
-            //this.log.info(shortNameNoExt, "->", exportId)
-            //this.log.info(strippedShortNameNoExt, "->", exportId)
-            internalsMap[shortNameNoExt] = exportId;
-            internalsMap[strippedShortNameNoExt] = exportId;
+            const moduleId = entry.id;
+            internalsMap[shortName] = moduleId;
+            internalsMap[shortNameNoExt] = moduleId;
+            internalsMap[strippedShortName] = moduleId;
+            internalsMap[strippedShortNameNoExt] = moduleId;
+            sourcesMap[fileName] = true;
         }
     }
     // Unified module ID normalization: strip extensions, baseUrl prefix, and remap to exports
@@ -224,18 +224,11 @@ export function generateTypescriptDefinition(options) {
         moduleId = moduleId.replace(/\.(d\.ts|ts|tsx|js|jsx)$/, '');
         // Strip baseUrl prefix
         moduleId = stripBaseUrlPrefix(moduleId);
-        // Strip index suffix
-        if (moduleId === "index") {
-            return options.prefix;
-        }
-        if (moduleId.endsWith("/index")) {
-            moduleId = moduleId.slice(0, -6);
-        }
         // Apply resolved prefix
-        if (internalsMap[moduleId]) {
-            moduleId = internalsMap[moduleId];
-        }
-        return moduleId;
+        const remapped = internalsMap[moduleId] ||
+            internalsMap[moduleId + "/index"] ||
+            internalsMap[moduleId + "/index.ts"];
+        return remapped || moduleId;
     }
     // Generate source files
     project.getSourceFiles().some(function (sourceFile) {
@@ -312,6 +305,9 @@ export function generateTypescriptDefinition(options) {
                 const resolved = resolveModuleImport(expression.text);
                 return ` require('${resolved}')`;
             }
+            else if (isNodeKindImportDeclaration(node) && !node.importClause) {
+                return '';
+            }
             else if (node.kind === Ts.SyntaxKind.DeclareKeyword) {
                 return '';
             }
@@ -375,7 +371,7 @@ export class TypescriptDefinitionTask extends BuildTask {
                 project,
                 prefix: lib.name,
                 exclude: ["node_modules/**/*"],
-                exports: lib.descriptor.exports || {},
+                exports: create_export_map(lib, lib.bundle),
             });
             file.write.text(storage.getBaseDirFS() + "/types.d.ts", dts);
             logDiagnostics(this.log, diagnostics);
@@ -385,4 +381,4 @@ export class TypescriptDefinitionTask extends BuildTask {
         }
     }
 }
-//# sourceMappingURL=emit-dts.js.map
+//# sourceMappingURL=emit-typescript-definition.js.map

package/esm/builder/helpers/task.js

@@ -0,0 +1,9 @@
+export class BuildTask {
+    target;
+    constructor(target) {
+        this.target = target;
+    }
+    get log() { return this.target.log; }
+    async init() { }
+}
+//# sourceMappingURL=task.js.map

package/esm/model/helpers/config-loader.js

@@ -67,7 +67,7 @@ export function readConfigFileSync(path) {
  * Find config files matching a base name (e.g. "bundle.component") in a directory.
  * Returns all matching paths across supported extensions.
  */
-export function findConfigFiles(dir, baseName, fnames) {
+export function findConfigFile(dir, baseName, fnames) {
     const results = [];
     for (const ext of config_extensions) {
         const fname = baseName + ext;
@@ -80,7 +80,12 @@ export function findConfigFiles(dir, baseName, fnames) {
             results.push(`${dir}/${fname}`);
         }
     }
-    return results;
+    if (results.length === 0)
+        return undefined;
+    if (results.length > 1) {
+        throw new Error(`Multiple config files found for '${baseName}': ${results.join(", ")}. Only one format is allowed.`);
+    }
+    return results[0];
 }
 /**
  * Read a singleton config file (exactly one format must exist).
@@ -88,13 +93,8 @@ export function findConfigFiles(dir, baseName, fnames) {
  * Returns `undefined` if no matching file exists.
  */
 export async function readSingletonConfigFile(dir, baseName, fnames) {
-    const paths = findConfigFiles(dir, baseName, fnames);
-    if (paths.length === 0)
-        return undefined;
-    if (paths.length > 1) {
-        throw new Error(`Multiple config files found for '${baseName}': ${paths.join(", ")}. Only one format is allowed.`);
-    }
-    const data = await readConfigFile(paths[0]);
-    return data !== undefined ? { data, path: paths[0] } : undefined;
+    const path = findConfigFile(dir, baseName, fnames);
+    const data = await readConfigFile(path);
+    return data !== undefined ? { data, path } : undefined;
 }
 //# sourceMappingURL=config-loader.js.map

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

@@ -1,10 +1,11 @@
 import Path from "node:path";
 import { makeComponentPublication } from "../component.js";
+import { resolve_normalized_suffixed_path } from "../../utils/file.js";
 function add_export_entry(exports, lib, key, value, baseDir) {
     const basename = key.startsWith("./") ? key.slice(2) : key;
     const filename = lib.make_file_id("export", basename);
     const source_ref = typeof value === "string" ? value : value?.import ?? value?.default ?? value?.require;
-    const entry = source_ref ? lib.resolve_entry_path(source_ref, baseDir) : null;
+    const entry = source_ref ? resolve_normalized_suffixed_path(lib.resolve_entry_path(source_ref, baseDir), ".") : null;
     const id = `${lib.name}${basename === "." ? "" : "/" + basename}`;
     exports[id] = {
         id,
@@ -14,7 +15,7 @@ function add_export_entry(exports, lib, key, value, baseDir) {
         source: entry,
     };
 }
-function create_export_map(lib, bun) {
+export function create_export_map(lib, bun) {
     const exports = {};
     if (bun) {
         for (const id in bun.distribueds) {
@@ -43,26 +44,28 @@ function create_export_map(lib, bun) {
     }
     return exports;
 }
-export function create_manifests(lib, bun, build_version) {
+export function create_bundle_manifest(lib, bun) {
+    if (!bun)
+        return null;
     const entries = create_export_map(lib, bun);
-    let bundle_manif = null;
-    if (bun) {
-        bundle_manif = bun.manifest;
-        const components = [];
-        for (const comp of bun.components.values()) {
-            components.push(makeComponentPublication(comp));
-        }
-        bundle_manif.data = {
-            baseline: bun.id + "-v0",
-            components: components,
-            exports: {},
-        };
-        for (const id in entries) {
-            const exp = entries[id];
-            bundle_manif.data.exports[id] = exp.filename;
-        }
+    const bundle_manif = bun.manifest;
+    const components = [];
+    for (const comp of bun.components.values()) {
+        components.push(makeComponentPublication(comp));
+    }
+    bundle_manif.data = {
+        baseline: bun.id + "-v0",
+        components: components,
+        exports: {},
+    };
+    for (const id in entries) {
+        const exp = entries[id];
+        bundle_manif.data.exports[id] = exp.filename;
     }
-    // Add bundle package.json 
+    return bundle_manif;
+}
+export function create_package_manifest(lib, bun, build_version) {
+    const entries = create_export_map(lib, bun);
     const pkg_manif = {
         ...lib.descriptor,
         name: lib.name,
@@ -74,14 +77,32 @@ export function create_manifests(lib, bun, build_version) {
         devDependencies: undefined,
         optionalDependencies: undefined,
     };
+    if (pkg_manif.dependencies) {
+        const resolved = lib.workspace.resolved_versions;
+        for (const dep in pkg_manif.dependencies) {
+            if (pkg_manif.dependencies[dep] === "*") {
+                const dep_resolved = resolved[dep];
+                if (dep_resolved) {
+                    const [major, minor] = dep_resolved.split(".");
+                    pkg_manif.dependencies[dep] = `^${major}.${minor}.0`;
+                }
+                else {
+                    lib.log.warn(`Library dependency '${dep}' is versioned as * but not updatable to locked version`);
+                }
+            }
+        }
+    }
     for (const id in entries) {
         const exp = entries[id];
         if (exp.exported) {
             if (!pkg_manif.exports)
                 pkg_manif.exports = {};
-            pkg_manif.exports[exp.exported] = { import: `./${exp.filename}`, types: "./types.d.ts" };
+            pkg_manif.exports[exp.exported] = {
+                import: `./${exp.filename}`,
+                types: "./types.d.ts",
+            };
         }
     }
-    return { package: pkg_manif, bundle: bundle_manif, entries };
+    return pkg_manif;
 }
 //# sourceMappingURL=create-manifests.js.map

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

@@ -3,11 +3,11 @@ import Fsp from "node:fs/promises";
 import { readJsonFile } from "../storage.js";
 import { checkComponentManifest } from "../component.js";
 import { makeNormalizedName, NameStyle } from "../../utils/normalized-name.js";
-import { create_manifests } from "./create-manifests.js";
+import { create_bundle_manifest } from "./create-manifests.js";
 import { Bundle, Library, Workspace } from "../workspace.js";
-import { make_canonical_path, make_normalized_dirname, make_normalized_path, make_relative_path } from "../../utils/file.js";
-import { is_config_filename, readConfigFile, readSingletonConfigFile } from "./config-loader.js";
-const exclude_dirs = ["node_modules"];
+import { file, make_canonical_path, make_normalized_dirname, make_normalized_path, make_relative_path } from "../../utils/file.js";
+import { findConfigFile, is_config_filename, readConfigFile, readSingletonConfigFile } from "./config-loader.js";
+const exclude_dirs = ["node_modules", ".git"];
 function is_ignored_dir(ws, path) {
     const normalized_path = make_normalized_path(path);
     for (const ignored of ws.ignored_directories) {
@@ -18,8 +18,8 @@ function is_ignored_dir(ws, path) {
     return false;
 }
 function setup_library_bundle(lib, bundle_desc) {
-    const manif = make_library_bundle_manifest(lib, bundle_desc);
     const ws = lib.workspace;
+    const manif = make_library_bundle_manifest(lib, bundle_desc);
     let bun = ws.get_bundle(manif.$id);
     if (!bun) {
         bun = new Bundle(manif, lib.path, ws, lib);
@@ -97,7 +97,9 @@ async function discover_library_components(lib, path, subdir = false) {
         const fstat = await Fsp.stat(fpath);
         if (fstat.isDirectory()) {
             if (!exclude_dirs.includes(fname)) {
-                await discover_library_components(lib, fpath, true);
+                if (await discover_library(lib.workspace, fpath, lib.installed) === Discovered.None) {
+                    await discover_library_components(lib, fpath, true);
+                }
             }
         }
         else if (fstat.isFile()) {
@@ -115,15 +117,19 @@ async function discover_library_components(lib, path, subdir = false) {
             }
         }
     }
-    // Analyze library deployment manifest (supports json/yaml/yml/toml, singleton)
-    const manifest_result = await readSingletonConfigFile(path, "bundle.manifest", fnames);
-    if (manifest_result) {
-        const manifest = manifest_result.data;
-        for (const pub of manifest.data.components) {
-            const fpath = path + "/" + (pub.ref ?? pub.id);
-            await discover_component(lib, fpath);
+}
+export function collect_declarations_field(lib, key, value) {
+    for (const decl of lib.declarations.values()) {
+        if (typeof decl[key] === typeof value) {
+            if (Array.isArray(value))
+                value.push(...decl[key]);
+            else if (typeof value === "object")
+                Object.assign(value, decl[key]);
+            else
+                value = decl[key];
         }
     }
+    return value;
 }
 function make_library_bundle_manifest(lib, file_desc) {
     let $id = file_desc?.$id;
@@ -138,26 +144,22 @@ function make_library_bundle_manifest(lib, file_desc) {
         lib.log.info(`Bundle '${$id}' named from library '${lib.name}'`);
     }
     const data = {
-        alias: lib.name,
         package: lib.get_id(),
-        namespaces: [],
-        dependencies: [],
-        redistribueds: {},
+        alias: collect_declarations_field(lib, "alias", lib.name),
+        namespaces: collect_declarations_field(lib, "namespaces", []),
+        dependencies: collect_declarations_field(lib, "dependencies", []),
+        distribueds: collect_declarations_field(lib, "distribueds", {}),
     };
     if (file_desc?.data) {
         data.alias = file_desc.data.alias ?? data.alias;
-        if (file_desc.data.redistribueds) {
-            const distribueds = file_desc.data.redistribueds;
-            if (Array.isArray(distribueds))
-                distribueds.forEach(dist => data.redistribueds[dist] = "*");
-            else
-                Object.assign(data.redistribueds, distribueds);
+        if (file_desc.data.distribueds) {
+            Object.assign(data.distribueds, file_desc.data.distribueds);
         }
-        if (file_desc.data.namespaces) {
-            data.namespaces = file_desc.data.namespaces;
+        if (Array.isArray(file_desc.data.namespaces)) {
+            data.namespaces.push(...file_desc.data.namespaces);
         }
-        if (file_desc.data.dependencies) {
-            data.dependencies = file_desc.data.dependencies;
+        if (Array.isArray(file_desc.data.dependencies)) {
+            data.dependencies.push(...file_desc.data.dependencies);
         }
     }
     const manifest = {
@@ -174,53 +176,71 @@ function make_library_bundle_manifest(lib, file_desc) {
     };
     return manifest;
 }
+var Discovered;
+(function (Discovered) {
+    Discovered[Discovered["None"] = 0] = "None";
+    Discovered[Discovered["Ignored"] = 1] = "Ignored";
+    Discovered[Discovered["Registered"] = 2] = "Registered";
+})(Discovered || (Discovered = {}));
 async function discover_library(ws, location, installed) {
     const lib_path = make_canonical_path(ws.path, location);
     if (is_ignored_dir(ws, lib_path))
-        return false;
+        return Discovered.Ignored;
+    const package_path = lib_path + "/package.json";
+    const manifest_path = findConfigFile(lib_path, "bundle.manifest");
+    if (!file.exists(package_path) && !file.exists(manifest_path))
+        return Discovered.None;
     const lib_not_exists = ws.libraries.reduce((r, lib) => r && lib.path !== lib_path, true);
-    if (lib_not_exists) {
-        const lib_desc = await readJsonFile(lib_path + "/package.json");
-        if (!lib_desc?.name)
-            return false;
-        const bundle_result = await readSingletonConfigFile(lib_path, "bundle.component");
-        const bundle_desc = bundle_result?.data;
-        if (bundle_desc || !installed) {
-            const other = ws.get_library(lib_desc.name);
-            if (other) {
-                if (lib_path.includes(other.path)) {
-                    ws.log.info(`ignore library build at ${lib_path}`);
-                    return false;
-                }
-                else {
-                    throw new Error(`library '${lib_desc.name}' declared multiple times\n - ${other.path}\n - ${lib_path}`);
-                }
+    if (!lib_not_exists)
+        return Discovered.Ignored;
+    const lib_desc = await readJsonFile(package_path);
+    if (!lib_desc?.name)
+        return Discovered.Ignored;
+    const manifest_desc = await readConfigFile(manifest_path);
+    if (manifest_desc || !installed) {
+        const other = ws.get_library(lib_desc.name);
+        if (other) {
+            if (lib_path.includes(other.path)) {
+                ws.log.info(`ignore library build at ${lib_path}`);
+                return Discovered.Ignored;
             }
-            const lib = new Library(lib_desc.name, lib_path, lib_desc, ws);
-            ws.libraries.push(lib);
-            ws.log.info(`+ 📚 library: ${lib.get_id()} (${make_relative_path(ws.path, location)})`);
-            if (bundle_desc) {
-                setup_library_bundle(lib, bundle_desc);
+            else {
+                throw new Error(`library '${lib_desc.name}' declared multiple times\n - ${other.path}\n - ${lib_path}`);
             }
-            const lib_search_path = lib_path + "/node_modules";
-            if (Fs.existsSync(lib_search_path)) {
-                lib.search_directories.push(lib_search_path);
+        }
+        const lib = new Library(lib_desc.name, lib_path, lib_desc, ws, installed);
+        ws.libraries.push(lib);
+        ws.log.info(`+ 📚 library: ${installed ? "⏬" : "🐣"} ${lib.get_id()} (${make_relative_path(ws.path, location)})`);
+        // Setup library infos from bundle manifest
+        setup_library_bundle(lib, manifest_desc);
+        // Analyze library deployment manifest (supports json/yaml/yml/toml, singleton)
+        if (manifest_desc?.data?.components) {
+            for (const pub of manifest_desc.data.components) {
+                const fpath = lib_path + "/" + (pub.ref ?? pub.id);
+                await discover_component(lib, fpath);
             }
-            await discover_library_components(lib, lib_path);
-            return true;
         }
+        // Setup node search directory
+        const lib_search_path = lib_path + "/node_modules";
+        if (Fs.existsSync(lib_search_path)) {
+            lib.search_directories.push(lib_search_path);
+        }
+        // Collect library declaration
+        await discover_library_components(lib, lib_path);
+        return Discovered.Registered;
     }
-    return false;
+    return Discovered.None;
 }
 async function discover_workspace_libraries(ws) {
     async function walk(dir) {
-        await discover_library(ws, dir, false);
-        for (const entry of Fs.readdirSync(dir, { withFileTypes: true })) {
-            if (entry.name === "node_modules")
-                continue;
-            const fullPath = dir + "/" + entry.name;
-            if (entry.isDirectory()) {
-                await walk(fullPath);
+        if (await discover_library(ws, dir, false) === Discovered.None) {
+            for (const entry of Fs.readdirSync(dir, { withFileTypes: true })) {
+                if (entry.name === "node_modules")
+                    continue;
+                const fullPath = dir + "/" + entry.name;
+                if (entry.isDirectory()) {
+                    await walk(fullPath);
+                }
             }
         }
     }
@@ -259,14 +279,23 @@ export async function discover_workspace(ws) {
     if (!package_lock) {
         throw new Error(`Package lock not found for '${ws.name}'`);
     }
+    for (const location in package_lock.packages) {
+        let pkg = package_lock.packages[location];
+        if (location.startsWith("node_modules/")) {
+            if (pkg.link) {
+                pkg = package_lock.packages[pkg.resolved];
+            }
+            const name = location.replace(/^.*node_modules\//, "");
+            ws.resolved_versions[name] = pkg.version;
+        }
+    }
     await discover_workspace_libraries(ws);
     for (const location in package_lock.packages) {
         await discover_library(ws, location, true);
     }
     for (const bun of ws.bundles) {
         if (bun.source) {
-            const manifs = create_manifests(bun.source, bun);
-            bun.manifest = manifs.bundle;
+            bun.manifest = create_bundle_manifest(bun.source, bun);
         }
     }
     show_constants(ws);

package/esm/model/workspace.js

@@ -1,16 +1,14 @@
 import Fs from "node:fs";
-import Fsp from "node:fs/promises";
 import Path from "node:path";
 import Process from "node:process";
+import DotEnv from "dotenv";
 import { readJsonFile } from "./storage.js";
 import {} from "./component.js";
-import { topologicalSort } from "../utils/graph-ordering.js";
-import DotEnv from "dotenv";
 import { computeNameHashID, makeNormalizedName, NameStyle } from "../utils/normalized-name.js";
-import { make_relative_path } from "../utils/file.js";
+import { make_normalized_path } from "../utils/file.js";
 import { Logger, Log } from "./helpers/logger.js";
 import { discover_workspace } from "./helpers/discover-workspace.js";
-import { create_manifests } from "./helpers/create-manifests.js";
+import { create_bundle_manifest } from "./helpers/create-manifests.js";
 export class WorkspaceItem {
     workspace;
     log;
@@ -25,17 +23,19 @@ export class Library extends WorkspaceItem {
     path;
     descriptor;
     workspace;
+    installed;
     bundle = null;
     declarations = new Map();
     applications = new Map();
     externals = {};
     search_directories = null;
-    constructor(name, path, descriptor, workspace) {
+    constructor(name, path, descriptor, workspace, installed) {
         super(workspace, `lib:${name}`);
         this.name = name;
         this.path = path;
         this.descriptor = descriptor;
         this.workspace = workspace;
+        this.installed = installed;
         this.search_directories = workspace.search_directories.slice();
         Object.assign(this.externals, descriptor.peerDependencies, descriptor.dependencies);
     }
@@ -49,13 +49,13 @@ export class Library extends WorkspaceItem {
         return base ? prefix + "." + base : prefix;
     }
     resolve_entry_path(entryId, baseDir) {
-        const fpath = make_relative_path(Process.cwd(), Path.resolve(baseDir, entryId));
+        const fpath = make_normalized_path(Path.resolve(baseDir, entryId));
         if (entryId.startsWith("."))
             return fpath;
         const parts = entryId.split("/");
         for (const search_path of this.search_directories) {
             if (Fs.existsSync(search_path + "/" + parts[0])) {
-                return make_relative_path(Process.cwd(), search_path + "/" + entryId);
+                return make_normalized_path(search_path + "/" + entryId);
             }
         }
         if (Fs.existsSync(fpath))
@@ -92,8 +92,7 @@ export class Bundle extends WorkspaceItem {
     }
     resolve_export(ref) {
         if (!this.manifest) {
-            const manifs = create_manifests(this.source, this);
-            this.manifest = manifs.bundle;
+            this.manifest = create_bundle_manifest(this.source, this);
             this.configured = true;
         }
         return this.exports?.[ref];
@@ -108,6 +107,7 @@ export class Workspace {
     bundles = [];
     libraries = [];
     constants = {};
+    resolved_versions = {};
     search_directories = [];
     ignored_directories = new Set();
     logger = new Logger();

package/esm/utils/file.js

@@ -1,22 +1,22 @@
 import Path from "path";
-import fs from "fs";
+import Fs from "fs";
 import { fileURLToPath } from "url";
 export const PackageRootDir = Path.resolve(fileURLToPath(import.meta.url), "../../..");
 export const file = {
     exists(path) {
-        return fs.existsSync(path) && fs.lstatSync(path).isFile();
+        return Fs.existsSync(path) && Fs.lstatSync(path).isFile();
     },
     copy: {
         toFile(src, dest) {
             dest = Path.resolve(dest);
             directory.make(Path.dirname(dest));
-            fs.copyFileSync(src, dest);
+            Fs.copyFileSync(src, dest);
             return dest;
         },
         toDir(src, dest) {
             dest = Path.resolve(dest, Path.basename(src));
             directory.make(Path.dirname(dest));
-            fs.copyFileSync(src, dest);
+            Fs.copyFileSync(src, dest);
             return dest;
         }
     },
@@ -24,22 +24,22 @@ export const file = {
         toFile(src, dest) {
             dest = Path.resolve(dest);
             directory.make(Path.dirname(dest));
-            fs.copyFileSync(src, dest);
-            fs.unlinkSync(src);
+            Fs.copyFileSync(src, dest);
+            Fs.unlinkSync(src);
             return dest;
         },
         toDir(src, dest) {
             dest = Path.resolve(dest, Path.basename(src));
             directory.make(Path.dirname(dest));
-            fs.copyFileSync(src, dest);
-            fs.unlinkSync(src);
+            Fs.copyFileSync(src, dest);
+            Fs.unlinkSync(src);
             return dest;
         },
     },
     read: {
         json(path) {
             try {
-                return JSON.parse(fs.readFileSync(path).toString());
+                return JSON.parse(Fs.readFileSync(path).toString());
             }
             catch (e) {
                 return undefined;
@@ -47,7 +47,7 @@ export const file = {
         },
         text(path) {
             try {
-                return fs.readFileSync(path).toString();
+                return Fs.readFileSync(path).toString();
             }
             catch (e) {
                 return undefined;
@@ -57,11 +57,11 @@ export const file = {
     write: {
         json(path, data) {
             directory.make(Path.dirname(path));
-            fs.writeFileSync(path, JSON.stringify(data, null, 2));
+            Fs.writeFileSync(path, JSON.stringify(data, null, 2));
         },
         text(path, data) {
             directory.make(Path.dirname(path));
-            fs.writeFileSync(path, Array.isArray(data) ? data.join("\n") : data.toString());
+            Fs.writeFileSync(path, Array.isArray(data) ? data.join("\n") : data.toString());
         }
     },
     find: {
@@ -69,30 +69,30 @@ export const file = {
             let previous, current = Path.resolve(base);
             do {
                 previous = current;
-                if (fs.existsSync(Path.join(current, subpath)))
+                if (Fs.existsSync(Path.join(current, subpath)))
                     return current;
                 current = Path.dirname(current);
             } while (current != previous);
         }
     },
     remove(path) {
-        if (fs.existsSync(path)) {
-            fs.unlinkSync(path);
+        if (Fs.existsSync(path)) {
+            Fs.unlinkSync(path);
         }
     },
 };
 export const directory = {
     exists(path) {
-        return fs.existsSync(path) && fs.lstatSync(path).isDirectory();
+        return Fs.existsSync(path) && Fs.lstatSync(path).isDirectory();
     },
     filenames(path, recursive) {
         try {
             if (recursive) {
                 function* walkSync(dir) {
-                    const files = fs.readdirSync(dir);
+                    const files = Fs.readdirSync(dir);
                     for (const file of files) {
                         const pathToFile = Path.join(dir, file);
-                        const isDirectory = fs.statSync(pathToFile).isDirectory();
+                        const isDirectory = Fs.statSync(pathToFile).isDirectory();
                         if (isDirectory) {
                             yield* walkSync(pathToFile);
                         }
@@ -108,7 +108,7 @@ export const directory = {
                 return _Result;
             }
             else
-                return fs.readdirSync(path) || [];
+                return Fs.readdirSync(path) || [];
         }
         catch (e) {
             return [];
@@ -116,9 +116,9 @@ export const directory = {
     },
     copy(src, dest, filter) {
         if (directory.exists(src)) {
-            for (const name of fs.readdirSync(src)) {
+            for (const name of Fs.readdirSync(src)) {
                 const path = Path.join(src, name);
-                const stats = fs.lstatSync(path);
+                const stats = Fs.lstatSync(path);
                 const destination = Path.join(dest, name);
                 if (stats.isDirectory()) {
                     directory.copy(path, destination, filter);
@@ -130,15 +130,15 @@ export const directory = {
         }
     },
     make(path) {
-        if (path && !fs.existsSync(path)) {
-            fs.mkdirSync(path, { recursive: true });
+        if (path && !Fs.existsSync(path)) {
+            Fs.mkdirSync(path, { recursive: true });
         }
     },
     remove(path, onlyInner) {
-        if (fs.existsSync(path) && fs.lstatSync(path).isDirectory()) {
-            fs.readdirSync(path).forEach(function (entry) {
+        if (Fs.existsSync(path) && Fs.lstatSync(path).isDirectory()) {
+            Fs.readdirSync(path).forEach(function (entry) {
                 var entry_path = Path.join(path, entry);
-                if (fs.lstatSync(entry_path).isDirectory()) {
+                if (Fs.lstatSync(entry_path).isDirectory()) {
                     directory.remove(entry_path);
                 }
                 else {
@@ -151,7 +151,7 @@ export const directory = {
                 }
             });
             if (!onlyInner) {
-                fs.rmdirSync(path);
+                Fs.rmdirSync(path);
             }
         }
     },
@@ -180,12 +180,36 @@ export function make_normalized_dirname(baseDir, ...path) {
 export function make_canonical_path(baseDir, ...path) {
     let targetPath = Path.resolve(baseDir, ...path);
     try {
-        const stats = fs.lstatSync(targetPath);
+        const stats = Fs.lstatSync(targetPath);
         if (stats.isSymbolicLink()) {
-            targetPath = fs.readlinkSync(targetPath);
+            targetPath = Fs.readlinkSync(targetPath);
         }
     }
     catch (err) { }
     return make_normalized_path(targetPath);
 }
+const FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.json'];
+/** Resolve a file path with extension probing */
+export function resolve_normalized_suffixed_path(baseDir, path, exts = FILE_EXTENSIONS) {
+    const resolved = make_normalized_path(baseDir, path);
+    // Check if exact path exists
+    if (Fs.existsSync(resolved) && Fs.statSync(resolved).isFile()) {
+        return resolved;
+    }
+    // Try with common extensions
+    for (const ext of exts) {
+        const withExt = resolved + ext;
+        if (Fs.existsSync(withExt))
+            return withExt;
+    }
+    // Try index files in directory
+    if (Fs.existsSync(resolved) && Fs.statSync(resolved).isDirectory()) {
+        for (const ext of exts) {
+            const indexPath = make_normalized_path(resolved, `index${ext}`);
+            if (Fs.existsSync(indexPath))
+                return indexPath;
+        }
+    }
+    return null;
+}
 //# sourceMappingURL=file.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@jointhedots/gear",
-   "version": "1.1.11",
+   "version": "1.1.13",
    "type": "module",
    "bin": {
       "jointhedots-gear": "esm/cli.js"
@@ -19,10 +19,13 @@
       ":build:ui": "node --enable-source-maps --watch-path=esm esm/cli make --buns jointhedots.ui --ws ../jointhedots-core/packages/jointhedots-ui",
       ":build:cortex": "node --enable-source-maps --watch-path=esm esm/cli make --buns @jointhedots/cortex --devmode --ws ../jointhedots-core/packages/jointhedots-cortex",
       ":build:libs": "node --enable-source-maps --watch-path=esm esm/cli make --libs @jointhedots/core,@jointhedots/ui --devmode --ws ../jointhedots-core",
+      ":build:lib:core": "node --enable-source-maps --watch-path=esm esm/cli make --libs @jointhedots/core --devmode --ws ../jointhedots-core/packages/jointhedots-core",
+      ":build:lib:ui": "node --enable-source-maps --watch-path=esm esm/cli make --libs @jointhedots/ui --devmode --ws ../jointhedots-core/packages/jointhedots-ui",
       ":build:app": "node --enable-source-maps --watch-path=esm esm/cli make --apps playground:ui --ws ../jointhedots-core",
       "serve:mono": "node --enable-source-maps --watch-path=esm esm/cli serve --app playground:ui --devmode --port 3002 --ws ../jointhedots-core",
       "serve:host": "node --enable-source-maps --watch-path=esm esm/cli serve --app playground:ui:host  --port 3002 --ws ../jointhedots-core",
       "serve:sfe": "node --enable-source-maps --watch-path=esm esm/cli serve --app sfe-demo --devmode --ws ../sf-explorer-app",
+      "serve:demo": "node --enable-source-maps --watch-path=esm esm/cli serve --app sfe-demo --devmode --ws ../sf-explorer-demo",
       "make:sfe": "node --enable-source-maps --watch-path=esm esm/cli make --libs @sf-explorer/app --devmode --ws ../sf-explorer-app",
       "prepublishOnly": "node scripts/prepublish.mjs"
    },