@zudojs/core 0.1.0 → 1.1.0

package/dist/runtime/runtimeError/runtimeError.lifecycle.js

@@ -1,29 +1,53 @@
 import { RuntimeErrorCode } from "./runtimeError.type.js";
 import { RuntimeError } from "./runtimeError.base.js";
 /**
- * Error thrown when runtime state transitions are invalid.
+ * Error thrown when an operation is attempted while the runtime is
+ * in a state that does not permit it (for example starting a runtime
+ * that is stopping, or stopping one that is still bootstrapping).
  */
-export class RuntimeStateError extends RuntimeError {
+export class InvalidRuntimeStateError extends RuntimeError {
+    /**
+     * The runtime state in which the operation was rejected.
+     */
+    state;
+    constructor(message, options = {}) {
+        const { state, ...rest } = options;
+        super(message, {
+            ...rest,
+            code: RuntimeErrorCode.INVALID_STATE_TRANSITION,
+            metadata: {
+                ...(rest.metadata ?? {}),
+                ...(state !== undefined && { state }),
+            },
+        });
+        this.name = "InvalidRuntimeStateError";
+        this.state = state;
+    }
+}
+/**
+ * Error thrown when a runtime state transition is not allowed by the
+ * runtime state table.
+ */
+export class InvalidRuntimeTransitionError extends RuntimeError {
     from;
     to;
     constructor(from, to, options = {}) {
         super(`Invalid runtime state transition from "${from}" to "${to}".`, {
             ...options,
             code: RuntimeErrorCode.INVALID_STATE_TRANSITION,
-            operation: options.operation ?? "run",
             metadata: {
                 ...(options.metadata ?? {}),
                 from,
                 to,
             },
         });
-        this.name = "RuntimeStateError";
+        this.name = "InvalidRuntimeTransitionError";
         this.from = from;
         this.to = to;
     }
 }
 /**
- * Error thrown when runtime startup fails.
+ * Error thrown when runtime startup (bootstrap) fails.
  */
 export class RuntimeStartError extends RuntimeError {
     constructor(message, options = {}) {
@@ -49,7 +73,7 @@ export class RuntimeStopError extends RuntimeError {
     }
 }
 /**
- * Error thrown when runtime initialization fails.
+ * Error thrown when module initialization fails during bootstrap.
  */
 export class RuntimeInitializationError extends RuntimeError {
     constructor(message, options = {}) {
@@ -62,7 +86,7 @@ export class RuntimeInitializationError extends RuntimeError {
     }
 }
 /**
- * Error thrown when runtime loading fails.
+ * Error thrown when module loading fails during bootstrap.
  */
 export class RuntimeLoadError extends RuntimeError {
     constructor(message, options = {}) {

package/dist/runtime/runtimeError/runtimeError.specialized.d.ts

@@ -5,7 +5,7 @@ import { RuntimeError } from "./runtimeError.base.js";
  */
 export declare class RuntimeTimeoutError extends RuntimeError {
     readonly timeoutMs: number;
-    constructor(message: string, timeoutMs: number, options?: Omit<RuntimeErrorOptions, "code">);
+    constructor(message: string, timeoutMs: number, options?: RuntimeErrorOptions);
 }
 /**
  * Error thrown when a runtime dependency is unavailable.

package/dist/runtime/runtimeError/runtimeError.specialized.js

@@ -8,7 +8,7 @@ export class RuntimeTimeoutError extends RuntimeError {
     constructor(message, timeoutMs, options = {}) {
         super(message, {
             ...options,
-            code: RuntimeErrorCode.OPERATION_TIMEOUT,
+            code: options.code ?? RuntimeErrorCode.OPERATION_TIMEOUT,
             metadata: {
                 ...(options.metadata ?? {}),
                 timeoutMs,

package/dist/runtime/runtimeError/runtimeError.type.d.ts

@@ -1,3 +1,4 @@
+import type { SerializedBaseError } from "@zudojs/errors";
 /**
  * Runtime lifecycle operations.
  */
@@ -57,18 +58,13 @@ export interface RuntimeErrorOptions {
 /**
  * Serializable representation of RuntimeError.
  */
-export interface RuntimeErrorJSON {
-    readonly name: string;
-    readonly message: string;
-    readonly code: string;
-    readonly operation?: RuntimeOperation;
-    readonly phase?: RuntimeErrorPhase;
+export type RuntimeErrorJSON = SerializedBaseError & {
+    readonly operation?: string;
+    readonly phase?: string;
     readonly runtimeId?: string;
     readonly runtimeName?: string;
     readonly moduleName?: string;
     readonly errorMetadata: RuntimeErrorMetadata;
     readonly recoverable: boolean;
-    readonly details?: unknown;
-    readonly status?: number;
-}
+};
 //# sourceMappingURL=runtimeError.type.d.ts.map

package/dist/runtime/runtimeLogger.d.ts

@@ -1,5 +1,5 @@
-import type { RuntimeContext } from "./runtimeContext/index.js";
+import type { RuntimeIdentity } from "./runtimeContext/index.js";
 import type { RuntimeEnvironment } from "./runtimeEnvironment/index.js";
 import type { Logger } from "../logging/core/logger.js";
-export declare function logRuntimeEvent(logger: Logger, context: RuntimeContext, environment: RuntimeEnvironment, level: "debug" | "info" | "warn" | "error", message: string, metadata?: Record<string, unknown>): void;
+export declare function logRuntimeEvent(logger: Logger, identity: RuntimeIdentity, environment: RuntimeEnvironment, level: "debug" | "info" | "warn" | "error", message: string, metadata?: Record<string, unknown>): void;
 //# sourceMappingURL=runtimeLogger.d.ts.map

package/dist/runtime/runtimeLogger.js

@@ -1,11 +1,11 @@
-export function logRuntimeEvent(logger, context, environment, level, message, metadata) {
+export function logRuntimeEvent(logger, identity, environment, level, message, metadata) {
     try {
         const log = logger;
         const method = log[level];
         if (typeof method === "function") {
             method.call(logger, message, {
-                runtimeId: context.identity.id,
-                runtimeName: context.identity.name,
+                runtimeId: identity.id,
+                runtimeName: identity.name,
                 environment: environment.engine,
                 ...metadata,
             });

package/dist/runtime/runtimeOptions/index.d.ts

@@ -6,5 +6,5 @@
 export { DEFAULT_RUNTIME_OPTIONS } from "./runtimeOptions.defaults.js";
 export { resolveRuntimeOptions, validateRuntimeOptions, } from "./runtimeOptions.resolver.js";
 export { isRuntimeMode, isRuntimeRole, assertRuntimeMode, assertRuntimeRole, } from "./runtimeOptions.validation.js";
-export type { RuntimeMode, RuntimeRole, RuntimeStartupOptions, RuntimeShutdownOptions, RuntimeSignalOptions, RuntimeDiagnosticsOptions, RuntimeInfrastructure, RuntimeOptions, ResolvedRuntimeOptions, } from "./runtimeOptions.type.js";
+export type { RuntimeMode, RuntimeRole, RuntimeStartupOptions, RuntimeShutdownOptions, RuntimeSignalOptions, RuntimeDiagnosticsOptions, RuntimeEnvironmentOverrides, RuntimeOptions, ResolvedRuntimeOptions, } from "./runtimeOptions.type.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/runtimeOptions/runtimeOptions.defaults.d.ts

@@ -2,5 +2,5 @@ import type { ResolvedRuntimeOptions } from "./runtimeOptions.type.js";
 /**
  * Default runtime configuration.
  */
-export declare const DEFAULT_RUNTIME_OPTIONS: Readonly<Omit<ResolvedRuntimeOptions, "infrastructure" | "metadata">>;
+export declare const DEFAULT_RUNTIME_OPTIONS: Readonly<Omit<ResolvedRuntimeOptions, "environment" | "metadata">>;
 //# sourceMappingURL=runtimeOptions.defaults.d.ts.map

package/dist/runtime/runtimeOptions/runtimeOptions.defaults.js

@@ -26,6 +26,8 @@ export const DEFAULT_RUNTIME_OPTIONS = Object.freeze({
         handleSighup: false,
         handleUncaughtException: true,
         handleUnhandledRejection: true,
+        forceExitOnSecondSignal: false,
+        forceExitCode: 1,
     },
     diagnostics: {
         startupLogging: true,

package/dist/runtime/runtimeOptions/runtimeOptions.resolver.js

@@ -8,6 +8,14 @@ export function resolveRuntimeOptions(options = {}) {
     const shutdown = options.shutdown ?? {};
     const signals = options.signals ?? {};
     const diagnostics = options.diagnostics ?? {};
+    /*
+     * Mode and role are validated here, not only in
+     * validateRuntimeOptions(): an unknown mode would otherwise be
+     * accepted silently and make the environment report neither
+     * production, development, nor test.
+     */
+    assertRuntimeMode(options.mode ?? DEFAULT_RUNTIME_OPTIONS.mode);
+    assertRuntimeRole(options.role ?? DEFAULT_RUNTIME_OPTIONS.role);
     validateRuntimeName(options.name);
     validateRuntimeTimeout(startup.timeoutMs, "startup");
     validateRuntimeTimeout(shutdown.timeoutMs, "shutdown");
@@ -47,6 +55,9 @@ export function resolveRuntimeOptions(options = {}) {
                 DEFAULT_RUNTIME_OPTIONS.signals.handleUncaughtException,
             handleUnhandledRejection: signals.handleUnhandledRejection ??
                 DEFAULT_RUNTIME_OPTIONS.signals.handleUnhandledRejection,
+            forceExitOnSecondSignal: signals.forceExitOnSecondSignal ??
+                DEFAULT_RUNTIME_OPTIONS.signals.forceExitOnSecondSignal,
+            forceExitCode: signals.forceExitCode ?? DEFAULT_RUNTIME_OPTIONS.signals.forceExitCode,
         },
         diagnostics: {
             startupLogging: diagnostics.startupLogging ??
@@ -58,8 +69,8 @@ export function resolveRuntimeOptions(options = {}) {
             includeModules: diagnostics.includeModules ??
                 DEFAULT_RUNTIME_OPTIONS.diagnostics.includeModules,
         },
-        infrastructure: Object.freeze({
-            ...options.infrastructure,
+        environment: Object.freeze({
+            ...options.environment,
         }),
         metadata: Object.freeze({
             ...options.metadata,

package/dist/runtime/runtimeOptions/runtimeOptions.type.d.ts

@@ -1,9 +1,4 @@
-import type { ApplicationContext } from "../../application/applicationContext.context.js";
-import type { ConfigurationManager } from "../../configuration/configurationManager.manager.js";
-import type { Logger } from "../../logging/core/logger.js";
-import type { ModuleLoader } from "../../modules/moduleLoader/index.js";
-import type { ModuleLifecycleManager } from "../../modules/moduleLifecycle/index.js";
-import type { ModuleRegistry } from "../../modules/moduleRegistry/index.js";
+import type { RuntimeEnvironmentVariables } from "../runtimeEnvironment/runtimeEnvironment.type.js";
 /**
  * Runtime execution mode.
  */
@@ -19,8 +14,19 @@ export interface RuntimeStartupOptions {
     readonly autoLoadModules?: boolean;
     readonly autoInitializeModules?: boolean;
     readonly autoStartModules?: boolean;
+    /**
+     * Continue bootstrapping when one or more modules fail to
+     * initialize. The runtime still becomes READY but the bootstrap
+     * result reports `success: false` with the failures listed.
+     */
     readonly continueOnInitializeError?: boolean;
+    /**
+     * Continue bootstrapping when one or more modules fail to start.
+     */
     readonly continueOnStartError?: boolean;
+    /**
+     * Bootstrap timeout in milliseconds. 0 disables the timeout.
+     */
     readonly timeoutMs?: number;
 }
 /**
@@ -31,37 +37,60 @@ export interface RuntimeShutdownOptions {
     readonly autoDestroyModules?: boolean;
     readonly continueOnStopError?: boolean;
     readonly continueOnDestroyError?: boolean;
+    /**
+     * Shutdown timeout in milliseconds. 0 disables the timeout.
+     */
     readonly timeoutMs?: number;
 }
 /**
  * Options related to runtime process signals.
+ *
+ * Handlers are registered when the runtime starts and removed when it
+ * stops, fails, or is disposed. The runtime never calls
+ * `process.exit()` unless `forceExitOnSecondSignal` is explicitly on.
  */
 export interface RuntimeSignalOptions {
+    /** Stop the runtime gracefully on SIGINT. */
     readonly handleSigint?: boolean;
+    /** Stop the runtime gracefully on SIGTERM. */
     readonly handleSigterm?: boolean;
+    /** Stop the runtime gracefully on SIGHUP. */
     readonly handleSighup?: boolean;
+    /** Mark the runtime failed and stop it on uncaughtException. */
     readonly handleUncaughtException?: boolean;
+    /** Mark the runtime failed and stop it on unhandledRejection. */
     readonly handleUnhandledRejection?: boolean;
+    /**
+     * When a second termination signal arrives while a graceful stop is
+     * already in progress, exit the process immediately with
+     * `forceExitCode`. Off by default: the second signal is logged and
+     * ignored.
+     */
+    readonly forceExitOnSecondSignal?: boolean;
+    /** Exit code used by `forceExitOnSecondSignal`. Defaults to 1. */
+    readonly forceExitCode?: number;
 }
 /**
  * Options controlling runtime diagnostics.
  */
 export interface RuntimeDiagnosticsOptions {
+    /** Emit info-level logs for bootstrap start/completion. */
     readonly startupLogging?: boolean;
+    /** Emit info-level logs for shutdown start/completion. */
     readonly shutdownLogging?: boolean;
+    /** Include the pipeline phase in bootstrap/shutdown logs. */
     readonly includeState?: boolean;
+    /** Include loaded module ids in bootstrap/shutdown logs. */
     readonly includeModules?: boolean;
 }
 /**
- * Dependencies that can be supplied to the runtime.
+ * Overrides for runtime environment detection. Useful for tests and
+ * for hosts that already know their environment.
  */
-export interface RuntimeInfrastructure {
-    readonly application: ApplicationContext;
-    readonly configuration: ConfigurationManager;
-    readonly logger: Logger;
-    readonly moduleRegistry: ModuleRegistry;
-    readonly moduleLoader: ModuleLoader;
-    readonly moduleLifecycle: ModuleLifecycleManager;
+export interface RuntimeEnvironmentOverrides {
+    readonly variables?: RuntimeEnvironmentVariables;
+    readonly isCI?: boolean;
+    readonly isContainer?: boolean;
 }
 /**
  * Complete runtime options.
@@ -74,7 +103,7 @@ export interface RuntimeOptions {
     readonly shutdown?: RuntimeShutdownOptions;
     readonly signals?: RuntimeSignalOptions;
     readonly diagnostics?: RuntimeDiagnosticsOptions;
-    readonly infrastructure?: Partial<RuntimeInfrastructure>;
+    readonly environment?: RuntimeEnvironmentOverrides;
     readonly metadata?: Readonly<Record<string, unknown>>;
 }
 /**
@@ -88,7 +117,7 @@ export interface ResolvedRuntimeOptions {
     readonly shutdown: Required<RuntimeShutdownOptions>;
     readonly signals: Required<RuntimeSignalOptions>;
     readonly diagnostics: Required<RuntimeDiagnosticsOptions>;
-    readonly infrastructure: Partial<RuntimeInfrastructure>;
+    readonly environment: RuntimeEnvironmentOverrides;
     readonly metadata: Readonly<Record<string, unknown>>;
 }
 //# sourceMappingURL=runtimeOptions.type.d.ts.map

package/dist/runtime/runtimeOptions/runtimeOptions.validation.js

@@ -1,4 +1,3 @@
-import { DEFAULT_RUNTIME_OPTIONS } from "./runtimeOptions.defaults.js";
 /**
  * Validates a runtime mode.
  */

package/dist/runtime/runtimeShutdown/index.d.ts

@@ -4,7 +4,8 @@
  * Handles the shutdown pipeline for stopping and
  * destroying runtime modules.
  */
-export { DefaultRuntimeShutdown, RuntimeShutdownError, withShutdownTimeout, createShutdownResult, } from "./runtimeShutdown.core.js";
-export { executeShutdownPipeline } from "./pipeline/index.js";
+export { DefaultRuntimeShutdown } from "./runtimeShutdown.core.js";
+export { executeShutdownPipeline, createShutdownPipelineState, createShutdownResult, } from "./pipeline/index.js";
+export type { ShutdownCounters, ShutdownPipelineState, } from "./pipeline/index.js";
 export type { RuntimeShutdownDependencies, RuntimeShutdownConfig, RuntimeShutdownPhase, RuntimeShutdownErrorInfo, RuntimeShutdownResult, RuntimeShutdown, ResolvedShutdownOptions, } from "./runtimeShutdown.type.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/runtimeShutdown/index.js

@@ -4,6 +4,6 @@
  * Handles the shutdown pipeline for stopping and
  * destroying runtime modules.
  */
-export { DefaultRuntimeShutdown, RuntimeShutdownError, withShutdownTimeout, createShutdownResult, } from "./runtimeShutdown.core.js";
-export { executeShutdownPipeline } from "./pipeline/index.js";
+export { DefaultRuntimeShutdown } from "./runtimeShutdown.core.js";
+export { executeShutdownPipeline, createShutdownPipelineState, createShutdownResult, } from "./pipeline/index.js";
 //# sourceMappingURL=index.js.map

package/dist/runtime/runtimeShutdown/pipeline/index.d.ts

@@ -3,5 +3,6 @@
  *
  * Module stopping and destruction stages.
  */
-export { executeShutdownPipeline } from "./runtimeShutdown.pipeline.js";
+export { executeShutdownPipeline, createShutdownPipelineState, createShutdownResult, } from "./runtimeShutdown.pipeline.js";
+export type { ShutdownCounters, ShutdownLogFn, ShutdownPipelineServices, ShutdownPipelineState, } from "./runtimeShutdown.pipeline.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/runtimeShutdown/pipeline/index.js

@@ -3,5 +3,5 @@
  *
  * Module stopping and destruction stages.
  */
-export { executeShutdownPipeline } from "./runtimeShutdown.pipeline.js";
+export { executeShutdownPipeline, createShutdownPipelineState, createShutdownResult, } from "./runtimeShutdown.pipeline.js";
 //# sourceMappingURL=index.js.map

package/dist/runtime/runtimeShutdown/pipeline/runtimeShutdown.pipeline.d.ts

@@ -1,9 +1,39 @@
 import type { ModuleLifecycleManager } from "../../../modules/moduleLifecycle/index.js";
-import type { RuntimeShutdownPhase, RuntimeShutdownErrorInfo, ResolvedShutdownOptions } from "../runtimeShutdown.type.js";
-type LogFn = (level: "debug" | "info" | "warn" | "error", message: string, metadata?: Record<string, unknown>) => void;
-export declare function executeShutdownPipeline(options: ResolvedShutdownOptions, errors: RuntimeShutdownErrorInfo[], counters: {
-    incrementStopped(): void;
-    incrementDestroyed(): void;
-}, moduleLifecycle: ModuleLifecycleManager, setPhase: (phase: RuntimeShutdownPhase) => void, log: LogFn): Promise<void>;
-export {};
+import type { RuntimeShutdownPhase, RuntimeShutdownErrorInfo, RuntimeShutdownResult, ResolvedShutdownOptions } from "../runtimeShutdown.type.js";
+export type ShutdownLogFn = (level: "debug" | "info" | "warn" | "error", message: string, metadata?: Record<string, unknown>) => void;
+/**
+ * Module counts produced by the shutdown pipeline.
+ */
+export interface ShutdownCounters {
+    stoppedModules: number;
+    destroyedModules: number;
+}
+/**
+ * Mutable pipeline state shared with the caller so that counts and
+ * recorded errors survive a thrown failure.
+ */
+export interface ShutdownPipelineState {
+    readonly counters: ShutdownCounters;
+    readonly errors: RuntimeShutdownErrorInfo[];
+}
+export declare function createShutdownPipelineState(): ShutdownPipelineState;
+/**
+ * Executes the stop → destroy pipeline.
+ *
+ * Mirrors the bootstrap pipeline contract: module-level failures are
+ * recorded once per module; a phase whose continueOn*Error flag is
+ * false throws (and the caller records that error once); aborted
+ * runs stop publishing phase changes.
+ */
+/**
+ * Services the shutdown pipeline drives.
+ */
+export interface ShutdownPipelineServices {
+    readonly moduleLifecycle: ModuleLifecycleManager;
+    /** Identity attached to every error the pipeline raises. */
+    readonly runtimeId?: string;
+    readonly runtimeName?: string;
+}
+export declare function executeShutdownPipeline(options: ResolvedShutdownOptions, services: ShutdownPipelineServices, state: ShutdownPipelineState, signal: AbortSignal, setPhase: (phase: RuntimeShutdownPhase) => void, log: ShutdownLogFn): Promise<void>;
+export declare function createShutdownResult(success: boolean, phase: RuntimeShutdownPhase, counters: ShutdownCounters, errors: readonly RuntimeShutdownErrorInfo[], startedAt: Date, completedAt: Date): RuntimeShutdownResult;
 //# sourceMappingURL=runtimeShutdown.pipeline.d.ts.map

package/dist/runtime/runtimeShutdown/pipeline/runtimeShutdown.pipeline.js

@@ -1,67 +1,101 @@
-import { RuntimeShutdownError } from "../runtimeShutdown.core.js";
-async function stopModules(errors, counters, continueOnError, moduleLifecycle, setPhase, log) {
-    setPhase("stopping");
-    log("debug", "Stopping runtime modules.");
-    try {
-        await invokeStopModules(moduleLifecycle);
-        setPhase("stopped");
-        counters.incrementStopped();
-        log("debug", "Runtime modules stopped.");
+import { RuntimeStopError } from "../../runtimeError/runtimeError.lifecycle.js";
+import { RuntimeErrorCode } from "../../runtimeError/runtimeError.type.js";
+export function createShutdownPipelineState() {
+    return {
+        counters: { stoppedModules: 0, destroyedModules: 0 },
+        errors: [],
+    };
+}
+export async function executeShutdownPipeline(options, services, state, signal, setPhase, log) {
+    const publish = (phase) => {
+        if (!signal.aborted)
+            setPhase(phase);
+    };
+    const { moduleLifecycle } = services;
+    const identity = {
+        runtimeId: services.runtimeId,
+        runtimeName: services.runtimeName,
+    };
+    if (options.stopModules) {
+        await runShutdownPhase("stopping", "stopped", () => moduleLifecycle.stop(phaseOptions(options.continueOnStopError)), moduleLifecycle, options.continueOnStopError, (count) => {
+            state.counters.stoppedModules = count;
+        }, RuntimeErrorCode.MODULE_STOP_FAILED, identity, state, publish, log);
     }
-    catch (error) {
-        errors.push({ phase: "stopping", error });
-        if (!continueOnError) {
-            throw new RuntimeShutdownError("Failed to stop runtime modules.", "MODULE_STOP_FAILED", error);
-        }
-        log("warn", "Runtime module shutdown reported an error. Continuing.", {
-            error,
-        });
+    if (options.destroyModules) {
+        await runShutdownPhase("destroying", "destroyed", () => moduleLifecycle.destroy(phaseOptions(options.continueOnDestroyError)), moduleLifecycle, options.continueOnDestroyError, (count) => {
+            state.counters.destroyedModules = count;
+        }, RuntimeErrorCode.MODULE_DESTROY_FAILED, identity, state, publish, log);
     }
 }
-async function destroyModules(errors, counters, continueOnError, moduleLifecycle, setPhase, log) {
-    setPhase("destroying");
-    log("debug", "Destroying runtime modules.");
+/**
+ * Per-phase options for the ModuleLifecycleManager: the runtime flag
+ * relaxes the manager when on and leaves its own setting when off
+ * (see the bootstrap pipeline for the rationale).
+ */
+function phaseOptions(continueOnError) {
+    return continueOnError ? { continueOnError: true } : {};
+}
+async function runShutdownPhase(phase, donePhase, run, moduleLifecycle, continueOnError, setCount, code, identity, state, publish, log) {
+    publish(phase);
+    log("debug", `Runtime modules ${phase}.`);
+    let result;
     try {
-        await invokeDestroyModules(moduleLifecycle);
-        setPhase("destroyed");
-        counters.incrementDestroyed();
-        log("debug", "Runtime modules destroyed.");
+        result = await run();
     }
     catch (error) {
-        errors.push({ phase: "destroying", error });
         if (!continueOnError) {
-            throw new RuntimeShutdownError("Failed to destroy runtime modules.", "MODULE_DESTROY_FAILED", error);
+            throw new RuntimeStopError(`Runtime module ${phase} failed.`, {
+                ...identity,
+                code,
+                phase,
+                cause: error,
+            });
         }
-        log("warn", "Runtime module destruction reported an error. Continuing.", {
+        state.errors.push({ phase, error });
+        log("warn", `Runtime module ${phase} reported an error. Continuing.`, {
             error,
         });
-    }
-}
-async function invokeStopModules(moduleLifecycle) {
-    if (typeof moduleLifecycle.stop === "function") {
-        await moduleLifecycle.stop();
         return;
     }
-    throw new RuntimeShutdownError("ModuleLifecycleManager does not expose a supported stop method.", "MODULE_STOP_METHOD_NOT_FOUND");
-}
-async function invokeDestroyModules(moduleLifecycle) {
-    if (typeof moduleLifecycle.destroy === "function") {
-        await moduleLifecycle.destroy();
-        return;
-    }
-    throw new RuntimeShutdownError("ModuleLifecycleManager does not expose a supported destroy method.", "MODULE_DESTROY_METHOD_NOT_FOUND");
-}
-export async function executeShutdownPipeline(options, errors, counters, moduleLifecycle, setPhase, log) {
-    if (options.stopModules) {
-        await stopModules(errors, counters, options.continueOnStopError, moduleLifecycle, setPhase, log);
-    }
-    if (options.destroyModules) {
-        await destroyModules(errors, counters, options.continueOnDestroyError, moduleLifecycle, setPhase, log);
+    setCount(result.completed.length);
+    for (const moduleId of result.failed) {
+        state.errors.push({
+            phase,
+            moduleName: moduleId,
+            error: moduleLifecycle.getState(moduleId)?.error ??
+                new Error(`Module "${moduleId}" failed during ${phase}.`),
+        });
     }
-    if (errors.length > 0 &&
-        !options.continueOnStopError &&
-        !options.continueOnDestroyError) {
-        throw new RuntimeShutdownError("Runtime shutdown completed with module errors.", "SHUTDOWN_MODULE_ERRORS", errors);
+    if (result.failed.length > 0) {
+        if (!continueOnError) {
+            throw new RuntimeStopError(`${result.failed.length} module(s) failed during ${phase}: ${result.failed.join(", ")}.`, {
+                ...identity,
+                code,
+                phase,
+                metadata: { modules: result.failed.join(",") },
+            });
+        }
+        log("warn", `Runtime module ${phase} completed with failures. Continuing.`, {
+            failed: [...result.failed],
+        });
     }
+    publish(donePhase);
+    log("debug", `Runtime modules ${donePhase}.`, {
+        completed: result.completed.length,
+        failed: result.failed.length,
+        skipped: result.skipped.length,
+    });
+}
+export function createShutdownResult(success, phase, counters, errors, startedAt, completedAt) {
+    return Object.freeze({
+        success,
+        phase,
+        stoppedModules: counters.stoppedModules,
+        destroyedModules: counters.destroyedModules,
+        errors: Object.freeze([...errors]),
+        startedAt,
+        completedAt,
+        durationMs: completedAt.getTime() - startedAt.getTime(),
+    });
 }
 //# sourceMappingURL=runtimeShutdown.pipeline.js.map

package/dist/runtime/runtimeShutdown/runtimeShutdown.core.d.ts

@@ -1,19 +1,12 @@
 import type { ResolvedRuntimeOptions } from "../runtimeOptions/index.js";
-import type { RuntimeShutdownDependencies, RuntimeShutdownConfig, RuntimeShutdownPhase, RuntimeShutdownResult, RuntimeShutdown, RuntimeShutdownErrorInfo } from "./runtimeShutdown.type.js";
-import { Context } from "../../context/core/context.js";
-import { RuntimeError } from "@zudojs/errors";
-export type RuntimeShutdownErrorCode = "SHUTDOWN_ALREADY_RUNNING" | "SHUTDOWN_ALREADY_COMPLETED" | "SHUTDOWN_FAILED" | "SHUTDOWN_TIMEOUT" | "SHUTDOWN_MODULE_ERRORS" | "SHUTDOWN_RESET_WHILE_RUNNING" | "MODULE_STOP_FAILED" | "MODULE_DESTROY_FAILED" | "MODULE_STOP_METHOD_NOT_FOUND" | "MODULE_DESTROY_METHOD_NOT_FOUND";
-export declare class RuntimeShutdownError extends RuntimeError {
-    readonly name = "RuntimeShutdownError";
-    readonly shutdownCode: RuntimeShutdownErrorCode;
-    constructor(message: string, code: RuntimeShutdownErrorCode, cause?: unknown);
-}
-export declare function withShutdownTimeout(operation: Promise<void>, timeoutMs: number): Promise<void>;
-export declare function createShutdownResult(success: boolean, phase: RuntimeShutdownPhase, stoppedModules: number, destroyedModules: number, errors: readonly RuntimeShutdownErrorInfo[], startedAt: Date, completedAt: Date): RuntimeShutdownResult;
+import type { RuntimeShutdownDependencies, RuntimeShutdownConfig, RuntimeShutdownPhase, RuntimeShutdownResult, RuntimeShutdown } from "./runtimeShutdown.type.js";
+/**
+ * Default shutdown service: stops and destroys modules according to
+ * the runtime's shutdown options.
+ */
 export declare class DefaultRuntimeShutdown implements RuntimeShutdown {
-    private readonly _context;
+    private readonly _identity;
     private readonly _environment;
-    private readonly _application;
     private readonly _moduleRegistry;
     private readonly _moduleLifecycle;
     private readonly _logger;
@@ -21,15 +14,14 @@ export declare class DefaultRuntimeShutdown implements RuntimeShutdown {
     private _running;
     private _phase;
     private _lastResult;
-    private _shutdownContext?;
     constructor(dependencies: RuntimeShutdownDependencies, runtimeOptions: ResolvedRuntimeOptions);
     get running(): boolean;
     get phase(): RuntimeShutdownPhase;
     shutdown(options?: RuntimeShutdownConfig): Promise<RuntimeShutdownResult>;
-    private resolveOptions;
     getLastResult(): RuntimeShutdownResult | undefined;
-    getShutdownContext(): Context | undefined;
     reset(): void;
+    private resolveOptions;
+    private errorContext;
     private log;
 }
 //# sourceMappingURL=runtimeShutdown.core.d.ts.map