@objectstack/core 0.9.1 → 0.9.2

package/dist/hot-reload.d.ts

@@ -0,0 +1,79 @@
+import type { HotReloadConfig } from '@objectstack/spec/system';
+import type { ObjectLogger } from './logger.js';
+import type { Plugin } from './types.js';
+/**
+ * Plugin State Manager
+ *
+ * Handles state persistence and restoration during hot reloads
+ */
+declare class PluginStateManager {
+    private logger;
+    private stateSnapshots;
+    private memoryStore;
+    constructor(logger: ObjectLogger);
+    /**
+     * Save plugin state before reload
+     */
+    saveState(pluginId: string, version: string, state: Record<string, any>, config: HotReloadConfig): Promise<string>;
+    /**
+     * Restore plugin state after reload
+     */
+    restoreState(pluginId: string, snapshotId?: string): Promise<Record<string, any> | undefined>;
+    /**
+     * Clear state for a plugin
+     */
+    clearState(pluginId: string): void;
+    /**
+     * Calculate simple checksum for state verification
+     * WARNING: This is a simple hash for demo purposes.
+     * In production, use a cryptographic hash like SHA-256.
+     */
+    private calculateChecksum;
+    /**
+     * Shutdown state manager
+     */
+    shutdown(): void;
+}
+/**
+ * Hot Reload Manager
+ *
+ * Manages hot reloading of plugins with state preservation
+ */
+export declare class HotReloadManager {
+    private logger;
+    private stateManager;
+    private reloadConfigs;
+    private watchHandles;
+    private reloadTimers;
+    constructor(logger: ObjectLogger);
+    /**
+     * Register a plugin for hot reload
+     */
+    registerPlugin(pluginName: string, config: HotReloadConfig): void;
+    /**
+     * Start watching for changes (requires file system integration)
+     */
+    startWatching(pluginName: string): void;
+    /**
+     * Stop watching for changes
+     */
+    stopWatching(pluginName: string): void;
+    /**
+     * Trigger hot reload for a plugin
+     */
+    reloadPlugin(pluginName: string, plugin: Plugin, version: string, getPluginState: () => Record<string, any>, restorePluginState: (state: Record<string, any>) => void): Promise<boolean>;
+    /**
+     * Schedule a reload with debouncing
+     */
+    scheduleReload(pluginName: string, reloadFn: () => Promise<void>): void;
+    /**
+     * Get state manager for direct access
+     */
+    getStateManager(): PluginStateManager;
+    /**
+     * Shutdown hot reload manager
+     */
+    shutdown(): void;
+}
+export {};
+//# sourceMappingURL=hot-reload.d.ts.map

package/dist/hot-reload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hot-reload.d.ts","sourceRoot":"","sources":["../src/hot-reload.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EAEhB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAezC;;;;GAIG;AACH,cAAM,kBAAkB;IACtB,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,cAAc,CAA0C;IAChE,OAAO,CAAC,WAAW,CAA0B;gBAEjC,MAAM,EAAE,YAAY;IAIhC;;OAEG;IACG,SAAS,CACb,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC1B,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,MAAM,CAAC;IA8ClB;;OAEG;IACG,YAAY,CAChB,QAAQ,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;IAgC3C;;OAEG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAMlC;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAazB;;OAEG;IACH,QAAQ,IAAI,IAAI;CAKjB;AAED;;;;GAIG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,aAAa,CAAsC;IAC3D,OAAO,CAAC,YAAY,CAA0B;IAC9C,OAAO,CAAC,YAAY,CAAqC;gBAE7C,MAAM,EAAE,YAAY;IAKhC;;OAEG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI;IAcjE;;OAEG;IACH,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAcvC;;OAEG;IACH,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAgBtC;;OAEG;IACG,YAAY,CAChB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACzC,kBAAkB,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,IAAI,GACvD,OAAO,CAAC,OAAO,CAAC;IA8EnB;;OAEG;IACH,cAAc,CACZ,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAC5B,IAAI;IAiCP;;OAEG;IACH,eAAe,IAAI,kBAAkB;IAIrC;;OAEG;IACH,QAAQ,IAAI,IAAI;CAkBjB"}

package/dist/hot-reload.js

@@ -0,0 +1,313 @@
+// Polyfill for UUID generation to support both Node.js and Browser
+const generateUUID = () => {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    // Basic UUID v4 fallback
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = Math.random() * 16 | 0;
+        const v = c === 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+};
+/**
+ * Plugin State Manager
+ *
+ * Handles state persistence and restoration during hot reloads
+ */
+class PluginStateManager {
+    constructor(logger) {
+        this.stateSnapshots = new Map();
+        this.memoryStore = new Map();
+        this.logger = logger.child({ component: 'StateManager' });
+    }
+    /**
+     * Save plugin state before reload
+     */
+    async saveState(pluginId, version, state, config) {
+        const snapshot = {
+            pluginId,
+            version,
+            timestamp: new Date().toISOString(),
+            state,
+            metadata: {
+                checksum: this.calculateChecksum(state),
+                compressed: false,
+            },
+        };
+        const snapshotId = generateUUID();
+        switch (config.stateStrategy) {
+            case 'memory':
+                this.memoryStore.set(snapshotId, snapshot);
+                this.logger.debug('State saved to memory', { pluginId, snapshotId });
+                break;
+            case 'disk':
+                // For disk storage, we would write to file system
+                // For now, store in memory as fallback
+                this.memoryStore.set(snapshotId, snapshot);
+                this.logger.debug('State saved to disk (memory fallback)', { pluginId, snapshotId });
+                break;
+            case 'distributed':
+                // For distributed storage, would use Redis/etcd
+                // For now, store in memory as fallback
+                this.memoryStore.set(snapshotId, snapshot);
+                this.logger.debug('State saved to distributed store (memory fallback)', {
+                    pluginId,
+                    snapshotId
+                });
+                break;
+            case 'none':
+                this.logger.debug('State persistence disabled', { pluginId });
+                break;
+        }
+        this.stateSnapshots.set(pluginId, snapshot);
+        return snapshotId;
+    }
+    /**
+     * Restore plugin state after reload
+     */
+    async restoreState(pluginId, snapshotId) {
+        // Try to get from snapshot ID first, otherwise use latest for plugin
+        let snapshot;
+        if (snapshotId) {
+            snapshot = this.memoryStore.get(snapshotId);
+        }
+        else {
+            snapshot = this.stateSnapshots.get(pluginId);
+        }
+        if (!snapshot) {
+            this.logger.warn('No state snapshot found', { pluginId, snapshotId });
+            return undefined;
+        }
+        // Verify checksum if available
+        if (snapshot.metadata?.checksum) {
+            const currentChecksum = this.calculateChecksum(snapshot.state);
+            if (currentChecksum !== snapshot.metadata.checksum) {
+                this.logger.error('State checksum mismatch - data may be corrupted', {
+                    pluginId,
+                    expected: snapshot.metadata.checksum,
+                    actual: currentChecksum
+                });
+                return undefined;
+            }
+        }
+        this.logger.debug('State restored', { pluginId, version: snapshot.version });
+        return snapshot.state;
+    }
+    /**
+     * Clear state for a plugin
+     */
+    clearState(pluginId) {
+        this.stateSnapshots.delete(pluginId);
+        // Note: We don't clear memory store as it might have multiple snapshots
+        this.logger.debug('State cleared', { pluginId });
+    }
+    /**
+     * Calculate simple checksum for state verification
+     * WARNING: This is a simple hash for demo purposes.
+     * In production, use a cryptographic hash like SHA-256.
+     */
+    calculateChecksum(state) {
+        // Simple checksum using JSON serialization
+        // TODO: Replace with crypto.createHash('sha256') for production
+        const stateStr = JSON.stringify(state);
+        let hash = 0;
+        for (let i = 0; i < stateStr.length; i++) {
+            const char = stateStr.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return hash.toString(16);
+    }
+    /**
+     * Shutdown state manager
+     */
+    shutdown() {
+        this.stateSnapshots.clear();
+        this.memoryStore.clear();
+        this.logger.info('State manager shutdown complete');
+    }
+}
+/**
+ * Hot Reload Manager
+ *
+ * Manages hot reloading of plugins with state preservation
+ */
+export class HotReloadManager {
+    constructor(logger) {
+        this.reloadConfigs = new Map();
+        this.watchHandles = new Map();
+        this.reloadTimers = new Map();
+        this.logger = logger.child({ component: 'HotReload' });
+        this.stateManager = new PluginStateManager(logger);
+    }
+    /**
+     * Register a plugin for hot reload
+     */
+    registerPlugin(pluginName, config) {
+        if (!config.enabled) {
+            this.logger.debug('Hot reload disabled for plugin', { plugin: pluginName });
+            return;
+        }
+        this.reloadConfigs.set(pluginName, config);
+        this.logger.info('Plugin registered for hot reload', {
+            plugin: pluginName,
+            watchPatterns: config.watchPatterns,
+            stateStrategy: config.stateStrategy
+        });
+    }
+    /**
+     * Start watching for changes (requires file system integration)
+     */
+    startWatching(pluginName) {
+        const config = this.reloadConfigs.get(pluginName);
+        if (!config || !config.enabled) {
+            return;
+        }
+        // Note: Actual file watching would require chokidar or similar
+        // This is a placeholder for the integration point
+        this.logger.info('File watching started', {
+            plugin: pluginName,
+            patterns: config.watchPatterns
+        });
+    }
+    /**
+     * Stop watching for changes
+     */
+    stopWatching(pluginName) {
+        const handle = this.watchHandles.get(pluginName);
+        if (handle) {
+            // Stop watching (would call chokidar close())
+            this.watchHandles.delete(pluginName);
+            this.logger.info('File watching stopped', { plugin: pluginName });
+        }
+        // Clear any pending reload timers
+        const timer = this.reloadTimers.get(pluginName);
+        if (timer) {
+            clearTimeout(timer);
+            this.reloadTimers.delete(pluginName);
+        }
+    }
+    /**
+     * Trigger hot reload for a plugin
+     */
+    async reloadPlugin(pluginName, plugin, version, getPluginState, restorePluginState) {
+        const config = this.reloadConfigs.get(pluginName);
+        if (!config) {
+            this.logger.warn('Cannot reload - plugin not registered', { plugin: pluginName });
+            return false;
+        }
+        this.logger.info('Starting hot reload', { plugin: pluginName });
+        try {
+            // Call before reload hooks
+            if (config.beforeReload) {
+                this.logger.debug('Executing before reload hooks', {
+                    plugin: pluginName,
+                    hooks: config.beforeReload
+                });
+                // Hook execution would be done through kernel's hook system
+            }
+            // Save state if configured
+            let snapshotId;
+            if (config.preserveState && config.stateStrategy !== 'none') {
+                const state = getPluginState();
+                snapshotId = await this.stateManager.saveState(pluginName, version, state, config);
+                this.logger.debug('Plugin state saved', { plugin: pluginName, snapshotId });
+            }
+            // Gracefully shutdown the plugin
+            if (plugin.destroy) {
+                this.logger.debug('Destroying plugin', { plugin: pluginName });
+                const shutdownPromise = plugin.destroy();
+                const timeoutPromise = new Promise((_, reject) => {
+                    setTimeout(() => reject(new Error('Shutdown timeout')), config.shutdownTimeout);
+                });
+                await Promise.race([shutdownPromise, timeoutPromise]);
+                this.logger.debug('Plugin destroyed successfully', { plugin: pluginName });
+            }
+            // At this point, the kernel would reload the plugin module
+            // This would be handled by the plugin loader
+            this.logger.debug('Plugin module would be reloaded here', { plugin: pluginName });
+            // Restore state if we saved it
+            if (snapshotId && config.preserveState) {
+                const restoredState = await this.stateManager.restoreState(pluginName, snapshotId);
+                if (restoredState) {
+                    restorePluginState(restoredState);
+                    this.logger.debug('Plugin state restored', { plugin: pluginName });
+                }
+            }
+            // Call after reload hooks
+            if (config.afterReload) {
+                this.logger.debug('Executing after reload hooks', {
+                    plugin: pluginName,
+                    hooks: config.afterReload
+                });
+                // Hook execution would be done through kernel's hook system
+            }
+            this.logger.info('Hot reload completed successfully', { plugin: pluginName });
+            return true;
+        }
+        catch (error) {
+            this.logger.error('Hot reload failed', {
+                plugin: pluginName,
+                error
+            });
+            return false;
+        }
+    }
+    /**
+     * Schedule a reload with debouncing
+     */
+    scheduleReload(pluginName, reloadFn) {
+        const config = this.reloadConfigs.get(pluginName);
+        if (!config) {
+            return;
+        }
+        // Clear existing timer
+        const existingTimer = this.reloadTimers.get(pluginName);
+        if (existingTimer) {
+            clearTimeout(existingTimer);
+        }
+        // Schedule new reload with debounce
+        const timer = setTimeout(() => {
+            this.logger.debug('Debounce period elapsed, executing reload', {
+                plugin: pluginName
+            });
+            reloadFn().catch(error => {
+                this.logger.error('Scheduled reload failed', {
+                    plugin: pluginName,
+                    error
+                });
+            });
+            this.reloadTimers.delete(pluginName);
+        }, config.debounceDelay);
+        this.reloadTimers.set(pluginName, timer);
+        this.logger.debug('Reload scheduled with debounce', {
+            plugin: pluginName,
+            delay: config.debounceDelay
+        });
+    }
+    /**
+     * Get state manager for direct access
+     */
+    getStateManager() {
+        return this.stateManager;
+    }
+    /**
+     * Shutdown hot reload manager
+     */
+    shutdown() {
+        // Stop all watching
+        for (const pluginName of this.watchHandles.keys()) {
+            this.stopWatching(pluginName);
+        }
+        // Clear all timers
+        for (const timer of this.reloadTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.reloadConfigs.clear();
+        this.watchHandles.clear();
+        this.reloadTimers.clear();
+        this.stateManager.shutdown();
+        this.logger.info('Hot reload manager shutdown complete');
+    }
+}

package/dist/index.d.ts

@@ -6,13 +6,16 @@
  */
 export * from './kernel-base.js';
 export * from './kernel.js';
+export * from './lite-kernel.js';
 export * from './types.js';
 export * from './logger.js';
 export * from './plugin-loader.js';
-export * from './enhanced-kernel.js';
 export * from './api-registry.js';
 export * from './api-registry-plugin.js';
 export * as QA from './qa/index.js';
 export * from './security/index.js';
+export * from './health-monitor.js';
+export * from './hot-reload.js';
+export * from './dependency-resolver.js';
 export type { Logger, IHttpServer, IHttpRequest, IHttpResponse, RouteHandler, Middleware, IDataEngine, DriverInterface } from '@objectstack/spec/contracts';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,eAAe,CAAC;AAGpC,cAAc,qBAAqB,CAAC;AAGpC,YAAY,EACR,MAAM,EACN,WAAW,EACX,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,UAAU,EACV,WAAW,EACX,eAAe,EAClB,MAAM,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,eAAe,CAAC;AAGpC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AAGzC,YAAY,EACR,MAAM,EACN,WAAW,EACX,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,UAAU,EACV,WAAW,EACX,eAAe,EAClB,MAAM,6BAA6B,CAAC"}

package/dist/index.js

@@ -6,12 +6,16 @@
  */
 export * from './kernel-base.js';
 export * from './kernel.js';
+export * from './lite-kernel.js';
 export * from './types.js';
 export * from './logger.js';
 export * from './plugin-loader.js';
-export * from './enhanced-kernel.js';
 export * from './api-registry.js';
 export * from './api-registry-plugin.js';
 export * as QA from './qa/index.js';
 // Export security utilities
 export * from './security/index.js';
+// Export Phase 2 components - Advanced lifecycle management
+export * from './health-monitor.js';
+export * from './hot-reload.js';
+export * from './dependency-resolver.js';

package/dist/kernel-base.d.ts

@@ -8,14 +8,14 @@ export type KernelState = 'idle' | 'initializing' | 'running' | 'stopping' | 'st
 /**
  * ObjectKernelBase - Abstract Base Class for Microkernel
  *
- * Provides common functionality for both ObjectKernel and EnhancedObjectKernel:
+ * Provides common functionality for ObjectKernel and LiteKernel:
  * - Plugin management (Map storage)
  * - Dependency resolution (topological sort)
  * - Hook/Event system
  * - Context creation
  * - State validation
  *
- * This eliminates ~120 lines of duplicate code between the two implementations.
+ * This eliminates code duplication between the implementations.
  */
 export declare abstract class ObjectKernelBase {
     protected plugins: Map<string, Plugin>;

package/dist/kernel-base.js

@@ -1,14 +1,14 @@
 /**
  * ObjectKernelBase - Abstract Base Class for Microkernel
  *
- * Provides common functionality for both ObjectKernel and EnhancedObjectKernel:
+ * Provides common functionality for ObjectKernel and LiteKernel:
  * - Plugin management (Map storage)
  * - Dependency resolution (topological sort)
  * - Hook/Event system
  * - Context creation
  * - State validation
  *
- * This eliminates ~120 lines of duplicate code between the two implementations.
+ * This eliminates code duplication between the implementations.
  */
 export class ObjectKernelBase {
     constructor(logger) {

package/dist/kernel.d.ts

@@ -1,55 +1,103 @@
 import { Plugin } from './types.js';
 import type { LoggerConfig } from '@objectstack/spec/system';
-import { ObjectKernelBase } from './kernel-base.js';
+import { ServiceLifecycle, ServiceFactory } from './plugin-loader.js';
 /**
- * ObjectKernel - MiniKernel Architecture
- *
- * A highly modular, plugin-based microkernel that:
- * - Manages plugin lifecycle (init, start, destroy)
- * - Provides dependency injection via service registry
- * - Implements event/hook system for inter-plugin communication
- * - Handles dependency resolution (topological sort)
- * - Provides configurable logging for server and browser
+ * Enhanced Kernel Configuration
+ */
+export interface ObjectKernelConfig {
+    logger?: Partial<LoggerConfig>;
+    /** Default plugin startup timeout in milliseconds */
+    defaultStartupTimeout?: number;
+    /** Whether to enable graceful shutdown */
+    gracefulShutdown?: boolean;
+    /** Graceful shutdown timeout in milliseconds */
+    shutdownTimeout?: number;
+    /** Whether to rollback on startup failure */
+    rollbackOnFailure?: boolean;
+}
+/**
+ * Enhanced ObjectKernel with Advanced Plugin Management
  *
- * Core philosophy:
- * - Business logic is completely separated into plugins
- * - Kernel only manages lifecycle, DI, and hooks
- * - Plugins are loaded as equal building blocks
+ * Extends the basic ObjectKernel with:
+ * - Async plugin loading with validation
+ * - Version compatibility checking
+ * - Plugin signature verification
+ * - Configuration validation (Zod)
+ * - Factory-based dependency injection
+ * - Service lifecycle management (singleton/transient/scoped)
+ * - Circular dependency detection
+ * - Lazy loading services
+ * - Graceful shutdown
+ * - Plugin startup timeout control
+ * - Startup failure rollback
+ * - Plugin health checks
  */
-export declare class ObjectKernel extends ObjectKernelBase {
-    constructor(config?: {
-        logger?: Partial<LoggerConfig>;
-    });
+export declare class ObjectKernel {
+    private plugins;
+    private services;
+    private hooks;
+    private state;
+    private logger;
+    private context;
+    private pluginLoader;
+    private config;
+    private startedPlugins;
+    private pluginStartTimes;
+    private shutdownHandlers;
+    constructor(config?: ObjectKernelConfig);
     /**
-     * Register a plugin
-     * @param plugin - Plugin instance
+     * Register a plugin with enhanced validation
      */
-    use(plugin: Plugin): this;
+    use(plugin: Plugin): Promise<this>;
     /**
-     * Bootstrap the kernel
-     * 1. Resolve dependencies (topological sort)
-     * 2. Init phase - plugins register services
-     * 3. Start phase - plugins execute business logic
-     * 4. Trigger 'kernel:ready' hook
+     * Register a service factory with lifecycle management
+     */
+    registerServiceFactory<T>(name: string, factory: ServiceFactory<T>, lifecycle?: ServiceLifecycle, dependencies?: string[]): this;
+    /**
+     * Bootstrap the kernel with enhanced features
      */
     bootstrap(): Promise<void>;
     /**
-     * Shutdown the kernel
-     * Calls destroy on all plugins in reverse order
+     * Graceful shutdown with timeout
      */
     shutdown(): Promise<void>;
     /**
-     * Graceful shutdown - destroy all plugins in reverse order
+     * Check health of a specific plugin
+     */
+    checkPluginHealth(pluginName: string): Promise<any>;
+    /**
+     * Check health of all plugins
      */
-    destroy(): Promise<void>;
+    checkAllPluginsHealth(): Promise<Map<string, any>>;
     /**
-     * Get a service from the registry
-     * Convenience method for external access
+     * Get plugin startup metrics
+     */
+    getPluginMetrics(): Map<string, number>;
+    /**
+     * Get a service (sync helper)
      */
     getService<T>(name: string): T;
+    /**
+     * Get a service asynchronously (supports factories)
+     */
+    getServiceAsync<T>(name: string, scopeId?: string): Promise<T>;
     /**
      * Check if kernel is running
      */
     isRunning(): boolean;
+    /**
+     * Get kernel state
+     */
+    getState(): string;
+    private initPluginWithTimeout;
+    private startPluginWithTimeout;
+    private rollbackStartedPlugins;
+    private performShutdown;
+    private resolveDependencies;
+    private registerShutdownSignals;
+    /**
+     * Register a custom shutdown handler
+     */
+    onShutdown(handler: () => Promise<void>): void;
 }
 //# sourceMappingURL=kernel.d.ts.map

package/dist/kernel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../src/kernel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEpC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,YAAa,SAAQ,gBAAgB;gBAClC,MAAM,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAA;KAAE;IAQvD;;;OAGG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAYzB;;;;;;OAMG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IA8BhC;;;OAGG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA2B9B;;;OAGG;IACH,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC;IAI9B;;OAEG;IACH,SAAS,IAAI,OAAO;CAGvB"}
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../src/kernel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAiB,MAAM,YAAY,CAAC;AAEnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAgC,gBAAgB,EAAE,cAAc,EAAuB,MAAM,oBAAoB,CAAC;AAEzH;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAC/B,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;IAE/B,qDAAqD;IACrD,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAE/B,0CAA0C;IAC1C,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B,gDAAgD;IAChD,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,6CAA6C;IAC7C,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,YAAY;IACrB,OAAO,CAAC,OAAO,CAA0C;IACzD,OAAO,CAAC,QAAQ,CAA+B;IAC/C,OAAO,CAAC,KAAK,CAA2E;IACxF,OAAO,CAAC,KAAK,CAAwE;IACrF,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,cAAc,CAA0B;IAChD,OAAO,CAAC,gBAAgB,CAAkC;IAC1D,OAAO,CAAC,gBAAgB,CAAkC;gBAE9C,MAAM,GAAE,kBAAuB;IAyF3C;;OAEG;IACG,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBxC;;OAEG;IACH,sBAAsB,CAAC,CAAC,EACpB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAC1B,SAAS,GAAE,gBAA6C,EACxD,YAAY,CAAC,EAAE,MAAM,EAAE,GACxB,IAAI;IAUP;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAqDhC;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAqC/B;;OAEG;IACG,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAIzD;;OAEG;IACG,qBAAqB,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAWxD;;OAEG;IACH,gBAAgB,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAIvC;;OAEG;IACH,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC;IAI9B;;OAEG;IACG,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAIpE;;OAEG;IACH,SAAS,IAAI,OAAO;IAIpB;;OAEG;IACH,QAAQ,IAAI,MAAM;YAMJ,qBAAqB;YAerB,sBAAsB;YA6CtB,sBAAsB;YAkBtB,eAAe;IA2B7B,OAAO,CAAC,mBAAmB;IAyC3B,OAAO,CAAC,uBAAuB;IA2B/B;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;CAGjD"}