@zintrust/core 0.4.12 → 0.4.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/core",
-  "version": "0.4.12",
+  "version": "0.4.13",
   "description": "Production-grade TypeScript backend framework for JavaScript",
   "homepage": "https://zintrust.com",
   "repository": {

package/src/cli/commands/StartCommand.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StartCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/StartCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAgtBvF,eAAO,MAAM,YAAY;cACb,YAAY;EA6BtB,CAAC"}
+{"version":3,"file":"StartCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/StartCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAmvBvF,eAAO,MAAM,YAAY;cACb,YAAY;EAmCtB,CAAC"}

package/src/cli/commands/StartCommand.js

@@ -7,6 +7,7 @@ import * as Common from '../../common/index.js';
 import { ErrorFactory } from '../../exceptions/ZintrustError.js';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from '../../node-singletons/fs.js';
 import * as path from '../../node-singletons/path.js';
+const isAbsolutePath = (value) => value.startsWith('/') || /^[A-Za-z]:[\\/]/.test(value);
 const resolveNpmPath = () => {
     try {
         return typeof Common.resolveNpmPath === 'function' ? Common.resolveNpmPath() : 'npm';
@@ -168,6 +169,26 @@ const resolveCacheEnabledPreference = (options) => {
         return options.cache;
     return undefined;
 };
+const resolveRootEnvPreference = (options) => {
+    const hasRootEnv = hasFlag('--root-env');
+    const hasNoRootEnv = hasFlag('--no-root-env');
+    if (hasRootEnv && hasNoRootEnv) {
+        throw ErrorFactory.createCliError('Error: Cannot use both --root-env and --no-root-env.');
+    }
+    if (hasRootEnv)
+        return true;
+    if (hasNoRootEnv)
+        return false;
+    if (typeof options.rootEnv === 'boolean')
+        return options.rootEnv;
+    return true;
+};
+const resolveEnvPath = (options, projectRoot) => {
+    const raw = typeof options.envPath === 'string' ? options.envPath.trim() : '';
+    if (raw === '')
+        return undefined;
+    return isAbsolutePath(raw) ? raw : path.join(projectRoot, raw);
+};
 const findNearestPackageJsonDir = (cwd) => {
     let current = path.resolve(cwd);
     while (true) {
@@ -210,9 +231,16 @@ const buildStartEnv = (projectRoot) => ({
     ...process.env,
     ZINTRUST_PROJECT_ROOT: projectRoot,
 });
-const ensureStartEnvLoaded = (context) => {
-    const extraCwds = context.cwd === context.projectRoot ? [] : [context.cwd];
-    EnvFileLoader.ensureLoaded({ cwd: context.projectRoot, extraCwds });
+const ensureStartEnvLoaded = (context, options) => {
+    const envPath = resolveEnvPath(options, context.projectRoot);
+    const rootEnv = resolveRootEnvPreference(options);
+    const extraCwds = envPath === undefined && context.cwd !== context.projectRoot ? [context.cwd] : [];
+    EnvFileLoader.ensureLoaded({
+        cwd: context.projectRoot,
+        includeCwd: rootEnv,
+        extraCwds,
+        ...(envPath === undefined ? {} : { envPaths: [envPath] }),
+    });
 };
 const isFrameworkRepo = (packageJson) => packageJson.name === '@zintrust/core';
 const hasDevScript = (packageJson) => {
@@ -483,7 +511,7 @@ const executeSplitStart = async (cmd, context, _options) => {
 const executeStart = async (options, cmd) => {
     const cwd = process.cwd();
     const context = resolveStartContext(cwd);
-    ensureStartEnvLoaded(context);
+    ensureStartEnvLoaded(context, options);
     const mode = resolveMode(options);
     const port = resolvePort(options);
     const runtime = resolveRuntime(options);
@@ -541,8 +569,11 @@ export const StartCommand = Object.freeze({
                 .option('--no-cache', 'Disable cache functionality')
                 .option('--watch', 'Force watch mode (Node only)')
                 .option('--no-watch', 'Disable watch mode (Node only)')
+                .option('--root-env', 'Load root project .env files for standalone service start')
+                .option('--no-root-env', 'Skip root project .env files for standalone service start')
                 .option('--mode <development|production|testing>', 'Override app mode')
                 .option('--env <name>', 'Wrangler environment name (Wrangler mode only)')
+                .option('--env-path <path>', 'Explicit env directory or .env file path for standalone service start')
                 .option('--wrangler-config <path>', 'Wrangler config path (Wrangler mode only)')
                 .option('--runtime <nodejs|cloudflare|lambda|deno|auto>', 'Set RUNTIME for spawned Node')
                 .option('-p, --port <number>', 'Override server port');

package/src/cli/utils/EnvFileLoader.d.ts

@@ -1,7 +1,9 @@
 type node_env = 'development' | 'production' | 'testing';
 type LoadOptions = {
     cwd?: string;
+    includeCwd?: boolean;
     extraCwds?: string[];
+    envPaths?: string[];
     overrideExisting?: boolean;
 };
 type LoadState = {

package/src/cli/utils/EnvFileLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EnvFileLoader.d.ts","sourceRoot":"","sources":["../../../../src/cli/utils/EnvFileLoader.ts"],"names":[],"mappings":"AAQA,KAAK,QAAQ,GAAG,aAAa,GAAG,YAAY,GAAG,SAAS,CAAC;AAmIzD,KAAK,WAAW,GAAG;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,YAAY,GAAG;IAClB,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAkHF,eAAO,MAAM,aAAa;qBA7DH,WAAW,KAAQ,SAAS;6BAyBpB,IAAI,CAAC,WAAW,EAAE,kBAAkB,CAAC,KAAQ,SAAS;mCAG/C,YAAY,KAAG,IAAI;oBA+BpC,SAAS;EAO5B,CAAC"}
+{"version":3,"file":"EnvFileLoader.d.ts","sourceRoot":"","sources":["../../../../src/cli/utils/EnvFileLoader.ts"],"names":[],"mappings":"AASA,KAAK,QAAQ,GAAG,aAAa,GAAG,YAAY,GAAG,SAAS,CAAC;AAmIzD,KAAK,WAAW,GAAG;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAaF,KAAK,YAAY,GAAG;IAClB,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAgMF,eAAO,MAAM,aAAa;qBAjDH,WAAW,KAAQ,SAAS;6BAapB,IAAI,CAAC,WAAW,EAAE,kBAAkB,CAAC,KAAQ,SAAS;mCAG/C,YAAY,KAAG,IAAI;oBA+BpC,SAAS;EAO5B,CAAC"}

package/src/cli/utils/EnvFileLoader.js

@@ -1,6 +1,7 @@
 import { Env } from '../../config/env.js';
+import { isArray, isNonEmptyString } from '../../helper/index.js';
 import { existsSync, readFileSync } from '../../node-singletons/fs.js';
-import { join } from '../../node-singletons/path.js';
+import * as path from '../../node-singletons/path.js';
 const safeEnvGet = (key, defaultValue = '') => {
     const envAny = Env;
     if (typeof envAny.get === 'function')
@@ -102,7 +103,7 @@ const applyToProcessEnv = (values, overrideExisting) => {
     }
 };
 const readEnvFileIfExists = (cwd, filename) => {
-    const fullPath = join(cwd, filename);
+    const fullPath = path.join(cwd, filename);
     if (!existsSync(fullPath))
         return undefined;
     const raw = readFileSync(fullPath, 'utf-8');
@@ -120,20 +121,20 @@ const resolveAppMode = (cwd) => {
 };
 const filesLoader = (cwd, mode) => {
     const files = [];
-    if (existsSync(join(cwd, '.env')))
+    if (existsSync(path.join(cwd, '.env')))
         files.push('.env');
     // Per your rule: production uses .env; dev uses .env.dev
     if (mode !== undefined && mode !== '' && mode !== 'production') {
         const modeFile = `.env.${mode}`;
-        if (existsSync(join(cwd, modeFile)))
+        if (existsSync(path.join(cwd, modeFile)))
             files.push(modeFile);
     }
     const local = '.env.local';
-    if (existsSync(join(cwd, local)))
+    if (existsSync(path.join(cwd, local)))
         files.push(local);
     if (mode !== undefined && mode !== '') {
         const modeLocal = `.env.${mode}.local`;
-        if (existsSync(join(cwd, modeLocal)))
+        if (existsSync(path.join(cwd, modeLocal)))
             files.push(modeLocal);
     }
     return files;
@@ -161,25 +162,85 @@ const loadFromCwd = (cwd, overrideExisting) => {
     }
     return { loadedFiles: files, mode };
 };
-const load = (options = {}) => {
-    if (cached !== undefined)
-        return cached;
-    const cwd = typeof options.cwd === 'string' && options.cwd !== '' ? options.cwd : process.cwd();
-    const extraCwds = Array.isArray(options.extraCwds)
-        ? options.extraCwds.filter((value) => typeof value === 'string' && value.trim() !== '')
-        : [];
+const loadFromFile = (filePath, overrideExisting) => {
+    if (!existsSync(filePath))
+        return { loadedFiles: [] };
+    const raw = readFileSync(filePath, 'utf-8');
+    const parsed = parseEnvFile(raw);
+    applyToProcessEnv(parsed, overrideExisting);
+    const rawMode = parsed['NODE_ENV'];
+    const mode = isNonEmptyString(rawMode) ? normalizeAppMode(rawMode) : undefined;
+    if (mode !== undefined) {
+        safeEnvSet('NODE_ENV', mode);
+    }
+    return { loadedFiles: [filePath], mode };
+};
+const normalizeCwdList = (value) => {
+    if (!isArray(value))
+        return [];
+    return value
+        .filter(isNonEmptyString)
+        .map((item) => item.trim())
+        .filter((item) => item !== '');
+};
+const normalizeEnvPathList = (value) => normalizeCwdList(value);
+const createLoadPlan = (options) => {
+    const cwd = isNonEmptyString(options.cwd) ? options.cwd : process.cwd();
+    const includeCwd = options.includeCwd !== false;
+    const extraCwds = normalizeCwdList(options.extraCwds);
+    const envPaths = normalizeEnvPathList(options.envPaths);
     const overrideExisting = options.overrideExisting ?? true;
-    const roots = [cwd, ...extraCwds].filter((value, index, items) => items.indexOf(value) === index);
-    let mergedMode;
-    const loadedFiles = [];
-    for (let index = 0; index < roots.length; index += 1) {
-        const root = roots[index];
-        const state = loadFromCwd(root, index === 0 ? overrideExisting : true);
-        if (mergedMode === undefined && state.mode !== undefined)
-            mergedMode = state.mode;
-        loadedFiles.push(...state.loadedFiles);
-    }
-    cached = { loadedFiles, mode: mergedMode };
+    const sources = [];
+    if (includeCwd) {
+        sources.push({
+            key: `cwd:${cwd}`,
+            path: cwd,
+            kind: 'cwd',
+            overrideExisting,
+        });
+    }
+    for (const extraCwd of extraCwds) {
+        sources.push({
+            key: `cwd:${extraCwd}`,
+            path: extraCwd,
+            kind: 'cwd',
+            overrideExisting: true,
+        });
+    }
+    for (const envPath of envPaths) {
+        const looksLikeFile = path.basename(envPath).startsWith('.env');
+        sources.push({
+            key: `${looksLikeFile ? 'file' : 'cwd'}:${envPath}`,
+            path: envPath,
+            kind: looksLikeFile ? 'file' : 'cwd',
+            overrideExisting: true,
+        });
+    }
+    return sources.filter((source, index, items) => items.findIndex((item) => item.key === source.key) === index);
+};
+const loadSource = (source) => {
+    if (source.kind === 'file')
+        return loadFromFile(source.path, source.overrideExisting);
+    return loadFromCwd(source.path, source.overrideExisting);
+};
+const mergeCachedState = (state, source, next) => {
+    state.loadedSourceKeys.push(source.key);
+    if (next.mode !== undefined && state.mode === undefined) {
+        state.mode = next.mode;
+    }
+    if (next.loadedFiles.length > 0) {
+        state.loadedFiles.push(...next.loadedFiles);
+    }
+    return state;
+};
+const load = (options = {}) => {
+    const plan = createLoadPlan(options);
+    cached ??= { loadedFiles: [], loadedSourceKeys: [] };
+    for (const source of plan) {
+        if (cached.loadedSourceKeys.includes(source.key))
+            continue;
+        mergeCachedState(cached, source, loadSource(source));
+    }
     return cached;
 };
 const ensureLoaded = (options = {}) => load({ ...options, overrideExisting: false });

package/src/index.js

@@ -1,11 +1,11 @@
 /**
- * @zintrust/core v0.4.12
+ * @zintrust/core v0.4.13
  *
  * ZinTrust Framework - Production-Grade TypeScript Backend
  * Built for performance, type safety, and exceptional developer experience
  *
  * Build Information:
- *   Built: 2026-03-23T13:57:31.438Z
+ *   Built: 2026-03-23T14:57:40.299Z
  *   Node: >=20.0.0
  *   License: MIT
  *
@@ -21,7 +21,7 @@
  * Available at runtime for debugging and health checks
  */
 export const ZINTRUST_VERSION = '0.1.41';
-export const ZINTRUST_BUILD_DATE = '2026-03-23T13:57:31.366Z'; // Replaced during build
+export const ZINTRUST_BUILD_DATE = '2026-03-23T14:57:40.266Z'; // Replaced during build
 export { Application } from './boot/Application.js';
 export { AwsSigV4 } from './common/index.js';
 export { SignedRequest } from './security/SignedRequest.js';

package/src/start.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../src/start.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,gCAAgC,CAAC;AAexC,eAAO,MAAM,UAAU,GAAI,eAAe,MAAM,KAAG,OAYlD,CAAC;AAEF,eAAO,MAAM,0BAA0B,GAAI,eAAe,OAAO,KAAG,oBASnE,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,eAAe,MAAM,EACrB,eAAe,OAAO,KACrB,OAAO,CAAC,oBAAoB,CAQ9B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,KAAK,QAAa,OAAO,CAAC,IAAI,CAO1C,CAAC;AAEF;;GAEG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEpE;;GAEG;AACH,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAElD;;GAEG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../src/start.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,gCAAgC,CAAC;AAuBxC,eAAO,MAAM,UAAU,GAAI,eAAe,MAAM,KAAG,OAYlD,CAAC;AAEF,eAAO,MAAM,0BAA0B,GAAI,eAAe,OAAO,KAAG,oBASnE,CAAC;AAqFF,eAAO,MAAM,qBAAqB,GAChC,eAAe,MAAM,EACrB,eAAe,OAAO,KACrB,OAAO,CAAC,oBAAoB,CAS9B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,KAAK,QAAa,OAAO,CAAC,IAAI,CAO1C,CAAC;AAEF;;GAEG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEpE;;GAEG;AACH,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAElD;;GAEG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC"}

package/src/start.js

@@ -1,8 +1,10 @@
 import { ErrorFactory } from './exceptions/ZintrustError.js';
+import { isArray, isNonEmptyString, isObject } from './helper/index.js';
 import { ZintrustLang } from './lang/lang.js';
 import { normalizeActiveServiceRuntime, } from './microservices/ServiceManifest.js';
 import { ProjectRuntime } from './runtime/ProjectRuntime.js';
 import { isNodeRuntime } from './runtime/detectRuntime.js';
+const isAbsolutePath = (value) => value.startsWith('/') || /^[A-Za-z]:[\\/]/.test(value);
 const fileUrlToPathLike = (value) => {
     if (!value.startsWith(ZintrustLang.FILE_PROTOCOL))
         return value;
@@ -34,7 +36,68 @@ export const configureStandaloneService = (activeService) => {
     }
     return ProjectRuntime.set({ activeService: normalized }).activeService ?? normalized;
 };
+const normalizeStandaloneEnvPaths = (value) => {
+    if (isNonEmptyString(value)) {
+        const trimmed = value.trim();
+        return trimmed === '' ? [] : [trimmed];
+    }
+    if (!isArray(value))
+        return [];
+    return value
+        .filter(isNonEmptyString)
+        .map((item) => item.trim())
+        .filter((item) => item !== '');
+};
+const resolveStandaloneProjectRoot = async () => {
+    const configuredRoot = process.env?.['ZINTRUST_PROJECT_ROOT'] ?? '';
+    if (isNonEmptyString(configuredRoot))
+        return configuredRoot;
+    const { existsSync } = await import('./node-singletons/fs.js');
+    const path = await import('./node-singletons/path.js');
+    let current = process.cwd();
+    while (true) {
+        if (existsSync(path.join(current, 'package.json')))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return process.cwd();
+        current = parent;
+    }
+};
+const resolveServiceEnvPath = async (importMetaUrl, activeService, projectRoot) => {
+    const path = await import('./node-singletons/path.js');
+    if (isObject(activeService) && isNonEmptyString(activeService['configRoot'])) {
+        return path.dirname(path.join(projectRoot, activeService['configRoot']));
+    }
+    const entryFile = fileUrlToPathLike(importMetaUrl);
+    const entryDir = path.dirname(entryFile);
+    return path.basename(entryDir) === 'src' ? path.dirname(entryDir) : entryDir;
+};
+const resolveConfiguredEnvPaths = async (projectRoot, activeService, importMetaUrl) => {
+    const path = await import('./node-singletons/path.js');
+    const configured = isObject(activeService)
+        ? normalizeStandaloneEnvPaths(activeService['envPath'])
+        : [];
+    if (configured.length > 0) {
+        return configured.map((value) => isAbsolutePath(value) ? value : path.join(projectRoot, value));
+    }
+    return [await resolveServiceEnvPath(importMetaUrl, activeService, projectRoot)];
+};
+const ensureStandaloneServiceEnv = async (importMetaUrl, activeService) => {
+    if (!isNodeRuntime())
+        return;
+    const { EnvFileLoader } = await import('./cli/utils/EnvFileLoader.js');
+    const projectRoot = await resolveStandaloneProjectRoot();
+    const envPaths = await resolveConfiguredEnvPaths(projectRoot, activeService, importMetaUrl);
+    const rootEnv = !isObject(activeService) || activeService['rootEnv'] !== false;
+    EnvFileLoader.ensureLoaded({
+        cwd: projectRoot,
+        includeCwd: rootEnv,
+        envPaths,
+    });
+};
 export const bootStandaloneService = async (importMetaUrl, activeService) => {
+    await ensureStandaloneServiceEnv(importMetaUrl, activeService);
     const configuredService = configureStandaloneService(activeService);
     if (isNodeMain(importMetaUrl)) {
         await start();