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

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();

package/units/implementations/firebase/Unit_FirebaseFunctionsApp.d.ts

@@ -0,0 +1,233 @@
+import { UnitPhaseImplementor } from '../../../core/types.js';
+import { FirebasePackageConfig } from '../../../config/types/index.js';
+import { StringMap } from '@nu-art/ts-common';
+import { Phase_BuildPushImage, Phase_Deploy, Phase_DeployImage, Phase_Launch } from '../../../phases/definitions/index.js';
+import { Unit_TypescriptLib, Unit_TypescriptLib_Config } from '../Unit_TypescriptLib.js';
+export declare const firebaseFunctionEmulator_ErrorStrings: string[];
+export declare const firebaseFunctionEmulator_WarningStrings: string[];
+type EnvConfig = {
+    defaultConfig?: string;
+    envConfig?: string;
+    projectId: string;
+    isLocal?: boolean;
+};
+export type FunctionTriggerType = 'http' | 'schedule' | 'eventarc';
+export type FunctionResourceConfig = {
+    cpu?: string | number;
+    memory?: string;
+    timeout?: number;
+    concurrency?: number;
+    minInstances?: number;
+    maxInstances?: number;
+};
+export type FunctionConfig = {
+    name: string;
+    trigger: FunctionTriggerType;
+    schedule?: string;
+    serviceAccountName?: string;
+    resources?: FunctionResourceConfig;
+};
+export type Unit_FirebaseFunctionsApp_Config = Unit_TypescriptLib_Config & {
+    firebaseConfig?: FirebasePackageConfig;
+    pathToFirebaseConfig: string;
+    envConfig: EnvConfig;
+    ignore?: string[];
+    debugPort: number;
+    basePort: number;
+    sslKey: string;
+    sslCert: string;
+    pathToEmulatorData: string;
+    sources?: string[];
+    functions: string[] | FunctionConfig[];
+    containerDeployment?: {
+        artifactRegistry: {
+            region: string;
+            repository: string;
+            projectId: string;
+        };
+        imageName: string;
+        dockerfile?: string;
+    };
+};
+/**
+ * Firebase Functions application unit.
+ *
+ * **Key Features**:
+ * - Extends Unit_TypescriptLib (compiles TypeScript)
+ * - Manages Firebase Functions configuration
+ * - Supports emulator with SSL and debug ports
+ * - Handles function deployment
+ *
+ * **Phases Implemented**:
+ * - `prepare()`: Sets up Firebase Functions config
+ * - `compile()`: Compiles TypeScript for functions
+ * - `launch()`: Starts Firebase Functions emulator
+ * - `deploy()`: Deploys functions to Firebase
+ *
+ * **Configuration**:
+ * - `debugPort`: Port for Node.js debugger
+ * - `basePort`: Base port for emulator
+ * - `sslKey`/`sslCert`: SSL certificates for emulator
+ * - `pathToEmulatorData`: Path for emulator data persistence
+ * - `envConfig`: Environment config (projectId, identityAccount)
+ *
+ * **Emulator**: Runs Firebase Functions emulator with log filtering and error detection.
+ */
+export declare class Unit_FirebaseFunctionsApp<C extends Unit_FirebaseFunctionsApp_Config = Unit_FirebaseFunctionsApp_Config> extends Unit_TypescriptLib<C> implements UnitPhaseImplementor<[Phase_Launch, Phase_Deploy, Phase_BuildPushImage, Phase_DeployImage]> {
+    functions: StringMap;
+    injectedMetadata: StringMap;
+    static staggerCount: number;
+    static DefaultConfig_FirebaseFunction: {
+        pathToFirebaseConfig: string;
+        debugPort: number;
+        basePort: number;
+        sslKey: string;
+        sslCert: string;
+        output: string;
+        pathToEmulatorData: string;
+    };
+    readonly emulatorLogStrings: {
+        error: string[];
+        warning: string[];
+    };
+    constructor(config: Unit_FirebaseFunctionsApp<C>['config']);
+    protected copyPackageJSONToOutput(): Promise<void>;
+    prepare(): Promise<void>;
+    resolveConfigs(): Promise<void>;
+    compile(): Promise<void>;
+    postCompile(): Promise<void>;
+    launch(): Promise<void>;
+    releaseEmulatorPorts(): Promise<void>;
+    deploy(): Promise<void>;
+    /**
+     * Builds Docker container image using Google Cloud Build and pushes it to Artifact Registry.
+     *
+     * **Process**:
+     * 1. Validates image tag is provided via CLI
+     * 2. Validates containerDeployment config exists
+     * 3. Constructs Artifact Registry image reference
+     * 4. Creates isolated staging directory with only required files (dist/, Dockerfile, .cloudbuild.yaml)
+     * 5. Builds and pushes image using Google Cloud Build from staging directory (no local Docker required)
+     *
+     * **Staging Directory Structure**:
+     * - `dist/` - Contains compiled code and package.json (copied from output)
+     * - `Dockerfile` - Container build instructions
+     * - `.cloudbuild.yaml` - Cloud Build configuration
+     *
+     * **Requirements**:
+     * - `--build-push-image <tag>` CLI flag with tag value
+     * - `containerDeployment` config in unit config
+     * - gcloud CLI installed and authenticated
+     * - Cloud Build API enabled in GCP project
+     * - No local Docker daemon required - Cloud Build handles everything
+     */
+    buildPushImage(): Promise<void>;
+    /**
+     * Discovers exported functions from the compiled dist/index.js file.
+     * Parses export statements to extract function names.
+     *
+     * @returns Array of function names found in exports
+     */
+    private discoverExportedFunctions;
+    /**
+     * Normalizes function configuration to FunctionConfig[] format.
+     * Handles both legacy format (string[]) and new format (FunctionConfig[]).
+     */
+    private normalizeFunctionConfigs;
+    /**
+     * Gets function names from configuration (for backward compatibility).
+     */
+    private getFunctionNames;
+    /**
+     * Gets function config by name.
+     */
+    private getFunctionConfig;
+    /**
+     * Validates that all configured functions exist in the compiled dist/index.js file.
+     * Throws ImplementationMissingException if any configured function is missing.
+     */
+    private validateFunctionsExist;
+    /**
+     * Deletes a single function using gcloud run services delete.
+     *
+     * @param functionName Name of the function to delete (original function name with underscores)
+     */
+    private deleteFunction;
+    /**
+     * Deletes multiple functions.
+     * Determines which functions to delete based on CLI parameters.
+     *
+     * @returns Array of function names that were deleted (or would be deleted in dry run)
+     */
+    private deleteFunctions;
+    /**
+     * Deploys container image from Artifact Registry to Firebase Functions using gcloud.
+     *
+     * **Process**:
+     * 1. Validates image tag is provided via CLI
+     * 2. Validates containerDeployment config exists
+     * 3. Validates configured functions exist in dist/index.js
+     * 4. Deletes functions if requested via CLI flags
+     * 5. Determines which functions to deploy (single or all)
+     * 6. Generates Cloud Run service YAML definitions for each function
+     * 7. Sets required environment variables (FIREBASE_CONFIG, GCLOUD_PROJECT, FUNCTION_TARGET, etc.)
+     * 8. Deploys each function using `gcloud run services replace` with YAML definition
+     * 9. Retrieves function URLs after successful deployment
+     *
+     * **Environment Variables Set**:
+     * - `FUNCTION_TARGET`: Function name to invoke
+     * - `GCLOUD_PROJECT`: Runtime project ID
+     * - `GOOGLE_CLOUD_PROJECT`: Runtime project ID (alternative)
+     * - `FIREBASE_CONFIG`: JSON string with projectId, databaseURL, storageBucket, locationId
+     * - `EVENTARC_CLOUD_EVENT_SOURCE`: Eventarc source path
+     * - `LOG_EXECUTION_ID`: Set to 'true' for execution ID logging
+     *
+     * **Function Configuration**:
+     * Functions can be configured in two formats:
+     * 1. **Legacy format** (string[]): Simple array of function names (all default to HTTP trigger)
+     * 2. **New format** (FunctionConfig[]): Array of function config objects with:
+     *    - `name`: Function name (must match exported function name)
+     *    - `trigger`: Trigger type ('http', 'schedule', or 'eventarc')
+     *    - `schedule`: Schedule expression (required for 'schedule' trigger, e.g., 'every 24 hours', '0 2 * * *')
+     *    - `resources`: Per-function resource configuration:
+     *      - `cpu`: CPU allocation (e.g., '1', '2', '4')
+     *      - `memory`: Memory allocation (e.g., '512Mi', '1Gi', '2Gi', '4Gi', '8Gi')
+     *      - `timeout`: Timeout in seconds (default: 300, max: 3600)
+     *      - `concurrency`: Container concurrency (default: 80, max: 1000)
+     *      - `minInstances`: Minimum number of instances (default: 0)
+     *      - `maxInstances`: Maximum number of instances (default: 100)
+     *
+     * **Trigger Types**:
+     * - `http`: HTTP-triggered function (deployed as Cloud Run service)
+     * - `schedule`: Scheduled function (requires `schedule` property, deployed as Cloud Run service with Cloud Scheduler)
+     * - `eventarc`: Event-triggered function (deployed as Cloud Run service with Eventarc)
+     *
+     * **Requirements**:
+     * - `--deploy-image <tag>` CLI flag with tag value
+     * - `containerDeployment` config in unit config
+     * - `functions` array in unit config (legacy or new format)
+     * - Image must already exist in Artifact Registry (built via buildPushImage)
+     * - gcloud CLI installed and authenticated
+     * - Cloud Functions API enabled in GCP project
+     * - Cloud Scheduler API enabled (for scheduled functions)
+     *
+     * **Note on Request Size Limits**:
+     * The `PayloadTooLargeError` is typically caused by Express body-parser limits, not Cloud Run limits.
+     * Configure `bodyParserLimit` in your HttpServer module config to increase the limit (default: 200kb).
+     * Cloud Run supports request bodies up to 32MB, but Express must be configured to accept them.
+     */
+    deployImage(): Promise<void>;
+    private getEnvConfig;
+    private resolveFunctionsRC;
+    private resolveProxyFile;
+    private pathToProxy;
+    private resolveConfigDir;
+    private resolveFunctionsJSON;
+    private resolveFunctionsRuntimeConfig;
+    private createAppVersionFile;
+    protected deriveDistDependencies(): StringMap;
+    private createDependenciesDir;
+    private runProxy;
+    private runEmulator;
+}
+export {};