@zintrust/core 0.4.11 → 0.4.13

package/package.json

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

package/src/boot/registry/registerRoute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registerRoute.d.ts","sourceRoot":"","sources":["../../../../src/boot/registry/registerRoute.ts"],"names":[],"mappings":"AAEA,OAAO,EAAU,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAW3D,eAAO,MAAM,kBAAkB,QAAO,OAKrC,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAU,CAAC,EAAE,YAAY,MAAM,KAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAMpF,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,CAAC,EAAE,YAAY,MAAM,KAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAOrF,CAAC;AA0FF,eAAO,MAAM,oBAAoB,GAC/B,kBAAkB,MAAM,EACxB,QAAQ,OAAO,KACd,OAAO,CAAC,IAAI,CAoBd,CAAC"}
+{"version":3,"file":"registerRoute.d.ts","sourceRoot":"","sources":["../../../../src/boot/registry/registerRoute.ts"],"names":[],"mappings":"AAEA,OAAO,EAAU,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAW3D,eAAO,MAAM,kBAAkB,QAAO,OAKrC,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAU,CAAC,EAAE,YAAY,MAAM,KAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAMpF,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,CAAC,EAAE,YAAY,MAAM,KAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAOrF,CAAC;AA4FF,eAAO,MAAM,oBAAoB,GAC/B,kBAAkB,MAAM,EACxB,QAAQ,OAAO,KACd,OAAO,CAAC,IAAI,CAoBd,CAAC"}

package/src/boot/registry/registerRoute.js

@@ -64,6 +64,7 @@ const registerAppRoutes = async (resolvedBasePath, router) => {
     }
 };
 const registerManifestRoutes = async (router) => {
+    await ProjectRuntime.tryLoadNodeRuntime();
     const serviceManifest = ProjectRuntime.getServiceManifest();
     if (serviceManifest.length === 0)
         return;

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.11
+ * @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:29:47.237Z
+ *   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:29:47.153Z'; // 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/runtime/PluginAutoImports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PluginAutoImports.d.ts","sourceRoot":"","sources":["../../../src/runtime/PluginAutoImports.ts"],"names":[],"mappings":"AAKA,OAAO,EAAmB,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAEzF,KAAK,YAAY,GACb;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAChC;IACE,EAAE,EAAE,KAAK,CAAC;IACV,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,WAAW,GAAG,eAAe,CAAC;IACtC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAuJN,eAAO,MAAM,iBAAiB;uCACY,uBAAuB,GAAY,OAAO,CAAC,YAAY,CAAC;IAkBhG;;;;;;OAMG;mCACkC,OAAO,CAAC,YAAY,CAAC;qCAkEnB,MAAM,EAAE,GAAG,OAAO,CAAC,YAAY,CAAC;EAavE,CAAC"}
+{"version":3,"file":"PluginAutoImports.d.ts","sourceRoot":"","sources":["../../../src/runtime/PluginAutoImports.ts"],"names":[],"mappings":"AAKA,OAAO,EAAmB,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AAEzF,KAAK,YAAY,GACb;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAChC;IACE,EAAE,EAAE,KAAK,CAAC;IACV,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,WAAW,GAAG,eAAe,CAAC;IACtC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AA6MN,eAAO,MAAM,iBAAiB;uCACY,uBAAuB,GAAY,OAAO,CAAC,YAAY,CAAC;IAkBhG;;;;;;OAMG;mCACkC,OAAO,CAAC,YAAY,CAAC;qCAkEnB,MAAM,EAAE,GAAG,OAAO,CAAC,YAAY,CAAC;EAavE,CAAC"}

package/src/runtime/PluginAutoImports.js

@@ -94,6 +94,47 @@ const resolveLocalPackageSpecifier = (specifier) => {
         return null;
     return pathToFileURL(resolved).href;
 };
+const isMissingPackageImport = (error, specifier) => {
+    if (specifier.startsWith('.'))
+        return false;
+    if (error === null || typeof error !== 'object')
+        return false;
+    const maybe = error;
+    const message = typeof maybe.message === 'string' ? maybe.message : '';
+    if (maybe.code === 'ERR_MODULE_NOT_FOUND' && message.length === 0)
+        return true;
+    if (maybe.code === 'ERR_MODULE_NOT_FOUND' && message.includes(specifier))
+        return true;
+    return (message.includes(`Cannot find package '${specifier}'`) ||
+        message.includes(`Cannot find module '${specifier}'`));
+};
+const getMissingPackageStatus = (error, specifier) => {
+    if (isMissingPackageImport(error, specifier)) {
+        Logger.debug('[plugins] Optional auto-import package not installed', {
+            specifier,
+        });
+        return 'missing';
+    }
+    return 'failed';
+};
+const importFromLocalFallback = async (specifier, fallback) => {
+    try {
+        await import(fallback);
+        Logger.debug('[plugins] Loaded auto-import specifier from local fallback', {
+            specifier,
+            fallback,
+        });
+        return 'loaded';
+    }
+    catch (fallbackError) {
+        Logger.debug('[plugins] Failed auto-import local fallback', {
+            specifier,
+            fallback,
+            error: fallbackError instanceof Error ? fallbackError.message : String(fallbackError),
+        });
+        return getMissingPackageStatus(fallbackError, specifier);
+    }
+};
 const importSingleSpecifier = async (entry) => {
     const target = entry.specifier.startsWith('.')
         ? resolveRelativeSpecifier(entry)
@@ -101,52 +142,48 @@ const importSingleSpecifier = async (entry) => {
     try {
         await import(target);
         Logger.debug('[plugins] Loaded auto-import specifier', { specifier: entry.specifier });
-        return true;
+        return 'loaded';
     }
-    catch {
+    catch (error) {
         const fallback = resolveLocalPackageSpecifier(entry.specifier);
-        if (fallback !== null) {
-            try {
-                await import(fallback);
-                Logger.debug('[plugins] Loaded auto-import specifier from local fallback', {
-                    specifier: entry.specifier,
-                    fallback,
-                });
-                return true;
-            }
-            catch (fallbackError) {
-                Logger.debug('[plugins] Failed auto-import local fallback', {
-                    specifier: entry.specifier,
-                    fallback,
-                    error: fallbackError instanceof Error ? fallbackError.message : String(fallbackError),
-                });
-            }
-        }
-        return false;
+        if (fallback !== null)
+            return importFromLocalFallback(entry.specifier, fallback);
+        return getMissingPackageStatus(error, entry.specifier);
     }
 };
 const importSpecifiers = async (specifiers) => {
     // Import all specifiers in parallel
     const importPromises = Array.from(specifiers).map(async (entry) => {
-        const success = await importSingleSpecifier(entry);
-        return { specifier: entry.specifier, success };
+        const status = await importSingleSpecifier(entry);
+        return { specifier: entry.specifier, status };
     });
     const results = await Promise.allSettled(importPromises);
-    // Count successful imports
-    return results.filter((result) => result.status === 'fulfilled' && result.value.success).length;
+    return results.reduce((summary, result) => {
+        if (result.status !== 'fulfilled') {
+            summary.failed += 1;
+            return summary;
+        }
+        if (result.value.status === 'loaded')
+            summary.loaded += 1;
+        else if (result.value.status === 'missing')
+            summary.missing += 1;
+        else
+            summary.failed += 1;
+        return summary;
+    }, { loaded: 0, missing: 0, failed: 0 });
 };
 export const PluginAutoImports = Object.freeze({
     async tryImportRuntimeAutoImports(mode = 'base') {
         const specifiers = OfficialPlugins.getAutoImports(mode);
-        const loaded = await importSpecifiers(specifiers.map((specifier) => ({ specifier, filePath: `official:${mode}` })));
-        if (loaded === specifiers.length) {
+        const summary = await importSpecifiers(specifiers.map((specifier) => ({ specifier, filePath: `official:${mode}` })));
+        if (summary.failed === 0) {
             return { ok: true, loadedPath: `official:${mode}` };
         }
         return {
             ok: false,
             loadedPath: `official:${mode}`,
             reason: 'import-failed',
-            errorMessage: `Loaded ${loaded}/${specifiers.length} official plugin imports`,
+            errorMessage: `Loaded ${summary.loaded}/${specifiers.length} official plugin imports`,
         };
     },
     /**
@@ -209,8 +246,8 @@ export const PluginAutoImports = Object.freeze({
         if (specifiers.length === 0) {
             return { ok: false, reason: 'import-failed', errorMessage: 'No import specifiers found' };
         }
-        const loaded = await importSpecifiers(specifiers);
-        if (loaded > 0) {
+        const summary = await importSpecifiers(specifiers);
+        if (summary.loaded > 0) {
             return { ok: true, loadedPath: 'manual-imports' };
         }
         return { ok: false, reason: 'import-failed', errorMessage: 'All specifier imports failed' };

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