@zintrust/core 1.5.4 → 1.5.5

package/bin/z.js

@@ -18,23 +18,90 @@ 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',
+    stdio: ['inherit', 'pipe', 'pipe'],
     env: process.env,
 });
+child.stdout?.on('data', (chunk) => {
+    process.stdout.write(chunk);
+});
+child.stderr?.on('data', (chunk) => {
+    process.stderr.write(chunk);
+});
+let childClosed = false;
+let delayedSignalTimer;
+const clearDelayedSignal = () => {
+    if (delayedSignalTimer === undefined)
+        return;
+    clearTimeout(delayedSignalTimer);
+    delayedSignalTimer = undefined;
+};
+const forwardSignal = (signal) => {
+    if (childClosed)
+        return;
+    try {
+        child.kill(signal);
+    }
+    catch {
+        // best-effort
+    }
+};
+const scheduleSignalForward = (signal) => {
+    if (childClosed || delayedSignalTimer !== undefined)
+        return;
+    delayedSignalTimer = globalThis.setTimeout(() => {
+        delayedSignalTimer = undefined;
+        forwardSignal(signal);
+    }, 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);
 const result = await new Promise((resolve, reject) => {
     let settled = false;
-    const finalize = (exitCode, signal) => {
+    let childResult = {
+        exitCode: null,
+        signal: null,
+    };
+    const finalize = () => {
         if (settled) {
             return;
         }
         settled = true;
+        childClosed = true;
+        clearDelayedSignal();
+        process.off('SIGINT', onSigint);
+        process.off('SIGTERM', onSigterm);
         child.off?.('error', reject);
-        child.off?.('exit', finalize);
-        child.off?.('close', finalize);
-        resolve({ exitCode, signal });
+        child.off?.('exit', handleExit);
+        child.off?.('close', handleClose);
+        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', finalize);
-    child.once('close', finalize);
+    child.once('exit', handleExit);
+    child.once('close', handleClose);
 });
 process.exit(result.exitCode ?? (result.signal === 'SIGINT' || result.signal === 'SIGTERM' ? 0 : 1));

package/bin/zin.js

@@ -8,6 +8,21 @@ 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 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 = (label, details = {}) => {
+    if (!isCliSpawnTraceEnabled())
+        return;
+    process.stderr.write(`${JSON.stringify({ trace: 'cli-wrapper', label, pid: process.pid, details })}\n`);
+};
 const here = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
 const tsTarget = path.join(here, 'zintrust-main.ts');
@@ -18,23 +33,165 @@ 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',
+    stdio: ['inherit', 'pipe', 'pipe'],
     env: process.env,
 });
+writeCliSpawnTrace('wrapper.child.started', {
+    childPid: child.pid,
+    command: process.execPath,
+    args: nodeArgs,
+});
+child.stdout?.on('data', (chunk) => {
+    writeCliSpawnTrace('wrapper.child.stdout.data', {
+        childPid: child.pid,
+        bytes: typeof chunk === 'string' ? Buffer.byteLength(chunk) : chunk.length,
+    });
+    process.stdout.write(chunk);
+});
+child.stdout?.on('end', () => {
+    writeCliSpawnTrace('wrapper.child.stdout.end', {
+        childPid: child.pid,
+    });
+});
+child.stdout?.on('close', () => {
+    writeCliSpawnTrace('wrapper.child.stdout.close', {
+        childPid: child.pid,
+    });
+});
+child.stderr?.on('data', (chunk) => {
+    writeCliSpawnTrace('wrapper.child.stderr.data', {
+        childPid: child.pid,
+        bytes: typeof chunk === 'string' ? Buffer.byteLength(chunk) : chunk.length,
+    });
+    process.stderr.write(chunk);
+});
+child.stderr?.on('end', () => {
+    writeCliSpawnTrace('wrapper.child.stderr.end', {
+        childPid: child.pid,
+    });
+});
+child.stderr?.on('close', () => {
+    writeCliSpawnTrace('wrapper.child.stderr.close', {
+        childPid: child.pid,
+    });
+});
+let childClosed = false;
+let delayedSignalTimer;
+const clearDelayedSignal = () => {
+    if (delayedSignalTimer === undefined)
+        return;
+    clearTimeout(delayedSignalTimer);
+    delayedSignalTimer = undefined;
+};
+const forwardSignal = (signal) => {
+    if (childClosed)
+        return;
+    try {
+        writeCliSpawnTrace('wrapper.signal.forward.attempt', {
+            childPid: child.pid,
+            signal,
+        });
+        child.kill(signal);
+        writeCliSpawnTrace('wrapper.signal.forward.complete', {
+            childPid: child.pid,
+            signal,
+        });
+    }
+    catch {
+        // best-effort
+    }
+};
+const scheduleSignalForward = (signal) => {
+    if (childClosed || delayedSignalTimer !== undefined)
+        return;
+    delayedSignalTimer = globalThis.setTimeout(() => {
+        delayedSignalTimer = undefined;
+        writeCliSpawnTrace('wrapper.signal.delay.fire', {
+            childPid: child.pid,
+            signal,
+        });
+        forwardSignal(signal);
+    }, 1500);
+    writeCliSpawnTrace('wrapper.signal.delay.schedule', {
+        childPid: child.pid,
+        signal,
+        delayMs: 1500,
+    });
+    delayedSignalTimer.unref?.();
+};
+const onSigint = () => {
+    writeCliSpawnTrace('wrapper.signal.received', {
+        childPid: child.pid,
+        signal: 'SIGINT',
+        tty: process.stdin.isTTY === true,
+    });
+    if (process.stdin.isTTY === true) {
+        scheduleSignalForward('SIGINT');
+        return;
+    }
+    forwardSignal('SIGINT');
+};
+const onSigterm = () => {
+    writeCliSpawnTrace('wrapper.signal.received', {
+        childPid: child.pid,
+        signal: 'SIGTERM',
+        tty: process.stdin.isTTY === true,
+    });
+    if (process.stdin.isTTY === true) {
+        scheduleSignalForward('SIGTERM');
+        return;
+    }
+    forwardSignal('SIGTERM');
+};
+process.on('SIGINT', onSigint);
+process.on('SIGTERM', onSigterm);
 const result = await new Promise((resolve, reject) => {
     let settled = false;
-    const finalize = (exitCode, signal) => {
+    let childResult = {
+        exitCode: null,
+        signal: null,
+    };
+    const finalize = () => {
         if (settled) {
             return;
         }
         settled = true;
+        writeCliSpawnTrace('wrapper.child.finalize', {
+            childPid: child.pid,
+            exitCode: childResult.exitCode,
+            signal: childResult.signal,
+        });
+        childClosed = true;
+        clearDelayedSignal();
+        process.off('SIGINT', onSigint);
+        process.off('SIGTERM', onSigterm);
         child.off?.('error', reject);
-        child.off?.('exit', finalize);
-        child.off?.('close', finalize);
-        resolve({ exitCode, signal });
+        child.off?.('exit', handleExit);
+        child.off?.('close', handleClose);
+        resolve(childResult);
+    };
+    const handleExit = (exitCode, signal) => {
+        writeCliSpawnTrace('wrapper.child.exit', {
+            childPid: child.pid,
+            exitCode,
+            signal,
+        });
+        childResult = { exitCode, signal };
+    };
+    const handleClose = (exitCode, signal) => {
+        writeCliSpawnTrace('wrapper.child.close', {
+            childPid: child.pid,
+            exitCode,
+            signal,
+        });
+        childResult = {
+            exitCode: childResult.exitCode ?? exitCode,
+            signal: childResult.signal ?? signal,
+        };
+        finalize();
     };
     child.once('error', reject);
-    child.once('exit', finalize);
-    child.once('close', finalize);
+    child.once('exit', handleExit);
+    child.once('close', handleClose);
 });
 process.exit(result.exitCode ?? (result.signal === 'SIGINT' || result.signal === 'SIGTERM' ? 0 : 1));

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;AA6HH,OAAO,EAAE,CAAC"}

package/bin/zintrust.js

@@ -21,23 +21,90 @@ 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',
+    stdio: ['inherit', 'pipe', 'pipe'],
     env: process.env,
 });
+child.stdout?.on('data', (chunk) => {
+    process.stdout.write(chunk);
+});
+child.stderr?.on('data', (chunk) => {
+    process.stderr.write(chunk);
+});
+let childClosed = false;
+let delayedSignalTimer;
+const clearDelayedSignal = () => {
+    if (delayedSignalTimer === undefined)
+        return;
+    clearTimeout(delayedSignalTimer);
+    delayedSignalTimer = undefined;
+};
+const forwardSignal = (signal) => {
+    if (childClosed)
+        return;
+    try {
+        child.kill(signal);
+    }
+    catch {
+        // best-effort
+    }
+};
+const scheduleSignalForward = (signal) => {
+    if (childClosed || delayedSignalTimer !== undefined)
+        return;
+    delayedSignalTimer = globalThis.setTimeout(() => {
+        delayedSignalTimer = undefined;
+        forwardSignal(signal);
+    }, 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);
 const result = await new Promise((resolve, reject) => {
     let settled = false;
-    const finalize = (exitCode, signal) => {
+    let childResult = {
+        exitCode: null,
+        signal: null,
+    };
+    const finalize = () => {
         if (settled) {
             return;
         }
         settled = true;
+        childClosed = true;
+        clearDelayedSignal();
+        process.off('SIGINT', onSigint);
+        process.off('SIGTERM', onSigterm);
         child.off?.('error', reject);
-        child.off?.('exit', finalize);
-        child.off?.('close', finalize);
-        resolve({ exitCode, signal });
+        child.off?.('exit', handleExit);
+        child.off?.('close', handleClose);
+        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', finalize);
-    child.once('close', finalize);
+    child.once('exit', handleExit);
+    child.once('close', handleClose);
 });
 process.exit(result.exitCode ?? (result.signal === 'SIGINT' || result.signal === 'SIGTERM' ? 0 : 1));

package/bin/zt.js

@@ -15,13 +15,90 @@ 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',
+    stdio: ['inherit', 'pipe', 'pipe'],
     env: process.env,
 });
+child.stdout?.on('data', (chunk) => {
+    process.stdout.write(chunk);
+});
+child.stderr?.on('data', (chunk) => {
+    process.stderr.write(chunk);
+});
+let childClosed = false;
+let delayedSignalTimer;
+const clearDelayedSignal = () => {
+    if (delayedSignalTimer === undefined)
+        return;
+    clearTimeout(delayedSignalTimer);
+    delayedSignalTimer = undefined;
+};
+const forwardSignal = (signal) => {
+    if (childClosed)
+        return;
+    try {
+        child.kill(signal);
+    }
+    catch {
+        // best-effort
+    }
+};
+const scheduleSignalForward = (signal) => {
+    if (childClosed || delayedSignalTimer !== undefined)
+        return;
+    delayedSignalTimer = globalThis.setTimeout(() => {
+        delayedSignalTimer = undefined;
+        forwardSignal(signal);
+    }, 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);
 const result = await new Promise((resolve, reject) => {
+    let settled = false;
+    let childResult = {
+        exitCode: null,
+        signal: null,
+    };
+    const finalize = () => {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        childClosed = true;
+        clearDelayedSignal();
+        process.off('SIGINT', onSigint);
+        process.off('SIGTERM', onSigterm);
+        child.off?.('error', reject);
+        child.off?.('exit', handleExit);
+        child.off?.('close', handleClose);
+        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('close', (exitCode, signal) => {
-        resolve({ exitCode, signal });
-    });
+    child.once('exit', handleExit);
+    child.once('close', handleClose);
 });
 process.exit(result.exitCode ?? (result.signal === 'SIGINT' || result.signal === 'SIGTERM' ? 0 : 1));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/core",
-  "version": "1.5.4",
+  "version": "1.5.5",
   "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.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,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;CAsH7D,CAAC"}