@reicek/neataptic-ts 0.1.21 → 0.1.23

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

@@ -0,0 +1,276 @@
+# dashboardManager
+
+## dashboardManager/dashboardManager.types.ts
+
+### AsciiMazeComplexityStats
+
+### AsciiMazeDetailedStats
+
+Expanded telemetry details retained by the dashboard between redraws.
+
+### AsciiMazeTelemetrySnapshot
+
+Public telemetry snapshot surfaced to browser consumers.
+
+### CurrentBestRecord
+
+Latest best candidate used by live rendering and telemetry.
+
+### DashboardArchiveFunction
+
+`(args: unknown[]) => void`
+
+### DashboardClearFunction
+
+`() => void`
+
+### DashboardHistoryState
+
+Bounded numeric histories used for trends and exports.
+
+### DashboardLogFunction
+
+`(args: unknown[]) => void`
+
+### DashboardManagerContext
+
+Shared runtime context passed into dashboard services.
+
+### DashboardManagerState
+
+Mutable runtime state owned by one dashboard instance.
+
+### DashboardManagerUpdateArgs
+
+Input accepted by the update orchestration service.
+
+### DashboardPresentationAdapter
+
+Shared presentation adapter used by browser and non-browser hosts.
+
+### DashboardScratchState
+
+Reused scratch arrays to keep redraw allocations predictable.
+
+### DashboardTelemetry
+
+Raw telemetry shape received from NEAT dashboard integrations.
+
+### DashboardTelemetryHook
+
+`(payload: import("test/examples/asciiMaze/dashboardManager/dashboardManager.types").DashboardTelemetryPayload) => void`
+
+### DashboardTelemetryPayload
+
+Telemetry payload emitted through events, postMessage, and runtime hooks.
+
+### MutationStatsMap
+
+### NeatGenome
+
+NEAT genome/network with runtime properties used by dashboard telemetry.
+
+### NeatInstance
+
+NEAT instance shape needed by dashboard helpers.
+
+### NeatSpecies
+
+NEAT species collection entry surface used by dashboard telemetry.
+
+### NumericTelemetryMap
+
+### OperatorStatsEntry
+
+Operator stats entry from NEAT.
+
+### RuntimeDashboardManager
+
+Compatibility alias for older runtime-facing imports.
+
+### SolvedMazeRecord
+
+Stored solved-maze archive entry.
+
+## dashboardManager/dashboardManager.ts
+
+### dashboardManager
+
+Public DashboardManager facade for the dedicated dashboardManager module boundary.
+
+The folder now owns local contracts, constants, pure formatting helpers, and
+stateful rendering and telemetry services. This facade keeps the established
+class-based API stable while delegating the heavy work to focused helpers.
+
+### DashboardManager
+
+Rich ASCII maze dashboard used by browser and terminal example hosts.
+
+#### getLastTelemetry
+
+`() => import("test/examples/asciiMaze/dashboardManager/dashboardManager.types").AsciiMazeTelemetrySnapshot`
+
+Return the latest public telemetry snapshot, including rich detail history when available.
+
+Returns: Latest dashboard telemetry snapshot.
+
+#### logFunction
+
+Optional log function exposed for engine-side safe-writer fallbacks.
+
+#### redraw
+
+`(currentMaze: string[], neat: unknown) => void`
+
+Clear and repaint the live dashboard using the current best candidate and histories.
+
+Parameters:
+- `currentMaze` - - Maze currently shown in the live panel.
+- `neat` - - Optional NEAT instance used to enrich stats.
+
+#### reset
+
+`() => void`
+
+Clear archive, current best, and telemetry state so the instance can be reused.
+
+#### update
+
+`(maze: string[], result: import("test/examples/asciiMaze/interfaces").IMazeRunResult | undefined, network: import("test/examples/asciiMaze/interfaces").INetwork | null, generation: number, neatInstance: import("src/neat").default | undefined) => void`
+
+Ingest one evolution update, refresh the live dashboard, and emit telemetry.
+
+Parameters:
+- `maze` - - Current maze layout.
+- `result` - - Latest run result for the tracked candidate.
+- `network` - - Candidate network used for the run.
+- `generation` - - Current generation number.
+- `neatInstance` - - Optional NEAT runtime used for advanced telemetry.
+
+## dashboardManager/dashboardManager.services.ts
+
+### applyDashboardUpdate
+
+`(context: import("test/examples/asciiMaze/dashboardManager/dashboardManager.types").DashboardManagerContext, args: import("test/examples/asciiMaze/dashboardManager/dashboardManager.types").DashboardManagerUpdateArgs) => void`
+
+Ingest one engine update, refresh the live view, and emit external telemetry.
+
+Parameters:
+- `context` - - Dashboard runtime context for state and output callbacks.
+- `args` - - Latest update payload from the evolution engine.
+
+### getDashboardLastTelemetry
+
+`(state: import("test/examples/asciiMaze/dashboardManager/dashboardManager.types").DashboardManagerState) => import("test/examples/asciiMaze/dashboardManager/dashboardManager.types").AsciiMazeTelemetrySnapshot`
+
+Produce the latest public telemetry snapshot from current dashboard state.
+
+Parameters:
+- `state` - - Mutable dashboard state.
+
+Returns: Public telemetry snapshot used by browser hosts.
+
+### redrawDashboard
+
+`(context: import("test/examples/asciiMaze/dashboardManager/dashboardManager.types").DashboardManagerContext, currentMaze: string[], neat: unknown) => void`
+
+Repaint the live dashboard from current state and refresh the detailed snapshot.
+
+Parameters:
+- `context` - - Dashboard runtime context for state and output callbacks.
+- `currentMaze` - - Maze currently being evolved.
+- `neat` - - Optional NEAT runtime instance used for detailed stats.
+
+### resetDashboardState
+
+`(state: import("test/examples/asciiMaze/dashboardManager/dashboardManager.types").DashboardManagerState) => void`
+
+Clear retained archive, best-candidate, and history state for a fresh run.
+
+Parameters:
+- `state` - - Mutable dashboard state to clear.
+
+## dashboardManager/dashboardManager.constants.ts
+
+### dashboardManager.constants
+
+Shared sizing, formatting, and top-N limits for the ASCII maze dashboard.
+
+These values are kept in one place so rendering, archive output, and
+telemetry helpers stay visually and semantically aligned.
+
+### DASHBOARD_MANAGER_CONSTANTS
+
+## dashboardManager/dashboardManager.utils.ts
+
+### buildDashboardSparkline
+
+`(series: number[], width: number) => string`
+
+Convert the recent tail of a numeric series into a compact sparkline.
+
+Parameters:
+- `series` - - Numeric history in chronological order.
+- `width` - - Maximum sample count included in the sparkline.
+
+Returns: Unicode sparkline string.
+
+### computeDashboardPathMetrics
+
+`(maze: string[], result: Pick<import("test/examples/asciiMaze/interfaces").IMazeRunResult, "path" | "steps" | "fitness">) => { optimalLength: number; pathLength: number; efficiencyPct: string; overheadPct: string; uniqueCellsVisited: number; revisitedCells: number; totalSteps: number; fitnessValue: number; }`
+
+Compute solved-path efficiency and visitation metrics for archive output.
+
+Parameters:
+- `maze` - - Maze layout containing start and exit markers.
+- `result` - - Run result with path, steps, and fitness.
+
+Returns: Derived path metrics used by solved archive formatting.
+
+### deriveDashboardArchitecture
+
+`(networkInstance: import("test/examples/asciiMaze/interfaces").INetwork | null | undefined) => string`
+
+Infer a compact architecture string from a network-like runtime object.
+
+Parameters:
+- `networkInstance` - - Network instance from the maze example runtime.
+
+Returns: Architecture string such as `6 - 8 - 4`, or `n/a` when unavailable.
+
+### formatDashboardStat
+
+`(label: string, value: string | number, colorLabel: string, colorValue: string, labelWidth: number) => string`
+
+Format a single framed dashboard stat line with aligned label and value columns.
+
+Parameters:
+- `label` - - Descriptive stat label.
+- `value` - - String or number value displayed after the label.
+- `colorLabel` - - Color token applied to the label segment.
+- `colorValue` - - Color token applied to the value segment.
+- `labelWidth` - - Fixed width used for the label column.
+
+Returns: Ready-to-log framed stat line.
+
+### getDashboardMazeKey
+
+`(maze: string[]) => string`
+
+Build a lightweight dedupe key for a maze layout.
+
+Parameters:
+- `maze` - - Maze rows in display order.
+
+Returns: Joined maze key used by the solved archive.
+
+### sliceDashboardHistoryForExport
+
+`(history: number[] | null | undefined) => number[]`
+
+Return the recent export window of a bounded numeric history buffer.
+
+Parameters:
+- `history` - - History buffer in chronological order.
+
+Returns: Independent tail slice suitable for telemetry export.

package/test/examples/asciiMaze/dashboardManager/archive/README.md

@@ -0,0 +1,16 @@
+# dashboardManager/archive
+
+## dashboardManager/archive/dashboardManager.archive.services.ts
+
+### recordSolvedMaze
+
+`(context: import("test/examples/asciiMaze/dashboardManager/dashboardManager.types").DashboardManagerContext, maze: string[], result: import("test/examples/asciiMaze/interfaces").IMazeRunResult, network: import("test/examples/asciiMaze/interfaces").INetwork, generation: number) => void`
+
+Record and emit a newly solved maze archive block when the layout has not been seen before.
+
+Parameters:
+- `context` - - Dashboard runtime context containing archive state and callbacks.
+- `maze` - - Solved maze layout.
+- `result` - - Successful run result used for archive stats.
+- `network` - - Network that solved the maze.
+- `generation` - - Generation number at solve time.

package/test/examples/asciiMaze/dashboardManager/archive/dashboardManager.archive.services.ts

@@ -0,0 +1,267 @@
+import { colors } from '../../colors';
+import type { IMazeRunResult, INetwork } from '../../interfaces';
+import { MazeVisualization } from '../../mazeVisualization';
+import { NetworkVisualization } from '../../networkVisualization';
+import { DASHBOARD_MANAGER_CONSTANTS as C } from '../dashboardManager.constants';
+import type {
+  DashboardManagerContext,
+  SolvedMazeRecord,
+} from '../dashboardManager.types';
+import {
+  buildDashboardSparkline,
+  computeDashboardPathMetrics,
+  deriveDashboardArchitecture,
+  getDashboardMazeKey,
+} from '../dashboardManager.utils';
+
+let cachedSolvedFooterBorder: string | null = null;
+
+/**
+ * Record and emit a newly solved maze archive block when the layout has not been seen before.
+ *
+ * @param context - Dashboard runtime context containing archive state and callbacks.
+ * @param maze - Solved maze layout.
+ * @param result - Successful run result used for archive stats.
+ * @param network - Network that solved the maze.
+ * @param generation - Generation number at solve time.
+ */
+export function recordSolvedMaze(
+  context: DashboardManagerContext,
+  maze: string[],
+  result: IMazeRunResult,
+  network: INetwork,
+  generation: number,
+): void {
+  const { state } = context;
+  const solvedMazeKey = getDashboardMazeKey(maze);
+  if (state.solvedMazeKeys.has(solvedMazeKey)) return;
+
+  const solvedRecord: SolvedMazeRecord = { maze, result, network, generation };
+  state.solvedMazes.push(solvedRecord);
+  state.solvedMazeKeys.add(solvedMazeKey);
+  appendSolvedToArchive(context, solvedRecord, state.solvedMazes.length);
+}
+
+function appendSolvedToArchive(
+  context: DashboardManagerContext,
+  solved: SolvedMazeRecord,
+  displayNumber: number,
+): void {
+  if (!context.archiveFn) return;
+
+  const blockLines: string[] = [];
+  appendSolvedHeader(blockLines, solved, displayNumber);
+  appendSolvedSparklines(context, blockLines, solved.network);
+  appendSolvedMaze(blockLines, solved);
+  appendSolvedPathStats(context, blockLines, solved);
+  appendSolvedFooterAndEmit(context.archiveFn, blockLines);
+}
+
+function appendSolvedHeader(
+  blockLines: string[],
+  solved: SolvedMazeRecord,
+  displayNumber: number,
+): void {
+  const rawFitness = solved.result?.fitness;
+  const formattedFitness =
+    typeof rawFitness === 'number' && Number.isFinite(rawFitness)
+      ? rawFitness.toFixed(2)
+      : 'n/a';
+  const title = ` SOLVED #${Math.max(1, displayNumber)} (GEN ${solved.generation})  FITNESS ${formattedFitness} `;
+  const leftPaddingSize = Math.max(
+    0,
+    Math.floor((C.FRAME_INNER_WIDTH - title.length) / 2),
+  );
+  const rightPaddingSize = Math.max(
+    0,
+    C.FRAME_INNER_WIDTH - title.length - leftPaddingSize,
+  );
+
+  blockLines.push(
+    `${colors.blueCore}╔${NetworkVisualization.pad(
+      '═'.repeat(C.FRAME_INNER_WIDTH),
+      C.FRAME_INNER_WIDTH,
+      '═',
+    )}╗${colors.reset}`,
+  );
+  blockLines.push(
+    `${colors.blueCore}║${' '.repeat(leftPaddingSize)}${colors.orangeNeon}${title}${colors.blueCore}${' '.repeat(rightPaddingSize)}║${colors.reset}`,
+  );
+  blockLines.push(
+    `${colors.blueCore}║${NetworkVisualization.pad(' ', C.FRAME_INNER_WIDTH, ' ')}║${colors.reset}`,
+  );
+}
+
+function appendSolvedSparklines(
+  context: DashboardManagerContext,
+  blockLines: string[],
+  network?: INetwork | null,
+): void {
+  const pushIfPresent = (label: string, value: string | null | undefined) => {
+    if (!value) return;
+    blockLines.push(
+      context.formatStat(
+        label,
+        value,
+        colors.neonSilver,
+        colors.cyanNeon,
+        C.SOLVED_LABEL_WIDTH,
+      ),
+    );
+  };
+
+  const architecture = deriveDashboardArchitecture(network);
+  if (architecture !== 'n/a') {
+    pushIfPresent(C.LABEL_ARCH, architecture.split(/\s*-\s*/).join(' <=> '));
+  }
+
+  const { histories } = context.state;
+  pushIfPresent(
+    'Fitness trend',
+    buildDashboardSparkline(histories.bestFitness, C.ARCHIVE_SPARK_WIDTH),
+  );
+  pushIfPresent(
+    'Nodes trend',
+    buildDashboardSparkline(histories.complexityNodes, C.ARCHIVE_SPARK_WIDTH),
+  );
+  pushIfPresent(
+    'Conns trend',
+    buildDashboardSparkline(histories.complexityConns, C.ARCHIVE_SPARK_WIDTH),
+  );
+  pushIfPresent(
+    'Hypervol trend',
+    buildDashboardSparkline(histories.hypervolume, C.ARCHIVE_SPARK_WIDTH),
+  );
+  pushIfPresent(
+    'Progress trend',
+    buildDashboardSparkline(histories.progress, C.ARCHIVE_SPARK_WIDTH),
+  );
+  pushIfPresent(
+    'Species trend',
+    buildDashboardSparkline(histories.speciesCount, C.ARCHIVE_SPARK_WIDTH),
+  );
+
+  blockLines.push(
+    `${colors.blueCore}║${NetworkVisualization.pad(' ', C.FRAME_INNER_WIDTH, ' ')}${colors.blueCore}║${colors.reset}`,
+  );
+}
+
+function appendSolvedMaze(
+  blockLines: string[],
+  solved: Pick<SolvedMazeRecord, 'maze' | 'result'>,
+): void {
+  const pathCoordinates = solved.result.path;
+  const endPosition = pathCoordinates?.at(-1) ?? [0, 0];
+  const visualization = MazeVisualization.visualizeMaze(
+    solved.maze,
+    endPosition as [number, number],
+    pathCoordinates,
+  );
+  const rawLines = Array.isArray(visualization)
+    ? visualization
+    : visualization.split('\n');
+
+  for (const rawLine of rawLines) {
+    const paddedRow = NetworkVisualization.pad(
+      rawLine,
+      C.FRAME_INNER_WIDTH,
+      ' ',
+    );
+    blockLines.push(
+      `${colors.blueCore}║${NetworkVisualization.pad(
+        paddedRow,
+        C.FRAME_INNER_WIDTH,
+        ' ',
+      )}${colors.blueCore}║${colors.reset}`,
+    );
+  }
+}
+
+function appendSolvedPathStats(
+  context: DashboardManagerContext,
+  blockLines: string[],
+  solved: Pick<SolvedMazeRecord, 'maze' | 'result'>,
+): void {
+  const metrics = computeDashboardPathMetrics(solved.maze, solved.result);
+  blockLines.push(
+    context.formatStat(
+      C.LABEL_PATH_EFF,
+      `${metrics.optimalLength}/${metrics.pathLength} (${metrics.efficiencyPct}%)`,
+      colors.neonSilver,
+      colors.cyanNeon,
+      C.SOLVED_LABEL_WIDTH,
+    ),
+  );
+  blockLines.push(
+    context.formatStat(
+      C.LABEL_PATH_OVER,
+      `${metrics.overheadPct}% longer than optimal`,
+      colors.neonSilver,
+      colors.cyanNeon,
+      C.SOLVED_LABEL_WIDTH,
+    ),
+  );
+  blockLines.push(
+    context.formatStat(
+      C.LABEL_UNIQUE,
+      `${metrics.uniqueCellsVisited}`,
+      colors.neonSilver,
+      colors.cyanNeon,
+      C.SOLVED_LABEL_WIDTH,
+    ),
+  );
+  blockLines.push(
+    context.formatStat(
+      C.LABEL_REVISITS,
+      `${metrics.revisitedCells} times`,
+      colors.neonSilver,
+      colors.cyanNeon,
+      C.SOLVED_LABEL_WIDTH,
+    ),
+  );
+  blockLines.push(
+    context.formatStat(
+      C.LABEL_STEPS,
+      `${metrics.totalSteps}`,
+      colors.neonSilver,
+      colors.cyanNeon,
+      C.SOLVED_LABEL_WIDTH,
+    ),
+  );
+  blockLines.push(
+    context.formatStat(
+      C.LABEL_FITNESS,
+      `${metrics.fitnessValue.toFixed(2)}`,
+      colors.neonSilver,
+      colors.cyanNeon,
+      C.SOLVED_LABEL_WIDTH,
+    ),
+  );
+}
+
+function appendSolvedFooterAndEmit(
+  archiveFn: (...args: unknown[]) => void,
+  blockLines: string[],
+): void {
+  if (cachedSolvedFooterBorder === null) {
+    cachedSolvedFooterBorder = `${colors.blueCore}╚${NetworkVisualization.pad(
+      '═'.repeat(C.FRAME_INNER_WIDTH),
+      C.FRAME_INNER_WIDTH,
+      '═',
+    )}╝${colors.reset}`;
+  }
+
+  blockLines.push(cachedSolvedFooterBorder);
+  try {
+    const archiveEmitter = archiveFn as (
+      payload: string,
+      options?: { prepend?: boolean },
+    ) => void;
+    archiveEmitter(blockLines.join('\n'), { prepend: true });
+  } catch {
+    for (const lineValue of blockLines) {
+      archiveFn(lineValue);
+    }
+  }
+  blockLines.length = 0;
+}

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

@@ -0,0 +1,35 @@
+/**
+ * Shared sizing, formatting, and top-N limits for the ASCII maze dashboard.
+ *
+ * These values are kept in one place so rendering, archive output, and
+ * telemetry helpers stay visually and semantically aligned.
+ */
+export const DASHBOARD_MANAGER_CONSTANTS = {
+  HISTORY_MAX: 500,
+  FRAME_INNER_WIDTH: 148,
+  LEFT_PADDING: 7,
+  RIGHT_PADDING: 1,
+  CONTENT_WIDTH: 148 - 7 - 1,
+  STAT_LABEL_WIDTH: 28,
+  ARCHIVE_SPARK_WIDTH: 64,
+  GENERAL_SPARK_WIDTH: 64,
+  SOLVED_LABEL_WIDTH: 22,
+  HISTORY_EXPORT_WINDOW: 200,
+  SPARK_BLOCKS: Object.freeze(['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█']),
+  DELTA_EPSILON: 1e-9,
+  TOP_OPERATOR_LIMIT: 6,
+  TOP_MUTATION_LIMIT: 8,
+  TOP_SPECIES_LIMIT: 5,
+  LAYER_INFER_LOOP_MULTIPLIER: 4,
+  LABEL_PATH_EFF: 'Path efficiency',
+  LABEL_PATH_OVER: 'Path overhead',
+  LABEL_UNIQUE: 'Unique cells visited',
+  LABEL_REVISITS: 'Cells revisited',
+  LABEL_STEPS: 'Steps',
+  LABEL_FITNESS: 'Fitness',
+  LABEL_ARCH: 'Architecture',
+  FRAME_SINGLE_LINE_CHAR: '═',
+  FRAME_BRIDGE_TOP: '╦════════════╦',
+  FRAME_BRIDGE_BOTTOM: '╩════════════╩',
+  EVOLVING_SECTION_LINE: '══════════════════════',
+} as const;

package/test/examples/asciiMaze/dashboardManager/dashboardManager.services.ts

@@ -0,0 +1,103 @@
+import type {
+  AsciiMazeTelemetrySnapshot,
+  DashboardManagerContext,
+  DashboardManagerState,
+  DashboardManagerUpdateArgs,
+} from './dashboardManager.types';
+import { recordSolvedMaze } from './archive/dashboardManager.archive.services';
+import { redrawDashboard as redrawDashboardLive } from './live/dashboardManager.live.services';
+import {
+  emitTelemetryPayload,
+  getDashboardLastTelemetry as getDashboardLastTelemetrySnapshot,
+  updateTelemetryHistory,
+} from './telemetry/dashboardManager.telemetry.services';
+
+/**
+ * Repaint the live dashboard from current state and refresh the detailed snapshot.
+ *
+ * @param context - Dashboard runtime context for state and output callbacks.
+ * @param currentMaze - Maze currently being evolved.
+ * @param neat - Optional NEAT runtime instance used for detailed stats.
+ */
+export function redrawDashboard(
+  context: DashboardManagerContext,
+  currentMaze: string[],
+  neat?: unknown,
+): void {
+  redrawDashboardLive(context, currentMaze, neat);
+}
+
+/**
+ * Ingest one engine update, refresh the live view, and emit external telemetry.
+ *
+ * @param context - Dashboard runtime context for state and output callbacks.
+ * @param args - Latest update payload from the evolution engine.
+ */
+export function applyDashboardUpdate(
+  context: DashboardManagerContext,
+  args: DashboardManagerUpdateArgs,
+): void {
+  const { state } = context;
+  const { generation, maze, result, network, neatInstance, telemetryHook } =
+    args;
+
+  if (state.runStartTs == null) {
+    state.runStartTs = Date.now();
+    state.perfStart = globalThis.performance?.now?.() ?? state.runStartTs;
+  }
+
+  state.lastUpdateTs = globalThis.performance?.now?.() ?? Date.now();
+  state.lastGeneration = generation;
+
+  if (result) {
+    state.currentBest = { result, network, generation };
+  }
+
+  if (result?.success && network) {
+    recordSolvedMaze(context, maze, result, network, generation);
+  }
+
+  updateTelemetryHistory(state, neatInstance);
+  redrawDashboardLive(context, maze, neatInstance);
+  emitTelemetryPayload(state, generation, telemetryHook);
+}
+
+/**
+ * Produce the latest public telemetry snapshot from current dashboard state.
+ *
+ * @param state - Mutable dashboard state.
+ * @returns Public telemetry snapshot used by browser hosts.
+ */
+export function getDashboardLastTelemetry(
+  state: DashboardManagerState,
+): AsciiMazeTelemetrySnapshot {
+  return getDashboardLastTelemetrySnapshot(state);
+}
+
+/**
+ * Clear retained archive, best-candidate, and history state for a fresh run.
+ *
+ * @param state - Mutable dashboard state to clear.
+ */
+export function resetDashboardState(state: DashboardManagerState): void {
+  state.solvedMazes = [];
+  state.solvedMazeKeys.clear();
+  state.currentBest = null;
+  state.lastTelemetry = null;
+  state.lastBestFitness = null;
+  state.lastDetailedStats = null;
+  state.runStartTs = null;
+  state.perfStart = null;
+  state.lastGeneration = null;
+  state.lastUpdateTs = null;
+  state.histories.bestFitness = [];
+  state.histories.complexityNodes = [];
+  state.histories.complexityConns = [];
+  state.histories.hypervolume = [];
+  state.histories.progress = [];
+  state.histories.speciesCount = [];
+  state.scratch.scores.length = 0;
+  state.scratch.speciesSizes.length = 0;
+  state.scratch.operatorStats.length = 0;
+  state.scratch.mutationEntries.length = 0;
+}