@jagilber-org/index-server 1.19.1

package/dist/utils/BufferRingExamples.js

@@ -0,0 +1,188 @@
+"use strict";
+/**
+ * BufferRing Usage Examples
+ *
+ * This file demonstrates various use cases for the configurable BufferRing utility,
+ * particularly for log management, metrics collection, and event handling in the
+ * Index Server.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverflowStrategy = exports.BufferRingFactory = exports.BufferRing = exports.LogStreamer = exports.LogViewerService = void 0;
+exports.createLogViewerBuffer = createLogViewerBuffer;
+exports.createMetricsCollector = createMetricsCollector;
+exports.createEventTracker = createEventTracker;
+exports.createToolMetricsBuffer = createToolMetricsBuffer;
+exports.createConfiguredBuffer = createConfiguredBuffer;
+const BufferRing_1 = require("./BufferRing");
+Object.defineProperty(exports, "BufferRing", { enumerable: true, get: function () { return BufferRing_1.BufferRing; } });
+Object.defineProperty(exports, "BufferRingFactory", { enumerable: true, get: function () { return BufferRing_1.BufferRingFactory; } });
+Object.defineProperty(exports, "OverflowStrategy", { enumerable: true, get: function () { return BufferRing_1.OverflowStrategy; } });
+const path_1 = __importDefault(require("path"));
+// Example 1: Log Buffer for Real-time Log Viewer
+function createLogViewerBuffer(logDir) {
+    const logBuffer = BufferRing_1.BufferRingFactory.createLogBuffer(1000, // Keep last 1000 log entries
+    path_1.default.join(logDir, 'log-buffer.json'));
+    // Event handling for log monitoring
+    logBuffer.on('entry-added', (logEntry) => {
+        // Could trigger WebSocket broadcast to connected clients
+        console.log(`New log entry: ${logEntry.slice(0, 100)}...`);
+    });
+    logBuffer.on('buffer-full', () => {
+        console.log('Log buffer is full, oldest entries will be dropped');
+    });
+    return logBuffer;
+}
+// Example 2: Metrics Collection with Periodic Persistence
+function createMetricsCollector(dataDir) {
+    const metricsBuffer = BufferRing_1.BufferRingFactory.createMetricsBuffer(500, path_1.default.join(dataDir, 'metrics-buffer.json'));
+    // Periodic persistence every 30 seconds
+    setInterval(async () => {
+        try {
+            await metricsBuffer.saveToDisk();
+            console.log(`Persisted ${metricsBuffer.getStats().count} metrics entries`);
+        }
+        catch (error) {
+            console.error('Failed to persist metrics:', error);
+        }
+    }, 30000);
+    return metricsBuffer;
+}
+// Example 3: Event Buffer for System Events
+function createEventTracker() {
+    const eventBuffer = BufferRing_1.BufferRingFactory.createEventBuffer(200);
+    // Track various system events
+    eventBuffer.on('entry-added', (event) => {
+        if (event.level === 'error') {
+            console.error('System error event:', event);
+        }
+    });
+    return eventBuffer;
+}
+// Example 4: Custom Tool Metrics Buffer with Memory Management
+function createToolMetricsBuffer() {
+    const toolMetrics = new BufferRing_1.BufferRing({
+        capacity: 1000,
+        overflowStrategy: BufferRing_1.OverflowStrategy.DROP_OLDEST,
+        autoPersist: false,
+        enableIntegrityCheck: false,
+        serializer: (entry) => {
+            const typedEntry = entry;
+            return {
+                ...entry,
+                timestamp: typedEntry.timestamp || new Date().toISOString()
+            };
+        }
+    });
+    // Memory cleanup when buffer gets large
+    toolMetrics.on('buffer-full', () => {
+        // Keep only successful calls from last hour
+        const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000).toISOString();
+        const recentSuccessful = toolMetrics.filter((entry) => entry.success && entry.timestamp > oneHourAgo);
+        toolMetrics.clear();
+        recentSuccessful.forEach(entry => toolMetrics.add(entry));
+        console.log(`Cleaned tool metrics buffer, retained ${recentSuccessful.length} entries`);
+    });
+    return toolMetrics;
+}
+function createConfiguredBuffer(config) {
+    switch (config.type) {
+        case 'log':
+            return BufferRing_1.BufferRingFactory.createLogBuffer(config.capacity, config.persistPath);
+        case 'metrics':
+            return BufferRing_1.BufferRingFactory.createMetricsBuffer(config.capacity, config.persistPath);
+        case 'events':
+            return BufferRing_1.BufferRingFactory.createEventBuffer(config.capacity);
+        case 'custom':
+            return new BufferRing_1.BufferRing({
+                capacity: config.capacity,
+                persistPath: config.persistPath,
+                overflowStrategy: config.overflowStrategy || BufferRing_1.OverflowStrategy.DROP_OLDEST,
+                autoPersist: config.autoPersist || false,
+                enableIntegrityCheck: !!config.persistPath
+            });
+        default:
+            throw new Error(`Unknown buffer type: ${config.type}`);
+    }
+}
+// Example 6: Integration with Log Viewer API
+class LogViewerService {
+    logBuffer;
+    constructor(logDir) {
+        this.logBuffer = createLogViewerBuffer(logDir);
+    }
+    addLogEntry(logLine) {
+        this.logBuffer.add(logLine);
+    }
+    getRecentLogs(count = 100) {
+        return this.logBuffer.getLast(count);
+    }
+    getLogRange(start, end) {
+        return this.logBuffer.getRange(start, end);
+    }
+    searchLogs(pattern) {
+        const regex = new RegExp(pattern, 'i');
+        return this.logBuffer.filter((line) => regex.test(line));
+    }
+    getLogStats() {
+        const stats = this.logBuffer.getStats();
+        return {
+            totalLines: stats.count,
+            bufferUtilization: stats.utilization,
+            memoryUsage: stats.memoryUsage,
+            totalProcessed: stats.totalAdded,
+            droppedLines: stats.totalDropped
+        };
+    }
+    clearLogs() {
+        this.logBuffer.clear();
+    }
+    async persistLogs() {
+        await this.logBuffer.saveToDisk();
+    }
+}
+exports.LogViewerService = LogViewerService;
+// Example 7: Real-time Log Streaming with Buffer
+class LogStreamer {
+    logBuffer;
+    subscribers = new Set();
+    constructor(bufferSize = 500) {
+        this.logBuffer = new BufferRing_1.BufferRing({
+            capacity: bufferSize,
+            overflowStrategy: BufferRing_1.OverflowStrategy.DROP_OLDEST
+        });
+        // Broadcast new entries to all subscribers
+        this.logBuffer.on('entry-added', (logEntry) => {
+            this.subscribers.forEach(callback => {
+                try {
+                    callback(logEntry);
+                }
+                catch (error) {
+                    console.error('Error in log subscriber:', error);
+                }
+            });
+        });
+    }
+    addLog(logEntry) {
+        this.logBuffer.add(logEntry);
+    }
+    subscribe(callback) {
+        this.subscribers.add(callback);
+        // Return unsubscribe function
+        return () => {
+            this.subscribers.delete(callback);
+        };
+    }
+    getBufferSnapshot() {
+        return this.logBuffer.getAll();
+    }
+    getStats() {
+        return {
+            bufferStats: this.logBuffer.getStats(),
+            subscriberCount: this.subscribers.size
+        };
+    }
+}
+exports.LogStreamer = LogStreamer;

package/dist/utils/envUtils.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Utility functions for environment variable parsing
+ */
+export declare const TRUTHY_VALUES: readonly ["1", "true", "yes", "on"];
+export declare const FALSY_VALUES: readonly ["0", "false", "no", "off"];
+export declare const FALSY_VALUES_EXTENDED: readonly ["0", "false", "no", "off", "disabled", "none"];
+export declare const TRUTHY_OR_DEFAULT: readonly ["true", "on", "yes", "default"];
+/**
+ * Check whether a raw string is a recognised truthy value.
+ */
+export declare function isTruthy(value: string | undefined): boolean;
+/**
+ * Check whether a raw string is a recognised falsy value.
+ */
+export declare function isFalsy(value: string | undefined): boolean;
+/**
+ * Extended falsy check that also recognises "disabled" and "none".
+ */
+export declare function isFalsyExtended(value: string | undefined): boolean;
+/**
+ * Returns true when DEBUG or VERBOSE_LOGGING env flags are set.
+ * Consolidates the repeated `process.env.INDEX_SERVER_DEBUG === '1' ||
+ * process.env.INDEX_SERVER_VERBOSE_LOGGING === '1'` check.
+ */
+export declare function isDebugOrVerbose(): boolean;
+/**
+ * Parse a boolean environment variable that accepts multiple truthy/falsy values:
+ * - Truthy: "1", "true", "yes", "on" (case insensitive)
+ * - Falsy: "0", "false", "no", "off" (case insensitive) or undefined/empty
+ *
+ * @param envVar - The environment variable value
+ * @param defaultValue - Default value if envVar is undefined/empty (default: false)
+ * @returns boolean value
+ */
+export declare function parseBooleanEnv(envVar: string | undefined, defaultValue?: boolean): boolean;
+/**
+ * Get a boolean environment variable with consistent parsing
+ * @param name - Environment variable name
+ * @param defaultValue - Default value if not set (default: false)
+ * @returns boolean value
+ */
+export declare function getBooleanEnv(name: string, defaultValue?: boolean): boolean;

package/dist/utils/envUtils.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * Utility functions for environment variable parsing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRUTHY_OR_DEFAULT = exports.FALSY_VALUES_EXTENDED = exports.FALSY_VALUES = exports.TRUTHY_VALUES = void 0;
+exports.isTruthy = isTruthy;
+exports.isFalsy = isFalsy;
+exports.isFalsyExtended = isFalsyExtended;
+exports.isDebugOrVerbose = isDebugOrVerbose;
+exports.parseBooleanEnv = parseBooleanEnv;
+exports.getBooleanEnv = getBooleanEnv;
+// ── Canonical truthy / falsy value sets ──────────────────────────────
+exports.TRUTHY_VALUES = ['1', 'true', 'yes', 'on'];
+exports.FALSY_VALUES = ['0', 'false', 'no', 'off'];
+exports.FALSY_VALUES_EXTENDED = ['0', 'false', 'no', 'off', 'disabled', 'none'];
+exports.TRUTHY_OR_DEFAULT = ['true', 'on', 'yes', 'default'];
+/**
+ * Check whether a raw string is a recognised truthy value.
+ */
+function isTruthy(value) {
+    if (!value)
+        return false;
+    return exports.TRUTHY_VALUES.includes(value.toLowerCase().trim());
+}
+/**
+ * Check whether a raw string is a recognised falsy value.
+ */
+function isFalsy(value) {
+    if (!value)
+        return false;
+    return exports.FALSY_VALUES.includes(value.toLowerCase().trim());
+}
+/**
+ * Extended falsy check that also recognises "disabled" and "none".
+ */
+function isFalsyExtended(value) {
+    if (!value)
+        return false;
+    return exports.FALSY_VALUES_EXTENDED.includes(value.toLowerCase().trim());
+}
+/**
+ * Returns true when DEBUG or VERBOSE_LOGGING env flags are set.
+ * Consolidates the repeated `process.env.INDEX_SERVER_DEBUG === '1' ||
+ * process.env.INDEX_SERVER_VERBOSE_LOGGING === '1'` check.
+ */
+function isDebugOrVerbose() {
+    return process.env.INDEX_SERVER_DEBUG === '1' || process.env.INDEX_SERVER_VERBOSE_LOGGING === '1';
+}
+/**
+ * Parse a boolean environment variable that accepts multiple truthy/falsy values:
+ * - Truthy: "1", "true", "yes", "on" (case insensitive)
+ * - Falsy: "0", "false", "no", "off" (case insensitive) or undefined/empty
+ *
+ * @param envVar - The environment variable value
+ * @param defaultValue - Default value if envVar is undefined/empty (default: false)
+ * @returns boolean value
+ */
+function parseBooleanEnv(envVar, defaultValue = false) {
+    if (!envVar)
+        return defaultValue;
+    const normalized = envVar.toLowerCase().trim();
+    if (exports.TRUTHY_VALUES.includes(normalized)) {
+        return true;
+    }
+    if (exports.FALSY_VALUES.includes(normalized)) {
+        return false;
+    }
+    // Unknown values default to false
+    return defaultValue;
+}
+/**
+ * Get a boolean environment variable with consistent parsing
+ * @param name - Environment variable name
+ * @param defaultValue - Default value if not set (default: false)
+ * @returns boolean value
+ */
+function getBooleanEnv(name, defaultValue = false) {
+    return parseBooleanEnv(process.env[name], defaultValue);
+}

package/dist/utils/memoryMonitor.d.ts

@@ -0,0 +1,83 @@
+interface MemorySnapshot {
+    timestamp: number;
+    heapUsed: number;
+    heapTotal: number;
+    external: number;
+    arrayBuffers: number;
+    rss: number;
+    pid: number;
+}
+interface MemoryTrend {
+    snapshots: MemorySnapshot[];
+    leakDetected: boolean;
+    growthRate: number;
+    recommendation: string;
+}
+declare class MemoryMonitor {
+    private snapshots;
+    private maxSnapshots;
+    private intervalId?;
+    private isMonitoring;
+    /**
+     * Start continuous memory monitoring
+     */
+    startMonitoring(intervalMs?: number): void;
+    /**
+     * Stop monitoring
+     */
+    stopMonitoring(): void;
+    /**
+     * Take a memory snapshot
+     */
+    takeSnapshot(): MemorySnapshot;
+    /**
+     * Get current memory status
+     */
+    getCurrentStatus(): string;
+    /**
+     * Analyze memory trends for potential leaks
+     */
+    analyzeTrends(windowMinutes?: number): MemoryTrend;
+    /**
+     * Get detailed memory report
+     */
+    getDetailedReport(): string;
+    /**
+     * Take heap snapshot (requires --expose-gc)
+     */
+    takeHeapSnapshot(): string | null;
+    /**
+     * Monitor event listeners for potential leaks
+     */
+    checkEventListeners(): string;
+    private formatBytes;
+}
+/**
+ * Get or create global memory monitor instance
+ */
+export declare function getMemoryMonitor(): MemoryMonitor;
+/**
+ * Quick memory status check
+ */
+export declare function memStatus(): void;
+/**
+ * Start memory monitoring
+ */
+export declare function startMemWatch(intervalMs?: number): void;
+/**
+ * Stop memory monitoring
+ */
+export declare function stopMemWatch(): void;
+/**
+ * Get memory report
+ */
+export declare function memReport(): void;
+/**
+ * Force garbage collection and show memory
+ */
+export declare function forceGC(): void;
+/**
+ * Check event listeners
+ */
+export declare function checkListeners(): void;
+export { MemoryMonitor, MemorySnapshot, MemoryTrend };

package/dist/utils/memoryMonitor.js

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryMonitor = void 0;
+exports.getMemoryMonitor = getMemoryMonitor;
+exports.memStatus = memStatus;
+exports.startMemWatch = startMemWatch;
+exports.stopMemWatch = stopMemWatch;
+exports.memReport = memReport;
+exports.forceGC = forceGC;
+exports.checkListeners = checkListeners;
+/**
+ * Memory Monitoring Utilities for MCP Server
+ *
+ * Provides comprehensive memory leak detection and monitoring tools.
+ * Use while attached to debugger for real-time memory analysis.
+ */
+const envUtils_1 = require("./envUtils");
+class MemoryMonitor {
+    snapshots = [];
+    maxSnapshots = 1000;
+    intervalId;
+    isMonitoring = false;
+    /**
+     * Start continuous memory monitoring
+     */
+    startMonitoring(intervalMs = 5000) {
+        if (this.isMonitoring) {
+            console.error('[MemoryMonitor] Already monitoring');
+            return;
+        }
+        console.error(`[MemoryMonitor] Starting memory monitoring (interval: ${intervalMs}ms)`);
+        this.isMonitoring = true;
+        this.intervalId = setInterval(() => {
+            this.takeSnapshot();
+        }, intervalMs);
+        // Take initial snapshot
+        this.takeSnapshot();
+    }
+    /**
+     * Stop monitoring
+     */
+    stopMonitoring() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = undefined;
+        }
+        this.isMonitoring = false;
+        console.error('[MemoryMonitor] Stopped monitoring');
+    }
+    /**
+     * Take a memory snapshot
+     */
+    takeSnapshot() {
+        const memUsage = process.memoryUsage();
+        const snapshot = {
+            timestamp: Date.now(),
+            heapUsed: memUsage.heapUsed,
+            heapTotal: memUsage.heapTotal,
+            external: memUsage.external,
+            arrayBuffers: memUsage.arrayBuffers,
+            rss: memUsage.rss,
+            pid: process.pid
+        };
+        this.snapshots.push(snapshot);
+        // Trim old snapshots
+        if (this.snapshots.length > this.maxSnapshots) {
+            this.snapshots.shift();
+        }
+        // Log significant changes
+        if (this.snapshots.length > 1) {
+            const previous = this.snapshots[this.snapshots.length - 2];
+            const heapGrowth = snapshot.heapUsed - previous.heapUsed;
+            const rssGrowth = snapshot.rss - previous.rss;
+            if (Math.abs(heapGrowth) > 1024 * 1024 || Math.abs(rssGrowth) > 5 * 1024 * 1024) {
+                const payload = {
+                    ts: snapshot.timestamp,
+                    level: 'info',
+                    src: 'memory',
+                    event: 'delta',
+                    heapDelta: heapGrowth,
+                    heapUsed: snapshot.heapUsed,
+                    rssDelta: rssGrowth,
+                    rss: snapshot.rss,
+                    pid: snapshot.pid
+                };
+                // Structured logging piggybacks on existing debug/verbose flags to avoid introducing new env flags.
+                const wantStructured = (0, envUtils_1.isDebugOrVerbose)();
+                try {
+                    if (wantStructured) {
+                        console.error(JSON.stringify(payload));
+                    }
+                    else {
+                        // Fallback concise plain text (single line) to preserve readability and avoid multi-line noise.
+                        console.error(`[MemoryMonitor] heapDelta=${this.formatBytes(heapGrowth)} heapUsed=${this.formatBytes(snapshot.heapUsed)} rssDelta=${this.formatBytes(rssGrowth)} rss=${this.formatBytes(snapshot.rss)}`);
+                    }
+                }
+                catch { /* swallow */ }
+            }
+        }
+        return snapshot;
+    }
+    /**
+     * Get current memory status
+     */
+    getCurrentStatus() {
+        const memUsage = process.memoryUsage();
+        return `Memory Status (PID: ${process.pid}):
+  Heap Used: ${this.formatBytes(memUsage.heapUsed)}
+  Heap Total: ${this.formatBytes(memUsage.heapTotal)}
+  RSS: ${this.formatBytes(memUsage.rss)}
+  External: ${this.formatBytes(memUsage.external)}
+  Array Buffers: ${this.formatBytes(memUsage.arrayBuffers)}`;
+    }
+    /**
+     * Analyze memory trends for potential leaks
+     */
+    analyzeTrends(windowMinutes = 10) {
+        const windowMs = windowMinutes * 60 * 1000;
+        const cutoff = Date.now() - windowMs;
+        const recentSnapshots = this.snapshots.filter(s => s.timestamp >= cutoff);
+        if (recentSnapshots.length < 3) {
+            return {
+                snapshots: recentSnapshots,
+                leakDetected: false,
+                growthRate: 0,
+                recommendation: 'Need more data points for analysis'
+            };
+        }
+        // Calculate growth rate (bytes per second)
+        const first = recentSnapshots[0];
+        const last = recentSnapshots[recentSnapshots.length - 1];
+        const timeDiff = (last.timestamp - first.timestamp) / 1000; // seconds
+        const heapGrowth = last.heapUsed - first.heapUsed;
+        const growthRate = heapGrowth / timeDiff;
+        // Detect potential leak (consistent growth > 100KB/minute)
+        const leakThreshold = (100 * 1024) / 60; // bytes per second
+        const leakDetected = growthRate > leakThreshold;
+        let recommendation = '';
+        if (leakDetected) {
+            recommendation = `⚠️  Potential memory leak detected! Growth rate: ${this.formatBytes(growthRate * 60)}/minute`;
+        }
+        else if (growthRate > 0) {
+            recommendation = `✅ Memory growth within normal range: ${this.formatBytes(growthRate * 60)}/minute`;
+        }
+        else {
+            recommendation = `✅ Memory usage stable or decreasing`;
+        }
+        return {
+            snapshots: recentSnapshots,
+            leakDetected,
+            growthRate,
+            recommendation
+        };
+    }
+    /**
+     * Get detailed memory report
+     */
+    getDetailedReport() {
+        const trend = this.analyzeTrends();
+        const current = this.getCurrentStatus();
+        return `
+=== MEMORY MONITOR REPORT ===
+${current}
+
+=== TREND ANALYSIS (10 min window) ===
+${trend.recommendation}
+Growth Rate: ${this.formatBytes(trend.growthRate * 60)}/minute
+Snapshots: ${trend.snapshots.length}
+Leak Detected: ${trend.leakDetected ? 'YES' : 'NO'}
+
+=== DEBUGGING TIPS ===
+1. Force GC: global.gc() (if --expose-gc flag used)
+2. Heap snapshot: takeHeapSnapshot()
+3. Check event listeners: process.listeners()
+4. Monitor specific objects with WeakRef
+`;
+    }
+    /**
+     * Take heap snapshot (requires --expose-gc)
+     */
+    takeHeapSnapshot() {
+        try {
+            if (typeof global.gc === 'function') {
+                global.gc();
+                console.error('[MemoryMonitor] Forced garbage collection');
+            }
+            // Note: This would require v8 module for actual heap snapshots
+            // For now, just return memory usage after GC
+            const afterGC = process.memoryUsage();
+            return `Heap snapshot taken. Memory after GC: ${this.formatBytes(afterGC.heapUsed)}`;
+        }
+        catch (error) {
+            return `Heap snapshot failed: ${error}. Start with --expose-gc flag for full functionality.`;
+        }
+    }
+    /**
+     * Monitor event listeners for potential leaks
+     */
+    checkEventListeners() {
+        const process_listeners = process.eventNames().map(name => ({
+            event: String(name),
+            count: process.listenerCount(name)
+        }));
+        return `Event Listeners:
+${process_listeners.map(l => `  ${l.event}: ${l.count}`).join('\n')}`;
+    }
+    formatBytes(bytes) {
+        if (bytes === 0)
+            return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(Math.abs(bytes)) / Math.log(k));
+        const sign = bytes < 0 ? '-' : '';
+        return `${sign}${parseFloat((Math.abs(bytes) / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+    }
+}
+exports.MemoryMonitor = MemoryMonitor;
+// Global instance
+let globalMemoryMonitor = null;
+/**
+ * Get or create global memory monitor instance
+ */
+function getMemoryMonitor() {
+    if (!globalMemoryMonitor) {
+        globalMemoryMonitor = new MemoryMonitor();
+    }
+    return globalMemoryMonitor;
+}
+/**
+ * Quick memory status check
+ */
+function memStatus() {
+    console.error(getMemoryMonitor().getCurrentStatus());
+}
+/**
+ * Start memory monitoring
+ */
+function startMemWatch(intervalMs = 5000) {
+    getMemoryMonitor().startMonitoring(intervalMs);
+}
+/**
+ * Stop memory monitoring
+ */
+function stopMemWatch() {
+    getMemoryMonitor().stopMonitoring();
+}
+/**
+ * Get memory report
+ */
+function memReport() {
+    console.error(getMemoryMonitor().getDetailedReport());
+}
+/**
+ * Force garbage collection and show memory
+ */
+function forceGC() {
+    const result = getMemoryMonitor().takeHeapSnapshot();
+    console.error(result);
+}
+/**
+ * Check event listeners
+ */
+function checkListeners() {
+    console.error(getMemoryMonitor().checkEventListeners());
+}
+// Global exports for debugger console
+if (typeof global !== 'undefined') {
+    const globalAny = global;
+    globalAny.memStatus = memStatus;
+    globalAny.startMemWatch = startMemWatch;
+    globalAny.stopMemWatch = stopMemWatch;
+    globalAny.memReport = memReport;
+    globalAny.forceGC = forceGC;
+    globalAny.checkListeners = checkListeners;
+}

package/dist/versioning/schemaVersion.d.ts

@@ -0,0 +1,6 @@
+export declare const SCHEMA_VERSION = "4";
+export interface MigrationResult {
+    changed: boolean;
+    notes?: string[];
+}
+export declare function migrateInstructionRecord(rec: Record<string, unknown>): MigrationResult;