@reicek/neataptic-ts 0.1.21 → 0.1.22

package/test/examples/asciiMaze/mazeMovement/README.md

@@ -0,0 +1,356 @@
+# mazeMovement
+
+## mazeMovement/mazeMovement.types.ts
+
+### mazeMovement.types
+
+Shared type surface for the dedicated mazeMovement module.
+
+Step 2 moves internal simulation contracts here first so later helper files
+can depend on one narrow typed surface.
+
+### DirectionSelectionStats
+
+Diagnostic telemetry produced when selecting a direction from network logits.
+
+Encapsulates the chosen direction along with entropy and probability data so
+downstream helpers can apply shaping rewards and penalties without
+rederiving softmax statistics on hot paths.
+
+### MazeMovementBufferPools
+
+Shared type surface for the dedicated mazeMovement module.
+
+Step 2 moves internal simulation contracts here first so later helper files
+can depend on one narrow typed surface.
+
+### MazeMovementRunServiceState
+
+Mutable run-scoped service state shared by the mazeMovement facade.
+
+The dedicated services module owns these counters so later runtime, policy,
+and shaping helpers can depend on one explicit mutable surface instead of
+directly reaching into class-private state.
+
+### MazeMovementSimulationResult
+
+Result shape returned by `MazeMovement.simulateAgent`.
+
+This contract matches the legacy inline return annotation so callers can
+keep depending on the current fields while the dedicated module boundary is
+being extracted.
+
+### SimulationState
+
+Internal aggregate state used during a single agent simulation run.
+
+Purpose:
+- Hold all derived runtime values, counters and diagnostic stats used by the
+  MazeMovement simulation helpers. This shape is intentionally rich so tests
+  and visualisers can inspect intermediate state when debugging.
+
+Notes:
+- This interface remains internal to the mazeMovement module boundary.
+- Property descriptions are explicit to surface helpful tooltips in editors.
+
+## mazeMovement/mazeMovement.ts
+
+### mazeMovement
+
+Public MazeMovement facade for the dedicated mazeMovement module boundary.
+
+The folder now owns runtime helpers, policy helpers, shaping helpers, and
+finalization logic. This file keeps the user-facing API in one place while
+the implementation stays split into focused helpers.
+
+### MazeMovement
+
+Maze movement entry surface used by fitness evaluation and evolution runs.
+
+The public API intentionally remains class-based so existing example imports
+do not change while the implementation lives under the dedicated module.
+
+#### #COORDINATE_SCRATCH
+
+Reused integer coordinate scratch for hot-path movement helpers.
+
+#### #hasReachedExit
+
+`(simulationState: import("test/examples/asciiMaze/mazeMovement/mazeMovement.types").SimulationState, exitPos: readonly [number, number]) => boolean`
+
+Determine whether the current state has reached the maze exit.
+
+Parameters:
+- `simulationState` - - Mutable run state for the active episode.
+- `exitPos` - - Exit coordinate for the run.
+
+Returns: True when the agent position matches the exit coordinate.
+
+#### #processMovementAndShaping
+
+`(simulationState: import("test/examples/asciiMaze/mazeMovement/mazeMovement.types").SimulationState, encodedMaze: number[][], distanceMap: number[][] | undefined) => boolean`
+
+Execute the selected move, apply post-action shaping, and evaluate stop rules.
+
+Parameters:
+- `simulationState` - - Mutable run state for the active episode.
+- `encodedMaze` - - Maze grid used for movement and distance lookup.
+- `distanceMap` - - Optional precomputed distance map.
+
+Returns: True when the episode should stop after this step.
+
+#### #processPerceptionAndPolicy
+
+`(simulationState: import("test/examples/asciiMaze/mazeMovement/mazeMovement.types").SimulationState, network: import("test/examples/asciiMaze/interfaces").INetwork, encodedMaze: number[][], exitPos: readonly [number, number], distanceMap: number[][] | undefined) => void`
+
+Refresh visit bookkeeping, perception state, and direction policy.
+
+Parameters:
+- `simulationState` - - Mutable run state for the active episode.
+- `network` - - Policy network used for action selection.
+- `encodedMaze` - - Maze grid used for the run.
+- `exitPos` - - Exit coordinate for the run.
+- `distanceMap` - - Optional precomputed distance map.
+
+#### moveAgent
+
+`(encodedMaze: readonly (readonly number[])[], position: readonly [number, number], direction: number) => [number, number]`
+
+Move the agent one step in the requested direction when the target cell is open.
+
+Parameters:
+- `encodedMaze` - - Maze grid used for collision checks.
+- `position` - - Current agent position.
+- `direction` - - Direction index in the action space.
+
+Returns: New position when the move is valid, otherwise the original position.
+
+#### selectDirection
+
+`(outputs: number[]) => import("test/examples/asciiMaze/mazeMovement/mazeMovement.types").DirectionSelectionStats`
+
+Convert raw network outputs into a chosen action plus diagnostics.
+
+Parameters:
+- `outputs` - - Raw action logits for the four maze directions.
+
+Returns: Chosen direction plus softmax and entropy diagnostics.
+
+#### simulateAgent
+
+`(network: import("test/examples/asciiMaze/interfaces").INetwork, encodedMaze: number[][], startPos: readonly [number, number], exitPos: readonly [number, number], distanceMap: number[][] | undefined, maxSteps: number) => import("test/examples/asciiMaze/mazeMovement/mazeMovement.types").MazeMovementSimulationResult`
+
+Simulate one full maze episode for a network-controlled agent.
+
+Parameters:
+- `network` - - Policy network used to choose actions.
+- `encodedMaze` - - Maze grid for the active episode.
+- `startPos` - - Start coordinate.
+- `exitPos` - - Exit coordinate.
+- `distanceMap` - - Optional precomputed distance map.
+- `maxSteps` - - Maximum allowed step count before termination.
+
+Returns: Final simulation result including path, fitness, and progress.
+
+## mazeMovement/mazeMovement.services.ts
+
+### mazeMovement.services
+
+Shared mutable services for the dedicated mazeMovement module.
+
+This module owns the pooled buffers, PRNG state, output-history plumbing,
+and shared run-scoped counters used by the legacy MazeMovement facade while
+Step 2 incrementally moves helper categories into the dedicated boundary.
+
+### getMazeMovementBufferMetadata
+
+`() => { cachedWidth: number; cachedHeight: number; }`
+
+Read the currently cached maze dimensions for bounds and index helpers.
+
+Returns: Cached width and height for the active pooled buffers.
+
+### getMazeMovementRunServiceState
+
+`() => import("test/examples/asciiMaze/mazeMovement/mazeMovement.types").MazeMovementRunServiceState`
+
+Expose the shared mutable run-scoped state used across helper categories.
+
+Returns: The singleton mutable run-state object for the current process.
+
+### indexMazeMovementCell
+
+`(x: number, y: number) => number`
+
+Convert a cell coordinate into the pooled linear grid index.
+
+Parameters:
+- `x` - - Zero-based maze column.
+- `y` - - Zero-based maze row.
+
+Returns: Linearized index used by pooled grid buffers.
+
+### initializeMazeMovementBufferPools
+
+`(width: number, height: number, maxSteps: number) => import("test/examples/asciiMaze/mazeMovement/mazeMovement.types").MazeMovementBufferPools`
+
+Ensure the pooled grid and path buffers are initialized for a run.
+
+Parameters:
+- `width` - - Maze width in cells.
+- `height` - - Maze height in cells.
+- `maxSteps` - - Maximum path length expected for the run.
+
+Returns: The initialized pooled buffer surface.
+
+### materializeMazeMovementPath
+
+`(length: number) => [number, number][]`
+
+Materialize the active pooled path buffers into a fresh tuple array.
+
+Parameters:
+- `length` - - Number of active path entries to copy.
+
+Returns: A newly allocated materialized path snapshot.
+
+### randomMazeMovementUnit
+
+`() => number`
+
+Generate a pseudo-random number in the range `[0, 1)`.
+
+Returns: A deterministic or host-random unit float for exploration logic.
+
+### readMazeMovementOutputHistory
+
+`(network: import("test/examples/asciiMaze/interfaces").INetwork) => number[][] | undefined`
+
+Read the reflected `_lastStepOutputs` network history when present.
+
+Parameters:
+- `network` - - Network that may carry the reflected output history.
+
+Returns: Sanitized output history or `undefined` when absent or invalid.
+
+### requireMazeMovementBufferPools
+
+`() => import("test/examples/asciiMaze/mazeMovement/mazeMovement.types").MazeMovementBufferPools`
+
+Return the initialized pooled buffer surface for the current run.
+
+Returns: The shared buffer pools.
+
+### resetMazeMovementRunServiceState
+
+`() => import("test/examples/asciiMaze/mazeMovement/mazeMovement.types").MazeMovementRunServiceState`
+
+Reset the shared mutable run-scoped state before a new simulation begins.
+
+Returns: The reused singleton state after reset.
+
+### writeMazeMovementOutputHistory
+
+`(network: import("test/examples/asciiMaze/interfaces").INetwork, history: number[][]) => void`
+
+Persist the reflected `_lastStepOutputs` network history.
+
+Parameters:
+- `network` - - Network receiving the reflected output history.
+- `history` - - Bounded output-history payload to persist.
+
+## mazeMovement/mazeMovement.constants.ts
+
+### mazeMovement.constants
+
+Frozen tuning surface for the dedicated mazeMovement module.
+
+This constant table keeps simulation policy, shaping thresholds, and lookup
+tables in one place so the public facade can stay focused on orchestration.
+
+### MAZE_MOVEMENT_CONSTANTS
+
+## mazeMovement/mazeMovement.utils.ts
+
+### computeActionEntropyFromCounts
+
+`(directionCounts: number[], logActions: number, scratch: Float64Array<ArrayBufferLike>) => number`
+
+Compute normalized action entropy from direction counts.
+
+Parameters:
+- `directionCounts` - - Number of moves taken in each direction.
+- `logActions` - - Precomputed normalization factor for the action space.
+- `scratch` - - Single-value floating-point scratch buffer reused by the caller.
+
+Returns: Normalized entropy in the range `[0, 1]`.
+
+### isFiniteNumberArray
+
+`(candidate: unknown) => boolean`
+
+Determine whether the provided value is a finite-number array.
+
+Parameters:
+- `candidate` - - Value to inspect.
+
+Returns: True when the input is an array of finite numbers.
+
+### materializePath
+
+`(length: number, pathX: Int32Array<ArrayBufferLike>, pathY: Int32Array<ArrayBufferLike>) => [number, number][]`
+
+Materialize the active prefix of pooled path buffers into a fresh array.
+
+Parameters:
+- `length` - - Number of path entries to materialize.
+- `pathX` - - Pooled X-coordinate buffer.
+- `pathY` - - Pooled Y-coordinate buffer.
+
+Returns: A newly allocated array of path tuples.
+
+### nextPowerOfTwo
+
+`(n: number) => number`
+
+Return the smallest power-of-two integer greater than or equal to `n`.
+
+Parameters:
+- `n` - - Target minimum integer capacity.
+
+Returns: The smallest power of two greater than or equal to `n`.
+
+### readOutputHistory
+
+`(network: import("test/examples/asciiMaze/interfaces").INetwork) => number[][] | undefined`
+
+Read the optional `_lastStepOutputs` history stored on a network.
+
+Parameters:
+- `network` - - Network instance that may expose a reflected outputs history.
+
+Returns: Sanitized history buffer or `undefined` when absent or invalid.
+
+### sumVisionGroup
+
+`(vision: number[], start: number, groupLength: number, scratch: Float64Array<ArrayBufferLike>) => number`
+
+Sum a contiguous group of entries from a vision vector into a reusable scratch buffer.
+
+Parameters:
+- `vision` - - Flat perception vector.
+- `start` - - Start index of the group to sum.
+- `groupLength` - - Number of entries in the group.
+- `scratch` - - Reusable scratch buffer populated with copied values.
+
+Returns: Numeric sum of the selected group.
+
+### writeOutputHistory
+
+`(network: import("test/examples/asciiMaze/interfaces").INetwork, history: number[][]) => void`
+
+Persist a bounded outputs history on the network via reflection.
+
+Parameters:
+- `network` - - Target network to mutate.
+- `history` - - Updated history buffer.

package/test/examples/asciiMaze/mazeMovement/finalization/README.md

@@ -0,0 +1,49 @@
+# mazeMovement/finalization
+
+## mazeMovement/finalization/mazeMovement.finalization.ts
+
+### mazeMovement.finalization
+
+Result-finalization helpers for the dedicated mazeMovement module.
+
+These helpers assemble the final simulation payload once the orchestration
+facade has finished stepping the run. Keeping this logic here lets the main
+facade stay focused on the episode loop rather than on score shaping math.
+
+### computeMazeMovementActionEntropy
+
+`(directionCounts: number[]) => number`
+
+Compute the normalized action-entropy summary for a finished run.
+
+Parameters:
+- `directionCounts` - - Per-direction action counts recorded during the run.
+
+Returns: Normalized entropy in the range `[0, 1]`.
+
+### finalizeFailedMazeMovementRun
+
+`(state: import("test/examples/asciiMaze/mazeMovement/mazeMovement.types").SimulationState, encodedMaze: number[][], startPos: readonly [number, number], exitPos: readonly [number, number], distanceMap: number[][] | undefined) => import("test/examples/asciiMaze/mazeMovement/mazeMovement.types").MazeMovementSimulationResult`
+
+Build the finalized payload for a failed maze run.
+
+Parameters:
+- `state` - - Completed simulation state for the failed run.
+- `encodedMaze` - - Maze grid used to compute fallback geometric progress.
+- `startPos` - - Start coordinate for the current episode.
+- `exitPos` - - Exit coordinate for the current episode.
+- `distanceMap` - - Optional precomputed distance map aligned to the maze.
+
+Returns: Failure result with shaped fitness, path, and diagnostic summaries.
+
+### finalizeSuccessfulMazeMovementRun
+
+`(state: import("test/examples/asciiMaze/mazeMovement/mazeMovement.types").SimulationState, maxSteps: number) => import("test/examples/asciiMaze/mazeMovement/mazeMovement.types").MazeMovementSimulationResult`
+
+Build the finalized payload for a successful maze run.
+
+Parameters:
+- `state` - - Completed simulation state for the successful run.
+- `maxSteps` - - Maximum allowed step budget for the run.
+
+Returns: Success result with fitness, path, and diagnostic summaries.

package/test/examples/asciiMaze/mazeMovement/finalization/mazeMovement.finalization.ts

@@ -0,0 +1,138 @@
+/**
+ * Result-finalization helpers for the dedicated mazeMovement module.
+ *
+ * These helpers assemble the final simulation payload once the orchestration
+ * facade has finished stepping the run. Keeping this logic here lets the main
+ * facade stay focused on the episode loop rather than on score shaping math.
+ */
+
+import { MazeUtils } from '../../mazeUtils';
+import { MAZE_MOVEMENT_CONSTANTS } from '../mazeMovement.constants';
+import {
+  materializeMazeMovementPath,
+  randomMazeMovementUnit,
+} from '../mazeMovement.services';
+import type {
+  MazeMovementSimulationResult,
+  SimulationState,
+} from '../mazeMovement.types';
+import { computeActionEntropyFromCounts } from '../mazeMovement.utils';
+
+const C = MAZE_MOVEMENT_CONSTANTS;
+const ACTION_ENTROPY_SCRATCH = new Float64Array(1);
+
+/**
+ * Build the finalized payload for a successful maze run.
+ *
+ * @param state - Completed simulation state for the successful run.
+ * @param maxSteps - Maximum allowed step budget for the run.
+ * @returns Success result with fitness, path, and diagnostic summaries.
+ */
+export function finalizeSuccessfulMazeMovementRun(
+  state: SimulationState,
+  maxSteps: number,
+): MazeMovementSimulationResult {
+  const stepsTaken = state.steps | 0;
+  const stepEfficiency = (maxSteps | 0) - stepsTaken;
+  const actionEntropy = computeMazeMovementActionEntropy(state.directionCounts);
+  const baseFitness =
+    C.SUCCESS_BASE_FITNESS +
+    stepEfficiency * C.STEP_EFFICIENCY_SCALE +
+    state.progressReward +
+    state.newCellExplorationBonus +
+    state.invalidMovePenalty;
+  const totalFitness =
+    baseFitness + actionEntropy * C.SUCCESS_ACTION_ENTROPY_SCALE;
+  const pathSnapshot = materializeMazeMovementPath(state.pathLength);
+  const saturationFraction =
+    stepsTaken > 0 ? state.saturatedSteps / stepsTaken : 0;
+
+  return {
+    success: true,
+    steps: stepsTaken,
+    path: pathSnapshot,
+    fitness: Math.max(C.MIN_SUCCESS_FITNESS, totalFitness),
+    progress: 100,
+    saturationFraction,
+    actionEntropy,
+  };
+}
+
+/**
+ * Build the finalized payload for a failed maze run.
+ *
+ * @param state - Completed simulation state for the failed run.
+ * @param encodedMaze - Maze grid used to compute fallback geometric progress.
+ * @param startPos - Start coordinate for the current episode.
+ * @param exitPos - Exit coordinate for the current episode.
+ * @param distanceMap - Optional precomputed distance map aligned to the maze.
+ * @returns Failure result with shaped fitness, path, and diagnostic summaries.
+ */
+export function finalizeFailedMazeMovementRun(
+  state: SimulationState,
+  encodedMaze: number[][],
+  startPos: readonly [number, number],
+  exitPos: readonly [number, number],
+  distanceMap?: number[][],
+): MazeMovementSimulationResult {
+  const progress = distanceMap
+    ? MazeUtils.calculateProgressFromDistanceMap(
+        distanceMap,
+        state.position,
+        startPos,
+      )
+    : MazeUtils.calculateProgress(
+        encodedMaze,
+        state.position,
+        startPos,
+        exitPos,
+      );
+  const progressFraction = progress / 100;
+  const shapedProgress =
+    Math.pow(progressFraction, C.PROGRESS_POWER) * C.PROGRESS_SCALE;
+  const explorationScore = state.visitedUniqueCount;
+  const actionEntropy = computeMazeMovementActionEntropy(state.directionCounts);
+  const entropyBonus = actionEntropy * C.ENTROPY_BONUS_WEIGHT;
+  const baseFitness =
+    shapedProgress +
+    explorationScore +
+    state.progressReward +
+    state.newCellExplorationBonus +
+    state.invalidMovePenalty +
+    entropyBonus +
+    state.localAreaPenalty;
+  const randomizedFitness =
+    baseFitness + randomMazeMovementUnit() * C.FITNESS_RANDOMNESS;
+  const stabilizedFitness =
+    randomizedFitness >= 0
+      ? randomizedFitness
+      : -Math.log1p(1 - randomizedFitness);
+  const pathSnapshot = materializeMazeMovementPath(state.pathLength);
+  const stepsTaken = state.steps | 0;
+  const saturationFraction =
+    stepsTaken > 0 ? state.saturatedSteps / stepsTaken : 0;
+
+  return {
+    success: false,
+    steps: stepsTaken,
+    path: pathSnapshot,
+    fitness: stabilizedFitness,
+    progress,
+    saturationFraction,
+    actionEntropy,
+  };
+}
+
+/**
+ * Compute the normalized action-entropy summary for a finished run.
+ *
+ * @param directionCounts - Per-direction action counts recorded during the run.
+ * @returns Normalized entropy in the range `[0, 1]`.
+ */
+function computeMazeMovementActionEntropy(directionCounts: number[]): number {
+  return computeActionEntropyFromCounts(
+    directionCounts,
+    C.LOG_ACTIONS,
+    ACTION_ENTROPY_SCRATCH,
+  );
+}

package/test/examples/asciiMaze/mazeMovement/mazeMovement.constants.ts

@@ -0,0 +1,101 @@
+/**
+ * Frozen tuning surface for the dedicated mazeMovement module.
+ *
+ * This constant table keeps simulation policy, shaping thresholds, and lookup
+ * tables in one place so the public facade can stay focused on orchestration.
+ */
+export const MAZE_MOVEMENT_CONSTANTS = Object.freeze({
+  DEFAULT_MAX_STEPS: 3000,
+  MOVE_HISTORY_LENGTH: 6,
+  REWARD_SCALE: 0.5,
+  LOOP_PENALTY: 10,
+  MEMORY_RETURN_PENALTY: 2,
+  REVISIT_PENALTY_PER_VISIT: 0.2,
+  VISIT_TERMINATION_THRESHOLD: 10,
+  INVALID_MOVE_PENALTY_HARSH: 1000,
+  INVALID_MOVE_PENALTY_MILD: 10,
+  OVERCONFIDENT_PROB: 0.985,
+  SECOND_PROB_LOW: 0.01,
+  LOGSTD_FLAT_THRESHOLD: 0.01,
+  OVERCONFIDENT_PENALTY: 0.25,
+  FLAT_COLLAPSE_PENALTY: 0.35,
+  SATURATION_ADJUST_MIN: 6,
+  SATURATION_ADJUST_INTERVAL: 5,
+  BIAS_CLAMP: 5,
+  BIAS_ADJUST_FACTOR: 0.5,
+  EPSILON_WARMUP_STEPS: 10,
+  EPSILON_STAGNANT_HIGH_THRESHOLD: 12,
+  EPSILON_STAGNANT_MED_THRESHOLD: 6,
+  EPSILON_SATURATION_TRIGGER: 3,
+  OSCILLATION_DETECT_LENGTH: 4,
+  SATURATION_PENALTY_TRIGGER: 5,
+  SATURATION_PENALTY_PERIOD: 10,
+  GLOBAL_BREAK_BONUS_START: 10,
+  GLOBAL_BREAK_BONUS_PER_STEP: 0.01,
+  GLOBAL_BREAK_BONUS_CAP: 0.5,
+  REPETITION_PENALTY_START: 4,
+  ENTROPY_BONUS_WEIGHT: 4,
+  VISION_LOS_START: 8,
+  VISION_GRAD_START: 12,
+  VISION_GROUP_LEN: 4,
+  PROXIMITY_GREEDY_DISTANCE: 2,
+  PROXIMITY_SUPPRESS_EXPLOR_DIST: 5,
+  EPSILON_INITIAL: 0.35,
+  EPSILON_STAGNANT_HIGH: 0.5,
+  EPSILON_STAGNANT_MED: 0.25,
+  EPSILON_SATURATIONS: 0.3,
+  EPSILON_MIN_NEAR_GOAL: 0.05,
+  NO_MOVE_STREAK_THRESHOLD: 5,
+  LOCAL_WINDOW: 30,
+  LOCAL_AREA_SPAN_THRESHOLD: 5,
+  LOCAL_AREA_STAGNATION_STEPS: 8,
+  LOCAL_AREA_PENALTY_AMOUNT: 0.05,
+  PROGRESS_REWARD_BASE: 0.3,
+  PROGRESS_REWARD_CONF_SCALE: 0.7,
+  PROGRESS_STEPS_MULT: 0.02,
+  PROGRESS_STEPS_MAX: 0.5,
+  DISTANCE_DELTA_SCALE: 2.0,
+  DISTANCE_DELTA_CONF_BASE: 0.4,
+  DISTANCE_DELTA_CONF_SCALE: 0.6,
+  PROGRESS_AWAY_BASE_PENALTY: 0.05,
+  PROGRESS_AWAY_CONF_SCALE: 0.15,
+  ENTROPY_HIGH_THRESHOLD: 0.95,
+  ENTROPY_CONFIDENT_THRESHOLD: 0.55,
+  ENTROPY_CONFIDENT_DIFF: 0.25,
+  ENTROPY_PENALTY: 0.03,
+  EXPLORATION_BONUS_SMALL: 0.015,
+  REPETITION_PENALTY_BASE: 0.05,
+  BACK_MOVE_PENALTY: 0.2,
+  SATURATION_PENALTY_BASE: 0.05,
+  SATURATION_PENALTY_ESCALATE: 0.1,
+  DEEP_STAGNATION_THRESHOLD: 40,
+  DEEP_STAGNATION_PENALTY: 2,
+  ACTION_DIM: 4,
+  LOG_ACTIONS: Math.log(4),
+  NO_MOVE: -1,
+  STD_MIN: 1e-6,
+  COLLAPSE_STD_THRESHOLD: 0.01,
+  COLLAPSE_STD_MED: 0.03,
+  COLLAPSE_RATIO_FULL: 1,
+  COLLAPSE_RATIO_HALF: 0.5,
+  TEMPERATURE_BASE: 1,
+  TEMPERATURE_SCALE: 1.2,
+  OUTPUT_HISTORY_LENGTH: 80,
+  FITNESS_RANDOMNESS: 0.01,
+  SUCCESS_BASE_FITNESS: 650,
+  STEP_EFFICIENCY_SCALE: 0.2,
+  SUCCESS_ACTION_ENTROPY_SCALE: 5,
+  MIN_SUCCESS_FITNESS: 150,
+  NEW_CELL_EXPLORATION_BONUS: 0.3,
+  REVISIT_PENALTY_STRONG: 0.5,
+  PROGRESS_POWER: 1.3,
+  PROGRESS_SCALE: 500,
+  NODE_TYPE_OUTPUT: 'output',
+  DIRECTION_DELTAS: [
+    [0, -1],
+    [1, 0],
+    [0, 1],
+    [-1, 0],
+  ] as const,
+  OPPOSITE_DIR: [2, 3, 0, 1] as const,
+} as const);