hakuban 0.6.2 → 0.7.1

package/hakuban.js

@@ -20,18 +20,87 @@ function takeObject(idx) {
     return ret;
 }
 
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+let WASM_VECTOR_LEN = 0;
 
-cachedTextDecoder.decode();
+let cachedUint8Memory0 = new Uint8Array();
 
-let cachegetUint8Memory0 = null;
 function getUint8Memory0() {
-    if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {
-        cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    if (cachedUint8Memory0.byteLength === 0) {
+        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8Memory0;
+}
+
+const 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;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+let cachedInt32Memory0 = new Int32Array();
+
+function getInt32Memory0() {
+    if (cachedInt32Memory0.byteLength === 0) {
+        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
     }
-    return cachegetUint8Memory0;
+    return cachedInt32Memory0;
 }
 
+const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
 function getStringFromWasm0(ptr, len) {
     return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
 }
@@ -109,220 +178,173 @@ function debugString(val) {
     // 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);
+/**
+* @param {number} local_exchange
+* @param {number} descriptor
+* @returns {number}
+*/
+function hakuban_tag_expose_contract_new(local_exchange, descriptor) {
+    const ret = wasm.hakuban_tag_expose_contract_new(local_exchange, descriptor);
+    return ret;
 }
-    : 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;
+/**
+* @param {number} tag_expose_contract_pointer
+*/
+function hakuban_tag_expose_contract_drop(tag_expose_contract_pointer) {
+    wasm.hakuban_tag_expose_contract_drop(tag_expose_contract_pointer);
 }
 
-let cachegetInt32Memory0 = null;
-function getInt32Memory0() {
-    if (cachegetInt32Memory0 === null || cachegetInt32Memory0.buffer !== wasm.memory.buffer) {
-        cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer);
-    }
-    return cachegetInt32Memory0;
+/**
+* @param {number} tag_expose_pointer
+*/
+function hakuban_tag_expose_contract_terminate(tag_expose_pointer) {
+    wasm.hakuban_tag_expose_contract_terminate(tag_expose_pointer);
 }
 
-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);
+/**
+* @param {number} tag_expose_pointer
+* @returns {number}
+*/
+function hakuban_tag_expose_contract_next(tag_expose_pointer) {
+    const ret = wasm.hakuban_tag_expose_contract_next(tag_expose_pointer);
+    return ret;
+}
 
-            } else {
-                state.a = a;
-            }
-        }
-    };
-    real.original = state;
+let cachedUint32Memory0 = new Uint32Array();
 
-    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));
+function getUint32Memory0() {
+    if (cachedUint32Memory0.byteLength === 0) {
+        cachedUint32Memory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32Memory0;
 }
 
-const u32CvtShim = new Uint32Array(2);
-
-const uint64CvtShim = new BigUint64Array(u32CvtShim.buffer);
+function getArrayU32FromWasm0(ptr, len) {
+    return getUint32Memory0().subarray(ptr / 4, ptr / 4 + len);
+}
 /**
-* @param {string} json_string
-* @returns {WasmHashResult}
+* @param {number} tag_expose_pointer
+* @returns {Uint32Array}
 */
-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);
+function hakuban_tag_expose_contract_ready(tag_expose_pointer) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.hakuban_tag_expose_contract_ready(retptr, tag_expose_pointer);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var v0 = getArrayU32FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_free(r0, r1 * 4);
+        return v0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 }
 
 /**
-* @param {string} default_log_level
+* @param {number} local_exchange
+* @param {number} descriptor
 * @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);
+function hakuban_tag_observe_contract_new(local_exchange, descriptor) {
+    const ret = wasm.hakuban_tag_observe_contract_new(local_exchange, descriptor);
     return ret;
 }
 
 /**
-* @param {string} name_str
-* @returns {WasmLocalNodeNewResult}
+* @param {number} tag_pointer
 */
-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);
+function hakuban_tag_observe_contract_drop(tag_pointer) {
+    wasm.hakuban_tag_observe_contract_drop(tag_pointer);
 }
 
 /**
-* @param {number} local_node
+* @param {number} tag_observe_pointer
 */
-function hakuban_local_node_drop(local_node) {
-    wasm.hakuban_local_node_drop(local_node);
+function hakuban_tag_observe_contract_terminate(tag_observe_pointer) {
+    wasm.hakuban_tag_observe_contract_terminate(tag_observe_pointer);
 }
 
 /**
-* @param {number} local_node
-* @param {string} descriptor
-* @returns {WasmObjectObserveResult}
+* @param {number} tag_observe_pointer
+* @returns {number}
 */
-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);
+function hakuban_tag_observe_contract_next(tag_observe_pointer) {
+    const ret = wasm.hakuban_tag_observe_contract_next(tag_observe_pointer);
+    return ret;
 }
 
 /**
-* @param {number} object_ptr
+* @param {number} tag_observe_pointer
+* @returns {Uint32Array}
 */
-function hakuban_object_observe_drop(object_ptr) {
-    wasm.hakuban_object_observe_drop(object_ptr);
+function hakuban_tag_observe_contract_ready(tag_observe_pointer) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.hakuban_tag_observe_contract_ready(retptr, tag_observe_pointer);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var v0 = getArrayU32FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_free(r0, r1 * 4);
+        return v0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 }
 
 /**
-* @param {number} object_observe_pointer
-* @returns {number}
+* @param {string} json_string
+* @returns {WasmResultWithPointer}
 */
-function hakuban_object_observe_state_borrow(object_observe_pointer) {
-    var ret = wasm.hakuban_object_observe_state_borrow(object_observe_pointer);
-    return ret;
+function hakuban_tag_descriptor_new(json_string) {
+    const ptr0 = passStringToWasm0(json_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.hakuban_tag_descriptor_new(ptr0, len0);
+    return WasmResultWithPointer.__wrap(ret);
 }
 
 /**
-* @param {number} state_ptr
+* @param {number} descriptor_pointer
 */
-function hakuban_object_observe_state_return(state_ptr) {
-    wasm.hakuban_object_observe_state_return(state_ptr);
+function hakuban_tag_descriptor_drop(descriptor_pointer) {
+    wasm.hakuban_tag_descriptor_drop(descriptor_pointer);
 }
 
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4);
+    getUint32Memory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
 /**
-* @param {number} state_ptr
-* @returns {BigInt}
+* @param {string} json_string
+* @param {Uint32Array} tag_pointers
+* @returns {WasmResultWithPointer}
 */
-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);
-    }
+function hakuban_object_descriptor_new(json_string, tag_pointers) {
+    const ptr0 = passStringToWasm0(json_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray32ToWasm0(tag_pointers, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.hakuban_object_descriptor_new(ptr0, len0, ptr1, len1);
+    return WasmResultWithPointer.__wrap(ret);
 }
 
 /**
-* @param {number} state_ptr
-* @returns {string}
+* @param {number} descriptor_pointer
 */
-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);
-    }
+function hakuban_object_descriptor_drop(descriptor_pointer) {
+    wasm.hakuban_object_descriptor_drop(descriptor_pointer);
 }
 
 /**
-* @param {number} state_ptr
+* @param {number} descriptor_pointer
 * @returns {string}
 */
-function hakuban_object_observe_state_data_type(state_ptr) {
+function hakuban_object_descriptor_json(descriptor_pointer) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.hakuban_object_observe_state_data_type(retptr, state_ptr);
+        wasm.hakuban_object_descriptor_json(retptr, descriptor_pointer);
         var r0 = getInt32Memory0()[retptr / 4 + 0];
         var r1 = getInt32Memory0()[retptr / 4 + 1];
         return getStringFromWasm0(r0, r1);
@@ -332,21 +354,18 @@ function hakuban_object_observe_state_data_type(state_ptr) {
     }
 }
 
-function getArrayU8FromWasm0(ptr, len) {
-    return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
-}
 /**
-* @param {number} state_ptr
-* @returns {Uint8Array}
+* @param {number} descriptor_pointer
+* @returns {Uint32Array}
 */
-function hakuban_object_observe_state_data(state_ptr) {
+function hakuban_object_descriptor_tags(descriptor_pointer) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.hakuban_object_observe_state_data(retptr, state_ptr);
+        wasm.hakuban_object_descriptor_tags(retptr, descriptor_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);
+        var v0 = getArrayU32FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_free(r0, r1 * 4);
         return v0;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
@@ -354,125 +373,152 @@ function hakuban_object_observe_state_data(state_ptr) {
 }
 
 /**
-* @param {number} object_observe_ptr
+* @param {string} default_log_level
 * @returns {number}
 */
-function hakuban_object_observe_events_get(object_observe_ptr) {
-    var ret = wasm.hakuban_object_observe_events_get(object_observe_ptr);
-    return ret;
+function hakuban_logger_initialize(default_log_level) {
+    const ptr0 = passStringToWasm0(default_log_level, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.hakuban_logger_initialize(ptr0, len0);
+    return ret >>> 0;
 }
 
-/**
-* @param {number} events_pointer
-*/
-function hakuban_object_descriptor_events_drop(events_pointer) {
-    wasm.hakuban_object_descriptor_events_drop(events_pointer);
+let cachedBigUint64Memory0 = new BigUint64Array();
+
+function getBigUint64Memory0() {
+    if (cachedBigUint64Memory0.byteLength === 0) {
+        cachedBigUint64Memory0 = new BigUint64Array(wasm.memory.buffer);
+    }
+    return cachedBigUint64Memory0;
 }
 
-/**
-* @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);
+function passArray64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8);
+    getBigUint64Memory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
 }
 
-/**
-* @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);
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4);
+    const mem = getUint32Memory0();
+    for (let i = 0; i < array.length; i++) {
+        mem[ptr / 4 + i] = addHeapObject(array[i]);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1);
+    getUint8Memory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
 /**
-* @param {number} tag_observe_pointer
+* @param {BigInt64Array} version
+* @param {any[]} format_jsvalues
+* @param {Uint8Array} data
+* @param {bigint} synchronized_us_ago
+* @returns {WasmResultWithPointer}
 */
-function hakuban_tag_observe_drop(tag_observe_pointer) {
-    wasm.hakuban_tag_observe_drop(tag_observe_pointer);
+function hakuban_object_state_new(version, format_jsvalues, data, synchronized_us_ago) {
+    const ptr0 = passArray64ToWasm0(version, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayJsValueToWasm0(format_jsvalues, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.hakuban_object_state_new(ptr0, len0, ptr1, len1, ptr2, len2, synchronized_us_ago);
+    return WasmResultWithPointer.__wrap(ret);
 }
 
 /**
-* @param {number} tag_observe_pointer
-* @param {string} object_descriptor
-* @returns {WasmTagObserveObjectStateBorrowResult}
+* @param {number} object_state_pointer
 */
-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);
+function hakuban_object_state_drop(object_state_pointer) {
+    wasm.hakuban_object_state_drop(object_state_pointer);
+}
+
+let cachedBigInt64Memory0 = new BigInt64Array();
+
+function getBigInt64Memory0() {
+    if (cachedBigInt64Memory0.byteLength === 0) {
+        cachedBigInt64Memory0 = new BigInt64Array(wasm.memory.buffer);
+    }
+    return cachedBigInt64Memory0;
 }
 
+function getArrayI64FromWasm0(ptr, len) {
+    return getBigInt64Memory0().subarray(ptr / 8, ptr / 8 + len);
+}
 /**
-* @param {number} tag_observe_pointer
-* @returns {string}
+* @param {number} object_state_pointer
+* @returns {BigInt64Array}
 */
-function hakuban_tag_observe_object_descriptors(tag_observe_pointer) {
+function hakuban_object_state_version(object_state_pointer) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.hakuban_tag_observe_object_descriptors(retptr, tag_observe_pointer);
+        wasm.hakuban_object_state_version(retptr, object_state_pointer);
         var r0 = getInt32Memory0()[retptr / 4 + 0];
         var r1 = getInt32Memory0()[retptr / 4 + 1];
-        return getStringFromWasm0(r0, r1);
+        var v0 = getArrayI64FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_free(r0, r1 * 8);
+        return v0;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_free(r0, r1);
     }
 }
 
 /**
-* @param {number} tag_observe_ptr
-* @returns {number}
+* @param {number} object_state_pointer
+* @returns {bigint}
 */
-function hakuban_tag_observe_events_get(tag_observe_ptr) {
-    var ret = wasm.hakuban_tag_observe_events_get(tag_observe_ptr);
-    return ret;
+function hakuban_object_state_synchronized_ago(object_state_pointer) {
+    const ret = wasm.hakuban_object_state_synchronized_ago(object_state_pointer);
+    return BigInt.asUintN(64, ret);
 }
 
-function isLikeNone(x) {
-    return x === undefined || x === null;
+function getArrayJsValueFromWasm0(ptr, len) {
+    const mem = getUint32Memory0();
+    const slice = mem.subarray(ptr / 4, ptr / 4 + len);
+    const result = [];
+    for (let i = 0; i < slice.length; i++) {
+        result.push(takeObject(slice[i]));
+    }
+    return result;
 }
 /**
-* @param {number} local_node_pointer
-* @param {boolean} upstream
-* @param {boolean | undefined} diff_produce
-* @param {boolean | undefined} diff_request
-* @returns {WasmRemoteNodeNewResult}
+* @param {number} object_state_pointer
+* @returns {any[]}
 */
-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);
+function hakuban_object_state_format(object_state_pointer) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.hakuban_object_state_format(retptr, object_state_pointer);
+        var r0 = getInt32Memory0()[retptr / 4 + 0];
+        var r1 = getInt32Memory0()[retptr / 4 + 1];
+        var v0 = getArrayJsValueFromWasm0(r0, r1).slice();
+        wasm.__wbindgen_free(r0, r1 * 4);
+        return v0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 }
 
-/**
-* @param {number} remote_node_pointer
-*/
-function hakuban_remote_node_drop(remote_node_pointer) {
-    wasm.hakuban_remote_node_drop(remote_node_pointer);
+function getArrayU8FromWasm0(ptr, len) {
+    return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
 }
-
 /**
-* @param {number} remote_node_pointer
+* @param {number} object_state_pointer
 * @returns {Uint8Array}
 */
-function hakuban_remote_node_connected(remote_node_pointer) {
+function hakuban_object_state_data(object_state_pointer) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.hakuban_remote_node_connected(retptr, remote_node_pointer);
+        wasm.hakuban_object_state_data(retptr, object_state_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;
@@ -482,88 +528,75 @@ function hakuban_remote_node_connected(remote_node_pointer) {
 }
 
 /**
-* @param {number} remote_node_pointer
+* @param {number} object_state_stream_pointer
 */
-function hakuban_remote_node_disconnected(remote_node_pointer) {
-    wasm.hakuban_remote_node_disconnected(remote_node_pointer);
+function hakuban_object_state_stream_drop(object_state_stream_pointer) {
+    wasm.hakuban_object_state_stream_drop(object_state_stream_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} object_state_stream_pointer
+* @returns {number}
+*/
+function hakuban_object_state_stream_next(object_state_stream_pointer) {
+    const ret = wasm.hakuban_object_state_stream_next(object_state_stream_pointer);
+    return ret;
 }
+
 /**
-* @param {number} remote_node_pointer
-* @param {Uint8Array} data
-* @returns {Uint8Array}
+* @param {number} object_state_stream_pointer
+* @returns {WasmResultWithPointer}
 */
-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);
-    }
+function hakuban_object_state_stream_current(object_state_stream_pointer) {
+    const ret = wasm.hakuban_object_state_stream_current(object_state_stream_pointer);
+    return WasmResultWithPointer.__wrap(ret);
 }
 
 /**
-* @param {number} remote_node_pointer
-* @param {Promise<any>} cancel
-* @returns {Promise<any>}
+* @param {number} object_state_stream_pointer
+* @returns {number}
 */
-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);
+function hakuban_object_state_stream_descriptor(object_state_stream_pointer) {
+    const ret = wasm.hakuban_object_state_stream_descriptor(object_state_stream_pointer);
+    return ret;
 }
 
 /**
-* @param {number} remote_node_pointer
-* @param {string} event
-* @returns {Uint8Array}
+* @param {number} local_exchange_pointer
+* @param {boolean} upstream
+* @param {boolean} diff_produce
+* @param {boolean} diff_request
+* @returns {number}
 */
-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);
-    }
+function hakuban_remote_exchange_new(local_exchange_pointer, upstream, diff_produce, diff_request) {
+    const ret = wasm.hakuban_remote_exchange_new(local_exchange_pointer, upstream, diff_produce, diff_request);
+    return ret;
+}
+
+/**
+* @param {number} remote_exchange_pointer
+*/
+function hakuban_remote_exchange_drop(remote_exchange_pointer) {
+    wasm.hakuban_remote_exchange_drop(remote_exchange_pointer);
+}
+
+/**
+* @param {number} remote_exchange_pointer
+* @returns {number}
+*/
+function hakuban_remote_exchange_next_message_to_network(remote_exchange_pointer) {
+    const ret = wasm.hakuban_remote_exchange_next_message_to_network(remote_exchange_pointer);
+    return ret;
 }
 
 /**
-* @param {number} remote_node_pointer
+* @param {number} message_pointer
 * @returns {Uint8Array}
 */
-function hakuban_remote_node_ack(remote_node_pointer) {
+function hakuban_message_take(message_pointer) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.hakuban_remote_node_ack(retptr, remote_node_pointer);
+        wasm.hakuban_message_take(retptr, message_pointer);
         var r0 = getInt32Memory0()[retptr / 4 + 0];
         var r1 = getInt32Memory0()[retptr / 4 + 1];
         var v0 = getArrayU8FromWasm0(r0, r1).slice();
@@ -575,263 +608,250 @@ function hakuban_remote_node_ack(remote_node_pointer) {
 }
 
 /**
-* @param {number} local_node
-* @param {string} descriptor
-* @returns {WasmTagExposeResult}
+* @param {number} remote_exchange_pointer
+* @param {Uint8Array} message_data
+* @returns {number}
 */
-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);
+function hakuban_remote_exchange_send_message_from_network(remote_exchange_pointer, message_data) {
+    const ptr0 = passArray8ToWasm0(message_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.hakuban_remote_exchange_send_message_from_network(remote_exchange_pointer, ptr0, len0);
+    return ret;
 }
 
 /**
-* @param {number} tag_expose_pointer
+* @param {number} local_exchange_pointer
+* @param {number} future_pointer
+* @param {bigint} waker_id
+* @returns {WasmResultWithPointer}
 */
-function hakuban_tag_expose_drop(tag_expose_pointer) {
-    wasm.hakuban_tag_expose_drop(tag_expose_pointer);
+function hakuban_future_returning_pointer_poll(local_exchange_pointer, future_pointer, waker_id) {
+    const ret = wasm.hakuban_future_returning_pointer_poll(local_exchange_pointer, future_pointer, waker_id);
+    return WasmResultWithPointer.__wrap(ret);
 }
 
 /**
-* @param {number} tag_expose_pointer
-* @returns {string}
+* @param {number} future
 */
-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);
-    }
+function hakuban_future_returning_pointer_drop(future) {
+    wasm.hakuban_future_returning_nothing_drop(future);
 }
 
 /**
-* @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}
+* @param {number} local_exchange_pointer
+* @param {number} future_pointer
+* @param {bigint} waker_id
+* @returns {WasmResultWithNothing}
 */
-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);
+function hakuban_future_returning_nothing_poll(local_exchange_pointer, future_pointer, waker_id) {
+    const ret = wasm.hakuban_future_returning_nothing_poll(local_exchange_pointer, future_pointer, waker_id);
+    return WasmResultWithNothing.__wrap(ret);
 }
 
 /**
-* @param {number} tag_expose_pointer
-* @param {string} object_descriptor
-* @returns {WasmTagExposeAssignmentResult}
+* @param {number} future
 */
-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);
+function hakuban_future_returning_nothing_drop(future) {
+    wasm.hakuban_future_returning_nothing_drop(future);
 }
 
 /**
-* @param {number} tag_expose_pointer
-* @param {string} object_descriptor
-* @param {BigInt} assignment_id
+* @param {number} object_state_sink_pointer
 * @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;
+function hakuban_object_state_sink_descriptor(object_state_sink_pointer) {
+    const ret = wasm.hakuban_object_state_sink_descriptor(object_state_sink_pointer);
+    return ret;
+}
+
+/**
+* @param {number} object_state_sink_pointer
+*/
+function hakuban_object_state_sink_drop(object_state_sink_pointer) {
+    wasm.hakuban_object_state_sink_drop(object_state_sink_pointer);
 }
 
 /**
-* @param {number} tag_expose_ptr
+* @param {number} object_state_sink_pointer
 * @returns {number}
 */
-function hakuban_tag_expose_events_get(tag_expose_ptr) {
-    var ret = wasm.hakuban_tag_expose_events_get(tag_expose_ptr);
+function hakuban_object_state_sink_next(object_state_sink_pointer) {
+    const ret = wasm.hakuban_object_state_sink_next(object_state_sink_pointer);
     return ret;
 }
 
 /**
-* @param {number} local_node
-* @param {string} descriptor
-* @returns {WasmObjectExposeResult}
+* @param {number} object_state_sink_pointer
+* @returns {WasmResultWithPointer}
 */
-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);
+function hakuban_object_state_sink_current(object_state_sink_pointer) {
+    const ret = wasm.hakuban_object_state_sink_current(object_state_sink_pointer);
+    return WasmResultWithPointer.__wrap(ret);
 }
 
 /**
-* @param {number} object_expose_pointer
+* @param {number} object_state_sink_pointer
+* @param {number} object_state_pointer
+* @returns {number}
 */
-function hakuban_object_expose_drop(object_expose_pointer) {
-    wasm.hakuban_object_expose_drop(object_expose_pointer);
+function hakuban_object_state_sink_push(object_state_sink_pointer, object_state_pointer) {
+    const ret = wasm.hakuban_object_state_sink_push(object_state_sink_pointer, object_state_pointer);
+    return ret;
 }
 
 /**
-* @param {number} object_expose_pointer
-* @param {string} data_version
-* @param {string} data_type
-* @param {Uint8Array} data
-* @param {BigInt} assignment_id
-* @returns {WasmObjectExposeStateResult}
+* @param {number} object_state_sink_params_pointer
 */
-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);
+function hakuban_object_state_sink_params_drop(object_state_sink_params_pointer) {
+    wasm.hakuban_object_state_sink_params_drop(object_state_sink_params_pointer);
 }
 
 /**
-* @param {number} object_expose_pointer
-* @returns {BigInt}
+* @param {number} object_state_sink_pointer
+*/
+function hakuban_object_state_sink_desynchronize(object_state_sink_pointer) {
+    wasm.hakuban_object_state_sink_desynchronize(object_state_sink_pointer);
+}
+
+/**
+* @param {string} name_str
+* @returns {WasmResultWithPointer}
+*/
+function hakuban_local_exchange_new(name_str) {
+    const ptr0 = passStringToWasm0(name_str, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.hakuban_local_exchange_new(ptr0, len0);
+    return WasmResultWithPointer.__wrap(ret);
+}
+
+/**
+* @param {number} local_exchange
+*/
+function hakuban_local_exchange_drop(local_exchange) {
+    wasm.hakuban_local_exchange_drop(local_exchange);
+}
+
+function getArrayU64FromWasm0(ptr, len) {
+    return getBigUint64Memory0().subarray(ptr / 8, ptr / 8 + len);
+}
+/**
+* @param {number} local_exchange
+* @returns {BigUint64Array}
 */
-function hakuban_object_expose_assignment(object_expose_pointer) {
+function hakuban_local_exchange_notified(local_exchange) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.hakuban_object_expose_assignment(retptr, object_expose_pointer);
+        wasm.hakuban_local_exchange_notified(retptr, local_exchange);
         var r0 = getInt32Memory0()[retptr / 4 + 0];
         var r1 = getInt32Memory0()[retptr / 4 + 1];
-        u32CvtShim[0] = r0;
-        u32CvtShim[1] = r1;
-        const n0 = uint64CvtShim[0];
-        return n0;
+        var v0 = getArrayU64FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_free(r0, r1 * 8);
+        return v0;
     } finally {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
 
+/**
+* @param {number} local_exchange
+* @param {number} descriptor
+* @returns {number}
+*/
+function hakuban_object_expose_contract_new(local_exchange, descriptor) {
+    const ret = wasm.hakuban_object_expose_contract_new(local_exchange, descriptor);
+    return ret;
+}
+
+/**
+* @param {number} object_ptr
+*/
+function hakuban_object_expose_contract_drop(object_ptr) {
+    wasm.hakuban_object_expose_contract_drop(object_ptr);
+}
+
 /**
 * @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);
+function hakuban_object_expose_contract_terminate(object_expose_pointer) {
+    wasm.hakuban_object_expose_contract_terminate(object_expose_pointer);
 }
 
 /**
-* @param {number} object_expose_ptr
+* @param {number} object_expose_pointer
 * @returns {number}
 */
-function hakuban_object_expose_events_get(object_expose_ptr) {
-    var ret = wasm.hakuban_object_expose_events_get(object_expose_ptr);
+function hakuban_object_expose_contract_next(object_expose_pointer) {
+    const ret = wasm.hakuban_object_expose_contract_next(object_expose_pointer);
     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));
+/**
+* @param {number} object_expose_pointer
+* @returns {WasmResultWithPointer}
+*/
+function hakuban_object_expose_contract_ready(object_expose_pointer) {
+    const ret = wasm.hakuban_object_expose_contract_ready(object_expose_pointer);
+    return WasmResultWithPointer.__wrap(ret);
 }
 
 /**
+* @param {number} local_exchange
+* @param {number} descriptor
+* @returns {number}
 */
-Object.freeze({ None:0,"0":"None",InvalidString:1,"1":"InvalidString",InvalidJSON:2,"2":"InvalidJSON",InvalidURL:3,"3":"InvalidURL",ObjectNotFound:4,"4":"ObjectNotFound", });
+function hakuban_object_observe_contract_new(local_exchange, descriptor) {
+    const ret = wasm.hakuban_object_observe_contract_new(local_exchange, descriptor);
+    return ret;
+}
+
 /**
+* @param {number} object_ptr
 */
-class WasmHashResult {
-
-    static __wrap(ptr) {
-        const obj = Object.create(WasmHashResult.prototype);
-        obj.ptr = ptr;
+function hakuban_object_observe_contract_drop(object_ptr) {
+    wasm.hakuban_object_observe_contract_drop(object_ptr);
+}
 
-        return obj;
-    }
+/**
+* @param {number} object_observe_pointer
+*/
+function hakuban_object_observe_contract_terminate(object_observe_pointer) {
+    wasm.hakuban_object_observe_contract_terminate(object_observe_pointer);
+}
 
-    __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+/**
+* @param {number} object_observe_pointer
+* @returns {number}
+*/
+function hakuban_object_observe_contract_next(object_observe_pointer) {
+    const ret = wasm.hakuban_object_observe_contract_next(object_observe_pointer);
+    return ret;
+}
 
-        return ptr;
-    }
+/**
+* @param {number} object_observe_pointer
+* @returns {WasmResultWithPointer}
+*/
+function hakuban_object_observe_contract_ready(object_observe_pointer) {
+    const ret = wasm.hakuban_object_observe_contract_ready(object_observe_pointer);
+    return WasmResultWithPointer.__wrap(ret);
+}
 
-    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);
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_exn_store(addHeapObject(e));
     }
 }
 /**
 */
-class WasmLocalNodeNewResult {
+Object.freeze({ Ok:0,"0":"Ok",Pending:1,"1":"Pending",NotAvailable:2,"2":"NotAvailable",InvalidString:3,"3":"InvalidString",InvalidJSON:4,"4":"InvalidJSON",InvalidURL:5,"5":"InvalidURL",InvalidLogLevel:6,"6":"InvalidLogLevel",UnknownError:7,"7":"UnknownError", });
+/**
+*/
+class WasmResultWithNothing {
 
     static __wrap(ptr) {
-        const obj = Object.create(WasmLocalNodeNewResult.prototype);
+        const obj = Object.create(WasmResultWithNothing.prototype);
         obj.ptr = ptr;
 
         return obj;
@@ -846,39 +866,28 @@ class WasmLocalNodeNewResult {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmlocalnodenewresult_free(ptr);
+        wasm.__wbg_wasmresultwithnothing_free(ptr);
     }
     /**
+    * @returns {number}
     */
-    get error() {
-        var ret = wasm.__wbg_get_wasmlocalnodenewresult_error(this.ptr);
+    get status() {
+        const ret = wasm.__wbg_get_wasmresultwithnothing_status(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);
+    set status(arg0) {
+        wasm.__wbg_set_wasmresultwithnothing_status(this.ptr, arg0);
     }
 }
 /**
 */
-class WasmObjectExposeResult {
+class WasmResultWithPointer {
 
     static __wrap(ptr) {
-        const obj = Object.create(WasmObjectExposeResult.prototype);
+        const obj = Object.create(WasmResultWithPointer.prototype);
         obj.ptr = ptr;
 
         return obj;
@@ -893,577 +902,152 @@ class WasmObjectExposeResult {
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmobjectexposeresult_free(ptr);
+        wasm.__wbg_wasmresultwithpointer_free(ptr);
     }
     /**
+    * @returns {number}
     */
-    get error() {
-        var ret = wasm.__wbg_get_wasmobjectexposeresult_error(this.ptr);
+    get status() {
+        const ret = wasm.__wbg_get_wasmresultwithpointer_status(this.ptr);
         return ret >>> 0;
     }
     /**
     * @param {number} arg0
     */
-    set error(arg0) {
-        wasm.__wbg_set_wasmobjectexposeresult_error(this.ptr, arg0);
+    set status(arg0) {
+        wasm.__wbg_set_wasmresultwithpointer_status(this.ptr, arg0);
     }
     /**
+    * @returns {number}
     */
-    get object_expose_pointer() {
-        var ret = wasm.__wbg_get_wasmobjectexposeresult_object_expose_pointer(this.ptr);
+    get value() {
+        const ret = wasm.__wbg_get_wasmresultwithpointer_value(this.ptr);
         return ret;
     }
     /**
     * @param {number} arg0
     */
-    set object_expose_pointer(arg0) {
-        wasm.__wbg_set_wasmobjectexposeresult_object_expose_pointer(this.ptr, arg0);
+    set value(arg0) {
+        wasm.__wbg_set_wasmresultwithpointer_value(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;
+async function load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
 
-        return ptr;
-    }
+            } 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);
 
-    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 {
+                } else {
+                    throw e;
+                }
+            }
+        }
 
-    static __wrap(ptr) {
-        const obj = Object.create(WasmObjectObserveResult.prototype);
-        obj.ptr = ptr;
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
 
-        return obj;
-    }
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
 
-    __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
 
-        return ptr;
+        } else {
+            return instance;
+        }
     }
+}
 
-    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);
-    }
+function getImports() {
     const imports = {};
     imports.wbg = {};
     imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
         takeObject(arg0);
     };
+    imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
+        const obj = getObject(arg1);
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr0 = isLikeNone(ret) ? 0 : 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_string_new = function(arg0, arg1) {
-        var ret = getStringFromWasm0(arg0, arg1);
+        const 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;
+    imports.wbg.__wbg_now_8172cd917e5eda6b = function(arg0) {
+        const ret = getObject(arg0).now();
         return ret;
     };
-    imports.wbg.__wbg_debug_6e114a5b27d7915d = function(arg0) {
+    imports.wbg.__wbg_debug_f15cb542ea509609 = function(arg0) {
         console.debug(getObject(arg0));
     };
-    imports.wbg.__wbg_error_ca520cb687b085a1 = function(arg0) {
+    imports.wbg.__wbg_error_ef9a0be47931175f = function(arg0) {
         console.error(getObject(arg0));
     };
-    imports.wbg.__wbg_info_32ab782ec7072fac = function(arg0) {
+    imports.wbg.__wbg_info_2874fdd5393f35ce = function(arg0) {
         console.info(getObject(arg0));
     };
-    imports.wbg.__wbg_log_fbd13631356d44e4 = function(arg0) {
+    imports.wbg.__wbg_log_4b5638ad60bdc54a = function(arg0) {
         console.log(getObject(arg0));
     };
-    imports.wbg.__wbg_warn_97f10a6b0dbb8c5c = function(arg0) {
+    imports.wbg.__wbg_warn_58110c4a199df084 = 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));
+    imports.wbg.__wbg_newnoargs_b5b063fc6c2f0376 = function(arg0, arg1) {
+        const 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));
+    imports.wbg.__wbg_get_765201544a2b6869 = function() { return handleError(function (arg0, arg1) {
+        const 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));
+    imports.wbg.__wbg_call_97ae9d8645dc388b = function() { return handleError(function (arg0, arg1) {
+        const 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));
+    imports.wbg.__wbg_self_6d479506f72c6a71 = function() { return handleError(function () {
+        const ret = self.self;
         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;
+    imports.wbg.__wbg_window_f2557cc78490aceb = function() { return handleError(function () {
+        const ret = window.window;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_globalThis_d61b1f48a57191ae = function() { return handleError(function () {
-        var ret = globalThis.globalThis;
+    imports.wbg.__wbg_globalThis_7f206bda628d5286 = function() { return handleError(function () {
+        const ret = globalThis.globalThis;
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_global_e7669da72fd7f239 = function() { return handleError(function () {
-        var ret = global.global;
+    imports.wbg.__wbg_global_ba75c50d1cf384f4 = function() { return handleError(function () {
+        const ret = global.global;
         return addHeapObject(ret);
     }, arguments) };
     imports.wbg.__wbindgen_is_undefined = function(arg0) {
-        var ret = getObject(arg0) === undefined;
+        const ret = getObject(arg0) === undefined;
         return ret;
     };
     imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
-        var ret = getObject(arg0);
+        const ret = getObject(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_new_693216e109162396 = function() {
-        var ret = new Error();
+    imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
+        const 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;
+    imports.wbg.__wbg_stack_658279fe44541cf6 = function(arg0, arg1) {
+        const ret = getObject(arg1).stack;
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
         getInt32Memory0()[arg0 / 4 + 1] = len0;
         getInt32Memory0()[arg0 / 4 + 0] = ptr0;
     };
-    imports.wbg.__wbg_error_09919627ac0992f5 = function(arg0, arg1) {
+    imports.wbg.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
         try {
             console.error(getStringFromWasm0(arg0, arg1));
         } finally {
@@ -1471,1126 +1055,1207 @@ async function init(input) {
         }
     };
     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;
+        const ret = debugString(getObject(arg1));
+        const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const 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);
+    return imports;
+}
 
+function finalizeInit(instance, module) {
     wasm = instance.exports;
     init.__wbindgen_wasm_module = module;
+    cachedBigInt64Memory0 = new BigInt64Array();
+    cachedBigUint64Memory0 = new BigUint64Array();
+    cachedInt32Memory0 = new Int32Array();
+    cachedUint32Memory0 = new Uint32Array();
+    cachedUint8Memory0 = new Uint8Array();
+
 
     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 function init(input) {
+    if (typeof input === 'undefined') {
+        input = new URL('hakuban_bg.wasm', import.meta.url);
     }
-  }
+    const imports = getImports();
 
-  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;
-        });
-      }
+    if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
+        input = fetch(input);
     }
-  }
 
-  clear() {
-    return this.queue = [];
-  }
-
-};
+    const { instance, module } = await load(await input, imports);
 
-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;
-  }
+    return finalizeInit(instance, module);
+}
 
-  on_exception(policy) {
-    this._on_exception_policy = policy;
-    return this;
+var unwrap_pointer = function(result) {
+  if (result.status === 0) {
+    return result.value;
+  } else {
+    throw "hakuban wasm call failed: " + result.status;
   }
+};
 
-  //terminate_on_deactivation: ()->
-  //	@terminate_on_deactivation = true
-  //	@
-  retry_backoff(times) {
-    this._retry_backoff = times;
-    return this;
+var unwrap_pointer_or_null = function(result) {
+  if (result.status === 0) {
+    return result.value;
+  } else if (result.status === 2) { //unavailable
+    return null;
+  } else {
+    throw "hakuban wasm call failed: " + result.status;
   }
+};
 
-  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 Future = class Future {
+  constructor(local_exchange, future_owner, poll_function, drop_function, _pointer) {
+    this.local_exchange = local_exchange;
+    this.future_owner = future_owner;
+    this.poll_function = poll_function;
+    this.drop_function = drop_function;
+    this._pointer = _pointer;
   }
 
-};
-
-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;
-                    }
-                }
-              }
+  async await_and_drop(aborted = null) {
+    var about_to_drop_notification_received, notified, result, to_listen;
+    try {
+      about_to_drop_notification_received = new Promise((about_to_drop_notification) => {
+        return this.lock_id = this.future_owner.drop_lock(about_to_drop_notification);
+      });
+      while (true) {
+        notified = this.local_exchange.notified();
+        result = this.local_exchange.with_pointer((local_exchange_pointer) => {
+          return this.poll_function(local_exchange_pointer, this._pointer, notified.id);
+        });
+        switch (result.status) {
+          case 0: //ok
+            return result.value;
+          case 1: //pending
+            to_listen = [notified, about_to_drop_notification_received];
+            if (aborted != null) {
+              to_listen.push(aborted);
             }
-            //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()];
-              }
+            switch ((await Promise.race(to_listen))) {
+              case "ABORT":
+                return false;
+              case "DROP":
+                return null;
             }
             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;
+          case 2: //unavailable, channel closed
+            return null;
           default:
-            throw "Unknown action: " + event.action;
+            throw result.status; //TODO: convert that to specific error
         }
       }
-      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);
+    } finally {
+      this.drop_function(this._pointer);
+      this.future_owner.drop_release(this.lock_id);
+      if (notified != null) {
+        this.local_exchange.return_notified(notified);
+      }
     }
   }
 
 };
 
-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;
+var logger_initialize = function(log_level, skip_if_already_initialized = false) {
+  var error;
+  if (0 === (error = hakuban_logger_initialize(log_level))) {
+    return true;
+  } else {
+    console.error("Failed to initialize logger, error " + error);
+    return false;
   }
+};
 
-  async run(handler) {
-    return (await handler(this));
-  }
+var do_and_drop, finalization_registry;
 
-  next_event() {
-    return this.next_change();
-  }
+finalization_registry = new FinalizationRegistry(function(function_and_arg) {
+  return function_and_arg[0](function_and_arg[1]);
+});
 
-  async next_change() {
-    while (true) {
-      switch ((await this._changes.shift())) {
-        case "change":
-          return true;
-        case "stop":
-          return false;
+do_and_drop = function(object_or_objects, block) {
+  var block_returned_promise, i, len, object, ref, ret;
+  try {
+    block_returned_promise = false;
+    ret = block(object_or_objects);
+    if ((ret != null) && typeof ret.then === 'function') {
+      block_returned_promise = true;
+      return ret.finally(() => {
+        var i, len, object, ref, results;
+        ref = [object_or_objects].flat();
+        results = [];
+        for (i = 0, len = ref.length; i < len; i++) {
+          object = ref[i];
+          results.push(object.drop());
+        }
+        return results;
+      });
+    } else {
+      return ret;
+    }
+  } finally {
+    if (!block_returned_promise) {
+      ref = [object_or_objects].flat();
+      for (i = 0, len = ref.length; i < len; i++) {
+        object = ref[i];
+        object.drop();
       }
     }
   }
-
-  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;
+var do_and_drop_or_return = function(object_or_objects, block) {
+  if (block != null) {
+    return do_and_drop(object_or_objects, block);
   } else {
-    console.error("Failed to initialize logger, error " + error);
-    return false;
+    return object_or_objects;
   }
 };
 
-raise_if_error = function(error_code) {
-  if (error_code !== 0) {
-    throw "Hakuban error: " + error_code;
+var PointerAlreadyDropped$1 = class PointerAlreadyDropped {
+  constructor() {
+    this.message = "PointerAlreadyDropped";
   }
-};
 
-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;
+var FFIObject = class FFIObject {
+  initialize_pointer(_local_exchange, _pointer, _drop_function) {
+    this._local_exchange = _local_exchange;
+    this._pointer = _pointer;
+    this._drop_function = _drop_function;
+    this._was_dropped = null;
+    this._drop_locks_sequence = 0;
+    this._drop_locks = {};
+    return finalization_registry.register(this, [this._drop_function, this._pointer], this);
   }
-  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;
-    })();
+  dropped() {
+    return this._was_dropped != null;
   }
 
-  as_json() {
-    return JSON.stringify({
-      tags: this.tags.map(function(tag) {
-        return tag.json;
-      }),
-      json: this.json
-    });
+  drop() {
+    if (this._was_dropped == null) {
+      this._was_dropped = new Promise(async(resolve) => {
+        var about_to_drop_notification, all_locks_dropped, i, len, ref;
+        if (this._pointer != null) {
+          if (Object.keys(this._drop_locks).length > 0) {
+            all_locks_dropped = new Promise((_all_locks_dropped_set) => {
+              this._all_locks_dropped_set = _all_locks_dropped_set;
+            });
+            ref = Object.values(this._drop_locks);
+            for (i = 0, len = ref.length; i < len; i++) {
+              about_to_drop_notification = ref[i];
+              about_to_drop_notification("DROP");
+            }
+            await all_locks_dropped;
+          }
+          if (Object.keys(this._drop_locks).length > 0) {
+            throw "Hakuban internal error: drop was attempted with existing drop locks";
+          }
+          finalization_registry.unregister(this);
+          this._drop_function(this._pointer);
+          if (this._local_exchange != null) {
+            this._local_exchange.notify();
+          }
+        }
+        this._pointer = false;
+        return resolve();
+      });
+    }
+    return this._was_dropped;
   }
 
-  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();
+  with_pointer(block) {
+    if (this.dropped()) {
+      throw new PointerAlreadyDropped$1();
     }
-    return this._hash;
+    return block(this._pointer);
   }
 
-};
-
-var TagDescriptor = class TagDescriptor {
-  constructor(json1) {
-    this.json = json1;
+  do_and_drop_or_return(block) {
+    return do_and_drop_or_return(this, block);
   }
 
-  as_json() {
-    return JSON.stringify(this.json);
+  drop_lock(about_to_drop_notification) {
+    var lock_id;
+    if (this._was_dropped != null) {
+      raise(FFIObject.prototype.PointerAlreadyDropped);
+    }
+    lock_id = this._drop_locks_sequence++;
+    this._drop_locks[lock_id] = about_to_drop_notification;
+    return lock_id;
   }
 
-  hash() {
-    var ret;
-    if (this._hash == null) {
-      ret = hakuban_json_hash(JSON.stringify(this.json));
-      raise_if_error(ret.error);
-      this._hash = ret.hash;
+  drop_release(lock_id) {
+    delete this._drop_locks[lock_id];
+    if ((this._was_dropped != null) && Object.keys(this._drop_locks).length === 0) {
+      return this._all_locks_dropped_set();
     }
-    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);
+var ObjectDescriptor = class ObjectDescriptor extends FFIObject {
+  constructor(tags, json, pointer = null) {
+    var tag, tag_pointer;
+    super();
+    if (pointer != null) {
+      this.json = JSON.parse(hakuban_object_descriptor_json(pointer));
+      this.tags = (function() {
+        var i, len, ref, results;
+        ref = hakuban_object_descriptor_tags(pointer);
+        results = [];
+        for (i = 0, len = ref.length; i < len; i++) {
+          tag_pointer = ref[i];
+          results.push(new TagDescriptor(null, null, tag_pointer));
+        }
+        return results;
+      })();
+    } else {
+      this.json = json;
+      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;
+      })();
+      pointer = unwrap_pointer(hakuban_object_descriptor_new(JSON.stringify(this.json), (function() {
+        var i, len, ref, results;
+        ref = this.tags;
+        results = [];
+        for (i = 0, len = ref.length; i < len; i++) {
+          tag = ref[i];
+          results.push(tag._pointer);
+        }
+        return results;
+      }).call(this)));
+    }
+    this.initialize_pointer(null, pointer, hakuban_object_descriptor_drop);
   }
 
-  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);
+var TagDescriptor = class TagDescriptor extends FFIObject {
+  constructor(json) {
+    var pointer;
+    super();
+    this.json = json;
+    pointer = unwrap_pointer(hakuban_tag_descriptor_new(JSON.stringify(this.json)));
+    this.initialize_pointer(null, pointer, hakuban_tag_descriptor_drop);
   }
 
-  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;
+var ObjectState_last_generated_version;
+
+ObjectState_last_generated_version = [0, 0, 0];
+
+//TODO: make this immutable for the users somehow
+var ObjectState = class ObjectState extends FFIObject {
+  constructor(data = null, version = null, format = null, synchronized_us_ago = 0, pointer = null) {
+    var timestamp, version_element, x;
+    super();
+    if (pointer != null) {
+      this.initialize_pointer(null, pointer, hakuban_object_state_drop);
+      this.version = (function() {
+        var i, len, ref, results;
+        ref = hakuban_object_state_version(pointer);
+        results = [];
+        for (i = 0, len = ref.length; i < len; i++) {
+          x = ref[i];
+          results.push(x);
+        }
+        return results;
+      })();
+      this.synchronized_us_ago = hakuban_object_state_synchronized_ago(pointer);
+      this.format = hakuban_object_state_format(pointer);
+      this.data = new TextDecoder().decode(hakuban_object_state_data(pointer));
+    } else {
+      if (version == null) {
+        timestamp = new Date().getTime();
+        version = [0, Math.floor(timestamp / 1000), (timestamp % 1000) * 1000];
+        while (version[1] === ObjectState_last_generated_version[1] && version[2] <= ObjectState_last_generated_version[2]) {
+          version[2]++;
+        }
+        ObjectState_last_generated_version = version;
+      }
+      this.version = (function() {
+        var i, len, results;
+        results = [];
+        for (i = 0, len = version.length; i < len; i++) {
+          version_element = version[i];
+          results.push(BigInt(version_element));
+        }
+        return results;
+      })();
+      if (format == null) {
+        format = [];
+      }
+      this.format = [format].flat(2e308);
+      this.synchronized_us_ago = BigInt(synchronized_us_ago);
+      this.data = data;
+    }
   }
 
-  with_default_deserializer(default_deserializer) {
-    this.default_deserializer = default_deserializer;
-    return this;
+  with_pointer(block) {
+    var pointer;
+    if (this.dropped()) {
+      throw new PointerAlreadyDropped();
+    }
+    if (this._pointer != null) {
+      return block(this._pointer);
+    } else {
+      pointer = unwrap_pointer(hakuban_object_state_new(this.version, this.format, new TextEncoder().encode(this.data), this.synchronized_us_ago));
+      this.initialize_pointer(null, pointer, hakuban_object_state_drop);
+      return block(this._pointer);
+    }
   }
 
-};
+  with_data(data) {
+    return new ObjectState(data, this.version, this.format, this.synchronized_us_ago);
+  }
 
-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;
+  with_version(version) {
+    return new ObjectState(this.data, version, this.format, this.synchronized_us_ago);
   }
 
-  observe() {
-    return new ObjectObserve(this.local_node, new ObjectDescriptor(this.tags, this.json), this.deserializer);
+  with_format(format) {
+    return new ObjectState(this.data, this.version, format, this.synchronized_us_ago);
   }
 
-  expose() {
-    return new ObjectExpose(this.local_node, new ObjectDescriptor(this.tags, this.json), this.serializer);
+  with_synchronized_us_ago(synchronized_us_ago) {
+    return new ObjectState(this.data, this.version, this.format, synchronized_us_ago);
   }
 
-  with_serializer(serializer) {
-    this.serializer = serializer;
-    return this;
+  json_deserialize() {
+    if (this.format[this.format.length - 1] !== "JSON") {
+      throw "Invalid data format";
+    }
+    return new ObjectState(JSON.parse(this.data), this.version, this.format.slice(0, -1), this.synchronized_us_ago);
   }
 
-  with_deserializer(deserializer) {
-    this.deserializer = deserializer;
-    return this;
+  json_serialize() {
+    return new ObjectState(JSON.stringify(this.data), this.version, this.format.concat("JSON"), this.synchronized_us_ago);
   }
 
 };
 
-TagBuilder = class TagBuilder {
-  constructor(local_node, serializer, deserializer, json1) {
-    this.local_node = local_node;
-    this.serializer = serializer;
-    this.deserializer = deserializer;
-    this.json = json1;
+var StreamEnumerator = class StreamEnumerator {
+  constructor(_stream, _without_implicit_drop = false, _async = false) {
+    this._stream = _stream;
+    this._without_implicit_drop = _without_implicit_drop;
+    this._async = _async;
   }
 
-  observe() {
-    return new TagObserve(this.local_node, new TagDescriptor(this.json), this.deserializer);
+  async(block) {
+    return new StreamEnumerator(this._stream, this._without_implicit_drop, true).call_or_return(block);
   }
 
-  expose() {
-    return new TagExpose(this.local_node, new TagDescriptor(this.json), this.serializer);
+  without_implicit_drop(block) {
+    return new StreamEnumerator(this._stream, true, this._async).call_or_return(block);
   }
 
-  with_serializer(serializer) {
-    this.serializer = serializer;
-    return this;
+  call_or_return(block) {
+    if (block != null) {
+      return this.call(block);
+    } else {
+      return this;
+    }
   }
 
-  with_deserializer(deserializer) {
-    this.deserializer = deserializer;
-    return this;
+  async call(block) {
+    var new_item, results;
+    results = [];
+    while ((new_item = (await this._stream.next())) != null) {
+      if (this._async) {
+        //TODO: will GC eat it before it fullfils?
+        results.push(new Promise(async(_resolve) => {
+          var item;
+          item = new_item; // :(
+          if (this._without_implicit_drop) {
+            return (await block(item));
+          } else {
+            try {
+              return (await block(item));
+            } finally {
+              await item.drop();
+            }
+          }
+        }));
+      } else {
+        if (this._without_implicit_drop) {
+          results.push((await block(new_item)));
+        } else {
+          try {
+            results.push((await block(new_item)));
+          } finally {
+            await new_item.drop();
+          }
+        }
+      }
+    }
+    return results;
   }
 
 };
 
-ObjectDescriptorEvents_finalization_registry = new FinalizationRegistry((pointer) => {
-  return hakuban_object_descriptor_events_drop(pointer);
-});
+var ObjectStateStream = class ObjectStateStream extends FFIObject {
+  constructor(local_exchange, pointer) {
+    super();
+    this.local_exchange = local_exchange;
+    this.initialize_pointer(this.local_exchange, pointer, hakuban_object_state_stream_drop);
+  }
 
-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);
+  descriptor() {
+    return this.with_pointer(function(pointer) {
+      return new ObjectDescriptor(null, null, hakuban_object_state_stream_descriptor(pointer));
+    });
   }
 
-  wait() {
-    return next();
+  async next(block) {
+    var error, future_pointer, pointer;
+    try {
+      future_pointer = this.with_pointer((pointer) => {
+        return hakuban_object_state_stream_next(pointer);
+      });
+      pointer = (await new Future(this.local_exchange, this, hakuban_future_returning_pointer_poll, hakuban_future_returning_pointer_drop, future_pointer).await_and_drop());
+      if (pointer != null) {
+        return new ObjectState(null, null, null, null, pointer).do_and_drop_or_return(block);
+      } else {
+        return null;
+      }
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped$1) {
+        return null;
+      }
+      throw error;
+    }
   }
 
-  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)
-      };
-    });
+  each(block) {
+    return new StreamEnumerator(this).call_or_return(block);
   }
 
-  async drop() {
-    if (this.cancel_waiting_resolve != null) {
-      this.cancel_waiting_resolve();
-      await this.wait_released;
+  current(block) {
+    var error, pointer;
+    try {
+      pointer = this.with_pointer((pointer) => {
+        return unwrap_pointer_or_null(hakuban_object_state_stream_current(pointer));
+      });
+      if (pointer != null) {
+        return new ObjectState(null, null, null, null, pointer).do_and_drop_or_return(block);
+      } else {
+        return null;
+      }
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped$1) {
+        return null;
+      }
+      throw error;
     }
-    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);
-});
+var ObjectStateSinkParams = class ObjectStateSinkParams extends FFIObject {
+  constructor(pointer) {
+    super();
+    this.initialize_pointer(null, pointer, hakuban_object_state_sink_params_drop);
+  }
 
-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;
+};
+
+var ObjectStateSink = class ObjectStateSink extends FFIObject {
+  constructor(local_exchange, pointer) {
+    super();
+    this.local_exchange = local_exchange;
+    this.initialize_pointer(this.local_exchange, pointer, hakuban_object_state_sink_drop);
+  }
+
+  descriptor() {
+    return this.with_pointer(function(pointer) {
+      return new ObjectDescriptor(null, null, hakuban_object_state_sink_descriptor(pointer));
+    });
+  }
+
+  async send(object_state) {
+    var error, future_pointer;
+    try {
+      future_pointer = this.with_pointer((sink_pointer) => {
+        return object_state.with_pointer((object_state_pointer) => {
+          return hakuban_object_state_sink_push(sink_pointer, object_state_pointer);
+        });
+      });
+      await new Future(this.local_exchange, this, hakuban_future_returning_nothing_poll, hakuban_future_returning_nothing_drop, future_pointer).await_and_drop();
+      this.local_exchange.notify();
+      return true;
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped) {
+        return null;
+      }
+      throw error;
+    }
   }
 
-  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
-    };
+  async next(block) {
+    var error, future_pointer, pointer;
+    try {
+      future_pointer = this.with_pointer((pointer) => {
+        return hakuban_object_state_sink_next(pointer);
+      });
+      pointer = (await new Future(this.local_exchange, this, hakuban_future_returning_pointer_poll, hakuban_future_returning_pointer_drop, future_pointer).await_and_drop());
+      if (pointer != null) {
+        return new ObjectStateSinkParams(pointer).do_and_drop_or_return(block);
+      } else {
+        return null;
+      }
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped) {
+        return null;
+      }
+      throw error;
+    }
   }
 
-  events() {
-    return new ObjectDescriptorEvents(hakuban_object_observe_events_get(this.pointer));
+  each(block) {
+    return new StreamEnumerator(this).call_or_return(block);
   }
 
-  manage() {
-    var ManagedObject$1;
-    ManagedObject$1 = class ManagedObject$1 extends ManagedObject {
-      state() {
-        var ref;
-        return (ref = this.contract) != null ? ref.object_state() : void 0;
+  current(block) {
+    var error, pointer;
+    try {
+      pointer = this.with_pointer((pointer) => {
+        return unwrap_pointer_or_null(hakuban_object_state_sink_current(pointer));
+      });
+      if (pointer != null) {
+        return new ObjectStateSinkParams(pointer).do_and_drop_or_return(block);
+      } else {
+        return null;
       }
-
-      data() {
-        var ref, ref1;
-        return (ref = this.contract) != null ? (ref1 = ref.object_state()) != null ? ref1.data : void 0 : void 0;
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped) {
+        return null;
       }
+      throw error;
+    }
+  }
 
-      check_active() {
-        return !!this.state();
+  desynchronize() {
+    var error;
+    try {
+      this.with_pointer((pointer) => {
+        return hakuban_object_state_sink_desynchronize(pointer);
+      });
+      this.local_exchange.notify();
+      return true;
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped) {
+        return null;
       }
-
-    };
-    return new ObjectManagerBuilder(this, ManagedObject$1);
+      throw error;
+    }
   }
 
 };
 
-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);
-  }
+var Contract;
 
-  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;
+Contract = class Contract extends FFIObject {
+  each(block) {
+    return new StreamEnumerator(this).call_or_return(block);
   }
 
-  assignment() {
-    return hakuban_object_expose_assignment(this.pointer);
-  }
+};
 
-  assigned() {
-    return this.assignment() > 0;
+var ObjectObserveContract = class ObjectObserveContract extends Contract {
+  constructor(local_exchange, descriptor) {
+    super();
+    this.local_exchange = local_exchange;
+    this.descriptor = descriptor[0] instanceof ObjectDescriptor ? descriptor[0] : new ObjectDescriptor(...descriptor);
+    this.local_exchange.with_pointer((local_exchange_pointer) => {
+      return this.descriptor.with_pointer((descriptor_pointer) => {
+        return this.initialize_pointer(this.local_exchange, hakuban_object_observe_contract_new(local_exchange_pointer, descriptor_pointer), hakuban_object_observe_contract_drop);
+      });
+    });
+    this.local_exchange.notify();
   }
 
-  desynchronize(assignment) {
-    if (!(typeof assignment === 'bigint')) {
-      assignment = BigInt(assignment);
+  terminate() {
+    var error;
+    try {
+      this.with_pointer((pointer) => {
+        return hakuban_object_observe_contract_terminate(pointer);
+      });
+      return this.local_exchange.notify();
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped$1) {
+        return null;
+      }
+      throw error;
     }
-    return hakuban_object_expose_desynchronize(this.pointer, assignment);
   }
 
-  events() {
-    return new ObjectDescriptorEvents(hakuban_object_expose_events_get(this.pointer));
+  async next(block) {
+    var error, future_pointer, pointer;
+    try {
+      future_pointer = this.with_pointer((pointer) => {
+        return hakuban_object_observe_contract_next(pointer);
+      });
+      pointer = (await new Future(this.local_exchange, this, hakuban_future_returning_pointer_poll, hakuban_future_returning_pointer_drop, future_pointer).await_and_drop());
+      this.local_exchange.notify();
+      if (pointer != null) {
+        return (await new ObjectStateStream(this.local_exchange, pointer).do_and_drop_or_return(block));
+      } else {
+        return null;
+      }
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped$1) {
+        return null;
+      }
+      throw error;
+    }
   }
 
-  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();
+  ready(block) {
+    var error, pointer;
+    try {
+      pointer = this.with_pointer((pointer) => {
+        return unwrap_pointer_or_null(hakuban_object_observe_contract_ready(pointer));
+      });
+      this.local_exchange.notify();
+      if (pointer != null) {
+        return new ObjectStateStream(this.local_exchange, pointer).do_and_drop_or_return(block);
+      } else {
+        return null;
       }
-
-      async run(handler) {
-        var ref;
-        boundMethodCheck(this, ManagedObject$1);
-        await super.run(handler);
-        return (ref = this.contract) != null ? ref.desynchronize(this._assignment) : void 0;
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped$1) {
+        return null;
       }
+      throw error;
+    }
+  }
 
-      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;
-      }
+var ObjectExposeContract = class ObjectExposeContract extends Contract {
+  constructor(local_exchange, descriptor) {
+    super();
+    this.local_exchange = local_exchange;
+    this.descriptor = descriptor[0] instanceof ObjectDescriptor ? descriptor[0] : new ObjectDescriptor(...descriptor);
+    this.local_exchange.with_pointer((local_exchange_pointer) => {
+      return this.descriptor.with_pointer((descriptor_pointer) => {
+        return this.initialize_pointer(this.local_exchange, hakuban_object_expose_contract_new(local_exchange_pointer, descriptor_pointer), hakuban_object_expose_contract_drop);
+      });
+    });
+    this.local_exchange.notify();
+  }
 
-      assigned() {
-        var ref;
-        boundMethodCheck(this, ManagedObject$1);
-        return (ref = this.contract) != null ? ref.assigned() : void 0;
+  terminate() {
+    var error;
+    try {
+      this.with_pointer((pointer) => {
+        return hakuban_object_expose_contract_terminate(pointer);
+      });
+      return this.local_exchange.notify();
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped$1) {
+        return null;
       }
+      throw error;
+    }
+  }
 
-      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;
+  async next(block) {
+    var error, future_pointer, pointer;
+    try {
+      future_pointer = this.with_pointer((pointer) => {
+        return hakuban_object_expose_contract_next(pointer);
+      });
+      pointer = (await new Future(this.local_exchange, this, hakuban_future_returning_pointer_poll, hakuban_future_returning_pointer_drop, future_pointer).await_and_drop());
+      this.local_exchange.notify();
+      if (pointer != null) {
+        return (await new ObjectStateSink(this.local_exchange, pointer).do_and_drop_or_return(block));
+      } else {
+        return null;
       }
-
-      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);
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped$1) {
+        return null;
       }
+      throw error;
+    }
+  }
 
-      check_active() {
-        return this.assigned();
+  ready(block) {
+    var error, pointer;
+    try {
+      pointer = this.with_pointer((pointer) => {
+        return unwrap_pointer_or_null(hakuban_object_expose_contract_ready(pointer));
+      });
+      this.local_exchange.notify();
+      if (pointer != null) {
+        return new ObjectStateSink(this.local_exchange, pointer).do_and_drop_or_return(block);
+      } else {
+        return null;
       }
-
-    };
-    return new ObjectManagerBuilder(this, ManagedObject$1);
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped$1) {
+        return null;
+      }
+      throw error;
+    }
   }
 
 };
 
-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;
+var TagObserveContract = class TagObserveContract extends Contract {
+  constructor(local_exchange, descriptor) {
+    super();
+    this.local_exchange = local_exchange;
+    this.descriptor = descriptor;
+    if (!(this.descriptor instanceof TagDescriptor)) {
+      this.descriptor = new TagDescriptor(this.descriptor);
+    }
+    this.local_exchange.with_pointer((local_exchange_pointer) => {
+      return this.descriptor.with_pointer((descriptor_pointer) => {
+        return this.initialize_pointer(this.local_exchange, hakuban_tag_observe_contract_new(local_exchange_pointer, descriptor_pointer), hakuban_tag_observe_contract_drop);
+      });
+    });
+    this.local_exchange.notify();
   }
 
-  drop() {
-    this.dropped = true;
-    hakuban_tag_observe_drop(this.pointer);
-    return TagObserve_finalization_registry.unregister(this);
+  terminate() {
+    var error;
+    try {
+      this.with_pointer((pointer) => {
+        return hakuban_tag_observe_contract_terminate(pointer);
+      });
+      return this.local_exchange.notify();
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped$1) {
+        return null;
+      }
+      throw error;
+    }
   }
 
-  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));
+  async next(block) {
+    var error, future_pointer, pointer;
+    try {
+      future_pointer = this.with_pointer((pointer) => {
+        return hakuban_tag_observe_contract_next(pointer);
+      });
+      pointer = (await new Future(this.local_exchange, this, hakuban_future_returning_pointer_poll, hakuban_future_returning_pointer_drop, future_pointer).await_and_drop());
+      this.local_exchange.notify();
+      if (pointer != null) {
+        return new ObjectStateStream(this.local_exchange, pointer).do_and_drop_or_return(block);
+      } else {
+        return null;
+      }
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped$1) {
+        return null;
+      }
+      throw error;
     }
-    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;
+  ready(block) {
+    var error, pointer, pointers;
+    try {
+      pointers = this.with_pointer((pointer) => {
+        return hakuban_tag_observe_contract_ready(pointer);
+      });
+      this.local_exchange.notify();
+      return do_and_drop_or_return((function() {
+        var i, len, results;
+        results = [];
+        for (i = 0, len = pointers.length; i < len; i++) {
+          pointer = pointers[i];
+          results.push(new ObjectStateStream(this.local_exchange, pointer));
+        }
+        return results;
+      }).call(this), block);
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped$1) {
+        return null;
+      }
+      throw error;
     }
-    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));
+};
+
+var TagExposeContract = class TagExposeContract extends Contract {
+  constructor(local_exchange, descriptor) {
+    super();
+    this.local_exchange = local_exchange;
+    this.descriptor = descriptor;
+    if (!(this.descriptor instanceof TagDescriptor)) {
+      this.descriptor = new TagDescriptor(this.descriptor);
+    }
+    this.local_exchange.with_pointer((local_exchange_pointer) => {
+      return this.descriptor.with_pointer((descriptor_pointer) => {
+        return this.initialize_pointer(this.local_exchange, hakuban_tag_expose_contract_new(local_exchange_pointer, descriptor_pointer), hakuban_tag_expose_contract_drop);
+      });
+    });
+    this.local_exchange.notify();
   }
 
-  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;
+  terminate() {
+    var error;
+    try {
+      this.with_pointer((pointer) => {
+        return hakuban_tag_expose_contract_terminate(pointer);
+      });
+      return this.local_exchange.notify();
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped$1) {
+        return null;
       }
+      throw error;
+    }
+  }
 
-      data() {
-        var ref, ref1;
-        return (ref = this.contract) != null ? (ref1 = ref.object_state(this.descriptor)) != null ? ref1.data : void 0 : void 0;
+  async next(block) {
+    var error, future_pointer, pointer;
+    try {
+      future_pointer = this.with_pointer((pointer) => {
+        return hakuban_tag_expose_contract_next(pointer);
+      });
+      pointer = (await new Future(this.local_exchange, this, hakuban_future_returning_pointer_poll, hakuban_future_returning_pointer_drop, future_pointer).await_and_drop());
+      this.local_exchange.notify();
+      if (pointer != null) {
+        return new ObjectStateSink(this.local_exchange, pointer).do_and_drop_or_return(block);
+      } else {
+        return null;
       }
-
-      check_active() {
-        return !!this.state();
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped$1) {
+        return null;
       }
+      throw error;
+    }
+  }
 
-    };
-    return new ObjectManagerBuilder(this, ManagedObject$1);
+  ready(block) {
+    var error, pointer, pointers;
+    try {
+      pointers = this.with_pointer((pointer) => {
+        return hakuban_tag_expose_contract_ready(pointer);
+      });
+      this.local_exchange.notify();
+      return do_and_drop_or_return((function() {
+        var i, len, results;
+        results = [];
+        for (i = 0, len = pointers.length; i < len; i++) {
+          pointer = pointers[i];
+          results.push(new ObjectStateSink(this.local_exchange, pointer));
+        }
+        return results;
+      }).call(this), block);
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped$1) {
+        return null;
+      }
+      throw error;
+    }
   }
 
 };
 
-TagExpose_finalization_registry = new FinalizationRegistry((pointer) => {
-  return hakuban_tag_expose_drop(pointer);
-});
+var ObjectContractBuilder, TagContractBuilder;
 
-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;
+var LocalExchange = class LocalExchange extends FFIObject {
+  constructor(name = "wasm") {
+    super();
+    this.name = name;
+    this._notification_sequence = BigInt(0);
+    this._notification_resolve = {};
+    this.initialize_pointer(null, unwrap_pointer(hakuban_local_exchange_new(this.name)), hakuban_local_exchange_drop);
   }
 
-  drop() {
-    this.dropped = true;
-    hakuban_tag_expose_drop(this.pointer);
-    return TagExpose_finalization_registry.unregister(this);
+  object(descriptor_or_tags, json_or_nothing) {
+    return new ObjectContractBuilder(this, [descriptor_or_tags, json_or_nothing]);
+  }
+
+  tag(descriptor) {
+    return new TagContractBuilder(this, descriptor);
+  }
+
+  notified() {
+    var id, promise;
+    id = ++this._notification_sequence;
+    promise = new Promise((resolve) => {
+      return this._notification_resolve[id] = resolve;
+    });
+    promise.id = id;
+    return promise;
   }
 
-  object_descriptors() {
-    var descriptor_as_json, i, len, ref, result, results;
-    result = hakuban_tag_expose_object_descriptors(this.pointer);
-    ref = JSON.parse(result);
+  notify() {
+    var i, id, len, ref, results;
+    ref = this.with_pointer(function(pointer) {
+      return hakuban_local_exchange_notified(pointer);
+    });
     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));
+      id = ref[i];
+      // if you want to put console.log here, you forgot to await
+      if (this._notification_resolve[id] != null) {
+        this._notification_resolve[id](true);
+        results.push(delete this._notification_resolve[id]);
+      } else {
+        results.push(void 0);
+      }
     }
     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;
+  return_notified(notification_promise) {
+    return delete this._notification_resolve[notification_promise.id];
   }
 
-  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;
+ObjectContractBuilder = class ObjectContractBuilder {
+  constructor(local_exchange, descriptor1) {
+    this.local_exchange = local_exchange;
+    this.descriptor = descriptor1;
   }
 
-  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);
+  observe(block) {
+    return new ObjectObserveContract(this.local_exchange, this.descriptor).do_and_drop_or_return(block);
   }
 
-  events() {
-    return new ObjectDescriptorEvents(hakuban_tag_expose_events_get(this.pointer));
+  expose(block) {
+    return new ObjectExposeContract(this.local_exchange, this.descriptor).do_and_drop_or_return(block);
   }
 
-  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;
-      }
+TagContractBuilder = class TagContractBuilder {
+  constructor(local_exchange, descriptor1) {
+    this.local_exchange = local_exchange;
+    this.descriptor = descriptor1;
+  }
 
-      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);
-      }
+  observe(block) {
+    return new TagObserveContract(this.local_exchange, this.descriptor).do_and_drop_or_return(block);
+  }
 
-      assignment() {
-        var ref;
-        boundMethodCheck(this, ManagedObject$1);
-        return (ref = this.contract) != null ? ref.assignment(this.descriptor) : void 0;
-      }
+  expose(block) {
+    return new TagExposeContract(this.local_exchange, this.descriptor).do_and_drop_or_return(block);
+  }
 
-      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;
-      }
+var RemoteExchange = class RemoteExchange extends FFIObject {
+  constructor(local_exchange, upstream, diff_produce, diff_request) {
+    super();
+    this.local_exchange = local_exchange;
+    this.local_exchange.with_pointer((local_exchange_pointer) => {
+      return this.initialize_pointer(this.local_exchange, hakuban_remote_exchange_new(local_exchange_pointer, upstream, diff_produce, diff_request), hakuban_remote_exchange_drop);
+    });
+  }
 
-      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);
+  async next() {
+    var error, future_pointer, pointer;
+    try {
+      future_pointer = this.with_pointer((pointer) => {
+        return hakuban_remote_exchange_next_message_to_network(pointer);
+      });
+      pointer = (await new Future(this.local_exchange, this, hakuban_future_returning_pointer_poll, hakuban_future_returning_pointer_drop, future_pointer).await_and_drop());
+      this.local_exchange.notify();
+      return pointer;
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped$1) {
+        return null;
       }
+      throw error;
+    }
+  }
 
-      check_active() {
-        return this.assigned();
+  async send(data) {
+    var error, future_pointer;
+    try {
+      future_pointer = this.with_pointer((pointer) => {
+        return hakuban_remote_exchange_send_message_from_network(pointer, new Uint8Array(data));
+      });
+      await new Future(this.local_exchange, this, hakuban_future_returning_nothing_poll, hakuban_future_returning_nothing_drop, future_pointer).await_and_drop();
+      return this.local_exchange.notify();
+    } catch (error1) {
+      error = error1;
+      if (error instanceof PointerAlreadyDropped$1) {
+        return null;
       }
-
-    };
-    return new ObjectManagerBuilder(this, ManagedObject$1);
+      throw error;
+    }
   }
 
 };
 
-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;
+  constructor(local_exchange, uri, options = {}) {
     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.local_exchange = local_exchange;
     this.uri = uri;
     this.options = options;
-    this.connected = false;
+    this._status_change({
+      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;
+  status() {
+    return Promise.resolve([this.status, this.next_status_promise]);
+  }
+
+  _status_change(new_status) {
+    var old_next_status_promise_resolve;
+    this.status = new_status;
+    old_next_status_promise_resolve = this.next_status_promise_resolve;
+    this.next_status_promise = new Promise((next_status_promise_resolve) => {
+      this.next_status_promise_resolve = next_status_promise_resolve;
+    });
+    if (old_next_status_promise_resolve != null) {
+      return old_next_status_promise_resolve([this.status, this.next_status_promise]);
     }
+  }
+
+  disconnect() {
+    this.reconnect_on_close = false;
     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;
+      return this.socket.close();
     }
-    hakuban_remote_node_drop(this.remote_node_pointer);
-    return WebsocketConnector_finalization_registry.unregister(this);
   }
 
   connect() {
     var error;
+    if (this.reconnection_timer != null) {
+      clearTimeout(this.reconnection_timer);
+    }
     this.reconnection_timer = void 0;
     try {
       this.socket = new WebSocket(this.uri);
     } catch (error1) {
       error = error1;
-      this.error = {
-        while: "connecting",
+      console.error('Error connecting to hakuban remote exchange:', error);
+      this._status_change({
+        connected: false,
         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);
+        console.debug('Connected to hakuban remote exchange');
       }
-      bytes_to_send = hakuban_remote_node_connected(this.remote_node_pointer);
-      return this.send(bytes_to_send);
+      this.remote_exchange = new RemoteExchange(this.local_exchange, true, true, true);
+      this.forwarding_to_network_stopped = new Promise(async(resolve) => {
+        var message_pointer;
+        try {
+          while ((this.remote_exchange != null) && ((message_pointer = (await this.remote_exchange.next())) != null)) {
+            this.send(hakuban_message_take(message_pointer));
+          }
+        } catch (error1) {
+          error = error1;
+          console.error('Error processing hakuban connection:', error);
+          if (this.socket != null) {
+            this.socket.close();
+          }
+        }
+        return resolve();
+      });
+      return this._status_change({
+        connected: true
+      });
     };
-    this.socket.onclose = this.socket_onclose = () => {
-      if (this.options.debug) {
-        console.debug('Disconnected from hakuban remote node');
+    // this may fire even if onopen never did
+    this.socket.onclose = async(event) => {
+      if (this.options.debug && (this.remote_exchange != null)) {
+        console.debug('Disconnected from hakuban remote exchange');
       }
-      if (this.keep_alive_interval) {
-        clearInterval(this.keep_alive_interval);
+      if (this.options.debug && (this.remote_exchange == null)) {
+        console.debug('Failed to connect to hakuban remote exchange');
       }
-      this.connected = false;
+      this._status_change({
+        connected: false,
+        disconnect_reason: event.reason,
+        clean_disconnect: event.wasClean
+      });
       this.socket = void 0;
-      hakuban_remote_node_disconnected(this.remote_node_pointer);
-      if (this.onstatuschange_proc != null) {
-        this.onstatuschange_proc(this);
+      if (this.keep_alive_interval != null) {
+        clearInterval(this.keep_alive_interval);
+        this.keep_alive_interval = null;
       }
       if (this.reconnection_timer != null) {
         clearTimeout(this.reconnection_timer);
+        this.reconnection_timer = null;
+      }
+      if (this.remote_exchange != null) {
+        await this.remote_exchange.drop();
+        await this.forwarding_to_network_stopped;
+        this.forwarding_to_network_stopped = null;
+        this.remote_exchange = null;
       }
-      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.socket.onmessage = async(event) => {
+      if (this.remote_exchange == null) {
+        return;
       }
-      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);
+      try {
+        return (await this.remote_exchange.send(event.data));
+      } catch (error1) {
+        error = error1;
+        console.error('Error processing hakuban connection:', error);
+        if (this.socket != null) {
+          return this.socket.close();
+        }
       }
-      this.ack_timer = setTimeout(this.ack, 1000);
-      return null;
     };
   }
 
@@ -2610,62 +2275,14 @@ var WebsocketConnector = class WebsocketConnector {
     }
   }
 
-  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));
+var initialize = async function(wasm, log_level) {
+  var result;
+  result = (await init(wasm));
+  logger_initialize(log_level);
+  return result;
 };
 
-export { JSON_deserialize, JSON_serialize, LocalNode, ObjectDescriptor, TagDescriptor, WebsocketConnector, initialize, initialize_wasm, logger_initialize };
+export { LocalExchange, ObjectDescriptor, ObjectExposeContract, ObjectObserveContract, ObjectState, TagDescriptor, TagExposeContract, TagObserveContract, WebsocketConnector, initialize };
 //# sourceMappingURL=hakuban.js.map