@vgai/engine 0.2.0

package/src/adapter/world-kind.ts

@@ -0,0 +1,34 @@
+/**
+ * `WorldKind` — the kinds of render surface a world can be (T7.1/T7.3/T6.2).
+ *
+ * Moved here (T7.5, `docs/BACKBONE-TASKS.md`'s D6 row) from `runtime/game.ts`
+ * so `adapter/game-adapter.ts`'s kind-tagged `MountedWorld` types can name it
+ * without a value-level import cycle (`runtime/game.ts` type-imports from
+ * `adapter/game-adapter.ts` already). This is a leaf module — it imports
+ * nothing — so anything may import it with zero risk of a cycle.
+ * `runtime/game.ts` re-exports this SAME type (`export type { WorldKind }`),
+ * so no existing `import type { WorldKind } from '../runtime/game'` call site
+ * needed to change.
+ */
+export type WorldKind = 'threejs' | 'pixijs' | 'react';
+
+/**
+ * Exhaustiveness guard for `WorldKind` dispatch (v4 architecture-review
+ * §7.4-2: a hypothetical 4th kind must fail to COMPILE at every kind-dispatch
+ * site, not silently contribute nothing or silently default to an existing
+ * kind). Lives here — colocated with the kind vocabulary itself, not in a
+ * generic util module — so the three call sites that need it
+ * (`runtime/create-runtime.ts`'s mount loop, `editor/adapter-resolver.ts`'s
+ * `resolveAllWorlds`, `editor/play-mode.ts`'s `installMultiWorldAuthoring`)
+ * import it from the same leaf module that defines `WorldKind`, keeping the
+ * type and its guard from drifting apart. The `never` parameter is the
+ * compile-time half of the guard (TS refuses to call this with anything the
+ * compiler hasn't already narrowed to zero remaining variants); the thrown
+ * Error is the runtime half, in case a value's static type lied (e.g. data
+ * crossing a JSON boundary).
+ */
+export function assertNever(value: never, context?: string): never {
+  throw new Error(
+    `Unreachable${context ? ` ${context}` : ''}: unexpected value ${JSON.stringify(value)}`,
+  );
+}

package/src/ai/navigation.ts

@@ -0,0 +1,164 @@
+/**
+ * NavMeshManager — wraps recast-navigation for navmesh generation + crowd pathfinding.
+ *
+ * Usage:
+ *   await init();  // WASM init (call once per app)
+ *   const nav = new NavMeshManager();
+ *   await nav.buildFromMeshes(meshes);
+ *   const path = nav.findPath(start, end);
+ *   const crowd = nav.createCrowd(10);
+ *   // In game loop: nav.updateCrowd(dt);
+ */
+
+import { NavMeshHelper, threeToSoloNavMesh } from '@recast-navigation/three';
+import type { CrowdAgent, NavMesh } from 'recast-navigation';
+import { Crowd, exportNavMesh, importNavMesh, init, NavMeshQuery } from 'recast-navigation';
+import type { Mesh, Scene } from 'three';
+import { DEFAULTS } from '../scene/defaults';
+
+export type { CrowdAgent };
+
+export interface Vector3Like {
+  x: number;
+  y: number;
+  z: number;
+}
+
+export interface NavMeshBuildParams {
+  cellSize?: number | undefined;
+  cellHeight?: number | undefined;
+  walkableSlopeAngle?: number | undefined;
+  walkableHeight?: number | undefined;
+  walkableClimb?: number | undefined;
+  walkableRadius?: number | undefined;
+  maxEdgeLen?: number | undefined;
+  maxSimplificationError?: number | undefined;
+  minRegionArea?: number | undefined;
+  mergeRegionArea?: number | undefined;
+}
+
+let wasmInitialized = false;
+
+export async function initNavigation(): Promise<void> {
+  if (wasmInitialized) return;
+  await init();
+  wasmInitialized = true;
+}
+
+export class NavMeshManager {
+  private navMesh: NavMesh | null = null;
+  private query: NavMeshQuery | null = null;
+  private crowd: Crowd | null = null;
+  private helper: NavMeshHelper | null = null;
+
+  /** Build navmesh from Three.js Mesh objects (grounds, obstacles, etc.). */
+  buildFromMeshes(meshes: Mesh[], params?: NavMeshBuildParams): boolean {
+    const d = DEFAULTS.navigation;
+    const result = threeToSoloNavMesh(meshes, {
+      cs: params?.cellSize ?? d.cellSize,
+      ch: params?.cellHeight ?? d.cellHeight,
+      walkableSlopeAngle: params?.walkableSlopeAngle ?? d.walkableSlopeAngle,
+      walkableHeight: params?.walkableHeight ?? d.walkableHeight,
+      walkableClimb: params?.walkableClimb ?? d.walkableClimb,
+      walkableRadius: params?.walkableRadius ?? d.walkableRadius,
+      maxEdgeLen: params?.maxEdgeLen ?? d.maxEdgeLen,
+      maxSimplificationError: params?.maxSimplificationError ?? d.maxSimplificationError,
+      minRegionArea: params?.minRegionArea ?? d.minRegionArea,
+      mergeRegionArea: params?.mergeRegionArea ?? d.mergeRegionArea,
+      // Recast tuning knobs with no DEFAULTS counterpart (not modeled there).
+      maxVertsPerPoly: 6,
+      detailSampleDist: 6,
+      detailSampleMaxError: 1,
+    });
+
+    if (!result.success || !result.navMesh) return false;
+
+    // Free the previous recast objects before replacing them (WASM heap leak).
+    this.destroyRecast();
+    this.navMesh = result.navMesh;
+    this.query = new NavMeshQuery(this.navMesh);
+    return true;
+  }
+
+  /**
+   * Destroy all live recast handles (crowd, query, navmesh) and dispose the
+   * debug helper. Recast objects live on the WASM heap and are NOT GC'd —
+   * they must be explicitly `.destroy()`ed or they leak.
+   */
+  private destroyRecast(): void {
+    if (this.helper) {
+      this.helper.parent?.remove(this.helper);
+      (this.helper as unknown as { dispose?: () => void }).dispose?.();
+      this.helper = null;
+    }
+    if (this.crowd) {
+      this.crowd.destroy();
+      this.crowd = null;
+    }
+    if (this.query) {
+      this.query.destroy();
+      this.query = null;
+    }
+    if (this.navMesh) {
+      this.navMesh.destroy();
+      this.navMesh = null;
+    }
+  }
+
+  /** True once a navmesh has been built (for the NavigationAdapter to gate on). */
+  hasNavMesh(): boolean {
+    return this.navMesh !== null;
+  }
+
+  /** Find a straight path between two world positions. Returns [] if no path. */
+  findPath(start: Vector3Like, end: Vector3Like): Vector3Like[] {
+    if (!this.query) return [];
+    const result = this.query.computePath(start, end);
+    if (!result.success) return [];
+    return result.path;
+  }
+
+  /** Create a crowd with up to maxAgents agents. */
+  createCrowd(maxAgents: number): Crowd {
+    if (!this.navMesh) throw new Error('Build navmesh first');
+    this.crowd = new Crowd(this.navMesh, { maxAgents, maxAgentRadius: 0.6 });
+    return this.crowd;
+  }
+
+  /** Step the crowd simulation. Call once per frame. */
+  updateCrowd(dt: number): void {
+    this.crowd?.update(dt);
+  }
+
+  /** Get or create the wireframe debug mesh. Add to scene once, call update() after rebuilding. */
+  getDebugMesh(scene: Scene): NavMeshHelper | null {
+    if (!this.navMesh) return null;
+    if (!this.helper) {
+      this.helper = new NavMeshHelper(this.navMesh);
+      scene.add(this.helper);
+    }
+    return this.helper;
+  }
+
+  /** Serialize the current navmesh to a binary blob. */
+  exportData(): Uint8Array {
+    if (!this.navMesh) throw new Error('No navmesh to export');
+    return exportNavMesh(this.navMesh);
+  }
+
+  /** Load a navmesh from a previously exported binary blob. */
+  loadFromData(data: Uint8Array): void {
+    const { navMesh } = importNavMesh(data);
+    // Free the previous recast objects before replacing them.
+    this.destroyRecast();
+    this.navMesh = navMesh;
+    this.query = new NavMeshQuery(this.navMesh);
+  }
+
+  dispose(scene: Scene): void {
+    // Ensure the helper is removed from the passed scene as well, then destroy
+    // every recast handle (crowd/query/navmesh) so nothing leaks on the WASM heap.
+    if (this.helper) scene.remove(this.helper);
+    this.destroyRecast();
+  }
+}

package/src/animation/anim-graph-types.ts

@@ -0,0 +1,56 @@
+/** The .animgraph.json file format */
+export interface AnimGraphFile {
+  version: number;
+  parameters: Record<string, AnimParameter>;
+  layers: AnimLayer[];
+}
+
+export interface AnimParameter {
+  type: 'float' | 'int' | 'bool' | 'trigger';
+  default: number | boolean;
+}
+
+export interface AnimLayer {
+  name: string;
+  blendMode?: 'override' | 'additive';
+  weight?: number;
+  boneMask?: string[];
+  defaultState: string;
+  states: Record<string, AnimState>;
+  transitions: AnimTransition[];
+}
+
+export interface AnimState {
+  clip?: string;
+  loop?: boolean;
+  speed?: number;
+  blendTree?: BlendTreeDef;
+}
+
+export interface BlendTreeDef {
+  type: '1D' | '2D' | 'direct';
+  parameter: string;
+  parameterY?: string; // for 2D
+  children: BlendChild[];
+}
+
+export interface BlendChild {
+  clip: string;
+  threshold: number;
+  thresholdY?: number; // for 2D
+  weight?: number; // for direct
+}
+
+export interface AnimTransition {
+  from: string; // '*' = any state (wildcard)
+  to: string;
+  conditions?: TransitionCondition[];
+  duration: number; // crossfade duration in seconds
+  exitTime?: number; // normalized time (0-1) — transition can happen after this point in the clip
+}
+
+export interface TransitionCondition {
+  param: string;
+  op: '>' | '<' | '>=' | '<=' | '==' | '!=' | 'trigger';
+  value?: number | boolean;
+}

package/src/animation/anim-graph.ts

@@ -0,0 +1,406 @@
+import * as THREE from 'three';
+import type {
+  AnimGraphFile,
+  AnimLayer,
+  AnimState,
+  AnimTransition,
+  TransitionCondition,
+} from './anim-graph-types';
+import { evaluateBlendTree } from './blend-node';
+
+/**
+ * Runtime animation graph for a single entity.
+ *
+ * This is the core custom code that Three.js doesn't provide.
+ * Three.js AnimationMixer handles clip playback and crossfading.
+ * This adds: state machines, parameter-driven transitions, blend trees.
+ *
+ * Weight management: all AnimationActions are pre-played at creation with
+ * weight 0. Weights are set explicitly every frame — we never use Three.js's
+ * fadeIn/fadeOut, which can cause total weight to dip below 1.0 and flash
+ * the bind pose (T-pose).
+ *
+ * Usage:
+ *   const graph = new AnimGraph(mixer, graphData, clips);
+ *   graph.setParameter('speed', 5.0);
+ *   graph.update(dt); // call each frame
+ */
+export class AnimGraph {
+  private mixer: THREE.AnimationMixer;
+  private layers: LayerRuntime[] = [];
+  private parameters = new Map<string, number | boolean>();
+  private triggers = new Set<string>();
+
+  constructor(
+    mixer: THREE.AnimationMixer,
+    data: AnimGraphFile,
+    clips: Map<string, THREE.AnimationClip>,
+  ) {
+    this.mixer = mixer;
+
+    // Initialize parameters with defaults
+    for (const [name, param] of Object.entries(data.parameters)) {
+      this.parameters.set(name, param.default);
+    }
+
+    // Create runtime for each layer
+    for (const layerDef of data.layers) {
+      this.layers.push(new LayerRuntime(mixer, layerDef, clips));
+    }
+  }
+
+  /** The names of all declared parameters (for the AnimationAdapter to enumerate). */
+  parameterNames(): string[] {
+    return [...this.parameters.keys()];
+  }
+
+  /** Set a float/int/bool parameter */
+  setParameter(name: string, value: number | boolean) {
+    this.parameters.set(name, value);
+  }
+
+  /** Get a parameter value */
+  getParameter(name: string): number | boolean | undefined {
+    return this.parameters.get(name);
+  }
+
+  /** Fire a trigger (auto-resets after consumed by a transition) */
+  trigger(name: string) {
+    this.triggers.add(name);
+  }
+
+  /** Get the current state name for a layer (default: first layer) */
+  getCurrentState(layerIndex = 0): string {
+    return this.layers[layerIndex]?.currentState ?? '';
+  }
+
+  /** Update the animation graph. Call once per frame. */
+  update(dt: number) {
+    // Triggers persist until a transition actually consumes them — we do NOT
+    // clear every frame. A trigger fired mid-crossfade (when no transition can
+    // fire) survives until the layer is ready to act on it.
+    const consumed = new Set<string>();
+    for (const layer of this.layers) {
+      layer.update(dt, this.parameters, this.triggers, consumed);
+    }
+
+    // Clear only triggers that were consumed by a transition this frame.
+    for (const name of consumed) {
+      this.triggers.delete(name);
+    }
+
+    // Advance the mixer
+    this.mixer.update(dt);
+  }
+}
+
+/**
+ * Runtime state for a single animation layer.
+ */
+class LayerRuntime {
+  private mixer: THREE.AnimationMixer;
+  private states: Map<string, AnimState>;
+  private transitions: AnimTransition[];
+  private actionMap = new Map<string, THREE.AnimationAction>();
+  currentState: string;
+  private previousState = '';
+  private stateTime = 0;
+  private stateDuration = 0;
+  private transitioning = false;
+  private transitionElapsed = 0;
+  private transitionDuration = 0;
+
+  constructor(
+    mixer: THREE.AnimationMixer,
+    layerDef: AnimLayer,
+    clips: Map<string, THREE.AnimationClip>,
+  ) {
+    this.mixer = mixer;
+    this.states = new Map(Object.entries(layerDef.states));
+    this.transitions = layerDef.transitions;
+    this.currentState = layerDef.defaultState;
+
+    // Collect the (loop, speed) config each clip name is played with. A clip
+    // name is a key into a single shared THREE.AnimationAction (ensureAction
+    // dedupes by name), so two states — or a state and a blend-tree child —
+    // that reference the same clip with different loop/speed would silently
+    // let whichever state was processed first win, and the other's config
+    // would be dropped with no signal. Per-state clip config is deferred
+    // (no real need for it yet) — the correct behavior for now is a loud
+    // error at graph load, not silent last-write-wins.
+    const clipConfigs = new Map<string, { loop: boolean; speed: number; state: string }>();
+    for (const [stateName, state] of this.states) {
+      if (state.clip) {
+        this.registerClipConfig(
+          clipConfigs,
+          state.clip,
+          state.loop ?? true,
+          state.speed ?? 1,
+          stateName,
+        );
+      }
+      if (state.blendTree) {
+        for (const child of state.blendTree.children) {
+          this.registerClipConfig(clipConfigs, child.clip, true, 1, stateName);
+        }
+      }
+    }
+
+    // Create AnimationActions for all referenced clips.
+    // All actions are played immediately at weight 0 — they stay active in the
+    // mixer but contribute nothing visually until we raise their weight.
+    for (const [clipName, config] of clipConfigs) {
+      this.ensureAction(clipName, clips, config.loop, config.speed);
+    }
+
+    // Start default state
+    this.enterState(this.currentState, new Map());
+  }
+
+  /** Record a clip's (loop, speed) config, throwing if a prior state disagrees. */
+  private registerClipConfig(
+    configs: Map<string, { loop: boolean; speed: number; state: string }>,
+    clipName: string,
+    loop: boolean,
+    speed: number,
+    stateName: string,
+  ) {
+    const existing = configs.get(clipName);
+    if (existing && (existing.loop !== loop || existing.speed !== speed)) {
+      throw new Error(
+        `AnimGraph: clip "${clipName}" is configured inconsistently across states — ` +
+          `state "${existing.state}" uses loop=${existing.loop}/speed=${existing.speed}, ` +
+          `but state "${stateName}" uses loop=${loop}/speed=${speed}. ` +
+          `Per-state clip config is not supported: every state (and blend-tree child) that ` +
+          `plays a given clip must agree on its loop/speed.`,
+      );
+    }
+    if (!existing) configs.set(clipName, { loop, speed, state: stateName });
+  }
+
+  private ensureAction(
+    clipName: string,
+    clips: Map<string, THREE.AnimationClip>,
+    loop: boolean,
+    speed: number,
+  ) {
+    if (this.actionMap.has(clipName)) return;
+    const clip = clips.get(clipName);
+    if (!clip) return;
+
+    const action = this.mixer.clipAction(clip);
+    action.setLoop(loop ? THREE.LoopRepeat : THREE.LoopOnce, Infinity);
+    action.clampWhenFinished = !loop;
+    action.timeScale = speed;
+    action.setEffectiveWeight(0);
+    action.play();
+    this.actionMap.set(clipName, action);
+  }
+
+  private enterState(stateName: string, parameters: Map<string, number | boolean>) {
+    const state = this.states.get(stateName);
+    if (!state) return;
+
+    this.currentState = stateName;
+    this.stateTime = 0;
+    this.transitioning = false;
+
+    // Zero all, then set the entering state to full weight
+    this.zeroAllWeights();
+
+    if (state.clip) {
+      const action = this.actionMap.get(state.clip);
+      if (action) {
+        action.reset();
+        action.setEffectiveWeight(1);
+        action.play();
+        this.stateDuration = action.getClip().duration;
+      }
+    }
+
+    if (state.blendTree) {
+      const weights = evaluateBlendTree(state.blendTree, parameters);
+      this.setWeights(weights, 1);
+      const heaviest = weights.reduce((a, b) => (b.weight > a.weight ? b : a), weights[0]!);
+      const action = this.actionMap.get(heaviest.clip);
+      this.stateDuration = action?.getClip().duration ?? 1;
+    }
+  }
+
+  /** Zero all action weights. */
+  private zeroAllWeights() {
+    for (const action of this.actionMap.values()) {
+      action.setEffectiveWeight(0);
+    }
+  }
+
+  /** Set weights for a list of clip/weight pairs, multiplied by a scale factor. */
+  private setWeights(weights: { clip: string; weight: number }[], scale: number) {
+    for (const { clip, weight } of weights) {
+      const action = this.actionMap.get(clip);
+      if (action) {
+        action.setEffectiveWeight(weight * scale);
+      }
+    }
+  }
+
+  /** Get the weight list for a state (single clip at weight 1, or blend tree evaluated). */
+  private getStateWeights(
+    stateName: string,
+    parameters: Map<string, number | boolean>,
+  ): { clip: string; weight: number }[] {
+    const state = this.states.get(stateName);
+    if (!state) return [];
+    if (state.clip) return [{ clip: state.clip, weight: 1 }];
+    if (state.blendTree) return evaluateBlendTree(state.blendTree, parameters);
+    return [];
+  }
+
+  update(
+    dt: number,
+    parameters: Map<string, number | boolean>,
+    triggers: Set<string>,
+    consumed: Set<string>,
+  ) {
+    this.stateTime += dt;
+    const normalizedTime = this.stateDuration > 0 ? this.stateTime / this.stateDuration : 1;
+
+    // Zero all weights, then set them based on current (and previous) state.
+    // This guarantees total weight = 1.0 every frame — no bind-pose bleed.
+    this.zeroAllWeights();
+
+    if (this.transitioning) {
+      this.transitionElapsed += dt;
+      const alpha = Math.min(this.transitionElapsed / this.transitionDuration, 1);
+
+      // Crossfade: outgoing * (1 - alpha) + incoming * alpha — sums to exactly 1.0
+      this.setWeights(this.getStateWeights(this.previousState, parameters), 1 - alpha);
+      this.setWeights(this.getStateWeights(this.currentState, parameters), alpha);
+
+      if (alpha >= 1) {
+        this.transitioning = false;
+      }
+      return;
+    }
+
+    // Not transitioning — current state at full weight
+    this.setWeights(this.getStateWeights(this.currentState, parameters), 1);
+
+    // Check transitions
+    for (const transition of this.transitions) {
+      // Match: exact state or wildcard
+      if (transition.from !== '*' && transition.from !== this.currentState) continue;
+      // A wildcard transition must never re-enter the state we're already in —
+      // otherwise a wildcard whose condition stays true fires every single
+      // frame (performTransition resets the action to time 0 each time), so
+      // the state is "entered" over and over and its animation never advances
+      // past frame 0. An explicit from:X→to:X self-transition is a deliberate
+      // restart and is allowed to fire.
+      if (transition.from === '*' && transition.to === this.currentState) continue;
+
+      // Check exit time
+      if (transition.exitTime !== undefined && normalizedTime < transition.exitTime) continue;
+
+      // Check conditions
+      if (
+        transition.conditions &&
+        !this.checkConditions(transition.conditions, parameters, triggers)
+      ) {
+        continue;
+      }
+
+      // Transition! Mark any trigger conditions as consumed so the graph
+      // clears them after all layers have had a chance to react this frame.
+      if (transition.conditions) {
+        for (const cond of transition.conditions) {
+          if (cond.op === 'trigger') consumed.add(cond.param);
+        }
+      }
+      this.performTransition(transition, parameters);
+      return;
+    }
+  }
+
+  private checkConditions(
+    conditions: TransitionCondition[],
+    parameters: Map<string, number | boolean>,
+    triggers: Set<string>,
+  ): boolean {
+    for (const cond of conditions) {
+      if (cond.op === 'trigger') {
+        if (!triggers.has(cond.param)) return false;
+        continue;
+      }
+
+      const paramVal = parameters.get(cond.param);
+      if (paramVal === undefined) return false;
+
+      const a = Number(paramVal);
+      const b = Number(cond.value ?? 0);
+
+      switch (cond.op) {
+        case '>':
+          if (!(a > b)) return false;
+          break;
+        case '<':
+          if (!(a < b)) return false;
+          break;
+        case '>=':
+          if (!(a >= b)) return false;
+          break;
+        case '<=':
+          if (!(a <= b)) return false;
+          break;
+        case '==':
+          if (paramVal !== cond.value && a !== b) return false;
+          break;
+        case '!=':
+          if (paramVal === cond.value || a === b) return false;
+          break;
+      }
+    }
+    return true;
+  }
+
+  private performTransition(transition: AnimTransition, parameters: Map<string, number | boolean>) {
+    const toState = this.states.get(transition.to);
+    if (!toState) return;
+
+    this.previousState = this.currentState;
+    this.currentState = transition.to;
+    this.stateTime = 0;
+    this.transitioning = true;
+    this.transitionElapsed = 0;
+    this.transitionDuration = transition.duration;
+
+    // Reset incoming actions to time=0 so they start fresh.
+    // No fadeIn/fadeOut — weights are managed explicitly in update().
+    if (toState.clip) {
+      const action = this.actionMap.get(toState.clip);
+      if (action) {
+        action.reset();
+        action.play();
+      }
+    }
+    if (toState.blendTree) {
+      for (const child of toState.blendTree.children) {
+        const action = this.actionMap.get(child.clip);
+        if (action) {
+          action.reset();
+          action.play();
+        }
+      }
+    }
+
+    // Estimate state duration for exitTime calculations
+    if (toState.clip) {
+      const action = this.actionMap.get(toState.clip);
+      this.stateDuration = action?.getClip().duration ?? 1;
+    } else if (toState.blendTree) {
+      const weights = evaluateBlendTree(toState.blendTree, parameters);
+      const heaviest = weights.reduce((a, b) => (b.weight > a.weight ? b : a), weights[0]!);
+      const action = this.actionMap.get(heaviest.clip);
+      this.stateDuration = action?.getClip().duration ?? 1;
+    }
+  }
+}

package/src/animation/anim-system.ts

@@ -0,0 +1,28 @@
+import type * as THREE from 'three';
+import type { AnimGraph } from './anim-graph';
+
+/**
+ * Registry of active animation graphs, keyed by Object3D (the entity).
+ *
+ * AnimGraph wraps a THREE.AnimationMixer (a class instance), so it can't live in
+ * a flat data store — we keep a simple Map<Object3D, AnimGraph> and update each
+ * one every frame. Each runtime owns its own map (see createGameRuntime) so that
+ * multiple concurrent runtimes never cross-contaminate each other's graphs.
+ *
+ * Usage:
+ *   const animGraphs: AnimGraphMap = new Map();
+ *   animGraphs.set(playerObject3D, new AnimGraph(mixer, data, clips));
+ *   // In system runner:
+ *   systems.add('animation', (dt) => animationSystem(animGraphs, dt));
+ */
+export type AnimGraphMap = Map<THREE.Object3D, AnimGraph>;
+
+/**
+ * Updates all active animation graphs.
+ * Call this in the ANIMATION phase.
+ */
+export function animationSystem(graphs: AnimGraphMap, dt: number) {
+  for (const graph of graphs.values()) {
+    graph.update(dt);
+  }
+}