@zudojs/core 0.1.0 → 1.1.0

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

@@ -1,103 +1,138 @@
-import { invokeModuleLoader, invokeInitializeModules, invokeStartModules, } from "./runtimeBootstrap.invoke.js";
-import { RuntimeBootstrapError as BaseRuntimeBootstrapError } from "@zudojs/errors";
-export class RuntimeBootstrapError extends BaseRuntimeBootstrapError {
-    bootstrapCode;
-    constructor(message, code, cause) {
-        super(message, { cause });
-        this.bootstrapCode = code;
-    }
+import { RuntimeLoadError, RuntimeInitializationError, RuntimeStartError, } from "../../runtimeError/runtimeError.lifecycle.js";
+import { RuntimeErrorCode } from "../../runtimeError/runtimeError.type.js";
+export function createBootstrapPipelineState() {
+    return {
+        counters: { loadedModules: 0, initializedModules: 0, startedModules: 0 },
+        errors: [],
+    };
 }
-async function loadModules(errors, counters, moduleLoader, setPhase, log) {
-    setPhase("loading");
-    log("debug", "Loading runtime modules.");
-    try {
-        await invokeModuleLoader(moduleLoader);
-        setPhase("loaded");
-        counters.incrementLoaded();
-        log("debug", "Runtime modules loaded.");
+/**
+ * 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 async function executeBootstrapPipeline(options, services, state, signal, setPhase, log) {
+    const publish = (phase) => {
+        if (!signal.aborted)
+            setPhase(phase);
+    };
+    const identity = {
+        runtimeId: services.runtimeId,
+        runtimeName: services.runtimeName,
+    };
+    if (options.loadModules) {
+        await loadModules(services.moduleLoader, identity, state, publish, log);
     }
-    catch (error) {
-        errors.push({ phase: "loading", error });
-        throw new RuntimeBootstrapError("Failed to load runtime modules.", "MODULE_LOAD_FAILED", error);
+    if (options.initializeModules) {
+        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(phaseOptions(options.continueOnStartError)), services.moduleLifecycle, options.continueOnStartError, (count) => {
+            state.counters.startedModules = count;
+        }, (message, opts) => new RuntimeStartError(message, {
+            ...identity,
+            ...opts,
+            code: RuntimeErrorCode.MODULE_START_FAILED,
+        }), state, publish, log);
     }
 }
-async function initializeModules(errors, counters, continueOnError, moduleLifecycle, setPhase, log) {
-    setPhase("initializing");
-    log("debug", "Initializing runtime modules.");
+/**
+ * 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.");
     try {
-        await invokeInitializeModules(moduleLifecycle);
-        setPhase("initialized");
-        counters.incrementInitialized();
-        log("debug", "Runtime modules initialized.");
+        const result = await moduleLoader.loadAll();
+        state.counters.loadedModules =
+            result.loaded.length + result.alreadyLoaded.length;
+        publish("loaded");
+        log("debug", "Runtime modules loaded.", {
+            loaded: result.loaded.length,
+            alreadyLoaded: result.alreadyLoaded.length,
+            skipped: result.skipped.length,
+        });
     }
     catch (error) {
-        errors.push({ phase: "initializing", error });
-        if (!continueOnError) {
-            throw new RuntimeBootstrapError("Failed to initialize runtime modules.", "MODULE_INITIALIZATION_FAILED", error);
-        }
-        log("warn", "Runtime module initialization reported an error. Continuing.", { error });
+        throw new RuntimeLoadError("Failed to load runtime modules.", {
+            ...identity,
+            phase: "loading",
+            cause: error,
+        });
     }
 }
-async function startModules(errors, counters, continueOnError, moduleLifecycle, setPhase, log) {
-    setPhase("starting");
-    log("debug", "Starting runtime modules.");
+async function runLifecyclePhase(phase, donePhase, run, moduleLifecycle, continueOnError, setCount, createError, state, publish, log) {
+    publish(phase);
+    log("debug", `Runtime modules ${phase}.`);
+    let result;
     try {
-        await invokeStartModules(moduleLifecycle);
-        setPhase("started");
-        counters.incrementStarted();
-        log("debug", "Runtime modules started.");
+        result = await run();
     }
     catch (error) {
-        errors.push({ phase: "starting", error });
         if (!continueOnError) {
-            throw new RuntimeBootstrapError("Failed to start runtime modules.", "MODULE_START_FAILED", error);
+            throw createError(`Runtime module ${phase} failed.`, {
+                phase,
+                cause: error,
+            });
         }
-        log("warn", "Runtime module startup reported an error. Continuing.", {
+        state.errors.push({ phase, error });
+        log("warn", `Runtime module ${phase} reported an error. Continuing.`, {
             error,
         });
-    }
-}
-export async function executeBootstrapPipeline(options, errors, counters, moduleLoader, moduleLifecycle, setPhase, log) {
-    if (options.loadModules) {
-        await loadModules(errors, counters, moduleLoader, setPhase, log);
-    }
-    if (options.initializeModules) {
-        await initializeModules(errors, counters, options.continueOnInitializeError, moduleLifecycle, setPhase, log);
-    }
-    if (options.startModules) {
-        await startModules(errors, counters, options.continueOnStartError, moduleLifecycle, setPhase, log);
-    }
-    if (errors.length > 0 &&
-        !options.continueOnInitializeError &&
-        !options.continueOnStartError) {
-        throw new RuntimeBootstrapError("Runtime bootstrap completed with module errors.", "BOOTSTRAP_MODULE_ERRORS", errors);
-    }
-}
-export async function withTimeout(operation, timeoutMs) {
-    if (timeoutMs <= 0) {
-        await operation;
         return;
     }
-    let timer;
-    const timeout = new Promise((_resolve, reject) => {
-        timer = setTimeout(() => {
-            reject(new RuntimeBootstrapError(`Runtime bootstrap exceeded the configured timeout of ${timeoutMs}ms.`, "BOOTSTRAP_TIMEOUT"));
-        }, timeoutMs);
-    });
-    try {
-        await Promise.race([operation, timeout]);
+    setCount(result.completed.length);
+    for (const moduleId of result.failed) {
+        state.errors.push({
+            phase,
+            moduleName: moduleId,
+            error: moduleLifecycle.getState(moduleId)?.error ??
+                new Error(`Module "${moduleId}" failed during ${phase}.`),
+        });
     }
-    finally {
-        clearTimeout(timer);
+    if (result.failed.length > 0) {
+        if (!continueOnError) {
+            throw createError(`${result.failed.length} module(s) failed during ${phase}: ${result.failed.join(", ")}.`, {
+                phase,
+                metadata: { modules: result.failed.join(",") },
+            });
+        }
+        log("warn", `Runtime module ${phase} completed with failures. Continuing.`, {
+            failed: [...result.failed],
+        });
     }
+    publish(donePhase);
+    log("debug", `Runtime modules ${donePhase}.`, {
+        completed: result.completed.length,
+        failed: result.failed.length,
+        skipped: result.skipped.length,
+    });
 }
-export function createBootstrapResult(success, phase, loadedModules, initializedModules, startedModules, errors, startedAt, completedAt) {
+export function createBootstrapResult(success, phase, counters, errors, startedAt, completedAt) {
     return Object.freeze({
         success,
         phase,
-        loadedModules,
-        initializedModules,
-        startedModules,
+        loadedModules: counters.loadedModules,
+        initializedModules: counters.initializedModules,
+        startedModules: counters.startedModules,
         errors: Object.freeze([...errors]),
         startedAt,
         completedAt,

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

@@ -1,9 +1,12 @@
 import type { ResolvedRuntimeOptions } from "../runtimeOptions/index.js";
 import type { RuntimeBootstrapDependencies, RuntimeBootstrapOptions, RuntimeBootstrapPhase, RuntimeBootstrapResult, RuntimeBootstrap } from "./runtimeBootstrap.type.js";
+/**
+ * Default bootstrap service: loads, initializes, and starts modules
+ * according to the runtime's startup options.
+ */
 export declare class DefaultRuntimeBootstrap implements RuntimeBootstrap {
-    private readonly _context;
+    private readonly _identity;
     private readonly _environment;
-    private readonly _application;
     private readonly _moduleLoader;
     private readonly _moduleRegistry;
     private readonly _moduleLifecycle;
@@ -12,14 +15,14 @@ export declare class DefaultRuntimeBootstrap implements RuntimeBootstrap {
     private _running;
     private _phase;
     private _lastResult;
-    private _bootstrapContext?;
     constructor(dependencies: RuntimeBootstrapDependencies, runtimeOptions: ResolvedRuntimeOptions);
     get running(): boolean;
     get phase(): RuntimeBootstrapPhase;
     bootstrap(options?: RuntimeBootstrapOptions): Promise<RuntimeBootstrapResult>;
-    private resolveOptions;
     getLastResult(): RuntimeBootstrapResult | undefined;
     reset(): void;
+    private resolveOptions;
+    private errorContext;
     private log;
 }
 //# sourceMappingURL=runtimeBootstrap.core.d.ts.map

package/dist/runtime/runtimeBootstrap/runtimeBootstrap.core.js

@@ -1,10 +1,16 @@
-import { Context, createContext } from "../../context/core/context.js";
-import { executeBootstrapPipeline, RuntimeBootstrapError, withTimeout, createBootstrapResult, } from "./pipeline/index.js";
+import { executeBootstrapPipeline, createBootstrapPipelineState, createBootstrapResult, } from "./pipeline/index.js";
 import { logRuntimeEvent } from "../runtimeLogger.js";
+import { withRuntimeTimeout } from "../runtimeTimeout.js";
+import { RuntimeError } from "../runtimeError/runtimeError.base.js";
+import { InvalidRuntimeStateError, RuntimeStartError, } from "../runtimeError/runtimeError.lifecycle.js";
+import { RuntimeErrorCode } from "../runtimeError/runtimeError.type.js";
+/**
+ * Default bootstrap service: loads, initializes, and starts modules
+ * according to the runtime's startup options.
+ */
 export class DefaultRuntimeBootstrap {
-    _context;
+    _identity;
     _environment;
-    _application;
     _moduleLoader;
     _moduleRegistry;
     _moduleLifecycle;
@@ -13,11 +19,9 @@ export class DefaultRuntimeBootstrap {
     _running = false;
     _phase = "created";
     _lastResult;
-    _bootstrapContext;
     constructor(dependencies, runtimeOptions) {
-        this._context = dependencies.context;
+        this._identity = dependencies.identity;
         this._environment = dependencies.environment;
-        this._application = dependencies.application;
         this._moduleLoader = dependencies.moduleLoader;
         this._moduleRegistry = dependencies.moduleRegistry;
         this._moduleLifecycle = dependencies.moduleLifecycle;
@@ -32,91 +36,115 @@ export class DefaultRuntimeBootstrap {
     }
     async bootstrap(options = {}) {
         if (this._running) {
-            throw new RuntimeBootstrapError("Runtime bootstrap is already running.", "BOOTSTRAP_ALREADY_RUNNING");
+            throw new InvalidRuntimeStateError("Runtime bootstrap is already running.", this.errorContext({ state: this._phase }));
         }
         if (this._phase === "completed") {
-            throw new RuntimeBootstrapError("Runtime has already been bootstrapped.", "BOOTSTRAP_ALREADY_COMPLETED");
+            throw new InvalidRuntimeStateError("Runtime has already been bootstrapped.", this.errorContext({ state: this._phase }));
         }
         this._running = true;
         this._phase = "created";
         const startedAt = new Date();
-        const errors = [];
-        let loadedModules = 0, initializedModules = 0, startedModules = 0;
         const configuration = this.resolveOptions(options);
-        this._bootstrapContext = createContext({
-            application: this._application,
-            type: "worker",
-            id: this._context.identity.id,
-        });
+        const state = createBootstrapPipelineState();
+        const diagnostics = this._runtimeOptions.diagnostics;
         try {
-            logRuntimeEvent(this._logger, this._context, this._environment, "info", "Runtime bootstrap started.");
-            const operation = executeBootstrapPipeline(configuration, errors, {
-                incrementLoaded: () => {
-                    loadedModules += 1;
-                },
-                incrementInitialized: () => {
-                    initializedModules += 1;
-                },
-                incrementStarted: () => {
-                    startedModules += 1;
-                },
-            }, this._moduleLoader, this._moduleLifecycle, (phase) => {
+            if (diagnostics.startupLogging) {
+                this.log("info", "Runtime bootstrap started.", {
+                    ...(diagnostics.includeState && { phase: this._phase }),
+                });
+            }
+            await withRuntimeTimeout((signal) => executeBootstrapPipeline(configuration, {
+                moduleLoader: this._moduleLoader,
+                moduleLifecycle: this._moduleLifecycle,
+                runtimeId: this._identity.id,
+                runtimeName: this._identity.name,
+            }, state, signal, (phase) => {
                 this._phase = phase;
-            }, this.log.bind(this));
-            await withTimeout(operation, configuration.timeoutMs);
+            }, this.log.bind(this)), configuration.timeoutMs, {
+                message: `Runtime bootstrap exceeded the configured timeout of ${configuration.timeoutMs}ms.`,
+                error: this.errorContext({
+                    code: RuntimeErrorCode.BOOTSTRAP_TIMEOUT,
+                    operation: "start",
+                    phase: "bootstrapping",
+                }),
+                onLateRejection: (error) => {
+                    this.log("warn", "Abandoned runtime bootstrap failed late.", {
+                        error,
+                    });
+                },
+            });
             this._phase = "completed";
-            const completedAt = new Date();
-            const result = createBootstrapResult(true, "completed", loadedModules, initializedModules, startedModules, errors, startedAt, completedAt);
+            const result = createBootstrapResult(state.errors.length === 0, "completed", state.counters, state.errors, startedAt, new Date());
             this._lastResult = result;
-            logRuntimeEvent(this._logger, this._context, this._environment, "info", "Runtime bootstrap completed.", {
-                durationMs: result.durationMs,
-                loadedModules,
-                initializedModules,
-                startedModules,
-            });
+            if (diagnostics.startupLogging) {
+                this.log(result.success ? "info" : "warn", result.success
+                    ? "Runtime bootstrap completed."
+                    : "Runtime bootstrap completed with errors.", {
+                    durationMs: result.durationMs,
+                    loadedModules: result.loadedModules,
+                    initializedModules: result.initializedModules,
+                    startedModules: result.startedModules,
+                    errors: result.errors.length,
+                    ...(diagnostics.includeState && { phase: result.phase }),
+                    ...(diagnostics.includeModules && {
+                        modules: this._moduleRegistry
+                            .getLoadedModules()
+                            .map((module) => module.id),
+                    }),
+                });
+            }
             return result;
         }
         catch (error) {
+            const failedPhase = this._phase;
             this._phase = "failed";
-            const bootstrapError = error instanceof RuntimeBootstrapError
+            const bootstrapError = error instanceof RuntimeError
                 ? error
-                : new RuntimeBootstrapError("Runtime bootstrap failed.", "BOOTSTRAP_FAILED", error);
-            errors.push({ phase: this._phase, error: bootstrapError });
-            const completedAt = new Date();
-            const result = createBootstrapResult(false, "failed", loadedModules, initializedModules, startedModules, errors, startedAt, completedAt);
+                : new RuntimeStartError("Runtime bootstrap failed.", this.errorContext({ phase: "bootstrapping", cause: error }));
+            state.errors.push({ phase: failedPhase, error: bootstrapError });
+            const result = createBootstrapResult(false, "failed", state.counters, state.errors, startedAt, new Date());
             this._lastResult = result;
-            logRuntimeEvent(this._logger, this._context, this._environment, "error", "Runtime bootstrap failed.", { error: bootstrapError });
+            this.log("error", "Runtime bootstrap failed.", {
+                error: bootstrapError,
+                failedPhase,
+                durationMs: result.durationMs,
+            });
             throw bootstrapError;
         }
         finally {
             this._running = false;
         }
     }
-    resolveOptions(options) {
-        return {
-            loadModules: options.loadModules ?? this._runtimeOptions.startup.autoLoadModules,
-            initializeModules: options.initializeModules ??
-                this._runtimeOptions.startup.autoInitializeModules,
-            startModules: options.startModules ?? this._runtimeOptions.startup.autoStartModules,
-            continueOnInitializeError: options.continueOnInitializeError ??
-                this._runtimeOptions.startup.continueOnInitializeError,
-            continueOnStartError: options.continueOnStartError ??
-                this._runtimeOptions.startup.continueOnStartError,
-            timeoutMs: options.timeoutMs ?? this._runtimeOptions.startup.timeoutMs,
-        };
-    }
     getLastResult() {
         return this._lastResult;
     }
     reset() {
         if (this._running) {
-            throw new RuntimeBootstrapError("Cannot reset runtime bootstrap while it is running.", "BOOTSTRAP_RESET_WHILE_RUNNING");
+            throw new InvalidRuntimeStateError("Cannot reset runtime bootstrap while it is running.", this.errorContext({ state: this._phase }));
         }
         this._phase = "created";
         this._lastResult = undefined;
     }
+    resolveOptions(options) {
+        const startup = this._runtimeOptions.startup;
+        return {
+            loadModules: options.loadModules ?? startup.autoLoadModules,
+            initializeModules: options.initializeModules ?? startup.autoInitializeModules,
+            startModules: options.startModules ?? startup.autoStartModules,
+            continueOnInitializeError: options.continueOnInitializeError ?? startup.continueOnInitializeError,
+            continueOnStartError: options.continueOnStartError ?? startup.continueOnStartError,
+            timeoutMs: options.timeoutMs ?? startup.timeoutMs,
+        };
+    }
+    errorContext(extra) {
+        return {
+            ...extra,
+            runtimeId: this._identity.id,
+            runtimeName: this._identity.name,
+        };
+    }
     log(level, message, metadata) {
-        logRuntimeEvent(this._logger, this._context, this._environment, level, message, metadata);
+        logRuntimeEvent(this._logger, this._identity, this._environment, level, message, metadata);
     }
 }
 //# sourceMappingURL=runtimeBootstrap.core.js.map

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

@@ -1,17 +1,16 @@
 import type { Logger } from "../../logging/core/logger.js";
-import type { ApplicationContext } from "../../application/applicationContext.context.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 { RuntimeContext } from "../runtimeContext/index.js";
+import type { RuntimeIdentity } from "../runtimeContext/index.js";
 import type { RuntimeEnvironment } from "../runtimeEnvironment/index.js";
 /**
  * Dependencies required by RuntimeBootstrap.
  */
 export interface RuntimeBootstrapDependencies {
-    readonly context: RuntimeContext;
+    /** Identity attached to errors and log entries. */
+    readonly identity: RuntimeIdentity;
     readonly environment: RuntimeEnvironment;
-    readonly application: ApplicationContext;
     readonly moduleLoader: ModuleLoader;
     readonly moduleRegistry: ModuleRegistry;
     readonly moduleLifecycle: ModuleLifecycleManager;
@@ -34,6 +33,9 @@ export interface RuntimeBootstrapOptions {
 export type RuntimeBootstrapPhase = "created" | "loading" | "loaded" | "initializing" | "initialized" | "starting" | "started" | "completed" | "failed";
 /**
  * Represents an error produced by a bootstrap phase.
+ *
+ * Module-level failures carry the failing module id in `moduleName`;
+ * pipeline-level failures (timeouts, loader errors) do not.
  */
 export interface RuntimeBootstrapErrorInfo {
     readonly phase: RuntimeBootstrapPhase;
@@ -42,6 +44,10 @@ export interface RuntimeBootstrapErrorInfo {
 }
 /**
  * Result of a bootstrap operation.
+ *
+ * `success` is true only when no error was recorded. A bootstrap that
+ * continued past module failures (continueOn*Error) resolves with
+ * `success: false` and the failures listed in `errors`.
  */
 export interface RuntimeBootstrapResult {
     readonly success: boolean;

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

@@ -1,10 +1,8 @@
 /**
  * Runtime Context
  *
- * Provides read-only access to the runtime environment and
- * runtime-owned infrastructure.
+ * The runtime's identity and its immutable ExecutionContext.
  */
-export { DefaultRuntimeContext } from "./runtimeContext.core.js";
-export { createRuntimeId, createRuntimeIdentity, createRuntimeContext, } from "./runtimeContext.factory.js";
-export type { RuntimeIdentity, RuntimeTiming, RuntimeContextDependencies, RuntimeContext, RuntimeContextState, } from "./runtimeContext.type.js";
+export { createRuntimeId, createRuntimeIdentity, createRuntimeExecutionContext, createRuntimeContext, } from "./runtimeContext.factory.js";
+export type { RuntimeIdentity, RuntimeExecutionMetadata, RuntimeExecutionContext, RuntimeContext, } from "./runtimeContext.type.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/runtimeContext/index.js

@@ -1,9 +1,7 @@
 /**
  * Runtime Context
  *
- * Provides read-only access to the runtime environment and
- * runtime-owned infrastructure.
+ * The runtime's identity and its immutable ExecutionContext.
  */
-export { DefaultRuntimeContext } from "./runtimeContext.core.js";
-export { createRuntimeId, createRuntimeIdentity, createRuntimeContext, } from "./runtimeContext.factory.js";
+export { createRuntimeId, createRuntimeIdentity, createRuntimeExecutionContext, createRuntimeContext, } from "./runtimeContext.factory.js";
 //# sourceMappingURL=index.js.map

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

@@ -1,6 +1,5 @@
 import type { RuntimeMode, RuntimeRole } from "../runtimeOptions/index.js";
-import type { RuntimeIdentity, RuntimeContextDependencies } from "./runtimeContext.type.js";
-import { DefaultRuntimeContext } from "./runtimeContext.core.js";
+import type { RuntimeExecutionContext, RuntimeIdentity } from "./runtimeContext.type.js";
 /**
  * Creates a unique runtime identifier.
  */
@@ -16,7 +15,14 @@ export declare function createRuntimeIdentity(options: {
     readonly processId?: number;
 }): RuntimeIdentity;
 /**
- * Creates a RuntimeContext.
+ * Creates the execution context of a runtime from its identity.
+ *
+ * `metadata` (typically `RuntimeOptions.metadata`) is merged under
+ * the identity fields, which always win.
  */
-export declare function createRuntimeContext(identity: RuntimeIdentity, dependencies: RuntimeContextDependencies, metadata?: Readonly<Record<string, unknown>>): DefaultRuntimeContext;
+export declare function createRuntimeExecutionContext(identity: RuntimeIdentity, metadata?: Readonly<Record<string, unknown>>): RuntimeExecutionContext;
+/**
+ * @deprecated Use createRuntimeExecutionContext.
+ */
+export declare const createRuntimeContext: typeof createRuntimeExecutionContext;
 //# sourceMappingURL=runtimeContext.factory.d.ts.map

package/dist/runtime/runtimeContext/runtimeContext.factory.js

@@ -1,17 +1,16 @@
-import { DefaultRuntimeContext } from "./runtimeContext.core.js";
+import { randomUUID } from "node:crypto";
+import { createExecutionContext } from "../../context/core/executionContext.context.js";
 /**
  * Creates a unique runtime identifier.
  */
 export function createRuntimeId(name) {
-    const timestamp = Date.now().toString(36);
-    const random = Math.random().toString(36).slice(2, 10);
     const normalizedName = name
         .slice(0, 100)
         .trim()
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-+|-+$/g, "");
-    return [normalizedName || "runtime", timestamp, random].join("-");
+    return `${normalizedName || "runtime"}-${randomUUID()}`;
 }
 /**
  * Creates a RuntimeIdentity.
@@ -28,11 +27,35 @@ export function createRuntimeIdentity(options) {
     });
 }
 /**
- * Creates a RuntimeContext.
+ * Creates the execution context of a runtime from its identity.
+ *
+ * `metadata` (typically `RuntimeOptions.metadata`) is merged under
+ * the identity fields, which always win.
  */
-export function createRuntimeContext(identity, dependencies, metadata = {}) {
-    return new DefaultRuntimeContext(identity, dependencies, metadata);
+export function createRuntimeExecutionContext(identity, metadata = {}) {
+    const runtimeMetadata = {
+        ...metadata,
+        runtimeId: identity.id,
+        runtimeName: identity.name,
+        runtimeMode: identity.mode,
+        runtimeRole: identity.role,
+        ...(identity.processId !== undefined
+            ? { processId: identity.processId }
+            : {}),
+    };
+    return createExecutionContext({
+        executionId: identity.id,
+        service: identity.name,
+        transport: "runtime",
+        operation: "runtime",
+        startedAt: identity.createdAt,
+        metadata: runtimeMetadata,
+    });
 }
+/**
+ * @deprecated Use createRuntimeExecutionContext.
+ */
+export const createRuntimeContext = createRuntimeExecutionContext;
 /**
  * Attempts to retrieve the current process ID.
  */