@vgai/engine 0.5.42 → 0.5.44

package/src/index.ts

@@ -32,7 +32,7 @@ export type {
   ResolvedGameManifest,
   RootAdapter,
 } from './manifest';
-export { DEFAULT_SERVER_MODULE, loadGameManifest } from './manifest';
+export { loadGameManifest } from './manifest';
 export type { GameSession } from './runtime/create-runtime';
 export type {
   MountEntry,

package/src/input/host-pointer.ts

@@ -72,6 +72,8 @@ export interface HostPointerTouch {
    * differently is holding a button nothing will ever release.
    */
   readonly phase: 'start' | 'move' | 'end';
+  /** True only when the browser ended this contact with `pointercancel`. */
+  readonly canceled: boolean;
   /**
    * DENSE finger index — the lowest slot free when this finger went down, and
    * free again the moment it lifts. NOT the browser's `pointerId`, which never
@@ -80,6 +82,22 @@ export interface HostPointerTouch {
   readonly index: number;
   /** Position in the design space (see {@link HostPointerOptions.designSize}). */
   readonly position: Vector2;
+  /** Position before design-resolution scaling, in surface CSS pixels. */
+  readonly screenPosition: Vector2;
+  /** Delta since this contact's preceding sample, in design pixels. */
+  readonly relative: Vector2;
+  /** Delta since this contact's preceding sample, in surface CSS pixels. */
+  readonly screenRelative: Vector2;
+  /** Design-pixel velocity derived from the browser event timestamps. */
+  readonly velocity: Vector2;
+  /** Surface CSS-pixel velocity derived from the browser event timestamps. */
+  readonly screenVelocity: Vector2;
+  /** Native PointerEvent pressure in the normalized [0, 1] range. */
+  readonly pressure: number;
+  /** Native PointerEvent tilt, in degrees. Touch contacts normally report zero. */
+  readonly tilt: Vector2;
+  /** Touch pointers are never an inverted pen; retained for Godot's event value contract. */
+  readonly penInverted: false;
 }
 
 /** What {@link createHostPointer} needs. */
@@ -141,6 +159,14 @@ export function createHostPointer(options: HostPointerOptions): HostPointer {
   const touches: HostPointerTouch[] = [];
   /** Browser `pointerId` -> dense finger index, for fingers currently down. */
   const fingerOfPointer = new Map<number, number>();
+  const sampleOfPointer = new Map<
+    number,
+    {
+      readonly position: Vector2;
+      readonly screenPosition: Vector2;
+      readonly timestamp: number;
+    }
+  >();
   const freeFinger = (): number => {
     const taken = new Set(fingerOfPointer.values());
     let index = 0;
@@ -152,11 +178,52 @@ export function createHostPointer(options: HostPointerOptions): HostPointer {
     if (touches.length > TOUCH_QUEUE_MAX) touches.shift();
   };
 
-  const queueTouch = (event: PointerEvent, point: Vector2): void => {
+  const queueTouch = (event: PointerEvent, point: Vector2, screenPoint: Vector2): void => {
+    const previous = sampleOfPointer.get(event.pointerId);
+    const relative =
+      previous === undefined
+        ? { x: 0, y: 0 }
+        : { x: point.x - previous.position.x, y: point.y - previous.position.y };
+    const screenRelative =
+      previous === undefined
+        ? { x: 0, y: 0 }
+        : {
+            x: screenPoint.x - previous.screenPosition.x,
+            y: screenPoint.y - previous.screenPosition.y,
+          };
+    const elapsedSeconds =
+      previous === undefined ? 0 : Math.max(0, event.timeStamp - previous.timestamp) / 1000;
+    const velocity =
+      elapsedSeconds > 0
+        ? { x: relative.x / elapsedSeconds, y: relative.y / elapsedSeconds }
+        : { x: 0, y: 0 };
+    const screenVelocity =
+      elapsedSeconds > 0
+        ? { x: screenRelative.x / elapsedSeconds, y: screenRelative.y / elapsedSeconds }
+        : { x: 0, y: 0 };
+    const common = {
+      position: point,
+      screenPosition: screenPoint,
+      relative,
+      screenRelative,
+      velocity,
+      screenVelocity,
+      pressure: Number.isFinite(event.pressure) ? Math.max(0, Math.min(1, event.pressure)) : 0,
+      tilt: {
+        x: Number.isFinite(event.tiltX) ? event.tiltX : 0,
+        y: Number.isFinite(event.tiltY) ? event.tiltY : 0,
+      },
+      penInverted: false as const,
+    };
     if (event.type === 'pointerdown') {
       const index = freeFinger();
       fingerOfPointer.set(event.pointerId, index);
-      queue({ phase: 'start', index, position: point });
+      sampleOfPointer.set(event.pointerId, {
+        position: point,
+        screenPosition: screenPoint,
+        timestamp: event.timeStamp,
+      });
+      queue({ phase: 'start', canceled: false, index, ...common });
       return;
     }
     // A move or a release from a pointer that never went down on this surface
@@ -165,10 +232,21 @@ export function createHostPointer(options: HostPointerOptions): HostPointer {
     if (index === undefined) return;
     if (event.type === 'pointerup' || event.type === 'pointercancel') {
       fingerOfPointer.delete(event.pointerId);
-      queue({ phase: 'end', index, position: point });
+      sampleOfPointer.delete(event.pointerId);
+      queue({
+        phase: 'end',
+        canceled: event.type === 'pointercancel',
+        index,
+        ...common,
+      });
       return;
     }
-    queue({ phase: 'move', index, position: point });
+    sampleOfPointer.set(event.pointerId, {
+      position: point,
+      screenPosition: screenPoint,
+      timestamp: event.timeStamp,
+    });
+    queue({ phase: 'move', canceled: false, index, ...common });
   };
 
   /** A client-space event as a point in the design space, via the surface rect
@@ -188,6 +266,7 @@ export function createHostPointer(options: HostPointerOptions): HostPointer {
     if (surface === null) return;
     const rect = surface.getBoundingClientRect();
     if (rect.width <= 0 || rect.height <= 0) return;
+    const screenPoint = { x: event.clientX - rect.left, y: event.clientY - rect.top };
     const point = toDesignSpace(event, rect);
 
     if (event.type === 'pointermove') {
@@ -199,7 +278,7 @@ export function createHostPointer(options: HostPointerOptions): HostPointer {
     }
     // A mouse or a pen is not a finger. A control that answered them here would
     // steal the clicks of a player who cannot see it.
-    if (event.pointerType === 'touch') queueTouch(event, point);
+    if (event.pointerType === 'touch') queueTouch(event, point, screenPoint);
   };
 
   const KINDS = ['pointerdown', 'pointermove', 'pointerup', 'pointercancel'] as const;

package/src/input/input-manager.ts

@@ -81,6 +81,41 @@ export class InputTickError extends Error {
   }
 }
 
+/** One named digital-pair axis whose interpolation is owned by {@link InputManager}.
+ *
+ * Foreign runtimes translate their authored axis table into this neutral carrier, then keep their
+ * public API at the compat boundary. The manager owns the live values because the values are a
+ * derived view of its action state, not a second device/input store. */
+export interface SmoothedInputAxisDefinition {
+  readonly name: string;
+  readonly negativeAction: string;
+  readonly positiveAction: string;
+  /** Units per second when returning to zero. */
+  readonly gravity: number;
+  /** Magnitudes below this threshold read as zero without changing retained interpolation. */
+  readonly dead: number;
+  /** Units per second when approaching a pressed direction. */
+  readonly sensitivity: number;
+  /** Reset to zero before accelerating when the newly pressed direction opposes the old value. */
+  readonly snap: boolean;
+  readonly invert: boolean;
+}
+
+/** Scene-owned handle over an InputManager-owned set of smoothed axes. */
+export interface SmoothedInputAxisSet {
+  advance(deltaTime: number): void;
+  getAxis(name: string): number;
+  getAxisRaw(name: string): number;
+  snapshot(): Record<string, number>;
+  dispose(): void;
+}
+
+interface SmoothedInputAxisSetState {
+  readonly definitions: ReadonlyMap<string, SmoothedInputAxisDefinition>;
+  readonly values: Map<string, number>;
+  disposed: boolean;
+}
+
 /** Shallow equality for a resolved action value (boolean/number/Vector2) —
  *  D15/T-D15.5's recording tap uses this to emit DELTAS only (the trace
  *  format's "deltas only" line), never a full snapshot every tick. `prev`
@@ -415,6 +450,8 @@ export class InputManager {
   // level values feeding the same max-magnitude/sum combine every real
   // binding uses (collectScalarContributions/collectVector2Contributions).
   private virtualDigitalHeld = new Set<string>();
+  /** Processed strength attached to a held virtual digital action. */
+  private virtualDigitalStrength = new Map<string, number>();
   private virtualDigitalTapQueued = new Set<string>();
   private virtualDigitalTapActive = new Set<string>();
   /** pulse-runner friction #4 — the release-edge mirror of
@@ -428,6 +465,9 @@ export class InputManager {
   private virtualDigitalJustReleased = new Set<string>();
   private virtualScalarValues = new Map<string, number>();
   private virtualVector2Values = new Map<string, Vector2>();
+  /** Derived digital-pair axes owned by mounted foreign runtimes. Their public GetAxis-shaped
+   * calls remain in compat; only interpolation state and action reads live beside their source. */
+  private smoothedAxisSets = new Set<SmoothedInputAxisSetState>();
   // D15/T-D15.5 — tick-indexed input scheduling + post-gate recording.
   //
   // `currentTick` is a FALLBACK, self-incrementing counter, used only when a
@@ -524,8 +564,61 @@ export class InputManager {
   private pointerLocked = false;
   /** Element currently wired for click-to-pointer-lock, and its listener. */
   private pointerLockElement: HTMLElement | null = null;
+  /** One report per refusal reason: a refused lock is the whole story of
+   *  "the mouse doesn't aim", and it was silent. */
+  private reportedPointerLockRefusals = new Set<string>();
+  private reportPointerLockRefused(reason: string): void {
+    if (this.reportedPointerLockRefusals.has(reason)) return;
+    this.reportedPointerLockRefusals.add(reason);
+    // biome-ignore lint/suspicious/noConsole: the game's own input intent failed in the browser — an error the editor console and a tester's evidence must both carry
+    console.error(
+      `Pointer lock was refused, so mouse look and mouse aim cannot engage: ${reason}. ` +
+        'The browser grants it only to a user gesture on a page it trusts — a page inside a ' +
+        'frame needs allow="pointer-lock", and some extensions block it.',
+    );
+  }
+  /** A retry already scheduled for Chrome's post-exit cooldown, if any. */
+  private pointerLockRetry: ReturnType<typeof setTimeout> | null = null;
   private onPointerLockClick = () => {
-    this.pointerLockElement?.requestPointerLock();
+    // Chrome answers with a promise that REJECTS when the lock is refused (a
+    // sandboxed/automated document, a policy, a frame without the permission).
+    // Three testers in a row reported "the mouse doesn't aim" on the hosted
+    // editor while automation could not lock at all — and the refusal was
+    // caught silently (runhuman passes 122–126). It is reported now, once
+    // per reason, as the error it is.
+    const request = this.pointerLockElement?.requestPointerLock() as unknown;
+    if (request instanceof Promise) {
+      request.catch((error: unknown) => {
+        const reason = error instanceof Error ? error.message : String(error);
+        // CHROME'S COOLDOWN IS NOT A REFUSAL. After Escape ends a lock, a
+        // request in the next ~1.25 s is rejected with "cannot be acquired
+        // immediately after the user has exited the lock" — and a player who
+        // clicks back into the game right away gets no aim and no second
+        // chance (runhuman pass 130: "I can't move the camera with the
+        // mouse"). The click's activation still stands for a few seconds, so
+        // the request is retried once when the cooldown has passed.
+        if (/exited the lock/i.test(reason) && this.pointerLockRetry === null) {
+          this.pointerLockRetry = setTimeout(() => {
+            this.pointerLockRetry = null;
+            const doc = typeof document !== 'undefined' ? document : null;
+            const activation =
+              typeof navigator !== 'undefined' ? navigator.userActivation : undefined;
+            if (!this.pointerLockElement || doc?.pointerLockElement === this.pointerLockElement) {
+              return;
+            }
+            if (activation?.isActive) {
+              this.onPointerLockClick();
+            } else {
+              // The cooldown outlived the click's activation: the retry
+              // cannot run, and a silent end here is "mouse dead, no error".
+              this.reportPointerLockRefused(`${reason} (the retry found no user activation left)`);
+            }
+          }, 1_300);
+          return;
+        }
+        this.reportPointerLockRefused(reason);
+      });
+    }
   };
   private onPointerLockChange = () => {
     const doc = typeof document !== 'undefined' ? document : null;
@@ -654,6 +747,7 @@ export class InputManager {
       }
     }
     this.virtualDigitalHeld.clear();
+    this.virtualDigitalStrength.clear();
     this.virtualDigitalTapQueued.clear();
     this.virtualDigitalTapActive.clear();
     this.virtualScalarValues.clear();
@@ -799,6 +893,116 @@ export class InputManager {
     return [...this.actions.keys()];
   }
 
+  /**
+   * Create a retained, action-backed set of digital axes. Foreign runtimes keep their public
+   * GetAxis-shaped API in compat, while interpolation and the live action reads stay in the input
+   * owner instead of becoming a parallel compat input store.
+   */
+  createSmoothedAxisSet(definitions: readonly SmoothedInputAxisDefinition[]): SmoothedInputAxisSet {
+    const byName = new Map<string, SmoothedInputAxisDefinition>();
+    for (const source of definitions) {
+      const definition = { ...source };
+      if (definition.name.length === 0) {
+        throw new Error('InputManager.createSmoothedAxisSet: axis names must not be empty');
+      }
+      if (byName.has(definition.name)) {
+        throw new Error(
+          `InputManager.createSmoothedAxisSet: duplicate axis ${JSON.stringify(definition.name)}`,
+        );
+      }
+      if (definition.negativeAction.length === 0 || definition.positiveAction.length === 0) {
+        throw new Error(
+          `InputManager.createSmoothedAxisSet: axis ${JSON.stringify(definition.name)} requires ` +
+            'both negative and positive actions',
+        );
+      }
+      for (const [field, value] of [
+        ['gravity', definition.gravity],
+        ['dead', definition.dead],
+        ['sensitivity', definition.sensitivity],
+      ] as const) {
+        if (!Number.isFinite(value) || value < 0) {
+          throw new Error(
+            `InputManager.createSmoothedAxisSet: ${definition.name}.${field} must be a finite ` +
+              `non-negative number, received ${String(value)}`,
+          );
+        }
+      }
+      byName.set(definition.name, Object.freeze(definition));
+    }
+
+    const state: SmoothedInputAxisSetState = {
+      definitions: byName,
+      values: new Map(),
+      disposed: false,
+    };
+    this.smoothedAxisSets.add(state);
+
+    const assertLive = (): void => {
+      if (state.disposed || this.disposed) {
+        throw new Error('InputManager smoothed axis set has been disposed');
+      }
+    };
+    const definitionOf = (name: string): SmoothedInputAxisDefinition => {
+      assertLive();
+      const definition = state.definitions.get(name);
+      if (definition === undefined) {
+        throw new Error(`InputManager smoothed axis set has no axis ${JSON.stringify(name)}`);
+      }
+      return definition;
+    };
+    const rawValue = (definition: SmoothedInputAxisDefinition): number => {
+      const negative = this.isPressed(definition.negativeAction) ? -1 : 0;
+      const positive = this.isPressed(definition.positiveAction) ? 1 : 0;
+      return (negative + positive) * (definition.invert ? -1 : 1);
+    };
+    const getAxis = (name: string): number => {
+      const definition = definitionOf(name);
+      const value = state.values.get(name) ?? 0;
+      return Math.abs(value) < definition.dead ? 0 : value;
+    };
+
+    return {
+      advance: (deltaTime) => {
+        assertLive();
+        if (!Number.isFinite(deltaTime) || deltaTime < 0) {
+          throw new Error(
+            `InputManager smoothed axis deltaTime must be finite and non-negative, received ` +
+              String(deltaTime),
+          );
+        }
+        for (const definition of state.definitions.values()) {
+          const target = rawValue(definition);
+          const current = state.values.get(definition.name) ?? 0;
+          let next: number;
+          if (target === 0) {
+            const step = definition.gravity * deltaTime;
+            next = current > 0 ? Math.max(0, current - step) : Math.min(0, current + step);
+          } else {
+            const from = definition.snap && current * target < 0 ? 0 : current;
+            const step = definition.sensitivity * deltaTime;
+            next = target > 0 ? Math.min(target, from + step) : Math.max(target, from - step);
+          }
+          state.values.set(definition.name, next);
+        }
+      },
+      getAxis,
+      getAxisRaw: (name) => rawValue(definitionOf(name)),
+      snapshot: () => {
+        assertLive();
+        const snapshot: Record<string, number> = {};
+        for (const name of state.definitions.keys()) snapshot[name] = getAxis(name);
+        return snapshot;
+      },
+      dispose: () => {
+        if (state.disposed) return;
+        state.disposed = true;
+        state.values.clear();
+        this.smoothedAxisSets.delete(state);
+      },
+    };
+  }
+
   /**
    * Poll gamepads and virtual look stick (call at start of frame).
    *
@@ -1014,9 +1218,11 @@ export class InputManager {
       if (typeof entry.value === 'boolean') {
         if (entry.value) {
           this.virtualDigitalHeld.add(entry.action);
+          this.virtualDigitalStrength.set(entry.action, 1);
           this.virtualDigitalTapActive.add(entry.action);
         } else {
           this.virtualDigitalHeld.delete(entry.action);
+          this.virtualDigitalStrength.delete(entry.action);
         }
       } else {
         this.applyVirtualActionValue(entry.action, entry.value);
@@ -1114,6 +1320,110 @@ export class InputManager {
     return false;
   }
 
+  /**
+   * Processed strength for a declared digital action without creating a
+   * second action-state store. Digital keys/buttons/touches contribute 1,
+   * while a directional gamepad axis contributes Godot's deadzone-rescaled
+   * magnitude. Multiple bindings combine by greatest strength, matching the
+   * action state that {@link isPressed} reads as a boolean.
+   */
+  getDigitalStrength(actionName: string): number {
+    this.assertValueType(actionName, 'digital', 'getDigitalStrength');
+    if (
+      this.machineInputActive &&
+      (this.virtualDigitalHeld.has(actionName) || this.virtualDigitalTapActive.has(actionName))
+    ) {
+      return this.virtualDigitalStrength.get(actionName) ?? 1;
+    }
+    if (!this.inputActive) return 0;
+    const bindings = this.actions.get(actionName);
+    if (!bindings) return 0;
+
+    let strength = 0;
+    for (const binding of bindings) {
+      switch (binding.type) {
+        case 'key':
+          if (this.keysDown.has(binding.code)) return 1;
+          break;
+        case 'mouse_button':
+          if (this.mouseButtons.has(binding.button)) return 1;
+          break;
+        case 'gamepad_button':
+          for (const gp of this.gamepads) {
+            const button = gp?.buttons[binding.button];
+            // Pinned InputEventJoypadButton::action_match reports 1 for a
+            // pressed button and 0 otherwise; GamepadButton.value is not its
+            // action strength.
+            if (button?.pressed) return 1;
+          }
+          break;
+        case 'gamepad_axis': {
+          const deadzone = binding.deadzone ?? GAMEPAD_AXIS_DEFAULT_DEADZONE;
+          for (const gp of this.gamepads) {
+            if (!gp) continue;
+            const raw = gp.axes[binding.axis] ?? 0;
+            const directional = binding.direction === 'positive' ? raw : -raw;
+            if (directional < deadzone) continue;
+            strength = Math.max(
+              strength,
+              deadzone === 1
+                ? 1
+                : Math.min(1, Math.max(0, (directional - deadzone) / (1 - deadzone))),
+            );
+          }
+          break;
+        }
+        case 'touch_button':
+          if (this.touchButtonsDown.has(binding.sourceId)) return 1;
+          break;
+      }
+    }
+    return strength;
+  }
+
+  /** Raw (pre-deadzone) strength for a declared digital action. */
+  getDigitalRawStrength(actionName: string): number {
+    this.assertValueType(actionName, 'digital', 'getDigitalRawStrength');
+    if (
+      this.machineInputActive &&
+      (this.virtualDigitalHeld.has(actionName) || this.virtualDigitalTapActive.has(actionName))
+    ) {
+      return this.virtualDigitalStrength.get(actionName) ?? 1;
+    }
+    if (!this.inputActive) return 0;
+    const bindings = this.actions.get(actionName);
+    if (!bindings) return 0;
+
+    let strength = 0;
+    for (const binding of bindings) {
+      switch (binding.type) {
+        case 'key':
+          if (this.keysDown.has(binding.code)) return 1;
+          break;
+        case 'mouse_button':
+          if (this.mouseButtons.has(binding.button)) return 1;
+          break;
+        case 'gamepad_button':
+          if (this.gamepads.some((gp) => gp?.buttons[binding.button]?.pressed)) return 1;
+          break;
+        case 'gamepad_axis':
+          for (const gp of this.gamepads) {
+            if (!gp) continue;
+            const raw = gp.axes[binding.axis] ?? 0;
+            strength = Math.max(
+              strength,
+              Math.min(1, Math.max(0, binding.direction === 'positive' ? raw : -raw)),
+            );
+          }
+          break;
+        case 'touch_button':
+          if (this.touchButtonsDown.has(binding.sourceId)) return 1;
+          break;
+      }
+    }
+    return strength;
+  }
+
   /** Was an action pressed this frame (not held from previous)? */
   isJustPressed(actionName: string): boolean {
     this.assertValueType(actionName, 'digital', 'isJustPressed');
@@ -1798,6 +2108,17 @@ export class InputManager {
     return this.gamepads.some((pad) => pad !== null);
   }
 
+  /** Connected W3C Gamepad indices in native slot order, gated by the same play/focus state as
+   * every other raw device poll. Foreign-engine adapters use their own collection value type. */
+  getConnectedGamepadIndices(): number[] {
+    if (!this.inputActive) return [];
+    const indices: number[] = [];
+    for (let index = 0; index < this.gamepads.length; index += 1) {
+      if (this.gamepads[index] !== null) indices.push(index);
+    }
+    return indices;
+  }
+
   isDeviceGamepadButtonPressed(button: number): boolean {
     if (!this.inputActive) return false;
     const index = this.firstConnectedGamepadIndex();
@@ -1805,6 +2126,15 @@ export class InputManager {
     return this.gamepadButtonsDown.has(`${index}:${button}`);
   }
 
+  /** Raw button state for one explicit native Gamepad slot. */
+  isDeviceGamepadButtonPressedAt(index: number, button: number): boolean {
+    if (!this.inputActive) return false;
+    if (!Number.isSafeInteger(index) || index < 0 || !Number.isSafeInteger(button) || button < 0) {
+      return false;
+    }
+    return this.gamepads[index]?.buttons[button]?.pressed ?? false;
+  }
+
   isDeviceGamepadButtonJustPressed(button: number): boolean {
     if (!this.inputActive) return false;
     const index = this.firstConnectedGamepadIndex();
@@ -1841,6 +2171,15 @@ export class InputManager {
     return this.gamepads[index]?.axes[axis] ?? 0;
   }
 
+  /** Raw axis value for one explicit native Gamepad slot. */
+  getDeviceGamepadAxisAt(index: number, axis: number): number {
+    if (!this.inputActive) return 0;
+    if (!Number.isSafeInteger(index) || index < 0 || !Number.isSafeInteger(axis) || axis < 0) {
+      return 0;
+    }
+    return this.gamepads[index]?.axes[axis] ?? 0;
+  }
+
   private firstConnectedGamepadIndex(): number {
     for (let i = 0; i < this.gamepads.length; i++) {
       if (this.gamepads[i] !== null) return i;
@@ -2266,6 +2605,31 @@ export class InputManager {
     return { delivered: true };
   }
 
+  /**
+   * Godot's `Input.action_press(action, strength)` door for a digital action.
+   * This extends the existing virtual held/edge state with its clamped
+   * processed strength instead of maintaining a parallel Godot action map.
+   */
+  setVirtualDigitalStrength(
+    action: string,
+    strength: number,
+  ): { delivered: boolean; reason?: string } {
+    this.assertActionExists(action, 'setVirtualDigitalStrength');
+    this.assertValueType(action, 'digital', 'setVirtualDigitalStrength');
+    if (!Number.isFinite(strength)) {
+      throw new Error('InputManager.setVirtualDigitalStrength: strength must be finite.');
+    }
+    if (!this.machineInputActive) {
+      return { delivered: false, reason: 'input-gated (input disabled by the editor)' };
+    }
+    const clamped = Math.min(1, Math.max(0, strength));
+    // `Input::action_press` sets api_pressed=true even when its clamped
+    // strength is zero; only `action_release` clears the pressed state.
+    this.applyVirtualActionValue(action, true);
+    this.virtualDigitalStrength.set(action, clamped);
+    return { delivered: true };
+  }
+
   /**
    * The write half of {@link setVirtualAction} — extracted so D15/T-D15.5's
    * `scheduleActionAtTick` can apply a non-boolean (scalar/vector2) queued
@@ -2315,6 +2679,7 @@ export class InputManager {
         } else {
           if (this.virtualDigitalHeld.has(action)) this.virtualDigitalJustReleased.add(action);
           this.virtualDigitalHeld.delete(action);
+          this.virtualDigitalStrength.delete(action);
         }
         break;
       case 'scalar':
@@ -2440,16 +2805,34 @@ export class InputManager {
     return { version: 1, ticks: this.inputTrace.slice() };
   }
 
-  /** Request pointer lock for FPS-style mouse control */
+  /**
+   * Request pointer lock for FPS-style mouse control.
+   *
+   * Wires `element` for click-to-lock (so a lock released by Escape comes back
+   * on the next click) AND, when the call itself is inside a user gesture,
+   * requests the lock right now. Games call this FROM a click handler
+   * (third-person's Player: canvas click → `requestPointerLock(canvas)`), and
+   * with only the listener wired that first click did nothing — the lock
+   * arrived one click late, with no feedback, which every hosted-editor tester
+   * read as "the mouse doesn't work" (runhuman passes 113–116). Outside a
+   * gesture the browser would refuse and log, so the immediate request is
+   * gated on `navigator.userActivation`.
+   */
   requestPointerLock(element: HTMLElement) {
     // Idempotent: never stack duplicate click listeners. Rewire if the element
     // changed, and track it so dispose() can remove the listener.
-    if (this.pointerLockElement === element) return;
-    if (this.pointerLockElement) {
-      this.pointerLockElement.removeEventListener('click', this.onPointerLockClick);
+    if (this.pointerLockElement !== element) {
+      if (this.pointerLockElement) {
+        this.pointerLockElement.removeEventListener('click', this.onPointerLockClick);
+      }
+      this.pointerLockElement = element;
+      element.addEventListener('click', this.onPointerLockClick);
+    }
+    const doc = typeof document !== 'undefined' ? document : null;
+    const activation = typeof navigator !== 'undefined' ? navigator.userActivation : undefined;
+    if (doc && doc.pointerLockElement !== element && activation?.isActive) {
+      this.onPointerLockClick();
     }
-    this.pointerLockElement = element;
-    element.addEventListener('click', this.onPointerLockClick);
   }
 
   /**
@@ -2465,6 +2848,10 @@ export class InputManager {
    * holding lock on a different element is not ours to drop.
    */
   exitPointerLock() {
+    if (this.pointerLockRetry !== null) {
+      clearTimeout(this.pointerLockRetry);
+      this.pointerLockRetry = null;
+    }
     const el = this.pointerLockElement;
     if (el) {
       el.removeEventListener('click', this.onPointerLockClick);
@@ -2480,6 +2867,16 @@ export class InputManager {
   dispose() {
     if (this.disposed) return;
     this.disposed = true;
+    // A manager torn down with a key under the hand (Stop while W is held)
+    // kept that key in `keysDown` for good — its listeners went away before
+    // the release arrived, and nothing else clears it. A disposed manager
+    // holds nothing.
+    this.flushHeldState();
+    for (const axes of this.smoothedAxisSets) {
+      axes.disposed = true;
+      axes.values.clear();
+    }
+    this.smoothedAxisSets.clear();
     if (typeof window !== 'undefined') {
       window.removeEventListener('keydown', this.onKeyDown);
       window.removeEventListener('keyup', this.onKeyUp);