@orgloop/core 0.1.5 → 0.1.6

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAE3D,qBAAa,cAAc;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqC;IAE7D,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAOtC,8EAA8E;IAC9E,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAQpD,4BAA4B;IAC5B,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;IAI7C,4CAA4C;IAC5C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B,mCAAmC;IACnC,IAAI,IAAI,cAAc,EAAE;IAIxB,uCAAuC;IACvC,IAAI,IAAI,IAAI,MAAM,CAEjB;CACD"}

package/dist/registry.js

@@ -0,0 +1,42 @@
+/**
+ * ModuleRegistry — singleton registry for loaded module instances.
+ *
+ * Tracks all active modules by name. Names are unique — attempting to
+ * register a duplicate throws ModuleConflictError.
+ */
+import { ModuleConflictError } from './errors.js';
+export class ModuleRegistry {
+    modules = new Map();
+    /** Register a module. Throws ModuleConflictError if name already exists. */
+    register(module) {
+        if (this.modules.has(module.name)) {
+            throw new ModuleConflictError(module.name, `Module "${module.name}" is already loaded`);
+        }
+        this.modules.set(module.name, module);
+    }
+    /** Unregister a module by name. Returns the removed instance or undefined. */
+    unregister(name) {
+        const module = this.modules.get(name);
+        if (module) {
+            this.modules.delete(name);
+        }
+        return module;
+    }
+    /** Get a module by name. */
+    get(name) {
+        return this.modules.get(name);
+    }
+    /** Check if a module name is registered. */
+    has(name) {
+        return this.modules.has(name);
+    }
+    /** List all registered modules. */
+    list() {
+        return [...this.modules.values()];
+    }
+    /** Get count of registered modules. */
+    get size() {
+        return this.modules.size;
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGlD,MAAM,OAAO,cAAc;IACT,OAAO,GAAG,IAAI,GAAG,EAA0B,CAAC;IAE7D,4EAA4E;IAC5E,QAAQ,CAAC,MAAsB;QAC9B,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;YACnC,MAAM,IAAI,mBAAmB,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,MAAM,CAAC,IAAI,qBAAqB,CAAC,CAAC;QACzF,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IACvC,CAAC;IAED,8EAA8E;IAC9E,UAAU,CAAC,IAAY;QACtB,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,MAAM,EAAE,CAAC;YACZ,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC3B,CAAC;QACD,OAAO,MAAM,CAAC;IACf,CAAC;IAED,4BAA4B;IAC5B,GAAG,CAAC,IAAY;QACf,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAED,4CAA4C;IAC5C,GAAG,CAAC,IAAY;QACf,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAED,mCAAmC;IACnC,IAAI;QACH,OAAO,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACnC,CAAC;IAED,uCAAuC;IACvC,IAAI,IAAI;QACP,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;IAC1B,CAAC;CACD"}

package/dist/runtime.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Runtime — the long-lived host process.
+ *
+ * Owns shared infrastructure (bus, scheduler, logger, webhook server)
+ * and manages modules through a registry. Modules are loaded/unloaded
+ * independently without affecting each other.
+ */
+import { EventEmitter } from 'node:events';
+import type { ModuleStatus, OrgLoopEvent, RuntimeStatus } from '@orgloop/sdk';
+import type { EventBus } from './bus.js';
+import type { RuntimeControl } from './http.js';
+import { LoggerManager } from './logger.js';
+import type { ModuleConfig } from './module-instance.js';
+import type { CheckpointStore } from './store.js';
+export interface SourceCircuitBreakerOptions {
+    /** Consecutive failures before opening circuit (default: 5) */
+    failureThreshold?: number;
+    /** Backoff period in ms before retry when circuit is open (default: 60000) */
+    retryAfterMs?: number;
+}
+export interface RuntimeOptions {
+    /** Custom event bus (default: InMemoryBus) */
+    bus?: EventBus;
+    /** Shared logger manager (default: new LoggerManager) */
+    loggerManager?: LoggerManager;
+    /** HTTP port for webhook server and control API (default: 4800) */
+    httpPort?: number;
+    /** Circuit breaker options for source polling */
+    circuitBreaker?: SourceCircuitBreakerOptions;
+    /** Data directory for checkpoints and WAL */
+    dataDir?: string;
+}
+export interface LoadModuleOptions {
+    /** Pre-instantiated source connectors (keyed by source ID) */
+    sources?: Map<string, import('@orgloop/sdk').SourceConnector>;
+    /** Pre-instantiated actor connectors (keyed by actor ID) */
+    actors?: Map<string, import('@orgloop/sdk').ActorConnector>;
+    /** Pre-instantiated package transforms (keyed by transform name) */
+    transforms?: Map<string, import('@orgloop/sdk').Transform>;
+    /** Pre-instantiated loggers (keyed by logger name) */
+    loggers?: Map<string, import('@orgloop/sdk').Logger>;
+    /** Custom checkpoint store for this module */
+    checkpointStore?: CheckpointStore;
+}
+declare class Runtime extends EventEmitter implements RuntimeControl {
+    private readonly bus;
+    private readonly scheduler;
+    private readonly loggerManager;
+    private readonly registry;
+    private readonly webhookServer;
+    private running;
+    private httpStarted;
+    private startedAt;
+    private readonly httpPort;
+    private readonly dataDir?;
+    private readonly circuitBreakerOpts;
+    private readonly circuitRetryTimers;
+    private readonly moduleConfigs;
+    private readonly moduleLoadOptions;
+    constructor(options?: RuntimeOptions);
+    start(): Promise<void>;
+    /** Start the HTTP server for webhooks and control API. */
+    startHttpServer(): Promise<void>;
+    /** Whether the HTTP server is currently running. */
+    isHttpStarted(): boolean;
+    stop(): Promise<void>;
+    loadModule(config: ModuleConfig, options?: LoadModuleOptions): Promise<ModuleStatus>;
+    unloadModule(name: string): Promise<void>;
+    reloadModule(name: string): Promise<void>;
+    inject(event: OrgLoopEvent, moduleName?: string): Promise<void>;
+    private processEvent;
+    private deliverToActor;
+    private pollSource;
+    private scheduleCircuitRetry;
+    status(): RuntimeStatus;
+    listModules(): ModuleStatus[];
+    getModuleStatus(name: string): ModuleStatus | undefined;
+    private emitLog;
+}
+export { Runtime };
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"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"}

package/dist/runtime.js

@@ -0,0 +1,519 @@
+/**
+ * Runtime — the long-lived host process.
+ *
+ * Owns shared infrastructure (bus, scheduler, logger, webhook server)
+ * and manages modules through a registry. Modules are loaded/unloaded
+ * independently without affecting each other.
+ */
+import { EventEmitter } from 'node:events';
+import { readFile } from 'node:fs/promises';
+import { generateTraceId } from '@orgloop/sdk';
+import { InMemoryBus } from './bus.js';
+import { ConnectorError, DeliveryError, ModuleNotFoundError, RuntimeError } from './errors.js';
+import { DEFAULT_HTTP_PORT, WebhookServer } from './http.js';
+import { LoggerManager } from './logger.js';
+import { ModuleInstance } from './module-instance.js';
+import { ModuleRegistry } from './registry.js';
+import { matchRoutes } from './router.js';
+import { Scheduler } from './scheduler.js';
+import { InMemoryCheckpointStore } from './store.js';
+import { executeTransformPipeline } from './transform.js';
+// ─── Runtime Class ───────────────────────────────────────────────────────────
+class Runtime extends EventEmitter {
+    // Shared infrastructure
+    bus;
+    scheduler = new Scheduler();
+    loggerManager;
+    registry = new ModuleRegistry();
+    webhookServer;
+    // Running state
+    running = false;
+    httpStarted = false;
+    startedAt = 0;
+    httpPort;
+    dataDir;
+    // Circuit breaker
+    circuitBreakerOpts;
+    circuitRetryTimers = new Map();
+    // Stored configs for reload
+    moduleConfigs = new Map();
+    moduleLoadOptions = new Map();
+    constructor(options) {
+        super();
+        this.bus = options?.bus ?? new InMemoryBus();
+        this.loggerManager = options?.loggerManager ?? new LoggerManager();
+        this.httpPort =
+            options?.httpPort ??
+                (process.env.ORGLOOP_PORT
+                    ? Number.parseInt(process.env.ORGLOOP_PORT, 10)
+                    : DEFAULT_HTTP_PORT);
+        this.dataDir = options?.dataDir;
+        this.circuitBreakerOpts = {
+            failureThreshold: options?.circuitBreaker?.failureThreshold ?? 5,
+            retryAfterMs: options?.circuitBreaker?.retryAfterMs ?? 60_000,
+        };
+        this.webhookServer = new WebhookServer((event) => this.inject(event));
+    }
+    // ─── Lifecycle ───────────────────────────────────────────────────────────
+    async start() {
+        if (this.running)
+            return;
+        // Start scheduler
+        this.scheduler.start((sourceId, moduleName) => this.pollSource(sourceId, moduleName));
+        this.running = true;
+        this.startedAt = Date.now();
+        await this.emitLog('runtime.start', { result: 'started' });
+    }
+    /** Start the HTTP server for webhooks and control API. */
+    async startHttpServer() {
+        if (this.httpStarted)
+            return;
+        this.webhookServer.runtime = this;
+        await this.webhookServer.start(this.httpPort);
+        this.httpStarted = true;
+    }
+    /** Whether the HTTP server is currently running. */
+    isHttpStarted() {
+        return this.httpStarted;
+    }
+    async stop() {
+        if (!this.running)
+            return;
+        await this.emitLog('runtime.stop', { result: 'stopping' });
+        // Deactivate and shutdown all modules
+        for (const mod of this.registry.list()) {
+            try {
+                mod.deactivate();
+                this.scheduler.removeSources(mod.name);
+                await mod.shutdown();
+            }
+            catch {
+                // Non-blocking
+            }
+        }
+        // Stop webhook server
+        if (this.httpStarted) {
+            await this.webhookServer.stop();
+            this.httpStarted = false;
+        }
+        // Stop scheduler
+        this.scheduler.stop();
+        // Clear circuit breaker timers
+        for (const timer of this.circuitRetryTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.circuitRetryTimers.clear();
+        // Flush and shutdown loggers
+        await this.loggerManager.flush();
+        await this.loggerManager.shutdown();
+        this.running = false;
+    }
+    // ─── Module Management ───────────────────────────────────────────────────
+    async loadModule(config, options) {
+        const checkpointStore = options?.checkpointStore ?? new InMemoryCheckpointStore();
+        const mod = new ModuleInstance(config, {
+            sources: options?.sources ?? new Map(),
+            actors: options?.actors ?? new Map(),
+            transforms: options?.transforms ?? new Map(),
+            loggers: options?.loggers ?? new Map(),
+            checkpointStore,
+        });
+        // Initialize all connectors
+        await mod.initialize();
+        // Activate and register before adding to scheduler
+        // (so the first poll finds the module in the registry)
+        mod.activate();
+        this.registry.register(mod);
+        // Add module loggers to shared LoggerManager (tagged with module name)
+        for (const [, logger] of mod.getLoggers()) {
+            this.loggerManager.addLogger(logger, mod.name);
+        }
+        // Register poll sources with shared scheduler
+        const defaultInterval = config.defaults?.poll_interval ?? '5m';
+        let hasWebhooks = false;
+        for (const srcCfg of config.sources) {
+            const connector = mod.getSource(srcCfg.id);
+            if (!connector)
+                continue;
+            if (typeof connector.webhook === 'function') {
+                // Webhook-based source: register with shared server
+                this.webhookServer.addHandler(srcCfg.id, connector.webhook());
+                hasWebhooks = true;
+            }
+            else {
+                // Poll-based source: register with shared scheduler
+                const interval = srcCfg.poll?.interval ?? defaultInterval;
+                this.scheduler.addSource(srcCfg.id, interval, mod.name);
+            }
+        }
+        // Start HTTP server on demand when webhook sources are present
+        if (hasWebhooks && !this.httpStarted) {
+            await this.startHttpServer();
+        }
+        // Store config and options for reload
+        this.moduleConfigs.set(config.name, config);
+        if (options) {
+            this.moduleLoadOptions.set(config.name, options);
+        }
+        await this.emitLog('module.active', {
+            result: `module "${config.name}" loaded`,
+            module: config.name,
+        });
+        return mod.status();
+    }
+    async unloadModule(name) {
+        const mod = this.registry.get(name);
+        if (!mod) {
+            throw new ModuleNotFoundError(name);
+        }
+        await this.emitLog('module.unloading', {
+            result: `unloading module "${name}"`,
+            module: name,
+        });
+        // Deactivate
+        mod.deactivate();
+        // Remove sources from scheduler
+        this.scheduler.removeSources(name);
+        // Remove webhook handlers for module sources
+        for (const srcCfg of mod.config.sources) {
+            this.webhookServer.removeHandler(srcCfg.id);
+        }
+        // Shutdown module resources
+        await mod.shutdown();
+        // Remove loggers by module tag
+        this.loggerManager.removeLoggersByTag(name);
+        // Unregister from registry
+        this.registry.unregister(name);
+        // Clean stored config
+        this.moduleConfigs.delete(name);
+        this.moduleLoadOptions.delete(name);
+        await this.emitLog('module.removed', {
+            result: `module "${name}" removed`,
+            module: name,
+        });
+    }
+    async reloadModule(name) {
+        const config = this.moduleConfigs.get(name);
+        if (!config) {
+            throw new ModuleNotFoundError(name);
+        }
+        const options = this.moduleLoadOptions.get(name);
+        await this.unloadModule(name);
+        await this.loadModule(config, options);
+    }
+    // ─── Event Processing ────────────────────────────────────────────────────
+    async inject(event, moduleName) {
+        const resolved = event.trace_id ? event : { ...event, trace_id: generateTraceId() };
+        if (moduleName) {
+            const mod = this.registry.get(moduleName);
+            if (!mod) {
+                throw new ModuleNotFoundError(moduleName);
+            }
+            await this.processEvent(resolved, mod);
+        }
+        else {
+            // Process through all active modules
+            for (const mod of this.registry.list()) {
+                if (mod.getState() === 'active') {
+                    await this.processEvent(resolved, mod);
+                }
+            }
+        }
+    }
+    async processEvent(event, mod) {
+        this.emit('event', event);
+        await this.emitLog('source.emit', {
+            event_id: event.id,
+            trace_id: event.trace_id,
+            source: event.source,
+            event_type: event.type,
+            module: mod.name,
+        });
+        // Write to bus (WAL)
+        await this.bus.publish(event);
+        // Match routes from this module
+        const matched = matchRoutes(event, mod.getRoutes());
+        if (matched.length === 0) {
+            await this.emitLog('route.no_match', {
+                event_id: event.id,
+                trace_id: event.trace_id,
+                source: event.source,
+                module: mod.name,
+            });
+            await this.bus.ack(event.id);
+            return;
+        }
+        // Process each matched route
+        for (const match of matched) {
+            const { route } = match;
+            await this.emitLog('route.match', {
+                event_id: event.id,
+                trace_id: event.trace_id,
+                route: route.name,
+                source: event.source,
+                target: route.then.actor,
+                module: mod.name,
+            });
+            // Run transform pipeline
+            let transformedEvent = event;
+            if (route.transforms && route.transforms.length > 0) {
+                const pipelineOptions = {
+                    definitions: mod.config.transforms,
+                    packageTransforms: mod.getTransformsMap(),
+                    onLog: (partial) => {
+                        void this.emitLog(partial.phase ?? 'transform.start', {
+                            ...partial,
+                            event_id: partial.event_id ?? event.id,
+                            trace_id: partial.trace_id ?? event.trace_id,
+                            route: route.name,
+                            module: mod.name,
+                        });
+                    },
+                };
+                const context = {
+                    source: event.source,
+                    target: route.then.actor,
+                    eventType: event.type,
+                    routeName: route.name,
+                };
+                try {
+                    const result = await executeTransformPipeline(event, context, route.transforms, pipelineOptions);
+                    if (result.dropped || !result.event) {
+                        continue; // Skip delivery for this route
+                    }
+                    transformedEvent = result.event;
+                }
+                catch (err) {
+                    // halt policy throws TransformError — emit error and skip delivery
+                    this.emit('error', err);
+                    continue;
+                }
+            }
+            // Deliver to actor
+            await this.deliverToActor(transformedEvent, route.name, route.then.actor, route, mod);
+        }
+        // Ack the event after all routes processed
+        await this.bus.ack(event.id);
+    }
+    async deliverToActor(event, routeName, actorId, route, mod) {
+        const actor = mod.getActor(actorId);
+        if (!actor) {
+            const error = new DeliveryError(actorId, routeName, `Actor "${actorId}" not found`);
+            this.emit('error', error);
+            return;
+        }
+        await this.emitLog('deliver.attempt', {
+            event_id: event.id,
+            trace_id: event.trace_id,
+            route: routeName,
+            target: actorId,
+            module: mod.name,
+        });
+        const startTime = Date.now();
+        try {
+            // Build delivery config
+            const deliveryConfig = {
+                ...(route.then.config ?? {}),
+            };
+            // Resolve launch prompt if configured
+            if (route.with?.prompt_file) {
+                try {
+                    const promptContent = await readFile(route.with.prompt_file, 'utf-8');
+                    deliveryConfig.launch_prompt = promptContent;
+                    deliveryConfig.launch_prompt_file = route.with.prompt_file;
+                }
+                catch {
+                    // Non-fatal: log but continue delivery
+                }
+            }
+            const result = await actor.deliver(event, deliveryConfig);
+            const durationMs = Date.now() - startTime;
+            if (result.status === 'delivered') {
+                await this.emitLog('deliver.success', {
+                    event_id: event.id,
+                    trace_id: event.trace_id,
+                    route: routeName,
+                    target: actorId,
+                    duration_ms: durationMs,
+                    module: mod.name,
+                });
+                this.emit('delivery', {
+                    event,
+                    route: routeName,
+                    actor: actorId,
+                    status: 'delivered',
+                });
+            }
+            else {
+                await this.emitLog('deliver.failure', {
+                    event_id: event.id,
+                    trace_id: event.trace_id,
+                    route: routeName,
+                    target: actorId,
+                    duration_ms: durationMs,
+                    error: result.error?.message ?? result.status,
+                    module: mod.name,
+                });
+                this.emit('delivery', {
+                    event,
+                    route: routeName,
+                    actor: actorId,
+                    status: result.status,
+                });
+            }
+        }
+        catch (err) {
+            const durationMs = Date.now() - startTime;
+            const error = new DeliveryError(actorId, routeName, 'Delivery failed', { cause: err });
+            this.emit('error', error);
+            await this.emitLog('deliver.failure', {
+                event_id: event.id,
+                trace_id: event.trace_id,
+                route: routeName,
+                target: actorId,
+                duration_ms: durationMs,
+                error: error.message,
+                module: mod.name,
+            });
+        }
+    }
+    // ─── Source Polling ───────────────────────────────────────────────────────
+    async pollSource(sourceId, moduleName) {
+        if (!moduleName)
+            return;
+        const mod = this.registry.get(moduleName);
+        if (!mod || mod.getState() !== 'active')
+            return;
+        const connector = mod.getSource(sourceId);
+        if (!connector)
+            return;
+        const healthState = mod.getHealthState(sourceId);
+        if (!healthState)
+            return;
+        // Circuit breaker: skip poll if circuit is open
+        if (healthState.circuitOpen) {
+            return;
+        }
+        healthState.lastPollAttempt = new Date().toISOString();
+        try {
+            const store = mod.getCheckpointStore();
+            const checkpoint = await store.get(sourceId);
+            const result = await connector.poll(checkpoint);
+            // Save checkpoint
+            if (result.checkpoint) {
+                await store.set(sourceId, result.checkpoint);
+            }
+            // Record successful poll
+            healthState.lastSuccessfulPoll = new Date().toISOString();
+            healthState.lastError = null;
+            healthState.totalEventsEmitted += result.events.length;
+            // If recovering from errors, log recovery
+            if (healthState.consecutiveErrors > 0) {
+                await this.emitLog('source.circuit_close', {
+                    source: sourceId,
+                    result: `recovered after ${healthState.consecutiveErrors} consecutive errors`,
+                    module: moduleName,
+                });
+            }
+            healthState.consecutiveErrors = 0;
+            healthState.status = 'healthy';
+            // Process each event through the module
+            for (const event of result.events) {
+                const enriched = event.trace_id ? event : { ...event, trace_id: generateTraceId() };
+                await this.processEvent(enriched, mod);
+            }
+        }
+        catch (err) {
+            const error = new ConnectorError(sourceId, 'Poll failed', { cause: err });
+            this.emit('error', error);
+            healthState.consecutiveErrors++;
+            healthState.lastError = err instanceof Error ? err.message : String(err);
+            // Update health status
+            if (healthState.consecutiveErrors >= this.circuitBreakerOpts.failureThreshold) {
+                healthState.status = 'unhealthy';
+                healthState.circuitOpen = true;
+                await this.emitLog('source.circuit_open', {
+                    source: sourceId,
+                    error: healthState.lastError,
+                    result: `${healthState.consecutiveErrors} consecutive failures — polling paused, will retry in ${Math.round(this.circuitBreakerOpts.retryAfterMs / 1000)}s`,
+                    module: moduleName,
+                });
+                // Schedule a retry after backoff
+                this.scheduleCircuitRetry(sourceId, moduleName);
+            }
+            else {
+                healthState.status = 'degraded';
+                await this.emitLog('system.error', {
+                    source: sourceId,
+                    error: error.message,
+                    module: moduleName,
+                });
+            }
+        }
+    }
+    scheduleCircuitRetry(sourceId, moduleName) {
+        const timerKey = `${moduleName}/${sourceId}`;
+        const existing = this.circuitRetryTimers.get(timerKey);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(async () => {
+            this.circuitRetryTimers.delete(timerKey);
+            if (!this.running)
+                return;
+            const mod = this.registry.get(moduleName);
+            if (!mod || mod.getState() !== 'active')
+                return;
+            const healthState = mod.getHealthState(sourceId);
+            if (!healthState || !healthState.circuitOpen)
+                return;
+            await this.emitLog('source.circuit_retry', {
+                source: sourceId,
+                result: 'attempting recovery poll',
+                module: moduleName,
+            });
+            // Temporarily allow poll by opening the circuit
+            healthState.circuitOpen = false;
+            await this.pollSource(sourceId, moduleName);
+        }, this.circuitBreakerOpts.retryAfterMs);
+        this.circuitRetryTimers.set(timerKey, timer);
+    }
+    // ─── RuntimeControl Implementation ───────────────────────────────────────
+    status() {
+        return {
+            running: this.running,
+            pid: process.pid,
+            uptime_ms: this.running ? Date.now() - this.startedAt : 0,
+            httpPort: this.httpPort,
+            modules: this.registry.list().map((m) => m.status()),
+        };
+    }
+    listModules() {
+        return this.registry.list().map((m) => m.status());
+    }
+    getModuleStatus(name) {
+        const mod = this.registry.get(name);
+        return mod?.status();
+    }
+    // ─── Logging ─────────────────────────────────────────────────────────────
+    async emitLog(phase, fields) {
+        const entry = {
+            timestamp: new Date().toISOString(),
+            event_id: fields.event_id ?? '',
+            trace_id: fields.trace_id ?? '',
+            phase,
+            source: fields.source,
+            target: fields.target,
+            route: fields.route,
+            transform: fields.transform,
+            event_type: fields.event_type,
+            result: fields.result,
+            duration_ms: fields.duration_ms,
+            error: fields.error,
+            metadata: fields.metadata,
+            module: fields.module,
+        };
+        await this.loggerManager.log(entry);
+    }
+}
+export { Runtime };
+//# sourceMappingURL=runtime.js.map