@deployforme/core 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -3,3 +3,4 @@ export { ModuleRegistry } from './module-registry';
 export { ModuleLoader } from './loader';
 export { createRuntimeContext, DefaultLogger } from './context';
 export * from './types';
+export * from './monitoring';

package/dist/index.js

@@ -25,3 +25,4 @@ var context_1 = require("./context");
 Object.defineProperty(exports, "createRuntimeContext", { enumerable: true, get: function () { return context_1.createRuntimeContext; } });
 Object.defineProperty(exports, "DefaultLogger", { enumerable: true, get: function () { return context_1.DefaultLogger; } });
 __exportStar(require("./types"), exports);
+__exportStar(require("./monitoring"), exports);

package/dist/kernel.d.ts

@@ -1,10 +1,18 @@
 import { RuntimeContext } from './types';
+import { Monitor } from './monitoring/monitor';
+import { MonitoringConfig } from './monitoring/types';
 export declare class Kernel {
     private registry;
     private loader;
     private context;
     private routeTracker;
-    constructor(context: RuntimeContext);
+    private monitor;
+    private dashboard?;
+    private config;
+    constructor(context: RuntimeContext, config?: MonitoringConfig);
+    private startDashboard;
+    stopDashboard(): void;
+    getMonitor(): Monitor;
     load(modulePath: string): Promise<void>;
     unload(moduleName: string): Promise<void>;
     reload(modulePath: string): Promise<void>;

package/dist/kernel.js

@@ -3,43 +3,80 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Kernel = void 0;
 const module_registry_1 = require("./module-registry");
 const loader_1 = require("./loader");
+const monitor_1 = require("./monitoring/monitor");
+const dashboard_1 = require("./monitoring/dashboard");
 class Kernel {
-    constructor(context) {
+    constructor(context, config = { liveRunnerActions: false }) {
         this.routeTracker = new Map();
         this.context = context;
         this.registry = new module_registry_1.ModuleRegistry();
         this.loader = new loader_1.ModuleLoader();
+        this.monitor = new monitor_1.Monitor();
+        this.config = config;
+        if (config.liveRunnerActions) {
+            this.startDashboard(config.port, config.host);
+        }
+    }
+    async startDashboard(port, host) {
+        try {
+            this.dashboard = new dashboard_1.Dashboard(this.monitor, port || 0, host || 'localhost');
+            await this.dashboard.start();
+        }
+        catch (error) {
+            this.context.logger?.error(`[Deploy4Me] Failed to start dashboard: ${error}`);
+        }
+    }
+    stopDashboard() {
+        if (this.dashboard) {
+            this.dashboard.stop();
+            this.dashboard = undefined;
+        }
+    }
+    getMonitor() {
+        return this.monitor;
     }
     async load(modulePath) {
-        const module = await this.loader.load(modulePath);
-        // Unload existing module if present
-        if (this.registry.has(module.name)) {
-            await this.unload(module.name);
+        const buildId = this.monitor.startBuild('unknown', modulePath);
+        try {
+            const module = await this.loader.load(modulePath);
+            this.monitor.completeBuild(buildId, 'success');
+            this.monitor.startBuild(module.name, modulePath);
+            // Unload existing module if present
+            if (this.registry.has(module.name)) {
+                await this.unload(module.name);
+            }
+            this.context.logger?.log(`[Deploy4Me] Loading module: ${module.name}@${module.version}`);
+            // Track routes registered during module.register()
+            const routeIds = [];
+            const originalRegister = this.context.http.registerRoute.bind(this.context.http);
+            this.context.http.registerRoute = (definition) => {
+                routeIds.push(definition.id);
+                originalRegister(definition);
+            };
+            // Register module
+            module.register(this.context);
+            // Restore original registerRoute
+            this.context.http.registerRoute = originalRegister;
+            // Store in registry
+            this.registry.register(module, routeIds);
+            this.routeTracker.set(module.name, routeIds);
+            // Register in monitor
+            this.monitor.registerModule(module.name, module.version, routeIds.length);
+            this.context.logger?.log(`[Deploy4Me] Module registered: ${module.name} (${routeIds.length} routes)`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.monitor.completeBuild(buildId, 'error', errorMessage);
+            throw error;
         }
-        this.context.logger?.log(`Loading module: ${module.name}@${module.version}`);
-        // Track routes registered during module.register()
-        const routeIds = [];
-        const originalRegister = this.context.http.registerRoute.bind(this.context.http);
-        this.context.http.registerRoute = (definition) => {
-            routeIds.push(definition.id);
-            originalRegister(definition);
-        };
-        // Register module
-        module.register(this.context);
-        // Restore original registerRoute
-        this.context.http.registerRoute = originalRegister;
-        // Store in registry
-        this.registry.register(module, routeIds);
-        this.routeTracker.set(module.name, routeIds);
-        this.context.logger?.log(`Module loaded: ${module.name} (${routeIds.length} routes)`);
     }
     async unload(moduleName) {
         const metadata = this.registry.get(moduleName);
         if (!metadata) {
-            this.context.logger?.warn(`Module not found: ${moduleName}`);
+            this.context.logger?.warn(`[Deploy4Me] Module not found: ${moduleName}`);
             return;
         }
-        this.context.logger?.log(`Unloading module: ${moduleName}`);
+        this.context.logger?.log(`[Deploy4Me] Unloading module: ${moduleName}`);
         // Call dispose if exists
         if (metadata.module.dispose) {
             metadata.module.dispose();
@@ -52,7 +89,9 @@ class Kernel {
         // Remove from registry
         this.registry.unregister(moduleName);
         this.routeTracker.delete(moduleName);
-        this.context.logger?.log(`Module unloaded: ${moduleName}`);
+        // Unregister from monitor
+        this.monitor.unregisterModule(moduleName);
+        this.context.logger?.log(`[Deploy4Me] Module unloaded: ${moduleName}`);
     }
     async reload(modulePath) {
         await this.load(modulePath);

package/dist/monitoring/dashboard.d.ts

@@ -0,0 +1,14 @@
+import { Monitor } from './monitor';
+export declare class Dashboard {
+    private server?;
+    private monitor;
+    private port;
+    private host;
+    constructor(monitor: Monitor, port?: number, host?: string);
+    start(): Promise<number>;
+    stop(): void;
+    private handleRequest;
+    private sendJSON;
+    private sendHTML;
+    private getHTML;
+}

package/dist/monitoring/dashboard.js

@@ -0,0 +1,386 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dashboard = void 0;
+const http = __importStar(require("http"));
+class Dashboard {
+    constructor(monitor, port = 0, host = 'localhost') {
+        this.monitor = monitor;
+        this.port = port;
+        this.host = host;
+    }
+    async start() {
+        return new Promise((resolve, reject) => {
+            this.server = http.createServer((req, res) => {
+                this.handleRequest(req, res);
+            });
+            this.server.on('error', reject);
+            this.server.listen(this.port, this.host, () => {
+                const addr = this.server.address();
+                const actualPort = typeof addr === 'object' ? addr.port : this.port;
+                const timestamp = new Date().toISOString();
+                console.log(`[${timestamp}] [SUCCESS] Dashboard started at http://${this.host}:${actualPort}`);
+                resolve(actualPort);
+            });
+        });
+    }
+    stop() {
+        if (this.server) {
+            this.server.close();
+            this.server = undefined;
+        }
+    }
+    handleRequest(req, res) {
+        const url = req.url || '/';
+        if (url === '/api/state') {
+            this.sendJSON(res, {
+                builds: this.monitor.getBuilds(),
+                modules: this.monitor.getActiveModules(),
+                stats: this.monitor.getStats()
+            });
+        }
+        else {
+            this.sendHTML(res);
+        }
+    }
+    sendJSON(res, data) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    }
+    sendHTML(res) {
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.end(this.getHTML());
+    }
+    getHTML() {
+        return `<!DOCTYPE html>
+<html lang="tr">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Deploy4Me Dashboard</title>
+  <style>
+    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600&display=swap');
+
+    :root {
+      --bg: #0a0a0a;
+      --text: #f2f2f2;
+      --text-dim: #666666;
+      --border: #1a1a1a;
+      --success: #4ade80;
+      --error: #f87171;
+      --process: #60a5fa;
+      --accent: #ffffff;
+    }
+
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    
+    body {
+      font-family: 'Inter', sans-serif;
+      background: var(--bg);
+      color: var(--text);
+      line-height: 1.6;
+      padding: 4rem 2rem;
+      display: flex;
+      justify-content: center;
+      -webkit-font-smoothing: antialiased;
+    }
+    
+    .container { width: 100%; max-width: 900px; }
+    
+    header {
+      margin-bottom: 4rem;
+      border-bottom: 1px solid var(--text);
+      padding-bottom: 1.5rem;
+      display: flex;
+      justify-content: space-between;
+      align-items: flex-end;
+    }
+
+    h1 { font-size: 1.4rem; font-weight: 500; letter-spacing: -0.03em; text-transform: lowercase; }
+    .subtitle { color: var(--text-dim); font-size: 0.8rem; }
+    
+    .stats {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
+      gap: 2rem;
+      margin-bottom: 5rem;
+    }
+    
+    .stat-label { font-size: 0.65rem; text-transform: uppercase; letter-spacing: 0.1em; color: var(--text-dim); margin-bottom: 0.5rem; }
+    .stat-value { font-size: 1.4rem; font-variant-numeric: tabular-nums; }
+    
+    .section { margin-bottom: 4rem; }
+    
+    .section-header {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      border-bottom: 1px solid var(--border);
+      margin-bottom: 1rem;
+      padding-bottom: 0.5rem;
+    }
+
+    .section-title {
+      font-size: 0.75rem;
+      font-weight: 600;
+      text-transform: uppercase;
+      letter-spacing: 0.15em;
+      color: var(--text-dim);
+    }
+
+    /* Tabs Styling */
+    .tabs { display: flex; gap: 1.5rem; }
+    .tab {
+      background: none;
+      border: none;
+      color: var(--text-dim);
+      font-family: inherit;
+      font-size: 0.75rem;
+      font-weight: 600;
+      text-transform: uppercase;
+      cursor: pointer;
+      padding: 0.5rem 0;
+      transition: color 0.2s;
+      position: relative;
+    }
+    .tab:hover { color: var(--text); }
+    .tab.active { color: var(--accent); }
+    .tab.active::after {
+      content: '';
+      position: absolute;
+      bottom: -0.6rem;
+      left: 0;
+      width: 100%;
+      height: 1px;
+      background: var(--accent);
+    }
+    
+    .list-item {
+      display: grid;
+      grid-template-columns: 1fr auto;
+      padding: 1rem 0;
+      border-bottom: 1px solid var(--border);
+      align-items: center;
+    }
+
+    .item-name { font-weight: 500; font-size: 1rem; }
+    .item-details {
+      font-size: 0.75rem;
+      color: var(--text-dim);
+      display: flex;
+      gap: 1rem;
+      font-family: 'ui-monospace', monospace;
+    }
+    
+    .status-text { font-size: 0.65rem; font-weight: 600; text-transform: uppercase; }
+    .status-building { color: var(--process); }
+    .status-success { color: var(--success); }
+    .status-error { color: var(--error); }
+
+    .error-log {
+      grid-column: 1 / -1;
+      font-family: 'ui-monospace', monospace;
+      font-size: 0.7rem;
+      color: var(--error);
+      padding: 0.5rem 0;
+      opacity: 0.8;
+    }
+
+    /* Pagination Styling */
+    .pagination {
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      gap: 2rem;
+      margin-top: 2rem;
+      font-size: 0.75rem;
+      color: var(--text-dim);
+      text-transform: uppercase;
+      letter-spacing: 0.1em;
+    }
+    .page-btn {
+      background: none;
+      border: 1px solid var(--border);
+      color: var(--text);
+      padding: 0.4rem 1rem;
+      cursor: pointer;
+      transition: all 0.2s;
+    }
+    .page-btn:disabled { color: var(--text-dim); cursor: not-allowed; border-color: transparent; }
+    .page-btn:not(:disabled):hover { border-color: var(--text-dim); }
+
+    .empty { color: var(--text-dim); padding: 2rem 0; font-style: italic; font-size: 0.8rem; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <header>
+      <h1>deploy4me.dashboard</h1>
+      <div id="stat-uptime" class="subtitle">0s</div>
+    </header>
+    
+    <div class="stats">
+      <div class="stat-item"><div class="stat-label">builds</div><div class="stat-value" id="stat-total">0</div></div>
+      <div class="stat-item"><div class="stat-label">success</div><div class="stat-value" id="stat-success">0</div></div>
+      <div class="stat-item"><div class="stat-label">failed</div><div class="stat-value" id="stat-failed">0</div></div>
+      <div class="stat-item"><div class="stat-label">active</div><div class="stat-value" id="stat-modules">0</div></div>
+    </div>
+    
+    <div class="section">
+      <div class="section-header"><div class="section-title">Active Modules</div></div>
+      <div id="modules"><div class="empty">Inquiring...</div></div>
+    </div>
+    
+    <div class="section">
+      <div class="section-header">
+        <div class="section-title">Build History</div>
+        <div class="tabs">
+          <button class="tab active" onclick="setFilter('all')">All</button>
+          <button class="tab" onclick="setFilter('building')">Building</button>
+          <button class="tab" onclick="setFilter('success')">Success</button>
+          <button class="tab" onclick="setFilter('error')">Failed</button>
+        </div>
+      </div>
+      <div id="builds"></div>
+      <div class="pagination">
+        <button id="prev-btn" class="page-btn" onclick="changePage(-1)">Previous</button>
+        <span id="page-info">Page 1</span>
+        <button id="next-btn" class="page-btn" onclick="changePage(1)">Next</button>
+      </div>
+    </div>
+  </div>
+  
+  <script>
+    let allBuilds = [];
+    let currentFilter = 'all';
+    let currentPage = 1;
+    const itemsPerPage = 8;
+
+    function formatUptime(ms) {
+      const s = Math.floor(ms / 1000);
+      const m = Math.floor(s / 60);
+      return m > 0 ? \`up \${m}m \${s%60}s\` : \`up \${s}s\`;
+    }
+    
+    function setFilter(filter) {
+      currentFilter = filter;
+      currentPage = 1;
+      document.querySelectorAll('.tab').forEach(t => {
+        t.classList.toggle('active', t.textContent.toLowerCase() === filter || (filter === 'error' && t.textContent === 'Failed'));
+      });
+      render();
+    }
+
+    function changePage(step) {
+      currentPage += step;
+      render();
+    }
+
+    function render() {
+      // Stats & Modules rendering
+      // ... (handled in fetchData)
+    }
+
+    async function fetchData() {
+      try {
+        const res = await fetch('/api/state');
+        const data = await res.json();
+        
+        // Update Stats
+        document.getElementById('stat-total').textContent = data.stats.totalBuilds;
+        document.getElementById('stat-success').textContent = data.stats.successfulBuilds;
+        document.getElementById('stat-failed').textContent = data.stats.failedBuilds;
+        document.getElementById('stat-modules').textContent = data.stats.activeModules;
+        document.getElementById('stat-uptime').textContent = formatUptime(data.stats.uptime);
+
+        // Update Modules
+        const modContainer = document.getElementById('modules');
+        modContainer.innerHTML = data.modules.map(mod => \`
+          <div class="list-item">
+            <div class="item-name">\${mod.name} <span style="color:var(--text-dim); font-size:0.7rem">v\${mod.version}</span></div>
+            <div class="status-text status-active">active</div>
+          </div>
+        \`).join('') || '<div class="empty">No active modules.</div>';
+
+        allBuilds = data.builds;
+        renderBuilds();
+      } catch (e) { console.error('Sync error'); }
+    }
+
+    function renderBuilds() {
+      const container = document.getElementById('builds');
+      
+      // Filter
+      const filtered = allBuilds.filter(b => currentFilter === 'all' || b.status === currentFilter);
+      
+      // Pagination
+      const totalPages = Math.ceil(filtered.length / itemsPerPage) || 1;
+      if (currentPage > totalPages) currentPage = totalPages;
+      
+      const start = (currentPage - 1) * itemsPerPage;
+      const paginated = filtered.slice(start, start + itemsPerPage);
+
+      document.getElementById('page-info').textContent = \`Page \${currentPage} of \${totalPages}\`;
+      document.getElementById('prev-btn').disabled = currentPage === 1;
+      document.getElementById('next-btn').disabled = currentPage === totalPages;
+
+      if (!paginated.length) {
+        container.innerHTML = '<div class="empty">No records found for this filter.</div>';
+        return;
+      }
+
+      container.innerHTML = paginated.map(build => \`
+        <div class="list-item">
+          <div>
+            <div class="item-name">\${build.moduleName}</div>
+            <div class="item-details">
+              <span>\${new Date(build.startTime).toLocaleTimeString('tr-TR')}</span>
+              <span>\${build.duration ? (build.duration/1000).toFixed(2)+'s' : '--'}</span>
+            </div>
+          </div>
+          <div class="status-text status-\${build.status}">\${build.status}</div>
+          \${build.error ? \`<div class="error-log">\${build.error}</div>\` : ''}
+        </div>
+      \`).join('');
+    }
+    
+    fetchData();
+    setInterval(fetchData, 3000);
+  </script>
+</body>
+</html>`;
+    }
+}
+exports.Dashboard = Dashboard;

package/dist/monitoring/index.d.ts

@@ -0,0 +1,3 @@
+export { Monitor } from './monitor';
+export { Dashboard } from './dashboard';
+export * from './types';

package/dist/monitoring/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dashboard = exports.Monitor = void 0;
+var monitor_1 = require("./monitor");
+Object.defineProperty(exports, "Monitor", { enumerable: true, get: function () { return monitor_1.Monitor; } });
+var dashboard_1 = require("./dashboard");
+Object.defineProperty(exports, "Dashboard", { enumerable: true, get: function () { return dashboard_1.Dashboard; } });
+__exportStar(require("./types"), exports);

package/dist/monitoring/monitor.d.ts

@@ -0,0 +1,21 @@
+import { BuildRecord, ActiveModule, MonitoringState } from './types';
+export declare class Monitor {
+    private state;
+    private maxBuilds;
+    constructor();
+    startBuild(moduleName: string, modulePath: string): string;
+    completeBuild(id: string, status: 'success' | 'error', error?: string): void;
+    registerModule(name: string, version: string, routeCount: number): void;
+    unregisterModule(name: string): void;
+    getState(): MonitoringState;
+    getBuilds(): BuildRecord[];
+    getActiveModules(): ActiveModule[];
+    getStats(): {
+        totalBuilds: number;
+        successfulBuilds: number;
+        failedBuilds: number;
+        buildingNow: number;
+        activeModules: number;
+        uptime: number;
+    };
+}

package/dist/monitoring/monitor.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Monitor = void 0;
+class Monitor {
+    constructor() {
+        this.maxBuilds = 100;
+        this.state = {
+            builds: [],
+            activeModules: new Map(),
+            startTime: new Date()
+        };
+    }
+    startBuild(moduleName, modulePath) {
+        const id = `${moduleName}-${Date.now()}`;
+        const record = {
+            id,
+            moduleName,
+            modulePath,
+            status: 'building',
+            startTime: new Date()
+        };
+        this.state.builds.unshift(record);
+        if (this.state.builds.length > this.maxBuilds) {
+            this.state.builds = this.state.builds.slice(0, this.maxBuilds);
+        }
+        return id;
+    }
+    completeBuild(id, status, error) {
+        const build = this.state.builds.find(b => b.id === id);
+        if (build) {
+            build.status = status;
+            build.endTime = new Date();
+            build.duration = build.endTime.getTime() - build.startTime.getTime();
+            if (error) {
+                build.error = error;
+            }
+        }
+    }
+    registerModule(name, version, routeCount) {
+        this.state.activeModules.set(name, {
+            name,
+            version,
+            loadedAt: new Date(),
+            routeCount,
+            status: 'active'
+        });
+    }
+    unregisterModule(name) {
+        this.state.activeModules.delete(name);
+    }
+    getState() {
+        return {
+            ...this.state,
+            activeModules: new Map(this.state.activeModules)
+        };
+    }
+    getBuilds() {
+        return [...this.state.builds];
+    }
+    getActiveModules() {
+        return Array.from(this.state.activeModules.values());
+    }
+    getStats() {
+        const builds = this.state.builds;
+        return {
+            totalBuilds: builds.length,
+            successfulBuilds: builds.filter(b => b.status === 'success').length,
+            failedBuilds: builds.filter(b => b.status === 'error').length,
+            buildingNow: builds.filter(b => b.status === 'building').length,
+            activeModules: this.state.activeModules.size,
+            uptime: Date.now() - this.state.startTime.getTime()
+        };
+    }
+}
+exports.Monitor = Monitor;

package/dist/monitoring/types.d.ts

@@ -0,0 +1,28 @@
+export interface MonitoringConfig {
+    liveRunnerActions: boolean;
+    port?: number;
+    host?: string;
+}
+export type BuildStatus = 'building' | 'success' | 'error';
+export interface BuildRecord {
+    id: string;
+    moduleName: string;
+    modulePath: string;
+    status: BuildStatus;
+    startTime: Date;
+    endTime?: Date;
+    duration?: number;
+    error?: string;
+}
+export interface ActiveModule {
+    name: string;
+    version: string;
+    loadedAt: Date;
+    routeCount: number;
+    status: 'active' | 'error';
+}
+export interface MonitoringState {
+    builds: BuildRecord[];
+    activeModules: Map<string, ActiveModule>;
+    startTime: Date;
+}

package/dist/monitoring/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deployforme/core",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Framework-agnostic runtime module management kernel",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",