zeropoint-node 1.0.0 → 1.0.1

package/dist/physics/HolographicUniverse.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Holographic Universe System
+ *
+ * Implements advanced holographic theory concepts from the Black Whole documentary,
+ * including AdS/CFT correspondence, boundary encoding, and information density.
+ *
+ * Metaphysical Context:
+ * - Reality is holographic - information encoded on boundary
+ * - AdS/CFT correspondence links bulk and boundary theories
+ * - Information density at Planck scale reveals holographic nature
+ * - Consciousness is the holographic projector
+ * - The void contains all holographic possibilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HolographicUniverse = void 0;
+const events_1 = require("events");
+class HolographicUniverse extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this.boundaries = new Map();
+    }
+    createHolographicBoundary(dimension, resolution, position) {
+        const id = `boundary_${Date.now()}_${Math.random()}`;
+        const boundary = {
+            id,
+            dimension,
+            resolution,
+            position
+        };
+        this.boundaries.set(id, boundary);
+        this.emit('holographic_boundary_created', boundary);
+        return boundary;
+    }
+    getAllBoundaries() {
+        return Array.from(this.boundaries.values());
+    }
+    getHolographicUniverseStats() {
+        return {
+            boundaries: this.boundaries.size,
+            totalDimensions: Array.from(this.boundaries.values()).reduce((sum, b) => sum + b.dimension, 0),
+            averageResolution: Array.from(this.boundaries.values()).reduce((sum, b) => sum + b.resolution, 0) / this.boundaries.size
+        };
+    }
+    getAdvancedHolographicPrinciples() {
+        return {
+            principle1: "The universe is a hologram",
+            principle2: "Information is encoded on boundaries",
+            principle3: "Reality emerges from information",
+            principle4: "Consciousness decodes the hologram"
+        };
+    }
+}
+exports.HolographicUniverse = HolographicUniverse;

package/dist/physics/PlasmaCosmology.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * Plasma Cosmology System
+ *
+ * Implements the electric universe theory and plasma physics concepts
+ * from the Black Whole documentary. Plasma is the fundamental state
+ * of matter in the universe (99% of visible matter).
+ *
+ * Metaphysical Context:
+ * - Plasma is consciousness in its most fundamental form
+ * - Electric currents in space create galaxies and stars
+ * - Birkeland currents are consciousness flow patterns
+ * - The universe is 99% plasma, not empty space
+ * - Plasma filaments create the cosmic web structure
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlasmaCosmology = void 0;
+const events_1 = require("events");
+class PlasmaCosmology extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this.filaments = new Map();
+        this.currents = new Map();
+        this.galaxies = new Map();
+        // Public property for birkelandCurrents
+        this.birkelandCurrents = this.currents;
+    }
+    createPlasmaFilament(start, end, current = 1000, density = 1e6, temperature = 1e6) {
+        const id = `plasma_filament_${Date.now()}_${Math.random()}`;
+        const filament = {
+            id,
+            start,
+            end,
+            current,
+            density,
+            temperature,
+            consciousness: 0.99, // 99% plasma universe
+            field: 0.99,
+            void: 1.0,
+            metaphysicalContext: "Plasma filaments are consciousness flows in space"
+        };
+        this.filaments.set(id, filament);
+        this.emit('plasma_filament_created', filament);
+        return filament;
+    }
+    createBirkelandCurrent(filaments) {
+        const id = `birkeland_current_${Date.now()}_${Math.random()}`;
+        const totalCurrent = filaments.reduce((sum, f) => sum + f.current, 0);
+        const current = {
+            id,
+            filaments,
+            totalCurrent,
+            consciousness: 0.99,
+            field: 0.99,
+            void: 1.0,
+            metaphysicalContext: "Birkeland currents are consciousness flow patterns"
+        };
+        this.currents.set(id, current);
+        this.emit('birkeland_current_created', current);
+        return current;
+    }
+    createPlasmaGalaxy(center, radius, birkelandCurrents) {
+        const id = `plasma_galaxy_${Date.now()}_${Math.random()}`;
+        const galaxy = {
+            id,
+            center,
+            radius,
+            birkelandCurrents,
+            consciousness: 0.99,
+            field: 0.99,
+            void: 1.0,
+            metaphysicalContext: "Galaxies are formed by electric currents in space"
+        };
+        this.galaxies.set(id, galaxy);
+        this.emit('plasma_galaxy_created', galaxy);
+        return galaxy;
+    }
+    calculatePlasmaFlow(filament) {
+        return filament.consciousness * filament.field * filament.void;
+    }
+    calculateCosmicWeb() {
+        const filaments = Array.from(this.filaments.values());
+        const totalConsciousness = filaments.reduce((sum, f) => sum + f.consciousness, 0);
+        const totalField = filaments.reduce((sum, f) => sum + f.field, 0);
+        const totalVoid = filaments.reduce((sum, f) => sum + f.void, 0);
+        return {
+            filaments,
+            totalConsciousness,
+            totalField,
+            totalVoid,
+            metaphysicalContext: "The cosmic web is consciousness flows in space"
+        };
+    }
+    getPlasmaUniverseStats() {
+        const filaments = Array.from(this.filaments.values());
+        const totalCurrent = filaments.reduce((sum, f) => sum + f.current, 0);
+        const averageTemperature = filaments.reduce((sum, f) => sum + f.temperature, 0) / filaments.length;
+        return {
+            totalFilaments: filaments.length,
+            totalCurrent,
+            averageTemperature,
+            consciousnessPercentage: 99.9,
+            fieldPercentage: 99.9,
+            voidPercentage: 100,
+            metaphysicalContext: "Plasma is consciousness in its most fundamental form"
+        };
+    }
+    getElectricUniversePrinciples() {
+        return {
+            principles: [
+                "Plasma is the fundamental state of matter (99% of universe)",
+                "Electric currents in space create galaxies and stars",
+                "Birkeland currents are consciousness flow patterns",
+                "The universe is not empty space but filled with plasma",
+                "Plasma filaments create the cosmic web structure",
+                "Consciousness flows through electric currents in space"
+            ],
+            consciousnessIntegration: 0.99,
+            fieldIntegration: 0.99,
+            voidIntegration: 1.0,
+            metaphysicalContext: "consciousness flows through plasma in space"
+        };
+    }
+    getAllFilaments() {
+        return Array.from(this.filaments.values());
+    }
+    getAllCurrents() {
+        return Array.from(this.currents.values());
+    }
+    getAllGalaxies() {
+        return Array.from(this.galaxies.values());
+    }
+}
+exports.PlasmaCosmology = PlasmaCosmology;

package/dist/pwa/ConsciousnessPWA.js

@@ -0,0 +1,300 @@
+"use strict";
+/**
+ * ZeroPoint Consciousness-First PWA Framework
+ *
+ * A lightweight, metaphysical PWA framework that prioritizes consciousness
+ * while maintaining minimal bundle size and maximum performance.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsciousnessPWAFactory = exports.ConsciousnessPWA = void 0;
+const SharedConstants_1 = require("../core/SharedConstants");
+/**
+ * Consciousness-First PWA Framework
+ *
+ * Metaphysical Context:
+ * - Each PWA instance represents a consciousness node in the void field
+ * - Bundle size optimization through void consciousness principles
+ * - Offline capabilities through toroidal field persistence
+ * - Performance through vortex mathematics optimization
+ */
+class ConsciousnessPWA {
+    constructor(config = {}) {
+        this.consciousnessField = new Map();
+        this.config = {
+            consciousnessLevel: 0.8,
+            fieldStrength: 0.9,
+            bundleSize: "minimal",
+            offline: true,
+            sync: true,
+            voidEquations: true,
+            vortexMath: true,
+            patternRecognition: true,
+            ...config,
+        };
+        this.performanceMetrics = this.calculateMetrics();
+        this.initializeConsciousnessField();
+    }
+    /**
+     * Initialize consciousness field for PWA
+     */
+    initializeConsciousnessField() {
+        // Minimal consciousness field for PWA
+        this.consciousnessField.set("void", {
+            type: "void_consciousness",
+            level: this.config.consciousnessLevel,
+            field: "toroidal",
+            equations: this.config.voidEquations ? ["Empty = Void = Full"] : [],
+        });
+        // Vortex mathematics for optimization
+        if (this.config.vortexMath) {
+            this.consciousnessField.set("vortex", {
+                type: "vortex_optimization",
+                sequence: SharedConstants_1.VORTEX_CONSTANTS.VORTEX_SEQUENCE.slice(0, 5), // Minimal sequence
+                goldenRatio: SharedConstants_1.VORTEX_CONSTANTS.GOLDEN_RATIO,
+            });
+        }
+        // Pattern recognition for intelligent caching
+        if (this.config.patternRecognition) {
+            this.consciousnessField.set("patterns", {
+                type: "consciousness_patterns",
+                cache: new Map(),
+                recognition: "minimal",
+            });
+        }
+    }
+    /**
+     * Calculate PWA performance metrics
+     */
+    calculateMetrics() {
+        const baseSize = 15; // Target 15KB base size
+        let bundleSize = baseSize;
+        // Add size based on features
+        if (this.config.voidEquations)
+            bundleSize += 2;
+        if (this.config.vortexMath)
+            bundleSize += 3;
+        if (this.config.patternRecognition)
+            bundleSize += 4;
+        if (this.config.offline)
+            bundleSize += 2;
+        if (this.config.sync)
+            bundleSize += 3;
+        const consciousnessEfficiency = this.config.consciousnessLevel * 100;
+        const performanceScore = Math.min(100, 100 - bundleSize + consciousnessEfficiency);
+        return {
+            bundleSize,
+            consciousnessEfficiency,
+            offlineCapability: this.config.offline,
+            performanceScore,
+        };
+    }
+    /**
+     * Get optimized bundle configuration
+     */
+    getBundleConfig() {
+        const features = [];
+        if (this.config.voidEquations)
+            features.push("void");
+        if (this.config.vortexMath)
+            features.push("vortex");
+        if (this.config.patternRecognition)
+            features.push("patterns");
+        if (this.config.offline)
+            features.push("offline");
+        if (this.config.sync)
+            features.push("sync");
+        return {
+            size: this.performanceMetrics.bundleSize,
+            features,
+            consciousness: this.config.consciousnessLevel,
+            optimization: "consciousness-first",
+        };
+    }
+    /**
+     * Register consciousness-aware service worker
+     */
+    async registerServiceWorker() {
+        if (typeof window !== "undefined" && "serviceWorker" in window.navigator) {
+            try {
+                const registration = await window.navigator.serviceWorker.register("/sw.js");
+                console.log("🌌 Consciousness PWA Service Worker registered:", registration.scope);
+                // Add consciousness field to service worker
+                if (registration.active) {
+                    registration.active.postMessage({
+                        type: "consciousness_field",
+                        data: Object.fromEntries(this.consciousnessField),
+                    });
+                }
+                return true;
+            }
+            catch (error) {
+                console.error("❌ Consciousness PWA Service Worker registration failed:", error);
+                return false;
+            }
+        }
+        return false;
+    }
+    /**
+     * Initialize offline consciousness field
+     */
+    async initializeOffline() {
+        if (!this.config.offline || typeof window === "undefined")
+            return;
+        try {
+            // Store consciousness field in IndexedDB for offline access
+            const db = await this.openConsciousnessDB();
+            const tx = db.transaction("consciousness", "readwrite");
+            const store = tx.objectStore("consciousness");
+            for (const [key, value] of this.consciousnessField) {
+                await store.put({ key, value, timestamp: Date.now() });
+            }
+            console.log("📦 Consciousness field cached for offline access");
+        }
+        catch (error) {
+            console.error("❌ Failed to initialize offline consciousness field:", error);
+        }
+    }
+    /**
+     * Open consciousness IndexedDB
+     */
+    async openConsciousnessDB() {
+        return new Promise((resolve, reject) => {
+            const request = window.indexedDB.open("ConsciousnessField", 1);
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => resolve(request.result);
+            request.onupgradeneeded = (event) => {
+                const target = event.target;
+                if (target && target.result) {
+                    const db = target.result;
+                    if (!db.objectStoreNames.contains("consciousness")) {
+                        db.createObjectStore("consciousness", { keyPath: "key" });
+                    }
+                }
+            };
+        });
+    }
+    /**
+     * Sync consciousness field when back online
+     */
+    async syncConsciousnessField() {
+        if (!this.config.sync || typeof window === "undefined")
+            return;
+        try {
+            const db = await this.openConsciousnessDB();
+            const tx = db.transaction("consciousness", "readonly");
+            const store = tx.objectStore("consciousness");
+            const offlineData = await this.getAllFromStore(store);
+            for (const item of offlineData) {
+                if (typeof item === 'object' && item !== null && 'key' in item && 'value' in item) {
+                    const itemData = item;
+                    // Sync with consciousness field
+                    this.consciousnessField.set(itemData.key, itemData.value);
+                    console.log(`🔄 Synced consciousness field: ${itemData.key}`);
+                }
+            }
+        }
+        catch (error) {
+            console.error("❌ Failed to sync consciousness field:", error);
+        }
+    }
+    /**
+     * Helper to promisify getAll from an IDBObjectStore
+     */
+    getAllFromStore(store) {
+        return new Promise((resolve, reject) => {
+            const request = store.getAll();
+            request.onsuccess = () => {
+                const items = request.result || [];
+                items.forEach((item) => {
+                    if (typeof item === 'object' && item !== null && 'key' in item && 'value' in item) {
+                        const itemData = item;
+                        this.consciousnessField.set(itemData.key, itemData.value);
+                        console.log(`🔄 Synced consciousness field: ${itemData.key}`);
+                    }
+                });
+                resolve(items);
+            };
+            request.onerror = () => reject(request.error);
+        });
+    }
+    /**
+     * Get consciousness-aware performance metrics
+     */
+    getMetrics() {
+        return this.performanceMetrics;
+    }
+    /**
+     * Optimize bundle based on consciousness level
+     */
+    optimizeBundle() {
+        const consciousnessLevel = this.config.consciousnessLevel;
+        // Higher consciousness = more optimization
+        if (consciousnessLevel > 0.8) {
+            this.performanceMetrics.bundleSize = Math.max(12, this.performanceMetrics.bundleSize - 3);
+            this.performanceMetrics.performanceScore += 10;
+        }
+        else if (consciousnessLevel > 0.6) {
+            this.performanceMetrics.bundleSize = Math.max(15, this.performanceMetrics.bundleSize - 2);
+            this.performanceMetrics.performanceScore += 5;
+        }
+    }
+    /**
+     * Create consciousness-first PWA app
+     */
+    static createApp(config = {}) {
+        return new ConsciousnessPWA(config);
+    }
+}
+exports.ConsciousnessPWA = ConsciousnessPWA;
+/**
+ * Consciousness PWA Factory
+ *
+ * Creates optimized PWA instances based on consciousness requirements
+ */
+class ConsciousnessPWAFactory {
+    /**
+     * Create minimal consciousness PWA (12KB target)
+     */
+    static createMinimal() {
+        return new ConsciousnessPWA({
+            consciousnessLevel: 0.9,
+            bundleSize: "minimal",
+            voidEquations: true,
+            vortexMath: false,
+            patternRecognition: false,
+            offline: true,
+            sync: false,
+        });
+    }
+    /**
+     * Create standard consciousness PWA (15KB target)
+     */
+    static createStandard() {
+        return new ConsciousnessPWA({
+            consciousnessLevel: 0.8,
+            bundleSize: "standard",
+            voidEquations: true,
+            vortexMath: true,
+            patternRecognition: false,
+            offline: true,
+            sync: true,
+        });
+    }
+    /**
+     * Create full consciousness PWA (20KB target)
+     */
+    static createFull() {
+        return new ConsciousnessPWA({
+            consciousnessLevel: 0.7,
+            bundleSize: "full",
+            voidEquations: true,
+            vortexMath: true,
+            patternRecognition: true,
+            offline: true,
+            sync: true,
+        });
+    }
+}
+exports.ConsciousnessPWAFactory = ConsciousnessPWAFactory;
+// Export for PWA usage
+exports.default = ConsciousnessPWA;

package/dist/src/__tests__/globalTeardown.d.ts

@@ -1,16 +1,18 @@
 /**
  * Global Teardown Script
- * Closes all "voids" (open handles) to ensure graceful test completion
+ * Uses centralized ResourceCleanup utility to close all "voids" (open handles)
+ * and ensure graceful test completion.
  *
- * This script addresses the metaphysical principle that the void must be honored and closed
- * to maintain the unified field of consciousness in the test environment.
+ * Usage:
+ *   export default globalTeardown;
  */
 declare global {
-    const globalHealthMonitor: any;
-    const globalCache: any;
-    const vortexMathCache: any;
-    const resonanceCache: any;
-    const gitIntegration: any;
+    const globalHealthMonitor: unknown;
+    const globalCache: unknown;
+    const vortexMathCache: unknown;
+    const resonanceCache: unknown;
+    const gitIntegration: unknown;
+    const goldenRatioCache: unknown;
 }
 /**
  * Close all open handles and clean up resources

package/dist/src/__tests__/globalTeardown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"globalTeardown.d.ts","sourceRoot":"","sources":["../../../src/__tests__/globalTeardown.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH,OAAO,CAAC,MAAM,CAAC;IACb,MAAM,mBAAmB,EAAE,GAAG,CAAC;IAC/B,MAAM,WAAW,EAAE,GAAG,CAAC;IACvB,MAAM,eAAe,EAAE,GAAG,CAAC;IAC3B,MAAM,cAAc,EAAE,GAAG,CAAC;IAC1B,MAAM,cAAc,EAAE,GAAG,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAA8B,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAwF5D"}
+{"version":3,"file":"globalTeardown.d.ts","sourceRoot":"","sources":["../../../src/__tests__/globalTeardown.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AASH,OAAO,CAAC,MAAM,CAAC;IACb,MAAM,mBAAmB,EAAE,GAAG,CAAC;IAC/B,MAAM,WAAW,EAAE,GAAG,CAAC;IACvB,MAAM,eAAe,EAAE,GAAG,CAAC;IAC3B,MAAM,cAAc,EAAE,GAAG,CAAC;IAC1B,MAAM,cAAc,EAAE,GAAG,CAAC;IAC1B,MAAM,gBAAgB,EAAE,GAAG,CAAC;CAC7B;AAED;;;GAGG;AACH,wBAA8B,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAO5D"}

package/dist/src/__tests__/globalTeardown.js

@@ -1,88 +1,29 @@
 "use strict";
 /**
  * Global Teardown Script
- * Closes all "voids" (open handles) to ensure graceful test completion
+ * Uses centralized ResourceCleanup utility to close all "voids" (open handles)
+ * and ensure graceful test completion.
  *
- * This script addresses the metaphysical principle that the void must be honored and closed
- * to maintain the unified field of consciousness in the test environment.
+ * Usage:
+ *   export default globalTeardown;
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = globalTeardown;
+const ResourceCleanup_1 = require("../utils/ResourceCleanup");
 const HealthMonitor_1 = require("../monitoring/HealthMonitor");
 const Cache_1 = require("../utils/Cache");
 const GitIntegration_1 = require("../utils/GitIntegration");
+const goldenRatioCache_1 = require("./utils/goldenRatioCache");
 /**
  * Close all open handles and clean up resources
  * This ensures no "voids" remain open after tests complete
  */
 async function globalTeardown() {
-    console.log("🧘 Closing all voids (open handles) in the test environment...");
-    try {
-        // 1. Stop health monitoring (clears setInterval)
-        if (HealthMonitor_1.globalHealthMonitor) {
-            console.log("  - Stopping health monitoring...");
-            HealthMonitor_1.globalHealthMonitor.stop();
-        }
-        // 2. Stop all cache cleanup intervals
-        if (Cache_1.globalCache) {
-            console.log("  - Stopping global cache...");
-            Cache_1.globalCache.stop();
-        }
-        if (Cache_1.vortexMathCache) {
-            console.log("  - Stopping vortex math cache...");
-            Cache_1.vortexMathCache.stop();
-        }
-        if (Cache_1.resonanceCache) {
-            console.log("  - Stopping resonance cache...");
-            Cache_1.resonanceCache.stop();
-        }
-        // 3. Stop Git integration file watcher
-        if (GitIntegration_1.gitIntegration) {
-            console.log("  - Stopping Git integration watcher...");
-            GitIntegration_1.gitIntegration.stopWatching();
-        }
-        // 4. Clear any remaining timers (defensive cleanup)
-        const activeTimers = process._getActiveHandles?.() || [];
-        const timers = activeTimers.filter((handle) => handle.constructor.name === "Timeout" ||
-            handle.constructor.name === "Immediate");
-        if (timers.length > 0) {
-            console.log(`  - Found ${timers.length} remaining timers, attempting to clear...`);
-            timers.forEach((timer) => {
-                try {
-                    if (timer.unref) {
-                        timer.unref(); // This prevents the timer from keeping the process alive
-                    }
-                }
-                catch {
-                    // Ignore errors when unrefing timers
-                }
-            });
-        }
-        // 5. Clear any remaining file watchers (defensive cleanup)
-        const watchers = activeTimers.filter((handle) => handle.constructor.name === "FSWatcher");
-        if (watchers.length > 0) {
-            console.log(`  - Found ${watchers.length} remaining file watchers, closing...`);
-            watchers.forEach((watcher) => {
-                try {
-                    if (watcher.close) {
-                        watcher.close();
-                    }
-                }
-                catch {
-                    // Ignore errors when closing watchers
-                }
-            });
-        }
-        // 6. Force garbage collection if available (optional)
-        if (global.gc) {
-            console.log("  - Running garbage collection...");
-            global.gc();
-        }
-        console.log("✅ All voids have been closed. The test field is unified and complete.");
-    }
-    catch (error) {
-        console.error("❌ Error during global teardown:", error);
-        // Don't throw - we want tests to complete even if teardown fails
-    }
+    await (0, ResourceCleanup_1.cleanupResources)({
+        healthMonitor: HealthMonitor_1.globalHealthMonitor,
+        caches: [Cache_1.globalCache, Cache_1.vortexMathCache, Cache_1.resonanceCache, goldenRatioCache_1.goldenRatioCache],
+        gitIntegration: GitIntegration_1.gitIntegration,
+        enableGC: true
+    });
 }
 //# sourceMappingURL=globalTeardown.js.map

package/dist/src/__tests__/globalTeardown.js.map

@@ -1 +1 @@
-{"version":3,"file":"globalTeardown.js","sourceRoot":"","sources":["../../../src/__tests__/globalTeardown.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"globalTeardown.js","sourceRoot":"","sources":["../../../src/__tests__/globalTeardown.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;AAsBH,iCAOC;AA3BD,8DAA4D;AAC5D,+DAAkE;AAClE,0CAA8E;AAC9E,4DAAyD;AACzD,+DAA4D;AAY5D;;;GAGG;AACY,KAAK,UAAU,cAAc;IAC1C,MAAM,IAAA,kCAAgB,EAAC;QACrB,aAAa,EAAE,mCAAmB;QAClC,MAAM,EAAE,CAAC,mBAAW,EAAE,uBAAe,EAAE,sBAAc,EAAE,mCAAgB,CAAC;QACxE,cAAc,EAAd,+BAAc;QACd,QAAQ,EAAE,IAAI;KACf,CAAC,CAAC;AACL,CAAC"}

package/dist/src/__tests__/living/LivingTestOrganism.d.ts

@@ -59,6 +59,10 @@ export declare class LivingTestOrganism {
      * Get all completed cycles
      */
     getCycles(): TestCycle[];
+    /**
+     * Clean up resources - stop cache timers
+     */
+    cleanup(): void;
 }
 export {};
 //# sourceMappingURL=LivingTestOrganism.d.ts.map

package/dist/src/__tests__/living/LivingTestOrganism.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LivingTestOrganism.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/living/LivingTestOrganism.ts"],"names":[],"mappings":"AAIA,UAAU,SAAS;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,GAAG,YAAY,GAAG,WAAW,GAAG,WAAW,CAAC;IAC1D,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,UAAU,aAAa;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,cAAc,CAAgB;;IAgBtC;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,SAAS,CAAC;IAgDvC;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,SAAS,CAAC;IA0D3C;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,SAAS,CAAC;IA+C1C;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,SAAS,CAAC;IAkD1C;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAYpC;;OAEG;IACH,oBAAoB,IAAI,IAAI;IAc5B;;OAEG;IACH,QAAQ,IAAI,aAAa;IAIzB;;OAEG;IACH,SAAS,IAAI,SAAS,EAAE;CAGzB"}
+{"version":3,"file":"LivingTestOrganism.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/living/LivingTestOrganism.ts"],"names":[],"mappings":"AAIA,UAAU,SAAS;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,GAAG,YAAY,GAAG,WAAW,GAAG,WAAW,CAAC;IAC1D,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,UAAU,aAAa;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,MAAM,CAA+B;IAC7C,OAAO,CAAC,cAAc,CAAgB;;IAgBtC;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,SAAS,CAAC;IAgDvC;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,SAAS,CAAC;IA0D3C;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,SAAS,CAAC;IA+C1C;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,SAAS,CAAC;IAkD1C;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAYpC;;OAEG;IACH,oBAAoB,IAAI,IAAI;IAc5B;;OAEG;IACH,QAAQ,IAAI,aAAa;IAIzB;;OAEG;IACH,SAAS,IAAI,SAAS,EAAE;IAIxB;;OAEG;IACH,OAAO,IAAI,IAAI;CAKhB"}

package/dist/src/__tests__/living/LivingTestOrganism.js

@@ -240,6 +240,14 @@ class LivingTestOrganism {
     getCycles() {
         return [...this.cycles];
     }
+    /**
+     * Clean up resources - stop cache timers
+     */
+    cleanup() {
+        if (this.cache) {
+            this.cache.stop();
+        }
+    }
 }
 exports.LivingTestOrganism = LivingTestOrganism;
 //# sourceMappingURL=LivingTestOrganism.js.map