screeps-clockwork 0.12.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,6 +1260,13 @@ function version() {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
+        __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;
             return ret;
@@ -1096,7 +1289,7 @@ function __wbg_get_imports() {
                 return addHeapObject(ret);
             }, arguments);
         },
-        __wbg_clockworkcostmatrix_get_pointer_bb635b319c5f0508: function (arg0) {
+        __wbg_clockworkcostmatrix_get_pointer_20f0153b006cac1d: function (arg0) {
             const ret = clockworkcostmatrix_get_pointer(takeObject(arg0));
             return ret;
         },
@@ -1120,6 +1313,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).getRawBuffer(getObject(arg1));
             return addHeapObject(ret);
         },
+        __wbg_new_02d162bc6cf02f60: function () {
+            const ret = new Object();
+            return addHeapObject(ret);
+        },
         __wbg_new_1f236d63ba0c4784: function (arg0, arg1) {
             const ret = new Error(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
@@ -1134,6 +1331,12 @@ function __wbg_get_imports() {
                 return addHeapObject(ret);
             }, arguments);
         },
+        __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;
         },
@@ -1221,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;
@@ -1399,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) {
@@ -1449,26 +1749,6 @@ 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`);
@@ -1729,6 +2009,12 @@ class ClockworkMultiroomFlowField {
     pathToOrigin(start) {
         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')));
+    }
 }
 
 /**
@@ -1807,6 +2093,12 @@ class ClockworkMultiroomMonoFlowField {
     pathToOrigin(start) {
         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')));
+    }
 }
 
 const DEFAULT_DIRECTION_ORDER = DirectionOrder.CardinalFirst;
@@ -1857,6 +2149,14 @@ class ClockworkMultiroomDistanceMap {
         var _a;
         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.
      * Pass `DirectionOrder.DiagonalFirst` to prefer diagonal directions when multiple neighbors are equally close.
@@ -1865,6 +2165,14 @@ class ClockworkMultiroomDistanceMap {
         var _a;
         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.
      * Pass `DirectionOrder.DiagonalFirst` to prefer diagonal directions when multiple neighbors are equally close.
@@ -1873,6 +2181,14 @@ class ClockworkMultiroomDistanceMap {
         var _a;
         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) {
@@ -1918,6 +2234,32 @@ function astarMultiroomDistanceMap(start, { costMatrixCallback, maxRooms = MAX_U
     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);
+}
 
 /**
  * Create a distance map for the given start positions, using a breadth-first search.
@@ -1937,12 +2279,39 @@ 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 = 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);
+}
 
 /**
  * Create a distance map for the given start positions, using Dijkstra's algorithm to
@@ -1967,6 +2336,32 @@ function dijkstraMultiroomDistanceMap(start, { costMatrixCallback, maxOps = MAX_
     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);
+}
 
 /**
  * Get the global range between two positions. This is different
@@ -1990,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();
@@ -2017,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 () {}`
@@ -2048,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