screeps-clockwork 0.6.0 → 0.7.2

package/dist/index.js

@@ -158,6 +158,36 @@ function getDataViewMemory0() {
     }
     return cachedDataViewMemory0;
 }
+/**
+ * @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;
+}
 
 let cachedUint32ArrayMemory0 = null;
 
@@ -183,16 +213,30 @@ function addBorrowedObject(obj) {
     return stack_pointer;
 }
 /**
+ * WASM wrapper for the BFS multiroom distance map function.
+ *
+ * # Arguments
+ * * `start_packed` - Array of packed position integers representing start positions
+ * * `get_cost_matrix` - JavaScript function that returns cost matrices for rooms
+ * * `max_ops` - Maximum number of tiles to explore
+ * * `max_rooms` - Maximum number of rooms to explore
+ * * `max_room_distance` - Maximum Manhattan distance in rooms to explore
+ * * `max_path_cost` - Maximum distance in tiles to explore
+ * * `any_of_destinations` - Array of packed positions to trigger early exit when any are reached
+ * * `all_of_destinations` - Array of packed positions to trigger early exit when all are reached
+ *
+ * # Returns
+ * A `MultiroomDistanceMap` containing the distances from the start positions
  * @param {Uint32Array} start_packed
  * @param {Function} get_cost_matrix
- * @param {number} max_rooms
  * @param {number} max_ops
+ * @param {number} max_rooms
  * @param {number} max_path_cost
- * @param {Uint32Array | undefined} [any_of_destinations]
- * @param {Uint32Array | undefined} [all_of_destinations]
- * @returns {MultiroomDistanceMap}
+ * @param {Uint32Array | null} [any_of_destinations]
+ * @param {Uint32Array | null} [all_of_destinations]
+ * @returns {SearchResult}
  */
-function js_astar_multiroom_distance_map(start_packed, get_cost_matrix, max_rooms, max_ops, max_path_cost, any_of_destinations, all_of_destinations) {
+function js_bfs_multiroom_distance_map(start_packed, get_cost_matrix, max_ops, max_rooms, max_path_cost, any_of_destinations, all_of_destinations) {
     try {
         const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
@@ -200,51 +244,22 @@ function js_astar_multiroom_distance_map(start_packed, get_cost_matrix, max_room
         var len1 = WASM_VECTOR_LEN;
         var ptr2 = isLikeNone(all_of_destinations) ? 0 : passArray32ToWasm0(all_of_destinations, wasm.__wbindgen_malloc);
         var len2 = WASM_VECTOR_LEN;
-        const ret = wasm.js_astar_multiroom_distance_map(ptr0, len0, addBorrowedObject(get_cost_matrix), max_rooms, max_ops, max_path_cost, ptr1, len1, ptr2, len2);
-        return MultiroomDistanceMap.__wrap(ret);
+        const ret = wasm.js_bfs_multiroom_distance_map(ptr0, len0, addBorrowedObject(get_cost_matrix), max_ops, max_rooms, max_path_cost, ptr1, len1, ptr2, len2);
+        return SearchResult.__wrap(ret);
     } finally {
         heap[stack_pointer++] = undefined;
     }
 }
 
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-}
-/**
- * @param {number} start
- * @param {MultiroomMonoFlowField} flow_field
- * @returns {Path}
- */
-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.__wrap(ret);
-}
-
-let cachedUint16ArrayMemory0 = null;
-
-function getUint16ArrayMemory0() {
-    if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
-        cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
-    }
-    return cachedUint16ArrayMemory0;
-}
-
-function getArrayU16FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
-}
 /**
  * @param {Uint32Array} start_packed
  * @param {Function} get_cost_matrix
  * @param {number} max_ops
  * @param {number} max_rooms
  * @param {number} max_path_cost
- * @param {Uint32Array | undefined} [any_of_destinations]
- * @param {Uint32Array | undefined} [all_of_destinations]
- * @returns {MultiroomDistanceMap}
+ * @param {Uint32Array | null} [any_of_destinations]
+ * @param {Uint32Array | null} [all_of_destinations]
+ * @returns {SearchResult}
  */
 function js_dijkstra_multiroom_distance_map(start_packed, get_cost_matrix, max_ops, max_rooms, max_path_cost, any_of_destinations, all_of_destinations) {
     try {
@@ -255,15 +270,38 @@ function js_dijkstra_multiroom_distance_map(start_packed, get_cost_matrix, max_o
         var ptr2 = isLikeNone(all_of_destinations) ? 0 : passArray32ToWasm0(all_of_destinations, wasm.__wbindgen_malloc);
         var len2 = WASM_VECTOR_LEN;
         const ret = wasm.js_dijkstra_multiroom_distance_map(ptr0, len0, addBorrowedObject(get_cost_matrix), max_ops, max_rooms, max_path_cost, ptr1, len1, ptr2, len2);
-        return MultiroomDistanceMap.__wrap(ret);
+        return SearchResult.__wrap(ret);
     } finally {
         heap[stack_pointer++] = undefined;
     }
 }
 
-function getArrayU32FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+/**
+ * @param {number} start
+ * @param {MultiroomMonoFlowField} flow_field
+ * @returns {Path}
+ */
+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.__wrap(ret);
+}
+
+/**
+ * Creates a monodirectional flow field for the given distance map.
+ * @param {MultiroomDistanceMap} distance_map
+ * @returns {MultiroomMonoFlowField}
+ */
+function multiroomMonoFlowField(distance_map) {
+    _assertClass(distance_map, MultiroomDistanceMap);
+    var ptr0 = distance_map.__destroy_into_raw();
+    const ret = wasm.multiroomMonoFlowField(ptr0);
+    return MultiroomMonoFlowField.__wrap(ret);
 }
 
 function getArrayJsValueFromWasm0(ptr, len) {
@@ -285,61 +323,16 @@ function passArrayJsValueToWasm0(array, malloc) {
     WASM_VECTOR_LEN = array.length;
     return ptr;
 }
-/**
- * WASM wrapper for the BFS multiroom distance map function.
- *
- * # Arguments
- * * `start_packed` - Array of packed position integers representing start positions
- * * `get_cost_matrix` - JavaScript function that returns cost matrices for rooms
- * * `max_ops` - Maximum number of tiles to explore
- * * `max_rooms` - Maximum number of rooms to explore
- * * `max_room_distance` - Maximum Manhattan distance in rooms to explore
- * * `max_path_cost` - Maximum distance in tiles to explore
- * * `any_of_destinations` - Array of packed positions to trigger early exit when any are reached
- * * `all_of_destinations` - Array of packed positions to trigger early exit when all are reached
- *
- * # Returns
- * A `MultiroomDistanceMap` containing the distances from the start positions
- * @param {Uint32Array} start_packed
- * @param {Function} get_cost_matrix
- * @param {number} max_ops
- * @param {number} max_rooms
- * @param {number} max_path_cost
- * @param {Uint32Array | undefined} [any_of_destinations]
- * @param {Uint32Array | undefined} [all_of_destinations]
- * @returns {MultiroomDistanceMap}
- */
-function js_bfs_multiroom_distance_map(start_packed, get_cost_matrix, max_ops, max_rooms, max_path_cost, any_of_destinations, all_of_destinations) {
-    try {
-        const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        var ptr1 = isLikeNone(any_of_destinations) ? 0 : passArray32ToWasm0(any_of_destinations, wasm.__wbindgen_malloc);
-        var len1 = WASM_VECTOR_LEN;
-        var ptr2 = isLikeNone(all_of_destinations) ? 0 : passArray32ToWasm0(all_of_destinations, wasm.__wbindgen_malloc);
-        var len2 = WASM_VECTOR_LEN;
-        const ret = wasm.js_bfs_multiroom_distance_map(ptr0, len0, addBorrowedObject(get_cost_matrix), max_ops, max_rooms, max_path_cost, ptr1, len1, ptr2, len2);
-        return MultiroomDistanceMap.__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.__wrap(ret);
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
 }
-
 /**
  * @param {number} room_name
- * @param {number | undefined} [plain_cost]
- * @param {number | undefined} [swamp_cost]
- * @param {number | undefined} [wall_cost]
+ * @param {number | null} [plain_cost]
+ * @param {number | null} [swamp_cost]
+ * @param {number | null} [wall_cost]
  * @returns {ClockworkCostMatrix}
  */
 function get_terrain_cost_matrix(room_name, plain_cost, swamp_cost, wall_cost) {
@@ -348,48 +341,30 @@ function get_terrain_cost_matrix(room_name, plain_cost, swamp_cost, wall_cost) {
 }
 
 /**
- * @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;
-}
-
-/**
- * Creates a monodirectional flow field for the given distance map.
+ * Creates a flow field for the given distance map.
  * @param {MultiroomDistanceMap} distance_map
- * @returns {MultiroomMonoFlowField}
+ * @returns {MultiroomFlowField}
  */
-function multiroomMonoFlowField(distance_map) {
+function multiroomFlowField(distance_map) {
     _assertClass(distance_map, MultiroomDistanceMap);
     var ptr0 = distance_map.__destroy_into_raw();
-    const ret = wasm.multiroomMonoFlowField(ptr0);
-    return MultiroomMonoFlowField.__wrap(ret);
+    const ret = wasm.multiroomFlowField(ptr0);
+    return MultiroomFlowField.__wrap(ret);
 }
 
+let cachedUint16ArrayMemory0 = null;
+
+function getUint16ArrayMemory0() {
+    if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
+        cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
+    }
+    return cachedUint16ArrayMemory0;
+}
+
+function getArrayU16FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
+}
 /**
  * @param {number} start
  * @param {MultiroomFlowField} flow_field
@@ -402,15 +377,39 @@ function js_path_to_multiroom_flow_field_origin(start, flow_field) {
 }
 
 /**
- * Creates a flow field for the given distance map.
+ * @param {number} start
  * @param {MultiroomDistanceMap} distance_map
- * @returns {MultiroomFlowField}
+ * @returns {Path}
  */
-function multiroomFlowField(distance_map) {
+function js_path_to_multiroom_distance_map_origin(start, distance_map) {
     _assertClass(distance_map, MultiroomDistanceMap);
-    var ptr0 = distance_map.__destroy_into_raw();
-    const ret = wasm.multiroomFlowField(ptr0);
-    return MultiroomFlowField.__wrap(ret);
+    const ret = wasm.js_path_to_multiroom_distance_map_origin(start, distance_map.__wbg_ptr);
+    return Path.__wrap(ret);
+}
+
+/**
+ * @param {Uint32Array} start_packed
+ * @param {Function} get_cost_matrix
+ * @param {number} max_rooms
+ * @param {number} max_ops
+ * @param {number} max_path_cost
+ * @param {Uint32Array | null} [any_of_destinations]
+ * @param {Uint32Array | null} [all_of_destinations]
+ * @returns {SearchResult}
+ */
+function js_astar_multiroom_distance_map(start_packed, get_cost_matrix, max_rooms, max_ops, max_path_cost, any_of_destinations, all_of_destinations) {
+    try {
+        const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(any_of_destinations) ? 0 : passArray32ToWasm0(any_of_destinations, wasm.__wbindgen_malloc);
+        var len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(all_of_destinations) ? 0 : passArray32ToWasm0(all_of_destinations, wasm.__wbindgen_malloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.js_astar_multiroom_distance_map(ptr0, len0, addBorrowedObject(get_cost_matrix), max_rooms, max_ops, max_path_cost, ptr1, len1, ptr2, len2);
+        return SearchResult.__wrap(ret);
+    } finally {
+        heap[stack_pointer++] = undefined;
+    }
 }
 
 /**
@@ -600,7 +599,7 @@ class ClockworkCostMatrix {
     /**
      * Creates a new cost matrix within the WASM module. Optionally, a default value
      * can be provided to initialize all cells in the matrix to that value.
-     * @param {number | undefined} [_default]
+     * @param {number | null} [_default]
      */
     constructor(_default) {
         const ret = wasm.clockworkcostmatrix_new(isLikeNone(_default) ? 0xFFFFFF : _default);
@@ -656,23 +655,6 @@ class DistanceMap {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_distancemap_free(ptr, 0);
     }
-    /**
-     * Converts the distance map into a flat array of distances.
-     * @returns {Uint32Array}
-     */
-    toArray() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.distancemap_toArray(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);
-        }
-    }
     /**
      * Gets the distance value at a given position.
      * @param {number} x
@@ -692,6 +674,23 @@ class DistanceMap {
     set(x, y, value) {
         wasm.distancemap_set(this.__wbg_ptr, x, y, value);
     }
+    /**
+     * Converts the distance map into a flat array of distances.
+     * @returns {Uint32Array}
+     */
+    toArray() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.distancemap_toArray(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);
+        }
+    }
 }
 
 const FlowFieldFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -725,23 +724,13 @@ class FlowField {
         wasm.__wbg_flowfield_free(ptr, 0);
     }
     /**
-     * Get the internal value for a given coordinate.
-     * @param {number} x
-     * @param {number} y
-     * @returns {number}
-     */
-    get(x, y) {
-        const ret = wasm.flowfield_get(this.__wbg_ptr, x, y);
-        return ret;
-    }
-    /**
-     * Set the internal value for a given coordinate.
+     * Add a direction to the list of valid directions for a given coordinate.
      * @param {number} x
      * @param {number} y
-     * @param {number} value
+     * @param {Direction} direction
      */
-    set(x, y, value) {
-        wasm.flowfield_set(this.__wbg_ptr, x, y, value);
+    addDirection(x, y, direction) {
+        wasm.flowfield_addDirection(this.__wbg_ptr, x, y, direction);
     }
     /**
      * Get the list of valid directions for a given coordinate.
@@ -774,13 +763,23 @@ class FlowField {
         wasm.flowfield_setDirections(this.__wbg_ptr, x, y, ptr0, len0);
     }
     /**
-     * Add a direction to the list of valid directions for a given coordinate.
+     * Get the internal value for a given coordinate.
      * @param {number} x
      * @param {number} y
-     * @param {Direction} direction
+     * @returns {number}
      */
-    addDirection(x, y, direction) {
-        wasm.flowfield_addDirection(this.__wbg_ptr, x, y, direction);
+    get(x, y) {
+        const ret = wasm.flowfield_get(this.__wbg_ptr, x, y);
+        return ret;
+    }
+    /**
+     * Set the internal value for a given coordinate.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} value
+     */
+    set(x, y, value) {
+        wasm.flowfield_set(this.__wbg_ptr, x, y, value);
     }
 }
 
@@ -828,7 +827,7 @@ class MonoFlowField {
      * Set the direction for a given coordinate.
      * @param {number} x
      * @param {number} y
-     * @param {Direction | undefined} [value]
+     * @param {Direction | null} [value]
      */
     set(x, y, value) {
         wasm.monoflowfield_set(this.__wbg_ptr, x, y, isLikeNone(value) ? 0 : value);
@@ -863,13 +862,30 @@ class MultiroomDistanceMap {
         wasm.__wbg_multiroomdistancemap_free(ptr, 0);
     }
     /**
-     * Creates a new empty multiroom distance map (JavaScript constructor)
+     * Gets the DistanceMap for a given room
+     * @param {number} room_name
+     * @returns {DistanceMap | undefined}
      */
-    constructor() {
-        const ret = wasm.multiroomdistancemap_js_new();
-        this.__wbg_ptr = ret >>> 0;
-        MultiroomDistanceMapFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    get_room(room_name) {
+        const ret = wasm.multiroomdistancemap_get_room(this.__wbg_ptr, room_name);
+        return ret === 0 ? undefined : DistanceMap.__wrap(ret);
+    }
+    /**
+     * Gets the list of rooms in the map
+     * @returns {Uint16Array}
+     */
+    get_rooms() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.multiroomdistancemap_get_rooms(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            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 distance value at a given position
@@ -880,6 +896,15 @@ class MultiroomDistanceMap {
         const ret = wasm.multiroomdistancemap_get(this.__wbg_ptr, packed_pos);
         return ret >>> 0;
     }
+    /**
+     * Creates a new empty multiroom distance map (JavaScript constructor)
+     */
+    constructor() {
+        const ret = wasm.multiroomdistancemap_js_new();
+        this.__wbg_ptr = ret >>> 0;
+        MultiroomDistanceMapFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
     /**
      * Sets the distance value at a given position
      * @param {number} packed_pos
@@ -888,32 +913,6 @@ class MultiroomDistanceMap {
     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.multiroomdistancemap_get_rooms(retptr, this.__wbg_ptr);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            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')
@@ -944,30 +943,13 @@ class MultiroomFlowField {
         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}
-     */
-    get(packed_pos) {
-        const ret = wasm.multiroomflowfield_get(this.__wbg_ptr, packed_pos);
-        return ret;
-    }
-    /**
-     * Sets the flow field value at a given position
-     * @param {number} packed_pos
-     * @param {number} value
+     * Gets the FlowField for a given room
+     * @param {number} room_name
+     * @returns {FlowField | undefined}
      */
-    set(packed_pos, value) {
-        wasm.multiroomflowfield_set(this.__wbg_ptr, packed_pos, value);
+    getRoom(room_name) {
+        const ret = wasm.multiroomflowfield_getRoom(this.__wbg_ptr, room_name);
+        return ret === 0 ? undefined : FlowField.__wrap(ret);
     }
     /**
      * Gets the list of rooms in the flow field
@@ -987,13 +969,12 @@ class MultiroomFlowField {
         }
     }
     /**
-     * Gets the FlowField for a given room
-     * @param {number} room_name
-     * @returns {FlowField | undefined}
+     * Adds a direction to the list of valid directions at a given position (JavaScript)
+     * @param {number} packed_pos
+     * @param {Direction} direction
      */
-    getRoom(room_name) {
-        const ret = wasm.multiroomflowfield_getRoom(this.__wbg_ptr, room_name);
-        return ret === 0 ? undefined : FlowField.__wrap(ret);
+    addDirection(packed_pos, direction) {
+        wasm.multiroomflowfield_addDirection(this.__wbg_ptr, packed_pos, direction);
     }
     /**
      * Gets the list of valid directions at a given position (JavaScript)
@@ -1024,12 +1005,30 @@ class MultiroomFlowField {
         wasm.multiroomflowfield_setDirections(this.__wbg_ptr, packed_pos, ptr0, len0);
     }
     /**
-     * Adds a direction to the list of valid directions at a given position (JavaScript)
+     * Gets the flow field value at a given position
      * @param {number} packed_pos
-     * @param {Direction} direction
+     * @returns {number}
      */
-    addDirection(packed_pos, direction) {
-        wasm.multiroomflowfield_addDirection(this.__wbg_ptr, packed_pos, direction);
+    get(packed_pos) {
+        const ret = wasm.multiroomflowfield_get(this.__wbg_ptr, packed_pos);
+        return ret;
+    }
+    /**
+     * Creates a new empty multiroom flow field (JavaScript constructor)
+     */
+    constructor() {
+        const ret = wasm.multiroomdistancemap_js_new();
+        this.__wbg_ptr = ret >>> 0;
+        MultiroomFlowFieldFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Sets the flow field value at a given position
+     * @param {number} packed_pos
+     * @param {number} value
+     */
+    set(packed_pos, value) {
+        wasm.multiroomflowfield_set(this.__wbg_ptr, packed_pos, value);
     }
 }
 
@@ -1061,30 +1060,13 @@ class MultiroomMonoFlowField {
         wasm.__wbg_multiroommonoflowfield_free(ptr, 0);
     }
     /**
-     * Creates a new empty multiroom monodirectional flow field (JavaScript constructor)
-     */
-    constructor() {
-        const ret = wasm.multiroommonoflowfield_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]
+     * Gets the MonoFlowField for a given room
+     * @param {number} room_name
+     * @returns {MonoFlowField | undefined}
      */
-    set(packed_pos, direction) {
-        wasm.multiroommonoflowfield_set(this.__wbg_ptr, packed_pos, isLikeNone(direction) ? 0 : direction);
+    getRoom(room_name) {
+        const ret = wasm.multiroommonoflowfield_getRoom(this.__wbg_ptr, room_name);
+        return ret === 0 ? undefined : MonoFlowField.__wrap(ret);
     }
     /**
      * Gets the list of rooms in the flow field
@@ -1104,13 +1086,30 @@ class MultiroomMonoFlowField {
         }
     }
     /**
-     * Gets the MonoFlowField for a given room
-     * @param {number} room_name
-     * @returns {MonoFlowField | undefined}
+     * Gets the direction at a given position
+     * @param {number} packed_pos
+     * @returns {Direction | undefined}
      */
-    getRoom(room_name) {
-        const ret = wasm.multiroommonoflowfield_getRoom(this.__wbg_ptr, room_name);
-        return ret === 0 ? undefined : MonoFlowField.__wrap(ret);
+    get(packed_pos) {
+        const ret = wasm.multiroommonoflowfield_get(this.__wbg_ptr, packed_pos);
+        return ret === 0 ? undefined : ret;
+    }
+    /**
+     * Creates a new empty multiroom monodirectional flow field (JavaScript constructor)
+     */
+    constructor() {
+        const ret = wasm.multiroommonoflowfield_js_new();
+        this.__wbg_ptr = ret >>> 0;
+        MultiroomMonoFlowFieldFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Sets the direction at a given position
+     * @param {number} packed_pos
+     * @param {Direction | null} [direction]
+     */
+    set(packed_pos, direction) {
+        wasm.multiroommonoflowfield_set(this.__wbg_ptr, packed_pos, isLikeNone(direction) ? 0 : direction);
     }
 }
 
@@ -1142,25 +1141,20 @@ class Path {
         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}
+     * @returns {Uint32Array}
      */
-    len() {
-        const ret = wasm.path_len(this.__wbg_ptr);
-        return ret >>> 0;
+    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);
+        }
     }
     /**
      * Given a position, find the index of the next adjacent position
@@ -1177,10 +1171,10 @@ class Path {
     /**
      * @returns {Uint32Array}
      */
-    to_array() {
+    to_array_reversed() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.path_to_array(retptr, this.__wbg_ptr);
+            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();
@@ -1190,13 +1184,84 @@ class Path {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * @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;
+    }
+}
+
+(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));
+
+const SearchResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_searchresult_free(ptr >>> 0, 1));
+/**
+ * A distance map search returns both the distance map (filled out
+ * with all tiles explored) and the targets found. These aren't necessarily
+ * the same positions specified as targets - if the target range is 5, then
+ * this is the first position in range 5 of the target. If multiple targets
+ * are specified, and you care about matching the found target with one of
+ * the original targets, you can iterate through your list and figure out the
+ * ones that are in range of the found target(s).
+ */
+class SearchResult {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SearchResult.prototype);
+        obj.__wbg_ptr = ptr;
+        SearchResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SearchResultFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_searchresult_free(ptr, 0);
+    }
+    /**
+     * @returns {MultiroomDistanceMap}
+     */
+    get distance_map() {
+        const ret = wasm.searchresult_distance_map(this.__wbg_ptr);
+        return MultiroomDistanceMap.__wrap(ret);
+    }
     /**
      * @returns {Uint32Array}
      */
-    to_array_reversed() {
+    get found_targets() {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.path_to_array_reversed(retptr, this.__wbg_ptr);
+            wasm.searchresult_found_targets(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();
@@ -1206,36 +1271,35 @@ class Path {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * @returns {number}
+     */
+    get ops() {
+        const ret = wasm.searchresult_ops(this.__wbg_ptr);
+        return ret >>> 0;
+    }
 }
 
-(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.__wbg_buffer_61b7ce01341d7f88 = function(arg0) {
+    imports.wbg.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
         const ret = getObject(arg0).buffer;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_call_500db948e69c7330 = function() { return handleError(function (arg0, arg1, arg2) {
+    imports.wbg.__wbg_call_7cccdd69e0791ae2 = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_ceil_5cd004a49ac02e2f = function(arg0) {
+    imports.wbg.__wbg_ceil_2a411b0e70cc0baf = function(arg0) {
         const ret = Math.ceil(arg0);
         return ret;
     };
-    imports.wbg.__wbg_clockworkcostmatrixgetpointer_c0e9996555799972 = function(arg0) {
+    imports.wbg.__wbg_clockworkcostmatrixgetpointer_ee2b0a46684eb38c = function(arg0) {
         const ret = clockworkcostmatrix_get_pointer(takeObject(arg0));
         return ret;
     };
-    imports.wbg.__wbg_create_861381d799b454bc = function(arg0) {
+    imports.wbg.__wbg_create_cfe43ccc88c64e0a = function(arg0) {
         const ret = Object.create(getObject(arg0));
         return addHeapObject(ret);
     };
@@ -1262,7 +1326,7 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).get(arg1, arg2);
         return ret;
     };
-    imports.wbg.__wbg_get_9aa3dff3f0266054 = function(arg0, arg1) {
+    imports.wbg.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) {
         const ret = getObject(arg0)[arg1 >>> 0];
         return addHeapObject(ret);
     };
@@ -1270,11 +1334,11 @@ function __wbg_get_imports() {
         const ret = getObject(arg0)[getObject(arg1)];
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_length_d65cf0786bfc5739 = function(arg0) {
+    imports.wbg.__wbg_length_e2d2a49132c1b256 = function(arg0) {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_log_261344311425094c = function(arg0, arg1) {
+    imports.wbg.__wbg_log_4a86514c61094407 = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_lookFor_04c5885fea38e9b2 = function() { return handleError(function (arg0, arg1) {
@@ -1289,7 +1353,7 @@ function __wbg_get_imports() {
         const ret = new Room.Terrain(getObject(arg0));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_newwithbyteoffsetandlength_ba35896968751d91 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a = function(arg0, arg1, arg2) {
         const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
         return addHeapObject(ret);
     };
@@ -1439,7 +1503,10 @@ const MAX_USIZE = 0xffffffff;
 
 function fromPacked(packedPos) {
     const pos = Object.create(RoomPosition.prototype);
-    pos.__packedPos = packedPos;
+    // Screeps stores __packedPos as a signed int32, while Clockwork receives
+    // packed positions from WASM as u32. Re-sign the same bits so Map lookups and
+    // direct comparisons against native RoomPosition.__packedPos values work.
+    pos.__packedPos = packedPos | 0;
     return pos;
 }
 function fromPackedRoomName(packedRoomName) {
@@ -1827,6 +1894,21 @@ class ClockworkMultiroomDistanceMap {
     }
 }
 
+function fromPackedSearchResult(result) {
+    const foundTargets = result.found_targets.reduce((acc, pos) => {
+        acc.push(fromPacked(pos));
+        return acc;
+    }, []);
+    const distanceMap = new ClockworkMultiroomDistanceMap(result.distance_map);
+    const ops = result.ops;
+    result.free();
+    return {
+        distanceMap,
+        foundTargets,
+        ops
+    };
+}
+
 /**
  * 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
@@ -1848,8 +1930,18 @@ function astarMultiroomDistanceMap(start, { costMatrixCallback, maxRooms = MAX_U
         throw new Error('At least one of maxRooms, maxOps, maxPathCost, anyOfDestinations, or allOfDestinations must be set');
     }
     const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
-    const result = js_astar_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomName(room)), maxRooms, maxOps, maxPathCost, anyOfDestinations ? new Uint32Array(anyOfDestinations.map(pos => pos.__packedPos)) : undefined, allOfDestinations ? new Uint32Array(allOfDestinations.map(pos => pos.__packedPos)) : undefined);
-    return new ClockworkMultiroomDistanceMap(result);
+    const result = js_astar_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomName(room)), maxRooms, maxOps, maxPathCost, anyOfDestinations
+        ? new Uint32Array(anyOfDestinations.reduce((acc, { pos, range }) => {
+            acc.push(pos.__packedPos, range);
+            return acc;
+        }, []))
+        : undefined, allOfDestinations
+        ? new Uint32Array(allOfDestinations.reduce((acc, { pos, range }) => {
+            acc.push(pos.__packedPos, range);
+            return acc;
+        }, []))
+        : undefined);
+    return fromPackedSearchResult(result);
 }
 
 /**
@@ -1873,8 +1965,18 @@ function bfsMultiroomDistanceMap(start, { costMatrixCallback, maxOps = MAX_USIZE
         throw new Error('At least one of maxOps, maxRooms, maxRoomDistance, maxPathCost, anyOfDestinations, or allOfDestinations must be set');
     }
     const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
-    const result = js_bfs_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomName(room)), maxOps, maxRooms, maxPathCost, anyOfDestinations ? new Uint32Array(anyOfDestinations.map(pos => pos.__packedPos)) : undefined, allOfDestinations ? new Uint32Array(allOfDestinations.map(pos => pos.__packedPos)) : undefined);
-    return new ClockworkMultiroomDistanceMap(result);
+    const result = js_bfs_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomName(room)), maxOps, maxRooms, maxPathCost, anyOfDestinations
+        ? new Uint32Array(anyOfDestinations.reduce((acc, { pos, range }) => {
+            acc.push(pos.__packedPos, range);
+            return acc;
+        }, []))
+        : undefined, allOfDestinations
+        ? new Uint32Array(allOfDestinations.reduce((acc, { pos, range }) => {
+            acc.push(pos.__packedPos, range);
+            return acc;
+        }, []))
+        : undefined);
+    return fromPackedSearchResult(result);
 }
 
 /**
@@ -1897,8 +1999,18 @@ function dijkstraMultiroomDistanceMap(start, { costMatrixCallback, maxOps = MAX_
         throw new Error('At least one of maxOps, maxRooms, maxPathCost, anyOfDestinations, or allOfDestinations must be set');
     }
     const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
-    const result = js_dijkstra_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomName(room)), maxOps, maxRooms, maxPathCost, anyOfDestinations ? new Uint32Array(anyOfDestinations.map(pos => pos.__packedPos)) : undefined, allOfDestinations ? new Uint32Array(allOfDestinations.map(pos => pos.__packedPos)) : undefined);
-    return new ClockworkMultiroomDistanceMap(result);
+    const result = js_dijkstra_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomName(room)), maxOps, maxRooms, maxPathCost, anyOfDestinations
+        ? new Uint32Array(anyOfDestinations.reduce((acc, { pos, range }) => {
+            acc.push(pos.__packedPos, range);
+            return acc;
+        }, []))
+        : undefined, allOfDestinations
+        ? new Uint32Array(allOfDestinations.reduce((acc, { pos, range }) => {
+            acc.push(pos.__packedPos, range);
+            return acc;
+        }, []))
+        : undefined);
+    return fromPackedSearchResult(result);
 }
 
 /**