@mulanjs/mulanjs 1.0.1-dev.20260220123726 → 1.0.1-dev.20260220131258

package/dist/mulan.esm.js

@@ -1,585 +1,377 @@
-/******/ 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");
+/******/ // The require scope
+/******/ var __webpack_require__ = {};
+/******/ 
+/************************************************************************/
+/******/ /* 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__ = {};
 
-class MuBlochSphereElement extends HTMLElement {
-    static get observedAttributes() {
-        return ['size'];
-    }
-    constructor() {
-        super();
-        this._arrow = null;
-        this._container = null;
-        this._disposeEffect = null;
-        this.attachShadow({ mode: 'open' });
+// NAMESPACE OBJECT: ./src/core/hooks.ts
+var hooks_namespaceObject = {};
+__webpack_require__.r(hooks_namespaceObject);
+__webpack_require__.d(hooks_namespaceObject, {
+  getCurrentInstance: () => (getCurrentInstance),
+  muEffect: () => (muEffect),
+  muGeom: () => (muGeom),
+  muMemo: () => (muMemo),
+  muPulse: () => (muPulse),
+  muState: () => (muState),
+  muVault: () => (muVault),
+  onMuDestroy: () => (onMuDestroy),
+  onMuIdle: () => (onMuIdle),
+  onMuInit: () => (onMuInit),
+  onMuMount: () => (onMuMount),
+  onMuResume: () => (onMuResume),
+  onMuShake: () => (onMuShake),
+  onMuVoice: () => (onMuVoice),
+  setCurrentInstance: () => (setCurrentInstance)
+});
+
+// NAMESPACE OBJECT: ./src/core/query.ts
+var query_namespaceObject = {};
+__webpack_require__.r(query_namespaceObject);
+__webpack_require__.d(query_namespaceObject, {
+  useMutation: () => (useMutation),
+  useQuery: () => (useQuery)
+});
+
+// NAMESPACE OBJECT: ./src/core/quantum.ts
+var quantum_namespaceObject = {};
+__webpack_require__.r(quantum_namespaceObject);
+__webpack_require__.d(quantum_namespaceObject, {
+  activeControls: () => (activeControls),
+  muControl: () => (muControl),
+  muEntangle: () => (muEntangle),
+  muGate: () => (muGate),
+  muMeasure: () => (muMeasure),
+  muParallel: () => (muParallel),
+  muQubit: () => (muQubit),
+  muRegister: () => (muRegister),
+  muSearch: () => (muSearch),
+  muSwitch: () => (muSwitch),
+  muTeleport: () => (muTeleport)
+});
+
+// NAMESPACE OBJECT: ./src/core/surge.ts
+var surge_namespaceObject = {};
+__webpack_require__.r(surge_namespaceObject);
+__webpack_require__.d(surge_namespaceObject, {
+  muBurst: () => (muBurst),
+  muSurge: () => (muSurge)
+});
+
+// NAMESPACE OBJECT: ./src/components/infinity-list.ts
+var infinity_list_namespaceObject = {};
+__webpack_require__.r(infinity_list_namespaceObject);
+__webpack_require__.d(infinity_list_namespaceObject, {
+  MuInfinity: () => (MuInfinity)
+});
+
+;// ./src/core/reactive.ts
+// 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;
     }
-    connectedCallback() {
-        this.render();
+    get value() {
+        if (activeEffect) {
+            this._subscribers.add(activeEffect);
+        }
+        return this._value;
     }
-    disconnectedCallback() {
-        if (this._disposeEffect) {
-            this._disposeEffect();
-            this._disposeEffect = null;
+    set value(newValue) {
+        if (newValue !== this._value) {
+            this._value = newValue;
+            this.notify();
         }
     }
-    // Property setter for 'qubit' (passed as .qubit="${q}" in Mulan)
-    set qubit(val) {
-        this._qubit = val;
-        this.initReactivity();
+    notify() {
+        this._subscribers.forEach(fn => fn());
     }
-    get qubit() {
-        return this._qubit;
+}
+// --- 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);
     }
-    attributeChangedCallback(name, oldValue, newValue) {
-        if (name === 'size' && this._container) {
-            this._container.style.width = newValue + 'px';
-            this._container.style.height = newValue + 'px';
+}
+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
+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;
+            }
         }
     }
-    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;
+    // [Anima] 1. Pre-Update: Snapshot positions of animated elements
+    const animationSnapshots = new Map();
+    // Only query if we might have animations to save perf
+    if (template.includes('mu-animate')) {
+        const animatedEls = container.querySelectorAll('[mu-animate]');
+        animatedEls.forEach(el => {
+            const key = el.getAttribute('mu-key') || el.id;
+            if (key) {
+                animationSnapshots.set(key, el.getBoundingClientRect());
             }
-            // 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';
+    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
+                }
+            }
+        }
     }
-    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();
+    // [Anima] 2. Post-Update: FLIP (First, Last, Invert, Play)
+    if (animationSnapshots.size > 0) {
+        const newAnimatedEls = container.querySelectorAll('[mu-animate]');
+        newAnimatedEls.forEach(el => {
+            const key = el.getAttribute('mu-key') || el.id;
+            if (key && animationSnapshots.has(key)) {
+                const oldRect = animationSnapshots.get(key);
+                const newRect = el.getBoundingClientRect();
+                const dx = oldRect.left - newRect.left;
+                const dy = oldRect.top - newRect.top;
+                // Only animate if moved
+                if (dx !== 0 || dy !== 0) {
+                    const htmlEl = el;
+                    // INVERT: Move it back to where it was instantly
+                    htmlEl.style.transform = `translate(${dx}px, ${dy}px)`;
+                    htmlEl.style.transition = 'none';
+                    // PLAY: Animate to zero (new position)
+                    requestAnimationFrame(() => {
+                        // Force reflow
+                        // void htmlEl.offsetWidth; 
+                        htmlEl.style.transition = 'transform 500ms cubic-bezier(0.25, 0.8, 0.25, 1)';
+                        htmlEl.style.transform = '';
+                    });
+                }
+            }
+        });
     }
 }
-// Register the custom element
-if (typeof customElements !== 'undefined') {
-    customElements.define('mu-bloch-sphere', MuBlochSphereElement);
+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/components/infinity-list.ts"
-/*!*****************************************!*\
-  !*** ./src/components/infinity-list.ts ***!
-  \*****************************************/
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
 
-__webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   MuInfinity: () => (/* binding */ MuInfinity)
-/* harmony export */ });
-class MuInfinity extends HTMLElement {
-    constructor() {
-        super();
-        this._items = [];
-        this._itemHeight = 50; // Default height
-        this._template = '';
-        this.attachShadow({ mode: 'open' });
-        // Structure:
-        // :host { overflow-y: auto; display: block; height: 100%; }
-        //   .spacer { height: totalHeight; position: relative; }
-        //     .content { position: absolute; top: padding; width: 100%; }
-        this.shadowRoot.innerHTML = `
-            <style>
-                :host {
-                    display: block;
-                    overflow-y: auto;
-                    height: 100%;
-                    position: relative;
-                }
-                .spacer {
-                    position: relative;
-                    width: 100%;
-                }
-                .content {
-                    position: absolute;
-                    top: 0;
-                    left: 0;
-                    width: 100%;
-                }
-            </style>
-            <div class="spacer">
-                <div class="content"></div>
-            </div>
-        `;
-        this.container = this.shadowRoot.host; // The host itself scrolls
-        this.spacer = this.shadowRoot.querySelector('.spacer');
-        this.content = this.shadowRoot.querySelector('.content');
-        this.onScroll = this.onScroll.bind(this);
-    }
-    static get observedAttributes() {
-        return ['item-height'];
-    }
-    attributeChangedCallback(name, oldValue, newValue) {
-        if (name === 'item-height') {
-            this._itemHeight = parseInt(newValue, 10) || 50;
-            this.renderVisible();
-        }
-    }
-    connectedCallback() {
-        // Find the template provided by the user (Support both standard and branded tags)
-        const templateTag = this.querySelector('template') || this.querySelector('mu-template');
-        if (templateTag) {
-            this._template = templateTag.innerHTML;
-        }
-        this.addEventListener('scroll', this.onScroll);
-        // Wait for next frame to get initial height if not set
-        requestAnimationFrame(() => this.renderVisible());
-    }
-    disconnectedCallback() {
-        this.removeEventListener('scroll', this.onScroll);
-    }
-    set items(value) {
-        this._items = value;
-        this.renderVisible();
-    }
-    get items() { return this._items; }
-    onScroll() {
-        requestAnimationFrame(() => this.renderVisible());
-    }
-    renderVisible() {
-        if (!this._items.length)
-            return;
-        const scrollTop = this.scrollTop;
-        const hostHeight = this.clientHeight || 400; // Default fallback if not sized
-        const totalHeight = this._items.length * this._itemHeight;
-        this.spacer.style.height = `${totalHeight}px`;
-        // Windowing Math
-        const startIndex = Math.floor(scrollTop / this._itemHeight);
-        const buffer = 5;
-        const visibleCount = Math.ceil(hostHeight / this._itemHeight);
-        const renderStart = Math.max(0, startIndex - buffer);
-        const renderEnd = Math.min(this._items.length, startIndex + visibleCount + buffer);
-        const startOffset = renderStart * this._itemHeight;
-        this.content.style.transform = `translateY(${startOffset}px)`;
-        // Render specific slice
-        const visibleItems = this._items.slice(renderStart, renderEnd);
-        // Simple string replacement template engine for the demo
-        // In a real Mulan compilation, this would be an optimized ASTR render
-        let html = '';
-        visibleItems.forEach((item, index) => {
-            const absoluteIndex = renderStart + index;
-            // Basic mustache replacement {{ item.prop }}
-            let rowHtml = this._template
-                .replace(/{{\s*item\s*}}/g, String(item)) // {{ item }}
-                .replace(/{{\s*index\s*}}/g, String(absoluteIndex)); // {{ index }}
-            // Handle object properties: {{ item.name }}
-            if (typeof item === 'object' && item !== null) {
-                rowHtml = rowHtml.replace(/{{\s*item\.(\w+)\s*}}/g, (_, prop) => {
-                    return String(item[prop] || '');
-                });
-            }
-            html += `<div style="height: ${this._itemHeight}px; overflow: hidden;">${rowHtml}</div>`;
-        });
-        this.content.innerHTML = html;
-    }
-}
-// Register
-if (typeof customElements !== 'undefined' && !customElements.get('mu-infinity')) {
-    customElements.define('mu-infinity', MuInfinity);
-}
-
-
-/***/ },
-
-/***/ "./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;
+/**
+ * Mulan Vault: The World's First Native Persistent State Primitive.
+ */
+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 {
+            startVal = JSON.parse(stored);
         }
-        // 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;
-            }
+        catch (e) {
+            console.warn(`[Mulan Vault] Corrupt persistent data for key "${key}", resetting.`);
         }
-        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));
-            }
+    // 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 toSave = JSON.stringify(payload);
+            // Non-obfuscated persistence to satisfy security audits
+            storage.setItem(key, toSave);
         }
-        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
+        catch (e) {
+            console.error(`[Mulan Vault] Failed to save key "${key}"`);
         }
-        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
+    });
+    // 4. Sync across Tabs
+    const sync = (e) => {
+        if (e.key === key && e.newValue) {
+            try {
+                const newVal = JSON.parse(e.newValue);
+                if (isObject) {
+                    Object.assign(state, newVal);
+                }
+                else {
+                    state.value = newVal;
+                }
             }
-        }
-        template() {
-            return '';
+            catch (e) { }
         }
     };
+    window.addEventListener('storage', sync);
+    // Explicit cleanup if provided by the environment (e.g. Mulan Hooks)
+    if (options.onCleanup) {
+        options.onCleanup(() => {
+            window.removeEventListener('storage', sync);
+        });
+    }
+    return state;
 }
 
-
-/***/ },
-
-/***/ "./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");
+;// ./src/core/hooks.ts
 
 
 // Global context to track the current component instance
@@ -593,14 +385,14 @@ function getCurrentInstance() {
 // --- Mulan Unique Reactivity Hooks ---
 function muState(initialValue) {
     if (typeof initialValue === 'object' && initialValue !== null) {
-        return (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.reactive)(initialValue);
+        return reactive(initialValue);
     }
     // Core reactive state container for primitives
-    return (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.reactive)({ value: initialValue });
+    return 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)(() => {
+    const signal = reactive({ value: undefined });
+    const stop = effect(() => {
         signal.value = computeFn();
     });
     const instance = getCurrentInstance();
@@ -612,7 +404,7 @@ function muMemo(computeFn) {
     return signal;
 }
 function muEffect(fn) {
-    const stop = (0,_reactive__WEBPACK_IMPORTED_MODULE_0__.effect)(fn);
+    const stop = effect(fn);
     const instance = getCurrentInstance();
     if (instance) {
         if (!instance._effects)
@@ -807,398 +599,211 @@ function muPulse() {
  * Powered by the Iron Fortress persistent primitive.
  */
 function muVault(key, initial, options = {}) {
-    return (0,_vault__WEBPACK_IMPORTED_MODULE_1__.persistent)(key, initial, Object.assign(Object.assign({}, options), { onCleanup: (fn) => onMuDestroy(fn) }));
+    return persistent(key, initial, Object.assign(Object.assign({}, options), { onCleanup: (fn) => onMuDestroy(fn) }));
 }
 
+;// ./src/core/component.ts
 
-/***/ },
-
-/***/ "./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 */   activeControls: () => (/* binding */ activeControls),
-/* harmony export */   muControl: () => (/* binding */ muControl),
-/* harmony export */   muEntangle: () => (/* binding */ muEntangle),
-/* harmony export */   muGate: () => (/* binding */ muGate),
-/* harmony export */   muMeasure: () => (/* binding */ muMeasure),
-/* harmony export */   muParallel: () => (/* binding */ muParallel),
-/* harmony export */   muQubit: () => (/* binding */ muQubit),
-/* harmony export */   muRegister: () => (/* binding */ muRegister),
-/* harmony export */   muSearch: () => (/* binding */ muSearch),
-/* harmony export */   muSwitch: () => (/* binding */ muSwitch),
-/* harmony export */   muTeleport: () => (/* binding */ muTeleport)
-/* harmony export */ });
-/* harmony import */ var _hooks__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./hooks */ "./src/core/hooks.ts");
 
-/**
- * Mulan Quantum (ASTR-Q+) Core
- * Advanced Simulation Engine for multi-qubit registers and entanglement.
- */
-// -- GLOBAL CONTEXT FOR QUANTUM CONTROL --
-// Defined at top to ensure visibility for muGate
-let activeControls = [];
-/**
- * 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
+// 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);
         }
-    });
-}
-/**
- * Backward compatible muQubit (Single Qubit Register)
- */
-function muQubit(initial = 0) {
-    const q = muRegister(1);
-    if (initial === 1) {
-        muGate(q, 'X', 0);
+        // Setup context for hooks
+        setCurrentInstance(this);
+        this.setup();
+        setCurrentInstance(null);
     }
-    // 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
-        });
+    // 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());
     }
-    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)));
-    // Prepare Effective Control (Explicit Arguments + Global Context)
-    const effectiveControl = [...(control === undefined ? [] : (Array.isArray(control) ? control : [control])), ...activeControls];
-    // Helper: Check if all control bits are 1
-    const checkControl = (index, ctrl) => {
-        if (ctrl === undefined || (Array.isArray(ctrl) && ctrl.length === 0))
-            return true;
-        const ctrls = Array.isArray(ctrl) ? ctrl : [ctrl];
-        return ctrls.every(c => ((index >> c) & 1) === 1);
-    };
-    // SWAP Gate (Unique case: affects 2 targets)
-    if (type === 'SWAP') {
-        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++) {
-            // Check active controls for SWAP too
-            if (activeControls.length > 0 && !checkControl(i, activeControls))
-                continue;
-            const bit1 = (i >> t1) & 1;
-            const bit2 = (i >> t2) & 1;
-            if (bit1 !== bit2) {
-                // 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;
-                }
-            }
+    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);
         }
-        updateState(reg, Object.assign(Object.assign({}, state), { amplitudes: newAmps }));
-        return;
+        // 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());
     }
-    // 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, effectiveControl))
-                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);
-        }
+    // Helper for compiler to register property bindings
+    _b(id, prop, value) {
+        this._propsQueue.push([id, prop, value]);
+        return "";
     }
-    else if (type === 'X' || type === 'CNOT') {
-        // CNOT is just Controlled-X
-        for (let i = 0; i < amplitudes.length; i++) {
-            if (!checkControl(i, effectiveControl))
-                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;
-            }
+    // 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 = 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
+        render(template, this.container);
+        // Flush Side Effects
+        this.flushProps();
+        this.flushEvents();
+        this.onUpdate();
     }
-    else if (type === 'Z' || type === 'CZ') {
-        // Z and CZ are Phase Flips
-        for (let i = 0; i < amplitudes.length; i++) {
-            if (!checkControl(i, effectiveControl))
-                continue;
-            const targetBit = (i >> target) & 1;
-            // Z Gate acts on |1>
-            if (targetBit === 1) {
-                newAmps[i] = { re: -amplitudes[i].re, im: -amplitudes[i].im };
+    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 = [];
     }
-    else if (type === 'Y') {
-        // Y: |0> -> i|1>, |1> -> -i|0>
-        for (let i = 0; i < amplitudes.length; i++) {
-            if (!checkControl(i, effectiveControl))
-                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 };
+    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 = [];
     }
-    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);
+// 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
         }
-    }
-    // 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 };
+        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
+            }
         }
-        else {
-            return { re: a.re * normFactor, im: a.im * normFactor };
+        template() {
+            return '';
         }
-    });
-    // 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;
-}
-/**
- * Quantum Loop: Parallel Execution
- * Applies a gate to multiple qubits "simultaneously" (in simulation steps).
- * Ideal for initialization (Hadamard Transform) or global operations.
- * @param reg Quantum Register
- * @param qubits Array of qubit indices
- * @param gate Gate type to apply (e.g. 'H', 'X')
- */
-function muParallel(reg, qubits, gate) {
-    if (gate === 'SWAP') {
-        throw new Error("SWAP cannot be applied in parallel (requires pairs).");
-    }
-    // In a real quantum computer, these happen at t=0.
-    // Here, we loop, but logical time is constant.
-    qubits.forEach(q => muGate(reg, gate, q));
+    };
 }
-/**
- * Applies a block of operations controlled by specific qubits.
- * Enables "Quantum If/Else".
- */
-function muControl(reg, controlQubit, inverse, block) {
-    // 1. Setup Context
-    if (inverse) {
-        muGate(reg, 'X', controlQubit); // Flip 0 to 1 to activate
-    }
-    activeControls.push(controlQubit);
-    try {
-        block();
+
+;// ./src/security/sanitizer.ts
+class Security {
+    /**
+     * IRON FORTRESS PROTOCOL
+     * Strictly escapes all HTML entities to prevent XSS.
+     * Use `mu-raw` attribute in templates to bypass this for trusted content.
+     */
+    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;
     }
-    finally {
-        activeControls.pop();
-        // Uncompute (Restore 0)
-        if (inverse) {
-            muGate(reg, 'X', controlQubit);
-        }
+    /**
+     * 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';`;
     }
-}
-/**
- * Quantum Switch: conditional Logic on Superposition
- * Executes different logic branches based on the state of control qubits.
- * Because the register can be in a superposition of states (e.g. |0> + |1>),
- * MULTIPLE branches can execute effectively simultaneously on different subspaces.
- *
- * @param reg Quantum Register
- * @param controlQubit The qubit controlling the switch (Single control for v1)
- * @param cases Object mapping state (0 or 1) to a function executing quantum operations
- */
-function muSwitch(reg, controlQubit, cases) {
-    if (cases[0]) {
-        muControl(reg, controlQubit, true, cases[0]);
+    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);
     }
-    if (cases[1]) {
-        muControl(reg, controlQubit, false, cases[1]);
+    /**
+     * 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/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");
+;// ./src/router/index.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) {
@@ -1209,1031 +814,1185 @@ var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _argume
     });
 };
 
-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;
+
+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
         }
-        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 {
-        get data() { return state.data; },
-        get isLoading() { return state.isLoading; },
-        get error() { return state.error; },
-        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 {
-        get data() { return state.data; },
-        get isLoading() { return state.isLoading; },
-        get error() { return state.error; },
-        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;
+    // 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 -->';
+        });
     }
-    get value() {
-        if (activeEffect) {
-            this._subscribers.add(activeEffect);
+    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.sanitize(match[i + 1]);
+                });
+                return { route: r, params };
+            }
         }
-        return this._value;
+        return { route: undefined, params: {} };
     }
-    set value(newValue) {
-        if (newValue !== this._value) {
-            this._value = newValue;
-            this.notify();
-        }
+    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.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)
+                        render(html, this.rootContainer);
+                    this.currentComponent = null;
+                }
+                else {
+                    // Simple HTML string/template
+                    if (this.rootContainer)
+                        render(componentToRender, this.rootContainer);
+                    this.currentComponent = null; // String templates don't have lifecycle instances
+                }
+            }
+            else {
+                if (this.rootContainer)
+                    render('<div style="text-align:center; padding:50px;"><h1>404</h1><p>Page Not Found</p></div>', this.rootContainer);
+            }
+        });
     }
-    notify() {
-        this._subscribers.forEach(fn => fn());
+    // [Chronos] Prefetch a route's component code in the background
+    prefetch(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isServer)
+                return;
+            const { route } = this.matchRoute(path);
+            if (route) {
+                let componentToRender = route.component;
+                // Check if it's a lazy-loaded function that hasn't been resolved yet
+                if (typeof componentToRender === 'function' && !componentToRender.prototype) {
+                    // If it's already a resolved module (from previous prefetch), componentToRender might be the result.
+                    // But typically in our simple implementation, route.component stays as the function until we replace it.
+                    // To avoid double-fetching, we can check if it has a specific flag or property. 
+                    // For this implementation, we'll just run it and let the browser cache the module request (standard ES Module behavior).
+                    try {
+                        // console.log(`[Chronos] Prefetching ${path}...`);
+                        yield componentToRender();
+                        // We don't need to do anything with the result here. 
+                        // The browser's module cache will handle the speedup when the user actually navigates.
+                    }
+                    catch (e) {
+                        console.warn(`[Chronos] Failed to prefetch ${path}`, e);
+                    }
+                }
+            }
+        });
     }
-}
-// --- Compatibility Layer (The Surface) ---
-function effect(fn) {
-    let stopped = false;
-    const run = () => {
-        if (stopped)
-            return;
-        const prev = activeEffect;
-        activeEffect = run;
-        try {
-            fn();
+    navigate(path) {
+        if (this.isServer) {
+            this.currentPath = path;
         }
-        finally {
-            activeEffect = prev;
+        else {
+            window.location.hash = path;
         }
-    };
-    run();
-    return () => {
-        stopped = true;
-    };
+    }
 }
-function track(target, key) {
-    if (activeEffect) {
-        let depsMap = targetMap.get(target);
-        if (!depsMap) {
-            targetMap.set(target, (depsMap = new Map()));
+// --- Factory for Easy Usage ---
+const createRouter = (options) => {
+    // Expose the router instance globally for <mu-link> to access
+    const router = new MuRouter(options.routes, options.rootContainer);
+    if (typeof window !== 'undefined') {
+        window.__MULAN_ROUTER__ = router;
+    }
+    return router;
+};
+// --- 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;
+                }
+            });
+            // [Chronos] Intelligent Pre-fetching
+            this.addEventListener('mouseenter', () => {
+                const to = this.getAttribute('to');
+                if (to) {
+                    const router = window.__MULAN_ROUTER__;
+                    if (router && typeof router.prefetch === 'function') {
+                        router.prefetch(to);
+                    }
+                }
+            });
+            // [Chronos] Also prefetch on focus for keyboard users
+            this.addEventListener('focus', () => {
+                const to = this.getAttribute('to');
+                if (to) {
+                    const router = window.__MULAN_ROUTER__;
+                    if (router && typeof router.prefetch === 'function') {
+                        router.prefetch(to);
+                    }
+                }
+            });
         }
-        let dep = depsMap.get(key);
-        if (!dep) {
-            depsMap.set(key, (dep = new Set()));
+        connectedCallback() {
+            this.style.cursor = 'pointer';
+            this.style.color = 'var(--primary, #9C27B0)'; // Default to brand color if available
+            this.style.textDecoration = 'none';
         }
-        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());
+        static get observedAttributes() { return ['to']; }
     }
+    customElements.define('mu-link', MuLink);
 }
-/**
- * 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/store/index.ts
 
-/***/ "./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;
-            }
-        }
-    }
-    // [Anima] 1. Pre-Update: Snapshot positions of animated elements
-    const animationSnapshots = new Map();
-    // Only query if we might have animations to save perf
-    if (template.includes('mu-animate')) {
-        const animatedEls = container.querySelectorAll('[mu-animate]');
-        animatedEls.forEach(el => {
-            const key = el.getAttribute('mu-key') || el.id;
-            if (key) {
-                animationSnapshots.set(key, el.getBoundingClientRect());
-            }
-        });
-    }
-    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
+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
+            effect(() => {
+                localStorage.setItem(key, JSON.stringify(this.state));
+            });
         }
+        this.state = reactive(loadedState);
     }
-    // [Anima] 2. Post-Update: FLIP (First, Last, Invert, Play)
-    if (animationSnapshots.size > 0) {
-        const newAnimatedEls = container.querySelectorAll('[mu-animate]');
-        newAnimatedEls.forEach(el => {
-            const key = el.getAttribute('mu-key') || el.id;
-            if (key && animationSnapshots.has(key)) {
-                const oldRect = animationSnapshots.get(key);
-                const newRect = el.getBoundingClientRect();
-                const dx = oldRect.left - newRect.left;
-                const dy = oldRect.top - newRect.top;
-                // Only animate if moved
-                if (dx !== 0 || dy !== 0) {
-                    const htmlEl = el;
-                    // INVERT: Move it back to where it was instantly
-                    htmlEl.style.transform = `translate(${dx}px, ${dy}px)`;
-                    htmlEl.style.transition = 'none';
-                    // PLAY: Animate to zero (new position)
-                    requestAnimationFrame(() => {
-                        // Force reflow
-                        // void htmlEl.offsetWidth; 
-                        htmlEl.style.transition = 'transform 500ms cubic-bezier(0.25, 0.8, 0.25, 1)';
-                        htmlEl.style.transform = '';
-                    });
-                }
-            }
+    // Subscribe to changes
+    subscribe(fn) {
+        this.subscribers.push(fn);
+        effect(() => {
+            fn(this.state);
         });
     }
-}
-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;
+    // 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.
+            });
+        }
     }
-    // Simple SSR fallback sanitizer (rudimentary)
-    return str.replace(/&/g, "&amp;")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;")
-        .replace(/"/g, "&quot;")
-        .replace(/'/g, "&#039;");
 }
 
+;// ./src/core/query.ts
+var query_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());
+    });
+};
 
-/***/ },
-
-/***/ "./src/core/surge.ts"
-/*!***************************!*\
-  !*** ./src/core/surge.ts ***!
-  \***************************/
-(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-
-__webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   muBurst: () => (/* binding */ muBurst),
-/* harmony export */   muSurge: () => (/* binding */ muSurge)
-/* harmony export */ });
-/**
- * muBurst - Adaptive Non-blocking Iterator
- * Processes large arrays in batches within a frame budget (typically 8-16ms)
- * to keep the UI responsive while executing at near-native loop speeds.
- */
-function muBurst(array, callback, options = {}) {
-    const { chunkSize = 1000, timeout = 8, onProgress } = options;
-    return new Promise((resolve) => {
-        let index = 0;
-        const total = array.length;
-        function process() {
-            const start = performance.now();
-            // Tight loop for high-speed processing
-            while (index < total && (performance.now() - start) < timeout) {
-                // Process in smaller bursts to allow more frequent time checks if needed
-                const endBurst = Math.min(index + chunkSize, total);
-                for (; index < endBurst; index++) {
-                    callback(array[index], index);
-                }
-            }
-            if (onProgress) {
-                onProgress((index / total) * 100);
-            }
-            if (index < total) {
-                requestAnimationFrame(process);
-            }
-            else {
-                resolve();
-            }
-        }
-        process();
-    });
-}
-/**
- * muSurge - Truly Parallel Execution
- * Distributes work across CPU cores using Web Workers.
- * Logic must be serializable.
- */
-function muSurge(array, taskFn, onProgress) {
-    const n = navigator.hardwareConcurrency || 4;
-    const chunkSize = Math.ceil(array.length / n);
-    const results = new Array(array.length);
-    let completedChunks = 0;
-    let completedItems = 0;
-    // Convert function to string if it isn't already
-    const fnStr = typeof taskFn === 'function' ? taskFn.toString() : taskFn;
-    const workerPart1 = `const taskFn = ${fnStr};`;
-    const workerPart2 = `self.onmessage = function(e) {`;
-    const workerPart3 = `  const { chunk, startIndex } = e.data;`;
-    const workerPart4 = `  try { const results = chunk.map(taskFn); self.postMessage({ results, startIndex }); }`;
-    const workerPart5 = `  catch (err) { self.postMessage({ error: err.message, startIndex }); }`;
-    const workerPart6 = `};`;
-    const workerCode = [workerPart1, workerPart2, workerPart3, workerPart4, workerPart5, workerPart6].join('\n');
-    const blob = new Blob([workerCode], { type: 'application/javascript' });
-    const workerUrl = URL.createObjectURL(blob);
-    return new Promise((resolve) => {
-        if (array.length === 0)
-            return resolve([]);
-        for (let i = 0; i < n; i++) {
-            const start = i * chunkSize;
-            const end = Math.min(start + chunkSize, array.length);
-            if (start >= end) {
-                completedChunks++;
-                continue;
-            }
-            const chunk = array.slice(start, end);
-            const worker = new Worker(workerUrl);
-            worker.onmessage = (e) => {
-                const { results: chunkResults, startIndex } = e.data;
-                // Merge results back into main array
-                for (let j = 0; j < chunkResults.length; j++) {
-                    results[startIndex + j] = chunkResults[j];
-                }
-                completedChunks++;
-                completedItems += chunkResults.length;
-                if (onProgress)
-                    onProgress((completedItems / array.length) * 100);
-                worker.terminate();
-                if (completedChunks === n) {
-                    URL.revokeObjectURL(workerUrl);
-                    resolve(results);
-                }
-            };
-            worker.postMessage({ chunk, startIndex: start, fnStr });
-        }
+function useQuery(queryFn, options = { enabled: true }) {
+    const state = reactive({
+        data: null,
+        isLoading: false,
+        error: null
     });
-}
-
-
-/***/ },
-
-/***/ "./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");
-
-
-/**
- * Mulan Vault: The World's First Native Persistent State Primitive.
- */
-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) {
+    const execute = () => query_awaiter(this, void 0, void 0, function* () {
+        state.isLoading = true;
+        state.error = null;
         try {
-            startVal = JSON.parse(stored);
+            const result = yield queryFn();
+            state.data = result;
         }
-        catch (e) {
-            console.warn(`[Mulan Vault] Corrupt persistent data for key "${key}", resetting.`);
+        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();
+        });
     }
-    // 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)(() => {
+    return {
+        get data() { return state.data; },
+        get isLoading() { return state.isLoading; },
+        get error() { return state.error; },
+        refetch: execute
+    };
+}
+function useMutation(mutationFn) {
+    const state = reactive({
+        data: null,
+        isLoading: false,
+        error: null
+    });
+    const mutate = (args) => query_awaiter(this, void 0, void 0, function* () {
+        state.isLoading = true;
+        state.error = null;
         try {
-            const payload = isObject ? state : state.value;
-            const toSave = JSON.stringify(payload);
-            // Non-obfuscated persistence to satisfy security audits
-            storage.setItem(key, toSave);
+            const result = yield mutationFn(args);
+            state.data = result;
+            return result;
         }
-        catch (e) {
-            console.error(`[Mulan Vault] Failed to save key "${key}"`);
+        catch (err) {
+            state.error = err;
+            throw err;
         }
-    });
-    // 4. Sync across Tabs
-    const sync = (e) => {
-        if (e.key === key && e.newValue) {
-            try {
-                const newVal = JSON.parse(e.newValue);
-                if (isObject) {
-                    Object.assign(state, newVal);
-                }
-                else {
-                    state.value = newVal;
-                }
-            }
-            catch (e) { }
+        finally {
+            state.isLoading = false;
         }
+    });
+    return {
+        get data() { return state.data; },
+        get isLoading() { return state.isLoading; },
+        get error() { return state.error; },
+        mutate
     };
-    window.addEventListener('storage', sync);
-    // Explicit cleanup if provided by the environment (e.g. Mulan Hooks)
-    if (options.onCleanup) {
-        options.onCleanup(() => {
-            window.removeEventListener('storage', sync);
-        });
-    }
-    return state;
 }
 
+;// ./src/core/quantum.ts
 
-/***/ },
-
-/***/ "./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
+/**
+ * Mulan Quantum (ASTR-Q+) Core
+ * Advanced Simulation Engine for multi-qubit registers and entanglement.
+ */
+// -- GLOBAL CONTEXT FOR QUANTUM CONTROL --
+// Defined at top to ensure visibility for muGate
+let activeControls = [];
+/**
+ * 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 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);
     }
-    // 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 -->';
+    // 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
         });
     }
-    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 };
+    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)));
+    // Prepare Effective Control (Explicit Arguments + Global Context)
+    const effectiveControl = [...(control === undefined ? [] : (Array.isArray(control) ? control : [control])), ...activeControls];
+    // Helper: Check if all control bits are 1
+    const checkControl = (index, ctrl) => {
+        if (ctrl === undefined || (Array.isArray(ctrl) && ctrl.length === 0))
+            return true;
+        const ctrls = Array.isArray(ctrl) ? ctrl : [ctrl];
+        return ctrls.every(c => ((index >> c) & 1) === 1);
+    };
+    // SWAP Gate (Unique case: affects 2 targets)
+    if (type === 'SWAP') {
+        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++) {
+            // Check active controls for SWAP too
+            if (activeControls.length > 0 && !checkControl(i, activeControls))
+                continue;
+            const bit1 = (i >> t1) & 1;
+            const bit2 = (i >> t2) & 1;
+            if (bit1 !== bit2) {
+                // 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;
+                }
             }
         }
-        return { route: undefined, params: {} };
+        updateState(reg, Object.assign(Object.assign({}, state), { amplitudes: newAmps }));
+        return;
     }
-    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
-                }
+    // 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, effectiveControl))
+                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 {
-                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);
+                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);
+        }
     }
-    // [Chronos] Prefetch a route's component code in the background
-    prefetch(path) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isServer)
-                return;
-            const { route } = this.matchRoute(path);
-            if (route) {
-                let componentToRender = route.component;
-                // Check if it's a lazy-loaded function that hasn't been resolved yet
-                if (typeof componentToRender === 'function' && !componentToRender.prototype) {
-                    // If it's already a resolved module (from previous prefetch), componentToRender might be the result.
-                    // But typically in our simple implementation, route.component stays as the function until we replace it.
-                    // To avoid double-fetching, we can check if it has a specific flag or property. 
-                    // For this implementation, we'll just run it and let the browser cache the module request (standard ES Module behavior).
-                    try {
-                        // console.log(`[Chronos] Prefetching ${path}...`);
-                        yield componentToRender();
-                        // We don't need to do anything with the result here. 
-                        // The browser's module cache will handle the speedup when the user actually navigates.
-                    }
-                    catch (e) {
-                        console.warn(`[Chronos] Failed to prefetch ${path}`, e);
-                    }
-                }
+    else if (type === 'X' || type === 'CNOT') {
+        // CNOT is just Controlled-X
+        for (let i = 0; i < amplitudes.length; i++) {
+            if (!checkControl(i, effectiveControl))
+                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;
             }
-        });
-    }
-    navigate(path) {
-        if (this.isServer) {
-            this.currentPath = path;
         }
-        else {
-            window.location.hash = path;
+    }
+    else if (type === 'Z' || type === 'CZ') {
+        // Z and CZ are Phase Flips
+        for (let i = 0; i < amplitudes.length; i++) {
+            if (!checkControl(i, effectiveControl))
+                continue;
+            const targetBit = (i >> target) & 1;
+            // Z Gate acts on |1>
+            if (targetBit === 1) {
+                newAmps[i] = { re: -amplitudes[i].re, im: -amplitudes[i].im };
+            }
         }
     }
-}
-// --- Factory for Easy Usage ---
-const createRouter = (options) => {
-    // Expose the router instance globally for <mu-link> to access
-    const router = new MuRouter(options.routes, options.rootContainer);
-    if (typeof window !== 'undefined') {
-        window.__MULAN_ROUTER__ = router;
+    else if (type === 'Y') {
+        // Y: |0> -> i|1>, |1> -> -i|0>
+        for (let i = 0; i < amplitudes.length; i++) {
+            if (!checkControl(i, effectiveControl))
+                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;
+}
+/**
+ * Quantum Loop: Parallel Execution
+ * Applies a gate to multiple qubits "simultaneously" (in simulation steps).
+ * Ideal for initialization (Hadamard Transform) or global operations.
+ * @param reg Quantum Register
+ * @param qubits Array of qubit indices
+ * @param gate Gate type to apply (e.g. 'H', 'X')
+ */
+function muParallel(reg, qubits, gate) {
+    if (gate === 'SWAP') {
+        throw new Error("SWAP cannot be applied in parallel (requires pairs).");
+    }
+    // In a real quantum computer, these happen at t=0.
+    // Here, we loop, but logical time is constant.
+    qubits.forEach(q => muGate(reg, gate, q));
+}
+/**
+ * Applies a block of operations controlled by specific qubits.
+ * Enables "Quantum If/Else".
+ */
+function muControl(reg, controlQubit, inverse, block) {
+    // 1. Setup Context
+    if (inverse) {
+        muGate(reg, 'X', controlQubit); // Flip 0 to 1 to activate
+    }
+    activeControls.push(controlQubit);
+    try {
+        block();
+    }
+    finally {
+        activeControls.pop();
+        // Uncompute (Restore 0)
+        if (inverse) {
+            muGate(reg, 'X', controlQubit);
+        }
+    }
+}
+/**
+ * Quantum Switch: conditional Logic on Superposition
+ * Executes different logic branches based on the state of control qubits.
+ * Because the register can be in a superposition of states (e.g. |0> + |1>),
+ * MULTIPLE branches can execute effectively simultaneously on different subspaces.
+ *
+ * @param reg Quantum Register
+ * @param controlQubit The qubit controlling the switch (Single control for v1)
+ * @param cases Object mapping state (0 or 1) to a function executing quantum operations
+ */
+function muSwitch(reg, controlQubit, cases) {
+    if (cases[0]) {
+        muControl(reg, controlQubit, true, cases[0]);
+    }
+    if (cases[1]) {
+        muControl(reg, controlQubit, false, cases[1]);
+    }
+}
+
+;// ./src/core/surge.ts
+/**
+ * muBurst - Adaptive Non-blocking Iterator
+ * Processes large arrays in batches within a frame budget (typically 8-16ms)
+ * to keep the UI responsive while executing at near-native loop speeds.
+ */
+function muBurst(array, callback, options = {}) {
+    const { chunkSize = 1000, timeout = 8, onProgress } = options;
+    return new Promise((resolve) => {
+        let index = 0;
+        const total = array.length;
+        function process() {
+            const start = performance.now();
+            // Tight loop for high-speed processing
+            while (index < total && (performance.now() - start) < timeout) {
+                // Process in smaller bursts to allow more frequent time checks if needed
+                const endBurst = Math.min(index + chunkSize, total);
+                for (; index < endBurst; index++) {
+                    callback(array[index], index);
+                }
+            }
+            if (onProgress) {
+                onProgress((index / total) * 100);
+            }
+            if (index < total) {
+                requestAnimationFrame(process);
+            }
+            else {
+                resolve();
+            }
+        }
+        process();
+    });
+}
+/**
+ * muSurge - Truly Parallel Execution
+ * Distributes work across CPU cores using Web Workers.
+ * Logic must be serializable.
+ */
+function muSurge(array, taskFn, onProgress) {
+    const n = navigator.hardwareConcurrency || 4;
+    const chunkSize = Math.ceil(array.length / n);
+    const results = new Array(array.length);
+    let completedChunks = 0;
+    let completedItems = 0;
+    // Convert function to string if it isn't already
+    const fnStr = typeof taskFn === 'function' ? taskFn.toString() : taskFn;
+    const workerPart1 = `const taskFn = ${fnStr};`;
+    const workerPart2 = `self.onmessage = function(e) {`;
+    const workerPart3 = `  const { chunk, startIndex } = e.data;`;
+    const workerPart4 = `  try { const results = chunk.map(taskFn); self.postMessage({ results, startIndex }); }`;
+    const workerPart5 = `  catch (err) { self.postMessage({ error: err.message, startIndex }); }`;
+    const workerPart6 = `};`;
+    const workerCode = [workerPart1, workerPart2, workerPart3, workerPart4, workerPart5, workerPart6].join('\n');
+    const blob = new Blob([workerCode], { type: 'application/javascript' });
+    const workerUrl = URL.createObjectURL(blob);
+    return new Promise((resolve) => {
+        if (array.length === 0)
+            return resolve([]);
+        for (let i = 0; i < n; i++) {
+            const start = i * chunkSize;
+            const end = Math.min(start + chunkSize, array.length);
+            if (start >= end) {
+                completedChunks++;
+                continue;
+            }
+            const chunk = array.slice(start, end);
+            const worker = new Worker(workerUrl);
+            worker.onmessage = (e) => {
+                const { results: chunkResults, startIndex } = e.data;
+                // Merge results back into main array
+                for (let j = 0; j < chunkResults.length; j++) {
+                    results[startIndex + j] = chunkResults[j];
+                }
+                completedChunks++;
+                completedItems += chunkResults.length;
+                if (onProgress)
+                    onProgress((completedItems / array.length) * 100);
+                worker.terminate();
+                if (completedChunks === n) {
+                    URL.revokeObjectURL(workerUrl);
+                    resolve(results);
+                }
+            };
+            worker.postMessage({ chunk, startIndex: start, fnStr });
+        }
+    });
+}
+
+;// ./src/components/bloch-sphere.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 = 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/components/infinity-list.ts
+class MuInfinity extends HTMLElement {
+    constructor() {
+        super();
+        this._items = [];
+        this._itemHeight = 50; // Default height
+        this._template = '';
+        this.attachShadow({ mode: 'open' });
+        // Structure:
+        // :host { overflow-y: auto; display: block; height: 100%; }
+        //   .spacer { height: totalHeight; position: relative; }
+        //     .content { position: absolute; top: padding; width: 100%; }
+        this.shadowRoot.innerHTML = `
+            <style>
+                :host {
+                    display: block;
+                    overflow-y: auto;
+                    height: 100%;
+                    position: relative;
+                }
+                .spacer {
+                    position: relative;
+                    width: 100%;
+                }
+                .content {
+                    position: absolute;
+                    top: 0;
+                    left: 0;
+                    width: 100%;
+                }
+            </style>
+            <div class="spacer">
+                <div class="content"></div>
+            </div>
+        `;
+        this.container = this.shadowRoot.host; // The host itself scrolls
+        this.spacer = this.shadowRoot.querySelector('.spacer');
+        this.content = this.shadowRoot.querySelector('.content');
+        this.onScroll = this.onScroll.bind(this);
+    }
+    static get observedAttributes() {
+        return ['item-height'];
     }
-    return router;
-};
-// --- 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;
-                }
-            });
-            // [Chronos] Intelligent Pre-fetching
-            this.addEventListener('mouseenter', () => {
-                const to = this.getAttribute('to');
-                if (to) {
-                    const router = window.__MULAN_ROUTER__;
-                    if (router && typeof router.prefetch === 'function') {
-                        router.prefetch(to);
-                    }
-                }
-            });
-            // [Chronos] Also prefetch on focus for keyboard users
-            this.addEventListener('focus', () => {
-                const to = this.getAttribute('to');
-                if (to) {
-                    const router = window.__MULAN_ROUTER__;
-                    if (router && typeof router.prefetch === 'function') {
-                        router.prefetch(to);
-                    }
-                }
-            });
-        }
-        connectedCallback() {
-            this.style.cursor = 'pointer';
-            this.style.color = 'var(--primary, #9C27B0)'; // Default to brand color if available
-            this.style.textDecoration = 'none';
+    attributeChangedCallback(name, oldValue, newValue) {
+        if (name === 'item-height') {
+            this._itemHeight = parseInt(newValue, 10) || 50;
+            this.renderVisible();
         }
-        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 {
-    /**
-     * IRON FORTRESS PROTOCOL
-     * Strictly escapes all HTML entities to prevent XSS.
-     * Use `mu-raw` attribute in templates to bypass this for trusted content.
-     */
-    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;
+    connectedCallback() {
+        // Find the template provided by the user (Support both standard and branded tags)
+        const templateTag = this.querySelector('template') || this.querySelector('mu-template');
+        if (templateTag) {
+            this._template = templateTag.innerHTML;
+        }
+        this.addEventListener('scroll', this.onScroll);
+        // Wait for next frame to get initial height if not set
+        requestAnimationFrame(() => this.renderVisible());
     }
-    /**
-     * 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';`;
+    disconnectedCallback() {
+        this.removeEventListener('scroll', this.onScroll);
     }
-    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);
+    set items(value) {
+        this._items = value;
+        this.renderVisible();
     }
-    /**
-     * 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);
-        });
+    get items() { return this._items; }
+    onScroll() {
+        requestAnimationFrame(() => this.renderVisible());
     }
-}
-
-
-/***/ },
-
-/***/ "./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);
+    renderVisible() {
+        if (!this._items.length)
+            return;
+        const scrollTop = this.scrollTop;
+        const hostHeight = this.clientHeight || 400; // Default fallback if not sized
+        const totalHeight = this._items.length * this._itemHeight;
+        this.spacer.style.height = `${totalHeight}px`;
+        // Windowing Math
+        const startIndex = Math.floor(scrollTop / this._itemHeight);
+        const buffer = 5;
+        const visibleCount = Math.ceil(hostHeight / this._itemHeight);
+        const renderStart = Math.max(0, startIndex - buffer);
+        const renderEnd = Math.min(this._items.length, startIndex + visibleCount + buffer);
+        const startOffset = renderStart * this._itemHeight;
+        this.content.style.transform = `translateY(${startOffset}px)`;
+        // Render specific slice
+        const visibleItems = this._items.slice(renderStart, renderEnd);
+        // Simple string replacement template engine for the demo
+        // In a real Mulan compilation, this would be an optimized ASTR render
+        let html = '';
+        visibleItems.forEach((item, index) => {
+            const absoluteIndex = renderStart + index;
+            // Basic mustache replacement {{ item.prop }}
+            let rowHtml = this._template
+                .replace(/{{\s*item\s*}}/g, String(item)) // {{ item }}
+                .replace(/{{\s*index\s*}}/g, String(absoluteIndex)); // {{ index }}
+            // Handle object properties: {{ item.name }}
+            if (typeof item === 'object' && item !== null) {
+                rowHtml = rowHtml.replace(/{{\s*item\.(\w+)\s*}}/g, (_, prop) => {
+                    return String(item[prop] || '');
+                });
             }
-            // 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);
+            html += `<div style="height: ${this._itemHeight}px; overflow: hidden;">${rowHtml}</div>`;
         });
-    }
-    // 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.
-            });
-        }
+        this.content.innerHTML = html;
     }
 }
+// Register
+if (typeof customElements !== 'undefined' && !customElements.get('mu-infinity')) {
+    customElements.define('mu-infinity', MuInfinity);
+}
 
-
-/***/ }
-
-/******/ });
-/************************************************************************/
-/******/ // 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_11__.MuBlochSphereElement),
-/* harmony export */   MuComponent: () => (/* reexport safe */ _core_component__WEBPACK_IMPORTED_MODULE_1__.MuComponent),
-/* harmony export */   MuInfinity: () => (/* reexport safe */ _components_infinity_list__WEBPACK_IMPORTED_MODULE_12__.MuInfinity),
-/* 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 */   activeControls: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.activeControls),
-/* 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 */   muBurst: () => (/* reexport safe */ _core_surge__WEBPACK_IMPORTED_MODULE_10__.muBurst),
-/* harmony export */   muControl: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muControl),
-/* 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 */   muParallel: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muParallel),
-/* 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 */   muSurge: () => (/* reexport safe */ _core_surge__WEBPACK_IMPORTED_MODULE_10__.muSurge),
-/* harmony export */   muSwitch: () => (/* reexport safe */ _core_quantum__WEBPACK_IMPORTED_MODULE_9__.muSwitch),
-/* 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 _core_surge__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./core/surge */ "./src/core/surge.ts");
-/* harmony import */ var _components_bloch_sphere__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./components/bloch-sphere */ "./src/components/bloch-sphere.ts");
-/* harmony import */ var _components_infinity_list__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./components/infinity-list */ "./src/components/infinity-list.ts");
+;// ./src/index.ts
 
 
 
@@ -2259,8 +2018,8 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-const Mulan = Object.assign(Object.assign(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, createRouter: _router_index__WEBPACK_IMPORTED_MODULE_3__.createRouter, 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__), _core_surge__WEBPACK_IMPORTED_MODULE_10__), _components_infinity_list__WEBPACK_IMPORTED_MODULE_12__), { render: _core_renderer__WEBPACK_IMPORTED_MODULE_2__.render, 
+const Mulan = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ reactive: reactive,
+    effect: effect, Component: MuComponent, defineComponent: defineComponent, Router: MuRouter, createRouter: createRouter, Store: MuStore, Security: Security }, hooks_namespaceObject), query_namespaceObject), quantum_namespaceObject), surge_namespaceObject), infinity_list_namespaceObject), { render: render, 
     // MULAN INSIGHT: Branded Logging
     log: (msg, ...args) => {
         console.log(`%c[MulanJS]%c ${msg}`, "color: #ff3e00; font-weight: bold; background: #222; padding: 2px 4px; border-radius: 3px;", "", ...args);
@@ -2292,57 +2051,8 @@ if (typeof window !== 'undefined') {
 if (typeof window !== 'undefined') {
     window.Mulan = Mulan;
 }
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Mulan);
+/* harmony default export */ const src = (Mulan);
 
-})();
+export { MuComponent as Component, MuBlochSphereElement, MuComponent, MuInfinity, MuRouter, MuStore, MuRouter as Router, Security, Signal, activeControls, src as default, defineComponent, effect, getCurrentInstance, hydrate, muBurst, muControl, muEffect, muEntangle, muGate, muGeom, muMeasure, muMemo, muParallel, muPulse, muQubit, muRegister, muSearch, muState, muSurge, muSwitch, muTeleport, muVault, onMuDestroy, onMuIdle, onMuInit, onMuMount, onMuResume, onMuShake, onMuVoice, persistent, reactive, ref, render, renderToString, sanitize, setCurrentInstance, useMutation, useQuery };
 
-const __webpack_exports__Component = __webpack_exports__.Component;
-const __webpack_exports__MuBlochSphereElement = __webpack_exports__.MuBlochSphereElement;
-const __webpack_exports__MuComponent = __webpack_exports__.MuComponent;
-const __webpack_exports__MuInfinity = __webpack_exports__.MuInfinity;
-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__activeControls = __webpack_exports__.activeControls;
-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__muBurst = __webpack_exports__.muBurst;
-const __webpack_exports__muControl = __webpack_exports__.muControl;
-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__muParallel = __webpack_exports__.muParallel;
-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__muSurge = __webpack_exports__.muSurge;
-const __webpack_exports__muSwitch = __webpack_exports__.muSwitch;
-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__MuInfinity as MuInfinity, __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__activeControls as activeControls, __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__muBurst as muBurst, __webpack_exports__muControl as muControl, __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__muParallel as muParallel, __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__muSurge as muSurge, __webpack_exports__muSwitch as muSwitch, __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 };
+//# sourceMappingURL=mulan.esm.js.map