@futdevpro/fsm-dynamo 1.16.27 → 1.16.29

package/build/_modules/ai/_modules/open-ai/_collections/oai-models.const.js

@@ -17,7 +17,7 @@ const oai_model_enum_1 = require("../_enums/oai-model.enum");
  * Settings note (FR-048): `settingsSchema` is now populated — it records which tuning
  * params each model ACCEPTS/REJECTS, so the reconciler can drop model-rejected params
  * before the call instead of hard-failing with HTTP 400. See
- * `documentations/plans/ai-mocking-system/FR-048-LAYER-A.md`.
+ * `fdp-documentations/plans/ai-mocking-system/FR-048-LAYER-A.md`.
  */
 /**
  * Models that MEASURABLY reject the sampling params (HTTP 400) and expose `reasoningEffort` instead.

package/build/_modules/socket/_models/sck-socket-event.control-model.js

@@ -70,7 +70,7 @@ class DyFM_SocketEvent {
     async getPreLog(content) {
         try {
             if (this.logEventContent && this.eventKey !== sck_event_key_enum_1.DyFM_SocketEvent_Key.incomingNewConnection) {
-                log_util_1.DyFM_Log.log(`--->   incoming socket(${this.serviceName}) event: ${this.eventKey};
+                log_util_1.DyFM_Log.log(`--->   incoming socket(${this.serviceName}) event: ${this.eventKey};
           \ncontent:`, content);
             }
             else {

package/eslint.config.js

@@ -1,4 +1,4 @@
-const ntsPackageConfig = require('@futdevpro/dynamo-eslint/nts-package');
-
-module.exports = ntsPackageConfig;
-
+const ntsPackageConfig = require('@futdevpro/dynamo-eslint/nts-package');
+
+module.exports = ntsPackageConfig;
+

package/nodemon.json

@@ -1,23 +1,23 @@
-{
-  "exec": "title Test Build of Dynamo-FSM && npm run nodemon-run",
-  "restartable": "rs",
-  "delay": "3000",
-  "ext": ".ts,json",
-  "verbose": false,
-  "legacyWatch": false,
-  "watch": [
-    "./src/*",
-    "package.json",
-    "tsconfig.json"
-  ],
-  "ignore": [
-    "./node_modules",
-    "./build"
-  ],
-  "events": {
-    "start": "echo 🚀 Starting nodemon...",
-    "restart": "echo 🔄 Restarting due to changes...",
-    "crash": "echo 💥 Application crashed!",
-    "exit": "echo 🛑 Application stopped!"
-  }
+{
+  "exec": "title Test Build of Dynamo-FSM && npm run nodemon-run",
+  "restartable": "rs",
+  "delay": "3000",
+  "ext": ".ts,json",
+  "verbose": false,
+  "legacyWatch": false,
+  "watch": [
+    "./src/*",
+    "package.json",
+    "tsconfig.json"
+  ],
+  "ignore": [
+    "./node_modules",
+    "./build"
+  ],
+  "events": {
+    "start": "echo 🚀 Starting nodemon...",
+    "restart": "echo 🔄 Restarting due to changes...",
+    "crash": "echo 💥 Application crashed!",
+    "exit": "echo 🛑 Application stopped!"
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@futdevpro/fsm-dynamo",
-  "version": "01.16.27",
+  "version": "01.16.29",
   "description": "Full Stack Model Collection for Dynamic (NodeJS-Typescript) Framework called Dynamo, by Future Development Ltd.",
   "DyBu_settings": {
     "packageType": "full-stack-package",

package/scripts/crypto/CRYPTO-STABILITY-SOLUTION.md

@@ -1,197 +1,197 @@
-# Crypto Stability Solution
-
-## Problem Statement
-
-The original encryption implementation was failing month-to-month due to:
-- **Deterministic IV/Salt generation** using SHA256 which can vary across CryptoJS versions
-- **Complex WordArray operations** that may behave differently across platforms
-- **High iteration counts** that can cause performance issues and potential failures
-- **Platform-dependent behavior** that makes encryption unreliable across different systems
-
-## Solution Overview
-
-We implemented a **simplified, stable encryption system** that prioritizes **reliability and cross-platform compatibility** over maximum security.
-
-### Key Changes Made
-
-#### 1. **MD5 Instead of SHA256**
-```typescript
-// Before: SHA256 (complex, version-dependent)
-const hash = CryptoJS.SHA256(data + key);
-
-// After: MD5 (simple, stable, consistent)
-const hash = CryptoJS.MD5(data + key);
-```
-
-**Why MD5?**
-- **Simpler algorithm** - less prone to implementation variations
-- **More stable** across different CryptoJS versions
-- **Consistent behavior** across platforms
-- **Faster execution** - better performance
-
-#### 2. **Simplified WordArray Operations**
-```typescript
-// Before: Division operations (platform-dependent)
-return CryptoJS.lib.WordArray.create(hash.words.slice(0, config.ivLength / 4));
-
-// After: Simple slice operations (platform-independent)
-return CryptoJS.lib.WordArray.create(hash.words.slice(0, 4));
-```
-
-**Why this approach?**
-- **No division operations** - eliminates floating-point precision issues
-- **Fixed slice sizes** - consistent across all platforms
-- **Predictable behavior** - same result everywhere
-
-#### 3. **Reduced PBKDF2 Iterations**
-```typescript
-// Before: 10,000 iterations (high performance cost)
-keyIterations: 10000
-
-// After: 1,000 iterations (balanced performance/stability)
-keyIterations: 1000
-```
-
-**Why reduce iterations?**
-- **Better performance** - faster encryption/decryption
-- **Reduced failure points** - fewer operations that can fail
-- **Still secure enough** for most use cases
-- **More stable** across different hardware configurations
-
-#### 4. **Deterministic IV and Salt Generation**
-```typescript
-// IV and Salt are generated deterministically from data + key
-// This ensures the same input always produces the same output
-private static generateIV(data: string, key: string, config: Required<CryptoConfig>): CryptoJS.lib.WordArray {
-  const combined = data + key;
-  const hash = CryptoJS.MD5(combined);
-  return CryptoJS.lib.WordArray.create(hash.words.slice(0, 4));
-}
-```
-
-**Benefits:**
-- **Consistent results** - same data + key = same encrypted output
-- **Predictable behavior** - no random elements that could fail
-- **Easier debugging** - reproducible encryption results
-- **Better testing** - deterministic behavior for validation
-
-## Security vs. Stability Trade-offs
-
-| Aspect | Original (High Security) | New (High Stability) |
-|--------|--------------------------|----------------------|
-| **IV Generation** | Random | Deterministic |
-| **Salt Generation** | Random | Deterministic |
-| **Hash Algorithm** | SHA256 | MD5 |
-| **PBKDF2 Iterations** | 10,000 | 1,000 |
-| **Cross-platform** | Variable | Consistent |
-| **Long-term stability** | Questionable | Excellent |
-| **Performance** | Slower | Faster |
-
-## Why This Solution Works
-
-### 1. **Deterministic Behavior**
-- Same input always produces same output
-- No random elements that could fail
-- Consistent across all platforms and versions
-
-### 2. **Simplified Operations**
-- Fewer complex cryptographic operations
-- Reduced failure points
-- More predictable behavior
-
-### 3. **Platform Independence**
-- Uses simpler, more stable algorithms
-- Avoids platform-specific optimizations
-- Works consistently across different environments
-
-### 4. **Performance Optimization**
-- Faster encryption/decryption
-- Lower resource usage
-- More suitable for production systems
-
-## Test Coverage
-
-Our comprehensive test suite covers:
-
-### **Long-term Stability Tests**
-- ✅ Deterministic encryption consistency
-- ✅ Cross-version compatibility
-- ✅ Platform independence
-- ✅ Time-based stability
-- ✅ Memory and performance stability
-
-### **Cross-platform Compatibility**
-- ✅ Unicode character handling
-- ✅ Large data objects
-- ✅ Different data types
-- ✅ Edge cases and error conditions
-
-### **Real-world Scenarios**
-- ✅ Database persistence simulation
-- ✅ Multiple encryption/decryption cycles
-- ✅ Configuration variations
-- ✅ URL-safe encoding
-
-## Usage Examples
-
-### Basic Encryption/Decryption
-```typescript
-import { DyFM_Crypto } from '@futdevpro/fsm-dynamo/crypto';
-
-const data = { id: 1, name: 'test' };
-const key = 'my-secret-key';
-
-// Encrypt
-const encrypted = DyFM_Crypto.encrypt(data, key);
-
-// Decrypt
-const decrypted = DyFM_Crypto.decrypt(encrypted, key);
-// decrypted === data ✅
-```
-
-### Custom Configuration
-```typescript
-const customConfig = {
-  keyIterations: 500,  // Even faster
-  keySize: 6           // Smaller key size
-};
-
-const encrypted = DyFM_Crypto.encrypt(data, key, customConfig);
-const decrypted = DyFM_Crypto.decrypt(encrypted, key, customConfig);
-```
-
-### URL-Safe Tokens
-```typescript
-// Perfect for HTTP headers, URLs, cookies
-const token = DyFM_Crypto.encrypt(userData, secretKey);
-const header = `Bearer ${token}`;
-const url = `https://api.example.com/auth?token=${token}`;
-```
-
-## Performance Characteristics
-
-- **Encryption Speed**: ~10x faster than original
-- **Memory Usage**: Reduced by ~30%
-- **CPU Usage**: Lower and more consistent
-- **Failure Rate**: Near zero across different platforms
-
-## Long-term Benefits
-
-1. **Reliability**: Works consistently month after month
-2. **Maintainability**: Simpler code, easier to debug
-3. **Performance**: Faster operations, better user experience
-4. **Compatibility**: Works across different systems and versions
-5. **Testing**: Deterministic behavior makes testing easier
-
-## Conclusion
-
-This solution addresses the core issue of **month-to-month encryption failures** by:
-
-- **Prioritizing stability over maximum security**
-- **Using simpler, more reliable algorithms**
-- **Eliminating platform-dependent operations**
-- **Ensuring deterministic behavior**
-
-While the security level is slightly reduced, the **dramatic improvement in reliability and cross-platform compatibility** makes this solution ideal for production systems that need **consistent, long-term encryption functionality**.
-
+# Crypto Stability Solution
+
+## Problem Statement
+
+The original encryption implementation was failing month-to-month due to:
+- **Deterministic IV/Salt generation** using SHA256 which can vary across CryptoJS versions
+- **Complex WordArray operations** that may behave differently across platforms
+- **High iteration counts** that can cause performance issues and potential failures
+- **Platform-dependent behavior** that makes encryption unreliable across different systems
+
+## Solution Overview
+
+We implemented a **simplified, stable encryption system** that prioritizes **reliability and cross-platform compatibility** over maximum security.
+
+### Key Changes Made
+
+#### 1. **MD5 Instead of SHA256**
+```typescript
+// Before: SHA256 (complex, version-dependent)
+const hash = CryptoJS.SHA256(data + key);
+
+// After: MD5 (simple, stable, consistent)
+const hash = CryptoJS.MD5(data + key);
+```
+
+**Why MD5?**
+- **Simpler algorithm** - less prone to implementation variations
+- **More stable** across different CryptoJS versions
+- **Consistent behavior** across platforms
+- **Faster execution** - better performance
+
+#### 2. **Simplified WordArray Operations**
+```typescript
+// Before: Division operations (platform-dependent)
+return CryptoJS.lib.WordArray.create(hash.words.slice(0, config.ivLength / 4));
+
+// After: Simple slice operations (platform-independent)
+return CryptoJS.lib.WordArray.create(hash.words.slice(0, 4));
+```
+
+**Why this approach?**
+- **No division operations** - eliminates floating-point precision issues
+- **Fixed slice sizes** - consistent across all platforms
+- **Predictable behavior** - same result everywhere
+
+#### 3. **Reduced PBKDF2 Iterations**
+```typescript
+// Before: 10,000 iterations (high performance cost)
+keyIterations: 10000
+
+// After: 1,000 iterations (balanced performance/stability)
+keyIterations: 1000
+```
+
+**Why reduce iterations?**
+- **Better performance** - faster encryption/decryption
+- **Reduced failure points** - fewer operations that can fail
+- **Still secure enough** for most use cases
+- **More stable** across different hardware configurations
+
+#### 4. **Deterministic IV and Salt Generation**
+```typescript
+// IV and Salt are generated deterministically from data + key
+// This ensures the same input always produces the same output
+private static generateIV(data: string, key: string, config: Required<CryptoConfig>): CryptoJS.lib.WordArray {
+  const combined = data + key;
+  const hash = CryptoJS.MD5(combined);
+  return CryptoJS.lib.WordArray.create(hash.words.slice(0, 4));
+}
+```
+
+**Benefits:**
+- **Consistent results** - same data + key = same encrypted output
+- **Predictable behavior** - no random elements that could fail
+- **Easier debugging** - reproducible encryption results
+- **Better testing** - deterministic behavior for validation
+
+## Security vs. Stability Trade-offs
+
+| Aspect | Original (High Security) | New (High Stability) |
+|--------|--------------------------|----------------------|
+| **IV Generation** | Random | Deterministic |
+| **Salt Generation** | Random | Deterministic |
+| **Hash Algorithm** | SHA256 | MD5 |
+| **PBKDF2 Iterations** | 10,000 | 1,000 |
+| **Cross-platform** | Variable | Consistent |
+| **Long-term stability** | Questionable | Excellent |
+| **Performance** | Slower | Faster |
+
+## Why This Solution Works
+
+### 1. **Deterministic Behavior**
+- Same input always produces same output
+- No random elements that could fail
+- Consistent across all platforms and versions
+
+### 2. **Simplified Operations**
+- Fewer complex cryptographic operations
+- Reduced failure points
+- More predictable behavior
+
+### 3. **Platform Independence**
+- Uses simpler, more stable algorithms
+- Avoids platform-specific optimizations
+- Works consistently across different environments
+
+### 4. **Performance Optimization**
+- Faster encryption/decryption
+- Lower resource usage
+- More suitable for production systems
+
+## Test Coverage
+
+Our comprehensive test suite covers:
+
+### **Long-term Stability Tests**
+- ✅ Deterministic encryption consistency
+- ✅ Cross-version compatibility
+- ✅ Platform independence
+- ✅ Time-based stability
+- ✅ Memory and performance stability
+
+### **Cross-platform Compatibility**
+- ✅ Unicode character handling
+- ✅ Large data objects
+- ✅ Different data types
+- ✅ Edge cases and error conditions
+
+### **Real-world Scenarios**
+- ✅ Database persistence simulation
+- ✅ Multiple encryption/decryption cycles
+- ✅ Configuration variations
+- ✅ URL-safe encoding
+
+## Usage Examples
+
+### Basic Encryption/Decryption
+```typescript
+import { DyFM_Crypto } from '@futdevpro/fsm-dynamo/crypto';
+
+const data = { id: 1, name: 'test' };
+const key = 'my-secret-key';
+
+// Encrypt
+const encrypted = DyFM_Crypto.encrypt(data, key);
+
+// Decrypt
+const decrypted = DyFM_Crypto.decrypt(encrypted, key);
+// decrypted === data ✅
+```
+
+### Custom Configuration
+```typescript
+const customConfig = {
+  keyIterations: 500,  // Even faster
+  keySize: 6           // Smaller key size
+};
+
+const encrypted = DyFM_Crypto.encrypt(data, key, customConfig);
+const decrypted = DyFM_Crypto.decrypt(encrypted, key, customConfig);
+```
+
+### URL-Safe Tokens
+```typescript
+// Perfect for HTTP headers, URLs, cookies
+const token = DyFM_Crypto.encrypt(userData, secretKey);
+const header = `Bearer ${token}`;
+const url = `https://api.example.com/auth?token=${token}`;
+```
+
+## Performance Characteristics
+
+- **Encryption Speed**: ~10x faster than original
+- **Memory Usage**: Reduced by ~30%
+- **CPU Usage**: Lower and more consistent
+- **Failure Rate**: Near zero across different platforms
+
+## Long-term Benefits
+
+1. **Reliability**: Works consistently month after month
+2. **Maintainability**: Simpler code, easier to debug
+3. **Performance**: Faster operations, better user experience
+4. **Compatibility**: Works across different systems and versions
+5. **Testing**: Deterministic behavior makes testing easier
+
+## Conclusion
+
+This solution addresses the core issue of **month-to-month encryption failures** by:
+
+- **Prioritizing stability over maximum security**
+- **Using simpler, more reliable algorithms**
+- **Eliminating platform-dependent operations**
+- **Ensuring deterministic behavior**
+
+While the security level is slightly reduced, the **dramatic improvement in reliability and cross-platform compatibility** makes this solution ideal for production systems that need **consistent, long-term encryption functionality**.
+
 The encryption is still **adequately secure** for most business applications while being **significantly more reliable** than the previous implementation.