@nu-art/build-and-install 0.401.0 → 0.401.1

package/{v3/UnitsMapper → units/discovery}/resolvers/UnitMapper_NodeProject.js

@@ -1,6 +1,21 @@
-import { Unit_NodeProject } from '../../units/index.js';
+import { Unit_NodeProject } from '../../implementations/Unit_NodeProject.js';
 import { tsValidateValue } from '@nu-art/ts-common';
 import { UnitMapper_Node } from './UnitMapper_Node.js';
+/**
+ * Mapper for discovering root NodeProject unit.
+ *
+ * **Discovery Criteria**:
+ * - Must have `package.json` with `unitConfig.type === 'node-project'`
+ * - Typically the monorepo root
+ *
+ * **Unit Creation**:
+ * - Creates `Unit_NodeProject` instance
+ * - Marks as root and top-level app
+ * - Enables hot reload
+ *
+ * **Usage**: Automatically registered by `BuildAndInstall.prepareUnitsMapper()`.
+ * There should typically be only one NodeProject unit per workspace.
+ */
 export class UnitMapper_NodeProject_Class extends UnitMapper_Node {
     static tsValidator_NodeProject = {
         type: tsValidateValue(['node-project']),
@@ -9,6 +24,12 @@ export class UnitMapper_NodeProject_Class extends UnitMapper_Node {
     constructor() {
         super(UnitMapper_NodeProject_Class.tsValidator_NodeProject);
     }
+    /**
+     * Creates a Unit_NodeProject instance from resolved context.
+     *
+     * @param context - Resolved node unit context
+     * @returns Unit_NodeProject instance
+     */
     async resolveNodeUnit(context) {
         return new Unit_NodeProject({
             ...context.baseConfig,

package/units/discovery/types.js

@@ -0,0 +1 @@
+export {};

package/units/implementations/Unit_NodeProject.d.ts

@@ -0,0 +1,59 @@
+import { UnitPhaseImplementor } from '../../core/types.js';
+import { StringMap } from '@nu-art/ts-common/utils/types';
+import { Unit_PackageJson, Unit_PackageJson_Config } from './Unit_PackageJson.js';
+import { ProjectUnit } from '../base/ProjectUnit.js';
+import { Phase_Install, Phase_IndicesMcpServer, Phase_PostPublish, Phase_Watch } from '../../phases/definitions/index.js';
+/**
+ * Configuration for NodeProject (root project unit).
+ */
+type Unit_TypescriptProject_Config = Unit_PackageJson_Config & {
+    globalPackages?: StringMap;
+    isRoot: true;
+};
+/**
+ * Root project unit representing the entire monorepo/workspace.
+ *
+ * **Key Responsibilities**:
+ * - Manages child units (all packages in workspace)
+ * - Handles workspace-level operations (install, watch)
+ * - Creates PNPM workspace configuration
+ * - Manages file watching for hot reload
+ *
+ * **Phases Implemented**:
+ * - `install()`: Installs all packages using PNPM workspace
+ * - `watch()`: Watches file changes and triggers incremental compilation
+ * - `postPublish()`: Post-publish operations
+ *
+ * **Watch Mode**:
+ * - Watches TypeScript, SCSS, JSON, SVG files in all child units
+ * - Uses chokidar for file watching
+ * - Debounces changes and compiles affected units in dependency order
+ * - Supports hot reload for units with `hasSelfHotReload` flag
+ *
+ * **Workspace Management**:
+ * - Creates `pnpm-workspace.yaml` with all child unit paths
+ * - Manages global packages installation
+ * - Handles dependency tree for watch compilation
+ */
+export declare class Unit_NodeProject<C extends Unit_TypescriptProject_Config = Unit_TypescriptProject_Config> extends Unit_PackageJson<C> implements UnitPhaseImplementor<[Phase_Install, Phase_Watch, Phase_PostPublish, Phase_IndicesMcpServer]> {
+    private watcher?;
+    readonly innerUnits: Unit_PackageJson[];
+    private readonly suffixesToWatch;
+    constructor(config: Unit_NodeProject<C>['config']);
+    protected deriveDistDependencies(): StringMap;
+    assignUnit(units: ProjectUnit[]): void;
+    /**
+     * Resolve all paths to watch in all project libs
+     * @private
+     * @returns string[]
+     */
+    private prepareWatchPaths;
+    stopWatch(): Promise<void | undefined>;
+    private findUnit;
+    install(): Promise<void>;
+    watch(timeout?: number, maxTimeout?: number): Promise<void>;
+    purge(): Promise<void>;
+    postPublish(): Promise<void>;
+    indicesMcpServer(): Promise<void>;
+}
+export {};

package/{v3/units → units/implementations}/Unit_NodeProject.js

@@ -6,13 +6,39 @@ import { Commando_PNPM } from '@nu-art/commando/shell/plugins/pnpm';
 import { PNPM } from '@nu-art/commando/shell/services/pnpm';
 import { Unit_PackageJson } from './Unit_PackageJson.js';
 import { resolve } from 'path';
-import { PhaseManager } from '../PhaseManager.js';
-import { phase_CompileWatch } from '../phase/index.js';
-import { UnitsDependencyMapper } from '../UnitsDependencyMapper/UnitsDependencyMapper.js';
+import { PhaseManager } from '../../phases/PhaseManager.js';
+import { phase_CompileWatch } from '../../phases/definitions/index.js';
+import { UnitsDependencyMapper } from '../../dependencies/UnitsDependencyMapper.js';
 import { CommandoException } from '@nu-art/commando/shell/core/CliError';
-import { CONST_PNPM_LOCK, CONST_PNPM_WORKSPACE } from '../../core/consts.js';
-import { RunningStatusHandler } from '../RunningStatusHandler.js';
+import { CONST_PNPM_LOCK, CONST_PNPM_WORKSPACE } from '../../config/consts.js';
+import { RunningStatusHandler } from '../../runtime/RunningStatusHandler.js';
 import { FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
+import { IndicesMcpServer } from '../../exports/IndicesMcpServer.js';
+/**
+ * Root project unit representing the entire monorepo/workspace.
+ *
+ * **Key Responsibilities**:
+ * - Manages child units (all packages in workspace)
+ * - Handles workspace-level operations (install, watch)
+ * - Creates PNPM workspace configuration
+ * - Manages file watching for hot reload
+ *
+ * **Phases Implemented**:
+ * - `install()`: Installs all packages using PNPM workspace
+ * - `watch()`: Watches file changes and triggers incremental compilation
+ * - `postPublish()`: Post-publish operations
+ *
+ * **Watch Mode**:
+ * - Watches TypeScript, SCSS, JSON, SVG files in all child units
+ * - Uses chokidar for file watching
+ * - Debounces changes and compiles affected units in dependency order
+ * - Supports hot reload for units with `hasSelfHotReload` flag
+ *
+ * **Workspace Management**:
+ * - Creates `pnpm-workspace.yaml` with all child unit paths
+ * - Manages global packages installation
+ * - Handles dependency tree for watch compilation
+ */
 export class Unit_NodeProject extends Unit_PackageJson {
     watcher;
     innerUnits = [];
@@ -241,4 +267,38 @@ export class Unit_NodeProject extends Unit_PackageJson {
     }
     async postPublish() {
     }
+    async indicesMcpServer() {
+        this.setStatus('Starting Export Indices MCP Server', 'start');
+        const projectRoot = this.config.fullPath;
+        const port = this.runtimeContext.runtimeParams.indicesMcpPort || 3001;
+        // Get active TypeScriptLib packages
+        const packages = this.innerUnits.filter(unit => unit.isInstanceOf(Unit_TypescriptLib));
+        if (packages.length === 0) {
+            this.logWarning('No TypeScriptLib packages found. MCP server will have no packages to expose.');
+        }
+        const server = new IndicesMcpServer(port, projectRoot, packages);
+        // Handle graceful shutdown
+        const shutdown = async () => {
+            this.logInfo('Shutting down Export Indices MCP Server...');
+            await server.stop();
+            process.exit(0);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+        try {
+            await server.start();
+            this.setStatus('Export Indices MCP Server running', 'end');
+            this.logInfo(`Export Indices MCP Server is running on http://localhost:${port}`);
+            this.logInfo('Press Ctrl+C to stop the server');
+            // Keep process alive - return a promise that never resolves
+            return new Promise(() => {
+                // This promise never resolves, keeping the process alive
+            });
+        }
+        catch (error) {
+            this.logError('Failed to start Export Indices MCP Server:', error);
+            this.setStatus('Export Indices MCP Server failed', 'end');
+            throw error;
+        }
+    }
 }

package/units/implementations/Unit_PackageJson.d.ts

@@ -0,0 +1,56 @@
+import { StringMap } from '@nu-art/ts-common';
+import { UnitPhaseImplementor } from '../../core/types.js';
+import { Config_ProjectUnit, ProjectUnit } from '../base/ProjectUnit.js';
+import { TS_PackageJSON } from '../discovery/types.js';
+import { Phase_Prepare, Phase_Purge } from '../../phases/definitions/index.js';
+/**
+ * Configuration for PackageJson units (units with package.json).
+ */
+export type Unit_PackageJson_Config = Config_ProjectUnit & {
+    packageJson: TS_PackageJSON;
+};
+/**
+ * Base class for all units that have a package.json file.
+ *
+ * **Key Responsibilities**:
+ * - Manages package.json template transformation
+ * - Handles dependency derivation (lib and dist dependencies)
+ * - Implements prepare and purge phases
+ *
+ * **Dependency Management**:
+ * - `deriveLibDependencies()`: Creates workspace dependencies for development
+ * - `deriveDistDependencies()`: Creates versioned dependencies for distribution
+ *
+ * **Template System**: Uses FileSystemUtils to transform package.json templates
+ * with runtime parameters (THUNDERSTORM_VERSION, __ENV__, etc.).
+ *
+ * **Phases Implemented**:
+ * - `prepare()`: Generates package.json from template with resolved dependencies
+ * - `purge()`: Deletes package.json and node_modules
+ *
+ * **Base For**: Unit_NodeProject, Unit_TypescriptLib, Unit_FirebaseHosting, etc.
+ */
+export declare class Unit_PackageJson<C extends Unit_PackageJson_Config = Unit_PackageJson_Config> extends ProjectUnit<C> implements UnitPhaseImplementor<[Phase_Purge, Phase_Prepare]> {
+    constructor(config: C);
+    protected npmCommand(command: string): string;
+    protected deriveDistDependencies(): StringMap;
+    protected deriveLibDependencies(): StringMap;
+    /**
+     * Prepares package.json by generating it from template with resolved dependencies.
+     *
+     * **Process**:
+     * 1. Derives lib dependencies (workspace:* for development)
+     * 2. Transforms package.json template with params
+     * 3. Writes transformed package.json to disk
+     *
+     * **Template Params**: Includes THUNDERSTORM_VERSION, __ENV__, and child unit versions.
+     */
+    prepare(): Promise<void>;
+    /**
+     * Purges package.json and node_modules folder.
+     *
+     * Used by `--purge` flag to clean up before reinstall.
+     */
+    purge(): Promise<void>;
+    protected releasePorts(allPorts: string[]): Promise<void>;
+}

package/{v3/units → units/implementations}/Unit_PackageJson.js

@@ -1,9 +1,30 @@
-import { CONST_NodeModules, CONST_PackageJSON } from '../../core/consts.js';
+import { CONST_NodeModules, CONST_PackageJSON } from '../../config/consts.js';
 import { __stringify } from '@nu-art/ts-common';
-import { ProjectUnit } from './ProjectUnit.js';
+import { ProjectUnit } from '../base/ProjectUnit.js';
 import { resolve } from 'path';
 import { Commando_NVM } from '@nu-art/commando/shell/plugins/nvm';
 import { DEFAULT_OLD_TEMPLATE_PATTERN, FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
+/**
+ * Base class for all units that have a package.json file.
+ *
+ * **Key Responsibilities**:
+ * - Manages package.json template transformation
+ * - Handles dependency derivation (lib and dist dependencies)
+ * - Implements prepare and purge phases
+ *
+ * **Dependency Management**:
+ * - `deriveLibDependencies()`: Creates workspace dependencies for development
+ * - `deriveDistDependencies()`: Creates versioned dependencies for distribution
+ *
+ * **Template System**: Uses FileSystemUtils to transform package.json templates
+ * with runtime parameters (THUNDERSTORM_VERSION, __ENV__, etc.).
+ *
+ * **Phases Implemented**:
+ * - `prepare()`: Generates package.json from template with resolved dependencies
+ * - `purge()`: Deletes package.json and node_modules
+ *
+ * **Base For**: Unit_NodeProject, Unit_TypescriptLib, Unit_FirebaseHosting, etc.
+ */
 export class Unit_PackageJson extends ProjectUnit {
     constructor(config) {
         super(config);
@@ -14,7 +35,7 @@ export class Unit_PackageJson extends ProjectUnit {
         return resolve(this.runtimeContext.parentUnit.config.fullPath, './node_modules/.bin', command);
     }
     deriveDistDependencies() {
-        const params = this.runtimeContext.childUnits.reduce((dependencies, unit) => {
+        const params = this.runtimeContext.parentUnit.innerUnits.reduce((dependencies, unit) => {
             dependencies[unit.config.key] = unit.config.packageJson.version;
             return dependencies;
         }, {
@@ -32,12 +53,27 @@ export class Unit_PackageJson extends ProjectUnit {
         }, { ...this.runtimeContext.baiConfig.templateParams?.packageJson, __ENV__: this.runtimeContext.runtimeParams.environment });
     }
     //######################### Phase Implementations #########################
+    /**
+     * Prepares package.json by generating it from template with resolved dependencies.
+     *
+     * **Process**:
+     * 1. Derives lib dependencies (workspace:* for development)
+     * 2. Transforms package.json template with params
+     * 3. Writes transformed package.json to disk
+     *
+     * **Template Params**: Includes THUNDERSTORM_VERSION, __ENV__, and child unit versions.
+     */
     async prepare() {
         const targetPath = resolve(this.config.fullPath, CONST_PackageJSON);
         const params = this.deriveLibDependencies();
         const packageJson = FileSystemUtils.file.template.transform(__stringify(this.config.packageJson, true), params);
         await FileSystemUtils.file.template.write(targetPath, packageJson, params, DEFAULT_OLD_TEMPLATE_PATTERN);
     }
+    /**
+     * Purges package.json and node_modules folder.
+     *
+     * Used by `--purge` flag to clean up before reinstall.
+     */
     async purge() {
         await FileSystemUtils.file.delete(resolve(this.config.fullPath, CONST_PackageJSON));
         await FileSystemUtils.folder.delete(resolve(this.config.fullPath, CONST_NodeModules));

package/{v3/units → units/implementations}/Unit_TypescriptLib.d.ts

@@ -1,15 +1,48 @@
 import { RecursivePartial, TypedMap } from '@nu-art/ts-common';
-import { UnitPhaseImplementor } from '../core/types.js';
+import { UnitPhaseImplementor } from '../../core/types.js';
 import { Unit_PackageJson, Unit_PackageJson_Config } from './Unit_PackageJson.js';
-import { Phase_CheckCyclicImports, Phase_Compile, Phase_Lint, Phase_PreCompile, Phase_PrintDependencyTree, Phase_Publish, Phase_Test, Phase_ToESM } from '../phase/index.js';
-import { TsConfig } from './types.js';
+import { Phase_CheckCyclicImports, Phase_Compile, Phase_ExtractDynamicDeps, Phase_Lint, Phase_MapExports, Phase_PreCompile, Phase_PrintDependencyTree, Phase_Publish, Phase_Test, Phase_ToESM } from '../../phases/definitions/index.js';
+import { TsConfig } from '../base/types.js';
 export type Unit_TypescriptLib_Config = Unit_PackageJson_Config & {
     customESLintConfig: boolean;
     customTSConfig: boolean;
     hasSelfHotReload: boolean;
     output: string;
 };
-export declare class Unit_TypescriptLib<C extends Unit_TypescriptLib_Config = Unit_TypescriptLib_Config> extends Unit_PackageJson<C> implements UnitPhaseImplementor<[Phase_PreCompile, Phase_Compile, Phase_PrintDependencyTree, Phase_CheckCyclicImports, Phase_Lint, Phase_Test, Phase_Publish, Phase_ToESM]> {
+/**
+ * TypeScript library unit for building TypeScript packages.
+ *
+ * **Key Responsibilities**:
+ * - Compiles TypeScript to JavaScript
+ * - Runs tests (pure, firebase, ui, mobile)
+ * - Lints code
+ * - Publishes packages
+ * - Manages assets (JSON, SCSS, SVG, images)
+ * - Handles ESM conversion
+ *
+ * **Phases Implemented**:
+ * - `preCompile()`: Prepares compilation (creates output dir, clears if needed)
+ * - `compile()`: Compiles TypeScript using tsc
+ * - `watchCompile()`: Incremental compilation for watch mode
+ * - `runTests()`: Runs tests based on test type
+ * - `lint()`: Lints code using ESLint
+ * - `publish()`: Publishes package to registry
+ * - `convertToESM()`: Converts package to ESM format
+ * - `printDependencyTree()`: Prints dependency tree
+ * - `checkCyclicImports()`: Checks for circular imports
+ *
+ * **Test Types**:
+ * - **pure**: Standard TypeScript tests (ts-mocha)
+ * - **firebase**: Tests with Firebase emulators
+ * - **ui**: UI tests (not implemented)
+ * - **mobile**: Mobile tests (not implemented)
+ *
+ * **Asset Management**: Automatically copies non-TypeScript files (JSON, SCSS, SVG, images)
+ * to output directory during compilation.
+ *
+ * **Dependency Resolution**: Resolves transitive dependencies for compilation order.
+ */
+export declare class Unit_TypescriptLib<C extends Unit_TypescriptLib_Config = Unit_TypescriptLib_Config> extends Unit_PackageJson<C> implements UnitPhaseImplementor<[Phase_PreCompile, Phase_Compile, Phase_PrintDependencyTree, Phase_CheckCyclicImports, Phase_Lint, Phase_Test, Phase_Publish, Phase_ToESM, Phase_ExtractDynamicDeps, Phase_MapExports]> {
     private TestTypeWorkspaceSetup;
     runTests(): Promise<void>;
     protected dependencyUnits: Unit_TypescriptLib[];
@@ -32,6 +65,9 @@ export declare class Unit_TypescriptLib<C extends Unit_TypescriptLib_Config = Un
      */
     removeSpecificFileFromDist(path: string): Promise<void>;
     preCompile(): Promise<void>;
+    extractDynamicDeps(): Promise<void>;
+    private extractPackageName;
+    mapExports(): Promise<void>;
     compile(): Promise<void>;
     protected postCompile(): Promise<void>;
     protected copyPackageJSONToOutput(): Promise<void>;

package/{v3/units → units/implementations}/Unit_TypescriptLib.js

@@ -1,27 +1,30 @@
 import * as fs from 'fs';
 import { copyFileSync, existsSync, promises as _fs, readdirSync, statSync } from 'fs';
 import { __stringify, arrayToMap, BadImplementationException, ImplementationMissingException, LogLevel, merge, NotImplementedYetException } from '@nu-art/ts-common';
-import { CONST_BaiConfig, CONST_FirebaseJSON, CONST_FirebaseRC, CONST_PackageJSON, CONST_PackageJSONTemplate, CONST_TS_CONFIG } from '../../core/consts.js';
+import { CONST_BaiConfig, CONST_FirebaseJSON, CONST_FirebaseRC, CONST_PackageJSON, CONST_PackageJSONTemplate, CONST_TS_CONFIG } from '../../config/consts.js';
 import { CommandoException } from '@nu-art/commando/shell/core/CliError';
 import { Commando_NVM } from '@nu-art/commando/shell/plugins/nvm';
 import { Commando_Basic } from '@nu-art/commando/shell/plugins/basic';
 import { resolve, resolve as pathResolve } from 'path';
 import { Unit_PackageJson } from './Unit_PackageJson.js';
 import { glob } from 'node:fs/promises';
-import { TestTypes } from '../../core/params/params.js';
+import { TestTypes } from '../../core/params.js';
 import { DEFAULT_OLD_TEMPLATE_PATTERN, DEFAULT_TEMPLATE_PATTERN, FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
 import path from 'node:path';
-const assetExtensions = [
-    'json',
-    'scss',
-    'svg',
-    'png',
-    'jpg',
-    'jpeg',
-    'rules',
-    '_ts',
-    'gif',
-    'csv',
+import { ExportMapper } from '../../exports/ExportMapper.js';
+const assets = [
+    '*.json',
+    '*.scss',
+    '*.svg',
+    '*.png',
+    '*.jpg',
+    '*.jpeg',
+    '*.rules',
+    '*._ts',
+    '*.gif',
+    '*.csv',
+    '*.yaml',
+    'dockerfile',
 ];
 const defaultTestPatterns = {
     pure: '**/*.test.ts',
@@ -33,9 +36,14 @@ const CONST_ESM_PREFIX = 'export NODE_OPTIONS=\'--import data:text/javascript,im
 const TestsCommandComposer = {
     pure: async (config, runtimeContext) => {
         const command = resolve(runtimeContext.parentUnit.config.fullPath, 'node_modules/.bin/ts-mocha');
-        const testFile = runtimeContext.runtimeParams.testFiles;
-        const grep = testFile?.length ? ` '${testFile.join('\' \'')}'` : ` '${defaultTestPatterns.pure}'`;
-        return `${CONST_ESM_PREFIX} && ${command} -p src/test/${CONST_TS_CONFIG} --timeout 0 ${grep}`;
+        const files = runtimeContext.runtimeParams.testFiles ?? [`src/test/${defaultTestPatterns.pure}`].map(file => `'${file}'`);
+        const testCases = runtimeContext.runtimeParams.testCases;
+        const cli_testFiles = ` ${files.join(' ')}`;
+        const cli_testCases = testCases ? ` --grep '${testCases.join('|')}'` : '';
+        const cli_watchFiles = files.map(file => `-watch-files ${file}`).join(' ');
+        const debugPort = runtimeContext.runtimeParams.testDebugPort;
+        const cli_debug = debugPort ? ` --inspect=${debugPort} -w ${cli_watchFiles}` : '';
+        return `${CONST_ESM_PREFIX} && ${command} -p src/test/${CONST_TS_CONFIG} --timeout 0 ${cli_debug}${cli_testFiles}${cli_testCases}`;
     },
     firebase: async (config, runtimeContext) => {
         const command = resolve(runtimeContext.parentUnit.config.fullPath, 'node_modules/.bin/ts-mocha');
@@ -57,6 +65,39 @@ const TestsCommandComposer = {
         throw new NotImplementedYetException('Mobile tests not implemented yet');
     },
 };
+/**
+ * TypeScript library unit for building TypeScript packages.
+ *
+ * **Key Responsibilities**:
+ * - Compiles TypeScript to JavaScript
+ * - Runs tests (pure, firebase, ui, mobile)
+ * - Lints code
+ * - Publishes packages
+ * - Manages assets (JSON, SCSS, SVG, images)
+ * - Handles ESM conversion
+ *
+ * **Phases Implemented**:
+ * - `preCompile()`: Prepares compilation (creates output dir, clears if needed)
+ * - `compile()`: Compiles TypeScript using tsc
+ * - `watchCompile()`: Incremental compilation for watch mode
+ * - `runTests()`: Runs tests based on test type
+ * - `lint()`: Lints code using ESLint
+ * - `publish()`: Publishes package to registry
+ * - `convertToESM()`: Converts package to ESM format
+ * - `printDependencyTree()`: Prints dependency tree
+ * - `checkCyclicImports()`: Checks for circular imports
+ *
+ * **Test Types**:
+ * - **pure**: Standard TypeScript tests (ts-mocha)
+ * - **firebase**: Tests with Firebase emulators
+ * - **ui**: UI tests (not implemented)
+ * - **mobile**: Mobile tests (not implemented)
+ *
+ * **Asset Management**: Automatically copies non-TypeScript files (JSON, SCSS, SVG, images)
+ * to output directory during compilation.
+ *
+ * **Dependency Resolution**: Resolves transitive dependencies for compilation order.
+ */
 export class Unit_TypescriptLib extends Unit_PackageJson {
     TestTypeWorkspaceSetup = {
         pure: async (config, runtimeContext) => {
@@ -168,7 +209,7 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
         });
     }
     async copyAssetsToOutput() {
-        const command = `find . \\( -name ${assetExtensions.map(suffix => `'*.${suffix}'`)
+        const command = `find . \\( -name ${assets.map(pattern => `'${pattern}'`)
             .join(' -o -name ')} \\) | cpio -pdmuv "${this.config.output}" > /dev/null 2>&1`;
         await this.allocateCommando(Commando_Basic)
             .cd(`${this.config.fullPath}/src/main`)
@@ -229,6 +270,115 @@ export class Unit_TypescriptLib extends Unit_PackageJson {
             .append('bash prebuild.sh')
             .execute();
     }
+    async extractDynamicDeps() {
+        this.setStatus('Extracting dynamic dependencies', 'start');
+        // Get all workspace package names from parent unit's child units
+        const workspacePackageNames = new Set();
+        for (const unit of this.runtimeContext.childUnits) {
+            workspacePackageNames.add(unit.config.key);
+        }
+        // Find all TypeScript files in src/main and src/test
+        const srcMainTs = `${this.config.fullPath}/src/main/**/*.ts`;
+        const srcMainTsx = `${this.config.fullPath}/src/main/**/*.tsx`;
+        const allFiles = [];
+        for await (const file of glob(srcMainTs, {}))
+            allFiles.push(file);
+        for await (const file of glob(srcMainTsx, {}))
+            allFiles.push(file);
+        // Regex patterns for ESM imports
+        const importFromRegex = /from\s+["']([^"']+)["']/g;
+        const dynamicImportRegex = /import\(["']([^"']+)["']\)/g;
+        const workspacePackages = new Set();
+        const externalPackages = new Set();
+        // Helper function to process import matches
+        const processImportMatches = (regex, content) => {
+            let match;
+            while ((match = regex.exec(content)) !== null) {
+                const importPath = match[1];
+                const packageName = this.extractPackageName(importPath);
+                if (packageName) {
+                    if (workspacePackageNames.has(packageName)) {
+                        workspacePackages.add(packageName);
+                    }
+                    else {
+                        externalPackages.add(packageName);
+                    }
+                }
+            }
+            regex.lastIndex = 0;
+        };
+        // Process each file
+        for (const filePath of allFiles) {
+            const content = await FileSystemUtils.file.read(filePath);
+            // Extract imports from "import ... from 'package'" and dynamic import('package')
+            processImportMatches(importFromRegex, content);
+            processImportMatches(dynamicImportRegex, content);
+        }
+        // Sort and convert to arrays
+        const workspaceArray = Array.from(workspacePackages).sort();
+        const externalArray = Array.from(externalPackages).sort();
+        // Write to _dynamic-deps.json
+        const outputPath = pathResolve(this.config.fullPath, '_dynamic-deps.json');
+        const output = {
+            workspace: workspaceArray,
+            external: externalArray
+        };
+        await FileSystemUtils.file.write(outputPath, __stringify(output, true));
+        this.logInfo(`Extracted ${workspaceArray.length} workspace and ${externalArray.length} external dependencies`);
+        this.setStatus('Dynamic dependencies extracted', 'end');
+    }
+    extractPackageName(importPath) {
+        // Skip relative imports
+        if (importPath.startsWith('.') || importPath.startsWith('/')) {
+            return null;
+        }
+        // Handle scoped packages: @scope/package or @scope/package/path
+        if (importPath.startsWith('@')) {
+            const parts = importPath.split('/');
+            if (parts.length >= 2) {
+                return `${parts[0]}/${parts[1]}`;
+            }
+            return null;
+        }
+        // Handle unscoped packages: package or package/path
+        const firstSlash = importPath.indexOf('/');
+        if (firstSlash === -1) {
+            return importPath;
+        }
+        return importPath.substring(0, firstSlash);
+    }
+    async mapExports() {
+        this.setStatus('Mapping exports', 'start');
+        // Get project root
+        const projectRoot = this.runtimeContext.parentUnit.config.fullPath;
+        // Find all TypeScript files in src/main
+        const srcMainTs = `${this.config.fullPath}/src/main/**/*.ts`;
+        const srcMainTsx = `${this.config.fullPath}/src/main/**/*.tsx`;
+        const allFiles = [];
+        for await (const file of glob(srcMainTs, {}))
+            allFiles.push(file);
+        for await (const file of glob(srcMainTsx, {}))
+            allFiles.push(file);
+        // Load previous errors if they exist (for retry capability)
+        const previousErrors = await ExportMapper.loadPreviousErrors(projectRoot, this.config.key);
+        // Map exports
+        const { exports, errors } = await ExportMapper.mapExports(projectRoot, this.config.fullPath, this.config.key, allFiles, previousErrors || undefined);
+        // Write exports to centralized location
+        const indexPath = ExportMapper.getIndexPath(projectRoot, this.config.key);
+        await FileSystemUtils.folder.create(indexPath);
+        const outputPath = pathResolve(indexPath, '_export-for-import.json');
+        await FileSystemUtils.file.write(outputPath, __stringify(exports, true));
+        // Generate optimized index files
+        await ExportMapper.generateIndexFiles(projectRoot, this.config.key, exports);
+        // Write errors to centralized location (if any)
+        await ExportMapper.writeErrors(projectRoot, this.config.key, errors);
+        // Log summary
+        this.logInfo(`Mapped ${exports.length} exports`);
+        if (errors.length > 0) {
+            this.logWarning(`Encountered ${errors.length} errors during export mapping. See ${indexPath}/_export-errors.json for details.`);
+        }
+        this.setStatus('Exports mapped', 'end');
+    }
     async compile() {
         if (!this.dependencyUnits)
             await this.prepare();