fenneckit 1.0.4 → 1.2.0

package/README.md

@@ -6,9 +6,10 @@
 npm install fenneckit@latest --save-dev
 npx fenneckit --help
 ```
-**English**: A Complete Storage System for Practical and Seamless Data Analysis
 
-**Zero Config** • Sequential Labs • Inter-Lab Data Sharing (within the same file) • Store Management
+**English**: A Complete Storage + Security + API Testing System for Practical and Seamless Data Analysis
+
+**Zero Config** • Sequential Labs • Inter-Lab Data Sharing (within the same file) • Store Management • Encrypted Secrets • Namespaces • Audit Log • HTTP Testing Kit
 
 **🦊Example** : soon
 
@@ -70,8 +71,8 @@ npx fenneckit
 4. Generates a report (`fenneckit.md`) after execution
 
 > **Important limitation**  
-> Data sharing (`setStore` / `getStore`) only works **inside the same file**.  
-> Different lab files **cannot** share STORE or TEMP data with each other.
+> Data sharing (`setStore` / `getStore` / secrets / namespaces) only works **inside the same file**.  
+> Different lab files **cannot** share STORE, TEMP, Secrets or Namespaces with each other.
 
 ---
 
@@ -80,71 +81,47 @@ npx fenneckit
 ```
 📁 FennecKit Execution
 │
-├─ 📄 file1.labs.js (STORE Instance #1)
+├─ 📄 file1.labs.js (STORE Instance #1 + SecretVault + Namespaces)
 │  │
 │  ├─ 🔬 Lab 1 (User Registration)
 │  │  ├─ 📝 Test 1: Create User
 │  │  │  ├─ STORE: {"userId": "123"} ✅ Shared with Lab 2
+│  │  │  ├─ SECRET: encrypted token ✅ Shared with Lab 2
+│  │  │  ├─ NAMESPACE "user": {...} ✅ Shared with Lab 2
 │  │  │  └─ TEMP: {"token": "abc"} ❌ Only here
 │  │  │
 │  │  └─ 📝 Test 2: Send Email
-│  │     └─ Can access STORE from Test 1
+│  │     └─ Can access STORE / SECRET / Namespaces from Test 1
 │  │
 │  ├─ 🔬 Lab 2 (Authentication)
 │  │  ├─ 📝 Test 1: Generate Token
 │  │  │  ├─ STORE: {"userId": "123"} ✅ From Lab 1
+│  │  │  ├─ SECRET / Namespace ✅ From Lab 1
 │  │  │  └─ TEMP: {"token": "new"} ❌ Only here
 │  │  │
 │  │  └─ 📝 Test 2: Verify Token
-│  │     └─ Can access STORE from Labs 1 & 2
+│  │     └─ Can access STORE / SECRET / Namespaces from Labs 1 & 2
 │  │
 │  └─ 🔬 Lab 3 (Cleanup)
-│     └─ File STORE cleared when execution ends
+│     └─ File STORE + Secrets + Namespaces cleared when execution ends
 │
-├─ 📄 file2.labs.js (STORE Instance #2 - ISOLATED)
-│  │
-│  ├─ 🔬 Lab 1
-│  │  └─ ❌ CANNOT access file1.labs.js STORE
-│  │
-│  └─ 🔬 Lab 2
-│     └─ ❌ CANNOT access file1.labs.js STORE
+├─ 📄 file2.labs.js (Completely ISOLATED)
+│  └─ ❌ CANNOT access anything from file1.labs.js
 │
-└─ 📄 file3.labs.js (STORE Instance #3 - ISOLATED)
-   └─ ❌ Isolated from file1.labs.js and file2.labs.js
+└─ 📄 file3.labs.js (Completely ISOLATED)
+   └─ ❌ Isolated from all other files
 ```
 
 ### Understanding the Hierarchy
 
-**🔴 Level 1: Different Files = NO Data Sharing**
-```
-file1.labs.js  ← STORE Instance #1 (isolated)
-file2.labs.js  ← STORE Instance #2 (isolated)
-file3.labs.js  ← STORE Instance #3 (isolated)
-
-❌ file1's STORE ≠ file2's STORE ≠ file3's STORE
-```
+**🔴 Level 1: Different Files = NO Data Sharing**  
+Each file gets its own isolated STORE, SecretVault and Namespaces.
 
-**🟡 Level 2: Same File, Different Labs = STORE Sharing**
-```
-file1.labs.js
-├─ Lab 1: setStore("userId", "123")
-├─ Lab 2: getStore("userId")  ✅ Can access
-└─ Lab 3: getStore("userId")  ✅ Can still access
-```
+**🟡 Level 2: Same File, Different Labs = STORE + Secrets + Namespaces Sharing**  
+Data set in Lab 1 is available in Lab 2, Lab 3, etc. (until cleared).
 
-**🟢 Level 3: Same Lab, Different Tests = STORE + TEMP Sharing**
-```
-Lab 1 (User Registration)
-├─ Test 1: 
-│  ├─ setStore("userId", "123")  ✅ Shared with other tests
-│  └─ setTemp("token", "abc")    ✅ Shared with other tests in Lab 1
-│
-├─ Test 2:
-│  ├─ getStore("userId")  ✅ Works (from Test 1)
-│  └─ getTemp("token")    ✅ Works (from Test 1)
-│
-└─ Lab 1 ends → TEMP cleared, STORE remains
-```
+**🟢 Level 3: Same Lab, Different Tests = STORE + TEMP + Secrets + Namespaces Sharing**  
+TEMP is automatically cleared when the Lab ends. Everything else remains.
 
 ---
 
@@ -154,217 +131,218 @@ Lab 1 (User Registration)
 
 In Jest and Vitest every test is isolated. You cannot pass data from one test to another.
 
-### FennecKit Solution – Three Storage Levels
+### FennecKit Solution – Storage Levels (v1.2.0)
 
 ```
 ┌─────────────────────────────────────────────────────────────┐
 │         FennecKit Storage System (Per File)                 │
 ├─────────────────────────────────────────────────────────────┤
 │                                                             │
-│  LEVEL 1: FILE SCOPE (Entire File)                         │
+│  LEVEL 1: FILE SCOPE                                        │
 │  ┌──────────────────────────────────────────────────────┐  │
 │  │ STORE (Global - Persistent within file)              │  │
 │  │ ├─ Shared across ALL Labs in this file               │  │
 │  │ ├─ Available until file execution ends               │  │
 │  │ ├─ Can be manually cleared with clearStore()         │  │
-│  │ └─ Example: userId, authToken, orderData            │  │
+│  │ └─ Example: userId, orderData, status                │  │
 │  └──────────────────────────────────────────────────────┘  │
 │                                                             │
-│  LEVEL 2: LAB SCOPE (Single Lab)                           │
+│  LEVEL 2: ENCRYPTED SECRETS (AES-256-GCM)                   │
 │  ┌──────────────────────────────────────────────────────┐  │
-│  │ STORE (Available to this and following Labs)         │  │
-│  │ └─ Set in Lab 1, used in Lab 2, Lab 3, etc          │  │
+│  │ SECRET VAULT                                         │  │
+│  │ ├─ Encrypted at rest inside the process              │  │
+│  │ ├─ Shared across Labs in the same file               │  │
+│  │ ├─ setSecret / getSecret / clearSecret               │  │
+│  │ └─ Example: auth tokens, API keys, passwords         │  │
 │  └──────────────────────────────────────────────────────┘  │
 │                                                             │
-│  LEVEL 3: LAB-LOCAL SCOPE (Single Lab Only)               │
+│  LEVEL 3: NAMESPACES                                        │
+│  ┌──────────────────────────────────────────────────────┐  │
+│  │ kit.namespace("user") / kit.namespace("order")       │  │
+│  │ ├─ Isolated key-value stores                         │  │
+│  │ ├─ Shared across Labs in the same file               │  │
+│  │ └─ Perfect for grouping related data                 │  │
+│  └──────────────────────────────────────────────────────┘  │
+│                                                             │
+│  LEVEL 4: LAB-LOCAL SCOPE                                   │
 │  ┌──────────────────────────────────────────────────────┐  │
 │  │ TEMP (Local - Auto-Cleaned)                          │  │
 │  │ ├─ Only available inside current Lab                 │  │
 │  │ ├─ Automatically cleared when Lab ends               │  │
-│  │ ├─ Cannot be manually cleared                        │  │
-│  │ └─ Example: timestamps, temp calculations           │  │
+│  │ └─ Example: timestamps, temp calculations            │  │
 │  └──────────────────────────────────────────────────────┘  │
 │                                                             │
 └─────────────────────────────────────────────────────────────┘
 ```
 
-### Storage Demo (same file)
+---
 
-```typescript
-// ========== LAB 1: User Registration ==========
-await newLabs("User Registration", async (kit) => {
-  await kit.test("Create User", async () => {
-    const userId = "user_123";
-    const email = "john@example.com";
+## 🔐 NEW in v1.2.0: Secret Vault (AES-256-GCM)
 
-    // STORE → available to all Labs in this file
-    kit.setStore("userId", userId);
-    kit.setStore("userEmail", email);
+Sensitive data should never live in plain STORE.
 
-    // TEMP → only for this Lab
-    kit.setTemp("tempToken", "abc123");
+```typescript
+await newLabs("Auth Lab", async (kit) => {
+  await kit.test("Login", async () => {
+    // Encrypted storage
+    kit.setSecret("accessToken", "eyJhbGciOiJIUzI1NiIs...");
+    kit.setSecret("refreshToken", "rt_abc123");
 
-    kit.done("User created");
+    kit.done("Tokens stored securely");
   });
-});
 
-// ========== LAB 2: Authentication ==========
-await newLabs("Authentication", async (kit) => {
-  await kit.test("Generate Token", async () => {
-    const userId = kit.getStore("userId");      // ✅ works (from Lab 1)
-    const email = kit.getStore("userEmail");    // ✅ works (from Lab 1)
-    const token = kit.getTemp("tempToken");     // ❌ undefined (cleared after Lab 1)
+  await kit.test("Use Token", async () => {
+    const token = kit.getSecret("accessToken"); // decrypted on the fly
+    kit.http.setAuth("bearer", token!);
+    kit.done("Token retrieved");
+  });
 
-    kit.done(`Token generated for: ${email}`);
+  await kit.test("Cleanup", async () => {
+    kit.clearSecret("accessToken");     // remove one key
+    // kit.clearSecret();               // clear entire vault
+    kit.done("Secrets cleared");
   });
 });
 ```
 
----
+**TTL Support for Secrets**
+```typescript
+kit.setSecretWithTTL("tempToken", "abc123", 30_000); // auto-delete after 30s
+```
 
-## 🧹 NEW: clearStore() Feature (v1.1.0)
+---
 
-Manually clear Store data between Labs for better state management and security.
+## 🗂️ NEW in v1.2.0: Namespaced Store
 
-### Two Ways to Clear
+Organize data into logical groups.
 
-#### 1. Clear specific key (inside Lab)
 ```typescript
-await newLabs("My Lab", async (kit) => {
-  await kit.test("Store sensitive data", async () => {
-    kit.setStore("authToken", "secret123");
-    kit.done("Token stored");
+await newLabs("E-Commerce Flow", async (kit) => {
+  const user = kit.namespace("user");
+  const order = kit.namespace("order");
+  const cart = kit.namespace("cart");
+
+  await kit.test("Register", async () => {
+    user.set("id", "usr_123");
+    user.set("email", "john@example.com");
+    kit.done("User namespace populated");
   });
 
-  await kit.test("Cleanup", async () => {
-    kit.clearStore("authToken");  // Remove only this key
-    kit.done("Token cleared");
+  await kit.test("Create Order", async () => {
+    order.set("id", "ord_456");
+    order.set("total", 299.99);
+    kit.done("Order namespace populated");
+  });
+
+  await kit.test("Read Later", async () => {
+    const userId = kit.getNamespace("user")?.get("id"); // "usr_123"
+    const total  = order.get("total");                  // 299.99
+    kit.done(`User ${userId} ordered ${total}`);
   });
 });
 ```
 
-#### 2. Clear all data (global)
+---
+
+## 📡 NEW in v1.2.0: HTTP Kit (API Testing)
+
+Built-in HTTP client with auth, retries, history and tracing.
+
 ```typescript
-import { newLabs, clearStore } from "fenneckit";
+await newLabs("API Smoke Test", async (kit) => {
+  // Set auth once
+  kit.http.setAuth("bearer", "your-token");
+  // or kit.http.setAuth("basic", "base64creds");
+  // or kit.http.setAuth("api-key", "key123");
+
+  await kit.test("GET Users", async () => {
+    const res = await kit.http.get("https://api.example.com/users", {
+      timeout: 5000,
+      retry: { max: 3, delay: 1000 }
+    });
+
+    if (res.status !== 200) {
+      kit.err(`Expected 200, got ${res.status}`);
+    }
 
-await newLabs("Lab 1", async (kit) => {
-  await kit.test("Setup", async () => {
-    kit.setStore("data1", "value1");
-    kit.setStore("data2", "value2");
-    kit.done("Stored");
+    kit.setStore("users", res.data);
+    kit.done(`Fetched ${res.data.length} users`);
   });
-});
 
-clearStore();  // Clear all STORE data globally
+  await kit.test("POST Order", async () => {
+    const res = await kit.http.post("https://api.example.com/orders", {
+      productId: "prod_1",
+      qty: 2
+    });
+
+    kit.done(`Order created: ${res.data.id}`);
+  });
 
-await newLabs("Lab 2", async (kit) => {
-  await kit.test("Fresh Start", async () => {
-    const data = kit.getStore("data1");  // undefined
-    kit.done("Fresh state");
+  // Inspect request history
+  await kit.test("Check History", async () => {
+    const last = kit.http.getLastRequest();
+    kit.log(`Last request took ${last?.duration}ms`);
   });
 });
 ```
 
-### When to Use clearStore()
-
-| Scenario | Method | Why |
-|----------|--------|-----|
-| Remove sensitive data | `clearStore("token")` | Security |
-| Free memory | `clearStore("largeObject")` | Performance |
-| Test isolation | `clearStore()` | Prevent data leakage |
-| Between phases | `clearStore("tempData")` | Clean state |
+**Available methods**:
+- `kit.http.get / post / put / patch / delete`
+- `kit.http.setAuth(type, credentials)` / `clearAuth()`
+- `kit.http.getRequestHistory()` / `getLastRequest()` / `clearHistory()`
 
 ---
 
-## 📊 Storage Lifecycle (per file)
-
-```
-FILE EXECUTION START
-│
-├─ Lab 1
-│  ├─ setStore(...) → kept across all labs
-│  ├─ setTemp(...)  → kept only for this Lab
-│  ├─ clearStore(...) → optionally remove keys
-│  └─ Lab ends → TEMP cleared, STORE remains (unless cleared)
-│
-├─ Lab 2
-│  ├─ getStore(...) → works (if not cleared)
-│  ├─ getTemp(...)  → undefined (cleared after Lab 1)
-│  ├─ clearStore(...) → can clear for next labs
-│  └─ Lab ends → TEMP cleared, STORE remains (unless cleared)
-│
-└─ FILE END → STORE completely cleared
-```
-
-**Remember**: This lifecycle is **per file**.  
-Running `npx fenneckit fileA.labs.js` and then `npx fenneckit fileB.labs.js` gives two completely separate STORE instances.
+## 📋 NEW in v1.2.0: Audit Log
 
----
-
-## 💡 Real-World Example (Single File)
+Every STORE / SECRET operation is automatically recorded.
 
 ```typescript
-// order-pipeline.labs.js
-
-import { newLabs, clearStore } from "fenneckit";
-
-// LAB 1
-await newLabs("Order Validation", async (kit) => {
-  await kit.test("Check Product Stock", async () => {
-    kit.setStore("productId", "prod_456");
-    kit.setStore("stockAvailable", 50);
-    kit.setTemp("validationTime", Date.now());
-    kit.done("Product stock verified");
+await newLabs("Audit Demo", async (kit) => {
+  await kit.test("Operations", async () => {
+    kit.setStore("userId", "123");
+    kit.setSecret("token", "secret");
+    kit.getStore("userId");
   });
-});
-
-// LAB 2
-await newLabs("Payment Processing", async (kit) => {
-  await kit.test("Charge Customer Card", async () => {
-    const productId = kit.getStore("productId");  // ✅ From Lab 1
-    const chargeId = `charge_${Date.now()}`;
 
-    kit.setStore("chargeId", chargeId);
-    kit.setStore("orderStatus", "paid");
-    kit.setTemp("transactionId", chargeId);
+  await kit.test("Inspect Audit", async () => {
+    const last5 = kit.audit.getLast(5);
+    const byKey = kit.audit.filterByKey("token");
+    const json  = kit.audit.export("json");
+    const csv   = kit.audit.export("csv");
 
-    kit.done(`Payment charged: ${chargeId}`);
+    kit.log(`Recorded ${last5.length} operations`);
   });
 });
+```
 
-// Clear sensitive payment data before shipping
-clearStore("chargeId");
+---
 
-// LAB 3
-await newLabs("Shipping & Notification", async (kit) => {
-  await kit.test("Create Shipping Label", async () => {
-    const status = kit.getStore("orderStatus");    // ✅ Available
-    const chargeId = kit.getStore("chargeId");     // ❌ Cleared
-    const tempTx = kit.getTemp("transactionId");   // ❌ Undefined
+## 🧹 clearStore() & clearSecret()
 
-    if (status === "paid") {
-      const tracking = `TRACK_${Date.now()}`;
-      kit.setStore("trackingNumber", tracking);
-      kit.done(`Shipping label created: ${tracking}`);
-    }
-  });
+```typescript
+// Clear specific key
+kit.clearStore("authToken");
+kit.clearSecret("accessToken");
 
-  await kit.test("Send Notification Email", async () => {
-    const tracking = kit.getStore("trackingNumber");
-    kit.done(`Email sent with tracking: ${tracking}`);
-  });
-});
+// Clear everything
+kit.clearStore();
+kit.clearSecret();
 ```
 
-Run it:
+---
+
+## ⏰ TTL Support (Time-To-Live)
 
-```bash
-npx fenneckit order-pipeline.labs.js
+```typescript
+// Auto-expire after 10 seconds
+kit.setStoreWithTTL("sessionId", "sess_abc", 10_000);
+kit.setSecretWithTTL("tempKey", "value", 30_000);
 ```
 
 ---
 
-## 🛠️ LabContext Methods
+## 🛠️ LabContext Methods (v1.2.0)
 
 ```typescript
 interface LabContext {
@@ -374,184 +352,136 @@ interface LabContext {
   err(msg: string): void          // stops the Lab
   flatErr(msg: string): void      // continues
   log(msg: string): void
-  warning(msg: string): void      // warning
+  warning(msg: string): void
 
   // Flow control
   out(): void                     // exit Lab immediately
-  ret(): void                     // restart Lab
+  ret(): void                     // restart Lab (max 3 times)
 
-  // Persistent (across Labs in same file)
+  // Persistent STORE
   setStore(key: string, value: any): void
   getStore(key: string): any
-  clearStore(key?: string): void  // NEW: clear specific key or all
+  clearStore(key?: string): void
+  setStoreWithTTL(key: string, value: any, ttlMs: number): void
+
+  // Encrypted Secrets (AES-256-GCM)
+  setSecret(key: string, value: string): void
+  getSecret(key: string): string | undefined
+  clearSecret(key?: string): void
+  setSecretWithTTL(key: string, value: string, ttlMs: number): void
+
+  // Namespaces
+  namespace(name: string): NamespacedStore
+  getNamespace(name: string): NamespacedStore | undefined
 
   // Temporary (Lab-local only)
   setTemp(key: string, value: any): void
   getTemp(key: string): any
+
+  // HTTP Kit
+  http: HttpKit
+
+  // Audit Log
+  audit: AuditLog
 }
 ```
 
 ---
 
-## 🚀 Quick Start
-
-### 1. Create a lab file
-
-```bash
-# example.labs.js
-```
+## 💡 Real-World Example (v1.2.0)
 
 ```typescript
 import { newLabs } from "fenneckit";
 
-await newLabs("User Registration Workflow", async (kit) => {
-  kit.log("Starting user registration...");
+await newLabs("E-Commerce API Test", async (kit) => {
+  const user  = kit.namespace("user");
+  const order = kit.namespace("order");
 
-  await kit.test("Create User", async () => {
-    const id = "user_" + Date.now();
-    kit.setStore("userId", id);
-    kit.done(`User created: ${id}`);
-  });
+  await kit.test("Register User", async () => {
+    const res = await kit.http.post("https://api.shop.com/auth/register", {
+      email: "test@example.com",
+      password: "secure123"
+    });
 
-  await kit.test("Send Welcome Email", async () => {
-    const id = kit.getStore("userId");
-    kit.done(`Email sent to user: ${id}`);
+    user.set("id", res.data.id);
+    kit.setSecret("token", res.data.token);          // encrypted
+    kit.http.setAuth("bearer", res.data.token);
+
+    kit.done("User registered");
   });
-});
-```
 
-### 2. Run
+  await kit.test("Create Order", async () => {
+    const res = await kit.http.post("https://api.shop.com/orders", {
+      items: [{ id: "prod_1", qty: 2 }]
+    });
 
-```bash
-npx fenneckit example.labs.js
-```
+    order.set("id", res.data.orderId);
+    order.set("total", res.data.total);
+    kit.done(`Order created: ${res.data.orderId}`);
+  });
 
-### 3. Check report
+  await kit.test("Security Cleanup", async () => {
+    kit.clearSecret("token");                        // remove sensitive data
+    kit.done("Secrets cleared");
+  });
 
-```bash
-cat fenneckit.md
+  await kit.test("Audit Check", async () => {
+    const log = kit.audit.getLast(10);
+    kit.log(`Audit entries: ${log.length}`);
+  });
+});
 ```
 
 ---
 
-## 📋 setStore vs setTemp vs clearStore
+## 📊 Storage Lifecycle (per file)
 
-| Scenario | Use | Why |
-|----------|-----|-----|
-| Pass data between Labs | `setStore` | Survives Lab end |
-| Performance timing | `setTemp` | Only needed inside one Lab |
-| Auth token / DB connection | `setStore` | Needed by multiple Labs |
-| Temporary calculation | `setTemp` | Auto-cleaned |
-| Remove sensitive data | `clearStore` | Security |
-| Reset before next phase | `clearStore` | Fresh state |
-| Cross-file sharing | ❌ Impossible | STORE is scoped to one file only |
+```
+FILE EXECUTION START
+│
+├─ Lab 1
+│  ├─ setStore / setSecret / namespace.set → kept across Labs
+│  ├─ setTemp → kept only for this Lab
+│  ├─ clearStore / clearSecret → optional cleanup
+│  └─ Lab ends → TEMP cleared, everything else remains
+│
+├─ Lab 2
+│  ├─ getStore / getSecret / namespace.get → works
+│  └─ Lab ends → TEMP cleared
+│
+└─ FILE END → STORE + Secrets + Namespaces completely cleared
+```
 
 ---
 
-## 🎯 Best Practices
+## 🎯 Best Practices (v1.2.0)
 
-1. **Clear names**
+1. **Secrets always go into the Vault**
    ```typescript
-   kit.setStore("userId", id);
-   kit.setStore("authToken", token);
+   kit.setSecret("token", token);   // ✅
+   kit.setStore("token", token);    // ❌ avoid
    ```
 
-2. **Always check before use**
+2. **Use namespaces for related data**
    ```typescript
-   const userId = kit.getStore("userId");
-   if (!userId) {
-     kit.err("userId missing from previous Lab!");
-   }
+   const user = kit.namespace("user");
+   user.set("id", id);
+   user.set("email", email);
    ```
 
-3. **Clear sensitive data**
+3. **Clear sensitive data when no longer needed**
    ```typescript
-   kit.clearStore("password");
+   kit.clearSecret("accessToken");
    kit.clearStore("creditCard");
    ```
 
-4. **One concern per Lab**  
-   Keep each Lab focused. Use STORE to pass only the necessary data.
-
-5. **Do not rely on cross-file data**  
-   If you need data from another file, write it to disk or a database yourself.
-
----
-
-## 🔄 Complete Multi-Lab Example (Payment → Invoice)
-
-```typescript
-import { newLabs, clearStore } from "fenneckit";
-
-await newLabs("Payment Validation", async (kit) => {
-  await kit.test("Validate Payment Details", async () => {
-    kit.setStore("customerId", "cust_123");
-    kit.setStore("amount", 299.99);
-    kit.setStore("currency", "USD");
-    kit.setTemp("validatedAt", Date.now());
-    kit.done("Payment validated: 299.99 USD");
-  });
-});
-
-await newLabs("Process Charge", async (kit) => {
-  await kit.test("Charge Card", async () => {
-    const amount = kit.getStore("amount");
-    const chargeId = `charge_${Date.now()}`;
-    kit.setStore("chargeId", chargeId);
-    kit.setStore("chargedAt", new Date().toISOString());
-    kit.done(`Charged: ${chargeId} for ${amount}`);
-  });
-});
-
-// Clear payment details (security)
-clearStore("chargeId");
-
-await newLabs("Generate Invoice", async (kit) => {
-  await kit.test("Create Invoice PDF", async () => {
-    const invoiceId = `inv_${Date.now()}`;
-    kit.setStore("invoiceId", invoiceId);
-    kit.done(`Invoice created: ${invoiceId}`);
-  });
-
-  await kit.test("Send Invoice Email", async () => {
-    const invoiceId = kit.getStore("invoiceId");
-    const customerId = kit.getStore("customerId");
-    kit.done(`Invoice ${invoiceId} emailed to ${customerId}`);
-  });
-});
-```
-
-Run:
-
-```bash
-npx fenneckit payment-pipeline.labs.js
-```
-
----
-
-## 📞 Troubleshooting
-
-**Q: Lab 2 cannot see Lab 1 data?**  
-A: You used `setTemp`. Switch to `setStore`.
-
-**Q: I cleared data but it's still there?**  
-A: Make sure you're using `clearStore()` correctly. Check key name.
-
-**Q: Can STORE survive across different files?**  
-A: No. Each file execution has its own isolated STORE.  
-`npx fenneckit a.labs.js` and `npx fenneckit b.labs.js` do not share data.
-
-**Q: How is TEMP cleaned?**  
-A: Automatically when the Lab finishes. No manual cleanup needed.
+4. **Check before use**
+   ```typescript
+   const token = kit.getSecret("token");
+   if (!token) kit.err("Token missing!");
+   ```
 
-**Q: How do I run multiple files?**  
-A:  
-```bash
-npx fenneckit file1.labs.js
-npx fenneckit file2.labs.js
-# or let the runner discover all *.labs.* files
-npx fenneckit
-```
+5. **Never rely on cross-file sharing** – write to disk/DB if needed.
 
 ---
 
@@ -563,32 +493,40 @@ npx fenneckit
 - `⚠️` / `🟡` Warning  
 - `📝` / `⚪` Info  
 - `⚙️` Store operation  
+- `🔐` Secret operation  
 - `⏱️` Temp operation  
 - `🧹` Clear operation  
+- `⏰` TTL expiration  
 
 ---
 
 ## 💪 Perfect For
 
-- Backend API testing (Express, Fastify, etc.)
+- Backend API testing (Express, Fastify, NestJS, etc.)
+- Security-conscious test flows (tokens, keys)
 - Database migration validation
-- CLI tool workflows
 - Microservice chaining
 - Pre-deployment smoke checks
-- Development-time sanity tests
-- State management testing
+- State management + audit trails
 - Data pipeline validation
 
 ---
 
 ## 📝 Version History
 
-### v1.0.0-beta (Current)
+### v1.2.0 (Current)
+- 🔐 **Secret Vault** – AES-256-GCM encryption
+- 🗂️ **Namespaced Store**
+- 📋 **Audit Log** (JSON / CSV export)
+- 📡 **HTTP Kit** with auth, retry, history
+- ⏰ **TTL support** for STORE & Secrets
+- Improved LabContext API
+
+### v1.1.0
 - ✨ Added `clearStore()` for store management
 - 🌳 Improved data sharing hierarchy documentation
-- 🧹 Better state cleanup capabilities
 
-### v1.0.0 (Initial Release)
+### v1.0.0
 - Core Lab functionality
 - STORE & TEMP storage
 - Zero config runner
@@ -600,7 +538,7 @@ npx fenneckit
 
 **Copyright © 2026 Lasith Ruwantha Amrwansha**  
 Written: 2026/09/17  
-Updated: 2026/09/20  
+Updated: 2026/09/21  
 Author: Ruwantha Amrwansha  
 Library: FennecKit 🦊
 

package/index.js

@@ -1,3 +1,3 @@
-import { newLabs, getStoreState, clearStore, } from "./libs/labs.js";
+import { newLabs } from "./libs/labs.js";
 import { testing } from "./libs/testing.js";
-export { newLabs, testing, getStoreState, clearStore };
+export { newLabs, testing };

package/libs/labs.js

@@ -1,38 +1,306 @@
 /*==================================
 * Copyright 2026 lasith ruwantha amrwansha
-* Written by 2026/09/17
+* Written by 2026/09/20
 * Author: ruwantha amrwansha
 * Library: FennecKit 🦊
-* Version: 1.1.0-beta (with clearStore feature)
 *===================================*/
-import { access, writeFile } from "fs/promises";
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync, } from "crypto";
+import report from "../utility/report.js";
 import path from "path";
-const d = new Date();
-const nowDate = d.toISOString().split('T')[0].replaceAll('-', '/');
-const Store = new Map();
-const headOfRepotPath = `
-# FennecKit 🦊 Report
-
-**🚀 Version:** 1.1.0-beta
-**⏰ Date:** ${nowDate}
-**✨ Features:** Zero Config • Sequential Labs • Inter-Lab Data Sharing • Store Management
-
----\n\n
-`;
-async function writeRepot(data) {
-    const repotPath = path.join(process.cwd(), "fenneckit.md");
-    try {
-        await access(repotPath);
-        await writeFile(repotPath, data, { flag: 'a' });
+class SecretVault {
+    vault = new Map();
+    masterKey;
+    cipher = "aes-256-gcm";
+    keyLength = 32;
+    ivLength = 16;
+    constructor(password = "fenneckit-default") {
+        this.masterKey = scryptSync(password, "salt", this.keyLength);
+    }
+    encrypt(data) {
+        const iv = randomBytes(this.ivLength);
+        const cipher = createCipheriv(this.cipher, this.masterKey, iv);
+        let encrypted = cipher.update(data, "utf8");
+        encrypted = Buffer.concat([encrypted, cipher.final()]);
+        const tag = cipher.getAuthTag();
+        return { encrypted, iv, tag };
+    }
+    decrypt(data, iv, tag) {
+        const decipher = createDecipheriv(this.cipher, this.masterKey, iv);
+        decipher.setAuthTag(tag);
+        let decrypted = decipher.update(data);
+        decrypted = Buffer.concat([decrypted, decipher.final()]);
+        return decrypted.toString("utf8");
+    }
+    set(key, value) {
+        const { encrypted, iv, tag } = this.encrypt(value);
+        const stored = Buffer.concat([iv, tag, encrypted]);
+        this.vault.set(key, stored);
+    }
+    get(key) {
+        const stored = this.vault.get(key);
+        if (!stored)
+            return undefined;
+        try {
+            const iv = stored.slice(0, this.ivLength);
+            const tag = stored.slice(this.ivLength, this.ivLength + 16);
+            const encrypted = stored.slice(this.ivLength + 16);
+            return this.decrypt(encrypted, iv, tag);
+        }
+        catch {
+            console.error(`Failed to decrypt secret: ${key}`);
+            return undefined;
+        }
+    }
+    delete(key) {
+        this.vault.delete(key);
+    }
+    clear() {
+        this.vault.clear();
+    }
+    keys() {
+        return Array.from(this.vault.keys());
+    }
+}
+class NamespacedStore {
+    data = new Map();
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+    set(key, value) {
+        this.data.set(key, value);
+    }
+    get(key) {
+        return this.data.get(key);
+    }
+    delete(key) {
+        this.data.delete(key);
+    }
+    clear(key) {
+        if (key) {
+            this.data.delete(key);
+        }
+        else {
+            this.data.clear();
+        }
+    }
+    keys() {
+        return Array.from(this.data.keys());
+    }
+    entries() {
+        return Array.from(this.data.entries());
+    }
+    has(key) {
+        return this.data.has(key);
+    }
+    toJSON() {
+        const obj = {};
+        for (const [key, value] of this.data) {
+            obj[key] = value;
+        }
+        return obj;
+    }
+}
+class AuditLog {
+    entries = [];
+    record(entry) {
+        this.entries.push(entry);
+    }
+    getLog() {
+        return [...this.entries];
+    }
+    getLast(n) {
+        return this.entries.slice(-n);
+    }
+    filterByKey(key) {
+        return this.entries.filter((e) => e.key === key);
+    }
+    filterByOperation(op) {
+        return this.entries.filter((e) => e.operation === op);
+    }
+    filterByNamespace(ns) {
+        return this.entries.filter((e) => e.namespace === ns);
+    }
+    export(format) {
+        if (format === "json") {
+            return JSON.stringify(this.entries, null, 2);
+        }
+        if (format === "csv") {
+            const headers = [
+                "timestamp",
+                "lab",
+                "test",
+                "operation",
+                "namespace",
+                "key",
+                "dataType",
+                "success",
+            ].join(",");
+            const rows = this.entries.map((e) => [
+                e.timestamp,
+                e.lab,
+                e.test,
+                e.operation,
+                e.namespace || "",
+                e.key,
+                e.dataType,
+                e.success ? "true" : "false",
+            ].join(","));
+            return [headers, ...rows].join("\n");
+        }
+        return "";
+    }
+    clear() {
+        this.entries = [];
+    }
+}
+class HttpKit {
+    authHeader = null;
+    requestHistory = [];
+    baseHeaders = {
+        "Content-Type": "application/json",
+        "User-Agent": "FennecKit/1.2.0",
+    };
+    setAuth(type, credentials) {
+        this.authHeader = { type, value: credentials };
     }
-    catch {
-        await writeFile(repotPath, headOfRepotPath + data);
+    clearAuth() {
+        this.authHeader = null;
+    }
+    getAuthHeader() {
+        if (!this.authHeader)
+            return {};
+        if (this.authHeader.type === "bearer") {
+            return { Authorization: `Bearer ${this.authHeader.value}` };
+        }
+        else if (this.authHeader.type === "api-key") {
+            return { "X-API-Key": this.authHeader.value };
+        }
+        else if (this.authHeader.type === "basic") {
+            return { Authorization: `Basic ${this.authHeader.value}` };
+        }
+        return {};
+    }
+    async makeRequest(method, url, body, options = {}) {
+        const startTime = Date.now();
+        const requestId = `req_\( {Date.now()}_ \){Math.random().toString(36).substr(2, 9)}`;
+        const headers = {
+            ...this.baseHeaders,
+            ...this.getAuthHeader(),
+            ...(options.headers || {}),
+        };
+        // Use AbortController for timeout (RequestInit does not support `timeout`)
+        const controller = new AbortController();
+        const timeoutMs = options.timeout ?? 30000;
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        const reqConfig = {
+            method,
+            headers,
+            signal: controller.signal,
+            redirect: options.followRedirects !== false ? "follow" : "manual",
+        };
+        if (body) {
+            reqConfig.body = typeof body === "string" ? body : JSON.stringify(body);
+        }
+        let lastError = null;
+        const maxRetries = options.retry?.max || 1;
+        const retryDelay = options.retry?.delay || 1000;
+        try {
+            for (let attempt = 0; attempt < maxRetries; attempt++) {
+                try {
+                    const response = await fetch(url, reqConfig);
+                    const duration = Date.now() - startTime;
+                    let data = null;
+                    const contentType = response.headers.get("content-type");
+                    if (contentType?.includes("application/json")) {
+                        data = await response.json();
+                    }
+                    else {
+                        data = await response.text();
+                    }
+                    const httpResponse = {
+                        status: response.status,
+                        statusText: response.statusText,
+                        headers: Object.fromEntries(response.headers.entries()),
+                        data,
+                        raw: response,
+                    };
+                    this.recordRequest({
+                        id: requestId,
+                        timestamp: new Date().toISOString(),
+                        method,
+                        url,
+                        status: response.status,
+                        duration,
+                        headers,
+                        requestBody: body,
+                        responseBody: data,
+                    });
+                    return httpResponse;
+                }
+                catch (error) {
+                    lastError = error;
+                    if (attempt < maxRetries - 1) {
+                        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+                    }
+                }
+            }
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+        const duration = Date.now() - startTime;
+        this.recordRequest({
+            id: requestId,
+            timestamp: new Date().toISOString(),
+            method,
+            url,
+            status: 0,
+            duration,
+            headers,
+            requestBody: body,
+            error: lastError?.message,
+        });
+        throw lastError || new Error(`HTTP request failed: ${method} ${url}`);
+    }
+    recordRequest(req) {
+        this.requestHistory.push(req);
+    }
+    async get(url, options) {
+        return this.makeRequest("GET", url, undefined, options);
+    }
+    async post(url, body, options) {
+        return this.makeRequest("POST", url, body, options);
+    }
+    async put(url, body, options) {
+        return this.makeRequest("PUT", url, body, options);
+    }
+    async patch(url, body, options) {
+        return this.makeRequest("PATCH", url, body, options);
+    }
+    async delete(url, options) {
+        return this.makeRequest("DELETE", url, undefined, options);
+    }
+    getRequestHistory() {
+        return [...this.requestHistory];
+    }
+    clearHistory() {
+        this.requestHistory = [];
+    }
+    getLastRequest() {
+        return this.requestHistory[this.requestHistory.length - 1];
     }
 }
 export async function newLabs(name, fn, retCount = 0) {
     let logs = `## ${name} 🌏\n\n\`\`\`\n`;
     let currentTest = "";
+    const Store = new Map();
+    const secretVault = new SecretVault();
+    const namespaces = new Map();
     const temp = new Map();
+    const http = new HttpKit();
+    const audit = new AuditLog();
+    const ttlMap = new Map();
     const Context = {
         out: () => {
             throw new Error("__Lab_Out__");
@@ -66,26 +334,91 @@ export async function newLabs(name, fn, retCount = 0) {
             logs += `[🟡] ${currentTest}: ${msg}\n`;
             console.log(`  ⚠️ [Warning] ${currentTest} -> ${msg}`);
         },
+        // Store
         setStore: (key, value) => {
             logs += `[⚙️] [STORE] set "${key}"\n`;
             Store.set(key, value);
+            audit.record({
+                timestamp: new Date().toISOString(),
+                lab: name,
+                test: currentTest,
+                operation: "set",
+                key,
+                dataType: typeof value,
+                success: true,
+            });
         },
         getStore: (key) => {
             logs += `[⚙️] [STORE] get "${key}"\n`;
+            audit.record({
+                timestamp: new Date().toISOString(),
+                lab: name,
+                test: currentTest,
+                operation: "get",
+                key,
+                dataType: "unknown",
+                success: true,
+            });
             return Store.get(key);
         },
         clearStore: (key) => {
             if (key) {
                 logs += `[⚙️] [STORE] cleared key "${key}"\n`;
-                console.log(`  🧹 [Store] Cleared: "${key}"`);
                 Store.delete(key);
             }
             else {
                 logs += `[⚙️] [STORE] cleared all data\n`;
-                console.log(`  🧹 [Store] Cleared all Store data`);
                 Store.clear();
             }
         },
+        // Secrets
+        setSecret: (key, value) => {
+            logs += `[🔐] [SECRET] set "${key}"\n`;
+            secretVault.set(key, value);
+            audit.record({
+                timestamp: new Date().toISOString(),
+                lab: name,
+                test: currentTest,
+                operation: "setSecret",
+                key,
+                dataType: "secret",
+                success: true,
+            });
+        },
+        getSecret: (key) => {
+            logs += `[🔐] [SECRET] get "${key}"\n`;
+            audit.record({
+                timestamp: new Date().toISOString(),
+                lab: name,
+                test: currentTest,
+                operation: "getSecret",
+                key,
+                dataType: "secret",
+                success: true,
+            });
+            return secretVault.get(key);
+        },
+        clearSecret: (key) => {
+            if (key) {
+                logs += `[🔐] [SECRET] cleared key "${key}"\n`;
+                secretVault.delete(key);
+            }
+            else {
+                logs += `[🔐] [SECRET] cleared all data\n`;
+                secretVault.clear();
+            }
+        },
+        // Namespaces
+        namespace: (ns) => {
+            if (!namespaces.has(ns)) {
+                namespaces.set(ns, new NamespacedStore(ns));
+            }
+            return namespaces.get(ns);
+        },
+        getNamespace: (ns) => {
+            return namespaces.get(ns);
+        },
+        // Temp
         setTemp: (key, value) => {
             logs += `[⏱️] [TEMP] set "${key}"\n`;
             temp.set(key, value);
@@ -94,6 +427,34 @@ export async function newLabs(name, fn, retCount = 0) {
             logs += `[⏱️] [TEMP] get "${key}"\n`;
             return temp.get(key);
         },
+        http,
+        audit,
+        // TTL
+        setStoreWithTTL: (key, value, ttlMs) => {
+            Context.setStore(key, value);
+            const existingTimer = ttlMap.get(key);
+            if (existingTimer)
+                clearTimeout(existingTimer);
+            const timer = setTimeout(() => {
+                Store.delete(key);
+                ttlMap.delete(key);
+                logs += `[⏰] [TTL] expired key "${key}"\n`;
+            }, ttlMs);
+            ttlMap.set(key, timer);
+        },
+        setSecretWithTTL: (key, value, ttlMs) => {
+            Context.setSecret(key, value);
+            const existingTimer = ttlMap.get(`secret:${key}`);
+            if (existingTimer)
+                clearTimeout(existingTimer);
+            const timer = setTimeout(() => {
+                secretVault.delete(key);
+                ttlMap.delete(`secret:${key}`);
+                logs += `[⏰] [TTL] expired secret "${key}"\n`;
+            }, ttlMs);
+            ttlMap.set(`secret:${key}`, timer);
+        },
+        // Testing
         test: async (testName, testFn) => {
             currentTest = testName;
             try {
@@ -103,7 +464,7 @@ export async function newLabs(name, fn, retCount = 0) {
                 console.log(`  🐛 [Bug Exception] in "${testName}":`, e.message || e);
                 throw e;
             }
-        }
+        },
     };
     console.log(`\n🔬 [Lab Initiated]: ${name}`);
     try {
@@ -113,36 +474,22 @@ export async function newLabs(name, fn, retCount = 0) {
         if (err.message === "__Lab_Out__") {
             logs += "```\n";
             temp.clear();
-            return await writeRepot(logs);
+            ttlMap.forEach((timer) => clearTimeout(timer));
+            // Write report here
+            return;
         }
         else if (err.message === "__Restart__") {
+            // Fixed: was newLabsV12
             return newLabs(name, fn, retCount + 1);
         }
         console.log(`❌ [Lab Failed]: ${name}\n`);
-        await writeRepot(logs + "```\n");
         temp.clear();
+        ttlMap.forEach((timer) => clearTimeout(timer));
         return;
     }
     logs += "```\n";
+    await report(logs);
     console.log(`✅ [Lab Success]: ${name} completed successfully.\n`);
     temp.clear();
-    await writeRepot(logs);
-}
-// Global Store hadels
-export function clearStore(key) {
-    if (key) {
-        Store.delete(key);
-        console.log(`🧹 [Global] Cleared store key: "${key}"`);
-    }
-    else {
-        Store.clear();
-        console.log(`🧹 [Global] Cleared all Store data`);
-    }
-}
-export function getStoreState() {
-    return new Map(Store);
+    ttlMap.forEach((timer) => clearTimeout(timer));
 }
-process.on('exit', () => {
-    console.log("[⛔] All Labs stopped");
-    Store.clear();
-});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fenneckit",
-  "version": "1.0.4",
+  "version": "1.2.0",
   "description": "A tiny, fast & adorable testing kit. Lightweight test framework with zero config – easy to hold, easy to run.",
   "keywords": [
     "testing",
@@ -34,11 +34,12 @@
     "build": "tsc",
     "test": "cd test && node ../dist/libs/fenneckit.js"
   },
-  "bin":{
-   "fenneckit": "./bin/fenneckit"
+  "bin": {
+    "fenneckit": "./bin/fenneckit"
   },
   "dependencies": {
     "chalk": "^6.0.0",
+    "crypto": "^1.0.1",
     "fs-extra": "^11.4.0",
     "path": "^0.12.7"
   },

package/utility/report.js

@@ -0,0 +1,26 @@
+import { access, writeFile } from "fs/promises";
+import path from "path";
+const d = new Date();
+const nowDate = d.toISOString().split('T')[0].replaceAll('-', '/');
+const Store = new Map();
+const headOfRepotPath = `
+# FennecKit 🦊 Report
+
+**🚀 Version:** 1.2.0
+
+**⏰ Date:** ${nowDate}
+
+**✨ Features:** Zero Config • Sequential Labs • Inter-Lab Data Sharing • Store Management
+
+---\n\n
+`;
+export default async function report(data) {
+    const repotPath = path.join(process.cwd(), "fenneckit.md");
+    try {
+        await access(repotPath);
+        await writeFile(repotPath, data, { flag: 'a' });
+    }
+    catch {
+        await writeFile(repotPath, headOfRepotPath + data);
+    }
+}