@zudojs/runtime 1.2.0 → 1.2.1

package/dist/lifecycle/lifecycle.core.d.ts

@@ -50,6 +50,15 @@ export declare class LifecycleManager {
      * Initializes all modules in dependency order.
      */
     initialize(): Promise<LifecycleResult>;
+    /**
+     * Returns the first declared dependency of `moduleId` that is known to
+     * have failed or been skipped, or `undefined` when none has.
+     *
+     * Only direct dependencies are inspected: `blocked` already contains
+     * every module skipped by an earlier group, and groups are visited in
+     * dependency order, so the cascade is transitive.
+     */
+    private findBlockingDependency;
     /**
      * Initializes a single module, converting a throw into a failure.
      */

package/dist/lifecycle/lifecycle.core.js

@@ -116,14 +116,44 @@ export class LifecycleManager {
         const groups = this.options.parallelInitialization
             ? depGraph.parallelGroups
             : depGraph.order.map((moduleId) => [moduleId]);
+        // Ids that must not have dependents initialized on top of them:
+        // modules whose own hook threw, plus modules already skipped for the
+        // same reason, so the skip cascades transitively. `continueOnFailure`
+        // used to consult only the failure COUNT, so a dependent of a broken
+        // module was initialized, readied, and reported as started — an API
+        // serving traffic against a database that never came up.
+        const blocked = new Set();
         for (const group of groups) {
             if (this.cancellation.isCancelled) {
                 break;
             }
-            const results = await Promise.all(group.map((moduleId) => this.initializeModule(moduleId)));
+            const runnable = [];
+            for (const moduleId of group) {
+                const blocker = this.findBlockingDependency(moduleId, blocked);
+                if (blocker === undefined) {
+                    runnable.push(moduleId);
+                    continue;
+                }
+                const failure = {
+                    moduleId,
+                    phase: "initialize",
+                    error: new RuntimeStartError(`Module "${moduleId}" was not initialized because its ` +
+                        `dependency "${blocker}" failed.`, { phase: "initialize", failedModuleId: blocker }),
+                    durationMs: 0,
+                };
+                failed.push(failure);
+                blocked.add(moduleId);
+                this.logger.error(`Module "${moduleId}" was skipped because its dependency "${blocker}" failed.`);
+                this.emitModuleEvent("runtime.module.failed", moduleId, "failed", {
+                    durationMs: 0,
+                    error: failure.error,
+                });
+            }
+            const results = await Promise.all(runnable.map((moduleId) => this.initializeModule(moduleId)));
             for (const result of results) {
                 if (result.failure) {
                     failed.push(result.failure);
+                    blocked.add(result.moduleId);
                 }
                 else if (!result.abandoned) {
                     succeeded.push(result.moduleId);
@@ -140,6 +170,18 @@ export class LifecycleManager {
             durationMs: Date.now() - startTime,
         });
     }
+    /**
+     * Returns the first declared dependency of `moduleId` that is known to
+     * have failed or been skipped, or `undefined` when none has.
+     *
+     * Only direct dependencies are inspected: `blocked` already contains
+     * every module skipped by an earlier group, and groups are visited in
+     * dependency order, so the cascade is transitive.
+     */
+    findBlockingDependency(moduleId, blocked) {
+        const dependencies = this.modules.get(moduleId)?.dependencies ?? [];
+        return dependencies.find((dependency) => blocked.has(dependency));
+    }
     /**
      * Initializes a single module, converting a throw into a failure.
      */

package/dist/lifecycle/lifecycle.type.d.ts

@@ -79,6 +79,14 @@ export interface LifecycleManagerOptions {
      * closing the same resources.
      */
     readonly shutdownTimeout?: number;
+    /**
+     * Keeps initializing and starting after a module fails.
+     *
+     * Only modules INDEPENDENT of the failure continue: a module that
+     * declares a failed (or already skipped) module in `dependencies` is
+     * never initialized or readied, and is reported in `failed` with the
+     * blocking dependency named. Defaults to false.
+     */
     readonly continueOnFailure?: boolean;
     /**
      * Receives one event per module per lifecycle phase.

package/dist/registry/registry.core.js

@@ -4,6 +4,7 @@
  * Manages multiple runtime instances for scenarios where Zudojs
  * runs multiple applications or workers in a single process.
  */
+import { RuntimeStateError } from "../runtimeError/index.js";
 /**
  * Runtime registry for managing multiple runtime instances.
  *
@@ -19,7 +20,7 @@ export class RuntimeRegistry {
      */
     register(id, runtime) {
         if (this.runtimes.has(id)) {
-            throw new Error(`Runtime "${id}" is already registered.`);
+            throw new RuntimeStateError(`Runtime "${id}" is already registered.`);
         }
         this.runtimes.set(id, runtime);
     }
@@ -56,7 +57,7 @@ export class RuntimeRegistry {
     require(id) {
         const runtime = this.runtimes.get(id);
         if (!runtime) {
-            throw new Error(`Runtime "${id}" not found.`);
+            throw new RuntimeStateError(`Runtime "${id}" not found.`);
         }
         return runtime;
     }

package/dist/runtimeOptions/runtimeOptions.core.js

@@ -1,5 +1,6 @@
 import { DEFAULT_RUNTIME_OPTIONS } from "./runtimeOptions.type.js";
 import { createRuntimeId } from "../runtimeContext/runtimeContext.factory.js";
+import { RuntimeError } from "@zudojs/errors";
 /**
  * Resolves runtime options with defaults applied.
  *
@@ -24,22 +25,40 @@ export function resolveRuntimeOptions(options) {
  */
 export function validateRuntimeOptions(options) {
     if (!options.environment) {
-        throw new Error("Runtime environment is required.");
+        throw new RuntimeError("Runtime environment is required.", {
+            metadata: { option: "environment" },
+        });
     }
     if (!options.applicationName) {
-        throw new Error("Application name is required.");
+        throw new RuntimeError("Application name is required.", {
+            metadata: { option: "applicationName" },
+        });
     }
     if (options.shutdownTimeout <= 0) {
-        throw new Error("Shutdown timeout must be positive.");
+        throw new RuntimeError("Shutdown timeout must be positive.", {
+            metadata: { option: "shutdownTimeout", value: options.shutdownTimeout },
+        });
     }
     if (options.startupTimeout <= 0) {
-        throw new Error("Startup timeout must be positive.");
+        throw new RuntimeError("Startup timeout must be positive.", {
+            metadata: { option: "startupTimeout", value: options.startupTimeout },
+        });
     }
     if (!Number.isFinite(options.fatalExitTimeout) || options.fatalExitTimeout < 0) {
-        throw new Error(`Fatal exit timeout must be a finite, non-negative number, got ${options.fatalExitTimeout}.`);
+        throw new RuntimeError(`Fatal exit timeout must be a finite, non-negative number, got ${options.fatalExitTimeout}.`, {
+            metadata: {
+                option: "fatalExitTimeout",
+                value: options.fatalExitTimeout,
+            },
+        });
     }
     if (options.readinessCheckTimeout < 0) {
-        throw new Error(`Readiness check timeout must be zero or positive, got ${options.readinessCheckTimeout}. Use 0 to run checks without a bound.`);
+        throw new RuntimeError(`Readiness check timeout must be zero or positive, got ${options.readinessCheckTimeout}. Use 0 to run checks without a bound.`, {
+            metadata: {
+                option: "readinessCheckTimeout",
+                value: options.readinessCheckTimeout,
+            },
+        });
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/runtime",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Application lifecycle orchestrator with dependency ordering, rollback, signals, and readiness checks.",
   "type": "module",
   "main": "./dist/index.js",
@@ -27,12 +27,12 @@
     "vitest": "^4.1.11"
   },
   "dependencies": {
-    "@zudojs/constants": "1.1.0",
-    "@zudojs/container": "1.1.1",
-    "@zudojs/core": "1.2.0",
-    "@zudojs/errors": "1.1.0",
-    "@zudojs/events": "1.1.0",
-    "@zudojs/logger": "1.2.0"
+    "@zudojs/constants": "1.1.1",
+    "@zudojs/container": "1.1.2",
+    "@zudojs/core": "1.2.1",
+    "@zudojs/errors": "1.2.0",
+    "@zudojs/events": "1.2.0",
+    "@zudojs/logger": "1.3.0"
   },
   "license": "MIT",
   "author": {