@zudojs/core 0.1.0 → 1.0.0

package/dist/runtime/runtime.js

@@ -1,179 +1,409 @@
-import { RuntimeError as BaseRuntimeError, RuntimeStateError as BaseRuntimeStateError, } from "@zudojs/errors";
-/** Error thrown for invalid runtime operations. */
-export class RuntimeStateError extends BaseRuntimeStateError {
-    constructor(message) {
-        super(message);
-    }
-}
-/** Error thrown when runtime startup/shutdown fails. */
-export class RuntimeError extends BaseRuntimeError {
-    moduleIds;
-    constructor(message, moduleIds = []) {
-        super(message, { phase: "runtime" });
-        this.moduleIds = Object.freeze([...moduleIds]);
-    }
-}
+import { getDefaultContextStorage } from "../context/provider/defaultContextStorage.storage.js";
+import { RuntimeState, assertRuntimeTransition, createRuntimeStateSnapshot, isRuntimeTerminal, } from "./runtimeState.state.js";
+import { createRuntimeExecutionContext, createRuntimeIdentity, } from "./runtimeContext/index.js";
+import { createRuntimeEnvironment } from "./runtimeEnvironment/index.js";
+import { resolveRuntimeOptions } from "./runtimeOptions/index.js";
+import { DefaultRuntimeBootstrap } from "./runtimeBootstrap/runtimeBootstrap.core.js";
+import { DefaultRuntimeShutdown } from "./runtimeShutdown/runtimeShutdown.core.js";
+import { RuntimeSignalManager } from "./runtimeSignals/runtimeSignals.js";
+import { InvalidRuntimeStateError } from "./runtimeError/runtimeError.lifecycle.js";
+import { RuntimeNotReadyError } from "./runtimeError/runtimeError.specialized.js";
+import { RuntimeTimeoutError } from "./runtimeError/runtimeError.specialized.js";
 /**
  * Default runtime implementation.
- * Orchestrates Application, Configuration, Logger, ModuleRegistry,
- * ModuleLoader, ModuleLifecycleManager.
+ *
+ * Owns the runtime state machine and identity, and orchestrates the
+ * bootstrap and shutdown services, the module subsystem, and process
+ * signal handling.
  */
 export class DefaultRuntime {
-    _state = "created";
-    startedAt;
-    stoppedAt;
-    failedAt;
-    error;
-    startPromise;
-    stopPromise;
-    application;
-    configuration;
-    logger;
-    moduleRegistry;
-    moduleLoader;
-    moduleLifecycle;
-    constructor(dependencies) {
-        this.application = dependencies.application;
-        this.configuration = dependencies.configuration;
-        this.logger = dependencies.logger;
-        this.moduleRegistry = dependencies.moduleRegistry;
-        this.moduleLoader = dependencies.moduleLoader;
-        this.moduleLifecycle = dependencies.moduleLifecycle;
+    _options;
+    _identity;
+    _context;
+    _contextStorage;
+    _environment;
+    _bootstrap;
+    _shutdown;
+    _signals;
+    _application;
+    _configuration;
+    _logger;
+    _moduleRegistry;
+    _moduleLoader;
+    _moduleLifecycle;
+    _state = RuntimeState.CREATED;
+    _timing;
+    _error;
+    _startPromise;
+    _stopPromise;
+    _unwound = false;
+    constructor(dependencies, options = {}) {
+        this._options = resolveRuntimeOptions(options);
+        this._application = dependencies.application;
+        this._configuration = dependencies.configuration;
+        this._logger = dependencies.logger;
+        this._moduleRegistry = dependencies.moduleRegistry;
+        this._moduleLoader = dependencies.moduleLoader;
+        this._moduleLifecycle = dependencies.moduleLifecycle;
+        this._identity = createRuntimeIdentity({
+            name: this._options.name,
+            mode: this._options.mode,
+            role: this._options.role,
+        });
+        this._timing = Object.freeze({ createdAt: this._identity.createdAt });
+        this._contextStorage =
+            dependencies.contextStorage ?? getDefaultContextStorage();
+        this._environment =
+            dependencies.environment ??
+                createRuntimeEnvironment({
+                    mode: this._options.mode,
+                    role: this._options.role,
+                    variables: this._options.environment.variables,
+                    isCI: this._options.environment.isCI,
+                    isContainer: this._options.environment.isContainer,
+                });
+        this._context = createRuntimeExecutionContext(this._identity, this._options.metadata);
+        this._bootstrap =
+            dependencies.bootstrap ??
+                new DefaultRuntimeBootstrap({
+                    identity: this._identity,
+                    environment: this._environment,
+                    moduleLoader: this._moduleLoader,
+                    moduleRegistry: this._moduleRegistry,
+                    moduleLifecycle: this._moduleLifecycle,
+                    logger: this._logger,
+                }, this._options);
+        this._shutdown =
+            dependencies.shutdown ??
+                new DefaultRuntimeShutdown({
+                    identity: this._identity,
+                    environment: this._environment,
+                    moduleRegistry: this._moduleRegistry,
+                    moduleLifecycle: this._moduleLifecycle,
+                    logger: this._logger,
+                }, this._options);
+        this._signals = new RuntimeSignalManager({
+            signals: this._options.signals,
+            target: dependencies.signalTarget,
+            logger: this._logger,
+        });
     }
     get state() {
         return this._state;
     }
+    get context() {
+        return this._context;
+    }
+    get contextStorage() {
+        return this._contextStorage;
+    }
+    get timing() {
+        return this._timing;
+    }
+    get environment() {
+        return this._environment;
+    }
+    get identity() {
+        return this._identity;
+    }
+    get options() {
+        return this._options;
+    }
+    get ready() {
+        return this._state === RuntimeState.READY;
+    }
+    get stopped() {
+        return this._state === RuntimeState.STOPPED;
+    }
+    get failed() {
+        return this._state === RuntimeState.FAILED;
+    }
+    get signalHandlersRegistered() {
+        return this._signals.registered;
+    }
     async start() {
-        if (this._state === "ready")
+        if (this._state === RuntimeState.READY)
             return;
-        if (this.startPromise)
-            return this.startPromise;
-        if (this._state === "stopping")
-            throw new RuntimeStateError("Cannot start the runtime while it is stopping.");
-        if (this._state === "stopped")
-            throw new RuntimeStateError("A stopped runtime cannot be started again.");
-        if (this._state === "failed")
-            throw new RuntimeStateError("A failed runtime cannot be restarted.");
-        this.startPromise = this.performStart();
+        if (this._startPromise)
+            return this._startPromise;
+        if (this._state !== RuntimeState.CREATED) {
+            throw new InvalidRuntimeStateError(this._state === RuntimeState.STOPPING
+                ? "Cannot start the runtime while it is stopping."
+                : this._state === RuntimeState.STOPPED
+                    ? "A stopped runtime cannot be started again."
+                    : "A failed runtime cannot be started again.", this.errorContext({ operation: "start", state: this._state }));
+        }
+        this._startPromise = this.inContext(() => this.performStart());
         try {
-            await this.startPromise;
+            await this._startPromise;
         }
         finally {
-            this.startPromise = undefined;
+            this._startPromise = undefined;
         }
     }
     async stop() {
-        if (this._state === "stopped")
+        if (this._state === RuntimeState.STOPPED)
             return;
-        if (this.stopPromise)
-            return this.stopPromise;
-        if (this._state === "created") {
-            this._state = "stopped";
-            this.stoppedAt = new Date();
+        if (this._stopPromise)
+            return this._stopPromise;
+        if (this._state === RuntimeState.BOOTSTRAPPING && this._startPromise) {
+            // A stop requested mid-bootstrap waits for bootstrap to settle,
+            // then unwinds whatever it produced.
+            await this._startPromise.catch(() => undefined);
+            return this.stop();
+        }
+        if (this._state === RuntimeState.CREATED) {
+            this.transitionTo(RuntimeState.STOPPED, "Runtime stopped before start.");
             return;
         }
-        if (this._state === "bootstrapping")
-            throw new RuntimeStateError("Cannot stop the runtime while it is bootstrapping.");
-        if (this._state === "stopping")
+        this._stopPromise = this.inContext(() => this._state === RuntimeState.FAILED ? this.unwind() : this.performStop());
+        try {
+            await this._stopPromise;
+        }
+        finally {
+            this._stopPromise = undefined;
+        }
+    }
+    fail(error) {
+        if (isRuntimeTerminal(this._state))
             return;
-        this.stopPromise = this.performStop();
+        this._error = error;
+        this.transitionTo(RuntimeState.FAILED, "Runtime marked as failed.");
+        this._signals.unregister();
+    }
+    async dispose() {
         try {
-            await this.stopPromise;
+            await this.stop();
         }
         finally {
-            this.stopPromise = undefined;
+            this._signals.unregister();
         }
     }
     async performStart() {
-        this._state = "bootstrapping";
-        this.error = undefined;
+        this.transitionTo(RuntimeState.BOOTSTRAPPING, "Runtime startup initiated.");
+        this._error = undefined;
+        this._signals.register({
+            onSignal: (signal) => this.handleSignal(signal),
+            onUncaughtException: (error) => this.handleFatal("uncaughtException", error),
+            onUnhandledRejection: (reason) => this.handleFatal("unhandledRejection", reason),
+        });
         try {
-            this.logger.info("Starting application runtime.");
-            await this.moduleLoader.loadAll();
-            const initialization = await this.moduleLifecycle.initialize();
-            if (initialization.failed.length > 0)
-                throw new RuntimeError("One or more modules failed during initialization.", initialization.failed);
-            const startup = await this.moduleLifecycle.start();
-            if (startup.failed.length > 0)
-                throw new RuntimeError("One or more modules failed during startup.", startup.failed);
-            this.startedAt = new Date();
-            this._state = "ready";
-            this.logger.info("Application runtime is ready.");
+            const result = await this._bootstrap.bootstrap();
+            if (this._state !== RuntimeState.BOOTSTRAPPING) {
+                // fail() was called while bootstrapping: unwind what started.
+                await this.unwind();
+                throw new InvalidRuntimeStateError("Runtime was marked failed during bootstrap.", this.errorContext({ operation: "start", state: this._state }));
+            }
+            if (!result.success) {
+                this._logger.warn("Runtime became ready with module errors (continueOn*Error).", this.logContext({ errors: result.errors.length }));
+            }
+            this.transitionTo(RuntimeState.READY, "Runtime startup completed.");
         }
         catch (error) {
-            this.error = error;
-            this.failedAt = new Date();
-            this._state = "failed";
-            this.logger.error("Application runtime failed to start.", { error });
-            try {
-                await this.moduleLifecycle.stopApplication();
-            }
-            catch (cleanupError) {
-                this.logger.error("Runtime startup cleanup failed.", {
-                    error: cleanupError,
-                });
+            this.fail(error);
+            this._logger.error("Runtime failed to start.", error, this.logContext());
+            // The module subsystem has already rolled back when the module
+            // lifecycle manager threw; a timed-out bootstrap is still
+            // running and must not be unwound concurrently.
+            if (!(error instanceof RuntimeTimeoutError)) {
+                await this.unwind();
             }
             throw error;
         }
     }
     async performStop() {
-        this._state = "stopping";
+        this.transitionTo(RuntimeState.STOPPING, "Runtime shutdown initiated.");
         try {
-            this.logger.info("Stopping application runtime.");
-            await this.moduleLifecycle.stopApplication();
-            this.stoppedAt = new Date();
-            this._state = "stopped";
-            this.logger.info("Application runtime stopped.");
+            await this.runShutdown();
+            // fail() may have been called while stopping; stay FAILED.
+            if (this._state === RuntimeState.STOPPING) {
+                this.transitionTo(RuntimeState.STOPPED, "Runtime shutdown completed.");
+            }
+            else {
+                this.recordTiming({ stoppedAt: new Date() });
+            }
         }
         catch (error) {
-            this.error = error;
-            this.failedAt = new Date();
-            this._state = "failed";
-            this.logger.error("Application runtime failed to stop cleanly.", {
-                error,
-            });
+            this.fail(error);
+            this._logger.error("Runtime failed to stop cleanly.", error, this.logContext());
             throw error;
         }
+        finally {
+            this._signals.unregister();
+        }
+    }
+    /**
+     * Best-effort module unwinding used after a failure. Errors are
+     * logged and swallowed; the runtime stays FAILED.
+     */
+    async unwind() {
+        if (this._unwound)
+            return;
+        try {
+            await this.runShutdown();
+        }
+        catch (error) {
+            this._logger.error("Runtime cleanup after failure reported errors.", error, this.logContext());
+        }
+        finally {
+            this.recordTiming({ stoppedAt: this._timing.stoppedAt ?? new Date() });
+        }
+    }
+    /**
+     * Runs an operation inside the runtime's execution context so that
+     * module hooks, container factories, and loggers reached from it
+     * observe the context through `contextStorage`.
+     */
+    inContext(operation) {
+        return this._contextStorage.run(this._context, operation);
+    }
+    async runShutdown() {
+        if (this._unwound)
+            return;
+        this._unwound = true;
+        const result = await this._shutdown.shutdown();
+        if (!result.success) {
+            this._logger.warn("Runtime shutdown completed with module errors (continueOn*Error).", this.logContext({ errors: result.errors.length }));
+        }
+    }
+    /*
+     * Process-level callbacks run in whatever async context was active
+     * when the listener was registered, so the handlers re-establish
+     * the runtime context explicitly.
+     */
+    handleSignal(signal) {
+        return this.inContext(async () => {
+            this._logger.info(`Stopping runtime after ${signal}.`, this.logContext({ signal }));
+            try {
+                await this.stop();
+            }
+            catch (error) {
+                this._logger.error(`Runtime shutdown after ${signal} failed.`, error, this.logContext({ signal }));
+            }
+        });
+    }
+    handleFatal(event, error) {
+        return this.inContext(async () => {
+            this._logger.fatal(`Runtime received ${event}; marking runtime failed and stopping.`, error, this.logContext({ event }));
+            if (this._state === RuntimeState.BOOTSTRAPPING && this._startPromise) {
+                await this._startPromise.catch(() => undefined);
+            }
+            this.fail(error);
+            try {
+                await this.stop();
+            }
+            catch (stopError) {
+                this._logger.error(`Runtime shutdown after ${event} failed.`, stopError, this.logContext({ event }));
+            }
+        });
+    }
+    transitionTo(next, reason) {
+        const current = this._state;
+        assertRuntimeTransition(current, next);
+        this._state = next;
+        this.recordTimingForState(next);
+        try {
+            this._logger.debug(`Runtime state changed from "${current}" to "${next}".`, this.logContext({ from: current, to: next, reason }));
+        }
+        catch {
+            /* Logging must never prevent a lifecycle transition. */
+        }
+    }
+    recordTimingForState(state) {
+        const now = new Date();
+        const t = this._timing;
+        switch (state) {
+            case RuntimeState.BOOTSTRAPPING:
+                this.recordTiming({ startupStartedAt: t.startupStartedAt ?? now });
+                break;
+            case RuntimeState.READY:
+                this.recordTiming({ readyAt: t.readyAt ?? now });
+                break;
+            case RuntimeState.STOPPING:
+                this.recordTiming({ shutdownStartedAt: t.shutdownStartedAt ?? now });
+                break;
+            case RuntimeState.STOPPED:
+                this.recordTiming({ stoppedAt: t.stoppedAt ?? now });
+                break;
+            case RuntimeState.FAILED:
+                this.recordTiming({ failedAt: t.failedAt ?? now });
+                break;
+            default:
+                break;
+        }
+    }
+    recordTiming(update) {
+        this._timing = Object.freeze({ ...this._timing, ...update });
+    }
+    logContext(extra = {}) {
+        return {
+            runtimeId: this._identity.id,
+            runtimeName: this._identity.name,
+            ...extra,
+        };
+    }
+    errorContext(extra) {
+        return {
+            ...extra,
+            runtimeId: this._identity.id,
+            runtimeName: this._identity.name,
+        };
     }
     getStatus() {
         return Object.freeze({
             state: this._state,
-            startedAt: this.startedAt,
-            stoppedAt: this.stoppedAt,
-            failedAt: this.failedAt,
-            error: this.error,
+            startedAt: this._timing.readyAt,
+            stoppedAt: this._timing.stoppedAt,
+            failedAt: this._timing.failedAt,
+            timing: this._timing,
+            error: this._error,
+            bootstrap: this._bootstrap.getLastResult(),
+            shutdown: this._shutdown.getLastResult(),
         });
     }
+    getStateSnapshot() {
+        return createRuntimeStateSnapshot(this._state);
+    }
+    getUptime() {
+        return Date.now() - this._identity.createdAt.getTime();
+    }
     getApplicationContext() {
-        return this.application;
+        return this._application;
     }
     getConfiguration() {
-        return this.configuration;
+        return this._configuration;
     }
     getLogger() {
-        return this.logger;
+        return this._logger;
     }
     getModuleRegistry() {
-        return this.moduleRegistry;
+        return this._moduleRegistry;
     }
     getModuleLoader() {
-        return this.moduleLoader;
+        return this._moduleLoader;
     }
     getModuleLifecycle() {
-        return this.moduleLifecycle;
+        return this._moduleLifecycle;
     }
     getModule(moduleId) {
-        return this.moduleRegistry.get(moduleId)?.instance;
+        return this._moduleRegistry.get(moduleId)?.instance;
     }
     requireModule(moduleId) {
-        const module = this.getModule(moduleId);
-        if (!module)
-            throw new RuntimeError(`Module "${moduleId}" is not loaded.`, [moduleId]);
+        // Throws the module subsystem's ModuleNotFoundError when unknown.
+        const module = this._moduleRegistry.require(moduleId).instance;
+        if (!module) {
+            throw new RuntimeNotReadyError(`Module "${moduleId}" is registered but not loaded.`, this.errorContext({
+                moduleName: moduleId,
+                metadata: { state: this._state },
+            }));
+        }
         return module;
     }
 }
-/** Creates a runtime. */
-export function createRuntime(dependencies) {
-    return new DefaultRuntime(dependencies);
+/**
+ * Creates a runtime.
+ */
+export function createRuntime(dependencies, options = {}) {
+    return new DefaultRuntime(dependencies, options);
 }
 //# sourceMappingURL=runtime.js.map

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

@@ -5,6 +5,7 @@
  * and starting runtime modules.
  */
 export { DefaultRuntimeBootstrap } from "./runtimeBootstrap.core.js";
-export { RuntimeBootstrapError, withTimeout, createBootstrapResult, executeBootstrapPipeline, } from "./pipeline/index.js";
+export { executeBootstrapPipeline, createBootstrapPipelineState, createBootstrapResult, } from "./pipeline/index.js";
+export type { BootstrapCounters, BootstrapPipelineServices, BootstrapPipelineState, } from "./pipeline/index.js";
 export type { RuntimeBootstrapDependencies, RuntimeBootstrapOptions, RuntimeBootstrapPhase, RuntimeBootstrapErrorInfo, RuntimeBootstrapResult, RuntimeBootstrap, ResolvedBootstrapOptions, } from "./runtimeBootstrap.type.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/runtimeBootstrap/index.js

@@ -5,5 +5,5 @@
  * and starting runtime modules.
  */
 export { DefaultRuntimeBootstrap } from "./runtimeBootstrap.core.js";
-export { RuntimeBootstrapError, withTimeout, createBootstrapResult, executeBootstrapPipeline, } from "./pipeline/index.js";
+export { executeBootstrapPipeline, createBootstrapPipelineState, createBootstrapResult, } from "./pipeline/index.js";
 //# sourceMappingURL=index.js.map

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

@@ -3,6 +3,6 @@
  *
  * Module loading, initialization, and startup stages.
  */
-export { RuntimeBootstrapError, executeBootstrapPipeline, withTimeout, createBootstrapResult, } from "./runtimeBootstrap.pipeline.js";
-export { invokeModuleLoader, invokeInitializeModules, invokeStartModules, } from "./runtimeBootstrap.invoke.js";
+export { executeBootstrapPipeline, createBootstrapPipelineState, createBootstrapResult, } from "./runtimeBootstrap.pipeline.js";
+export type { BootstrapCounters, BootstrapLogFn, BootstrapPipelineServices, BootstrapPipelineState, } from "./runtimeBootstrap.pipeline.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -3,6 +3,5 @@
  *
  * Module loading, initialization, and startup stages.
  */
-export { RuntimeBootstrapError, executeBootstrapPipeline, withTimeout, createBootstrapResult, } from "./runtimeBootstrap.pipeline.js";
-export { invokeModuleLoader, invokeInitializeModules, invokeStartModules, } from "./runtimeBootstrap.invoke.js";
+export { executeBootstrapPipeline, createBootstrapPipelineState, createBootstrapResult, } from "./runtimeBootstrap.pipeline.js";
 //# sourceMappingURL=index.js.map

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

@@ -1,19 +1,45 @@
 import type { ModuleLoader } from "../../../modules/moduleLoader/index.js";
 import type { ModuleLifecycleManager } from "../../../modules/moduleLifecycle/index.js";
-import type { RuntimeBootstrapPhase, RuntimeBootstrapErrorInfo, ResolvedBootstrapOptions } from "../runtimeBootstrap.type.js";
-export type RuntimeBootstrapErrorCode = "BOOTSTRAP_ALREADY_RUNNING" | "BOOTSTRAP_ALREADY_COMPLETED" | "BOOTSTRAP_FAILED" | "BOOTSTRAP_TIMEOUT" | "BOOTSTRAP_MODULE_ERRORS" | "BOOTSTRAP_RESET_WHILE_RUNNING" | "MODULE_LOAD_FAILED" | "MODULE_INITIALIZATION_FAILED" | "MODULE_START_FAILED" | "MODULE_LOADER_METHOD_NOT_FOUND" | "MODULE_INITIALIZE_METHOD_NOT_FOUND" | "MODULE_START_METHOD_NOT_FOUND";
-import { RuntimeBootstrapError as BaseRuntimeBootstrapError } from "@zudojs/errors";
-export declare class RuntimeBootstrapError extends BaseRuntimeBootstrapError {
-    readonly bootstrapCode: RuntimeBootstrapErrorCode;
-    constructor(message: string, code: RuntimeBootstrapErrorCode, cause?: unknown);
+import type { RuntimeBootstrapPhase, RuntimeBootstrapErrorInfo, RuntimeBootstrapResult, ResolvedBootstrapOptions } from "../runtimeBootstrap.type.js";
+export type BootstrapLogFn = (level: "debug" | "info" | "warn" | "error", message: string, metadata?: Record<string, unknown>) => void;
+/**
+ * Module counts produced by the bootstrap pipeline.
+ */
+export interface BootstrapCounters {
+    loadedModules: number;
+    initializedModules: number;
+    startedModules: number;
 }
-type LogFn = (level: "debug" | "info" | "warn" | "error", message: string, metadata?: Record<string, unknown>) => void;
-export declare function executeBootstrapPipeline(options: ResolvedBootstrapOptions, errors: RuntimeBootstrapErrorInfo[], counters: {
-    incrementLoaded(): void;
-    incrementInitialized(): void;
-    incrementStarted(): void;
-}, moduleLoader: ModuleLoader, moduleLifecycle: ModuleLifecycleManager, setPhase: (phase: RuntimeBootstrapPhase) => void, log: LogFn): Promise<void>;
-export declare function withTimeout(operation: Promise<void>, timeoutMs: number): Promise<void>;
-export declare function createBootstrapResult(success: boolean, phase: RuntimeBootstrapPhase, loadedModules: number, initializedModules: number, startedModules: number, errors: readonly RuntimeBootstrapErrorInfo[], startedAt: Date, completedAt: Date): import("../runtimeBootstrap.type.js").RuntimeBootstrapResult;
-export {};
+/**
+ * Services the bootstrap pipeline drives.
+ */
+export interface BootstrapPipelineServices {
+    readonly moduleLoader: ModuleLoader;
+    readonly moduleLifecycle: ModuleLifecycleManager;
+    /** Identity attached to every error the pipeline raises. */
+    readonly runtimeId?: string;
+    readonly runtimeName?: string;
+}
+/**
+ * Mutable pipeline state shared with the caller so that counts and
+ * recorded errors survive a thrown failure.
+ */
+export interface BootstrapPipelineState {
+    readonly counters: BootstrapCounters;
+    readonly errors: RuntimeBootstrapErrorInfo[];
+}
+export declare function createBootstrapPipelineState(): BootstrapPipelineState;
+/**
+ * Executes the load → initialize → start pipeline.
+ *
+ * - Module-level failures reported by the ModuleLifecycleManager are
+ *   recorded once per module (with `moduleName`).
+ * - When the phase's continueOn*Error flag is false the pipeline
+ *   throws; the thrown error is NOT pushed to `errors` here — the
+ *   caller records it exactly once.
+ * - Once `signal` is aborted (timeout) the pipeline stops publishing
+ *   phase changes so an abandoned run cannot mutate the owner.
+ */
+export declare function executeBootstrapPipeline(options: ResolvedBootstrapOptions, services: BootstrapPipelineServices, state: BootstrapPipelineState, signal: AbortSignal, setPhase: (phase: RuntimeBootstrapPhase) => void, log: BootstrapLogFn): Promise<void>;
+export declare function createBootstrapResult(success: boolean, phase: RuntimeBootstrapPhase, counters: BootstrapCounters, errors: readonly RuntimeBootstrapErrorInfo[], startedAt: Date, completedAt: Date): RuntimeBootstrapResult;
 //# sourceMappingURL=runtimeBootstrap.pipeline.d.ts.map