screeps-clockwork 0.5.0 → 0.7.1

package/dist/index.js

@@ -183,54 +183,73 @@ function addBorrowedObject(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}
+ * @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_bfs_multiroom_flow_field(start_packed, get_cost_matrix, max_tiles, max_rooms, max_room_distance, max_tile_distance) {
+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;
-        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);
+        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;
     }
 }
 
+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}`);
     }
 }
 /**
- * WASM wrapper for the Dijkstra distance map function.
- * @param {Uint32Array} start_packed
- * @param {ClockworkCostMatrix} cost_matrix
- * @returns {DistanceMap}
+ * @param {number} start
+ * @param {MultiroomMonoFlowField} flow_field
+ * @returns {Path}
  */
-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_distance_map(ptr0, len0, cost_matrix.__wbg_ptr);
-    return DistanceMap.__wrap(ret);
+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 {number} start
- * @param {FlowField} flow_field
+ * @param {MultiroomFlowField} 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 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.__wrap(ret);
 }
 
 function getArrayJsValueFromWasm0(ptr, len) {
@@ -253,249 +272,93 @@ function passArrayJsValueToWasm0(array, malloc) {
     return ptr;
 }
 /**
- * WASM wrapper for the BFS distance map function.
- * @param {Uint32Array} start_packed
- * @param {ClockworkCostMatrix} cost_matrix
- * @returns {DistanceMap}
- */
-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_bfs_distance_map(ptr0, len0, cost_matrix.__wbg_ptr);
-    return DistanceMap.__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 {MultiroomDistanceMap}
+ * @param {number} room_name
+ * @param {number | null} [plain_cost]
+ * @param {number | null} [swamp_cost]
+ * @param {number | null} [wall_cost]
+ * @returns {ClockworkCostMatrix}
  */
-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;
-    }
+function get_terrain_cost_matrix(room_name, plain_cost, swamp_cost, wall_cost) {
+    const ret = wasm.get_terrain_cost_matrix(room_name, isLikeNone(plain_cost) ? 0xFFFFFF : plain_cost, isLikeNone(swamp_cost) ? 0xFFFFFF : swamp_cost, isLikeNone(wall_cost) ? 0xFFFFFF : wall_cost);
+    return ClockworkCostMatrix.__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
+ * Creates a flow field for the given distance map.
+ * @param {MultiroomDistanceMap} distance_map
  * @returns {MultiroomFlowField}
  */
-function js_dijkstra_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_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 {
-        heap[stack_pointer++] = undefined;
-    }
-}
-
-/**
- * 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 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 Dijkstra flow field function.
- * @param {Uint32Array} start_packed
- * @param {ClockworkCostMatrix} cost_matrix
- * @returns {FlowField}
- */
-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_dijkstra_flow_field(ptr0, len0, cost_matrix.__wbg_ptr);
-    return FlowField.__wrap(ret);
+function multiroomFlowField(distance_map) {
+    _assertClass(distance_map, MultiroomDistanceMap);
+    var ptr0 = distance_map.__destroy_into_raw();
+    const ret = wasm.multiroomFlowField(ptr0);
+    return MultiroomFlowField.__wrap(ret);
 }
 
 /**
  * @param {Uint32Array} start_packed
  * @param {Function} get_cost_matrix
- * @param {number} max_tiles
+ * @param {number} max_ops
  * @param {number} max_rooms
- * @param {number} max_room_distance
- * @param {number} max_tile_distance
- * @returns {MultiroomMonoFlowField}
+ * @param {number} max_path_cost
+ * @param {Uint32Array | null} [any_of_destinations]
+ * @param {Uint32Array | null} [all_of_destinations]
+ * @returns {SearchResult}
  */
-function js_dijkstra_multiroom_mono_flow_field(start_packed, get_cost_matrix, max_tiles, max_rooms, max_room_distance, max_tile_distance) {
+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 {
         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);
+        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_dijkstra_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;
     }
 }
 
 /**
- * @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);
-}
-
-/**
- * WASM wrapper for the BFS flow field function.
- * @param {Uint32Array} start_packed
- * @param {ClockworkCostMatrix} cost_matrix
- * @returns {FlowField}
- */
-function js_bfs_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_flow_field(ptr0, len0, cost_matrix.__wbg_ptr);
-    return FlowField.__wrap(ret);
-}
-
-/**
- * @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);
-}
-
-/**
- * @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$1.__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);
-}
-/**
- * WASM wrapper for the BFS multiroom monodirectional flow field function.
+ * 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_tiles
+ * @param {number} max_ops
  * @param {number} max_rooms
- * @param {number} max_room_distance
- * @param {number} max_tile_distance
- * @returns {MultiroomMonoFlowField}
+ * @param {number} max_path_cost
+ * @param {Uint32Array | null} [any_of_destinations]
+ * @param {Uint32Array | null} [all_of_destinations]
+ * @returns {SearchResult}
  */
-function js_bfs_multiroom_mono_flow_field(start_packed, get_cost_matrix, max_tiles, max_rooms, max_room_distance, max_tile_distance) {
+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;
-        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);
+        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 SearchResult.__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}
  */
@@ -527,6 +390,29 @@ function get_range(packed_pos_1, packed_pos_2) {
     return ret >>> 0;
 }
 
+/**
+ * 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);
+}
+
+/**
+ * @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);
+}
+
 /**
  * Translates `COLOR_*` and `COLORS_ALL` constants.
  * @enum {1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10}
@@ -692,6 +578,14 @@ const ClockworkCostMatrixFinalization = (typeof FinalizationRegistry === 'undefi
  */
 class ClockworkCostMatrix {
 
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ClockworkCostMatrix.prototype);
+        obj.__wbg_ptr = ptr;
+        ClockworkCostMatrixFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -706,7 +600,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);
@@ -934,7 +828,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);
@@ -1170,7 +1064,7 @@ class MultiroomMonoFlowField {
      * Creates a new empty multiroom monodirectional flow field (JavaScript constructor)
      */
     constructor() {
-        const ret = wasm.multiroomdistancemap_js_new();
+        const ret = wasm.multiroommonoflowfield_js_new();
         this.__wbg_ptr = ret >>> 0;
         MultiroomMonoFlowFieldFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -1187,7 +1081,7 @@ class MultiroomMonoFlowField {
     /**
      * Sets the direction at a given position
      * @param {number} packed_pos
-     * @param {Direction | undefined} [direction]
+     * @param {Direction | null} [direction]
      */
     set(packed_pos, direction) {
         wasm.multiroommonoflowfield_set(this.__wbg_ptr, packed_pos, isLikeNone(direction) ? 0 : direction);
@@ -1226,11 +1120,11 @@ const PathFinalization = (typeof FinalizationRegistry === 'undefined')
 /**
  * A list of positions representing a path.
  */
-class Path$1 {
+class Path {
 
     static __wrap(ptr) {
         ptr = ptr >>> 0;
-        const obj = Object.create(Path$1.prototype);
+        const obj = Object.create(Path.prototype);
         obj.__wbg_ptr = ptr;
         PathFinalization.register(obj, obj.__wbg_ptr, obj);
         return obj;
@@ -1322,22 +1216,91 @@ class Path$1 {
     ? { 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}
+     */
+    get found_targets() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            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();
+            wasm.__wbindgen_free(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get ops() {
+        const ret = wasm.searchresult_ops(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
-    imports.wbg.__wbg_call_0411c0c3c424db9a = function() { return handleError(function (arg0, arg1, arg2) {
+    imports.wbg.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
+        const ret = getObject(arg0).buffer;
+        return addHeapObject(ret);
+    };
+    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_73d048b08f059b46 = function(arg0) {
+    imports.wbg.__wbg_ceil_2a411b0e70cc0baf = function(arg0) {
         const ret = Math.ceil(arg0);
         return ret;
     };
-    imports.wbg.__wbg_clockworkcostmatrixgetpointer_79ff2a01ab0022a6 = function(arg0) {
+    imports.wbg.__wbg_clockworkcostmatrixgetpointer_ac59edc2cad584d6 = function(arg0) {
         const ret = clockworkcostmatrix_get_pointer(takeObject(arg0));
         return ret;
     };
-    imports.wbg.__wbg_create_7616c10d022615b4 = function(arg0) {
+    imports.wbg.__wbg_create_cfe43ccc88c64e0a = function(arg0) {
         const ret = Object.create(getObject(arg0));
         return addHeapObject(ret);
     };
@@ -1352,6 +1315,10 @@ function __wbg_get_imports() {
             wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
         }
     };
+    imports.wbg.__wbg_getRawBuffer_063ad218fd3b8817 = function(arg0, arg1) {
+        const ret = getObject(arg0).getRawBuffer(getObject(arg1));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_getRoomTerrain_82fcc54e35a8985e = function() { return handleError(function (arg0) {
         const ret = Game.map.getRoomTerrain(getObject(arg0));
         return addHeapObject(ret);
@@ -1360,7 +1327,7 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).get(arg1, arg2);
         return ret;
     };
-    imports.wbg.__wbg_get_68aa371864aa301a = function(arg0, arg1) {
+    imports.wbg.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) {
         const ret = getObject(arg0)[arg1 >>> 0];
         return addHeapObject(ret);
     };
@@ -1368,11 +1335,11 @@ function __wbg_get_imports() {
         const ret = getObject(arg0)[getObject(arg1)];
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_length_e74df4881604f1d9 = function(arg0) {
+    imports.wbg.__wbg_length_e2d2a49132c1b256 = function(arg0) {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_log_e9cc7e18c0c70cf4 = function(arg0, arg1) {
+    imports.wbg.__wbg_log_223889c5580129ef = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_lookFor_04c5885fea38e9b2 = function() { return handleError(function (arg0, arg1) {
@@ -1383,6 +1350,14 @@ function __wbg_get_imports() {
         const ret = new Error();
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_newinternal_306f5ebf22959477 = function() { return handleError(function (arg0) {
+        const ret = new Room.Terrain(getObject(arg0));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a = function(arg0, arg1, arg2) {
+        const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_rooms_c7983d4650f28959 = function() {
         const ret = Game.rooms;
         return addHeapObject(ret);
@@ -1413,6 +1388,10 @@ function __wbg_get_imports() {
         const ret = getObject(arg0) === undefined;
         return ret;
     };
+    imports.wbg.__wbindgen_memory = function() {
+        const ret = wasm.memory;
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
         const obj = getObject(arg1);
         const ret = typeof(obj) === 'number' ? obj : undefined;
@@ -1481,6 +1460,46 @@ function initSync(module) {
     return __wbg_finalize_init(instance);
 }
 
+const cache = new Set();
+let cacheTick = 0;
+/**
+ * Mark an item as ephemeral. This means that the item will be freed after the
+ * current tick.
+ *
+ * If you don't use this to clean up your data, you'll need to call `free()`
+ * yourself.
+ *
+ * @param item - The item to be cleaned up.
+ * @returns The item.
+ */
+function ephemeral(item) {
+    if (cacheTick !== Game.time) {
+        for (const item of cache) {
+            try {
+                item.free();
+            }
+            catch (_a) {
+                // may have already been cleaned up
+            }
+        }
+        cache.clear();
+        cacheTick = Game.time;
+    }
+    cache.add(item);
+    return item;
+}
+/**
+ * Persist an ephemeral item. This means that the item will not be freed after
+ * the current tick.
+ *
+ * @param item - The item to be persisted.
+ * @returns The item.
+ */
+function persist(item) {
+    cache.delete(item);
+    return item;
+}
+
 const MAX_USIZE = 0xffffffff;
 
 function fromPacked(packedPos) {
@@ -1520,14 +1539,59 @@ function packRoomName(room) {
 }
 
 /**
- * A path from a start position to an end position. Typically returned by a
- * function like `pathToFlowFieldOrigin` rather than created directly.
+ * A flow field for a single room that stores multiple directions per tile.
  */
-class Path {
-    constructor(path) {
-        this.path = path;
-    }
-    /**
+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();
+    }
+}
+
+/**
+ * A path from a start position to an end position. Typically returned by a
+ * function like `pathToFlowFieldOrigin` rather than created directly.
+ */
+class ClockworkPath {
+    constructor(path) {
+        this.path = path;
+    }
+    /**
      * Iterate over the path.
      *
      * @example
@@ -1625,175 +1689,64 @@ class Path {
 }
 
 /**
- * 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.
+ * A flow field that spans multiple rooms, storing multiple directions per tile.
  */
-class ClockworkMultiroomDistanceMap {
-    constructor(_map) {
-        this._map = _map;
+class ClockworkMultiroomFlowField {
+    constructor(_flowField) {
+        this._flowField = _flowField;
     }
     /**
-     * Get the stored value for a given position.
+     * Get the flow field value at a given position.
      */
     get(pos) {
-        return this._map.get(pos.__packedPos);
+        return this._flowField.get(pos.__packedPos);
     }
     /**
-     * Set the stored value for a given position.
+     * Set the flow field value at 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();
+        this._flowField.set(pos.__packedPos, value);
     }
     /**
-     * Path to the origin from a given position.
+     * Get the list of valid directions at 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;
+    getDirections(pos) {
+        return this._flowField.getDirections(pos.__packedPos);
     }
     /**
-     * Get the internal value for a given coordinate.
+     * Set the list of valid directions at a given position.
      */
-    get(x, y) {
-        return this._flowField.get(x, y);
+    setDirections(pos, directions) {
+        this._flowField.setDirections(pos.__packedPos, directions);
     }
     /**
-     * Set the internal value for a given coordinate.
+     * Add a direction to the list of valid directions at a given position.
      */
-    set(x, y, value) {
-        this._flowField.set(x, y, value);
+    addDirection(pos, direction) {
+        this._flowField.addDirection(pos.__packedPos, direction);
     }
     /**
-     * Get the list of valid directions for a given coordinate.
+     * Get the list of rooms in the flow field.
      */
-    getDirections(x, y) {
-        return this._flowField.getDirections(x, y);
+    getRooms() {
+        const rooms = [];
+        for (const packedRoomName of this._flowField.getRooms()) {
+            rooms.push(fromPackedRoomName(packedRoomName));
+        }
+        return rooms;
     }
     /**
-     * Set the list of valid directions for a given coordinate.
+     * Get the flow field for a given room.
      */
-    setDirections(x, y, directions) {
-        this._flowField.setDirections(x, y, directions);
+    getRoom(roomName) {
+        const flowField = this._flowField.getRoom(packRoomName(roomName));
+        return flowField ? new ClockworkFlowField(flowField) : null;
     }
     /**
-     * Add a direction to the list of valid directions for a given coordinate.
+     * Find a path from a given position to the origin of the flow field.
      */
-    addDirection(x, y, direction) {
-        this._flowField.addDirection(x, y, direction);
+    pathToOrigin(start) {
+        return new ClockworkPath(js_path_to_multiroom_flow_field_origin(start.__packedPos, this._flowField));
     }
     /**
      * Free the memory allocated for this flow field.
@@ -1801,13 +1754,6 @@ class ClockworkFlowField {
     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));
-    }
 }
 
 /**
@@ -1835,51 +1781,27 @@ class ClockworkMonoFlowField {
     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));
-    }
 }
 
 /**
- * A flow field that spans multiple rooms, storing multiple directions per tile.
+ * A flow field that spans multiple rooms, storing a single direction per tile.
  */
-class ClockworkMultiroomFlowField {
+class ClockworkMultiroomMonoFlowField {
     constructor(_flowField) {
         this._flowField = _flowField;
     }
     /**
-     * Get the flow field value at a given position.
+     * Get the direction 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);
+        var _a;
+        return (_a = this._flowField.get(pos.__packedPos)) !== null && _a !== void 0 ? _a : null;
     }
     /**
-     * Add a direction to the list of valid directions at a given position.
+     * Set the direction at a given position.
      */
-    addDirection(pos, direction) {
-        this._flowField.addDirection(pos.__packedPos, direction);
+    set(pos, direction) {
+        this._flowField.set(pos.__packedPos, direction !== null && direction !== void 0 ? direction : undefined);
     }
     /**
      * Get the list of rooms in the flow field.
@@ -1896,13 +1818,13 @@ class ClockworkMultiroomFlowField {
      */
     getRoom(roomName) {
         const flowField = this._flowField.getRoom(packRoomName(roomName));
-        return flowField ? new ClockworkFlowField(flowField) : null;
+        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_flow_field_origin(start.__packedPos, this._flowField));
+        return new ClockworkPath(js_path_to_multiroom_mono_flow_field_origin(start.__packedPos, this._flowField));
     }
     /**
      * Free the memory allocated for this flow field.
@@ -1913,182 +1835,156 @@ class ClockworkMultiroomFlowField {
 }
 
 /**
- * A flow field that spans multiple rooms, storing a single direction per tile.
+ * A distance map that covers multiple rooms. Typically returned by a function
+ * like `bfsMultiroomDistanceMap` rather than created directly.
  */
-class ClockworkMultiroomMonoFlowField {
-    constructor(_flowField) {
-        this._flowField = _flowField;
+class ClockworkMultiroomDistanceMap {
+    constructor(_map) {
+        this._map = _map;
     }
     /**
-     * Get the direction at a given position.
+     * Get the stored value for a given position.
      */
     get(pos) {
-        var _a;
-        return (_a = this._flowField.get(pos.__packedPos)) !== null && _a !== void 0 ? _a : null;
+        return this._map.get(pos.__packedPos);
     }
     /**
-     * Set the direction at a given position.
+     * Set the stored value for a given position.
      */
-    set(pos, direction) {
-        this._flowField.set(pos.__packedPos, direction !== null && direction !== void 0 ? direction : undefined);
+    set(pos, value) {
+        this._map.set(pos.__packedPos, value);
     }
     /**
-     * Get the list of rooms in the flow field.
+     * 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() {
-        const rooms = [];
-        for (const packedRoomName of this._flowField.getRooms()) {
-            rooms.push(fromPackedRoomName(packedRoomName));
-        }
-        return rooms;
+        return [...this._map.get_rooms()].map(room => fromPackedRoomName(room));
     }
     /**
-     * Get the flow field for a given room.
+     * Free the memory allocated for this distance map.
      */
-    getRoom(roomName) {
-        const flowField = this._flowField.getRoom(packRoomName(roomName));
-        return flowField ? new ClockworkMonoFlowField(flowField) : null;
+    free() {
+        this._map.free();
     }
     /**
-     * Find a path from a given position to the origin of the flow field.
+     * Path to the origin from a given position.
      */
     pathToOrigin(start) {
-        return new Path(js_path_to_multiroom_mono_flow_field_origin(start.__packedPos, this._flowField));
+        return new ClockworkPath(js_path_to_multiroom_distance_map_origin(start.__packedPos, this._map));
     }
     /**
-     * Free the memory allocated for this flow field.
+     * Flow field for this distance map.
      */
-    free() {
-        this._flowField.free();
+    toFlowField() {
+        return new ClockworkMultiroomFlowField(multiroomFlowField(this._map));
+    }
+    /**
+     * Mono-directional flow field for this distance map.
+     */
+    toMonoFlowField() {
+        return new ClockworkMultiroomMonoFlowField(multiroomMonoFlowField(this._map));
     }
 }
 
-/**
- * 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
- * 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.
- *
- * @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.
- *
- * @param start - The starting positions.
- * @param costMatrix - The cost matrix to use for the flow field.
- * @returns The flow field.
- */
-function bfsMonoFlowField(start, costMatrix) {
-    const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
-    const result = js_bfs_mono_flow_field(startPacked, costMatrix);
-    return new ClockworkMonoFlowField(result);
+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
+    };
 }
+
 /**
- * Generate a multiroom flow field for a set of positions using a breadth-first search algorithm.
+ * 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.
  *
- * 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 calculates a distance map across multiple rooms, with a few configurable limits:
+ * - `maxOps`: The maximum number of pathfinding operations to perform.
+ * - `maxRooms`: The maximum number of rooms to explore.
+ * - `maxPathCost`: Don't explore tiles with a greater path cost than this.
  *
- * This might be useful for creeps with only MOVE parts and/or empty
- * CARRY parts, which don't generate fatigue.
+ * At least one of these limits must be set.
  *
  * @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.
+ * @param options - The options for the distance map.
+ * @returns A multi-room distance map.
  */
-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');
+function astarMultiroomDistanceMap(start, { costMatrixCallback, maxRooms = MAX_USIZE, maxOps = MAX_USIZE, maxPathCost = MAX_USIZE, anyOfDestinations, allOfDestinations }) {
+    if ([maxRooms, maxOps, maxPathCost].every(n => n === MAX_USIZE) && !anyOfDestinations && !allOfDestinations) {
+        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_bfs_multiroom_flow_field(startPacked, (packedRoomName) => {
-        const roomName = fromPackedRoomName(packedRoomName);
-        return costMatrixCallback(roomName);
-    }, maxTiles, maxRooms, maxRoomDistance, maxTileDistance);
-    return new ClockworkMultiroomFlowField(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);
 }
+
 /**
- * Generate a multiroom mono-directional flow field for a set of positions using a breadth-first search algorithm.
+ * 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.
  *
- * 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 calculates a distance map across multiple rooms, with a few configurable limits:
+ * - `maxOps`: The maximum number of pathfinding operations to perform.
+ * - `maxRooms`: The maximum number of rooms to explore.
+ * - `maxPathCost`: Don't explore tiles with a greater path cost than this.
  *
- * This might be useful for creeps with only MOVE parts and/or empty
- * CARRY parts, which don't generate fatigue.
+ * At least one of these limits must be set.
  *
  * @param start - The starting positions.
- * @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.
+ * @param options - The options for the distance map.
+ * @returns A multi-room distance map.
  */
-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');
+function bfsMultiroomDistanceMap(start, { costMatrixCallback, maxOps = MAX_USIZE, maxRooms = MAX_USIZE, maxPathCost = MAX_USIZE, anyOfDestinations, allOfDestinations }) {
+    if ([maxOps, maxRooms, maxPathCost].every(n => n === MAX_USIZE) && !anyOfDestinations && !allOfDestinations) {
+        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_mono_flow_field(startPacked, (packedRoomName) => {
-        const roomName = fromPackedRoomName(packedRoomName);
-        return costMatrixCallback(roomName);
-    }, maxTiles, maxRooms, maxRoomDistance, maxTileDistance);
-    return new ClockworkMultiroomMonoFlowField(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);
 }
 
-/**
- * Generate a [distance map](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html) 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.
- *
- * 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 dijkstraDistanceMap(start, costMatrix) {
-    const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
-    const result = js_dijkstra_distance_map(startPacked, costMatrix);
-    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.
+ * - `maxOps`: The maximum number of pathfinding operations to perform.
  * - `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.
+ * - `maxPathCost`: Don't explore tiles with a greater path cost than this.
  *
  * At least one of these limits must be set.
  *
@@ -2096,101 +1992,23 @@ function dijkstraDistanceMap(start, costMatrix) {
  * @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');
+function dijkstraMultiroomDistanceMap(start, { costMatrixCallback, maxOps = MAX_USIZE, maxRooms = MAX_USIZE, maxPathCost = MAX_USIZE, anyOfDestinations, allOfDestinations }) {
+    if ([maxOps, maxRooms, maxPathCost].every(n => n === MAX_USIZE) && !anyOfDestinations && !allOfDestinations) {
+        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)), maxTiles, maxRooms, maxRoomDistance, maxTileDistance);
-    return new ClockworkMultiroomDistanceMap(result);
-}
-
-/**
- * Generate a [flow field](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html) 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 costMatrix - The cost matrix to use for the flow field.
- * @returns The flow field.
- */
-function dijkstraFlowField(start, costMatrix) {
-    const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
-    const result = js_dijkstra_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 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.
- *
- * 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 dijkstraMonoFlowField(start, costMatrix) {
-    const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
-    const result = js_dijkstra_mono_flow_field(startPacked, costMatrix);
-    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);
+    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);
 }
 
 /**
@@ -2206,6 +2024,10 @@ function getRange(pos1, pos2) {
     return get_range(pos1.__packedPos, pos2.__packedPos);
 }
 
+function getTerrainCostMatrix(roomName, { plainCost, swampCost, wallCost } = {}) {
+    return get_terrain_cost_matrix(packRoomName(roomName), plainCost, swampCost, wallCost);
+}
+
 let wasm_bytes;
 let wasm_module;
 let wasm_instance;
@@ -2221,6 +2043,7 @@ let initialized = false;
 function initialize(verbose = false) {
     // need to freshly override the fake console object each tick
     console.error = console_error;
+    const start = Game.cpu.getUsed();
     if (!wasm_bytes)
         wasm_bytes = require('screeps_clockwork.wasm');
     if (verbose && !initialized)
@@ -2233,7 +2056,7 @@ function initialize(verbose = false) {
         wasm_instance = initSync({ module: wasm_module });
     if (verbose && !initialized) {
         console.log('[clockwork] wasm_instance loaded');
-        console.log(`[clockwork] version ${version()} initialized`);
+        console.log(`[clockwork] version ${version()} initialized with ${(Game.cpu.getUsed() - start).toFixed(2)} CPU`);
     }
     initialized = true;
 }
@@ -2264,22 +2087,16 @@ exports.ClockworkFlowField = ClockworkFlowField;
 exports.ClockworkMonoFlowField = ClockworkMonoFlowField;
 exports.ClockworkMultiroomFlowField = ClockworkMultiroomFlowField;
 exports.ClockworkMultiroomMonoFlowField = ClockworkMultiroomMonoFlowField;
+exports.ClockworkPath = ClockworkPath;
 exports.DistanceMap = DistanceMap;
 exports.FlowField = FlowField;
 exports.MonoFlowField = MonoFlowField;
-exports.Path = Path;
-exports.bfsDistanceMap = bfsDistanceMap;
-exports.bfsFlowField = bfsFlowField;
-exports.bfsMonoFlowField = bfsMonoFlowField;
+exports.astarMultiroomDistanceMap = astarMultiroomDistanceMap;
 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.ephemeral = ephemeral;
 exports.getRange = getRange;
+exports.getTerrainCostMatrix = getTerrainCostMatrix;
 exports.initialize = initialize;
+exports.persist = persist;
 //# sourceMappingURL=index.js.map