@crowdedkingdoms/construct 0.0.0 → 0.2.0-dev.1

package/src/engine/GameLoop.ts

@@ -0,0 +1,106 @@
+/**
+ * The frame loop, and the one place where "the scene's local pose" becomes
+ * "what everyone else sees". Each frame:
+ *
+ *   1. the active scene updates and renders,
+ *   2. the loop reads `scene.localPose()`, stamps program/name/tint, and hands
+ *      it to the replication store (which sends at 5 Hz, only on change),
+ *   3. if the player crossed into another chunk, the store is told to move,
+ *   4. the save blob's position is patched (autosaved by the store).
+ *
+ * Scenes never talk to the network for presence. That is the whole point.
+ */
+import type { SceneSize } from './GameScene';
+import type { SceneRouter } from './SceneRouter';
+import type { GameSession } from '../platform/GameSession';
+import { FLAG_IN_PROGRAM, FLAG_MOVING } from '../platform/realtime/actorCodec';
+import { chunkKey, worldToChunk } from '../platform/realtime/space';
+
+export class GameLoop {
+  private frame: number | null = null;
+  private lastMs = 0;
+  private lastChunkKey: string | null = null;
+  private lastSavePatchMs = 0;
+  private rightInset = 0;
+  private resizeObserver: ResizeObserver | null = null;
+
+  constructor(
+    private readonly root: HTMLElement,
+    private readonly router: SceneRouter,
+    private readonly session: GameSession,
+  ) {}
+
+  start(): void {
+    if (this.frame !== null) return;
+    this.resizeObserver = new ResizeObserver(() => this.router.resize(this.size()));
+    this.resizeObserver.observe(this.root);
+    this.router.resize(this.size());
+    this.lastMs = performance.now();
+    const tick = (nowMs: number) => {
+      this.frame = requestAnimationFrame(tick);
+      const dt = Math.min(0.1, Math.max(0, (nowMs - this.lastMs) / 1000));
+      this.lastMs = nowMs;
+      this.step(dt, nowMs);
+    };
+    this.frame = requestAnimationFrame(tick);
+  }
+
+  stop(): void {
+    if (this.frame !== null) cancelAnimationFrame(this.frame);
+    this.frame = null;
+    this.resizeObserver?.disconnect();
+    this.resizeObserver = null;
+  }
+
+  /** A docked overlay took `px` pixels on the right; re-measure. */
+  setRightInset(px: number): void {
+    this.rightInset = px;
+    this.router.resize(this.size());
+  }
+
+  size(): SceneSize {
+    // The stylesheet already shrinks #game-root by --ck-game-right-inset while
+    // Crowdy Studio is docked, so the rect is the visible area; the inset is
+    // passed along for scenes that want to know, not subtracted again.
+    const rect = this.root.getBoundingClientRect();
+    return {
+      width: Math.max(1, Math.floor(rect.width)),
+      height: Math.max(1, Math.floor(rect.height)),
+      rightInset: this.rightInset,
+    };
+  }
+
+  private step(dt: number, nowMs: number): void {
+    const scene = this.router.current;
+    if (!scene) return;
+    scene.update(dt, nowMs);
+    if (!this.session.joined) return;
+
+    const pose = scene.localPose();
+    const moving = Math.hypot(pose.vx, pose.vy, pose.vz) > 0.05;
+    const flags =
+      (pose.flags & ~(FLAG_MOVING | FLAG_IN_PROGRAM)) |
+      (moving ? FLAG_MOVING : 0) |
+      (scene.programId !== 0 ? FLAG_IN_PROGRAM : 0) |
+      this.session.extraPoseFlags();
+    this.session.feedPose({
+      ...pose,
+      flags,
+      program: scene.programId,
+      name: this.session.displayName,
+      tint: this.session.tint,
+    });
+
+    const chunk = worldToChunk(pose);
+    const key = chunkKey(chunk);
+    if (key !== this.lastChunkKey) {
+      this.lastChunkKey = key;
+      void this.session.moveTo(chunk);
+    }
+
+    if (nowMs - this.lastSavePatchMs > 2000) {
+      this.lastSavePatchMs = nowMs;
+      this.session.rememberPosition(scene.id, pose);
+    }
+  }
+}

package/src/engine/GameScene.ts

@@ -0,0 +1,74 @@
+/**
+ * The renderer adapter boundary.
+ *
+ * A scene owns a renderer (three.js, pixi.js, a 2D canvas, anything) and the
+ * local player's position inside it. It does NOT own networking, identity,
+ * persistence or Studio: those come in through `SceneContext` and are the same
+ * object for every scene, which is what lets the holodeck (three.js) hand a
+ * player to a program (pixi.js) without anyone reconnecting.
+ *
+ * The contract is deliberately small. If your game needs more from the
+ * platform, add it to `GameSession` (engine-agnostic) rather than widening
+ * this interface, and read docs/RENDERER-ADAPTER.md before you do.
+ */
+import type { GameSession } from '../platform/GameSession';
+import type { Pose } from '../platform/realtime/actorCodec';
+import type { Input } from './Input';
+import type { SceneRouter } from './SceneRouter';
+
+export interface SceneContext {
+  /** The element the scene renders into. Sized by the loop on resize. */
+  root: HTMLElement;
+  /** Everything platform: session, remote players, chat, save, studio. */
+  session: GameSession;
+  /** Keyboard/pointer state with a suppression switch for overlays. */
+  input: Input;
+  /** Ask to load another scene (a program pad, a "return to hub" key). */
+  router: SceneRouter;
+  /** The DOM HUD: transient hints and toasts. Scenes draw no DOM themselves. */
+  hud: SceneHud;
+}
+
+export interface SceneHud {
+  /** A persistent one-line prompt ("Press E to load Paint"); null clears it. */
+  setHint(text: string | null): void;
+  /** A short-lived notice. */
+  toast(text: string, tone?: 'info' | 'warn' | 'error'): void;
+  /** Replace the F1 / ? overlay lines for this scene. */
+  setHelpLines?(lines: string[]): void;
+}
+
+export interface SceneSize {
+  width: number;
+  height: number;
+  /** Pixels reserved on the right by a docked overlay (Crowdy Studio). */
+  rightInset: number;
+}
+
+export interface GameScene {
+  /** Stable id used by the router and the save blob. */
+  readonly id: string;
+  /**
+   * The `program` byte broadcast in the pose while the player is here
+   * (0 = holodeck). Scenes hide actors whose `program` differs.
+   */
+  readonly programId: number;
+
+  mount(context: SceneContext, size: SceneSize): Promise<void> | void;
+  /** Called once per animation frame with seconds elapsed. Simulate + render. */
+  update(dt: number, nowMs: number): void;
+  resize(size: SceneSize): void;
+  unmount(): void;
+
+  /**
+   * The local player's current pose in this scene's coordinates. The loop
+   * feeds it to the replication store every frame (the store dedups sends).
+   * A scene with no notion of position returns a fixed pose.
+   */
+  localPose(): Pose;
+  /** Place the local player (spawn, restore from save, teleport). */
+  setLocalPosition(position: { x: number; y: number; z: number; yaw?: number }): void;
+}
+
+/** A scene factory registered with the router; constructed on first load. */
+export type SceneFactory = () => GameScene;

package/src/engine/Input.test.ts

@@ -0,0 +1,129 @@
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { Input, isPointerLockOn, isTextEntry } from './Input';
+
+describe('isPointerLockOn', () => {
+  it('treats a descendant canvas as locked, not only the root', () => {
+    const root = document.createElement('div');
+    const canvas = document.createElement('canvas');
+    root.appendChild(canvas);
+    expect(isPointerLockOn(root, canvas)).toBe(true);
+    expect(isPointerLockOn(root, root)).toBe(true);
+    expect(isPointerLockOn(root, document.createElement('div'))).toBe(false);
+    expect(isPointerLockOn(root, null)).toBe(false);
+  });
+});
+
+describe('isTextEntry', () => {
+  it('recognises inputs and Monaco', () => {
+    const input = document.createElement('input');
+    expect(isTextEntry(input)).toBe(true);
+    const div = document.createElement('div');
+    expect(isTextEntry(div)).toBe(false);
+    const monaco = document.createElement('div');
+    monaco.className = 'monaco-editor';
+    const inner = document.createElement('div');
+    monaco.appendChild(inner);
+    expect(isTextEntry(inner)).toBe(true);
+  });
+});
+
+describe('Input', () => {
+  const inputs: Input[] = [];
+
+  afterEach(() => {
+    for (const input of inputs) input.dispose();
+    inputs.length = 0;
+  });
+
+  function attach(): { input: Input; root: HTMLElement; canvas: HTMLCanvasElement } {
+    const root = document.createElement('div');
+    const canvas = document.createElement('canvas');
+    root.appendChild(canvas);
+    document.body.appendChild(root);
+    const input = new Input();
+    input.attach(root);
+    inputs.push(input);
+    return { input, root, canvas };
+  }
+
+  it('maps WASD to axes and Shift to run', () => {
+    const { input } = attach();
+    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyW' }));
+    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyD' }));
+    expect(input.axes()).toEqual({ x: 1, y: 1 });
+    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'ShiftLeft' }));
+    expect(input.isRun()).toBe(true);
+  });
+
+  it('does not record gameplay keys while suppressed or in a text field', () => {
+    const { input } = attach();
+    const release = input.suppress();
+    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyW' }));
+    expect(input.axes()).toEqual({ x: 0, y: 0 });
+    release();
+    const field = document.createElement('input');
+    document.body.appendChild(field);
+    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyW', bubbles: true }));
+    // default target is window/body, not the field — still records
+    expect(input.isDown('KeyW')).toBe(true);
+  });
+
+  it('sets locked when pointer lock is on a descendant canvas', () => {
+    const { input, canvas } = attach();
+    Object.defineProperty(document, 'pointerLockElement', {
+      configurable: true,
+      get: () => canvas,
+    });
+    document.dispatchEvent(new Event('pointerlockchange'));
+    expect(input.pointer.locked).toBe(true);
+    expect(input.isLooking()).toBe(true);
+    Object.defineProperty(document, 'pointerLockElement', {
+      configurable: true,
+      get: () => null,
+    });
+    document.dispatchEvent(new Event('pointerlockchange'));
+    expect(input.pointer.locked).toBe(false);
+  });
+
+  it('looks while RMB is held and cancels on exitLook', () => {
+    const { input } = attach();
+    window.dispatchEvent(new PointerEvent('pointerdown', { button: 2, buttons: 2 }));
+    expect(input.isLooking()).toBe(true);
+    input.exitLook();
+    expect(input.isLooking()).toBe(false);
+    window.dispatchEvent(new PointerEvent('pointerup', { button: 2, buttons: 0 }));
+    window.dispatchEvent(new PointerEvent('pointerdown', { button: 2, buttons: 2 }));
+    expect(input.isLooking()).toBe(true);
+  });
+
+  it('pans on MMB or Alt+LMB', () => {
+    const { input } = attach();
+    window.dispatchEvent(new PointerEvent('pointerdown', { button: 1, buttons: 4 }));
+    expect(input.isPanning()).toBe(true);
+    window.dispatchEvent(new PointerEvent('pointerup', { button: 1, buttons: 0 }));
+    window.dispatchEvent(new PointerEvent('pointerdown', { button: 0, buttons: 1, altKey: true }));
+    expect(input.isPanning()).toBe(true);
+  });
+
+  it('accumulates wheel over the game root and takeWheel consumes it', () => {
+    const { input, canvas } = attach();
+    canvas.dispatchEvent(
+      new WheelEvent('wheel', { deltaY: -120, bubbles: true, cancelable: true }),
+    );
+    expect(input.takeWheel()).toBe(-120);
+    expect(input.takeWheel()).toBe(0);
+  });
+
+  it('onKeys registers every code', () => {
+    const { input } = attach();
+    const seen: string[] = [];
+    const off = input.onKeys(['KeyT', 'Enter'], (event) => seen.push(event.code));
+    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyT' }));
+    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'Enter' }));
+    expect(seen).toEqual(['KeyT', 'Enter']);
+    off();
+    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyT' }));
+    expect(seen).toEqual(['KeyT', 'Enter']);
+  });
+});

package/src/engine/Input.ts

@@ -0,0 +1,257 @@
+/**
+ * Keyboard + pointer state shared by every scene, with one switch overlays
+ * flip: `suppressed`. While an overlay (Crowdy Studio, the chat box, the Setup
+ * wizard) has focus, gameplay must not see keys — but the overlay's own
+ * shortcuts still fire through `onKey`.
+ *
+ * Pointer lock is true when the lock element is the attached root *or any
+ * descendant* (the scene canvas). Look also works as an RMB drag so insecure
+ * HTTP (the IDE browser on a public IP) can still turn the camera.
+ */
+import { Controls } from './controls';
+
+export type KeyHandler = (event: KeyboardEvent) => void;
+
+export interface PointerState {
+  x: number;
+  y: number;
+  /** Movement since the last frame (consumed by `takePointerDelta`). */
+  dx: number;
+  dy: number;
+  down: boolean;
+  locked: boolean;
+  /** `MouseEvent.buttons` bitfield (1 LMB, 2 RMB, 4 MMB). */
+  buttons: number;
+  alt: boolean;
+}
+
+const TEXT_INPUT_TAGS = new Set(['INPUT', 'TEXTAREA', 'SELECT']);
+
+export function isTextEntry(target: EventTarget | null): boolean {
+  if (!(target instanceof HTMLElement)) return false;
+  if (TEXT_INPUT_TAGS.has(target.tagName)) return true;
+  if (target.isContentEditable) return true;
+  // Monaco's editor surface.
+  return Boolean(target.closest('.monaco-editor'));
+}
+
+/** True when pointer lock is on `root` or a node inside it (the scene canvas). */
+export function isPointerLockOn(root: EventTarget | null, lockElement: Element | null): boolean {
+  if (!lockElement || !(root instanceof Node)) return false;
+  return lockElement === root || root.contains(lockElement);
+}
+
+export class Input {
+  private readonly keys = new Set<string>();
+  private readonly keyHandlers = new Map<string, Set<KeyHandler>>();
+  private readonly pointerState: PointerState = {
+    x: 0,
+    y: 0,
+    dx: 0,
+    dy: 0,
+    down: false,
+    locked: false,
+    buttons: 0,
+    alt: false,
+  };
+  private suppressedDepth = 0;
+  private detach: (() => void) | null = null;
+  private attachedRoot: HTMLElement | null = null;
+  private wheelY = 0;
+  /** Escape cancels RMB look until the button is released. */
+  private lookCancelled = false;
+
+  attach(target: HTMLElement): void {
+    if (this.detach) return;
+    this.attachedRoot = target;
+    const onKeyDown = (event: KeyboardEvent) => {
+      const inText = isTextEntry(event.target);
+      // Shortcuts registered with onKey fire even while suppressed, unless the
+      // player is typing in a text field.
+      if (!inText) {
+        const handlers = this.keyHandlers.get(event.code);
+        if (handlers) for (const handler of [...handlers]) handler(event);
+      }
+      if (this.suppressed || inText) return;
+      this.keys.add(event.code);
+    };
+    const onKeyUp = (event: KeyboardEvent) => {
+      this.keys.delete(event.code);
+    };
+    const onBlur = () => this.keys.clear();
+    const onPointerMove = (event: PointerEvent) => {
+      if (this.suppressed) return;
+      this.pointerState.dx += event.movementX;
+      this.pointerState.dy += event.movementY;
+      this.pointerState.x = event.clientX;
+      this.pointerState.y = event.clientY;
+      this.pointerState.buttons = event.buttons;
+      this.pointerState.alt = event.altKey;
+    };
+    const onPointerDown = (event: PointerEvent) => {
+      if (this.suppressed || isTextEntry(event.target)) return;
+      this.pointerState.down = true;
+      this.pointerState.buttons = event.buttons;
+      this.pointerState.alt = event.altKey;
+      this.pointerState.x = event.clientX;
+      this.pointerState.y = event.clientY;
+      if (event.button === 2) this.lookCancelled = false;
+    };
+    const onPointerUp = (event: PointerEvent) => {
+      this.pointerState.buttons = event.buttons;
+      this.pointerState.alt = event.altKey;
+      if (event.buttons === 0) this.pointerState.down = false;
+      if ((event.buttons & 2) === 0) this.lookCancelled = false;
+    };
+    const onLockChange = () => {
+      this.pointerState.locked = isPointerLockOn(target, document.pointerLockElement);
+    };
+    const onWheel = (event: WheelEvent) => {
+      if (this.suppressed || isTextEntry(event.target)) return;
+      if (
+        this.attachedRoot &&
+        event.target instanceof Node &&
+        !this.attachedRoot.contains(event.target)
+      ) {
+        return;
+      }
+      this.wheelY += event.deltaY;
+      event.preventDefault();
+    };
+    const onContextMenu = (event: Event) => {
+      if (this.isLooking() || (this.pointerState.buttons & 2) !== 0) {
+        event.preventDefault();
+      }
+    };
+    window.addEventListener('keydown', onKeyDown);
+    window.addEventListener('keyup', onKeyUp);
+    window.addEventListener('blur', onBlur);
+    window.addEventListener('pointermove', onPointerMove);
+    window.addEventListener('pointerdown', onPointerDown);
+    window.addEventListener('pointerup', onPointerUp);
+    window.addEventListener('wheel', onWheel, { passive: false });
+    window.addEventListener('contextmenu', onContextMenu);
+    document.addEventListener('pointerlockchange', onLockChange);
+    this.detach = () => {
+      window.removeEventListener('keydown', onKeyDown);
+      window.removeEventListener('keyup', onKeyUp);
+      window.removeEventListener('blur', onBlur);
+      window.removeEventListener('pointermove', onPointerMove);
+      window.removeEventListener('pointerdown', onPointerDown);
+      window.removeEventListener('pointerup', onPointerUp);
+      window.removeEventListener('wheel', onWheel);
+      window.removeEventListener('contextmenu', onContextMenu);
+      document.removeEventListener('pointerlockchange', onLockChange);
+      this.detach = null;
+      this.attachedRoot = null;
+    };
+  }
+
+  dispose(): void {
+    this.detach?.();
+    this.keys.clear();
+    this.keyHandlers.clear();
+  }
+
+  /** True while an overlay owns the keyboard. Nested overlays stack. */
+  get suppressed(): boolean {
+    return this.suppressedDepth > 0;
+  }
+
+  /** Suppress gameplay input; returns the release function. */
+  suppress(): () => void {
+    this.suppressedDepth += 1;
+    this.keys.clear();
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.suppressedDepth = Math.max(0, this.suppressedDepth - 1);
+    };
+  }
+
+  isDown(code: string): boolean {
+    return this.keys.has(code);
+  }
+
+  anyDown(codes: readonly string[]): boolean {
+    return codes.some((code) => this.keys.has(code));
+  }
+
+  /** -1..1 on each axis from WASD / arrows. */
+  axes(): { x: number; y: number } {
+    const x =
+      (this.anyDown(Controls.moveRight) ? 1 : 0) - (this.anyDown(Controls.moveLeft) ? 1 : 0);
+    const y =
+      (this.anyDown(Controls.moveForward) ? 1 : 0) - (this.anyDown(Controls.moveBack) ? 1 : 0);
+    return { x, y };
+  }
+
+  isRun(): boolean {
+    return this.anyDown(Controls.run);
+  }
+
+  /**
+   * Pointer-lock look, or RMB held (and not cancelled by Escape). Used by the
+   * holodeck so insecure HTTP can still turn the camera.
+   */
+  isLooking(): boolean {
+    if (this.suppressed) return false;
+    if (this.pointerState.locked) return true;
+    if (this.lookCancelled) return false;
+    return (this.pointerState.buttons & 2) !== 0;
+  }
+
+  /** MMB, or Alt+LMB — Paint camera pan without stealing paint/erase. */
+  isPanning(): boolean {
+    if (this.suppressed) return false;
+    if ((this.pointerState.buttons & 4) !== 0) return true;
+    return this.pointerState.alt && (this.pointerState.buttons & 1) !== 0;
+  }
+
+  /** Exit pointer lock and cancel an in-progress RMB look. */
+  exitLook(): void {
+    this.lookCancelled = true;
+    if (typeof document !== 'undefined' && document.pointerLockElement) {
+      document.exitPointerLock();
+    }
+  }
+
+  onKey(code: string, handler: KeyHandler): () => void {
+    let set = this.keyHandlers.get(code);
+    if (!set) {
+      set = new Set();
+      this.keyHandlers.set(code, set);
+    }
+    set.add(handler);
+    return () => {
+      set?.delete(handler);
+    };
+  }
+
+  onKeys(codes: readonly string[], handler: KeyHandler): () => void {
+    const releases = codes.map((code) => this.onKey(code, handler));
+    return () => {
+      for (const release of releases) release();
+    };
+  }
+
+  get pointer(): Readonly<PointerState> {
+    return this.pointerState;
+  }
+
+  /** Read and reset the accumulated pointer delta (once per frame). */
+  takePointerDelta(): { dx: number; dy: number } {
+    const delta = { dx: this.pointerState.dx, dy: this.pointerState.dy };
+    this.pointerState.dx = 0;
+    this.pointerState.dy = 0;
+    return delta;
+  }
+
+  /** Read and reset accumulated wheel deltaY (once per frame). */
+  takeWheel(): number {
+    const y = this.wheelY;
+    this.wheelY = 0;
+    return y;
+  }
+}

package/src/engine/SceneRouter.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import type { GameScene, SceneContext, SceneSize } from './GameScene';
+import { SceneRouter } from './SceneRouter';
+import { NEUTRAL_POSE } from '../platform/realtime/actorCodec';
+
+function fakeScene(
+  id: string,
+  programId: number,
+  failMount = false,
+): GameScene & { mounted: number; unmounted: number } {
+  let pos = { x: 0, y: 0, z: 0 };
+  return {
+    id,
+    programId,
+    mounted: 0,
+    unmounted: 0,
+    mount() {
+      if (failMount) throw new Error(`${id} cannot mount`);
+      this.mounted++;
+    },
+    unmount() {
+      this.unmounted++;
+    },
+    update() {},
+    resize() {},
+    localPose: () => ({ ...NEUTRAL_POSE, ...pos }),
+    setLocalPosition(p) {
+      pos = { x: p.x, y: p.y, z: p.z };
+    },
+  };
+}
+
+const size: SceneSize = { width: 100, height: 50, rightInset: 0 };
+const context = {} as SceneContext;
+
+describe('SceneRouter', () => {
+  it('constructs scenes lazily, mounts once per load, and unmounts the previous', async () => {
+    const router = new SceneRouter();
+    const hub = fakeScene('hub', 0);
+    const prog = fakeScene('prog', 1);
+    const hubFactory = vi.fn(() => hub);
+    router.register('hub', hubFactory);
+    router.register('prog', () => prog);
+    router.bind(context, size);
+    expect(hubFactory).not.toHaveBeenCalled();
+    await router.load('hub');
+    await router.load('prog', { x: 3, y: 0, z: 4 });
+    expect(hub.mounted).toBe(1);
+    expect(hub.unmounted).toBe(1);
+    expect(prog.localPose()).toMatchObject({ x: 3, z: 4 });
+    expect(router.current?.id).toBe('prog');
+    await router.load('prog');
+    expect(prog.mounted).toBe(1);
+  });
+
+  it('restores the previous scene when a mount fails', async () => {
+    const router = new SceneRouter();
+    const hub = fakeScene('hub', 0);
+    const broken = fakeScene('broken', 2, true);
+    router.register('hub', () => hub);
+    router.register('broken', () => broken);
+    router.bind(context, size);
+    await router.load('hub', { x: 7, y: 0, z: 7 });
+    const errors: unknown[] = [];
+    router.events.on('error', (e) => errors.push(e));
+    await expect(router.load('broken')).rejects.toThrow(/cannot mount/);
+    expect(router.current?.id).toBe('hub');
+    expect(hub.mounted).toBe(2);
+    expect(hub.localPose()).toMatchObject({ x: 7, z: 7 });
+    expect(errors).toHaveLength(1);
+  });
+
+  it('refuses unknown ids and loads before bind', async () => {
+    const router = new SceneRouter();
+    await expect(router.load('nope')).rejects.toThrow(/bind/);
+    router.bind(context, size);
+    await expect(router.load('nope')).rejects.toThrow(/No scene registered/);
+  });
+});