@volynets/reflex-store 0.0.0-stage → 0.0.2

package/dist/chunks/compiler-Dsb3E2ck.js

@@ -0,0 +1,2516 @@
+import require$$0 from 'util';
+import require$$1 from 'fs';
+
+class CompiledStoreTransformError extends Error {
+    constructor(diagnostics){
+        super(diagnostics.map((diagnostic)=>diagnostic.message).join("\n"));
+        this.name = "CompiledStoreTransformError";
+        this.diagnostics = diagnostics;
+    }
+}
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var wasm = {exports: {}};
+
+wasm.exports;
+
+var hasRequiredWasm;
+
+function requireWasm () {
+	if (hasRequiredWasm) return wasm.exports;
+	hasRequiredWasm = 1;
+	(function (module) {
+		let imports = {};
+		imports['__wbindgen_placeholder__'] = module.exports;
+		let wasm;
+		const { TextEncoder, TextDecoder } = require$$0;
+		const heap = new Array(128).fill(undefined);
+		heap.push(undefined, null, true, false);
+		function getObject(idx) {
+		    return heap[idx];
+		}
+		let WASM_VECTOR_LEN = 0;
+		let cachedUint8ArrayMemory0 = null;
+		function getUint8ArrayMemory0() {
+		    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+		        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+		    }
+		    return cachedUint8ArrayMemory0;
+		}
+		let cachedTextEncoder = new TextEncoder('utf-8');
+		const encodeString = typeof cachedTextEncoder.encodeInto === 'function' ? function(arg, view) {
+		    return cachedTextEncoder.encodeInto(arg, view);
+		} : function(arg, view) {
+		    const buf = cachedTextEncoder.encode(arg);
+		    view.set(buf);
+		    return {
+		        read: arg.length,
+		        written: buf.length
+		    };
+		};
+		function passStringToWasm0(arg, malloc, realloc) {
+		    if (realloc === undefined) {
+		        const buf = cachedTextEncoder.encode(arg);
+		        const ptr = malloc(buf.length, 1) >>> 0;
+		        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+		        WASM_VECTOR_LEN = buf.length;
+		        return ptr;
+		    }
+		    let len = arg.length;
+		    let ptr = malloc(len, 1) >>> 0;
+		    const mem = getUint8ArrayMemory0();
+		    let offset = 0;
+		    for(; offset < len; offset++){
+		        const code = arg.charCodeAt(offset);
+		        if (code > 0x7F) break;
+		        mem[ptr + offset] = code;
+		    }
+		    if (offset !== len) {
+		        if (offset !== 0) {
+		            arg = arg.slice(offset);
+		        }
+		        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+		        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+		        const ret = encodeString(arg, view);
+		        offset += ret.written;
+		        ptr = realloc(ptr, len, offset, 1) >>> 0;
+		    }
+		    WASM_VECTOR_LEN = offset;
+		    return ptr;
+		}
+		let cachedDataViewMemory0 = null;
+		function getDataViewMemory0() {
+		    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+		        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+		    }
+		    return cachedDataViewMemory0;
+		}
+		let heap_next = heap.length;
+		function addHeapObject(obj) {
+		    if (heap_next === heap.length) heap.push(heap.length + 1);
+		    const idx = heap_next;
+		    heap_next = heap[idx];
+		    heap[idx] = obj;
+		    return idx;
+		}
+		function handleError(f, args) {
+		    try {
+		        return f.apply(this, args);
+		    } catch (e) {
+		        wasm.__wbindgen_export_2(addHeapObject(e));
+		    }
+		}
+		let cachedTextDecoder = new TextDecoder('utf-8', {
+		    ignoreBOM: true,
+		    fatal: true
+		});
+		cachedTextDecoder.decode();
+		function getStringFromWasm0(ptr, len) {
+		    ptr = ptr >>> 0;
+		    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+		}
+		function getCachedStringFromWasm0(ptr, len) {
+		    if (ptr === 0) {
+		        return getObject(len);
+		    } else {
+		        return getStringFromWasm0(ptr, len);
+		    }
+		}
+		function getArrayU8FromWasm0(ptr, len) {
+		    ptr = ptr >>> 0;
+		    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+		}
+		function dropObject(idx) {
+		    if (idx < 132) return;
+		    heap[idx] = heap_next;
+		    heap_next = idx;
+		}
+		function takeObject(idx) {
+		    const ret = getObject(idx);
+		    dropObject(idx);
+		    return ret;
+		}
+		function isLikeNone(x) {
+		    return x === undefined || x === null;
+		}
+		const CLOSURE_DTORS = typeof FinalizationRegistry === 'undefined' ? {
+		    register: ()=>{},
+		    unregister: ()=>{}
+		} : new FinalizationRegistry((state)=>{
+		    wasm.__wbindgen_export_4.get(state.dtor)(state.a, state.b);
+		});
+		function makeMutClosure(arg0, arg1, dtor, f) {
+		    const state = {
+		        a: arg0,
+		        b: arg1,
+		        cnt: 1,
+		        dtor
+		    };
+		    const real = (...args)=>{
+		        // First up with a closure we increment the internal reference
+		        // count. This ensures that the Rust closure environment won't
+		        // be deallocated while we're invoking it.
+		        state.cnt++;
+		        const a = state.a;
+		        state.a = 0;
+		        try {
+		            return f(a, state.b, ...args);
+		        } finally{
+		            if (--state.cnt === 0) {
+		                wasm.__wbindgen_export_4.get(state.dtor)(a, state.b);
+		                CLOSURE_DTORS.unregister(state);
+		            } else {
+		                state.a = a;
+		            }
+		        }
+		    };
+		    real.original = state;
+		    CLOSURE_DTORS.register(real, state, state);
+		    return real;
+		}
+		function debugString(val) {
+		    // primitive types
+		    const type = typeof val;
+		    if (type == 'number' || type == 'boolean' || val == null) {
+		        return `${val}`;
+		    }
+		    if (type == 'string') {
+		        return `"${val}"`;
+		    }
+		    if (type == 'symbol') {
+		        const description = val.description;
+		        if (description == null) {
+		            return 'Symbol';
+		        } else {
+		            return `Symbol(${description})`;
+		        }
+		    }
+		    if (type == 'function') {
+		        const name = val.name;
+		        if (typeof name == 'string' && name.length > 0) {
+		            return `Function(${name})`;
+		        } else {
+		            return 'Function';
+		        }
+		    }
+		    // objects
+		    if (Array.isArray(val)) {
+		        const length = val.length;
+		        let debug = '[';
+		        if (length > 0) {
+		            debug += debugString(val[0]);
+		        }
+		        for(let i = 1; i < length; i++){
+		            debug += ', ' + debugString(val[i]);
+		        }
+		        debug += ']';
+		        return debug;
+		    }
+		    // Test for built-in
+		    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+		    let className;
+		    if (builtInMatches && builtInMatches.length > 1) {
+		        className = builtInMatches[1];
+		    } else {
+		        // Failed to match the standard '[object ClassName]'
+		        return toString.call(val);
+		    }
+		    if (className == 'Object') {
+		        // we're a user defined class or Object
+		        // JSON.stringify avoids problems with cycles, and is generally much
+		        // easier than looping through ownProperties of `val`.
+		        try {
+		            return 'Object(' + JSON.stringify(val) + ')';
+		        } catch (_) {
+		            return 'Object';
+		        }
+		    }
+		    // errors
+		    if (val instanceof Error) {
+		        return `${val.name}: ${val.message}\n${val.stack}`;
+		    }
+		    // TODO we could test for more things here, like `Set`s and `Map`s.
+		    return className;
+		}
+		/**
+		 * @param {string} s
+		 * @param {any} opts
+		 * @returns {any}
+		 */ module.exports.minifySync = function(s, opts) {
+		    try {
+		        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+		        wasm.minifySync(retptr, addHeapObject(s), addHeapObject(opts));
+		        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+		        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+		        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+		        if (r2) {
+		            throw takeObject(r1);
+		        }
+		        return takeObject(r0);
+		    } finally{
+		        wasm.__wbindgen_add_to_stack_pointer(16);
+		    }
+		};
+		/**
+		 * @param {string} s
+		 * @param {any} opts
+		 * @returns {Promise<any>}
+		 */ module.exports.minify = function(s, opts) {
+		    const ret = wasm.minify(addHeapObject(s), addHeapObject(opts));
+		    return takeObject(ret);
+		};
+		/**
+		 * @param {string} s
+		 * @param {any} opts
+		 * @returns {any}
+		 */ module.exports.parseSync = function(s, opts) {
+		    try {
+		        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+		        wasm.parseSync(retptr, addHeapObject(s), addHeapObject(opts));
+		        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+		        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+		        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+		        if (r2) {
+		            throw takeObject(r1);
+		        }
+		        return takeObject(r0);
+		    } finally{
+		        wasm.__wbindgen_add_to_stack_pointer(16);
+		    }
+		};
+		/**
+		 * @param {string} s
+		 * @param {any} opts
+		 * @returns {Promise<any>}
+		 */ module.exports.parse = function(s, opts) {
+		    const ret = wasm.parse(addHeapObject(s), addHeapObject(opts));
+		    return takeObject(ret);
+		};
+		/**
+		 * @param {any} s
+		 * @param {any} opts
+		 * @returns {any}
+		 */ module.exports.printSync = function(s, opts) {
+		    try {
+		        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+		        wasm.printSync(retptr, addHeapObject(s), addHeapObject(opts));
+		        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+		        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+		        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+		        if (r2) {
+		            throw takeObject(r1);
+		        }
+		        return takeObject(r0);
+		    } finally{
+		        wasm.__wbindgen_add_to_stack_pointer(16);
+		    }
+		};
+		/**
+		 * @param {any} s
+		 * @param {any} opts
+		 * @returns {Promise<any>}
+		 */ module.exports.print = function(s, opts) {
+		    const ret = wasm.print(addHeapObject(s), addHeapObject(opts));
+		    return takeObject(ret);
+		};
+		/**
+		 * @param {any} s
+		 * @param {any} opts
+		 * @param {any} experimental_plugin_bytes_resolver
+		 * @returns {any}
+		 */ module.exports.transformSync = function(s, opts, experimental_plugin_bytes_resolver) {
+		    try {
+		        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+		        wasm.transformSync(retptr, addHeapObject(s), addHeapObject(opts), addHeapObject(experimental_plugin_bytes_resolver));
+		        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+		        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+		        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+		        if (r2) {
+		            throw takeObject(r1);
+		        }
+		        return takeObject(r0);
+		    } finally{
+		        wasm.__wbindgen_add_to_stack_pointer(16);
+		    }
+		};
+		/**
+		 * @param {any} s
+		 * @param {any} opts
+		 * @param {any} experimental_plugin_bytes_resolver
+		 * @returns {Promise<any>}
+		 */ module.exports.transform = function(s, opts, experimental_plugin_bytes_resolver) {
+		    const ret = wasm.transform(addHeapObject(s), addHeapObject(opts), addHeapObject(experimental_plugin_bytes_resolver));
+		    return takeObject(ret);
+		};
+		function __wbg_adapter_52(arg0, arg1, arg2) {
+		    wasm.__wbindgen_export_5(arg0, arg1, addHeapObject(arg2));
+		}
+		function __wbg_adapter_97(arg0, arg1, arg2, arg3) {
+		    wasm.__wbindgen_export_6(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+		}
+		module.exports.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
+		    const ret = String(getObject(arg1));
+		    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+		    const len1 = WASM_VECTOR_LEN;
+		    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+		    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+		};
+		module.exports.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
+		    const ret = getObject(arg0).buffer;
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbg_call_672a4d21634d4a24 = function() {
+		    return handleError(function(arg0, arg1) {
+		        const ret = getObject(arg0).call(getObject(arg1));
+		        return addHeapObject(ret);
+		    }, arguments);
+		};
+		module.exports.__wbg_call_7cccdd69e0791ae2 = function() {
+		    return handleError(function(arg0, arg1, arg2) {
+		        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+		        return addHeapObject(ret);
+		    }, arguments);
+		};
+		module.exports.__wbg_done_769e5ede4b31c67b = function(arg0) {
+		    const ret = getObject(arg0).done;
+		    return ret;
+		};
+		module.exports.__wbg_entries_3265d4158b33e5dc = function(arg0) {
+		    const ret = Object.entries(getObject(arg0));
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
+		    var v0 = getCachedStringFromWasm0(arg0, arg1);
+		    if (arg0 !== 0) {
+		        wasm.__wbindgen_export_3(arg0, arg1, 1);
+		    }
+		    console.error(v0);
+		};
+		module.exports.__wbg_getRandomValues_1c61fac11405ffdc = function() {
+		    return handleError(function(arg0, arg1) {
+		        globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+		    }, arguments);
+		};
+		module.exports.__wbg_get_67b2ba62fc30de12 = function() {
+		    return handleError(function(arg0, arg1) {
+		        const ret = Reflect.get(getObject(arg0), getObject(arg1));
+		        return addHeapObject(ret);
+		    }, arguments);
+		};
+		module.exports.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) {
+		    const ret = getObject(arg0)[arg1 >>> 0];
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbg_getwithrefkey_1dc361bd10053bfe = function(arg0, arg1) {
+		    const ret = getObject(arg0)[getObject(arg1)];
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbg_instanceof_ArrayBuffer_e14585432e3737fc = function(arg0) {
+		    let result;
+		    try {
+		        result = getObject(arg0) instanceof ArrayBuffer;
+		    } catch (_) {
+		        result = false;
+		    }
+		    const ret = result;
+		    return ret;
+		};
+		module.exports.__wbg_instanceof_Map_f3469ce2244d2430 = function(arg0) {
+		    let result;
+		    try {
+		        result = getObject(arg0) instanceof Map;
+		    } catch (_) {
+		        result = false;
+		    }
+		    const ret = result;
+		    return ret;
+		};
+		module.exports.__wbg_instanceof_Uint8Array_17156bcf118086a9 = function(arg0) {
+		    let result;
+		    try {
+		        result = getObject(arg0) instanceof Uint8Array;
+		    } catch (_) {
+		        result = false;
+		    }
+		    const ret = result;
+		    return ret;
+		};
+		module.exports.__wbg_isArray_a1eab7e0d067391b = function(arg0) {
+		    const ret = Array.isArray(getObject(arg0));
+		    return ret;
+		};
+		module.exports.__wbg_isSafeInteger_343e2beeeece1bb0 = function(arg0) {
+		    const ret = Number.isSafeInteger(getObject(arg0));
+		    return ret;
+		};
+		module.exports.__wbg_iterator_9a24c88df860dc65 = function() {
+		    const ret = Symbol.iterator;
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbg_length_a446193dc22c12f8 = function(arg0) {
+		    const ret = getObject(arg0).length;
+		    return ret;
+		};
+		module.exports.__wbg_length_e2d2a49132c1b256 = function(arg0) {
+		    const ret = getObject(arg0).length;
+		    return ret;
+		};
+		module.exports.__wbg_new_23a2665fac83c611 = function(arg0, arg1) {
+		    try {
+		        var state0 = {
+		            a: arg0,
+		            b: arg1
+		        };
+		        var cb0 = (arg0, arg1)=>{
+		            const a = state0.a;
+		            state0.a = 0;
+		            try {
+		                return __wbg_adapter_97(a, state0.b, arg0, arg1);
+		            } finally{
+		                state0.a = a;
+		            }
+		        };
+		        const ret = new Promise(cb0);
+		        return addHeapObject(ret);
+		    } finally{
+		        state0.a = state0.b = 0;
+		    }
+		};
+		module.exports.__wbg_new_405e22f390576ce2 = function() {
+		    const ret = new Object();
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbg_new_5e0be73521bc8c17 = function() {
+		    const ret = new Map();
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbg_new_78feb108b6472713 = function() {
+		    const ret = new Array();
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbg_new_8a6f238a6ece86ea = function() {
+		    const ret = new Error();
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbg_new_a12002a7f91c75be = function(arg0) {
+		    const ret = new Uint8Array(getObject(arg0));
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbg_newnoargs_105ed471475aaf50 = function(arg0, arg1) {
+		    var v0 = getCachedStringFromWasm0(arg0, arg1);
+		    const ret = new Function(v0);
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbg_next_25feadfc0913fea9 = function(arg0) {
+		    const ret = getObject(arg0).next;
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbg_next_6574e1a8a62d1055 = function() {
+		    return handleError(function(arg0) {
+		        const ret = getObject(arg0).next();
+		        return addHeapObject(ret);
+		    }, arguments);
+		};
+		module.exports.__wbg_queueMicrotask_97d92b4fcc8a61c5 = function(arg0) {
+		    queueMicrotask(getObject(arg0));
+		};
+		module.exports.__wbg_queueMicrotask_d3219def82552485 = function(arg0) {
+		    const ret = getObject(arg0).queueMicrotask;
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbg_resolve_4851785c9c5f573d = function(arg0) {
+		    const ret = Promise.resolve(getObject(arg0));
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbg_set_37837023f3d740e8 = function(arg0, arg1, arg2) {
+		    getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+		};
+		module.exports.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+		    getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+		};
+		module.exports.__wbg_set_65595bdd868b3009 = function(arg0, arg1, arg2) {
+		    getObject(arg0).set(getObject(arg1), arg2 >>> 0);
+		};
+		module.exports.__wbg_set_8fc6bf8a5b1071d1 = function(arg0, arg1, arg2) {
+		    const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
+		    const ret = getObject(arg1).stack;
+		    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+		    const len1 = WASM_VECTOR_LEN;
+		    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+		    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+		};
+		module.exports.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function() {
+		    const ret = typeof commonjsGlobal === 'undefined' ? null : commonjsGlobal;
+		    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+		};
+		module.exports.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 = function() {
+		    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+		    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+		};
+		module.exports.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function() {
+		    const ret = typeof self === 'undefined' ? null : self;
+		    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+		};
+		module.exports.__wbg_static_accessor_WINDOW_5de37043a91a9c40 = function() {
+		    const ret = typeof window === 'undefined' ? null : window;
+		    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+		};
+		module.exports.__wbg_then_44b73946d2fb3e7d = function(arg0, arg1) {
+		    const ret = getObject(arg0).then(getObject(arg1));
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbg_value_cd1ffa7b1ab794f1 = function(arg0) {
+		    const ret = getObject(arg0).value;
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbindgen_as_number = function(arg0) {
+		    const ret = +getObject(arg0);
+		    return ret;
+		};
+		module.exports.__wbindgen_bigint_from_i64 = function(arg0) {
+		    const ret = arg0;
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbindgen_bigint_from_u64 = function(arg0) {
+		    const ret = BigInt.asUintN(64, arg0);
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) {
+		    const v = getObject(arg1);
+		    const ret = typeof v === 'bigint' ? v : undefined;
+		    getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+		    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+		};
+		module.exports.__wbindgen_boolean_get = function(arg0) {
+		    const v = getObject(arg0);
+		    const ret = typeof v === 'boolean' ? v ? 1 : 0 : 2;
+		    return ret;
+		};
+		module.exports.__wbindgen_cb_drop = function(arg0) {
+		    const obj = takeObject(arg0).original;
+		    if (obj.cnt-- == 1) {
+		        obj.a = 0;
+		        return true;
+		    }
+		    const ret = false;
+		    return ret;
+		};
+		module.exports.__wbindgen_closure_wrapper16832 = function(arg0, arg1, arg2) {
+		    const ret = makeMutClosure(arg0, arg1, 666, __wbg_adapter_52);
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbindgen_debug_string = function(arg0, arg1) {
+		    const ret = debugString(getObject(arg1));
+		    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+		    const len1 = WASM_VECTOR_LEN;
+		    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+		    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+		};
+		module.exports.__wbindgen_error_new = function(arg0, arg1) {
+		    const ret = new Error(getStringFromWasm0(arg0, arg1));
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbindgen_in = function(arg0, arg1) {
+		    const ret = getObject(arg0) in getObject(arg1);
+		    return ret;
+		};
+		module.exports.__wbindgen_is_bigint = function(arg0) {
+		    const ret = typeof getObject(arg0) === 'bigint';
+		    return ret;
+		};
+		module.exports.__wbindgen_is_function = function(arg0) {
+		    const ret = typeof getObject(arg0) === 'function';
+		    return ret;
+		};
+		module.exports.__wbindgen_is_null = function(arg0) {
+		    const ret = getObject(arg0) === null;
+		    return ret;
+		};
+		module.exports.__wbindgen_is_object = function(arg0) {
+		    const val = getObject(arg0);
+		    const ret = typeof val === 'object' && val !== null;
+		    return ret;
+		};
+		module.exports.__wbindgen_is_string = function(arg0) {
+		    const ret = typeof getObject(arg0) === 'string';
+		    return ret;
+		};
+		module.exports.__wbindgen_is_undefined = function(arg0) {
+		    const ret = getObject(arg0) === undefined;
+		    return ret;
+		};
+		module.exports.__wbindgen_jsval_eq = function(arg0, arg1) {
+		    const ret = getObject(arg0) === getObject(arg1);
+		    return ret;
+		};
+		module.exports.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
+		    const ret = getObject(arg0) == getObject(arg1);
+		    return ret;
+		};
+		module.exports.__wbindgen_memory = function() {
+		    const ret = wasm.memory;
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbindgen_number_get = function(arg0, arg1) {
+		    const obj = getObject(arg1);
+		    const ret = typeof obj === 'number' ? obj : undefined;
+		    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+		    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+		};
+		module.exports.__wbindgen_number_new = function(arg0) {
+		    const ret = arg0;
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbindgen_object_clone_ref = function(arg0) {
+		    const ret = getObject(arg0);
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbindgen_object_drop_ref = function(arg0) {
+		    takeObject(arg0);
+		};
+		module.exports.__wbindgen_string_get = function(arg0, arg1) {
+		    const obj = getObject(arg1);
+		    const ret = typeof obj === 'string' ? obj : undefined;
+		    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+		    var len1 = WASM_VECTOR_LEN;
+		    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+		    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+		};
+		module.exports.__wbindgen_string_new = function(arg0, arg1) {
+		    const ret = getStringFromWasm0(arg0, arg1);
+		    return addHeapObject(ret);
+		};
+		module.exports.__wbindgen_throw = function(arg0, arg1) {
+		    throw new Error(getStringFromWasm0(arg0, arg1));
+		};
+		const path = new URL('../compiler/swc.wasm', import.meta.url);
+		const bytes = require$$1.readFileSync(path);
+		const wasmModule = new WebAssembly.Module(bytes);
+		const wasmInstance = new WebAssembly.Instance(wasmModule, imports);
+		wasm = wasmInstance.exports;
+		module.exports.__wasm = wasm; 
+	} (wasm));
+	return wasm.exports;
+}
+
+var wasmExports = requireWasm();
+
+const DUMMY_SPAN = {
+    start: 0,
+    end: 0,
+    ctxt: 0
+};
+function parseModule(code, id) {
+    const isTypeScript = /\.([cm]?ts)x?$/i.test(id);
+    return normalizeParsed(wasmExports.parseSync(code, {
+        syntax: isTypeScript ? "typescript" : "ecmascript",
+        tsx: /\.([cm]?ts)x$/i.test(id),
+        jsx: /\.([cm]?jsx)$/i.test(id),
+        target: "es2022"
+    }));
+}
+function normalizeParsed(node) {
+    if (!node || typeof node !== "object") return node;
+    if (Array.isArray(node)) return node.map(normalizeParsed);
+    if (node.type === "FunctionBody") node.type = "BlockStatement";
+    for (const key of Object.keys(node)){
+        if (key !== "span") node[key] = normalizeParsed(node[key]);
+    }
+    return node;
+}
+/** SWC WASM uses FunctionBody where the compiler's normalized AST uses blocks. */ function printModule(program, options) {
+    const functionTypes = new Set([
+        "FunctionDeclaration",
+        "FunctionExpression",
+        "ArrowFunctionExpression",
+        "MethodProperty",
+        "GetterProperty",
+        "SetterProperty",
+        "ClassMethod",
+        "PrivateMethod",
+        "Constructor"
+    ]);
+    const convert = (node, parentType, key)=>{
+        if (!node || typeof node !== "object") return node;
+        if (Array.isArray(node)) return node.map((child)=>convert(child, parentType, key));
+        const result = {};
+        for (const field of Object.keys(node))result[field] = convert(node[field], node.type, field);
+        if (node.type === "BlockStatement" && key === "body" && functionTypes.has(parentType)) {
+            result.type = "FunctionBody";
+            delete result.ctxt;
+        }
+        if ((node.type === "GetterProperty" || node.type === "SetterProperty") && result.function?.body) result.function.body.type = "FunctionBody";
+        return result;
+    };
+    return wasmExports.printSync(convert(program), options);
+}
+function collectStaticMemberPath(node) {
+    const path = [];
+    let current = node;
+    while(current?.type === "MemberExpression"){
+        if (current.computed || current.property?.type === "Computed") {
+            return null;
+        }
+        const key = getStaticPropertyKey(current.property);
+        if (key === null) {
+            return null;
+        }
+        path.unshift(key);
+        current = current.object;
+    }
+    if (current?.type !== "Identifier") {
+        return null;
+    }
+    path.unshift(current.value);
+    return path;
+}
+function getStaticPropertyKey(node) {
+    switch(node?.type){
+        case "Identifier":
+            return node.value;
+        case "StringLiteral":
+            return node.value;
+        case "NumericLiteral":
+            return String(node.value);
+        default:
+            return null;
+    }
+}
+function visitNode(node, visit, parent) {
+    if (node === null || typeof node !== "object") {
+        return;
+    }
+    if (typeof node.type === "string") {
+        visit(node, parent);
+    }
+    for (const key of Object.keys(node)){
+        if (key === "span" || key === "ctxt" || key === "type" || key === "raw") {
+            continue;
+        }
+        const value = node[key];
+        if (Array.isArray(value)) {
+            for (const child of value){
+                visitNode(child, visit, node);
+            }
+            continue;
+        }
+        visitNode(value, visit, node);
+    }
+}
+
+const STORE_MODULES$1 = new Set([
+    "@volynets/reflex-store",
+    "@volynets/reflex-store/store",
+    "@volynets/reflex-store/compiled-store",
+    "@volynets/reflex-store/advanced",
+    "@reflex/store",
+    "@reflex/store/store",
+    "@reflex/store/compiled-store",
+    "@reflex/store/advanced"
+]);
+const bindingKey = (identifier)=>identifier.value + "#" + identifier.ctxt;
+function memberRoot(node) {
+    while(node?.type === "MemberExpression" || node?.type === "OptionalChainingExpression")node = node.object ?? node.base;
+    return node?.type === "Identifier" ? node : null;
+}
+function collectFactoryNames(program) {
+    const names = new Set();
+    let hasLocalCreateStore = false;
+    for (const item of program.body){
+        if (item.type === "ImportDeclaration") {
+            for (const specifier of item.specifiers){
+                if (specifier.local.value === "createStore") hasLocalCreateStore = true;
+                if (item.typeOnly || specifier.type !== "ImportSpecifier" || specifier.isTypeOnly || !STORE_MODULES$1.has(item.source.value)) continue;
+                if ((specifier.imported?.value ?? specifier.local.value) === "createStore") names.add(bindingKey(specifier.local));
+            }
+        } else if (item.type === "FunctionDeclaration" || item.type === "ClassDeclaration") {
+            if (item.identifier?.value === "createStore") hasLocalCreateStore = true;
+        } else if (item.type === "VariableDeclaration") {
+            for (const declaration of item.declarations){
+                if (declaration.id.type === "Identifier" && declaration.id.value === "createStore") hasLocalCreateStore = true;
+            }
+        }
+    }
+    // Bare declarations are supported by the compiler API (the Vite plugin gates them).
+    if (!hasLocalCreateStore && names.size === 0) {
+        const declared = new Set();
+        const collectDeclared = (pattern)=>visitNode(pattern, (node)=>{
+                if (node.type === "Identifier" && node.value === "createStore") declared.add(bindingKey(node));
+            });
+        visitNode(program, (node)=>{
+            if (node.type === "VariableDeclarator") collectDeclared(node.id);
+            if ([
+                "FunctionDeclaration",
+                "FunctionExpression",
+                "ArrowFunctionExpression",
+                "ClassDeclaration"
+            ].includes(node.type)) {
+                if (node.identifier) collectDeclared(node.identifier);
+                for (const parameter of node.params ?? [])collectDeclared(parameter.pat ?? parameter);
+            }
+        });
+        visitNode(program, (node)=>{
+            if (node.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.value === "createStore" && !declared.has(bindingKey(node.callee))) names.add(bindingKey(node.callee));
+        });
+    }
+    return names;
+}
+const pathKey = (path)=>JSON.stringify(path);
+function collectStoreBindings(program, diagnostics = []) {
+    const stores = new Map();
+    const names = collectFactoryNames(program);
+    const recognized = new Set();
+    const factoryUses = new Set();
+    const parents = new WeakMap();
+    visitNode(program, (node, parent)=>{
+        if (parent !== undefined) parents.set(node, parent);
+        if (node.type === "ImportDeclaration") {
+            for (const specifier of node.specifiers)factoryUses.add(specifier.local);
+        }
+    });
+    visitNode(program, (node, parent)=>{
+        if (node.type !== "VariableDeclarator" || parent?.type !== "VariableDeclaration" || node.id?.type !== "Identifier" || !isCreateStoreCall(node.init, names)) return;
+        recognized.add(node.init);
+        factoryUses.add(node.init.callee);
+        if (!isSupportedStoreDeclarationContext(node, parents)) {
+            diagnostics.push({
+                code: "unsupported-binding",
+                message: "Compiled stores must be declared at module scope or inside a function body."
+            });
+            return;
+        }
+        const objectArg = node.init.arguments?.[0]?.expression;
+        if (objectArg?.type !== "ObjectExpression" || node.init.arguments.length < 1 || node.init.arguments.length > 2) {
+            diagnostics.push({
+                code: "unsupported-shape",
+                message: "Compiled stores require a static object literal and optional static options."
+            });
+            return;
+        }
+        let displayName;
+        const optionsArg = node.init.arguments[1]?.expression;
+        if (optionsArg) {
+            if (optionsArg.type !== "ObjectExpression" || optionsArg.properties.some((property)=>property.type !== "KeyValueProperty" || getStaticPropertyKey(property.key) !== "name" || property.value?.type !== "StringLiteral") || optionsArg.properties.length > 1) {
+                diagnostics.push({
+                    code: "unsupported-shape",
+                    message: "Compiled store options require a static optional name string."
+                });
+                return;
+            }
+            displayName = optionsArg.properties[0]?.value.value;
+        }
+        const branchPaths = new Set();
+        const leafPaths = new Map();
+        const leaves = [];
+        const methods = [];
+        const getters = [];
+        collectLeafPaths(objectArg, [], leafPaths, branchPaths, leaves, methods, getters, collectBoundaryNames(program), diagnostics);
+        stores.set(bindingKey(node.id), {
+            name: node.id.value,
+            identifier: node.id,
+            displayName,
+            needsFacade: methods.length > 0 || getters.length > 0,
+            branchPaths,
+            leafPaths,
+            leaves,
+            methods,
+            getters
+        });
+    });
+    visitNode(program, (node)=>{
+        if (node.type === "ForStatement" && node.init?.type === "VariableDeclaration" && node.init.declarations.some((declaration)=>isCreateStoreCall(declaration.init, names))) {
+            diagnostics.push({
+                code: "unsupported-binding",
+                message: "Compiled stores cannot be declared in a for-loop initializer."
+            });
+        }
+        if (node.type === "Identifier" && names.has(bindingKey(node)) && !factoryUses.has(node)) {
+            diagnostics.push({
+                code: "unsupported-binding",
+                message: "The createStore binding can only be used as a direct store factory."
+            });
+        }
+        if (isCreateStoreCall(node, names) && !recognized.has(node)) {
+            diagnostics.push({
+                code: "unsupported-binding",
+                message: "Compiled stores must be declared in a variable declaration."
+            });
+        }
+    });
+    visitNode(program, (node, parent)=>{
+        if (node.type !== "Identifier") return;
+        const store = stores.get(bindingKey(node));
+        if (!store || parent?.type === "VariableDeclarator" && parent.id === node) return;
+        if (parent?.type !== "MemberExpression" || parent.object !== node) {
+            store.needsFacade = true;
+            return;
+        }
+        let member = parent;
+        let owner = parents.get(member);
+        while(owner?.type === "MemberExpression" && owner.object === member){
+            member = owner;
+            owner = parents.get(member);
+        }
+        const parts = collectStaticMemberPath(member)?.slice(1);
+        if (!parts || ![
+            ...store.leafPaths.values()
+        ].some((leaf)=>leaf.parts.length <= parts.length && leaf.parts.every((key, index)=>parts[index] === key))) store.needsFacade = true;
+    });
+    return stores;
+}
+function isSupportedStoreDeclarationContext(declarator, parents) {
+    const declaration = parents.get(declarator);
+    if (declaration?.type !== "VariableDeclaration") return false;
+    const directParent = parents.get(declaration);
+    const statementContainers = new Set([
+        "BlockStatement",
+        "IfStatement",
+        "WhileStatement",
+        "DoWhileStatement",
+        "ForStatement",
+        "ForInStatement",
+        "ForOfStatement",
+        "SwitchStatement",
+        "SwitchCase",
+        "TryStatement",
+        "CatchClause",
+        "LabeledStatement",
+        "WithStatement"
+    ]);
+    let current = directParent;
+    let insideBlock = false;
+    while(current !== undefined){
+        if (current.type === "MethodProperty" || current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") return true;
+        if (current.type === "StaticBlock") return false;
+        if (current.type === "Module") {
+            return current === directParent || insideBlock;
+        }
+        if (current.type === "BlockStatement") insideBlock = true;
+        else if (!statementContainers.has(current.type)) return false;
+        current = parents.get(current);
+    }
+    return false;
+}
+function isCreateStoreCall(expression, names) {
+    return expression?.type === "CallExpression" && expression.callee?.type === "Identifier" && names.has(bindingKey(expression.callee));
+}
+function collectBoundaryNames(program) {
+    const names = {
+        leaf: new Set(),
+        opaque: new Set()
+    };
+    for (const item of program.body){
+        if (item.type !== "ImportDeclaration" || !STORE_MODULES$1.has(item.source.value)) continue;
+        for (const specifier of item.specifiers){
+            if (specifier.type !== "ImportSpecifier" || specifier.isTypeOnly) continue;
+            const imported = specifier.imported?.value ?? specifier.local.value;
+            if (imported === "leaf" || imported === "opaque") names[imported].add(bindingKey(specifier.local));
+        }
+    }
+    return names;
+}
+function methodFunction(property) {
+    return {
+        type: "FunctionExpression",
+        span: property.span,
+        ctxt: property.ctxt ?? property.body?.ctxt ?? 0,
+        identifier: null,
+        params: property.params ?? [],
+        decorators: property.decorators ?? [],
+        body: property.body,
+        generator: property.generator ?? false,
+        async: property.async ?? false,
+        typeParameters: property.typeParameters ?? null,
+        returnType: property.returnType ?? property.typeAnnotation ?? null
+    };
+}
+function getterFunction(property) {
+    property = property.function ?? property;
+    return {
+        type: "FunctionExpression",
+        span: property.span,
+        ctxt: property.body?.ctxt ?? 0,
+        identifier: null,
+        params: [],
+        decorators: [],
+        body: property.body,
+        generator: false,
+        async: false,
+        typeParameters: null,
+        returnType: property.typeAnnotation ?? null
+    };
+}
+function collectLeafPaths(object, prefix, target, branches, leaves, methods, getters, boundaries, diagnostics) {
+    const keys = new Set();
+    for (const property of object.properties ?? []){
+        const key = getStaticPropertyKey(property.key);
+        if (key === null || key === "__proto__" || prefix.length === 0 && (key === "dispose" || key === "constructor") || keys.has(key)) {
+            diagnostics.push({
+                code: "unsupported-shape",
+                message: "Compiled store shapes require unique static keys and do not support spreads, shorthand, setters, __proto__ or reserved lifecycle names."
+            });
+            continue;
+        }
+        keys.add(key);
+        if (property.type === "MethodProperty") {
+            if (property.async || property.generator) {
+                diagnostics.push({
+                    code: "unsupported-shape",
+                    message: "Compiled store methods must be synchronous non-generator actions."
+                });
+                continue;
+            }
+            if (prefix.length !== 0) {
+                diagnostics.push({
+                    code: "unsupported-shape",
+                    message: "Compiled store methods are supported only at the root."
+                });
+                continue;
+            }
+            methods.push({
+                key,
+                fn: methodFunction(property)
+            });
+            continue;
+        }
+        if (property.type === "GetterProperty") {
+            if (prefix.length !== 0) {
+                diagnostics.push({
+                    code: "unsupported-shape",
+                    message: "Compiled store getters are supported only at the root."
+                });
+                continue;
+            }
+            getters.push({
+                key,
+                fn: getterFunction(property)
+            });
+            continue;
+        }
+        if (property.type !== "KeyValueProperty") {
+            diagnostics.push({
+                code: "unsupported-shape",
+                message: "Compiled store shapes support data properties, root methods and root getters."
+            });
+            continue;
+        }
+        const path = [
+            ...prefix,
+            key
+        ];
+        let initial = property.value;
+        let isBoundary = false;
+        const value = property.value;
+        if (value?.type === "CallExpression" && value.callee?.type === "Identifier") {
+            const callee = bindingKey(value.callee);
+            const isLeaf = boundaries.leaf.has(callee);
+            const isOpaque = boundaries.opaque.has(callee);
+            if (isLeaf || isOpaque) {
+                if (value.arguments?.length !== 1 || !value.arguments[0]?.expression) {
+                    diagnostics.push({
+                        code: "unsupported-shape",
+                        message: "leaf() and opaque() compiled-store boundaries require one value argument."
+                    });
+                    continue;
+                }
+                initial = isOpaque ? value : value.arguments[0].expression;
+                isBoundary = true;
+            }
+        }
+        if (!isBoundary && initial?.type === "ObjectExpression") {
+            branches.add(pathKey(path));
+            collectLeafPaths(initial, path, target, branches, leaves, methods, getters, boundaries, diagnostics);
+            continue;
+        }
+        const leaf = {
+            initial,
+            path: pathKey(path),
+            parts: path,
+            mangled: path.map((part)=>part.replace(/[^A-Za-z0-9_$]/g, "_")).join("_")
+        };
+        target.set(pathKey(path), leaf);
+        leaves.push(leaf);
+    }
+}
+
+function scanUnsupportedStoreSyntax(program, state) {
+    if (state.stores.size === 0) return;
+    for (const store of state.stores.values()){
+        for (const getter of store.getters){
+            visitNode(getter.fn, (node)=>{
+                if (node.type === "CallExpression" && node.callee?.type === "MemberExpression") {
+                    const path = collectStaticMemberPath(node.callee);
+                    const receiver = node.callee.object;
+                    const receiverStore = receiver?.type === "ThisExpression" ? store : path?.length === 2 ? state.stores.get(bindingKey(memberRoot(node.callee))) : undefined;
+                    const method = receiver?.type === "ThisExpression" ? node.callee.property?.value : path?.[1];
+                    if (receiverStore?.methods.some((candidate)=>candidate.key === method)) addDiagnostic(state, "unsupported-write", "Compiled getters cannot call store actions.");
+                }
+                if (node.type === "AwaitExpression" || node.type === "YieldExpression") addDiagnostic(state, "unsupported-write", "Compiled getters must be pure synchronous computations.");
+                if (node.type === "AssignmentExpression" || node.type === "UpdateExpression") {
+                    let root = node.left ?? node.argument;
+                    while(root?.type === "MemberExpression")root = root.object;
+                    if (root?.type === "ThisExpression" || root?.type === "Identifier" && state.stores.has(bindingKey(root))) addDiagnostic(state, "unsupported-write", "Compiled getters cannot write store state.");
+                }
+            });
+        }
+    }
+    const intrinsicNames = new Map();
+    for (const item of program.body){
+        if (item.type !== "ImportDeclaration" || !STORE_MODULES$1.has(item.source.value)) continue;
+        for (const specifier of item.specifiers){
+            if (specifier.type !== "ImportSpecifier" || specifier.isTypeOnly) continue;
+            const imported = specifier.imported?.value ?? specifier.local.value;
+            if ([
+                "snapshot",
+                "hydrate",
+                "getStoreName"
+            ].includes(imported) && STORE_MODULES$1.has(item.source.value)) intrinsicNames.set(bindingKey(specifier.local), {
+                arity: imported === "hydrate" ? 2 : 1,
+                rootIndex: 0
+            });
+        }
+    }
+    const returnRoots = new Set();
+    const collectReturned = (node)=>{
+        if (node?.type === "Identifier" && state.stores.has(bindingKey(node))) returnRoots.add(node);
+        if (node?.type === "ObjectExpression") {
+            for (const property of node.properties)collectReturned(property.type === "KeyValueProperty" ? property.value : property);
+        }
+    };
+    visitNode(program, (node)=>{
+        if (node.type === "ReturnStatement") collectReturned(node.argument);
+    });
+    const intrinsicRoots = new Set();
+    visitNode(program, (node)=>{
+        if (node.type !== "CallExpression" || node.callee?.type !== "Identifier") return;
+        const intrinsic = intrinsicNames.get(bindingKey(node.callee));
+        const root = node.arguments?.[intrinsic?.rootIndex ?? 0]?.expression;
+        if (intrinsic && node.arguments.length === intrinsic.arity && node.arguments.every((arg)=>!arg.spread) && root?.type === "Identifier" && state.stores.has(bindingKey(root))) intrinsicRoots.add(root);
+    });
+    visitNode(program, (node, parent)=>{
+        if (node.type === "Identifier" && state.stores.has(bindingKey(node)) && !intrinsicRoots.has(node) && !returnRoots.has(node) && !(parent?.type === "VariableDeclarator" && parent.id === node) && !(parent?.type === "MemberExpression" && parent.object === node) && !(parent?.type === "ReturnStatement" && parent.argument === node)) {
+            addDiagnostic(state, "spread-reflection", REFLECTION_MESSAGE);
+        }
+        if (node.type === "AssignmentExpression" || node.type === "UpdateExpression") {
+            const target = node.left ?? node.argument;
+            if (isStoreMember(target, state) || isStoreRootOrBranch(target, state)) {
+                const parts = collectStaticMemberPath(target);
+                const root = memberRoot(target);
+                const store = root && state.stores.get(bindingKey(root));
+                if (!parts || !store?.leafPaths.has(pathKey(parts.slice(1))) || node.type === "AssignmentExpression" && ![
+                    "=",
+                    "+=",
+                    "-="
+                ].includes(node.operator)) {
+                    addDiagnostic(state, "unsupported-write", "Only declared compiled-store leaves support =, +=, -=, ++ and --.");
+                }
+                if (node.type === "AssignmentExpression" && node.operator !== "=") {
+                    visitNode(node.right, (child)=>{
+                        if (child.type === "AwaitExpression" || child.type === "YieldExpression") addDiagnostic(state, "unsupported-write", "Suspending a compiled-store compound assignment is unsupported.");
+                    });
+                }
+            }
+        } else if (node.type === "MemberExpression") {
+            scanMemberExpression(node, state);
+        } else if (node.type === "VariableDeclarator") {
+            scanVariableDeclarator(node, state);
+        } else if (node.type === "BinaryExpression" && node.operator === "in") {
+            if (isStoreRootOrBranch(node.right, state)) {
+                addDiagnostic(state, "spread-reflection", REFLECTION_MESSAGE);
+            }
+        } else if (node.type === "UnaryExpression" && node.operator === "delete") {
+            if (isStoreMember(node.argument, state) || isStoreRootOrBranch(node.argument, state)) {
+                addDiagnostic(state, "delete", "Deleting compiled-store paths is not supported in phase 1.");
+            }
+        } else if (node.type === "CallExpression") {
+            scanCallExpression(node, state);
+        } else if (node.type === "ObjectExpression") {
+            scanObjectExpression(node, state);
+        } else if (node.type === "OptionalChainingExpression" || node.type === "OptChainExpression") {
+            if (!isStoreMember(node.base ?? node, state)) return;
+            addDiagnostic(state, "optional-chain", "Optional chaining on compiled stores is not supported in phase 1.");
+        }
+    });
+}
+const REFLECTION_MESSAGE = "Spread and reflection are not guaranteed for compiled stores in phase 1.";
+function scanMemberExpression(node, state) {
+    const root = memberRoot(node);
+    if (root !== null && state.stores.has(bindingKey(root)) && hasDynamicMemberAccess(node)) {
+        addDiagnostic(state, "dynamic-access", "Dynamic compiled-store access is not supported in phase 1.");
+    }
+}
+function scanVariableDeclarator(node, state) {
+    if (node.id?.type === "ObjectPattern" && isStoreRootOrBranch(node.init, state)) {
+        addDiagnostic(state, "spread-reflection", REFLECTION_MESSAGE);
+    } else if (node.id?.type === "Identifier" && isStoreBranchMember(node.init, state)) {
+        addDiagnostic(state, "branch-alias", "Aliasing nested compiled-store branches is not supported in phase 1.");
+    }
+}
+function scanCallExpression(node, state) {
+    const calleePath = collectStaticMemberPath(node.callee);
+    if (calleePath === null) return;
+    const [root, method] = calleePath;
+    const isReflection = root === "Object" && (method === "keys" || method === "values" || method === "entries" || method === "getOwnPropertyNames" || method === "getOwnPropertySymbols") || root === "Reflect" && method === "ownKeys";
+    if (isReflection && isStoreRootOrBranch(node.arguments?.[0]?.expression, state)) {
+        addDiagnostic(state, "spread-reflection", REFLECTION_MESSAGE);
+    }
+}
+function scanObjectExpression(node, state) {
+    for (const property of node.properties ?? []){
+        if (property.type === "SpreadElement" && isStoreRootOrBranch(property.arguments ?? property.expression, state)) {
+            addDiagnostic(state, "spread-reflection", REFLECTION_MESSAGE);
+        }
+    }
+}
+function isStoreRootOrBranch(node, state) {
+    return node?.type === "Identifier" ? state.stores.has(bindingKey(node)) : isStoreBranchMember(node, state);
+}
+function isStoreBranchMember(node, state) {
+    const parts = collectStaticMemberPath(node);
+    if (parts === null || parts.length < 2) return false;
+    const [root, ...path] = parts;
+    if (root === undefined) return false;
+    const rootNode = memberRoot(node);
+    return rootNode !== null && (state.stores.get(bindingKey(rootNode))?.branchPaths.has(pathKey(path)) ?? false);
+}
+function isStoreMember(node, state) {
+    const root = memberRoot(node);
+    return root !== null && state.stores.has(bindingKey(root));
+}
+function hasDynamicMemberAccess(node) {
+    let current = node;
+    while(current?.type === "MemberExpression"){
+        if (current.computed || current.property?.type === "Computed") return true;
+        current = current.object;
+    }
+    return false;
+}
+function addDiagnostic(state, code, message) {
+    if (!state.diagnostics.some((diagnostic)=>diagnostic.code === code && diagnostic.message === message)) {
+        state.diagnostics.push({
+            code,
+            message
+        });
+    }
+}
+
+const STORE_MODULES = new Set([
+    "@volynets/reflex-store",
+    "@volynets/reflex-store/store",
+    "@volynets/reflex-store/compiled-store",
+    "@volynets/reflex-store/advanced",
+    "@reflex/store",
+    "@reflex/store/store",
+    "@reflex/store/compiled-store",
+    "@reflex/store/advanced"
+]);
+const DEFAULT_RUNTIME_MODULE = "@volynets/reflex-store/runtime";
+const DEFAULT_LOWERING_TARGET = {
+    scope: {
+        exportName: "createStoreScope",
+        localName: "__reflex_createStoreScope",
+        actionMethod: "action"
+    },
+    signal: {
+        runtimeModule: "@volynets/reflex-store/runtime/internal",
+        exportName: "createStoreCell",
+        localName: "__reflex_signal"
+    },
+    identifiers: {
+        context: "ctx",
+        value: "value",
+        read: ({ mangledPath })=>`__read_${mangledPath}`,
+        set: ({ mangledPath })=>`__set_${mangledPath}`,
+        write: ({ mangledPath })=>`__write_${mangledPath}`,
+        temporary: ({ index, label })=>`__${label}_${index}`
+    }
+};
+function compileStore(code, id = "compiled-store.ts", options = {}) {
+    const ast = parseModule(code, id);
+    const identifiers = new Set();
+    visitNode(ast, (node)=>{
+        if (node.type === "Identifier") identifiers.add(node.value);
+    });
+    const factoryNames = collectFactoryNames(ast);
+    const diagnostics = [];
+    const state = {
+        diagnostics,
+        options: {
+            importRuntime: options.importRuntime ?? true,
+            eraseFacade: options.eraseFacade ?? false,
+            onDiagnostic: options.onDiagnostic ?? "throw"
+        },
+        target: resolveLoweringTarget(options),
+        stores: collectStoreBindings(ast, diagnostics),
+        tempCounter: 0,
+        identifiers,
+        factoryNames
+    };
+    state.target.scope.localName = allocateName(state.target.scope.localName, state);
+    state.target.signal.localName = allocateName(state.target.signal.localName, state);
+    state.target.identifiers.context = allocateName(state.target.identifiers.context, state);
+    state.target.identifiers.value = allocateName(state.target.identifiers.value, state);
+    const hasGetters = [
+        ...state.stores.values()
+    ].some((store)=>store.getters.length > 0);
+    if (hasGetters) {
+        state.computedName = allocateName("__reflex_createDisposableComputed", state);
+    }
+    const defaultScope = state.target.runtimeModule === DEFAULT_RUNTIME_MODULE && state.target.scope.exportName === "createStoreScope";
+    if (!defaultScope) {
+        for (const store of state.stores.values()){
+            if (store.methods.length > 0 || store.getters.length > 0) {
+                state.diagnostics.push({
+                    code: "unsupported-shape",
+                    message: "Compiled store methods and getters require the default Store scope lowering target."
+                });
+            }
+        }
+    }
+    scanUnsupportedStoreSyntax(ast, state);
+    for (const store of state.stores.values()){
+        for (const member of [
+            ...store.methods,
+            ...store.getters
+        ]){
+            scanUnsupportedStoreSyntax({
+                ...ast,
+                body: [
+                    ...ast.body.filter((item)=>item.type === "ImportDeclaration"),
+                    {
+                        type: "ExpressionStatement",
+                        span: DUMMY_SPAN,
+                        expression: rewriteStoreThis(member.fn, store)
+                    }
+                ]
+            }, state);
+        }
+    }
+    if (state.diagnostics.length > 0 && state.options.onDiagnostic === "throw") {
+        throw new CompiledStoreTransformError(state.diagnostics);
+    }
+    if (state.diagnostics.length > 0) return {
+        code,
+        diagnostics: [
+            ...state.diagnostics
+        ],
+        map: null
+    };
+    const transformed = transformProgram(ast, state);
+    const output = printModule(transformed, {
+        filename: id,
+        sourceMaps: true
+    });
+    return {
+        code: output.code,
+        diagnostics: [
+            ...state.diagnostics
+        ],
+        map: output.map ?? null
+    };
+}
+function resolveLoweringTarget(options) {
+    const target = options.loweringTarget;
+    return {
+        runtimeModule: target?.runtimeModule ?? options.runtimeModule ?? DEFAULT_RUNTIME_MODULE,
+        scope: {
+            ...DEFAULT_LOWERING_TARGET.scope,
+            ...target?.model ? {
+                curried: true
+            } : {},
+            ...target?.model,
+            ...target?.scope
+        },
+        signal: {
+            ...target?.runtimeModule || options.runtimeModule || target?.signal?.exportName ? {
+                exportName: "signal",
+                localName: "__reflex_signal"
+            } : DEFAULT_LOWERING_TARGET.signal,
+            ...target?.signal
+        },
+        identifiers: {
+            ...DEFAULT_LOWERING_TARGET.identifiers,
+            ...target?.identifiers
+        }
+    };
+}
+function transformCompiledStore(code, id = "compiled-store.ts", options = {}) {
+    return compileStore(code, id, options);
+}
+function transformProgram(program, state) {
+    if (program.type !== "Module") {
+        return program;
+    }
+    let body = program.body.flatMap((item)=>transformModuleItem(item, state));
+    if (state.stores.size > 0 && state.options.importRuntime) {
+        body = insertRuntimeImport(body, state);
+    }
+    return {
+        ...program,
+        body
+    };
+}
+function transformModuleItem(item, state) {
+    switch(item.type){
+        case "ImportDeclaration":
+            return transformImportDeclaration(item, state);
+        case "VariableDeclaration":
+            return transformVariableDeclaration(item, state);
+        case "ExpressionStatement":
+            return [
+                {
+                    ...item,
+                    expression: transformExpression(item.expression, state)
+                }
+            ];
+        case "FunctionDeclaration":
+            return [
+                transformFunctionDeclaration(item, state)
+            ];
+        case "ExportDeclaration":
+            return [
+                {
+                    ...item,
+                    declaration: item.declaration?.type === "FunctionDeclaration" ? transformFunctionDeclaration(item.declaration, state) : transformNestedFunctions(item.declaration, state)
+                }
+            ];
+        case "ExportDefaultDeclaration":
+            return [
+                {
+                    ...item,
+                    decl: transformNestedFunctions(item.decl, state)
+                }
+            ];
+        case "ExportDefaultExpression":
+            return [
+                {
+                    ...item,
+                    expression: transformExpression(item.expression, state)
+                }
+            ];
+        default:
+            return [
+                transformNestedFunctions(item, state)
+            ];
+    }
+}
+function transformBlockStatement(block, state) {
+    return {
+        ...block,
+        stmts: (block.stmts ?? []).flatMap((statement)=>transformStatement(statement, state))
+    };
+}
+function transformFunctionDeclaration(declaration, state) {
+    return {
+        ...declaration,
+        body: transformBlockStatement(declaration.body, state)
+    };
+}
+function transformNestedFunctions(node, state) {
+    if (node === null || typeof node !== "object") return node;
+    if (Array.isArray(node)) {
+        return node.map((child)=>transformNestedFunctions(child, state));
+    }
+    if (node.type === "FunctionDeclaration") {
+        return transformFunctionDeclaration(node, state);
+    }
+    if (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+        return transformExpression(node, state);
+    }
+    if (node.type === "BlockStatement") {
+        return transformBlockStatement(node, state);
+    }
+    const transformed = {
+        ...node
+    };
+    for (const key of Object.keys(node)){
+        if (key === "span" || key === "ctxt" || key === "type" || key === "raw") {
+            continue;
+        }
+        const value = node[key];
+        if (Array.isArray(value)) {
+            transformed[key] = value.map((child)=>transformNestedFunctions(child, state));
+        } else if (value !== null && typeof value === "object") {
+            transformed[key] = transformNestedFunctions(value, state);
+        }
+    }
+    return transformed;
+}
+function transformSingleStatement(statement, state) {
+    const transformed = transformStatement(statement, state);
+    if (transformed.length === 1) return transformed[0];
+    return {
+        type: "BlockStatement",
+        span: statement.span,
+        ctxt: statement.ctxt,
+        stmts: transformed
+    };
+}
+function transformStatement(statement, state) {
+    switch(statement?.type){
+        case "VariableDeclaration":
+            return transformVariableDeclaration(statement, state);
+        case "ExpressionStatement":
+            return [
+                {
+                    ...statement,
+                    expression: transformExpression(statement.expression, state)
+                }
+            ];
+        case "ReturnStatement":
+        case "ThrowStatement":
+            return [
+                {
+                    ...statement,
+                    argument: statement.argument ? transformExpression(statement.argument, state) : statement.argument
+                }
+            ];
+        case "BlockStatement":
+            return [
+                transformBlockStatement(statement, state)
+            ];
+        case "FunctionDeclaration":
+            return [
+                transformFunctionDeclaration(statement, state)
+            ];
+        case "IfStatement":
+            return [
+                {
+                    ...statement,
+                    test: transformExpression(statement.test, state),
+                    consequent: transformSingleStatement(statement.consequent, state),
+                    alternate: statement.alternate ? transformSingleStatement(statement.alternate, state) : statement.alternate
+                }
+            ];
+        case "WhileStatement":
+        case "DoWhileStatement":
+            return [
+                {
+                    ...statement,
+                    test: transformExpression(statement.test, state),
+                    body: transformSingleStatement(statement.body, state)
+                }
+            ];
+        case "ForStatement":
+            return [
+                {
+                    ...statement,
+                    init: statement.init?.type === "VariableDeclaration" ? transformVariableDeclaration(statement.init, state)[0] ?? statement.init : statement.init ? transformExpression(statement.init, state) : statement.init,
+                    test: statement.test ? transformExpression(statement.test, state) : statement.test,
+                    update: statement.update ? transformExpression(statement.update, state) : statement.update,
+                    body: transformSingleStatement(statement.body, state)
+                }
+            ];
+        case "ForInStatement":
+        case "ForOfStatement":
+            return [
+                {
+                    ...statement,
+                    right: transformExpression(statement.right, state),
+                    body: transformSingleStatement(statement.body, state)
+                }
+            ];
+        case "LabeledStatement":
+            return [
+                {
+                    ...statement,
+                    body: transformSingleStatement(statement.body, state)
+                }
+            ];
+        case "WithStatement":
+            return [
+                {
+                    ...statement,
+                    object: transformExpression(statement.object, state),
+                    body: transformSingleStatement(statement.body, state)
+                }
+            ];
+        case "TryStatement":
+            return [
+                {
+                    ...statement,
+                    block: transformBlockStatement(statement.block, state),
+                    handler: statement.handler ? {
+                        ...statement.handler,
+                        body: transformBlockStatement(statement.handler.body, state)
+                    } : statement.handler,
+                    finalizer: statement.finalizer ? transformBlockStatement(statement.finalizer, state) : statement.finalizer
+                }
+            ];
+        case "SwitchStatement":
+            return [
+                {
+                    ...statement,
+                    discriminant: transformExpression(statement.discriminant, state),
+                    cases: (statement.cases ?? []).map((item)=>({
+                            ...item,
+                            test: item.test ? transformExpression(item.test, state) : item.test,
+                            consequent: (item.consequent ?? []).flatMap((child)=>transformStatement(child, state))
+                        }))
+                }
+            ];
+        default:
+            return [
+                statement
+            ];
+    }
+}
+function transformImportDeclaration(item, state) {
+    if (!STORE_MODULES.has(item.source?.value)) {
+        return [
+            item
+        ];
+    }
+    const specifiers = (item.specifiers ?? []).filter((specifier)=>!state.factoryNames.has(bindingKey(specifier.local)));
+    if (specifiers.length === 0) {
+        return [];
+    }
+    return [
+        {
+            ...item,
+            specifiers
+        }
+    ];
+}
+function transformVariableDeclaration(item, state) {
+    const output = [];
+    let pending = [];
+    const flushPending = ()=>{
+        if (pending.length === 0) {
+            return;
+        }
+        output.push({
+            ...item,
+            declarations: pending
+        });
+        pending = [];
+    };
+    for (const declaration of item.declarations ?? []){
+        const name = declaration.id?.type === "Identifier" ? declaration.id.value : null;
+        const binding = name === null ? undefined : state.stores.get(bindingKey(declaration.id));
+        if (binding === undefined) {
+            pending.push(transformVariableDeclarator(declaration, state));
+            continue;
+        }
+        flushPending();
+        output.push(...createCompiledStoreStatements(binding, item.kind, state));
+    }
+    flushPending();
+    return output;
+}
+function transformVariableDeclarator(declaration, state) {
+    if (declaration.init === undefined) {
+        return declaration;
+    }
+    return {
+        ...declaration,
+        init: transformExpression(declaration.init, state)
+    };
+}
+function insertRuntimeImport(body, state) {
+    const { scope, runtimeModule, signal } = state.target;
+    const signalModule = signal.runtimeModule ?? runtimeModule;
+    const runtimeNames = [
+        scope.exportName + " as " + scope.localName
+    ];
+    if (state.computedName) runtimeNames.push("createDisposableComputed as " + state.computedName);
+    if (signalModule === runtimeModule) runtimeNames.push(signal.exportName + " as " + signal.localName);
+    let source = "import { " + runtimeNames.join(", ") + " } from " + JSON.stringify(runtimeModule) + ";";
+    if (signalModule !== runtimeModule) {
+        source += "\nimport { " + signal.exportName + " as " + signal.localName + " } from " + JSON.stringify(signalModule) + ";";
+    }
+    const imports = parseModule(source, "compiled-store-runtime-import.ts").body;
+    const insertIndex = body.findIndex((item)=>item.type !== "ImportDeclaration");
+    const index = insertIndex === -1 ? body.length : insertIndex;
+    return [
+        ...body.slice(0, index),
+        ...imports,
+        ...body.slice(index)
+    ];
+}
+function createCompiledStoreStatements(binding, kind, state) {
+    const lines = [];
+    const { identifiers, scope, signal } = state.target;
+    const defaultScope = state.target.runtimeModule === DEFAULT_RUNTIME_MODULE && scope.exportName === "createStoreScope";
+    const scopeName = defaultScope ? nextTemp(state, "scope") : binding.name;
+    const emitFacade = defaultScope && (!state.options.eraseFacade || binding.needsFacade);
+    if (emitFacade) binding.lifetimeName ??= allocateName("__store_alive", state);
+    for (const method of binding.methods){
+        method.internalName ??= allocateName("__store_method_" + method.key.replace(/[^A-Za-z0-9_$]/g, "_"), state);
+    }
+    for (const getter of binding.getters){
+        getter.internalName ??= allocateName("__store_getter_" + getter.key.replace(/[^A-Za-z0-9_$]/g, "_"), state);
+    }
+    for (const leaf of binding.leaves){
+        const names = getLeafNames(leaf, state);
+        lines.push(defaultScope ? "let " + names.read + ";" : "const " + names.read + " = " + createCellSource(leaf, binding, state) + ";");
+        lines.push("let " + names.write + ";");
+    }
+    lines.push(kind + " " + scopeName + " = " + scope.localName + "((" + identifiers.context + ") => {");
+    for (const leaf of binding.leaves){
+        const names = getLeafNames(leaf, state);
+        const action = formatMemberAccess(identifiers.context, scope.actionMethod);
+        if (defaultScope) {
+            lines.push("  " + names.read + " = " + identifiers.context + ".own(" + createCellSource(leaf, binding, state) + ");");
+        }
+        if (!defaultScope && signal.exportName === "createStoreCell" && signal.runtimeModule === "@volynets/reflex-store/runtime/internal") {
+            lines.push("  " + identifiers.context + ".onDispose(" + names.read + ".dispose);");
+        }
+        if (defaultScope && signal.exportName === "createStoreCell" && signal.runtimeModule === "@volynets/reflex-store/runtime/internal") {
+            lines.push("  " + names.write + " = " + identifiers.context + ".writer(" + names.read + ");");
+            continue;
+        }
+        lines.push("  " + names.write + " = " + action + "((" + identifiers.value + ") => {");
+        lines.push("    " + names.read + ".set(" + identifiers.value + ");");
+        lines.push("    return " + identifiers.value + ";");
+        lines.push("  });");
+    }
+    const action = formatMemberAccess(identifiers.context, scope.actionMethod);
+    for (const method of binding.methods){
+        const fn = transformExpression(rewriteStoreThis(method.fn, binding), state);
+        lines.push("  const " + method.internalName + " = " + action + "(" + printExpression(fn) + ");");
+    }
+    for (const getter of binding.getters){
+        if (!state.computedName) {
+            throw new Error("Missing generated computed import for store getter.");
+        }
+        const getterValue = nextTemp(state, "getter");
+        const fn = transformExpression(rewriteStoreThis(getter.fn, binding), state);
+        lines.push("  const " + getterValue + " = " + state.computedName + "(() => (" + printExpression(fn) + ").call(" + binding.name + "));");
+        lines.push("  " + identifiers.context + ".own({ [Symbol.dispose]: () => " + getterValue + ".dispose() });");
+        lines.push("  const " + getter.internalName + " = " + getterValue + ".read;");
+    }
+    lines.push("  return " + (defaultScope ? createStoreScopeSource(binding, identifiers.context, emitFacade) : createStoreObjectSource(binding, state)) + ";");
+    lines.push(scope.curried ? "})();" : "});");
+    if (emitFacade) {
+        const facade = createStoreObjectSource(binding, state, scopeName);
+        const contents = facade.slice(1, -1).trim();
+        lines.push(kind + " " + binding.name + " = { " + contents + (contents ? "," : "") + " dispose: " + scopeName + ".dispose, [Symbol.dispose]: " + scopeName + "[Symbol.dispose] };");
+    }
+    if (emitFacade) {
+        if (binding.displayName) lines.push("Object.defineProperty(" + binding.name + ", Symbol.for('@volynets/reflex-store/name'), { value: " + JSON.stringify(binding.displayName) + " });");
+        const guard = "if (!" + formatMemberAccess(scopeName, binding.lifetimeName) + "()) throw new Error('Cannot use a disposed compiled store'); ";
+        const writes = binding.leaves.map((leaf, index)=>getLeafNames(leaf, state).write + "(values[" + index + "]);").join(" ");
+        const collects = binding.leaves.map((leaf)=>getLeafNames(leaf, state).read + ".collect();").join(" ");
+        lines.push("Object.defineProperty(" + binding.name + ", Symbol.for('@volynets/reflex-store/data/1'), { value: {" + "raw: () => { " + guard + "return " + createStoreDataSource(binding, state) + "; }," + "snapshot: (data, copy) => { " + guard + "return " + createStoreDataSource(binding, state, true) + "; }," + "paths: " + JSON.stringify(binding.leaves.map((leaf)=>leaf.parts)) + "," + "branches: " + JSON.stringify([
+            [],
+            ...[
+                ...binding.branchPaths
+            ].map((path)=>JSON.parse(path))
+        ]) + "," + "hydrate: (values) => { " + guard + writes + " }," + "collect: () => { " + collects + " }," + "dispose: " + binding.name + ".dispose } });");
+    }
+    return parseModule(lines.join("\n"), "compiled-store-lowering.ts").body;
+}
+function createCellSource(leaf, binding, state) {
+    const signal = state.target.signal;
+    const options = binding.displayName && signal.exportName === "createStoreCell" ? ", " + JSON.stringify({
+        name: binding.displayName + "." + leaf.parts.join(".")
+    }) : "";
+    return signal.localName + "(" + printExpression(leaf.initial) + options + ")";
+}
+function rewriteStoreThis(node, binding, root = true) {
+    if (!node || typeof node !== "object") return node;
+    if (Array.isArray(node)) return node.map((child)=>rewriteStoreThis(child, binding, false));
+    if (node.type === "ThisExpression") return {
+        ...binding.identifier
+    };
+    if (!root && [
+        "FunctionExpression",
+        "FunctionDeclaration",
+        "MethodProperty",
+        "GetterProperty",
+        "SetterProperty",
+        "ClassExpression",
+        "ClassDeclaration"
+    ].includes(node.type)) return node;
+    const result = {
+        ...node
+    };
+    for (const key of Object.keys(node)){
+        if (![
+            "span",
+            "ctxt"
+        ].includes(key)) result[key] = rewriteStoreThis(node[key], binding, false);
+    }
+    return result;
+}
+function createStoreDataSource(binding, state, snapshot = false) {
+    const root = createStoreTreeNode();
+    for (const path of binding.branchPaths){
+        let branch = root;
+        for (const key of JSON.parse(path)){
+            let next = branch.branches.get(key);
+            if (!next) branch.branches.set(key, next = createStoreTreeNode());
+            branch = next;
+        }
+    }
+    for (const leaf of binding.leaves)insertStoreLeaf(root, leaf.parts, leaf);
+    const render = (node)=>{
+        const entries = [
+            ...node.branches
+        ].map(([key, branch])=>({
+                key,
+                value: render(branch)
+            }));
+        for (const [key, leaf] of node.leaves){
+            let value = getLeafNames(leaf, state).read + "()";
+            if (snapshot) {
+                value = "data";
+                for (const part of leaf.parts)value = formatMemberAccess(value, part);
+                value = "copy(" + value + ")";
+            }
+            entries.push({
+                key,
+                value
+            });
+        }
+        if (snapshot) {
+            // Match Reflect.ownKeys ordering: array-index keys precede other strings.
+            const indexOf = (key)=>{
+                const index = Number(key);
+                return Number.isInteger(index) && index >= 0 && index < 0xffffffff && String(index) === key ? index : Infinity;
+            };
+            entries.sort((a, b)=>indexOf(a.key) - indexOf(b.key));
+        }
+        const object = "{" + entries.map(({ key, value })=>formatObjectKey(key) + ": " + value).join(", ") + "}";
+        return snapshot ? "Object.freeze(" + object + ")" : object;
+    };
+    return render(root);
+}
+function createStoreScopeSource(binding, context, emitFacade) {
+    const members = [
+        ...emitFacade ? [
+            binding.lifetimeName + ": () => !" + context + ".disposed"
+        ] : [],
+        ...binding.methods.map((method)=>method.internalName + ": " + method.internalName),
+        ...binding.getters.map((getter)=>getter.internalName + ": " + getter.internalName)
+    ];
+    return members.length === 0 ? "{}" : "{ " + members.join(", ") + " }";
+}
+function createStoreObjectSource(binding, state, scopeName) {
+    const root = createStoreTreeNode();
+    for (const path of binding.branchPaths){
+        let branch = root;
+        for (const key of JSON.parse(path)){
+            let next = branch.branches.get(key);
+            if (!next) {
+                next = createStoreTreeNode();
+                branch.branches.set(key, next);
+            }
+            branch = next;
+        }
+    }
+    for (const leaf of binding.leaves){
+        insertStoreLeaf(root, leaf.parts, leaf);
+    }
+    return createStoreTreeObjectSource(root, state, 2, binding, scopeName);
+}
+function createStoreTreeNode() {
+    return {
+        branches: new Map(),
+        leaves: new Map()
+    };
+}
+function insertStoreLeaf(node, parts, leaf) {
+    const [head, ...tail] = parts;
+    if (head === undefined) {
+        return;
+    }
+    if (tail.length === 0) {
+        node.leaves.set(head, leaf);
+        return;
+    }
+    let branch = node.branches.get(head);
+    if (branch === undefined) {
+        branch = createStoreTreeNode();
+        node.branches.set(head, branch);
+    }
+    insertStoreLeaf(branch, tail, leaf);
+}
+function createStoreTreeObjectSource(node, state, indent, rootBinding, scopeName) {
+    const pad = " ".repeat(indent);
+    const childPad = " ".repeat(indent + 2);
+    const entries = [];
+    for (const [key, branch] of node.branches){
+        entries.push(childPad + formatObjectKey(key) + ": " + createStoreTreeObjectSource(branch, state, indent + 2));
+    }
+    for (const [key, leaf] of node.leaves){
+        const names = getLeafNames(leaf, state);
+        entries.push([
+            childPad + "get " + formatObjectKey(key) + "() {",
+            childPad + "  return " + names.read + "();",
+            childPad + "},",
+            childPad + "set " + formatObjectKey(key) + "(" + state.target.identifiers.value + ") {",
+            childPad + "  " + names.write + "(" + state.target.identifiers.value + ");",
+            childPad + "}"
+        ].join("\n"));
+    }
+    if (rootBinding && scopeName) {
+        for (const method of rootBinding.methods){
+            entries.push(childPad + formatObjectKey(method.key) + ": " + "function (...args) { if (!" + formatMemberAccess(scopeName, rootBinding.lifetimeName) + "()) throw new Error('Cannot call a disposed compiled store'); return " + formatMemberAccess(scopeName, method.internalName) + ".apply(" + rootBinding.name + ", args); }");
+        }
+        for (const getter of rootBinding.getters){
+            entries.push(childPad + "get " + formatObjectKey(getter.key) + "() { if (!" + formatMemberAccess(scopeName, rootBinding.lifetimeName) + "()) throw new Error('Cannot read a disposed compiled store'); return " + formatMemberAccess(scopeName, getter.internalName) + "(); }");
+        }
+    }
+    if (entries.length === 0) {
+        return "{}";
+    }
+    return "{\n" + entries.join(",\n") + "\n" + pad + "}";
+}
+function formatObjectKey(key) {
+    return isIdentifierName(key) ? key : JSON.stringify(key);
+}
+function formatMemberAccess(object, property) {
+    return isIdentifierName(property) ? `${object}.${property}` : `${object}[${JSON.stringify(property)}]`;
+}
+function allocateName(preferred, state) {
+    if (!isIdentifierName(preferred)) throw new Error("Invalid generated identifier: " + preferred);
+    let name = preferred;
+    let suffix = 0;
+    while(state.identifiers.has(name))name = preferred + "_" + ++suffix;
+    state.identifiers.add(name);
+    return name;
+}
+function getLeafNames(leaf, state) {
+    if (leaf.names) return leaf.names;
+    const context = {
+        path: leaf.parts,
+        mangledPath: leaf.mangled
+    };
+    return leaf.names = {
+        read: allocateName(state.target.identifiers.read(context), state),
+        set: allocateName(state.target.identifiers.set(context), state),
+        write: allocateName(state.target.identifiers.write(context), state)
+    };
+}
+function printExpression(expression) {
+    const output = printModule({
+        type: "Module",
+        span: DUMMY_SPAN,
+        body: [
+            {
+                type: "ExpressionStatement",
+                span: DUMMY_SPAN,
+                expression
+            }
+        ],
+        interpreter: null
+    }, {
+        sourceMaps: false
+    }).code.trim();
+    return output.endsWith(";") ? output.slice(0, -1) : output;
+}
+function transformExpression(node, state) {
+    if (node.type === "FunctionExpression") {
+        return {
+            ...node,
+            body: transformBlockStatement(node.body, state)
+        };
+    }
+    if (node.type === "ArrowFunctionExpression") {
+        return {
+            ...node,
+            body: node.body.type === "BlockStatement" ? transformBlockStatement(node.body, state) : transformExpression(node.body, state)
+        };
+    }
+    let result = node;
+    const stack = [
+        {
+            phase: "enter",
+            node,
+            assign (expression) {
+                result = expression;
+            }
+        }
+    ];
+    while(stack.length > 0){
+        const frame = stack.pop();
+        if (frame === undefined) continue;
+        if (frame.phase === "exit") {
+            frame.assign(finalizeExpression(frame.node, frame.slots, state));
+            continue;
+        }
+        const expression = frame.node;
+        if (expression.type === "FunctionExpression" || expression.type === "ArrowFunctionExpression") {
+            frame.assign(transformExpression(expression, state));
+            continue;
+        }
+        const childCount = countTransformChildren(expression, state);
+        if (childCount === 0) {
+            const withNestedFunctions = transformNestedFunctions(expression, state);
+            frame.assign(finalizeExpression(withNestedFunctions, EMPTY_SLOTS, state));
+            continue;
+        }
+        const slots = createSlots(childCount);
+        stack.push({
+            phase: "exit",
+            node: expression,
+            assign: frame.assign,
+            slots
+        });
+        pushExpressionChildren(expression, state, slots, stack);
+    }
+    return result;
+}
+function nextTemp(state, label) {
+    state.tempCounter += 1;
+    return allocateName(state.target.identifiers.temporary({
+        index: state.tempCounter,
+        label
+    }), state);
+}
+function isIdentifierName(value) {
+    return /^[$A-Z_a-z][$\w]*$/.test(value);
+}
+function getLeafPathForMember(node, stores) {
+    const parts = collectStaticMemberPath(node);
+    if (parts === null || parts.length < 2) {
+        return null;
+    }
+    const [root, ...path] = parts;
+    if (root === undefined) {
+        return null;
+    }
+    const rootNode = memberRoot(node);
+    const store = rootNode ? stores.get(bindingKey(rootNode)) : undefined;
+    if (!store) {
+        return null;
+    }
+    return store.leafPaths.get(pathKey(path)) ?? null;
+}
+function getLeafPathForTarget(node, stores) {
+    if (node?.type === "MemberExpression") {
+        return getLeafPathForMember(node, stores);
+    }
+    if (node?.type === "SimpleAssignmentTarget" && node.value?.type === "MemberExpression") {
+        return getLeafPathForMember(node.value, stores);
+    }
+    return null;
+}
+function createReadCall(leaf, state) {
+    return createCallExpression(getLeafNames(leaf, state).read, []);
+}
+function createWriteCall(leaf, value, state) {
+    return createCallExpression(getLeafNames(leaf, state).write, [
+        value
+    ]);
+}
+function createCompoundAssignment(leaf, operator, right, rhsTemp, nextTempName, state) {
+    const previous = nextTemp(state, "previous");
+    return createIIFE([
+        createConstDeclaration(previous, createReadCall(leaf, state)),
+        createConstDeclaration(rhsTemp, right),
+        createConstDeclaration(nextTempName, createBinaryExpression(createIdentifierExpression(previous), operator, createIdentifierExpression(rhsTemp))),
+        createExpressionStatement(createWriteCall(leaf, createIdentifierExpression(nextTempName), state)),
+        createReturnStatement(createIdentifierExpression(nextTempName))
+    ]);
+}
+function createUpdateExpressionLowering(leaf, operator, tempName, prefix, state) {
+    const declaration = createConstDeclaration(tempName, createReadCall(leaf, state));
+    declaration.kind = "let";
+    const result = nextTemp(state, "result");
+    return createIIFE([
+        declaration,
+        createConstDeclaration(result, {
+            type: "UpdateExpression",
+            span: DUMMY_SPAN,
+            operator: operator === "+" ? "++" : "--",
+            prefix,
+            argument: createIdentifierExpression(tempName)
+        }),
+        createExpressionStatement(createWriteCall(leaf, createIdentifierExpression(tempName), state)),
+        createReturnStatement(createIdentifierExpression(result))
+    ]);
+}
+function createIdentifierExpression(name) {
+    return {
+        type: "Identifier",
+        span: DUMMY_SPAN,
+        ctxt: 0,
+        value: name,
+        optional: false
+    };
+}
+function createCallExpression(calleeName, args) {
+    return {
+        type: "CallExpression",
+        span: DUMMY_SPAN,
+        ctxt: 0,
+        callee: createIdentifierExpression(calleeName),
+        arguments: args.map((expression)=>({
+                expression
+            })),
+        typeArguments: undefined
+    };
+}
+function createBinaryExpression(left, operator, right) {
+    return {
+        type: "BinaryExpression",
+        span: DUMMY_SPAN,
+        operator,
+        left,
+        right
+    };
+}
+function createConstDeclaration(name, init) {
+    return {
+        type: "VariableDeclaration",
+        span: DUMMY_SPAN,
+        ctxt: 0,
+        kind: "const",
+        declare: false,
+        declarations: [
+            {
+                type: "VariableDeclarator",
+                span: DUMMY_SPAN,
+                definite: false,
+                id: {
+                    type: "Identifier",
+                    span: DUMMY_SPAN,
+                    ctxt: 0,
+                    value: name,
+                    optional: false,
+                    typeAnnotation: undefined
+                },
+                init
+            }
+        ]
+    };
+}
+function createExpressionStatement(expression) {
+    return {
+        type: "ExpressionStatement",
+        span: DUMMY_SPAN,
+        expression
+    };
+}
+function createReturnStatement(argument) {
+    return {
+        type: "ReturnStatement",
+        span: DUMMY_SPAN,
+        argument
+    };
+}
+function createIIFE(statements) {
+    return {
+        type: "CallExpression",
+        span: DUMMY_SPAN,
+        ctxt: 0,
+        callee: {
+            type: "ParenthesisExpression",
+            span: DUMMY_SPAN,
+            expression: {
+                type: "ArrowFunctionExpression",
+                span: DUMMY_SPAN,
+                ctxt: 0,
+                params: [],
+                body: {
+                    type: "BlockStatement",
+                    span: DUMMY_SPAN,
+                    ctxt: 0,
+                    stmts: statements
+                },
+                async: false,
+                generator: false,
+                typeParameters: undefined,
+                returnType: undefined
+            }
+        },
+        arguments: [],
+        typeArguments: undefined
+    };
+}
+const EMPTY_SLOTS = [];
+const SIMPLE_CHILDREN = new Set([
+    "BinaryExpression",
+    "ParenthesisExpression",
+    "UnaryExpression",
+    "ConditionalExpression",
+    "SequenceExpression",
+    "TemplateLiteral"
+]);
+function createSlots(size) {
+    return new Array(size);
+}
+function countTransformChildren(node, state) {
+    switch(node.type){
+        case "AssignmentExpression":
+            return 1;
+        case "UpdateExpression":
+            return getLeafPathForTarget(node.argument, state.stores) === null ? 1 : 0;
+        case "MemberExpression":
+            return 1;
+        case "CallExpression":
+            return getCallExpressionChildCount(node);
+        default:
+            return SIMPLE_CHILDREN.has(node.type) ? getSimpleChildSpecs(node).length : 0;
+    }
+}
+function pushExpressionChildren(node, state, slots, stack) {
+    switch(node.type){
+        case "AssignmentExpression":
+            pushChild(stack, node.right, slots, 0);
+            return;
+        case "UpdateExpression":
+            if (getLeafPathForTarget(node.argument, state.stores) === null) {
+                pushChild(stack, node.argument, slots, 0);
+            }
+            return;
+        case "MemberExpression":
+            pushChild(stack, node.object, slots, 0);
+            return;
+        case "CallExpression":
+            {
+                for(let argIndex = node.arguments.length - 1; argIndex >= 0; argIndex--){
+                    const arg = node.arguments[argIndex];
+                    if (arg?.expression === undefined) {
+                        continue;
+                    }
+                    const slotIndex = getCallExpressionSlotIndex(node, argIndex);
+                    pushChild(stack, arg.expression, slots, slotIndex);
+                }
+                const index = getCallExpressionCalleeSlotIndex(node);
+                if (index !== -1) {
+                    const calleeExpression = getCalleeExpression(node.callee);
+                    if (calleeExpression !== null) {
+                        pushChild(stack, calleeExpression, slots, index);
+                    }
+                }
+                return;
+            }
+        default:
+            const specs = getSimpleChildSpecs(node);
+            for(let i = specs.length - 1; i >= 0; i--){
+                const [index, expression] = specs[i];
+                pushChild(stack, expression, slots, index);
+            }
+            return;
+    }
+}
+function finalizeExpression(node, slots, state) {
+    switch(node.type){
+        case "AssignmentExpression":
+            return finalizeAssignmentExpression(node, slots, state);
+        case "UpdateExpression":
+            return finalizeUpdateExpression(node, slots, state);
+        case "MemberExpression":
+            return finalizeMemberExpression(node, slots, state);
+        case "CallExpression":
+            return finalizeCallExpression(node, slots);
+        default:
+            return SIMPLE_CHILDREN.has(node.type) ? finalizeSimpleExpression(node, slots) : node;
+    }
+}
+function getSimpleChildSpecs(node) {
+    switch(node.type){
+        case "BinaryExpression":
+            return [
+                [
+                    0,
+                    node.left
+                ],
+                [
+                    1,
+                    node.right
+                ]
+            ];
+        case "ParenthesisExpression":
+            return [
+                [
+                    0,
+                    node.expression
+                ]
+            ];
+        case "UnaryExpression":
+            return [
+                [
+                    0,
+                    node.argument
+                ]
+            ];
+        case "ConditionalExpression":
+            return [
+                [
+                    0,
+                    node.test
+                ],
+                [
+                    1,
+                    node.consequent
+                ],
+                [
+                    2,
+                    node.alternate
+                ]
+            ];
+        case "SequenceExpression":
+        case "TemplateLiteral":
+            return node.expressions.map((expression, index)=>[
+                    index,
+                    expression
+                ]);
+        default:
+            return [];
+    }
+}
+function finalizeSimpleExpression(node, slots) {
+    switch(node.type){
+        case "BinaryExpression":
+            return {
+                ...node,
+                left: slots[0] ?? node.left,
+                right: slots[1] ?? node.right
+            };
+        case "ParenthesisExpression":
+            return {
+                ...node,
+                expression: slots[0] ?? node.expression
+            };
+        case "UnaryExpression":
+            return {
+                ...node,
+                argument: slots[0] ?? node.argument
+            };
+        case "ConditionalExpression":
+            return {
+                ...node,
+                test: slots[0] ?? node.test,
+                consequent: slots[1] ?? node.consequent,
+                alternate: slots[2] ?? node.alternate
+            };
+        case "SequenceExpression":
+        case "TemplateLiteral":
+            return {
+                ...node,
+                expressions: node.expressions.map((expression, index)=>slots[index] ?? expression)
+            };
+        default:
+            return node;
+    }
+}
+function finalizeAssignmentExpression(node, slots, state) {
+    const leafPath = getLeafPathForTarget(node.left, state.stores);
+    const right = slots[0] ?? node.right;
+    if (leafPath === null) {
+        return {
+            ...node,
+            right
+        };
+    }
+    switch(node.operator){
+        case "=":
+            return createWriteCall(leafPath, right, state);
+        case "+=":
+            return createCompoundAssignment(leafPath, "+", right, nextTemp(state, "rhs"), nextTemp(state, "next"), state);
+        case "-=":
+            return createCompoundAssignment(leafPath, "-", right, nextTemp(state, "rhs"), nextTemp(state, "next"), state);
+        default:
+            return {
+                ...node,
+                right
+            };
+    }
+}
+function finalizeUpdateExpression(node, slots, state) {
+    const leafPath = getLeafPathForTarget(node.argument, state.stores);
+    if (leafPath === null) {
+        return {
+            ...node,
+            argument: slots[0] ?? node.argument
+        };
+    }
+    const operator = node.operator === "++" ? "+" : node.operator === "--" ? "-" : null;
+    if (operator === null) {
+        return node;
+    }
+    return createUpdateExpressionLowering(leafPath, operator, nextTemp(state, node.prefix ? "next" : "prev"), node.prefix, state);
+}
+function finalizeMemberExpression(node, slots, state) {
+    const next = {
+        ...node,
+        object: slots[0] ?? node.object
+    };
+    const leafPath = getLeafPathForMember(next, state.stores);
+    if (leafPath === null) {
+        return next;
+    }
+    return createReadCall(leafPath, state);
+}
+function finalizeCallExpression(node, slots, state) {
+    const nextArgs = node.arguments.map((arg, index)=>{
+        if (arg?.expression === undefined) {
+            return arg;
+        }
+        const slotIndex = getCallExpressionSlotIndex(node, index);
+        return {
+            ...arg,
+            expression: slotIndex === -1 ? arg.expression : slots[slotIndex] ?? arg.expression
+        };
+    });
+    const calleeSlotIndex = getCallExpressionCalleeSlotIndex(node);
+    const calleeExpression = getCalleeExpression(node.callee);
+    const nextCallee = calleeSlotIndex === -1 || calleeExpression === null ? node.callee : setCalleeExpression(node.callee, slots[calleeSlotIndex] ?? calleeExpression);
+    return {
+        ...node,
+        callee: nextCallee,
+        arguments: nextArgs
+    };
+}
+function getCallExpressionChildCount(node) {
+    let count = 0;
+    if (getCalleeExpression(node.callee) !== null) {
+        count += 1;
+    }
+    for (const arg of node.arguments ?? []){
+        if (arg?.expression !== undefined) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function getCallExpressionCalleeSlotIndex(node, _state) {
+    return getCalleeExpression(node.callee) === null ? -1 : 0;
+}
+function getCallExpressionSlotIndex(node, argumentIndex, _state) {
+    let index = getCallExpressionCalleeSlotIndex(node) === -1 ? 0 : 1;
+    for(let i = 0; i < argumentIndex; i++){
+        if (node.arguments[i]?.expression !== undefined) {
+            index += 1;
+        }
+    }
+    return node.arguments[argumentIndex]?.expression === undefined ? -1 : index;
+}
+function getCalleeExpression(callee) {
+    if (callee?.type === "Super") {
+        return null;
+    }
+    if (callee?.type === "Expression") {
+        return callee.expression;
+    }
+    return callee;
+}
+function setCalleeExpression(callee, expression) {
+    if (callee?.type === "Expression") {
+        return {
+            ...callee,
+            expression
+        };
+    }
+    return expression;
+}
+function pushChild(stack, node, slots, index) {
+    stack.push({
+        phase: "enter",
+        node,
+        assign (expression) {
+            slots[index] = expression;
+        }
+    });
+}
+
+export { CompiledStoreTransformError as C, compileStore as c, transformCompiledStore as t };