@mulanjs/mulanjs 1.0.1-dev.20260212143840

package/dist/core/quantum.js

@@ -0,0 +1,284 @@
+import { muState } from './hooks';
+/**
+ * Creates a quantum register of size n.
+ * State vector will have 2^n amplitudes.
+ */
+export function muRegister(n) {
+    const numStates = Math.pow(2, n);
+    const amplitudes = new Array(numStates).fill(0).map((_, i) => ({
+        re: i === 0 ? 1 : 0,
+        im: 0
+    }));
+    return muState({
+        value: {
+            size: n,
+            amplitudes
+        }
+    });
+}
+/**
+ * Backward compatible muQubit (Single Qubit Register)
+ */
+export function muQubit(initial = 0) {
+    const q = muRegister(1);
+    if (initial === 1) {
+        muGate(q, 'X', 0);
+    }
+    // Add compatibility properties for Phase 1 components
+    // These properties are getters that dynamically access the amplitudes array
+    Object.defineProperty(q.value, 'alpha', { get: () => q.value.amplitudes[0] });
+    Object.defineProperty(q.value, 'beta', { get: () => q.value.amplitudes[1] });
+    return q;
+}
+/**
+ * Internal helper to update register state while maintaining compatibility
+ */
+function updateState(reg, newState) {
+    if (newState.size === 1) {
+        // Re-inject compatibility getters for muQubit users
+        Object.defineProperty(newState, 'alpha', {
+            get: () => newState.amplitudes[0],
+            configurable: true,
+            enumerable: true
+        });
+        Object.defineProperty(newState, 'beta', {
+            get: () => newState.amplitudes[1],
+            configurable: true,
+            enumerable: true
+        });
+    }
+    reg.value = newState;
+}
+export function muGate(reg, type, target = 0, control) {
+    const state = reg.value;
+    const n = state.size;
+    const amplitudes = state.amplitudes;
+    const newAmps = amplitudes.map(a => (Object.assign({}, a)));
+    // Helper: Check if all control bits are 1
+    const checkControl = (index, ctrl) => {
+        if (ctrl === undefined)
+            return true;
+        if (typeof ctrl === 'number') {
+            return ((index >> ctrl) & 1) === 1;
+        }
+        return ctrl.every(c => ((index >> c) & 1) === 1);
+    };
+    // SWAP Gate (Unique case: affects 2 targets)
+    if (type === 'SWAP') {
+        const t1 = target;
+        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++) {
+            const bit1 = (i >> t1) & 1;
+            const bit2 = (i >> t2) & 1;
+            if (bit1 !== bit2) {
+                // Determine the swap partner index
+                // If i has (0,1), partner has (1,0) at those positions
+                const partner = i ^ (1 << t1) ^ (1 << t2);
+                if (i < partner) {
+                    const temp = newAmps[i];
+                    newAmps[i] = newAmps[partner];
+                    newAmps[partner] = temp;
+                }
+            }
+        }
+        updateState(reg, Object.assign(Object.assign({}, state), { amplitudes: newAmps }));
+        return;
+    }
+    // Standard Single-Qubit & Controlled Gates
+    if (type === 'H') {
+        const s = 1 / Math.sqrt(2);
+        const processed = new Set();
+        for (let i = 0; i < state.amplitudes.length; i++) {
+            if (processed.has(i))
+                continue;
+            // Check Controls first
+            if (!checkControl(i, control))
+                continue;
+            const targetBit = (i >> target) & 1;
+            const pairedIndex = targetBit ? (i & ~(1 << target)) : (i | (1 << target));
+            const a = state.amplitudes[i];
+            const b = state.amplitudes[pairedIndex];
+            if (targetBit === 0) {
+                newAmps[i] = { re: s * (a.re + b.re), im: s * (a.im + b.im) };
+                newAmps[pairedIndex] = { re: s * (a.re - b.re), im: s * (a.im - b.im) };
+            }
+            else {
+                newAmps[pairedIndex] = { re: s * (b.re + a.re), im: s * (b.im + a.im) };
+                newAmps[i] = { re: s * (b.re - a.re), im: s * (b.im - a.im) };
+            }
+            processed.add(i);
+            processed.add(pairedIndex);
+        }
+    }
+    else if (type === 'X' || type === 'CNOT') {
+        // CNOT is just Controlled-X
+        for (let i = 0; i < amplitudes.length; i++) {
+            if (!checkControl(i, control))
+                continue;
+            const targetBit = (i >> target) & 1;
+            const pairedIndex = targetBit ? (i & ~(1 << target)) : (i | (1 << target));
+            if (i < pairedIndex) {
+                const temp = newAmps[i];
+                newAmps[i] = newAmps[pairedIndex];
+                newAmps[pairedIndex] = temp;
+            }
+        }
+    }
+    else if (type === 'Z' || type === 'CZ') {
+        // Z and CZ are Phase Flips
+        for (let i = 0; i < amplitudes.length; i++) {
+            if (!checkControl(i, control))
+                continue;
+            const targetBit = (i >> target) & 1;
+            // Z Gate acts on |1>
+            if (targetBit === 1) {
+                newAmps[i] = { re: -amplitudes[i].re, im: -amplitudes[i].im };
+            }
+        }
+    }
+    else if (type === 'Y') {
+        // Y: |0> -> i|1>, |1> -> -i|0>
+        for (let i = 0; i < amplitudes.length; i++) {
+            if (!checkControl(i, control))
+                continue;
+            const targetBit = (i >> target) & 1;
+            const pairedIndex = targetBit ? (i & ~(1 << target)) : (i | (1 << target));
+            if (i < pairedIndex) {
+                // We process pairs (i, pairedIndex) where i has 0 at target, paired has 1
+                const a = newAmps[i]; // Coeff of |0>
+                const b = newAmps[pairedIndex]; // Coeff of |1>
+                // New |0> = -i * Old |1>
+                newAmps[i] = { re: b.im, im: -b.re };
+                // New |1> = i * Old |0>
+                newAmps[pairedIndex] = { re: -a.im, im: a.re };
+            }
+        }
+    }
+    updateState(reg, Object.assign(Object.assign({}, state), { amplitudes: newAmps }));
+}
+/**
+ * Mulan Search Logic (Grover's Operator)
+ * Automatically constructs a multi-controlled Phase Flip (Z) for a specific target state.
+ * This is the core of the "Quantum Switch" or "Quantum Search" capability.
+ * @param reg Quantum Register
+ * @param targetState The integer state to "search" and mark (e.g. 2 for |10>)
+ */
+export function muSearch(reg, targetState) {
+    const n = reg.value.size;
+    const controls = [];
+    // 1. Identify which bits are 0 and need wrapping with X gates
+    // Logic: To mark |010>, we want C-C-Z to trigger on 111.
+    // So we apply X to bits that are 0, then C-C-Z, then X again.
+    // We treat the last bit as the 'target' for the Z gate, rest as controls
+    const targetQubit = n - 1;
+    for (let i = 0; i < n; i++) {
+        const bit = (targetState >> i) & 1;
+        if (i === targetQubit) {
+            // If target bit logic requires 0, we flip it to 1 for the Z gate to work
+            if (bit === 0)
+                muGate(reg, 'X', i);
+        }
+        else {
+            controls.push(i);
+            if (bit === 0)
+                muGate(reg, 'X', i);
+        }
+    }
+    // 2. Apply Multi-Controlled Z
+    muGate(reg, 'Z', targetQubit, controls);
+    // 3. Uncompute (Restore 0s)
+    for (let i = 0; i < n; i++) {
+        const bit = (targetState >> i) & 1;
+        if (bit === 0)
+            muGate(reg, 'X', i);
+    }
+    // --- GROVER DIFFUSER (Amplification) ---
+    // This flips the probability amplitudes around the mean, boosting the target state.
+    // 1. Apply H to all
+    for (let i = 0; i < n; i++)
+        muGate(reg, 'H', i);
+    // 2. Apply X to all
+    for (let i = 0; i < n; i++)
+        muGate(reg, 'X', i);
+    // 3. Multi-Controlled Z (Reflection about |0...0>)
+    // We want to flip phase of |11...1> state after X transformation (which corresponds to |00...0> original)
+    // Target is last qubit, controls are 0 to n-2
+    const diffControls = [];
+    for (let i = 0; i < n - 1; i++)
+        diffControls.push(i);
+    muGate(reg, 'Z', n - 1, diffControls);
+    // 4. Uncompute X
+    for (let i = 0; i < n; i++)
+        muGate(reg, 'X', i);
+    // 5. Uncompute H
+    for (let i = 0; i < n; i++)
+        muGate(reg, 'H', i);
+}
+export function muEntangle(reg, i, j) {
+    muGate(reg, 'H', i);
+    muGate(reg, 'CNOT', j, i);
+}
+/**
+ * Quantum Teleportation Protocol
+ * Transfers the state of `msgIdx` to `targetIdx` using `ancillaIdx` as a resource.
+ * @param reg Register
+ * @param msgIdx The qubit containing the state to teleport (Alice)
+ * @param ancillaIdx The helper qubit (Alice's half of entanglement)
+ * @param targetIdx The destination qubit (Bob)
+ */
+export function muTeleport(reg, msgIdx, ancillaIdx, targetIdx) {
+    // 1. Create Bell Pair (Entanglement) between Ancilla and Target
+    // Represents the shared link between Alice and Bob
+    muEntangle(reg, ancillaIdx, targetIdx);
+    // 2. Bell Measurement on Message + Ancilla (Alice's side)
+    muGate(reg, 'CNOT', ancillaIdx, msgIdx); // Control: msg, Target: ancilla
+    muGate(reg, 'H', msgIdx);
+    // 3. Measure Alice's qubits (This collapses them)
+    const m1 = muMeasure(reg, msgIdx); // Measures "Z" component
+    const m2 = muMeasure(reg, ancillaIdx); // Measures "X" component
+    // 4. Classical Communication & Correction (Bob's side)
+    // Apply corrections to Target based on measurements
+    if (m2 === 1)
+        muGate(reg, 'X', targetIdx);
+    if (m1 === 1)
+        muGate(reg, 'Z', targetIdx);
+}
+/**
+ * Measures a specific qubit in the register, collapsing the superposition.
+ * @param reg Quantum Register
+ * @param target Index of qubit to measure
+ * @returns 0 or 1
+ */
+export function muMeasure(reg, target = 0) {
+    const state = reg.value;
+    const amplitudes = state.amplitudes;
+    let prob0 = 0;
+    // 1. Calculate Probability of |0>
+    for (let i = 0; i < amplitudes.length; i++) {
+        if (((i >> target) & 1) === 0) {
+            const a = amplitudes[i];
+            prob0 += (a.re * a.re) + (a.im * a.im);
+        }
+    }
+    // 2. Determine Outcome
+    const result = Math.random() < prob0 ? 0 : 1;
+    const resultProb = result === 0 ? prob0 : (1 - prob0);
+    const normFactor = resultProb > 0 ? (1 / Math.sqrt(resultProb)) : 0;
+    // 3. Collapse the State (Wavefunction Collapse)
+    const newAmps = amplitudes.map((a, i) => {
+        const bit = (i >> target) & 1;
+        if (bit !== result) {
+            return { re: 0, im: 0 };
+        }
+        else {
+            return { re: a.re * normFactor, im: a.im * normFactor };
+        }
+    });
+    // We need to call updateState to ensure reactivity if specialized getters exist
+    // But since this file has updateState internal, we can just call it.
+    // However, the internal updateState function needs to be in scope. 
+    // It is defined at line 60. So we are good.
+    updateState(reg, Object.assign(Object.assign({}, state), { amplitudes: newAmps }));
+    return result;
+}

package/dist/core/query.js

@@ -0,0 +1,63 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { reactive, effect } from './reactive';
+export function useQuery(queryFn, options = { enabled: true }) {
+    const state = reactive({
+        data: null,
+        isLoading: false,
+        error: null
+    });
+    const execute = () => __awaiter(this, void 0, void 0, function* () {
+        state.isLoading = true;
+        state.error = null;
+        try {
+            const result = yield queryFn();
+            state.data = result;
+        }
+        catch (err) {
+            state.error = err;
+        }
+        finally {
+            state.isLoading = false;
+        }
+    });
+    if (options.enabled) {
+        // Run automatically
+        effect(() => {
+            // Basic effect wrapper to allow reactivity if queryFn relies on signals
+            execute();
+        });
+    }
+    return Object.assign(Object.assign({}, state), { refetch: execute });
+}
+export function useMutation(mutationFn) {
+    const state = reactive({
+        data: null,
+        isLoading: false,
+        error: null
+    });
+    const mutate = (args) => __awaiter(this, void 0, void 0, function* () {
+        state.isLoading = true;
+        state.error = null;
+        try {
+            const result = yield mutationFn(args);
+            state.data = result;
+            return result;
+        }
+        catch (err) {
+            state.error = err;
+            throw err;
+        }
+        finally {
+            state.isLoading = false;
+        }
+    });
+    return Object.assign(Object.assign({}, state), { mutate });
+}

package/dist/core/reactive.js

@@ -0,0 +1,105 @@
+// MulanJS 2.0: Signal-Powered Reactivity Engine
+// "Compatible Surface, World-Class Engine"
+let activeEffect = null;
+const targetMap = new WeakMap();
+// --- Signal Core (The Engine) ---
+export class Signal {
+    constructor(initialValue) {
+        this._subscribers = new Set();
+        this._value = initialValue;
+    }
+    get value() {
+        if (activeEffect) {
+            this._subscribers.add(activeEffect);
+        }
+        return this._value;
+    }
+    set value(newValue) {
+        if (newValue !== this._value) {
+            this._value = newValue;
+            this.notify();
+        }
+    }
+    notify() {
+        this._subscribers.forEach(fn => fn());
+    }
+}
+// --- Compatibility Layer (The Surface) ---
+export function effect(fn) {
+    let stopped = false;
+    const run = () => {
+        if (stopped)
+            return;
+        const prev = activeEffect;
+        activeEffect = run;
+        try {
+            fn();
+        }
+        finally {
+            activeEffect = prev;
+        }
+    };
+    run();
+    return () => {
+        stopped = true;
+    };
+}
+function track(target, key) {
+    if (activeEffect) {
+        let depsMap = targetMap.get(target);
+        if (!depsMap) {
+            targetMap.set(target, (depsMap = new Map()));
+        }
+        let dep = depsMap.get(key);
+        if (!dep) {
+            depsMap.set(key, (dep = new Set()));
+        }
+        dep.add(activeEffect);
+    }
+}
+function trigger(target, key) {
+    const depsMap = targetMap.get(target);
+    if (!depsMap)
+        return;
+    const dep = depsMap.get(key);
+    if (dep) {
+        dep.forEach((fn) => fn());
+    }
+}
+/**
+ * Creates a reactive proxy object (Vue-compatible).
+ * Now optimized to respect Mulan Cycle.
+ */
+export function reactive(target) {
+    return new Proxy(target, {
+        get(obj, prop, receiver) {
+            // IRON FORTRESS: Prototype Pollution Protection (Read)
+            if (prop === '__proto__' || prop === 'constructor' || prop === 'prototype') {
+                return undefined;
+            }
+            track(obj, prop);
+            const val = Reflect.get(obj, prop, receiver);
+            if (val !== null && typeof val === 'object') {
+                return reactive(val);
+            }
+            return val;
+        },
+        set(obj, prop, value, receiver) {
+            // IRON FORTRESS: Prototype Pollution Protection
+            if (prop === '__proto__' || prop === 'constructor' || prop === 'prototype') {
+                console.warn(`[Iron Fortress] Blocked attempt to modify dangerous property: ${String(prop)}`);
+                return false;
+            }
+            const result = Reflect.set(obj, prop, value, receiver);
+            trigger(obj, prop);
+            return result;
+        },
+    });
+}
+/**
+ * Creates a standalone reactive reference.
+ * Backed by the Mulan Signal Engine.
+ */
+export function ref(value) {
+    return new Signal(value);
+}

package/dist/core/renderer.js

@@ -0,0 +1,70 @@
+export function render(template, container) {
+    // Focus Preservation (The "Mulan Glance" Technique)
+    let focusedId = null;
+    let selectionStart = null;
+    let selectionEnd = null;
+    let preservedValue = null;
+    if (document.activeElement && container.contains(document.activeElement)) {
+        const el = document.activeElement;
+        if (el.hasAttribute('data-mu-id')) {
+            focusedId = el.getAttribute('data-mu-id');
+            if (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) {
+                selectionStart = el.selectionStart;
+                selectionEnd = el.selectionEnd;
+                preservedValue = el.value;
+            }
+        }
+    }
+    container.innerHTML = template;
+    // Restore Focus and Value
+    if (focusedId) {
+        const el = container.querySelector(`[data-mu-id="${focusedId}"]`);
+        if (el) {
+            // Restore value first to ensure cursor positioning works correctly
+            if (preservedValue !== null && (el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement)) {
+                el.value = preservedValue;
+            }
+            el.focus();
+            if ((el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) && selectionStart !== null) {
+                try {
+                    el.setSelectionRange(selectionStart, selectionEnd);
+                }
+                catch (e) {
+                    // input types that don't support selection (e.g. number/email) might throw
+                }
+            }
+        }
+    }
+}
+export function hydrate(template, container) {
+    // In a string-based framework, hydration is often just "take over".
+    // For now, we'll verify if the server content matches (simple check)
+    // and then assume control. In a more advanced version, we'd attach listeners without re-rendering.
+    if (container.innerHTML.trim() !== template.trim()) {
+        console.warn('Hydration Mismatch: Server rendered content differs from Client.');
+        container.innerHTML = template; // Fallback to full render
+    }
+    else {
+        // console.log('Hydration Successful.');
+    }
+    // Future: Attach event listeners here if we had a mechanism for it.
+}
+export function renderToString(template) {
+    // SSR Function: returns the HTML string for the server to send.
+    // Can include additional sanitization or metadata injection here.
+    return template;
+}
+export function sanitize(str) {
+    // Check if we are in a browser environment
+    if (typeof document !== 'undefined') {
+        const temp = document.createElement('div');
+        temp.textContent = str;
+        return temp.innerHTML;
+    }
+    // Simple SSR fallback sanitizer (rudimentary)
+    return str.replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#039;");
+}

package/dist/core/vault.js

@@ -0,0 +1,81 @@
+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;
+    // 1. Load from Storage
+    const stored = storage.getItem(key);
+    let startVal = initialValue;
+    if (stored) {
+        try {
+            const raw = options.encrypt ? beastDecode(stored) : stored;
+            startVal = JSON.parse(raw);
+        }
+        catch (e) {
+            console.warn(`[Iron Fortress] Corrupt persistent data for key "${key}", resetting.`);
+        }
+    }
+    // 2. Create Reactive State (Follow muState pattern for consistency)
+    const isObject = typeof startVal === 'object' && startVal !== null;
+    const state = isObject ? reactive(startVal) : reactive({ value: startVal });
+    // 3. Auto-Save on Change
+    muEffect(() => {
+        try {
+            const payload = isObject ? state : state.value;
+            const raw = JSON.stringify(payload);
+            const toSave = options.encrypt ? beastXOR(raw) : raw;
+            storage.setItem(key, toSave);
+        }
+        catch (e) {
+            console.error(`[Iron Fortress] 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);
+                if (isObject) {
+                    Object.assign(state, newVal);
+                }
+                else {
+                    state.value = newVal;
+                }
+            }
+            catch (e) { }
+        }
+    };
+    window.addEventListener('storage', sync);
+    // Auto-cleanup if used inside a component
+    try {
+        const { onMuDestroy } = require('./hooks');
+        onMuDestroy(() => {
+            window.removeEventListener('storage', sync);
+        });
+    }
+    catch (e) {
+        // muVault might be used outside component setup in some advanced cases, 
+        // fallback to manual or no-cleanup if so.
+    }
+    return state;
+}

package/dist/index.js

@@ -0,0 +1,52 @@
+export * from './core/reactive';
+export { MuComponent, MuComponent as Component, defineComponent } from './core/component';
+export * from './core/renderer';
+export { MuRouter, MuRouter as Router } from './router/index';
+export { MuStore } from './store/index';
+export * from './security/sanitizer';
+export * from './core/hooks';
+export * from './core/query';
+export * from './core/vault';
+export * from './core/quantum';
+export * from './components/bloch-sphere';
+// Global Mulan Object for non-module usage
+import { reactive, effect } from './core/reactive';
+import { MuComponent, defineComponent } from './core/component';
+import { MuRouter } from './router/index';
+import { MuStore } from './store/index';
+import { Security } from './security/sanitizer';
+import * as Hooks from './core/hooks';
+import * as Query from './core/query';
+import * as Quantum from './core/quantum';
+const Mulan = Object.assign(Object.assign(Object.assign(Object.assign({ reactive,
+    effect, Component: MuComponent, defineComponent, Router: MuRouter, Store: MuStore, Security: Security }, Hooks), Query), Quantum), { 
+    // 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);
+    }, warn: (msg, ...args) => {
+        console.warn(`%c[MulanJS]%c ${msg}`, "color: #ffcc00; font-weight: bold; background: #222; padding: 2px 4px; border-radius: 3px;", "", ...args);
+    }, error: (msg, ...args) => {
+        console.error(`%c[MulanJS]%c ${msg}`, "color: #ff0000; font-weight: bold; background: #222; padding: 2px 4px; border-radius: 3px;", "", ...args);
+    } });
+// Security: Freeze the object to prevent runtime tampering
+Object.freeze(Mulan);
+Object.freeze(Mulan.Security);
+// MULAN INSIGHT: Initialize Global Registry
+if (typeof window !== 'undefined') {
+    window.__MULAN_INSIGHT__ = window.__MULAN_INSIGHT__ || { components: new Map() };
+    // MULAN INSIGHT: HMR Support
+    window.__MULAN_REFRESH__ = () => {
+        var _a;
+        const components = (_a = window.__MULAN_INSIGHT__) === null || _a === void 0 ? void 0 : _a.components;
+        if (components) {
+            components.forEach((comp) => {
+                if (comp && typeof comp.update === 'function') {
+                    // Force refresh
+                    comp.update();
+                }
+            });
+        }
+    };
+}
+window.Mulan = Mulan;
+export default Mulan;