@zudojs/core 0.0.1 → 1.0.0

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

@@ -1,11 +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 { RuntimeState } from "../runtimeState.state.js";
-import type { RuntimeStateSnapshot } from "../runtimeState.state.js";
+import type { ExecutionContext } from "../../context/core/executionContext.context.js";
 import type { RuntimeMode, RuntimeRole } from "../runtimeOptions/index.js";
 /**
  * Runtime identity.
@@ -19,50 +12,46 @@ export interface RuntimeIdentity {
     readonly processId?: number;
 }
 /**
- * Runtime timing information.
+ * Metadata carried by a runtime's execution context.
+ *
+ * The identity fields are always present; `RuntimeOptions.metadata`
+ * is merged in (identity fields cannot be overridden) so
+ * user-supplied values are reachable as `context.metadata[key]`.
  */
-export interface RuntimeTiming {
-    readonly createdAt: Date;
-    readonly startupStartedAt?: Date;
-    readonly readyAt?: Date;
-    readonly shutdownStartedAt?: Date;
-    readonly stoppedAt?: Date;
-}
-/**
- * Runtime context dependencies.
- */
-export interface RuntimeContextDependencies {
-    readonly application: ApplicationContext;
-    readonly configuration: ConfigurationManager;
-    readonly logger: Logger;
-    readonly moduleRegistry: ModuleRegistry;
-    readonly moduleLoader: ModuleLoader;
-    readonly moduleLifecycle: ModuleLifecycleManager;
+export interface RuntimeExecutionMetadata {
+    readonly runtimeId: string;
+    readonly runtimeName: string;
+    readonly runtimeMode: RuntimeMode;
+    readonly runtimeRole: RuntimeRole;
+    readonly processId?: number;
+    readonly [key: string]: unknown;
 }
 /**
- * Runtime context contract.
+ * The execution context of a runtime.
+ *
+ * A runtime is single-use, so its whole lifetime is one execution:
+ * `executionId` is the runtime id, `service` is the runtime name,
+ * `startedAt` is the runtime's creation time, and `transport` /
+ * `operation` are `"runtime"`. The runtime establishes this context
+ * (via its ContextStorage) around bootstrap, shutdown, every module
+ * lifecycle hook, and application start/stop, so
+ * `contextStorage.get()` inside those returns it or a context
+ * derived from it.
+ *
+ * It is immutable. Mutable runtime state (state, timing, failure)
+ * lives on the Runtime object.
  */
-export interface RuntimeContext {
-    readonly identity: RuntimeIdentity;
-    readonly state: RuntimeState;
-    readonly timing: RuntimeTiming;
-    readonly metadata: Readonly<Record<string, unknown>>;
-    readonly application: ApplicationContext;
-    readonly configuration: ConfigurationManager;
-    readonly logger: Logger;
-    readonly moduleRegistry: ModuleRegistry;
-    readonly moduleLoader: ModuleLoader;
-    readonly moduleLifecycle: ModuleLifecycleManager;
-    getStateSnapshot(): RuntimeStateSnapshot;
-    get<T = unknown>(key: string): T | undefined;
-    has(key: string): boolean;
-    getUptime(): number;
+export interface RuntimeExecutionContext extends ExecutionContext {
+    readonly service: string;
+    readonly transport: "runtime";
+    readonly operation: "runtime";
+    readonly metadata: RuntimeExecutionMetadata;
 }
 /**
- * Internal mutable state used by RuntimeContext.
+ * @deprecated Use RuntimeExecutionContext. The former mutable
+ * runtime context (state, timing, service references) no longer
+ * exists: state and timing live on the Runtime, and services are
+ * reached through the Runtime accessors.
  */
-export interface RuntimeContextState {
-    state: RuntimeState;
-    timing: RuntimeTiming;
-}
+export type RuntimeContext = RuntimeExecutionContext;
 //# sourceMappingURL=runtimeContext.type.d.ts.map

package/dist/runtime/runtimeEnvironment/detection/runtimeEnvironment.env.d.ts

@@ -1,4 +1,9 @@
 import type { RuntimeEnvironmentVariables } from "../runtimeEnvironment.type.js";
 export declare function detectCI(variables: RuntimeEnvironmentVariables): boolean;
+/**
+ * Detects a container environment from the supplied variable
+ * snapshot only, so callers that inject variables get deterministic
+ * results.
+ */
 export declare function detectContainer(variables: RuntimeEnvironmentVariables): boolean;
 //# sourceMappingURL=runtimeEnvironment.env.d.ts.map

package/dist/runtime/runtimeEnvironment/detection/runtimeEnvironment.env.js

@@ -1,4 +1,3 @@
-import { getProcessObject } from "./runtimeEnvironment.detection.js";
 export function detectCI(variables) {
     const explicit = variables.CI ?? variables.CONTINUOUS_INTEGRATION;
     if (isTruthyEnvironmentValue(explicit)) {
@@ -21,6 +20,11 @@ export function detectCI(variables) {
     }
     return false;
 }
+/**
+ * Detects a container environment from the supplied variable
+ * snapshot only, so callers that inject variables get deterministic
+ * results.
+ */
 export function detectContainer(variables) {
     if (isTruthyEnvironmentValue(variables.CONTAINER)) {
         return true;
@@ -31,9 +35,7 @@ export function detectContainer(variables) {
     if (variables.KUBERNETES_SERVICE_HOST) {
         return true;
     }
-    const processObject = getProcessObject();
-    const release = processObject?.env?.container;
-    if (release) {
+    if (variables.container) {
         return true;
     }
     return false;

package/dist/runtime/runtimeEnvironment/detection/runtimeEnvironment.os.d.ts

@@ -1,4 +1,8 @@
 import type { RuntimeOS } from "../runtimeEnvironment.type.js";
+/**
+ * Returns the Node `os` module when running on a Node-compatible
+ * engine, or undefined on engines without a process object.
+ */
 export declare function getNodeOsObject(): RuntimeOS | undefined;
 export declare function safeCall<T>(fn: (() => T) | undefined): T | undefined;
 //# sourceMappingURL=runtimeEnvironment.os.d.ts.map

package/dist/runtime/runtimeEnvironment/detection/runtimeEnvironment.os.js

@@ -1,16 +1,14 @@
+import * as os from "node:os";
 import { getProcessObject } from "./runtimeEnvironment.detection.js";
+/**
+ * Returns the Node `os` module when running on a Node-compatible
+ * engine, or undefined on engines without a process object.
+ */
 export function getNodeOsObject() {
-    const runtimeProcess = getProcessObject();
-    const requireFunction = globalThis.require;
-    if (!requireFunction || !runtimeProcess) {
-        return undefined;
-    }
-    try {
-        return requireFunction("node:os");
-    }
-    catch {
+    if (!getProcessObject()) {
         return undefined;
     }
+    return os;
 }
 export function safeCall(fn) {
     if (!fn) {

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

@@ -4,7 +4,7 @@
  * Detects and provides access to the runtime environment
  * including engine, platform, process info, and variables.
  */
-export { DefaultRuntimeEnvironment, RuntimeEnvironmentError, createRuntimeEnvironment, } from "./runtimeEnvironment.core.js";
+export { DefaultRuntimeEnvironment, MissingEnvironmentVariableError, createRuntimeEnvironment, } from "./runtimeEnvironment.core.js";
 export { detectRuntimeEngine, detectPlatform, detectProcessInfo, detectHostInfo, getNodeOsObject, safeCall, detectCI, detectContainer, } from "./detection/index.js";
-export type { RuntimePlatform, RuntimeEngine, RuntimeEnvironmentVariables, RuntimeProcessInfo, RuntimeHostInfo, RuntimeEngineInfo, RuntimeEnvironmentInfo, RuntimeEnvironment, RuntimeEnvironmentOptions, } from "./runtimeEnvironment.type.js";
+export type { RuntimePlatform, RuntimeEngine, RuntimeEnvironmentVariables, RuntimeProcessInfo, RuntimeHostInfo, RuntimeEngineInfo, RuntimeEnvironmentInfo, RuntimeEnvironmentSummary, RuntimeEnvironment, RuntimeEnvironmentOptions, } from "./runtimeEnvironment.type.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/runtimeEnvironment/index.js

@@ -4,6 +4,6 @@
  * Detects and provides access to the runtime environment
  * including engine, platform, process info, and variables.
  */
-export { DefaultRuntimeEnvironment, RuntimeEnvironmentError, createRuntimeEnvironment, } from "./runtimeEnvironment.core.js";
+export { DefaultRuntimeEnvironment, MissingEnvironmentVariableError, createRuntimeEnvironment, } from "./runtimeEnvironment.core.js";
 export { detectRuntimeEngine, detectPlatform, detectProcessInfo, detectHostInfo, getNodeOsObject, safeCall, detectCI, detectContainer, } from "./detection/index.js";
 //# sourceMappingURL=index.js.map

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

@@ -1,22 +1,18 @@
-import type { RuntimeMode } from "../runtimeOptions/index.js";
-import type { RuntimeEnvironmentInfo, RuntimeEnvironment, RuntimeEnvironmentOptions } from "./runtimeEnvironment.type.js";
-import { RuntimeError } from "@zudojs/errors";
+import type { RuntimeMode, RuntimeRole } from "../runtimeOptions/index.js";
+import type { RuntimeEngine, RuntimePlatform, RuntimeEnvironmentInfo, RuntimeEnvironmentSummary, RuntimeEnvironment, RuntimeEnvironmentOptions } from "./runtimeEnvironment.type.js";
+import { RuntimeError } from "../runtimeError/runtimeError.base.js";
 /**
- * Environment error codes.
+ * Error thrown when a required environment variable is missing or
+ * empty.
  */
-export type RuntimeEnvironmentErrorCode = "ENVIRONMENT_VARIABLE_NOT_FOUND" | "ENVIRONMENT_INVALID_MODE" | "ENVIRONMENT_INVALID_ROLE";
-/**
- * Error thrown during environment operations.
- */
-export declare class RuntimeEnvironmentError extends RuntimeError {
-    readonly envCode: RuntimeEnvironmentErrorCode;
-    readonly variableName?: string;
-    constructor(message: string, code: RuntimeEnvironmentErrorCode, variableName?: string);
+export declare class MissingEnvironmentVariableError extends RuntimeError {
+    readonly variableName: string;
+    constructor(variableName: string);
 }
 /**
  * Creates a new RuntimeEnvironment.
  */
-export declare function createRuntimeEnvironment(options: import("./runtimeEnvironment.type.js").RuntimeEnvironmentOptions): import("./runtimeEnvironment.type.js").RuntimeEnvironment;
+export declare function createRuntimeEnvironment(options: RuntimeEnvironmentOptions): RuntimeEnvironment;
 /**
  * Default RuntimeEnvironment implementation.
  */
@@ -25,9 +21,9 @@ export declare class DefaultRuntimeEnvironment implements RuntimeEnvironment {
     constructor(options: RuntimeEnvironmentOptions);
     get info(): RuntimeEnvironmentInfo;
     get mode(): RuntimeMode;
-    get role(): import("../runtimeOptions/index.js").RuntimeRole;
-    get engine(): import("./runtimeEnvironment.type.js").RuntimeEngine;
-    get platform(): import("./runtimeEnvironment.type.js").RuntimePlatform;
+    get role(): RuntimeRole;
+    get engine(): RuntimeEngine;
+    get platform(): RuntimePlatform;
     get(name: string): string | undefined;
     require(name: string): string;
     has(name: string): boolean;
@@ -36,6 +32,13 @@ export declare class DefaultRuntimeEnvironment implements RuntimeEnvironment {
     isTest(): boolean;
     isCI(): boolean;
     isContainer(): boolean;
-    toJSON(): RuntimeEnvironmentInfo;
+    /**
+     * Serializable summary of the environment.
+     *
+     * Environment variables are intentionally omitted: the snapshot
+     * routinely contains credentials (DATABASE_URL, cloud keys, ...)
+     * and must never reach structured logs or JSON.stringify output.
+     */
+    toJSON(): RuntimeEnvironmentSummary;
 }
 //# sourceMappingURL=runtimeEnvironment.core.d.ts.map

package/dist/runtime/runtimeEnvironment/runtimeEnvironment.core.js

@@ -1,18 +1,18 @@
 import { detectRuntimeEngine, detectPlatform, detectProcessInfo, detectHostInfo, readProcessEnvironment, detectCI, detectContainer, } from "./detection/index.js";
-import { RuntimeError } from "@zudojs/errors";
+import { RuntimeError } from "../runtimeError/runtimeError.base.js";
+import { RuntimeErrorCode } from "../runtimeError/runtimeError.type.js";
 /**
- * Error thrown during environment operations.
+ * Error thrown when a required environment variable is missing or
+ * empty.
  */
-export class RuntimeEnvironmentError extends RuntimeError {
-    envCode;
+export class MissingEnvironmentVariableError extends RuntimeError {
     variableName;
-    constructor(message, code, variableName) {
-        super(message, {
-            code: "RUNTIME_ENVIRONMENT",
-            phase: "environment",
+    constructor(variableName) {
+        super(`Required environment variable "${variableName}" is not defined.`, {
+            code: RuntimeErrorCode.INVALID_ENVIRONMENT,
+            metadata: { variableName },
         });
-        this.name = "RuntimeEnvironmentError";
-        this.envCode = code;
+        this.name = "MissingEnvironmentVariableError";
         this.variableName = variableName;
     }
 }
@@ -70,7 +70,7 @@ export class DefaultRuntimeEnvironment {
     require(name) {
         const value = this.get(name);
         if (value === undefined || value.length === 0) {
-            throw new RuntimeEnvironmentError(`Required environment variable "${name}" is not defined.`, "ENVIRONMENT_VARIABLE_NOT_FOUND", name);
+            throw new MissingEnvironmentVariableError(name);
         }
         return value;
     }
@@ -92,13 +92,20 @@ export class DefaultRuntimeEnvironment {
     isContainer() {
         return this._info.isContainer;
     }
+    /**
+     * Serializable summary of the environment.
+     *
+     * Environment variables are intentionally omitted: the snapshot
+     * routinely contains credentials (DATABASE_URL, cloud keys, ...)
+     * and must never reach structured logs or JSON.stringify output.
+     */
     toJSON() {
+        const { variables: _variables, ...summary } = this._info;
         return Object.freeze({
-            ...this._info,
+            ...summary,
             host: Object.freeze({ ...this._info.host }),
             process: Object.freeze({ ...this._info.process }),
             engine: Object.freeze({ ...this._info.engine }),
-            variables: Object.freeze({ ...this._info.variables }),
         });
     }
 }

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

@@ -41,6 +41,9 @@ export interface RuntimeEngineInfo {
 }
 /**
  * Complete runtime environment information.
+ *
+ * `variables` holds the full environment snapshot and may contain
+ * secrets. It is deliberately excluded from {@link RuntimeEnvironment.toJSON}.
  */
 export interface RuntimeEnvironmentInfo {
     readonly mode: RuntimeMode;
@@ -55,6 +58,11 @@ export interface RuntimeEnvironmentInfo {
     readonly isDevelopment: boolean;
     readonly isTest: boolean;
 }
+/**
+ * Environment information safe for logs and serialization: everything
+ * in RuntimeEnvironmentInfo except the raw variables.
+ */
+export type RuntimeEnvironmentSummary = Omit<RuntimeEnvironmentInfo, "variables">;
 /**
  * Runtime environment contract.
  */
@@ -72,7 +80,10 @@ export interface RuntimeEnvironment {
     isTest(): boolean;
     isCI(): boolean;
     isContainer(): boolean;
-    toJSON(): RuntimeEnvironmentInfo;
+    /**
+     * Serializable summary. Never includes environment variables.
+     */
+    toJSON(): RuntimeEnvironmentSummary;
 }
 /**
  * Options used to create a RuntimeEnvironment.

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

@@ -1,4 +1,4 @@
-import type { RuntimeErrorOptions } from "./runtimeError.type.js";
+import type { RuntimeErrorOptions, RuntimeErrorCode } from "./runtimeError.type.js";
 import type { RuntimeError as RuntimeErrorType } from "./runtimeError.base.js";
 /**
  * Runtime Errors
@@ -6,7 +6,7 @@ import type { RuntimeError as RuntimeErrorType } from "./runtimeError.base.js";
  * Error classes and utilities for runtime failures.
  */
 export { RuntimeError } from "./runtimeError.base.js";
-export { RuntimeStateError, RuntimeStartError, RuntimeStopError, RuntimeInitializationError, RuntimeLoadError, } from "./runtimeError.lifecycle.js";
+export { InvalidRuntimeStateError, InvalidRuntimeTransitionError, RuntimeStartError, RuntimeStopError, RuntimeInitializationError, RuntimeLoadError, } from "./runtimeError.lifecycle.js";
 export { RuntimeTimeoutError, RuntimeDependencyError, RuntimeNotReadyError, RuntimeUnsupportedOperationError, RuntimeCancellationError, } from "./runtimeError.specialized.js";
 export { RuntimeErrorCode } from "./runtimeError.type.js";
 export type { RuntimeOperation, RuntimeErrorPhase, RuntimeErrorMetadata, RuntimeErrorOptions, RuntimeErrorJSON, } from "./runtimeError.type.js";
@@ -21,7 +21,7 @@ export declare function isRuntimeError(error: unknown): error is RuntimeErrorTyp
 /**
  * Checks whether an unknown error has a specific runtime code.
  */
-export declare function hasRuntimeErrorCode(error: unknown, code: import("./runtimeError.type.js").RuntimeErrorCode): boolean;
+export declare function hasRuntimeErrorCode(error: unknown, code: RuntimeErrorCode): boolean;
 /**
  * Creates a runtime error with contextual information.
  */

package/dist/runtime/runtimeError/index.js

@@ -5,7 +5,7 @@ import { RuntimeError } from "./runtimeError.base.js";
  * Error classes and utilities for runtime failures.
  */
 export { RuntimeError } from "./runtimeError.base.js";
-export { RuntimeStateError, RuntimeStartError, RuntimeStopError, RuntimeInitializationError, RuntimeLoadError, } from "./runtimeError.lifecycle.js";
+export { InvalidRuntimeStateError, InvalidRuntimeTransitionError, RuntimeStartError, RuntimeStopError, RuntimeInitializationError, RuntimeLoadError, } from "./runtimeError.lifecycle.js";
 export { RuntimeTimeoutError, RuntimeDependencyError, RuntimeNotReadyError, RuntimeUnsupportedOperationError, RuntimeCancellationError, } from "./runtimeError.specialized.js";
 export { RuntimeErrorCode } from "./runtimeError.type.js";
 /**

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

@@ -1,15 +1,20 @@
-import { FrameworkError } from "../../errors/frameworkError.error.js";
-import type { SerializedBaseError } from "@zudojs/errors";
-import type { RuntimeErrorOptions, RuntimeErrorMetadata } from "./runtimeError.type.js";
+import { RuntimeError as BaseRuntimeError } from "@zudojs/errors";
+import type { RuntimeErrorOptions, RuntimeErrorJSON, RuntimeErrorMetadata, RuntimeOperation, RuntimeErrorPhase } from "./runtimeError.type.js";
 /**
- * Base error for all runtime failures.
+ * Base error for all runtime failures raised by @zudojs/core.
  *
- * Extends FrameworkError so runtime errors can be caught
- * uniformly with other framework errors.
+ * Extends RuntimeError from @zudojs/errors so runtime failures are
+ * recognised across packages (`instanceof RuntimeError` and
+ * `isRuntimeError()` from either package agree), while carrying the
+ * core-specific runtime context (operation, phase, identity, module).
  */
-export declare class RuntimeError extends FrameworkError {
-    readonly operation?: import("./runtimeError.type.js").RuntimeOperation;
-    readonly phase?: import("./runtimeError.type.js").RuntimeErrorPhase;
+export declare class RuntimeError extends BaseRuntimeError {
+    /**
+     * The runtime lifecycle phase during which the error occurred.
+     * Narrows the base `phase: string` to the known runtime phases.
+     */
+    readonly phase?: RuntimeErrorPhase;
+    readonly operation?: RuntimeOperation;
     readonly runtimeId?: string;
     readonly runtimeName?: string;
     readonly moduleName?: string;
@@ -17,14 +22,6 @@ export declare class RuntimeError extends FrameworkError {
     readonly recoverable: boolean;
     constructor(message: string, options?: RuntimeErrorOptions);
     getCause(): Error | undefined;
-    toJSON(): SerializedBaseError & {
-        readonly operation?: string;
-        readonly phase?: string;
-        readonly runtimeId?: string;
-        readonly runtimeName?: string;
-        readonly moduleName?: string;
-        readonly errorMetadata: RuntimeErrorMetadata;
-        readonly recoverable: boolean;
-    };
+    toJSON(): RuntimeErrorJSON;
 }
 //# sourceMappingURL=runtimeError.base.d.ts.map

package/dist/runtime/runtimeError/runtimeError.base.js

@@ -1,50 +1,45 @@
-import { FrameworkError } from "../../errors/frameworkError.error.js";
+import { RuntimeError as BaseRuntimeError } from "@zudojs/errors";
 import { RuntimeErrorCode } from "./runtimeError.type.js";
 /**
- * Base error for all runtime failures.
+ * Base error for all runtime failures raised by @zudojs/core.
  *
- * Extends FrameworkError so runtime errors can be caught
- * uniformly with other framework errors.
+ * Extends RuntimeError from @zudojs/errors so runtime failures are
+ * recognised across packages (`instanceof RuntimeError` and
+ * `isRuntimeError()` from either package agree), while carrying the
+ * core-specific runtime context (operation, phase, identity, module).
  */
-export class RuntimeError extends FrameworkError {
+export class RuntimeError extends BaseRuntimeError {
     operation;
-    phase;
     runtimeId;
     runtimeName;
     moduleName;
     errorMetadata;
     recoverable;
     constructor(message, options = {}) {
-        const details = {};
-        if (options.operation !== undefined) {
-            details.operation = options.operation;
-        }
-        if (options.phase !== undefined) {
-            details.phase = options.phase;
-        }
-        if (options.runtimeId !== undefined) {
-            details.runtimeId = options.runtimeId;
-        }
-        if (options.runtimeName !== undefined) {
-            details.runtimeName = options.runtimeName;
-        }
-        if (options.moduleName !== undefined) {
-            details.moduleName = options.moduleName;
-        }
-        if (options.metadata !== undefined) {
-            details.metadata = options.metadata;
-        }
-        if (options.recoverable !== undefined) {
-            details.recoverable = options.recoverable;
-        }
         super(message, {
             code: options.code ?? RuntimeErrorCode.RUNTIME_FAILURE,
-            details,
+            phase: options.phase,
+            component: options.moduleName,
             cause: options.cause,
+            isOperational: false,
+            metadata: serializableMetadata({
+                ...(options.operation !== undefined && {
+                    operation: options.operation,
+                }),
+                ...(options.runtimeId !== undefined && {
+                    runtimeId: options.runtimeId,
+                }),
+                ...(options.runtimeName !== undefined && {
+                    runtimeName: options.runtimeName,
+                }),
+                ...(options.moduleName !== undefined && {
+                    moduleName: options.moduleName,
+                }),
+                ...(options.metadata ?? {}),
+            }),
         });
         this.name = "RuntimeError";
         this.operation = options.operation;
-        this.phase = options.phase;
         this.runtimeId = options.runtimeId;
         this.runtimeName = options.runtimeName;
         this.moduleName = options.moduleName;
@@ -54,7 +49,7 @@ export class RuntimeError extends FrameworkError {
         this.recoverable = options.recoverable ?? false;
     }
     getCause() {
-        return normalizeError(this.cause);
+        return this.cause instanceof Error ? this.cause : undefined;
     }
     toJSON() {
         return {
@@ -70,12 +65,19 @@ export class RuntimeError extends FrameworkError {
     }
 }
 /**
- * Normalizes an unknown value into an Error.
+ * Keeps only JSON-safe metadata values so BaseError metadata stays
+ * transportable; richer values remain on `errorMetadata`.
  */
-function normalizeError(value) {
-    if (value instanceof Error) {
-        return value;
+function serializableMetadata(metadata) {
+    const result = {};
+    for (const [key, value] of Object.entries(metadata)) {
+        if (typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean" ||
+            value === null) {
+            result[key] = value;
+        }
     }
-    return undefined;
+    return result;
 }
 //# sourceMappingURL=runtimeError.base.js.map

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

@@ -1,15 +1,30 @@
 import type { RuntimeErrorOptions } 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 declare class RuntimeStateError extends RuntimeError {
-    readonly from: import("./runtimeError.type.js").RuntimeErrorPhase | string;
-    readonly to: import("./runtimeError.type.js").RuntimeErrorPhase | string;
-    constructor(from: import("./runtimeError.type.js").RuntimeErrorPhase | string, to: import("./runtimeError.type.js").RuntimeErrorPhase | string, options?: Omit<RuntimeErrorOptions, "code">);
+export declare class InvalidRuntimeStateError extends RuntimeError {
+    /**
+     * The runtime state in which the operation was rejected.
+     */
+    readonly state?: string;
+    constructor(message: string, options?: Omit<RuntimeErrorOptions, "code"> & {
+        readonly state?: string;
+    });
 }
 /**
- * Error thrown when runtime startup fails.
+ * Error thrown when a runtime state transition is not allowed by the
+ * runtime state table.
+ */
+export declare class InvalidRuntimeTransitionError extends RuntimeError {
+    readonly from: string;
+    readonly to: string;
+    constructor(from: string, to: string, options?: Omit<RuntimeErrorOptions, "code">);
+}
+/**
+ * Error thrown when runtime startup (bootstrap) fails.
  */
 export declare class RuntimeStartError extends RuntimeError {
     constructor(message: string, options?: Omit<RuntimeErrorOptions, "operation">);
@@ -21,13 +36,13 @@ export declare class RuntimeStopError extends RuntimeError {
     constructor(message: string, options?: Omit<RuntimeErrorOptions, "operation">);
 }
 /**
- * Error thrown when runtime initialization fails.
+ * Error thrown when module initialization fails during bootstrap.
  */
 export declare class RuntimeInitializationError extends RuntimeError {
     constructor(message: string, options?: Omit<RuntimeErrorOptions, "operation">);
 }
 /**
- * Error thrown when runtime loading fails.
+ * Error thrown when module loading fails during bootstrap.
  */
 export declare class RuntimeLoadError extends RuntimeError {
     constructor(message: string, options?: Omit<RuntimeErrorOptions, "operation">);