hakuban 0.7.3 → 0.8.0

package/hakuban.js

@@ -1,54 +1,40 @@
 let wasm;
 
-const cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-
-cachedTextDecoder.decode();
-
-let cachedUint8Memory0 = new Uint8Array();
-
-function getUint8Memory0() {
-    if (cachedUint8Memory0.byteLength === 0) {
-        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8Memory0;
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_export_2.set(idx, obj);
+    return idx;
 }
 
-function getStringFromWasm0(ptr, len) {
-    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
 }
 
-const heap = new Array(32).fill(undefined);
-
-heap.push(undefined, null, true, false);
-
-let heap_next = heap.length;
-
-function addHeapObject(obj) {
-    if (heap_next === heap.length) heap.push(heap.length + 1);
-    const idx = heap_next;
-    heap_next = heap[idx];
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
 
-    heap[idx] = obj;
-    return idx;
-}
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); }
+let cachedUint8ArrayMemory0 = null;
 
-function getObject(idx) { return heap[idx]; }
-
-function dropObject(idx) {
-    if (idx < 36) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
 }
 
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
 let WASM_VECTOR_LEN = 0;
 
-const cachedTextEncoder = new TextEncoder('utf-8');
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
 
 const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
     ? function (arg, view) {
@@ -67,16 +53,16 @@ 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);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
         WASM_VECTOR_LEN = buf.length;
         return ptr;
     }
 
     let len = arg.length;
-    let ptr = malloc(len);
+    let ptr = malloc(len, 1) >>> 0;
 
-    const mem = getUint8Memory0();
+    const mem = getUint8ArrayMemory0();
 
     let offset = 0;
 
@@ -90,338 +76,283 @@ function passStringToWasm0(arg, malloc, realloc) {
         if (offset !== 0) {
             arg = arg.slice(offset);
         }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3);
-        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
         const ret = encodeString(arg, view);
 
         offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
     }
 
     WASM_VECTOR_LEN = offset;
     return ptr;
 }
 
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
 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 cachedInt32Memory0;
+/**
+ * @param {string} default_log_level
+ * @returns {WasmResult}
+ */
+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 WasmResult.__wrap(ret);
 }
 
-function debugString(val) {
-    // primitive types
-    const type = typeof val;
-    if (type == 'number' || type == 'boolean' || val == null) {
-        return  `${val}`;
-    }
-    if (type == 'string') {
-        return `"${val}"`;
-    }
-    if (type == 'symbol') {
-        const description = val.description;
-        if (description == null) {
-            return 'Symbol';
-        } else {
-            return `Symbol(${description})`;
-        }
-    }
-    if (type == 'function') {
-        const name = val.name;
-        if (typeof name == 'string' && name.length > 0) {
-            return `Function(${name})`;
-        } else {
-            return 'Function';
-        }
-    }
-    // objects
-    if (Array.isArray(val)) {
-        const length = val.length;
-        let debug = '[';
-        if (length > 0) {
-            debug += debugString(val[0]);
-        }
-        for(let i = 1; i < length; i++) {
-            debug += ', ' + debugString(val[i]);
-        }
-        debug += ']';
-        return debug;
-    }
-    // Test for built-in
-    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
-    let className;
-    if (builtInMatches.length > 1) {
-        className = builtInMatches[1];
-    } else {
-        // Failed to match the standard '[object ClassName]'
-        return toString.call(val);
-    }
-    if (className == 'Object') {
-        // we're a user defined class or Object
-        // JSON.stringify avoids problems with cycles, and is generally much
-        // easier than looping through ownProperties of `val`.
-        try {
-            return 'Object(' + JSON.stringify(val) + ')';
-        } catch (_) {
-            return 'Object';
-        }
-    }
-    // errors
-    if (val instanceof Error) {
-        return `${val.name}: ${val.message}\n${val.stack}`;
-    }
-    // TODO we could test for more things here, like `Set`s and `Map`s.
-    return className;
+/**
+ * @param {number} exchange
+ * @param {number} descriptor
+ * @param {number} capacity
+ * @returns {number}
+ */
+function hakuban_object_expose_contract_new(exchange, descriptor, capacity) {
+    const ret = wasm.hakuban_object_expose_contract_new(exchange, descriptor, capacity);
+    return ret >>> 0;
 }
+
 /**
-* @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;
+ * @param {number} object_ptr
+ */
+function hakuban_object_expose_contract_drop(object_ptr) {
+    wasm.hakuban_object_expose_contract_drop(object_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);
+ * @param {number} object_expose_pointer
+ * @returns {number}
+ */
+function hakuban_object_expose_contract_next(object_expose_pointer) {
+    const ret = wasm.hakuban_object_expose_contract_next(object_expose_pointer);
+    return ret >>> 0;
 }
 
 /**
-* @param {number} tag_expose_pointer
-*/
-function hakuban_tag_expose_contract_terminate(tag_expose_pointer) {
-    wasm.hakuban_tag_expose_contract_terminate(tag_expose_pointer);
+ * @param {number} exchange
+ * @param {number} descriptor
+ * @returns {number}
+ */
+function hakuban_object_observe_contract_new(exchange, descriptor) {
+    const ret = wasm.hakuban_object_observe_contract_new(exchange, descriptor);
+    return ret >>> 0;
 }
 
 /**
-* @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;
+ * @param {number} object_ptr
+ */
+function hakuban_object_observe_contract_drop(object_ptr) {
+    wasm.hakuban_object_observe_contract_drop(object_ptr);
 }
 
-let cachedUint32Memory0 = new Uint32Array();
+/**
+ * @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 >>> 0;
+}
 
-function getUint32Memory0() {
-    if (cachedUint32Memory0.byteLength === 0) {
-        cachedUint32Memory0 = new Uint32Array(wasm.memory.buffer);
-    }
-    return cachedUint32Memory0;
+/**
+ * @param {number} object_state_sink_pointer
+ * @returns {number}
+ */
+function hakuban_object_state_sink_descriptor(object_state_sink_pointer) {
+    const ret = wasm.hakuban_object_state_sink_descriptor(object_state_sink_pointer);
+    return ret >>> 0;
 }
 
-function getArrayU32FromWasm0(ptr, len) {
-    return getUint32Memory0().subarray(ptr / 4, ptr / 4 + len);
+/**
+ * @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_pointer
-* @returns {Uint32Array}
-*/
-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 {number} object_state_sink_pointer
+ * @returns {number}
+ */
+function hakuban_object_state_sink_next(object_state_sink_pointer) {
+    const ret = wasm.hakuban_object_state_sink_next(object_state_sink_pointer);
+    return ret >>> 0;
 }
 
 /**
-* @param {number} local_exchange
-* @param {number} descriptor
-* @returns {number}
-*/
-function hakuban_tag_observe_contract_new(local_exchange, descriptor) {
-    const ret = wasm.hakuban_tag_observe_contract_new(local_exchange, descriptor);
-    return ret;
+ * @param {number} object_state_sink_pointer
+ * @param {number} object_state_pointer
+ * @returns {number}
+ */
+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 >>> 0;
 }
 
 /**
-* @param {number} tag_pointer
-*/
-function hakuban_tag_observe_contract_drop(tag_pointer) {
-    wasm.hakuban_tag_observe_contract_drop(tag_pointer);
+ * @param {number} object_state_sink_params_pointer
+ */
+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} tag_observe_pointer
-*/
-function hakuban_tag_observe_contract_terminate(tag_observe_pointer) {
-    wasm.hakuban_tag_observe_contract_terminate(tag_observe_pointer);
+ * @param {number} object_state_stream_pointer
+ */
+function hakuban_object_state_stream_drop(object_state_stream_pointer) {
+    wasm.hakuban_object_state_stream_drop(object_state_stream_pointer);
 }
 
 /**
-* @param {number} tag_observe_pointer
-* @returns {number}
-*/
-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_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 >>> 0;
 }
 
 /**
-* @param {number} tag_observe_pointer
-* @returns {Uint32Array}
-*/
-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_state_stream_pointer
+ * @returns {number}
+ */
+function hakuban_object_state_stream_descriptor(object_state_stream_pointer) {
+    const ret = wasm.hakuban_object_state_stream_descriptor(object_state_stream_pointer);
+    return ret >>> 0;
 }
 
 /**
-* @param {string} json_string
-* @returns {WasmResultWithPointer}
-*/
-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} exchange
+ * @param {number} descriptor
+ * @returns {number}
+ */
+function hakuban_tag_observe_contract_new(exchange, descriptor) {
+    const ret = wasm.hakuban_tag_observe_contract_new(exchange, descriptor);
+    return ret >>> 0;
 }
 
 /**
-* @param {number} descriptor_pointer
-*/
-function hakuban_tag_descriptor_drop(descriptor_pointer) {
-    wasm.hakuban_tag_descriptor_drop(descriptor_pointer);
+ * @param {number} tag_pointer
+ */
+function hakuban_tag_observe_contract_drop(tag_pointer) {
+    wasm.hakuban_tag_observe_contract_drop(tag_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} tag_observe_pointer
+ * @returns {number}
+ */
+function hakuban_tag_observe_contract_next(tag_observe_pointer) {
+    const ret = wasm.hakuban_tag_observe_contract_next(tag_observe_pointer);
+    return ret >>> 0;
 }
+
 /**
-* @param {string} json_string
-* @param {Uint32Array} tag_pointers
-* @returns {WasmResultWithPointer}
-*/
-function hakuban_object_descriptor_new(json_string, tag_pointers) {
-    const ptr0 = passStringToWasm0(json_string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ * @param {number} exchange_pointer
+ * @param {string} local_name
+ * @param {string} local_address
+ * @returns {number}
+ */
+function hakuban_upstream_connection_new(exchange_pointer, local_name, local_address) {
+    const ptr0 = passStringToWasm0(local_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray32ToWasm0(tag_pointers, wasm.__wbindgen_malloc);
+    const ptr1 = passStringToWasm0(local_address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.hakuban_object_descriptor_new(ptr0, len0, ptr1, len1);
-    return WasmResultWithPointer.__wrap(ret);
+    const ret = wasm.hakuban_upstream_connection_new(exchange_pointer, ptr0, len0, ptr1, len1);
+    return ret >>> 0;
 }
 
 /**
-* @param {number} descriptor_pointer
-*/
-function hakuban_object_descriptor_drop(descriptor_pointer) {
-    wasm.hakuban_object_descriptor_drop(descriptor_pointer);
+ * @param {number} wasm_upstream_connection
+ */
+function hakuban_upstream_connection_drop(wasm_upstream_connection) {
+    wasm.hakuban_upstream_connection_drop(wasm_upstream_connection);
 }
 
 /**
-* @param {number} descriptor_pointer
-* @returns {string}
-*/
-function hakuban_object_descriptor_json(descriptor_pointer) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.hakuban_object_descriptor_json(retptr, descriptor_pointer);
-        var r0 = getInt32Memory0()[retptr / 4 + 0];
-        var r1 = getInt32Memory0()[retptr / 4 + 1];
-        return getStringFromWasm0(r0, r1);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_free(r0, r1);
-    }
+ * @param {number} wasm_upstream_connection
+ * @returns {number}
+ */
+function hakuban_upstream_connection_next_message_to_network(wasm_upstream_connection) {
+    const ret = wasm.hakuban_upstream_connection_next_message_to_network(wasm_upstream_connection);
+    return ret >>> 0;
 }
 
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
 /**
-* @param {number} descriptor_pointer
-* @returns {Uint32Array}
-*/
-function hakuban_object_descriptor_tags(descriptor_pointer) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.hakuban_object_descriptor_tags(retptr, descriptor_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} message_pointer
+ * @returns {Uint8Array}
+ */
+function hakuban_message_serialize(message_pointer) {
+    const ret = wasm.hakuban_message_serialize(message_pointer);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
 /**
-* @param {string} default_log_level
-* @returns {number}
-*/
-function hakuban_logger_initialize(default_log_level) {
-    const ptr0 = passStringToWasm0(default_log_level, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+ * @param {number} wasm_upstream_connection
+ * @param {Uint8Array} message_data
+ * @returns {number}
+ */
+function hakuban_upstream_connection_send_message_from_network(wasm_upstream_connection, message_data) {
+    const ptr0 = passArray8ToWasm0(message_data, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.hakuban_logger_initialize(ptr0, len0);
+    const ret = wasm.hakuban_upstream_connection_send_message_from_network(wasm_upstream_connection, ptr0, len0);
     return ret >>> 0;
 }
 
-let cachedBigUint64Memory0 = new BigUint64Array();
+let cachedBigUint64ArrayMemory0 = null;
 
-function getBigUint64Memory0() {
-    if (cachedBigUint64Memory0.byteLength === 0) {
-        cachedBigUint64Memory0 = new BigUint64Array(wasm.memory.buffer);
+function getBigUint64ArrayMemory0() {
+    if (cachedBigUint64ArrayMemory0 === null || cachedBigUint64ArrayMemory0.byteLength === 0) {
+        cachedBigUint64ArrayMemory0 = new BigUint64Array(wasm.memory.buffer);
     }
-    return cachedBigUint64Memory0;
+    return cachedBigUint64ArrayMemory0;
 }
 
 function passArray64ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 8);
-    getBigUint64Memory0().set(arg, ptr / 8);
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getBigUint64ArrayMemory0().set(arg, ptr / 8);
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
 
 function passArrayJsValueToWasm0(array, malloc) {
-    const ptr = malloc(array.length * 4);
-    const mem = getUint32Memory0();
+    const ptr = malloc(array.length * 4, 4) >>> 0;
     for (let i = 0; i < array.length; i++) {
-        mem[ptr / 4 + i] = addHeapObject(array[i]);
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
     }
     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 {BigInt64Array} version
-* @param {any[]} format_jsvalues
-* @param {Uint8Array} data
-* @param {bigint} synchronized_us_ago
-* @returns {WasmResultWithPointer}
-*/
+ * @param {BigInt64Array} version
+ * @param {any[]} format_jsvalues
+ * @param {Uint8Array} data
+ * @param {bigint} synchronized_us_ago
+ * @returns {WasmResult}
+ */
 function hakuban_object_state_new(version, format_jsvalues, data, synchronized_us_ago) {
     const ptr0 = passArray64ToWasm0(version, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
@@ -430,509 +361,332 @@ function hakuban_object_state_new(version, format_jsvalues, data, synchronized_u
     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);
+    return WasmResult.__wrap(ret);
 }
 
 /**
-* @param {number} object_state_pointer
-*/
+ * @param {number} object_state_pointer
+ */
 function hakuban_object_state_drop(object_state_pointer) {
     wasm.hakuban_object_state_drop(object_state_pointer);
 }
 
-let cachedBigInt64Memory0 = new BigInt64Array();
+let cachedBigInt64ArrayMemory0 = null;
 
-function getBigInt64Memory0() {
-    if (cachedBigInt64Memory0.byteLength === 0) {
-        cachedBigInt64Memory0 = new BigInt64Array(wasm.memory.buffer);
+function getBigInt64ArrayMemory0() {
+    if (cachedBigInt64ArrayMemory0 === null || cachedBigInt64ArrayMemory0.byteLength === 0) {
+        cachedBigInt64ArrayMemory0 = new BigInt64Array(wasm.memory.buffer);
     }
-    return cachedBigInt64Memory0;
+    return cachedBigInt64ArrayMemory0;
 }
 
 function getArrayI64FromWasm0(ptr, len) {
-    return getBigInt64Memory0().subarray(ptr / 8, ptr / 8 + len);
+    ptr = ptr >>> 0;
+    return getBigInt64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
 }
 /**
-* @param {number} object_state_pointer
-* @returns {BigInt64Array}
-*/
+ * @param {number} object_state_pointer
+ * @returns {BigInt64Array}
+ */
 function hakuban_object_state_version(object_state_pointer) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.hakuban_object_state_version(retptr, object_state_pointer);
-        var r0 = getInt32Memory0()[retptr / 4 + 0];
-        var r1 = getInt32Memory0()[retptr / 4 + 1];
-        var v0 = getArrayI64FromWasm0(r0, r1).slice();
-        wasm.__wbindgen_free(r0, r1 * 8);
-        return v0;
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
+    const ret = wasm.hakuban_object_state_version(object_state_pointer);
+    var v1 = getArrayI64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
 }
 
 /**
-* @param {number} object_state_pointer
-* @returns {bigint}
-*/
+ * @param {number} object_state_pointer
+ * @returns {bigint}
+ */
 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 getArrayJsValueFromWasm0(ptr, len) {
-    const mem = getUint32Memory0();
-    const slice = mem.subarray(ptr / 4, ptr / 4 + len);
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
     const result = [];
-    for (let i = 0; i < slice.length; i++) {
-        result.push(takeObject(slice[i]));
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
     }
+    wasm.__externref_drop_slice(ptr, len);
     return result;
 }
 /**
-* @param {number} object_state_pointer
-* @returns {any[]}
-*/
+ * @param {number} object_state_pointer
+ * @returns {any[]}
+ */
 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);
-    }
+    const ret = wasm.hakuban_object_state_format(object_state_pointer);
+    var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
 }
 
-function getArrayU8FromWasm0(ptr, len) {
-    return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
-}
 /**
-* @param {number} object_state_pointer
-* @returns {Uint8Array}
-*/
+ * @param {number} object_state_pointer
+ * @returns {Uint8Array}
+ */
 function hakuban_object_state_data(object_state_pointer) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.hakuban_object_state_data(retptr, object_state_pointer);
-        var r0 = getInt32Memory0()[retptr / 4 + 0];
-        var r1 = getInt32Memory0()[retptr / 4 + 1];
-        var v0 = getArrayU8FromWasm0(r0, r1).slice();
-        wasm.__wbindgen_free(r0, r1 * 1);
-        return v0;
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
+    const ret = wasm.hakuban_object_state_data(object_state_pointer);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
 }
 
 /**
-* @param {number} object_state_stream_pointer
-*/
-function hakuban_object_state_stream_drop(object_state_stream_pointer) {
-    wasm.hakuban_object_state_stream_drop(object_state_stream_pointer);
+ * @param {string} json_string
+ * @returns {WasmResult}
+ */
+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 WasmResult.__wrap(ret);
 }
 
 /**
-* @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} descriptor_pointer
+ */
+function hakuban_tag_descriptor_drop(descriptor_pointer) {
+    wasm.hakuban_tag_descriptor_drop(descriptor_pointer);
 }
 
-/**
-* @param {number} object_state_stream_pointer
-* @returns {WasmResultWithPointer}
-*/
-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);
-}
+let cachedUint32ArrayMemory0 = null;
 
-/**
-* @param {number} object_state_stream_pointer
-* @returns {number}
-*/
-function hakuban_object_state_stream_descriptor(object_state_stream_pointer) {
-    const ret = wasm.hakuban_object_state_stream_descriptor(object_state_stream_pointer);
-    return ret;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
 }
 
-/**
-* @param {number} local_exchange_pointer
-* @param {boolean} upstream
-* @param {boolean} diff_produce
-* @param {boolean} diff_request
-* @returns {number}
-*/
-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;
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
 }
-
 /**
-* @param {number} remote_exchange_pointer
-*/
-function hakuban_remote_exchange_drop(remote_exchange_pointer) {
-    wasm.hakuban_remote_exchange_drop(remote_exchange_pointer);
+ * @param {string} json_string
+ * @param {Uint32Array} tag_pointers
+ * @returns {WasmResult}
+ */
+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 WasmResult.__wrap(ret);
 }
 
 /**
-* @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} descriptor_pointer
+ */
+function hakuban_object_descriptor_drop(descriptor_pointer) {
+    wasm.hakuban_object_descriptor_drop(descriptor_pointer);
 }
 
 /**
-* @param {number} message_pointer
-* @returns {Uint8Array}
-*/
-function hakuban_message_take(message_pointer) {
+ * @param {number} descriptor_pointer
+ * @returns {string}
+ */
+function hakuban_object_descriptor_json(descriptor_pointer) {
+    let deferred1_0;
+    let deferred1_1;
     try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        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();
-        wasm.__wbindgen_free(r0, r1 * 1);
-        return v0;
+        const ret = wasm.hakuban_object_descriptor_json(descriptor_pointer);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
 }
 
-/**
-* @param {number} remote_exchange_pointer
-* @param {Uint8Array} message_data
-* @returns {number}
-*/
-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} local_exchange_pointer
-* @param {number} future_pointer
-* @param {bigint} waker_id
-* @returns {WasmResultWithPointer}
-*/
-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} future
-*/
-function hakuban_future_returning_pointer_drop(future) {
-    wasm.hakuban_future_returning_nothing_drop(future);
-}
-
-/**
-* @param {number} local_exchange_pointer
-* @param {number} future_pointer
-* @param {bigint} waker_id
-* @returns {WasmResultWithNothing}
-*/
-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} future
-*/
-function hakuban_future_returning_nothing_drop(future) {
-    wasm.hakuban_future_returning_nothing_drop(future);
-}
-
-/**
-* @param {number} object_state_sink_pointer
-* @returns {number}
-*/
-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} object_state_sink_pointer
-* @returns {number}
-*/
-function hakuban_object_state_sink_next(object_state_sink_pointer) {
-    const ret = wasm.hakuban_object_state_sink_next(object_state_sink_pointer);
-    return ret;
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
-
 /**
-* @param {number} object_state_sink_pointer
-* @returns {WasmResultWithPointer}
-*/
-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} descriptor_pointer
+ * @returns {Uint32Array}
+ */
+function hakuban_object_descriptor_tags(descriptor_pointer) {
+    const ret = wasm.hakuban_object_descriptor_tags(descriptor_pointer);
+    var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+    return v1;
 }
 
 /**
-* @param {number} object_state_sink_pointer
-* @param {number} object_state_pointer
-* @returns {number}
-*/
-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} exchange
+ * @param {number} descriptor
+ * @param {number} capacity
+ * @returns {number}
+ */
+function hakuban_tag_expose_contract_new(exchange, descriptor, capacity) {
+    const ret = wasm.hakuban_tag_expose_contract_new(exchange, descriptor, capacity);
+    return ret >>> 0;
 }
 
 /**
-* @param {number} object_state_sink_params_pointer
-*/
-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} tag_expose_contract_pointer
+ */
+function hakuban_tag_expose_contract_drop(tag_expose_contract_pointer) {
+    wasm.hakuban_tag_expose_contract_drop(tag_expose_contract_pointer);
 }
 
 /**
-* @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 {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 >>> 0;
 }
 
 /**
-* @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);
+ * @returns {WasmResult}
+ */
+function hakuban_exchange_new() {
+    const ret = wasm.hakuban_exchange_new();
+    return WasmResult.__wrap(ret);
 }
 
 /**
-* @param {number} local_exchange
-*/
-function hakuban_local_exchange_drop(local_exchange) {
-    wasm.hakuban_local_exchange_drop(local_exchange);
+ * @param {number} exchange
+ */
+function hakuban_exchange_drop(exchange) {
+    wasm.hakuban_exchange_drop(exchange);
 }
 
 function getArrayU64FromWasm0(ptr, len) {
-    return getBigUint64Memory0().subarray(ptr / 8, ptr / 8 + len);
-}
-/**
-* @param {number} local_exchange
-* @returns {BigUint64Array}
-*/
-function hakuban_local_exchange_notified(local_exchange) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.hakuban_local_exchange_notified(retptr, local_exchange);
-        var r0 = getInt32Memory0()[retptr / 4 + 0];
-        var r1 = getInt32Memory0()[retptr / 4 + 1];
-        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
-*/
-function hakuban_object_expose_contract_terminate(object_expose_pointer) {
-    wasm.hakuban_object_expose_contract_terminate(object_expose_pointer);
-}
-
-/**
-* @param {number} object_expose_pointer
-* @returns {number}
-*/
-function hakuban_object_expose_contract_next(object_expose_pointer) {
-    const ret = wasm.hakuban_object_expose_contract_next(object_expose_pointer);
-    return ret;
+    ptr = ptr >>> 0;
+    return getBigUint64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
 }
-
 /**
-* @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} exchange
+ * @returns {BigUint64Array}
+ */
+function hakuban_exchange_notified(exchange) {
+    const ret = wasm.hakuban_exchange_notified(exchange);
+    var v1 = getArrayU64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
 }
 
 /**
-* @param {number} local_exchange
-* @param {number} descriptor
-* @returns {number}
-*/
-function hakuban_object_observe_contract_new(local_exchange, descriptor) {
-    const ret = wasm.hakuban_object_observe_contract_new(local_exchange, descriptor);
-    return ret;
+ * @param {number} exchange_pointer
+ * @param {number} future_pointer
+ * @param {bigint} waker_id
+ * @returns {WasmResult}
+ */
+function hakuban_future_poll(exchange_pointer, future_pointer, waker_id) {
+    const ret = wasm.hakuban_future_poll(exchange_pointer, future_pointer, waker_id);
+    return WasmResult.__wrap(ret);
 }
 
 /**
-* @param {number} object_ptr
-*/
-function hakuban_object_observe_contract_drop(object_ptr) {
-    wasm.hakuban_object_observe_contract_drop(object_ptr);
+ * @param {number} future
+ */
+function hakuban_future_drop(future) {
+    wasm.hakuban_future_drop(future);
 }
 
 /**
-* @param {number} object_observe_pointer
-*/
-function hakuban_object_observe_contract_terminate(object_observe_pointer) {
-    wasm.hakuban_object_observe_contract_terminate(object_observe_pointer);
-}
+ * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9}
+ */
+Object.freeze({
+    Ok: 0, "0": "Ok",
+    Pointer: 1, "1": "Pointer",
+    Pending: 2, "2": "Pending",
+    EndOfStream: 3, "3": "EndOfStream",
+    InvalidString: 4, "4": "InvalidString",
+    InvalidJSON: 5, "5": "InvalidJSON",
+    InvalidURL: 6, "6": "InvalidURL",
+    InvalidLogLevel: 7, "7": "InvalidLogLevel",
+    LoggerInitializationError: 8, "8": "LoggerInitializationError",
+    ConnectionTerminated: 9, "9": "ConnectionTerminated",
+});
 
-/**
-* @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;
-}
+const WasmResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmresult_free(ptr >>> 0, 1));
 
-/**
-* @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);
-}
-
-function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        wasm.__wbindgen_exn_store(addHeapObject(e));
-    }
-}
-/**
-*/
-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 {
+class WasmResult {
 
     static __wrap(ptr) {
-        const obj = Object.create(WasmResultWithNothing.prototype);
-        obj.ptr = ptr;
-
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmResult.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmResultFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
-        const ptr = this.ptr;
-        this.ptr = 0;
-
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmResultFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wasmresultwithnothing_free(ptr);
+        wasm.__wbg_wasmresult_free(ptr, 0);
     }
     /**
-    * @returns {number}
-    */
+     * @returns {WasmResultStatus}
+     */
     get status() {
-        const ret = wasm.__wbg_get_wasmresultwithnothing_status(this.ptr);
-        return ret >>> 0;
+        const ret = wasm.__wbg_get_wasmresult_status(this.__wbg_ptr);
+        return ret;
     }
     /**
-    * @param {number} arg0
-    */
+     * @param {WasmResultStatus} arg0
+     */
     set status(arg0) {
-        wasm.__wbg_set_wasmresultwithnothing_status(this.ptr, arg0);
-    }
-}
-/**
-*/
-class WasmResultWithPointer {
-
-    static __wrap(ptr) {
-        const obj = Object.create(WasmResultWithPointer.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_wasmresultwithpointer_free(ptr);
+        wasm.__wbg_set_wasmresult_status(this.__wbg_ptr, arg0);
     }
     /**
-    * @returns {number}
-    */
-    get status() {
-        const ret = wasm.__wbg_get_wasmresultwithpointer_status(this.ptr);
-        return ret >>> 0;
+     * @returns {number | undefined}
+     */
+    get pointer() {
+        const ret = wasm.__wbg_get_wasmresult_pointer(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
     }
     /**
-    * @param {number} arg0
-    */
-    set status(arg0) {
-        wasm.__wbg_set_wasmresultwithpointer_status(this.ptr, arg0);
+     * @param {number | null} [arg0]
+     */
+    set pointer(arg0) {
+        wasm.__wbg_set_wasmresult_pointer(this.__wbg_ptr, isLikeNone(arg0) ? 0x100000001 : (arg0) >>> 0);
     }
     /**
-    * @returns {number}
-    */
-    get value() {
-        const ret = wasm.__wbg_get_wasmresultwithpointer_value(this.ptr);
-        return ret;
+     * @returns {string | undefined}
+     */
+    get error_message() {
+        const ret = wasm.__wbg_get_wasmresult_error_message(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
     }
     /**
-    * @param {number} arg0
-    */
-    set value(arg0) {
-        wasm.__wbg_set_wasmresultwithpointer_value(this.ptr, arg0);
+     * @param {string | null} [arg0]
+     */
+    set error_message(arg0) {
+        var ptr0 = isLikeNone(arg0) ? 0 : passStringToWasm0(arg0, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.__wbg_set_wasmresult_error_message(this.__wbg_ptr, ptr0, len0);
     }
 }
 
-async function load(module, imports) {
+async function __wbg_load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
         if (typeof WebAssembly.instantiateStreaming === 'function') {
             try {
@@ -940,7 +694,7 @@ async function load(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);
+                    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;
@@ -963,103 +717,102 @@ async function load(module, imports) {
     }
 }
 
-function getImports() {
+function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
-    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
-        const ret = getStringFromWasm0(arg0, arg1);
-        return addHeapObject(ret);
+    imports.wbg.__wbg_call_672a4d21634d4a24 = function() { return handleError(function (arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_debug_3cb59063b29f58c1 = function(arg0) {
+        console.debug(arg0);
     };
-    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
-        takeObject(arg0);
+    imports.wbg.__wbg_error_524f506f44df1645 = function(arg0) {
+        console.error(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.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.error(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+        }
     };
-    imports.wbg.__wbg_debug_f15cb542ea509609 = function(arg0) {
-        console.debug(getObject(arg0));
+    imports.wbg.__wbg_info_3daf2e093e091b66 = function(arg0) {
+        console.info(arg0);
     };
-    imports.wbg.__wbg_error_ef9a0be47931175f = function(arg0) {
-        console.error(getObject(arg0));
+    imports.wbg.__wbg_log_c222819a41e063d3 = function(arg0) {
+        console.log(arg0);
     };
-    imports.wbg.__wbg_info_2874fdd5393f35ce = function(arg0) {
-        console.info(getObject(arg0));
+    imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
+        const ret = new Error();
+        return ret;
     };
-    imports.wbg.__wbg_log_4b5638ad60bdc54a = function(arg0) {
-        console.log(getObject(arg0));
+    imports.wbg.__wbg_newnoargs_105ed471475aaf50 = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return ret;
     };
-    imports.wbg.__wbg_warn_58110c4a199df084 = function(arg0) {
-        console.warn(getObject(arg0));
+    imports.wbg.__wbg_now_2c95c9de01293173 = function(arg0) {
+        const ret = arg0.now();
+        return ret;
     };
-    imports.wbg.__wbg_now_8172cd917e5eda6b = function(arg0) {
-        const ret = getObject(arg0).now();
+    imports.wbg.__wbg_performance_7a3ffd0b17f663ad = function(arg0) {
+        const ret = arg0.performance;
         return ret;
     };
-    imports.wbg.__wbg_newnoargs_b5b063fc6c2f0376 = function(arg0, arg1) {
-        const ret = new Function(getStringFromWasm0(arg0, arg1));
-        return addHeapObject(ret);
+    imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
+        const ret = arg1.stack;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
-    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_97ae9d8645dc388b = function() { return handleError(function (arg0, arg1) {
-        const ret = getObject(arg0).call(getObject(arg1));
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_self_6d479506f72c6a71 = function() { return handleError(function () {
-        const ret = self.self;
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_window_f2557cc78490aceb = function() { return handleError(function () {
-        const ret = window.window;
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_globalThis_7f206bda628d5286 = function() { return handleError(function () {
-        const ret = globalThis.globalThis;
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbg_global_ba75c50d1cf384f4 = function() { return handleError(function () {
-        const ret = global.global;
-        return addHeapObject(ret);
-    }, arguments) };
-    imports.wbg.__wbindgen_is_undefined = function(arg0) {
-        const ret = getObject(arg0) === undefined;
-        return ret;
+    imports.wbg.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function() {
+        const ret = typeof global === 'undefined' ? null : global;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
     };
-    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
-        const ret = getObject(arg0);
-        return addHeapObject(ret);
+    imports.wbg.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 = function() {
+        const ret = typeof globalThis === 'undefined' ? null : globalThis;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
     };
-    imports.wbg.__wbg_new_abda76e883ba8a5f = function() {
-        const ret = new Error();
-        return addHeapObject(ret);
+    imports.wbg.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function() {
+        const ret = typeof self === 'undefined' ? null : self;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
     };
-    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_static_accessor_WINDOW_5de37043a91a9c40 = function() {
+        const ret = typeof window === 'undefined' ? null : window;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
     };
-    imports.wbg.__wbg_error_f851667af71bcfc6 = function(arg0, arg1) {
-        try {
-            console.error(getStringFromWasm0(arg0, arg1));
-        } finally {
-            wasm.__wbindgen_free(arg0, arg1);
-        }
+    imports.wbg.__wbg_warn_4ca3906c248c47c4 = function(arg0) {
+        console.warn(arg0);
     };
-    imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
-        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_init_externref_table = function() {
+        const table = wasm.__wbindgen_export_2;
+        const offset = table.grow(4);
+        table.set(0, undefined);
+        table.set(offset + 0, undefined);
+        table.set(offset + 1, null);
+        table.set(offset + 2, true);
+        table.set(offset + 3, false);
+    };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = arg0 === undefined;
+        return ret;
+    };
+    imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
+        const obj = arg1;
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
+        return ret;
     };
     imports.wbg.__wbindgen_throw = function(arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
@@ -1068,59 +821,62 @@ function getImports() {
     return imports;
 }
 
-function finalizeInit(instance, module) {
+function __wbg_finalize_init(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();
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedBigInt64ArrayMemory0 = null;
+    cachedBigUint64ArrayMemory0 = null;
+    cachedDataViewMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
 
 
+    wasm.__wbindgen_start();
     return wasm;
 }
 
-async function init(input) {
-    if (typeof input === 'undefined') {
-        input = new URL('hakuban_bg.wasm', import.meta.url);
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module_or_path !== 'undefined') {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path);
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead');
+        }
+    }
+
+    if (typeof module_or_path === 'undefined') {
+        module_or_path = new URL('hakuban_bg.wasm', import.meta.url);
     }
-    const imports = getImports();
+    const imports = __wbg_get_imports();
 
-    if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
-        input = fetch(input);
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
     }
 
-    const { instance, module } = await load(await input, imports);
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
 
-    return finalizeInit(instance, module);
+    return __wbg_finalize_init(instance, module);
 }
 
 var unwrap_pointer = function(result) {
-  if (result.status === 0) {
-    return result.value;
-  } else {
-    throw "hakuban wasm call failed: " + result.status;
-  }
-};
-
-var unwrap_pointer_or_null = function(result) {
-  if (result.status === 0) {
-    return result.value;
-  } else if (result.status === 2) { //unavailable
-    return null;
+  if (result.status === 1) {
+    return result.pointer;
   } else {
     throw "hakuban wasm call failed: " + result.status;
   }
 };
 
 var Future = class Future {
-  constructor(local_exchange, future_owner, poll_function, drop_function, _pointer) {
-    this.local_exchange = local_exchange;
+  constructor(exchange, future_owner, poll_function, drop_function, _pointer, debug_description) {
+    this.exchange = exchange;
     this.future_owner = future_owner;
     this.poll_function = poll_function;
     this.drop_function = drop_function;
     this._pointer = _pointer;
+    this.debug_description = debug_description;
   }
 
   async await_and_drop(aborted = null) {
@@ -1130,14 +886,23 @@ var Future = class Future {
         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);
+        notified = this.exchange.notified();
+        if (this.debug_description && log_level() === "trace") {
+          console.debug("polling " + this.debug_description, notified.id);
+        }
+        result = this.exchange.with_pointer((exchange_pointer) => {
+          return this.poll_function(exchange_pointer, this._pointer, notified.id);
         });
+        if (this.debug_description && log_level() === "trace") {
+          console.debug("polled " + this.debug_description, notified.id, result.status);
+        }
+        this.exchange.notify();
         switch (result.status) {
-          case 0: //ok
-            return result.value;
-          case 1: //pending
+          case 0: // ok
+            return true;
+          case 1: // pointer
+            return result.pointer;
+          case 2: // pending
             to_listen = [notified, about_to_drop_notification_received];
             if (aborted != null) {
               to_listen.push(aborted);
@@ -1149,9 +914,10 @@ var Future = class Future {
                 return null;
             }
             break;
-          case 2: //unavailable, channel closed
+          case 3: // end of stream
             return null;
           default:
+            console.error(result.error_message);
             throw result.status; //TODO: convert that to specific error
         }
       }
@@ -1159,24 +925,37 @@ var Future = class Future {
       this.drop_function(this._pointer);
       this.future_owner.drop_release(this.lock_id);
       if (notified != null) {
-        this.local_exchange.return_notified(notified);
+        this.exchange.return_notified(notified);
       }
     }
   }
 
 };
 
+var logger_initialized, logger_log_level;
+
+logger_initialized = false;
+
+logger_log_level = void 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;
+  var result;
+  if (!logger_initialized || !skip_if_already_initialized) {
+    result = hakuban_logger_initialize(log_level);
+    if (result.status === 0) {
+      logger_initialized = true;
+      return logger_log_level = log_level;
+    } else {
+      return console.error("Failed to initialize logger, error " + result.error_message);
+    }
   }
 };
 
-var do_and_drop, finalization_registry;
+var log_level = function() {
+  return logger_log_level;
+};
+
+var do_and_drop, do_and_drop_or_return, finalization_registry;
 
 finalization_registry = new FinalizationRegistry(function(function_and_arg) {
   return function_and_arg[0](function_and_arg[1]);
@@ -1213,7 +992,7 @@ do_and_drop = function(object_or_objects, block) {
   }
 };
 
-var do_and_drop_or_return = function(object_or_objects, block) {
+do_and_drop_or_return = function(object_or_objects, block) {
   if (block != null) {
     return do_and_drop(object_or_objects, block);
   } else {
@@ -1229,8 +1008,8 @@ var PointerAlreadyDropped$1 = class PointerAlreadyDropped {
 };
 
 var FFIObject = class FFIObject {
-  initialize_pointer(_local_exchange, _pointer, _drop_function) {
-    this._local_exchange = _local_exchange;
+  initialize_pointer(_exchange, _pointer, _drop_function) {
+    this._exchange = _exchange;
     this._pointer = _pointer;
     this._drop_function = _drop_function;
     this._was_dropped = null;
@@ -1264,8 +1043,8 @@ var FFIObject = class FFIObject {
           }
           finalization_registry.unregister(this);
           this._drop_function(this._pointer);
-          if (this._local_exchange != null) {
-            this._local_exchange.notify();
+          if (this._exchange != null) {
+            this._exchange.notify();
           }
         }
         this._pointer = false;
@@ -1410,6 +1189,10 @@ var ObjectState = class ObjectState extends FFIObject {
     }
   }
 
+  static from_pointer(_exchange, pointer) {
+    return new ObjectState(null, null, null, null, pointer);
+  }
+
   with_pointer(block) {
     var pointer;
     if (this.dropped()) {
@@ -1453,127 +1236,123 @@ var ObjectState = class ObjectState extends FFIObject {
 
 };
 
-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;
-  }
-
-  async(block) {
-    return new StreamEnumerator(this._stream, this._without_implicit_drop, true).call_or_return(block);
-  }
-
-  without_implicit_drop(block) {
-    return new StreamEnumerator(this._stream, true, this._async).call_or_return(block);
-  }
-
-  call_or_return(block) {
-    if (block != null) {
-      return this.call(block);
-    } else {
-      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));
+var Stream = class Stream {
+  static mixin(new_object, _ffi_next, _item_constructor, debug_description) {
+    var StreamAsyncIterator;
+    // Rust StreamExt-like methods
+    new_object.next = async function(block) {
+      var error, future_pointer, pointer;
+      try {
+        future_pointer = this.with_pointer((pointer) => {
+          return _ffi_next(pointer);
+        });
+        pointer = (await new Future(this.exchange, this, hakuban_future_poll, hakuban_future_drop, future_pointer, debug_description + ".next").await_and_drop());
+        if (pointer != null) {
+          if (_item_constructor != null) {
+            return (await new _item_constructor(this.exchange, pointer).do_and_drop_or_return(block));
           } else {
-            try {
-              return (await block(item));
-            } finally {
-              await item.drop();
-            }
+            return pointer;
           }
-        }));
-      } else {
-        if (this._without_implicit_drop) {
-          results.push((await block(new_item)));
         } else {
+          return null;
+        }
+      } catch (error1) {
+        error = error1;
+        if (error instanceof PointerAlreadyDropped$1) {
+          return null;
+        }
+        throw error;
+      }
+    };
+    new_object.for_each_concurrent = async function(block) {
+      var id, item, ref, sequence, task, tasks;
+      //TODO: simplify when we get rid of coffee
+      task = function(tasks, id, item) {
+        return new Promise(async(_resolve) => {
           try {
-            results.push((await block(new_item)));
+            return (await block(item));
           } finally {
-            await new_item.drop();
+            await item.drop();
+            delete tasks[id];
           }
+        });
+      };
+      tasks = {};
+      sequence = 0;
+      ref = this;
+      for await (item of ref) {
+        id = ++sequence;
+        tasks[id] = task(tasks, id, item);
+      }
+      return (await Promise.all(Object.values(tasks)));
+    };
+    new_object.for_each = async function(block) {
+      var item, ref, results;
+      ref = this;
+      results = [];
+      for await (item of ref) {
+        try {
+          results.push((await block(item)));
+        } finally {
+          await item.drop();
         }
       }
-    }
-    return results;
+      return results;
+    };
+    // JS AsyncIterator methods
+    StreamAsyncIterator = class StreamAsyncIterator {
+      constructor(stream) {
+        this.next = async function() {
+          var item;
+          item = (await stream.next());
+          if (item != null) {
+            return {
+              done: false,
+              value: item
+            };
+          } else {
+            return {
+              done: true
+            };
+          }
+        };
+        this.return = function(value) {
+          stream.drop();
+          return {
+            done: true,
+            value: value
+          };
+        };
+      }
+
+    };
+    return new_object[Symbol.asyncIterator] = function() {
+      return new StreamAsyncIterator(this);
+    };
   }
 
 };
 
 var ObjectStateStream = class ObjectStateStream extends FFIObject {
-  constructor(local_exchange, pointer) {
+  constructor(exchange, pointer) {
     super();
-    this.local_exchange = local_exchange;
-    this.initialize_pointer(this.local_exchange, pointer, hakuban_object_state_stream_drop);
-  }
-
-  descriptor() {
-    return this.with_pointer(function(pointer) {
-      return new ObjectDescriptor(null, null, hakuban_object_state_stream_descriptor(pointer));
-    });
+    Stream.mixin(this, hakuban_object_state_stream_next, (function(_exchange, pointer) {
+      return new ObjectState(null, null, null, null, pointer);
+    }), "ObjectStateStream");
+    this.exchange = exchange;
+    this.initialize_pointer(this.exchange, pointer, hakuban_object_state_stream_drop);
   }
-
-  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;
-    }
-  }
-
-  each(block) {
-    return new StreamEnumerator(this).call_or_return(block);
-  }
-
-  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;
-    }
+
+  descriptor() {
+    return this.with_pointer(function(pointer) {
+      return new ObjectDescriptor(null, null, hakuban_object_state_stream_descriptor(pointer));
+    });
   }
 
 };
 
 var ObjectStateSinkParams = class ObjectStateSinkParams extends FFIObject {
-  constructor(pointer) {
+  constructor(_exchange, pointer) {
     super();
     this.initialize_pointer(null, pointer, hakuban_object_state_sink_params_drop);
   }
@@ -1581,10 +1360,11 @@ var ObjectStateSinkParams = class ObjectStateSinkParams extends FFIObject {
 };
 
 var ObjectStateSink = class ObjectStateSink extends FFIObject {
-  constructor(local_exchange, pointer) {
+  constructor(exchange, pointer) {
     super();
-    this.local_exchange = local_exchange;
-    this.initialize_pointer(this.local_exchange, pointer, hakuban_object_state_sink_drop);
+    Stream.mixin(this, hakuban_object_state_sink_next, ObjectStateSinkParams);
+    this.exchange = exchange;
+    this.initialize_pointer(this.exchange, pointer, hakuban_object_state_sink_drop);
   }
 
   descriptor() {
@@ -1601,74 +1381,11 @@ var ObjectStateSink = class ObjectStateSink extends FFIObject {
           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;
-    }
-  }
-
-  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;
-    }
-  }
-
-  each(block) {
-    return new StreamEnumerator(this).call_or_return(block);
-  }
-
-  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;
-      }
-    } catch (error1) {
-      error = error1;
-      if (error instanceof PointerAlreadyDropped) {
-        return null;
-      }
-      throw error;
-    }
-  }
-
-  desynchronize() {
-    var error;
-    try {
-      this.with_pointer((pointer) => {
-        return hakuban_object_state_sink_desynchronize(pointer);
-      });
-      this.local_exchange.notify();
+      await new Future(this.exchange, this, hakuban_future_poll, hakuban_future_drop, future_pointer).await_and_drop();
       return true;
     } catch (error1) {
       error = error1;
-      if (error instanceof PointerAlreadyDropped) {
+      if (error instanceof PointerAlreadyDropped$1) {
         return null;
       }
       throw error;
@@ -1677,342 +1394,101 @@ var ObjectStateSink = class ObjectStateSink extends FFIObject {
 
 };
 
-var Contract;
-
-Contract = class Contract extends FFIObject {
-  each(block) {
-    return new StreamEnumerator(this).call_or_return(block);
-  }
-
-};
-
-var ObjectObserveContract = class ObjectObserveContract extends Contract {
-  constructor(local_exchange, descriptor) {
+var ObjectObserveContract = class ObjectObserveContract extends FFIObject {
+  constructor(exchange, descriptor) {
     super();
-    this.local_exchange = local_exchange;
+    Stream.mixin(this, hakuban_object_observe_contract_next, ObjectStateStream);
+    this.exchange = exchange;
     this.descriptor = descriptor[0] instanceof ObjectDescriptor ? descriptor[0] : new ObjectDescriptor(...descriptor);
-    this.local_exchange.with_pointer((local_exchange_pointer) => {
+    this.exchange.with_pointer((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);
+        return this.initialize_pointer(this.exchange, hakuban_object_observe_contract_new(exchange_pointer, descriptor_pointer), hakuban_object_observe_contract_drop);
       });
     });
-    this.local_exchange.notify();
-  }
-
-  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;
-    }
-  }
-
-  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;
-    }
-  }
-
-  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;
-      }
-    } catch (error1) {
-      error = error1;
-      if (error instanceof PointerAlreadyDropped$1) {
-        return null;
-      }
-      throw error;
-    }
+    this.exchange.notify();
   }
 
 };
 
-var ObjectExposeContract = class ObjectExposeContract extends Contract {
-  constructor(local_exchange, descriptor) {
+var ObjectExposeContract = class ObjectExposeContract extends FFIObject {
+  constructor(exchange, descriptor, capacity) {
     super();
-    this.local_exchange = local_exchange;
+    Stream.mixin(this, hakuban_object_expose_contract_next, ObjectStateSink);
+    this.exchange = exchange;
     this.descriptor = descriptor[0] instanceof ObjectDescriptor ? descriptor[0] : new ObjectDescriptor(...descriptor);
-    this.local_exchange.with_pointer((local_exchange_pointer) => {
+    this.exchange.with_pointer((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);
+        return this.initialize_pointer(this.exchange, hakuban_object_expose_contract_new(exchange_pointer, descriptor_pointer, capacity), hakuban_object_expose_contract_drop);
       });
     });
-    this.local_exchange.notify();
-  }
-
-  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;
-    }
-  }
-
-  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;
-      }
-    } catch (error1) {
-      error = error1;
-      if (error instanceof PointerAlreadyDropped$1) {
-        return null;
-      }
-      throw error;
-    }
-  }
-
-  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;
-      }
-    } catch (error1) {
-      error = error1;
-      if (error instanceof PointerAlreadyDropped$1) {
-        return null;
-      }
-      throw error;
-    }
+    this.exchange.notify();
   }
 
 };
 
-var TagObserveContract = class TagObserveContract extends Contract {
-  constructor(local_exchange, descriptor) {
+var TagObserveContract = class TagObserveContract extends FFIObject {
+  constructor(exchange, descriptor) {
     super();
-    this.local_exchange = local_exchange;
+    Stream.mixin(this, hakuban_tag_observe_contract_next, ObjectStateStream);
+    this.exchange = exchange;
     this.descriptor = descriptor;
     if (!(this.descriptor instanceof TagDescriptor)) {
       this.descriptor = new TagDescriptor(this.descriptor);
     }
-    this.local_exchange.with_pointer((local_exchange_pointer) => {
+    this.exchange.with_pointer((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);
+        return this.initialize_pointer(this.exchange, hakuban_tag_observe_contract_new(exchange_pointer, descriptor_pointer), hakuban_tag_observe_contract_drop);
       });
     });
-    this.local_exchange.notify();
-  }
-
-  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;
-    }
-  }
-
-  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;
-    }
-  }
-
-  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;
-    }
+    this.exchange.notify();
   }
 
 };
 
-var TagExposeContract = class TagExposeContract extends Contract {
-  constructor(local_exchange, descriptor) {
+var TagExposeContract = class TagExposeContract extends FFIObject {
+  constructor(exchange, descriptor, capacity) {
     super();
-    this.local_exchange = local_exchange;
+    Stream.mixin(this, hakuban_tag_expose_contract_next, ObjectStateSink);
+    this.exchange = exchange;
     this.descriptor = descriptor;
     if (!(this.descriptor instanceof TagDescriptor)) {
       this.descriptor = new TagDescriptor(this.descriptor);
     }
-    this.local_exchange.with_pointer((local_exchange_pointer) => {
+    this.exchange.with_pointer((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);
+        return this.initialize_pointer(this.exchange, hakuban_tag_expose_contract_new(exchange_pointer, descriptor_pointer, capacity), hakuban_tag_expose_contract_drop);
       });
     });
-    this.local_exchange.notify();
-  }
-
-  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;
-    }
-  }
-
-  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;
-      }
-    } catch (error1) {
-      error = error1;
-      if (error instanceof PointerAlreadyDropped$1) {
-        return null;
-      }
-      throw error;
-    }
-  }
-
-  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;
-    }
+    this.exchange.notify();
   }
 
 };
 
-var ObjectContractBuilder, TagContractBuilder;
+var ObjectExposeContractBuilder, ObjectObserveContractBuilder, TagExposeContractBuilder, TagObserveContractBuilder;
 
-var LocalExchange = class LocalExchange extends FFIObject {
+var Exchange = class Exchange 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);
+    this.initialize_pointer(null, unwrap_pointer(hakuban_exchange_new(this.name)), hakuban_exchange_drop);
+  }
+
+  object_observe_contract(descriptor_or_tags, json_or_nothing) {
+    return new ObjectObserveContractBuilder(this, [descriptor_or_tags, json_or_nothing]);
   }
 
-  object(descriptor_or_tags, json_or_nothing) {
-    return new ObjectContractBuilder(this, [descriptor_or_tags, json_or_nothing]);
+  object_expose_contract(descriptor_or_tags, json_or_nothing) {
+    return new ObjectExposeContractBuilder(this, [descriptor_or_tags, json_or_nothing]);
   }
 
-  tag(descriptor) {
-    return new TagContractBuilder(this, descriptor);
+  tag_observe_contract(descriptor) {
+    return new TagObserveContractBuilder(this, descriptor);
+  }
+
+  tag_expose_contract(descriptor) {
+    return new TagExposeContractBuilder(this, descriptor);
   }
 
   notified() {
@@ -2028,7 +1504,7 @@ var LocalExchange = class LocalExchange extends FFIObject {
   notify() {
     var i, id, len, ref, results;
     ref = this.with_pointer(function(pointer) {
-      return hakuban_local_exchange_notified(pointer);
+      return hakuban_exchange_notified(pointer);
     });
     results = [];
     for (i = 0, len = ref.length; i < len; i++) {
@@ -2050,73 +1526,81 @@ var LocalExchange = class LocalExchange extends FFIObject {
 
 };
 
-ObjectContractBuilder = class ObjectContractBuilder {
-  constructor(local_exchange, descriptor1) {
-    this.local_exchange = local_exchange;
+ObjectObserveContractBuilder = class ObjectObserveContractBuilder {
+  constructor(exchange, descriptor1) {
+    this.exchange = exchange;
+    this.descriptor = descriptor1;
+  }
+
+  build(block) {
+    return new ObjectObserveContract(this.exchange, this.descriptor).do_and_drop_or_return(block);
+  }
+
+};
+
+ObjectExposeContractBuilder = class ObjectExposeContractBuilder {
+  constructor(exchange, descriptor1) {
+    this.exchange = exchange;
     this.descriptor = descriptor1;
+    this.capacity = 1;
+  }
+
+  with_capacity(capacity) {
+    return this.capacity = capacity;
+  }
+
+  build(block) {
+    return new ObjectExposeContract(this.exchange, this.descriptor, this.capacity).do_and_drop_or_return(block);
   }
 
-  observe(block) {
-    return new ObjectObserveContract(this.local_exchange, this.descriptor).do_and_drop_or_return(block);
+};
+
+TagObserveContractBuilder = class TagObserveContractBuilder {
+  constructor(exchange, descriptor1) {
+    this.exchange = exchange;
+    this.descriptor = descriptor1;
   }
 
-  expose(block) {
-    return new ObjectExposeContract(this.local_exchange, this.descriptor).do_and_drop_or_return(block);
+  build(block) {
+    return new TagObserveContract(this.exchange, this.descriptor).do_and_drop_or_return(block);
   }
 
 };
 
-TagContractBuilder = class TagContractBuilder {
-  constructor(local_exchange, descriptor1) {
-    this.local_exchange = local_exchange;
+TagExposeContractBuilder = class TagExposeContractBuilder {
+  constructor(exchange, descriptor1) {
+    this.exchange = exchange;
     this.descriptor = descriptor1;
+    this.capacity = 1;
   }
 
-  observe(block) {
-    return new TagObserveContract(this.local_exchange, this.descriptor).do_and_drop_or_return(block);
+  with_capacity(capacity) {
+    return this.capacity = capacity;
   }
 
-  expose(block) {
-    return new TagExposeContract(this.local_exchange, this.descriptor).do_and_drop_or_return(block);
+  build(block) {
+    return new TagExposeContract(this.exchange, this.descriptor, this.capacity).do_and_drop_or_return(block);
   }
 
 };
 
-var RemoteExchange = class RemoteExchange extends FFIObject {
-  constructor(local_exchange, upstream, diff_produce, diff_request) {
+var UpstreamConnection = class UpstreamConnection extends FFIObject {
+  constructor(exchange, local_name, local_address) {
     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);
+    Stream.mixin(this, hakuban_upstream_connection_next_message_to_network, void 0, "UpstreamConnection");
+    this.exchange = exchange;
+    this.exchange.with_pointer((exchange_pointer) => {
+      return this.initialize_pointer(this.exchange, hakuban_upstream_connection_new(exchange_pointer, local_name, local_address), hakuban_upstream_connection_drop);
     });
   }
 
-  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;
-    }
-  }
-
   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));
+        return hakuban_upstream_connection_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();
+      return (await new Future(this.exchange, this, hakuban_future_poll, hakuban_future_drop, future_pointer, "UpstreamConnection.send").await_and_drop());
     } catch (error1) {
       error = error1;
       if (error instanceof PointerAlreadyDropped$1) {
@@ -2129,14 +1613,15 @@ var RemoteExchange = class RemoteExchange extends FFIObject {
 };
 
 //TODO: hide private methods
+//TODO: implement timeout
+//TODO: make timeout and keep-alive interval configurable
 var WebsocketConnector = class WebsocketConnector {
-  constructor(local_exchange, uri, options = {}) {
+  constructor(exchange, uri) {
     this.connect = this.connect.bind(this);
     this.ping = this.ping.bind(this);
     this.send = this.send.bind(this);
-    this.local_exchange = local_exchange;
+    this.exchange = exchange;
     this.uri = uri;
-    this.options = options;
     this._status_change({
       connected: false
     });
@@ -2146,6 +1631,7 @@ var WebsocketConnector = class WebsocketConnector {
     this.connect();
   }
 
+  //TOOD: make this iterable
   status() {
     return Promise.resolve([this.status, this.next_status_promise]);
   }
@@ -2179,7 +1665,7 @@ var WebsocketConnector = class WebsocketConnector {
       this.socket = new WebSocket(this.uri);
     } catch (error1) {
       error = error1;
-      console.error('Error connecting to hakuban remote exchange:', error);
+      console.error('Error connecting to remote exchange:', error);
       this._status_change({
         connected: false,
         error: error
@@ -2187,16 +1673,15 @@ var WebsocketConnector = class WebsocketConnector {
       return false;
     }
     this.socket.binaryType = "arraybuffer";
-    this.socket.onopen = () => {
-      if (this.options.debug) {
-        console.debug('Connected to hakuban remote exchange');
-      }
-      this.remote_exchange = new RemoteExchange(this.local_exchange, true, true, true);
+    this.socket.onopen = (event) => {
+      console.debug('Connected to remote exchange');
+      this.upstream_connection = new UpstreamConnection(this.exchange, "js-client", "unknown");
       this.forwarding_to_network_stopped = new Promise(async(resolve) => {
-        var message_pointer;
+        var message_pointer, ref;
         try {
-          while ((this.remote_exchange != null) && ((message_pointer = (await this.remote_exchange.next())) != null)) {
-            this.send(hakuban_message_take(message_pointer));
+          ref = this.upstream_connection;
+          for await (message_pointer of ref) {
+            this.send(hakuban_message_serialize(message_pointer));
           }
         } catch (error1) {
           error = error1;
@@ -2213,12 +1698,8 @@ var WebsocketConnector = class WebsocketConnector {
     };
     // 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.options.debug && (this.remote_exchange == null)) {
-        console.debug('Failed to connect to hakuban remote exchange');
-      }
+      console.debug('Disconnected from remote exchange');
+      console.debug('Failed to connect to remote exchange');
       this._status_change({
         connected: false,
         disconnect_reason: event.reason,
@@ -2233,22 +1714,25 @@ var WebsocketConnector = class WebsocketConnector {
         clearTimeout(this.reconnection_timer);
         this.reconnection_timer = null;
       }
-      if (this.remote_exchange != null) {
-        await this.remote_exchange.drop();
+      if (this.upstream_connection != null) {
+        await this.upstream_connection.drop();
         await this.forwarding_to_network_stopped;
         this.forwarding_to_network_stopped = null;
-        this.remote_exchange = null;
+        this.upstream_connection = null;
       }
       if (this.reconnect_on_close) {
         return this.reconnection_timer = setTimeout(this.connect, 1000);
       }
     };
     return this.socket.onmessage = async(event) => {
-      if (this.remote_exchange == null) {
+      if ((event.data.byteLength === 0) || (event.data.length === 0) || (typeof event.data === 'string') || (event.data instanceof String)) {
+        return;
+      }
+      if (this.upstream_connection == null) {
         return;
       }
       try {
-        return (await this.remote_exchange.send(event.data));
+        return (await this.upstream_connection.send(event.data));
       } catch (error1) {
         error = error1;
         console.error('Error processing hakuban connection:', error);
@@ -2260,29 +1744,27 @@ var WebsocketConnector = class WebsocketConnector {
   }
 
   ping() {
-    if (this.socket) {
-      return this.socket.send(new Uint8Array());
+    if (this.socket != null) {
+      return this.socket.send(".");
     }
   }
 
   send(bytes_to_send) {
-    if (bytes_to_send.length > 0) {
-      this.socket.send(bytes_to_send);
-      if (this.keep_alive_interval) {
-        clearInterval(this.keep_alive_interval);
-      }
-      return this.keep_alive_interval = setInterval(this.ping, 10000);
+    this.socket.send(bytes_to_send);
+    if (this.keep_alive_interval) {
+      clearInterval(this.keep_alive_interval);
     }
+    return this.keep_alive_interval = setInterval(this.ping, 10000);
   }
 
 };
 
 var initialize = async function(wasm, log_level) {
   var result;
-  result = (await init(wasm));
+  result = (await __wbg_init(wasm));
   logger_initialize(log_level);
   return result;
 };
 
-export { LocalExchange, ObjectDescriptor, ObjectExposeContract, ObjectObserveContract, ObjectState, TagDescriptor, TagExposeContract, TagObserveContract, WebsocketConnector, initialize };
+export { Exchange, ObjectDescriptor, ObjectExposeContract, ObjectObserveContract, ObjectState, TagDescriptor, TagExposeContract, TagObserveContract, WebsocketConnector, initialize };
 //# sourceMappingURL=hakuban.js.map