@mulanjs/mulanjs 1.0.1-dev.20260227135307 → 1.0.1-dev.20260227172006

package/dist/mulan.js

@@ -10,427 +10,507 @@
 })(this, () => {
 return /******/ (() => { // webpackBootstrap
 /******/ 	"use strict";
-/******/ 	// 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__ = {};
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  "default": () => (/* binding */ src)
-});
-
-// UNUSED EXPORTS: Component, MuBlochSphereElement, MuComponent, MuInfinity, MuRouter, MuStore, Router, Security, Signal, activeControls, defineComponent, effect, getCurrentInstance, hydrate, muBurst, muControl, muDebounced, muEffect, muEntangle, muGate, muGeom, muHistory, muMeasure, muMemo, muParallel, muPulse, muQubit, muRegister, muSearch, muState, muSurge, muSuspense, muSwitch, muTeleport, muThrottled, muVault, onMuDestroy, onMuIdle, onMuInit, onMuMount, onMuPanic, onMuResume, onMuShake, onMuVisibility, onMuVoice, persistent, reactive, ref, render, renderToString, sanitize, setCurrentInstance, useMutation, useQuery
-
-// NAMESPACE OBJECT: ./src/core/hooks.ts
-var hooks_namespaceObject = {};
-__webpack_require__.r(hooks_namespaceObject);
-__webpack_require__.d(hooks_namespaceObject, {
-  getCurrentInstance: () => (getCurrentInstance),
-  muDebounced: () => (muDebounced),
-  muEffect: () => (muEffect),
-  muGeom: () => (muGeom),
-  muHistory: () => (muHistory),
-  muMemo: () => (muMemo),
-  muPulse: () => (muPulse),
-  muState: () => (muState),
-  muSuspense: () => (muSuspense),
-  muThrottled: () => (muThrottled),
-  muVault: () => (muVault),
-  onMuDestroy: () => (onMuDestroy),
-  onMuIdle: () => (onMuIdle),
-  onMuInit: () => (onMuInit),
-  onMuMount: () => (onMuMount),
-  onMuPanic: () => (onMuPanic),
-  onMuResume: () => (onMuResume),
-  onMuShake: () => (onMuShake),
-  onMuVisibility: () => (onMuVisibility),
-  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)
-});
+/******/ 	var __webpack_modules__ = ({
 
-// 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)
-});
+/***/ 37
+(__unused_webpack_module, exports, __webpack_require__) {
 
-// NAMESPACE OBJECT: ./src/core/surge.ts
-var surge_namespaceObject = {};
-__webpack_require__.r(surge_namespaceObject);
-__webpack_require__.d(surge_namespaceObject, {
-  muBurst: () => (muBurst),
-  muSurge: () => (muSurge)
-});
 
-;// ./src/core/reactive.ts
-// MulanJS 2.0: Signal-Powered Reactivity Engine
-// "Compatible Surface, World-Class Engine"
-let activeEffect = null;
-let activeEffectRunner = null;
-const targetMap = new WeakMap();
-// --- Signal Core (The Engine) ---
-class Signal {
-    constructor(initialValue) {
-        this._subscribers = new Set();
-        this._value = initialValue;
-    }
-    get value() {
-        if (activeEffectRunner) {
-            this._subscribers.add(activeEffectRunner.run);
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.defineComponent = exports.MuComponent = void 0;
+const renderer_1 = __webpack_require__(619);
+const hooks_1 = __webpack_require__(166);
+const reactive_1 = __webpack_require__(359);
+// 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._domEffects = [];
+        this._isDestroyed = false;
+        this._isResuming = false; // Quantum Resumability Flag
+        this._resumeRoot = null;
+        this._propsQueue = [];
+        this._eventQueue = [];
+        // --- MulanJS List Reconciliation Engine (No-VDOM) ---
+        // Cache to store generated DOM rows by mu-key
+        this._listCaches = new Map();
+        // --- MulanJS Conditional Engine (No-VDOM) ---
+        // Cache to store conditionally toggled blocks
+        this._ifCaches = new Map();
+        this.container = container;
+        this.state = {};
+        this.$uid = 'mu_' + Math.random().toString(36).substr(2, 9);
+        // MULAN INSIGHT: Quantum Resumability Detection
+        if (typeof window !== 'undefined' && container) {
+            const rootAttr = container.getAttribute('data-mu-root');
+            const stateScript = container.querySelector('script[type="mulan/state"]');
+            if (rootAttr || stateScript) {
+                console.log(`%c[Mulan Quantum]%c Resuming component from server state...`, "color: #00ffcc; font-weight: bold;", "");
+                this._isResuming = true;
+                this.$uid = rootAttr || this.$uid;
+                if (stateScript) {
+                    try {
+                        const serverState = JSON.parse(stateScript.textContent || '{}');
+                        // Inject server state into this instance
+                        Object.assign(this, serverState);
+                    }
+                    catch (e) {
+                        console.error("[Mulan Quantum] Failed to parse server state:", e);
+                    }
+                }
+            }
         }
-        return this._value;
-    }
-    set value(newValue) {
-        if (newValue !== this._value) {
-            this._value = newValue;
-            this.notify();
+        // 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_1.setCurrentInstance)(this);
+        this.setup();
+        (0, hooks_1.setCurrentInstance)(null);
     }
-    notify() {
-        this._subscribers.forEach(fn => fn());
+    // 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());
     }
-}
-// --- Compatibility Layer (The Surface) ---
-function effect(fn, targetNode) {
-    let stopped = false;
-    const run = () => {
-        if (stopped)
+    onUpdate() { }
+    onDestroy() {
+        var _a, _c;
+        if (this._isDestroyed)
             return;
-        const prevRunner = activeEffectRunner;
-        activeEffectRunner = { run, node: targetNode };
-        try {
-            fn();
-        }
-        finally {
-            activeEffectRunner = prevRunner;
+        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);
         }
-    };
-    run();
-    return () => {
-        stopped = true;
-    };
-}
-function track(target, key) {
-    if (activeEffectRunner) {
-        let depsMap = targetMap.get(target);
-        if (!depsMap) {
-            targetMap.set(target, (depsMap = new Map()));
+        // 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 = [];
+        console.log(`[Mulan Cycle] Stopping ${this._domEffects.length} DOM effects for ${this.$uid}`);
+        this._domEffects.forEach(stop => stop());
+        this._domEffects = [];
+        // 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 "";
+    }
+    // Manual binding helper for template literals
+    bind(handler, type = 'click') {
+        const id = 'ev_' + Math.random().toString(36).substr(2, 9);
+        this._e(id, type, handler);
+        return `data-mu-id="${id}"`;
+    }
+    mount() {
+        console.log(`[Mulan Cycle] Mounting component ${this.$uid}`);
+        if (this._isResuming) {
+            // Quantum Resumability: Skip initial render, just attach effects to existing DOM
+            console.log(`[Mulan Quantum] Skipping initial render, recovering DOM nodes...`);
+            this._resume();
         }
-        let dep = depsMap.get(key);
-        if (!dep) {
-            depsMap.set(key, (dep = new Set()));
+        else {
+            // Standard Hydration/Mount
+            const stop = (0, reactive_1.effect)(() => {
+                console.log(`[Mulan Reactivity] Triggering macro-update for ${this.$uid}`);
+                this.update();
+            });
+            this._effects.push(stop);
         }
-        dep.add(activeEffectRunner.run);
+        this.onMount();
     }
-}
-function trigger(target, key) {
-    const depsMap = targetMap.get(target);
-    if (!depsMap)
-        return;
-    const dep = depsMap.get(key);
-    if (dep) {
-        dep.forEach((fn) => fn());
+    /**
+     * Internal method to execute the resumability pass.
+     * Overridden by compiler-generated code.
+     */
+    _resume() {
+        // Clear queues
+        this._propsQueue = [];
+        this._eventQueue = [];
+        // Call the template with resumption context
+        // In a real implementation, the compiler will inject 'recovery' instructions
+        this._recoveryMode = true;
+        this.template();
+        this._recoveryMode = false;
+        // Flush bindings (events/props) to existing nodes
+        this.flushProps();
+        this.flushEvents();
     }
-}
-/**
- * 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;
-            }
+    // New helper for the compiler to register a fine-grained DOM property effect
+    _bindEffect(fn, targetNode) {
+        const stop = (0, reactive_1.effect)(fn, targetNode);
+        this._domEffects.push(stop);
+        return stop;
+    }
+    update() {
+        if (this._isDestroyed) {
+            console.warn(`[Mulan Warning] Update called on destroyed component ${this.$uid}. Blocking render.`);
+            return;
         }
+        // Clear queues before render
+        this._propsQueue = [];
+        this._eventQueue = [];
+        const template = this.template();
+        // Render HTML
+        (0, renderer_1.render)(template, this.container);
+        // Flush Side Effects
+        this.flushProps();
+        this.flushEvents();
+        this.onUpdate();
     }
-    // [Anima] 1. Pre-Update: Snapshot positions of animated elements
-    const animationSnapshots = new Map();
-    // Only query if we might have animations to save perf
-    if (typeof template === 'string' && 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());
+    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;
             }
-        });
-    }
-    if (typeof template === 'string') {
-        container.innerHTML = template;
-    }
-    else {
-        container.innerHTML = '';
-        container.appendChild(template);
+        }
+        this._propsQueue = [];
     }
-    // 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
-                }
+    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 = [];
     }
-    // [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 = '';
-                    });
+    /**
+     * Reconciles a list of bound data to an existing DOM parent segment.
+     * @param listId Unique ID for this specific mu-for directive Block
+     * @param container The DOM Element or Fragment where children are attached
+     * @param array The current state array
+     * @param keyProp The property to extract from each item to use as a unique key (e.g. 'id')
+     * @param renderRow A function that takes an item and returns a new { fragment, effects }
+     */
+    _reconcileList(listId, anchorToken, array, keyProp, renderRow) {
+        if (!this._listCaches.has(listId)) {
+            this._listCaches.set(listId, new Map());
+        }
+        const cache = this._listCaches.get(listId);
+        const newKeys = new Set();
+        const parent = anchorToken.parentNode;
+        if (!parent)
+            return;
+        // 1. Array Iteration: Match against cache or Create
+        // Use a DocumentFragment to batch new node insertions natively
+        const collectorFrag = document.createDocumentFragment();
+        const newOrderNodes = [];
+        const newOrderKeys = [];
+        let requiresSwap = false;
+        let lastCachedIndex = -1;
+        for (let i = 0; i < array.length; i++) {
+            const item = array[i];
+            const key = keyProp ? item[keyProp] : i; // fallback to index if no key
+            newKeys.add(key);
+            newOrderKeys.push(key);
+            let cached = cache.get(key);
+            if (!cached) {
+                // Not in cache, Render a brand new row structure
+                const { fragment, effects } = renderRow(item, i);
+                // Track actual DOM nodes
+                const createdNodes = Array.from(fragment.childNodes);
+                cached = { nodes: createdNodes, effects, index: i }; // Store index for fast swap detection
+                cache.set(key, cached);
+                // Batch append to our in-memory fragment!
+                // This eliminates thousands of live DOM reflows on creation.
+                collectorFrag.appendChild(fragment);
+                newOrderNodes.push(...createdNodes);
+            }
+            else {
+                // Exists in cache
+                // Batch append to the in-memory array for index tracking
+                newOrderNodes.push(...cached.nodes);
+                // Fast-Path Swap Detection: If the cached index is physically out of numerical sequence,
+                // we know the array order was unsynchronized and needs reconciliation.
+                if (cached.index < lastCachedIndex) {
+                    requiresSwap = true;
                 }
+                cached.index = i;
+                lastCachedIndex = i;
             }
-        });
-    }
-}
-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 (typeof template === 'string') {
-        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.');
+        // 2. Fragment Batch Insertion (O(1) Live DOM Reflow for Creations)
+        if (collectorFrag.childNodes.length > 0) {
+            parent.insertBefore(collectorFrag, anchorToken.nextSibling);
         }
-    }
-    else {
-        container.innerHTML = '';
-        container.appendChild(template);
-    }
-    // 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
-
-
-/**
- * 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);
+        // 3. Bidirectional Swap Sync (O(K) isolated shifts instead of O(N) cascades)
+        if (requiresSwap) {
+            let currentSibling = anchorToken.nextSibling;
+            // We iterate through our guaranteed physical newOrderNodes list
+            for (let j = 0; j < newOrderNodes.length; j++) {
+                const targetNode = newOrderNodes[j];
+                if (targetNode !== currentSibling) {
+                    // The physical live DOM is out of sync. Move targetNode to where it belongs immediately.
+                    parent.insertBefore(targetNode, currentSibling);
+                }
+                else {
+                    // Node is correctly positioned, simply advance the sliding logical pointer
+                    currentSibling = currentSibling.nextSibling;
+                }
+            }
         }
-        catch (e) {
-            console.warn(`[Mulan Vault] Corrupt persistent data for key "${key}", resetting.`);
+        // 4. Cleanup Phase: Rapidly detach unmounted nodes
+        if (cache.size > newKeys.size) {
+            for (const [key, cached] of cache.entries()) {
+                if (!newKeys.has(key)) {
+                    // Remove from DOM
+                    cached.nodes.forEach((node) => {
+                        if (node.parentNode === parent) {
+                            parent.removeChild(node);
+                        }
+                    });
+                    // Stop any targeted effects tied to these nodes
+                    cached.effects.forEach((stop) => stop());
+                    // Delete from cache tracking
+                    cache.delete(key);
+                }
+            }
         }
     }
-    // 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);
-        }
-        catch (e) {
-            console.error(`[Mulan Vault] Failed to save key "${key}"`);
+    /**
+     * Reconciles a conditional block (mu-if) to an existing DOM parent segment.
+     */
+    _reconcileIf(ifId, anchorToken, condition, renderBlock) {
+        if (!this._ifCaches.has(ifId)) {
+            this._ifCaches.set(ifId, { isMounted: false, nodes: [], effects: [] });
         }
-    });
-    // 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);
+        let cached = this._ifCaches.get(ifId);
+        if (condition) {
+            // Should be mounted
+            if (!cached.isMounted) {
+                // We need to render and mount it
+                let nodesToMount;
+                if (cached.nodes.length === 0) {
+                    // First time render
+                    const { fragment, effects } = renderBlock();
+                    nodesToMount = Array.from(fragment.childNodes);
+                    cached.nodes = nodesToMount;
+                    cached.effects = effects;
                 }
                 else {
-                    state.value = newVal;
+                    // Re-mounting previously cached nodes
+                    nodesToMount = cached.nodes;
                 }
+                cached.isMounted = true;
+                const parent = anchorToken.parentNode;
+                if (!parent)
+                    return;
+                const targetSibling = anchorToken.nextSibling;
+                nodesToMount.forEach(node => {
+                    parent.insertBefore(node, targetSibling);
+                });
+            }
+        }
+        else {
+            // Should NOT be mounted
+            if (cached.isMounted) {
+                // Unmount nodes but keep them in cache
+                cached.nodes.forEach(node => {
+                    if (node.parentNode) {
+                        node.parentNode.removeChild(node);
+                    }
+                });
+                cached.isMounted = false;
+                // Note: We deliberately do NOT destroy the effects here, they stay active in memory!
             }
-            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
-
-
+exports.MuComponent = MuComponent;
+// Helper to create functional components wrapped in the class system
+// Helper to create functional components wrapped in the class system
+// Supports both () => render and { setup() } signatures
+function defineComponent(optionsOrSetup) {
+    return class UniversalComponent extends MuComponent {
+        constructor(container) {
+            super(container);
+            // setup() is called by super constructor
+        }
+        setup() {
+            let setupResult;
+            if (typeof optionsOrSetup === 'function') {
+                // It's a setup function returning render fn
+                setupResult = optionsOrSetup.call(this);
+            }
+            else if (typeof optionsOrSetup === 'object' && optionsOrSetup.setup) {
+                // It's an options object with setup()
+                setupResult = optionsOrSetup.setup.call(this);
+            }
+            // Handle result
+            if (typeof setupResult === 'function') {
+                // It's a render function
+                this.template = setupResult;
+            }
+            else if (setupResult && typeof setupResult === 'object') {
+                // It's bindings
+                Object.assign(this, setupResult);
+                // We assume template is assigned to prototype by compiler
+            }
+        }
+        template() {
+            return '';
+        }
+    };
+}
+exports.defineComponent = defineComponent;
+
+
+/***/ },
+
+/***/ 156
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.MuStore = exports.Router = exports.MuRouter = exports.defineComponent = exports.Component = exports.MuComponent = void 0;
+__exportStar(__webpack_require__(359), exports);
+var component_1 = __webpack_require__(37);
+Object.defineProperty(exports, "MuComponent", ({ enumerable: true, get: function () { return component_1.MuComponent; } }));
+Object.defineProperty(exports, "Component", ({ enumerable: true, get: function () { return component_1.MuComponent; } }));
+Object.defineProperty(exports, "defineComponent", ({ enumerable: true, get: function () { return component_1.defineComponent; } }));
+__exportStar(__webpack_require__(619), exports);
+var index_1 = __webpack_require__(580);
+Object.defineProperty(exports, "MuRouter", ({ enumerable: true, get: function () { return index_1.MuRouter; } }));
+Object.defineProperty(exports, "Router", ({ enumerable: true, get: function () { return index_1.MuRouter; } }));
+var index_2 = __webpack_require__(482);
+Object.defineProperty(exports, "MuStore", ({ enumerable: true, get: function () { return index_2.MuStore; } }));
+__exportStar(__webpack_require__(500), exports);
+__exportStar(__webpack_require__(166), exports);
+__exportStar(__webpack_require__(598), exports);
+__exportStar(__webpack_require__(234), exports);
+__exportStar(__webpack_require__(679), exports);
+__exportStar(__webpack_require__(172), exports);
+__exportStar(__webpack_require__(615), exports);
+__exportStar(__webpack_require__(382), exports);
+__exportStar(__webpack_require__(678), exports);
+// Global Mulan Object for non-module usage
+const reactive_1 = __webpack_require__(359);
+const component_2 = __webpack_require__(37);
+const index_3 = __webpack_require__(580);
+const index_4 = __webpack_require__(482);
+const sanitizer_1 = __webpack_require__(500);
+const Hooks = __importStar(__webpack_require__(166));
+const Query = __importStar(__webpack_require__(598));
+const renderer_1 = __webpack_require__(619);
+const Quantum = __importStar(__webpack_require__(679));
+const Surge = __importStar(__webpack_require__(172));
+const InfinityList = __importStar(__webpack_require__(382));
+const Mulan = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ reactive: reactive_1.reactive,
+    effect: reactive_1.effect, Component: component_2.MuComponent, defineComponent: component_2.defineComponent, Router: index_3.MuRouter, createRouter: index_3.createRouter, Store: index_4.MuStore, Security: sanitizer_1.Security }, Hooks), Query), Quantum), Surge), InfinityList), { render: renderer_1.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);
+    }, warn: (msg, ...args) => {
+        console.warn(`%c[MulanJS]%c ${msg}`, "color: #ffcc00; font-weight: bold; background: #222; padding: 2px 4px; border-radius: 3px;", "", ...args);
+    }, error: (msg, ...args) => {
+        console.error(`%c[MulanJS]%c ${msg}`, "color: #ff0000; font-weight: bold; background: #222; padding: 2px 4px; border-radius: 3px;", "", ...args);
+    } });
+// Security: Freeze the object to prevent runtime tampering
+Object.freeze(Mulan);
+Object.freeze(Mulan.Security);
+// MULAN INSIGHT: Initialize Global Registry
+if (typeof window !== 'undefined') {
+    window.__MULAN_INSIGHT__ = window.__MULAN_INSIGHT__ || { components: new Map() };
+    // MULAN INSIGHT: HMR Support
+    window.__MULAN_REFRESH__ = () => {
+        var _a;
+        const components = (_a = window.__MULAN_INSIGHT__) === null || _a === void 0 ? void 0 : _a.components;
+        if (components) {
+            components.forEach((comp) => {
+                if (comp && typeof comp.update === 'function') {
+                    // Force refresh
+                    comp.update();
+                }
+            });
+        }
+    };
+}
+if (typeof window !== 'undefined') {
+    window.Mulan = Mulan;
+}
+exports["default"] = Mulan;
+
+
+/***/ },
+
+/***/ 166
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.muHistory = exports.onMuPanic = exports.muThrottled = exports.muDebounced = exports.onMuVisibility = exports.muSuspense = exports.muVault = exports.muPulse = exports.muGeom = exports.onMuVoice = exports.onMuShake = exports.onMuResume = exports.onMuIdle = exports.onMuDestroy = exports.onMuMount = exports.onMuInit = exports.muEffect = exports.muMemo = exports.muState = exports.getCurrentInstance = exports.setCurrentInstance = void 0;
+const reactive_1 = __webpack_require__(359);
+const vault_1 = __webpack_require__(234);
 // Global context to track the current component instance
 let currentInstance = null;
 function setCurrentInstance(instance) {
     currentInstance = instance;
 }
+exports.setCurrentInstance = setCurrentInstance;
 function getCurrentInstance() {
     return currentInstance;
 }
+exports.getCurrentInstance = getCurrentInstance;
 // --- Mulan Unique Reactivity Hooks ---
 function muState(initialValue) {
     if (typeof initialValue === 'object' && initialValue !== null) {
-        return reactive(initialValue);
+        return (0, reactive_1.reactive)(initialValue);
     }
     // Core reactive state container for primitives
-    return reactive({ value: initialValue });
+    return (0, reactive_1.reactive)({ value: initialValue });
 }
+exports.muState = muState;
 function muMemo(computeFn) {
-    const signal = reactive({ value: undefined });
-    const stop = effect(() => {
+    const signal = (0, reactive_1.reactive)({ value: undefined });
+    const stop = (0, reactive_1.effect)(() => {
         signal.value = computeFn();
     });
     const instance = getCurrentInstance();
@@ -441,8 +521,9 @@ function muMemo(computeFn) {
     }
     return signal;
 }
+exports.muMemo = muMemo;
 function muEffect(fn) {
-    const stop = effect(fn);
+    const stop = (0, reactive_1.effect)(fn);
     const instance = getCurrentInstance();
     if (instance) {
         if (!instance._effects)
@@ -450,6 +531,7 @@ function muEffect(fn) {
         instance._effects.push(stop);
     }
 }
+exports.muEffect = muEffect;
 // --- The "Mulan Cycle" (Lifecycle) ---
 function onMuInit(fn) {
     const instance = getCurrentInstance();
@@ -464,6 +546,7 @@ function onMuInit(fn) {
         console.warn('onMuInit called outside of component setup context.');
     }
 }
+exports.onMuInit = onMuInit;
 function onMuMount(fn) {
     // New hook for when component is actually in DOM (simulated for now via update)
     const instance = getCurrentInstance();
@@ -475,6 +558,7 @@ function onMuMount(fn) {
         instance._hooks.onMuMount.push(fn);
     }
 }
+exports.onMuMount = onMuMount;
 function onMuDestroy(fn) {
     const instance = getCurrentInstance();
     if (instance) {
@@ -485,6 +569,7 @@ function onMuDestroy(fn) {
         instance._hooks.onMuDestroy.push(fn);
     }
 }
+exports.onMuDestroy = onMuDestroy;
 /**
  * onMuIdle - The "Environment Life" Hook.
  * Executes heavy logic ONLY when the browser is taking a nap (idle).
@@ -513,6 +598,7 @@ function onMuIdle(fn) {
         });
     }
 }
+exports.onMuIdle = onMuIdle;
 /**
  * onMuResume - The "Tab Life" Hook.
  * Executes when the user switches BACK to this tab.
@@ -527,6 +613,7 @@ function onMuResume(fn) {
     document.addEventListener('visibilitychange', handler);
     onMuDestroy(() => document.removeEventListener('visibilitychange', handler));
 }
+exports.onMuResume = onMuResume;
 /**
  * onMuShake - The "Physical Life" Hook.
  * Executes when the device is shaken.
@@ -565,6 +652,7 @@ function onMuShake(fn) {
         console.warn("[MulanJS] Device Motion not supported on this device.");
     }
 }
+exports.onMuShake = onMuShake;
 /**
  * onMuVoice - The "Sound Life" Hook.
  * Executes when a specific word is spoken.
@@ -600,6 +688,7 @@ function onMuVoice(command, fn) {
         recognition.stop();
     });
 }
+exports.onMuVoice = onMuVoice;
 // --- "Outside The Box" Hooks (Mulan Exclusives) ---
 /**
  * muGeom - Tracks window or element dimensions reactively.
@@ -617,6 +706,7 @@ function muGeom() {
     });
     return dims;
 }
+exports.muGeom = muGeom;
 /**
  * muPulse - Reactive network status.
  */
@@ -632,13 +722,15 @@ function muPulse() {
     });
     return status;
 }
+exports.muPulse = muPulse;
 /**
  * muVault - Secure reactive LocalStorage wrapper.
  * Powered by the Iron Fortress persistent primitive.
  */
 function muVault(key, initial, options = {}) {
-    return persistent(key, initial, Object.assign(Object.assign({}, options), { onCleanup: (fn) => onMuDestroy(fn) }));
+    return (0, vault_1.persistent)(key, initial, Object.assign(Object.assign({}, options), { onCleanup: (fn) => onMuDestroy(fn) }));
 }
+exports.muVault = muVault;
 // --- Next-Gen MulanJS Hooks ---
 /**
  * muSuspense - The Asynchronous Barrier.
@@ -662,6 +754,7 @@ function muSuspense(promiseFn) {
     });
     return state;
 }
+exports.muSuspense = muSuspense;
 /**
  * onMuVisibility - The Intersection Observer Hook.
  * Triggers when the component enters/leaves the viewport.
@@ -683,6 +776,7 @@ function onMuVisibility(callback, options = { threshold: 0.1 }) {
         });
     });
 }
+exports.onMuVisibility = onMuVisibility;
 /**
  * muDebounced - High-performance debouncing built directly into a reactive signal.
  */
@@ -701,6 +795,7 @@ function muDebounced(initialValue, delayMs) {
         }
     };
 }
+exports.muDebounced = muDebounced;
 /**
  * muThrottled - High-performance throttling built directly into a reactive signal.
  */
@@ -720,6 +815,7 @@ function muThrottled(initialValue, delayMs) {
         }
     };
 }
+exports.muThrottled = muThrottled;
 /**
  * onMuPanic - The Iron Fortress Error Boundary.
  * Catches unhandled exceptions within the component scope.
@@ -743,6 +839,7 @@ function onMuPanic(fallbackFn) {
         window.removeEventListener('unhandledrejection', handler);
     });
 }
+exports.onMuPanic = onMuPanic;
 /**
  * muHistory - State with built-in Undo/Redo tracking.
  */
@@ -781,638 +878,502 @@ function muHistory(initialValue) {
         get future() { return historyTracker.log.slice(pointer.value + 1); }
     };
 }
+exports.muHistory = muHistory;
 
-;// ./src/core/component.ts
 
+/***/ },
 
+/***/ 172
+(__unused_webpack_module, exports) {
 
-// 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._domEffects = [];
-        this._isDestroyed = false;
-        this._propsQueue = [];
-        this._eventQueue = [];
-        // --- MulanJS List Reconciliation Engine (No-VDOM) ---
-        // Cache to store generated DOM rows by mu-key
-        this._listCaches = new Map();
-        // --- MulanJS Conditional Engine (No-VDOM) ---
-        // Cache to store conditionally toggled blocks
-        this._ifCaches = new Map();
-        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
-        setCurrentInstance(this);
-        this.setup();
-        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 = [];
-        console.log(`[Mulan Cycle] Stopping ${this._domEffects.length} DOM effects for ${this.$uid}`);
-        this._domEffects.forEach(stop => stop());
-        this._domEffects = [];
-        // 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 "";
-    }
-    // Manual binding helper for template literals
-    bind(handler, type = 'click') {
-        const id = 'ev_' + Math.random().toString(36).substr(2, 9);
-        this._e(id, type, handler);
-        return `data-mu-id="${id}"`;
-    }
-    mount() {
-        console.log(`[Mulan Cycle] Mounting component ${this.$uid}`);
-        // The main render effect (legacy strings fallback / macro structure)
-        const stop = effect(() => {
-            console.log(`[Mulan Reactivity] Triggering macro-update for ${this.$uid}`);
-            this.update();
-        });
-        this._effects.push(stop);
-        this.onMount();
-    }
-    // New helper for the compiler to register a fine-grained DOM property effect
-    _bindEffect(fn, targetNode) {
-        const stop = effect(fn, targetNode);
-        this._domEffects.push(stop);
-        return stop;
-    }
-    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();
-    }
-    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;
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.muSurge = exports.muBurst = void 0;
+/**
+ * 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);
+                }
             }
-        }
-        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));
+            if (onProgress) {
+                onProgress((index / total) * 100);
+            }
+            if (index < total) {
+                requestAnimationFrame(process);
+            }
+            else {
+                resolve();
             }
         }
-        this._eventQueue = [];
-    }
-    /**
-     * Reconciles a list of bound data to an existing DOM parent segment.
-     * @param listId Unique ID for this specific mu-for directive Block
-     * @param container The DOM Element or Fragment where children are attached
-     * @param array The current state array
-     * @param keyProp The property to extract from each item to use as a unique key (e.g. 'id')
-     * @param renderRow A function that takes an item and returns a new { fragment, effects }
-     */
-    _reconcileList(listId, anchorToken, array, keyProp, renderRow) {
-        if (!this._listCaches.has(listId)) {
-            this._listCaches.set(listId, new Map());
-        }
-        const cache = this._listCaches.get(listId);
-        const newKeys = new Set();
-        const parent = anchorToken.parentNode;
-        if (!parent)
-            return;
-        // 1. Array Iteration: Match against cache or Create
-        // Use a DocumentFragment to batch new node insertions natively
-        const collectorFrag = document.createDocumentFragment();
-        const newOrderNodes = [];
-        const newOrderKeys = [];
-        let requiresSwap = false;
-        let lastCachedIndex = -1;
-        for (let i = 0; i < array.length; i++) {
-            const item = array[i];
-            const key = keyProp ? item[keyProp] : i; // fallback to index if no key
-            newKeys.add(key);
-            newOrderKeys.push(key);
-            let cached = cache.get(key);
-            if (!cached) {
-                // Not in cache, Render a brand new row structure
-                const { fragment, effects } = renderRow(item, i);
-                // Track actual DOM nodes
-                const createdNodes = Array.from(fragment.childNodes);
-                cached = { nodes: createdNodes, effects, index: i }; // Store index for fast swap detection
-                cache.set(key, cached);
-                // Batch append to our in-memory fragment!
-                // This eliminates thousands of live DOM reflows on creation.
-                collectorFrag.appendChild(fragment);
-                newOrderNodes.push(...createdNodes);
-            }
-            else {
-                // Exists in cache
-                // Batch append to the in-memory array for index tracking
-                newOrderNodes.push(...cached.nodes);
-                // Fast-Path Swap Detection: If the cached index is physically out of numerical sequence,
-                // we know the array order was unsynchronized and needs reconciliation.
-                if (cached.index < lastCachedIndex) {
-                    requiresSwap = true;
-                }
-                cached.index = i;
-                lastCachedIndex = i;
+        process();
+    });
+}
+exports.muBurst = muBurst;
+/**
+ * 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;
             }
-        }
-        // 2. Fragment Batch Insertion (O(1) Live DOM Reflow for Creations)
-        if (collectorFrag.childNodes.length > 0) {
-            parent.insertBefore(collectorFrag, anchorToken.nextSibling);
-        }
-        // 3. Bidirectional Swap Sync (O(K) isolated shifts instead of O(N) cascades)
-        if (requiresSwap) {
-            let currentSibling = anchorToken.nextSibling;
-            // We iterate through our guaranteed physical newOrderNodes list
-            for (let j = 0; j < newOrderNodes.length; j++) {
-                const targetNode = newOrderNodes[j];
-                if (targetNode !== currentSibling) {
-                    // The physical live DOM is out of sync. Move targetNode to where it belongs immediately.
-                    parent.insertBefore(targetNode, currentSibling);
+            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];
                 }
-                else {
-                    // Node is correctly positioned, simply advance the sliding logical pointer
-                    currentSibling = currentSibling.nextSibling;
+                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 });
         }
-        // 4. Cleanup Phase: Rapidly detach unmounted nodes
-        if (cache.size > newKeys.size) {
-            for (const [key, cached] of cache.entries()) {
-                if (!newKeys.has(key)) {
-                    // Remove from DOM
-                    cached.nodes.forEach((node) => {
-                        if (node.parentNode === parent) {
-                            parent.removeChild(node);
-                        }
-                    });
-                    // Stop any targeted effects tied to these nodes
-                    cached.effects.forEach((stop) => stop());
-                    // Delete from cache tracking
-                    cache.delete(key);
-                }
-            }
+    });
+}
+exports.muSurge = muSurge;
+
+
+/***/ },
+
+/***/ 234
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.persistent = void 0;
+const hooks_1 = __webpack_require__(166);
+const reactive_1 = __webpack_require__(359);
+/**
+ * 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);
+        }
+        catch (e) {
+            console.warn(`[Mulan Vault] Corrupt persistent data for key "${key}", resetting.`);
         }
     }
-    /**
-     * Reconciles a conditional block (mu-if) to an existing DOM parent segment.
-     */
-    _reconcileIf(ifId, anchorToken, condition, renderBlock) {
-        if (!this._ifCaches.has(ifId)) {
-            this._ifCaches.set(ifId, { isMounted: false, nodes: [], effects: [] });
+    // 2. Create Reactive State (Follow muState pattern for consistency)
+    const isObject = typeof startVal === 'object' && startVal !== null;
+    const state = isObject ? (0, reactive_1.reactive)(startVal) : (0, reactive_1.reactive)({ value: startVal });
+    // 3. Auto-Save on Change
+    (0, hooks_1.muEffect)(() => {
+        try {
+            const payload = isObject ? state : state.value;
+            const toSave = JSON.stringify(payload);
+            // Non-obfuscated persistence to satisfy security audits
+            storage.setItem(key, toSave);
         }
-        let cached = this._ifCaches.get(ifId);
-        if (condition) {
-            // Should be mounted
-            if (!cached.isMounted) {
-                // We need to render and mount it
-                let nodesToMount;
-                if (cached.nodes.length === 0) {
-                    // First time render
-                    const { fragment, effects } = renderBlock();
-                    nodesToMount = Array.from(fragment.childNodes);
-                    cached.nodes = nodesToMount;
-                    cached.effects = effects;
+        catch (e) {
+            console.error(`[Mulan Vault] Failed to save key "${key}"`);
+        }
+    });
+    // 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 {
-                    // Re-mounting previously cached nodes
-                    nodesToMount = cached.nodes;
+                    state.value = newVal;
                 }
-                cached.isMounted = true;
-                const parent = anchorToken.parentNode;
-                if (!parent)
-                    return;
-                const targetSibling = anchorToken.nextSibling;
-                nodesToMount.forEach(node => {
-                    parent.insertBefore(node, targetSibling);
-                });
             }
+            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;
+}
+exports.persistent = persistent;
+
+
+/***/ },
+
+/***/ 359
+(__unused_webpack_module, exports) {
+
+
+// MulanJS 2.0: Signal-Powered Reactivity Engine
+// "Compatible Surface, World-Class Engine"
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.ref = exports.reactive = exports.effect = exports.Signal = exports.nextTick = exports.queueEffect = void 0;
+let activeEffect = null;
+let activeEffectRunner = null;
+const targetMap = new WeakMap();
+// --- Mulan Quantum Scheduler (Time-Slicing) ---
+// Assign unique IDs to effects for basic topological sorting (lower IDs run first)
+let effectIdCounter = 0;
+const pendingEffects = new Set();
+let isScheduling = false;
+const TIME_BUDGET = 8; // 8ms frame budget for 60FPS lock
+function runScheduler() {
+    if (pendingEffects.size === 0) {
+        isScheduling = false;
+        return;
+    }
+    const start = typeof performance !== 'undefined' ? performance.now() : Date.now();
+    // Convert to array and sort to ensure parent effects run before children (Topological Push-Pull approximation)
+    const sortedEffects = Array.from(pendingEffects).sort((a, b) => {
+        return (a._id || 0) - (b._id || 0);
+    });
+    for (const fn of sortedEffects) {
+        pendingEffects.delete(fn);
+        fn();
+        const now = typeof performance !== 'undefined' ? performance.now() : Date.now();
+        if (now - start > TIME_BUDGET) {
+            break; // Yield to browser
+        }
+    }
+    if (pendingEffects.size > 0) {
+        if (typeof MessageChannel !== 'undefined') {
+            const channel = new MessageChannel();
+            channel.port1.onmessage = runScheduler;
+            channel.port2.postMessage(null);
         }
         else {
-            // Should NOT be mounted
-            if (cached.isMounted) {
-                // Unmount nodes but keep them in cache
-                cached.nodes.forEach(node => {
-                    if (node.parentNode) {
-                        node.parentNode.removeChild(node);
-                    }
-                });
-                cached.isMounted = false;
-                // Note: We deliberately do NOT destroy the effects here, they stay active in memory!
-            }
+            setTimeout(runScheduler, 0);
         }
     }
+    else {
+        isScheduling = false;
+    }
 }
-// Helper to create functional components wrapped in the class system
-// Helper to create functional components wrapped in the class system
-// Supports both () => render and { setup() } signatures
-function defineComponent(optionsOrSetup) {
-    return class UniversalComponent extends MuComponent {
-        constructor(container) {
-            super(container);
-            // setup() is called by super constructor
-        }
-        setup() {
-            let setupResult;
-            if (typeof optionsOrSetup === 'function') {
-                // It's a setup function returning render fn
-                setupResult = optionsOrSetup.call(this);
-            }
-            else if (typeof optionsOrSetup === 'object' && optionsOrSetup.setup) {
-                // It's an options object with setup()
-                setupResult = optionsOrSetup.setup.call(this);
-            }
-            // Handle result
-            if (typeof setupResult === 'function') {
-                // It's a render function
-                this.template = setupResult;
-            }
-            else if (setupResult && typeof setupResult === 'object') {
-                // It's bindings
-                Object.assign(this, setupResult);
-                // We assume template is assigned to prototype by compiler
-            }
+function queueEffect(fn) {
+    pendingEffects.add(fn);
+    if (!isScheduling) {
+        isScheduling = true;
+        if (typeof Promise !== 'undefined') {
+            Promise.resolve().then(runScheduler);
         }
-        template() {
-            return '';
+        else {
+            setTimeout(runScheduler, 0);
         }
-    };
+    }
 }
-
-;// ./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;
+exports.queueEffect = queueEffect;
+function nextTick() {
+    return Promise.resolve();
+}
+exports.nextTick = nextTick;
+// --- Signal Core (The Engine) ---
+class Signal {
+    constructor(initialValue) {
+        this._subscribers = new Set();
+        this._value = initialValue;
     }
-    /**
-     * 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';`;
+    get value() {
+        if (activeEffectRunner) {
+            this._subscribers.add(activeEffectRunner.run);
+        }
+        return this._value;
     }
-    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 value(newValue) {
+        if (newValue !== this._value) {
+            this._value = newValue;
+            this.notify();
+        }
     }
-    /**
-     * 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);
+    notify() {
+        this._subscribers.forEach(fn => {
+            if (fn._sync) {
+                fn();
+            }
+            else {
+                queueEffect(fn);
+            }
         });
     }
 }
-
-;// ./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) {
-        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
+exports.Signal = Signal;
+// --- Compatibility Layer (The Surface) ---
+function effect(fn, targetNode, options = {}) {
+    let stopped = false;
+    const id = ++effectIdCounter;
+    const run = () => {
+        if (stopped)
+            return;
+        const prevRunner = activeEffectRunner;
+        activeEffectRunner = { run, node: targetNode, id };
+        try {
+            fn();
+        }
+        finally {
+            activeEffectRunner = prevRunner;
+        }
+    };
+    // Attach ID for topological sorting
+    run._id = id;
+    run._sync = options.sync;
+    run();
+    return () => {
+        stopped = true;
+        pendingEffects.delete(run);
+    };
+}
+exports.effect = effect;
+function track(target, key) {
+    if (activeEffectRunner) {
+        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(activeEffectRunner.run);
     }
-    // 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;
-                }
+}
+function trigger(target, key) {
+    const depsMap = targetMap.get(target);
+    if (!depsMap)
+        return;
+    const dep = depsMap.get(key);
+    if (dep) {
+        dep.forEach((fn) => {
+            if (fn._sync) {
+                fn(); // Run synchronously if explicitly requested (e.g. for muMemo)
+            }
+            else {
+                queueEffect(fn); // Push to Quantum Scheduler
             }
-            return '<!-- 404 -->';
         });
     }
-    matchRoute(hash) {
-        // Simple exact match first
-        let route = this.routes.find((r) => r.path === hash);
-        if (route)
-            return { route, params: {} };
-        // Regex match for params e.g. /user/:id
-        for (const r of this.routes) {
-            const paramNames = [];
-            const regexPath = r.path.replace(/:([^/]+)/g, (_, key) => {
-                paramNames.push(key);
-                return '([^/]+)';
-            });
-            const match = new RegExp(`^${regexPath}$`).exec(hash);
-            if (match) {
-                const params = {};
-                paramNames.forEach((name, i) => {
-                    // SECURE: Automatically sanitize all route parameters
-                    params[name] = Security.sanitize(match[i + 1]);
-                });
-                return { route: r, params };
+}
+/**
+ * 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;
             }
-        }
-        return { route: undefined, params: {} };
-    }
-    handleRoute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isServer)
-                return;
-            const currentRouteId = ++this.lastRouteId;
-            const hash = window.location.hash.slice(1) || '/';
-            const { route, params } = this.matchRoute(hash);
-            // Security Check: Validate URL to prevent malicious hash injection
-            if (hash !== '/' && !Security.validateUrl('http://dummy.com' + hash)) {
-                console.error("Security Alert: Malformed URL detected.");
-                return;
+            track(obj, prop);
+            const val = Reflect.get(obj, prop, receiver);
+            if (val !== null && typeof val === 'object') {
+                return reactive(val);
             }
-            // 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
+            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;
             }
-            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);
-            }
-        });
+            const result = Reflect.set(obj, prop, value, receiver);
+            trigger(obj, prop);
+            return result;
+        },
+    });
+}
+exports.reactive = reactive;
+/**
+ * Creates a standalone reactive reference.
+ * Backed by the Mulan Signal Engine.
+ */
+function ref(value) {
+    return new Signal(value);
+}
+exports.ref = ref;
+
+
+/***/ },
+
+/***/ 382
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.MuInfinity = void 0;
+const MuInfinityBase = typeof HTMLElement !== 'undefined' ? HTMLElement : class {
+};
+class MuInfinity extends MuInfinityBase {
+    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);
     }
-    // [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);
-                    }
-                }
-            }
-        });
+    static get observedAttributes() {
+        return ['item-height'];
     }
-    navigate(path) {
-        if (this.isServer) {
-            this.currentPath = path;
+    attributeChangedCallback(name, oldValue, newValue) {
+        if (name === 'item-height') {
+            this._itemHeight = parseInt(newValue, 10) || 50;
+            this.renderVisible();
         }
-        else {
-            window.location.hash = path;
+    }
+    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());
     }
-}
-// --- 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;
+    disconnectedCallback() {
+        this.removeEventListener('scroll', this.onScroll);
     }
-    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';
-        }
-        static get observedAttributes() { return ['to']; }
+    set items(value) {
+        this._items = value;
+        this.renderVisible();
     }
-    customElements.define('mu-link', MuLink);
+    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;
+    }
+}
+exports.MuInfinity = MuInfinity;
+// Register
+if (typeof customElements !== 'undefined' && !customElements.get('mu-infinity')) {
+    customElements.define('mu-infinity', MuInfinity);
 }
 
-;// ./src/store/index.ts
 
+/***/ },
+
+/***/ 482
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.MuStore = void 0;
+const reactive_1 = __webpack_require__(359);
 class MuStore {
     constructor(initialState, options) {
         this.subscribers = [];
@@ -1430,16 +1391,16 @@ class MuStore {
                 console.error("Failed to load state", e);
             }
             // Auto-save effect
-            effect(() => {
+            (0, reactive_1.effect)(() => {
                 localStorage.setItem(key, JSON.stringify(this.state));
             });
         }
-        this.state = reactive(loadedState);
+        this.state = (0, reactive_1.reactive)(loadedState);
     }
     // Subscribe to changes
     subscribe(fn) {
         this.subscribers.push(fn);
-        effect(() => {
+        (0, reactive_1.effect)(() => {
             fn(this.state);
         });
     }
@@ -1454,436 +1415,445 @@ class MuStore {
         }
     }
 }
+exports.MuStore = MuStore;
 
-;// ./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());
-    });
-};
 
-function useQuery(queryFn, options = { enabled: true }) {
-    const state = reactive({
-        data: null,
-        isLoading: false,
-        error: null
-    });
-    const execute = () => query_awaiter(this, void 0, void 0, function* () {
-        state.isLoading = true;
-        state.error = null;
-        try {
-            const result = yield queryFn();
-            state.data = result;
-        }
-        catch (err) {
-            state.error = err;
-        }
-        finally {
-            state.isLoading = false;
-        }
-    });
-    if (options.enabled) {
-        // Run automatically
-        effect(() => {
-            // Basic effect wrapper to allow reactivity if queryFn relies on signals
-            execute();
+/***/ },
+
+/***/ 500
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Security = void 0;
+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;
+    }
+    /**
+     * Generates a strict Content Security Policy header value.
+     * @param options Configuration for allowed sources
+     */
+    static generateCSP(options = {}) {
+        const scriptSrc = ["'self'", ...(options.scriptSrc || [])].join(" ");
+        const styleSrc = ["'self'", "'unsafe-inline'", ...(options.styleSrc || [])].join(" ");
+        return `default-src 'self'; script-src ${scriptSrc}; style-src ${styleSrc}; object-src 'none'; base-uri 'self';`;
+    }
+    static validateUrl(url) {
+        // Basic URL validation
+        const pattern = new RegExp('^(https?:\\/\\/)?' + // protocol
+            '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|' + // domain name
+            '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR ip (v4) address
+            '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*' + // port and path
+            '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
+            '(\\#[-a-z\\d_]*)?$', 'i'); // fragment locator
+        return !!pattern.test(url);
+    }
+    /**
+     * Prevents XSS by sanitizing common input fields on blur.
+     * Can be used as a utility in forms.
+     */
+    static preventXSS(inputElement) {
+        inputElement.addEventListener('blur', (e) => {
+            const target = e.target;
+            target.value = Security.sanitize(target.value);
         });
     }
-    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 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
-    };
 }
+exports.Security = Security;
 
-;// ./src/core/quantum.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 muState({
-        value: {
-            size: n,
-            amplitudes
-        }
+/***/ },
+
+/***/ 580
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
-}
-/**
- * Backward compatible muQubit (Single Qubit Register)
- */
-function muQubit(initial = 0) {
-    const q = muRegister(1);
-    if (initial === 1) {
-        muGate(q, 'X', 0);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.createRouter = exports.MuRouter = void 0;
+const renderer_1 = __webpack_require__(619);
+const sanitizer_1 = __webpack_require__(500);
+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
+        }
     }
-    // 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
+    // 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 -->';
         });
     }
-    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;
-                }
+    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] = sanitizer_1.Security.sanitize(match[i + 1]);
+                });
+                return { route: r, params };
             }
         }
-        updateState(reg, Object.assign(Object.assign({}, state), { amplitudes: newAmps }));
-        return;
+        return { route: undefined, params: {} };
     }
-    // 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) };
+    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 !== '/' && !sanitizer_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, renderer_1.render)(html, this.rootContainer);
+                    this.currentComponent = null;
+                }
+                else {
+                    // Simple HTML string/template
+                    if (this.rootContainer)
+                        (0, renderer_1.render)(componentToRender, this.rootContainer);
+                    this.currentComponent = null; // String templates don't have lifecycle instances
+                }
             }
             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) };
+                if (this.rootContainer)
+                    (0, renderer_1.render)('<div style="text-align:center; padding:50px;"><h1>404</h1><p>Page Not Found</p></div>', this.rootContainer);
             }
-            processed.add(i);
-            processed.add(pairedIndex);
-        }
+        });
     }
-    else if (type === 'X' || type === 'CNOT') {
-        // CNOT is just Controlled-X
-        for (let i = 0; i < amplitudes.length; i++) {
-            if (!checkControl(i, 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;
+    // [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 === '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 };
-            }
+    navigate(path) {
+        if (this.isServer) {
+            this.currentPath = path;
         }
-    }
-    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 };
-            }
+        else {
+            window.location.hash = path;
         }
     }
-    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);
+exports.MuRouter = MuRouter;
+// --- 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;
+};
+exports.createRouter = createRouter;
+// --- Web Component: <mu-link> ---
+// Usage: <mu-link to="/about">About Us</mu-link>
+const MuLinkBase = typeof HTMLElement !== 'undefined' ? HTMLElement : class {
+};
+if (typeof window !== 'undefined' && !customElements.get('mu-link')) {
+    class MuLink extends MuLinkBase {
+        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);
+                    }
+                }
+            });
         }
-        else {
-            controls.push(i);
-            if (bit === 0)
-                muGate(reg, 'X', i);
+        connectedCallback() {
+            this.style.cursor = 'pointer';
+            this.style.color = 'var(--primary, #9C27B0)'; // Default to brand color if available
+            this.style.textDecoration = 'none';
         }
+        static get observedAttributes() { return ['to']; }
     }
-    // 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);
+    customElements.define('mu-link', MuLink);
 }
-/**
- * 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);
+
+
+/***/ },
+
+/***/ 598
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.useMutation = exports.useQuery = void 0;
+const reactive_1 = __webpack_require__(359);
+function useQuery(queryFn, options = { enabled: true }) {
+    const state = (0, reactive_1.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;
         }
-    }
-    // 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 };
+        catch (err) {
+            state.error = err;
         }
-        else {
-            return { re: a.re * normFactor, im: a.im * normFactor };
+        finally {
+            state.isLoading = false;
         }
     });
-    // 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).");
+    if (options.enabled) {
+        // Run automatically
+        (0, reactive_1.effect)(() => {
+            // Basic effect wrapper to allow reactivity if queryFn relies on signals
+            execute();
+        });
     }
-    // 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));
+    return {
+        get data() { return state.data; },
+        get isLoading() { return state.isLoading; },
+        get error() { return state.error; },
+        refetch: execute
+    };
 }
-/**
- * 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);
+exports.useQuery = useQuery;
+function useMutation(mutationFn) {
+    const state = (0, reactive_1.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;
         }
-    }
-}
-/**
- * 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]);
-    }
+        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
+    };
 }
+exports.useMutation = useMutation;
+
+
+/***/ },
+
+/***/ 615
+(__unused_webpack_module, exports, __webpack_require__) {
 
-;// ./src/components/bloch-sphere.ts
 
-class MuBlochSphereElement extends HTMLElement {
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.MuBlochSphereElement = void 0;
+const reactive_1 = __webpack_require__(359);
+const MuBlochBase = typeof HTMLElement !== 'undefined' ? HTMLElement : class {
+};
+class MuBlochSphereElement extends MuBlochBase {
     static get observedAttributes() {
         return ['size'];
     }
@@ -1923,7 +1893,7 @@ class MuBlochSphereElement extends HTMLElement {
         if (!this._qubit)
             return;
         // MulanJS Effect: Run whenever the qubit state changes
-        this._disposeEffect = effect(() => {
+        this._disposeEffect = (0, reactive_1.effect)(() => {
             const state = this._qubit.value; // Access reactive proxy
             if (!state || !state.amplitudes)
                 return;
@@ -2130,274 +2100,604 @@ class MuBlochSphereElement extends HTMLElement {
             this.initReactivity();
     }
 }
+exports.MuBlochSphereElement = MuBlochSphereElement;
 // 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'];
+
+/***/ },
+
+/***/ 619
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.sanitize = exports.hydrate = exports.render = void 0;
+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;
+            }
+        }
     }
-    attributeChangedCallback(name, oldValue, newValue) {
-        if (name === 'item-height') {
-            this._itemHeight = parseInt(newValue, 10) || 50;
-            this.renderVisible();
+    // [Anima] 1. Pre-Update: Snapshot positions of animated elements
+    const animationSnapshots = new Map();
+    // Only query if we might have animations to save perf
+    if (typeof template === 'string' && 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());
+            }
+        });
+    }
+    if (typeof template === 'string') {
+        container.innerHTML = template;
+    }
+    else {
+        container.innerHTML = '';
+        container.appendChild(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
+                }
+            }
         }
     }
-    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;
+    // [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 = '';
+                    });
+                }
+            }
+        });
+    }
+}
+exports.render = render;
+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 (typeof template === 'string') {
+        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.');
         }
-        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);
+    else {
+        container.innerHTML = '';
+        container.appendChild(template);
     }
-    set items(value) {
-        this._items = value;
-        this.renderVisible();
+    // Future: Attach event listeners here if we had a mechanism for it.
+}
+exports.hydrate = hydrate;
+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;
     }
-    get items() { return this._items; }
-    onScroll() {
-        requestAnimationFrame(() => this.renderVisible());
+    // Simple SSR fallback sanitizer (rudimentary)
+    return str.replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#039;");
+}
+exports.sanitize = sanitize;
+
+
+/***/ },
+
+/***/ 678
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.renderToString = void 0;
+/**
+ * Renders a Mulan component to a static HTML string with a resumability envelope.
+ */
+function renderToString(ComponentClass, props = {}) {
+    // 1. Initialize component in a virtual container (not used for DOM)
+    // On server, we mock the container or just pass a dummy object
+    const dummyContainer = {
+        querySelector: () => null,
+        querySelectorAll: () => [],
+        appendChild: () => { },
+        removeChild: () => { },
+        getAttribute: () => null
+    };
+    const instance = new ComponentClass(dummyContainer);
+    // Pass props
+    Object.assign(instance, props);
+    // 2. Render to HTML
+    if (typeof instance.renderToString !== 'function') {
+        throw new Error(`Component ${ComponentClass.name} was not compiled for SSR.`);
+    }
+    const html = instance.renderToString();
+    // 3. Extract State for Resumability
+    // We only want to serialize data that was exposed in setup()
+    // For now, we'll serialize any property on the instance that isn't internal
+    const state = {};
+    for (const key in instance) {
+        if (key.startsWith('_') || key === 'container' || key === 'state' || typeof instance[key] === 'function')
+            continue;
+        const value = instance[key];
+        // Handle signals specifically
+        if (value && typeof value === 'object' && 'value' in value) {
+            state[key] = value.value;
+        }
+        else {
+            state[key] = value;
+        }
     }
-    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>`;
+    // 4. Construct Resumability Envelope
+    const stateScript = `<script type="mulan/state" data-mu-uid="${instance.$uid}">${JSON.stringify(state)}</script>`;
+    const envelope = `<div data-mu-root="${instance.$uid}">${html}${stateScript}</div>`;
+    return {
+        html,
+        state,
+        envelope
+    };
+}
+exports.renderToString = renderToString;
+
+
+/***/ },
+
+/***/ 679
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.muSwitch = exports.muControl = exports.muParallel = exports.muMeasure = exports.muTeleport = exports.muEntangle = exports.muSearch = exports.muGate = exports.muQubit = exports.muRegister = exports.activeControls = void 0;
+const hooks_1 = __webpack_require__(166);
+/**
+ * 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
+exports.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_1.muState)({
+        value: {
+            size: n,
+            amplitudes
+        }
+    });
+}
+exports.muRegister = muRegister;
+/**
+ * Backward compatible muQubit (Single Qubit Register)
+ */
+function muQubit(initial = 0) {
+    const q = muRegister(1);
+    if (initial === 1) {
+        muGate(q, 'X', 0);
+    }
+    // Add compatibility properties for Phase 1 components
+    // These properties are getters that dynamically access the amplitudes array
+    Object.defineProperty(q.value, 'alpha', { get: () => q.value.amplitudes[0] });
+    Object.defineProperty(q.value, 'beta', { get: () => q.value.amplitudes[1] });
+    return q;
+}
+exports.muQubit = muQubit;
+/**
+ * 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
         });
-        this.content.innerHTML = html;
+        Object.defineProperty(newState, 'beta', {
+            get: () => newState.amplitudes[1],
+            configurable: true,
+            enumerable: true
+        });
+    }
+    reg.value = newState;
+}
+function muGate(reg, type, target = 0, control) {
+    const state = reg.value;
+    const n = state.size;
+    const amplitudes = state.amplitudes;
+    const newAmps = amplitudes.map(a => (Object.assign({}, a)));
+    // Prepare Effective Control (Explicit Arguments + Global Context)
+    const effectiveControl = [...(control === undefined ? [] : (Array.isArray(control) ? control : [control])), ...exports.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 (exports.activeControls.length > 0 && !checkControl(i, exports.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;
+                }
+            }
+        }
+        updateState(reg, Object.assign(Object.assign({}, state), { amplitudes: newAmps }));
+        return;
+    }
+    // Standard Single-Qubit & Controlled Gates
+    if (type === 'H') {
+        const s = 1 / Math.sqrt(2);
+        const processed = new Set();
+        for (let i = 0; i < state.amplitudes.length; i++) {
+            if (processed.has(i))
+                continue;
+            // Check Controls first
+            if (!checkControl(i, 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);
+        }
     }
+    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;
+            }
+        }
+    }
+    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 };
+            }
+        }
+    }
+    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 }));
+}
+exports.muGate = muGate;
+/**
+ * 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);
 }
-// Register
-if (typeof customElements !== 'undefined' && !customElements.get('mu-infinity')) {
-    customElements.define('mu-infinity', MuInfinity);
+exports.muSearch = muSearch;
+function muEntangle(reg, i, j) {
+    muGate(reg, 'H', i);
+    muGate(reg, 'CNOT', j, i);
 }
-
-;// ./src/core/surge.ts
+exports.muEntangle = muEntangle;
 /**
- * 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.
+ * 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 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();
-    });
+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);
 }
+exports.muTeleport = muTeleport;
 /**
- * muSurge - Truly Parallel Execution
- * Distributes work across CPU cores using Web Workers.
- * Logic must be serializable.
+ * 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 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 muMeasure(reg, target = 0) {
+    const state = reg.value;
+    const amplitudes = state.amplitudes;
+    let prob0 = 0;
+    // 1. Calculate Probability of |0>
+    for (let i = 0; i < amplitudes.length; i++) {
+        if (((i >> target) & 1) === 0) {
+            const a = amplitudes[i];
+            prob0 += (a.re * a.re) + (a.im * a.im);
+        }
+    }
+    // 2. Determine Outcome
+    const result = Math.random() < prob0 ? 0 : 1;
+    const resultProb = result === 0 ? prob0 : (1 - prob0);
+    const normFactor = resultProb > 0 ? (1 / Math.sqrt(resultProb)) : 0;
+    // 3. Collapse the State (Wavefunction Collapse)
+    const newAmps = amplitudes.map((a, i) => {
+        const bit = (i >> target) & 1;
+        if (bit !== result) {
+            return { re: 0, im: 0 };
+        }
+        else {
+            return { re: a.re * normFactor, im: a.im * normFactor };
         }
     });
+    // We need to call updateState to ensure reactivity if specialized getters exist
+    // But since this file has updateState internal, we can just call it.
+    // However, the internal updateState function needs to be in scope. 
+    // It is defined at line 60. So we are good.
+    updateState(reg, Object.assign(Object.assign({}, state), { amplitudes: newAmps }));
+    return result;
 }
-
-;// ./src/index.ts
-
-
-
-
-
-
-
-
-
-
-
-
-
-// Global Mulan Object for non-module usage
-
-
-
-
-
-
-
-
-
-
-
-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);
-    }, warn: (msg, ...args) => {
-        console.warn(`%c[MulanJS]%c ${msg}`, "color: #ffcc00; font-weight: bold; background: #222; padding: 2px 4px; border-radius: 3px;", "", ...args);
-    }, error: (msg, ...args) => {
-        console.error(`%c[MulanJS]%c ${msg}`, "color: #ff0000; font-weight: bold; background: #222; padding: 2px 4px; border-radius: 3px;", "", ...args);
-    } });
-// Security: Freeze the object to prevent runtime tampering
-Object.freeze(Mulan);
-Object.freeze(Mulan.Security);
-// MULAN INSIGHT: Initialize Global Registry
-if (typeof window !== 'undefined') {
-    window.__MULAN_INSIGHT__ = window.__MULAN_INSIGHT__ || { components: new Map() };
-    // MULAN INSIGHT: HMR Support
-    window.__MULAN_REFRESH__ = () => {
-        var _a;
-        const components = (_a = window.__MULAN_INSIGHT__) === null || _a === void 0 ? void 0 : _a.components;
-        if (components) {
-            components.forEach((comp) => {
-                if (comp && typeof comp.update === 'function') {
-                    // Force refresh
-                    comp.update();
-                }
-            });
+exports.muMeasure = muMeasure;
+/**
+ * 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));
+}
+exports.muParallel = muParallel;
+/**
+ * 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
+    }
+    exports.activeControls.push(controlQubit);
+    try {
+        block();
+    }
+    finally {
+        exports.activeControls.pop();
+        // Uncompute (Restore 0)
+        if (inverse) {
+            muGate(reg, 'X', controlQubit);
         }
-    };
+    }
 }
-if (typeof window !== 'undefined') {
-    window.Mulan = Mulan;
+exports.muControl = muControl;
+/**
+ * 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]);
+    }
 }
-/* harmony default export */ const src = (Mulan);
+exports.muSwitch = muSwitch;
+
 
-__webpack_exports__ = __webpack_exports__["default"];
+/***/ }
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// 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;
+/******/ 		}
+/******/ 		// 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].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__(156);
+/******/ 	__webpack_exports__ = __webpack_exports__["default"];
+/******/ 	
 /******/ 	return __webpack_exports__;
 /******/ })()
 ;