@mulanjs/mulanjs 1.0.1-dev.20260212143840

package/dist/mulan.esm.js

@@ -0,0 +1,1948 @@
+/******/ var __webpack_modules__ = ({
+
+/***/ "./src/components/bloch-sphere.ts"
+/*!****************************************!*\
+  !*** ./src/components/bloch-sphere.ts ***!
+  \****************************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   MuBlochSphereElement: () => (/* binding */ MuBlochSphereElement)
+/* harmony export */ });
+/* harmony import */ var _core_reactive__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../core/reactive */ "./src/core/reactive.ts");
+
+class MuBlochSphereElement extends HTMLElement {
+    static get observedAttributes() {
+        return ['size'];
+    }
+    constructor() {
+        super();
+        this._arrow = null;
+        this._container = null;
+        this._disposeEffect = null;
+        this.attachShadow({ mode: 'open' });
+    }
+    connectedCallback() {
+        this.render();
+    }
+    disconnectedCallback() {
+        if (this._disposeEffect) {
+            this._disposeEffect();
+            this._disposeEffect = null;
+        }
+    }
+    // Property setter for 'qubit' (passed as .qubit="${q}" in Mulan)
+    set qubit(val) {
+        this._qubit = val;
+        this.initReactivity();
+    }
+    get qubit() {
+        return this._qubit;
+    }
+    attributeChangedCallback(name, oldValue, newValue) {
+        if (name === 'size' && this._container) {
+            this._container.style.width = newValue + 'px';
+            this._container.style.height = newValue + 'px';
+        }
+    }
+    initReactivity() {
+        if (this._disposeEffect)
+            this._disposeEffect();
+        if (!this._qubit)
+            return;
+        // MulanJS Effect: Run whenever the qubit state changes
+        this._disposeEffect = (0,_core_reactive__WEBPACK_IMPORTED_MODULE_0__.effect)(() => {
+            const state = this._qubit.value; // Access reactive proxy
+            if (!state || !state.amplitudes)
+                return;
+            // Assume Single Qubit for Visualizer (Index 0 if passed a register)
+            // If passed a register, we visualize the first qubit's logical projection (partial trace simplified)
+            // Or assume input IS a specific qubit projection?
+            // For simplified demo, we assume the register is size 1 OR we visualize Q0 of the register.
+            const amps = state.amplitudes;
+            // Support 1-qubit visualization from N-qubit register requires partial trace.
+            // For now, let's assume the user passes a 1-qubit register OR we visualize index 0.
+            // |psi> = a|0> + b|1>
+            // a = amps[0] (re, im)
+            // b = amps[1] (re, im)
+            // Dealing with multi-qubit registers (naive projection for visualization):
+            // We sum up probabilities for 0xxxx vs 1xxxx to get Z-axis.
+            // This is "marginal probability".
+            let p0 = 0;
+            let p1 = 0;
+            // Calculate Probabilities
+            for (let i = 0; i < amps.length; i++) {
+                const mag = amps[i].re * amps[i].re + amps[i].im * amps[i].im;
+                if ((i & 1) === 0)
+                    p0 += mag;
+                else
+                    p1 += mag;
+            }
+            // Theta from Z-projection
+            // P0 = cos^2(theta/2) -> theta = 2 * acos(sqrt(P0))
+            const theta = 2 * Math.acos(Math.min(1, Math.sqrt(p0)));
+            // Phi?
+            // Phase is relative phase between |0> and |1>.
+            // We can look at the phase of the '1' component relative to '0'.
+            // Simple approach: Look at amps[1] phase vs amps[0] phase.
+            // But with entanglement, pure state phase is tricky.
+            // Let's implement full density matrix if needed, but for now:
+            // naive: atan2(amps[1].im, amps[1].re) - atan2(amps[0].im, amps[0].re)
+            // We use the first pair (0 and 1) as proxy if multiple.
+            const a0 = amps[0];
+            const a1 = amps[1]; // Valid for N>=1
+            const phase0 = Math.atan2(a0.im, a0.re);
+            const phase1 = Math.atan2(a1.im, a1.re);
+            let phi = phase1 - phase0;
+            // Update Arrow
+            this.updateArrow(theta, phi);
+        });
+    }
+    updateArrow(theta, phi) {
+        if (!this._arrow)
+            return;
+        // Convert Quantum Coords (Theta, Phi) to CSS Transforms
+        // Theta 0 = Top (|0>)
+        // Theta PI = Bottom (|1>)
+        // Theta PI/2 = Equator
+        // CSS Rotate sequence:
+        // 1. Start pointing UP (Y or Z axis in CSS?)
+        // Let's say Arrow starts pointing UP (Y-).
+        // Rotate Z by Phi (Azimuth)
+        // Rotate X by Theta (Polar) - No, that's not standard Euler.
+        // Standard Physics:
+        // Z is Up (in Bloch), but CSS 3D Y is usually 'Down' or 'Up'.
+        // Let's Map:
+        // Bloch Z+ (|0>) -> CSS Y- (Top)
+        // Bloch Z- (|1>) -> CSS Y+ (Bottom)
+        // Bloch X+ (|+>) -> CSS Z+ (Front)
+        // Transform:
+        // rotateY(phi) ? No, phi rotates around Z-axis (Vertical).
+        // theta rotates from Z-axis down.
+        // CSS:
+        // rotateY(phi) -> Rotates around Vertical axis.
+        // rotateZ(theta) -> Rotates "down" from up?
+        // Let's simplify:
+        // transform: rotateY(${phi}rad) rotateZ(${theta}rad)
+        // Note: CSS rotations order matters.
+        const degTheta = theta * (180 / Math.PI);
+        const degPhi = phi * (180 / Math.PI);
+        // Adjustment for visual alignment
+        this._arrow.style.transform = `rotateY(${degPhi}deg) rotateZ(${degTheta}deg)`;
+        // Color based on state
+        const isSuperposition = Math.abs(theta - Math.PI / 2) < 0.1;
+        this._arrow.style.backgroundColor = isSuperposition ? '#00ffff' : '#ff00ff';
+    }
+    render() {
+        if (!this.shadowRoot)
+            return;
+        const size = this.getAttribute('size') || '200';
+        this.shadowRoot.innerHTML = `
+            <style>
+                :host {
+                    display: inline-block;
+                    perspective: 1000px;
+                }
+                .sphere-container {
+                    width: ${size}px;
+                    height: ${size}px;
+                    position: relative;
+                    transform-style: preserve-3d;
+                    margin: 0 auto;
+                }
+                .sphere {
+                    width: 100%;
+                    height: 100%;
+                    border-radius: 50%;
+                    border: 1px solid rgba(255, 255, 255, 0.2);
+                    position: absolute;
+                    background: radial-gradient(circle at 30% 30%, rgba(255, 255, 255, 0.1), rgba(0, 0, 0, 0.8));
+                    box-shadow: inset 0 0 20px rgba(255, 255, 255, 0.05);
+                    transform: rotateX(15deg) rotateY(15deg); /* Initial tilt for view */
+                }
+                /* Equator Ring */
+                .equator {
+                    position: absolute;
+                    top: 50%;
+                    left: 0;
+                    width: 100%;
+                    height: 100%;
+                    border: 1px dashed rgba(255, 255, 255, 0.3);
+                    border-radius: 50%;
+                    transform: rotateX(90deg);
+                    pointer-events: none;
+                }
+                /* Axis Lines */
+                .axis {
+                    position: absolute;
+                    background: rgba(255, 255, 255, 0.1);
+                }
+                .z-axis { width: 2px; height: 100%; left: 50%; top: 0; }
+                
+                /* The Quantum Arrow */
+                .arrow-container {
+                    position: absolute;
+                    top: 50%;
+                    left: 50%;
+                    width: 0;
+                    height: 0;
+                    transform-style: preserve-3d;
+                    transform: rotateX(15deg) rotateY(15deg); /* Match sphere tilt */
+                }
+                
+                .arrow-pivot {
+                    position: absolute;
+                    top: 0;
+                    left: 0;
+                    width: 4px;
+                    height: 50%; /* Length of radius */
+                    /* Pivot logic: we want to rotate around the center point */
+                    /* CSS Default transform-origin is 50% 50% */
+                    /* We construct the arrow such that it points UP from center */
+                }
+                
+                .arrow-rod {
+                    width: 4px;
+                    height: ${parseInt(size) / 2 - 10}px;
+                    background: #ff00ff;
+                    position: absolute;
+                    bottom: 0;
+                    left: -2px;
+                    transform-origin: bottom center;
+                    transition: transform 0.5s cubic-bezier(0.175, 0.885, 0.32, 1.275), background-color 0.3s;
+                    border-radius: 2px;
+                    box-shadow: 0 0 10px currentColor;
+                }
+                
+                .arrow-head {
+                    width: 0; 
+                    height: 0; 
+                    border-left: 6px solid transparent;
+                    border-right: 6px solid transparent;
+                    border-bottom: 12px solid #ff00ff;
+                    position: absolute;
+                    top: -10px;
+                    left: -6px;
+                }
+                
+                .label {
+                    position: absolute;
+                    color: #aaa;
+                    font-family: monospace;
+                    font-size: 10px;
+                }
+                .label-0 { top: 5px; left: 50%; transform: translateX(-50%); }
+                .label-1 { bottom: 5px; left: 50%; transform: translateX(-50%); }
+            </style>
+            
+            <div class="sphere-container">
+                <div class="sphere">
+                    <div class="equator"></div>
+                    <div class="axis z-axis"></div>
+                    <div class="label label-0">|0></div>
+                    <div class="label label-1">|1></div>
+                </div>
+                
+                <div class="arrow-container">
+                    <!-- The rod is the actual rotating element -->
+                    <div class="arrow-rod">
+                        <div class="arrow-head"></div>
+                    </div>
+                </div>
+            </div>
+        `;
+        this._container = this.shadowRoot.querySelector('.sphere-container');
+        this._arrow = this.shadowRoot.querySelector('.arrow-rod');
+        // Re-init reactivity if qubit was set before render
+        if (this._qubit)
+            this.initReactivity();
+    }
+}
+// Register the custom element
+if (typeof customElements !== 'undefined') {
+    customElements.define('mu-bloch-sphere', MuBlochSphereElement);
+}
+
+
+/***/ },
+
+/***/ "./src/core/component.ts"
+/*!*******************************!*\
+  !*** ./src/core/component.ts ***!
+  \*******************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   MuComponent: () => (/* binding */ MuComponent),
+/* harmony export */   defineComponent: () => (/* binding */ defineComponent)
+/* harmony export */ });
+/* harmony import */ var _renderer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./renderer */ "./src/core/renderer.ts");
+/* harmony import */ var _hooks__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./hooks */ "./src/core/hooks.ts");
+/* harmony import */ var _reactive__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./reactive */ "./src/core/reactive.ts");
+
+
+
+// Or a simple component that returns an object of state/methods used by template? 
+// For Mulan 2.0, let's say functional component returns a template string render function explicitly.
+class MuComponent {
+    constructor(container) {
+        this._hooks = {};
+        this._effects = [];
+        this._isDestroyed = false;
+        this._propsQueue = [];
+        this._eventQueue = [];
+        this.container = container;
+        this.state = {};
+        this.$uid = 'mu_' + Math.random().toString(36).substr(2, 9);
+        // MULAN INSIGHT: Global Registry for Debugging
+        if (typeof window !== 'undefined') {
+            const global = window;
+            global.__MULAN_INSIGHT__ = global.__MULAN_INSIGHT__ || { components: new Map() };
+            global.__MULAN_INSIGHT__.components.set(this.$uid, this);
+        }
+        // Setup context for hooks
+        (0,_hooks__WEBPACK_IMPORTED_MODULE_1__.setCurrentInstance)(this);
+        this.setup();
+        (0,_hooks__WEBPACK_IMPORTED_MODULE_1__.setCurrentInstance)(null);
+    }
+    // Optional setup method for class components wanting to use hooks
+    setup() { }
+    onMount() {
+        var _a, _c;
+        // Mulan Cycle: Init
+        (_a = this._hooks.onMuInit) === null || _a === void 0 ? void 0 : _a.forEach(fn => fn());
+        // Mulan Cycle: Mount (Simulated immediately after init for now in this version)
+        (_c = this._hooks.onMuMount) === null || _c === void 0 ? void 0 : _c.forEach(fn => fn());
+    }
+    onUpdate() { }
+    onDestroy() {
+        var _a, _c;
+        if (this._isDestroyed)
+            return;
+        this._isDestroyed = true;
+        console.log(`[Mulan Cycle] Destroying component ${this.$uid} (${this.constructor.name})`);
+        // MULAN INSIGHT: Cleanup
+        if (typeof window !== 'undefined') {
+            const global = window;
+            (_a = global.__MULAN_INSIGHT__) === null || _a === void 0 ? void 0 : _a.components.delete(this.$uid);
+        }
+        // Mulan Cycle: Stop all effects to prevent leaks
+        console.log(`[Mulan Cycle] Stopping ${this._effects.length} effects for ${this.$uid}`);
+        this._effects.forEach(stop => stop());
+        this._effects = [];
+        // Mulan Cycle: Destroy hooks
+        (_c = this._hooks.onMuDestroy) === null || _c === void 0 ? void 0 : _c.forEach(fn => fn());
+    }
+    // Helper for compiler to register property bindings
+    _b(id, prop, value) {
+        this._propsQueue.push([id, prop, value]);
+        return "";
+    }
+    // Helper for compiler to register event bindings
+    _e(id, type, handler) {
+        this._eventQueue.push([id, type, handler]);
+        return "";
+    }
+    mount() {
+        console.log(`[Mulan Cycle] Mounting component ${this.$uid}`);
+        const stop = (0,_reactive__WEBPACK_IMPORTED_MODULE_2__.effect)(() => {
+            console.log(`[Mulan Reactivity] Triggering update for ${this.$uid}`);
+            this.update();
+        });
+        this._effects.push(stop);
+        this.onMount();
+    }
+    update() {
+        if (this._isDestroyed) {
+            console.warn(`[Mulan Warning] Update called on destroyed component ${this.$uid}. Blocking render.`);
+            return;
+        }
+        // Clear queues before render
+        this._propsQueue = [];
+        this._eventQueue = [];
+        const template = this.template();
+        // Render HTML
+        (0,_renderer__WEBPACK_IMPORTED_MODULE_0__.render)(template, this.container);
+        // Flush Side Effects
+        this.flushProps();
+        this.flushEvents();
+        this.onUpdate();
+    }
+    flushProps() {
+        for (const [id, prop, value] of this._propsQueue) {
+            const el = this.container.querySelector(`[data-mu-id="${id}"]`);
+            if (el) {
+                // @ts-ignore
+                el[prop] = value;
+            }
+        }
+        this._propsQueue = [];
+    }
+    flushEvents() {
+        for (const [id, type, handler] of this._eventQueue) {
+            const el = this.container.querySelector(`[data-mu-id="${id}"]`);
+            if (el) {
+                // Bind handler to this component instance to ensure 'this' works in methods
+                el.addEventListener(type, handler.bind(this));
+            }
+        }
+        this._eventQueue = [];
+    }
+}
+// Helper to create functional components wrapped in the class system
+// Helper to create functional components wrapped in the class system
+// Supports both () => render and { setup() } signatures
+function defineComponent(optionsOrSetup) {
+    return class UniversalComponent extends MuComponent {
+        constructor(container) {
+            super(container);
+            // setup() is called by super constructor
+        }
+        setup() {
+            let setupResult;
+            if (typeof optionsOrSetup === 'function') {
+                // It's a setup function returning render fn
+                setupResult = optionsOrSetup.call(this);
+            }
+            else if (typeof optionsOrSetup === 'object' && optionsOrSetup.setup) {
+                // It's an options object with setup()
+                setupResult = optionsOrSetup.setup.call(this);
+            }
+            // Handle result
+            if (typeof setupResult === 'function') {
+                // It's a render function
+                this.template = setupResult;
+            }
+            else if (setupResult && typeof setupResult === 'object') {
+                // It's bindings
+                Object.assign(this, setupResult);
+                // We assume template is assigned to prototype by compiler
+            }
+        }
+        template() {
+            return '';
+        }
+    };
+}
+
+
+/***/ },
+
+/***/ "./src/core/hooks.ts"
+/*!***************************!*\
+  !*** ./src/core/hooks.ts ***!
+  \***************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   getCurrentInstance: () => (/* binding */ getCurrentInstance),
+/* harmony export */   muEffect: () => (/* binding */ muEffect),
+/* harmony export */   muGeom: () => (/* binding */ muGeom),
+/* harmony export */   muMemo: () => (/* binding */ muMemo),
+/* harmony export */   muPulse: () => (/* binding */ muPulse),
+/* harmony export */   muState: () => (/* binding */ muState),
+/* harmony export */   muVault: () => (/* binding */ muVault),
+/* harmony export */   onMuDestroy: () => (/* binding */ onMuDestroy),
+/* harmony export */   onMuIdle: () => (/* binding */ onMuIdle),
+/* harmony export */   onMuInit: () => (/* binding */ onMuInit),
+/* harmony export */   onMuMount: () => (/* binding */ onMuMount),
+/* harmony export */   onMuResume: () => (/* binding */ onMuResume),
+/* harmony export */   onMuShake: () => (/* binding */ onMuShake),
+/* harmony export */   onMuVoice: () => (/* binding */ onMuVoice),
+/* harmony export */   setCurrentInstance: () => (/* binding */ setCurrentInstance)
+/* harmony export */ });
+/* harmony import */ var _reactive__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./reactive */ "./src/core/reactive.ts");
+/* harmony import */ var _vault__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./vault */ "./src/core/vault.ts");
+
+
+// Global context to track the current component instance
+let currentInstance = null;
+function setCurrentInstance(instance) {
+    currentInstance = instance;
+}
+function getCurrentInstance() {
+    return currentInstance;
+}
+// --- Mulan Unique Reactivity Hooks ---
+function muState(initialValue) {
+    if (typeof initialValue === 'object' && initialValue !== null) {
+        return (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.reactive)(initialValue);
+    }
+    // Core reactive state container for primitives
+    return (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.reactive)({ value: initialValue });
+}
+function muMemo(computeFn) {
+    const signal = (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.reactive)({ value: undefined });
+    const stop = (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.effect)(() => {
+        signal.value = computeFn();
+    });
+    const instance = getCurrentInstance();
+    if (instance) {
+        if (!instance._effects)
+            instance._effects = [];
+        instance._effects.push(stop);
+    }
+    return signal;
+}
+function muEffect(fn) {
+    const stop = (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.effect)(fn);
+    const instance = getCurrentInstance();
+    if (instance) {
+        if (!instance._effects)
+            instance._effects = [];
+        instance._effects.push(stop);
+    }
+}
+// --- The "Mulan Cycle" (Lifecycle) ---
+function onMuInit(fn) {
+    const instance = getCurrentInstance();
+    if (instance) {
+        if (!instance._hooks)
+            instance._hooks = {};
+        if (!instance._hooks.onMuInit)
+            instance._hooks.onMuInit = [];
+        instance._hooks.onMuInit.push(fn);
+    }
+    else {
+        console.warn('onMuInit called outside of component setup context.');
+    }
+}
+function onMuMount(fn) {
+    // New hook for when component is actually in DOM (simulated for now via update)
+    const instance = getCurrentInstance();
+    if (instance) {
+        if (!instance._hooks)
+            instance._hooks = {};
+        if (!instance._hooks.onMuMount)
+            instance._hooks.onMuMount = [];
+        instance._hooks.onMuMount.push(fn);
+    }
+}
+function onMuDestroy(fn) {
+    const instance = getCurrentInstance();
+    if (instance) {
+        if (!instance._hooks)
+            instance._hooks = {};
+        if (!instance._hooks.onMuDestroy)
+            instance._hooks.onMuDestroy = [];
+        instance._hooks.onMuDestroy.push(fn);
+    }
+}
+/**
+ * onMuIdle - The "Environment Life" Hook.
+ * Executes heavy logic ONLY when the browser is taking a nap (idle).
+ */
+function onMuIdle(fn) {
+    const instance = getCurrentInstance();
+    // Polyfill for Safari/Old Browsers
+    const requestIdleCallback = window.requestIdleCallback || function (cb) {
+        return setTimeout(() => {
+            cb({
+                didTimeout: false,
+                timeRemaining: function () { return 50; }
+            });
+        }, 1);
+    };
+    const cancelIdleCallback = window.cancelIdleCallback || function (id) {
+        clearTimeout(id);
+    };
+    const idleId = requestIdleCallback(() => {
+        fn();
+    });
+    // Auto-cleanup if component dies before idle time
+    if (instance) {
+        onMuDestroy(() => {
+            cancelIdleCallback(idleId);
+        });
+    }
+}
+/**
+ * onMuResume - The "Tab Life" Hook.
+ * Executes when the user switches BACK to this tab.
+ * Perfect for refreshing data or resuming animations to save battery.
+ */
+function onMuResume(fn) {
+    const handler = () => {
+        if (document.visibilityState === 'visible') {
+            fn();
+        }
+    };
+    document.addEventListener('visibilitychange', handler);
+    onMuDestroy(() => document.removeEventListener('visibilitychange', handler));
+}
+/**
+ * onMuShake - The "Physical Life" Hook.
+ * Executes when the device is shaken.
+ * Usage: Undo, Refresh, or "Rage Quit" easter eggs.
+ */
+function onMuShake(fn) {
+    // Threshold for shake detection
+    const threshold = 15;
+    let lastX = 0, lastY = 0, lastZ = 0;
+    let lastTime = 0;
+    const handler = (e) => {
+        const current = e.accelerationIncludingGravity;
+        if (!current)
+            return;
+        const time = Date.now();
+        if ((time - lastTime) > 100) {
+            const diffTime = time - lastTime;
+            lastTime = time;
+            const x = current.x || 0;
+            const y = current.y || 0;
+            const z = current.z || 0;
+            const speed = Math.abs(x + y + z - lastX - lastY - lastZ) / diffTime * 10000;
+            if (speed > threshold) {
+                fn();
+            }
+            lastX = x;
+            lastY = y;
+            lastZ = z;
+        }
+    };
+    if (window.DeviceMotionEvent) {
+        window.addEventListener('devicemotion', handler);
+        onMuDestroy(() => window.removeEventListener('devicemotion', handler));
+    }
+    else {
+        console.warn("[MulanJS] Device Motion not supported on this device.");
+    }
+}
+/**
+ * onMuVoice - The "Sound Life" Hook.
+ * Executes when a specific word is spoken.
+ * @param command The word to listen for (e.g., "save", "next")
+ * @param fn The action to take
+ */
+function onMuVoice(command, fn) {
+    const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
+    if (!SpeechRecognition) {
+        console.warn("[MulanJS] Voice Control (Web Speech API) not supported in this browser.");
+        return;
+    }
+    const recognition = new SpeechRecognition();
+    recognition.continuous = true;
+    recognition.lang = 'en-US';
+    recognition.interimResults = false;
+    recognition.onresult = (event) => {
+        const last = event.results.length - 1;
+        const spoken = event.results[last][0].transcript.trim().toLowerCase();
+        console.log(`[Mulan Voice] Heard: "${spoken}"`);
+        if (spoken.includes(command.toLowerCase())) {
+            fn();
+        }
+    };
+    recognition.start();
+    // Auto-restart if it stops (Continuous listening)
+    recognition.onend = () => {
+        // Simple check to see if we should still be listening
+        // In a real app we might want more control
+        // recognition.start(); 
+    };
+    onMuDestroy(() => {
+        recognition.stop();
+    });
+}
+// --- "Outside The Box" Hooks (Mulan Exclusives) ---
+/**
+ * muGeom - Tracks window or element dimensions reactively.
+ */
+function muGeom() {
+    const dims = muState({ width: window.innerWidth, height: window.innerHeight });
+    const handler = () => {
+        dims.width = window.innerWidth;
+        dims.height = window.innerHeight;
+    };
+    window.addEventListener('resize', handler);
+    // Auto-cleanup
+    onMuDestroy(() => {
+        window.removeEventListener('resize', handler);
+    });
+    return dims;
+}
+/**
+ * muPulse - Reactive network status.
+ */
+function muPulse() {
+    const status = muState({ online: navigator.onLine });
+    const setOnline = () => status.online = true;
+    const setOffline = () => status.online = false;
+    window.addEventListener('online', setOnline);
+    window.addEventListener('offline', setOffline);
+    onMuDestroy(() => {
+        window.removeEventListener('online', setOnline);
+        window.removeEventListener('offline', setOffline);
+    });
+    return status;
+}
+/**
+ * muVault - Secure reactive LocalStorage wrapper.
+ * Powered by the Iron Fortress persistent primitive.
+ */
+function muVault(key, initial, options = {}) {
+    return (0,_vault__WEBPACK_IMPORTED_MODULE_1__.persistent)(key, initial, options);
+}
+
+
+/***/ },
+
+/***/ "./src/core/quantum.ts"
+/*!*****************************!*\
+  !*** ./src/core/quantum.ts ***!
+  \*****************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   muEntangle: () => (/* binding */ muEntangle),
+/* harmony export */   muGate: () => (/* binding */ muGate),
+/* harmony export */   muMeasure: () => (/* binding */ muMeasure),
+/* harmony export */   muQubit: () => (/* binding */ muQubit),
+/* harmony export */   muRegister: () => (/* binding */ muRegister),
+/* harmony export */   muSearch: () => (/* binding */ muSearch),
+/* harmony export */   muTeleport: () => (/* binding */ muTeleport)
+/* harmony export */ });
+/* harmony import */ var _hooks__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./hooks */ "./src/core/hooks.ts");
+
+/**
+ * Creates a quantum register of size n.
+ * State vector will have 2^n amplitudes.
+ */
+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 (0,_hooks__WEBPACK_IMPORTED_MODULE_0__.muState)({
+        value: {
+            size: n,
+            amplitudes
+        }
+    });
+}
+/**
+ * Backward compatible muQubit (Single Qubit Register)
+ */
+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;
+}
+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>)
+ */
+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);
+}
+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)
+ */
+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
+ */
+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;
+}
+
+
+/***/ },
+
+/***/ "./src/core/query.ts"
+/*!***************************!*\
+  !*** ./src/core/query.ts ***!
+  \***************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   useMutation: () => (/* binding */ useMutation),
+/* harmony export */   useQuery: () => (/* binding */ useQuery)
+/* harmony export */ });
+/* harmony import */ var _reactive__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./reactive */ "./src/core/reactive.ts");
+var __awaiter = (undefined && undefined.__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());
+    });
+};
+
+function useQuery(queryFn, options = { enabled: true }) {
+    const state = (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.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
+        (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.effect)(() => {
+            // Basic effect wrapper to allow reactivity if queryFn relies on signals
+            execute();
+        });
+    }
+    return Object.assign(Object.assign({}, state), { refetch: execute });
+}
+function useMutation(mutationFn) {
+    const state = (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.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 });
+}
+
+
+/***/ },
+
+/***/ "./src/core/reactive.ts"
+/*!******************************!*\
+  !*** ./src/core/reactive.ts ***!
+  \******************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Signal: () => (/* binding */ Signal),
+/* harmony export */   effect: () => (/* binding */ effect),
+/* harmony export */   reactive: () => (/* binding */ reactive),
+/* harmony export */   ref: () => (/* binding */ ref)
+/* harmony export */ });
+// MulanJS 2.0: Signal-Powered Reactivity Engine
+// "Compatible Surface, World-Class Engine"
+let activeEffect = null;
+const targetMap = new WeakMap();
+// --- Signal Core (The Engine) ---
+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) ---
+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.
+ */
+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.
+ */
+function ref(value) {
+    return new Signal(value);
+}
+
+
+/***/ },
+
+/***/ "./src/core/renderer.ts"
+/*!******************************!*\
+  !*** ./src/core/renderer.ts ***!
+  \******************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   hydrate: () => (/* binding */ hydrate),
+/* harmony export */   render: () => (/* binding */ render),
+/* harmony export */   renderToString: () => (/* binding */ renderToString),
+/* harmony export */   sanitize: () => (/* binding */ sanitize)
+/* harmony 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
+                }
+            }
+        }
+    }
+}
+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.
+}
+function renderToString(template) {
+    // SSR Function: returns the HTML string for the server to send.
+    // Can include additional sanitization or metadata injection here.
+    return template;
+}
+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, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#039;");
+}
+
+
+/***/ },
+
+/***/ "./src/core/vault.ts"
+/*!***************************!*\
+  !*** ./src/core/vault.ts ***!
+  \***************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   persistent: () => (/* binding */ persistent)
+/* harmony export */ });
+/* harmony import */ var _hooks__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./hooks */ "./src/core/hooks.ts");
+/* harmony import */ var _reactive__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./reactive */ "./src/core/reactive.ts");
+
+
+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.
+ */
+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 ? (0,_reactive__WEBPACK_IMPORTED_MODULE_1__.reactive)(startVal) : (0,_reactive__WEBPACK_IMPORTED_MODULE_1__.reactive)({ value: startVal });
+    // 3. Auto-Save on Change
+    (0,_hooks__WEBPACK_IMPORTED_MODULE_0__.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 } = __webpack_require__(/*! ./hooks */ "./src/core/hooks.ts");
+        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;
+}
+
+
+/***/ },
+
+/***/ "./src/router/index.ts"
+/*!*****************************!*\
+  !*** ./src/router/index.ts ***!
+  \*****************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   MuRouter: () => (/* binding */ MuRouter),
+/* harmony export */   createRouter: () => (/* binding */ createRouter)
+/* harmony export */ });
+/* harmony import */ var _core_renderer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../core/renderer */ "./src/core/renderer.ts");
+/* harmony import */ var _security_sanitizer__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../security/sanitizer */ "./src/security/sanitizer.ts");
+var __awaiter = (undefined && undefined.__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());
+    });
+};
+
+
+class MuRouter {
+    constructor(routes, rootContainer = null) {
+        this.currentPath = '';
+        this.currentComponent = null;
+        this.lastRouteId = 0;
+        this.routes = routes;
+        this.rootContainer = rootContainer;
+        this.isServer = rootContainer === null; // If no container, assume server/headless mode
+        if (!this.isServer) {
+            window.addEventListener('hashchange', this.handleRoute.bind(this));
+            this.handleRoute(); // Initial load
+        }
+    }
+    // SSR Method: Simulate a route visit on the server
+    serverLookup(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.currentPath = path;
+            const { route, params } = this.matchRoute(path);
+            if (route) {
+                // Run guards/resolvers here if needed
+                let componentToRender = route.component;
+                // Support Lazy Loading
+                if (typeof componentToRender === 'function' && !componentToRender.prototype) {
+                    const module = yield componentToRender();
+                    componentToRender = module.default || module;
+                }
+                if (typeof componentToRender === 'function') {
+                    // Class component SSR
+                    // We need a dummy container for the component to "render" into its own buffer
+                    // For simplicity in this string-based framework, we mock the container
+                    const mockContainer = { innerHTML: '' };
+                    const instance = new componentToRender(mockContainer);
+                    if (instance.setParams)
+                        instance.setParams(params);
+                    // Manually trigger mount logic without DOM effects if possible, or just template()
+                    // Ideally, we just want the template string.
+                    return instance.template();
+                }
+                else {
+                    return componentToRender;
+                }
+            }
+            return '<!-- 404 -->';
+        });
+    }
+    matchRoute(hash) {
+        // Simple exact match first
+        let route = this.routes.find((r) => r.path === hash);
+        if (route)
+            return { route, params: {} };
+        // Regex match for params e.g. /user/:id
+        for (const r of this.routes) {
+            const paramNames = [];
+            const regexPath = r.path.replace(/:([^/]+)/g, (_, key) => {
+                paramNames.push(key);
+                return '([^/]+)';
+            });
+            const match = new RegExp(`^${regexPath}$`).exec(hash);
+            if (match) {
+                const params = {};
+                paramNames.forEach((name, i) => {
+                    // SECURE: Automatically sanitize all route parameters
+                    params[name] = _security_sanitizer__WEBPACK_IMPORTED_MODULE_1__.Security.sanitize(match[i + 1]);
+                });
+                return { route: r, params };
+            }
+        }
+        return { route: undefined, params: {} };
+    }
+    handleRoute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isServer)
+                return;
+            const currentRouteId = ++this.lastRouteId;
+            const hash = window.location.hash.slice(1) || '/';
+            const { route, params } = this.matchRoute(hash);
+            // Security Check: Validate URL to prevent malicious hash injection
+            if (hash !== '/' && !_security_sanitizer__WEBPACK_IMPORTED_MODULE_1__.Security.validateUrl('http://dummy.com' + hash)) {
+                console.error("Security Alert: Malformed URL detected.");
+                return;
+            }
+            // Navigation Guard (Middleware)
+            if (route === null || route === void 0 ? void 0 : route.beforeEnter) {
+                yield new Promise((resolve) => {
+                    route.beforeEnter(hash, this.currentPath, (allow) => {
+                        if (allow)
+                            resolve();
+                        else {
+                            console.warn(`Navigation to ${hash} blocked by guard.`);
+                            // Ideally redirect or stay, here we just stop processing
+                            throw new Error('Navigation Blocked');
+                        }
+                    });
+                }).catch(() => { return; }); // Stop execution if blocked
+            }
+            this.currentPath = hash;
+            if (route) {
+                if (route.title) {
+                    document.title = route.title;
+                }
+                else if (route.meta && route.meta.title) {
+                    // Fallback to meta.title if used
+                    document.title = route.meta.title;
+                }
+                if (this.rootContainer) {
+                    // Mulan Cycle: Destroy previous component before rendering new one
+                    if (this.currentComponent) {
+                        console.log(`[Router] Navigation from ${this.currentPath} to ${hash}. Destroying previous component.`);
+                        if (this.currentComponent.onDestroy) {
+                            this.currentComponent.onDestroy();
+                        }
+                    }
+                    this.rootContainer.innerHTML = ''; // Clear previous content
+                }
+                let componentToRender = route.component;
+                // Support Lazy Loading
+                if (typeof componentToRender === 'function' && !componentToRender.prototype) {
+                    try {
+                        const module = yield componentToRender();
+                        if (currentRouteId !== this.lastRouteId) {
+                            console.log(`[Router] Navigation to ${hash} interrupted by newer navigation. Abandoning.`);
+                            return;
+                        }
+                        componentToRender = module.default || module;
+                    }
+                    catch (e) {
+                        console.error("Failed to lazy load component", e);
+                        return;
+                    }
+                }
+                if (typeof componentToRender === 'function') {
+                    // It's a class component
+                    if (this.rootContainer) {
+                        const instance = new componentToRender(this.rootContainer);
+                        this.currentComponent = instance;
+                        // Inject params if the component accepts them
+                        if (instance.setParams) {
+                            instance.setParams(params);
+                        }
+                        instance.mount();
+                    }
+                }
+                else if (typeof componentToRender === 'object' && componentToRender.template) {
+                    // Object Component (Simple SFC without script or Options API)
+                    const html = componentToRender.template();
+                    if (this.rootContainer)
+                        (0,_core_renderer__WEBPACK_IMPORTED_MODULE_0__.render)(html, this.rootContainer);
+                    this.currentComponent = null;
+                }
+                else {
+                    // Simple HTML string/template
+                    if (this.rootContainer)
+                        (0,_core_renderer__WEBPACK_IMPORTED_MODULE_0__.render)(componentToRender, this.rootContainer);
+                    this.currentComponent = null; // String templates don't have lifecycle instances
+                }
+            }
+            else {
+                if (this.rootContainer)
+                    (0,_core_renderer__WEBPACK_IMPORTED_MODULE_0__.render)('<div style="text-align:center; padding:50px;"><h1>404</h1><p>Page Not Found</p></div>', this.rootContainer);
+            }
+        });
+    }
+    navigate(path) {
+        if (this.isServer) {
+            this.currentPath = path;
+        }
+        else {
+            window.location.hash = path;
+        }
+    }
+}
+// --- Factory for Easy Usage ---
+const createRouter = (options) => {
+    return new MuRouter(options.routes, options.rootContainer);
+};
+// --- Web Component: <mu-link> ---
+// Usage: <mu-link to="/about">About Us</mu-link>
+if (typeof window !== 'undefined' && !customElements.get('mu-link')) {
+    class MuLink extends HTMLElement {
+        constructor() {
+            super();
+            this.addEventListener('click', (e) => {
+                e.preventDefault();
+                const to = this.getAttribute('to');
+                if (to) {
+                    // Update Hash for SPA Navigation
+                    window.location.hash = to;
+                }
+            });
+        }
+        connectedCallback() {
+            this.style.cursor = 'pointer';
+            this.style.color = 'var(--primary, #9C27B0)'; // Default to brand color if available
+            this.style.textDecoration = 'none';
+        }
+        static get observedAttributes() { return ['to']; }
+    }
+    customElements.define('mu-link', MuLink);
+}
+
+
+/***/ },
+
+/***/ "./src/security/sanitizer.ts"
+/*!***********************************!*\
+  !*** ./src/security/sanitizer.ts ***!
+  \***********************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Security: () => (/* binding */ Security)
+/* harmony export */ });
+class Security {
+    static sanitize(input) {
+        // 1. Basic entity encoding
+        let secure = input
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;")
+            .replace(/"/g, "&quot;")
+            .replace(/'/g, "&#039;");
+        // 2. Remove dangerous events (extra layer if encoding fails)
+        const dangerousEvents = ['onload', 'onclick', 'onerror', 'onmouseover', 'onfocus'];
+        dangerousEvents.forEach(event => {
+            const regex = new RegExp(event, 'gi');
+            secure = secure.replace(regex, 'data-blocked-' + event);
+        });
+        return secure;
+    }
+    /**
+     * Generates a strict Content Security Policy header value.
+     * @param options Configuration for allowed sources
+     */
+    static generateCSP(options = {}) {
+        const scriptSrc = ["'self'", ...(options.scriptSrc || [])].join(" ");
+        const styleSrc = ["'self'", "'unsafe-inline'", ...(options.styleSrc || [])].join(" ");
+        return `default-src 'self'; script-src ${scriptSrc}; style-src ${styleSrc}; object-src 'none'; base-uri 'self';`;
+    }
+    static validateUrl(url) {
+        // Basic URL validation
+        const pattern = new RegExp('^(https?:\\/\\/)?' + // protocol
+            '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|' + // domain name
+            '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR ip (v4) address
+            '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*' + // port and path
+            '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
+            '(\\#[-a-z\\d_]*)?$', 'i'); // fragment locator
+        return !!pattern.test(url);
+    }
+    /**
+     * Prevents XSS by sanitizing common input fields on blur.
+     * Can be used as a utility in forms.
+     */
+    static preventXSS(inputElement) {
+        inputElement.addEventListener('blur', (e) => {
+            const target = e.target;
+            target.value = Security.sanitize(target.value);
+        });
+    }
+}
+
+
+/***/ },
+
+/***/ "./src/store/index.ts"
+/*!****************************!*\
+  !*** ./src/store/index.ts ***!
+  \****************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   MuStore: () => (/* binding */ MuStore)
+/* harmony export */ });
+/* harmony import */ var _core_reactive__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../core/reactive */ "./src/core/reactive.ts");
+
+class MuStore {
+    constructor(initialState, options) {
+        this.subscribers = [];
+        // Load from local storage if persist is true
+        let loadedState = initialState;
+        if (options === null || options === void 0 ? void 0 : options.persist) {
+            const key = options.key || 'mulan-store';
+            try {
+                const stored = localStorage.getItem(key);
+                if (stored) {
+                    loadedState = Object.assign(Object.assign({}, initialState), JSON.parse(stored));
+                }
+            }
+            catch (e) {
+                console.error("Failed to load state", e);
+            }
+            // Auto-save effect
+            (0,_core_reactive__WEBPACK_IMPORTED_MODULE_0__.effect)(() => {
+                localStorage.setItem(key, JSON.stringify(this.state));
+            });
+        }
+        this.state = (0,_core_reactive__WEBPACK_IMPORTED_MODULE_0__.reactive)(loadedState);
+    }
+    // Subscribe to changes
+    subscribe(fn) {
+        this.subscribers.push(fn);
+        (0,_core_reactive__WEBPACK_IMPORTED_MODULE_0__.effect)(() => {
+            fn(this.state);
+        });
+    }
+    // Action dispatcher pattern
+    dispatch(action) {
+        const result = action(this.state);
+        if (result instanceof Promise) {
+            result.then(() => {
+                // Optional: Notify subscribers of async completion if needed manually?
+                // But reactive() handles updates automatically.
+            });
+        }
+    }
+}
+
+
+/***/ }
+
+/******/ });
+/************************************************************************/
+/******/ // The module cache
+/******/ var __webpack_module_cache__ = {};
+/******/ 
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/ 	// Check if module is in cache
+/******/ 	var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 	if (cachedModule !== undefined) {
+/******/ 		return cachedModule.exports;
+/******/ 	}
+/******/ 	// Check if module exists (development only)
+/******/ 	if (__webpack_modules__[moduleId] === undefined) {
+/******/ 		var e = new Error("Cannot find module '" + moduleId + "'");
+/******/ 		e.code = 'MODULE_NOT_FOUND';
+/******/ 		throw e;
+/******/ 	}
+/******/ 	// Create a new module (and put it into the cache)
+/******/ 	var module = __webpack_module_cache__[moduleId] = {
+/******/ 		// no module.id needed
+/******/ 		// no module.loaded needed
+/******/ 		exports: {}
+/******/ 	};
+/******/ 
+/******/ 	// Execute the module function
+/******/ 	__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 
+/******/ 	// Return the exports of the module
+/******/ 	return module.exports;
+/******/ }
+/******/ 
+/************************************************************************/
+/******/ /* webpack/runtime/define property getters */
+/******/ (() => {
+/******/ 	// define getter functions for harmony exports
+/******/ 	__webpack_require__.d = (exports, definition) => {
+/******/ 		for(var key in definition) {
+/******/ 			if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 				Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 			}
+/******/ 		}
+/******/ 	};
+/******/ })();
+/******/ 
+/******/ /* webpack/runtime/hasOwnProperty shorthand */
+/******/ (() => {
+/******/ 	__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ })();
+/******/ 
+/******/ /* webpack/runtime/make namespace object */
+/******/ (() => {
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = (exports) => {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/ })();
+/******/ 
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
+(() => {
+/*!**********************!*\
+  !*** ./src/index.ts ***!
+  \**********************/
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Component: () => (/* reexport safe */ _core_component__WEBPACK_IMPORTED_MODULE_1__.MuComponent),
+/* harmony export */   MuBlochSphereElement: () => (/* reexport safe */ _components_bloch_sphere__WEBPACK_IMPORTED_MODULE_10__.MuBlochSphereElement),
+/* harmony export */   MuComponent: () => (/* reexport safe */ _core_component__WEBPACK_IMPORTED_MODULE_1__.MuComponent),
+/* harmony export */   MuRouter: () => (/* reexport safe */ _router_index__WEBPACK_IMPORTED_MODULE_3__.MuRouter),
+/* harmony export */   MuStore: () => (/* reexport safe */ _store_index__WEBPACK_IMPORTED_MODULE_4__.MuStore),
+/* harmony export */   Router: () => (/* reexport safe */ _router_index__WEBPACK_IMPORTED_MODULE_3__.MuRouter),
+/* harmony export */   Security: () => (/* reexport safe */ _security_sanitizer__WEBPACK_IMPORTED_MODULE_5__.Security),
+/* harmony export */   Signal: () => (/* reexport safe */ _core_reactive__WEBPACK_IMPORTED_MODULE_0__.Signal),
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__),
+/* harmony export */   defineComponent: () => (/* reexport safe */ _core_component__WEBPACK_IMPORTED_MODULE_1__.defineComponent),
+/* harmony export */   effect: () => (/* reexport safe */ _core_reactive__WEBPACK_IMPORTED_MODULE_0__.effect),
+/* harmony export */   getCurrentInstance: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.getCurrentInstance),
+/* harmony export */   hydrate: () => (/* reexport safe */ _core_renderer__WEBPACK_IMPORTED_MODULE_2__.hydrate),
+/* harmony export */   muEffect: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.muEffect),
+/* harmony export */   muEntangle: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muEntangle),
+/* harmony export */   muGate: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muGate),
+/* harmony export */   muGeom: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.muGeom),
+/* harmony export */   muMeasure: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muMeasure),
+/* harmony export */   muMemo: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.muMemo),
+/* harmony export */   muPulse: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.muPulse),
+/* harmony export */   muQubit: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muQubit),
+/* harmony export */   muRegister: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muRegister),
+/* harmony export */   muSearch: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muSearch),
+/* harmony export */   muState: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.muState),
+/* harmony export */   muTeleport: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muTeleport),
+/* harmony export */   muVault: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.muVault),
+/* harmony export */   onMuDestroy: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.onMuDestroy),
+/* harmony export */   onMuIdle: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.onMuIdle),
+/* harmony export */   onMuInit: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.onMuInit),
+/* harmony export */   onMuMount: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.onMuMount),
+/* harmony export */   onMuResume: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.onMuResume),
+/* harmony export */   onMuShake: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.onMuShake),
+/* harmony export */   onMuVoice: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.onMuVoice),
+/* harmony export */   persistent: () => (/* reexport safe */ _core_vault__WEBPACK_IMPORTED_MODULE_8__.persistent),
+/* harmony export */   reactive: () => (/* reexport safe */ _core_reactive__WEBPACK_IMPORTED_MODULE_0__.reactive),
+/* harmony export */   ref: () => (/* reexport safe */ _core_reactive__WEBPACK_IMPORTED_MODULE_0__.ref),
+/* harmony export */   render: () => (/* reexport safe */ _core_renderer__WEBPACK_IMPORTED_MODULE_2__.render),
+/* harmony export */   renderToString: () => (/* reexport safe */ _core_renderer__WEBPACK_IMPORTED_MODULE_2__.renderToString),
+/* harmony export */   sanitize: () => (/* reexport safe */ _core_renderer__WEBPACK_IMPORTED_MODULE_2__.sanitize),
+/* harmony export */   setCurrentInstance: () => (/* reexport safe */ _core_hooks__WEBPACK_IMPORTED_MODULE_6__.setCurrentInstance),
+/* harmony export */   useMutation: () => (/* reexport safe */ _core_query__WEBPACK_IMPORTED_MODULE_7__.useMutation),
+/* harmony export */   useQuery: () => (/* reexport safe */ _core_query__WEBPACK_IMPORTED_MODULE_7__.useQuery)
+/* harmony export */ });
+/* harmony import */ var _core_reactive__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./core/reactive */ "./src/core/reactive.ts");
+/* harmony import */ var _core_component__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./core/component */ "./src/core/component.ts");
+/* harmony import */ var _core_renderer__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./core/renderer */ "./src/core/renderer.ts");
+/* harmony import */ var _router_index__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./router/index */ "./src/router/index.ts");
+/* harmony import */ var _store_index__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./store/index */ "./src/store/index.ts");
+/* harmony import */ var _security_sanitizer__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./security/sanitizer */ "./src/security/sanitizer.ts");
+/* harmony import */ var _core_hooks__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./core/hooks */ "./src/core/hooks.ts");
+/* harmony import */ var _core_query__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./core/query */ "./src/core/query.ts");
+/* harmony import */ var _core_vault__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./core/vault */ "./src/core/vault.ts");
+/* harmony import */ var _core_quantum__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./core/quantum */ "./src/core/quantum.ts");
+/* harmony import */ var _components_bloch_sphere__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./components/bloch-sphere */ "./src/components/bloch-sphere.ts");
+
+
+
+
+
+
+
+
+
+
+
+// Global Mulan Object for non-module usage
+
+
+
+
+
+
+
+
+const Mulan = Object.assign(Object.assign(Object.assign(Object.assign({ reactive: _core_reactive__WEBPACK_IMPORTED_MODULE_0__.reactive,
+    effect: _core_reactive__WEBPACK_IMPORTED_MODULE_0__.effect, Component: _core_component__WEBPACK_IMPORTED_MODULE_1__.MuComponent, defineComponent: _core_component__WEBPACK_IMPORTED_MODULE_1__.defineComponent, Router: _router_index__WEBPACK_IMPORTED_MODULE_3__.MuRouter, Store: _store_index__WEBPACK_IMPORTED_MODULE_4__.MuStore, Security: _security_sanitizer__WEBPACK_IMPORTED_MODULE_5__.Security }, _core_hooks__WEBPACK_IMPORTED_MODULE_6__), _core_query__WEBPACK_IMPORTED_MODULE_7__), _core_quantum__WEBPACK_IMPORTED_MODULE_9__), { 
+    // 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;
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Mulan);
+
+})();
+
+const __webpack_exports__Component = __webpack_exports__.Component;
+const __webpack_exports__MuBlochSphereElement = __webpack_exports__.MuBlochSphereElement;
+const __webpack_exports__MuComponent = __webpack_exports__.MuComponent;
+const __webpack_exports__MuRouter = __webpack_exports__.MuRouter;
+const __webpack_exports__MuStore = __webpack_exports__.MuStore;
+const __webpack_exports__Router = __webpack_exports__.Router;
+const __webpack_exports__Security = __webpack_exports__.Security;
+const __webpack_exports__Signal = __webpack_exports__.Signal;
+const __webpack_exports__default = __webpack_exports__["default"];
+const __webpack_exports__defineComponent = __webpack_exports__.defineComponent;
+const __webpack_exports__effect = __webpack_exports__.effect;
+const __webpack_exports__getCurrentInstance = __webpack_exports__.getCurrentInstance;
+const __webpack_exports__hydrate = __webpack_exports__.hydrate;
+const __webpack_exports__muEffect = __webpack_exports__.muEffect;
+const __webpack_exports__muEntangle = __webpack_exports__.muEntangle;
+const __webpack_exports__muGate = __webpack_exports__.muGate;
+const __webpack_exports__muGeom = __webpack_exports__.muGeom;
+const __webpack_exports__muMeasure = __webpack_exports__.muMeasure;
+const __webpack_exports__muMemo = __webpack_exports__.muMemo;
+const __webpack_exports__muPulse = __webpack_exports__.muPulse;
+const __webpack_exports__muQubit = __webpack_exports__.muQubit;
+const __webpack_exports__muRegister = __webpack_exports__.muRegister;
+const __webpack_exports__muSearch = __webpack_exports__.muSearch;
+const __webpack_exports__muState = __webpack_exports__.muState;
+const __webpack_exports__muTeleport = __webpack_exports__.muTeleport;
+const __webpack_exports__muVault = __webpack_exports__.muVault;
+const __webpack_exports__onMuDestroy = __webpack_exports__.onMuDestroy;
+const __webpack_exports__onMuIdle = __webpack_exports__.onMuIdle;
+const __webpack_exports__onMuInit = __webpack_exports__.onMuInit;
+const __webpack_exports__onMuMount = __webpack_exports__.onMuMount;
+const __webpack_exports__onMuResume = __webpack_exports__.onMuResume;
+const __webpack_exports__onMuShake = __webpack_exports__.onMuShake;
+const __webpack_exports__onMuVoice = __webpack_exports__.onMuVoice;
+const __webpack_exports__persistent = __webpack_exports__.persistent;
+const __webpack_exports__reactive = __webpack_exports__.reactive;
+const __webpack_exports__ref = __webpack_exports__.ref;
+const __webpack_exports__render = __webpack_exports__.render;
+const __webpack_exports__renderToString = __webpack_exports__.renderToString;
+const __webpack_exports__sanitize = __webpack_exports__.sanitize;
+const __webpack_exports__setCurrentInstance = __webpack_exports__.setCurrentInstance;
+const __webpack_exports__useMutation = __webpack_exports__.useMutation;
+const __webpack_exports__useQuery = __webpack_exports__.useQuery;
+export { __webpack_exports__Component as Component, __webpack_exports__MuBlochSphereElement as MuBlochSphereElement, __webpack_exports__MuComponent as MuComponent, __webpack_exports__MuRouter as MuRouter, __webpack_exports__MuStore as MuStore, __webpack_exports__Router as Router, __webpack_exports__Security as Security, __webpack_exports__Signal as Signal, __webpack_exports__default as default, __webpack_exports__defineComponent as defineComponent, __webpack_exports__effect as effect, __webpack_exports__getCurrentInstance as getCurrentInstance, __webpack_exports__hydrate as hydrate, __webpack_exports__muEffect as muEffect, __webpack_exports__muEntangle as muEntangle, __webpack_exports__muGate as muGate, __webpack_exports__muGeom as muGeom, __webpack_exports__muMeasure as muMeasure, __webpack_exports__muMemo as muMemo, __webpack_exports__muPulse as muPulse, __webpack_exports__muQubit as muQubit, __webpack_exports__muRegister as muRegister, __webpack_exports__muSearch as muSearch, __webpack_exports__muState as muState, __webpack_exports__muTeleport as muTeleport, __webpack_exports__muVault as muVault, __webpack_exports__onMuDestroy as onMuDestroy, __webpack_exports__onMuIdle as onMuIdle, __webpack_exports__onMuInit as onMuInit, __webpack_exports__onMuMount as onMuMount, __webpack_exports__onMuResume as onMuResume, __webpack_exports__onMuShake as onMuShake, __webpack_exports__onMuVoice as onMuVoice, __webpack_exports__persistent as persistent, __webpack_exports__reactive as reactive, __webpack_exports__ref as ref, __webpack_exports__render as render, __webpack_exports__renderToString as renderToString, __webpack_exports__sanitize as sanitize, __webpack_exports__setCurrentInstance as setCurrentInstance, __webpack_exports__useMutation as useMutation, __webpack_exports__useQuery as useQuery };