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

package/dist/core/ssr.js

@@ -0,0 +1,50 @@
+"use strict";
+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;

package/dist/core/surge.js

@@ -1,9 +1,12 @@
+"use strict";
+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.
  */
-export function muBurst(array, callback, options = {}) {
+function muBurst(array, callback, options = {}) {
     const { chunkSize = 1000, timeout = 8, onProgress } = options;
     return new Promise((resolve) => {
         let index = 0;
@@ -31,12 +34,13 @@ export function muBurst(array, callback, options = {}) {
         process();
     });
 }
+exports.muBurst = muBurst;
 /**
  * muSurge - Truly Parallel Execution
  * Distributes work across CPU cores using Web Workers.
  * Logic must be serializable.
  */
-export function muSurge(array, taskFn, onProgress) {
+function muSurge(array, taskFn, onProgress) {
     const n = navigator.hardwareConcurrency || 4;
     const chunkSize = Math.ceil(array.length / n);
     const results = new Array(array.length);
@@ -85,3 +89,4 @@ export function muSurge(array, taskFn, onProgress) {
         }
     });
 }
+exports.muSurge = muSurge;

package/dist/core/vault.js

@@ -1,9 +1,12 @@
-import { muEffect } from './hooks';
-import { reactive } from './reactive';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.persistent = void 0;
+const hooks_1 = require("./hooks");
+const reactive_1 = require("./reactive");
 /**
  * Mulan Vault: The World's First Native Persistent State Primitive.
  */
-export function persistent(key, initialValue, options = {}) {
+function persistent(key, initialValue, options = {}) {
     const storage = options.storage || window.localStorage;
     // 1. Load from Storage
     const stored = storage.getItem(key);
@@ -18,9 +21,9 @@ export function persistent(key, initialValue, options = {}) {
     }
     // 2. Create Reactive State (Follow muState pattern for consistency)
     const isObject = typeof startVal === 'object' && startVal !== null;
-    const state = isObject ? reactive(startVal) : reactive({ value: startVal });
+    const state = isObject ? (0, reactive_1.reactive)(startVal) : (0, reactive_1.reactive)({ value: startVal });
     // 3. Auto-Save on Change
-    muEffect(() => {
+    (0, hooks_1.muEffect)(() => {
         try {
             const payload = isObject ? state : state.value;
             const toSave = JSON.stringify(payload);
@@ -55,3 +58,4 @@ export function persistent(key, initialValue, options = {}) {
     }
     return state;
 }
+exports.persistent = persistent;

package/dist/index.js

@@ -1,30 +1,66 @@
-export * from './core/reactive';
-export { MuComponent, MuComponent as Component, defineComponent } from './core/component';
-export * from './core/renderer';
-export { MuRouter, MuRouter as Router } from './router/index';
-export { MuStore } from './store/index';
-export * from './security/sanitizer';
-export * from './core/hooks';
-export * from './core/query';
-export * from './core/vault';
-export * from './core/quantum';
-export * from './core/surge';
-export * from './components/bloch-sphere';
-export * from './components/infinity-list';
+"use strict";
+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(require("./core/reactive"), exports);
+var component_1 = require("./core/component");
+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(require("./core/renderer"), exports);
+var index_1 = require("./router/index");
+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 = require("./store/index");
+Object.defineProperty(exports, "MuStore", { enumerable: true, get: function () { return index_2.MuStore; } });
+__exportStar(require("./security/sanitizer"), exports);
+__exportStar(require("./core/hooks"), exports);
+__exportStar(require("./core/query"), exports);
+__exportStar(require("./core/vault"), exports);
+__exportStar(require("./core/quantum"), exports);
+__exportStar(require("./core/surge"), exports);
+__exportStar(require("./components/bloch-sphere"), exports);
+__exportStar(require("./components/infinity-list"), exports);
+__exportStar(require("./core/ssr"), exports);
 // Global Mulan Object for non-module usage
-import { reactive, effect } from './core/reactive';
-import { MuComponent, defineComponent } from './core/component';
-import { MuRouter, createRouter } from './router/index';
-import { MuStore } from './store/index';
-import { Security } from './security/sanitizer';
-import * as Hooks from './core/hooks';
-import * as Query from './core/query';
-import { render } from './core/renderer';
-import * as Quantum from './core/quantum';
-import * as Surge from './core/surge';
-import * as InfinityList from './components/infinity-list';
-const Mulan = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ reactive,
-    effect, Component: MuComponent, defineComponent, Router: MuRouter, createRouter, Store: MuStore, Security: Security }, Hooks), Query), Quantum), Surge), InfinityList), { render, 
+const reactive_1 = require("./core/reactive");
+const component_2 = require("./core/component");
+const index_3 = require("./router/index");
+const index_4 = require("./store/index");
+const sanitizer_1 = require("./security/sanitizer");
+const Hooks = __importStar(require("./core/hooks"));
+const Query = __importStar(require("./core/query"));
+const renderer_1 = require("./core/renderer");
+const Quantum = __importStar(require("./core/quantum"));
+const Surge = __importStar(require("./core/surge"));
+const InfinityList = __importStar(require("./components/infinity-list"));
+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);
@@ -56,4 +92,4 @@ if (typeof window !== 'undefined') {
 if (typeof window !== 'undefined') {
     window.Mulan = Mulan;
 }
-export default Mulan;
+exports.default = Mulan;

package/dist/mulan.esm.js

@@ -106,6 +106,59 @@ __webpack_require__.d(infinity_list_namespaceObject, {
 let activeEffect = null;
 let activeEffectRunner = null;
 const targetMap = new WeakMap();
+// --- Mulan Quantum Scheduler (Time-Slicing) ---
+// Assign unique IDs to effects for basic topological sorting (lower IDs run first)
+let effectIdCounter = 0;
+const pendingEffects = new Set();
+let isScheduling = false;
+const TIME_BUDGET = 8; // 8ms frame budget for 60FPS lock
+function runScheduler() {
+    if (pendingEffects.size === 0) {
+        isScheduling = false;
+        return;
+    }
+    const start = typeof performance !== 'undefined' ? performance.now() : Date.now();
+    // Convert to array and sort to ensure parent effects run before children (Topological Push-Pull approximation)
+    const sortedEffects = Array.from(pendingEffects).sort((a, b) => {
+        return (a._id || 0) - (b._id || 0);
+    });
+    for (const fn of sortedEffects) {
+        pendingEffects.delete(fn);
+        fn();
+        const now = typeof performance !== 'undefined' ? performance.now() : Date.now();
+        if (now - start > TIME_BUDGET) {
+            break; // Yield to browser
+        }
+    }
+    if (pendingEffects.size > 0) {
+        if (typeof MessageChannel !== 'undefined') {
+            const channel = new MessageChannel();
+            channel.port1.onmessage = runScheduler;
+            channel.port2.postMessage(null);
+        }
+        else {
+            setTimeout(runScheduler, 0);
+        }
+    }
+    else {
+        isScheduling = false;
+    }
+}
+function queueEffect(fn) {
+    pendingEffects.add(fn);
+    if (!isScheduling) {
+        isScheduling = true;
+        if (typeof Promise !== 'undefined') {
+            Promise.resolve().then(runScheduler);
+        }
+        else {
+            setTimeout(runScheduler, 0);
+        }
+    }
+}
+function nextTick() {
+    return Promise.resolve();
+}
 // --- Signal Core (The Engine) ---
 class Signal {
     constructor(initialValue) {
@@ -125,17 +178,25 @@ class Signal {
         }
     }
     notify() {
-        this._subscribers.forEach(fn => fn());
+        this._subscribers.forEach(fn => {
+            if (fn._sync) {
+                fn();
+            }
+            else {
+                queueEffect(fn);
+            }
+        });
     }
 }
 // --- Compatibility Layer (The Surface) ---
-function effect(fn, targetNode) {
+function effect(fn, targetNode, options = {}) {
     let stopped = false;
+    const id = ++effectIdCounter;
     const run = () => {
         if (stopped)
             return;
         const prevRunner = activeEffectRunner;
-        activeEffectRunner = { run, node: targetNode };
+        activeEffectRunner = { run, node: targetNode, id };
         try {
             fn();
         }
@@ -143,9 +204,13 @@ function effect(fn, targetNode) {
             activeEffectRunner = prevRunner;
         }
     };
+    // Attach ID for topological sorting
+    run._id = id;
+    run._sync = options.sync;
     run();
     return () => {
         stopped = true;
+        pendingEffects.delete(run);
     };
 }
 function track(target, key) {
@@ -167,7 +232,14 @@ function trigger(target, key) {
         return;
     const dep = depsMap.get(key);
     if (dep) {
-        dep.forEach((fn) => fn());
+        dep.forEach((fn) => {
+            if (fn._sync) {
+                fn(); // Run synchronously if explicitly requested (e.g. for muMemo)
+            }
+            else {
+                queueEffect(fn); // Push to Quantum Scheduler
+            }
+        });
     }
 }
 /**
@@ -311,11 +383,6 @@ function hydrate(template, container) {
     }
     // 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') {
@@ -775,6 +842,8 @@ class MuComponent {
         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) ---
@@ -786,6 +855,26 @@ class MuComponent {
         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);
+                    }
+                }
+            }
+        }
         // MULAN INSIGHT: Global Registry for Debugging
         if (typeof window !== 'undefined') {
             const global = window;
@@ -846,14 +935,38 @@ class MuComponent {
     }
     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);
+        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();
+        }
+        else {
+            // Standard Hydration/Mount
+            const stop = effect(() => {
+                console.log(`[Mulan Reactivity] Triggering macro-update for ${this.$uid}`);
+                this.update();
+            });
+            this._effects.push(stop);
+        }
         this.onMount();
     }
+    /**
+     * 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();
+    }
     // New helper for the compiler to register a fine-grained DOM property effect
     _bindEffect(fn, targetNode) {
         const stop = effect(fn, targetNode);
@@ -1349,8 +1462,10 @@ const createRouter = (options) => {
 };
 // --- 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 HTMLElement {
+    class MuLink extends MuLinkBase {
         constructor() {
             super();
             this.addEventListener('click', (e) => {
@@ -1953,7 +2068,9 @@ function muSurge(array, taskFn, onProgress) {
 
 ;// ./src/components/bloch-sphere.ts
 
-class MuBlochSphereElement extends HTMLElement {
+const MuBlochBase = typeof HTMLElement !== 'undefined' ? HTMLElement : class {
+};
+class MuBlochSphereElement extends MuBlochBase {
     static get observedAttributes() {
         return ['size'];
     }
@@ -2206,7 +2323,9 @@ if (typeof customElements !== 'undefined') {
 }
 
 ;// ./src/components/infinity-list.ts
-class MuInfinity extends HTMLElement {
+const MuInfinityBase = typeof HTMLElement !== 'undefined' ? HTMLElement : class {
+};
+class MuInfinity extends MuInfinityBase {
     constructor() {
         super();
         this._items = [];
@@ -2317,6 +2436,54 @@ if (typeof customElements !== 'undefined' && !customElements.get('mu-infinity'))
     customElements.define('mu-infinity', MuInfinity);
 }
 
+;// ./src/core/ssr.ts
+/**
+ * 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
+    };
+}
+
 ;// ./src/index.ts
 
 
@@ -2331,6 +2498,7 @@ if (typeof customElements !== 'undefined' && !customElements.get('mu-infinity'))
 
 
 
+
 // Global Mulan Object for non-module usage
 
 
@@ -2378,6 +2546,6 @@ if (typeof window !== 'undefined') {
 }
 /* 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 };
+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, nextTick, onMuDestroy, onMuIdle, onMuInit, onMuMount, onMuPanic, onMuResume, onMuShake, onMuVisibility, onMuVoice, persistent, queueEffect, reactive, ref, render, renderToString, sanitize, setCurrentInstance, useMutation, useQuery };
 
 //# sourceMappingURL=mulan.esm.js.map