@zintrust/core 1.5.4 → 1.6.0

package/bin/launcher.d.ts

@@ -0,0 +1,6 @@
+type RunCliWrapperInput = {
+    traceName?: string;
+};
+export declare const runCliWrapper: (input?: RunCliWrapperInput) => Promise<void>;
+export {};
+//# sourceMappingURL=launcher.d.ts.map

package/bin/launcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"launcher.d.ts","sourceRoot":"","sources":["../../bin/launcher.ts"],"names":[],"mappings":"AAMA,KAAK,kBAAkB,GAAG;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AA6LF,eAAO,MAAM,aAAa,GAAU,QAAO,kBAAuB,KAAG,OAAO,CAAC,IAAI,CAoBhF,CAAC"}

package/bin/launcher.js

@@ -0,0 +1,167 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const CLI_SPAWN_TRACE_ENV_KEYS = ['CLI_SPAWN_TRACE', 'ZIN_SPAWN_TRACE'];
+const here = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const isCliSpawnTraceEnabled = () => {
+    return CLI_SPAWN_TRACE_ENV_KEYS.some((key) => {
+        const raw = process.env[key];
+        if (typeof raw !== 'string')
+            return false;
+        const normalized = raw.trim().toLowerCase();
+        return (normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on');
+    });
+};
+const writeCliSpawnTrace = (input, label, details = {}) => {
+    if (input.traceName === undefined || !isCliSpawnTraceEnabled())
+        return;
+    process.stderr.write(`${JSON.stringify({ trace: input.traceName, label, pid: process.pid, details })}\n`);
+};
+const resolveNodeArgs = () => {
+    const tsTarget = path.join(here, 'zintrust-main.ts');
+    const jsTarget = path.join(here, 'zintrust-main.js');
+    const target = existsSync(tsTarget) ? tsTarget : jsTarget;
+    if (!target.endsWith('.ts')) {
+        return [target, ...process.argv.slice(2)];
+    }
+    return ['--import', require.resolve('tsx'), target, ...process.argv.slice(2)];
+};
+const getExitCode = (exitCode, signal) => {
+    if (typeof exitCode === 'number')
+        return exitCode;
+    if (signal === 'SIGINT' || signal === 'SIGTERM')
+        return 0;
+    return 1;
+};
+const attachOutputRelay = (input, child, stream) => {
+    const childStream = child[stream];
+    const targetStream = stream === 'stdout' ? process.stdout : process.stderr;
+    childStream?.on('data', (chunk) => {
+        writeCliSpawnTrace(input, `wrapper.child.${stream}.data`, {
+            childPid: child.pid,
+            bytes: typeof chunk === 'string' ? Buffer.byteLength(chunk) : chunk.length,
+        });
+        targetStream.write(chunk);
+    });
+};
+const waitForChildClose = async (input, child, onBeforeResolve) => {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let childResult = {
+            exitCode: null,
+            signal: null,
+        };
+        const finalize = () => {
+            if (settled)
+                return;
+            settled = true;
+            onBeforeResolve();
+            child.off?.('error', reject);
+            child.off?.('exit', handleExit);
+            child.off?.('close', handleClose);
+            writeCliSpawnTrace(input, 'wrapper.child.finalize', {
+                childPid: child.pid,
+                exitCode: childResult.exitCode,
+                signal: childResult.signal,
+            });
+            resolve(childResult);
+        };
+        const handleExit = (exitCode, signal) => {
+            childResult = { exitCode, signal };
+        };
+        const handleClose = (exitCode, signal) => {
+            childResult = {
+                exitCode: childResult.exitCode ?? exitCode,
+                signal: childResult.signal ?? signal,
+            };
+            finalize();
+        };
+        child.once('error', reject);
+        child.once('exit', handleExit);
+        child.once('close', handleClose);
+    });
+};
+const registerSignalHandlers = (input, child) => {
+    let childClosed = false;
+    let delayedSignalTimer;
+    const clearDelayedSignal = () => {
+        if (delayedSignalTimer === undefined)
+            return;
+        clearTimeout(delayedSignalTimer);
+        delayedSignalTimer = undefined;
+    };
+    const forwardSignal = (signal) => {
+        if (childClosed)
+            return;
+        try {
+            writeCliSpawnTrace(input, 'wrapper.signal.forward', {
+                childPid: child.pid,
+                signal,
+            });
+            child.kill(signal);
+        }
+        catch {
+            // best-effort
+        }
+    };
+    const scheduleSignalForward = (signal) => {
+        if (childClosed || delayedSignalTimer !== undefined)
+            return;
+        delayedSignalTimer = globalThis.setTimeout(() => {
+            delayedSignalTimer = undefined;
+            writeCliSpawnTrace(input, 'wrapper.signal.delay.fire', {
+                childPid: child.pid,
+                signal,
+            });
+            forwardSignal(signal);
+        }, 1500);
+        writeCliSpawnTrace(input, 'wrapper.signal.delay.schedule', {
+            childPid: child.pid,
+            signal,
+            delayMs: 1500,
+        });
+        delayedSignalTimer.unref?.();
+    };
+    const onSigint = () => {
+        if (process.stdin.isTTY === true) {
+            scheduleSignalForward('SIGINT');
+            return;
+        }
+        forwardSignal('SIGINT');
+    };
+    const onSigterm = () => {
+        if (process.stdin.isTTY === true) {
+            scheduleSignalForward('SIGTERM');
+            return;
+        }
+        forwardSignal('SIGTERM');
+    };
+    process.on('SIGINT', onSigint);
+    process.on('SIGTERM', onSigterm);
+    return () => {
+        childClosed = true;
+        clearDelayedSignal();
+        process.off('SIGINT', onSigint);
+        process.off('SIGTERM', onSigterm);
+    };
+};
+export const runCliWrapper = async (input = {}) => {
+    const nodeArgs = resolveNodeArgs();
+    const child = spawn(process.execPath, nodeArgs, {
+        stdio: ['inherit', 'pipe', 'pipe'],
+        env: process.env,
+    });
+    writeCliSpawnTrace(input, 'wrapper.child.started', {
+        childPid: child.pid,
+        command: process.execPath,
+        args: nodeArgs,
+    });
+    attachOutputRelay(input, child, 'stdout');
+    attachOutputRelay(input, child, 'stderr');
+    const unregisterSignalHandlers = registerSignalHandlers(input, child);
+    const result = await waitForChildClose(input, child, unregisterSignalHandlers);
+    process.exit(getExitCode(result.exitCode, result.signal));
+};

package/bin/z.js

@@ -3,38 +3,5 @@
  * ZinTrust CLI Shortcut - 'z'
  * Mirrors bin/zintrust.ts for convenience
  */
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-const here = path.dirname(fileURLToPath(import.meta.url));
-const require = createRequire(import.meta.url);
-const tsTarget = path.join(here, 'zintrust-main.ts');
-const jsTarget = path.join(here, 'zintrust-main.js');
-const target = existsSync(tsTarget) ? tsTarget : jsTarget;
-const tsxImportPath = require.resolve('tsx');
-const nodeArgs = target.endsWith('.ts')
-    ? ['--import', tsxImportPath, target, ...process.argv.slice(2)]
-    : [target, ...process.argv.slice(2)];
-const child = spawn(process.execPath, nodeArgs, {
-    stdio: 'inherit',
-    env: process.env,
-});
-const result = await new Promise((resolve, reject) => {
-    let settled = false;
-    const finalize = (exitCode, signal) => {
-        if (settled) {
-            return;
-        }
-        settled = true;
-        child.off?.('error', reject);
-        child.off?.('exit', finalize);
-        child.off?.('close', finalize);
-        resolve({ exitCode, signal });
-    };
-    child.once('error', reject);
-    child.once('exit', finalize);
-    child.once('close', finalize);
-});
-process.exit(result.exitCode ?? (result.signal === 'SIGINT' || result.signal === 'SIGTERM' ? 0 : 1));
+import { runCliWrapper } from './launcher.js';
+await runCliWrapper();

package/bin/zin.js

@@ -3,38 +3,5 @@
  * ZinTrust CLI Shortcut - 'zin'
  * Mirrors bin/zintrust.ts for convenience
  */
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-const here = path.dirname(fileURLToPath(import.meta.url));
-const require = createRequire(import.meta.url);
-const tsTarget = path.join(here, 'zintrust-main.ts');
-const jsTarget = path.join(here, 'zintrust-main.js');
-const target = existsSync(tsTarget) ? tsTarget : jsTarget;
-const tsxImportPath = require.resolve('tsx');
-const nodeArgs = target.endsWith('.ts')
-    ? ['--import', tsxImportPath, target, ...process.argv.slice(2)]
-    : [target, ...process.argv.slice(2)];
-const child = spawn(process.execPath, nodeArgs, {
-    stdio: 'inherit',
-    env: process.env,
-});
-const result = await new Promise((resolve, reject) => {
-    let settled = false;
-    const finalize = (exitCode, signal) => {
-        if (settled) {
-            return;
-        }
-        settled = true;
-        child.off?.('error', reject);
-        child.off?.('exit', finalize);
-        child.off?.('close', finalize);
-        resolve({ exitCode, signal });
-    };
-    child.once('error', reject);
-    child.once('exit', finalize);
-    child.once('close', finalize);
-});
-process.exit(result.exitCode ?? (result.signal === 'SIGINT' || result.signal === 'SIGTERM' ? 0 : 1));
+import { runCliWrapper } from './launcher.js';
+await runCliWrapper({ traceName: 'cli-wrapper' });

package/bin/zintrust.d.ts

@@ -4,7 +4,7 @@
  *
  * This bin script is a thin wrapper around the hashbang-free implementation in
  * bin/zintrust-main.ts. Keeping the implementation hashbang-free allows other
- * shortcuts (zin/z/zt) to import it without parse issues.
+ * shortcuts (zin/z/zt) to reuse the same launcher behavior.
  */
 export {};
 //# sourceMappingURL=zintrust.d.ts.map

package/bin/zintrust.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zintrust.d.ts","sourceRoot":"","sources":["../../bin/zintrust.ts"],"names":[],"mappings":";AAEA;;;;;;GAMG;AA8CH,OAAO,EAAE,CAAC"}
+{"version":3,"file":"zintrust.d.ts","sourceRoot":"","sources":["../../bin/zintrust.ts"],"names":[],"mappings":";AAEA;;;;;;GAMG"}

package/bin/zintrust.js

@@ -4,40 +4,7 @@
  *
  * This bin script is a thin wrapper around the hashbang-free implementation in
  * bin/zintrust-main.ts. Keeping the implementation hashbang-free allows other
- * shortcuts (zin/z/zt) to import it without parse issues.
+ * shortcuts (zin/z/zt) to reuse the same launcher behavior.
  */
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-const here = path.dirname(fileURLToPath(import.meta.url));
-const require = createRequire(import.meta.url);
-const tsTarget = path.join(here, 'zintrust-main.ts');
-const jsTarget = path.join(here, 'zintrust-main.js');
-const target = existsSync(tsTarget) ? tsTarget : jsTarget;
-const tsxImportPath = require.resolve('tsx');
-const nodeArgs = target.endsWith('.ts')
-    ? ['--import', tsxImportPath, target, ...process.argv.slice(2)]
-    : [target, ...process.argv.slice(2)];
-const child = spawn(process.execPath, nodeArgs, {
-    stdio: 'inherit',
-    env: process.env,
-});
-const result = await new Promise((resolve, reject) => {
-    let settled = false;
-    const finalize = (exitCode, signal) => {
-        if (settled) {
-            return;
-        }
-        settled = true;
-        child.off?.('error', reject);
-        child.off?.('exit', finalize);
-        child.off?.('close', finalize);
-        resolve({ exitCode, signal });
-    };
-    child.once('error', reject);
-    child.once('exit', finalize);
-    child.once('close', finalize);
-});
-process.exit(result.exitCode ?? (result.signal === 'SIGINT' || result.signal === 'SIGTERM' ? 0 : 1));
+import { runCliWrapper } from './launcher.js';
+await runCliWrapper();

package/bin/zt.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env -S node --import tsx
 /**
- * ZinTrust CLI Shortcut - 'z'
+ * ZinTrust CLI Shortcut - 'zt'
  * Mirrors bin/zintrust.ts for convenience
  */
 export {};

package/bin/zt.js

@@ -1,27 +1,7 @@
 #!/usr/bin/env node
 /**
- * ZinTrust CLI Shortcut - 'z'
+ * ZinTrust CLI Shortcut - 'zt'
  * Mirrors bin/zintrust.ts for convenience
  */
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-const here = path.dirname(fileURLToPath(import.meta.url));
-const tsTarget = path.join(here, 'zintrust-main.ts');
-const jsTarget = path.join(here, 'zintrust-main.js');
-const target = existsSync(tsTarget) ? tsTarget : jsTarget;
-const nodeArgs = target.endsWith('.ts')
-    ? ['--import', 'tsx', target, ...process.argv.slice(2)]
-    : [target, ...process.argv.slice(2)];
-const child = spawn(process.execPath, nodeArgs, {
-    stdio: 'inherit',
-    env: process.env,
-});
-const result = await new Promise((resolve, reject) => {
-    child.once('error', reject);
-    child.once('close', (exitCode, signal) => {
-        resolve({ exitCode, signal });
-    });
-});
-process.exit(result.exitCode ?? (result.signal === 'SIGINT' || result.signal === 'SIGTERM' ? 0 : 1));
+import { runCliWrapper } from './launcher.js';
+await runCliWrapper();

package/package.json

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

package/src/boot/bootstrap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../src/boot/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAyWH,eAAO,MAAM,cAAc,eAAmB,CAAC"}
+{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../../src/boot/bootstrap.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAgbH,eAAO,MAAM,cAAc,eAAmB,CAAC"}

package/src/boot/bootstrap.js

@@ -11,6 +11,7 @@ import { Env } from '../config/env.js';
 import { Logger } from '../config/logger.js';
 import { shutdownRedisConnections } from '../config/workers.js';
 import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import { ShutdownTrace } from '../helper/ShutdownTrace.js';
 import { ProjectRuntime } from '../runtime/ProjectRuntime.js';
 import { StartupErrorLogging } from '../runtime/StartupErrorLogging.js';
 import { WorkerProjectAutoImports } from '../runtime/WorkerProjectAutoImports.js';
@@ -92,66 +93,130 @@ const withTimeout = async (promise, timeoutMs, label) => {
             globalThis.clearTimeout(timeoutId);
     }
 };
+const shutdownWorkersIfNeeded = async (signal, remainingMs) => {
+    if (appConfig.worker !== true ||
+        (appConfig.detectRuntime() !== 'nodejs' && appConfig.detectRuntime() !== 'lambda') ||
+        appConfig.dockerWorker === true) {
+        return;
+    }
+    try {
+        ShutdownTrace.log('bootstrap.graceful-shutdown.worker-shutdown.start', {
+            signal,
+            remainingMs: remainingMs(),
+        });
+        const workers = await loadWorkersModule();
+        const workerBudgetMs = Math.min(15000, remainingMs());
+        await withTimeout(workers.WorkerShutdown.shutdown({
+            signal,
+            timeout: workerBudgetMs,
+            forceExit: false,
+        }), workerBudgetMs, 'Worker shutdown timed out');
+        ShutdownTrace.logHandles('bootstrap.graceful-shutdown.worker-shutdown.complete', {
+            workerBudgetMs,
+            remainingMs: remainingMs(),
+        });
+    }
+    catch (error) {
+        Logger.warn('Worker shutdown failed (continuing with app shutdown)', error);
+        ShutdownTrace.logHandles('bootstrap.graceful-shutdown.worker-shutdown.failed', {
+            remainingMs: remainingMs(),
+        });
+    }
+};
+const shutdownServerIfNeeded = async (remainingMs) => {
+    if (serverInstance === undefined)
+        return;
+    ShutdownTrace.log('bootstrap.graceful-shutdown.server-close.start', {
+        remainingMs: remainingMs(),
+    });
+    await serverInstance.close();
+    ShutdownTrace.logHandles('bootstrap.graceful-shutdown.server-close.complete', {
+        remainingMs: remainingMs(),
+    });
+};
+const shutdownAppIfNeeded = async (remainingMs) => {
+    if (appInstance === undefined)
+        return;
+    try {
+        const appBudgetMs = Math.min(5000, remainingMs());
+        ShutdownTrace.log('bootstrap.graceful-shutdown.app-shutdown.start', {
+            appBudgetMs,
+            remainingMs: remainingMs(),
+        });
+        await withTimeout(appInstance.shutdown(), appBudgetMs, 'App shutdown timed out');
+        ShutdownTrace.logHandles('bootstrap.graceful-shutdown.app-shutdown.complete', {
+            appBudgetMs,
+            remainingMs: remainingMs(),
+        });
+    }
+    catch (error) {
+        Logger.warn('App shutdown failed or timed out, forcing exit', error);
+        ShutdownTrace.logHandles('bootstrap.graceful-shutdown.app-shutdown.failed', {
+            remainingMs: remainingMs(),
+        });
+    }
+};
+const shutdownTrackedRedis = async (remainingMs) => {
+    try {
+        const redisBudgetMs = Math.max(250, Math.min(3000, remainingMs()));
+        ShutdownTrace.log('bootstrap.graceful-shutdown.redis-shutdown.start', {
+            redisBudgetMs,
+            remainingMs: remainingMs(),
+        });
+        await withTimeout(shutdownRedisConnections(), redisBudgetMs, 'Redis connection shutdown timed out');
+        ShutdownTrace.logHandles('bootstrap.graceful-shutdown.redis-shutdown.complete', {
+            redisBudgetMs,
+            remainingMs: remainingMs(),
+        });
+    }
+    catch (error) {
+        Logger.warn('Redis connection shutdown failed (continuing with app shutdown)', error);
+        ShutdownTrace.logHandles('bootstrap.graceful-shutdown.redis-shutdown.failed', {
+            remainingMs: remainingMs(),
+        });
+    }
+};
+const runGracefulShutdownPhases = async (signal, remainingMs) => {
+    await shutdownWorkersIfNeeded(signal, remainingMs);
+    await shutdownServerIfNeeded(remainingMs);
+    await shutdownAppIfNeeded(remainingMs);
+    await shutdownTrackedRedis(remainingMs);
+    Logger.info('✅ Application shut down successfully');
+    ShutdownTrace.logHandles('bootstrap.graceful-shutdown.complete', {
+        remainingMs: remainingMs(),
+    });
+};
 const gracefulShutdown = async (signal) => {
     if (isShuttingDown)
         return;
     isShuttingDown = true;
-    const shutdownBudgetMs = Env.getInt('SHUTDOWN_TIMEOUT', 1500);
+    const shutdownBudgetMs = Env.getInt('SHUTDOWN_TIMEOUT', 10000);
     const minForceExitMs = shutdownBudgetMs + 250;
     const forceExitMs = Math.max(Env.getInt('SHUTDOWN_FORCE_EXIT_MS', 10000), minForceExitMs);
     const deadlineMs = Date.now() + shutdownBudgetMs;
     const remainingMs = () => Math.max(0, deadlineMs - Date.now());
     Logger.info(`${signal} received, shutting down gracefully...`);
+    ShutdownTrace.logHandles('bootstrap.graceful-shutdown.received', {
+        signal,
+        shutdownBudgetMs,
+        forceExitMs,
+        workerEnabled: appConfig.worker,
+    });
     try {
         const forceExitTimer = globalThis.setTimeout(() => {
             process.exit(0);
         }, forceExitMs);
         // Best-effort: don't keep the process alive just for this timer
         forceExitTimer.unref?.();
-        await withTimeout((async () => {
-            // Shutdown worker management system FIRST (before database closes)
-            if (appConfig.worker === true &&
-                (appConfig.detectRuntime() === 'nodejs' || appConfig.detectRuntime() === 'lambda') &&
-                appConfig.dockerWorker === false) {
-                try {
-                    const workers = await loadWorkersModule();
-                    const workerBudgetMs = Math.min(15000, remainingMs());
-                    await withTimeout(workers.WorkerShutdown.shutdown({
-                        signal,
-                        timeout: workerBudgetMs,
-                        forceExit: false,
-                    }), workerBudgetMs, 'Worker shutdown timed out');
-                }
-                catch (error) {
-                    Logger.warn('Worker shutdown failed (continuing with app shutdown)', error);
-                }
-            }
-            if (serverInstance !== undefined) {
-                await serverInstance.close();
-            }
-            if (appInstance !== undefined) {
-                try {
-                    const appBudgetMs = Math.min(5000, remainingMs());
-                    await withTimeout(appInstance.shutdown(), appBudgetMs, 'App shutdown timed out');
-                }
-                catch (error) {
-                    Logger.warn('App shutdown failed or timed out, forcing exit', error);
-                }
-            }
-            try {
-                const redisBudgetMs = Math.max(250, Math.min(3000, remainingMs()));
-                await withTimeout(shutdownRedisConnections(), redisBudgetMs, 'Redis connection shutdown timed out');
-            }
-            catch (error) {
-                Logger.warn('Redis connection shutdown failed (continuing with app shutdown)', error);
-            }
-            Logger.info('✅ Application shut down successfully');
-        })(), shutdownBudgetMs, 'Graceful shutdown timed out');
+        await withTimeout(runGracefulShutdownPhases(signal, remainingMs), shutdownBudgetMs, 'Graceful shutdown timed out');
         globalThis.clearTimeout(forceExitTimer);
         process.exit(0);
     }
     catch (error) {
         Logger.error('Graceful shutdown failed:', error);
+        ShutdownTrace.logHandles('bootstrap.graceful-shutdown.error', {
+            error: error instanceof Error ? error.message : String(error),
+        });
         process.exit(1);
     }
 };

package/src/boot/registry/runtime.d.ts

@@ -1,15 +1,17 @@
 import type { IShutdownManager } from './type';
 import type { IRouter } from '../../index.js';
 export declare const registerFrameworkShutdownHooks: (shutdownManager: IShutdownManager) => void;
-export declare const createLifecycle: (params: {
+type LifecycleParams = {
     environment: string;
     resolvedBasePath: string;
     router: IRouter;
     shutdownManager: IShutdownManager;
     getBooted: () => boolean;
     setBooted: (value: boolean) => void;
-}) => {
+};
+export declare const createLifecycle: (params: LifecycleParams) => {
     boot: () => Promise<void>;
     shutdown: () => Promise<void>;
 };
+export {};
 //# sourceMappingURL=runtime.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../src/boot/registry/runtime.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AASvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AA+P9C,eAAO,MAAM,8BAA8B,GAAI,iBAAiB,gBAAgB,KAAG,IA6BlF,CAAC;AAwUF,eAAO,MAAM,eAAe,GAAI,QAAQ;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,OAAO,CAAC;IAChB,eAAe,EAAE,gBAAgB,CAAC;IAClC,SAAS,EAAE,MAAM,OAAO,CAAC;IACzB,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACrC,KAAG;IAAE,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAyF7D,CAAC"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../../src/boot/registry/runtime.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAUvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAkQ9C,eAAO,MAAM,8BAA8B,GAAI,iBAAiB,gBAAgB,KAAG,IA6BlF,CAAC;AA8UF,KAAK,eAAe,GAAG;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,OAAO,CAAC;IAChB,eAAe,EAAE,gBAAgB,CAAC;IAClC,SAAS,EAAE,MAAM,OAAO,CAAC;IACzB,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACrC,CAAC;AA4HF,eAAO,MAAM,eAAe,GAC1B,QAAQ,eAAe,KACtB;IAAE,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAK5D,CAAC"}