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

package/{v3/phase → phases/definitions}/consts.js

@@ -62,6 +62,20 @@ export const phase_PreCompile = {
     method: 'preCompile',
     filter: (baiParams) => !baiParams.noBuild,
 };
+export const phaseKey_ExtractDynamicDeps = 'extract-dynamic-deps';
+export const phase_ExtractDynamicDeps = {
+    key: phaseKey_ExtractDynamicDeps,
+    name: 'Extract Dynamic Dependencies',
+    method: 'extractDynamicDeps',
+    filter: (baiParams) => baiParams.extractDynamicDeps,
+};
+export const phaseKey_MapExports = 'map-exports';
+export const phase_MapExports = {
+    key: phaseKey_MapExports,
+    name: 'Map Exports',
+    method: 'mapExports',
+    filter: (baiParams) => baiParams.mapExports,
+};
 export const phaseKey_Compile = 'compile';
 export const phase_Compile = {
     key: phaseKey_Compile,
@@ -95,7 +109,7 @@ export const phases_Build = [
     [phase_Purge, phase_Prepare],
     [phase_ToESM],
     [phase_Install],
-    [phase_Lint, phase_PreCompile, phase_Compile, phase_Test,],
+    [phase_Lint, phase_PreCompile, phase_ExtractDynamicDeps, phase_MapExports, phase_Compile, phase_Test,],
     [phase_Watch]
 ];
 export const phaseKey_Launch = 'launch';
@@ -105,8 +119,16 @@ export const phase_Launch = {
     method: 'launch',
     filter: (baiParams) => !!baiParams.launch,
 };
+export const phaseKey_IndicesMcpServer = 'indices-mcp-server';
+export const phase_IndicesMcpServer = {
+    key: phaseKey_IndicesMcpServer,
+    name: 'Export Indices MCP Server',
+    method: 'indicesMcpServer',
+    filter: (baiParams) => baiParams.indicesMcpServer,
+};
 export const phases_Launch = [[
         phase_Launch,
+        phase_IndicesMcpServer,
     ]];
 export const phaseKey_Publish = 'publish';
 export const phase_Publish = {
@@ -129,4 +151,24 @@ export const phase_Deploy = {
     method: 'deploy',
     filter: (baiParams) => !!baiParams.deploy,
 };
-export const phases_Deploy = [[phase_Publish, phase_Deploy], [phase_PostPublish]];
+export const phaseKey_BuildPushImage = 'build-push-image';
+export const phase_BuildPushImage = {
+    key: phaseKey_BuildPushImage,
+    name: 'Build & Push Container Image',
+    method: 'buildPushImage',
+    filter: (baiParams) => !!baiParams.buildPushImage,
+};
+export const phaseKey_DeployImage = 'deploy-image';
+export const phase_DeployImage = {
+    key: phaseKey_DeployImage,
+    name: 'Deploy Container Image',
+    method: 'deployImage',
+    filter: (baiParams) => !!baiParams.deployImage,
+    dependencyPhase: [phase_BuildPushImage],
+};
+export const phases_Deploy = [
+    [phase_BuildPushImage],
+    [phase_DeployImage],
+    [phase_Publish, phase_Deploy],
+    [phase_PostPublish]
+];

package/phases/definitions/types.d.ts

@@ -0,0 +1,40 @@
+import { BaiParams } from '../../core/params.js';
+/**
+ * Phase definition for build system execution.
+ *
+ * **Phase Structure**:
+ * - Phases are grouped into phase groups (arrays of phases)
+ * - Phases in a group can run in parallel
+ * - Phase groups run sequentially
+ *
+ * **Key Properties**:
+ * - `key`: Unique identifier for the phase
+ * - `method`: Method name that units must implement (e.g., 'compile', 'test')
+ * - `filter`: Optional function to determine if phase should run based on runtime params
+ * - `unitCategory`: Which units participate ('active' or 'project')
+ * - `dependencyPhase`: Phases that must complete before this phase runs
+ * - `terminateAfterPhase`: If true, stops execution after this phase completes
+ *
+ * **Unit Participation**:
+ * - Units must implement the phase method to participate
+ * - Units must be in the correct category (active/project)
+ * - Phase filter must pass (if present)
+ *
+ * **Examples**: See `phase/consts.ts` for all phase definitions.
+ */
+export type Phase<PhaseMethod extends string> = {
+    /** Unique identifier for the phase */
+    key: string;
+    /** Display name for the phase */
+    name: string;
+    /** Method name that units must implement */
+    method: PhaseMethod;
+    /** Optional filter to determine if phase should run based on runtime params */
+    filter?: (params: BaiParams) => boolean;
+    /** If true, terminates execution after this phase completes */
+    terminateAfterPhase?: boolean;
+    /** Phases that must complete before this phase runs */
+    dependencyPhase?: Phase<string>[];
+    /** Unit category: 'project' = all project units (active + dependencies), 'active' = only active units (default) */
+    unitCategory?: "project" | "active";
+};

package/phases/index.d.ts

@@ -0,0 +1,2 @@
+export * from './definitions/index.js';
+export * from './PhaseManager.js';

package/phases/index.js

@@ -0,0 +1,2 @@
+export * from './definitions/index.js';
+export * from './PhaseManager.js';

package/run.js

@@ -0,0 +1,10 @@
+import { BuildAndInstall } from './BuildAndInstall.js';
+(async () => {
+    const buildAndInstall = new BuildAndInstall();
+    await buildAndInstall.build();
+    await buildAndInstall.run();
+})()
+    .catch((err) => {
+    process.exit(2);
+})
+    .then(() => process.exit(0));

package/runtime/RunningStatusHandler.d.ts

@@ -0,0 +1,104 @@
+import { Logger } from '@nu-art/ts-common';
+import { BaiParams } from '../core/params.js';
+/**
+ * Manages execution state persistence for resume support.
+ *
+ * **Purpose**: Enables `--continue` flag to resume from last completed step.
+ *
+ * **State Management**:
+ * - **startIndex**: Current step index (0-based)
+ * - **completedUnits**: Units completed in current step
+ * - **runtimeParams**: Runtime parameters (for state validation)
+ *
+ * **Persistence**:
+ * - Saves state to `.trash/output/running-status.json` after each step/unit
+ * - Loads state on init if `--continue` flag is set
+ * - State includes: index, runtimeParams, completedUnits
+ *
+ * **Isolation Mode**: When isolated, skips saving state (useful for tests).
+ *
+ * **Usage Flow**:
+ * 1. `init()` - Loads state if `--continue`
+ * 2. `onStepStarted()` - Saves current step index
+ * 3. `onUnitCompleted()` - Marks unit as completed, saves state
+ * 4. `onStepEnded()` - Clears completed units for next step
+ * 5. `isCompleted()` - Checks if unit already completed (for resume)
+ */
+export declare class RunningStatusHandler extends Logger {
+    private isolated;
+    private readonly outputFolder;
+    private completedUnits;
+    runtimeParams: BaiParams;
+    startIndex: number;
+    constructor(outputFolder: string, runtimeParams: BaiParams);
+    /**
+     * Initializes the status handler.
+     *
+     * **Actions**:
+     * - Creates output folder if missing
+     * - Loads saved state if `--continue` flag is set
+     * - Merges loaded runtime params with current params (loaded params take precedence)
+     */
+    init(): Promise<void>;
+    /**
+     * Enables isolation mode (skips saving state).
+     *
+     * Useful for tests or when state persistence is not desired.
+     *
+     * @returns This instance for chaining
+     */
+    isolate(): RunningStatusHandler;
+    /**
+     * Checks if a unit has already been completed (for resume).
+     *
+     * @param unitKey - Unit key to check
+     * @returns True if unit is marked as completed
+     */
+    isCompleted(unitKey: string): boolean;
+    /**
+     * Marks a unit as completed and saves state.
+     *
+     * Called after a unit successfully completes all its phases.
+     *
+     * @param unitKey - Unit key that completed
+     */
+    onUnitCompleted(unitKey: string): Promise<void>;
+    /**
+     * Called when a step completes successfully.
+     *
+     * Clears completed units list for the next step.
+     */
+    onStepEnded(): Promise<void>;
+    /**
+     * Called when a step starts.
+     *
+     * Updates start index and saves state (unless isolated).
+     *
+     * @param index - Step index (0-based)
+     */
+    onStepStarted(index: number): Promise<void>;
+    /**
+     * Saves current state to disk.
+     *
+     * Writes to `.trash/output/running-status.json` with:
+     * - Current step index
+     * - Runtime params (for validation)
+     * - Completed units in current step
+     *
+     * Called after each step start and unit completion.
+     */
+    private saveStatus;
+    /**
+     * Loads saved state from disk.
+     *
+     * **Behavior**:
+     * - Reads from `.trash/output/running-status.json`
+     * - Restores step index, completed units, and runtime params
+     * - Returns undefined if file doesn't exist or parse fails (logs error)
+     *
+     * **Note**: Runtime params from file override current params (for consistency).
+     *
+     * @returns Promise resolving to step index, or undefined if load fails
+     */
+    load(): Promise<any>;
+}

package/runtime/RunningStatusHandler.js

@@ -0,0 +1,153 @@
+import fs, { promises as _fs } from 'fs';
+import { __stringify, Logger } from '@nu-art/ts-common';
+/**
+ * Manages execution state persistence for resume support.
+ *
+ * **Purpose**: Enables `--continue` flag to resume from last completed step.
+ *
+ * **State Management**:
+ * - **startIndex**: Current step index (0-based)
+ * - **completedUnits**: Units completed in current step
+ * - **runtimeParams**: Runtime parameters (for state validation)
+ *
+ * **Persistence**:
+ * - Saves state to `.trash/output/running-status.json` after each step/unit
+ * - Loads state on init if `--continue` flag is set
+ * - State includes: index, runtimeParams, completedUnits
+ *
+ * **Isolation Mode**: When isolated, skips saving state (useful for tests).
+ *
+ * **Usage Flow**:
+ * 1. `init()` - Loads state if `--continue`
+ * 2. `onStepStarted()` - Saves current step index
+ * 3. `onUnitCompleted()` - Marks unit as completed, saves state
+ * 4. `onStepEnded()` - Clears completed units for next step
+ * 5. `isCompleted()` - Checks if unit already completed (for resume)
+ */
+export class RunningStatusHandler extends Logger {
+    isolated = false;
+    outputFolder;
+    // The completed units in the phase.. when running -con, these can be skipped
+    completedUnits = [];
+    runtimeParams;
+    startIndex = 0;
+    constructor(outputFolder, runtimeParams) {
+        super();
+        this.outputFolder = outputFolder;
+        this.runtimeParams = runtimeParams;
+    }
+    /**
+     * Initializes the status handler.
+     *
+     * **Actions**:
+     * - Creates output folder if missing
+     * - Loads saved state if `--continue` flag is set
+     * - Merges loaded runtime params with current params (loaded params take precedence)
+     */
+    async init() {
+        if (!fs.existsSync(this.outputFolder))
+            await _fs.mkdir(this.outputFolder, { recursive: true });
+        if (this.runtimeParams.continue) {
+            const currentParams = this.runtimeParams;
+            this.startIndex = await this.load();
+            this.runtimeParams = Object.assign(currentParams, this.runtimeParams);
+        }
+    }
+    /**
+     * Enables isolation mode (skips saving state).
+     *
+     * Useful for tests or when state persistence is not desired.
+     *
+     * @returns This instance for chaining
+     */
+    isolate() {
+        this.isolated = true;
+        return this;
+    }
+    /**
+     * Checks if a unit has already been completed (for resume).
+     *
+     * @param unitKey - Unit key to check
+     * @returns True if unit is marked as completed
+     */
+    isCompleted(unitKey) {
+        return this.completedUnits.includes(unitKey);
+    }
+    /**
+     * Marks a unit as completed and saves state.
+     *
+     * Called after a unit successfully completes all its phases.
+     *
+     * @param unitKey - Unit key that completed
+     */
+    async onUnitCompleted(unitKey) {
+        this.logDebug(`On unit completed: ${unitKey}`);
+        this.completedUnits.push(unitKey);
+        await this.saveStatus();
+    }
+    /**
+     * Called when a step completes successfully.
+     *
+     * Clears completed units list for the next step.
+     */
+    async onStepEnded() {
+        this.logDebug(`On step ended successfully #${this.startIndex}`);
+        this.completedUnits = [];
+    }
+    /**
+     * Called when a step starts.
+     *
+     * Updates start index and saves state (unless isolated).
+     *
+     * @param index - Step index (0-based)
+     */
+    async onStepStarted(index) {
+        this.startIndex = index;
+        this.logDebug(`Setting execution index to #${this.startIndex}`);
+        await this.saveStatus();
+    }
+    /**
+     * Saves current state to disk.
+     *
+     * Writes to `.trash/output/running-status.json` with:
+     * - Current step index
+     * - Runtime params (for validation)
+     * - Completed units in current step
+     *
+     * Called after each step start and unit completion.
+     */
+    async saveStatus() {
+        if (this.isolated)
+            return;
+        await _fs.writeFile(`${this.outputFolder}/running-status.json`, __stringify({
+            index: this.startIndex,
+            runtimeParams: this.runtimeParams,
+            completedUnits: this.completedUnits
+        }, true));
+    }
+    /**
+     * Loads saved state from disk.
+     *
+     * **Behavior**:
+     * - Reads from `.trash/output/running-status.json`
+     * - Restores step index, completed units, and runtime params
+     * - Returns undefined if file doesn't exist or parse fails (logs error)
+     *
+     * **Note**: Runtime params from file override current params (for consistency).
+     *
+     * @returns Promise resolving to step index, or undefined if load fails
+     */
+    async load() {
+        try {
+            const data = JSON.parse(await _fs.readFile(`${this.outputFolder}/running-status.json`, { encoding: 'utf-8' }));
+            this.startIndex = data.index;
+            this.completedUnits = data.completedUnits ?? [];
+            this.runtimeParams = data.runtimeParams;
+            return data.index;
+        }
+        catch (e) {
+            this.logError('Failed reading running status, using initial status', e);
+            return;
+        }
+    }
+}

package/runtime/types.d.ts

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

package/runtime/types.js

@@ -0,0 +1,2 @@
+// Runtime types will be defined here if needed
+export {};

package/{defaults → templates}/consts.d.ts

@@ -11,6 +11,15 @@ export declare const Const_FirebaseDefaultsKeyToFile: {
     [k in typeof Const_FirebaseConfigKeys[number]]: string;
 };
 export declare const Default_Files: ProjectConfig_DefaultFileRoutes;
+/**
+ * Template file paths for Firebase Functions container builds.
+ * These are used when no custom templates are specified in baiConfig.
+ */
+export declare const FunctionBuildTemplateFiles: {
+    dockerfile: string;
+    cloudbuildYaml: string;
+    serviceYaml: string;
+};
 export declare const Default_OutputFiles: {
     output: string;
     outputLogs: string;

package/{defaults → templates}/consts.js

@@ -3,8 +3,9 @@ import { dirname } from 'node:path';
 // ESM-safe replacements for __filename/__dirname
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const CONST_FirebaseConfig = `${__dirname}/.firebase_config`;
-const CONST_BackendProxy = `${__dirname}/backend-proxy`;
+const CONST_FirebaseConfig = `${__dirname}/firebase/config`;
+const CONST_FirebaseFunctions = `${__dirname}/firebase/functions`;
+const CONST_BackendProxy = `${__dirname}/backend/proxy`;
 export const Const_FirebaseConfigKeys = [
     'databaseRules',
     'firestoreIndexesRules',
@@ -28,6 +29,15 @@ export const Default_Files = {
         proxy: `${CONST_BackendProxy}/proxy._ts`
     }
 };
+/**
+ * Template file paths for Firebase Functions container builds.
+ * These are used when no custom templates are specified in baiConfig.
+ */
+export const FunctionBuildTemplateFiles = {
+    dockerfile: `${CONST_FirebaseFunctions}/dockerfile`,
+    cloudbuildYaml: `${CONST_FirebaseFunctions}/cloudbuild.yaml`,
+    serviceYaml: `${CONST_FirebaseFunctions}/service.yaml`,
+};
 const Default_OutputPath = './.trash';
 export const Default_OutputFiles = {
     output: Default_OutputPath,

package/templates/firebase/functions/cloudbuild.yaml

@@ -0,0 +1,17 @@
+steps:
+  - name: 'gcr.io/cloud-builders/docker'
+    args:
+      - 'build'
+      - '--platform=linux/amd64'
+      - '-t'
+      - '{{IMAGE_REFERENCE}}'
+      - '-t'
+      - '{{IMAGE_REFERENCE_LATEST}}'
+      - '-f'
+      - '{{DOCKERFILE_PATH}}'
+{{LABELS}}
+      - '.'
+images:
+  - '{{IMAGE_REFERENCE}}'
+  - '{{IMAGE_REFERENCE_LATEST}}'
+

package/templates/firebase/functions/dockerfile

@@ -0,0 +1,19 @@
+FROM node:22
+WORKDIR /workspace/dist
+
+# Copy dist folder (which contains package.json and all compiled code)
+COPY dist/ ./
+
+# Install dependencies including functions-framework
+RUN npm install --production && \
+    npm install -g @google-cloud/functions-framework
+
+# Expose the port that Cloud Run will use
+EXPOSE 8080
+
+# Use functions-framework to run the function
+# FUNCTION_TARGET environment variable (set by deployment) specifies which exported function to invoke
+# PORT is automatically set by Cloud Run (default 8080)
+# The framework will load index.js (since we're already in the dist directory)
+CMD ["functions-framework", "--source=index.js"]
+

package/templates/firebase/functions/service.yaml

@@ -0,0 +1,49 @@
+HttpSeapiVersion: serving.knative.dev/v1
+kind: Service
+metadata:
+  name: {{SERVICE_NAME}}
+  labels:
+    goog-cloudfunctions-runtime: nodejs22
+    cloud.googleapis.com/location: {{REGION}}
+    goog-managed-by: cloudfunctions
+  annotations:
+    serving.knative.dev/creator: service-{{RUNTIME_PROJECT_ID}}@gcf-admin-robot.iam.gserviceaccount.com
+    run.googleapis.com/client-name: cli-firebase
+    cloudfunctions.googleapis.com/function-id: {{FUNCTION_NAME}}
+    run.googleapis.com/ingress: all
+    run.googleapis.com/ingress-status: all
+spec:
+  template:
+    metadata:
+      labels: {}
+      annotations:
+        autoscaling.knative.dev/maxScale: '{{MAX_INSTANCES}}'
+        autoscaling.knative.dev/minScale: '{{MIN_INSTANCES}}'
+        run.googleapis.com/startup-cpu-boost: 'true'
+        cloudfunctions.googleapis.com/trigger-type: {{TRIGGER_TYPE}}
+    spec:
+      containerConcurrency: {{CONCURRENCY}}
+      timeoutSeconds: {{TIMEOUT}}
+{{SERVICE_ACCOUNT}}
+      containers:
+      - name: worker
+        image: {{IMAGE_REFERENCE}}
+        ports:
+        - name: http1
+          containerPort: 8080
+        env:
+{{ENV_VARS}}
+        resources:
+          limits:
+            cpu: '{{CPU}}'
+            memory: {{MEMORY}}
+        startupProbe:
+          timeoutSeconds: 240
+          periodSeconds: 240
+          failureThreshold: 1
+          tcpSocket:
+            port: 8080
+  traffic:
+  - percent: 100
+    latestRevision: true
+

package/{v3/units → units/base}/BaseUnit.d.ts

@@ -3,15 +3,23 @@ import { CommandoInteractive } from '@nu-art/commando/shell/index';
 import { BaseCommando } from '@nu-art/commando/shell/core/BaseCommando';
 import { MergeTypes } from '@nu-art/commando/shell/core/class-merger';
 import { Commando_Basic } from '@nu-art/commando/shell/plugins/basic';
-import { BAI_Config } from '../../core/types/index.js';
-import { UnitsDependencyMapper } from '../UnitsDependencyMapper/UnitsDependencyMapper.js';
-import { BaiParams } from '../../core/params/params.js';
-import { Workspace } from '../Workspace.js';
+import { BAI_Config } from '../../config/types/index.js';
+import { UnitsDependencyMapper } from '../../dependencies/UnitsDependencyMapper.js';
+import { BaiParams } from '../../core/params.js';
+import { Workspace } from '../../workspace/Workspace.js';
+/**
+ * Base configuration for all units.
+ */
 export type BaseUnit_Config = {
     key: string;
     label: string;
     isTopLevelApp?: boolean;
 };
+/**
+ * Runtime context provided to all units during execution.
+ *
+ * Contains version, config, dependency mapper, runtime params, and workspace reference.
+ */
 export type UnitRuntimeContext = {
     version: string;
     baiConfig: Readonly<BAI_Config>;
@@ -21,6 +29,28 @@ export type UnitRuntimeContext = {
     globalOutputFolder: string;
     workspace?: Workspace;
 };
+/**
+ * Base class for all units in the build system.
+ *
+ * **Unit Lifecycle**:
+ * 1. **Discovery**: Units are discovered by UnitsMapper from file system
+ * 2. **Initialization**: Constructor sets up config and logging
+ * 3. **Context Setup**: `setupRuntimeContext()` provides runtime information
+ * 4. **Phase Execution**: Phases call unit methods (e.g., `compile()`, `test()`)
+ * 5. **Termination**: `kill()` stops all running processes
+ *
+ * **Key Features**:
+ * - **Commando Integration**: Allocates Commando instances for shell commands
+ * - **Process Management**: Tracks and kills subprocesses on termination
+ * - **Logging**: Buffered logging with status tracking
+ * - **Time Tracking**: Measures operation duration
+ *
+ * **Phase Methods**: Units implement phase methods (e.g., `prepare()`, `compile()`, `test()`)
+ * that are called by PhaseManager. Methods are discovered via reflection.
+ *
+ * **Status Tracking**: Units track their status ('Pending Initialization', 'Running', etc.)
+ * for monitoring and debugging.
+ */
 export declare abstract class BaseUnit<C extends BaseUnit_Config = BaseUnit_Config, RT_Context extends UnitRuntimeContext = UnitRuntimeContext> extends Logger {
     readonly config: Readonly<C>;
     private unitStatus;

package/{v3/units → units/base}/BaseUnit.js

@@ -1,6 +1,27 @@
 import { _logger_finalDate, _logger_getPrefix, _logger_timezoneOffset, BeLogged, exists, lastElement, LogClient_MemBuffer, Logger, LogLevel, removeItemFromArray, timeCounter } from '@nu-art/ts-common';
-import { dispatcher_UnitStatusChange } from '../../old/PhaseRunnerDispatcher.js';
 import { CommandoPool } from '@nu-art/commando/shell/core/CommandoPool';
+/**
+ * Base class for all units in the build system.
+ *
+ * **Unit Lifecycle**:
+ * 1. **Discovery**: Units are discovered by UnitsMapper from file system
+ * 2. **Initialization**: Constructor sets up config and logging
+ * 3. **Context Setup**: `setupRuntimeContext()` provides runtime information
+ * 4. **Phase Execution**: Phases call unit methods (e.g., `compile()`, `test()`)
+ * 5. **Termination**: `kill()` stops all running processes
+ *
+ * **Key Features**:
+ * - **Commando Integration**: Allocates Commando instances for shell commands
+ * - **Process Management**: Tracks and kills subprocesses on termination
+ * - **Logging**: Buffered logging with status tracking
+ * - **Time Tracking**: Measures operation duration
+ *
+ * **Phase Methods**: Units implement phase methods (e.g., `prepare()`, `compile()`, `test()`)
+ * that are called by PhaseManager. Methods are discovered via reflection.
+ *
+ * **Status Tracking**: Units track their status ('Pending Initialization', 'Running', etc.)
+ * for monitoring and debugging.
+ */
 export class BaseUnit extends Logger {
     config;
     unitStatus = 'Pending Initialization';
@@ -86,7 +107,6 @@ export class BaseUnit extends Logger {
             }
         this.log(logLevel, false, [`Unit status update: ${this.unitStatus} => ${status}${operationDuration}`]);
         this.unitStatus = `${status}${operationDuration}`;
-        dispatcher_UnitStatusChange.dispatch(this);
     }
     addToClassStack = (cls) => {
         this.classStack.push(cls.name);

package/units/base/ProjectUnit.d.ts

@@ -0,0 +1,32 @@
+import { StringMap } from '@nu-art/ts-common';
+import { BaseUnit, BaseUnit_Config, UnitRuntimeContext } from './BaseUnit.js';
+export type Config_ProjectUnit = BaseUnit_Config & {
+    relativePath: string;
+    fullPath: string;
+    dependencies: StringMap;
+};
+export type ProjectUnit_RuntimeContext = UnitRuntimeContext & {
+    parentUnit: ProjectUnit<any>;
+    childUnits: ProjectUnit[];
+};
+/**
+ * Abstract base class for project units (packages/apps in the workspace).
+ *
+ * **Project Units vs Base Units**:
+ * - **Project Units**: Have file paths, dependencies, and participate in dependency resolution
+ * - **Base Units**: Generic units without file system context
+ *
+ * **Key Properties**:
+ * - `relativePath`: Path relative to project root
+ * - `fullPath`: Absolute path to unit directory
+ * - `dependencies`: Map of dependency keys (for dependency resolution)
+ *
+ * **Runtime Context**: ProjectUnits receive `ProjectUnit_RuntimeContext` which includes:
+ * - `parentUnit`: Root NodeProject unit
+ * - `childUnits`: All project units in workspace
+ *
+ * **Examples**: Unit_NodeProject, Unit_TypescriptLib, Unit_FirebaseHostingApp
+ */
+export declare abstract class ProjectUnit<C extends Config_ProjectUnit = Config_ProjectUnit> extends BaseUnit<C, ProjectUnit_RuntimeContext> {
+    constructor(config: C);
+}