screeps-clockwork 0.5.0 → 0.7.1

package/dist/src/index.d.ts

@@ -1,12 +1,13 @@
 import 'fastestsmallesttextencoderdecoder-encodeinto/EncoderDecoderTogether.min.js';
 import { ClockworkCostMatrix, DistanceMap, FlowField, MonoFlowField } from './wasm/screeps_clockwork';
 export { ClockworkCostMatrix, DistanceMap, FlowField, MonoFlowField };
+export * from './utils/cleanup';
+export * from './wrappers/astarDistanceMap';
 export * from './wrappers/bfsDistanceMap';
-export * from './wrappers/bfsFlowField';
 export * from './wrappers/dijkstraDistanceMap';
-export * from './wrappers/dijkstraFlowField';
 export * from './wrappers/flowField';
 export * from './wrappers/getRange';
+export * from './wrappers/getTerrainCostMatrix';
 export * from './wrappers/monoFlowField';
 export * from './wrappers/multiroomFlowField';
 export * from './wrappers/multiroomMonoFlowField';

package/dist/src/utils/cleanup.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Mark an item as ephemeral. This means that the item will be freed after the
+ * current tick.
+ *
+ * If you don't use this to clean up your data, you'll need to call `free()`
+ * yourself.
+ *
+ * @param item - The item to be cleaned up.
+ * @returns The item.
+ */
+export declare function ephemeral<T extends {
+    free: () => void;
+}>(item: T): T;
+/**
+ * Persist an ephemeral item. This means that the item will not be freed after
+ * the current tick.
+ *
+ * @param item - The item to be persisted.
+ * @returns The item.
+ */
+export declare function persist<T extends {
+    free: () => void;
+}>(item: T): T;

package/dist/src/wasm/screeps_clockwork.d.ts

@@ -1,55 +1,41 @@
 /* tslint:disable */
 /* eslint-disable */
-/**
- * WASM wrapper for the BFS multiroom flow field function.
- */
-export function js_bfs_multiroom_flow_field(start_packed: Uint32Array, get_cost_matrix: Function, max_tiles: number, max_rooms: number, max_room_distance: number, max_tile_distance: number): MultiroomFlowField;
-/**
- * WASM wrapper for the Dijkstra distance map function.
- */
-export function js_dijkstra_distance_map(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): DistanceMap;
-export function js_path_to_flow_field_origin(start: number, flow_field: FlowField): Path;
-/**
- * WASM wrapper for the BFS distance map function.
- */
-export function js_bfs_distance_map(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): DistanceMap;
-export function js_dijkstra_multiroom_distance_map(start_packed: Uint32Array, get_cost_matrix: Function, max_tiles: number, max_rooms: number, max_room_distance: number, max_tile_distance: number): MultiroomDistanceMap;
-export function js_dijkstra_multiroom_flow_field(start_packed: Uint32Array, get_cost_matrix: Function, max_tiles: number, max_rooms: number, max_room_distance: number, max_tile_distance: number): MultiroomFlowField;
-/**
- * WASM wrapper for the BFS multiroom distance map function.
- */
-export function js_bfs_multiroom_distance_map(start_packed: Uint32Array, get_cost_matrix: Function, max_tiles: number, max_rooms: number, max_room_distance: number, max_tile_distance: number): MultiroomDistanceMap;
-/**
- * WASM wrapper for the Dijkstra flow field function.
- */
-export function js_dijkstra_flow_field(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): FlowField;
-export function js_dijkstra_multiroom_mono_flow_field(start_packed: Uint32Array, get_cost_matrix: Function, max_tiles: number, max_rooms: number, max_room_distance: number, max_tile_distance: number): MultiroomMonoFlowField;
-export function js_path_to_multiroom_distance_map_origin(start: number, distance_map: MultiroomDistanceMap): Path;
-/**
- * WASM wrapper for the BFS flow field function.
- */
-export function js_bfs_flow_field(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): FlowField;
-export function js_path_to_mono_flow_field_origin(start: number, flow_field: MonoFlowField): Path;
+export function js_astar_multiroom_distance_map(start_packed: Uint32Array, get_cost_matrix: Function, max_rooms: number, max_ops: number, max_path_cost: number, any_of_destinations?: Uint32Array | null, all_of_destinations?: Uint32Array | null): SearchResult;
 export function js_path_to_multiroom_mono_flow_field_origin(start: number, flow_field: MultiroomMonoFlowField): Path;
+export function js_path_to_multiroom_flow_field_origin(start: number, flow_field: MultiroomFlowField): Path;
+export function get_terrain_cost_matrix(room_name: number, plain_cost?: number | null, swamp_cost?: number | null, wall_cost?: number | null): ClockworkCostMatrix;
 /**
- * WASM wrapper for the BFS multiroom monodirectional flow field function.
- */
-export function js_bfs_multiroom_mono_flow_field(start_packed: Uint32Array, get_cost_matrix: Function, max_tiles: number, max_rooms: number, max_room_distance: number, max_tile_distance: number): MultiroomMonoFlowField;
-/**
- * WASM wrapper for the BFS mono flow field function.
+ * Creates a flow field for the given distance map.
  */
-export function js_bfs_mono_flow_field(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): MonoFlowField;
-export function js_path_to_distance_map_origin(start: number, distance_map: DistanceMap): Path;
-export function js_path_to_multiroom_flow_field_origin(start: number, flow_field: MultiroomFlowField): Path;
+export function multiroomFlowField(distance_map: MultiroomDistanceMap): MultiroomFlowField;
+export function js_dijkstra_multiroom_distance_map(start_packed: Uint32Array, get_cost_matrix: Function, max_ops: number, max_rooms: number, max_path_cost: number, any_of_destinations?: Uint32Array | null, all_of_destinations?: Uint32Array | null): SearchResult;
 /**
- * WASM wrapper for the Dijkstra mono flow field function.
+ * WASM wrapper for the BFS multiroom distance map function.
+ *
+ * # Arguments
+ * * `start_packed` - Array of packed position integers representing start positions
+ * * `get_cost_matrix` - JavaScript function that returns cost matrices for rooms
+ * * `max_ops` - Maximum number of tiles to explore
+ * * `max_rooms` - Maximum number of rooms to explore
+ * * `max_room_distance` - Maximum Manhattan distance in rooms to explore
+ * * `max_path_cost` - Maximum distance in tiles to explore
+ * * `any_of_destinations` - Array of packed positions to trigger early exit when any are reached
+ * * `all_of_destinations` - Array of packed positions to trigger early exit when all are reached
+ *
+ * # Returns
+ * A `MultiroomDistanceMap` containing the distances from the start positions
  */
-export function js_dijkstra_mono_flow_field(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): MonoFlowField;
+export function js_bfs_multiroom_distance_map(start_packed: Uint32Array, get_cost_matrix: Function, max_ops: number, max_rooms: number, max_path_cost: number, any_of_destinations?: Uint32Array | null, all_of_destinations?: Uint32Array | null): SearchResult;
 export function version(): string;
 /**
  * Exports the global range calculation between two positions.
  */
 export function get_range(packed_pos_1: number, packed_pos_2: number): number;
+/**
+ * Creates a monodirectional flow field for the given distance map.
+ */
+export function multiroomMonoFlowField(distance_map: MultiroomDistanceMap): MultiroomMonoFlowField;
+export function js_path_to_multiroom_distance_map_origin(start: number, distance_map: MultiroomDistanceMap): Path;
 /**
  * Translates `COLOR_*` and `COLORS_ALL` constants.
  */
@@ -203,7 +189,7 @@ export class ClockworkCostMatrix {
    * Creates a new cost matrix within the WASM module. Optionally, a default value
    * can be provided to initialize all cells in the matrix to that value.
    */
-  constructor(_default?: number);
+  constructor(_default?: number | null);
   /**
    * Gets the cost of a given position in the cost matrix.
    */
@@ -278,7 +264,7 @@ export class MonoFlowField {
   /**
    * Set the direction for a given coordinate.
    */
-  set(x: number, y: number, value?: Direction): void;
+  set(x: number, y: number, value?: Direction | null): void;
 }
 /**
  * Maps distance values across multiple rooms, storing a DistanceMap for each room
@@ -360,7 +346,7 @@ export class MultiroomMonoFlowField {
   /**
    * Sets the direction at a given position
    */
-  set(packed_pos: number, direction?: Direction): void;
+  set(packed_pos: number, direction?: Direction | null): void;
   /**
    * Gets the list of rooms in the flow field
    */
@@ -420,52 +406,43 @@ export class SearchGoal {
   readonly pos: any;
   readonly range: number;
 }
+/**
+ * A distance map search returns both the distance map (filled out
+ * with all tiles explored) and the targets found. These aren't necessarily
+ * the same positions specified as targets - if the target range is 5, then
+ * this is the first position in range 5 of the target. If multiple targets
+ * are specified, and you care about matching the found target with one of
+ * the original targets, you can iterate through your list and figure out the
+ * ones that are in range of the found target(s).
+ */
+export class SearchResult {
+  private constructor();
+  free(): void;
+  readonly distance_map: MultiroomDistanceMap;
+  readonly found_targets: Uint32Array;
+  readonly ops: number;
+}
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
-  readonly js_bfs_multiroom_flow_field: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
-  readonly js_dijkstra_distance_map: (a: number, b: number, c: number) => number;
-  readonly js_path_to_flow_field_origin: (a: number, b: number) => number;
-  readonly __wbg_flowfield_free: (a: number, b: number) => void;
-  readonly flowfield_get: (a: number, b: number, c: number) => number;
-  readonly flowfield_set: (a: number, b: number, c: number, d: number) => void;
-  readonly flowfield_getDirections: (a: number, b: number, c: number, d: number) => void;
-  readonly flowfield_setDirections: (a: number, b: number, c: number, d: number, e: number) => void;
-  readonly flowfield_addDirection: (a: number, b: number, c: number, d: number) => void;
-  readonly js_bfs_distance_map: (a: number, b: number, c: number) => number;
-  readonly js_dijkstra_multiroom_distance_map: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
-  readonly js_dijkstra_multiroom_flow_field: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
-  readonly js_bfs_multiroom_distance_map: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
-  readonly js_dijkstra_flow_field: (a: number, b: number, c: number) => number;
-  readonly js_dijkstra_multiroom_mono_flow_field: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
-  readonly js_path_to_multiroom_distance_map_origin: (a: number, b: number) => number;
+  readonly js_astar_multiroom_distance_map: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => number;
   readonly __wbg_clockworkcostmatrix_free: (a: number, b: number) => void;
   readonly clockworkcostmatrix_new: (a: number) => number;
   readonly clockworkcostmatrix_get: (a: number, b: number, c: number) => number;
   readonly clockworkcostmatrix_set: (a: number, b: number, c: number, d: number) => void;
-  readonly js_bfs_flow_field: (a: number, b: number, c: number) => number;
-  readonly js_path_to_mono_flow_field_origin: (a: number, b: number) => number;
+  readonly __wbg_searchresult_free: (a: number, b: number) => void;
+  readonly searchresult_distance_map: (a: number) => number;
+  readonly searchresult_found_targets: (a: number, b: number) => void;
+  readonly searchresult_ops: (a: number) => number;
   readonly js_path_to_multiroom_mono_flow_field_origin: (a: number, b: number) => number;
-  readonly __wbg_multiroomdistancemap_free: (a: number, b: number) => void;
-  readonly multiroomdistancemap_js_new: () => number;
-  readonly multiroomdistancemap_get: (a: number, b: number) => number;
-  readonly multiroomdistancemap_set: (a: number, b: number, c: number) => void;
-  readonly multiroomdistancemap_get_rooms: (a: number, b: number) => void;
-  readonly multiroomdistancemap_get_room: (a: number, b: number) => number;
   readonly __wbg_multiroommonoflowfield_free: (a: number, b: number) => void;
+  readonly multiroommonoflowfield_js_new: () => number;
   readonly multiroommonoflowfield_get: (a: number, b: number) => number;
   readonly multiroommonoflowfield_set: (a: number, b: number, c: number) => void;
   readonly multiroommonoflowfield_getRooms: (a: number, b: number) => void;
   readonly multiroommonoflowfield_getRoom: (a: number, b: number) => number;
-  readonly multiroommonoflowfield_js_new: () => number;
-  readonly js_bfs_multiroom_mono_flow_field: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
-  readonly __wbg_monoflowfield_free: (a: number, b: number) => void;
-  readonly monoflowfield_get: (a: number, b: number, c: number) => number;
-  readonly monoflowfield_set: (a: number, b: number, c: number, d: number) => void;
-  readonly js_bfs_mono_flow_field: (a: number, b: number, c: number) => number;
-  readonly js_path_to_distance_map_origin: (a: number, b: number) => number;
   readonly js_path_to_multiroom_flow_field_origin: (a: number, b: number) => number;
   readonly __wbg_multiroomflowfield_free: (a: number, b: number) => void;
   readonly multiroomflowfield_js_new: () => number;
@@ -476,11 +453,25 @@ export interface InitOutput {
   readonly multiroomflowfield_getDirections: (a: number, b: number, c: number) => void;
   readonly multiroomflowfield_setDirections: (a: number, b: number, c: number, d: number) => void;
   readonly multiroomflowfield_addDirection: (a: number, b: number, c: number) => void;
-  readonly js_dijkstra_mono_flow_field: (a: number, b: number, c: number) => number;
+  readonly get_terrain_cost_matrix: (a: number, b: number, c: number, d: number) => number;
+  readonly multiroomFlowField: (a: number) => number;
+  readonly js_dijkstra_multiroom_distance_map: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => number;
   readonly __wbg_distancemap_free: (a: number, b: number) => void;
   readonly distancemap_toArray: (a: number, b: number) => void;
   readonly distancemap_get: (a: number, b: number, c: number) => number;
   readonly distancemap_set: (a: number, b: number, c: number, d: number) => void;
+  readonly __wbg_flowfield_free: (a: number, b: number) => void;
+  readonly flowfield_get: (a: number, b: number, c: number) => number;
+  readonly flowfield_set: (a: number, b: number, c: number, d: number) => void;
+  readonly flowfield_getDirections: (a: number, b: number, c: number, d: number) => void;
+  readonly flowfield_setDirections: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly flowfield_addDirection: (a: number, b: number, c: number, d: number) => void;
+  readonly js_bfs_multiroom_distance_map: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => number;
+  readonly __wbg_monoflowfield_free: (a: number, b: number) => void;
+  readonly monoflowfield_get: (a: number, b: number, c: number) => number;
+  readonly monoflowfield_set: (a: number, b: number, c: number, d: number) => void;
+  readonly version: (a: number) => void;
+  readonly get_range: (a: number, b: number) => number;
   readonly __wbg_path_free: (a: number, b: number) => void;
   readonly __wbg_pathfatigue_free: (a: number, b: number) => void;
   readonly path_add: (a: number, b: number) => void;
@@ -491,10 +482,16 @@ export interface InitOutput {
   readonly path_to_array_reversed: (a: number, b: number) => void;
   readonly pathfatigue_new: (a: number) => number;
   readonly pathfatigue_refresh: (a: number, b: number) => void;
-  readonly pathfatigue_moveTime: (a: number, b: number) => number;
-  readonly version: (a: number) => void;
-  readonly get_range: (a: number, b: number) => number;
   readonly pathfatigue_len: (a: number) => number;
+  readonly pathfatigue_moveTime: (a: number, b: number) => number;
+  readonly multiroomMonoFlowField: (a: number) => number;
+  readonly js_path_to_multiroom_distance_map_origin: (a: number, b: number) => number;
+  readonly __wbg_multiroomdistancemap_free: (a: number, b: number) => void;
+  readonly multiroomdistancemap_js_new: () => number;
+  readonly multiroomdistancemap_get: (a: number, b: number) => number;
+  readonly multiroomdistancemap_set: (a: number, b: number, c: number) => void;
+  readonly multiroomdistancemap_get_rooms: (a: number, b: number) => void;
+  readonly multiroomdistancemap_get_room: (a: number, b: number) => number;
   readonly __wbg_searchgoal_free: (a: number, b: number) => void;
   readonly searchgoal_pos: (a: number) => number;
   readonly searchgoal_range: (a: number) => number;

package/dist/src/wrappers/astarDistanceMap.d.ts

@@ -0,0 +1,35 @@
+import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
+/**
+ * Create a distance map for the given start positions, using a breadth-first search.
+ * This does not factor in terrain costs (treating anything less than 255 in the cost
+ * matrix as passable), so it's faster but less useful than Dijkstra's algorithm.
+ *
+ * This calculates a distance map across multiple rooms, with a few configurable limits:
+ * - `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 must be set.
+ *
+ * @param start - The starting positions.
+ * @param options - The options for the distance map.
+ * @returns A multi-room distance map.
+ */
+export declare function astarMultiroomDistanceMap(start: RoomPosition[], { costMatrixCallback, maxRooms, maxOps, maxPathCost, anyOfDestinations, allOfDestinations }: {
+    costMatrixCallback: (room: string) => ClockworkCostMatrix | undefined;
+    maxRooms?: number;
+    maxOps?: number;
+    maxPathCost?: number;
+    anyOfDestinations?: {
+        pos: RoomPosition;
+        range: number;
+    }[];
+    allOfDestinations?: {
+        pos: RoomPosition;
+        range: number;
+    }[];
+}): {
+    distanceMap: import("./multiroomDistanceMap").ClockworkMultiroomDistanceMap;
+    foundTargets: RoomPosition[];
+    ops: number;
+};

package/dist/src/wrappers/bfsDistanceMap.d.ts

@@ -1,35 +1,13 @@
 import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
-import { ClockworkDistanceMap } from './distanceMap';
-import { ClockworkMultiroomDistanceMap } from './multiroomDistanceMap';
-/**
- * Generate a [distance map](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html) for a set of positions
- * using a breadth-first search algorithm.
- *
- * The BFS algorithm doesn't include variable costs, and only considers
- * values of 255 (impassible) in the provided cost matrix. Any other
- * values are ignored.
- *
- * This might be useful for creeps with only MOVE parts and/or empty
- * CARRY parts, which don't generate fatigue.
- *
- * Note that the `roomName` on start positions is ignored - all positions
- * are assumed to be in the same room as the cost matrix.
- *
- * @param start - The starting positions.
- * @param costMatrix - The cost matrix to use for the flow field.
- * @returns The flow field.
- */
-export declare function bfsDistanceMap(start: RoomPosition[], costMatrix: ClockworkCostMatrix): ClockworkDistanceMap;
 /**
  * Create a distance map for the given start positions, using a breadth-first search.
  * This does not factor in terrain costs (treating anything less than 255 in the cost
  * matrix as passable), so it's faster but less useful than Dijkstra's algorithm.
  *
  * This calculates a distance map across multiple rooms, with a few configurable limits:
- * - `maxTiles`: The maximum number of tiles to explore.
+ * - `maxOps`: The maximum number of pathfinding operations to perform.
  * - `maxRooms`: The maximum number of rooms to explore.
- * - `maxRoomDistance`: Don't explore rooms further (in Manhattan distance) than this.
- * - `maxTileDistance`: Don't explore tiles further (in Chebyshev distance) than this.
+ * - `maxPathCost`: Don't explore tiles with a greater path cost than this.
  *
  * At least one of these limits must be set.
  *
@@ -37,10 +15,21 @@ export declare function bfsDistanceMap(start: RoomPosition[], costMatrix: Clockw
  * @param options - The options for the distance map.
  * @returns A multi-room distance map.
  */
-export declare function bfsMultiroomDistanceMap(start: RoomPosition[], { costMatrixCallback, maxTiles, maxRooms, maxRoomDistance, maxTileDistance }: {
+export declare function bfsMultiroomDistanceMap(start: RoomPosition[], { costMatrixCallback, maxOps, maxRooms, maxPathCost, anyOfDestinations, allOfDestinations }: {
     costMatrixCallback: (room: string) => ClockworkCostMatrix | undefined;
-    maxTiles?: number;
+    maxOps?: number;
     maxRooms?: number;
-    maxRoomDistance?: number;
-    maxTileDistance?: number;
-}): ClockworkMultiroomDistanceMap;
+    maxPathCost?: number;
+    anyOfDestinations?: {
+        pos: RoomPosition;
+        range: number;
+    }[];
+    allOfDestinations?: {
+        pos: RoomPosition;
+        range: number;
+    }[];
+}): {
+    distanceMap: import("./multiroomDistanceMap").ClockworkMultiroomDistanceMap;
+    foundTargets: RoomPosition[];
+    ops: number;
+};

package/dist/src/wrappers/dijkstraDistanceMap.d.ts

@@ -1,32 +1,12 @@
 import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
-import { ClockworkDistanceMap } from './distanceMap';
-import { ClockworkMultiroomDistanceMap } from './multiroomDistanceMap';
-/**
- * Generate a [distance map](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html) for a set of positions
- * using Dijkstra's algorithm.
- *
- * Dijkstra's algorithm includes variable costs to account for terrain or other cost functions.
- *
- * Note that values of 0 in the cost matrix may have unexpected behavior. You probably want
- * a cost matrix with a default value of at least 1.
- *
- * Note that the `roomName` on start positions is ignored - all positions
- * are assumed to be in the same room as the cost matrix.
- *
- * @param start - The starting positions.
- * @param costMatrix - The cost matrix to use for the flow field.
- * @returns The flow field.
- */
-export declare function dijkstraDistanceMap(start: RoomPosition[], costMatrix: ClockworkCostMatrix): ClockworkDistanceMap;
 /**
  * Create a distance map for the given start positions, using Dijkstra's algorithm to
  * factor in terrain costs (0-255, where 255 is impassable).
  *
  * This calculates a distance map across multiple rooms, with a few configurable limits:
- * - `maxTiles`: The maximum number of tiles to explore.
+ * - `maxOps`: The maximum number of pathfinding operations to perform.
  * - `maxRooms`: The maximum number of rooms to explore.
- * - `maxRoomDistance`: Don't explore rooms further (in Manhattan distance) than this.
- * - `maxTileDistance`: Don't explore tiles further (in accumulated cost) than this.
+ * - `maxPathCost`: Don't explore tiles with a greater path cost than this.
  *
  * At least one of these limits must be set.
  *
@@ -34,10 +14,21 @@ export declare function dijkstraDistanceMap(start: RoomPosition[], costMatrix: C
  * @param options - The options for the distance map.
  * @returns A multi-room distance map.
  */
-export declare function dijkstraMultiroomDistanceMap(start: RoomPosition[], { costMatrixCallback, maxTiles, maxRooms, maxRoomDistance, maxTileDistance }: {
+export declare function dijkstraMultiroomDistanceMap(start: RoomPosition[], { costMatrixCallback, maxOps, maxRooms, maxPathCost, anyOfDestinations, allOfDestinations }: {
     costMatrixCallback: (room: string) => ClockworkCostMatrix | undefined;
-    maxTiles?: number;
+    maxOps?: number;
     maxRooms?: number;
-    maxRoomDistance?: number;
-    maxTileDistance?: number;
-}): ClockworkMultiroomDistanceMap;
+    maxPathCost?: number;
+    anyOfDestinations?: {
+        pos: RoomPosition;
+        range: number;
+    }[];
+    allOfDestinations?: {
+        pos: RoomPosition;
+        range: number;
+    }[];
+}): {
+    distanceMap: import("./multiroomDistanceMap").ClockworkMultiroomDistanceMap;
+    foundTargets: RoomPosition[];
+    ops: number;
+};

package/dist/src/wrappers/distanceMap.d.ts

@@ -1,5 +1,4 @@
 import { DistanceMap } from '../wasm/screeps_clockwork';
-import { Path } from './path';
 /**
  * A distance map for a single room.
  */
@@ -22,8 +21,4 @@ export declare class ClockworkDistanceMap {
      * Frees the memory allocated for this distance map.
      */
     free(): void;
-    /**
-     * Path to the origin from a given position.
-     */
-    pathToOrigin(start: RoomPosition): Path;
 }

package/dist/src/wrappers/flowField.d.ts

@@ -1,5 +1,4 @@
 import { FlowField } from '../wasm/screeps_clockwork';
-import { Path } from './path';
 /**
  * A flow field for a single room that stores multiple directions per tile.
  */
@@ -30,9 +29,4 @@ export declare class ClockworkFlowField {
      * Free the memory allocated for this flow field.
      */
     free(): void;
-    /**
-     * Given a flow field (for a single room), find the path from a given position to
-     * the origin. Never paths through other rooms.
-     */
-    pathToOrigin(start: RoomPosition): Path;
 }

package/dist/src/wrappers/getTerrainCostMatrix.d.ts

@@ -0,0 +1,6 @@
+import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
+export declare function getTerrainCostMatrix(roomName: string, { plainCost, swampCost, wallCost }?: {
+    plainCost?: number;
+    swampCost?: number;
+    wallCost?: number;
+}): ClockworkCostMatrix;

package/dist/src/wrappers/monoFlowField.d.ts

@@ -1,5 +1,4 @@
 import { MonoFlowField } from '../wasm/screeps_clockwork';
-import { Path } from './path';
 /**
  * A flow field for a single room that stores one direction per tile.
  */
@@ -18,9 +17,4 @@ export declare class ClockworkMonoFlowField {
      * Free the memory allocated for this flow field.
      */
     free(): void;
-    /**
-     * Given a monodirectional flow field (for a single room), find the path from a given position to
-     * the origin. Never paths through other rooms.
-     */
-    pathToOrigin(start: RoomPosition): Path;
 }

package/dist/src/wrappers/multiroomDistanceMap.d.ts

@@ -1,5 +1,7 @@
 import { DistanceMap, MultiroomDistanceMap } from '../wasm/screeps_clockwork';
-import { Path } from './path';
+import { ClockworkMultiroomFlowField } from './multiroomFlowField';
+import { ClockworkMultiroomMonoFlowField } from './multiroomMonoFlowField';
+import { ClockworkPath } from './path';
 /**
  * A distance map that covers multiple rooms. Typically returned by a function
  * like `bfsMultiroomDistanceMap` rather than created directly.
@@ -30,5 +32,13 @@ export declare class ClockworkMultiroomDistanceMap {
     /**
      * Path to the origin from a given position.
      */
-    pathToOrigin(start: RoomPosition): Path;
+    pathToOrigin(start: RoomPosition): ClockworkPath;
+    /**
+     * Flow field for this distance map.
+     */
+    toFlowField(): ClockworkMultiroomFlowField;
+    /**
+     * Mono-directional flow field for this distance map.
+     */
+    toMonoFlowField(): ClockworkMultiroomMonoFlowField;
 }

package/dist/src/wrappers/multiroomFlowField.d.ts

@@ -1,6 +1,6 @@
 import { MultiroomFlowField } from '../wasm/screeps_clockwork';
 import { ClockworkFlowField } from './flowField';
-import { Path } from './path';
+import { ClockworkPath } from './path';
 /**
  * A flow field that spans multiple rooms, storing multiple directions per tile.
  */
@@ -38,7 +38,7 @@ export declare class ClockworkMultiroomFlowField {
     /**
      * Find a path from a given position to the origin of the flow field.
      */
-    pathToOrigin(start: RoomPosition): Path;
+    pathToOrigin(start: RoomPosition): ClockworkPath;
     /**
      * Free the memory allocated for this flow field.
      */

package/dist/src/wrappers/multiroomMonoFlowField.d.ts

@@ -1,6 +1,6 @@
 import { MultiroomMonoFlowField } from '../wasm/screeps_clockwork';
 import { ClockworkMonoFlowField } from './monoFlowField';
-import { Path } from './path';
+import { ClockworkPath } from './path';
 /**
  * A flow field that spans multiple rooms, storing a single direction per tile.
  */
@@ -26,7 +26,7 @@ export declare class ClockworkMultiroomMonoFlowField {
     /**
      * Find a path from a given position to the origin of the flow field.
      */
-    pathToOrigin(start: RoomPosition): Path;
+    pathToOrigin(start: RoomPosition): ClockworkPath;
     /**
      * Free the memory allocated for this flow field.
      */

package/dist/src/wrappers/path.d.ts

@@ -1,11 +1,11 @@
-import { Path as ClockworkPath } from '../wasm/screeps_clockwork';
+import { Path } from '../wasm/screeps_clockwork';
 /**
  * A path from a start position to an end position. Typically returned by a
  * function like `pathToFlowFieldOrigin` rather than created directly.
  */
-export declare class Path {
+export declare class ClockworkPath {
     private readonly path;
-    constructor(path: ClockworkPath);
+    constructor(path: Path);
     /**
      * Iterate over the path.
      *

package/dist/src/wrappers/searchResult.d.ts

@@ -0,0 +1,7 @@
+import { SearchResult } from '../wasm/screeps_clockwork';
+import { ClockworkMultiroomDistanceMap } from './multiroomDistanceMap';
+export declare function fromPackedSearchResult(result: SearchResult): {
+    distanceMap: ClockworkMultiroomDistanceMap;
+    foundTargets: RoomPosition[];
+    ops: number;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "screeps-clockwork",
-  "version": "0.5.0",
+  "version": "0.7.1",
   "description": "A WASM movement library for Screeps",
   "main": "dist/index.js",
   "types": "dist/src/index.d.ts",
@@ -9,6 +9,7 @@
     "build:lib": "wasm-pack build --target web --out-dir src/wasm --config build.rustflags=[\\'-Ctarget-feature=-reference-types\\',\\'-Ctarget-feature=-multivalue\\',\\'-Ctarget-feature=-sign-ext\\'] -Z build-std=std,panic_abort",
     "build:src": "rollup -c",
     "build:docs": "typedoc",
+    "build:pserver": "run-s build:lib build:src && rollup -c --environment DEST:pserver",
     "watch": "run-s build watch:both",
     "watch:lib": "cargo-watch -w lib -s \"npm run build:lib\"",
     "watch:src": "wait-on src/wasm/screeps_clockwork_bg.wasm && rollup -cw",
@@ -33,7 +34,7 @@
   "homepage": "https://github.com/glitchassassin/screeps-clockwork#readme",
   "devDependencies": {
     "@rollup/plugin-commonjs": "^28.0.1",
-    "@rollup/plugin-node-resolve": "^15.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.0",
     "@rollup/plugin-typescript": "^12.1.1",
     "@rollup/plugin-wasm": "^6.2.2",
     "@types/node": "^22.10.1",
@@ -48,6 +49,7 @@
     "rollup-plugin-copy": "^3.5.0",
     "rollup-plugin-screeps": "^1.0.1",
     "source-map": "0.6.1",
+    "tslib": "^2.8.1",
     "typedoc": "^0.27.3",
     "typescript": "^5.7.2"
   },