xypriss 1.0.1 → 1.1.0

package/dist/esm/mods/security/src/components/secure-object/core/secure-object-core.js

@@ -0,0 +1,1603 @@
+import { SecureBuffer } from '../../secure-memory.js';
+import { memoryManager, MemoryUtils } from '../../../utils/memory/index.js';
+import { SensitiveKeysManager } from '../encryption/sensitive-keys.js';
+import { CryptoHandler } from '../encryption/crypto-handler.js';
+import { MetadataManager } from '../metadata/metadata-manager.js';
+import { EventManager } from '../events/event-manager.js';
+import { SerializationHandler } from '../serialization/serialization-handler.js';
+import { IdGenerator } from '../utils/id-generator.js';
+import { ValidationUtils } from '../utils/validation.js';
+import { SecureString } from '../../secure-string/core/secure-string-core.js';
+import 'crypto';
+import '../../secure-string/advanced/entropy-analyzer.js';
+import '../../secure-string/advanced/quantum-safe.js';
+import '../../secure-string/advanced/performance-monitor.js';
+import { MemoryEventType, PoolStrategy } from '../../../utils/memory/types.js';
+
+/***************************************************************************
+ * XyPrissSecurity - Secure Array Types
+ *
+ * This file contains type definitions for the SecureArray modular architecture
+ *
+ * @author Nehonix
+ *
+ * @license MIT
+ *
+ * Copyright (c) 2025 Nehonix. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ ***************************************************************************** */
+/**
+ * A secure object that can store sensitive data
+ * T represents the initial type, but the object can be extended with additional keys
+ */
+class SecureObject {
+    /**
+     * Creates a new secure object
+     */
+    constructor(initialData, options) {
+        // Core data storage
+        this.data = new Map();
+        this.secureBuffers = new Map();
+        // State management
+        this._isDestroyed = false;
+        this._isReadOnly = false;
+        // Enhanced memory management
+        this._memoryTracking = false;
+        this._autoCleanup = false;
+        this._createdAt = Date.now();
+        this._lastAccessed = Date.now();
+        this._id = IdGenerator.generate();
+        this._isReadOnly = false; // Start as writable
+        // Initialize modular components
+        this.sensitiveKeysManager = new SensitiveKeysManager();
+        this.cryptoHandler = new CryptoHandler(this._id);
+        this.metadataManager = new MetadataManager();
+        this.eventManager = new EventManager();
+        this.serializationHandler = new SerializationHandler(this.cryptoHandler, this.metadataManager);
+        // Set encryption key if provided
+        if (options?.encryptionKey) {
+            this.cryptoHandler.setEncryptionKey(options.encryptionKey);
+        }
+        // Configure memory management with enhanced features
+        this._memoryTracking = options?.enableMemoryTracking ?? true; // Enable by default
+        this._autoCleanup = options?.autoCleanup ?? true; // Enable by default
+        // Set memory limits if provided
+        if (options?.maxMemory) {
+            memoryManager.setLimits(options.maxMemory, options.gcThreshold || 0.8);
+        }
+        // Register with advanced memory manager if tracking is enabled
+        if (this._memoryTracking) {
+            memoryManager.registerObject(this, this._id);
+            // Listen to memory events for proactive management
+            memoryManager.on(MemoryEventType.MEMORY_PRESSURE, (event) => {
+                if (event.data?.pressure > 0.8) {
+                    this.handleMemoryPressure();
+                }
+            });
+            memoryManager.on(MemoryEventType.LEAK_DETECTED, (event) => {
+                if (event.data?.leaks?.includes(this._id)) {
+                    console.warn(`Potential memory leak detected in SecureObject ${this._id}`);
+                }
+            });
+        }
+        // Create memory pool for secure buffers if not exists
+        this.initializeSecureBufferPool();
+        // Set initial data
+        if (initialData) {
+            this.setAll(initialData);
+        }
+        // Set read-only status after initial data is set
+        this._isReadOnly = options?.readOnly ?? false;
+    }
+    /**
+     * Creates a SecureObject from another SecureObject (deep copy)
+     */
+    static from(other) {
+        other.ensureNotDestroyed();
+        const copy = new SecureObject();
+        for (const key of other.keys()) {
+            const value = other.get(key);
+            copy.set(String(key), value);
+        }
+        return copy;
+    }
+    /**
+     * Creates a read-only SecureObject
+     */
+    static readOnly(data) {
+        return new SecureObject(data, { readOnly: true });
+    }
+    /**
+     * Creates a read-only SecureObject (public usage)
+     */
+    /** Permanently enable read-only mode (cannot be disabled). */
+    enableReadOnly() {
+        this.ensureNotDestroyed();
+        this._isReadOnly = true;
+        return this;
+    }
+    // ===== PROPERTY ACCESSORS =====
+    /**
+     * Gets the unique ID of this SecureObject
+     */
+    get id() {
+        return this._id;
+    }
+    /**
+     * Checks if the SecureObject is read-only
+     */
+    get isReadOnly() {
+        return this._isReadOnly;
+    }
+    /**
+     * Checks if the SecureObject has been destroyed
+     */
+    get isDestroyed() {
+        return this._isDestroyed;
+    }
+    /**
+     * Gets the number of stored values
+     */
+    get size() {
+        this.ensureNotDestroyed();
+        return this.data.size;
+    }
+    /**
+     * Checks if the object is empty
+     */
+    get isEmpty() {
+        this.ensureNotDestroyed();
+        return this.data.size === 0;
+    }
+    // ===== VALIDATION METHODS =====
+    /**
+     * Ensures the SecureObject hasn't been destroyed
+     */
+    ensureNotDestroyed() {
+        if (this._isDestroyed) {
+            throw new Error("SecureObject has been destroyed and cannot be used");
+        }
+    }
+    /**
+     * Ensures the SecureObject is not read-only for write operations
+     */
+    ensureNotReadOnly() {
+        if (this._isReadOnly) {
+            throw new Error("SecureObject is read-only");
+        }
+    }
+    /**
+     * Updates the last accessed timestamp for memory management
+     */
+    updateLastAccessed() {
+        this._lastAccessed = Date.now();
+    }
+    // ===== MEMORY MANAGEMENT =====
+    /**
+     * Initialize secure buffer pool for efficient memory reuse
+     */
+    initializeSecureBufferPool() {
+        if (!this.secureBufferPool) {
+            try {
+                this.secureBufferPool =
+                    memoryManager.getPool("secure-buffer-pool") ||
+                        memoryManager.createPool({
+                            name: "secure-buffer-pool",
+                            factory: () => new Uint8Array(1024), // 1KB buffers
+                            reset: (buffer) => {
+                                // Secure wipe before reuse
+                                this.secureWipe(buffer);
+                            },
+                            capacity: 50,
+                            strategy: PoolStrategy.LRU,
+                            validator: (buffer) => buffer instanceof Uint8Array,
+                        });
+            }
+            catch (error) {
+                // Pool might already exist, try to get it
+                this.secureBufferPool =
+                    memoryManager.getPool("secure-buffer-pool");
+            }
+        }
+    }
+    /**
+     * Handle memory pressure situations
+     */
+    handleMemoryPressure() {
+        if (this._autoCleanup) {
+            // Clean up unused secure buffers
+            this.forceGarbageCollection();
+            // Emit event for external handlers
+            this.eventManager.emit("gc", undefined, {
+                timestamp: Date.now(),
+                objectId: this._id,
+                action: "memory_pressure_cleanup",
+            });
+        }
+    }
+    /**
+     * Secure wipe of buffer memory
+     */
+    secureWipe(buffer) {
+        if (!buffer || buffer.length === 0)
+            return;
+        // Multiple-pass secure wipe
+        const passes = [0x00, 0xff, 0xaa, 0x55, 0x00];
+        for (const pattern of passes) {
+            buffer.fill(pattern);
+        }
+        // Final random pass if crypto is available
+        if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+            crypto.getRandomValues(buffer);
+        }
+        buffer.fill(0x00); // Final zero pass
+    }
+    /**
+     * Gets enhanced memory usage statistics for this SecureObject
+     */
+    getMemoryUsage() {
+        this.ensureNotDestroyed();
+        let allocatedMemory = 0;
+        for (const buffer of this.secureBuffers.values()) {
+            allocatedMemory += buffer.length();
+        }
+        const now = Date.now();
+        const usage = {
+            allocatedMemory,
+            bufferCount: this.secureBuffers.size,
+            dataSize: this.data.size,
+            createdAt: this._createdAt,
+            lastAccessed: this._lastAccessed,
+            age: now - this._createdAt,
+            formattedMemory: MemoryUtils.formatBytes(allocatedMemory),
+            poolStats: this.secureBufferPool?.getStats(),
+        };
+        return usage;
+    }
+    /**
+     * Forces enhanced garbage collection for this SecureObject
+     */
+    forceGarbageCollection() {
+        this.ensureNotDestroyed();
+        if (this._memoryTracking) {
+            const beforeUsage = this.getMemoryUsage();
+            // Clean up unused secure buffers with secure wipe
+            for (const [key, buffer] of this.secureBuffers.entries()) {
+                if (!this.data.has(key)) {
+                    // Secure wipe before destroying (get buffer data safely)
+                    try {
+                        const bufferData = buffer.getBuffer(); // Use correct method
+                        if (bufferData instanceof Uint8Array) {
+                            this.secureWipe(bufferData);
+                        }
+                    }
+                    catch (error) {
+                        // Buffer might already be destroyed, continue
+                    }
+                    buffer.destroy();
+                    this.secureBuffers.delete(key);
+                }
+            }
+            // Return unused buffers to pool
+            if (this.secureBufferPool) ;
+            // Trigger global GC with enhanced features
+            const gcResult = memoryManager.forceGC();
+            const afterUsage = this.getMemoryUsage();
+            const freedMemory = beforeUsage.allocatedMemory - afterUsage.allocatedMemory;
+            this.eventManager.emit("gc", undefined, {
+                timestamp: Date.now(),
+                bufferCount: this.secureBuffers.size,
+                freedMemory,
+                gcDuration: gcResult.duration,
+                gcSuccess: gcResult.success,
+                beforeUsage: beforeUsage.formattedMemory,
+                afterUsage: afterUsage.formattedMemory,
+            });
+        }
+    }
+    /**
+     * Enables memory tracking for this SecureObject
+     */
+    enableMemoryTracking() {
+        this.ensureNotDestroyed();
+        if (!this._memoryTracking) {
+            this._memoryTracking = true;
+            memoryManager.registerObject(this, this._id);
+        }
+        return this;
+    }
+    /**
+     * Disables memory tracking for this SecureObject
+     */
+    disableMemoryTracking() {
+        this.ensureNotDestroyed();
+        if (this._memoryTracking) {
+            this._memoryTracking = false;
+            memoryManager.removeReference(this._id);
+        }
+        return this;
+    }
+    // ===== SENSITIVE KEYS MANAGEMENT =====
+    /**
+     * Adds keys to the sensitive keys list
+     */
+    addSensitiveKeys(...keys) {
+        this.ensureNotDestroyed();
+        ValidationUtils.validateKeys(keys);
+        this.sensitiveKeysManager.add(...keys);
+        return this;
+    }
+    /**
+     * Removes keys from the sensitive keys list
+     */
+    removeSensitiveKeys(...keys) {
+        this.ensureNotDestroyed();
+        ValidationUtils.validateKeys(keys);
+        this.sensitiveKeysManager.remove(...keys);
+        return this;
+    }
+    /**
+     * Sets the complete list of sensitive keys (replaces existing list)
+     */
+    setSensitiveKeys(keys) {
+        this.ensureNotDestroyed();
+        ValidationUtils.validateKeys(keys);
+        this.sensitiveKeysManager.set(keys);
+        return this;
+    }
+    /**
+     * Gets the current list of sensitive keys
+     */
+    getSensitiveKeys() {
+        this.ensureNotDestroyed();
+        return this.sensitiveKeysManager.getAll();
+    }
+    /**
+     * Checks if a key is marked as sensitive
+     */
+    isSensitiveKey(key) {
+        ValidationUtils.validateKey(key);
+        return this.sensitiveKeysManager.isSensitive(key);
+    }
+    /**
+     * Clears all sensitive keys
+     */
+    clearSensitiveKeys() {
+        this.ensureNotDestroyed();
+        this.sensitiveKeysManager.clear();
+        return this;
+    }
+    /**
+     * Resets sensitive keys to default values
+     */
+    resetToDefaultSensitiveKeys() {
+        this.ensureNotDestroyed();
+        this.sensitiveKeysManager.resetToDefault();
+        return this;
+    }
+    /**
+     * Gets the default sensitive keys that are automatically initialized
+     */
+    static get getDefaultSensitiveKeys() {
+        return SensitiveKeysManager.getDefaultKeys();
+    }
+    /**
+     * Adds custom regex patterns for sensitive key detection
+     * @param patterns - Regex patterns or strings to match sensitive keys
+     */
+    addSensitivePatterns(...patterns) {
+        this.ensureNotDestroyed();
+        this.sensitiveKeysManager.addCustomPatterns(...patterns);
+        return this;
+    }
+    /**
+     * Removes custom sensitive patterns
+     */
+    removeSensitivePatterns(...patterns) {
+        this.ensureNotDestroyed();
+        this.sensitiveKeysManager.removeCustomPatterns(...patterns);
+        return this;
+    }
+    /**
+     * Clears all custom sensitive patterns
+     */
+    clearSensitivePatterns() {
+        this.ensureNotDestroyed();
+        this.sensitiveKeysManager.clearCustomPatterns();
+        return this;
+    }
+    /**
+     * Gets all custom sensitive patterns
+     */
+    getSensitivePatterns() {
+        this.ensureNotDestroyed();
+        return this.sensitiveKeysManager.getCustomPatterns();
+    }
+    // ===== ENCRYPTION MANAGEMENT =====
+    /**
+     * Sets the encryption key for sensitive data encryption
+     */
+    setEncryptionKey(key = null) {
+        this.ensureNotDestroyed();
+        ValidationUtils.validateEncryptionKey(key);
+        this.cryptoHandler.setEncryptionKey(key);
+        return this;
+    }
+    /**
+     * Gets the current encryption key
+     */
+    get getEncryptionKey() {
+        return this.cryptoHandler.getEncryptionKey();
+    }
+    /**
+     * Decrypts a value using the encryption key
+     */
+    decryptValue(encryptedValue) {
+        this.ensureNotDestroyed();
+        return this.cryptoHandler.decryptValue(encryptedValue);
+    }
+    /**
+     * Decrypts all encrypted values in an object
+     */
+    decryptObject(obj) {
+        this.ensureNotDestroyed();
+        return this.cryptoHandler.decryptObject(obj);
+    }
+    /**
+     * Encrypts all values in the object using AES-256-CTR-HMAC encryption
+     * with proper memory management and atomic operations
+     */
+    encryptAll() {
+        this.ensureNotDestroyed();
+        this.ensureNotReadOnly();
+        // Check if encryption key is set
+        const encryptionStatus = this.cryptoHandler.getEncryptionStatus();
+        if (!encryptionStatus.hasEncryptionKey) {
+            throw new Error("Encryption key must be set before calling encryptAll()");
+        }
+        // Prepare temporary map for atomic operation
+        const encryptedEntries = new Map();
+        const originalMetadata = new Map();
+        const keysToProcess = [];
+        try {
+            // First pass: encrypt all values into temporary storage
+            for (const [key, value] of this.data.entries()) {
+                if (value !== undefined) {
+                    // Skip already encrypted values to avoid double encryption
+                    if (typeof value === "string" &&
+                        this.cryptoHandler.isEncrypted(value)) {
+                        continue;
+                    }
+                    // Store original metadata for rollback
+                    if (this.metadataManager.has(key)) {
+                        originalMetadata.set(key, this.metadataManager.get(key));
+                    }
+                    // Get the actual value to encrypt
+                    let valueToEncrypt = value;
+                    // If it's a SecureBuffer, convert it back to its original form
+                    if (value instanceof SecureBuffer) {
+                        const metadata = this.metadataManager.get(key);
+                        if (metadata?.type === "string") {
+                            valueToEncrypt = new TextDecoder().decode(value.getBuffer());
+                        }
+                        else if (metadata?.type === "Uint8Array") {
+                            valueToEncrypt = new Uint8Array(value.getBuffer());
+                        }
+                        else {
+                            valueToEncrypt = new TextDecoder().decode(value.getBuffer());
+                        }
+                    }
+                    // Encrypt the value
+                    const encryptedValue = this.cryptoHandler.encryptValue(valueToEncrypt);
+                    encryptedEntries.set(key, encryptedValue);
+                    keysToProcess.push(key);
+                }
+            }
+            // Second pass: atomically commit all changes
+            for (const key of keysToProcess) {
+                const encryptedValue = encryptedEntries.get(key);
+                const originalValue = this.data.get(key);
+                // Clean up any existing SecureBuffer for this key
+                this.cleanupKey(key);
+                // Store encrypted value
+                this.data.set(key, encryptedValue);
+                // Update metadata with correct type information
+                // Store original type in the type field using special format
+                const originalType = typeof originalValue;
+                this.metadataManager.update(key, `encrypted:${originalType}`, true);
+            }
+        }
+        catch (error) {
+            // Rollback: restore original state on any failure
+            for (const key of keysToProcess) {
+                if (originalMetadata.has(key)) {
+                    // Restore original metadata
+                    const original = originalMetadata.get(key);
+                    this.metadataManager.update(key, original.type, original.isSecure);
+                }
+            }
+            throw new Error(`Encryption failed: ${error.message}`);
+        }
+        this.updateLastAccessed();
+        this.eventManager.emit("set", "encrypt_all", `${keysToProcess.length}_values_encrypted`);
+        return this;
+    }
+    /**
+     * Gets the raw encrypted data without decryption (for verification)
+     */
+    getRawEncryptedData() {
+        this.ensureNotDestroyed();
+        return new Map(this.data);
+    }
+    /**
+     * Gets a specific key's raw encrypted form (for verification)
+     */
+    getRawEncryptedValue(key) {
+        this.ensureNotDestroyed();
+        const stringKey = ValidationUtils.sanitizeKey(key);
+        return this.data.get(stringKey);
+    }
+    /**
+     * Gets encryption status from the crypto handler
+     */
+    getEncryptionStatus() {
+        return this.cryptoHandler.getEncryptionStatus();
+    }
+    // ===== EVENT MANAGEMENT =====
+    /**
+     * Adds an event listener
+     */
+    addEventListener(event, listener) {
+        ValidationUtils.validateEventType(event);
+        ValidationUtils.validateEventListener(listener);
+        this.eventManager.addEventListener(event, listener);
+    }
+    /**
+     * Removes an event listener
+     */
+    removeEventListener(event, listener) {
+        ValidationUtils.validateEventType(event);
+        ValidationUtils.validateEventListener(listener);
+        this.eventManager.removeEventListener(event, listener);
+    }
+    /**
+     * Creates a one-time event listener
+     */
+    once(event, listener) {
+        ValidationUtils.validateEventType(event);
+        ValidationUtils.validateEventListener(listener);
+        this.eventManager.once(event, listener);
+    }
+    /**
+     * Waits for a specific event to be emitted
+     */
+    waitFor(event, timeout) {
+        ValidationUtils.validateEventType(event);
+        if (timeout !== undefined) {
+            ValidationUtils.validateTimeout(timeout);
+        }
+        return this.eventManager.waitFor(event, timeout);
+    }
+    // ===== CORE DATA OPERATIONS =====
+    /**
+     * Sets a value - allows both existing keys and new dynamic keys
+     */
+    set(key, value) {
+        this.ensureNotDestroyed();
+        this.ensureNotReadOnly();
+        this.updateLastAccessed();
+        const stringKey = ValidationUtils.sanitizeKey(key);
+        ValidationUtils.isValidSecureValue(value);
+        // Clean up any existing secure buffer for this key
+        this.cleanupKey(stringKey);
+        // Handle different types of values
+        if (value &&
+            typeof value === "object" &&
+            value.constructor.name === "Uint8Array") {
+            // Store Uint8Array in a secure buffer
+            const secureBuffer = SecureBuffer.from(value);
+            this.secureBuffers.set(stringKey, secureBuffer);
+            this.data.set(stringKey, secureBuffer);
+            this.metadataManager.update(stringKey, "Uint8Array", true);
+        }
+        else if (typeof value === "string") {
+            // Store strings in secure buffers
+            const secureBuffer = SecureBuffer.from(value);
+            this.secureBuffers.set(stringKey, secureBuffer);
+            this.data.set(stringKey, secureBuffer);
+            this.metadataManager.update(stringKey, "string", true);
+        }
+        else if (ValidationUtils.isSecureString(value)) {
+            // Store SecureString reference
+            this.data.set(stringKey, value);
+            this.metadataManager.update(stringKey, "SecureString", true);
+        }
+        else if (ValidationUtils.isSecureObject(value)) {
+            // Store SecureObject reference
+            this.data.set(stringKey, value);
+            this.metadataManager.update(stringKey, "SecureObject", true);
+        }
+        else {
+            // Store other values directly (numbers, booleans, null, undefined)
+            this.data.set(stringKey, value);
+            this.metadataManager.update(stringKey, typeof value, false);
+        }
+        this.eventManager.emit("set", stringKey, value);
+        return this;
+    }
+    /**
+     * Sets multiple values at once
+     */
+    setAll(values) {
+        this.ensureNotDestroyed();
+        this.ensureNotReadOnly();
+        for (const key in values) {
+            if (Object.prototype.hasOwnProperty.call(values, key)) {
+                this.set(String(key), values[key]);
+            }
+        }
+        return this;
+    }
+    /**
+     * Gets a value with automatic decryption
+     */
+    get(key) {
+        this.ensureNotDestroyed();
+        this.updateLastAccessed();
+        const stringKey = ValidationUtils.sanitizeKey(key);
+        const value = this.data.get(stringKey);
+        // Update access metadata
+        if (this.metadataManager.has(stringKey)) {
+            const metadata = this.metadataManager.get(stringKey);
+            this.metadataManager.update(stringKey, metadata.type, metadata.isSecure);
+        }
+        // Check if value is encrypted (starts with [ENCRYPTED:)
+        if (typeof value === "string" &&
+            this.cryptoHandler.isEncrypted(value)) {
+            try {
+                // Decrypt the value automatically
+                const decryptedValue = this.cryptoHandler.decryptValue(value);
+                this.eventManager.emit("get", stringKey, decryptedValue);
+                return decryptedValue;
+            }
+            catch (error) {
+                console.error(`Failed to decrypt value for key ${stringKey}:`, error);
+                // Return the encrypted value if decryption fails
+                this.eventManager.emit("get", stringKey, value);
+                return value;
+            }
+        }
+        if (value instanceof SecureBuffer) {
+            // Convert SecureBuffer back to original type based on metadata
+            const buffer = value.getBuffer();
+            const metadata = this.metadataManager.get(stringKey);
+            if (metadata?.type === "Uint8Array" ||
+                metadata?.type === "encrypted:Uint8Array") {
+                // Return as Uint8Array for binary data
+                const result = new Uint8Array(buffer);
+                this.eventManager.emit("get", stringKey, result);
+                return result;
+            }
+            else {
+                // Return as string for text data
+                const result = new TextDecoder().decode(buffer);
+                this.eventManager.emit("get", stringKey, result);
+                return result;
+            }
+        }
+        this.eventManager.emit("get", stringKey, value);
+        return value;
+    }
+    /**
+     * Gets a value safely, returning undefined if key doesn't exist
+     */
+    getSafe(key) {
+        try {
+            return this.has(key) ? this.get(key) : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Gets a value with a default fallback
+     */
+    getWithDefault(key, defaultValue) {
+        return this.has(key) ? this.get(key) : defaultValue;
+    }
+    /**
+     * Checks if a key exists
+     */
+    has(key) {
+        this.ensureNotDestroyed();
+        const stringKey = ValidationUtils.sanitizeKey(key);
+        return this.data.has(stringKey);
+    }
+    /**
+     * Deletes a key - allows both existing keys and dynamic keys
+     */
+    delete(key) {
+        this.ensureNotDestroyed();
+        this.ensureNotReadOnly();
+        const stringKey = ValidationUtils.sanitizeKey(key);
+        if (!this.data.has(stringKey)) {
+            return false;
+        }
+        // Clean up any secure buffer
+        this.cleanupKey(stringKey);
+        const deleted = this.data.delete(stringKey);
+        this.metadataManager.delete(stringKey);
+        this.eventManager.emit("delete", stringKey);
+        return deleted;
+    }
+    /**
+     * Cleans up resources associated with a key
+     */
+    cleanupKey(key) {
+        if (this.secureBuffers.has(key)) {
+            this.secureBuffers.get(key)?.destroy();
+            this.secureBuffers.delete(key);
+        }
+        // Note: We don't destroy SecureString or SecureObject instances
+        // as they might be used elsewhere
+    }
+    /**
+     * Clears all data
+     */
+    clear() {
+        this.ensureNotDestroyed();
+        this.ensureNotReadOnly();
+        // Destroy all secure buffers
+        for (const buffer of this.secureBuffers.values()) {
+            buffer.destroy();
+        }
+        this.secureBuffers.clear();
+        this.data.clear();
+        this.metadataManager.clear();
+        this.eventManager.emit("clear");
+    }
+    // ===== ITERATION AND COLLECTION METHODS =====
+    /**
+     * Gets all keys
+     */
+    keys() {
+        this.ensureNotDestroyed();
+        return Array.from(this.data.keys());
+    }
+    /**
+     * Gets all values
+     */
+    values() {
+        this.ensureNotDestroyed();
+        return this.keys().map((key) => this.get(key));
+    }
+    /**
+     * Gets all entries as [key, value] pairs
+     */
+    entries() {
+        this.ensureNotDestroyed();
+        return this.keys().map((key) => [key, this.get(key)]);
+    }
+    /**
+     * Iterates over each key-value pair
+     */
+    forEach(callback) {
+        this.ensureNotDestroyed();
+        ValidationUtils.validateCallback(callback, "forEach callback");
+        for (const key of this.keys()) {
+            callback(this.get(key), key, this);
+        }
+    }
+    /**
+     * Maps over values and returns a new array
+     */
+    map(callback) {
+        this.ensureNotDestroyed();
+        ValidationUtils.validateMapper(callback);
+        return this.keys().map((key) => callback(this.get(key), key, this));
+    }
+    /**
+     * Filters entries based on a predicate function (like Array.filter)
+     * Returns a new SecureObject with only the entries that match the condition
+     */
+    filter(predicate) {
+        this.ensureNotDestroyed();
+        ValidationUtils.validatePredicate(predicate);
+        const filtered = new SecureObject();
+        for (const key of this.keys()) {
+            const value = this.get(key);
+            if (predicate(value, key, this)) {
+                filtered.set(String(key), value);
+            }
+        }
+        // Emit event with filter details
+        this.eventManager.emit("filtered", undefined, {
+            operation: "filter",
+            resultSize: filtered.size,
+            originalSize: this.size,
+        });
+        return filtered;
+    }
+    /**
+     * Filters entries by specific key names (type-safe for known keys)
+     * Returns a new SecureObject with only the specified keys
+     *
+     * @example
+     * const user = createSecureObject({ name: "John", password: "secret", age: 30 });
+     * const credentials = user.filterByKeys("name", "password");
+     */
+    filterByKeys(...keys) {
+        this.ensureNotDestroyed();
+        const filtered = new SecureObject();
+        for (const key of keys) {
+            if (this.has(key)) {
+                const stringKey = String(key);
+                filtered.set(stringKey, this.get(key));
+            }
+        }
+        // Copy sensitive keys that are included in the filter
+        const relevantSensitiveKeys = this.getSensitiveKeys().filter((k) => keys.includes(k));
+        if (relevantSensitiveKeys.length > 0) {
+            filtered.setSensitiveKeys(relevantSensitiveKeys);
+        }
+        this.eventManager.emit("filtered", undefined, {
+            operation: "filterByKeys",
+            keys: keys.map((k) => String(k)),
+            resultSize: filtered.size,
+        });
+        return filtered;
+    }
+    /**
+     * Filters entries by value type using a type guard function
+     * Returns a new SecureObject with only values of the specified type
+     *
+     * @example
+     * const data = createSecureObject({ name: "John", age: 30, active: true });
+     * const strings = data.filterByType((v): v is string => typeof v === "string");
+     */
+    filterByType(typeGuard) {
+        this.ensureNotDestroyed();
+        const filtered = new SecureObject();
+        for (const key of this.keys()) {
+            const value = this.get(key);
+            if (typeGuard(value)) {
+                const stringKey = String(key);
+                filtered.set(stringKey, value);
+            }
+        }
+        this.eventManager.emit("filtered", undefined, {
+            operation: "filterByType",
+            resultSize: filtered.size,
+        });
+        return filtered;
+    }
+    /**
+     * Filters entries to only include sensitive keys
+     * Returns a new SecureObject with only sensitive data
+     *
+     * @example
+     * const user = createSecureObject({ name: "John", password: "secret", age: 30 });
+     * user.addSensitiveKeys("password");
+     * const sensitiveData = user.filterSensitive(); // Only contains password
+     */
+    filterSensitive() {
+        this.ensureNotDestroyed();
+        const filtered = new SecureObject();
+        const sensitiveKeys = this.getSensitiveKeys();
+        for (const key of this.keys()) {
+            const stringKey = String(key);
+            if (sensitiveKeys.includes(stringKey)) {
+                filtered.set(stringKey, this.get(key));
+            }
+        }
+        // Copy all sensitive keys to the filtered object
+        filtered.setSensitiveKeys([...sensitiveKeys]);
+        this.eventManager.emit("filtered", undefined, {
+            operation: "filterSensitive",
+            resultSize: filtered.size,
+        });
+        return filtered;
+    }
+    /**
+     * Filters entries to exclude sensitive keys
+     * Returns a new SecureObject with only non-sensitive data
+     *
+     * @example
+     * const user = createSecureObject({ name: "John", password: "secret", age: 30 });
+     * user.addSensitiveKeys("password");
+     * const publicData = user.filterNonSensitive(); // Contains name and age
+     */
+    filterNonSensitive(options) {
+        this.ensureNotDestroyed();
+        // Default to non-strict mode (false) - only exact matches
+        const strictMode = options?.strictMode === true;
+        const filtered = new SecureObject();
+        for (const key of this.keys()) {
+            const stringKey = String(key);
+            // Use the enhanced sensitive key detection with strictMode
+            if (!this.sensitiveKeysManager.isSensitive(stringKey, strictMode)) {
+                const value = this.get(key);
+                // If the value is a nested object, process it with the same strictMode
+                if (value &&
+                    typeof value === "object" &&
+                    value !== null &&
+                    !Array.isArray(value)) {
+                    // Process nested object with the same strict mode
+                    const processedValue = this.processNestedObjectForFiltering(value, strictMode);
+                    filtered.set(stringKey, processedValue);
+                }
+                else {
+                    filtered.set(stringKey, value);
+                }
+            }
+        }
+        this.eventManager.emit("filtered", undefined, {
+            operation: "filterNonSensitive",
+            resultSize: filtered.size,
+        });
+        return filtered;
+    }
+    /**
+     * Processes nested objects for filtering with the same strict mode
+     */
+    processNestedObjectForFiltering(obj, strictMode) {
+        if (Array.isArray(obj)) {
+            // Handle arrays
+            return obj.map((item) => typeof item === "object" && item !== null
+                ? this.processNestedObjectForFiltering(item, strictMode)
+                : item);
+        }
+        else if (typeof obj === "object" && obj !== null) {
+            // Handle objects
+            const result = {};
+            for (const [key, value] of Object.entries(obj)) {
+                if (!this.sensitiveKeysManager.isSensitive(key, strictMode)) {
+                    if (typeof value === "object" && value !== null) {
+                        // Recursively process nested objects/arrays
+                        result[key] = this.processNestedObjectForFiltering(value, strictMode);
+                    }
+                    else {
+                        result[key] = value;
+                    }
+                }
+                // If key is sensitive, skip it (don't add to result)
+            }
+            return result;
+        }
+        return obj;
+    }
+    // ===== METADATA OPERATIONS =====
+    /**
+     * Gets metadata for a specific key
+     */
+    getMetadata(key) {
+        this.ensureNotDestroyed();
+        const stringKey = ValidationUtils.sanitizeKey(key);
+        return this.metadataManager.get(stringKey);
+    }
+    /**
+     * Gets metadata for all keys
+     */
+    getAllMetadata() {
+        this.ensureNotDestroyed();
+        return this.metadataManager.getAll();
+    }
+    // ===== SERIALIZATION METHODS =====
+    /**
+     * Converts to a regular object with security-focused serialization
+     *
+     * BEHAVIOR: This is the security-focused method that handles sensitive key filtering.
+     * Use this method when you need controlled access to data with security considerations.
+     * For simple object conversion without filtering, use toObject().
+     *
+     *  @example
+     * const user = fObject({
+        id: "1",
+        email: "test@test.com",
+        password: "test123",
+        isVerified: true,
+        userName: "test",
+        firstName: "test",
+        lastName: "test",
+        bio: "test",
+        });
+
+        const getAllResult = user.getAll();
+        console.log("getAllResult.email:", getAllResult.email);
+        console.log("getAllResult.password:", getAllResult.password);
+        console.log("Has password?", "password" in getAllResult);
+        
+        // Purpose: Security-conscious data access
+        // Behavior: Filters out sensitive keys by default
+        // Result:  password: undefined (filtered for security)
+        // With encryptSensitive: true: ✔ password: "[ENCRYPTED:...]" (encrypted but included)
+     */
+    getAll(options = {}) {
+        this.ensureNotDestroyed();
+        ValidationUtils.validateSerializationOptions(options);
+        const sensitiveKeys = new Set(this.sensitiveKeysManager.getAll());
+        return this.serializationHandler.toObject(this.data, sensitiveKeys, options);
+    }
+    /**
+     * Gets the full object as a regular JavaScript object
+     *
+     * BEHAVIOR: Returns ALL data including sensitive keys (like standard JS object conversion).
+     * This method does NOT filter sensitive keys by default - use getAll() for security-focused serialization.
+     *
+     * @example
+     * const user = fObject({
+        id: "1",
+        email: "test@test.com",
+        password: "test123",
+        isVerified: true,
+        userName: "test",
+        firstName: "test",
+        lastName: "test",
+        bio: "test",
+        });
+
+        const toObjectResult = user.toObject();
+        console.log("toObjectResult.email:", toObjectResult.email);
+        console.log("toObjectResult.password:", toObjectResult.password);
+        console.log("Has password?", "password" in toObjectResult);
+
+        // Purpose: Standard JavaScript object conversion
+        // Behavior: Returns ALL data including sensitive keys (like password)
+        // Result: ✔ password: "test123" (included)
+
+        Sensitive keys can be handled using .add/removeSensitiveKeys()
+     */
+    toObject(options) {
+        // toObject() should return ALL data by default (no filtering)
+        // Pass an empty Set to indicate no keys should be filtered
+        const noFiltering = new Set();
+        return this.serializationHandler.toObject(this.data, noFiltering, options);
+    }
+    /**
+     * Converts to JSON string
+     */
+    toJSON(options = {}) {
+        this.ensureNotDestroyed();
+        ValidationUtils.validateSerializationOptions(options);
+        // Use non-strict mode by default (only exact matches)
+        const strictMode = options.strictSensitiveKeys === true;
+        const isSensitiveKey = (key) => this.sensitiveKeysManager.isSensitive(key, strictMode);
+        return this.serializationHandler.toJSON(this.data, isSensitiveKey, options);
+    }
+    // ===== UTILITY METHODS =====
+    /**
+     * Creates a hash of the entire object content
+     */
+    async hash(algorithm = "SHA-256", format = "hex") {
+        this.ensureNotDestroyed();
+        const serialized = this.serializationHandler.createHashableRepresentation(this.entries());
+        const secureString = new SecureString(serialized);
+        try {
+            return await secureString.hash(algorithm, format);
+        }
+        finally {
+            secureString.destroy();
+        }
+    }
+    /**
+     * Executes a function with the object data and optionally clears it afterward
+     */
+    use(fn, autoClear = false) {
+        this.ensureNotDestroyed();
+        ValidationUtils.validateCallback(fn, "use function");
+        try {
+            return fn(this);
+        }
+        finally {
+            if (autoClear) {
+                this.destroy();
+            }
+        }
+    }
+    /**
+     * Creates a shallow copy of the SecureObject
+     */
+    clone() {
+        this.ensureNotDestroyed();
+        return SecureObject.from(this);
+    }
+    /**
+     * Merges another object into this one
+     */
+    merge(other, overwrite = true) {
+        this.ensureNotDestroyed();
+        this.ensureNotReadOnly();
+        if (other instanceof SecureObject) {
+            for (const key of other.keys()) {
+                const stringKey = String(key);
+                if (overwrite || !this.has(key)) {
+                    this.set(stringKey, other.get(key));
+                }
+            }
+        }
+        else {
+            for (const key in other) {
+                if (Object.prototype.hasOwnProperty.call(other, key)) {
+                    if (overwrite || !this.has(key)) {
+                        this.set(String(key), other[key]);
+                    }
+                }
+            }
+        }
+        return this;
+    }
+    // ===== AMAZING NEW FEATURES =====
+    /**
+     * Transform values with a mapper function (like Array.map but returns SecureObject)
+     * Returns a new SecureObject with transformed values
+     */
+    transform(mapper) {
+        this.ensureNotDestroyed();
+        ValidationUtils.validateMapper(mapper);
+        const transformed = new SecureObject();
+        for (const key of this.keys()) {
+            const value = this.get(key);
+            const newValue = mapper(value, key, this);
+            const stringKey = String(key);
+            transformed.set(stringKey, newValue);
+        }
+        this.eventManager.emit("filtered", undefined, {
+            operation: "transform",
+            resultSize: transformed.size,
+        });
+        return transformed;
+    }
+    /**
+     * Group entries by a classifier function
+     * Returns a Map where keys are group identifiers and values are SecureObjects
+     */
+    groupBy(classifier) {
+        this.ensureNotDestroyed();
+        ValidationUtils.validateCallback(classifier, "Classifier function");
+        const groups = new Map();
+        for (const key of this.keys()) {
+            const value = this.get(key);
+            const groupKey = classifier(value, key);
+            if (!groups.has(groupKey)) {
+                groups.set(groupKey, new SecureObject());
+            }
+            const group = groups.get(groupKey);
+            const stringKey = String(key);
+            group.set(stringKey, value);
+        }
+        this.eventManager.emit("filtered", undefined, {
+            operation: "groupBy",
+            resultSize: groups.size,
+        });
+        return groups;
+    }
+    /**
+     * Partition entries into two groups based on a predicate
+     * Returns [matching, notMatching] SecureObjects
+     */
+    partition(predicate) {
+        this.ensureNotDestroyed();
+        ValidationUtils.validatePredicate(predicate);
+        const matching = new SecureObject();
+        const notMatching = new SecureObject();
+        for (const key of this.keys()) {
+            const value = this.get(key);
+            const stringKey = String(key);
+            if (predicate(value, key)) {
+                matching.set(stringKey, value);
+            }
+            else {
+                notMatching.set(stringKey, value);
+            }
+        }
+        this.eventManager.emit("filtered", undefined, {
+            operation: "partition",
+            resultSize: matching.size + notMatching.size,
+        });
+        return [matching, notMatching];
+    }
+    /**
+     * Pick specific keys (like Lodash pick but type-safe)
+     * Returns a new SecureObject with only the specified keys
+     */
+    pick(...keys) {
+        return this.filterByKeys(...keys);
+    }
+    /**
+     * Omit specific keys (opposite of pick)
+     * Returns a new SecureObject without the specified keys
+     */
+    omit(...keys) {
+        this.ensureNotDestroyed();
+        const omitted = new SecureObject();
+        const keysToOmit = new Set(keys.map((k) => String(k)));
+        for (const key of this.keys()) {
+            const stringKey = String(key);
+            if (!keysToOmit.has(stringKey)) {
+                omitted.set(stringKey, this.get(key));
+            }
+        }
+        this.eventManager.emit("filtered", undefined, {
+            operation: "omit",
+            keys: keys.map((k) => String(k)),
+            resultSize: omitted.size,
+        });
+        return omitted;
+    }
+    /**
+     * Flatten nested objects (one level deep)
+     * Converts { user: { name: "John" } } to { "user.name": "John" }
+     */
+    flatten(separator = ".") {
+        this.ensureNotDestroyed();
+        const flattened = new SecureObject();
+        for (const key of this.keys()) {
+            const value = this.get(key);
+            const stringKey = String(key);
+            if (value &&
+                typeof value === "object" &&
+                !Array.isArray(value) &&
+                !(value instanceof Date)) {
+                // Flatten nested object
+                for (const [nestedKey, nestedValue] of Object.entries(value)) {
+                    const flatKey = `${stringKey}${separator}${nestedKey}`;
+                    flattened.set(flatKey, nestedValue);
+                }
+            }
+            else {
+                flattened.set(stringKey, value);
+            }
+        }
+        this.eventManager.emit("filtered", undefined, {
+            operation: "flatten",
+            resultSize: flattened.size,
+        });
+        return flattened;
+    }
+    /**
+     * Compact - removes null, undefined, and empty values
+     * Returns a new SecureObject with only truthy values
+     */
+    compact() {
+        return this.filter((value) => {
+            if (value === null || value === undefined)
+                return false;
+            if (typeof value === "string" && value.trim() === "")
+                return false;
+            if (Array.isArray(value) && value.length === 0)
+                return false;
+            if (typeof value === "object" && Object.keys(value).length === 0)
+                return false;
+            return true;
+        });
+    }
+    /**
+     * Invert - swap keys and values
+     * Returns a new SecureObject with keys and values swapped
+     */
+    invert() {
+        this.ensureNotDestroyed();
+        const inverted = new SecureObject();
+        for (const key of this.keys()) {
+            const value = this.get(key);
+            const stringValue = String(value);
+            const stringKey = String(key);
+            inverted.set(stringValue, stringKey);
+        }
+        this.eventManager.emit("filtered", undefined, {
+            operation: "invert",
+            resultSize: inverted.size,
+        });
+        return inverted;
+    }
+    /**
+     * Defaults - merge with default values (only for missing keys)
+     * Returns a new SecureObject with defaults applied
+     */
+    defaults(defaultValues) {
+        this.ensureNotDestroyed();
+        const result = new SecureObject();
+        // First, copy all existing values
+        for (const key of this.keys()) {
+            const stringKey = String(key);
+            result.set(stringKey, this.get(key));
+        }
+        // Then, add defaults for missing keys
+        for (const [key, value] of Object.entries(defaultValues)) {
+            if (!this.has(key)) {
+                result.set(key, value);
+            }
+        }
+        this.eventManager.emit("filtered", undefined, {
+            operation: "defaults",
+            resultSize: result.size,
+        });
+        return result;
+    }
+    /**
+     * Tap - execute a function with the object and return the object (for chaining)
+     * Useful for debugging or side effects in method chains
+     */
+    tap(fn) {
+        this.ensureNotDestroyed();
+        ValidationUtils.validateCallback(fn, "Tap function");
+        fn(this);
+        return this;
+    }
+    pipe(...fns) {
+        this.ensureNotDestroyed();
+        return fns.reduce((result, fn) => {
+            ValidationUtils.validateCallback(fn, "Pipe function");
+            return fn(result);
+        }, this);
+    }
+    /**
+     * Sample - get random entries from the object
+     * Returns a new SecureObject with randomly selected entries
+     */
+    sample(count = 1) {
+        this.ensureNotDestroyed();
+        if (count <= 0) {
+            return new SecureObject();
+        }
+        const allKeys = this.keys();
+        const sampleSize = Math.min(count, allKeys.length);
+        const sampledKeys = [];
+        // Simple random sampling without replacement
+        const availableKeys = [...allKeys];
+        for (let i = 0; i < sampleSize; i++) {
+            const randomIndex = Math.floor(Math.random() * availableKeys.length);
+            sampledKeys.push(availableKeys.splice(randomIndex, 1)[0]);
+        }
+        const sampled = new SecureObject();
+        for (const key of sampledKeys) {
+            const stringKey = String(key);
+            sampled.set(stringKey, this.get(key));
+        }
+        this.eventManager.emit("filtered", undefined, {
+            operation: "sample",
+            resultSize: sampled.size,
+        });
+        return sampled;
+    }
+    /**
+     * Shuffle - return a new SecureObject with keys in random order
+     * Returns a new SecureObject with the same data but shuffled key order
+     */
+    shuffle() {
+        this.ensureNotDestroyed();
+        const allKeys = this.keys();
+        const shuffledKeys = [...allKeys];
+        // Fisher-Yates shuffle
+        for (let i = shuffledKeys.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [shuffledKeys[i], shuffledKeys[j]] = [
+                shuffledKeys[j],
+                shuffledKeys[i],
+            ];
+        }
+        const shuffled = new SecureObject();
+        for (const key of shuffledKeys) {
+            const stringKey = String(key);
+            shuffled.set(stringKey, this.get(key));
+        }
+        this.eventManager.emit("filtered", undefined, {
+            operation: "shuffle",
+            resultSize: shuffled.size,
+        });
+        return shuffled;
+    }
+    /**
+     * Chunk - split object into chunks of specified size
+     * Returns an array of SecureObjects, each containing up to 'size' entries
+     */
+    chunk(size) {
+        this.ensureNotDestroyed();
+        if (size <= 0) {
+            throw new Error("Chunk size must be greater than 0");
+        }
+        const allKeys = this.keys();
+        const chunks = [];
+        for (let i = 0; i < allKeys.length; i += size) {
+            const chunk = new SecureObject();
+            const chunkKeys = allKeys.slice(i, i + size);
+            for (const key of chunkKeys) {
+                const stringKey = String(key);
+                chunk.set(stringKey, this.get(key));
+            }
+            chunks.push(chunk);
+        }
+        this.eventManager.emit("filtered", undefined, {
+            operation: "chunk",
+            resultSize: chunks.length,
+        });
+        return chunks;
+    }
+    // ===== SERIALIZATION AND EXPORT =====
+    /**
+     * Serializes the SecureObject to a secure format
+     */
+    serialize(options = {}) {
+        this.ensureNotDestroyed();
+        try {
+            const { includeMetadata = true, encryptSensitive = false, format = "json", } = options;
+            // Create serialization package
+            const package_ = {
+                version: "2.0.0",
+                format: "XyPrissSecurity-SecureObject",
+                timestamp: Date.now(),
+                objectId: this._id,
+                data: this.serializationHandler.toObject(this.data, (key) => this.sensitiveKeysManager.isSensitive(key, true), // Use strict mode
+                options),
+                metadata: includeMetadata
+                    ? this.getSerializationMetadata()
+                    : null,
+                size: this.size,
+                isReadOnly: this._isReadOnly,
+                encryptionEnabled: this.cryptoHandler.getEncryptionStatus().hasEncryptionKey,
+            };
+            // Return as JSON string or binary based on format
+            if (format === "binary") {
+                const jsonString = JSON.stringify(package_);
+                const binaryData = new TextEncoder().encode(jsonString);
+                return Array.from(binaryData)
+                    .map((b) => b.toString(16).padStart(2, "0"))
+                    .join("");
+            }
+            else {
+                return JSON.stringify(package_, null, 2);
+            }
+        }
+        catch (error) {
+            console.error("Serialization failed:", error);
+            throw new Error(`Serialization failed: ${error.message}`);
+        }
+    }
+    /**
+     * Exports the SecureObject data in various formats
+     */
+    exportData(format = "json") {
+        this.ensureNotDestroyed();
+        try {
+            const data = this.toObject();
+            switch (format) {
+                case "json":
+                    return JSON.stringify(data, null, 2);
+                case "csv":
+                    return this.exportToCSV(data);
+                case "xml":
+                    return this.exportToXML(data);
+                case "yaml":
+                    return this.exportToYAML(data);
+                default:
+                    throw new Error(`Unsupported export format: ${format}`);
+            }
+        }
+        catch (error) {
+            console.error("Export failed:", error);
+            throw new Error(`Export failed: ${error.message}`);
+        }
+    }
+    /**
+     * Gets serialization metadata
+     */
+    getSerializationMetadata() {
+        const stats = this.metadataManager.getStats();
+        const memoryUsage = this.getMemoryUsage();
+        return {
+            totalEntries: stats.totalEntries,
+            secureEntries: stats.secureEntries,
+            memoryUsage: memoryUsage.allocatedMemory,
+            lastModified: stats.newestEntry?.getTime() || this._createdAt,
+            createdAt: this._createdAt,
+            accessCount: stats.totalAccesses,
+            averageAccesses: stats.averageAccesses,
+            oldestEntry: stats.oldestEntry?.getTime() || null,
+            newestEntry: stats.newestEntry?.getTime() || null,
+        };
+    }
+    /**
+     * Exports to CSV format
+     */
+    exportToCSV(data) {
+        const entries = Object.entries(data);
+        if (entries.length === 0)
+            return "Key,Value,Type\n";
+        let csv = "Key,Value,Type\n";
+        for (const [key, value] of entries) {
+            const type = typeof value;
+            const valueStr = type === "object" ? JSON.stringify(value) : String(value);
+            const escapedValue = `"${valueStr.replace(/"/g, '""')}"`;
+            csv += `"${key}",${escapedValue},${type}\n`;
+        }
+        return csv;
+    }
+    /**
+     * Exports to XML format
+     */
+    exportToXML(data) {
+        let xml = '<?xml version="1.0" encoding="UTF-8"?>\n<SecureObject>\n';
+        for (const [key, value] of Object.entries(data)) {
+            const type = typeof value;
+            const valueStr = type === "object" ? JSON.stringify(value) : String(value);
+            xml += `  <entry key="${this.escapeXML(key)}" type="${type}">${this.escapeXML(valueStr)}</entry>\n`;
+        }
+        xml += "</SecureObject>";
+        return xml;
+    }
+    /**
+     * Exports to YAML format
+     */
+    exportToYAML(data) {
+        let yaml = "# SecureObject Export\n";
+        yaml += `# Generated: ${new Date().toISOString()}\n\n`;
+        for (const [key, value] of Object.entries(data)) {
+            const type = typeof value;
+            if (type === "object") {
+                yaml += `${key}:\n`;
+                yaml += `  value: ${JSON.stringify(value)}\n`;
+                yaml += `  type: ${type}\n\n`;
+            }
+            else {
+                yaml += `${key}: ${JSON.stringify(value)}\n`;
+            }
+        }
+        return yaml;
+    }
+    /**
+     * Escapes XML special characters
+     */
+    escapeXML(str) {
+        return str
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;")
+            .replace(/"/g, "&quot;")
+            .replace(/'/g, "&#39;");
+    }
+    /**
+     * Destroys the SecureObject and clears all data
+     */
+    destroy() {
+        if (!this._isDestroyed) {
+            // Clean up memory tracking
+            if (this._memoryTracking) {
+                memoryManager.removeReference(this._id);
+            }
+            this.clear();
+            this.eventManager.clear();
+            this._isDestroyed = true;
+            this.eventManager.emit("destroy");
+        }
+    }
+    /**
+     * Custom inspection for debugging (masks sensitive data)
+     */
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+        if (this._isDestroyed) {
+            return "SecureObject [DESTROYED]";
+        }
+        const stats = this.metadataManager.getStats();
+        return `SecureObject [${this.size} items, ${stats.secureEntries} secure] ${this._isReadOnly ? "[READ-ONLY]" : ""}`;
+    }
+}
+
+export { SecureObject };
+//# sourceMappingURL=secure-object-core.js.map