@nu-art/build-and-install 0.401.9 → 0.500.0

package/BuildAndInstall.js

@@ -8,7 +8,7 @@ import { PhaseManager } from './phases/PhaseManager.js';
 import { Workspace } from './workspace/Workspace.js';
 import { resolve } from 'path';
 import { CONST_BaiConfig, CONST_NodeModules, CONST_VersionApp } from './config/consts.js';
-import { UnitMapper_FirebaseFunction, UnitMapper_FirebaseHosting, UnitMapper_NodeLib, UnitMapper_NodeProject } from './units/discovery/resolvers/index.js';
+import { UnitMapper_FirebaseFunction, UnitMapper_FirebaseHosting, UnitMapper_NodeLib, UnitMapper_NodeProject, UnitMapper_ViteHosting } from './units/discovery/resolvers/index.js';
 import { CLIParamsResolver } from '@nu-art/cli-params';
 import { RunningStatusHandler } from './runtime/RunningStatusHandler.js';
 import { FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
@@ -60,6 +60,7 @@ export class BuildAndInstall extends Logger {
             .addRules(UnitMapper_NodeLib)
             .addRules(UnitMapper_NodeProject)
             .addRules(UnitMapper_FirebaseHosting)
+            .addRules(UnitMapper_ViteHosting)
             .addRules(UnitMapper_FirebaseFunction)
             .setRuntimeParams(this.runtimeParams);
     }

package/config/types/project-config.d.ts

@@ -29,6 +29,19 @@ export type BAI_Config = {
                 '.firebaserc'?: string;
                 baseEmulationPort?: number;
             };
+            playwright?: {
+                browsers?: ('chromium' | 'firefox' | 'webkit')[];
+                headless?: boolean;
+                baseURL?: string;
+                viewport?: {
+                    width: number;
+                    height: number;
+                };
+                vite?: {
+                    port?: number;
+                    configPath?: string;
+                };
+            };
         };
         firebase?: {
             databaseRules?: string;
@@ -41,7 +54,7 @@ export type BAI_Config = {
             eslintConfig?: string;
         };
         backend: {
-            proxy: string;
+            proxy: string | null;
         };
     };
 };

package/core/params.js

@@ -117,7 +117,7 @@ export const BaiParam_Test = {
     group: 'Test',
     description: 'Run the tests in all the project packages',
 };
-export const TestTypes = ['pure', 'firebase', 'ui', 'mobile'];
+export const TestTypes = ['pure', 'firebase', 'ui', 'mobile', 'playwright'];
 export const BaiParam_TestType = {
     keys: ['--test-type', '-tt'],
     keyName: 'testType',
@@ -296,7 +296,7 @@ export const BaiParam_Publish = {
     process: (part) => part ?? 'patch'
 };
 export const BaiParam_UsePackage = {
-    keys: ['-up', '--use-packages'],
+    keys: ['-up', '--use-package'],
     keyName: 'usePackage',
     type: 'string[]',
     group: 'Other',

package/dependencies/UnitsDependencyMapper.d.ts

@@ -69,4 +69,12 @@ export declare class UnitsDependencyMapper extends Logger {
      * Returns all leaf units (those with no dependencies).
      */
     getLeaves(): string[];
+    /**
+     * Detects cycles in a given dependency map (used for error reporting).
+     */
+    private detectCyclesInMap;
+    /**
+     * Formats the dependency graph as a readable string for error messages.
+     */
+    private formatDependencyGraph;
 }

package/dependencies/UnitsDependencyMapper.js

@@ -99,10 +99,23 @@ export class UnitsDependencyMapper extends Logger {
                 }
             }
             if (nextLayer.length === 0) {
-                this.logWarning(participatingKeys);
-                this.logWarning(map);
-                this.logWarning(`Cyclic or disconnected dependency detected: ${lastNode?.key ?? '??'} and [${nextLayer.join(', ')}]`);
-                throw new Error('Cyclic or disconnected dependency detected');
+                // Detect and report cycles explicitly
+                const cycles = this.detectCyclesInMap(map);
+                const unresolved = _keys(map).filter(key => !resolved.has(key) && !topLayer.includes(key));
+                let errorMessage = '';
+                errorMessage += `Last processed node: ${lastNode?.key ?? '??'}\n`;
+                errorMessage += `Unresolved nodes: [${unresolved.join(', ')}]\n`;
+                errorMessage += 'Cyclic or disconnected dependency detected!\n\n';
+                if (cycles.length > 0) {
+                    errorMessage += `Found ${cycles.length} cycle(s):\n`;
+                    for (const cycle of cycles) {
+                        errorMessage += `  Cycle: ${cycle.join(' -> ')}\n`;
+                    }
+                    errorMessage += '\n';
+                }
+                this.logVerbose(`Full dependency graph:`, this.formatDependencyGraph(map));
+                this.logWarning(errorMessage);
+                throw new Error(errorMessage);
             }
             nextLayer.sort();
             layers.push(sortArray(nextLayer));
@@ -306,4 +319,45 @@ export class UnitsDependencyMapper extends Logger {
     getLeaves() {
         return _values(this.map).filter(node => node.dependsOn.length === 0).map(node => node.key).sort();
     }
+    /**
+     * Detects cycles in a given dependency map (used for error reporting).
+     */
+    detectCyclesInMap(map) {
+        const visited = new Set();
+        const inStack = new Set();
+        const cycles = [];
+        const visit = (key, path) => {
+            if (inStack.has(key)) {
+                const cycleStart = path.indexOf(key);
+                cycles.push(path.slice(cycleStart).concat(key));
+                return;
+            }
+            if (visited.has(key))
+                return;
+            visited.add(key);
+            inStack.add(key);
+            const node = map[key];
+            if (node)
+                for (const dep of node.dependsOn)
+                    visit(dep, path.concat(key));
+            inStack.delete(key);
+        };
+        for (const key of _keys(map))
+            visit(key, []);
+        return cycles;
+    }
+    /**
+     * Formats the dependency graph as a readable string for error messages.
+     */
+    formatDependencyGraph(map) {
+        const lines = [];
+        for (const key of _keys(map)) {
+            const node = map[key];
+            const deps = node.dependsOn.length > 0
+                ? ` -> [${node.dependsOn.join(', ')}]`
+                : ' (no dependencies)';
+            lines.push(`  ${key}${deps}`);
+        }
+        return lines.join('\n');
+    }
 }

package/exports/IndicesMcpServer.js

@@ -201,7 +201,7 @@ export class IndicesMcpServer extends Logger {
                 package: packageName,
                 stale,
                 message: stale
-                    ? "Source files are newer than index files. Run 'bai --map-exports' to regenerate."
+                    ? 'Source files are newer than index files. Run \'bai --map-exports\' to regenerate.'
                     : 'Indices are up to date.'
             });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/build-and-install",
-  "version": "0.401.9",
+  "version": "0.500.0",
   "description": "A build system for monorepos that orchestrates building, testing, and deploying units with dependency-aware phase execution",
   "type": "module",
   "keywords": [
@@ -39,12 +39,12 @@
   },
   "dependencies": {
     "chokidar": "^3.6.0",
-    "@nu-art/cli-params": "0.401.9",
-    "@nu-art/ts-common": "0.401.9",
-    "@nu-art/commando": "0.401.9"
+    "@nu-art/cli-params": "0.500.0",
+    "@nu-art/ts-common": "0.500.0",
+    "@nu-art/commando": "0.500.0"
   },
   "devDependencies": {
-    "@nu-art/testalot": "0.401.9"
+    "@nu-art/testalot": "0.500.0"
   },
   "unitConfig": {
     "type": "typescript-lib"

package/phases/PhaseManager.js

@@ -99,8 +99,8 @@ export class PhaseManager extends Logger {
                 // A unit is eligible if it's eligible for at least one phase in the group
                 const eligibleUnitKeys = new Set();
                 for (const phase of phaseGroup) {
-                    const unitCategory = phase.unitCategory ?? "active";
-                    const phaseEligibleKeys = unitCategory === "project" ? this.projectUnitKeys : this.activeUnits;
+                    const unitCategory = phase.unitCategory ?? 'active';
+                    const phaseEligibleKeys = unitCategory === 'project' ? this.projectUnitKeys : this.activeUnits;
                     phaseEligibleKeys.forEach(key => eligibleUnitKeys.add(key));
                 }
                 const layerUnits = layer.filter(u => eligibleUnitKeys.has(u.config.key));
@@ -113,8 +113,8 @@ export class PhaseManager extends Logger {
                         if (!(phase.method in unit && typeof unit[phase.method] === 'function'))
                             return false;
                         // Check if unit is eligible for this specific phase
-                        const unitCategory = phase.unitCategory ?? "active";
-                        const phaseEligibleKeys = unitCategory === "project" ? this.projectUnitKeys : this.activeUnits;
+                        const unitCategory = phase.unitCategory ?? 'active';
+                        const phaseEligibleKeys = unitCategory === 'project' ? this.projectUnitKeys : this.activeUnits;
                         return phaseEligibleKeys.includes(unit.config.key);
                     });
                     if (supportedPhases.length === 0)

package/phases/definitions/types.d.ts

@@ -36,5 +36,5 @@ export type Phase<PhaseMethod extends string> = {
     /** 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";
+    unitCategory?: 'project' | 'active';
 };

package/templates/backend/proxy/proxy._ts

@@ -1,56 +1,61 @@
 import express from 'express';
-import request from 'request';
 import * as fs from 'fs';
+import {Readable} from 'node:stream';
+import {createServer} from 'node:https';
 
 
 const _express: express.Express = express();
 let _counter = 0;
-_express.all('*', (req, res) => {
+_express.all('*', async (req, res) => {
 	const counter = ++_counter;
 	const qMark = req.originalUrl.indexOf('?');
 	const query = qMark > 1 ? req.originalUrl.substring(qMark) : '';
 	const path = req.path;
-	let url = `http://127.0.0.1:SERVER_PORT/PROJECT_ID/us-central1/api${path}${query}`;
-	if (path.startsWith('/emulatorDownload') || path.startsWith('/emulatorUpload'))
-		url = `http://127.0.0.1:SERVER_PORT/PROJECT_ID/us-central1${path}${query}`;
-
+	let url = `http://127.0.0.1:{{SERVER_PORT}}/{{PROJECT_ID}}/us-central1/api${path}${query}`;
 	console.log(`PROXY ${counter} - [${req.method}] ${url}`);
 
-	const handleError = (error: any) => {
-	    if(!error)
-	        return;
+	try {
+		const headers: Record<string, string | string[] | undefined> = {...req.headers};
+		delete headers['host'];
+		delete headers['content-length'];
 
-		console.log(`ERROR calling: ${url}`, error);
-        res.status(503).end();
-	};
+		const fetchOptions: RequestInit = {
+			method: req.method,
+			headers: headers as HeadersInit
+		};
 
-	try {
-		let reqContent;
-		if (req.method === 'POST') {
-			reqContent = request.post({uri: url, body: req.body}, handleError);
-		} else if (req.method === 'PUT') {
-			reqContent = request.put({uri: url, body: req.body}, handleError);
-		} else if (req.method === 'GET') {
-			reqContent = request.get(url, handleError);
-		} else if (req.method === 'DELETE') {
-			reqContent = request.delete(url, handleError);
-		} else if (req.method === 'HEAD') {
-			reqContent = request.head(url, handleError);
+		// Stream request body for methods that can have a body (fetch forbids body on GET/HEAD)
+		if (req.method !== 'GET' && req.method !== 'HEAD') {
+			fetchOptions.body = Readable.toWeb(req) as any;
+			(fetchOptions as RequestInit & { duplex: 'half' }).duplex = 'half';
+		}
+
+		const response = await fetch(url, fetchOptions);
+
+		res.status(response.status);
+		// Don't forward content-encoding/content-length: fetch already decompressed the body
+		response.headers.forEach((value, key) => {
+			const k = key.toLowerCase();
+			if (k === 'content-encoding' || k === 'content-length') return;
+			res.setHeader(key, value);
+		});
+
+		if (response.body) {
+			Readable.fromWeb(response.body as Parameters<typeof Readable.fromWeb>[0]).pipe(res, {end: true});
 		} else {
-			reqContent = request(url, handleError);
+			res.end();
 		}
 
-		req.pipe(reqContent).pipe(res, {end: true});
 		console.log(`PROXY ${counter} - END`);
 	} catch (e) {
 		console.log(`ERROR calling: ${url}`, e);
-		res.status(500).end();
+		res.status(503).end();
 	}
 });
 
 const ssl = {
-	key: 'PATH_TO_SSL_KEY',
-	cert: 'PATH_TO_SSL_CERTIFICATE'
+	key: '{{PATH_TO_SSL_KEY}}',
+	cert: '{{PATH_TO_SSL_CERTIFICATE}}'
 };
 
 let key = ssl.key;
@@ -68,5 +73,5 @@ const options = {
 	requestCert: false,
 };
 
-require('https').createServer(options, _express).listen(PROXY_PORT);
-console.log('SSL proxy started!!!');
+createServer(options, _express).listen(+'{{PROXY_PORT}}');
+console.log(`SSL proxy started at port: {{PROXY_PORT}}`);

package/templates/firebase/config/database.rules.json

@@ -2,6 +2,12 @@
   "rules": {
     ".read": false,
     ".write": false,
+    "_config": {
+      "frontend": {
+        ".read": true,
+        ".write": false
+      }
+    },
     "state": {
       "ModuleBE_SyncManager": {
         "syncData": {

package/templates/firebase/functions/service.yaml

@@ -12,8 +12,6 @@ metadata:
     cloudfunctions.googleapis.com/function-id: {{FUNCTION_NAME}}
     run.googleapis.com/ingress: all
     run.googleapis.com/ingress-status: all
-    run.googleapis.com/invoker-iam-disabled: 'true'
-    run.googleapis.com/maxScale: '100'
 spec:
   template:
     metadata:

package/units/discovery/resolvers/UnitMapper_FirebaseHosting.d.ts

@@ -1,6 +1,6 @@
 import { TypedMap } from '@nu-art/ts-common';
 import { UnitMapper_Node, UnitMapper_NodeContext } from './UnitMapper_Node.js';
-import { FirebaseHosting_EnvConfig, Unit_FirebaseHostingApp, UnitConfigJSON_FirebaseHosting } from '../../implementations/firebase/Unit_FirebaseHostingApp.js';
+import { Unit_FirebaseHostingApp, UnitConfigJSON_FirebaseHosting, WebpackHosting_EnvConfig } from '../../implementations/firebase/Unit_FirebaseHostingApp.js';
 export declare class UnitMapper_FirebaseHosting_Class extends UnitMapper_Node<Unit_FirebaseHostingApp, UnitConfigJSON_FirebaseHosting> {
     static tsValidator_FirebaseHosting: {
         label: import("@nu-art/ts-common").Validator<string>;
@@ -9,17 +9,13 @@ export declare class UnitMapper_FirebaseHosting_Class extends UnitMapper_Node<Un
         hasSelfHotReload: import("@nu-art/ts-common").Validator<boolean>;
         type: import("@nu-art/ts-common").Validator<any>;
         servingPort: import("@nu-art/ts-common").Validator<number>;
-        envs: (import("@nu-art/ts-common").ValidatorImpl<any> | ((input?: TypedMap<FirebaseHosting_EnvConfig> | undefined) => import("@nu-art/ts-common").InvalidResultObject<TypedMap<FirebaseHosting_EnvConfig>> | undefined))[];
+        envs: (import("@nu-art/ts-common").ValidatorImpl<any> | ((input?: TypedMap<WebpackHosting_EnvConfig> | undefined) => import("@nu-art/ts-common").InvalidResultObject<TypedMap<WebpackHosting_EnvConfig>> | undefined))[];
         hostingConfig: import("@nu-art/ts-common").ValidatorImpl<any>;
         hostingDeployment: (import("@nu-art/ts-common").ValidatorImpl<any> | ((input?: object | undefined) => string | object | undefined))[];
     };
     constructor();
     protected resolveNodeUnit(context: UnitMapper_NodeContext<UnitConfigJSON_FirebaseHosting>): Promise<Unit_FirebaseHostingApp<{
-        envConfig: {
-            config: import("@nu-art/ts-common").TS_Object;
-            projectId: string;
-            isLocal: boolean;
-        };
+        envConfig: WebpackHosting_EnvConfig;
         isTopLevelApp: true;
         hasSelfHotReload: boolean;
         customESLintConfig: boolean;
@@ -28,8 +24,8 @@ export declare class UnitMapper_FirebaseHosting_Class extends UnitMapper_Node<Un
         packageJson: import("../types.js").TS_PackageJSON<UnitConfigJSON_FirebaseHosting>;
         label: string;
         servingPort: number;
-        hostingConfig?: import("../../implementations/firebase/Unit_FirebaseHostingApp.js").FirebaseHostingConfig | undefined;
-        envs: TypedMap<FirebaseHosting_EnvConfig>;
+        hostingConfig?: import("../../implementations/firebase/Unit_HostingApp.js").FirebaseHostingConfig | undefined;
+        envs: TypedMap<WebpackHosting_EnvConfig>;
         fullPath: import("@nu-art/ts-common").AbsolutePath;
         relativePath: import("@nu-art/ts-common").RelativePath;
         key: string;

package/units/discovery/resolvers/UnitMapper_FirebaseHosting.js

@@ -7,6 +7,7 @@ const valuesValidator = {
     config: tsValidateMustExist,
     projectId: tsValidateAnyString,
     isLocal: tsValidateBoolean(false),
+    webpackConfig: tsValidateOptional
 };
 // Artifact Registry generic package name validation: lowercase, alphanumeric with dots, underscores, hyphens
 // Cannot start/end with separators, no consecutive separators
@@ -41,7 +42,8 @@ export class UnitMapper_FirebaseHosting_Class extends UnitMapper_Node {
         const envConfig = {
             config: envUnitConfig?.config,
             projectId: envUnitConfig?.projectId,
-            isLocal: envUnitConfig?.isLocal ?? env === 'local'
+            isLocal: envUnitConfig?.isLocal ?? env === 'local',
+            webpackConfig: envUnitConfig?.webpackConfig,
         };
         const { type, ...unitConfig } = context.packageJson.unitConfig;
         return new Unit_FirebaseHostingApp({

package/units/discovery/resolvers/UnitMapper_Node.js

@@ -1,7 +1,8 @@
-import { _keys, deepClone, tsValidate, tsValidateBoolean, tsValidateOptionalAnyString, tsValidateResult } from '@nu-art/ts-common';
+import { _keys, deepClone, tsValidateBoolean, tsValidateOptionalAnyString, tsValidateResult } from '@nu-art/ts-common';
 import { FilesCache } from '../../../core/FilesCache.js';
 import { UnitMapper_Base } from './UnitMapper_Base.js';
 import { FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
+import { Unit_PackageJson } from '../../implementations/Unit_PackageJson.js';
 export class UnitMapper_Node extends UnitMapper_Base {
     static invalidPaths = [];
     static tsValidator_Node = {
@@ -32,7 +33,7 @@ export class UnitMapper_Node extends UnitMapper_Base {
             if (tsValidateResult(packageJson.unitConfig.type, this.validator.type))
                 return; // not the expected type for this mapper
             packageJson = deepClone(packageJson);
-            tsValidate(packageJson.unitConfig, this.validator);
+            const configValidationResult = tsValidateResult(packageJson.unitConfig, this.validator, undefined, false);
             const dependencies = packageJson.dependencies;
             if (dependencies)
                 packageJson.dependencies = _keys(dependencies).reduce((acc, key) => {
@@ -55,7 +56,10 @@ export class UnitMapper_Node extends UnitMapper_Base {
             };
             const customESLintConfig = packageJson.unitConfig.customESLintConfig ?? false;
             const customTSConfig = packageJson.unitConfig.customTSConfig ?? false;
-            return this.resolveNodeUnit({ path, root, packageJson, baseConfig, customESLintConfig, customTSConfig });
+            const unit = await this.resolveNodeUnit({ path, root, packageJson, baseConfig, customESLintConfig, customTSConfig });
+            if (unit instanceof Unit_PackageJson)
+                unit.configValidationResult = configValidationResult;
+            return unit;
         }
         catch (e) {
             this.logError(`Failed to load package.json at: ${pathToFile}`, e);

package/units/discovery/resolvers/UnitMapper_ViteHosting.d.ts

@@ -0,0 +1,46 @@
+import { TypedMap } from '@nu-art/ts-common';
+import { UnitMapper_Node, UnitMapper_NodeContext } from './UnitMapper_Node.js';
+import { FirebaseHosting_EnvConfig } from '../../implementations/firebase/Unit_HostingApp.js';
+import { Unit_ViteHostingApp } from '../../implementations/firebase/Unit_ViteHostingApp.js';
+type UnitConfigJSON_ViteHosting_Node = import('../../discovery/resolvers/UnitMapper_Node.js').UnitConfigJSON_Node & {
+    servingPort?: number;
+    hostingConfig?: import('../../implementations/firebase/Unit_HostingApp.js').FirebaseHostingConfig;
+    envs: TypedMap<FirebaseHosting_EnvConfig>;
+};
+export declare class UnitMapper_ViteHosting_Class extends UnitMapper_Node<Unit_ViteHostingApp, UnitConfigJSON_ViteHosting_Node> {
+    static tsValidator_ViteHosting: {
+        label: import("@nu-art/ts-common").Validator<string>;
+        customESLintConfig: import("@nu-art/ts-common").Validator<boolean>;
+        customTSConfig: import("@nu-art/ts-common").Validator<boolean>;
+        hasSelfHotReload: import("@nu-art/ts-common").Validator<boolean>;
+        type: import("@nu-art/ts-common").Validator<any>;
+        servingPort: import("@nu-art/ts-common").Validator<number>;
+        envs: (import("@nu-art/ts-common").ValidatorImpl<any> | ((input?: TypedMap<FirebaseHosting_EnvConfig> | undefined) => import("@nu-art/ts-common").InvalidResultObject<TypedMap<FirebaseHosting_EnvConfig>> | undefined))[];
+        hostingConfig: import("@nu-art/ts-common").ValidatorImpl<any>;
+        hostingDeployment: (import("@nu-art/ts-common").ValidatorImpl<any> | ((input?: object | undefined) => string | object | undefined))[];
+    };
+    constructor();
+    protected resolveNodeUnit(context: UnitMapper_NodeContext<UnitConfigJSON_ViteHosting_Node>): Promise<Unit_ViteHostingApp<{
+        envConfig: {
+            config: import("@nu-art/ts-common").TS_Object;
+            projectId: string;
+            isLocal: boolean;
+        };
+        isTopLevelApp: true;
+        hasSelfHotReload: boolean;
+        customESLintConfig: boolean;
+        customTSConfig: boolean;
+        output: string;
+        packageJson: import("../types.js").TS_PackageJSON<UnitConfigJSON_ViteHosting_Node>;
+        label: string;
+        servingPort: number;
+        hostingConfig?: import("../../implementations/firebase/Unit_HostingApp.js").FirebaseHostingConfig | undefined;
+        envs: TypedMap<FirebaseHosting_EnvConfig>;
+        fullPath: import("@nu-art/ts-common").AbsolutePath;
+        relativePath: import("@nu-art/ts-common").RelativePath;
+        key: string;
+        dependencies: import("@nu-art/ts-common").StringMap;
+    }>>;
+}
+export declare const UnitMapper_ViteHosting: UnitMapper_ViteHosting_Class;
+export {};

package/units/discovery/resolvers/UnitMapper_ViteHosting.js

@@ -0,0 +1,59 @@
+import { tsValidateAnyString, tsValidateBoolean, tsValidateDynamicObject, tsValidateMustExist, tsValidateOptional, tsValidateOptionalAnyNumber, tsValidateOptionalObject, tsValidateRegexp, tsValidateValue } from '@nu-art/ts-common';
+import { UnitMapper_Node } from './UnitMapper_Node.js';
+import { Unit_HostingApp } from '../../implementations/firebase/Unit_HostingApp.js';
+import { Unit_ViteHostingApp } from '../../implementations/firebase/Unit_ViteHostingApp.js';
+import { resolve } from 'path';
+import { BaiParam_SetEnv } from '../../../core/params.js';
+const valuesValidator = {
+    config: tsValidateMustExist,
+    projectId: tsValidateAnyString,
+    isLocal: tsValidateBoolean(false),
+};
+const packageNameRegex = /^[a-z0-9]+([._-][a-z0-9]+)*$/;
+const hostingDeploymentValidator = {
+    artifactRegistry: {
+        region: tsValidateAnyString,
+        repository: tsValidateAnyString,
+        projectId: tsValidateAnyString,
+    },
+    packageName: tsValidateRegexp(packageNameRegex, true),
+};
+export class UnitMapper_ViteHosting_Class extends UnitMapper_Node {
+    static tsValidator_ViteHosting = {
+        type: tsValidateValue(['vite-hosting']),
+        servingPort: tsValidateOptionalAnyNumber,
+        envs: tsValidateDynamicObject(valuesValidator, tsValidateAnyString),
+        hostingConfig: tsValidateOptional,
+        hostingDeployment: tsValidateOptionalObject(hostingDeploymentValidator),
+        ...UnitMapper_Node.tsValidator_Node,
+    };
+    constructor() {
+        super(UnitMapper_ViteHosting_Class.tsValidator_ViteHosting);
+    }
+    async resolveNodeUnit(context) {
+        const outputDir = context.packageJson.publishConfig?.directory;
+        const env = this.runtimeParams[BaiParam_SetEnv.keyName];
+        const envUnitConfig = context.packageJson.unitConfig.envs[env];
+        if (!envUnitConfig)
+            this.logWarning('Package Json config:', context.packageJson.unitConfig);
+        const envConfig = {
+            config: envUnitConfig?.config,
+            projectId: envUnitConfig?.projectId,
+            isLocal: envUnitConfig?.isLocal ?? env === 'local'
+        };
+        const { type, ...unitConfig } = context.packageJson.unitConfig;
+        return new Unit_ViteHostingApp({
+            ...context.baseConfig,
+            ...Unit_HostingApp.DefaultConfig_Hosting,
+            ...unitConfig,
+            envConfig,
+            isTopLevelApp: true,
+            hasSelfHotReload: unitConfig.hasSelfHotReload ?? false,
+            customESLintConfig: context.customESLintConfig,
+            customTSConfig: context.customTSConfig,
+            output: resolve(context.baseConfig.fullPath, outputDir ?? Unit_HostingApp.DefaultConfig_Hosting.output),
+            packageJson: context.packageJson,
+        });
+    }
+}
+export const UnitMapper_ViteHosting = new UnitMapper_ViteHosting_Class();

package/units/discovery/resolvers/index.d.ts

@@ -2,3 +2,4 @@ export * from './UnitMapper_NodeLib.js';
 export * from './UnitMapper_NodeProject.js';
 export * from './UnitMapper_FirebaseFunction.js';
 export * from './UnitMapper_FirebaseHosting.js';
+export * from './UnitMapper_ViteHosting.js';

package/units/discovery/resolvers/index.js

@@ -2,3 +2,4 @@ export * from './UnitMapper_NodeLib.js';
 export * from './UnitMapper_NodeProject.js';
 export * from './UnitMapper_FirebaseFunction.js';
 export * from './UnitMapper_FirebaseHosting.js';
+export * from './UnitMapper_ViteHosting.js';

package/units/implementations/Unit_PackageJson.d.ts

@@ -1,4 +1,4 @@
-import { StringMap } from '@nu-art/ts-common';
+import { InvalidResult, 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';
@@ -31,6 +31,7 @@ export type Unit_PackageJson_Config = Config_ProjectUnit & {
  * **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, Phase_PrepareWatch]> {
+    configValidationResult?: InvalidResult<any>;
     constructor(config: C);
     protected npmCommand(command: string): string;
     protected deriveDistDependencies(): StringMap;

package/units/implementations/Unit_PackageJson.js

@@ -1,7 +1,8 @@
 import { CONST_NodeModules, CONST_PackageJSON } from '../../config/consts.js';
-import { __stringify } from '@nu-art/ts-common';
+import { __stringify, ValidationException } from '@nu-art/ts-common';
 import { ProjectUnit } from '../base/ProjectUnit.js';
 import { resolve } from 'path';
+import { existsSync } from 'fs';
 import { Commando_NVM } from '@nu-art/commando';
 import { DEFAULT_OLD_TEMPLATE_PATTERN, FileSystemUtils } from '@nu-art/ts-common/utils/FileSystemUtils';
 /**
@@ -26,12 +27,16 @@ import { DEFAULT_OLD_TEMPLATE_PATTERN, FileSystemUtils } from '@nu-art/ts-common
  * **Base For**: Unit_NodeProject, Unit_TypescriptLib, Unit_FirebaseHosting, etc.
  */
 export class Unit_PackageJson extends ProjectUnit {
+    configValidationResult;
     constructor(config) {
         super(config);
         this.addToClassStack(Unit_PackageJson);
     }
     //######################### Internal Logic #########################
     npmCommand(command) {
+        const packageBin = resolve(this.config.fullPath, './node_modules/.bin', command);
+        if (existsSync(packageBin))
+            return packageBin;
         return resolve(this.runtimeContext.parentUnit.config.fullPath, './node_modules/.bin', command);
     }
     deriveDistDependencies() {
@@ -64,6 +69,8 @@ export class Unit_PackageJson extends ProjectUnit {
      * **Template Params**: Includes THUNDERSTORM_VERSION, __ENV__, and child unit versions.
      */
     async prepare() {
+        if (this.configValidationResult)
+            throw new ValidationException(`Invalid unit config for '${this.config.key}'`, undefined, this.configValidationResult);
         await this._sharedPrepare();
     }
     async watchPrepare() {
@@ -86,6 +93,7 @@ export class Unit_PackageJson extends ProjectUnit {
     }
     async releasePorts(allPorts) {
         const commando = this.allocateCommando(Commando_NVM).applyNVM();
+        this.logInfo('Releasing ports: ', allPorts);
         await commando.setUID(this.config.key)
             .append(`array=($(lsof -ti:${allPorts.join(',')}))`)
             .append(`((\${#array[@]} > 0)) && kill -9 "\${array[@]}"`)

package/units/implementations/Unit_TypescriptLib.d.ts

@@ -14,7 +14,7 @@ export type Unit_TypescriptLib_Config = Unit_PackageJson_Config & {
  *
  * **Key Responsibilities**:
  * - Compiles TypeScript to JavaScript
- * - Runs tests (pure, firebase, ui, mobile)
+ * - Runs tests (pure, firebase, ui, mobile, playwright)
  * - Lints code
  * - Publishes packages
  * - Manages assets (JSON, SCSS, SVG, images)
@@ -36,6 +36,11 @@ export type Unit_TypescriptLib_Config = Unit_PackageJson_Config & {
  * - **firebase**: Tests with Firebase emulators
  * - **ui**: UI tests (not implemented)
  * - **mobile**: Mobile tests (not implemented)
+ * - **playwright**: Playwright test runner (@playwright/test)
+ *   - Automatic browser instance management (one per worker)
+ *   - Better performance with shared browser instances across test files
+ *   - Built-in fixtures and test isolation
+ *   - Pattern: **\/*.test.playwright.ts
  *
  * **Asset Management**: Automatically copies non-TypeScript files (JSON, SCSS, SVG, images)
  * to output directory during compilation.
@@ -45,6 +50,7 @@ export type Unit_TypescriptLib_Config = Unit_PackageJson_Config & {
 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>;
+    private generatePlaywrightConfig;
     protected dependencyUnits: Unit_TypescriptLib[];
     constructor(config: Unit_TypescriptLib<C>['config']);
     protected clearOutputDir(): Promise<void>;