@zintrust/core 0.1.20 → 0.1.22

package/src/performance/Optimizer.js

@@ -59,8 +59,52 @@ function createCacheState(cacheDir, ttlMs, maxEntries) {
         cacheDir,
         ttlMs,
         maxEntries,
+        pendingWrites: new Map(),
     };
 }
+async function ensureCacheDir(cacheDir) {
+    try {
+        await fs.fsPromises.access(cacheDir);
+    }
+    catch {
+        await fs.fsPromises.mkdir(cacheDir, { recursive: true });
+    }
+}
+async function flushPendingWrites(state) {
+    if (state.pendingWrites.size === 0) {
+        state.flushTimer = undefined;
+        return false;
+    }
+    const pending = state.pendingWrites;
+    state.pendingWrites = new Map();
+    state.flushTimer = undefined;
+    try {
+        await ensureCacheDir(state.cacheDir);
+    }
+    catch (error) {
+        Logger.error('Failed to ensure cache directory before flush', error);
+        return false;
+    }
+    const writes = Array.from(pending.entries()).map(async ([key, entry]) => {
+        const file = path.join(state.cacheDir, `${key}.json`);
+        await fs.fsPromises.writeFile(file, entry.payload);
+    });
+    await Promise.all(writes);
+    return true;
+}
+function scheduleCacheWrite(state, key, payload) {
+    state.pendingWrites.set(key, { payload });
+    if (state.flushTimer !== undefined)
+        return;
+    state.flushTimer = setTimeout(() => {
+        void flushPendingWrites(state).catch((error) => {
+            Logger.error('Failed to flush generation cache writes', error);
+        });
+    }, 50);
+    if (isUnrefableTimer(state.flushTimer)) {
+        state.flushTimer.unref();
+    }
+}
 function initializeCacheState(state) {
     loadFromDisk(state);
 }
@@ -95,26 +139,26 @@ function startCacheCleanup(state) {
 function createCacheInstance(state) {
     return {
         /**
-         * Get from cache
+         * Get from cache (async)
          */
-        get(type, params) {
+        async get(type, params) {
             const key = getCacheKey(type, params);
             const entry = state.cache.get(key);
             if (entry === undefined)
-                return null;
+                return Promise.resolve(null); //NoSONAR
             // Check TTL
             if (Date.now() - entry.timestamp > state.ttlMs) {
                 state.cache.delete(key);
                 const file = path.join(state.cacheDir, `${key}.json`);
                 deleteFileNonBlocking(file);
-                return null;
+                return Promise.resolve(null); //NoSONAR
             }
-            return entry.code;
+            return Promise.resolve(entry.code); //NoSONAR
         },
         /**
-         * Set in cache
+         * Set in cache (async)
          */
-        set(type, params, code) {
+        async set(type, params, code) {
             const key = getCacheKey(type, params);
             // If key already exists, delete first so insertion order updates for LRU
             if (state.cache.has(key))
@@ -134,27 +178,34 @@ function createCacheInstance(state) {
                     deleteFileNonBlocking(file);
                 }
             }
+            const payload = JSON.stringify({ code, timestamp: Date.now() }, null, 2);
+            scheduleCacheWrite(state, key, payload);
         },
         /**
-         * Save cache to disk
+         * Save cache to disk (async)
          */
-        save() {
-            saveCacheToDisk(state);
+        async save() {
+            await saveCacheToDisk(state);
         },
         /**
-         * Clear cache
+         * Clear cache (async)
          */
-        clear() {
+        async clear() {
             if (state.cleanupInterval) {
                 clearInterval(state.cleanupInterval);
                 state.cleanupInterval = undefined;
             }
-            clearCache(state);
+            if (state.flushTimer) {
+                clearTimeout(state.flushTimer);
+                state.flushTimer = undefined;
+            }
+            state.pendingWrites.clear();
+            await clearCache(state);
         },
         /**
-         * Get cache statistics
+         * Get cache statistics (async)
          */
-        getStats() {
+        async getStats() {
             return getCacheStats(state);
         },
     };
@@ -166,38 +217,65 @@ function attachCacheStateForTests(instance, state) {
     });
 }
 /**
- * Save cache to disk
+ * Save cache to disk (async)
  */
-function saveCacheToDisk(state) {
-    if (fs.existsSync(state.cacheDir) === false) {
-        fs.mkdirSync(state.cacheDir, { recursive: true });
+async function saveCacheToDisk(state) {
+    try {
+        const flushedEnsured = await flushPendingWrites(state);
+        if (!flushedEnsured) {
+            await ensureCacheDir(state.cacheDir);
+        }
+        const writes = Array.from(state.cache.entries()).map(async ([key, entry]) => {
+            const file = path.join(state.cacheDir, `${key}.json`);
+            await fs.fsPromises.writeFile(file, JSON.stringify(entry, null, 2));
+        });
+        await Promise.all(writes);
     }
-    for (const [key, entry] of state.cache.entries()) {
-        const file = path.join(state.cacheDir, `${key}.json`);
-        fs.writeFileSync(file, JSON.stringify(entry, null, 2));
+    catch (error) {
+        Logger.error('Failed to save cache to disk', error);
     }
 }
 /**
- * Clear cache
+ * Clear cache (async)
  */
-function clearCache(state) {
+async function clearCache(state) {
     state.cache.clear();
-    if (fs.existsSync(state.cacheDir) === true) {
-        fs.rmSync(state.cacheDir, { recursive: true });
+    state.pendingWrites.clear();
+    try {
+        try {
+            await fs.fsPromises.access(state.cacheDir);
+        }
+        catch {
+            return; // Dir doesn't exist
+        }
+        await fs.fsPromises.rm(state.cacheDir, { recursive: true });
+    }
+    catch (error) {
+        Logger.error('Failed to clear cache', error);
     }
 }
 /**
- * Get cache statistics
+ * Get cache statistics (async)
  */
-function getCacheStats(state) {
+async function getCacheStats(state) {
     let diskUsage = 0;
-    if (fs.existsSync(state.cacheDir) === true) {
-        const files = fs.readdirSync(state.cacheDir);
-        for (const file of files) {
-            const stats = fs.statSync(path.join(state.cacheDir, file));
-            diskUsage += stats.size;
+    try {
+        try {
+            await fs.fsPromises.access(state.cacheDir);
+            const files = await fs.fsPromises.readdir(state.cacheDir);
+            const sizes = await Promise.all(files.map(async (file) => {
+                const stats = await fs.fsPromises.stat(path.join(state.cacheDir, file));
+                return stats.size;
+            }));
+            diskUsage = sizes.reduce((sum, size) => sum + size, 0);
+        }
+        catch {
+            // ignore
         }
     }
+    catch {
+        // ignore
+    }
     return {
         size: diskUsage,
         entries: state.cache.size,
@@ -242,24 +320,39 @@ function toInt32(value) {
     return uint32 > 2147483647 ? uint32 - 4294967296 : uint32;
 }
 /**
- * Load cache from disk
+ * Load cache from disk (async)
  */
-function loadFromDisk(state) {
-    if (fs.existsSync(state.cacheDir) === true) {
+async function loadFromDisk(state) {
+    try {
         try {
-            const files = fs.readdirSync(state.cacheDir);
-            for (const file of files) {
-                if (file.endsWith('.json') === true) {
-                    const content = fs.readFileSync(path.join(state.cacheDir, file), 'utf-8');
-                    const data = JSON.parse(content);
-                    state.cache.set(file.replace('.json', ''), data);
-                }
-            }
+            await fs.fsPromises.access(state.cacheDir);
         }
-        catch (err) {
-            Logger.error(`Failed to load cache from disk: ${err instanceof Error ? err.message : String(err)}`);
+        catch {
+            return;
+        }
+        const files = await fs.fsPromises.readdir(state.cacheDir);
+        const jsonFiles = files.filter((file) => file.endsWith('.json') === true);
+        const parsedEntries = await Promise.all(jsonFiles.map(async (file) => {
+            const filePath = path.join(state.cacheDir, file);
+            const content = await fs.fsPromises.readFile(filePath, 'utf-8');
+            try {
+                const data = JSON.parse(content);
+                return { key: file.replace('.json', ''), data };
+            }
+            catch {
+                // ignore corrupted files
+                return null;
+            }
+        }));
+        for (const entry of parsedEntries) {
+            if (entry !== null) {
+                state.cache.set(entry.key, entry.data);
+            }
         }
     }
+    catch (err) {
+        Logger.error(`Failed to load cache from disk: ${err instanceof Error ? err.message : String(err)}`);
+    }
 }
 /**
  * Lazy Module Loader - Load dependencies only when needed
@@ -474,17 +567,36 @@ async function generateInParallel(stats, generators, batchSize) {
  */
 async function generateWithCache(cache, stats, type, params, generatorFn) {
     // Try cache
-    const cached = cache.get(type, params);
+    let cached = null;
+    try {
+        cached = await cache.get(type, params);
+    }
+    catch (err) {
+        Logger.warn('GenerationCache.get failed; treating as cache miss', {
+            type,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
     if (cached !== null) {
-        stats.cacheHits++;
-        return JSON.parse(cached);
+        try {
+            stats.cacheHits++;
+            return JSON.parse(cached);
+        }
+        catch (err) {
+            Logger.warn('Failed to parse cached generation result; treating as cache miss', {
+                type,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
     }
     // Generate
     const startTime = performance.now();
     const result = await generatorFn();
     const duration = performance.now() - startTime;
-    // Cache result
-    cache.set(type, params, JSON.stringify(result));
+    // Cache result (fire-and-forget)
+    void cache
+        .set(type, params, JSON.stringify(result))
+        .catch((err) => Logger.error('GenerationCache.set failed', err));
     stats.cacheMisses++;
     stats.savedTime += duration;
     return result;
@@ -492,6 +604,16 @@ async function generateWithCache(cache, stats, type, params, generatorFn) {
 /**
  * Get optimization statistics
  */
+function getCacheStatusSync(cache) {
+    const state = cache[GENERATION_CACHE_STATE_SYMBOL];
+    const map = state?.cache;
+    if (!(map instanceof Map))
+        return { size: 0, keys: [] };
+    return {
+        size: map.size,
+        keys: Array.from(map.keys()),
+    };
+}
 function getOptimizerStats(cache, stats) {
     const total = stats.cacheHits + stats.cacheMisses;
     const hitRate = total > 0 ? (stats.cacheHits / total) * 100 : 0;
@@ -501,7 +623,7 @@ function getOptimizerStats(cache, stats) {
         hitRate: `${hitRate.toFixed(1)}%`,
         parallelRuns: stats.parallelRuns,
         estimatedSavedTime: `${stats.savedTime.toFixed(2)}ms`,
-        cacheStatus: cache.getStats(),
+        cacheStatus: getCacheStatusSync(cache),
     };
 }
 export default PerformanceOptimizer;

package/src/profiling/RequestProfiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RequestProfiler.d.ts","sourceRoot":"","sources":["../../../src/profiling/RequestProfiler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAC,MAAM,2BAA2B,CAAC;AAGhE,OAAO,KAAK,EAAE,YAAY,EAAC,MAAM,wBAAwB,CAAC;AAE1D,OAAO,KAAK,EAAE,WAAW,EAAa,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAE9E,MAAM,WAAW,gBAAgB;IAC/B,cAAc,IAAI,YAAY,CAAC;IAC/B,aAAa,IAAI,WAAW,CAAC;IAC7B,iBAAiB,IAAI,eAAe,CAAC;IACrC,cAAc,CAAC,EAAE,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IACnE,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAAC;CAChD;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe;IAC1B;;OAEG;cACO,gBAAgB;EAkE1B,CAAC;AAmBH;;GAEG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,eAAe,eAAe,CAAC"}
+{"version":3,"file":"RequestProfiler.d.ts","sourceRoot":"","sources":["../../../src/profiling/RequestProfiler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAGjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE3D,OAAO,KAAK,EAAE,WAAW,EAAa,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAE9E,MAAM,WAAW,gBAAgB;IAC/B,cAAc,IAAI,YAAY,CAAC;IAC/B,aAAa,IAAI,WAAW,CAAC;IAC7B,iBAAiB,IAAI,eAAe,CAAC;IACrC,cAAc,CAAC,EAAE,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IACnE,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAAC;CAChD;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe;IAC1B;;OAEG;cACO,gBAAgB;EAsE1B,CAAC;AAmBH;;GAEG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,eAAe,eAAe,CAAC"}

package/src/profiling/RequestProfiler.js

@@ -49,13 +49,15 @@ export const RequestProfiler = Object.freeze({
                 const queriesExecuted = queryLog.length;
                 const patterns = n1Detector.detect(queryLog);
                 const memoryDelta = memoryProfiler.delta();
-                return {
+                const report = {
                     duration,
                     queriesExecuted,
                     n1Patterns: patterns,
                     memoryDelta,
                     timestamp: new Date(),
                 };
+                queryLogger.clear('profiling');
+                return report;
             },
             generateReport(profile) {
                 const n1Section = formatN1Section(profile.n1Patterns);

package/src/routing/doc.d.ts

@@ -8,21 +8,20 @@ export { MIME_TYPES_MAP } from './common';
 /**
  * Find the package root directory
  */
-export { findPackageRoot, getFrameworkPublicRoots, getPublicRoot } from './publicRoot';
+export { findPackageRoot, findPackageRootAsync, getFrameworkPublicRoots, getFrameworkPublicRootsAsync, getPublicRoot, getPublicRootAsync, } from './publicRoot';
 /**
  * Set relaxed CSP headers for docs (allows external assets like Tailwind CDN, Google Fonts)
  */
 export declare const setDocumentationCSPHeaders: (response: IResponse) => void;
 /**
- * Serve a documentation static file
- * Returns true if file was served, false if not found
+ * Serve a documentation static file (async)
  */
-export declare const serveDocumentationFile: (urlPath: string, response: IResponse) => boolean;
+export declare const serveDocumentationFileAsync: (urlPath: string, response: IResponse) => Promise<boolean>;
 export declare const registerDocRoutes: (router: IRouter) => void;
 declare const _default: {
     registerDocRoutes: (router: IRouter) => void;
     setDocumentationCSPHeaders: (response: IResponse) => void;
-    serveDocumentationFile: (urlPath: string, response: IResponse) => boolean;
+    serveDocumentationFileAsync: (urlPath: string, response: IResponse) => Promise<boolean>;
 };
 export default _default;
 //# sourceMappingURL=doc.d.ts.map

package/src/routing/doc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doc.d.ts","sourceRoot":"","sources":["../../../src/routing/doc.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAMhD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAG/C,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;GAEG;AAEH,OAAO,EAAE,eAAe,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAoB9F;;GAEG;AACH,eAAO,MAAM,0BAA0B,GAAI,UAAU,SAAS,KAAG,IAWhE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,SAAS,MAAM,EAAE,UAAU,SAAS,KAAG,OAkC7E,CAAC;AASF,eAAO,MAAM,iBAAiB,GAAI,QAAQ,OAAO,KAAG,IAMnD,CAAC;;gCANwC,OAAO,KAAG,IAAI;2CA5DH,SAAS,KAAG,IAAI;sCAiBrB,MAAM,YAAY,SAAS,KAAG,OAAO;;AAmDrF,wBAAyF"}
+{"version":3,"file":"doc.d.ts","sourceRoot":"","sources":["../../../src/routing/doc.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAMhD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAG/C,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;GAEG;AAEH,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,uBAAuB,EACvB,4BAA4B,EAC5B,aAAa,EACb,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAiB7B;;GAEG;AACH,eAAO,MAAM,0BAA0B,GAAI,UAAU,SAAS,KAAG,IAWhE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,2BAA2B,GACtC,SAAS,MAAM,EACf,UAAU,SAAS,KAClB,OAAO,CAAC,OAAO,CAgDjB,CAAC;AASF,eAAO,MAAM,iBAAiB,GAAI,QAAQ,OAAO,KAAG,IAMnD,CAAC;;gCANwC,OAAO,KAAG,IAAI;2CA5EH,SAAS,KAAG,IAAI;2CAiB1D,MAAM,YACL,SAAS,KAClB,OAAO,CAAC,OAAO,CAAC;;AAiEnB,wBAIE"}

package/src/routing/doc.js

@@ -8,19 +8,16 @@ import * as fs from '../node-singletons/fs.js';
 import * as path from '../node-singletons/path.js';
 import { MIME_TYPES_MAP, resolveSafePath, tryDecodeURIComponent } from './common.js';
 import { ErrorRouting } from './error.js';
-import { getPublicRoot } from './publicRoot.js';
+import { getPublicRootAsync } from './publicRoot.js';
 import { Router } from './Router.js';
 export { MIME_TYPES_MAP } from './common.js';
 /**
  * Find the package root directory
  */
 // Backward-compatible re-exports
-export { findPackageRoot, getFrameworkPublicRoots, getPublicRoot } from './publicRoot.js';
-/**
- * Map URL path to physical file path for /doc routes
- */
-const mapStaticPath = (urlPath) => {
-    const publicRoot = getPublicRoot();
+export { findPackageRoot, findPackageRootAsync, getFrameworkPublicRoots, getFrameworkPublicRootsAsync, getPublicRoot, getPublicRootAsync, } from './publicRoot.js';
+const mapStaticPathAsync = async (urlPath) => {
+    const publicRoot = await getPublicRootAsync();
     const normalize = (p) => (p.startsWith('/') ? p.slice(1) : p);
     if (urlPath === '/doc' || urlPath === '/doc/')
         return publicRoot;
@@ -45,28 +42,42 @@ export const setDocumentationCSPHeaders = (response) => {
         "font-src 'self' data: https://fonts.gstatic.com;");
 };
 /**
- * Serve a documentation static file
- * Returns true if file was served, false if not found
+ * Serve a documentation static file (async)
  */
-export const serveDocumentationFile = (urlPath, response) => {
-    let filePath = mapStaticPath(urlPath);
+export const serveDocumentationFileAsync = async (urlPath, response) => {
+    let filePath = await mapStaticPathAsync(urlPath);
     if (filePath === undefined) {
         return false;
     }
     try {
-        if (fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()) {
-            filePath = path.join(filePath, 'index.html');
+        try {
+            const stats = await fs.fsPromises.stat(filePath);
+            if (stats.isDirectory()) {
+                filePath = path.join(filePath, 'index.html');
+            }
+        }
+        catch {
+            // ignore
         }
-        if (!fs.existsSync(filePath) && !path.extname(filePath)) {
+        const exists = async (p) => {
+            try {
+                await fs.fsPromises.access(p);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        };
+        if (!(await exists(filePath)) && !path.extname(filePath)) {
             const htmlPath = `${filePath}.html`;
-            if (fs.existsSync(htmlPath)) {
+            if (await exists(htmlPath)) {
                 filePath = htmlPath;
             }
         }
-        if (fs.existsSync(filePath)) {
+        if (await exists(filePath)) {
             const ext = path.extname(filePath).toLowerCase();
             const contentType = MIME_TYPES_MAP[ext] || 'application/octet-stream';
-            const content = fs.readFileSync(filePath);
+            const content = await fs.fsPromises.readFile(filePath);
             response.setStatus(200);
             response.setHeader('Content-Type', contentType);
             response.send(content);
@@ -78,10 +89,10 @@ export const serveDocumentationFile = (urlPath, response) => {
     }
     return false;
 };
-const handleDocRequest = (req, res) => {
+const handleDocRequest = async (req, res) => {
     setDocumentationCSPHeaders(res);
     const urlPath = req.getPath();
-    if (serveDocumentationFile(urlPath, res))
+    if (await serveDocumentationFileAsync(urlPath, res))
         return;
     ErrorRouting.handleNotFound(req, res);
 };
@@ -92,4 +103,8 @@ export const registerDocRoutes = (router) => {
     // Greedy path match for nested assets like /doc/assets/app.js
     Router.get(router, '/doc/:path*', handleDocRequest);
 };
-export default { registerDocRoutes, setDocumentationCSPHeaders, serveDocumentationFile };
+export default {
+    registerDocRoutes,
+    setDocumentationCSPHeaders,
+    serveDocumentationFileAsync,
+};

package/src/routing/publicRoot.d.ts

@@ -6,13 +6,22 @@
  * Find the package root directory.
  */
 export declare const findPackageRoot: (startDir: string) => string;
+/**
+ * Find the package root directory (async).
+ */
+export declare const findPackageRootAsync: (startDir: string) => Promise<string>;
 /**
  * Framework public roots (dist/public preferred).
  */
 export declare const getFrameworkPublicRoots: () => string[];
+export declare const getFrameworkPublicRootsAsync: () => Promise<string[]>;
 /**
  * Resolve the effective public root.
  * Prefers app-local `public/` when present; otherwise falls back to framework public roots.
  */
 export declare const getPublicRoot: () => string;
+/**
+ * Resolve the effective public root (async).
+ */
+export declare const getPublicRootAsync: () => Promise<string>;
 //# sourceMappingURL=publicRoot.d.ts.map

package/src/routing/publicRoot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"publicRoot.d.ts","sourceRoot":"","sources":["../../../src/routing/publicRoot.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,KAAG,MASlD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,QAAO,MAAM,EAIhD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,QAAO,MAgBhC,CAAC"}
+{"version":3,"file":"publicRoot.d.ts","sourceRoot":"","sources":["../../../src/routing/publicRoot.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,KAAG,MAalD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAAU,UAAU,MAAM,KAAG,OAAO,CAAC,MAAM,CAkB3E,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,QAAO,MAAM,EAIhD,CAAC;AAEF,eAAO,MAAM,4BAA4B,QAAa,OAAO,CAAC,MAAM,EAAE,CAIrE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,QAAO,MAgBhC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,QAAa,OAAO,CAAC,MAAM,CA+BzD,CAAC"}

package/src/routing/publicRoot.js

@@ -11,8 +11,13 @@ import * as path from '../node-singletons/path.js';
 export const findPackageRoot = (startDir) => {
     let current = startDir;
     for (let i = 0; i < 10; i++) {
-        if (fs.existsSync(path.join(current, 'package.json')))
-            return current;
+        try {
+            if (fs.existsSync(path.join(current, 'package.json')))
+                return current;
+        }
+        catch {
+            // ignore access errors
+        }
         const parent = path.dirname(current);
         if (parent === current)
             break;
@@ -20,6 +25,27 @@ export const findPackageRoot = (startDir) => {
     }
     return startDir;
 };
+/**
+ * Find the package root directory (async).
+ */
+export const findPackageRootAsync = async (startDir) => {
+    const findUp = async (current, depth) => {
+        if (depth >= 10)
+            return startDir;
+        try {
+            await fs.fsPromises.access(path.join(current, 'package.json'));
+            return current;
+        }
+        catch {
+            // ignore
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            return startDir;
+        return findUp(parent, depth + 1);
+    };
+    return findUp(startDir, 0);
+};
 /**
  * Framework public roots (dist/public preferred).
  */
@@ -28,6 +54,11 @@ export const getFrameworkPublicRoots = () => {
     const packageRoot = findPackageRoot(thisDir);
     return [path.join(packageRoot, 'dist/public'), path.join(packageRoot, 'public')];
 };
+export const getFrameworkPublicRootsAsync = async () => {
+    const thisDir = esmDirname(import.meta.url);
+    const packageRoot = await findPackageRootAsync(thisDir);
+    return [path.join(packageRoot, 'dist/public'), path.join(packageRoot, 'public')];
+};
 /**
  * Resolve the effective public root.
  * Prefers app-local `public/` when present; otherwise falls back to framework public roots.
@@ -47,3 +78,33 @@ export const getPublicRoot = () => {
     }
     return candidates[0];
 };
+/**
+ * Resolve the effective public root (async).
+ */
+export const getPublicRootAsync = async () => {
+    const appRoots = [path.join(process.cwd(), 'public')];
+    const fwRoots = await getFrameworkPublicRootsAsync();
+    const candidates = [...appRoots, ...fwRoots];
+    const exists = async (p) => {
+        try {
+            await fs.fsPromises.access(p);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const hasIndex = async (root) => exists(path.join(root, 'index.html'));
+    const checks = await Promise.all(candidates.map(async (candidate) => {
+        const rootExists = await exists(candidate);
+        const indexExists = rootExists ? await hasIndex(candidate) : false;
+        return { candidate, rootExists, indexExists };
+    }));
+    const withIndex = checks.find((c) => c.indexExists);
+    if (withIndex)
+        return withIndex.candidate;
+    const firstExisting = checks.find((c) => c.rootExists);
+    if (firstExisting)
+        return firstExisting.candidate;
+    return candidates[0];
+};

package/src/runtime/StartupConfigFileRegistry.d.ts

@@ -0,0 +1,21 @@
+export declare const StartupConfigFile: {
+    readonly Broadcast: "config/broadcast.ts";
+    readonly Cache: "config/cache.ts";
+    readonly Database: "config/database.ts";
+    readonly Mail: "config/mail.ts";
+    readonly Middleware: "config/middleware.ts";
+    readonly Notification: "config/notification.ts";
+    readonly Queue: "config/queue.ts";
+    readonly Storage: "config/storage.ts";
+};
+export type StartupConfigFileTyps = typeof StartupConfigFile.Broadcast | typeof StartupConfigFile.Cache | typeof StartupConfigFile.Database | typeof StartupConfigFile.Mail | typeof StartupConfigFile.Middleware | typeof StartupConfigFile.Notification | typeof StartupConfigFile.Queue | typeof StartupConfigFile.Storage;
+export declare const StartupConfigFileRegistry: Readonly<{
+    preload(files: readonly StartupConfigFileTyps[]): Promise<void>;
+    isPreloaded(): boolean;
+    get<T>(file: StartupConfigFileTyps): T | undefined;
+    has(file: StartupConfigFileTyps): boolean;
+    /** Intended for tests only. */
+    clear(): void;
+}>;
+export default StartupConfigFileRegistry;
+//# sourceMappingURL=StartupConfigFileRegistry.d.ts.map

package/src/runtime/StartupConfigFileRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StartupConfigFileRegistry.d.ts","sourceRoot":"","sources":["../../../src/runtime/StartupConfigFileRegistry.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;;;;;;;;CASpB,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAC7B,OAAO,iBAAiB,CAAC,SAAS,GAClC,OAAO,iBAAiB,CAAC,KAAK,GAC9B,OAAO,iBAAiB,CAAC,QAAQ,GACjC,OAAO,iBAAiB,CAAC,IAAI,GAC7B,OAAO,iBAAiB,CAAC,UAAU,GACnC,OAAO,iBAAiB,CAAC,YAAY,GACrC,OAAO,iBAAiB,CAAC,KAAK,GAC9B,OAAO,iBAAiB,CAAC,OAAO,CAAC;AAKrC,eAAO,MAAM,yBAAyB;mBACf,SAAS,qBAAqB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;mBAetD,OAAO;QAIlB,CAAC,QAAQ,qBAAqB,GAAG,CAAC,GAAG,SAAS;cAIxC,qBAAqB,GAAG,OAAO;IAIzC,+BAA+B;aACtB,IAAI;EAIb,CAAC;AAEH,eAAe,yBAAyB,CAAC"}