screeps-clockwork 0.4.0 → 0.5.0

package/dist/index.js

@@ -24,6 +24,16 @@ function requireEncoderDecoderTogether_min () {
 
 requireEncoderDecoderTogether_min();
 
+function clockworkcostmatrix_get_pointer(value) {
+        if (!value || 
+            typeof value !== 'object' || 
+            !('__wbg_ptr' in value) ||
+            value.constructor.name !== 'ClockworkCostMatrix') {
+            return 0;
+        }
+        return value.__wbg_ptr;
+    }
+
 let wasm;
 
 const heap = new Array(128).fill(undefined);
@@ -34,6 +44,23 @@ function getObject(idx) { return heap[idx]; }
 
 let heap_next = heap.length;
 
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_exn_store(addHeapObject(e));
+    }
+}
+
 function dropObject(idx) {
     if (idx < 132) return;
     heap[idx] = heap_next;
@@ -46,28 +73,6 @@ function takeObject(idx) {
     return ret;
 }
 
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
-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 addHeapObject(obj) {
-    if (heap_next === heap.length) heap.push(heap.length + 1);
-    const idx = heap_next;
-    heap_next = heap[idx];
-
-    heap[idx] = obj;
-    return idx;
-}
-
 const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
 
 if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); }
@@ -85,6 +90,75 @@ function getStringFromWasm0(ptr, len) {
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
 let cachedUint32ArrayMemory0 = null;
 
 function getUint32ArrayMemory0() {
@@ -94,38 +168,69 @@ function getUint32ArrayMemory0() {
     return cachedUint32ArrayMemory0;
 }
 
-function getArrayU32FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+let stack_pointer = 128;
+
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
+}
+/**
+ * WASM wrapper for the BFS multiroom flow field function.
+ * @param {Uint32Array} start_packed
+ * @param {Function} get_cost_matrix
+ * @param {number} max_tiles
+ * @param {number} max_rooms
+ * @param {number} max_room_distance
+ * @param {number} max_tile_distance
+ * @returns {MultiroomFlowField}
+ */
+function js_bfs_multiroom_flow_field(start_packed, get_cost_matrix, max_tiles, max_rooms, max_room_distance, max_tile_distance) {
+    try {
+        const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.js_bfs_multiroom_flow_field(ptr0, len0, addBorrowedObject(get_cost_matrix), max_tiles, max_rooms, max_room_distance, max_tile_distance);
+        return MultiroomFlowField.__wrap(ret);
+    } finally {
+        heap[stack_pointer++] = undefined;
+    }
 }
 
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {
         throw new Error(`expected instance of ${klass.name}`);
     }
-    return instance.ptr;
-}
-
-let WASM_VECTOR_LEN = 0;
-
-function passArray32ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 4, 4) >>> 0;
-    getUint32ArrayMemory0().set(arg, ptr / 4);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
 }
 /**
- * WASM wrapper for the Dijkstra flow field function.
+ * WASM wrapper for the Dijkstra distance map function.
  * @param {Uint32Array} start_packed
  * @param {ClockworkCostMatrix} cost_matrix
- * @returns {FlowField}
+ * @returns {DistanceMap}
  */
-function js_dijkstra_flow_field(start_packed, cost_matrix) {
+function js_dijkstra_distance_map(start_packed, cost_matrix) {
     const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     _assertClass(cost_matrix, ClockworkCostMatrix);
-    const ret = wasm.js_dijkstra_flow_field(ptr0, len0, cost_matrix.__wbg_ptr);
-    return FlowField.__wrap(ret);
+    const ret = wasm.js_dijkstra_distance_map(ptr0, len0, cost_matrix.__wbg_ptr);
+    return DistanceMap.__wrap(ret);
+}
+
+/**
+ * @param {number} start
+ * @param {FlowField} flow_field
+ * @returns {Path}
+ */
+function js_path_to_flow_field_origin(start, flow_field) {
+    _assertClass(flow_field, FlowField);
+    const ret = wasm.js_path_to_flow_field_origin(start, flow_field.__wbg_ptr);
+    return Path$1.__wrap(ret);
 }
 
 function getArrayJsValueFromWasm0(ptr, len) {
@@ -148,98 +253,123 @@ function passArrayJsValueToWasm0(array, malloc) {
     return ptr;
 }
 /**
- * @param {number} start
- * @param {MonoFlowField} flow_field
- * @returns {Path}
- */
-function js_path_to_mono_flow_field_origin(start, flow_field) {
-    _assertClass(flow_field, MonoFlowField);
-    const ret = wasm.js_path_to_mono_flow_field_origin(start, flow_field.__wbg_ptr);
-    return Path$1.__wrap(ret);
-}
-
-/**
- * WASM wrapper for the Dijkstra distance map function.
+ * WASM wrapper for the BFS distance map function.
  * @param {Uint32Array} start_packed
  * @param {ClockworkCostMatrix} cost_matrix
  * @returns {DistanceMap}
  */
-function js_dijkstra_distance_map(start_packed, cost_matrix) {
+function js_bfs_distance_map(start_packed, cost_matrix) {
     const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     _assertClass(cost_matrix, ClockworkCostMatrix);
-    const ret = wasm.js_dijkstra_distance_map(ptr0, len0, cost_matrix.__wbg_ptr);
+    const ret = wasm.js_bfs_distance_map(ptr0, len0, cost_matrix.__wbg_ptr);
     return DistanceMap.__wrap(ret);
 }
 
 /**
- * WASM wrapper for the BFS mono flow field function.
  * @param {Uint32Array} start_packed
- * @param {ClockworkCostMatrix} cost_matrix
- * @returns {MonoFlowField}
- */
-function js_bfs_mono_flow_field(start_packed, cost_matrix) {
-    const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    _assertClass(cost_matrix, ClockworkCostMatrix);
-    const ret = wasm.js_bfs_mono_flow_field(ptr0, len0, cost_matrix.__wbg_ptr);
-    return MonoFlowField.__wrap(ret);
-}
-
-/**
- * @param {number} start
- * @param {DistanceMap} distance_map
- * @returns {Path}
+ * @param {Function} get_cost_matrix
+ * @param {number} max_tiles
+ * @param {number} max_rooms
+ * @param {number} max_room_distance
+ * @param {number} max_tile_distance
+ * @returns {MultiroomDistanceMap}
  */
-function js_path_to_distance_map_origin(start, distance_map) {
-    _assertClass(distance_map, DistanceMap);
-    const ret = wasm.js_path_to_distance_map_origin(start, distance_map.__wbg_ptr);
-    return Path$1.__wrap(ret);
+function js_dijkstra_multiroom_distance_map(start_packed, get_cost_matrix, max_tiles, max_rooms, max_room_distance, max_tile_distance) {
+    try {
+        const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.js_dijkstra_multiroom_distance_map(ptr0, len0, addBorrowedObject(get_cost_matrix), max_tiles, max_rooms, max_room_distance, max_tile_distance);
+        return MultiroomDistanceMap.__wrap(ret);
+    } finally {
+        heap[stack_pointer++] = undefined;
+    }
 }
 
 /**
- * @returns {string}
+ * @param {Uint32Array} start_packed
+ * @param {Function} get_cost_matrix
+ * @param {number} max_tiles
+ * @param {number} max_rooms
+ * @param {number} max_room_distance
+ * @param {number} max_tile_distance
+ * @returns {MultiroomFlowField}
  */
-function version() {
-    let deferred1_0;
-    let deferred1_1;
+function js_dijkstra_multiroom_flow_field(start_packed, get_cost_matrix, max_tiles, max_rooms, max_room_distance, max_tile_distance) {
     try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.version(retptr);
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        deferred1_0 = r0;
-        deferred1_1 = r1;
-        return getStringFromWasm0(r0, r1);
+        const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.js_dijkstra_multiroom_flow_field(ptr0, len0, addBorrowedObject(get_cost_matrix), max_tiles, max_rooms, max_room_distance, max_tile_distance);
+        return MultiroomFlowField.__wrap(ret);
     } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        heap[stack_pointer++] = undefined;
     }
 }
 
 /**
- * Exports the global range calculation between two positions.
- * @param {number} packed_pos_1
- * @param {number} packed_pos_2
- * @returns {number}
+ * WASM wrapper for the BFS multiroom distance map function.
+ * @param {Uint32Array} start_packed
+ * @param {Function} get_cost_matrix
+ * @param {number} max_tiles
+ * @param {number} max_rooms
+ * @param {number} max_room_distance
+ * @param {number} max_tile_distance
+ * @returns {MultiroomDistanceMap}
  */
-function get_range(packed_pos_1, packed_pos_2) {
-    const ret = wasm.get_range(packed_pos_1, packed_pos_2);
-    return ret >>> 0;
+function js_bfs_multiroom_distance_map(start_packed, get_cost_matrix, max_tiles, max_rooms, max_room_distance, max_tile_distance) {
+    try {
+        const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.js_bfs_multiroom_distance_map(ptr0, len0, addBorrowedObject(get_cost_matrix), max_tiles, max_rooms, max_room_distance, max_tile_distance);
+        return MultiroomDistanceMap.__wrap(ret);
+    } finally {
+        heap[stack_pointer++] = undefined;
+    }
 }
 
 /**
- * WASM wrapper for the BFS distance map function.
+ * WASM wrapper for the Dijkstra flow field function.
  * @param {Uint32Array} start_packed
  * @param {ClockworkCostMatrix} cost_matrix
- * @returns {DistanceMap}
+ * @returns {FlowField}
  */
-function js_bfs_distance_map(start_packed, cost_matrix) {
+function js_dijkstra_flow_field(start_packed, cost_matrix) {
     const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     _assertClass(cost_matrix, ClockworkCostMatrix);
-    const ret = wasm.js_bfs_distance_map(ptr0, len0, cost_matrix.__wbg_ptr);
-    return DistanceMap.__wrap(ret);
+    const ret = wasm.js_dijkstra_flow_field(ptr0, len0, cost_matrix.__wbg_ptr);
+    return FlowField.__wrap(ret);
+}
+
+/**
+ * @param {Uint32Array} start_packed
+ * @param {Function} get_cost_matrix
+ * @param {number} max_tiles
+ * @param {number} max_rooms
+ * @param {number} max_room_distance
+ * @param {number} max_tile_distance
+ * @returns {MultiroomMonoFlowField}
+ */
+function js_dijkstra_multiroom_mono_flow_field(start_packed, get_cost_matrix, max_tiles, max_rooms, max_room_distance, max_tile_distance) {
+    try {
+        const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.js_dijkstra_multiroom_mono_flow_field(ptr0, len0, addBorrowedObject(get_cost_matrix), max_tiles, max_rooms, max_room_distance, max_tile_distance);
+        return MultiroomMonoFlowField.__wrap(ret);
+    } finally {
+        heap[stack_pointer++] = undefined;
+    }
+}
+
+/**
+ * @param {number} start
+ * @param {MultiroomDistanceMap} distance_map
+ * @returns {Path}
+ */
+function js_path_to_multiroom_distance_map_origin(start, distance_map) {
+    _assertClass(distance_map, MultiroomDistanceMap);
+    const ret = wasm.js_path_to_multiroom_distance_map_origin(start, distance_map.__wbg_ptr);
+    return Path$1.__wrap(ret);
 }
 
 /**
@@ -257,51 +387,186 @@ function js_bfs_flow_field(start_packed, cost_matrix) {
 }
 
 /**
- * WASM wrapper for the Dijkstra mono flow field function.
- * @param {Uint32Array} start_packed
- * @param {ClockworkCostMatrix} cost_matrix
- * @returns {MonoFlowField}
+ * @param {number} start
+ * @param {MonoFlowField} flow_field
+ * @returns {Path}
  */
-function js_dijkstra_mono_flow_field(start_packed, cost_matrix) {
-    const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
-    const len0 = WASM_VECTOR_LEN;
-    _assertClass(cost_matrix, ClockworkCostMatrix);
-    const ret = wasm.js_dijkstra_mono_flow_field(ptr0, len0, cost_matrix.__wbg_ptr);
-    return MonoFlowField.__wrap(ret);
+function js_path_to_mono_flow_field_origin(start, flow_field) {
+    _assertClass(flow_field, MonoFlowField);
+    const ret = wasm.js_path_to_mono_flow_field_origin(start, flow_field.__wbg_ptr);
+    return Path$1.__wrap(ret);
 }
 
 /**
  * @param {number} start
- * @param {FlowField} flow_field
+ * @param {MultiroomMonoFlowField} flow_field
  * @returns {Path}
  */
-function js_path_to_flow_field_origin(start, flow_field) {
-    _assertClass(flow_field, FlowField);
-    const ret = wasm.js_path_to_flow_field_origin(start, flow_field.__wbg_ptr);
+function js_path_to_multiroom_mono_flow_field_origin(start, flow_field) {
+    _assertClass(flow_field, MultiroomMonoFlowField);
+    const ret = wasm.js_path_to_multiroom_mono_flow_field_origin(start, flow_field.__wbg_ptr);
     return Path$1.__wrap(ret);
 }
 
-function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        wasm.__wbindgen_exn_store(addHeapObject(e));
+let cachedUint16ArrayMemory0 = null;
+
+function getUint16ArrayMemory0() {
+    if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
+        cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
     }
+    return cachedUint16ArrayMemory0;
 }
 
-function notDefined(what) { return () => { throw new Error(`${what} is not defined`); }; }
-/**
- * Translates `COLOR_*` and `COLORS_ALL` constants.
- */
-Object.freeze({ Red:1,"1":"Red",Purple:2,"2":"Purple",Blue:3,"3":"Blue",Cyan:4,"4":"Cyan",Green:5,"5":"Green",Yellow:6,"6":"Yellow",Orange:7,"7":"Orange",Brown:8,"8":"Brown",Grey:9,"9":"Grey",White:10,"10":"White", });
+function getArrayU16FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
+}
 /**
- * Translates the `DENSITY_*` constants.
+ * WASM wrapper for the BFS multiroom monodirectional flow field function.
+ * @param {Uint32Array} start_packed
+ * @param {Function} get_cost_matrix
+ * @param {number} max_tiles
+ * @param {number} max_rooms
+ * @param {number} max_room_distance
+ * @param {number} max_tile_distance
+ * @returns {MultiroomMonoFlowField}
  */
-Object.freeze({ Low:1,"1":"Low",Moderate:2,"2":"Moderate",High:3,"3":"High",Ultra:4,"4":"Ultra", });
-/**
- * Translates direction constants.
+function js_bfs_multiroom_mono_flow_field(start_packed, get_cost_matrix, max_tiles, max_rooms, max_room_distance, max_tile_distance) {
+    try {
+        const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.js_bfs_multiroom_mono_flow_field(ptr0, len0, addBorrowedObject(get_cost_matrix), max_tiles, max_rooms, max_room_distance, max_tile_distance);
+        return MultiroomMonoFlowField.__wrap(ret);
+    } finally {
+        heap[stack_pointer++] = undefined;
+    }
+}
+
+/**
+ * WASM wrapper for the BFS mono flow field function.
+ * @param {Uint32Array} start_packed
+ * @param {ClockworkCostMatrix} cost_matrix
+ * @returns {MonoFlowField}
+ */
+function js_bfs_mono_flow_field(start_packed, cost_matrix) {
+    const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    _assertClass(cost_matrix, ClockworkCostMatrix);
+    const ret = wasm.js_bfs_mono_flow_field(ptr0, len0, cost_matrix.__wbg_ptr);
+    return MonoFlowField.__wrap(ret);
+}
+
+/**
+ * @param {number} start
+ * @param {DistanceMap} distance_map
+ * @returns {Path}
+ */
+function js_path_to_distance_map_origin(start, distance_map) {
+    _assertClass(distance_map, DistanceMap);
+    const ret = wasm.js_path_to_distance_map_origin(start, distance_map.__wbg_ptr);
+    return Path$1.__wrap(ret);
+}
+
+/**
+ * @param {number} start
+ * @param {MultiroomFlowField} flow_field
+ * @returns {Path}
+ */
+function js_path_to_multiroom_flow_field_origin(start, flow_field) {
+    _assertClass(flow_field, MultiroomFlowField);
+    const ret = wasm.js_path_to_multiroom_flow_field_origin(start, flow_field.__wbg_ptr);
+    return Path$1.__wrap(ret);
+}
+
+/**
+ * WASM wrapper for the Dijkstra mono flow field function.
+ * @param {Uint32Array} start_packed
+ * @param {ClockworkCostMatrix} cost_matrix
+ * @returns {MonoFlowField}
+ */
+function js_dijkstra_mono_flow_field(start_packed, cost_matrix) {
+    const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    _assertClass(cost_matrix, ClockworkCostMatrix);
+    const ret = wasm.js_dijkstra_mono_flow_field(ptr0, len0, cost_matrix.__wbg_ptr);
+    return MonoFlowField.__wrap(ret);
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+/**
+ * @returns {string}
+ */
+function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.version(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred1_0 = r0;
+        deferred1_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * Exports the global range calculation between two positions.
+ * @param {number} packed_pos_1
+ * @param {number} packed_pos_2
+ * @returns {number}
+ */
+function get_range(packed_pos_1, packed_pos_2) {
+    const ret = wasm.get_range(packed_pos_1, packed_pos_2);
+    return ret >>> 0;
+}
+
+/**
+ * Translates `COLOR_*` and `COLORS_ALL` constants.
+ * @enum {1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10}
+ */
+Object.freeze({
+    Red: 1, "1": "Red",
+    Purple: 2, "2": "Purple",
+    Blue: 3, "3": "Blue",
+    Cyan: 4, "4": "Cyan",
+    Green: 5, "5": "Green",
+    Yellow: 6, "6": "Yellow",
+    Orange: 7, "7": "Orange",
+    Brown: 8, "8": "Brown",
+    Grey: 9, "9": "Grey",
+    White: 10, "10": "White",
+});
+/**
+ * Translates the `DENSITY_*` constants.
+ * @enum {1 | 2 | 3 | 4}
+ */
+Object.freeze({
+    Low: 1, "1": "Low",
+    Moderate: 2, "2": "Moderate",
+    High: 3, "3": "High",
+    Ultra: 4, "4": "Ultra",
+});
+/**
+ * Translates direction constants.
+ * @enum {1 | 2 | 3 | 4 | 5 | 6 | 7 | 8}
  */
-Object.freeze({ Top:1,"1":"Top",TopRight:2,"2":"TopRight",Right:3,"3":"Right",BottomRight:4,"4":"BottomRight",Bottom:5,"5":"Bottom",BottomLeft:6,"6":"BottomLeft",Left:7,"7":"Left",TopLeft:8,"8":"TopLeft", });
+Object.freeze({
+    Top: 1, "1": "Top",
+    TopRight: 2, "2": "TopRight",
+    Right: 3, "3": "Right",
+    BottomRight: 4, "4": "BottomRight",
+    Bottom: 5, "5": "Bottom",
+    BottomLeft: 6, "6": "BottomLeft",
+    Left: 7, "7": "Left",
+    TopLeft: 8, "8": "TopLeft",
+});
 /**
  * Type used for when the game returns a direction to an exit.
  *
@@ -313,8 +578,14 @@ Object.freeze({ Top:1,"1":"Top",TopRight:2,"2":"TopRight",Right:3,"3":"Right",Bo
  *
  * [`Room::find`]: crate::objects::Room::find
  * [`Room::find_exit_to`]: crate::objects::Room::find_exit_to
+ * @enum {1 | 3 | 5 | 7}
  */
-Object.freeze({ Top:1,"1":"Top",Right:3,"3":"Right",Bottom:5,"5":"Bottom",Left:7,"7":"Left", });
+Object.freeze({
+    Top: 1, "1": "Top",
+    Right: 3, "3": "Right",
+    Bottom: 5, "5": "Bottom",
+    Left: 7, "7": "Left",
+});
 /**
  * Translates `FIND_*` constants for interal API calls
  *
@@ -324,25 +595,88 @@ Object.freeze({ Top:1,"1":"Top",Right:3,"3":"Right",Bottom:5,"5":"Bottom",Left:7
  *
  * This is hidden from the documentation to avoid confusion due to its narrow
  * use case, but wasm_bindgen requires it remain public.
+ * @enum {1 | 3 | 5 | 7 | 10 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 10011 | 10012 | 10021 | 10022 | 10051}
  */
 Object.freeze({
-/**
- * Find all exit positions at the top of the room
- */
-ExitTop:1,"1":"ExitTop",ExitRight:3,"3":"ExitRight",ExitBottom:5,"5":"ExitBottom",ExitLeft:7,"7":"ExitLeft",Exit:10,"10":"Exit",Creeps:101,"101":"Creeps",MyCreeps:102,"102":"MyCreeps",HostileCreeps:103,"103":"HostileCreeps",SourcesActive:104,"104":"SourcesActive",Sources:105,"105":"Sources",DroppedResources:106,"106":"DroppedResources",Structures:107,"107":"Structures",MyStructures:108,"108":"MyStructures",HostileStructures:109,"109":"HostileStructures",Flags:110,"110":"Flags",ConstructionSites:111,"111":"ConstructionSites",MySpawns:112,"112":"MySpawns",HostileSpawns:113,"113":"HostileSpawns",MyConstructionSites:114,"114":"MyConstructionSites",HostileConstructionSites:115,"115":"HostileConstructionSites",Minerals:116,"116":"Minerals",Nukes:117,"117":"Nukes",Tombstones:118,"118":"Tombstones",PowerCreeps:119,"119":"PowerCreeps",MyPowerCreeps:120,"120":"MyPowerCreeps",HostilePowerCreeps:121,"121":"HostilePowerCreeps",Deposits:122,"122":"Deposits",Ruins:123,"123":"Ruins",ScoreContainers:10011,"10011":"ScoreContainers",ScoreCollectors:10012,"10012":"ScoreCollectors",SymbolContainers:10021,"10021":"SymbolContainers",SymbolDecoders:10022,"10022":"SymbolDecoders",Reactors:10051,"10051":"Reactors", });
+    /**
+     * Find all exit positions at the top of the room
+     */
+    ExitTop: 1, "1": "ExitTop",
+    ExitRight: 3, "3": "ExitRight",
+    ExitBottom: 5, "5": "ExitBottom",
+    ExitLeft: 7, "7": "ExitLeft",
+    Exit: 10, "10": "Exit",
+    Creeps: 101, "101": "Creeps",
+    MyCreeps: 102, "102": "MyCreeps",
+    HostileCreeps: 103, "103": "HostileCreeps",
+    SourcesActive: 104, "104": "SourcesActive",
+    Sources: 105, "105": "Sources",
+    DroppedResources: 106, "106": "DroppedResources",
+    Structures: 107, "107": "Structures",
+    MyStructures: 108, "108": "MyStructures",
+    HostileStructures: 109, "109": "HostileStructures",
+    Flags: 110, "110": "Flags",
+    ConstructionSites: 111, "111": "ConstructionSites",
+    MySpawns: 112, "112": "MySpawns",
+    HostileSpawns: 113, "113": "HostileSpawns",
+    MyConstructionSites: 114, "114": "MyConstructionSites",
+    HostileConstructionSites: 115, "115": "HostileConstructionSites",
+    Minerals: 116, "116": "Minerals",
+    Nukes: 117, "117": "Nukes",
+    Tombstones: 118, "118": "Tombstones",
+    PowerCreeps: 119, "119": "PowerCreeps",
+    MyPowerCreeps: 120, "120": "MyPowerCreeps",
+    HostilePowerCreeps: 121, "121": "HostilePowerCreeps",
+    Deposits: 122, "122": "Deposits",
+    Ruins: 123, "123": "Ruins",
+    ScoreContainers: 10011, "10011": "ScoreContainers",
+    ScoreCollectors: 10012, "10012": "ScoreCollectors",
+    SymbolContainers: 10021, "10021": "SymbolContainers",
+    SymbolDecoders: 10022, "10022": "SymbolDecoders",
+    Reactors: 10051, "10051": "Reactors",
+});
 /**
  * Translates the `EFFECT_*` constants, which are natural effect types
+ * @enum {1001 | 1002}
  */
-Object.freeze({ Invulnerability:1001,"1001":"Invulnerability",CollapseTimer:1002,"1002":"CollapseTimer", });
+Object.freeze({
+    Invulnerability: 1001, "1001": "Invulnerability",
+    CollapseTimer: 1002, "1002": "CollapseTimer",
+});
 /**
  * Translates the `PWR_*` constants, which are types of powers used by power
  * creeps
+ * @enum {1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19}
  */
-Object.freeze({ GenerateOps:1,"1":"GenerateOps",OperateSpawn:2,"2":"OperateSpawn",OperateTower:3,"3":"OperateTower",OperateStorage:4,"4":"OperateStorage",OperateLab:5,"5":"OperateLab",OperateExtension:6,"6":"OperateExtension",OperateObserver:7,"7":"OperateObserver",OperateTerminal:8,"8":"OperateTerminal",DisruptSpawn:9,"9":"DisruptSpawn",DisruptTower:10,"10":"DisruptTower",Shield:12,"12":"Shield",RegenSource:13,"13":"RegenSource",RegenMineral:14,"14":"RegenMineral",DisruptTerminal:15,"15":"DisruptTerminal",OperatePower:16,"16":"OperatePower",Fortify:17,"17":"Fortify",OperateController:18,"18":"OperateController",OperateFactory:19,"19":"OperateFactory", });
+Object.freeze({
+    GenerateOps: 1, "1": "GenerateOps",
+    OperateSpawn: 2, "2": "OperateSpawn",
+    OperateTower: 3, "3": "OperateTower",
+    OperateStorage: 4, "4": "OperateStorage",
+    OperateLab: 5, "5": "OperateLab",
+    OperateExtension: 6, "6": "OperateExtension",
+    OperateObserver: 7, "7": "OperateObserver",
+    OperateTerminal: 8, "8": "OperateTerminal",
+    DisruptSpawn: 9, "9": "DisruptSpawn",
+    DisruptTower: 10, "10": "DisruptTower",
+    Shield: 12, "12": "Shield",
+    RegenSource: 13, "13": "RegenSource",
+    RegenMineral: 14, "14": "RegenMineral",
+    DisruptTerminal: 15, "15": "DisruptTerminal",
+    OperatePower: 16, "16": "OperatePower",
+    Fortify: 17, "17": "Fortify",
+    OperateController: 18, "18": "OperateController",
+    OperateFactory: 19, "19": "OperateFactory",
+});
 /**
  * Translates `TERRAIN_*` constants.
+ * @enum {0 | 1 | 2}
  */
-Object.freeze({ Plain:0,"0":"Plain",Wall:1,"1":"Wall",Swamp:2,"2":"Swamp", });
+Object.freeze({
+    Plain: 0, "0": "Plain",
+    Wall: 1, "1": "Wall",
+    Swamp: 2, "2": "Swamp",
+});
 
 const __wbindgen_enum_Look = ["creep", "energy", "resource", "source", "mineral", "structure", "flag", "constructionSite", "nuke", "terrain", "tombstone", "powerCreep", "deposit", "ruin", "scoreContainer", "scoreCollector", "symbolContainer", "symbolDecoder", "reactor"];
 
@@ -607,90 +941,178 @@ class MonoFlowField {
     }
 }
 
-const PathFinalization = (typeof FinalizationRegistry === 'undefined')
+const MultiroomDistanceMapFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_path_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_multiroomdistancemap_free(ptr >>> 0, 1));
 /**
- * A list of positions representing a path.
+ * Maps distance values across multiple rooms, storing a DistanceMap for each room
  */
-class Path$1 {
+class MultiroomDistanceMap {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Path$1.prototype);
+        const obj = Object.create(MultiroomDistanceMap.prototype);
         obj.__wbg_ptr = ptr;
-        PathFinalization.register(obj, obj.__wbg_ptr, obj);
+        MultiroomDistanceMapFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
     }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        PathFinalization.unregister(this);
+        MultiroomDistanceMapFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_path_free(ptr, 0);
+        wasm.__wbg_multiroomdistancemap_free(ptr, 0);
     }
     /**
-     * @param {number} packed_position
+     * Creates a new empty multiroom distance map (JavaScript constructor)
      */
-    add(packed_position) {
-        wasm.path_add(this.__wbg_ptr, packed_position);
+    constructor() {
+        const ret = wasm.multiroomdistancemap_js_new();
+        this.__wbg_ptr = ret >>> 0;
+        MultiroomDistanceMapFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
-     * @param {number} index
-     * @returns {number | undefined}
+     * Gets the distance value at a given position
+     * @param {number} packed_pos
+     * @returns {number}
      */
-    get(index) {
+    get(packed_pos) {
+        const ret = wasm.multiroomdistancemap_get(this.__wbg_ptr, packed_pos);
+        return ret >>> 0;
+    }
+    /**
+     * Sets the distance value at a given position
+     * @param {number} packed_pos
+     * @param {number} value
+     */
+    set(packed_pos, value) {
+        wasm.multiroomdistancemap_set(this.__wbg_ptr, packed_pos, value);
+    }
+    /**
+     * Gets the list of rooms in the map
+     * @returns {Uint16Array}
+     */
+    get_rooms() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.path_get(retptr, this.__wbg_ptr, index);
+            wasm.multiroomdistancemap_get_rooms(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            return r0 === 0 ? undefined : r1 >>> 0;
+            var v1 = getArrayU16FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_free(r0, r1 * 2, 2);
+            return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
+     * Gets the DistanceMap for a given room
+     * @param {number} room_name
+     * @returns {DistanceMap | undefined}
+     */
+    get_room(room_name) {
+        const ret = wasm.multiroomdistancemap_get_room(this.__wbg_ptr, room_name);
+        return ret === 0 ? undefined : DistanceMap.__wrap(ret);
+    }
+}
+
+const MultiroomFlowFieldFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_multiroomflowfield_free(ptr >>> 0, 1));
+/**
+ * Maps flow field values across multiple rooms, storing a FlowField for each room
+ */
+class MultiroomFlowField {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(MultiroomFlowField.prototype);
+        obj.__wbg_ptr = ptr;
+        MultiroomFlowFieldFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MultiroomFlowFieldFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_multiroomflowfield_free(ptr, 0);
+    }
+    /**
+     * Creates a new empty multiroom flow field (JavaScript constructor)
+     */
+    constructor() {
+        const ret = wasm.multiroomflowfield_js_new();
+        this.__wbg_ptr = ret >>> 0;
+        MultiroomFlowFieldFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Gets the flow field value at a given position
+     * @param {number} packed_pos
      * @returns {number}
      */
-    len() {
-        const ret = wasm.path_len(this.__wbg_ptr);
-        return ret >>> 0;
+    get(packed_pos) {
+        const ret = wasm.multiroomflowfield_get(this.__wbg_ptr, packed_pos);
+        return ret;
     }
     /**
-     * Given a position, find the index of the next adjacent position
-     * in the path. If the position is not in the path, the target is
-     * the next adjacent position closest to the end of the path. If
-     * the position is neither on nor adjacent to the path, return None.
-     * @param {number} packed_position
-     * @returns {number | undefined}
+     * Sets the flow field value at a given position
+     * @param {number} packed_pos
+     * @param {number} value
      */
-    find_next_index(packed_position) {
+    set(packed_pos, value) {
+        wasm.multiroomflowfield_set(this.__wbg_ptr, packed_pos, value);
+    }
+    /**
+     * Gets the list of rooms in the flow field
+     * @returns {Uint16Array}
+     */
+    getRooms() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.path_find_next_index(retptr, this.__wbg_ptr, packed_position);
+            wasm.multiroomflowfield_getRooms(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            return r0 === 0 ? undefined : r1 >>> 0;
+            var v1 = getArrayU16FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_free(r0, r1 * 2, 2);
+            return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
     /**
-     * @returns {Uint32Array}
+     * Gets the FlowField for a given room
+     * @param {number} room_name
+     * @returns {FlowField | undefined}
      */
-    to_array() {
+    getRoom(room_name) {
+        const ret = wasm.multiroomflowfield_getRoom(this.__wbg_ptr, room_name);
+        return ret === 0 ? undefined : FlowField.__wrap(ret);
+    }
+    /**
+     * Gets the list of valid directions at a given position (JavaScript)
+     * @param {number} packed_pos
+     * @returns {any[]}
+     */
+    getDirections(packed_pos) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.path_to_array(retptr, this.__wbg_ptr);
+            wasm.multiroomflowfield_getDirections(retptr, this.__wbg_ptr, packed_pos);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
             wasm.__wbindgen_free(r0, r1 * 4, 4);
             return v1;
         } finally {
@@ -698,36 +1120,290 @@ class Path$1 {
         }
     }
     /**
-     * @returns {Uint32Array}
+     * Sets the list of valid directions at a given position (JavaScript)
+     * @param {number} packed_pos
+     * @param {any[]} directions
      */
-    to_array_reversed() {
+    setDirections(packed_pos, directions) {
+        const ptr0 = passArrayJsValueToWasm0(directions, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.multiroomflowfield_setDirections(this.__wbg_ptr, packed_pos, ptr0, len0);
+    }
+    /**
+     * Adds a direction to the list of valid directions at a given position (JavaScript)
+     * @param {number} packed_pos
+     * @param {Direction} direction
+     */
+    addDirection(packed_pos, direction) {
+        wasm.multiroomflowfield_addDirection(this.__wbg_ptr, packed_pos, direction);
+    }
+}
+
+const MultiroomMonoFlowFieldFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_multiroommonoflowfield_free(ptr >>> 0, 1));
+/**
+ * Maps monodirectional flow field values across multiple rooms, storing a MonoFlowField for each room
+ */
+class MultiroomMonoFlowField {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(MultiroomMonoFlowField.prototype);
+        obj.__wbg_ptr = ptr;
+        MultiroomMonoFlowFieldFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MultiroomMonoFlowFieldFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_multiroommonoflowfield_free(ptr, 0);
+    }
+    /**
+     * Creates a new empty multiroom monodirectional flow field (JavaScript constructor)
+     */
+    constructor() {
+        const ret = wasm.multiroomdistancemap_js_new();
+        this.__wbg_ptr = ret >>> 0;
+        MultiroomMonoFlowFieldFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Gets the direction at a given position
+     * @param {number} packed_pos
+     * @returns {Direction | undefined}
+     */
+    get(packed_pos) {
+        const ret = wasm.multiroommonoflowfield_get(this.__wbg_ptr, packed_pos);
+        return ret === 0 ? undefined : ret;
+    }
+    /**
+     * Sets the direction at a given position
+     * @param {number} packed_pos
+     * @param {Direction | undefined} [direction]
+     */
+    set(packed_pos, direction) {
+        wasm.multiroommonoflowfield_set(this.__wbg_ptr, packed_pos, isLikeNone(direction) ? 0 : direction);
+    }
+    /**
+     * Gets the list of rooms in the flow field
+     * @returns {Uint16Array}
+     */
+    getRooms() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.path_to_array_reversed(retptr, this.__wbg_ptr);
+            wasm.multiroommonoflowfield_getRooms(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var v1 = getArrayU32FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_free(r0, r1 * 4, 4);
+            var v1 = getArrayU16FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_free(r0, r1 * 2, 2);
             return v1;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Gets the MonoFlowField for a given room
+     * @param {number} room_name
+     * @returns {MonoFlowField | undefined}
+     */
+    getRoom(room_name) {
+        const ret = wasm.multiroommonoflowfield_getRoom(this.__wbg_ptr, room_name);
+        return ret === 0 ? undefined : MonoFlowField.__wrap(ret);
+    }
 }
 
-(typeof FinalizationRegistry === 'undefined')
+const PathFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_pathfatigue_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_path_free(ptr >>> 0, 1));
+/**
+ * A list of positions representing a path.
+ */
+class Path$1 {
 
-(typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_searchgoal_free(ptr >>> 0, 1));
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Path$1.prototype);
+        obj.__wbg_ptr = ptr;
+        PathFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PathFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_path_free(ptr, 0);
+    }
+    /**
+     * @param {number} packed_position
+     */
+    add(packed_position) {
+        wasm.path_add(this.__wbg_ptr, packed_position);
+    }
+    /**
+     * @param {number} index
+     * @returns {number | undefined}
+     */
+    get(index) {
+        const ret = wasm.path_get(this.__wbg_ptr, index);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * @returns {number}
+     */
+    len() {
+        const ret = wasm.path_len(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Given a position, find the index of the next adjacent position
+     * in the path. If the position is not in the path, the target is
+     * the next adjacent position closest to the end of the path. If
+     * the position is neither on nor adjacent to the path, return None.
+     * @param {number} packed_position
+     * @returns {number | undefined}
+     */
+    find_next_index(packed_position) {
+        const ret = wasm.path_find_next_index(this.__wbg_ptr, packed_position);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    to_array() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.path_to_array(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_free(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    to_array_reversed() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.path_to_array_reversed(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_free(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+
+(typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_pathfatigue_free(ptr >>> 0, 1));
+
+(typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_searchgoal_free(ptr >>> 0, 1));
 
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
-    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
-        takeObject(arg0);
+    imports.wbg.__wbg_call_0411c0c3c424db9a = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_ceil_73d048b08f059b46 = function(arg0) {
+        const ret = Math.ceil(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_clockworkcostmatrixgetpointer_79ff2a01ab0022a6 = function(arg0) {
+        const ret = clockworkcostmatrix_get_pointer(takeObject(arg0));
+        return ret;
+    };
+    imports.wbg.__wbg_create_7616c10d022615b4 = function(arg0) {
+        const ret = Object.create(getObject(arg0));
+        return addHeapObject(ret);
+    };
+    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_getRoomTerrain_82fcc54e35a8985e = function() { return handleError(function (arg0) {
+        const ret = Game.map.getRoomTerrain(getObject(arg0));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_get_1f5a4efd15e39f01 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).get(arg1, arg2);
+        return ret;
+    };
+    imports.wbg.__wbg_get_68aa371864aa301a = function(arg0, arg1) {
+        const ret = getObject(arg0)[arg1 >>> 0];
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_getvalue_a18eaf2c77e125e4 = function(arg0, arg1) {
+        const ret = getObject(arg0)[getObject(arg1)];
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_length_e74df4881604f1d9 = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
+    imports.wbg.__wbg_log_e9cc7e18c0c70cf4 = function(arg0, arg1) {
+        console.log(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg_lookFor_04c5885fea38e9b2 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).lookFor(__wbindgen_enum_Look[arg1]);
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
+        const ret = new Error();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_rooms_c7983d4650f28959 = function() {
+        const ret = Game.rooms;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_setpacked_50526296a5796941 = function(arg0, arg1) {
+        getObject(arg0).__packedPos = arg1 >>> 0;
+    };
+    imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
+        const ret = getObject(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_static_accessor_ROOM_POSITION_PROTOTYPE_359d8a1531b99b4c = function() {
+        const ret = RoomPosition.prototype;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_structuretype_d5991613c372a27e = function(arg0) {
+        const ret = getObject(arg0).structureType;
+        return (__wbindgen_enum_StructureType.indexOf(ret) + 1 || 22) - 1;
     };
     imports.wbg.__wbindgen_is_null = function(arg0) {
         const ret = getObject(arg0) === null;
@@ -747,70 +1423,33 @@ function __wbg_get_imports() {
         const ret = arg0;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+        takeObject(arg0);
+    };
+    imports.wbg.__wbindgen_rethrow = function(arg0) {
+        throw takeObject(arg0);
+    };
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
     imports.wbg.__wbindgen_try_into_number = function(arg0) {
         let result;
-    try { result = +getObject(arg0); } catch (e) { result = e; }
-    const ret = result;
-    return addHeapObject(ret);
-};
-imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
-    const ret = getStringFromWasm0(arg0, arg1);
-    return addHeapObject(ret);
-};
-imports.wbg.__wbg_setpacked_e36387710a3ff5bb = function(arg0, arg1) {
-    getObject(arg0).__packedPos = arg1 >>> 0;
-};
-imports.wbg.__wbg_getvalue_b80bdd3552834f00 = function(arg0, arg1) {
-    const ret = getObject(arg0)[getObject(arg1)];
-    return addHeapObject(ret);
-};
-imports.wbg.__wbg_getRoomTerrain_de7e854c5bcae92b = function() { return handleError(function (arg0) {
-    const ret = Game.map.getRoomTerrain(getObject(arg0));
-    return addHeapObject(ret);
-}, arguments) };
-imports.wbg.__wbg_lookFor_649f089b6bfdb0c7 = function() { return handleError(function (arg0, arg1) {
-    const ret = getObject(arg0).lookFor(__wbindgen_enum_Look[arg1]);
-    return isLikeNone(ret) ? 0 : addHeapObject(ret);
-}, arguments) };
-imports.wbg.__wbg_rooms_8265844828084f14 = function() {
-    const ret = Game.rooms;
-    return addHeapObject(ret);
-};
-imports.wbg.__wbg_static_accessor_ROOM_POSITION_PROTOTYPE_359d8a1531b99b4c = function() {
-    const ret = RoomPosition.prototype;
-    return addHeapObject(ret);
-};
-imports.wbg.__wbg_structuretype_f649797e27122f54 = function(arg0) {
-    const ret = getObject(arg0).structureType;
-    return (__wbindgen_enum_StructureType.indexOf(ret) + 1 || 22) - 1;
-};
-imports.wbg.__wbg_get_ac6072ecac1ab4ec = function(arg0, arg1, arg2) {
-    const ret = getObject(arg0).get(arg1, arg2);
-    return ret;
-};
-imports.wbg.__wbg_get_5419cf6b954aa11d = function(arg0, arg1) {
-    const ret = getObject(arg0)[arg1 >>> 0];
-    return addHeapObject(ret);
-};
-imports.wbg.__wbg_length_f217bbbf7e8e4df4 = function(arg0) {
-    const ret = getObject(arg0).length;
-    return ret;
-};
-imports.wbg.__wbg_create_70ef5302cb22a5c4 = function(arg0) {
-    const ret = Object.create(getObject(arg0));
-    return addHeapObject(ret);
-};
-imports.wbg.__wbg_ceil_f6b5b24722eb28de = typeof Math.ceil == 'function' ? Math.ceil : notDefined('Math.ceil');
-imports.wbg.__wbindgen_throw = function(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
-};
+        try { result = +getObject(arg0); } catch (e) { result = e; }
+        const ret = result;
+        return addHeapObject(ret);
+    };
 
-return imports;
+    return imports;
 }
 
 function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     cachedDataViewMemory0 = null;
+    cachedUint16ArrayMemory0 = null;
     cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;
 
@@ -819,31 +1458,513 @@ function __wbg_finalize_init(instance, module) {
     return wasm;
 }
 
-function initSync(module) {
-    if (wasm !== undefined) return wasm;
-
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module !== 'undefined') {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module);
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead');
+        }
+    }
+
+    const imports = __wbg_get_imports();
+
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+
+    const instance = new WebAssembly.Instance(module, imports);
+
+    return __wbg_finalize_init(instance);
+}
+
+const MAX_USIZE = 0xffffffff;
+
+function fromPacked(packedPos) {
+    const pos = Object.create(RoomPosition.prototype);
+    pos.__packedPos = packedPos;
+    return pos;
+}
+function fromPackedRoomName(packedRoomName) {
+    // Handle sim room case
+    if (packedRoomName === 0) {
+        return 'sim';
+    }
+    const HALF_WORLD_SIZE = 128;
+    const x_coord = ((packedRoomName >> 8) & 0xff) - HALF_WORLD_SIZE;
+    const y_coord = (packedRoomName & 0xff) - HALF_WORLD_SIZE;
+    const result = (x_coord >= 0 ? `E${x_coord}` : `W${~x_coord}`) + (y_coord >= 0 ? `S${y_coord}` : `N${~y_coord}`);
+    return result;
+}
+function packRoomName(room) {
+    // Handle sim room case
+    if (room === 'sim') {
+        return 0;
+    }
+    const HALF_WORLD_SIZE = 128;
+    const [, h_dir, h_coord, v_dir, v_coord] = room.match(/^([WE])(\d+)([NS])(\d+)$/);
+    let x = parseInt(h_coord);
+    if (h_dir === 'W') {
+        x = ~x;
+    }
+    let y = parseInt(v_coord);
+    if (v_dir === 'N') {
+        y = ~y;
+    }
+    x += HALF_WORLD_SIZE;
+    y += HALF_WORLD_SIZE;
+    return (x << 8) | y;
+}
+
+/**
+ * A path from a start position to an end position. Typically returned by a
+ * function like `pathToFlowFieldOrigin` rather than created directly.
+ */
+class Path {
+    constructor(path) {
+        this.path = path;
+    }
+    /**
+     * Iterate over the path.
+     *
+     * @example
+     * ```typescript
+     * for (const pos of path) {
+     *   console.log(pos);
+     * }
+     * ```
+     */
+    [Symbol.iterator]() {
+        let index = 0;
+        const length = this.length;
+        return {
+            next: () => {
+                if (index < length - 1) {
+                    return { value: this.get(index++), done: false };
+                }
+                else {
+                    return { value: this.get(index++), done: true };
+                }
+            }
+        };
+    }
+    /**
+     * Iterate over the path in reverse order.
+     *
+     * @example
+     * ```typescript
+     * for (const pos of path.reversed()) {
+     *   console.log(pos);
+     * }
+     * ```
+     */
+    *reversed() {
+        let index = this.length - 1;
+        return {
+            next: () => {
+                if (index > 0) {
+                    return { value: this.get(index--), done: false };
+                }
+                else {
+                    return { value: this.get(index--), done: true };
+                }
+            }
+        };
+    }
+    /**
+     * Get the position at a given index.
+     */
+    get(index) {
+        const packedPos = this.path.get(index);
+        if (packedPos === undefined) {
+            throw new Error('Index out of bounds');
+        }
+        return fromPacked(packedPos);
+    }
+    /**
+     * Get the length of the path.
+     */
+    get length() {
+        return this.path.len();
+    }
+    /**
+     * Given a current position, find the index of the next position in the path.
+     */
+    findNextIndex(pos) {
+        return this.path.find_next_index(pos.__packedPos);
+    }
+    /**
+     * Convert the path to an array of positions.
+     */
+    toArray() {
+        const result = [];
+        for (const packedPos of this.path.to_array()) {
+            result.push(fromPacked(packedPos));
+        }
+        return result;
+    }
+    /**
+     * Convert the path to an array of positions in reverse order.
+     */
+    toArrayReversed() {
+        const result = [];
+        for (const packedPos of this.path.to_array_reversed()) {
+            result.push(fromPacked(packedPos));
+        }
+        return result;
+    }
+    /**
+     * Free the memory allocated for this path.
+     */
+    free() {
+        this.path.free();
+    }
+}
+
+/**
+ * A distance map for a single room.
+ */
+class ClockworkDistanceMap {
+    constructor(_map) {
+        this._map = _map;
+    }
+    /**
+     * Gets the distance value at a given position.
+     */
+    get(x, y) {
+        return this._map.get(x, y);
+    }
+    /**
+     * Sets the distance value at a given position.
+     */
+    set(x, y, value) {
+        this._map.set(x, y, value);
+    }
+    /**
+     * Converts the distance map into a flat array of distances.
+     */
+    toArray() {
+        return this._map.toArray();
+    }
+    /**
+     * Frees the memory allocated for this distance map.
+     */
+    free() {
+        this._map.free();
+    }
+    /**
+     * Path to the origin from a given position.
+     */
+    pathToOrigin(start) {
+        return new Path(js_path_to_distance_map_origin(start.__packedPos, this._map));
+    }
+}
+
+/**
+ * A distance map that covers multiple rooms. Typically returned by a function
+ * like `bfsMultiroomDistanceMap` rather than created directly.
+ */
+class ClockworkMultiroomDistanceMap {
+    constructor(_map) {
+        this._map = _map;
+    }
+    /**
+     * Get the stored value for a given position.
+     */
+    get(pos) {
+        return this._map.get(pos.__packedPos);
+    }
+    /**
+     * Set the stored value for a given position.
+     */
+    set(pos, value) {
+        this._map.set(pos.__packedPos, value);
+    }
+    /**
+     * Get the DistanceMap for a given room.
+     */
+    getRoom(room) {
+        return this._map.get_room(packRoomName(room));
+    }
+    /**
+     * List all the rooms covered by this distance map.
+     */
+    getRooms() {
+        return [...this._map.get_rooms()].map(room => fromPackedRoomName(room));
+    }
+    /**
+     * Free the memory allocated for this distance map.
+     */
+    free() {
+        this._map.free();
+    }
+    /**
+     * Path to the origin from a given position.
+     */
+    pathToOrigin(start) {
+        return new Path(js_path_to_multiroom_distance_map_origin(start.__packedPos, this._map));
+    }
+}
+
+/**
+ * Generate a [distance map](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html) for a set of positions
+ * using a breadth-first search algorithm.
+ *
+ * The BFS algorithm doesn't include variable costs, and only considers
+ * values of 255 (impassible) in the provided cost matrix. Any other
+ * values are ignored.
+ *
+ * This might be useful for creeps with only MOVE parts and/or empty
+ * CARRY parts, which don't generate fatigue.
+ *
+ * Note that the `roomName` on start positions is ignored - all positions
+ * are assumed to be in the same room as the cost matrix.
+ *
+ * @param start - The starting positions.
+ * @param costMatrix - The cost matrix to use for the flow field.
+ * @returns The flow field.
+ */
+function bfsDistanceMap(start, costMatrix) {
+    const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
+    const result = js_bfs_distance_map(startPacked, costMatrix);
+    return new ClockworkDistanceMap(result);
+}
+/**
+ * Create a distance map for the given start positions, using a breadth-first search.
+ * This does not factor in terrain costs (treating anything less than 255 in the cost
+ * matrix as passable), so it's faster but less useful than Dijkstra's algorithm.
+ *
+ * This calculates a distance map across multiple rooms, with a few configurable limits:
+ * - `maxTiles`: The maximum number of tiles to explore.
+ * - `maxRooms`: The maximum number of rooms to explore.
+ * - `maxRoomDistance`: Don't explore rooms further (in Manhattan distance) than this.
+ * - `maxTileDistance`: Don't explore tiles further (in Chebyshev distance) than this.
+ *
+ * At least one of these limits must be set.
+ *
+ * @param start - The starting positions.
+ * @param options - The options for the distance map.
+ * @returns A multi-room distance map.
+ */
+function bfsMultiroomDistanceMap(start, { costMatrixCallback, maxTiles = MAX_USIZE, maxRooms = MAX_USIZE, maxRoomDistance = MAX_USIZE, maxTileDistance = MAX_USIZE }) {
+    if ([maxTiles, maxRooms, maxRoomDistance, maxTileDistance].every(n => n === MAX_USIZE)) {
+        throw new Error('At least one of maxTiles, maxRooms, maxRoomDistance, or maxTileDistance must be set');
+    }
+    const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
+    const result = js_bfs_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomName(room)), maxTiles, maxRooms, maxRoomDistance, maxTileDistance);
+    return new ClockworkMultiroomDistanceMap(result);
+}
+
+/**
+ * A flow field for a single room that stores multiple directions per tile.
+ */
+class ClockworkFlowField {
+    constructor(_flowField) {
+        this._flowField = _flowField;
+    }
+    /**
+     * Get the internal value for a given coordinate.
+     */
+    get(x, y) {
+        return this._flowField.get(x, y);
+    }
+    /**
+     * Set the internal value for a given coordinate.
+     */
+    set(x, y, value) {
+        this._flowField.set(x, y, value);
+    }
+    /**
+     * Get the list of valid directions for a given coordinate.
+     */
+    getDirections(x, y) {
+        return this._flowField.getDirections(x, y);
+    }
+    /**
+     * Set the list of valid directions for a given coordinate.
+     */
+    setDirections(x, y, directions) {
+        this._flowField.setDirections(x, y, directions);
+    }
+    /**
+     * Add a direction to the list of valid directions for a given coordinate.
+     */
+    addDirection(x, y, direction) {
+        this._flowField.addDirection(x, y, direction);
+    }
+    /**
+     * Free the memory allocated for this flow field.
+     */
+    free() {
+        this._flowField.free();
+    }
+    /**
+     * Given a flow field (for a single room), find the path from a given position to
+     * the origin. Never paths through other rooms.
+     */
+    pathToOrigin(start) {
+        return new Path(js_path_to_flow_field_origin(start.__packedPos, this._flowField));
+    }
+}
+
+/**
+ * A flow field for a single room that stores one direction per tile.
+ */
+class ClockworkMonoFlowField {
+    constructor(_flowField) {
+        this._flowField = _flowField;
+    }
+    /**
+     * Get the direction for a given coordinate.
+     */
+    get(x, y) {
+        return this._flowField.get(x, y);
+    }
+    /**
+     * Set the direction for a given coordinate.
+     */
+    set(x, y, value) {
+        this._flowField.set(x, y, value);
+    }
+    /**
+     * Free the memory allocated for this flow field.
+     */
+    free() {
+        this._flowField.free();
+    }
+    /**
+     * Given a monodirectional flow field (for a single room), find the path from a given position to
+     * the origin. Never paths through other rooms.
+     */
+    pathToOrigin(start) {
+        return new Path(js_path_to_mono_flow_field_origin(start.__packedPos, this._flowField));
+    }
+}
 
-    if (typeof module !== 'undefined') {
-        if (Object.getPrototypeOf(module) === Object.prototype) {
-            ({module} = module);
-        } else {
-            console.warn('using deprecated parameters for `initSync()`; pass a single object instead');
+/**
+ * A flow field that spans multiple rooms, storing multiple directions per tile.
+ */
+class ClockworkMultiroomFlowField {
+    constructor(_flowField) {
+        this._flowField = _flowField;
+    }
+    /**
+     * Get the flow field value at a given position.
+     */
+    get(pos) {
+        return this._flowField.get(pos.__packedPos);
+    }
+    /**
+     * Set the flow field value at a given position.
+     */
+    set(pos, value) {
+        this._flowField.set(pos.__packedPos, value);
+    }
+    /**
+     * Get the list of valid directions at a given position.
+     */
+    getDirections(pos) {
+        return this._flowField.getDirections(pos.__packedPos);
+    }
+    /**
+     * Set the list of valid directions at a given position.
+     */
+    setDirections(pos, directions) {
+        this._flowField.setDirections(pos.__packedPos, directions);
+    }
+    /**
+     * Add a direction to the list of valid directions at a given position.
+     */
+    addDirection(pos, direction) {
+        this._flowField.addDirection(pos.__packedPos, direction);
+    }
+    /**
+     * Get the list of rooms in the flow field.
+     */
+    getRooms() {
+        const rooms = [];
+        for (const packedRoomName of this._flowField.getRooms()) {
+            rooms.push(fromPackedRoomName(packedRoomName));
         }
+        return rooms;
     }
-
-    const imports = __wbg_get_imports();
-
-    if (!(module instanceof WebAssembly.Module)) {
-        module = new WebAssembly.Module(module);
+    /**
+     * Get the flow field for a given room.
+     */
+    getRoom(roomName) {
+        const flowField = this._flowField.getRoom(packRoomName(roomName));
+        return flowField ? new ClockworkFlowField(flowField) : null;
     }
+    /**
+     * Find a path from a given position to the origin of the flow field.
+     */
+    pathToOrigin(start) {
+        return new Path(js_path_to_multiroom_flow_field_origin(start.__packedPos, this._flowField));
+    }
+    /**
+     * Free the memory allocated for this flow field.
+     */
+    free() {
+        this._flowField.free();
+    }
+}
 
-    const instance = new WebAssembly.Instance(module, imports);
-
-    return __wbg_finalize_init(instance);
+/**
+ * A flow field that spans multiple rooms, storing a single direction per tile.
+ */
+class ClockworkMultiroomMonoFlowField {
+    constructor(_flowField) {
+        this._flowField = _flowField;
+    }
+    /**
+     * Get the direction at a given position.
+     */
+    get(pos) {
+        var _a;
+        return (_a = this._flowField.get(pos.__packedPos)) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * Set the direction at a given position.
+     */
+    set(pos, direction) {
+        this._flowField.set(pos.__packedPos, direction !== null && direction !== void 0 ? direction : undefined);
+    }
+    /**
+     * Get the list of rooms in the flow field.
+     */
+    getRooms() {
+        const rooms = [];
+        for (const packedRoomName of this._flowField.getRooms()) {
+            rooms.push(fromPackedRoomName(packedRoomName));
+        }
+        return rooms;
+    }
+    /**
+     * Get the flow field for a given room.
+     */
+    getRoom(roomName) {
+        const flowField = this._flowField.getRoom(packRoomName(roomName));
+        return flowField ? new ClockworkMonoFlowField(flowField) : null;
+    }
+    /**
+     * Find a path from a given position to the origin of the flow field.
+     */
+    pathToOrigin(start) {
+        return new Path(js_path_to_multiroom_mono_flow_field_origin(start.__packedPos, this._flowField));
+    }
+    /**
+     * Free the memory allocated for this flow field.
+     */
+    free() {
+        this._flowField.free();
+    }
 }
 
 /**
- * Generate a [distance map](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html) for a set of positions
+ * Generate a [flow field](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html) for a set of positions
  * using a breadth-first search algorithm.
  *
  * The BFS algorithm doesn't include variable costs, and only considers
@@ -853,6 +1974,26 @@ function initSync(module) {
  * This might be useful for creeps with only MOVE parts and/or empty
  * CARRY parts, which don't generate fatigue.
  *
+ * @param start - The starting positions.
+ * @param costMatrix - The cost matrix to use for the flow field.
+ * @returns The flow field.
+ */
+function bfsFlowField(start, costMatrix) {
+    const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
+    const result = js_bfs_flow_field(startPacked, costMatrix);
+    return new ClockworkFlowField(result);
+}
+/**
+ * Generate a [mono-directional flow field](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html)
+ * for a set of positions using a breadth-first search algorithm.
+ *
+ * The BFS algorithm doesn't include variable costs, and only considers
+ * values of 255 (impassible) in the provided cost matrix. Any other
+ * values are ignored.
+ *
+ * This might be useful for creeps with only MOVE parts and/or empty
+ * CARRY parts, which don't generate fatigue.
+ *
  * Note that the `roomName` on start positions is ignored - all positions
  * are assumed to be in the same room as the cost matrix.
  *
@@ -860,15 +2001,13 @@ function initSync(module) {
  * @param costMatrix - The cost matrix to use for the flow field.
  * @returns The flow field.
  */
-function bfsDistanceMap(start, costMatrix) {
+function bfsMonoFlowField(start, costMatrix) {
     const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
-    const result = js_bfs_distance_map(startPacked, costMatrix);
-    return result;
+    const result = js_bfs_mono_flow_field(startPacked, costMatrix);
+    return new ClockworkMonoFlowField(result);
 }
-
 /**
- * Generate a [flow field](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html) for a set of positions
- * using a breadth-first search algorithm.
+ * Generate a multiroom flow field for a set of positions using a breadth-first search algorithm.
  *
  * The BFS algorithm doesn't include variable costs, and only considers
  * values of 255 (impassible) in the provided cost matrix. Any other
@@ -878,17 +2017,23 @@ function bfsDistanceMap(start, costMatrix) {
  * CARRY parts, which don't generate fatigue.
  *
  * @param start - The starting positions.
- * @param costMatrix - The cost matrix to use for the flow field.
+ * @param costMatrixCallback - A function that returns a cost matrix for a given room name.
+ * @param options - Options for the flow field generation.
  * @returns The flow field.
  */
-function bfsFlowField(start, costMatrix) {
+function bfsMultiroomFlowField(start, { costMatrixCallback, maxTiles = MAX_USIZE, maxRooms = MAX_USIZE, maxRoomDistance = MAX_USIZE, maxTileDistance = MAX_USIZE }) {
+    if ([maxTiles, maxRooms, maxRoomDistance, maxTileDistance].every(n => n === MAX_USIZE)) {
+        throw new Error('At least one of maxTiles, maxRooms, maxRoomDistance, or maxTileDistance must be set');
+    }
     const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
-    const result = js_bfs_flow_field(startPacked, costMatrix);
-    return result;
+    const result = js_bfs_multiroom_flow_field(startPacked, (packedRoomName) => {
+        const roomName = fromPackedRoomName(packedRoomName);
+        return costMatrixCallback(roomName);
+    }, maxTiles, maxRooms, maxRoomDistance, maxTileDistance);
+    return new ClockworkMultiroomFlowField(result);
 }
 /**
- * Generate a [mono-directional flow field](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html)
- * for a set of positions using a breadth-first search algorithm.
+ * Generate a multiroom mono-directional flow field for a set of positions using a breadth-first search algorithm.
  *
  * The BFS algorithm doesn't include variable costs, and only considers
  * values of 255 (impassible) in the provided cost matrix. Any other
@@ -897,17 +2042,21 @@ function bfsFlowField(start, costMatrix) {
  * This might be useful for creeps with only MOVE parts and/or empty
  * CARRY parts, which don't generate fatigue.
  *
- * Note that the `roomName` on start positions is ignored - all positions
- * are assumed to be in the same room as the cost matrix.
- *
  * @param start - The starting positions.
- * @param costMatrix - The cost matrix to use for the flow field.
+ * @param getCostMatrix - A function that returns a cost matrix for a given room name.
+ * @param options - Options for the flow field generation.
  * @returns The flow field.
  */
-function bfsMonoFlowField(start, costMatrix) {
+function bfsMultiroomMonoFlowField(start, { costMatrixCallback, maxTiles = MAX_USIZE, maxRooms = MAX_USIZE, maxRoomDistance = MAX_USIZE, maxTileDistance = MAX_USIZE }) {
+    if ([maxTiles, maxRooms, maxRoomDistance, maxTileDistance].every(n => n === MAX_USIZE)) {
+        throw new Error('At least one of maxTiles, maxRooms, maxRoomDistance, or maxTileDistance must be set');
+    }
     const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
-    const result = js_bfs_mono_flow_field(startPacked, costMatrix);
-    return result;
+    const result = js_bfs_multiroom_mono_flow_field(startPacked, (packedRoomName) => {
+        const roomName = fromPackedRoomName(packedRoomName);
+        return costMatrixCallback(roomName);
+    }, maxTiles, maxRooms, maxRoomDistance, maxTileDistance);
+    return new ClockworkMultiroomMonoFlowField(result);
 }
 
 /**
@@ -929,7 +2078,31 @@ function bfsMonoFlowField(start, costMatrix) {
 function dijkstraDistanceMap(start, costMatrix) {
     const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
     const result = js_dijkstra_distance_map(startPacked, costMatrix);
-    return result;
+    return new ClockworkDistanceMap(result);
+}
+/**
+ * Create a distance map for the given start positions, using Dijkstra's algorithm to
+ * factor in terrain costs (0-255, where 255 is impassable).
+ *
+ * This calculates a distance map across multiple rooms, with a few configurable limits:
+ * - `maxTiles`: The maximum number of tiles to explore.
+ * - `maxRooms`: The maximum number of rooms to explore.
+ * - `maxRoomDistance`: Don't explore rooms further (in Manhattan distance) than this.
+ * - `maxTileDistance`: Don't explore tiles further (in accumulated cost) than this.
+ *
+ * At least one of these limits must be set.
+ *
+ * @param start - The starting positions.
+ * @param options - The options for the distance map.
+ * @returns A multi-room distance map.
+ */
+function dijkstraMultiroomDistanceMap(start, { costMatrixCallback, maxTiles = MAX_USIZE, maxRooms = MAX_USIZE, maxRoomDistance = MAX_USIZE, maxTileDistance = MAX_USIZE }) {
+    if ([maxTiles, maxRooms, maxRoomDistance, maxTileDistance].every(n => n === MAX_USIZE)) {
+        throw new Error('At least one of maxTiles, maxRooms, maxRoomDistance, or maxTileDistance must be set');
+    }
+    const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
+    const result = js_dijkstra_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomName(room)), maxTiles, maxRooms, maxRoomDistance, maxTileDistance);
+    return new ClockworkMultiroomDistanceMap(result);
 }
 
 /**
@@ -948,7 +2121,7 @@ function dijkstraDistanceMap(start, costMatrix) {
 function dijkstraFlowField(start, costMatrix) {
     const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
     const result = js_dijkstra_flow_field(startPacked, costMatrix);
-    return result;
+    return new ClockworkFlowField(result);
 }
 /**
  * Generate a [mono-directional flow field](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html)
@@ -969,7 +2142,55 @@ function dijkstraFlowField(start, costMatrix) {
 function dijkstraMonoFlowField(start, costMatrix) {
     const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
     const result = js_dijkstra_mono_flow_field(startPacked, costMatrix);
-    return result;
+    return new ClockworkMonoFlowField(result);
+}
+/**
+ * Generate a multiroom flow field for a set of positions using Dijkstra's algorithm.
+ *
+ * Dijkstra's algorithm includes variable costs to account for terrain or other cost functions.
+ *
+ * Note that values of 0 in the cost matrix may have unexpected behavior. You probably want
+ * a cost matrix with a default value of at least 1.
+ *
+ * @param start - The starting positions.
+ * @param costMatrixCallback - A function that returns a cost matrix for a given room name.
+ * @param options - Options for the flow field generation.
+ * @returns The flow field.
+ */
+function dijkstraMultiroomFlowField(start, { costMatrixCallback, maxTiles = MAX_USIZE, maxRooms = MAX_USIZE, maxRoomDistance = MAX_USIZE, maxTileDistance = MAX_USIZE }) {
+    if ([maxTiles, maxRooms, maxRoomDistance, maxTileDistance].every(n => n === MAX_USIZE)) {
+        throw new Error('At least one of maxTiles, maxRooms, maxRoomDistance, or maxTileDistance must be set');
+    }
+    const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
+    const result = js_dijkstra_multiroom_flow_field(startPacked, (packedRoomName) => {
+        const roomName = fromPackedRoomName(packedRoomName);
+        return costMatrixCallback(roomName);
+    }, maxTiles, maxRooms, maxRoomDistance, maxTileDistance);
+    return new ClockworkMultiroomFlowField(result);
+}
+/**
+ * Generate a multiroom mono-directional flow field for a set of positions using Dijkstra's algorithm.
+ *
+ * Dijkstra's algorithm includes variable costs to account for terrain or other cost functions.
+ *
+ * Note that values of 0 in the cost matrix may have unexpected behavior. You probably want
+ * a cost matrix with a default value of at least 1.
+ *
+ * @param start - The starting positions.
+ * @param costMatrixCallback - A function that returns a cost matrix for a given room name.
+ * @param options - Options for the flow field generation.
+ * @returns The flow field.
+ */
+function dijkstraMultiroomMonoFlowField(start, { costMatrixCallback, maxTiles = MAX_USIZE, maxRooms = MAX_USIZE, maxRoomDistance = MAX_USIZE, maxTileDistance = MAX_USIZE }) {
+    if ([maxTiles, maxRooms, maxRoomDistance, maxTileDistance].every(n => n === MAX_USIZE)) {
+        throw new Error('At least one of maxTiles, maxRooms, maxRoomDistance, or maxTileDistance must be set');
+    }
+    const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
+    const result = js_dijkstra_multiroom_mono_flow_field(startPacked, (packedRoomName) => {
+        const roomName = fromPackedRoomName(packedRoomName);
+        return costMatrixCallback(roomName);
+    }, maxTiles, maxRooms, maxRoomDistance, maxTileDistance);
+    return new ClockworkMultiroomMonoFlowField(result);
 }
 
 /**
@@ -985,90 +2206,6 @@ function getRange(pos1, pos2) {
     return get_range(pos1.__packedPos, pos2.__packedPos);
 }
 
-function fromPacked(packedPos) {
-    const pos = Object.create(RoomPosition.prototype);
-    pos.__packedPos = packedPos;
-    return pos;
-}
-
-class Path {
-    constructor(path) {
-        this.path = path;
-    }
-    [Symbol.iterator]() {
-        let index = 0;
-        const length = this.length;
-        return {
-            next: () => {
-                if (index < length - 1) {
-                    return { value: this.get(index++), done: false };
-                }
-                else {
-                    return { value: this.get(index++), done: true };
-                }
-            }
-        };
-    }
-    /**
-     * Iterate over the path in reverse order
-     */
-    *reversed() {
-        let index = this.length - 1;
-        return {
-            next: () => {
-                if (index > 0) {
-                    return { value: this.get(index--), done: false };
-                }
-                else {
-                    return { value: this.get(index--), done: true };
-                }
-            }
-        };
-    }
-    get(index) {
-        const packedPos = this.path.get(index);
-        if (packedPos === undefined) {
-            throw new Error('Index out of bounds');
-        }
-        return fromPacked(packedPos);
-    }
-    get length() {
-        return this.path.len();
-    }
-    findNextIndex(index) {
-        return this.path.find_next_index(index);
-    }
-    toArray() {
-        const result = [];
-        for (const packedPos of this.path.to_array()) {
-            result.push(fromPacked(packedPos));
-        }
-        return result;
-    }
-    toArrayReversed() {
-        const result = [];
-        for (const packedPos of this.path.to_array_reversed()) {
-            result.push(fromPacked(packedPos));
-        }
-        return result;
-    }
-    free() {
-        this.path.free();
-    }
-}
-
-function pathToDistanceMapOrigin(start, distanceMap) {
-    return new Path(js_path_to_distance_map_origin(start.__packedPos, distanceMap));
-}
-
-function pathToFlowFieldOrigin(start, flowField) {
-    return new Path(js_path_to_flow_field_origin(start.__packedPos, flowField));
-}
-
-function pathToMonoFlowFieldOrigin(start, flowField) {
-    return new Path(js_path_to_mono_flow_field_origin(start.__packedPos, flowField));
-}
-
 let wasm_bytes;
 let wasm_module;
 let wasm_instance;
@@ -1082,6 +2219,8 @@ let initialized = false;
  * @param verbose - If true, will log the state of the WASM module as it loads.
  */
 function initialize(verbose = false) {
+    // need to freshly override the fake console object each tick
+    console.error = console_error;
     if (!wasm_bytes)
         wasm_bytes = require('screeps_clockwork.wasm');
     if (verbose && !initialized)
@@ -1098,8 +2237,33 @@ function initialize(verbose = false) {
     }
     initialized = true;
 }
+// This provides the function `console.error` that wasm_bindgen sometimes expects to exist,
+// especially with type checks in debug mode. An alternative is to have this be `function () {}`
+// and let the exception handler log the thrown JS exceptions, but there is some additional
+// information that wasm_bindgen only passes here.
+//
+// There is nothing special about this function and it may also be used by any JS/Rust code as a convenience.
+function console_error() {
+    const processedArgs = Array.from(arguments)
+        .map(arg => {
+        if (arg instanceof Error) {
+            // On this version of Node, the `stack` property of errors contains
+            // the message as well.
+            return arg.stack;
+        }
+        else {
+            return arg;
+        }
+    })
+        .join(' ');
+    console.log('ERROR:', processedArgs);
+}
 
 exports.ClockworkCostMatrix = ClockworkCostMatrix;
+exports.ClockworkFlowField = ClockworkFlowField;
+exports.ClockworkMonoFlowField = ClockworkMonoFlowField;
+exports.ClockworkMultiroomFlowField = ClockworkMultiroomFlowField;
+exports.ClockworkMultiroomMonoFlowField = ClockworkMultiroomMonoFlowField;
 exports.DistanceMap = DistanceMap;
 exports.FlowField = FlowField;
 exports.MonoFlowField = MonoFlowField;
@@ -1107,12 +2271,15 @@ exports.Path = Path;
 exports.bfsDistanceMap = bfsDistanceMap;
 exports.bfsFlowField = bfsFlowField;
 exports.bfsMonoFlowField = bfsMonoFlowField;
+exports.bfsMultiroomDistanceMap = bfsMultiroomDistanceMap;
+exports.bfsMultiroomFlowField = bfsMultiroomFlowField;
+exports.bfsMultiroomMonoFlowField = bfsMultiroomMonoFlowField;
 exports.dijkstraDistanceMap = dijkstraDistanceMap;
 exports.dijkstraFlowField = dijkstraFlowField;
 exports.dijkstraMonoFlowField = dijkstraMonoFlowField;
+exports.dijkstraMultiroomDistanceMap = dijkstraMultiroomDistanceMap;
+exports.dijkstraMultiroomFlowField = dijkstraMultiroomFlowField;
+exports.dijkstraMultiroomMonoFlowField = dijkstraMultiroomMonoFlowField;
 exports.getRange = getRange;
 exports.initialize = initialize;
-exports.pathToDistanceMapOrigin = pathToDistanceMapOrigin;
-exports.pathToFlowFieldOrigin = pathToFlowFieldOrigin;
-exports.pathToMonoFlowFieldOrigin = pathToMonoFlowFieldOrigin;
 //# sourceMappingURL=index.js.map