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

package/dist/core/hooks.js

@@ -1,24 +1,30 @@
-import { reactive, effect } from './reactive';
-import { persistent } from './vault';
+"use strict";
+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 = require("./reactive");
+const vault_1 = require("./vault");
 // Global context to track the current component instance
 let currentInstance = null;
-export function setCurrentInstance(instance) {
+function setCurrentInstance(instance) {
     currentInstance = instance;
 }
-export function getCurrentInstance() {
+exports.setCurrentInstance = setCurrentInstance;
+function getCurrentInstance() {
     return currentInstance;
 }
+exports.getCurrentInstance = getCurrentInstance;
 // --- Mulan Unique Reactivity Hooks ---
-export function muState(initialValue) {
+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 });
 }
-export function muMemo(computeFn) {
-    const signal = reactive({ value: undefined });
-    const stop = effect(() => {
+exports.muState = muState;
+function muMemo(computeFn) {
+    const signal = (0, reactive_1.reactive)({ value: undefined });
+    const stop = (0, reactive_1.effect)(() => {
         signal.value = computeFn();
     });
     const instance = getCurrentInstance();
@@ -29,8 +35,9 @@ export function muMemo(computeFn) {
     }
     return signal;
 }
-export function muEffect(fn) {
-    const stop = effect(fn);
+exports.muMemo = muMemo;
+function muEffect(fn) {
+    const stop = (0, reactive_1.effect)(fn);
     const instance = getCurrentInstance();
     if (instance) {
         if (!instance._effects)
@@ -38,8 +45,9 @@ export function muEffect(fn) {
         instance._effects.push(stop);
     }
 }
+exports.muEffect = muEffect;
 // --- The "Mulan Cycle" (Lifecycle) ---
-export function onMuInit(fn) {
+function onMuInit(fn) {
     const instance = getCurrentInstance();
     if (instance) {
         if (!instance._hooks)
@@ -52,7 +60,8 @@ export function onMuInit(fn) {
         console.warn('onMuInit called outside of component setup context.');
     }
 }
-export function onMuMount(fn) {
+exports.onMuInit = onMuInit;
+function onMuMount(fn) {
     // New hook for when component is actually in DOM (simulated for now via update)
     const instance = getCurrentInstance();
     if (instance) {
@@ -63,7 +72,8 @@ export function onMuMount(fn) {
         instance._hooks.onMuMount.push(fn);
     }
 }
-export function onMuDestroy(fn) {
+exports.onMuMount = onMuMount;
+function onMuDestroy(fn) {
     const instance = getCurrentInstance();
     if (instance) {
         if (!instance._hooks)
@@ -73,11 +83,12 @@ export 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).
  */
-export function onMuIdle(fn) {
+function onMuIdle(fn) {
     const instance = getCurrentInstance();
     // Polyfill for Safari/Old Browsers
     const requestIdleCallback = window.requestIdleCallback || function (cb) {
@@ -101,12 +112,13 @@ export function onMuIdle(fn) {
         });
     }
 }
+exports.onMuIdle = onMuIdle;
 /**
  * onMuResume - The "Tab Life" Hook.
  * Executes when the user switches BACK to this tab.
  * Perfect for refreshing data or resuming animations to save battery.
  */
-export function onMuResume(fn) {
+function onMuResume(fn) {
     const handler = () => {
         if (document.visibilityState === 'visible') {
             fn();
@@ -115,12 +127,13 @@ export 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.
  * Usage: Undo, Refresh, or "Rage Quit" easter eggs.
  */
-export function onMuShake(fn) {
+function onMuShake(fn) {
     // Threshold for shake detection
     const threshold = 15;
     let lastX = 0, lastY = 0, lastZ = 0;
@@ -153,13 +166,14 @@ export 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.
  * @param command The word to listen for (e.g., "save", "next")
  * @param fn The action to take
  */
-export function onMuVoice(command, fn) {
+function onMuVoice(command, fn) {
     const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
     if (!SpeechRecognition) {
         console.warn("[MulanJS] Voice Control (Web Speech API) not supported in this browser.");
@@ -188,11 +202,12 @@ export function onMuVoice(command, fn) {
         recognition.stop();
     });
 }
+exports.onMuVoice = onMuVoice;
 // --- "Outside The Box" Hooks (Mulan Exclusives) ---
 /**
  * muGeom - Tracks window or element dimensions reactively.
  */
-export function muGeom() {
+function muGeom() {
     const dims = muState({ width: window.innerWidth, height: window.innerHeight });
     const handler = () => {
         dims.width = window.innerWidth;
@@ -205,10 +220,11 @@ export function muGeom() {
     });
     return dims;
 }
+exports.muGeom = muGeom;
 /**
  * muPulse - Reactive network status.
  */
-export function muPulse() {
+function muPulse() {
     const status = muState({ online: navigator.onLine });
     const setOnline = () => status.online = true;
     const setOffline = () => status.online = false;
@@ -220,19 +236,21 @@ export function muPulse() {
     });
     return status;
 }
+exports.muPulse = muPulse;
 /**
  * muVault - Secure reactive LocalStorage wrapper.
  * Powered by the Iron Fortress persistent primitive.
  */
-export function muVault(key, initial, options = {}) {
-    return persistent(key, initial, Object.assign(Object.assign({}, options), { onCleanup: (fn) => onMuDestroy(fn) }));
+function muVault(key, initial, options = {}) {
+    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.
  * Natively handles async state (loading/data/error) without wrapper components.
  */
-export function muSuspense(promiseFn) {
+function muSuspense(promiseFn) {
     const state = muState({
         loading: true,
         data: null,
@@ -250,11 +268,12 @@ export function muSuspense(promiseFn) {
     });
     return state;
 }
+exports.muSuspense = muSuspense;
 /**
  * onMuVisibility - The Intersection Observer Hook.
  * Triggers when the component enters/leaves the viewport.
  */
-export function onMuVisibility(callback, options = { threshold: 0.1 }) {
+function onMuVisibility(callback, options = { threshold: 0.1 }) {
     const instance = getCurrentInstance();
     // We defer observation to mount phase to ensure DOM exists
     onMuMount(() => {
@@ -271,10 +290,11 @@ export function onMuVisibility(callback, options = { threshold: 0.1 }) {
         });
     });
 }
+exports.onMuVisibility = onMuVisibility;
 /**
  * muDebounced - High-performance debouncing built directly into a reactive signal.
  */
-export function muDebounced(initialValue, delayMs) {
+function muDebounced(initialValue, delayMs) {
     const state = muState(initialValue);
     let timeoutId;
     return {
@@ -289,10 +309,11 @@ export function muDebounced(initialValue, delayMs) {
         }
     };
 }
+exports.muDebounced = muDebounced;
 /**
  * muThrottled - High-performance throttling built directly into a reactive signal.
  */
-export function muThrottled(initialValue, delayMs) {
+function muThrottled(initialValue, delayMs) {
     const state = muState(initialValue);
     let lastRan = 0;
     return {
@@ -308,11 +329,12 @@ export function muThrottled(initialValue, delayMs) {
         }
     };
 }
+exports.muThrottled = muThrottled;
 /**
  * onMuPanic - The Iron Fortress Error Boundary.
  * Catches unhandled exceptions within the component scope.
  */
-export function onMuPanic(fallbackFn) {
+function onMuPanic(fallbackFn) {
     const instance = getCurrentInstance();
     const handler = (event) => {
         // Broad catch - in a full implementation, we'd inspect the stack trace 
@@ -331,10 +353,11 @@ export function onMuPanic(fallbackFn) {
         window.removeEventListener('unhandledrejection', handler);
     });
 }
+exports.onMuPanic = onMuPanic;
 /**
  * muHistory - State with built-in Undo/Redo tracking.
  */
-export function muHistory(initialValue) {
+function muHistory(initialValue) {
     const state = muState(initialValue);
     // Explicit wrapper object because muState treats bare arrays dynamically
     const historyTracker = muState({ log: [initialValue] });
@@ -369,3 +392,4 @@ export function muHistory(initialValue) {
         get future() { return historyTracker.log.slice(pointer.value + 1); }
     };
 }
+exports.muHistory = muHistory;

package/dist/core/quantum.js

@@ -1,32 +1,36 @@
-import { muState } from './hooks';
+"use strict";
+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 = require("./hooks");
 /**
  * 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
-export let activeControls = [];
+exports.activeControls = [];
 /**
  * Creates a quantum register of size n.
  * State vector will have 2^n amplitudes.
  */
-export function muRegister(n) {
+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({
+    return (0, hooks_1.muState)({
         value: {
             size: n,
             amplitudes
         }
     });
 }
+exports.muRegister = muRegister;
 /**
  * Backward compatible muQubit (Single Qubit Register)
  */
-export function muQubit(initial = 0) {
+function muQubit(initial = 0) {
     const q = muRegister(1);
     if (initial === 1) {
         muGate(q, 'X', 0);
@@ -37,6 +41,7 @@ export function muQubit(initial = 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
  */
@@ -56,13 +61,13 @@ function updateState(reg, newState) {
     }
     reg.value = newState;
 }
-export function muGate(reg, type, target = 0, control) {
+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];
+    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))
@@ -77,7 +82,7 @@ export function muGate(reg, type, target = 0, control) {
         // 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))
+            if (exports.activeControls.length > 0 && !checkControl(i, exports.activeControls))
                 continue;
             const bit1 = (i >> t1) & 1;
             const bit2 = (i >> t2) & 1;
@@ -167,6 +172,7 @@ export function muGate(reg, type, target = 0, control) {
     }
     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.
@@ -174,7 +180,7 @@ export function muGate(reg, type, target = 0, control) {
  * @param reg Quantum Register
  * @param targetState The integer state to "search" and mark (e.g. 2 for |10>)
  */
-export function muSearch(reg, targetState) {
+function muSearch(reg, targetState) {
     const n = reg.value.size;
     const controls = [];
     // 1. Identify which bits are 0 and need wrapping with X gates
@@ -225,10 +231,12 @@ export function muSearch(reg, targetState) {
     for (let i = 0; i < n; i++)
         muGate(reg, 'H', i);
 }
-export function muEntangle(reg, i, j) {
+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.
@@ -237,7 +245,7 @@ export function muEntangle(reg, i, j) {
  * @param ancillaIdx The helper qubit (Alice's half of entanglement)
  * @param targetIdx The destination qubit (Bob)
  */
-export function muTeleport(reg, msgIdx, ancillaIdx, targetIdx) {
+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);
@@ -254,13 +262,14 @@ export function muTeleport(reg, msgIdx, ancillaIdx, 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
  */
-export function muMeasure(reg, target = 0) {
+function muMeasure(reg, target = 0) {
     const state = reg.value;
     const amplitudes = state.amplitudes;
     let prob0 = 0;
@@ -292,6 +301,7 @@ export function muMeasure(reg, target = 0) {
     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).
@@ -300,7 +310,7 @@ export function muMeasure(reg, target = 0) {
  * @param qubits Array of qubit indices
  * @param gate Gate type to apply (e.g. 'H', 'X')
  */
-export function muParallel(reg, qubits, gate) {
+function muParallel(reg, qubits, gate) {
     if (gate === 'SWAP') {
         throw new Error("SWAP cannot be applied in parallel (requires pairs).");
     }
@@ -308,27 +318,29 @@ export function muParallel(reg, qubits, gate) {
     // 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".
  */
-export function muControl(reg, controlQubit, inverse, block) {
+function muControl(reg, controlQubit, inverse, block) {
     // 1. Setup Context
     if (inverse) {
         muGate(reg, 'X', controlQubit); // Flip 0 to 1 to activate
     }
-    activeControls.push(controlQubit);
+    exports.activeControls.push(controlQubit);
     try {
         block();
     }
     finally {
-        activeControls.pop();
+        exports.activeControls.pop();
         // Uncompute (Restore 0)
         if (inverse) {
             muGate(reg, 'X', controlQubit);
         }
     }
 }
+exports.muControl = muControl;
 /**
  * Quantum Switch: conditional Logic on Superposition
  * Executes different logic branches based on the state of control qubits.
@@ -339,7 +351,7 @@ export function muControl(reg, controlQubit, inverse, block) {
  * @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
  */
-export function muSwitch(reg, controlQubit, cases) {
+function muSwitch(reg, controlQubit, cases) {
     if (cases[0]) {
         muControl(reg, controlQubit, true, cases[0]);
     }
@@ -347,3 +359,4 @@ export function muSwitch(reg, controlQubit, cases) {
         muControl(reg, controlQubit, false, cases[1]);
     }
 }
+exports.muSwitch = muSwitch;

package/dist/core/query.js

@@ -1,3 +1,4 @@
+"use strict";
 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) {
@@ -7,9 +8,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { reactive, effect } from './reactive';
-export function useQuery(queryFn, options = { enabled: true }) {
-    const state = reactive({
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMutation = exports.useQuery = void 0;
+const reactive_1 = require("./reactive");
+function useQuery(queryFn, options = { enabled: true }) {
+    const state = (0, reactive_1.reactive)({
         data: null,
         isLoading: false,
         error: null
@@ -30,7 +33,7 @@ export function useQuery(queryFn, options = { enabled: true }) {
     });
     if (options.enabled) {
         // Run automatically
-        effect(() => {
+        (0, reactive_1.effect)(() => {
             // Basic effect wrapper to allow reactivity if queryFn relies on signals
             execute();
         });
@@ -42,8 +45,9 @@ export function useQuery(queryFn, options = { enabled: true }) {
         refetch: execute
     };
 }
-export function useMutation(mutationFn) {
-    const state = reactive({
+exports.useQuery = useQuery;
+function useMutation(mutationFn) {
+    const state = (0, reactive_1.reactive)({
         data: null,
         isLoading: false,
         error: null
@@ -71,3 +75,4 @@ export function useMutation(mutationFn) {
         mutate
     };
 }
+exports.useMutation = useMutation;

package/dist/core/reactive.js

@@ -1,10 +1,68 @@
+"use strict";
 // MulanJS 2.0: Signal-Powered Reactivity Engine
 // "Compatible Surface, World-Class Engine"
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ref = exports.reactive = exports.effect = exports.Signal = exports.nextTick = exports.queueEffect = void 0;
 let activeEffect = null;
 let activeEffectRunner = null;
 const targetMap = new WeakMap();
+// --- Mulan Quantum Scheduler (Time-Slicing) ---
+// Assign unique IDs to effects for basic topological sorting (lower IDs run first)
+let effectIdCounter = 0;
+const pendingEffects = new Set();
+let isScheduling = false;
+const TIME_BUDGET = 8; // 8ms frame budget for 60FPS lock
+function runScheduler() {
+    if (pendingEffects.size === 0) {
+        isScheduling = false;
+        return;
+    }
+    const start = typeof performance !== 'undefined' ? performance.now() : Date.now();
+    // Convert to array and sort to ensure parent effects run before children (Topological Push-Pull approximation)
+    const sortedEffects = Array.from(pendingEffects).sort((a, b) => {
+        return (a._id || 0) - (b._id || 0);
+    });
+    for (const fn of sortedEffects) {
+        pendingEffects.delete(fn);
+        fn();
+        const now = typeof performance !== 'undefined' ? performance.now() : Date.now();
+        if (now - start > TIME_BUDGET) {
+            break; // Yield to browser
+        }
+    }
+    if (pendingEffects.size > 0) {
+        if (typeof MessageChannel !== 'undefined') {
+            const channel = new MessageChannel();
+            channel.port1.onmessage = runScheduler;
+            channel.port2.postMessage(null);
+        }
+        else {
+            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);
+        }
+    }
+}
+exports.queueEffect = queueEffect;
+function nextTick() {
+    return Promise.resolve();
+}
+exports.nextTick = nextTick;
 // --- Signal Core (The Engine) ---
-export class Signal {
+class Signal {
     constructor(initialValue) {
         this._subscribers = new Set();
         this._value = initialValue;
@@ -22,17 +80,26 @@ export class Signal {
         }
     }
     notify() {
-        this._subscribers.forEach(fn => fn());
+        this._subscribers.forEach(fn => {
+            if (fn._sync) {
+                fn();
+            }
+            else {
+                queueEffect(fn);
+            }
+        });
     }
 }
+exports.Signal = Signal;
 // --- Compatibility Layer (The Surface) ---
-export 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();
         }
@@ -40,11 +107,16 @@ export 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);
     };
 }
+exports.effect = effect;
 function track(target, key) {
     if (activeEffectRunner) {
         let depsMap = targetMap.get(target);
@@ -64,14 +136,21 @@ 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
+            }
+        });
     }
 }
 /**
  * Creates a reactive proxy object (Vue-compatible).
  * Now optimized to respect Mulan Cycle.
  */
-export function reactive(target) {
+function reactive(target) {
     return new Proxy(target, {
         get(obj, prop, receiver) {
             // IRON FORTRESS: Prototype Pollution Protection (Read)
@@ -97,10 +176,12 @@ export function reactive(target) {
         },
     });
 }
+exports.reactive = reactive;
 /**
  * Creates a standalone reactive reference.
  * Backed by the Mulan Signal Engine.
  */
-export function ref(value) {
+function ref(value) {
     return new Signal(value);
 }
+exports.ref = ref;

package/dist/core/renderer.js

@@ -1,4 +1,7 @@
-export function render(template, container) {
+"use strict";
+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;
@@ -81,7 +84,8 @@ export function render(template, container) {
         });
     }
 }
-export function hydrate(template, container) {
+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.
@@ -100,12 +104,8 @@ export function hydrate(template, container) {
     }
     // Future: Attach event listeners here if we had a mechanism for it.
 }
-export function renderToString(template) {
-    // SSR Function: returns the HTML string for the server to send.
-    // Can include additional sanitization or metadata injection here.
-    return template;
-}
-export function sanitize(str) {
+exports.hydrate = hydrate;
+function sanitize(str) {
     // Check if we are in a browser environment
     if (typeof document !== 'undefined') {
         const temp = document.createElement('div');
@@ -119,3 +119,4 @@ export function sanitize(str) {
         .replace(/"/g, """)
         .replace(/'/g, "'");
 }
+exports.sanitize = sanitize;