hakuban 0.5.5 → 0.6.2

package/hakuban.js

@@ -0,0 +1,2671 @@
+let wasm;
+
+const heap = new Array(32).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+function getObject(idx) { return heap[idx]; }
+
+let heap_next = heap.length;
+
+function dropObject(idx) {
+    if (idx < 36) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+let cachegetUint8Memory0 = null;
+function getUint8Memory0() {
+    if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {
+        cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachegetUint8Memory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+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 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.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;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+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);
+        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len);
+
+    const mem = getUint8Memory0();
+
+    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);
+        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachegetInt32Memory0 = null;
+function getInt32Memory0() {
+    if (cachegetInt32Memory0 === null || cachegetInt32Memory0.buffer !== wasm.memory.buffer) {
+        cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachegetInt32Memory0;
+}
+
+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_2.get(state.dtor)(a, state.b);
+
+            } else {
+                state.a = a;
+            }
+        }
+    };
+    real.original = state;
+
+    return real;
+}
+function __wbg_adapter_16(arg0, arg1, arg2) {
+    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h2cb5c9e37b253332(arg0, arg1, addHeapObject(arg2));
+}
+
+const u32CvtShim = new Uint32Array(2);
+
+const uint64CvtShim = new BigUint64Array(u32CvtShim.buffer);
+/**
+* @param {string} json_string
+* @returns {WasmHashResult}
+*/
+function hakuban_json_hash(json_string) {
+    var ptr0 = passStringToWasm0(json_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ret = wasm.hakuban_json_hash(ptr0, len0);
+    return WasmHashResult.__wrap(ret);
+}
+
+/**
+* @param {string} default_log_level
+* @returns {number}
+*/
+function hakuban_logger_initialize(default_log_level) {
+    var ptr0 = passStringToWasm0(default_log_level, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ret = wasm.hakuban_logger_initialize(ptr0, len0);
+    return ret;
+}
+
+/**
+* @param {string} name_str
+* @returns {WasmLocalNodeNewResult}
+*/
+function hakuban_local_node_new(name_str) {
+    var ptr0 = passStringToWasm0(name_str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ret = wasm.hakuban_local_node_new(ptr0, len0);
+    return WasmLocalNodeNewResult.__wrap(ret);
+}
+
+/**
+* @param {number} local_node
+*/
+function hakuban_local_node_drop(local_node) {
+    wasm.hakuban_local_node_drop(local_node);
+}
+
+/**
+* @param {number} local_node
+* @param {string} descriptor
+* @returns {WasmObjectObserveResult}
+*/
+function hakuban_object_observe_new(local_node, descriptor) {
+    var ptr0 = passStringToWasm0(descriptor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ret = wasm.hakuban_object_observe_new(local_node, ptr0, len0);
+    return WasmObjectObserveResult.__wrap(ret);
+}
+
+/**
+* @param {number} object_ptr
+*/
+function hakuban_object_observe_drop(object_ptr) {
+    wasm.hakuban_object_observe_drop(object_ptr);
+}
+
+/**
+* @param {number} object_observe_pointer
+* @returns {number}
+*/
+function hakuban_object_observe_state_borrow(object_observe_pointer) {
+    var ret = wasm.hakuban_object_observe_state_borrow(object_observe_pointer);
+    return ret;
+}
+
+/**
+* @param {number} state_ptr
+*/
+function hakuban_object_observe_state_return(state_ptr) {
+    wasm.hakuban_object_observe_state_return(state_ptr);
+}
+
+/**
+* @param {number} state_ptr
+* @returns {BigInt}
+*/
+function hakuban_object_observe_state_synchronized(state_ptr) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.hakuban_object_observe_state_synchronized(retptr, state_ptr);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        u32CvtShim[0] = r0;
+        u32CvtShim[1] = r1;
+        const n0 = uint64CvtShim[0];
+        return n0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+* @param {number} state_ptr
+* @returns {string}
+*/
+function hakuban_object_observe_state_data_version(state_ptr) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.hakuban_object_observe_state_data_version(retptr, state_ptr);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(r0, r1);
+    }
+}
+
+/**
+* @param {number} state_ptr
+* @returns {string}
+*/
+function hakuban_object_observe_state_data_type(state_ptr) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.hakuban_object_observe_state_data_type(retptr, state_ptr);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(r0, r1);
+    }
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
+}
+/**
+* @param {number} state_ptr
+* @returns {Uint8Array}
+*/
+function hakuban_object_observe_state_data(state_ptr) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.hakuban_object_observe_state_data(retptr, state_ptr);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var v0 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_free(r0, r1 * 1);
+        return v0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+* @param {number} object_observe_ptr
+* @returns {number}
+*/
+function hakuban_object_observe_events_get(object_observe_ptr) {
+    var ret = wasm.hakuban_object_observe_events_get(object_observe_ptr);
+    return ret;
+}
+
+/**
+* @param {number} events_pointer
+*/
+function hakuban_object_descriptor_events_drop(events_pointer) {
+    wasm.hakuban_object_descriptor_events_drop(events_pointer);
+}
+
+/**
+* @param {number} events_pointer
+* @param {Promise<any>} cancel
+* @returns {Promise<any>}
+*/
+function hakuban_object_descriptor_events_next(events_pointer, cancel) {
+    var ret = wasm.hakuban_object_descriptor_events_next(events_pointer, addHeapObject(cancel));
+    return takeObject(ret);
+}
+
+/**
+* @param {number} local_node
+* @param {string} descriptor
+* @returns {WasmTagObserveResult}
+*/
+function hakuban_tag_observe_new(local_node, descriptor) {
+    var ptr0 = passStringToWasm0(descriptor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ret = wasm.hakuban_tag_observe_new(local_node, ptr0, len0);
+    return WasmTagObserveResult.__wrap(ret);
+}
+
+/**
+* @param {number} tag_observe_pointer
+*/
+function hakuban_tag_observe_drop(tag_observe_pointer) {
+    wasm.hakuban_tag_observe_drop(tag_observe_pointer);
+}
+
+/**
+* @param {number} tag_observe_pointer
+* @param {string} object_descriptor
+* @returns {WasmTagObserveObjectStateBorrowResult}
+*/
+function hakuban_tag_observe_object_state_borrow(tag_observe_pointer, object_descriptor) {
+    var ptr0 = passStringToWasm0(object_descriptor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ret = wasm.hakuban_tag_observe_object_state_borrow(tag_observe_pointer, ptr0, len0);
+    return WasmTagObserveObjectStateBorrowResult.__wrap(ret);
+}
+
+/**
+* @param {number} tag_observe_pointer
+* @returns {string}
+*/
+function hakuban_tag_observe_object_descriptors(tag_observe_pointer) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.hakuban_tag_observe_object_descriptors(retptr, tag_observe_pointer);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(r0, r1);
+    }
+}
+
+/**
+* @param {number} tag_observe_ptr
+* @returns {number}
+*/
+function hakuban_tag_observe_events_get(tag_observe_ptr) {
+    var ret = wasm.hakuban_tag_observe_events_get(tag_observe_ptr);
+    return ret;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+/**
+* @param {number} local_node_pointer
+* @param {boolean} upstream
+* @param {boolean | undefined} diff_produce
+* @param {boolean | undefined} diff_request
+* @returns {WasmRemoteNodeNewResult}
+*/
+function hakuban_remote_node_new(local_node_pointer, upstream, diff_produce, diff_request) {
+    var ret = wasm.hakuban_remote_node_new(local_node_pointer, upstream, isLikeNone(diff_produce) ? 0xFFFFFF : diff_produce ? 1 : 0, isLikeNone(diff_request) ? 0xFFFFFF : diff_request ? 1 : 0);
+    return WasmRemoteNodeNewResult.__wrap(ret);
+}
+
+/**
+* @param {number} remote_node_pointer
+*/
+function hakuban_remote_node_drop(remote_node_pointer) {
+    wasm.hakuban_remote_node_drop(remote_node_pointer);
+}
+
+/**
+* @param {number} remote_node_pointer
+* @returns {Uint8Array}
+*/
+function hakuban_remote_node_connected(remote_node_pointer) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.hakuban_remote_node_connected(retptr, remote_node_pointer);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var r2 = getInt32Memory0()[retptr / 4 + 2];
+        var r3 = getInt32Memory0()[retptr / 4 + 3];
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v0 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_free(r0, r1 * 1);
+        return v0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+* @param {number} remote_node_pointer
+*/
+function hakuban_remote_node_disconnected(remote_node_pointer) {
+    wasm.hakuban_remote_node_disconnected(remote_node_pointer);
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1);
+    getUint8Memory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+/**
+* @param {number} remote_node_pointer
+* @param {Uint8Array} data
+* @returns {Uint8Array}
+*/
+function hakuban_remote_node_received_message(remote_node_pointer, data) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        var ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.hakuban_remote_node_received_message(retptr, remote_node_pointer, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var r2 = getInt32Memory0()[retptr / 4 + 2];
+        var r3 = getInt32Memory0()[retptr / 4 + 3];
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v1 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_free(r0, r1 * 1);
+        return v1;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+* @param {number} remote_node_pointer
+* @param {Promise<any>} cancel
+* @returns {Promise<any>}
+*/
+function hakuban_remote_node_next_local_node_event(remote_node_pointer, cancel) {
+    var ret = wasm.hakuban_remote_node_next_local_node_event(remote_node_pointer, addHeapObject(cancel));
+    return takeObject(ret);
+}
+
+/**
+* @param {number} remote_node_pointer
+* @param {string} event
+* @returns {Uint8Array}
+*/
+function hakuban_remote_node_received_local_node_event(remote_node_pointer, event) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        var ptr0 = passStringToWasm0(event, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.hakuban_remote_node_received_local_node_event(retptr, remote_node_pointer, ptr0, len0);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var r2 = getInt32Memory0()[retptr / 4 + 2];
+        var r3 = getInt32Memory0()[retptr / 4 + 3];
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v1 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_free(r0, r1 * 1);
+        return v1;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+* @param {number} remote_node_pointer
+* @returns {Uint8Array}
+*/
+function hakuban_remote_node_ack(remote_node_pointer) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.hakuban_remote_node_ack(retptr, remote_node_pointer);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var v0 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_free(r0, r1 * 1);
+        return v0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+* @param {number} local_node
+* @param {string} descriptor
+* @returns {WasmTagExposeResult}
+*/
+function hakuban_tag_expose_new(local_node, descriptor) {
+    var ptr0 = passStringToWasm0(descriptor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ret = wasm.hakuban_tag_expose_new(local_node, ptr0, len0);
+    return WasmTagExposeResult.__wrap(ret);
+}
+
+/**
+* @param {number} tag_expose_pointer
+*/
+function hakuban_tag_expose_drop(tag_expose_pointer) {
+    wasm.hakuban_tag_expose_drop(tag_expose_pointer);
+}
+
+/**
+* @param {number} tag_expose_pointer
+* @returns {string}
+*/
+function hakuban_tag_expose_object_descriptors(tag_expose_pointer) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.hakuban_tag_expose_object_descriptors(retptr, tag_expose_pointer);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(r0, r1);
+    }
+}
+
+/**
+* @param {number} tag_expose_pointer
+* @param {string} object_descriptor
+* @param {string} data_version
+* @param {string} data_type
+* @param {Uint8Array} data
+* @param {BigInt} assignment_id
+* @returns {WasmTagExposeSetObjectStateResult}
+*/
+function hakuban_tag_expose_set_object_state(tag_expose_pointer, object_descriptor, data_version, data_type, data, assignment_id) {
+    var ptr0 = passStringToWasm0(object_descriptor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ptr1 = passStringToWasm0(data_version, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    var ptr2 = passStringToWasm0(data_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len2 = WASM_VECTOR_LEN;
+    var ptr3 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    var len3 = WASM_VECTOR_LEN;
+    uint64CvtShim[0] = assignment_id;
+    const low4 = u32CvtShim[0];
+    const high4 = u32CvtShim[1];
+    var ret = wasm.hakuban_tag_expose_set_object_state(tag_expose_pointer, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, low4, high4);
+    return WasmTagExposeSetObjectStateResult.__wrap(ret);
+}
+
+/**
+* @param {number} tag_expose_pointer
+* @param {string} object_descriptor
+* @returns {WasmTagExposeAssignmentResult}
+*/
+function hakuban_tag_expose_assignment(tag_expose_pointer, object_descriptor) {
+    var ptr0 = passStringToWasm0(object_descriptor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ret = wasm.hakuban_tag_expose_assignment(tag_expose_pointer, ptr0, len0);
+    return WasmTagExposeAssignmentResult.__wrap(ret);
+}
+
+/**
+* @param {number} tag_expose_pointer
+* @param {string} object_descriptor
+* @param {BigInt} assignment_id
+* @returns {number}
+*/
+function hakuban_tag_expose_desynchronize(tag_expose_pointer, object_descriptor, assignment_id) {
+    var ptr0 = passStringToWasm0(object_descriptor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    uint64CvtShim[0] = assignment_id;
+    const low1 = u32CvtShim[0];
+    const high1 = u32CvtShim[1];
+    var ret = wasm.hakuban_tag_expose_desynchronize(tag_expose_pointer, ptr0, len0, low1, high1);
+    return ret >>> 0;
+}
+
+/**
+* @param {number} tag_expose_ptr
+* @returns {number}
+*/
+function hakuban_tag_expose_events_get(tag_expose_ptr) {
+    var ret = wasm.hakuban_tag_expose_events_get(tag_expose_ptr);
+    return ret;
+}
+
+/**
+* @param {number} local_node
+* @param {string} descriptor
+* @returns {WasmObjectExposeResult}
+*/
+function hakuban_object_expose_new(local_node, descriptor) {
+    var ptr0 = passStringToWasm0(descriptor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ret = wasm.hakuban_object_expose_new(local_node, ptr0, len0);
+    return WasmObjectExposeResult.__wrap(ret);
+}
+
+/**
+* @param {number} object_expose_pointer
+*/
+function hakuban_object_expose_drop(object_expose_pointer) {
+    wasm.hakuban_object_expose_drop(object_expose_pointer);
+}
+
+/**
+* @param {number} object_expose_pointer
+* @param {string} data_version
+* @param {string} data_type
+* @param {Uint8Array} data
+* @param {BigInt} assignment_id
+* @returns {WasmObjectExposeStateResult}
+*/
+function hakuban_object_expose_set_state(object_expose_pointer, data_version, data_type, data, assignment_id) {
+    var ptr0 = passStringToWasm0(data_version, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ptr1 = passStringToWasm0(data_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    var ptr2 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    var len2 = WASM_VECTOR_LEN;
+    uint64CvtShim[0] = assignment_id;
+    const low3 = u32CvtShim[0];
+    const high3 = u32CvtShim[1];
+    var ret = wasm.hakuban_object_expose_set_state(object_expose_pointer, ptr0, len0, ptr1, len1, ptr2, len2, low3, high3);
+    return WasmObjectExposeStateResult.__wrap(ret);
+}
+
+/**
+* @param {number} object_expose_pointer
+* @returns {BigInt}
+*/
+function hakuban_object_expose_assignment(object_expose_pointer) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.hakuban_object_expose_assignment(retptr, object_expose_pointer);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        u32CvtShim[0] = r0;
+        u32CvtShim[1] = r1;
+        const n0 = uint64CvtShim[0];
+        return n0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+* @param {number} object_expose_pointer
+* @param {BigInt} assignment_id
+*/
+function hakuban_object_expose_desynchronize(object_expose_pointer, assignment_id) {
+    uint64CvtShim[0] = assignment_id;
+    const low0 = u32CvtShim[0];
+    const high0 = u32CvtShim[1];
+    wasm.hakuban_object_expose_desynchronize(object_expose_pointer, low0, high0);
+}
+
+/**
+* @param {number} object_expose_ptr
+* @returns {number}
+*/
+function hakuban_object_expose_events_get(object_expose_ptr) {
+    var ret = wasm.hakuban_object_expose_events_get(object_expose_ptr);
+    return ret;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_exn_store(addHeapObject(e));
+    }
+}
+function __wbg_adapter_120(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures__invoke2_mut__h3fbc4a767cc461bf(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+/**
+*/
+Object.freeze({ None:0,"0":"None",InvalidString:1,"1":"InvalidString",InvalidJSON:2,"2":"InvalidJSON",InvalidURL:3,"3":"InvalidURL",ObjectNotFound:4,"4":"ObjectNotFound", });
+/**
+*/
+class WasmHashResult {
+
+    static __wrap(ptr) {
+        const obj = Object.create(WasmHashResult.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmhashresult_free(ptr);
+    }
+    /**
+    */
+    get error() {
+        var ret = wasm.__wbg_get_wasmhashresult_error(this.ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set error(arg0) {
+        wasm.__wbg_set_wasmhashresult_error(this.ptr, arg0);
+    }
+    /**
+    */
+    get hash() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_wasmhashresult_hash(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            u32CvtShim[0] = r0;
+            u32CvtShim[1] = r1;
+            const n0 = uint64CvtShim[0];
+            return n0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * @param {BigInt} arg0
+    */
+    set hash(arg0) {
+        uint64CvtShim[0] = arg0;
+        const low0 = u32CvtShim[0];
+        const high0 = u32CvtShim[1];
+        wasm.__wbg_set_wasmhashresult_hash(this.ptr, low0, high0);
+    }
+}
+/**
+*/
+class WasmLocalNodeNewResult {
+
+    static __wrap(ptr) {
+        const obj = Object.create(WasmLocalNodeNewResult.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmlocalnodenewresult_free(ptr);
+    }
+    /**
+    */
+    get error() {
+        var ret = wasm.__wbg_get_wasmlocalnodenewresult_error(this.ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set error(arg0) {
+        wasm.__wbg_set_wasmlocalnodenewresult_error(this.ptr, arg0);
+    }
+    /**
+    */
+    get local_node_pointer() {
+        var ret = wasm.__wbg_get_wasmlocalnodenewresult_local_node_pointer(this.ptr);
+        return ret;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set local_node_pointer(arg0) {
+        wasm.__wbg_set_wasmlocalnodenewresult_local_node_pointer(this.ptr, arg0);
+    }
+}
+/**
+*/
+class WasmObjectExposeResult {
+
+    static __wrap(ptr) {
+        const obj = Object.create(WasmObjectExposeResult.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmobjectexposeresult_free(ptr);
+    }
+    /**
+    */
+    get error() {
+        var ret = wasm.__wbg_get_wasmobjectexposeresult_error(this.ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set error(arg0) {
+        wasm.__wbg_set_wasmobjectexposeresult_error(this.ptr, arg0);
+    }
+    /**
+    */
+    get object_expose_pointer() {
+        var ret = wasm.__wbg_get_wasmobjectexposeresult_object_expose_pointer(this.ptr);
+        return ret;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set object_expose_pointer(arg0) {
+        wasm.__wbg_set_wasmobjectexposeresult_object_expose_pointer(this.ptr, arg0);
+    }
+}
+/**
+*/
+class WasmObjectExposeStateResult {
+
+    static __wrap(ptr) {
+        const obj = Object.create(WasmObjectExposeStateResult.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmobjectexposestateresult_free(ptr);
+    }
+    /**
+    */
+    get error() {
+        var ret = wasm.__wbg_get_wasmobjectexposestateresult_error(this.ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set error(arg0) {
+        wasm.__wbg_set_wasmobjectexposestateresult_error(this.ptr, arg0);
+    }
+    /**
+    */
+    get changed() {
+        var ret = wasm.__wbg_get_wasmobjectexposestateresult_changed(this.ptr);
+        return ret !== 0;
+    }
+    /**
+    * @param {boolean} arg0
+    */
+    set changed(arg0) {
+        wasm.__wbg_set_wasmobjectexposestateresult_changed(this.ptr, arg0);
+    }
+}
+/**
+*/
+class WasmObjectObserveResult {
+
+    static __wrap(ptr) {
+        const obj = Object.create(WasmObjectObserveResult.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmobjectobserveresult_free(ptr);
+    }
+    /**
+    */
+    get error() {
+        var ret = wasm.__wbg_get_wasmobjectobserveresult_error(this.ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set error(arg0) {
+        wasm.__wbg_set_wasmobjectobserveresult_error(this.ptr, arg0);
+    }
+    /**
+    */
+    get object_observe_pointer() {
+        var ret = wasm.__wbg_get_wasmobjectobserveresult_object_observe_pointer(this.ptr);
+        return ret;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set object_observe_pointer(arg0) {
+        wasm.__wbg_set_wasmobjectobserveresult_object_observe_pointer(this.ptr, arg0);
+    }
+}
+/**
+*/
+class WasmRemoteNodeNewResult {
+
+    static __wrap(ptr) {
+        const obj = Object.create(WasmRemoteNodeNewResult.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmremotenodenewresult_free(ptr);
+    }
+    /**
+    */
+    get error() {
+        var ret = wasm.__wbg_get_wasmremotenodenewresult_error(this.ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set error(arg0) {
+        wasm.__wbg_set_wasmremotenodenewresult_error(this.ptr, arg0);
+    }
+    /**
+    */
+    get remote_node_pointer() {
+        var ret = wasm.__wbg_get_wasmremotenodenewresult_remote_node_pointer(this.ptr);
+        return ret;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set remote_node_pointer(arg0) {
+        wasm.__wbg_set_wasmremotenodenewresult_remote_node_pointer(this.ptr, arg0);
+    }
+}
+/**
+*/
+class WasmTagExposeAssignmentResult {
+
+    static __wrap(ptr) {
+        const obj = Object.create(WasmTagExposeAssignmentResult.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmtagexposeassignmentresult_free(ptr);
+    }
+    /**
+    */
+    get error() {
+        var ret = wasm.__wbg_get_wasmtagexposeassignmentresult_error(this.ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set error(arg0) {
+        wasm.__wbg_set_wasmtagexposeassignmentresult_error(this.ptr, arg0);
+    }
+    /**
+    */
+    get assignment() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.__wbg_get_wasmtagexposeassignmentresult_assignment(retptr, this.ptr);
+            var r0 = getInt32Memory0()[retptr / 4 + 0];
+            var r1 = getInt32Memory0()[retptr / 4 + 1];
+            u32CvtShim[0] = r0;
+            u32CvtShim[1] = r1;
+            const n0 = uint64CvtShim[0];
+            return n0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+    * @param {BigInt} arg0
+    */
+    set assignment(arg0) {
+        uint64CvtShim[0] = arg0;
+        const low0 = u32CvtShim[0];
+        const high0 = u32CvtShim[1];
+        wasm.__wbg_set_wasmtagexposeassignmentresult_assignment(this.ptr, low0, high0);
+    }
+}
+/**
+*/
+class WasmTagExposeResult {
+
+    static __wrap(ptr) {
+        const obj = Object.create(WasmTagExposeResult.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmtagexposeresult_free(ptr);
+    }
+    /**
+    */
+    get error() {
+        var ret = wasm.__wbg_get_wasmtagexposeresult_error(this.ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set error(arg0) {
+        wasm.__wbg_set_wasmtagexposeresult_error(this.ptr, arg0);
+    }
+    /**
+    */
+    get tag_expose_pointer() {
+        var ret = wasm.__wbg_get_wasmtagexposeresult_tag_expose_pointer(this.ptr);
+        return ret;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set tag_expose_pointer(arg0) {
+        wasm.__wbg_set_wasmtagexposeresult_tag_expose_pointer(this.ptr, arg0);
+    }
+}
+/**
+*/
+class WasmTagExposeSetObjectStateResult {
+
+    static __wrap(ptr) {
+        const obj = Object.create(WasmTagExposeSetObjectStateResult.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmtagexposesetobjectstateresult_free(ptr);
+    }
+    /**
+    */
+    get error() {
+        var ret = wasm.__wbg_get_wasmtagexposesetobjectstateresult_error(this.ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set error(arg0) {
+        wasm.__wbg_set_wasmtagexposesetobjectstateresult_error(this.ptr, arg0);
+    }
+    /**
+    */
+    get changed() {
+        var ret = wasm.__wbg_get_wasmtagexposesetobjectstateresult_changed(this.ptr);
+        return ret !== 0;
+    }
+    /**
+    * @param {boolean} arg0
+    */
+    set changed(arg0) {
+        wasm.__wbg_set_wasmtagexposesetobjectstateresult_changed(this.ptr, arg0);
+    }
+}
+/**
+*/
+class WasmTagObserveObjectStateBorrowResult {
+
+    static __wrap(ptr) {
+        const obj = Object.create(WasmTagObserveObjectStateBorrowResult.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmtagobserveobjectstateborrowresult_free(ptr);
+    }
+    /**
+    */
+    get error() {
+        var ret = wasm.__wbg_get_wasmtagobserveobjectstateborrowresult_error(this.ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set error(arg0) {
+        wasm.__wbg_set_wasmtagobserveobjectstateborrowresult_error(this.ptr, arg0);
+    }
+    /**
+    */
+    get state_pointer() {
+        var ret = wasm.__wbg_get_wasmtagobserveobjectstateborrowresult_state_pointer(this.ptr);
+        return ret;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set state_pointer(arg0) {
+        wasm.__wbg_set_wasmtagobserveobjectstateborrowresult_state_pointer(this.ptr, arg0);
+    }
+}
+/**
+*/
+class WasmTagObserveResult {
+
+    static __wrap(ptr) {
+        const obj = Object.create(WasmTagObserveResult.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmtagobserveresult_free(ptr);
+    }
+    /**
+    */
+    get error() {
+        var ret = wasm.__wbg_get_wasmtagobserveresult_error(this.ptr);
+        return ret >>> 0;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set error(arg0) {
+        wasm.__wbg_set_wasmtagobserveresult_error(this.ptr, arg0);
+    }
+    /**
+    */
+    get tag_observe_pointer() {
+        var ret = wasm.__wbg_get_wasmtagobserveresult_tag_observe_pointer(this.ptr);
+        return ret;
+    }
+    /**
+    * @param {number} arg0
+    */
+    set tag_observe_pointer(arg0) {
+        wasm.__wbg_set_wasmtagobserveresult_tag_observe_pointer(this.ptr, arg0);
+    }
+}
+
+async function load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+
+            } catch (e) {
+                if (module.headers.get('Content-Type') != 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+
+        } else {
+            return instance;
+        }
+    }
+}
+
+async function init(input) {
+    if (typeof input === 'undefined') {
+        input = new URL('hakuban_bg.wasm', import.meta.url);
+    }
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+        takeObject(arg0);
+    };
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        var ret = getStringFromWasm0(arg0, arg1);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_cb_drop = function(arg0) {
+        const obj = takeObject(arg0).original;
+        if (obj.cnt-- == 1) {
+            obj.a = 0;
+            return true;
+        }
+        var ret = false;
+        return ret;
+    };
+    imports.wbg.__wbg_debug_6e114a5b27d7915d = function(arg0) {
+        console.debug(getObject(arg0));
+    };
+    imports.wbg.__wbg_error_ca520cb687b085a1 = function(arg0) {
+        console.error(getObject(arg0));
+    };
+    imports.wbg.__wbg_info_32ab782ec7072fac = function(arg0) {
+        console.info(getObject(arg0));
+    };
+    imports.wbg.__wbg_log_fbd13631356d44e4 = function(arg0) {
+        console.log(getObject(arg0));
+    };
+    imports.wbg.__wbg_warn_97f10a6b0dbb8c5c = function(arg0) {
+        console.warn(getObject(arg0));
+    };
+    imports.wbg.__wbg_now_5fa0ca001e042f8a = function(arg0) {
+        var ret = getObject(arg0).now();
+        return ret;
+    };
+    imports.wbg.__wbg_newnoargs_f579424187aa1717 = function(arg0, arg1) {
+        var ret = new Function(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_get_8bbb82393651dd9c = function() { return handleError(function (arg0, arg1) {
+        var ret = Reflect.get(getObject(arg0), getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_call_89558c3e96703ca1 = function() { return handleError(function (arg0, arg1) {
+        var ret = getObject(arg0).call(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_call_94697a95cb7e239c = function() { return handleError(function (arg0, arg1, arg2) {
+        var ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_new_4beacc9c71572250 = 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_120(a, state0.b, arg0, arg1);
+                } finally {
+                    state0.a = a;
+                }
+            };
+            var ret = new Promise(cb0);
+            return addHeapObject(ret);
+        } finally {
+            state0.a = state0.b = 0;
+        }
+    };
+    imports.wbg.__wbg_resolve_4f8f547f26b30b27 = function(arg0) {
+        var ret = Promise.resolve(getObject(arg0));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_then_a6860c82b90816ca = function(arg0, arg1) {
+        var ret = getObject(arg0).then(getObject(arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_then_58a04e42527f52c6 = function(arg0, arg1, arg2) {
+        var ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_self_e23d74ae45fb17d1 = function() { return handleError(function () {
+        var ret = self.self;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_window_b4be7f48b24ac56e = function() { return handleError(function () {
+        var ret = window.window;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_globalThis_d61b1f48a57191ae = function() { return handleError(function () {
+        var ret = globalThis.globalThis;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_global_e7669da72fd7f239 = function() { return handleError(function () {
+        var ret = global.global;
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        var ret = getObject(arg0) === undefined;
+        return ret;
+    };
+    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+        var ret = getObject(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new_693216e109162396 = function() {
+        var ret = new Error();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_stack_0ddaca5d1abfb52f = function(arg0, arg1) {
+        var ret = getObject(arg1).stack;
+        var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbg_error_09919627ac0992f5 = function(arg0, arg1) {
+        try {
+            console.error(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_free(arg0, arg1);
+        }
+    };
+    imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
+        var ret = debugString(getObject(arg1));
+        var ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        getInt32Memory0()[arg0 / 4 + 1] = len0;
+        getInt32Memory0()[arg0 / 4 + 0] = ptr0;
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbindgen_closure_wrapper2024 = function(arg0, arg1, arg2) {
+        var ret = makeMutClosure(arg0, arg1, 490, __wbg_adapter_16);
+        return addHeapObject(ret);
+    };
+
+    if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
+        input = fetch(input);
+    }
+
+
+
+    const { instance, module } = await load(await input, imports);
+
+    wasm = instance.exports;
+    init.__wbindgen_wasm_module = module;
+
+    return wasm;
+}
+
+var Queue;
+
+Queue = class Queue {
+  constructor() {
+    this.queue = [];
+    this.wake = null;
+  }
+
+  push(value) {
+    this.queue.push(value);
+    if (this.wake != null) {
+      this.wake();
+      return this.wake = null;
+    }
+  }
+
+  async shift() {
+    var value;
+    while (true) {
+      value = this.queue.shift();
+      if (value != null) {
+        return value;
+      } else {
+        if (this.wake != null) {
+          throw "2 concurrent shifts on a single queue";
+        }
+        await new Promise((wake) => {
+          this.wake = wake;
+          return null;
+        });
+      }
+    }
+  }
+
+  clear() {
+    return this.queue = [];
+  }
+
+};
+
+var ObjectManagerBuilder = class ObjectManagerBuilder {
+  constructor(contract, managed_object_class) {
+    this.contract = contract;
+    this.managed_object_class = managed_object_class;
+    this._on_exception_policy = "retry";
+    this._retry_backoff = [0.01, 0.1, 1.0, 10.0];
+    this._terminate_on_deactivation = false;
+  }
+
+  on_exception(policy) {
+    this._on_exception_policy = policy;
+    return this;
+  }
+
+  //terminate_on_deactivation: ()->
+  //	@terminate_on_deactivation = true
+  //	@
+  retry_backoff(times) {
+    this._retry_backoff = times;
+    return this;
+  }
+
+  with_async(block) {
+    return new ObjectManager(this.contract, this.managed_object_class, block, this._retry_backoff, this._terminate_on_deactivation, this._on_exception_policy);
+  }
+
+};
+
+var ObjectManager = class ObjectManager {
+  constructor(contract, object_class, block, retry_backoff, terminate_on_deactivation, on_exception_policy) {
+    var event_loop_stop_requested;
+    this.objects = this.objects.bind(this);
+    this.object = this.object.bind(this);
+    this.drop = this.drop.bind(this);
+    this.contract = contract;
+    this._existing_objects = {};
+    this._active_objects = {};
+    this.event_queue = new Queue();
+    //TODO: make one loop out of following two
+    event_loop_stop_requested = new Promise((event_loop_stop) => {
+      this.event_loop_stop = event_loop_stop;
+      return null;
+    });
+    this.event_loop_stopped = new Promise(async(resolve, reject) => {
+      var event, events;
+      events = this.contract.events();
+      while (event = (await Promise.race([events.next(), event_loop_stop_requested]))) {
+        if (typeof event === "undefined" || event === null) {
+          break;
+        }
+        this.event_queue.push(event);
+      }
+      events.drop();
+      return resolve();
+    });
+    this.async_loop_stopped = new Promise(async(resolve, reject) => {
+      var base, base1, descriptor_for_lambda, error, event, heal_multiplier, i, interval_since_last_exception, key, len, name, name1, object, ref, ref1;
+      while ((event = (await this.event_queue.shift())) != null) {
+        switch (event.action) {
+          case "Insert":
+          case "Change":
+          case "Remove":
+          case "Stopped":
+          case "Timer":
+            object = (base = this._existing_objects)[name = event.descriptor.hash()] || (base[name] = new object_class(this.contract, event.descriptor));
+            if (!object.running && (object.block_result != null)) {
+              error = (await object.block_result);
+              object.block_result = null;
+              if (object.last_exception_at != null) {
+                interval_since_last_exception = Date.now() - object.last_exception_at;
+                heal_multiplier = 10;
+                object.current_delay_index -= Math.floor(interval_since_last_exception / (retry_backoff[retry_backoff.length - 1] * 1000.0 * heal_multiplier));
+                if (object.current_delay_index < 0) {
+                  object.current_delay_index = 0;
+                }
+              }
+              if (error != null) {
+                switch (on_exception_policy) {
+                  case "throw":
+                  case "raise":
+                    throw error.exception;
+                  case "retry":
+                    object.last_exception_at = Date.now();
+                    object.earliest_next_run = Date.now() + retry_backoff[object.current_delay_index] * 1000.0;
+                    //wrapped to avoid weird capture effects of coffee
+                    (function(lambda_sleep_time, lambda_descriptor, lambda_event_queue) {
+                      return setTimeout((() => {
+                        return lambda_event_queue.push({
+                          action: "Timer",
+                          descriptor: lambda_descriptor
+                        });
+                      }), lambda_sleep_time);
+                    })(object.earliest_next_run - Date.now(), event.descriptor, this.event_queue);
+                    if (object.current_delay_index < retry_backoff.length - 1) {
+                      object.current_delay_index += 1;
+                    }
+                }
+              }
+            }
+            //when "ignore_failing_descriptor"
+            //when "drop_contract"
+            if (object.check_active()) {
+              if ((block != null) && !object.running && ((object.earliest_next_run == null) || Date.now() >= object.earliest_next_run)) {
+                descriptor_for_lambda = event.descriptor;
+                object.running = true;
+                //wrapped to avoid weird capture effects of coffee
+                object.block_result = (function(descriptor, object, block, event_queue) {
+                  return new Promise(async(resolve, reject) => {
+                    try {
+                      await object.run(block);
+                      return resolve(void 0);
+                    } catch (error1) {
+                      error = error1;
+                      console.error("Exception in hakuban manager lambda:", error);
+                      return resolve(error);
+                    } finally {
+                      object.running = false;
+                      event_queue.push({
+                        action: "Stopped",
+                        descriptor: descriptor_for_lambda
+                      });
+                    }
+                  });
+                })(event.descriptor, object, block, this.event_queue);
+              }
+              (base1 = this._active_objects)[name1 = event.descriptor.hash()] || (base1[name1] = object);
+              object.change();
+            } else {
+              delete this._active_objects[event.descriptor.hash()];
+              if (object.running) {
+                object.stop();
+              } else {
+                delete this._existing_objects[event.descriptor.hash()];
+              }
+            }
+            break;
+          case "Drop":
+            this.event_loop_stop();
+            await this.event_loop_stopped;
+            ref = {...this._existing_objects};
+            for (key in ref) {
+              object = ref[key];
+              if (object.running) {
+                object.stop();
+              } else {
+                delete this._existing_objects[key];
+              }
+            }
+            while (Object.keys(this._existing_objects).length > 0) {
+              event = (await this.event_queue.shift());
+              if (event.action === "Stopped") {
+                delete this._existing_objects[event.descriptor.hash()];
+              }
+            }
+            this.event_queue.clear();
+            ref1 = Object.keys(this._active_objects);
+            for (i = 0, len = ref1.length; i < len; i++) {
+              key = ref1[i];
+              delete this._active_objects[key];
+            }
+            this.contract.drop();
+            this.contract = null;
+            this.event_queue = null;
+            resolve();
+            return;
+          default:
+            throw "Unknown action: " + event.action;
+        }
+      }
+      return reject("Queue died unexpectedly");
+    });
+  }
+
+  objects() {
+    return Object.values(this._active_objects);
+  }
+
+  object() {
+    return Object.values(this._active_objects)[0];
+  }
+
+  async drop() {
+    if (this.contract) {
+      this.event_queue.push({
+        action: 'Drop'
+      });
+      return (await this.async_loop_stopped);
+    }
+  }
+
+};
+
+var ManagedObject = class ManagedObject {
+  constructor(contract, descriptor1) {
+    this.run = this.run.bind(this);
+    this.next_event = this.next_event.bind(this);
+    this.next_change = this.next_change.bind(this);
+    this.change = this.change.bind(this);
+    this.stop = this.stop.bind(this);
+    this.contract = contract;
+    this.descriptor = descriptor1;
+    this._changes = new Queue();
+    this.current_delay_index = 0;
+  }
+
+  async run(handler) {
+    return (await handler(this));
+  }
+
+  next_event() {
+    return this.next_change();
+  }
+
+  async next_change() {
+    while (true) {
+      switch ((await this._changes.shift())) {
+        case "change":
+          return true;
+        case "stop":
+          return false;
+      }
+    }
+  }
+
+  change() {
+    return this._changes.push("change");
+  }
+
+  stop() {
+    return this._changes.push("stop");
+  }
+
+};
+
+var LocalNode_finalization_registry, ObjectBuilder, ObjectDescriptorEvents, ObjectDescriptorEvents_finalization_registry, ObjectExpose, ObjectExpose_finalization_registry, ObjectObserve, ObjectObserve_finalization_registry, TagBuilder, TagExpose, TagExpose_finalization_registry, TagObserve, TagObserve_finalization_registry, WebsocketConnector_finalization_registry, logger_initialized, raise_if_error,
+  boundMethodCheck = function(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new Error('Bound instance method accessed before binding'); } };
+
+logger_initialized = false;
+
+var initialize_wasm = async function(wasm) {
+  return (await init(wasm));
+};
+
+var logger_initialize = async function(log_level, skip_if_already_initialized = false) {
+  var error;
+  if (logger_initialized && skip_if_already_initialized) {
+    return true;
+  }
+  if (0 === (error = (await hakuban_logger_initialize(log_level)))) {
+    return logger_initialized = true;
+  } else {
+    console.error("Failed to initialize logger, error " + error);
+    return false;
+  }
+};
+
+raise_if_error = function(error_code) {
+  if (error_code !== 0) {
+    throw "Hakuban error: " + error_code;
+  }
+};
+
+var JSON_serialize = function(data_type, cooked) {
+  return {
+    data_type: ["JSON"].concat(data_type),
+    data: new TextEncoder().encode(JSON.stringify(cooked))
+  };
+};
+
+var JSON_deserialize = function(data_type, raw) {
+  if (data_type.length === 0 || data_type[0] !== "JSON") {
+    throw "Expected JSON data_type, got: " + data_type;
+  }
+  return {
+    data_type: data_type.slice(1),
+    data: JSON.parse(new TextDecoder().decode(raw))
+  };
+};
+
+var ObjectDescriptor = class ObjectDescriptor {
+  constructor(tags, json1) {
+    var tag;
+    this.json = json1;
+    this.tags = (function() {
+      var i, len, results;
+      results = [];
+      for (i = 0, len = tags.length; i < len; i++) {
+        tag = tags[i];
+        results.push(tag instanceof TagDescriptor ? tag : new TagDescriptor(tag));
+      }
+      return results;
+    })();
+  }
+
+  as_json() {
+    return JSON.stringify({
+      tags: this.tags.map(function(tag) {
+        return tag.json;
+      }),
+      json: this.json
+    });
+  }
+
+  hash() {
+    var ret;
+    if (this._hash == null) {
+      this._hash = this.tags.map(function(tag) {
+        return tag.hash().toString();
+      }).sort().join(",") + "|";
+      ret = hakuban_json_hash(JSON.stringify(this.json));
+      raise_if_error(ret.error);
+      this._hash += ret.hash.toString();
+    }
+    return this._hash;
+  }
+
+};
+
+var TagDescriptor = class TagDescriptor {
+  constructor(json1) {
+    this.json = json1;
+  }
+
+  as_json() {
+    return JSON.stringify(this.json);
+  }
+
+  hash() {
+    var ret;
+    if (this._hash == null) {
+      ret = hakuban_json_hash(JSON.stringify(this.json));
+      raise_if_error(ret.error);
+      this._hash = ret.hash;
+    }
+    return this._hash;
+  }
+
+};
+
+LocalNode_finalization_registry = new FinalizationRegistry((pointer) => {
+  return hakuban_local_node_drop(pointer);
+});
+
+var LocalNode = class LocalNode {
+  constructor(name = "wasm") {
+    var result;
+    this.name = name;
+    logger_initialize("warn", true);
+    result = hakuban_local_node_new(this.name);
+    raise_if_error(result.error);
+    this.pointer = result.local_node_pointer;
+    LocalNode_finalization_registry.register(this, this.pointer, this);
+    this.with_default_serializer(JSON_serialize);
+    this.with_default_deserializer(JSON_deserialize);
+  }
+
+  destroy() {
+    hakuban_local_node_drop(this.pointer);
+    return LocalNode_finalization_registry.unregister(this);
+  }
+
+  object(tags, json) {
+    return new ObjectBuilder(this, this.default_serializer, this.default_deserializer, tags, json);
+  }
+
+  tag(json) {
+    return new TagBuilder(this, this.default_serializer, this.default_deserializer, json);
+  }
+
+  with_default_serializer(default_serializer) {
+    this.default_serializer = default_serializer;
+    return this;
+  }
+
+  with_default_deserializer(default_deserializer) {
+    this.default_deserializer = default_deserializer;
+    return this;
+  }
+
+};
+
+ObjectBuilder = class ObjectBuilder {
+  constructor(local_node, serializer, deserializer, tags1, json1) {
+    this.local_node = local_node;
+    this.serializer = serializer;
+    this.deserializer = deserializer;
+    this.tags = tags1;
+    this.json = json1;
+  }
+
+  observe() {
+    return new ObjectObserve(this.local_node, new ObjectDescriptor(this.tags, this.json), this.deserializer);
+  }
+
+  expose() {
+    return new ObjectExpose(this.local_node, new ObjectDescriptor(this.tags, this.json), this.serializer);
+  }
+
+  with_serializer(serializer) {
+    this.serializer = serializer;
+    return this;
+  }
+
+  with_deserializer(deserializer) {
+    this.deserializer = deserializer;
+    return this;
+  }
+
+};
+
+TagBuilder = class TagBuilder {
+  constructor(local_node, serializer, deserializer, json1) {
+    this.local_node = local_node;
+    this.serializer = serializer;
+    this.deserializer = deserializer;
+    this.json = json1;
+  }
+
+  observe() {
+    return new TagObserve(this.local_node, new TagDescriptor(this.json), this.deserializer);
+  }
+
+  expose() {
+    return new TagExpose(this.local_node, new TagDescriptor(this.json), this.serializer);
+  }
+
+  with_serializer(serializer) {
+    this.serializer = serializer;
+    return this;
+  }
+
+  with_deserializer(deserializer) {
+    this.deserializer = deserializer;
+    return this;
+  }
+
+};
+
+ObjectDescriptorEvents_finalization_registry = new FinalizationRegistry((pointer) => {
+  return hakuban_object_descriptor_events_drop(pointer);
+});
+
+ObjectDescriptorEvents = class ObjectDescriptorEvents {
+  constructor(pointer1) {
+    this.wait = this.wait.bind(this);
+    this.next = this.next.bind(this);
+    this.drop = this.drop.bind(this);
+    this.pointer = pointer1;
+    ObjectDescriptorEvents_finalization_registry.register(this, this.pointer, this);
+  }
+
+  wait() {
+    return next();
+  }
+
+  next() {
+    var cancel_waiting_promise, next_event_promise;
+    this.wait_released = new Promise((wait_release) => {
+      this.wait_release = wait_release;
+      return null;
+    });
+    cancel_waiting_promise = new Promise((resolve) => {
+      return this.cancel_waiting_resolve = resolve;
+    });
+    next_event_promise = hakuban_object_descriptor_events_next(this.pointer, cancel_waiting_promise);
+    next_event_promise.cancel = async(value) => {
+      this.cancel_waiting_resolve.resolve(value);
+      return (await next_event_promise);
+    };
+    return next_event_promise.then((value) => {
+      var parsed;
+      this.wait_release();
+      this.wait_released = null;
+      this.cancel_waiting_resolve = null;
+      parsed = JSON.parse(value);
+      return {
+        action: parsed.action,
+        descriptor: new ObjectDescriptor(parsed.key.tags, parsed.key.json)
+      };
+    });
+  }
+
+  async drop() {
+    if (this.cancel_waiting_resolve != null) {
+      this.cancel_waiting_resolve();
+      await this.wait_released;
+    }
+    ObjectDescriptorEvents_finalization_registry.unregister(this);
+    hakuban_object_descriptor_events_drop(this.pointer);
+    return this.pointer = null;
+  }
+
+};
+
+ObjectObserve_finalization_registry = new FinalizationRegistry((pointer) => {
+  return hakuban_object_observe_drop(pointer);
+});
+
+ObjectObserve = class ObjectObserve {
+  constructor(local_node, descriptor1, deserializer) {
+    var result;
+    this.drop = this.drop.bind(this);
+    this.object_state = this.object_state.bind(this);
+    this.events = this.events.bind(this);
+    this.manage = this.manage.bind(this);
+    this.local_node = local_node;
+    this.descriptor = descriptor1;
+    this.deserializer = deserializer;
+    result = hakuban_object_observe_new(this.local_node.pointer, this.descriptor.as_json());
+    raise_if_error(result.error);
+    this.pointer = result.object_observe_pointer;
+    ObjectObserve_finalization_registry.register(this, this.pointer, this);
+    this.dropped = false;
+  }
+
+  drop() {
+    this.dropped = true;
+    hakuban_object_observe_drop(this.pointer);
+    ObjectObserve_finalization_registry.unregister(this);
+    return this.pointer = null;
+  }
+
+  object_state() {
+    var data_type, deserialized, raw, state_pointer, synchronized, version;
+    if (this.pointer == null) {
+      return null;
+    }
+    state_pointer = hakuban_object_observe_state_borrow(this.pointer);
+    if (state_pointer === 0) {
+      return null;
+    }
+    synchronized = hakuban_object_observe_state_synchronized(state_pointer);
+    version = JSON.parse(hakuban_object_observe_state_data_version(state_pointer));
+    data_type = JSON.parse(hakuban_object_observe_state_data_type(state_pointer));
+    raw = hakuban_object_observe_state_data(state_pointer);
+    hakuban_object_observe_state_return(state_pointer);
+    deserialized = this.deserializer(data_type, raw);
+    return {
+      version: version,
+      data: deserialized.data,
+      data_type: deserialized.data_type,
+      synchronized: synchronized
+    };
+  }
+
+  events() {
+    return new ObjectDescriptorEvents(hakuban_object_observe_events_get(this.pointer));
+  }
+
+  manage() {
+    var ManagedObject$1;
+    ManagedObject$1 = class ManagedObject$1 extends ManagedObject {
+      state() {
+        var ref;
+        return (ref = this.contract) != null ? ref.object_state() : void 0;
+      }
+
+      data() {
+        var ref, ref1;
+        return (ref = this.contract) != null ? (ref1 = ref.object_state()) != null ? ref1.data : void 0 : void 0;
+      }
+
+      check_active() {
+        return !!this.state();
+      }
+
+    };
+    return new ObjectManagerBuilder(this, ManagedObject$1);
+  }
+
+};
+
+ObjectExpose_finalization_registry = new FinalizationRegistry((pointer) => {
+  return hakuban_object_expose_drop(pointer);
+});
+
+ObjectExpose = class ObjectExpose {
+  constructor(local_node, descriptor1, serializer) {
+    var result;
+    this.drop = this.drop.bind(this);
+    this.set_object_state = this.set_object_state.bind(this);
+    this.assignment = this.assignment.bind(this);
+    this.assigned = this.assigned.bind(this);
+    this.desynchronize = this.desynchronize.bind(this);
+    this.events = this.events.bind(this);
+    this.manage = this.manage.bind(this);
+    this.local_node = local_node;
+    this.descriptor = descriptor1;
+    this.serializer = serializer;
+    result = hakuban_object_expose_new(this.local_node.pointer, this.descriptor.as_json());
+    raise_if_error(result.error);
+    this.pointer = result.object_expose_pointer;
+    ObjectExpose_finalization_registry.register(this, this.pointer, this);
+    this.dropped = false;
+  }
+
+  drop() {
+    this.dropped = true;
+    hakuban_object_expose_drop(this.pointer);
+    return ObjectExpose_finalization_registry.unregister(this);
+  }
+
+  set_object_state(version, cooked_data, data_type = [], assignment = 0) {
+    var result, serialized;
+    serialized = this.serializer(data_type, cooked_data);
+    if (!(typeof assignment === 'bigint')) {
+      assignment = BigInt(assignment);
+    }
+    result = hakuban_object_expose_set_state(this.pointer, JSON.stringify(version), JSON.stringify(serialized.data_type), serialized.data, assignment);
+    raise_if_error(result.error);
+    return result.changed;
+  }
+
+  assignment() {
+    return hakuban_object_expose_assignment(this.pointer);
+  }
+
+  assigned() {
+    return this.assignment() > 0;
+  }
+
+  desynchronize(assignment) {
+    if (!(typeof assignment === 'bigint')) {
+      assignment = BigInt(assignment);
+    }
+    return hakuban_object_expose_desynchronize(this.pointer, assignment);
+  }
+
+  events() {
+    return new ObjectDescriptorEvents(hakuban_object_expose_events_get(this.pointer));
+  }
+
+  manage() {
+    var ManagedObject$1;
+    ManagedObject$1 = class ManagedObject$1 extends ManagedObject {
+      constructor(contract, descriptor) {
+        super(contract, descriptor);
+        this.run = this.run.bind(this);
+        this.do_change = this.do_change.bind(this);
+        this.assignment = this.assignment.bind(this);
+        this.assigned = this.assigned.bind(this);
+        this.set_state = this.set_state.bind(this);
+        this.set_data = this.set_data.bind(this);
+        this._assignment = contract.assignment();
+      }
+
+      async run(handler) {
+        var ref;
+        boundMethodCheck(this, ManagedObject$1);
+        await super.run(handler);
+        return (ref = this.contract) != null ? ref.desynchronize(this._assignment) : void 0;
+      }
+
+      do_change(change) {
+        var ref;
+        boundMethodCheck(this, ManagedObject$1);
+        this._assignment = (ref = this.contract) != null ? ref.assignment() : void 0;
+        return super.do_change(change);
+      }
+
+      assignment() {
+        var ref;
+        boundMethodCheck(this, ManagedObject$1);
+        return (ref = this.contract) != null ? ref.assignment() : void 0;
+      }
+
+      assigned() {
+        var ref;
+        boundMethodCheck(this, ManagedObject$1);
+        return (ref = this.contract) != null ? ref.assigned() : void 0;
+      }
+
+      set_state(version, cooked_data, data_type = []) {
+        var ref;
+        boundMethodCheck(this, ManagedObject$1);
+        return (ref = this.contract) != null ? ref.set_object_state(version, cooked_data, data_type, this._assignment) : void 0;
+      }
+
+      set_data(data) {
+        var timestamp;
+        boundMethodCheck(this, ManagedObject$1);
+        timestamp = new Date().getTime();
+        return this.set_state([1, Math.floor(timestamp / 1000), timestamp - Math.floor(timestamp / 1000) * 1000, 0], data);
+      }
+
+      check_active() {
+        return this.assigned();
+      }
+
+    };
+    return new ObjectManagerBuilder(this, ManagedObject$1);
+  }
+
+};
+
+TagObserve_finalization_registry = new FinalizationRegistry((pointer) => {
+  return hakuban_tag_observe_drop(pointer);
+});
+
+TagObserve = class TagObserve {
+  constructor(local_node, descriptor1, deserializer) {
+    var result;
+    this.drop = this.drop.bind(this);
+    this.object_descriptors = this.object_descriptors.bind(this);
+    this.object_state = this.object_state.bind(this);
+    this.local_node = local_node;
+    this.descriptor = descriptor1;
+    this.deserializer = deserializer;
+    result = hakuban_tag_observe_new(this.local_node.pointer, this.descriptor.as_json());
+    raise_if_error(result.error);
+    this.pointer = result.tag_observe_pointer;
+    TagObserve_finalization_registry.register(this, this.pointer, this);
+    this.dropped = false;
+  }
+
+  drop() {
+    this.dropped = true;
+    hakuban_tag_observe_drop(this.pointer);
+    return TagObserve_finalization_registry.unregister(this);
+  }
+
+  object_descriptors() {
+    var descriptor_as_json, i, len, ref, result, results;
+    result = hakuban_tag_observe_object_descriptors(this.pointer);
+    ref = JSON.parse(result);
+    results = [];
+    for (i = 0, len = ref.length; i < len; i++) {
+      descriptor_as_json = ref[i];
+      results.push(new ObjectDescriptor(descriptor_as_json.tags, descriptor_as_json.json));
+    }
+    return results;
+  }
+
+  object_state(object_descriptor) {
+    var data_type, deserialized, raw, result, synchronized, version;
+    result = hakuban_tag_observe_object_state_borrow(this.pointer, object_descriptor.as_json());
+    if (result.error === 4) {
+      return null;
+    }
+    if (result.state_pointer === 0) {
+      return null;
+    }
+    synchronized = hakuban_object_observe_state_synchronized(result.state_pointer);
+    version = JSON.parse(hakuban_object_observe_state_data_version(result.state_pointer));
+    data_type = JSON.parse(hakuban_object_observe_state_data_type(result.state_pointer));
+    raw = hakuban_object_observe_state_data(result.state_pointer);
+    hakuban_object_observe_state_return(result.state_pointer);
+    deserialized = this.deserializer(data_type, raw);
+    return {
+      version: version,
+      data: deserialized.data,
+      data_type: deserialized.data_type,
+      synchronized: synchronized
+    };
+  }
+
+  events() {
+    return new ObjectDescriptorEvents(hakuban_tag_observe_events_get(this.pointer));
+  }
+
+  manage() {
+    var ManagedObject$1;
+    ManagedObject$1 = class ManagedObject$1 extends ManagedObject {
+      state() {
+        var ref;
+        return (ref = this.contract) != null ? ref.object_state(this.descriptor) : void 0;
+      }
+
+      data() {
+        var ref, ref1;
+        return (ref = this.contract) != null ? (ref1 = ref.object_state(this.descriptor)) != null ? ref1.data : void 0 : void 0;
+      }
+
+      check_active() {
+        return !!this.state();
+      }
+
+    };
+    return new ObjectManagerBuilder(this, ManagedObject$1);
+  }
+
+};
+
+TagExpose_finalization_registry = new FinalizationRegistry((pointer) => {
+  return hakuban_tag_expose_drop(pointer);
+});
+
+TagExpose = class TagExpose {
+  constructor(local_node, descriptor1, serializer) {
+    var result;
+    this.drop = this.drop.bind(this);
+    this.object_descriptors = this.object_descriptors.bind(this);
+    this.set_object_state = this.set_object_state.bind(this);
+    this.assignment = this.assignment.bind(this);
+    this.assigned = this.assigned.bind(this);
+    this.desynchronize = this.desynchronize.bind(this);
+    this.events = this.events.bind(this);
+    this.manage = this.manage.bind(this);
+    this.local_node = local_node;
+    this.descriptor = descriptor1;
+    this.serializer = serializer;
+    result = hakuban_tag_expose_new(this.local_node.pointer, this.descriptor.as_json());
+    raise_if_error(result.error);
+    this.pointer = result.tag_expose_pointer;
+    TagExpose_finalization_registry.register(this, this.pointer, this);
+    this.dropped = false;
+  }
+
+  drop() {
+    this.dropped = true;
+    hakuban_tag_expose_drop(this.pointer);
+    return TagExpose_finalization_registry.unregister(this);
+  }
+
+  object_descriptors() {
+    var descriptor_as_json, i, len, ref, result, results;
+    result = hakuban_tag_expose_object_descriptors(this.pointer);
+    ref = JSON.parse(result);
+    results = [];
+    for (i = 0, len = ref.length; i < len; i++) {
+      descriptor_as_json = ref[i];
+      results.push(new ObjectDescriptor(descriptor_as_json.tags, descriptor_as_json.json));
+    }
+    return results;
+  }
+
+  set_object_state(object_descriptor, version, cooked_data, data_type = [], assignment = 0) {
+    var result, serialized;
+    serialized = this.serializer(data_type, cooked_data);
+    if (!(typeof assignment === 'bigint')) {
+      assignment = BigInt(assignment);
+    }
+    result = hakuban_tag_expose_set_object_state(this.pointer, object_descriptor.as_json(), JSON.stringify(version), JSON.stringify(serialized.data_type), serialized.data, assignment);
+    raise_if_error(result.error);
+    return result.changed;
+  }
+
+  assignment(object_descriptor) {
+    var result;
+    result = hakuban_tag_expose_assignment(this.pointer, object_descriptor.as_json());
+    raise_if_error(result.error);
+    return result.assignment;
+  }
+
+  assigned(object_descriptor) {
+    return this.assignment(object_descriptor) > 0;
+  }
+
+  desynchronize(object_descriptor, assignment) {
+    var error;
+    if (!(typeof assignment === 'bigint')) {
+      assignment = BigInt(assignment);
+    }
+    error = hakuban_tag_expose_desynchronize(this.pointer, object_descriptor.as_json(), assignment);
+    return raise_if_error(error);
+  }
+
+  events() {
+    return new ObjectDescriptorEvents(hakuban_tag_expose_events_get(this.pointer));
+  }
+
+  manage() {
+    var ManagedObject$1;
+    ManagedObject$1 = class ManagedObject$1 extends ManagedObject {
+      constructor(contract, descriptor) {
+        super(contract, descriptor);
+        this.run = this.run.bind(this);
+        this.do_change = this.do_change.bind(this);
+        this.assignment = this.assignment.bind(this);
+        this.assigned = this.assigned.bind(this);
+        this.set_state = this.set_state.bind(this);
+        this.set_data = this.set_data.bind(this);
+        this._assignment = contract.assignment(this.descriptor);
+      }
+
+      async run(handler) {
+        var ref;
+        boundMethodCheck(this, ManagedObject$1);
+        await super.run(handler);
+        return (ref = this.contract) != null ? ref.desynchronize(this.descriptor, this._assignment) : void 0;
+      }
+
+      do_change(change) {
+        var ref;
+        boundMethodCheck(this, ManagedObject$1);
+        this._assignment = (ref = this.contract) != null ? ref.assignment(this.descriptor) : void 0;
+        return super.do_change(change);
+      }
+
+      assignment() {
+        var ref;
+        boundMethodCheck(this, ManagedObject$1);
+        return (ref = this.contract) != null ? ref.assignment(this.descriptor) : void 0;
+      }
+
+      assigned() {
+        var ref;
+        boundMethodCheck(this, ManagedObject$1);
+        return (ref = this.contract) != null ? ref.assigned(this.descriptor) : void 0;
+      }
+
+      set_state(version, cooked_data, data_type = []) {
+        var ref;
+        boundMethodCheck(this, ManagedObject$1);
+        return (ref = this.contract) != null ? ref.set_object_state(this.descriptor, version, cooked_data, data_type, this._assignment) : void 0;
+      }
+
+      set_data(data) {
+        var timestamp;
+        boundMethodCheck(this, ManagedObject$1);
+        timestamp = new Date().getTime();
+        return this.set_state([1, Math.floor(timestamp / 1000), timestamp - Math.floor(timestamp / 1000) * 1000, 0], data);
+      }
+
+      check_active() {
+        return this.assigned();
+      }
+
+    };
+    return new ObjectManagerBuilder(this, ManagedObject$1);
+  }
+
+};
+
+WebsocketConnector_finalization_registry = new FinalizationRegistry((pointer) => {
+  return hakuban_remote_node_drop(pointer);
+});
+
+//TODO: hide private methods
+//TODO: handle errors somehow
+var WebsocketConnector = class WebsocketConnector {
+  constructor(local_node, uri, options = {}) {
+    var result;
+    this.connect = this.connect.bind(this);
+    this.ping = this.ping.bind(this);
+    this.send = this.send.bind(this);
+    this.ack = this.ack.bind(this);
+    this.local_node = local_node;
+    this.uri = uri;
+    this.options = options;
+    this.connected = false;
+    this.socket = void 0;
+    this.error = void 0;
+    this.reconnection_timer = void 0;
+    this.reconnect_on_close = true;
+    this.ack_timer = void 0;
+    result = hakuban_remote_node_new(this.local_node.pointer, true, true, true);
+    raise_if_error(result.error);
+    this.remote_node_pointer = result.remote_node_pointer;
+    this.event_loop_stop = new Promise((resolve) => {
+      return this.event_loop_stop_resolve = resolve;
+    });
+    this.event_loop_promise = this.event_loop();
+    WebsocketConnector_finalization_registry.register(this, this.remote_node_pointer, this);
+    this.connect();
+  }
+
+  async destroy() {
+    this.event_loop_stop_resolve(["stop"]);
+    await this.event_loop_promise;
+    this.reconnect_on_close = false;
+    if (this.keep_alive_interval) {
+      clearInterval(this.keep_alive_interval);
+    }
+    if (this.reconnection_timer != null) {
+      clearTimeout(this.reconnection_timer);
+      this.reconnection_timer = null;
+    }
+    if (this.socket != null) {
+      this.socket.onclose = null;
+      this.socket.onerror = null;
+      this.socket.onmessage = null;
+      this.socket.close();
+      this.socket_onclose();
+    }
+    if (this.ack_timer != null) {
+      clearTimeout(this.ack_timer);
+      this.ack_timer = null;
+    }
+    hakuban_remote_node_drop(this.remote_node_pointer);
+    return WebsocketConnector_finalization_registry.unregister(this);
+  }
+
+  connect() {
+    var error;
+    this.reconnection_timer = void 0;
+    try {
+      this.socket = new WebSocket(this.uri);
+    } catch (error1) {
+      error = error1;
+      this.error = {
+        while: "connecting",
+        error: error
+      };
+      if (this.onstatuschange_proc != null) {
+        this.onstatuschange_proc(this);
+      }
+      return false;
+    }
+    this.socket.binaryType = "arraybuffer";
+    this.socket.onopen = () => {
+      var bytes_to_send;
+      if (this.options.debug) {
+        console.debug('Connected to hakuban remote node');
+      }
+      this.connected = true;
+      this.error = void 0;
+      if (this.onstatuschange_proc != null) {
+        this.onstatuschange_proc(this);
+      }
+      bytes_to_send = hakuban_remote_node_connected(this.remote_node_pointer);
+      return this.send(bytes_to_send);
+    };
+    this.socket.onclose = this.socket_onclose = () => {
+      if (this.options.debug) {
+        console.debug('Disconnected from hakuban remote node');
+      }
+      if (this.keep_alive_interval) {
+        clearInterval(this.keep_alive_interval);
+      }
+      this.connected = false;
+      this.socket = void 0;
+      hakuban_remote_node_disconnected(this.remote_node_pointer);
+      if (this.onstatuschange_proc != null) {
+        this.onstatuschange_proc(this);
+      }
+      if (this.reconnection_timer != null) {
+        clearTimeout(this.reconnection_timer);
+      }
+      this.reconnection_timer = null;
+      if (this.reconnect_on_close) {
+        return this.reconnection_timer = setTimeout(this.connect, 1000);
+      }
+    };
+    this.socket.onerror = (error) => {
+      if (this.options.debug) {
+        console.debug('Hakuban socket error', error);
+      }
+      return this.error = {
+        while: "connected",
+        error: error
+      };
+    };
+    return this.socket.onmessage = (event) => {
+      var bytes_to_send;
+      bytes_to_send = hakuban_remote_node_received_message(this.remote_node_pointer, new Uint8Array(event.data));
+      this.send(bytes_to_send);
+      if (this.ack_timer != null) {
+        clearTimeout(this.ack_timer);
+      }
+      this.ack_timer = setTimeout(this.ack, 1000);
+      return null;
+    };
+  }
+
+  ping() {
+    if (this.socket) {
+      return this.socket.send(new Uint8Array());
+    }
+  }
+
+  send(bytes_to_send) {
+    if (bytes_to_send.length > 0) {
+      this.socket.send(bytes_to_send);
+      if (this.keep_alive_interval) {
+        clearInterval(this.keep_alive_interval);
+      }
+      return this.keep_alive_interval = setInterval(this.ping, 10000);
+    }
+  }
+
+  ack() {
+    var bytes_to_send;
+    if (this.socket != null) {
+      bytes_to_send = hakuban_remote_node_ack(this.remote_node_pointer);
+      if (bytes_to_send.length > 0) {
+        return this.send(bytes_to_send);
+      }
+    }
+  }
+
+  async event_loop() {
+    var cancel_waiting_promise, cancel_waiting_resolve, event, next_local_node_event, promise;
+    next_local_node_event = false;
+    cancel_waiting_resolve = null;
+    cancel_waiting_promise = new Promise(function(resolve) {
+      return cancel_waiting_resolve = resolve;
+    });
+    while (true) {
+      if (!next_local_node_event) {
+        next_local_node_event = hakuban_remote_node_next_local_node_event(this.remote_node_pointer, cancel_waiting_promise).then(function(event) {
+          return ["local_node_event", event];
+        });
+      }
+      [promise, event] = (await Promise.any([this.event_loop_stop, next_local_node_event]));
+      if (promise === "local_node_event") {
+        next_local_node_event = false;
+        setTimeout(((event) => {
+          var bytes_to_send;
+          if (this.connected) {
+            bytes_to_send = hakuban_remote_node_received_local_node_event(this.remote_node_pointer, event);
+            return this.send(bytes_to_send);
+          }
+        }), 0, event);
+      } else {
+        break;
+      }
+    }
+    if (next_local_node_event) {
+      cancel_waiting_resolve(true);
+      return (await next_local_node_event);
+    }
+  }
+
+  onstatuschange(proc) {
+    this.onstatuschange_proc = proc;
+    if (this.onstatuschange_proc != null) {
+      this.onstatuschange_proc();
+    }
+    return this;
+  }
+
+};
+
+var initialize = async function(wasm) {
+  return (await initialize_wasm(wasm));
+};
+
+export { JSON_deserialize, JSON_serialize, LocalNode, ObjectDescriptor, TagDescriptor, WebsocketConnector, initialize, initialize_wasm, logger_initialize };
+//# sourceMappingURL=hakuban.js.map