xypriss 1.0.1 → 1.1.0

package/dist/cjs/mods/security/src/index.js

@@ -0,0 +1,417 @@
+'use strict';
+
+var types = require('./types.js');
+var hashCore = require('./core/hash/hash-core.js');
+require('./core/hash/hash-types.js');
+require('crypto');
+require('./core/hash/hash-security.js');
+require('./core/hash/hash-advanced.js');
+require('./algorithms/hash-algorithms.js');
+require('./core/keys/keys-types.js');
+require('./core/keys/keys-logger.js');
+require('./core/keys/keys-utils.js');
+require('./core/keys/algorithms/mods/PBKDF2Algo.js');
+var randomCore = require('./core/random/random-core.js');
+require('./core/random/random-types.js');
+require('./core/random/random-sources.js');
+require('nehonix-uri-processor');
+require('./utils/memory/index.js');
+require('argon2');
+require('child_process');
+require('./types/secure-memory.js');
+require('https');
+var runtimeVerification = require('./components/runtime-verification.js');
+var tamperEvidentLogging = require('./components/tamper-evident-logging.js');
+require('./components/secure-string/advanced/entropy-analyzer.js');
+require('./components/secure-string/advanced/quantum-safe.js');
+require('./components/secure-string/advanced/performance-monitor.js');
+var index$1 = require('./components/secure-object/index.js');
+require('./components/secure-array/utils/id-generator.js');
+var passwordTypes = require('./core/password/password-types.js');
+require('./core/password/index.js');
+require('./components/fortified-function/core/fortified-function-core.js');
+require('./components/fortified-function/core/fortified-config.js');
+require('./components/fortified-function/core/fortified-logger.js');
+require('events');
+require('./components/fortified-function/serializer/safe-serializer.js');
+require('nehoid');
+require('./components/fortified-function/UFA/ultra-fast-allocator.js');
+var passwordCore = require('./core/password/password-core.js');
+
+/***************************************************************************
+ * XyPrissSecurity - Ex xypriss2-js is an Advanced JavaScript Security Library designed for XyPriss
+ *
+ * This file contains the main entry point for the XyPrissSecurity library.
+ *
+ * @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.
+ ***************************************************************************** */
+/**
+ * # XyPrissSecurity - Advanced JavaScript Security Library
+ *
+ * **The most comprehensive cryptographic security library for JavaScript applications**
+ *
+ * XyPrissSecurity provides enterprise-grade security features including military-grade encryption,
+ * secure data structures, advanced password management, and real-time security monitoring.
+ * Built with TypeScript for maximum type safety and developer experience.
+ *
+ * ## Core Features
+ *
+ * ### Secure Data Structures
+ * - **SecureArray**: Military-grade encrypted arrays with AES-256-CTR-HMAC
+ * - **SecureString**: Protected string handling with automatic memory cleanup
+ * - **SecureObject**: Encrypted object storage with metadata management
+ * - **SecureBuffer**: Protected memory allocation with secure wiping
+ *
+ * ### Cryptographic Operations
+ * - **Token Generation**: Secure random tokens with configurable entropy
+ * - **Password Management**: Argon2ID hashing with pepper support
+ * - **Hash Functions**: SHA-256/512, BLAKE3, with timing-safe operations
+ * - **Key Derivation**: PBKDF2, Argon2, scrypt with memory-hard algorithms
+ *
+ * ### Performance & Security
+ * - **FortifiedFunction**: Ultra-fast function execution with security monitoring
+ * - **Cache System**: High-performance caching with encryption support
+ * - **Memory Management**: Automatic cleanup and leak detection
+ * - **Side-Channel Protection**: Constant-time operations and fault resistance
+ *
+ * ### Advanced Security
+ * - **Post-Quantum Cryptography**: Lamport signatures and Ring-LWE
+ * - **Canary Tokens**: Intrusion detection and monitoring
+ * - **Attestation**: Code integrity verification
+ * - **Entropy Augmentation**: Enhanced randomness sources
+ *
+ * ## Quick Start Examples
+ *
+ * ### Basic Token Generation
+ * ```typescript
+ * import { XyPrissSecurity, generateSecureToken } from "xypriss-security";
+ *
+ * // Generate a secure API key
+ * const apiKey = XyPrissSecurity.generateSecureToken({
+ *     length: 32,
+ *     entropy: "maximum",
+ *     includeSymbols: false
+ * });
+ * console.log(apiKey); // "aK7mN9pQ2rS8tU3vW6xY1zB4cD5eF7gH"
+ *
+ * // Quick token generation
+ * const sessionToken = generateSecureToken(64, "base64url");
+ * ```
+ *
+ * ### Secure Data Structures
+ * ```typescript
+ * import { fArray, fString, fObject } from "xypriss-security";
+ *
+ * // Secure array with encryption
+ * const sensitiveData = fArray(["api-key-1", "secret-token", "user-data"]);
+ * sensitiveData.setEncryptionKey("your-encryption-key-2025");
+ * sensitiveData.encryptAll();
+ *
+ * // Secure string with automatic cleanup
+ * const password = fString("user-password-123", {
+ *     protectionLevel: "maximum",
+ *     enableEncryption: true
+ * });
+ *
+ * // Secure object with metadata
+ * const userCredentials = fObject({
+ *     username: "john_doe",
+ *     apiKey: "secret-key-value"
+ * });
+ * ```
+ *
+ * ### Password Management
+ * ```typescript
+ * import { PasswordManager, encryptSecurePass, verifyEncryptedPassword } from "xypriss-security";
+ *
+ * // Advanced password hashing with pepper
+ * const pepper = process.env.PASSWORD_PEPPER;
+ * const hashedPassword = await encryptSecurePass("userPassword123", pepper);
+ *
+ * // Verify password with timing-safe comparison
+ * const isValid = await verifyEncryptedPassword("userPassword123", hashedPassword, pepper);
+ *
+ * // Password manager with custom configuration
+ * const pm = PasswordManager.create({
+ *     algorithm: "argon2id",
+ *     memoryCost: 65536,
+ *     timeCost: 3
+ * });
+ * ```
+ *
+ * ### High-Performance Functions
+ * ```typescript
+ * import { func, createFortifiedFunction } from "xypriss-security";
+ *
+ * // Ultra-fast function with security monitoring
+ * const optimizedFunction = func(async (data: string) => {
+ *     return data.toUpperCase();
+ * }, {
+ *     ultraFast: "maximum",
+ *     smartCaching: true,
+ *     autoEncrypt: true
+ * });
+ *
+ * const result = await optimizedFunction.execute("hello world");
+ * const analytics = optimizedFunction.getAnalyticsData();
+ * ```
+ *
+ * ## Security Best Practices
+ *
+ * 1. **Always use environment variables for sensitive keys**
+ * 2. **Enable encryption for sensitive data structures**
+ * 3. **Use timing-safe operations for authentication**
+ * 4. **Implement proper memory cleanup with destroy() methods**
+ * 5. **Monitor security status with built-in analytics**
+ *
+ * @author Nehonix
+ * @version 4.2.0
+ * @license MIT
+ * @see {@link https://lab.nehonix.space/nehonix_viewer/_doc/Nehonix%20XyPrissSecurity} Official Documentation
+ * @see {@link https://github.com/Nehonix-Team/XyPriss} GitHub Repository
+ * @see {@link https://nodejs.org/api/crypto.html} Node.js Crypto Module
+ * @see {@link https://github.com/ranisalt/node-argon2} Argon2 Implementation
+ * @see {@link https://github.com/paulmillr/noble-hashes} Noble Hashes Library
+ * @see {@link https://libsodium.gitbook.io/doc/} Libsodium Documentation
+ * @see {@link https://github.com/jedisct1/libsodium.js} Libsodium.js
+ * @see {@link https://www.npmjs.com/package/bcryptjs} BCrypt.js Package
+ *
+ * @example
+ * ```typescript
+ * // Complete security setup example
+ * import { XyPrissSecurity, fArray, PasswordManager } from "xypriss-security";
+ *
+ * // 1. Generate secure tokens
+ * const apiKey = XyPrissSecurity.generateAPIKey(32, "api");
+ * const sessionToken = XyPrissSecurity.generateSessionToken();
+ *
+ * // 2. Secure data storage
+ * const userData = fArray([]);
+ * userData.setEncryptionKey(process.env.ENCRYPTION_KEY);
+ * userData.push("sensitive-user-data");
+ *
+ * // 3. Password management
+ * const pm = PasswordManager.getInstance();
+ * const hashedPassword = await pm.hash("userPassword");
+ *
+ * // 4. Security monitoring
+ * const stats = XyPrissSecurity.getStats();
+ * const securityStatus = XyPrissSecurity.verifyRuntimeSecurity();
+ *
+ * console.log("Security Status:", securityStatus.isSecure);
+ * console.log("Operations:", stats.totalOperations);
+ * ```
+ */
+/**
+ * ### Random Data Generation
+ *
+ * High-entropy random data generation for cryptographic operations.
+ *
+ * @example
+ * ```typescript
+ * import { getRandomBytes, generateSecureUUID } from "xypriss-security";
+ *
+ * // Generate random bytes
+ * const randomData = getRandomBytes(32);
+ *
+ * // Generate secure UUID
+ * const uuid = generateSecureUUID();
+ * ```
+ */
+/** Generate cryptographically secure random bytes */
+randomCore.SecureRandom.getRandomBytes;
+/** Generate secure UUID with high entropy */
+randomCore.SecureRandom.generateSecureUUID;
+/**
+ * ### Hash Operations
+ *
+ * Military-grade hashing functions with timing-safe operations and
+ * automatic salt generation for maximum security.
+ *
+ * @example
+ * ```typescript
+ * import { createSecureHash, createSecureHMAC, verifyHash } from "xypriss-security";
+ *
+ * // Create secure hash with automatic salt
+ * const hash = createSecureHash("data to hash");
+ *
+ * // Create HMAC with secret key
+ * const hmac = createSecureHMAC("sha256", "secret-key", "data");
+ *
+ * // Verify hash with timing-safe comparison
+ * const isValid = verifyHash("original-data", hash);
+ * ```
+ *
+ * @see {@link https://github.com/paulmillr/noble-hashes} Noble Hashes - Modern Crypto Library
+ * @see {@link https://nodejs.org/api/crypto.html#cryptocreatehashstring-options} Node.js Hash Functions
+ * @see {@link https://tools.ietf.org/html/rfc2104} RFC 2104 - HMAC Specification
+ * @see {@link https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf} NIST SHA Standards
+ */
+/** Create secure hash with automatic salt generation */
+hashCore.Hash.createSecureHash;
+/** Create secure HMAC with timing-safe operations */
+hashCore.Hash.createSecureHMAC;
+/** Verify hash with constant-time comparison */
+hashCore.Hash.verifyHash;
+/**
+ * ### Password Manager Quick Access
+ *
+ * Convenient alias for password manager with default configuration.
+ * For production use with custom configuration, use PasswordManager.create()
+ * or PasswordManager.getInstance() with specific options.
+ *
+ * @example
+ * ```typescript
+ * import { pm } from "xypriss-security";
+ *
+ * // Quick password operations with default config
+ * const hash = await pm.hash("userPassword");
+ * const result = await pm.verify("userPassword", hash);
+ *
+ * // For custom configuration:
+ * // const customPM = PasswordManager.create({ memoryCost: 131072 });
+ * ```
+ *
+ * @deprecated Consider using PasswordManager.getInstance() for explicit configuration
+ */
+passwordCore.PasswordManager.getInstance();
+/**
+ * ### Create Secure Object
+ *
+ * Creates a secure object instance with encryption, metadata management,
+ * and comprehensive security features for sensitive data storage.
+ *
+ * **Key Features:**
+ * - Automatic encryption for sensitive values
+ * - Metadata tracking and management
+ * - Event-driven architecture
+ * - Secure serialization and deserialization
+ * - Memory protection and cleanup
+ *
+ * @param initialData - The initial data to store in the secure object
+ * @param options - Configuration options for encryption and security
+ * @returns A new SecureObject instance with enhanced protection
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { fObject } from "xypriss-security";
+ *
+ * // Create secure object with initial data
+ * const userCredentials = fObject({
+ *     username: "john_doe",
+ *     apiKey: "secret-api-key-12345",
+ *     sessionToken: "session-token-abcdef"
+ * });
+ *
+ * // Access and modify data
+ * userCredentials.set("lastLogin", new Date().toISOString());
+ * const apiKey = userCredentials.get("apiKey");
+ *
+ * // Secure cleanup
+ * userCredentials.destroy();
+ * ```
+ *
+ * @example Advanced Configuration
+ * ```typescript
+ * import { fObject } from "xypriss-security";
+ *
+ * // Create with encryption and metadata tracking
+ * const secureConfig = fObject({
+ *     databaseUrl: "postgresql://user:pass@localhost/db",
+ *     encryptionKey: "master-encryption-key-2025",
+ *     apiSecrets: {
+ *         stripe: "sk_live_...",
+ *         aws: "AKIA..."
+ *     }
+ * }, {
+ *     encryptionKey: process.env.OBJECT_ENCRYPTION_KEY,
+ *     enableMetadata: true,
+ *     autoCleanup: true
+ * });
+ *
+ * // Mark sensitive keys for special handling
+ * secureConfig.markSensitive("databaseUrl");
+ * secureConfig.markSensitive("encryptionKey");
+ * secureConfig.markSensitive("apiSecrets");
+ *
+ * // Export with encryption
+ * const encrypted = secureConfig.serialize({ encrypt: true });
+ *
+ * // Event handling
+ * secureConfig.on("accessed", (key) => {
+ *     console.log(`Sensitive key accessed: ${key}`);
+ * });
+ * ```
+ *
+ * @author Seth Eleazar
+ * @since 1.0.0
+ */
+function fObject(...args) {
+    return index$1.createSecureObject(...args);
+}
+
+Object.defineProperty(exports, 'EntropySource', {
+    enumerable: true,
+    get: function () { return types.EntropySource; }
+});
+Object.defineProperty(exports, 'HashAlgorithm', {
+    enumerable: true,
+    get: function () { return types.HashAlgorithm; }
+});
+Object.defineProperty(exports, 'KeyDerivationAlgorithm', {
+    enumerable: true,
+    get: function () { return types.KeyDerivationAlgorithm; }
+});
+Object.defineProperty(exports, 'SecurityLevel', {
+    enumerable: true,
+    get: function () { return types.SecurityLevel; }
+});
+Object.defineProperty(exports, 'TokenType', {
+    enumerable: true,
+    get: function () { return types.TokenType; }
+});
+exports.Hash = hashCore.Hash;
+exports.Random = randomCore.SecureRandom;
+Object.defineProperty(exports, 'SecurityIssueType', {
+    enumerable: true,
+    get: function () { return runtimeVerification.SecurityIssueType; }
+});
+exports.verifyRuntimeSecurity = runtimeVerification.verifyRuntimeSecurity;
+Object.defineProperty(exports, 'LogLevel', {
+    enumerable: true,
+    get: function () { return tamperEvidentLogging.LogLevel; }
+});
+exports.TamperEvidentLogger = tamperEvidentLogging.TamperEvidentLogger;
+exports.createSecureObject = index$1.createSecureObject;
+Object.defineProperty(exports, 'PasswordAlgorithm', {
+    enumerable: true,
+    get: function () { return passwordTypes.PasswordAlgorithm; }
+});
+Object.defineProperty(exports, 'PasswordSecurityLevel', {
+    enumerable: true,
+    get: function () { return passwordTypes.PasswordSecurityLevel; }
+});
+exports.PasswordManager = passwordCore.PasswordManager;
+exports.fObject = fObject;
+//# sourceMappingURL=index.js.map

package/dist/cjs/mods/security/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../mods/security/src/index.ts"],"sourcesContent":[null],"names":["SecureRandom","Hash","PasswordManager","fObjectUtils.createSecureObject"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BiF;AAEjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4JG;AAkgBH;;;;;;;;;;;;;;;AAeG;AAEH;AAC8BA,uBAAY,CAAC,eAAe;AAE1D;AACkCA,uBAAY,CAAC,mBAAmB;AAmBlE;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AAEH;AACgCC,aAAI,CAAC,iBAAiB;AAEtD;AACgCA,aAAI,CAAC,iBAAiB;AAEtD;AAC0BA,aAAI,CAAC,WAAW;AAyL1C;;;;;;;;;;;;;;;;;;;;AAoBG;AACeC,4BAAe,CAAC,WAAW,GAAG;AA0EhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEG;AACa,SAAA,OAAO,CACnB,GAAG,IAA2D,EAAA;AAE9D,IAAA,OAAOC,0BAA+B,CAAI,GAAG,IAAI,CAAC,CAAC;AACvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/mods/security/src/types/global.js

@@ -0,0 +1,51 @@
+'use strict';
+
+/**
+ * Global type definitions for XyPrissSecurity
+ *
+ * This file contains polyfills and type definitions for modern JavaScript features
+ * that may not be available in all environments.
+ */
+/**
+ * Runtime polyfills for WeakRef and FinalizationRegistry
+ */
+function initializePolyfills() {
+    // Check if WeakRef is available
+    if (typeof globalThis.WeakRef === "undefined") {
+        // Simple polyfill for WeakRef
+        globalThis.WeakRef = class WeakRef {
+            constructor(target) {
+                this.target = target;
+            }
+            deref() {
+                return this.target;
+            }
+        };
+    }
+    // Check if FinalizationRegistry is available
+    if (typeof globalThis.FinalizationRegistry === "undefined") {
+        // Simple polyfill for FinalizationRegistry
+        globalThis.FinalizationRegistry = class FinalizationRegistry {
+            constructor(cleanupCallback) {
+                this.registrations = new Map();
+                this.cleanupCallback = cleanupCallback;
+            }
+            register(target, heldValue, unregisterToken) {
+                this.registrations.set(target, heldValue);
+                // Simple timeout-based cleanup (not perfect but better than nothing)
+                setTimeout(() => {
+                    if (this.registrations.has(target)) {
+                        this.cleanupCallback(heldValue);
+                        this.registrations.delete(target);
+                    }
+                }, 30000); // 30 seconds
+            }
+            unregister(unregisterToken) {
+                return this.registrations.delete(unregisterToken);
+            }
+        };
+    }
+}
+
+exports.initializePolyfills = initializePolyfills;
+//# sourceMappingURL=global.js.map

package/dist/cjs/mods/security/src/types/global.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"global.js","sources":["../../../../../../mods/security/src/types/global.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAAA;;;;;AAKG;AAwBH;;AAEG;SACa,mBAAmB,GAAA;;AAE/B,IAAA,IAAI,OAAQ,UAAkB,CAAC,OAAO,KAAK,WAAW,EAAE;;AAEnD,QAAA,UAAkB,CAAC,OAAO,GAAG,MAAM,OAAO,CAAA;AAGvC,YAAA,WAAA,CAAY,MAAS,EAAA;AACjB,gBAAA,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;aACxB;YAED,KAAK,GAAA;gBACD,OAAO,IAAI,CAAC,MAAM,CAAC;aACtB;SACJ,CAAC;KACL;;AAGD,IAAA,IAAI,OAAQ,UAAkB,CAAC,oBAAoB,KAAK,WAAW,EAAE;;AAEhE,QAAA,UAAkB,CAAC,oBAAoB,GAAG,MAAM,oBAAoB,CAAA;AAMjE,YAAA,WAAA,CAAY,eAAuC,EAAA;AAF3C,gBAAA,IAAA,CAAA,aAAa,GAAG,IAAI,GAAG,EAAa,CAAC;AAGzC,gBAAA,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;aAC1C;AAED,YAAA,QAAQ,CACJ,MAAc,EACd,SAAY,EACZ,eAAwB,EAAA;gBAExB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;;gBAG1C,UAAU,CAAC,MAAK;oBACZ,IAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;AAChC,wBAAA,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;AAChC,wBAAA,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;qBACrC;AACL,iBAAC,EAAE,KAAK,CAAC,CAAC;aACb;AAED,YAAA,UAAU,CAAC,eAAuB,EAAA;gBAC9B,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;aACrD;SACJ,CAAC;KACL;AACL;;;;"}

package/dist/cjs/mods/security/src/types/secure-mem.type.js

@@ -0,0 +1,100 @@
+'use strict';
+
+// Safe library instances
+exports.sodium = null;
+exports.nobleHashes = null;
+exports.nobleCiphers = null;
+// Library status tracking
+const libraryStatus = {
+    sodium: false,
+    nobleHashes: false,
+    nobleCiphers: false,
+};
+// Safe library initialization with proper error handling
+async function initializeSecurityLibraries() {
+    // Initialize libsodium with proper async handling
+    try {
+        const sodiumLib = await import('libsodium-wrappers');
+        if (sodiumLib.default) {
+            // Wait for sodium to be ready if it has a ready promise
+            if (sodiumLib.default.ready &&
+                typeof sodiumLib.default.ready.then === "function") {
+                await sodiumLib.default.ready;
+            }
+            // Verify required methods exist
+            if (typeof sodiumLib.default.randombytes_buf === "function") {
+                exports.sodium = sodiumLib.default;
+                libraryStatus.sodium = true;
+                // console.log(
+                //     "✔ libsodium-wrappers loaded successfully for SecureBuffer"
+                // );
+            }
+        }
+    }
+    catch (e) {
+        console.warn("⚠️ libsodium-wrappers not available for SecureBuffer:", e.message);
+    }
+    // Initialize @noble/hashes using require for compatibility
+    try {
+        const nobleHashesLib = require("@noble/hashes/sha256");
+        const nobleHashesLib512 = require("@noble/hashes/sha512");
+        if (nobleHashesLib &&
+            nobleHashesLib.sha256 &&
+            nobleHashesLib512 &&
+            nobleHashesLib512.sha512) {
+            exports.nobleHashes = {
+                sha256: nobleHashesLib.sha256,
+                sha512: nobleHashesLib512.sha512,
+            };
+            libraryStatus.nobleHashes = true;
+            // console.log(
+            //     "✔ @noble/hashes loaded successfully for SecureBuffer"
+            // );
+        }
+    }
+    catch (e) {
+        console.warn("⚠️ @noble/hashes not available for SecureBuffer:", e.message);
+    }
+    // Initialize @noble/ciphers using require for compatibility
+    try {
+        // Try importing specific submodules instead of root module
+        const chachaLib = require("@noble/ciphers/chacha");
+        const aesLib = require("@noble/ciphers/aes");
+        if (chachaLib && aesLib) {
+            exports.nobleCiphers = {
+                chacha20poly1305: chachaLib.chacha20poly1305,
+                aes: aesLib,
+            };
+            libraryStatus.nobleCiphers = true;
+            // console.log(
+            //     "✔ @noble/ciphers loaded successfully for SecureBuffer"
+            // );
+        }
+    }
+    catch (e) {
+        // Silently fail - this is optional
+        // console.warn(
+        //     "⚠️ @noble/ciphers not available for SecureBuffer:",
+        //     (e as Error).message
+        // );
+    }
+}
+// Initialize libraries asynchronously and non-blocking
+let initializationPromise = null;
+function ensureLibrariesInitialized() {
+    if (!initializationPromise) {
+        initializationPromise = initializeSecurityLibraries().catch((_error) => {
+            // Silently handle initialization errors - libraries are optional
+            // console.error(
+            //     "Failed to initialize security libraries for SecureBuffer:",
+            //     error
+            // );
+        });
+    }
+    return initializationPromise;
+}
+
+exports.ensureLibrariesInitialized = ensureLibrariesInitialized;
+exports.initializeSecurityLibraries = initializeSecurityLibraries;
+exports.libraryStatus = libraryStatus;
+//# sourceMappingURL=secure-mem.type.js.map

package/dist/cjs/mods/security/src/types/secure-mem.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"secure-mem.type.js","sources":["../../../../../../mods/security/src/types/secure-mem.type.ts"],"sourcesContent":[null],"names":["sodium","nobleHashes","nobleCiphers"],"mappings":";;AA8BA;AACIA,cAAM,GAA2B,KAAK;AACtCC,mBAAW,GAAgC,KAAK;AAChDC,oBAAY,GAAiC,KAAK;AAEtD;AACA,MAAM,aAAa,GAAG;AAClB,IAAA,MAAM,EAAE,KAAK;AACb,IAAA,WAAW,EAAE,KAAK;AAClB,IAAA,YAAY,EAAE,KAAK;EACrB;AAEF;AACO,eAAe,2BAA2B,GAAA;;AAE7C,IAAA,IAAI;AACA,QAAA,MAAM,SAAS,GAAG,MAAM,OAAO,oBAAoB,CAAC,CAAC;AACrD,QAAA,IAAI,SAAS,CAAC,OAAO,EAAE;;AAEnB,YAAA,IACI,SAAS,CAAC,OAAO,CAAC,KAAK;gBACvB,OAAO,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,UAAU,EACpD;AACE,gBAAA,MAAM,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC;aACjC;;YAGD,IAAI,OAAO,SAAS,CAAC,OAAO,CAAC,eAAe,KAAK,UAAU,EAAE;AACzD,gBAAAF,cAAM,GAAG,SAAS,CAAC,OAA0B,CAAC;AAC9C,gBAAA,aAAa,CAAC,MAAM,GAAG,IAAI,CAAC;;;;aAI/B;SACJ;KACJ;IAAC,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,IAAI,CACR,uDAAuD,EACtD,CAAW,CAAC,OAAO,CACvB,CAAC;KACL;;AAGD,IAAA,IAAI;AACA,QAAA,MAAM,cAAc,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;AACvD,QAAA,MAAM,iBAAiB,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;AAC1D,QAAA,IACI,cAAc;AACd,YAAA,cAAc,CAAC,MAAM;YACrB,iBAAiB;YACjB,iBAAiB,CAAC,MAAM,EAC1B;AACE,YAAAC,mBAAW,GAAG;gBACV,MAAM,EAAE,cAAc,CAAC,MAAM;gBAC7B,MAAM,EAAE,iBAAiB,CAAC,MAAM;aACX,CAAC;AAC1B,YAAA,aAAa,CAAC,WAAW,GAAG,IAAI,CAAC;;;;SAIpC;KACJ;IAAC,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,IAAI,CACR,kDAAkD,EACjD,CAAW,CAAC,OAAO,CACvB,CAAC;KACL;;AAGD,IAAA,IAAI;;AAEA,QAAA,MAAM,SAAS,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;AACnD,QAAA,MAAM,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;AAC7C,QAAA,IAAI,SAAS,IAAI,MAAM,EAAE;AACrB,YAAAC,oBAAY,GAAG;gBACX,gBAAgB,EAAE,SAAS,CAAC,gBAAgB;AAC5C,gBAAA,GAAG,EAAE,MAAM;aACW,CAAC;AAC3B,YAAA,aAAa,CAAC,YAAY,GAAG,IAAI,CAAC;;;;SAIrC;KACJ;IAAC,OAAO,CAAC,EAAE;;;;;;KAMX;AACL,CAAC;AAED;AACA,IAAI,qBAAqB,GAAyB,IAAI,CAAC;SAEvC,0BAA0B,GAAA;IACtC,IAAI,CAAC,qBAAqB,EAAE;QACxB,qBAAqB,GAAG,2BAA2B,EAAE,CAAC,KAAK,CACvD,CAAC,MAAM,KAAI;;;;;;AAMX,SAAC,CACJ,CAAC;KACL;AACD,IAAA,OAAO,qBAAqB,CAAC;AACjC;;;;;;"}

package/dist/cjs/mods/security/src/types/secure-memory.js

@@ -0,0 +1,20 @@
+'use strict';
+
+// Memory protection levels
+exports.MemoryProtectionLevel = void 0;
+(function (MemoryProtectionLevel) {
+    MemoryProtectionLevel["BASIC"] = "basic";
+    MemoryProtectionLevel["ENHANCED"] = "enhanced";
+    MemoryProtectionLevel["MILITARY"] = "military";
+    MemoryProtectionLevel["QUANTUM_SAFE"] = "quantum_safe";
+})(exports.MemoryProtectionLevel || (exports.MemoryProtectionLevel = {}));
+// Buffer state tracking
+exports.BufferState = void 0;
+(function (BufferState) {
+    BufferState["UNINITIALIZED"] = "uninitialized";
+    BufferState["ACTIVE"] = "active";
+    BufferState["LOCKED"] = "locked";
+    BufferState["DESTROYED"] = "destroyed";
+    BufferState["CORRUPTED"] = "corrupted";
+})(exports.BufferState || (exports.BufferState = {}));
+//# sourceMappingURL=secure-memory.js.map

package/dist/cjs/mods/security/src/types/secure-memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"secure-memory.js","sources":["../../../../../../mods/security/src/types/secure-memory.ts"],"sourcesContent":[null],"names":["MemoryProtectionLevel","BufferState"],"mappings":";;AACA;AACYA,uCAKX;AALD,CAAA,UAAY,qBAAqB,EAAA;AAC7B,IAAA,qBAAA,CAAA,OAAA,CAAA,GAAA,OAAe,CAAA;AACf,IAAA,qBAAA,CAAA,UAAA,CAAA,GAAA,UAAqB,CAAA;AACrB,IAAA,qBAAA,CAAA,UAAA,CAAA,GAAA,UAAqB,CAAA;AACrB,IAAA,qBAAA,CAAA,cAAA,CAAA,GAAA,cAA6B,CAAA;AACjC,CAAC,EALWA,6BAAqB,KAArBA,6BAAqB,GAKhC,EAAA,CAAA,CAAA,CAAA;AAED;AACYC,6BAMX;AAND,CAAA,UAAY,WAAW,EAAA;AACnB,IAAA,WAAA,CAAA,eAAA,CAAA,GAAA,eAA+B,CAAA;AAC/B,IAAA,WAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,WAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,WAAA,CAAA,WAAA,CAAA,GAAA,WAAuB,CAAA;AACvB,IAAA,WAAA,CAAA,WAAA,CAAA,GAAA,WAAuB,CAAA;AAC3B,CAAC,EANWA,mBAAW,KAAXA,mBAAW,GAMtB,EAAA,CAAA,CAAA;;"}

package/dist/cjs/mods/security/src/types.js

@@ -0,0 +1,63 @@
+'use strict';
+
+/**
+ * Type definitions for the XyPrissSecurity library
+ */
+/**
+ * Security level enum
+ */
+exports.SecurityLevel = void 0;
+(function (SecurityLevel) {
+    SecurityLevel["STANDARD"] = "standard";
+    SecurityLevel["HIGH"] = "high";
+    SecurityLevel["MAXIMUM"] = "maximum";
+})(exports.SecurityLevel || (exports.SecurityLevel = {}));
+/**
+ * Token type enum
+ */
+exports.TokenType = void 0;
+(function (TokenType) {
+    TokenType["GENERAL"] = "general";
+    TokenType["API_KEY"] = "api_key";
+    TokenType["SESSION"] = "session";
+    TokenType["JWT"] = "jwt";
+    TokenType["TOTP"] = "totp";
+})(exports.TokenType || (exports.TokenType = {}));
+/**
+ * Hash algorithm enum - can be used as values
+ */
+exports.HashAlgorithm = void 0;
+(function (HashAlgorithm) {
+    HashAlgorithm["SHA256"] = "sha256";
+    HashAlgorithm["SHA512"] = "sha512";
+    HashAlgorithm["SHA3_256"] = "sha3-256";
+    HashAlgorithm["SHA3_512"] = "sha3-512";
+    HashAlgorithm["BLAKE3"] = "blake3";
+    HashAlgorithm["BLAKE2B"] = "blake2b";
+    HashAlgorithm["BLAKE2S"] = "blake2s";
+    HashAlgorithm["PBKDF2"] = "pbkdf2";
+})(exports.HashAlgorithm || (exports.HashAlgorithm = {}));
+/**
+ * Key derivation algorithm enum
+ */
+exports.KeyDerivationAlgorithm = void 0;
+(function (KeyDerivationAlgorithm) {
+    KeyDerivationAlgorithm["PBKDF2"] = "pbkdf2";
+    KeyDerivationAlgorithm["ARGON2"] = "argon2";
+    KeyDerivationAlgorithm["BALLOON"] = "balloon";
+})(exports.KeyDerivationAlgorithm || (exports.KeyDerivationAlgorithm = {}));
+/**
+ * Entropy source enum
+ */
+exports.EntropySource = void 0;
+(function (EntropySource) {
+    EntropySource["SYSTEM"] = "system";
+    EntropySource["BROWSER"] = "browser";
+    EntropySource["USER"] = "user";
+    EntropySource["NETWORK"] = "network";
+    EntropySource["COMBINED"] = "combined";
+    EntropySource["CSPRNG"] = "csprng";
+    EntropySource["MATH_RANDOM"] = "math_random";
+    EntropySource["CUSTOM"] = "custom";
+})(exports.EntropySource || (exports.EntropySource = {}));
+//# sourceMappingURL=types.js.map

package/dist/cjs/mods/security/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":["../../../../../mods/security/src/types.ts"],"sourcesContent":[null],"names":["SecurityLevel","TokenType","HashAlgorithm","KeyDerivationAlgorithm","EntropySource"],"mappings":";;AAAA;;AAEG;AAMH;;AAEG;AACSA,+BAIX;AAJD,CAAA,UAAY,aAAa,EAAA;AACrB,IAAA,aAAA,CAAA,UAAA,CAAA,GAAA,UAAqB,CAAA;AACrB,IAAA,aAAA,CAAA,MAAA,CAAA,GAAA,MAAa,CAAA;AACb,IAAA,aAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACvB,CAAC,EAJWA,qBAAa,KAAbA,qBAAa,GAIxB,EAAA,CAAA,CAAA,CAAA;AAED;;AAEG;AACSC,2BAMX;AAND,CAAA,UAAY,SAAS,EAAA;AACjB,IAAA,SAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACnB,IAAA,SAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACnB,IAAA,SAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACnB,IAAA,SAAA,CAAA,KAAA,CAAA,GAAA,KAAW,CAAA;AACX,IAAA,SAAA,CAAA,MAAA,CAAA,GAAA,MAAa,CAAA;AACjB,CAAC,EANWA,iBAAS,KAATA,iBAAS,GAMpB,EAAA,CAAA,CAAA,CAAA;AAED;;AAEG;AACSC,+BASX;AATD,CAAA,UAAY,aAAa,EAAA;AACrB,IAAA,aAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,aAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,aAAA,CAAA,UAAA,CAAA,GAAA,UAAqB,CAAA;AACrB,IAAA,aAAA,CAAA,UAAA,CAAA,GAAA,UAAqB,CAAA;AACrB,IAAA,aAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,aAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACnB,IAAA,aAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACnB,IAAA,aAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACrB,CAAC,EATWA,qBAAa,KAAbA,qBAAa,GASxB,EAAA,CAAA,CAAA,CAAA;AAoBD;;AAEG;AACSC,wCAIX;AAJD,CAAA,UAAY,sBAAsB,EAAA;AAC9B,IAAA,sBAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,sBAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,sBAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACvB,CAAC,EAJWA,8BAAsB,KAAtBA,8BAAsB,GAIjC,EAAA,CAAA,CAAA,CAAA;AAED;;AAEG;AACSC,+BASX;AATD,CAAA,UAAY,aAAa,EAAA;AACrB,IAAA,aAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,aAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACnB,IAAA,aAAA,CAAA,MAAA,CAAA,GAAA,MAAa,CAAA;AACb,IAAA,aAAA,CAAA,SAAA,CAAA,GAAA,SAAmB,CAAA;AACnB,IAAA,aAAA,CAAA,UAAA,CAAA,GAAA,UAAqB,CAAA;AACrB,IAAA,aAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACjB,IAAA,aAAA,CAAA,aAAA,CAAA,GAAA,aAA2B,CAAA;AAC3B,IAAA,aAAA,CAAA,QAAA,CAAA,GAAA,QAAiB,CAAA;AACrB,CAAC,EATWA,qBAAa,KAAbA,qBAAa,GASxB,EAAA,CAAA,CAAA;;"}