@mulanjs/mulanjs 1.0.1-dev.20260219221500 → 1.0.1-dev.20260220121828

package/dist/core/quantum.js

@@ -1,4 +1,11 @@
 import { muState } from './hooks';
+/**
+ * Mulan Quantum (ASTR-Q+) Core
+ * Advanced Simulation Engine for multi-qubit registers and entanglement.
+ */
+// -- GLOBAL CONTEXT FOR QUANTUM CONTROL --
+// Defined at top to ensure visibility for muGate
+export let activeControls = [];
 /**
  * Creates a quantum register of size n.
  * State vector will have 2^n amplitudes.
@@ -54,14 +61,14 @@ export function muGate(reg, type, target = 0, control) {
     const n = state.size;
     const amplitudes = state.amplitudes;
     const newAmps = amplitudes.map(a => (Object.assign({}, a)));
+    // Prepare Effective Control (Explicit Arguments + Global Context)
+    const effectiveControl = [...(control === undefined ? [] : (Array.isArray(control) ? control : [control])), ...activeControls];
     // Helper: Check if all control bits are 1
     const checkControl = (index, ctrl) => {
-        if (ctrl === undefined)
+        if (ctrl === undefined || (Array.isArray(ctrl) && ctrl.length === 0))
             return true;
-        if (typeof ctrl === 'number') {
-            return ((index >> ctrl) & 1) === 1;
-        }
-        return ctrl.every(c => ((index >> c) & 1) === 1);
+        const ctrls = Array.isArray(ctrl) ? ctrl : [ctrl];
+        return ctrls.every(c => ((index >> c) & 1) === 1);
     };
     // SWAP Gate (Unique case: affects 2 targets)
     if (type === 'SWAP') {
@@ -69,6 +76,9 @@ export function muGate(reg, type, target = 0, control) {
         const t2 = control; // SWAP uses control arg as second target 
         // Iterate only half to avoid double swapping
         for (let i = 0; i < amplitudes.length; i++) {
+            // Check active controls for SWAP too
+            if (activeControls.length > 0 && !checkControl(i, activeControls))
+                continue;
             const bit1 = (i >> t1) & 1;
             const bit2 = (i >> t2) & 1;
             if (bit1 !== bit2) {
@@ -93,7 +103,7 @@ export function muGate(reg, type, target = 0, control) {
             if (processed.has(i))
                 continue;
             // Check Controls first
-            if (!checkControl(i, control))
+            if (!checkControl(i, effectiveControl))
                 continue;
             const targetBit = (i >> target) & 1;
             const pairedIndex = targetBit ? (i & ~(1 << target)) : (i | (1 << target));
@@ -114,7 +124,7 @@ export function muGate(reg, type, target = 0, control) {
     else if (type === 'X' || type === 'CNOT') {
         // CNOT is just Controlled-X
         for (let i = 0; i < amplitudes.length; i++) {
-            if (!checkControl(i, control))
+            if (!checkControl(i, effectiveControl))
                 continue;
             const targetBit = (i >> target) & 1;
             const pairedIndex = targetBit ? (i & ~(1 << target)) : (i | (1 << target));
@@ -128,7 +138,7 @@ export function muGate(reg, type, target = 0, control) {
     else if (type === 'Z' || type === 'CZ') {
         // Z and CZ are Phase Flips
         for (let i = 0; i < amplitudes.length; i++) {
-            if (!checkControl(i, control))
+            if (!checkControl(i, effectiveControl))
                 continue;
             const targetBit = (i >> target) & 1;
             // Z Gate acts on |1>
@@ -140,7 +150,7 @@ export function muGate(reg, type, target = 0, control) {
     else if (type === 'Y') {
         // Y: |0> -> i|1>, |1> -> -i|0>
         for (let i = 0; i < amplitudes.length; i++) {
-            if (!checkControl(i, control))
+            if (!checkControl(i, effectiveControl))
                 continue;
             const targetBit = (i >> target) & 1;
             const pairedIndex = targetBit ? (i & ~(1 << target)) : (i | (1 << target));
@@ -282,3 +292,58 @@ export function muMeasure(reg, target = 0) {
     updateState(reg, Object.assign(Object.assign({}, state), { amplitudes: newAmps }));
     return result;
 }
+/**
+ * Quantum Loop: Parallel Execution
+ * Applies a gate to multiple qubits "simultaneously" (in simulation steps).
+ * Ideal for initialization (Hadamard Transform) or global operations.
+ * @param reg Quantum Register
+ * @param qubits Array of qubit indices
+ * @param gate Gate type to apply (e.g. 'H', 'X')
+ */
+export function muParallel(reg, qubits, gate) {
+    if (gate === 'SWAP') {
+        throw new Error("SWAP cannot be applied in parallel (requires pairs).");
+    }
+    // In a real quantum computer, these happen at t=0.
+    // Here, we loop, but logical time is constant.
+    qubits.forEach(q => muGate(reg, gate, q));
+}
+/**
+ * Applies a block of operations controlled by specific qubits.
+ * Enables "Quantum If/Else".
+ */
+export function muControl(reg, controlQubit, inverse, block) {
+    // 1. Setup Context
+    if (inverse) {
+        muGate(reg, 'X', controlQubit); // Flip 0 to 1 to activate
+    }
+    activeControls.push(controlQubit);
+    try {
+        block();
+    }
+    finally {
+        activeControls.pop();
+        // Uncompute (Restore 0)
+        if (inverse) {
+            muGate(reg, 'X', controlQubit);
+        }
+    }
+}
+/**
+ * Quantum Switch: conditional Logic on Superposition
+ * Executes different logic branches based on the state of control qubits.
+ * Because the register can be in a superposition of states (e.g. |0> + |1>),
+ * MULTIPLE branches can execute effectively simultaneously on different subspaces.
+ *
+ * @param reg Quantum Register
+ * @param controlQubit The qubit controlling the switch (Single control for v1)
+ * @param cases Object mapping state (0 or 1) to a function executing quantum operations
+ */
+export function muSwitch(reg, controlQubit, cases) {
+    if (cases[0]) {
+        muControl(reg, controlQubit, true, cases[0]);
+    }
+    if (cases[1]) {
+        muControl(reg, controlQubit, false, cases[1]);
+    }
+}

package/dist/core/query.js

@@ -35,7 +35,12 @@ export function useQuery(queryFn, options = { enabled: true }) {
             execute();
         });
     }
-    return Object.assign(Object.assign({}, state), { refetch: execute });
+    return {
+        get data() { return state.data; },
+        get isLoading() { return state.isLoading; },
+        get error() { return state.error; },
+        refetch: execute
+    };
 }
 export function useMutation(mutationFn) {
     const state = reactive({
@@ -59,5 +64,10 @@ export function useMutation(mutationFn) {
             state.isLoading = false;
         }
     });
-    return Object.assign(Object.assign({}, state), { mutate });
+    return {
+        get data() { return state.data; },
+        get isLoading() { return state.isLoading; },
+        get error() { return state.error; },
+        mutate
+    };
 }

package/dist/core/surge.js

@@ -0,0 +1,92 @@
+/**
+ * muBurst - Adaptive Non-blocking Iterator
+ * Processes large arrays in batches within a frame budget (typically 8-16ms)
+ * to keep the UI responsive while executing at near-native loop speeds.
+ */
+export function muBurst(array, callback, options = {}) {
+    const { chunkSize = 1000, timeout = 8, onProgress } = options;
+    return new Promise((resolve) => {
+        let index = 0;
+        const total = array.length;
+        function process() {
+            const start = performance.now();
+            // Tight loop for high-speed processing
+            while (index < total && (performance.now() - start) < timeout) {
+                // Process in smaller bursts to allow more frequent time checks if needed
+                const endBurst = Math.min(index + chunkSize, total);
+                for (; index < endBurst; index++) {
+                    callback(array[index], index);
+                }
+            }
+            if (onProgress) {
+                onProgress((index / total) * 100);
+            }
+            if (index < total) {
+                requestAnimationFrame(process);
+            }
+            else {
+                resolve();
+            }
+        }
+        process();
+    });
+}
+/**
+ * muSurge - Truly Parallel Execution
+ * Distributes work across CPU cores using Web Workers.
+ * Logic must be serializable.
+ */
+export function muSurge(array, taskFn, onProgress) {
+    const n = navigator.hardwareConcurrency || 4;
+    const chunkSize = Math.ceil(array.length / n);
+    const results = new Array(array.length);
+    let completedChunks = 0;
+    let completedItems = 0;
+    // Convert function to string if it isn't already
+    const fnStr = typeof taskFn === 'function' ? taskFn.toString() : taskFn;
+    const workerCode = `
+        const taskFn = ${fnStr};
+        self.onmessage = function(e) {
+            const { chunk, startIndex } = e.data;
+            try {
+                const results = chunk.map(taskFn);
+                self.postMessage({ results, startIndex });
+            } catch (err) {
+                self.postMessage({ error: err.message, startIndex });
+            }
+        };
+    `;
+    const blob = new Blob([workerCode], { type: 'application/javascript' });
+    const workerUrl = URL.createObjectURL(blob);
+    return new Promise((resolve) => {
+        if (array.length === 0)
+            return resolve([]);
+        for (let i = 0; i < n; i++) {
+            const start = i * chunkSize;
+            const end = Math.min(start + chunkSize, array.length);
+            if (start >= end) {
+                completedChunks++;
+                continue;
+            }
+            const chunk = array.slice(start, end);
+            const worker = new Worker(workerUrl);
+            worker.onmessage = (e) => {
+                const { results: chunkResults, startIndex } = e.data;
+                // Merge results back into main array
+                for (let j = 0; j < chunkResults.length; j++) {
+                    results[startIndex + j] = chunkResults[j];
+                }
+                completedChunks++;
+                completedItems += chunkResults.length;
+                if (onProgress)
+                    onProgress((completedItems / array.length) * 100);
+                worker.terminate();
+                if (completedChunks === n) {
+                    URL.revokeObjectURL(workerUrl);
+                    resolve(results);
+                }
+            };
+            worker.postMessage({ chunk, startIndex: start, fnStr });
+        }
+    });
+}

package/dist/core/vault.js

@@ -1,24 +1,7 @@
 import { muEffect } from './hooks';
 import { reactive } from './reactive';
-const MULAN_SECRET = 'b3ast_mulan_s3cur1ty_k3y';
-function beastXOR(str) {
-    let result = '';
-    for (let i = 0; i < str.length; i++) {
-        result += String.fromCharCode(str.charCodeAt(i) ^ MULAN_SECRET.charCodeAt(i % MULAN_SECRET.length));
-    }
-    return btoa(result);
-}
-function beastDecode(encoded) {
-    const str = atob(encoded);
-    let result = '';
-    for (let i = 0; i < str.length; i++) {
-        result += String.fromCharCode(str.charCodeAt(i) ^ MULAN_SECRET.charCodeAt(i % MULAN_SECRET.length));
-    }
-    return result;
-}
 /**
  * Mulan Vault: The World's First Native Persistent State Primitive.
- * Now fortified with Iron Fortress Obfuscation.
  */
 export function persistent(key, initialValue, options = {}) {
     const storage = options.storage || window.localStorage;
@@ -27,11 +10,10 @@ export function persistent(key, initialValue, options = {}) {
     let startVal = initialValue;
     if (stored) {
         try {
-            const raw = options.encrypt ? beastDecode(stored) : stored;
-            startVal = JSON.parse(raw);
+            startVal = JSON.parse(stored);
         }
         catch (e) {
-            console.warn(`[Iron Fortress] Corrupt persistent data for key "${key}", resetting.`);
+            console.warn(`[Mulan Vault] Corrupt persistent data for key "${key}", resetting.`);
         }
     }
     // 2. Create Reactive State (Follow muState pattern for consistency)
@@ -41,20 +23,19 @@ export function persistent(key, initialValue, options = {}) {
     muEffect(() => {
         try {
             const payload = isObject ? state : state.value;
-            const raw = JSON.stringify(payload);
-            const toSave = options.encrypt ? beastXOR(raw) : raw;
+            const toSave = JSON.stringify(payload);
+            // Non-obfuscated persistence to satisfy security audits
             storage.setItem(key, toSave);
         }
         catch (e) {
-            console.error(`[Iron Fortress] Failed to save key "${key}"`);
+            console.error(`[Mulan Vault] Failed to save key "${key}"`);
         }
     });
     // 4. Sync across Tabs
     const sync = (e) => {
         if (e.key === key && e.newValue) {
             try {
-                const raw = options.encrypt ? beastDecode(e.newValue) : e.newValue;
-                const newVal = JSON.parse(raw);
+                const newVal = JSON.parse(e.newValue);
                 if (isObject) {
                     Object.assign(state, newVal);
                 }

package/dist/index.js

@@ -8,6 +8,7 @@ export * from './core/hooks';
 export * from './core/query';
 export * from './core/vault';
 export * from './core/quantum';
+export * from './core/surge';
 export * from './components/bloch-sphere';
 export * from './components/infinity-list';
 // Global Mulan Object for non-module usage
@@ -20,9 +21,10 @@ import * as Hooks from './core/hooks';
 import * as Query from './core/query';
 import { render } from './core/renderer';
 import * as Quantum from './core/quantum';
+import * as Surge from './core/surge';
 import * as InfinityList from './components/infinity-list';
-const Mulan = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ reactive,
-    effect, Component: MuComponent, defineComponent, Router: MuRouter, createRouter, Store: MuStore, Security: Security }, Hooks), Query), Quantum), InfinityList), { render, 
+const Mulan = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ reactive,
+    effect, Component: MuComponent, defineComponent, Router: MuRouter, createRouter, Store: MuStore, Security: Security }, Hooks), Query), Quantum), Surge), InfinityList), { render, 
     // MULAN INSIGHT: Branded Logging
     log: (msg, ...args) => {
         console.log(`%c[MulanJS]%c ${msg}`, "color: #ff3e00; font-weight: bold; background: #222; padding: 2px 4px; border-radius: 3px;", "", ...args);