@bloopjs/web 0.0.30 → 0.0.32

package/dist/mod.js

@@ -1,4 +1,4 @@
-// node_modules/@bloopjs/engine/dist/engine.js
+// ../bloop/dist/mod.js
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -9,8 +9,42 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
+var exports_util = {};
+__export(exports_util, {
+  unwrap: () => unwrap,
+  toHexString: () => toHexString,
+  assert: () => assert
+});
+function toHexString(dataView, length) {
+  length ??= dataView.byteLength;
+  let hexString = "";
+  for (let i = 0;i < length; i++) {
+    const byte = dataView.getUint8(i);
+    hexString += `${byte.toString(16).padStart(2, "0")} `;
+  }
+  return hexString.trim();
+}
+function assert(condition, message) {
+  if (condition == null || condition === false) {
+    throw new Error(message ?? "Assertion failed");
+  }
+}
+function unwrap(value, message) {
+  assert(value != null, message ?? `Unwrap failed: value is ${value}`);
+  return value;
+}
+var __defProp2 = Object.defineProperty;
+var __export2 = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
 var exports_enums = {};
-__export(exports_enums, {
+__export2(exports_enums, {
   MouseButton: () => MouseButton,
   Key: () => Key,
   EventType: () => EventType
@@ -239,6 +273,17 @@ var Key;
 var MOUSE_OFFSET = 256;
 var MOUSE_BUTTONS_OFFSET = 16;
 var KEYBOARD_OFFSET = 0;
+var EVENT_PAYLOAD_SIZE = 8;
+var EVENT_PAYLOAD_ALIGN = 4;
+function keyToKeyCode(key) {
+  return Key[key];
+}
+function keyCodeToKey(code) {
+  return Key[code];
+}
+function mouseButtonToMouseButtonCode(button) {
+  return MouseButton[button];
+}
 function mouseButtonCodeToMouseButton(code) {
   return MouseButton[code];
 }
@@ -937,76 +982,1426 @@ class KeyboardContext {
     return state;
   }
 }
+
+class TimeContext {
+  dataView;
+  constructor(dataView) {
+    this.dataView = dataView;
+  }
+  get frame() {
+    if (!this.dataView) {
+      throw new Error("TimeContext DataView is not initialized");
+    }
+    return this.dataView.getUint32(0, true);
+  }
+  get dt() {
+    if (!this.dataView) {
+      throw new Error("TimeContext DataView is not initialized");
+    }
+    return this.dataView.getUint32(4, true) / 1000;
+  }
+  get time() {
+    if (!this.dataView) {
+      throw new Error("TimeContext DataView is not initialized");
+    }
+    return this.dataView.getUint32(8, true) / 1000;
+  }
+}
 var DEFAULT_WASM_URL = new URL("../wasm/bloop.wasm", import.meta.url);
 var TIME_CTX_OFFSET = 0;
 var INPUT_CTX_OFFSET = TIME_CTX_OFFSET + 4;
 var EVENTS_OFFSET = INPUT_CTX_OFFSET + 4;
+var SNAPSHOT_HEADER_USER_LEN_OFFSET = 4;
+var SNAPSHOT_HEADER_ENGINE_LEN_OFFSET = 8;
+var originalConsole = globalThis.console;
+var noop = () => {};
+var stubConsole = Object.fromEntries(Object.keys(originalConsole).map((key) => [key, noop]));
+function muteConsole() {
+  globalThis.console = stubConsole;
+}
+function unmuteConsole() {
+  globalThis.console = originalConsole;
+}
 
-// src/mod.ts
-function connect(runtime) {
-  let isPaused = true;
-  let now = performance.now();
-  let frameHandle = -1;
-  const handleKeydown = (event) => {
-    runtime.emit.keydown(event.key);
-  };
-  window.addEventListener("keydown", handleKeydown);
-  const handleKeyup = (event) => {
-    runtime.emit.keyup(event.key);
-  };
-  window.addEventListener("keyup", handleKeyup);
-  const handleMousemove = (event) => {
-    runtime.emit.mousemove(event.clientX, event.clientY);
-  };
-  window.addEventListener("mousemove", handleMousemove);
-  const handleMousedown = (event) => {
-    runtime.emit.mousedown(mouseButtonCodeToMouseButton(event.button + 1));
+class Sim {
+  wasm;
+  id;
+  #memory;
+  #time;
+  #serialize;
+  #isPaused = false;
+  constructor(wasm, memory, opts) {
+    this.wasm = wasm;
+    this.#memory = memory;
+    this.#time = new TimeContext(new DataView(this.#memory.buffer, this.wasm.get_time_ctx()));
+    this.id = `${Math.floor(Math.random() * 1e6)}`;
+    this.#serialize = opts?.serialize;
+  }
+  step(ms) {
+    if (this.#isPaused && !this.isReplaying) {
+      return;
+    }
+    this.wasm.step(ms ?? 16);
+  }
+  cloneSession(source) {
+    this.loadTape(source.saveTape());
+    this.restore(source.snapshot());
+  }
+  pause() {
+    this.#isPaused = true;
+  }
+  unpause() {
+    this.#isPaused = false;
+  }
+  get isPaused() {
+    return this.#isPaused;
+  }
+  stepBack() {
+    if (this.time.frame === 0) {
+      return;
+    }
+    this.seek(this.time.frame - 1);
+  }
+  seek(frame, inclusive) {
+    assert(this.hasHistory, "Not recording or playing back, can't seek to frame");
+    const targetFrame = inclusive ? frame + 1 : frame;
+    const shouldMute = frame < this.time.frame;
+    if (shouldMute) {
+      muteConsole();
+    }
+    this.wasm.seek(targetFrame);
+    if (shouldMute) {
+      unmuteConsole();
+    }
+  }
+  record() {
+    const serializer = this.#serialize ? this.#serialize() : null;
+    const size = serializer ? serializer.size : 0;
+    const result = this.wasm.start_recording(size, 1024);
+    if (result !== 0) {
+      throw new Error(`failed to start recording, error code=${result}`);
+    }
+  }
+  snapshot() {
+    const serializer = this.#serialize ? this.#serialize() : null;
+    const size = serializer ? serializer.size : 0;
+    const ptr = this.wasm.take_snapshot(size);
+    const header = new Uint32Array(this.#memory.buffer, ptr, 4);
+    const userLenIndex = SNAPSHOT_HEADER_USER_LEN_OFFSET / Uint32Array.BYTES_PER_ELEMENT;
+    const engineLenIndex = SNAPSHOT_HEADER_ENGINE_LEN_OFFSET / Uint32Array.BYTES_PER_ELEMENT;
+    assert(header[userLenIndex], `header user length missing`);
+    assert(header[engineLenIndex], `header engine length missing`);
+    const length = header[userLenIndex] + header[engineLenIndex];
+    const memoryView = new Uint8Array(this.#memory.buffer, ptr, length);
+    const copy = new Uint8Array(length);
+    copy.set(memoryView);
+    return copy;
+  }
+  saveTape() {
+    const tapeLen = this.wasm.get_tape_len();
+    const tapePtr = this.wasm.get_tape_ptr();
+    const memoryView = new Uint8Array(this.#memory.buffer, tapePtr, tapeLen);
+    const copy = new Uint8Array(tapeLen);
+    copy.set(memoryView);
+    return copy;
+  }
+  loadTape(tape) {
+    const tapePtr = this.wasm.alloc(tape.byteLength);
+    assert(tapePtr > 0, `failed to allocate ${tape.byteLength} bytes for tape load, pointer=${tapePtr}`);
+    const memoryView = new Uint8Array(this.#memory.buffer, tapePtr, tape.byteLength);
+    memoryView.set(tape);
+    this.wasm.stop_recording();
+    const result = this.wasm.load_tape(tapePtr, tape.byteLength);
+    assert(result === 0, `failed to load tape, error code=${result}`);
+    this.wasm.free(tapePtr, tape.byteLength);
+  }
+  restore(snapshot) {
+    const dataPtr = this.wasm.alloc(snapshot.byteLength);
+    assert(dataPtr > 0, `failed to allocate ${snapshot.byteLength} bytes for snapshot restore, pointer=${dataPtr}`);
+    const memoryView = new Uint8Array(this.#memory.buffer, dataPtr, snapshot.byteLength);
+    memoryView.set(snapshot);
+    this.wasm.restore(dataPtr);
+    this.wasm.free(dataPtr, snapshot.byteLength);
+  }
+  unmount() {
+    this.wasm.deinit();
+  }
+  get time() {
+    if (!this.#time.dataView || this.#time.dataView.buffer !== this.#memory.buffer) {
+      this.#time.dataView = new DataView(this.#memory.buffer, this.wasm.get_time_ctx());
+    }
+    return this.#time;
+  }
+  get buffer() {
+    return this.#memory.buffer;
+  }
+  get isRecording() {
+    return this.wasm.is_recording();
+  }
+  get isReplaying() {
+    return this.wasm.is_replaying();
+  }
+  get hasHistory() {
+    return this.isRecording || this.isReplaying;
+  }
+  emit = {
+    keydown: (key) => {
+      this.wasm.emit_keydown(keyToKeyCode(key));
+    },
+    keyup: (key) => {
+      this.wasm.emit_keyup(keyToKeyCode(key));
+    },
+    mousemove: (x, y) => {
+      this.wasm.emit_mousemove(x, y);
+    },
+    mousedown: (button) => {
+      this.wasm.emit_mousedown(mouseButtonToMouseButtonCode(button));
+    },
+    mouseup: (button) => {
+      this.wasm.emit_mouseup(mouseButtonToMouseButtonCode(button));
+    },
+    mousewheel: (x, y) => {
+      this.wasm.emit_mousewheel(x, y);
+    }
   };
-  window.addEventListener("mousedown", handleMousedown);
-  const handleMousewheel = (event) => {
-    runtime.emit.mousewheel(event.deltaX, event.deltaY);
+}
+async function mount(opts) {
+  const bytes = await fetch(opts.wasmUrl ?? DEFAULT_WASM_URL).then((res) => res.arrayBuffer()).catch((e) => {
+    console.error(`Failed to fetch wasm at ${opts.wasmUrl ?? DEFAULT_WASM_URL}`, e);
+    throw e;
+  });
+  const memory = new WebAssembly.Memory({ initial: 17, maximum: 1000 });
+  const wasmInstantiatedSource = await WebAssembly.instantiate(bytes, {
+    env: {
+      memory,
+      __cb: function(system_handle, ptr) {
+        opts.hooks.setBuffer(memory.buffer);
+        opts.hooks.systemsCallback(system_handle, ptr);
+      },
+      console_log: function(ptr, len) {
+        const bytes2 = new Uint8Array(memory.buffer, ptr, len);
+        const string = new TextDecoder("utf-8").decode(bytes2);
+        console.log(string);
+      },
+      user_data_len: function() {
+        const serializer = opts.hooks.serialize();
+        return serializer ? serializer.size : 0;
+      },
+      user_data_serialize: function(ptr, len) {
+        const serializer = opts.hooks.serialize();
+        assert(len === serializer.size, `user_data_serialize length mismatch, expected=${serializer.size} got=${len}`);
+        serializer.write(memory.buffer, ptr);
+      },
+      user_data_deserialize: function(ptr, len) {
+        opts.hooks.deserialize(memory.buffer, ptr, len);
+      }
+    }
+  });
+  const wasm = wasmInstantiatedSource.instance.exports;
+  const enginePointer = wasm.initialize();
+  const sim = new Sim(wasm, memory, {
+    serialize: opts.hooks.serialize
+  });
+  if (opts.startRecording ?? true) {
+    sim.record();
+  }
+  opts.hooks.setBuffer(memory.buffer);
+  opts.hooks.setContext(enginePointer);
+  return {
+    sim
   };
-  window.addEventListener("wheel", handleMousewheel);
-  const playbarHotkeys = (event) => {
-    const isPauseHotkey = event.key === "Enter" && (event.ctrlKey || event.metaKey);
-    if (isPauseHotkey || event.key === "6") {
-      isPaused = !isPaused;
+}
+
+class Bloop {
+  #systems = [];
+  #context;
+  #engineBuffer = new ArrayBuffer(0);
+  static create(opts = {}) {
+    return new Bloop(opts, "dontCallMeDirectly");
+  }
+  constructor(opts = {}, dontCallMeDirectly) {
+    if (dontCallMeDirectly !== "dontCallMeDirectly") {
+      throw new Error("Bloop constructor is private. Use Bloop.create() to create a new game instance.");
     }
-    if (isPaused) {
-      switch (event.key) {
-        case ",":
-        case "5":
-          runtime.stepBack();
-          break;
-        case ".":
-        case "7":
-          runtime.step();
-          break;
+    this.#context = {
+      bag: opts.bag ?? {},
+      time: new TimeContext,
+      inputs: new InputContext,
+      rawPointer: -1
+    };
+  }
+  get bag() {
+    return this.#context.bag;
+  }
+  get context() {
+    return this.#context;
+  }
+  system(label, system) {
+    system.label ??= label;
+    this.#systems.push(system);
+    return this.#systems.length;
+  }
+  hooks = {
+    serialize: () => {
+      const str = JSON.stringify(this.#context.bag);
+      const encoder = new TextEncoder;
+      const textBytes = encoder.encode(str);
+      return {
+        size: textBytes.byteLength,
+        write: (buffer, ptr) => {
+          const memoryView = new Uint8Array(buffer, ptr, textBytes.byteLength);
+          memoryView.set(textBytes);
+        }
+      };
+    },
+    deserialize: (buffer, ptr, len) => {
+      const bagBytes = new Uint8Array(buffer, ptr, len);
+      const decoder = new TextDecoder;
+      const str = decoder.decode(bagBytes);
+      try {
+        this.#context.bag = JSON.parse(str);
+      } catch (e) {
+        console.error("failed to deserialize bag", { json: str, error: e });
+      }
+    },
+    setBuffer: (buffer) => {
+      this.#engineBuffer = buffer;
+    },
+    setContext: (ptr) => {
+      if (!this.#engineBuffer) {
+        throw new Error("Tried to set context before engine buffer");
+      }
+      const dv = new DataView(this.#engineBuffer, ptr);
+      const timeCtxPtr = dv.getUint32(TIME_CTX_OFFSET, true);
+      const inputCtxPtr = dv.getUint32(INPUT_CTX_OFFSET, true);
+      this.#context.rawPointer = ptr;
+      this.#context.inputs.dataView = new DataView(this.#engineBuffer, inputCtxPtr);
+      this.#context.time.dataView = new DataView(this.#engineBuffer, timeCtxPtr);
+    },
+    systemsCallback: (system_handle, ptr) => {
+      this.hooks.setContext(ptr);
+      const dv = new DataView(this.#engineBuffer, ptr);
+      const eventsPtr = dv.getUint32(EVENTS_OFFSET, true);
+      const eventsDataView = new DataView(this.#engineBuffer, eventsPtr);
+      for (const system of this.#systems) {
+        system.update?.(this.#context);
+        const eventCount = eventsDataView.getUint32(0, true);
+        let offset = Uint32Array.BYTES_PER_ELEMENT;
+        for (let i = 0;i < eventCount; i++) {
+          const eventType = eventsDataView.getUint8(offset);
+          const payloadSize = EVENT_PAYLOAD_SIZE;
+          const payloadByte = eventsDataView.getUint8(offset + EVENT_PAYLOAD_ALIGN);
+          const payloadVec2 = {
+            x: eventsDataView.getFloat32(offset + EVENT_PAYLOAD_ALIGN, true),
+            y: eventsDataView.getFloat32(offset + EVENT_PAYLOAD_ALIGN + Float32Array.BYTES_PER_ELEMENT, true)
+          };
+          switch (eventType) {
+            case exports_enums.EventType.KeyDown: {
+              system.keydown?.(attachEvent(this.#context, {
+                key: keyCodeToKey(payloadByte)
+              }));
+              break;
+            }
+            case exports_enums.EventType.KeyUp:
+              system.keyup?.(attachEvent(this.#context, {
+                key: keyCodeToKey(payloadByte)
+              }));
+              break;
+            case exports_enums.EventType.MouseDown:
+              system.mousedown?.(attachEvent(this.#context, {
+                button: mouseButtonCodeToMouseButton(payloadByte)
+              }));
+              break;
+            case exports_enums.EventType.MouseUp:
+              system.mouseup?.(attachEvent(this.#context, {
+                button: mouseButtonCodeToMouseButton(payloadByte)
+              }));
+              break;
+            case exports_enums.EventType.MouseMove:
+              system.mousemove?.(attachEvent(this.#context, {
+                x: payloadVec2.x,
+                y: payloadVec2.y
+              }));
+              break;
+            case exports_enums.EventType.MouseWheel:
+              system.mousewheel?.(attachEvent(this.#context, {
+                x: payloadVec2.x,
+                y: payloadVec2.y
+              }));
+              break;
+            default:
+              throw new Error(`Unknown event type: ${eventType}`);
+          }
+          offset += EVENT_PAYLOAD_ALIGN + EVENT_PAYLOAD_SIZE;
+        }
+        this.#context.event = undefined;
       }
     }
   };
-  window.addEventListener("keydown", playbarHotkeys);
-  function frame() {
-    if (!isPaused) {
-      runtime.step(performance.now() - now);
+}
+function attachEvent(context, event) {
+  context.event = event;
+  return context;
+}
+
+// ../engine/dist/engine.js
+var __defProp3 = Object.defineProperty;
+var __export3 = (target, all) => {
+  for (var name in all)
+    __defProp3(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var exports_enums2 = {};
+__export3(exports_enums2, {
+  MouseButton: () => MouseButton2,
+  Key: () => Key2,
+  EventType: () => EventType2
+});
+var EventType2;
+((EventType22) => {
+  EventType22[EventType22["None"] = 0] = "None";
+  EventType22[EventType22["KeyDown"] = 1] = "KeyDown";
+  EventType22[EventType22["KeyUp"] = 2] = "KeyUp";
+  EventType22[EventType22["MouseMove"] = 3] = "MouseMove";
+  EventType22[EventType22["MouseDown"] = 4] = "MouseDown";
+  EventType22[EventType22["MouseUp"] = 5] = "MouseUp";
+  EventType22[EventType22["MouseWheel"] = 6] = "MouseWheel";
+  EventType22[EventType22["FrameStart"] = 7] = "FrameStart";
+})(EventType2 ||= {});
+var MouseButton2;
+((MouseButton22) => {
+  MouseButton22[MouseButton22["None"] = 0] = "None";
+  MouseButton22[MouseButton22["Left"] = 1] = "Left";
+  MouseButton22[MouseButton22["Middle"] = 2] = "Middle";
+  MouseButton22[MouseButton22["Right"] = 3] = "Right";
+  MouseButton22[MouseButton22["X1"] = 4] = "X1";
+  MouseButton22[MouseButton22["X2"] = 5] = "X2";
+  MouseButton22[MouseButton22["X3"] = 6] = "X3";
+  MouseButton22[MouseButton22["X4"] = 7] = "X4";
+  MouseButton22[MouseButton22["X5"] = 8] = "X5";
+})(MouseButton2 ||= {});
+var Key2;
+((Key22) => {
+  Key22[Key22["None"] = 0] = "None";
+  Key22[Key22["Backquote"] = 1] = "Backquote";
+  Key22[Key22["Backslash"] = 2] = "Backslash";
+  Key22[Key22["BracketLeft"] = 3] = "BracketLeft";
+  Key22[Key22["BracketRight"] = 4] = "BracketRight";
+  Key22[Key22["Comma"] = 5] = "Comma";
+  Key22[Key22["Digit0"] = 6] = "Digit0";
+  Key22[Key22["Digit1"] = 7] = "Digit1";
+  Key22[Key22["Digit2"] = 8] = "Digit2";
+  Key22[Key22["Digit3"] = 9] = "Digit3";
+  Key22[Key22["Digit4"] = 10] = "Digit4";
+  Key22[Key22["Digit5"] = 11] = "Digit5";
+  Key22[Key22["Digit6"] = 12] = "Digit6";
+  Key22[Key22["Digit7"] = 13] = "Digit7";
+  Key22[Key22["Digit8"] = 14] = "Digit8";
+  Key22[Key22["Digit9"] = 15] = "Digit9";
+  Key22[Key22["Equal"] = 16] = "Equal";
+  Key22[Key22["IntlBackslash"] = 17] = "IntlBackslash";
+  Key22[Key22["IntlRo"] = 18] = "IntlRo";
+  Key22[Key22["IntlYen"] = 19] = "IntlYen";
+  Key22[Key22["KeyA"] = 20] = "KeyA";
+  Key22[Key22["KeyB"] = 21] = "KeyB";
+  Key22[Key22["KeyC"] = 22] = "KeyC";
+  Key22[Key22["KeyD"] = 23] = "KeyD";
+  Key22[Key22["KeyE"] = 24] = "KeyE";
+  Key22[Key22["KeyF"] = 25] = "KeyF";
+  Key22[Key22["KeyG"] = 26] = "KeyG";
+  Key22[Key22["KeyH"] = 27] = "KeyH";
+  Key22[Key22["KeyI"] = 28] = "KeyI";
+  Key22[Key22["KeyJ"] = 29] = "KeyJ";
+  Key22[Key22["KeyK"] = 30] = "KeyK";
+  Key22[Key22["KeyL"] = 31] = "KeyL";
+  Key22[Key22["KeyM"] = 32] = "KeyM";
+  Key22[Key22["KeyN"] = 33] = "KeyN";
+  Key22[Key22["KeyO"] = 34] = "KeyO";
+  Key22[Key22["KeyP"] = 35] = "KeyP";
+  Key22[Key22["KeyQ"] = 36] = "KeyQ";
+  Key22[Key22["KeyR"] = 37] = "KeyR";
+  Key22[Key22["KeyS"] = 38] = "KeyS";
+  Key22[Key22["KeyT"] = 39] = "KeyT";
+  Key22[Key22["KeyU"] = 40] = "KeyU";
+  Key22[Key22["KeyV"] = 41] = "KeyV";
+  Key22[Key22["KeyW"] = 42] = "KeyW";
+  Key22[Key22["KeyX"] = 43] = "KeyX";
+  Key22[Key22["KeyY"] = 44] = "KeyY";
+  Key22[Key22["KeyZ"] = 45] = "KeyZ";
+  Key22[Key22["Minus"] = 46] = "Minus";
+  Key22[Key22["Period"] = 47] = "Period";
+  Key22[Key22["Quote"] = 48] = "Quote";
+  Key22[Key22["Semicolon"] = 49] = "Semicolon";
+  Key22[Key22["Slash"] = 50] = "Slash";
+  Key22[Key22["AltLeft"] = 51] = "AltLeft";
+  Key22[Key22["AltRight"] = 52] = "AltRight";
+  Key22[Key22["Backspace"] = 53] = "Backspace";
+  Key22[Key22["CapsLock"] = 54] = "CapsLock";
+  Key22[Key22["ContextMenu"] = 55] = "ContextMenu";
+  Key22[Key22["ControlLeft"] = 56] = "ControlLeft";
+  Key22[Key22["ControlRight"] = 57] = "ControlRight";
+  Key22[Key22["Enter"] = 58] = "Enter";
+  Key22[Key22["MetaLeft"] = 59] = "MetaLeft";
+  Key22[Key22["MetaRight"] = 60] = "MetaRight";
+  Key22[Key22["ShiftLeft"] = 61] = "ShiftLeft";
+  Key22[Key22["ShiftRight"] = 62] = "ShiftRight";
+  Key22[Key22["Space"] = 63] = "Space";
+  Key22[Key22["Tab"] = 64] = "Tab";
+  Key22[Key22["Convert"] = 65] = "Convert";
+  Key22[Key22["KanaMode"] = 66] = "KanaMode";
+  Key22[Key22["Lang1"] = 67] = "Lang1";
+  Key22[Key22["Lang2"] = 68] = "Lang2";
+  Key22[Key22["Lang3"] = 69] = "Lang3";
+  Key22[Key22["Lang4"] = 70] = "Lang4";
+  Key22[Key22["Lang5"] = 71] = "Lang5";
+  Key22[Key22["NonConvert"] = 72] = "NonConvert";
+  Key22[Key22["Delete"] = 73] = "Delete";
+  Key22[Key22["End"] = 74] = "End";
+  Key22[Key22["Help"] = 75] = "Help";
+  Key22[Key22["Home"] = 76] = "Home";
+  Key22[Key22["Insert"] = 77] = "Insert";
+  Key22[Key22["PageDown"] = 78] = "PageDown";
+  Key22[Key22["PageUp"] = 79] = "PageUp";
+  Key22[Key22["ArrowDown"] = 80] = "ArrowDown";
+  Key22[Key22["ArrowLeft"] = 81] = "ArrowLeft";
+  Key22[Key22["ArrowRight"] = 82] = "ArrowRight";
+  Key22[Key22["ArrowUp"] = 83] = "ArrowUp";
+  Key22[Key22["NumLock"] = 84] = "NumLock";
+  Key22[Key22["Numpad0"] = 85] = "Numpad0";
+  Key22[Key22["Numpad1"] = 86] = "Numpad1";
+  Key22[Key22["Numpad2"] = 87] = "Numpad2";
+  Key22[Key22["Numpad3"] = 88] = "Numpad3";
+  Key22[Key22["Numpad4"] = 89] = "Numpad4";
+  Key22[Key22["Numpad5"] = 90] = "Numpad5";
+  Key22[Key22["Numpad6"] = 91] = "Numpad6";
+  Key22[Key22["Numpad7"] = 92] = "Numpad7";
+  Key22[Key22["Numpad8"] = 93] = "Numpad8";
+  Key22[Key22["Numpad9"] = 94] = "Numpad9";
+  Key22[Key22["NumpadAdd"] = 95] = "NumpadAdd";
+  Key22[Key22["NumpadBackspace"] = 96] = "NumpadBackspace";
+  Key22[Key22["NumpadClear"] = 97] = "NumpadClear";
+  Key22[Key22["NumpadClearEntry"] = 98] = "NumpadClearEntry";
+  Key22[Key22["NumpadComma"] = 99] = "NumpadComma";
+  Key22[Key22["NumpadDecimal"] = 100] = "NumpadDecimal";
+  Key22[Key22["NumpadDivide"] = 101] = "NumpadDivide";
+  Key22[Key22["NumpadEnter"] = 102] = "NumpadEnter";
+  Key22[Key22["NumpadEqual"] = 103] = "NumpadEqual";
+  Key22[Key22["NumpadHash"] = 104] = "NumpadHash";
+  Key22[Key22["NumpadMemoryAdd"] = 105] = "NumpadMemoryAdd";
+  Key22[Key22["NumpadMemoryClear"] = 106] = "NumpadMemoryClear";
+  Key22[Key22["NumpadMemoryRecall"] = 107] = "NumpadMemoryRecall";
+  Key22[Key22["NumpadMemoryStore"] = 108] = "NumpadMemoryStore";
+  Key22[Key22["NumpadMemorySubtract"] = 109] = "NumpadMemorySubtract";
+  Key22[Key22["NumpadMultiply"] = 110] = "NumpadMultiply";
+  Key22[Key22["NumpadParenLeft"] = 111] = "NumpadParenLeft";
+  Key22[Key22["NumpadParenRight"] = 112] = "NumpadParenRight";
+  Key22[Key22["NumpadStar"] = 113] = "NumpadStar";
+  Key22[Key22["NumpadSubtract"] = 114] = "NumpadSubtract";
+  Key22[Key22["Escape"] = 115] = "Escape";
+  Key22[Key22["Fn"] = 116] = "Fn";
+  Key22[Key22["FnLock"] = 117] = "FnLock";
+  Key22[Key22["PrintScreen"] = 118] = "PrintScreen";
+  Key22[Key22["ScrollLock"] = 119] = "ScrollLock";
+  Key22[Key22["Pause"] = 120] = "Pause";
+  Key22[Key22["BrowserBack"] = 121] = "BrowserBack";
+  Key22[Key22["BrowserFavorites"] = 122] = "BrowserFavorites";
+  Key22[Key22["BrowserForward"] = 123] = "BrowserForward";
+  Key22[Key22["BrowserHome"] = 124] = "BrowserHome";
+  Key22[Key22["BrowserRefresh"] = 125] = "BrowserRefresh";
+  Key22[Key22["BrowserSearch"] = 126] = "BrowserSearch";
+  Key22[Key22["BrowserStop"] = 127] = "BrowserStop";
+  Key22[Key22["Eject"] = 128] = "Eject";
+  Key22[Key22["LaunchApp1"] = 129] = "LaunchApp1";
+  Key22[Key22["LaunchApp2"] = 130] = "LaunchApp2";
+  Key22[Key22["LaunchMail"] = 131] = "LaunchMail";
+  Key22[Key22["MediaPlayPause"] = 132] = "MediaPlayPause";
+  Key22[Key22["MediaSelect"] = 133] = "MediaSelect";
+  Key22[Key22["MediaStop"] = 134] = "MediaStop";
+  Key22[Key22["MediaTrackNext"] = 135] = "MediaTrackNext";
+  Key22[Key22["MediaTrackPrevious"] = 136] = "MediaTrackPrevious";
+  Key22[Key22["Power"] = 137] = "Power";
+  Key22[Key22["Sleep"] = 138] = "Sleep";
+  Key22[Key22["AudioVolumeDown"] = 139] = "AudioVolumeDown";
+  Key22[Key22["AudioVolumeMute"] = 140] = "AudioVolumeMute";
+  Key22[Key22["AudioVolumeUp"] = 141] = "AudioVolumeUp";
+  Key22[Key22["WakeUp"] = 142] = "WakeUp";
+  Key22[Key22["Hyper"] = 143] = "Hyper";
+  Key22[Key22["Super"] = 144] = "Super";
+  Key22[Key22["Turbo"] = 145] = "Turbo";
+  Key22[Key22["Abort"] = 146] = "Abort";
+  Key22[Key22["Resume"] = 147] = "Resume";
+  Key22[Key22["Suspend"] = 148] = "Suspend";
+  Key22[Key22["Again"] = 149] = "Again";
+  Key22[Key22["Copy"] = 150] = "Copy";
+  Key22[Key22["Cut"] = 151] = "Cut";
+  Key22[Key22["Find"] = 152] = "Find";
+  Key22[Key22["Open"] = 153] = "Open";
+  Key22[Key22["Paste"] = 154] = "Paste";
+  Key22[Key22["Props"] = 155] = "Props";
+  Key22[Key22["Select"] = 156] = "Select";
+  Key22[Key22["Undo"] = 157] = "Undo";
+  Key22[Key22["Hiragana"] = 158] = "Hiragana";
+  Key22[Key22["Katakana"] = 159] = "Katakana";
+  Key22[Key22["F1"] = 160] = "F1";
+  Key22[Key22["F2"] = 161] = "F2";
+  Key22[Key22["F3"] = 162] = "F3";
+  Key22[Key22["F4"] = 163] = "F4";
+  Key22[Key22["F5"] = 164] = "F5";
+  Key22[Key22["F6"] = 165] = "F6";
+  Key22[Key22["F7"] = 166] = "F7";
+  Key22[Key22["F8"] = 167] = "F8";
+  Key22[Key22["F9"] = 168] = "F9";
+  Key22[Key22["F10"] = 169] = "F10";
+  Key22[Key22["F11"] = 170] = "F11";
+  Key22[Key22["F12"] = 171] = "F12";
+  Key22[Key22["F13"] = 172] = "F13";
+  Key22[Key22["F14"] = 173] = "F14";
+  Key22[Key22["F15"] = 174] = "F15";
+  Key22[Key22["F16"] = 175] = "F16";
+  Key22[Key22["F17"] = 176] = "F17";
+  Key22[Key22["F18"] = 177] = "F18";
+  Key22[Key22["F19"] = 178] = "F19";
+  Key22[Key22["F20"] = 179] = "F20";
+  Key22[Key22["F21"] = 180] = "F21";
+  Key22[Key22["F22"] = 181] = "F22";
+  Key22[Key22["F23"] = 182] = "F23";
+  Key22[Key22["F24"] = 183] = "F24";
+  Key22[Key22["F25"] = 184] = "F25";
+  Key22[Key22["F26"] = 185] = "F26";
+  Key22[Key22["F27"] = 186] = "F27";
+  Key22[Key22["F28"] = 187] = "F28";
+  Key22[Key22["F29"] = 188] = "F29";
+  Key22[Key22["F30"] = 189] = "F30";
+  Key22[Key22["F31"] = 190] = "F31";
+  Key22[Key22["F32"] = 191] = "F32";
+  Key22[Key22["F33"] = 192] = "F33";
+  Key22[Key22["F34"] = 193] = "F34";
+  Key22[Key22["F35"] = 194] = "F35";
+})(Key2 ||= {});
+var MOUSE_OFFSET2 = 256;
+var MOUSE_BUTTONS_OFFSET2 = 16;
+var KEYBOARD_OFFSET2 = 0;
+function mouseButtonCodeToMouseButton2(code) {
+  return MouseButton2[code];
+}
+
+class InputContext2 {
+  #dataView;
+  #keys;
+  #mouse;
+  constructor(dataView) {
+    if (dataView) {
+      this.#dataView = dataView;
     }
-    now = performance.now();
-    frameHandle = requestAnimationFrame(frame);
-  }
-  frame();
-  return () => {
-    window.removeEventListener("keydown", handleKeydown);
-    window.removeEventListener("keyup", handleKeyup);
-    window.removeEventListener("mousemove", handleMousemove);
-    window.removeEventListener("mousedown", handleMousedown);
-    window.removeEventListener("wheel", handleMousewheel);
-    window.removeEventListener("keydown", playbarHotkeys);
-    cancelAnimationFrame(frameHandle);
-  };
+  }
+  get dataView() {
+    if (!this.#dataView) {
+      throw new Error("DataView is not initialized on InputContext");
+    }
+    return this.#dataView;
+  }
+  set dataView(dataView) {
+    this.#dataView = dataView;
+    this.#keys = undefined;
+    this.#mouse = undefined;
+  }
+  get keys() {
+    if (!this.#keys) {
+      this.#keys = new KeyboardContext2(new DataView(this.dataView.buffer, this.dataView.byteOffset + KEYBOARD_OFFSET2));
+    }
+    return this.#keys;
+  }
+  get mouse() {
+    if (!this.#mouse) {
+      this.#mouse = new MouseContext2(new DataView(this.dataView.buffer, this.dataView.byteOffset + MOUSE_OFFSET2));
+    }
+    return this.#mouse;
+  }
+}
+
+class MouseContext2 {
+  #dataView;
+  #buttonStates = new Map;
+  constructor(dataView) {
+    this.#dataView = dataView;
+  }
+  get x() {
+    return this.#dataView.getFloat32(0, true);
+  }
+  get y() {
+    return this.#dataView.getFloat32(4, true);
+  }
+  get wheel() {
+    return { x: this.wheelX, y: this.wheelY };
+  }
+  get wheelX() {
+    return this.#dataView.getFloat32(8, true);
+  }
+  get wheelY() {
+    return this.#dataView.getFloat32(12, true);
+  }
+  get left() {
+    return this.#buttonState(1);
+  }
+  get right() {
+    return this.#buttonState(3);
+  }
+  get middle() {
+    return this.#buttonState(2);
+  }
+  #buttonState(code) {
+    let state;
+    if (this.#buttonStates.has(code)) {
+      state = this.#buttonStates.get(code);
+    } else {
+      state = { down: false, held: false, up: false };
+      this.#buttonStates.set(code, state);
+    }
+    const offset = MOUSE_BUTTONS_OFFSET2;
+    state.held = !!(this.#dataView.getUint8(offset + code) & 1);
+    state.down = state.held && !(this.#dataView.getUint8(offset + code) & 2);
+    state.up = !state.held && !!(this.#dataView.getUint8(offset + code) & 2);
+    return state;
+  }
+}
+
+class KeyboardContext2 {
+  #dataView;
+  #keystates = new Map;
+  constructor(dataView) {
+    this.#dataView = dataView;
+  }
+  get shift() {
+    return this.shiftLeft || this.shiftRight;
+  }
+  get alt() {
+    return this.altLeft || this.altRight;
+  }
+  get control() {
+    return this.controlLeft || this.controlRight;
+  }
+  get meta() {
+    return this.metaLeft || this.metaRight;
+  }
+  get backquote() {
+    return this.#keystate(1);
+  }
+  get backslash() {
+    return this.#keystate(2);
+  }
+  get bracketLeft() {
+    return this.#keystate(3);
+  }
+  get bracketRight() {
+    return this.#keystate(4);
+  }
+  get comma() {
+    return this.#keystate(5);
+  }
+  get digit0() {
+    return this.#keystate(6);
+  }
+  get digit1() {
+    return this.#keystate(7);
+  }
+  get digit2() {
+    return this.#keystate(8);
+  }
+  get digit3() {
+    return this.#keystate(9);
+  }
+  get digit4() {
+    return this.#keystate(10);
+  }
+  get digit5() {
+    return this.#keystate(11);
+  }
+  get digit6() {
+    return this.#keystate(12);
+  }
+  get digit7() {
+    return this.#keystate(13);
+  }
+  get digit8() {
+    return this.#keystate(14);
+  }
+  get digit9() {
+    return this.#keystate(15);
+  }
+  get equal() {
+    return this.#keystate(16);
+  }
+  get intlBackslash() {
+    return this.#keystate(17);
+  }
+  get intlRo() {
+    return this.#keystate(18);
+  }
+  get intlYen() {
+    return this.#keystate(19);
+  }
+  get a() {
+    return this.#keystate(20);
+  }
+  get b() {
+    return this.#keystate(21);
+  }
+  get c() {
+    return this.#keystate(22);
+  }
+  get d() {
+    return this.#keystate(23);
+  }
+  get e() {
+    return this.#keystate(24);
+  }
+  get f() {
+    return this.#keystate(25);
+  }
+  get g() {
+    return this.#keystate(26);
+  }
+  get h() {
+    return this.#keystate(27);
+  }
+  get i() {
+    return this.#keystate(28);
+  }
+  get j() {
+    return this.#keystate(29);
+  }
+  get k() {
+    return this.#keystate(30);
+  }
+  get l() {
+    return this.#keystate(31);
+  }
+  get m() {
+    return this.#keystate(32);
+  }
+  get n() {
+    return this.#keystate(33);
+  }
+  get o() {
+    return this.#keystate(34);
+  }
+  get p() {
+    return this.#keystate(35);
+  }
+  get q() {
+    return this.#keystate(36);
+  }
+  get r() {
+    return this.#keystate(37);
+  }
+  get s() {
+    return this.#keystate(38);
+  }
+  get t() {
+    return this.#keystate(39);
+  }
+  get u() {
+    return this.#keystate(40);
+  }
+  get v() {
+    return this.#keystate(41);
+  }
+  get w() {
+    return this.#keystate(42);
+  }
+  get x() {
+    return this.#keystate(43);
+  }
+  get y() {
+    return this.#keystate(44);
+  }
+  get z() {
+    return this.#keystate(45);
+  }
+  get minus() {
+    return this.#keystate(46);
+  }
+  get period() {
+    return this.#keystate(47);
+  }
+  get quote() {
+    return this.#keystate(48);
+  }
+  get semicolon() {
+    return this.#keystate(49);
+  }
+  get slash() {
+    return this.#keystate(50);
+  }
+  get altLeft() {
+    return this.#keystate(51);
+  }
+  get altRight() {
+    return this.#keystate(52);
+  }
+  get backspace() {
+    return this.#keystate(53);
+  }
+  get capsLock() {
+    return this.#keystate(54);
+  }
+  get contextMenu() {
+    return this.#keystate(55);
+  }
+  get controlLeft() {
+    return this.#keystate(56);
+  }
+  get controlRight() {
+    return this.#keystate(57);
+  }
+  get enter() {
+    return this.#keystate(58);
+  }
+  get metaLeft() {
+    return this.#keystate(59);
+  }
+  get metaRight() {
+    return this.#keystate(60);
+  }
+  get shiftLeft() {
+    return this.#keystate(61);
+  }
+  get shiftRight() {
+    return this.#keystate(62);
+  }
+  get space() {
+    return this.#keystate(63);
+  }
+  get tab() {
+    return this.#keystate(64);
+  }
+  get convert() {
+    return this.#keystate(65);
+  }
+  get kanaMode() {
+    return this.#keystate(66);
+  }
+  get lang1() {
+    return this.#keystate(67);
+  }
+  get lang2() {
+    return this.#keystate(68);
+  }
+  get lang3() {
+    return this.#keystate(69);
+  }
+  get lang4() {
+    return this.#keystate(70);
+  }
+  get lang5() {
+    return this.#keystate(71);
+  }
+  get nonConvert() {
+    return this.#keystate(72);
+  }
+  get delete() {
+    return this.#keystate(73);
+  }
+  get end() {
+    return this.#keystate(74);
+  }
+  get help() {
+    return this.#keystate(75);
+  }
+  get home() {
+    return this.#keystate(76);
+  }
+  get insert() {
+    return this.#keystate(77);
+  }
+  get pageDown() {
+    return this.#keystate(78);
+  }
+  get pageUp() {
+    return this.#keystate(79);
+  }
+  get arrowDown() {
+    return this.#keystate(80);
+  }
+  get arrowLeft() {
+    return this.#keystate(81);
+  }
+  get arrowRight() {
+    return this.#keystate(82);
+  }
+  get arrowUp() {
+    return this.#keystate(83);
+  }
+  get numLock() {
+    return this.#keystate(84);
+  }
+  get numpad0() {
+    return this.#keystate(85);
+  }
+  get numpad1() {
+    return this.#keystate(86);
+  }
+  get numpad2() {
+    return this.#keystate(87);
+  }
+  get numpad3() {
+    return this.#keystate(88);
+  }
+  get numpad4() {
+    return this.#keystate(89);
+  }
+  get numpad5() {
+    return this.#keystate(90);
+  }
+  get numpad6() {
+    return this.#keystate(91);
+  }
+  get numpad7() {
+    return this.#keystate(92);
+  }
+  get numpad8() {
+    return this.#keystate(93);
+  }
+  get numpad9() {
+    return this.#keystate(94);
+  }
+  get numpadAdd() {
+    return this.#keystate(95);
+  }
+  get numpadBackspace() {
+    return this.#keystate(96);
+  }
+  get numpadClear() {
+    return this.#keystate(97);
+  }
+  get numpadClearEntry() {
+    return this.#keystate(98);
+  }
+  get numpadComma() {
+    return this.#keystate(99);
+  }
+  get numpadDecimal() {
+    return this.#keystate(100);
+  }
+  get numpadDivide() {
+    return this.#keystate(101);
+  }
+  get numpadEnter() {
+    return this.#keystate(102);
+  }
+  get numpadEqual() {
+    return this.#keystate(103);
+  }
+  get numpadHash() {
+    return this.#keystate(104);
+  }
+  get numpadMemoryAdd() {
+    return this.#keystate(105);
+  }
+  get numpadMemoryClear() {
+    return this.#keystate(106);
+  }
+  get numpadMemoryRecall() {
+    return this.#keystate(107);
+  }
+  get numpadMemoryStore() {
+    return this.#keystate(108);
+  }
+  get numpadMemorySubtract() {
+    return this.#keystate(109);
+  }
+  get numpadMultiply() {
+    return this.#keystate(110);
+  }
+  get numpadParenLeft() {
+    return this.#keystate(111);
+  }
+  get numpadParenRight() {
+    return this.#keystate(112);
+  }
+  get numpadStar() {
+    return this.#keystate(113);
+  }
+  get numpadSubtract() {
+    return this.#keystate(114);
+  }
+  get escape() {
+    return this.#keystate(115);
+  }
+  get fn() {
+    return this.#keystate(116);
+  }
+  get fnLock() {
+    return this.#keystate(117);
+  }
+  get printScreen() {
+    return this.#keystate(118);
+  }
+  get scrollLock() {
+    return this.#keystate(119);
+  }
+  get pause() {
+    return this.#keystate(120);
+  }
+  get browserBack() {
+    return this.#keystate(121);
+  }
+  get browserFavorites() {
+    return this.#keystate(122);
+  }
+  get browserForward() {
+    return this.#keystate(123);
+  }
+  get browserHome() {
+    return this.#keystate(124);
+  }
+  get browserRefresh() {
+    return this.#keystate(125);
+  }
+  get browserSearch() {
+    return this.#keystate(126);
+  }
+  get browserStop() {
+    return this.#keystate(127);
+  }
+  get eject() {
+    return this.#keystate(128);
+  }
+  get launchApp1() {
+    return this.#keystate(129);
+  }
+  get launchApp2() {
+    return this.#keystate(130);
+  }
+  get launchMail() {
+    return this.#keystate(131);
+  }
+  get mediaPlayPause() {
+    return this.#keystate(132);
+  }
+  get mediaSelect() {
+    return this.#keystate(133);
+  }
+  get mediaStop() {
+    return this.#keystate(134);
+  }
+  get mediaTrackNext() {
+    return this.#keystate(135);
+  }
+  get mediaTrackPrevious() {
+    return this.#keystate(136);
+  }
+  get power() {
+    return this.#keystate(137);
+  }
+  get sleep() {
+    return this.#keystate(138);
+  }
+  get audioVolumeDown() {
+    return this.#keystate(139);
+  }
+  get audioVolumeMute() {
+    return this.#keystate(140);
+  }
+  get audioVolumeUp() {
+    return this.#keystate(141);
+  }
+  get wakeUp() {
+    return this.#keystate(142);
+  }
+  get hyper() {
+    return this.#keystate(143);
+  }
+  get super() {
+    return this.#keystate(144);
+  }
+  get turbo() {
+    return this.#keystate(145);
+  }
+  get abort() {
+    return this.#keystate(146);
+  }
+  get resume() {
+    return this.#keystate(147);
+  }
+  get suspend() {
+    return this.#keystate(148);
+  }
+  get again() {
+    return this.#keystate(149);
+  }
+  get copy() {
+    return this.#keystate(150);
+  }
+  get cut() {
+    return this.#keystate(151);
+  }
+  get find() {
+    return this.#keystate(152);
+  }
+  get open() {
+    return this.#keystate(153);
+  }
+  get paste() {
+    return this.#keystate(154);
+  }
+  get props() {
+    return this.#keystate(155);
+  }
+  get select() {
+    return this.#keystate(156);
+  }
+  get undo() {
+    return this.#keystate(157);
+  }
+  get hiragana() {
+    return this.#keystate(158);
+  }
+  get katakana() {
+    return this.#keystate(159);
+  }
+  get f1() {
+    return this.#keystate(160);
+  }
+  get f2() {
+    return this.#keystate(161);
+  }
+  get f3() {
+    return this.#keystate(162);
+  }
+  get f4() {
+    return this.#keystate(163);
+  }
+  get f5() {
+    return this.#keystate(164);
+  }
+  get f6() {
+    return this.#keystate(165);
+  }
+  get f7() {
+    return this.#keystate(166);
+  }
+  get f8() {
+    return this.#keystate(167);
+  }
+  get f9() {
+    return this.#keystate(168);
+  }
+  get f10() {
+    return this.#keystate(169);
+  }
+  get f11() {
+    return this.#keystate(170);
+  }
+  get f12() {
+    return this.#keystate(171);
+  }
+  get f13() {
+    return this.#keystate(172);
+  }
+  get f14() {
+    return this.#keystate(173);
+  }
+  get f15() {
+    return this.#keystate(174);
+  }
+  get f16() {
+    return this.#keystate(175);
+  }
+  get f17() {
+    return this.#keystate(176);
+  }
+  get f18() {
+    return this.#keystate(177);
+  }
+  get f19() {
+    return this.#keystate(178);
+  }
+  get f20() {
+    return this.#keystate(179);
+  }
+  get f21() {
+    return this.#keystate(180);
+  }
+  get f22() {
+    return this.#keystate(181);
+  }
+  get f23() {
+    return this.#keystate(182);
+  }
+  get f24() {
+    return this.#keystate(183);
+  }
+  get f25() {
+    return this.#keystate(184);
+  }
+  get f26() {
+    return this.#keystate(185);
+  }
+  get f27() {
+    return this.#keystate(186);
+  }
+  get f28() {
+    return this.#keystate(187);
+  }
+  get f29() {
+    return this.#keystate(188);
+  }
+  get f30() {
+    return this.#keystate(189);
+  }
+  get f31() {
+    return this.#keystate(190);
+  }
+  get f32() {
+    return this.#keystate(191);
+  }
+  get f33() {
+    return this.#keystate(192);
+  }
+  get f34() {
+    return this.#keystate(193);
+  }
+  get f35() {
+    return this.#keystate(194);
+  }
+  #keystate(code) {
+    let state;
+    if (this.#keystates.has(code)) {
+      state = this.#keystates.get(code);
+    } else {
+      state = { down: false, held: false, up: false };
+      this.#keystates.set(code, state);
+    }
+    state.held = !!(this.#dataView.getUint8(code) & 1);
+    state.down = state.held && !(this.#dataView.getUint8(code) & 2);
+    state.up = !state.held && !!(this.#dataView.getUint8(code) & 2);
+    return state;
+  }
+}
+var DEFAULT_WASM_URL2 = new URL("../wasm/bloop.wasm", import.meta.url);
+var TIME_CTX_OFFSET2 = 0;
+var INPUT_CTX_OFFSET2 = TIME_CTX_OFFSET2 + 4;
+var EVENTS_OFFSET2 = INPUT_CTX_OFFSET2 + 4;
+
+// src/App.ts
+async function start(opts) {
+  if (!opts.sim) {
+    const { sim } = await mount({
+      hooks: opts.game.hooks,
+      startRecording: opts.startRecording ?? true,
+      wasmUrl: opts.engineWasmUrl
+    });
+    opts.sim = sim;
+  }
+  const app = new App(opts.sim, opts.game);
+  return app;
+}
+
+class App {
+  #sim;
+  game;
+  #rafHandle = null;
+  #unsubscribe = null;
+  #now = performance.now();
+  constructor(sim, game) {
+    this.#sim = sim;
+    this.game = game;
+    this.subscribe();
+  }
+  get sim() {
+    return this.#sim;
+  }
+  set sim(sim) {
+    this.#sim = sim;
+  }
+  subscribe() {
+    const handleKeydown = (event) => {
+      this.sim.emit.keydown(event.code);
+    };
+    window.addEventListener("keydown", handleKeydown);
+    const handleKeyup = (event) => {
+      this.sim.emit.keyup(event.code);
+    };
+    window.addEventListener("keyup", handleKeyup);
+    const handleMousemove = (event) => {
+      this.sim.emit.mousemove(event.clientX, event.clientY);
+    };
+    window.addEventListener("mousemove", handleMousemove);
+    const handleMousedown = (event) => {
+      this.sim.emit.mousedown(mouseButtonCodeToMouseButton2(event.button + 1));
+    };
+    window.addEventListener("mousedown", handleMousedown);
+    const handleMousewheel = (event) => {
+      this.sim.emit.mousewheel(event.deltaX, event.deltaY);
+    };
+    window.addEventListener("wheel", handleMousewheel);
+    const playbarHotkeys = (event) => {
+      const isPauseHotkey = event.key === "Enter" && (event.ctrlKey || event.metaKey);
+      if (isPauseHotkey || event.key === "6") {
+        this.sim.isPaused ? this.sim.unpause() : this.sim.pause();
+      }
+      if (this.sim.isPaused) {
+        switch (event.key) {
+          case ",":
+          case "5":
+            this.sim.stepBack();
+            break;
+          case ".":
+          case "7":
+            this.sim.step();
+            break;
+        }
+      }
+    };
+    window.addEventListener("keydown", playbarHotkeys);
+    const frame = () => {
+      this.sim.step(performance.now() - this.#now);
+      this.#now = performance.now();
+      this.#rafHandle = requestAnimationFrame(frame);
+    };
+    frame();
+    this.#unsubscribe = () => {
+      window.removeEventListener("keydown", handleKeydown);
+      window.removeEventListener("keyup", handleKeyup);
+      window.removeEventListener("mousemove", handleMousemove);
+      window.removeEventListener("mousedown", handleMousedown);
+      window.removeEventListener("wheel", handleMousewheel);
+      window.removeEventListener("keydown", playbarHotkeys);
+      if (this.#rafHandle != null) {
+        cancelAnimationFrame(this.#rafHandle);
+      }
+    };
+  }
+  cleanup() {
+    this.#unsubscribe?.();
+    this.sim.unmount();
+  }
+  async acceptHmr(module, opts) {
+    const game = module.game ?? module;
+    if (!game.hooks) {
+      throw new Error(`HMR: missing game.hooks export on module: ${JSON.stringify(module)}`);
+    }
+    this.sim.pause();
+    const { sim } = await mount({
+      hooks: game.hooks,
+      wasmUrl: new URL("/bloop-wasm/bloop.wasm", window.location.href),
+      ...opts
+    });
+    sim.cloneSession(this.sim);
+    this.sim.unmount();
+    this.sim = sim;
+    this.game = game;
+  }
 }
 export {
-  connect
+  start,
+  App
 };
 
-//# debugId=CED373C6D92686EE64756E2164756E21
+//# debugId=2D6099B6C20ED59864756E2164756E21
 //# sourceMappingURL=mod.js.map