screeps-clockwork 0.11.0 → 0.13.0

package/dist/index.js

@@ -852,6 +852,16 @@ Object.freeze({
     Wall: 1, "1": "Wall",
     Swamp: 2, "2": "Swamp",
 });
+function clear_portals() {
+    wasm.clear_portals();
+}
+/**
+ * @returns {any}
+ */
+function debug_portal_index() {
+    const ret = wasm.debug_portal_index();
+    return takeObject(ret);
+}
 /**
  * Exports the global range calculation between two positions.
  * @param {number} packed_pos_1
@@ -898,6 +908,31 @@ function js_astar_multiroom_distance_map(start_packed, get_cost_matrix, max_room
         heap[stack_pointer++] = undefined;
     }
 }
+/**
+ * @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_portal_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_portal_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;
+    }
+}
 /**
  * WASM wrapper for the BFS multiroom distance map function.
  *
@@ -937,6 +972,31 @@ function js_bfs_multiroom_distance_map(start_packed, get_cost_matrix, max_ops, m
         heap[stack_pointer++] = undefined;
     }
 }
+/**
+ * @param {Uint32Array} start_packed
+ * @param {Function} get_cost_matrix
+ * @param {number} max_ops
+ * @param {number} max_rooms
+ * @param {number} max_path_cost
+ * @param {Uint32Array | null} [any_of_destinations]
+ * @param {Uint32Array | null} [all_of_destinations]
+ * @returns {SearchResult}
+ */
+function js_bfs_portal_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_portal_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 {Uint32Array} start_packed
  * @param {Function} get_cost_matrix
@@ -962,6 +1022,31 @@ function js_dijkstra_multiroom_distance_map(start_packed, get_cost_matrix, max_o
         heap[stack_pointer++] = undefined;
     }
 }
+/**
+ * @param {Uint32Array} start_packed
+ * @param {Function} get_cost_matrix
+ * @param {number} max_ops
+ * @param {number} max_rooms
+ * @param {number} max_path_cost
+ * @param {Uint32Array | null} [any_of_destinations]
+ * @param {Uint32Array | null} [all_of_destinations]
+ * @returns {SearchResult}
+ */
+function js_dijkstra_portal_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_dijkstra_portal_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
@@ -985,6 +1070,29 @@ function js_path_to_multiroom_distance_map_origin(start, distance_map, direction
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
+/**
+ * @param {number} start
+ * @param {MultiroomDistanceMap} distance_map
+ * @param {DirectionOrder} direction_order
+ * @returns {Path}
+ */
+function js_path_to_multiroom_distance_map_origin_with_portals(start, distance_map, direction_order) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        _assertClass(distance_map, MultiroomDistanceMap);
+        wasm.js_path_to_multiroom_distance_map_origin_with_portals(retptr, start, distance_map.__wbg_ptr, direction_order);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return Path.__wrap(r0);
+    }
+    finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
 /**
  * @param {number} start
  * @param {MultiroomFlowField} flow_field
@@ -1007,6 +1115,28 @@ function js_path_to_multiroom_flow_field_origin(start, flow_field) {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
+/**
+ * @param {number} start
+ * @param {MultiroomFlowField} flow_field
+ * @returns {Path}
+ */
+function js_path_to_multiroom_flow_field_origin_with_portals(start, flow_field) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        _assertClass(flow_field, MultiroomFlowField);
+        wasm.js_path_to_multiroom_flow_field_origin_with_portals(retptr, start, flow_field.__wbg_ptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return Path.__wrap(r0);
+    }
+    finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
 /**
  * @param {number} start
  * @param {MultiroomMonoFlowField} flow_field
@@ -1029,6 +1159,28 @@ function js_path_to_multiroom_mono_flow_field_origin(start, flow_field) {
         wasm.__wbindgen_add_to_stack_pointer(16);
     }
 }
+/**
+ * @param {number} start
+ * @param {MultiroomMonoFlowField} flow_field
+ * @returns {Path}
+ */
+function js_path_to_multiroom_mono_flow_field_origin_with_portals(start, flow_field) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        _assertClass(flow_field, MultiroomMonoFlowField);
+        wasm.js_path_to_multiroom_mono_flow_field_origin_with_portals(retptr, start, flow_field.__wbg_ptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return Path.__wrap(r0);
+    }
+    finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
 /**
  * Creates a flow field for the given distance map.
  * @param {MultiroomDistanceMap} distance_map
@@ -1051,6 +1203,40 @@ function multiroomMonoFlowField(distance_map, direction_order) {
     const ret = wasm.multiroomMonoFlowField(distance_map.__wbg_ptr, direction_order);
     return MultiroomMonoFlowField.__wrap(ret);
 }
+/**
+ * @param {MultiroomDistanceMap} distance_map
+ * @param {DirectionOrder} direction_order
+ * @returns {MultiroomFlowField}
+ */
+function multiroomPortalFlowField(distance_map, direction_order) {
+    _assertClass(distance_map, MultiroomDistanceMap);
+    const ret = wasm.multiroomPortalFlowField(distance_map.__wbg_ptr, direction_order);
+    return MultiroomFlowField.__wrap(ret);
+}
+/**
+ * @param {MultiroomDistanceMap} distance_map
+ * @param {DirectionOrder} direction_order
+ * @returns {MultiroomMonoFlowField}
+ */
+function multiroomPortalMonoFlowField(distance_map, direction_order) {
+    _assertClass(distance_map, MultiroomDistanceMap);
+    const ret = wasm.multiroomPortalMonoFlowField(distance_map.__wbg_ptr, direction_order);
+    return MultiroomMonoFlowField.__wrap(ret);
+}
+/**
+ * @param {number} room_limit
+ */
+function set_portal_distance_cache_room_limit(room_limit) {
+    wasm.set_portal_distance_cache_room_limit(room_limit);
+}
+/**
+ * @param {Uint32Array} packed_pairs
+ */
+function set_portals(packed_pairs) {
+    const ptr0 = passArray32ToWasm0(packed_pairs, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.set_portals(ptr0, len0);
+}
 /**
  * @returns {string}
  */
@@ -1074,9 +1260,12 @@ 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_debug_string_edece8177ad01481: function (arg0, arg1) {
+            const ret = debugString(getObject(arg1));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
         __wbg___wbindgen_is_undefined_35bb9f4c7fd651d5: function (arg0) {
             const ret = getObject(arg0) === undefined;
@@ -1100,11 +1289,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_c0709a574ef183e2: function (arg0) {
+        __wbg_clockworkcostmatrix_get_pointer_20f0153b006cac1d: function (arg0) {
             const ret = clockworkcostmatrix_get_pointer(takeObject(arg0));
             return ret;
         },
@@ -1128,37 +1313,10 @@ 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)];
+        __wbg_new_02d162bc6cf02f60: function () {
+            const ret = new Object();
             return addHeapObject(ret);
         },
-        __wbg_length_2591a0f4f659a55c: function (arg0) {
-            const ret = getObject(arg0).length;
-            return ret;
-        },
-        __wbg_log_525543f2526b398f: 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,9 +1331,11 @@ function __wbg_get_imports() {
                 return addHeapObject(ret);
             }, arguments);
         },
-        __wbg_rooms_c5dbffde521939da: function () {
-            const ret = Game.rooms;
-            return addHeapObject(ret);
+        __wbg_set_a0e911be3da02782: function () {
+            return handleError(function (arg0, arg1, arg2) {
+                const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+                return ret;
+            }, arguments);
         },
         __wbg_set_packed_cc769b1ab2aa7e8e: function (arg0, arg1) {
             getObject(arg0).__packedPos = arg1 >>> 0;
@@ -1191,10 +1351,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 +1375,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 +1399,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));
@@ -1273,6 +1424,74 @@ function addBorrowedObject(obj) {
     heap[--stack_pointer] = obj;
     return stack_pointer;
 }
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        }
+        else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        }
+        else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for (let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    }
+    else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        }
+        catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
 function dropObject(idx) {
     if (idx < 1028)
         return;
@@ -1451,6 +1670,35 @@ function initSync(module) {
     return __wbg_finalize_init(instance);
 }
 
+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 packPortalPairs(portals) {
+    const packed = new Uint32Array(portals.length * 2);
+    for (let i = 0; i < portals.length; i++) {
+        const offset = i * 2;
+        packed[offset] = portals[i][0].__packedPos;
+        packed[offset + 1] = portals[i][1].__packedPos;
+    }
+    return packed;
+}
+
 const MAX_USIZE = 0xffffffff;
 
 function fromPacked(packedPos) {
@@ -1472,6 +1720,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 +1749,47 @@ function packRoomName(room) {
     return (x << 8) | y;
 }
 
+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 +1797,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 +1846,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 +1903,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 +1913,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 +1936,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 +1947,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 +2000,20 @@ 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')));
+    }
+    /**
+     * Find a portal-aware path from a given position to the origin of the flow field.
+     */
+    pathToOriginWithPortals(start) {
+        return new ClockworkPath(js_path_to_multiroom_flow_field_origin_with_portals(start.__packedPos, assertNotFreed(this._flowField, 'ClockworkMultiroomFlowField')));
     }
 }
 
@@ -1723,20 +2021,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 +2048,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 +2084,20 @@ 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')));
+    }
+    /**
+     * Find a portal-aware path from a given position to the origin of the flow field.
+     */
+    pathToOriginWithPortals(start) {
+        return new ClockworkPath(js_path_to_multiroom_mono_flow_field_origin_with_portals(start.__packedPos, assertNotFreed(this._flowField, 'ClockworkMultiroomMonoFlowField')));
     }
 }
 
@@ -1791,33 +2107,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 +2147,15 @@ 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));
+    }
+    /**
+     * Portal-aware path to the origin from a given position.
+     * Pass `DirectionOrder.DiagonalFirst` to prefer diagonal steps when multiple neighbors are equally close.
+     */
+    pathToOriginWithPortals(start, options = {}) {
+        var _a;
+        return new ClockworkPath(js_path_to_multiroom_distance_map_origin_with_portals(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 +2163,15 @@ 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));
+    }
+    /**
+     * Portal-aware flow field for this distance map.
+     * Pass `DirectionOrder.DiagonalFirst` to prefer diagonal directions when multiple neighbors are equally close.
+     */
+    toFlowFieldWithPortals(options = {}) {
+        var _a;
+        return new ClockworkMultiroomFlowField(multiroomPortalFlowField(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 +2179,35 @@ 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));
+    }
+    /**
+     * Portal-aware monodirectional flow field for this distance map.
+     * Pass `DirectionOrder.DiagonalFirst` to prefer diagonal directions when multiple neighbors are equally close.
+     */
+    toMonoFlowFieldWithPortals(options = {}) {
+        var _a;
+        return new ClockworkMultiroomMonoFlowField(multiroomPortalMonoFlowField(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 +2230,34 @@ 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);
+}
+/**
+ * Create a portal-aware distance map for the given start positions, using A* to
+ * optimize the search toward the given destinations.
+ *
+ * Portals configured with `initialize({ portals })` or `setPortals` are treated
+ * like exits: stepping onto a portal entrance lands on its paired exit.
+ *
+ * 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.
+ *
+ * At least one of these limits or destination lists must be set.
+ *
+ * @param start - The starting positions.
+ * @param options - The options for the distance map.
+ * @returns A multi-room distance map.
+ */
+function astarPortalMultiroomDistanceMap(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 = packPositions(start);
+    const result = js_astar_portal_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomNameCached(room)), maxRooms, maxOps, maxPathCost, packDestinations(anyOfDestinations), packDestinations(allOfDestinations));
     return fromPackedSearchResult(result);
 }
 
@@ -1912,20 +2279,37 @@ function astarMultiroomDistanceMap(start, { costMatrixCallback, maxRooms = MAX_U
  */
 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');
+        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_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);
+}
+/**
+ * Create a portal-aware 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.
+ *
+ * Portals configured with `initialize({ portals })` or `setPortals` are treated
+ * like exits: stepping onto a portal entrance lands on its paired exit.
+ *
+ * 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.
+ *
+ * At least one of these limits or destination lists must be set.
+ *
+ * @param start - The starting positions.
+ * @param options - The options for the distance map.
+ * @returns A multi-room distance map.
+ */
+function bfsPortalMultiroomDistanceMap(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 = packPositions(start);
+    const result = js_bfs_portal_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomNameCached(room)), maxOps, maxRooms, maxPathCost, packDestinations(anyOfDestinations), packDestinations(allOfDestinations));
     return fromPackedSearchResult(result);
 }
 
@@ -1948,18 +2332,34 @@ 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);
+}
+/**
+ * Create a portal-aware distance map for the given start positions, using Dijkstra's
+ * algorithm to factor in terrain costs (0-255, where 255 is impassable).
+ *
+ * Portals configured with `initialize({ portals })` or `setPortals` are treated
+ * like exits: stepping onto a portal entrance lands on its paired exit.
+ *
+ * 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.
+ *
+ * At least one of these limits or destination lists must be set.
+ *
+ * @param start - The starting positions.
+ * @param options - The options for the distance map.
+ * @returns A multi-room distance map.
+ */
+function dijkstraPortalMultiroomDistanceMap(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 = packPositions(start);
+    const result = js_dijkstra_portal_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomNameCached(room)), maxOps, maxRooms, maxPathCost, packDestinations(anyOfDestinations), packDestinations(allOfDestinations));
     return fromPackedSearchResult(result);
 }
 
@@ -1985,15 +2385,31 @@ let wasm_bytes;
 let wasm_module;
 let wasm_instance;
 let initialized = false;
+let initializeOptionsApplied = false;
+let pendingInitializeOptions;
+let configuredPortalList;
+let configuredPortalDistanceCacheRoomLimit;
 /**
- * The `initialize` function should be called in your main loop before
- * using any other screeps-clockwork functions. Depending on available
- * CPU, it may not load the WASM module completely in the first tick,
- * but it will pick back up where it left off if the script times out.
+ * The `initialize` function initializes the WASM module and applies global
+ * setup options. Call it in your main loop before using any other
+ * screeps-clockwork functions. Depending on available CPU, it may not load the
+ * WASM module completely in the first tick, but it will pick back up where it
+ * left off if the script times out.
+ *
+ * It is safe to call this function repeatedly, but setup options such as
+ * portals and portal cache sizing are applied only once, after WASM
+ * initialization has completed. Use `setPortals` when you intentionally need
+ * to reconfigure portals later.
  *
- * @param verbose - If true, will log the state of the WASM module as it loads.
+ * @param options - Pass `true` or `{ verbose: true }` to log WASM loading;
+ * provide portals and cache sizing to apply them once after WASM initialization.
  */
-function initialize(verbose = false) {
+function initialize(options = false) {
+    var _a;
+    const verbose = typeof options === 'boolean' ? options : ((_a = options.verbose) !== null && _a !== void 0 ? _a : false);
+    if (typeof options !== 'boolean') {
+        recordInitializeOptions(options);
+    }
     // need to freshly override the fake console object each tick
     console.error = console_error;
     const start = Game.cpu.getUsed();
@@ -2012,6 +2428,77 @@ function initialize(verbose = false) {
         console.logUnsafe(`[clockwork] version ${version()} initialized with ${(Game.cpu.getUsed() - start).toFixed(2)} CPU`);
     }
     initialized = true;
+    applyInitializeOptions();
+}
+function recordInitializeOptions(options) {
+    var _a, _b;
+    if (options.portalDistanceCacheRoomLimit === undefined && options.portals === undefined) {
+        return;
+    }
+    pendingInitializeOptions = {
+        portals: (_a = options.portals) !== null && _a !== void 0 ? _a : pendingInitializeOptions === null || pendingInitializeOptions === void 0 ? void 0 : pendingInitializeOptions.portals,
+        portalDistanceCacheRoomLimit: (_b = options.portalDistanceCacheRoomLimit) !== null && _b !== void 0 ? _b : pendingInitializeOptions === null || pendingInitializeOptions === void 0 ? void 0 : pendingInitializeOptions.portalDistanceCacheRoomLimit
+    };
+}
+function applyInitializeOptions() {
+    if (!initialized || initializeOptionsApplied || !pendingInitializeOptions) {
+        return;
+    }
+    const options = pendingInitializeOptions;
+    if (options.portalDistanceCacheRoomLimit !== undefined || options.portals !== undefined) {
+        if (options.portalDistanceCacheRoomLimit !== undefined &&
+            options.portalDistanceCacheRoomLimit !== configuredPortalDistanceCacheRoomLimit) {
+            applyPortalDistanceCacheRoomLimit(options.portalDistanceCacheRoomLimit);
+        }
+        if (options.portals && options.portals !== configuredPortalList) {
+            setPortals(options.portals);
+        }
+        initializeOptionsApplied = true;
+    }
+}
+/**
+ * Configure the portal pairs used by portal-aware pathfinding functions.
+ * Each pair is installed bidirectionally.
+ */
+function setPortals(portals) {
+    set_portals(packPortalPairs(portals));
+    configuredPortalList = portals;
+}
+function applyPortalDistanceCacheRoomLimit(roomLimit) {
+    if (!Number.isFinite(roomLimit) || roomLimit < 0 || Math.floor(roomLimit) !== roomLimit) {
+        throw new Error('Portal distance cache room limit must be a non-negative integer');
+    }
+    set_portal_distance_cache_room_limit(roomLimit);
+    configuredPortalDistanceCacheRoomLimit = roomLimit;
+}
+/**
+ * Remove all configured portal pairs while preserving the initialize-time cache limit.
+ */
+function clearPortals() {
+    clear_portals();
+    configuredPortalList = undefined;
+}
+/**
+ * Return debug counters for the configured portal index and its nearest-portal cache.
+ * `totalSize` is an approximate in-memory size formatted for logs; `totalSizeBytes`
+ * preserves the raw byte estimate.
+ */
+function debugPortalIndex() {
+    const info = debug_portal_index();
+    return Object.assign(Object.assign({}, info), { totalSize: formatBytes(info.totalSizeBytes) });
+}
+function formatBytes(bytes) {
+    const units = ['B', 'KiB', 'MiB', 'GiB'];
+    let value = bytes;
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+        value /= 1024;
+        unitIndex++;
+    }
+    if (unitIndex === 0) {
+        return `${bytes} B`;
+    }
+    return `${value.toFixed(2)} ${units[unitIndex]}`;
 }
 // This provides the function `console.error` that wasm_bindgen sometimes expects to exist,
 // especially with type checks in debug mode. An alternative is to have this be `function () {}`
@@ -2019,8 +2506,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
@@ -2043,9 +2530,15 @@ exports.ClockworkMultiroomMonoFlowField = ClockworkMultiroomMonoFlowField;
 exports.ClockworkPath = ClockworkPath;
 exports.DirectionOrder = DirectionOrder;
 exports.astarMultiroomDistanceMap = astarMultiroomDistanceMap;
+exports.astarPortalMultiroomDistanceMap = astarPortalMultiroomDistanceMap;
 exports.bfsMultiroomDistanceMap = bfsMultiroomDistanceMap;
+exports.bfsPortalMultiroomDistanceMap = bfsPortalMultiroomDistanceMap;
+exports.clearPortals = clearPortals;
+exports.debugPortalIndex = debugPortalIndex;
 exports.dijkstraMultiroomDistanceMap = dijkstraMultiroomDistanceMap;
+exports.dijkstraPortalMultiroomDistanceMap = dijkstraPortalMultiroomDistanceMap;
 exports.getRange = getRange;
 exports.getTerrainCostMatrix = getTerrainCostMatrix;
 exports.initialize = initialize;
+exports.setPortals = setPortals;
 //# sourceMappingURL=index.js.map