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

package/dist/mulan.esm.js

@@ -1,417 +1,504 @@
-/******/ // 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__ = {};
-
-// 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/core/surge.ts
-var surge_namespaceObject = {};
-__webpack_require__.r(surge_namespaceObject);
-__webpack_require__.d(surge_namespaceObject, {
-  muBurst: () => (muBurst),
-  muSurge: () => (muSurge)
-});
+/***/ 37
+(__unused_webpack_module, exports, __webpack_require__) {
 
-// NAMESPACE OBJECT: ./src/components/infinity-list.ts
-var infinity_list_namespaceObject = {};
-__webpack_require__.r(infinity_list_namespaceObject);
-__webpack_require__.d(infinity_list_namespaceObject, {
-  MuInfinity: () => (MuInfinity)
-});
 
-;// ./src/core/reactive.ts
-// MulanJS 2.0: Signal-Powered Reactivity Engine
-// "Compatible Surface, World-Class Engine"
-let activeEffect = null;
-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();
+    }
+    flushProps() {
+        for (const [id, prop, value] of this._propsQueue) {
+            const el = this.container.querySelector(`[data-mu-id="${id}"]`);
+            if (el) {
+                // @ts-ignore
+                el[prop] = value;
             }
         }
+        this._propsQueue = [];
     }
-    // [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());
+    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 = [];
     }
-    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;
+    /**
+     * 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);
             }
-            el.focus();
-            if ((el instanceof HTMLInputElement || el instanceof HTMLTextAreaElement) && selectionStart !== null) {
-                try {
-                    el.setSelectionRange(selectionStart, selectionEnd);
+            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;
                 }
-                catch (e) {
-                    // input types that don't support selection (e.g. number/email) might throw
+                cached.index = i;
+                lastCachedIndex = i;
+            }
+        }
+        // 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);
+                }
+                else {
+                    // Node is correctly positioned, simply advance the sliding logical pointer
+                    currentSibling = currentSibling.nextSibling;
                 }
             }
         }
-    }
-    // [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 = '';
+        // 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);
                 }
             }
-        });
-    }
-}
-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.');
-        }
-    }
-    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);
-        }
-        catch (e) {
-            console.warn(`[Mulan Vault] Corrupt persistent data for key "${key}", resetting.`);
         }
     }
-    // 2. Create Reactive State (Follow muState pattern for consistency)
-    const isObject = typeof startVal === 'object' && startVal !== null;
-    const state = isObject ? reactive(startVal) : reactive({ value: startVal });
-    // 3. Auto-Save on Change
-    muEffect(() => {
-        try {
-            const payload = isObject ? state : state.value;
-            const 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
-
-
-// Global context to track the current component instance
-let currentInstance = null;
-function setCurrentInstance(instance) {
-    currentInstance = instance;
 }
+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();
@@ -422,8 +509,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)
@@ -431,6 +519,7 @@ function muEffect(fn) {
         instance._effects.push(stop);
     }
 }
+exports.muEffect = muEffect;
 // --- The "Mulan Cycle" (Lifecycle) ---
 function onMuInit(fn) {
     const instance = getCurrentInstance();
@@ -445,6 +534,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();
@@ -456,6 +546,7 @@ function onMuMount(fn) {
         instance._hooks.onMuMount.push(fn);
     }
 }
+exports.onMuMount = onMuMount;
 function onMuDestroy(fn) {
     const instance = getCurrentInstance();
     if (instance) {
@@ -466,6 +557,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).
@@ -494,6 +586,7 @@ function onMuIdle(fn) {
         });
     }
 }
+exports.onMuIdle = onMuIdle;
 /**
  * onMuResume - The "Tab Life" Hook.
  * Executes when the user switches BACK to this tab.
@@ -508,6 +601,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.
@@ -546,6 +640,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.
@@ -581,6 +676,7 @@ function onMuVoice(command, fn) {
         recognition.stop();
     });
 }
+exports.onMuVoice = onMuVoice;
 // --- "Outside The Box" Hooks (Mulan Exclusives) ---
 /**
  * muGeom - Tracks window or element dimensions reactively.
@@ -598,6 +694,7 @@ function muGeom() {
     });
     return dims;
 }
+exports.muGeom = muGeom;
 /**
  * muPulse - Reactive network status.
  */
@@ -613,13 +710,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.
@@ -643,6 +742,7 @@ function muSuspense(promiseFn) {
     });
     return state;
 }
+exports.muSuspense = muSuspense;
 /**
  * onMuVisibility - The Intersection Observer Hook.
  * Triggers when the component enters/leaves the viewport.
@@ -664,6 +764,7 @@ function onMuVisibility(callback, options = { threshold: 0.1 }) {
         });
     });
 }
+exports.onMuVisibility = onMuVisibility;
 /**
  * muDebounced - High-performance debouncing built directly into a reactive signal.
  */
@@ -682,6 +783,7 @@ function muDebounced(initialValue, delayMs) {
         }
     };
 }
+exports.muDebounced = muDebounced;
 /**
  * muThrottled - High-performance throttling built directly into a reactive signal.
  */
@@ -701,6 +803,7 @@ function muThrottled(initialValue, delayMs) {
         }
     };
 }
+exports.muThrottled = muThrottled;
 /**
  * onMuPanic - The Iron Fortress Error Boundary.
  * Catches unhandled exceptions within the component scope.
@@ -724,6 +827,7 @@ function onMuPanic(fallbackFn) {
         window.removeEventListener('unhandledrejection', handler);
     });
 }
+exports.onMuPanic = onMuPanic;
 /**
  * muHistory - State with built-in Undo/Redo tracking.
  */
@@ -762,638 +866,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);
-                });
-            }
-        }
-        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;
 }
-// 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
+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
         }
-        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
-            }
+    }
+    if (pendingEffects.size > 0) {
+        if (typeof MessageChannel !== 'undefined') {
+            const channel = new MessageChannel();
+            channel.port1.onmessage = runScheduler;
+            channel.port2.postMessage(null);
         }
-        template() {
-            return '';
+        else {
+            setTimeout(runScheduler, 0);
         }
-    };
+    }
+    else {
+        isScheduling = false;
+    }
 }
-
-;// ./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;
+function queueEffect(fn) {
+    pendingEffects.add(fn);
+    if (!isScheduling) {
+        isScheduling = true;
+        if (typeof Promise !== 'undefined') {
+            Promise.resolve().then(runScheduler);
+        }
+        else {
+            setTimeout(runScheduler, 0);
+        }
     }
-    /**
-     * 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';`;
+}
+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;
     }
-    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);
+    get value() {
+        if (activeEffectRunner) {
+            this._subscribers.add(activeEffectRunner.run);
+        }
+        return this._value;
     }
-    /**
-     * 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);
+    set value(newValue) {
+        if (newValue !== this._value) {
+            this._value = newValue;
+            this.notify();
+        }
+    }
+    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 = [];
@@ -1411,16 +1379,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);
         });
     }
@@ -1435,556 +1403,476 @@ 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;
         }
+        catch (err) {
+            state.error = err;
+        }
+        finally {
+            state.isLoading = false;
+        }
+    });
+    if (options.enabled) {
+        // Run automatically
+        (0, reactive_1.effect)(() => {
+            // Basic effect wrapper to allow reactivity if queryFn relies on signals
+            execute();
+        });
     }
-    // 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 };
+    return {
+        get data() { return state.data; },
+        get isLoading() { return state.isLoading; },
+        get error() { return state.error; },
+        refetch: execute
+    };
+}
+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;
         }
-        else {
-            return { re: a.re * normFactor, im: a.im * normFactor };
+        catch (err) {
+            state.error = err;
+            throw err;
+        }
+        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;
+    return {
+        get data() { return state.data; },
+        get isLoading() { return state.isLoading; },
+        get error() { return state.error; },
+        mutate
+    };
 }
-/**
- * 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).");
+exports.useMutation = useMutation;
+
+
+/***/ },
+
+/***/ 615
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+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'];
     }
-    // In a real quantum computer, these happen at t=0.
-    // Here, we loop, but logical time is constant.
-    qubits.forEach(q => muGate(reg, gate, q));
-}
-/**
- * Applies a block of operations controlled by specific qubits.
- * Enables "Quantum If/Else".
- */
-function muControl(reg, controlQubit, inverse, block) {
-    // 1. Setup Context
-    if (inverse) {
-        muGate(reg, 'X', controlQubit); // Flip 0 to 1 to activate
+    constructor() {
+        super();
+        this._arrow = null;
+        this._container = null;
+        this._disposeEffect = null;
+        this.attachShadow({ mode: 'open' });
     }
-    activeControls.push(controlQubit);
-    try {
-        block();
+    connectedCallback() {
+        this.render();
     }
-    finally {
-        activeControls.pop();
-        // Uncompute (Restore 0)
-        if (inverse) {
-            muGate(reg, 'X', controlQubit);
+    disconnectedCallback() {
+        if (this._disposeEffect) {
+            this._disposeEffect();
+            this._disposeEffect = null;
         }
     }
-}
-/**
- * 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]);
+    // Property setter for 'qubit' (passed as .qubit="${q}" in Mulan)
+    set qubit(val) {
+        this._qubit = val;
+        this.initReactivity();
     }
-    if (cases[1]) {
-        muControl(reg, controlQubit, false, cases[1]);
+    get qubit() {
+        return this._qubit;
     }
-}
-
-;// ./src/core/surge.ts
-/**
- * muBurst - Adaptive Non-blocking Iterator
- * Processes large arrays in batches within a frame budget (typically 8-16ms)
- * to keep the UI responsive while executing at near-native loop speeds.
- */
-function muBurst(array, callback, options = {}) {
-    const { chunkSize = 1000, timeout = 8, onProgress } = options;
-    return new Promise((resolve) => {
-        let index = 0;
-        const total = array.length;
-        function process() {
-            const start = performance.now();
-            // Tight loop for high-speed processing
-            while (index < total && (performance.now() - start) < timeout) {
-                // Process in smaller bursts to allow more frequent time checks if needed
-                const endBurst = Math.min(index + chunkSize, total);
-                for (; index < endBurst; index++) {
-                    callback(array[index], index);
-                }
-            }
-            if (onProgress) {
-                onProgress((index / total) * 100);
-            }
-            if (index < total) {
-                requestAnimationFrame(process);
-            }
-            else {
-                resolve();
-            }
-        }
-        process();
-    });
-}
-/**
- * muSurge - Truly Parallel Execution
- * Distributes work across CPU cores using Web Workers.
- * Logic must be serializable.
- */
-function muSurge(array, taskFn, onProgress) {
-    const n = navigator.hardwareConcurrency || 4;
-    const chunkSize = Math.ceil(array.length / n);
-    const results = new Array(array.length);
-    let completedChunks = 0;
-    let completedItems = 0;
-    // Convert function to string if it isn't already
-    const fnStr = typeof taskFn === 'function' ? taskFn.toString() : taskFn;
-    const workerPart1 = `const taskFn = ${fnStr};`;
-    const workerPart2 = `self.onmessage = function(e) {`;
-    const workerPart3 = `  const { chunk, startIndex } = e.data;`;
-    const workerPart4 = `  try { const results = chunk.map(taskFn); self.postMessage({ results, startIndex }); }`;
-    const workerPart5 = `  catch (err) { self.postMessage({ error: err.message, startIndex }); }`;
-    const workerPart6 = `};`;
-    const workerCode = [workerPart1, workerPart2, workerPart3, workerPart4, workerPart5, workerPart6].join('\n');
-    const blob = new Blob([workerCode], { type: 'application/javascript' });
-    const workerUrl = URL.createObjectURL(blob);
-    return new Promise((resolve) => {
-        if (array.length === 0)
-            return resolve([]);
-        for (let i = 0; i < n; i++) {
-            const start = i * chunkSize;
-            const end = Math.min(start + chunkSize, array.length);
-            if (start >= end) {
-                completedChunks++;
-                continue;
-            }
-            const chunk = array.slice(start, end);
-            const worker = new Worker(workerUrl);
-            worker.onmessage = (e) => {
-                const { results: chunkResults, startIndex } = e.data;
-                // Merge results back into main array
-                for (let j = 0; j < chunkResults.length; j++) {
-                    results[startIndex + j] = chunkResults[j];
-                }
-                completedChunks++;
-                completedItems += chunkResults.length;
-                if (onProgress)
-                    onProgress((completedItems / array.length) * 100);
-                worker.terminate();
-                if (completedChunks === n) {
-                    URL.revokeObjectURL(workerUrl);
-                    resolve(results);
-                }
-            };
-            worker.postMessage({ chunk, startIndex: start, fnStr });
-        }
-    });
-}
-
-;// ./src/components/bloch-sphere.ts
-
-class MuBlochSphereElement extends HTMLElement {
-    static get observedAttributes() {
-        return ['size'];
-    }
-    constructor() {
-        super();
-        this._arrow = null;
-        this._container = null;
-        this._disposeEffect = null;
-        this.attachShadow({ mode: 'open' });
-    }
-    connectedCallback() {
-        this.render();
-    }
-    disconnectedCallback() {
-        if (this._disposeEffect) {
-            this._disposeEffect();
-            this._disposeEffect = null;
-        }
-    }
-    // Property setter for 'qubit' (passed as .qubit="${q}" in Mulan)
-    set qubit(val) {
-        this._qubit = val;
-        this.initReactivity();
-    }
-    get qubit() {
-        return this._qubit;
-    }
-    attributeChangedCallback(name, oldValue, newValue) {
-        if (name === 'size' && this._container) {
-            this._container.style.width = newValue + 'px';
-            this._container.style.height = newValue + 'px';
+    attributeChangedCallback(name, oldValue, newValue) {
+        if (name === 'size' && this._container) {
+            this._container.style.width = newValue + 'px';
+            this._container.style.height = newValue + 'px';
         }
     }
     initReactivity() {
@@ -1993,7 +1881,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;
@@ -2200,184 +2088,603 @@ 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);
+
+/***/ },
+
+/***/ 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;
+            }
+        }
     }
-    static get observedAttributes() {
-        return ['item-height'];
+    // [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
+                }
+            }
+        }
+    }
+    // [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.');
+        }
+    }
+    else {
+        container.innerHTML = '';
+        container.appendChild(template);
+    }
+    // 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;
+    }
+    // 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;
+        }
+    }
+    // 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
+        });
+        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);
     }
-    attributeChangedCallback(name, oldValue, newValue) {
-        if (name === 'item-height') {
-            this._itemHeight = parseInt(newValue, 10) || 50;
-            this.renderVisible();
+    // --- 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);
+}
+exports.muSearch = muSearch;
+function muEntangle(reg, i, j) {
+    muGate(reg, 'H', i);
+    muGate(reg, 'CNOT', j, i);
+}
+exports.muEntangle = muEntangle;
+/**
+ * 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);
+}
+exports.muTeleport = muTeleport;
+/**
+ * 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);
         }
     }
-    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;
+    // 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 };
         }
-        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 {
+            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;
+}
+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).");
     }
-    set items(value) {
-        this._items = value;
-        this.renderVisible();
+    // 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
     }
-    get items() { return this._items; }
-    onScroll() {
-        requestAnimationFrame(() => this.renderVisible());
+    exports.activeControls.push(controlQubit);
+    try {
+        block();
     }
-    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;
+    finally {
+        exports.activeControls.pop();
+        // Uncompute (Restore 0)
+        if (inverse) {
+            muGate(reg, 'X', controlQubit);
+        }
     }
 }
-// Register
-if (typeof customElements !== 'undefined' && !customElements.get('mu-infinity')) {
-    customElements.define('mu-infinity', MuInfinity);
+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]);
+    }
 }
+exports.muSwitch = muSwitch;
 
-;// ./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();
-                }
-            });
-        }
-    };
-}
-if (typeof window !== 'undefined') {
-    window.Mulan = Mulan;
-}
-/* harmony default export */ const src = (Mulan);
-
-export { MuComponent as Component, MuBlochSphereElement, MuComponent, MuInfinity, MuRouter, MuStore, MuRouter as Router, Security, Signal, activeControls, src as default, defineComponent, effect, getCurrentInstance, hydrate, muBurst, muControl, 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 };
+/******/ });
+/************************************************************************/
+/******/ // 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);
+/******/ export { __webpack_exports__ as default };
+/******/ 
 
 //# sourceMappingURL=mulan.esm.js.map