@zudojs/core 1.0.0 → 1.1.0

package/README.md

@@ -103,7 +103,7 @@ onInitialize → onReady → onShutdown → onDestroy
 
 `createConfigurationManager({ registry, schemas, loaderOptions, validationOptions, redactorOptions })` loads registered sources by priority, deep-merges them, applies schema defaults, validates, and exposes an immutable `Configuration`.
 
-- `manager.on(event, listener)` / `manager.off(...)` receive `initializing`, `loaded`, `validated`, `ready`, `failed`, `reloading`, and `reloaded` events.
+- `manager.on(type, listener)` / `manager.off(...)` receive the `configuration.initializing`, `configuration.loaded`, `configuration.validated`, `configuration.ready`, `configuration.failed`, `configuration.reloading`, and `configuration.reloaded` events (`"*"` subscribes to all of them).
 - `manager.getSection(name)` returns a scoped configuration for a registered section; `manager.reload()` keeps programmatic defaults and serialises overlapping reloads.
 - Values are deep-frozen; `toObject()` returns an independent deep copy. Path lookups never walk the prototype chain, and `getNumber` accepts only plain decimal numbers.
 - Secrets never reach errors or logs: validation, load, and source errors pass through the redactor, which matches whole key words (`password`, `secret`, `token`, `pwd`, `passphrase`, `auth`, `dsn`, `credential`, ...).
@@ -120,7 +120,7 @@ onInitialize → onReady → onShutdown → onDestroy
 
 ## Execution context
 
-There is one execution-context model: the immutable `ExecutionContext` (`createExecutionContext`, `deriveExecutionContext`, `withExecutionMetadata`) propagated by `ContextStorage`, which wraps `AsyncLocalStorage`. `run(context, fn)` and `runDerived(overrides, fn)` establish a context for the callback and everything it awaits, `runWithValues(values, fn)` adds request-scoped values, and `capture()` / `runSnapshot(snapshot, fn)` carry a context across queue or timer boundaries. `getDefaultContextStorage()` is the process-wide instance every component uses unless another is injected.
+There is one execution-context model: the immutable `ExecutionContext` (`createExecutionContext`, `deriveExecutionContext`, `withExecutionMetadata`) propagated by `ContextStorage`, which wraps `AsyncLocalStorage`. `run(context, fn)` and `runDerived(overrides, fn)` establish a context for the callback and everything it awaits, `runWithValues(context, values, fn)` additionally binds a `ContextValues` collection (read back with `getValues()`), and `capture()` / `runSnapshot(snapshot, fn)` carry a context across queue or timer boundaries. `getDefaultContextStorage()` is the process-wide instance every component uses unless another is injected.
 
 Propagation is real at runtime:
 

package/dist/application/applicationContext.context.d.ts

@@ -5,7 +5,14 @@ import type { Logger } from "../logging/core/logger.js";
 import type { ContextStorage } from "../context/provider/contextStorage.storage.js";
 export interface ApplicationContextOptions {
     readonly container: Container;
-    readonly configuration: Configuration;
+    /**
+     * The application configuration, or a function returning the
+     * current one. Pass a function (for example
+     * `() => manager.getConfiguration()`) so that
+     * `getConfiguration()` reflects configuration reloads instead of
+     * the snapshot taken when the context was created.
+     */
+    readonly configuration: Configuration | (() => Configuration);
     readonly modules: ModuleRegistry;
     readonly logger: Logger;
     /**
@@ -34,6 +41,10 @@ export declare class ApplicationContext {
     getContainer(): Container;
     /**
      * Application configuration.
+     *
+     * When the context was created with a configuration accessor
+     * (as `createApplication` does), this returns the configuration
+     * manager's current configuration, including reloads.
      */
     getConfiguration(): Configuration;
     /**

package/dist/application/applicationContext.context.js

@@ -13,7 +13,11 @@ export class ApplicationContext {
     contextStorage;
     constructor(options) {
         this.container = options.container;
-        this.configuration = options.configuration;
+        const configuration = options.configuration;
+        this.configuration =
+            typeof configuration === "function"
+                ? configuration
+                : () => configuration;
         this.modules = options.modules;
         this.logger = options.logger;
         this.contextStorage = options.contextStorage ?? getDefaultContextStorage();
@@ -26,9 +30,13 @@ export class ApplicationContext {
     }
     /**
      * Application configuration.
+     *
+     * When the context was created with a configuration accessor
+     * (as `createApplication` does), this returns the configuration
+     * manager's current configuration, including reloads.
      */
     getConfiguration() {
-        return this.configuration;
+        return this.configuration();
     }
     /**
      * Registered application modules.

package/dist/application/createApplication.js

@@ -44,7 +44,12 @@ export async function createApplication(options = {}) {
     }
     const context = new ApplicationContext({
         container,
-        configuration: configuration.getConfiguration(),
+        /*
+         * An accessor rather than a snapshot: after
+         * `configuration.reload()` the application context must hand
+         * out the reloaded configuration, not the one captured here.
+         */
+        configuration: () => configuration.getConfiguration(),
         modules: moduleRegistry,
         logger,
         contextStorage,

package/dist/configuration/configurationManager.manager.d.ts

@@ -53,6 +53,7 @@ export declare class ConfigurationManager {
     private loadResult;
     private validationReport;
     private missingSetConfigurationWarned;
+    private inFlightReload;
     private stateValue;
     constructor(options?: ConfigurationManagerOptions);
     /**
@@ -72,7 +73,16 @@ export declare class ConfigurationManager {
      */
     getListenerErrors(): readonly unknown[];
     initialize(): Promise<ConfigurationManagerResult>;
+    /**
+     * Reloads configuration from the registered sources.
+     *
+     * Overlapping calls are serialised: a reload requested while one
+     * is already in progress shares that in-flight reload instead of
+     * failing with InvalidStateError. A manager that is not ready yet
+     * is initialized instead.
+     */
     reload(): Promise<ConfigurationManagerResult>;
+    private performReload;
     getConfiguration(): Configuration;
     getProvider(): ConfigurationProvider;
     getRegistry(): ConfigurationRegistry;

package/dist/configuration/configurationManager.manager.js

@@ -31,6 +31,7 @@ export class ConfigurationManager {
     loadResult;
     validationReport;
     missingSetConfigurationWarned = false;
+    inFlightReload;
     stateValue = ConfigurationManagerState.CREATED;
     constructor(options = {}) {
         this.loader =
@@ -104,9 +105,26 @@ export class ConfigurationManager {
             throw error;
         }
     }
+    /**
+     * Reloads configuration from the registered sources.
+     *
+     * Overlapping calls are serialised: a reload requested while one
+     * is already in progress shares that in-flight reload instead of
+     * failing with InvalidStateError. A manager that is not ready yet
+     * is initialized instead.
+     */
     async reload() {
+        if (this.inFlightReload)
+            return this.inFlightReload;
         if (this.stateValue !== ConfigurationManagerState.READY)
             return this.initialize();
+        const reload = this.performReload().finally(() => {
+            this.inFlightReload = undefined;
+        });
+        this.inFlightReload = reload;
+        return reload;
+    }
+    async performReload() {
         const previousConfiguration = this.configuration;
         const previousLoadResult = this.loadResult;
         const previousValidation = this.validationReport;

package/dist/container/container.d.ts

@@ -26,7 +26,6 @@ export interface ContainerOptions {
  */
 export declare class Container {
     private readonly providers;
-    private readonly scopedInstances;
     private readonly currentScope;
     private readonly resolving;
     private activeScope;

package/dist/container/container.js

@@ -8,7 +8,6 @@ import { ProviderNotFoundError, ProviderAlreadyRegisteredError, InvalidProviderE
  */
 export class Container {
     providers = new Map();
-    scopedInstances = new WeakMap();
     currentScope;
     resolving = [];
     activeScope;
@@ -29,6 +28,7 @@ export class Container {
             provider: provider,
             scope,
             resolved: false,
+            scopedInstances: new WeakMap(),
         });
     }
     /**
@@ -81,9 +81,8 @@ export class Container {
             return registration.instance;
         }
         if (registration.scope === "scoped" && scopeKey) {
-            const cache = this.scopedInstances.get(scopeKey);
-            if (cache?.has(token)) {
-                return cache.get(token);
+            if (registration.scopedInstances.has(scopeKey)) {
+                return registration.scopedInstances.get(scopeKey);
             }
         }
         const instance = this.createInstance(token, registration, scopeKey);
@@ -92,12 +91,7 @@ export class Container {
             registration.resolved = true;
         }
         else if (registration.scope === "scoped" && scopeKey) {
-            let cache = this.scopedInstances.get(scopeKey);
-            if (!cache) {
-                cache = new Map();
-                this.scopedInstances.set(scopeKey, cache);
-            }
-            cache.set(token, instance);
+            registration.scopedInstances.set(scopeKey, instance);
         }
         return instance;
     }

package/dist/logging/core/logEntry.entry.js

@@ -123,7 +123,18 @@ export function sanitizeLogValue(value, seen = new WeakSet(), depth = 0) {
         }
         const result = {};
         for (const [key, item] of Object.entries(objectValue)) {
-            result[key] = sanitizeLogValue(item, seen, depth + 1);
+            /*
+             * Assigning result["__proto__"] would replace the prototype
+             * (and drop the value from serialized output) instead of
+             * storing the key, so own "__proto__" keys — as produced by
+             * JSON.parse on untrusted input — are defined explicitly.
+             */
+            Object.defineProperty(result, key, {
+                value: sanitizeLogValue(item, seen, depth + 1),
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
         }
         return result;
     }

package/dist/modules/moduleLifecycle/index.d.ts

@@ -8,6 +8,6 @@
  * state maps) is internal to this subsystem and intentionally
  * not exported from this barrel.
  */
-export { type ModuleLifecyclePhase, type ModuleLifecycleState, type ModuleLifecycleHookName, type ModuleLifecycleStep, type ModuleLifecycleHooks, type ModuleLifecycleOptions, ModuleLifecycleError, type ModuleLifecycleResult, type ModuleLifecycleSkip, } from "./moduleLifecycle.type.js";
+export { type ModuleLifecyclePhase, type ModuleLifecycleState, type ModuleLifecycleHookName, type ModuleLifecycleStep, type ModuleLifecycleHooks, type ModuleLifecycleOptions, type ModuleLifecyclePhaseOptions, ModuleLifecycleError, type ModuleLifecycleResult, type ModuleLifecycleSkip, } from "./moduleLifecycle.type.js";
 export { ModuleLifecycleManager, createModuleLifecycleManager, } from "./moduleLifecycle.lifecycle.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/modules/moduleLifecycle/moduleLifecycle.lifecycle.d.ts

@@ -2,7 +2,8 @@ import type { Module, ModuleId } from "../module.js";
 import type { ModuleDefinition } from "../moduleDefinition.definition.js";
 import type { ModuleRegistration, ModuleRegistry } from "../moduleRegistry/index.js";
 import type { ModuleLoader } from "../moduleLoader/index.js";
-import type { ModuleLifecycleOptions, ModuleLifecycleResult, ModuleLifecycleState } from "./moduleLifecycle.type.js";
+import type { ModuleLifecycleOptions, ModuleLifecyclePhaseOptions, ModuleLifecycleResult, ModuleLifecycleState } from "./moduleLifecycle.type.js";
+import type { ModuleDependency } from "../moduleDependency/moduleDependency.type.js";
 /**
  * Module lifecycle manager.
  * Initializes, starts, stops, and destroys modules in dependency order.
@@ -15,10 +16,10 @@ export declare class ModuleLifecycleManager {
     private readonly states;
     private operation;
     constructor(registry: ModuleRegistry, loader: ModuleLoader, options?: ModuleLifecycleOptions);
-    initialize(): Promise<ModuleLifecycleResult>;
-    start(): Promise<ModuleLifecycleResult>;
-    stop(): Promise<ModuleLifecycleResult>;
-    destroy(): Promise<ModuleLifecycleResult>;
+    initialize(options?: ModuleLifecyclePhaseOptions): Promise<ModuleLifecycleResult>;
+    start(options?: ModuleLifecyclePhaseOptions): Promise<ModuleLifecycleResult>;
+    stop(options?: ModuleLifecyclePhaseOptions): Promise<ModuleLifecycleResult>;
+    destroy(options?: ModuleLifecyclePhaseOptions): Promise<ModuleLifecycleResult>;
     /**
      * Rolls back modules that completed earlier phases after a
      * startup failure.
@@ -55,6 +56,14 @@ export declare class ModuleLifecycleManager {
      * optional dependency on the given module.
      */
     private getLoadedDependents;
+    /**
+     * Dependencies of a registered module: those declared on the
+     * definition plus any the loaded instance declares itself
+     * (`Module.dependencies`, e.g. via the BaseModule constructor).
+     * Instance-declared dependencies are required; a definition
+     * entry for the same id wins so optional/version flags survive.
+     */
+    private resolveDependencies;
     startApplication(): Promise<{
         readonly initialized: ModuleLifecycleResult;
         readonly started: ModuleLifecycleResult;
@@ -69,11 +78,27 @@ export declare class ModuleLifecycleManager {
     isInitialized(moduleId: ModuleId): boolean;
     isStarted(moduleId: ModuleId): boolean;
     isDestroyed(moduleId: ModuleId): boolean;
+    /**
+     * Builds the dependency graph over the loaded modules only.
+     *
+     * Lifecycle phases run for loaded modules, so a registered but
+     * unloaded definition (autoLoad: false) must not be able to
+     * break them with a missing or circular dependency of its own.
+     * Dependencies of a loaded module that are not loaded are kept
+     * as edges so the ordering reports them as missing.
+     */
     private createGraph;
     private getStartupOrder;
     private getShutdownOrder;
     private runExclusive;
 }
+/**
+ * Resolves the dependencies of a registration: definition-declared
+ * dependencies plus the ids the loaded instance declares through
+ * `Module.dependencies`. Shared by the lifecycle manager and the
+ * loader so both agree on the graph.
+ */
+export declare function resolveRegistrationDependencies(registry: ModuleRegistry, registration: ModuleRegistration): readonly ModuleDependency[];
 /** Creates a module lifecycle manager. */
 export declare function createModuleLifecycleManager(registry: ModuleRegistry, loader: ModuleLoader, options?: ModuleLifecycleOptions): ModuleLifecycleManager;
 //# sourceMappingURL=moduleLifecycle.lifecycle.d.ts.map

package/dist/modules/moduleLifecycle/moduleLifecycle.lifecycle.js

@@ -25,11 +25,11 @@ export class ModuleLifecycleManager {
         };
         this.contextStorage = options.contextStorage ?? getDefaultContextStorage();
     }
-    async initialize() {
+    async initialize(options = {}) {
         return this.runExclusive(async () => {
             ensureStateSynchronized(this.registry, this.states);
             try {
-                return await executeLifecyclePhase(this.getStartupOrder(), "initialize", "initializing", "initialized", this.options.continueOnInitializeError, this.registry, this.loader, this.states, this.contextStorage);
+                return await executeLifecyclePhase(this.getStartupOrder(), "initialize", "initializing", "initialized", options.continueOnError ?? this.options.continueOnInitializeError, this.registry, this.loader, this.states, this.contextStorage);
             }
             catch (error) {
                 await this.rollbackAfterFailure(error, { stopFirst: false });
@@ -37,11 +37,11 @@ export class ModuleLifecycleManager {
             }
         });
     }
-    async start() {
+    async start(options = {}) {
         return this.runExclusive(async () => {
             ensureStateSynchronized(this.registry, this.states);
             try {
-                return await executeLifecyclePhase(this.getStartupOrder(), "start", "starting", "started", this.options.continueOnStartError, this.registry, this.loader, this.states, this.contextStorage);
+                return await executeLifecyclePhase(this.getStartupOrder(), "start", "starting", "started", options.continueOnError ?? this.options.continueOnStartError, this.registry, this.loader, this.states, this.contextStorage);
             }
             catch (error) {
                 await this.rollbackAfterFailure(error, { stopFirst: true });
@@ -49,16 +49,16 @@ export class ModuleLifecycleManager {
             }
         });
     }
-    async stop() {
+    async stop(options = {}) {
         return this.runExclusive(async () => {
             ensureStateSynchronized(this.registry, this.states);
-            return executeLifecyclePhase(this.getShutdownOrder(), "stop", "stopping", "stopped", this.options.continueOnStopError, this.registry, this.loader, this.states, this.contextStorage);
+            return executeLifecyclePhase(this.getShutdownOrder(), "stop", "stopping", "stopped", options.continueOnError ?? this.options.continueOnStopError, this.registry, this.loader, this.states, this.contextStorage);
         });
     }
-    async destroy() {
+    async destroy(options = {}) {
         return this.runExclusive(async () => {
             ensureStateSynchronized(this.registry, this.states);
-            return executeLifecyclePhase(this.getShutdownOrder(), "destroy", "destroying", "destroyed", this.options.continueOnDestroyError, this.registry, this.loader, this.states, this.contextStorage);
+            return executeLifecyclePhase(this.getShutdownOrder(), "destroy", "destroying", "destroyed", options.continueOnError ?? this.options.continueOnDestroyError, this.registry, this.loader, this.states, this.contextStorage);
         });
     }
     /**
@@ -178,14 +178,22 @@ export class ModuleLifecycleManager {
                 continue;
             if (registration.state !== "loaded")
                 continue;
-            const dependsOnModule = this.registry
-                .getDependencies(registration.definition.id)
-                .some((dependency) => dependency.id === moduleId);
+            const dependsOnModule = this.resolveDependencies(registration).some((dependency) => dependency.id === moduleId);
             if (dependsOnModule)
                 dependents.push(registration.definition.id);
         }
         return dependents;
     }
+    /**
+     * Dependencies of a registered module: those declared on the
+     * definition plus any the loaded instance declares itself
+     * (`Module.dependencies`, e.g. via the BaseModule constructor).
+     * Instance-declared dependencies are required; a definition
+     * entry for the same id wins so optional/version flags survive.
+     */
+    resolveDependencies(registration) {
+        return resolveRegistrationDependencies(this.registry, registration);
+    }
     async startApplication() {
         /*
          * When continueOn*Error is disabled, phase failures are
@@ -220,21 +228,31 @@ export class ModuleLifecycleManager {
     isDestroyed(moduleId) {
         return isModuleDestroyed(moduleId, this.states);
     }
+    /**
+     * Builds the dependency graph over the loaded modules only.
+     *
+     * Lifecycle phases run for loaded modules, so a registered but
+     * unloaded definition (autoLoad: false) must not be able to
+     * break them with a missing or circular dependency of its own.
+     * Dependencies of a loaded module that are not loaded are kept
+     * as edges so the ordering reports them as missing.
+     */
     createGraph() {
-        const nodes = this.registry.getAll().map((r) => ({
+        const nodes = this.registry
+            .getAll()
+            .filter((r) => r.state === "loaded")
+            .map((r) => ({
             id: r.definition.id,
-            dependencies: this.registry.getDependencies(r.definition.id),
+            dependencies: this.resolveDependencies(r),
             version: r.definition.version,
         }));
         return createModuleDependencyGraph(nodes);
     }
     getStartupOrder() {
-        const order = resolveModuleStartupOrder(this.createGraph());
-        return Object.freeze(order.filter((id) => this.registry.get(id)?.state === "loaded"));
+        return resolveModuleStartupOrder(this.createGraph());
     }
     getShutdownOrder() {
-        const order = resolveModuleShutdownOrder(this.createGraph());
-        return Object.freeze(order.filter((id) => this.registry.get(id)?.state === "loaded"));
+        return resolveModuleShutdownOrder(this.createGraph());
     }
     async runExclusive(operation) {
         while (this.operation)
@@ -253,6 +271,29 @@ export class ModuleLifecycleManager {
         }
     }
 }
+/**
+ * Resolves the dependencies of a registration: definition-declared
+ * dependencies plus the ids the loaded instance declares through
+ * `Module.dependencies`. Shared by the lifecycle manager and the
+ * loader so both agree on the graph.
+ */
+export function resolveRegistrationDependencies(registry, registration) {
+    const declared = registry.getDependencies(registration.definition.id);
+    const instanceDependencies = registration.instance?.dependencies ?? [];
+    if (instanceDependencies.length === 0)
+        return declared;
+    const seen = new Set(declared.map((dependency) => dependency.id));
+    const merged = [...declared];
+    for (const id of instanceDependencies) {
+        if (typeof id !== "string" || id.length === 0 || seen.has(id))
+            continue;
+        if (id === registration.definition.id)
+            continue;
+        seen.add(id);
+        merged.push(Object.freeze({ id, optional: false }));
+    }
+    return Object.freeze(merged);
+}
 /** Creates a module lifecycle manager. */
 export function createModuleLifecycleManager(registry, loader, options = {}) {
     return new ModuleLifecycleManager(registry, loader, options);

package/dist/modules/moduleLifecycle/moduleLifecycle.type.d.ts

@@ -86,6 +86,19 @@ export interface ModuleLifecycleOptions {
      */
     readonly contextStorage?: ContextStorage;
 }
+/**
+ * Per-call overrides accepted by the ModuleLifecycleManager phase
+ * methods (initialize/start/stop/destroy).
+ */
+export interface ModuleLifecyclePhaseOptions {
+    /**
+     * Overrides the manager's continueOn*Error setting for this one
+     * phase run. The runtime passes its own startup/shutdown flags
+     * here so a hand-assembled manager cannot disagree with the
+     * runtime that drives it.
+     */
+    readonly continueOnError?: boolean;
+}
 import { ModuleOperationError } from "../moduleError/moduleError.lifecycle.js";
 /**
  * Error thrown when a module lifecycle operation fails.

package/dist/modules/moduleLoader/moduleLoader.loader.js

@@ -76,6 +76,56 @@ export class ModuleLoader {
      */
     async loadClosure(requested, options) {
         const closure = this.collectClosure(requested);
+        const loaded = [];
+        const alreadyLoaded = [];
+        const order = [];
+        /*
+         * Instances may declare dependencies of their own
+         * (Module.dependencies) that the definition does not list.
+         * Those are only known after instantiation, so the closure is
+         * extended and loaded in rounds until nothing new appears.
+         */
+        let pending = new Set(closure.keys());
+        while (pending.size > 0) {
+            const graph = this.createGraph([...closure.values()]);
+            const roundOrder = resolveModuleStartupOrder(graph).filter((id) => pending.has(id));
+            const discovered = [];
+            for (const moduleId of roundOrder) {
+                const registration = this.registry.get(moduleId);
+                if (!registration)
+                    throw new ModuleLoadError(moduleId, new Error(`Module "${moduleId}" disappeared from the registry during loading.`));
+                order.push(moduleId);
+                let instance;
+                if (registration.state === "loaded" && registration.instance) {
+                    instance = registration.instance;
+                    alreadyLoaded.push(instance);
+                }
+                else {
+                    instance = await this.instantiate(registration.definition);
+                    loaded.push(instance);
+                }
+                for (const dependencyId of instance.dependencies ?? []) {
+                    if (closure.has(dependencyId))
+                        continue;
+                    if (!this.registry.has(dependencyId))
+                        throw new MissingModuleDependencyError(moduleId, dependencyId);
+                    discovered.push(dependencyId);
+                }
+            }
+            const extra = this.collectClosure(discovered);
+            pending = new Set();
+            for (const [id, definition] of extra) {
+                if (closure.has(id))
+                    continue;
+                closure.set(id, definition);
+                pending.add(id);
+            }
+        }
+        /*
+         * Skipped modules are determined after loading so that an
+         * autoLoad:false module pulled in by an instance-declared
+         * dependency is reported as loaded, not skipped.
+         */
         const skipped = [];
         if (options.reportSkipped) {
             for (const definition of this.registry.getDefinitions()) {
@@ -84,28 +134,6 @@ export class ModuleLoader {
                 }
             }
         }
-        if (closure.size === 0)
-            return {
-                loaded: [],
-                alreadyLoaded: [],
-                skipped: Object.freeze([...skipped]),
-                order: [],
-            };
-        const graph = this.createGraph([...closure.values()]);
-        const order = resolveModuleStartupOrder(graph);
-        const loaded = [];
-        const alreadyLoaded = [];
-        for (const moduleId of order) {
-            const registration = this.registry.get(moduleId);
-            if (!registration)
-                throw new ModuleLoadError(moduleId, new Error(`Module "${moduleId}" disappeared from the registry during loading.`));
-            if (registration.state === "loaded" && registration.instance) {
-                alreadyLoaded.push(registration.instance);
-                continue;
-            }
-            const instance = await this.instantiate(registration.definition);
-            loaded.push(instance);
-        }
         return {
             loaded: Object.freeze([...loaded]),
             alreadyLoaded: Object.freeze([...alreadyLoaded]),
@@ -174,9 +202,17 @@ export class ModuleLoader {
                  * they cannot enumerate or reach undeclared modules.
                  */
                 moduleContexts: (dependencyId) => this.contexts.get(dependencyId),
-                declaredDependencies: this.registry
-                    .getDependencies(moduleId)
-                    .map((dependency) => dependency.id),
+                /*
+                 * Dependencies declared by the instance itself
+                 * (Module.dependencies) are honoured alongside the
+                 * definition's, matching the lifecycle ordering.
+                 */
+                declaredDependencies: [
+                    ...this.registry
+                        .getDependencies(moduleId)
+                        .map((dependency) => dependency.id),
+                    ...(module.dependencies ?? []),
+                ],
             });
             this.contexts.set(moduleId, context);
             this.registry.setState(moduleId, "loaded", { instance: module });

package/dist/runtime/runtimeBootstrap/pipeline/runtimeBootstrap.pipeline.js

@@ -30,12 +30,12 @@ export async function executeBootstrapPipeline(options, services, state, signal,
         await loadModules(services.moduleLoader, identity, state, publish, log);
     }
     if (options.initializeModules) {
-        await runLifecyclePhase("initializing", "initialized", () => services.moduleLifecycle.initialize(), services.moduleLifecycle, options.continueOnInitializeError, (count) => {
+        await runLifecyclePhase("initializing", "initialized", () => services.moduleLifecycle.initialize(phaseOptions(options.continueOnInitializeError)), services.moduleLifecycle, options.continueOnInitializeError, (count) => {
             state.counters.initializedModules = count;
         }, (message, opts) => new RuntimeInitializationError(message, { ...identity, ...opts }), state, publish, log);
     }
     if (options.startModules) {
-        await runLifecyclePhase("starting", "started", () => services.moduleLifecycle.start(), services.moduleLifecycle, options.continueOnStartError, (count) => {
+        await runLifecyclePhase("starting", "started", () => services.moduleLifecycle.start(phaseOptions(options.continueOnStartError)), services.moduleLifecycle, options.continueOnStartError, (count) => {
             state.counters.startedModules = count;
         }, (message, opts) => new RuntimeStartError(message, {
             ...identity,
@@ -44,6 +44,19 @@ export async function executeBootstrapPipeline(options, services, state, signal,
         }), state, publish, log);
     }
 }
+/**
+ * Per-phase options handed to the ModuleLifecycleManager.
+ *
+ * The runtime's continueOn*Error flag can only relax the manager: when
+ * it is on, the manager must keep going too (otherwise it would roll
+ * every module back and throw, and the runtime would report READY
+ * with nothing running). When it is off the manager keeps its own
+ * setting; a permissive manager then returns the failures and the
+ * runtime throws and unwinds.
+ */
+function phaseOptions(continueOnError) {
+    return continueOnError ? { continueOnError: true } : {};
+}
 async function loadModules(moduleLoader, identity, state, publish, log) {
     publish("loading");
     log("debug", "Loading runtime modules.");

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");

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

@@ -17,16 +17,24 @@ export async function executeShutdownPipeline(options, services, state, signal,
         runtimeName: services.runtimeName,
     };
     if (options.stopModules) {
-        await runShutdownPhase("stopping", "stopped", () => moduleLifecycle.stop(), moduleLifecycle, options.continueOnStopError, (count) => {
+        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);
     }
     if (options.destroyModules) {
-        await runShutdownPhase("destroying", "destroyed", () => moduleLifecycle.destroy(), moduleLifecycle, options.continueOnDestroyError, (count) => {
+        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);
     }
 }
+/**
+ * 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}.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/core",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Application lifecycle management, execution context propagation, and runtime orchestration for Zudojs applications.",
   "type": "module",
   "main": "./dist/index.js",
@@ -55,10 +55,14 @@
     "vitest": "^4.1.11"
   },
   "dependencies": {
-    "@zudojs/errors": "1.0.0",
-    "@zudojs/constants": "1.0.0"
+    "@zudojs/errors": "1.0.1",
+    "@zudojs/constants": "1.0.1"
   },
   "license": "MIT",
+  "author": {
+    "name": "Oluwayemi Oyinlola",
+    "url": "https://github.com/oyinlola-tech"
+  },
   "publishConfig": {
     "access": "public"
   },