screeps-clockwork 0.1.1 → 0.2.1

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

@@ -0,0 +1,380 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * @returns {string}
+ */
+export function version(): string;
+/**
+ * Exports the global range calculation between two positions.
+ * @param {number} packed_pos_1
+ * @param {number} packed_pos_2
+ * @returns {number}
+ */
+export function get_range(packed_pos_1: number, packed_pos_2: number): number;
+/**
+ * WASM wrapper for the Dijkstra flow field function.
+ * @param {Uint32Array} start_packed
+ * @param {ClockworkCostMatrix} cost_matrix
+ * @returns {FlowField}
+ */
+export function js_dijkstra_flow_field(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): FlowField;
+/**
+ * WASM wrapper for the Dijkstra mono flow field function.
+ * @param {Uint32Array} start_packed
+ * @param {ClockworkCostMatrix} cost_matrix
+ * @returns {MonoFlowField}
+ */
+export function js_dijkstra_mono_flow_field(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): MonoFlowField;
+/**
+ * WASM wrapper for the BFS flow field function.
+ * @param {Uint32Array} start_packed
+ * @param {ClockworkCostMatrix} cost_matrix
+ * @returns {FlowField}
+ */
+export function js_bfs_flow_field(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): FlowField;
+/**
+ * WASM wrapper for the Dijkstra distance map function.
+ * @param {Uint32Array} start_packed
+ * @param {ClockworkCostMatrix} cost_matrix
+ * @returns {DistanceMap}
+ */
+export function js_dijkstra_distance_map(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): DistanceMap;
+/**
+ * WASM wrapper for the BFS distance map function.
+ * @param {Uint32Array} start_packed
+ * @param {ClockworkCostMatrix} cost_matrix
+ * @returns {DistanceMap}
+ */
+export function js_bfs_distance_map(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): DistanceMap;
+/**
+ * WASM wrapper for the BFS mono flow field function.
+ * @param {Uint32Array} start_packed
+ * @param {ClockworkCostMatrix} cost_matrix
+ * @returns {MonoFlowField}
+ */
+export function js_bfs_mono_flow_field(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): MonoFlowField;
+/**
+ * Translates `COLOR_*` and `COLORS_ALL` constants.
+ */
+export enum Color {
+  Red = 1,
+  Purple = 2,
+  Blue = 3,
+  Cyan = 4,
+  Green = 5,
+  Yellow = 6,
+  Orange = 7,
+  Brown = 8,
+  Grey = 9,
+  White = 10,
+}
+/**
+ * Translates the `DENSITY_*` constants.
+ */
+export enum Density {
+  Low = 1,
+  Moderate = 2,
+  High = 3,
+  Ultra = 4,
+}
+/**
+ * Translates direction constants.
+ */
+export enum Direction {
+  Top = 1,
+  TopRight = 2,
+  Right = 3,
+  BottomRight = 4,
+  Bottom = 5,
+  BottomLeft = 6,
+  Left = 7,
+  TopLeft = 8,
+}
+/**
+ * Type used for when the game returns a direction to an exit.
+ *
+ * Restricted more than `Direction` in that it can't be diagonal. Used as the
+ * result of [`Room::find_exit_to`].
+ *
+ * Can be converted to [`Find`] for immediate use of [`Room::find`]
+ * and [`Direction`].
+ *
+ * [`Room::find`]: crate::objects::Room::find
+ * [`Room::find_exit_to`]: crate::objects::Room::find_exit_to
+ */
+export enum ExitDirection {
+  Top = 1,
+  Right = 3,
+  Bottom = 5,
+  Left = 7,
+}
+/**
+ * Translates `FIND_*` constants for interal API calls
+ *
+ * Unless you're storing the type of find constant to be used for a call, you
+ * likely want the constants which implement the `FindConstant` trait to make
+ * calls to find methods.
+ *
+ * This is hidden from the documentation to avoid confusion due to its narrow
+ * use case, but wasm_bindgen requires it remain public.
+ */
+export enum Find {
+  /**
+   * Find all exit positions at the top of the room
+   */
+  ExitTop = 1,
+  ExitRight = 3,
+  ExitBottom = 5,
+  ExitLeft = 7,
+  Exit = 10,
+  Creeps = 101,
+  MyCreeps = 102,
+  HostileCreeps = 103,
+  SourcesActive = 104,
+  Sources = 105,
+  DroppedResources = 106,
+  Structures = 107,
+  MyStructures = 108,
+  HostileStructures = 109,
+  Flags = 110,
+  ConstructionSites = 111,
+  MySpawns = 112,
+  HostileSpawns = 113,
+  MyConstructionSites = 114,
+  HostileConstructionSites = 115,
+  Minerals = 116,
+  Nukes = 117,
+  Tombstones = 118,
+  PowerCreeps = 119,
+  MyPowerCreeps = 120,
+  HostilePowerCreeps = 121,
+  Deposits = 122,
+  Ruins = 123,
+  ScoreContainers = 10011,
+  ScoreCollectors = 10012,
+  SymbolContainers = 10021,
+  SymbolDecoders = 10022,
+  Reactors = 10051,
+}
+/**
+ * Translates the `EFFECT_*` constants, which are natural effect types
+ */
+export enum NaturalEffectType {
+  Invulnerability = 1001,
+  CollapseTimer = 1002,
+}
+/**
+ * Translates the `PWR_*` constants, which are types of powers used by power
+ * creeps
+ */
+export enum PowerType {
+  GenerateOps = 1,
+  OperateSpawn = 2,
+  OperateTower = 3,
+  OperateStorage = 4,
+  OperateLab = 5,
+  OperateExtension = 6,
+  OperateObserver = 7,
+  OperateTerminal = 8,
+  DisruptSpawn = 9,
+  DisruptTower = 10,
+  Shield = 12,
+  RegenSource = 13,
+  RegenMineral = 14,
+  DisruptTerminal = 15,
+  OperatePower = 16,
+  Fortify = 17,
+  OperateController = 18,
+  OperateFactory = 19,
+}
+/**
+ * Translates `TERRAIN_*` constants.
+ */
+export enum Terrain {
+  Plain = 0,
+  Wall = 1,
+  Swamp = 2,
+}
+/**
+ * A wrapper around the `LocalCostMatrix` type from the Screeps API.
+ * Instances can be passed between WASM and JS as a pointer, using the
+ * methods to get and set values, rather than copying the entire matrix.
+ */
+export class ClockworkCostMatrix {
+  free(): void;
+  /**
+   * Creates a new cost matrix within the WASM module. Optionally, a default value
+   * can be provided to initialize all cells in the matrix to that value.
+   * @param {number | undefined} [_default]
+   */
+  constructor(_default?: number);
+  /**
+   * Gets the cost of a given position in the cost matrix.
+   * @param {number} x
+   * @param {number} y
+   * @returns {number}
+   */
+  get(x: number, y: number): number;
+  /**
+   * Sets the cost of a given position in the cost matrix.
+   * @param {number} x
+   * @param {number} y
+   * @param {number} value
+   */
+  set(x: number, y: number, value: number): void;
+}
+/**
+ * Maps a distance value onto individual room tile positions.
+ */
+export class DistanceMap {
+  free(): void;
+  /**
+   * Converts the distance map into a flat array of distances.
+   * @returns {Uint32Array}
+   */
+  toArray(): Uint32Array;
+  /**
+   * Gets the distance value at a given position.
+   * @param {number} x
+   * @param {number} y
+   * @returns {number}
+   */
+  get(x: number, y: number): number;
+  /**
+   * Sets the distance value at a given position.
+   * @param {number} x
+   * @param {number} y
+   * @param {number} value
+   */
+  set(x: number, y: number, value: number): void;
+}
+/**
+ * A flow field is a 50x50 grid (representing a room), representing viable directions
+ * to travel to reach a particular target (or targets). A given tile may have multiple
+ * equally valid directions, so we represent this as a bitfield (where each bit in an
+ * 8-bit unsigned integer represents a direction that is either viable or not).
+ */
+export class FlowField {
+  free(): void;
+  /**
+   * Get the internal value for a given coordinate.
+   * @param {number} x
+   * @param {number} y
+   * @returns {number}
+   */
+  get(x: number, y: number): number;
+  /**
+   * Set the internal value for a given coordinate.
+   * @param {number} x
+   * @param {number} y
+   * @param {number} value
+   */
+  set(x: number, y: number, value: number): void;
+  /**
+   * Get the list of valid directions for a given coordinate.
+   * @param {number} x
+   * @param {number} y
+   * @returns {any[]}
+   */
+  getDirections(x: number, y: number): any[];
+  /**
+   * Set the list of valid directions for a given coordinate.
+   * @param {number} x
+   * @param {number} y
+   * @param {any[]} directions
+   */
+  setDirections(x: number, y: number, directions: any[]): void;
+  /**
+   * Add a direction to the list of valid directions for a given coordinate.
+   * @param {number} x
+   * @param {number} y
+   * @param {Direction} direction
+   */
+  addDirection(x: number, y: number, direction: Direction): void;
+}
+/**
+ * A flow field is a 50x50 grid (representing a room), representing viable directions
+ * to travel to reach a particular target (or targets). A mono flow field only stores
+ * a single direction for each tile, so we represent this as 4 bits of an unsigned
+ * integer (0 for no direction, 1 for TOP, etc.).
+ */
+export class MonoFlowField {
+  free(): void;
+  /**
+   * Get the direction for a given coordinate.
+   * @param {number} x
+   * @param {number} y
+   * @returns {Direction | undefined}
+   */
+  get(x: number, y: number): Direction | undefined;
+  /**
+   * Set the direction for a given coordinate.
+   * @param {number} x
+   * @param {number} y
+   * @param {Direction | undefined} [value]
+   */
+  set(x: number, y: number, value?: Direction): void;
+}
+export class SearchGoal {
+  free(): void;
+  readonly pos: any;
+  readonly range: number;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly version: (a: number) => void;
+  readonly get_range: (a: number, b: number) => number;
+  readonly js_dijkstra_flow_field: (a: number, b: number, c: number) => number;
+  readonly js_dijkstra_mono_flow_field: (a: number, b: number, c: number) => number;
+  readonly js_bfs_flow_field: (a: number, b: number, c: 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 __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 __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 js_dijkstra_distance_map: (a: number, b: number, c: 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_bfs_mono_flow_field: (a: number, b: number, c: number) => number;
+  readonly __wbg_searchgoal_free: (a: number, b: number) => void;
+  readonly searchgoal_pos: (a: number) => number;
+  readonly searchgoal_range: (a: number) => number;
+  readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

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

@@ -1,2 +1,20 @@
-import { ClockworkCostMatrix } from '../../wasm';
-export declare function bfsDistanceMap(start: RoomPosition[], costMatrix: ClockworkCostMatrix): import("../../wasm").DistanceMap;
+import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
+/**
+ * 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): import("../wasm/screeps_clockwork").DistanceMap;

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

@@ -1,3 +1,36 @@
-import { ClockworkCostMatrix } from '../../wasm';
-export declare function bfsFlowField(start: RoomPosition[], costMatrix: ClockworkCostMatrix): import("../../wasm").FlowField;
-export declare function bfsMonoFlowField(start: RoomPosition[], costMatrix: ClockworkCostMatrix): import("../../wasm").MonoFlowField;
+import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
+/**
+ * Generate a [flow field](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html) for a set of positions
+ * using a breadth-first search algorithm.
+ *
+ * The BFS algorithm doesn't include variable costs, and only considers
+ * values of 255 (impassible) in the provided cost matrix. Any other
+ * values are ignored.
+ *
+ * This might be useful for creeps with only MOVE parts and/or empty
+ * CARRY parts, which don't generate fatigue.
+ *
+ * @param start - The starting positions.
+ * @param costMatrix - The cost matrix to use for the flow field.
+ * @returns The flow field.
+ */
+export declare function bfsFlowField(start: RoomPosition[], costMatrix: ClockworkCostMatrix): import("../wasm/screeps_clockwork").FlowField;
+/**
+ * Generate a [mono-directional flow field](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html)
+ * for a set of positions using a breadth-first search algorithm.
+ *
+ * The BFS algorithm doesn't include variable costs, and only considers
+ * values of 255 (impassible) in the provided cost matrix. Any other
+ * values are ignored.
+ *
+ * This might be useful for creeps with only MOVE parts and/or empty
+ * CARRY parts, which don't generate fatigue.
+ *
+ * Note that the `roomName` on start positions is ignored - all positions
+ * are assumed to be in the same room as the cost matrix.
+ *
+ * @param start - The starting positions.
+ * @param costMatrix - The cost matrix to use for the flow field.
+ * @returns The flow field.
+ */
+export declare function bfsMonoFlowField(start: RoomPosition[], costMatrix: ClockworkCostMatrix): import("../wasm/screeps_clockwork").MonoFlowField;

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

@@ -0,0 +1,18 @@
+import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
+/**
+ * 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): import("../wasm/screeps_clockwork").DistanceMap;

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

@@ -0,0 +1,32 @@
+import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
+/**
+ * Generate a [flow field](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html) for a set of positions
+ * using Dijkstra's algorithm.
+ *
+ * Dijkstra's algorithm includes variable costs to account for terrain or other cost functions.
+ *
+ * Note that values of 0 in the cost matrix may have unexpected behavior. You probably want
+ * a cost matrix with a default value of at least 1.
+ *
+ * @param start - The starting positions.
+ * @param costMatrix - The cost matrix to use for the flow field.
+ * @returns The flow field.
+ */
+export declare function dijkstraFlowField(start: RoomPosition[], costMatrix: ClockworkCostMatrix): import("../wasm/screeps_clockwork").FlowField;
+/**
+ * Generate a [mono-directional flow field](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html)
+ * for a set of positions using Dijkstra's algorithm.
+ *
+ * Dijkstra's algorithm includes variable costs to account for terrain or other cost functions.
+ *
+ * Note that values of 0 in the cost matrix may have unexpected behavior. You probably want
+ * a cost matrix with a default value of at least 1.
+ *
+ * Note that the `roomName` on start positions is ignored - all positions
+ * are assumed to be in the same room as the cost matrix.
+ *
+ * @param start - The starting positions.
+ * @param costMatrix - The cost matrix to use for the flow field.
+ * @returns The flow field.
+ */
+export declare function dijkstraMonoFlowField(start: RoomPosition[], costMatrix: ClockworkCostMatrix): import("../wasm/screeps_clockwork").MonoFlowField;

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

@@ -1 +1,10 @@
+/**
+ * Get the global range between two positions. This is different
+ * from the `getRange` method on `RoomPosition`, which gets the
+ * range only within the same room.
+ *
+ * @param pos1 - The first position.
+ * @param pos2 - The second position.
+ * @returns The range between the two positions.
+ */
 export declare function getRange(pos1: RoomPosition, pos2: RoomPosition): number;

package/package.json

@@ -1,62 +1,64 @@
 {
-    "name": "screeps-clockwork",
-    "version": "0.1.1",
-    "description": "A WASM movement library for Screeps",
-    "main": "dist/index.js",
-    "types": "dist/src/index.d.ts",
-    "scripts": {
-        "build": "run-s build:lib build:src",
-        "build:lib": "wasm-pack build --target web --out-dir 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",
-        "watch": "run-p watch:lib watch:pserver",
-        "watch:lib": "cargo-watch -w lib -s \"npm run build:lib\"",
-        "watch:src": "rollup -cw",
-        "watch:pserver": "rollup -cw --environment DEST:pserver"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/glitchassassin/screeps-clockwork.git"
-    },
-    "keywords": [
-        "typescript",
-        "screeps",
-        "wasm",
-        "pathfinding"
-    ],
-    "author": "Jon Winsley <jon.winsley@gmail.com>",
-    "license": "SEE LICENSE IN LICENSE",
-    "bugs": {
-        "url": "https://github.com/glitchassassin/screeps-clockwork/issues"
-    },
-    "homepage": "https://github.com/glitchassassin/screeps-clockwork#readme",
-    "devDependencies": {
-        "@knodes/typedoc-plugin-pages": "^0.23.1",
-        "@rollup/plugin-commonjs": "^25.0.3",
-        "@rollup/plugin-node-resolve": "^15.1.0",
-        "@rollup/plugin-typescript": "^8.3.4",
-        "@rollup/plugin-wasm": "^6.2.2",
-        "@types/node": "^22.7.8",
-        "@types/screeps": "^3.3.0",
-        "@typescript-eslint/eslint-plugin": "^5.0.0",
-        "@typescript-eslint/parser": "^5.0.0",
-        "eslint": "^8.0.0",
-        "prettier": "^2.0.0",
-        "rollup": "^2.78.0",
-        "rollup-plugin-clear": "^2.0.7",
-        "rollup-plugin-copy": "^3.5.0",
-        "rollup-plugin-screeps": "^1.0.1",
-        "source-map": "^0.6.1",
-        "typescript": "^4.7.4"
-    },
-    "dependencies": {
-        "fastestsmallesttextencoderdecoder-encodeinto": "^1.0.22",
-        "npm-run-all": "^4.1.5"
-    },
-    "type": "module",
-    "files": [
-        "dist/**/*"
-    ],
-    "publishConfig": {
-        "access": "public"
-    }
+  "name": "screeps-clockwork",
+  "version": "0.2.1",
+  "description": "A WASM movement library for Screeps",
+  "main": "dist/index.js",
+  "types": "dist/src/index.d.ts",
+  "scripts": {
+    "build": "run-s build:lib build:src",
+    "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",
+    "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",
+    "watch:pserver": "rollup -cw --environment DEST:pserver",
+    "watch:both": "run-p watch:lib watch:pserver"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/glitchassassin/screeps-clockwork.git"
+  },
+  "keywords": [
+    "typescript",
+    "screeps",
+    "wasm",
+    "pathfinding"
+  ],
+  "author": "Jon Winsley <jon.winsley@gmail.com>",
+  "license": "SEE LICENSE IN LICENSE",
+  "bugs": {
+    "url": "https://github.com/glitchassassin/screeps-clockwork/issues"
+  },
+  "homepage": "https://github.com/glitchassassin/screeps-clockwork#readme",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^28.0.1",
+    "@rollup/plugin-node-resolve": "^15.1.0",
+    "@rollup/plugin-typescript": "^12.1.1",
+    "@rollup/plugin-wasm": "^6.2.2",
+    "@types/node": "^22.9.3",
+    "@types/screeps": "^3.3.0",
+    "@typescript-eslint/eslint-plugin": "^8.15.0",
+    "@typescript-eslint/parser": "^8.15.0",
+    "eslint": "^9.15.0",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^3.3.3",
+    "rollup": "2.79.2",
+    "rollup-plugin-clear": "^2.0.7",
+    "rollup-plugin-copy": "^3.5.0",
+    "rollup-plugin-screeps": "^1.0.1",
+    "source-map": "0.6.1",
+    "typedoc": "^0.27.0-beta.2",
+    "typescript": "^5.7.2"
+  },
+  "dependencies": {
+    "fastestsmallesttextencoderdecoder-encodeinto": "^1.0.22"
+  },
+  "type": "module",
+  "files": [
+    "dist/**/*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
 }