screeps-clockwork 0.10.0 → 0.12.0

package/dist/index.js

@@ -1074,10 +1074,6 @@ function version() {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg___wbindgen_is_null_2042690d351e14f0: function (arg0) {
-            const ret = getObject(arg0) === null;
-            return ret;
-        },
         __wbg___wbindgen_is_undefined_35bb9f4c7fd651d5: function (arg0) {
             const ret = getObject(arg0) === undefined;
             return ret;
@@ -1100,11 +1096,7 @@ function __wbg_get_imports() {
                 return addHeapObject(ret);
             }, arguments);
         },
-        __wbg_ceil_2f02237b685bdce4: function (arg0) {
-            const ret = Math.ceil(arg0);
-            return ret;
-        },
-        __wbg_clockworkcostmatrix_get_pointer_0e40dd616e7e32da: function (arg0) {
+        __wbg_clockworkcostmatrix_get_pointer_bb635b319c5f0508: function (arg0) {
             const ret = clockworkcostmatrix_get_pointer(takeObject(arg0));
             return ret;
         },
@@ -1128,37 +1120,6 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).getRawBuffer(getObject(arg1));
             return addHeapObject(ret);
         },
-        __wbg_getRoomTerrain_ff542df2ea2015b1: function () {
-            return handleError(function (arg0) {
-                const ret = Game.map.getRoomTerrain(getObject(arg0));
-                return addHeapObject(ret);
-            }, arguments);
-        },
-        __wbg_get_8f8e5734959cd5fc: function (arg0, arg1, arg2) {
-            const ret = getObject(arg0).get(arg1, arg2);
-            return ret;
-        },
-        __wbg_get_unchecked_1dfe6d05ad91d9b7: function (arg0, arg1) {
-            const ret = getObject(arg0)[arg1 >>> 0];
-            return addHeapObject(ret);
-        },
-        __wbg_get_value_3083233b2ad9f36e: function (arg0, arg1) {
-            const ret = getObject(arg0)[getObject(arg1)];
-            return addHeapObject(ret);
-        },
-        __wbg_length_2591a0f4f659a55c: function (arg0) {
-            const ret = getObject(arg0).length;
-            return ret;
-        },
-        __wbg_log_c012383707c9fbe6: function (arg0, arg1) {
-            console.log(getStringFromWasm0(arg0, arg1));
-        },
-        __wbg_lookFor_0ddc4d9f22e9bfe5: function () {
-            return handleError(function (arg0, arg1) {
-                const ret = getObject(arg0).lookFor(__wbindgen_enum_Look[arg1]);
-                return isLikeNone(ret) ? 0 : addHeapObject(ret);
-            }, arguments);
-        },
         __wbg_new_1f236d63ba0c4784: function (arg0, arg1) {
             const ret = new Error(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
@@ -1173,10 +1134,6 @@ function __wbg_get_imports() {
                 return addHeapObject(ret);
             }, arguments);
         },
-        __wbg_rooms_c5dbffde521939da: function () {
-            const ret = Game.rooms;
-            return addHeapObject(ret);
-        },
         __wbg_set_packed_cc769b1ab2aa7e8e: function (arg0, arg1) {
             getObject(arg0).__packedPos = arg1 >>> 0;
         },
@@ -1191,10 +1148,6 @@ function __wbg_get_imports() {
             const ret = RoomPosition.prototype;
             return addHeapObject(ret);
         },
-        __wbg_structure_type_dbc211ed19dd8423: function (arg0) {
-            const ret = getObject(arg0).structureType;
-            return (__wbindgen_enum_StructureType.indexOf(ret) + 1 || 22) - 1;
-        },
         __wbindgen_cast_0000000000000001: function (arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
@@ -1219,8 +1172,6 @@ function __wbg_get_imports() {
         "./screeps_clockwork_bg.js": import0,
     };
 }
-const __wbindgen_enum_Look = ["creep", "energy", "resource", "source", "mineral", "structure", "flag", "constructionSite", "nuke", "terrain", "tombstone", "powerCreep", "deposit", "ruin", "scoreContainer", "scoreCollector", "symbolContainer", "symbolDecoder", "reactor"];
-const __wbindgen_enum_StructureType = ["spawn", "extension", "road", "constructedWall", "rampart", "keeperLair", "portal", "controller", "link", "storage", "tower", "observer", "powerBank", "powerSpawn", "extractor", "lab", "terminal", "container", "nuker", "factory", "invaderCore"];
 const ClockworkCostMatrixFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => { }, unregister: () => { } }
     : new FinalizationRegistry(ptr => wasm.__wbg_clockworkcostmatrix_free(ptr, 1));
@@ -1245,9 +1196,6 @@ const MultiroomMonoFlowFieldFinalization = (typeof FinalizationRegistry === 'und
 const PathFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => { }, unregister: () => { } }
     : new FinalizationRegistry(ptr => wasm.__wbg_path_free(ptr, 1));
-(typeof FinalizationRegistry === 'undefined')
-    ? { register: () => { }, unregister: () => { } }
-    : new FinalizationRegistry(ptr => wasm.__wbg_pathfatigue_free(ptr, 1));
 (typeof FinalizationRegistry === 'undefined')
     ? { register: () => { }, unregister: () => { } }
     : new FinalizationRegistry(ptr => wasm.__wbg_searchgoal_free(ptr, 1));
@@ -1472,6 +1420,15 @@ function fromPackedRoomName(packedRoomName) {
     const result = (x_coord >= 0 ? `E${x_coord}` : `W${~x_coord}`) + (y_coord >= 0 ? `S${y_coord}` : `N${~y_coord}`);
     return result;
 }
+const roomNameCache = new Map();
+function fromPackedRoomNameCached(packedRoomName) {
+    let roomName = roomNameCache.get(packedRoomName);
+    if (roomName === undefined) {
+        roomName = fromPackedRoomName(packedRoomName);
+        roomNameCache.set(packedRoomName, roomName);
+    }
+    return roomName;
+}
 function packRoomName(room) {
     // Handle sim room case
     if (room === 'sim') {
@@ -1492,30 +1449,67 @@ function packRoomName(room) {
     return (x << 8) | y;
 }
 
+function packPositions(positions) {
+    const packed = new Uint32Array(positions.length);
+    for (let i = 0; i < positions.length; i++) {
+        packed[i] = positions[i].__packedPos;
+    }
+    return packed;
+}
+function packDestinations(destinations) {
+    if (!destinations) {
+        return undefined;
+    }
+    const packed = new Uint32Array(destinations.length * 2);
+    for (let i = 0; i < destinations.length; i++) {
+        const offset = i * 2;
+        packed[offset] = destinations[i].pos.__packedPos;
+        packed[offset + 1] = destinations[i].range;
+    }
+    return packed;
+}
+
+function assertNotFreed(handle, label) {
+    if (!handle) {
+        throw new Error(`${label} has been freed`);
+    }
+    return handle;
+}
+function freeHandle(handle) {
+    handle === null || handle === void 0 ? void 0 : handle.free();
+    return undefined;
+}
+
 /**
  * A distance map for a single room.
  */
 class ClockworkDistanceMap {
-    constructor(_map) {
-        this._map = _map;
+    constructor(map) {
+        this._map = map;
+    }
+    /**
+     * Frees the underlying WASM distance map allocation.
+     */
+    free() {
+        this._map = freeHandle(this._map);
     }
     /**
      * Gets the distance value at a given position.
      */
     get(x, y) {
-        return this._map.get(x, y);
+        return assertNotFreed(this._map, 'ClockworkDistanceMap').get(x, y);
     }
     /**
      * Sets the distance value at a given position.
      */
     set(x, y, value) {
-        this._map.set(x, y, value);
+        assertNotFreed(this._map, 'ClockworkDistanceMap').set(x, y, value);
     }
     /**
      * Converts the distance map into a flat array of distances.
      */
     toArray() {
-        return this._map.toArray();
+        return assertNotFreed(this._map, 'ClockworkDistanceMap').toArray();
     }
 }
 
@@ -1523,38 +1517,44 @@ class ClockworkDistanceMap {
  * A flow field for a single room that stores multiple directions per tile.
  */
 class ClockworkFlowField {
-    constructor(_flowField) {
-        this._flowField = _flowField;
+    constructor(flowField) {
+        this._flowField = flowField;
+    }
+    /**
+     * Frees the underlying WASM flow field allocation.
+     */
+    free() {
+        this._flowField = freeHandle(this._flowField);
     }
     /**
      * Get the internal value for a given coordinate.
      */
     get(x, y) {
-        return this._flowField.get(x, y);
+        return assertNotFreed(this._flowField, 'ClockworkFlowField').get(x, y);
     }
     /**
      * Set the internal value for a given coordinate.
      */
     set(x, y, value) {
-        this._flowField.set(x, y, value);
+        assertNotFreed(this._flowField, 'ClockworkFlowField').set(x, y, value);
     }
     /**
      * Get the list of valid directions for a given coordinate.
      */
     getDirections(x, y) {
-        return this._flowField.getDirections(x, y);
+        return assertNotFreed(this._flowField, 'ClockworkFlowField').getDirections(x, y);
     }
     /**
      * Set the list of valid directions for a given coordinate.
      */
     setDirections(x, y, directions) {
-        this._flowField.setDirections(x, y, directions);
+        assertNotFreed(this._flowField, 'ClockworkFlowField').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);
+        assertNotFreed(this._flowField, 'ClockworkFlowField').addDirection(x, y, direction);
     }
 }
 
@@ -1566,6 +1566,12 @@ class ClockworkPath {
     constructor(path) {
         this.path = path;
     }
+    /**
+     * Frees the underlying WASM path allocation.
+     */
+    free() {
+        this.path = freeHandle(this.path);
+    }
     /**
      * Iterate over the path.
      *
@@ -1617,7 +1623,7 @@ class ClockworkPath {
      * Get the position at a given index.
      */
     get(index) {
-        const packedPos = this.path.get(index);
+        const packedPos = assertNotFreed(this.path, 'ClockworkPath').get(index);
         if (packedPos === undefined) {
             throw new Error('Index out of bounds');
         }
@@ -1627,20 +1633,20 @@ class ClockworkPath {
      * Get the length of the path.
      */
     get length() {
-        return this.path.len();
+        return assertNotFreed(this.path, 'ClockworkPath').len();
     }
     /**
      * Given a current position, find the index of the next position in the path.
      */
     findNextIndex(pos) {
-        return this.path.find_next_index(pos.__packedPos);
+        return assertNotFreed(this.path, 'ClockworkPath').find_next_index(pos.__packedPos);
     }
     /**
      * Convert the path to an array of positions.
      */
     toArray() {
         const result = [];
-        for (const packedPos of this.path.to_array()) {
+        for (const packedPos of assertNotFreed(this.path, 'ClockworkPath').to_array()) {
             result.push(fromPacked(packedPos));
         }
         return result;
@@ -1650,7 +1656,7 @@ class ClockworkPath {
      */
     toArrayReversed() {
         const result = [];
-        for (const packedPos of this.path.to_array_reversed()) {
+        for (const packedPos of assertNotFreed(this.path, 'ClockworkPath').to_array_reversed()) {
             result.push(fromPacked(packedPos));
         }
         return result;
@@ -1661,45 +1667,51 @@ class ClockworkPath {
  * A flow field that spans multiple rooms, storing multiple directions per tile.
  */
 class ClockworkMultiroomFlowField {
-    constructor(_flowField) {
-        this._flowField = _flowField;
+    constructor(flowField) {
+        this._flowField = flowField;
+    }
+    /**
+     * Frees the underlying WASM multiroom flow field allocation.
+     */
+    free() {
+        this._flowField = freeHandle(this._flowField);
     }
     /**
      * Get the flow field value at a given position.
      */
     get(pos) {
-        return this._flowField.get(pos.__packedPos);
+        return assertNotFreed(this._flowField, 'ClockworkMultiroomFlowField').get(pos.__packedPos);
     }
     /**
      * Set the flow field value at a given position.
      */
     set(pos, value) {
-        this._flowField.set(pos.__packedPos, value);
+        assertNotFreed(this._flowField, 'ClockworkMultiroomFlowField').set(pos.__packedPos, value);
     }
     /**
      * Get the list of valid directions at a given position.
      */
     getDirections(pos) {
-        return this._flowField.getDirections(pos.__packedPos);
+        return assertNotFreed(this._flowField, 'ClockworkMultiroomFlowField').getDirections(pos.__packedPos);
     }
     /**
      * Set the list of valid directions at a given position.
      */
     setDirections(pos, directions) {
-        this._flowField.setDirections(pos.__packedPos, directions);
+        assertNotFreed(this._flowField, 'ClockworkMultiroomFlowField').setDirections(pos.__packedPos, directions);
     }
     /**
      * Add a direction to the list of valid directions at a given position.
      */
     addDirection(pos, direction) {
-        this._flowField.addDirection(pos.__packedPos, direction);
+        assertNotFreed(this._flowField, 'ClockworkMultiroomFlowField').addDirection(pos.__packedPos, direction);
     }
     /**
      * Get the list of rooms in the flow field.
      */
     getRooms() {
         const rooms = [];
-        for (const packedRoomName of this._flowField.getRooms()) {
+        for (const packedRoomName of assertNotFreed(this._flowField, 'ClockworkMultiroomFlowField').getRooms()) {
             rooms.push(fromPackedRoomName(packedRoomName));
         }
         return rooms;
@@ -1708,14 +1720,14 @@ class ClockworkMultiroomFlowField {
      * Get the flow field for a given room.
      */
     getRoom(roomName) {
-        const flowField = this._flowField.getRoom(packRoomName(roomName));
+        const flowField = assertNotFreed(this._flowField, 'ClockworkMultiroomFlowField').getRoom(packRoomName(roomName));
         return flowField ? new ClockworkFlowField(flowField) : null;
     }
     /**
      * Find a path from a given position to the origin of the flow field.
      */
     pathToOrigin(start) {
-        return new ClockworkPath(js_path_to_multiroom_flow_field_origin(start.__packedPos, this._flowField));
+        return new ClockworkPath(js_path_to_multiroom_flow_field_origin(start.__packedPos, assertNotFreed(this._flowField, 'ClockworkMultiroomFlowField')));
     }
 }
 
@@ -1723,20 +1735,26 @@ class ClockworkMultiroomFlowField {
  * A flow field for a single room that stores one direction per tile.
  */
 class ClockworkMonoFlowField {
-    constructor(_flowField) {
-        this._flowField = _flowField;
+    constructor(flowField) {
+        this._flowField = flowField;
+    }
+    /**
+     * Frees the underlying WASM flow field allocation.
+     */
+    free() {
+        this._flowField = freeHandle(this._flowField);
     }
     /**
      * Get the direction for a given coordinate.
      */
     get(x, y) {
-        return this._flowField.get(x, y);
+        return assertNotFreed(this._flowField, 'ClockworkMonoFlowField').get(x, y);
     }
     /**
      * Set the direction for a given coordinate.
      */
     set(x, y, value) {
-        this._flowField.set(x, y, value);
+        assertNotFreed(this._flowField, 'ClockworkMonoFlowField').set(x, y, value);
     }
 }
 
@@ -1744,28 +1762,34 @@ class ClockworkMonoFlowField {
  * A flow field that spans multiple rooms, storing a single direction per tile.
  */
 class ClockworkMultiroomMonoFlowField {
-    constructor(_flowField) {
-        this._flowField = _flowField;
+    constructor(flowField) {
+        this._flowField = flowField;
+    }
+    /**
+     * Frees the underlying WASM multiroom flow field allocation.
+     */
+    free() {
+        this._flowField = freeHandle(this._flowField);
     }
     /**
      * Get the direction at a given position.
      */
     get(pos) {
         var _a;
-        return (_a = this._flowField.get(pos.__packedPos)) !== null && _a !== void 0 ? _a : null;
+        return (_a = assertNotFreed(this._flowField, 'ClockworkMultiroomMonoFlowField').get(pos.__packedPos)) !== null && _a !== void 0 ? _a : null;
     }
     /**
      * Set the direction at a given position.
      */
     set(pos, direction) {
-        this._flowField.set(pos.__packedPos, direction !== null && direction !== void 0 ? direction : undefined);
+        assertNotFreed(this._flowField, 'ClockworkMultiroomMonoFlowField').set(pos.__packedPos, direction !== null && direction !== void 0 ? direction : undefined);
     }
     /**
      * Get the list of rooms in the flow field.
      */
     getRooms() {
         const rooms = [];
-        for (const packedRoomName of this._flowField.getRooms()) {
+        for (const packedRoomName of assertNotFreed(this._flowField, 'ClockworkMultiroomMonoFlowField').getRooms()) {
             rooms.push(fromPackedRoomName(packedRoomName));
         }
         return rooms;
@@ -1774,14 +1798,14 @@ class ClockworkMultiroomMonoFlowField {
      * Get the flow field for a given room.
      */
     getRoom(roomName) {
-        const flowField = this._flowField.getRoom(packRoomName(roomName));
+        const flowField = assertNotFreed(this._flowField, 'ClockworkMultiroomMonoFlowField').getRoom(packRoomName(roomName));
         return flowField ? new ClockworkMonoFlowField(flowField) : null;
     }
     /**
      * Find a path from a given position to the origin of the flow field.
      */
     pathToOrigin(start) {
-        return new ClockworkPath(js_path_to_multiroom_mono_flow_field_origin(start.__packedPos, this._flowField));
+        return new ClockworkPath(js_path_to_multiroom_mono_flow_field_origin(start.__packedPos, assertNotFreed(this._flowField, 'ClockworkMultiroomMonoFlowField')));
     }
 }
 
@@ -1791,33 +1815,39 @@ const DEFAULT_DIRECTION_ORDER = DirectionOrder.CardinalFirst;
  * like `bfsMultiroomDistanceMap` rather than created directly.
  */
 class ClockworkMultiroomDistanceMap {
-    constructor(_map) {
-        this._map = _map;
+    constructor(map) {
+        this._map = map;
+    }
+    /**
+     * Frees the underlying WASM multiroom distance map allocation.
+     */
+    free() {
+        this._map = freeHandle(this._map);
     }
     /**
      * Get the stored value for a given position.
      */
     get(pos) {
-        return this._map.get(pos.__packedPos);
+        return assertNotFreed(this._map, 'ClockworkMultiroomDistanceMap').get(pos.__packedPos);
     }
     /**
      * Set the stored value for a given position.
      */
     set(pos, value) {
-        this._map.set(pos.__packedPos, value);
+        assertNotFreed(this._map, 'ClockworkMultiroomDistanceMap').set(pos.__packedPos, value);
     }
     /**
      * Get the DistanceMap for a given room.
      */
     getRoom(room) {
-        const map = this._map.get_room(packRoomName(room));
+        const map = assertNotFreed(this._map, 'ClockworkMultiroomDistanceMap').get_room(packRoomName(room));
         return map ? new ClockworkDistanceMap(map) : undefined;
     }
     /**
      * List all the rooms covered by this distance map.
      */
     getRooms() {
-        return [...this._map.get_rooms()].map(room => fromPackedRoomName(room));
+        return [...assertNotFreed(this._map, 'ClockworkMultiroomDistanceMap').get_rooms()].map(room => fromPackedRoomName(room));
     }
     /**
      * Path to the origin from a given position.
@@ -1825,7 +1855,7 @@ class ClockworkMultiroomDistanceMap {
      */
     pathToOrigin(start, options = {}) {
         var _a;
-        return new ClockworkPath(js_path_to_multiroom_distance_map_origin(start.__packedPos, this._map, (_a = options.directionOrder) !== null && _a !== void 0 ? _a : DEFAULT_DIRECTION_ORDER));
+        return new ClockworkPath(js_path_to_multiroom_distance_map_origin(start.__packedPos, assertNotFreed(this._map, 'ClockworkMultiroomDistanceMap'), (_a = options.directionOrder) !== null && _a !== void 0 ? _a : DEFAULT_DIRECTION_ORDER));
     }
     /**
      * Flow field for this distance map.
@@ -1833,7 +1863,7 @@ class ClockworkMultiroomDistanceMap {
      */
     toFlowField(options = {}) {
         var _a;
-        return new ClockworkMultiroomFlowField(multiroomFlowField(this._map, (_a = options.directionOrder) !== null && _a !== void 0 ? _a : DEFAULT_DIRECTION_ORDER));
+        return new ClockworkMultiroomFlowField(multiroomFlowField(assertNotFreed(this._map, 'ClockworkMultiroomDistanceMap'), (_a = options.directionOrder) !== null && _a !== void 0 ? _a : DEFAULT_DIRECTION_ORDER));
     }
     /**
      * Mono-directional flow field for this distance map.
@@ -1841,22 +1871,27 @@ class ClockworkMultiroomDistanceMap {
      */
     toMonoFlowField(options = {}) {
         var _a;
-        return new ClockworkMultiroomMonoFlowField(multiroomMonoFlowField(this._map, (_a = options.directionOrder) !== null && _a !== void 0 ? _a : DEFAULT_DIRECTION_ORDER));
+        return new ClockworkMultiroomMonoFlowField(multiroomMonoFlowField(assertNotFreed(this._map, 'ClockworkMultiroomDistanceMap'), (_a = options.directionOrder) !== null && _a !== void 0 ? _a : DEFAULT_DIRECTION_ORDER));
     }
 }
 
 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;
-    return {
-        distanceMap,
-        foundTargets,
-        ops
-    };
+    try {
+        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;
+        return {
+            distanceMap,
+            foundTargets,
+            ops
+        };
+    }
+    finally {
+        result.free();
+    }
 }
 
 /**
@@ -1879,18 +1914,8 @@ function astarMultiroomDistanceMap(start, { costMatrixCallback, maxRooms = MAX_U
     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_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);
+    const startPacked = packPositions(start);
+    const result = js_astar_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomNameCached(room)), maxRooms, maxOps, maxPathCost, packDestinations(anyOfDestinations), packDestinations(allOfDestinations));
     return fromPackedSearchResult(result);
 }
 
@@ -1914,18 +1939,8 @@ function bfsMultiroomDistanceMap(start, { costMatrixCallback, maxOps = MAX_USIZE
     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_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);
+    const startPacked = packPositions(start);
+    const result = js_bfs_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomNameCached(room)), maxOps, maxRooms, maxPathCost, packDestinations(anyOfDestinations), packDestinations(allOfDestinations));
     return fromPackedSearchResult(result);
 }
 
@@ -1948,18 +1963,8 @@ function dijkstraMultiroomDistanceMap(start, { costMatrixCallback, maxOps = MAX_
     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)), 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);
+    const startPacked = packPositions(start);
+    const result = js_dijkstra_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomNameCached(room)), maxOps, maxRooms, maxPathCost, packDestinations(anyOfDestinations), packDestinations(allOfDestinations));
     return fromPackedSearchResult(result);
 }
 
@@ -2019,8 +2024,8 @@ function initialize(verbose = false) {
 // information that wasm_bindgen only passes here.
 //
 // There is nothing special about this function and it may also be used by any JS/Rust code as a convenience.
-function console_error() {
-    const processedArgs = Array.from(arguments)
+function console_error(...args) {
+    const processedArgs = args
         .map(arg => {
         if (arg instanceof Error) {
             // On this version of Node, the `stack` property of errors contains