@galfus/transport-browser 0.31.0-alpha → 0.31.1-alpha

package/src/sdk/galfus.ts

@@ -0,0 +1,1805 @@
+/* Automatically generated by Galfus Engine codegen. Do not edit directly. */
+/* Browser/WASM public API contract for the wasm-bindgen GalfusBrowser module. */
+
+import type {
+  AnimationEvent,
+  AnimationTarget,
+  AnimValue,
+  BufferDesc,
+  Camera2DDesc,
+  Camera3DDesc,
+  CameraLookAt3D,
+  CameraLookAt3DStateDesc,
+  EnvironmentRealm3DDesc,
+  GalfusEngine,
+  GamepadInfo,
+  GpuTextureDesc,
+  InstancedModel3DDesc,
+  InvocationDesc,
+  InvocationFilter,
+  Light2DDesc,
+  Light3DDesc,
+  Material2DDesc,
+  Material3DDesc,
+  Model3DDesc,
+  MultiverseSchedule,
+  ParticleEmitter2DDesc,
+  ParticleEmitter3DDesc,
+  PathCommand,
+  PathFollowConfig,
+  PathFollowState,
+  PlatformCapabilities,
+  PlatformEvent,
+  Portal3DDesc,
+  Shadow2DConfigDesc,
+  Shape2DDesc,
+  SpatialAudio,
+  Sprite2DDesc,
+  Svg2DDesc,
+  SvgElementRectResult,
+  SvgTextLayoutResult,
+  TargetDesc,
+  TargetTextureBinding,
+  TextureUpdateDesc,
+  Transform2D,
+  Transform2DDesc,
+  Transform3D,
+  Transform3DDesc,
+  TransitionConfig,
+  TransitionState,
+  ViewportRect,
+  WindowConfig
+} from '@galfus/transport-types';
+export type {
+  AnimValue,
+  AnimationEvent,
+  AnimationTarget,
+  BufferDesc,
+  Camera2DDesc,
+  Camera3DDesc,
+  CameraLookAt3D,
+  CameraLookAt3DStateDesc,
+  EnvironmentRealm3DDesc,
+  GalfusEngine,
+  GamepadInfo,
+  GpuTextureDesc,
+  InstancedModel3DDesc,
+  InvocationDesc,
+  InvocationFilter,
+  Light2DDesc,
+  Light3DDesc,
+  Material2DDesc,
+  Material3DDesc,
+  Model3DDesc,
+  MultiverseSchedule,
+  ParticleEmitter2DDesc,
+  ParticleEmitter3DDesc,
+  PathCommand,
+  PathFollowConfig,
+  PathFollowState,
+  PlatformCapabilities,
+  PlatformEvent,
+  Portal3DDesc,
+  Shadow2DConfigDesc,
+  Shape2DDesc,
+  SpatialAudio,
+  SpatialAudioConfig,
+  SpatialTransform,
+  Sprite2DDesc,
+  Svg2DDesc,
+  SvgElementRectResult,
+  SvgTextLayoutResult,
+  TargetDesc,
+  TargetTextureBinding,
+  TextureUpdateDesc,
+  Transform2D,
+  Transform2DDesc,
+  Transform3D,
+  Transform3DDesc,
+  TransitionConfig,
+  TransitionState,
+  ViewportRect,
+  WindowConfig
+} from '@galfus/transport-types';
+import { WasmAudio } from './audio';
+
+/** Shape of the JavaScript module generated by wasm-bindgen with --target web. */
+export interface GalfusBrowserWasmModule {
+  default(input?: unknown): Promise<unknown>;
+  [exportName: string]: unknown;
+}
+
+/** Error raised when the loaded WASM module lacks an engine method. */
+export class GalfusError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'GalfusError';
+  }
+}
+
+/** Full engine API (platform, multiverse, realms, animation) backed by the WASM module. */
+export class GalfusBrowser implements GalfusEngine {
+  private _addon: any;
+  private _audio: WasmAudio;
+
+  constructor(module: unknown) {
+    this._addon = module;
+    this._audio = new WasmAudio();
+  }
+
+  /** Browser/WASM methods report failures by throwing JavaScript errors. */
+  getLastError(): string {
+    return '';
+  }
+
+  /** Unlocks Web Audio after a user gesture. */
+  enableAudio(): Promise<void> {
+    return this._audio.enable();
+  }
+
+  /** Loads raw audio data into the browser Web Audio backend. */
+  audioLoadSound(soundId: number, data: any, _dataLen: number): void {
+    this._audio.load(soundId, data);
+  }
+
+  /** Plays a loaded sound through Web Audio. */
+  audioPlaySound(
+    soundId: number,
+    volume: number,
+    panning: number,
+    speed: number,
+    looping: boolean
+  ): number {
+    return this._audio.play(soundId, volume, panning, speed, looping);
+  }
+
+  /** Plays a loaded sound with browser spatial attenuation and panning. */
+  audioPlaySoundSpatial(soundId: number, spatial: SpatialAudio): number {
+    return this._audio.playSpatial(soundId, spatial);
+  }
+
+  /** Updates a browser spatial voice. */
+  audioUpdateSoundSpatial(voiceId: number, spatial: SpatialAudio): void {
+    this._audio.updateSpatial(voiceId, spatial);
+  }
+
+  /** Pauses a browser voice. */
+  audioPauseSound(voiceId: number): void {
+    this._audio.pause(voiceId);
+  }
+  /** Resumes a browser voice. */
+  audioResumeSound(voiceId: number): void {
+    this._audio.resume(voiceId);
+  }
+  /** Stops a browser voice. */
+  audioStopSound(voiceId: number): void {
+    this._audio.stop(voiceId);
+  }
+  /** Updates a browser voice volume. */
+  audioSetVolume(voiceId: number, volume: number): void {
+    this._audio.setVolume(voiceId, volume);
+  }
+  /** Updates a browser voice panning. */
+  audioSetPanning(voiceId: number, panning: number): void {
+    this._audio.setPanning(voiceId, panning);
+  }
+  /** Unloads a browser sound and stops its voices. */
+  audioUnloadSound(soundId: number): void {
+    this._audio.unload(soundId);
+  }
+
+  /** Initializes the global platform coordinator. */
+  platformInit(): void {
+    if (typeof this._addon.platformInit !== 'function') {
+      throw new GalfusError('WASM method not implemented: platformInit');
+    }
+    this._addon.platformInit();
+  }
+
+  /** Initializes the global platform coordinator in headless mode. */
+  platformInitHeadless(): void {
+    if (typeof this._addon.platformInitHeadless !== 'function') {
+      throw new GalfusError('WASM method not implemented: platformInitHeadless');
+    }
+    this._addon.platformInitHeadless();
+  }
+
+  /** Shuts down and cleans up the platform coordinator. */
+  platformShutdown(): void {
+    if (typeof this._addon.platformShutdown !== 'function') {
+      throw new GalfusError('WASM method not implemented: platformShutdown');
+    }
+    this._addon.platformShutdown();
+  }
+
+  /** Retrieves platform environment capabilities as structured data. */
+  platformGetCapabilities(): PlatformCapabilities {
+    if (typeof this._addon.platformGetCapabilities !== 'function') {
+      throw new GalfusError('WASM method not implemented: platformGetCapabilities');
+    }
+    return this._addon.platformGetCapabilities();
+  }
+
+  /** Creates a new window or binds a surface from a configuration. */
+  windowCreate(config: WindowConfig | string): number {
+    if (typeof this._addon.windowCreate !== 'function') {
+      throw new GalfusError('WASM method not implemented: windowCreate');
+    }
+    return this._addon.windowCreate(typeof config === 'string' ? JSON.parse(config) : config);
+  }
+
+  /** Closes and destroys a window by its logical ID. */
+  windowClose(windowId: number): void {
+    if (typeof this._addon.windowClose !== 'function') {
+      throw new GalfusError('WASM method not implemented: windowClose');
+    }
+    this._addon.windowClose(windowId);
+  }
+
+  /** Updates the title bar of a window. */
+  windowSetTitle(windowId: number, title: string): void {
+    if (typeof this._addon.windowSetTitle !== 'function') {
+      throw new GalfusError('WASM method not implemented: windowSetTitle');
+    }
+    this._addon.windowSetTitle(windowId, title);
+  }
+
+  /** Requests keyboard focus for a window input surface. */
+  windowRequestInputFocus(windowId: number): void {
+    if (typeof this._addon.windowRequestInputFocus !== 'function') {
+      throw new GalfusError('WASM method not implemented: windowRequestInputFocus');
+    }
+    this._addon.windowRequestInputFocus(windowId);
+  }
+
+  /** Configures whether a focused browser window captures Tab key navigation. */
+  windowSetTabCapture(windowId: number, enabled: number): void {
+    if (typeof this._addon.windowSetTabCapture !== 'function') {
+      throw new GalfusError('WASM method not implemented: windowSetTabCapture');
+    }
+    this._addon.windowSetTabCapture(windowId, enabled);
+  }
+
+  /** Enables or disables input method composition for a window. */
+  windowSetImeAllowed(windowId: number, allowed: number): void {
+    if (typeof this._addon.windowSetImeAllowed !== 'function') {
+      throw new GalfusError('WASM method not implemented: windowSetImeAllowed');
+    }
+    this._addon.windowSetImeAllowed(windowId, allowed);
+  }
+
+  /** Sets the input method candidate area in physical window pixels. */
+  windowSetImeCursorArea(
+    windowId: number,
+    x: number,
+    y: number,
+    width: number,
+    height: number
+  ): void {
+    if (typeof this._addon.windowSetImeCursorArea !== 'function') {
+      throw new GalfusError('WASM method not implemented: windowSetImeCursorArea');
+    }
+    this._addon.windowSetImeCursorArea(windowId, x, y, width, height);
+  }
+
+  /** Updates the cursor grab mode (0: None, 1: Confined, 2: Locked). */
+  windowSetCursorGrab(windowId: number, mode: number): void {
+    if (typeof this._addon.windowSetCursorGrab !== 'function') {
+      throw new GalfusError('WASM method not implemented: windowSetCursorGrab');
+    }
+    this._addon.windowSetCursorGrab(windowId, mode);
+  }
+
+  /** Updates the visual appearance icon of the cursor. */
+  windowSetCursorIcon(windowId: number, icon: number): void {
+    if (typeof this._addon.windowSetCursorIcon !== 'function') {
+      throw new GalfusError('WASM method not implemented: windowSetCursorIcon');
+    }
+    this._addon.windowSetCursorIcon(windowId, icon);
+  }
+
+  /** Sets the visual application icon of a window using raw encoded image bytes (ICO, PNG, WebP, JPEG). */
+  windowSetIcon(windowId: number, data: any, dataLen: number): void {
+    if (typeof this._addon.windowSetIcon !== 'function') {
+      throw new GalfusError('WASM method not implemented: windowSetIcon');
+    }
+    this._addon.windowSetIcon(windowId, data, dataLen);
+  }
+
+  /** Pumps platform input events into a fixed-layout batch; its pointers expire on release or shutdown. */
+  platformPumpEvents(): PlatformEvent[] {
+    if (typeof this._addon.platformPumpEvents !== 'function') {
+      throw new GalfusError('WASM method not implemented: platformPumpEvents');
+    }
+    return this._addon.platformPumpEvents();
+  }
+
+  /** Releases an event batch and invalidates its native pointer ranges. */
+  platformReleaseEventBatch(batchId: number): void {
+    if (typeof this._addon.platformReleaseEventBatch !== 'function') {
+      throw new GalfusError('WASM method not implemented: platformReleaseEventBatch');
+    }
+    this._addon.platformReleaseEventBatch(batchId);
+  }
+
+  /** Retrieves all currently connected gamepads and their capabilities. */
+  gamepadGetConnected(): GamepadInfo[] {
+    if (typeof this._addon.gamepadGetConnected !== 'function') {
+      throw new GalfusError('WASM method not implemented: gamepadGetConnected');
+    }
+    return this._addon.gamepadGetConnected();
+  }
+
+  /** Triggers rumble vibration on a connected gamepad. */
+  gamepadSetRumble(
+    gamepadId: number,
+    strongMagnitude: number,
+    weakMagnitude: number,
+    durationMs: number
+  ): void {
+    if (typeof this._addon.gamepadSetRumble !== 'function') {
+      throw new GalfusError('WASM method not implemented: gamepadSetRumble');
+    }
+    this._addon.gamepadSetRumble(gamepadId, strongMagnitude, weakMagnitude, durationMs);
+  }
+
+  /** Reads the physical inner size (width, height) of a Platform window into two uint32 out pointers. */
+  platformGetWindowSizeRaw(windowId: number, outWidth: any, outHeight: any): void {
+    if (typeof this._addon.platformGetWindowSizeRaw !== 'function') {
+      throw new GalfusError('WASM method not implemented: platformGetWindowSizeRaw');
+    }
+    this._addon.platformGetWindowSizeRaw(windowId, outWidth, outHeight);
+  }
+
+  /** Attaches a platform window to the Multiverse context for surface rendering. */
+  async multiverseAttachWindow(windowId: number): Promise<void> {
+    if (typeof this._addon.multiverseAttachWindow !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseAttachWindow');
+    }
+    await this._addon.multiverseAttachWindow(windowId);
+  }
+
+  /** Registers a new Target in the Multiverse using a TargetDesc descriptor. */
+  multiverseCreateTarget(targetId: number, desc: TargetDesc | string): void {
+    if (typeof this._addon.multiverseCreateTarget !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseCreateTarget');
+    }
+    this._addon.multiverseCreateTarget(
+      targetId,
+      typeof desc === 'string' ? JSON.parse(desc) : desc
+    );
+  }
+
+  /** Destroys a Target in the Multiverse. */
+  multiverseDestroyTarget(targetId: number): void {
+    if (typeof this._addon.multiverseDestroyTarget !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseDestroyTarget');
+    }
+    this._addon.multiverseDestroyTarget(targetId);
+  }
+
+  /** Registers a solid color test Realm in the Multiverse. */
+  multiverseRegisterColorRealm(realmId: number, r: number, g: number, b: number, a: number): void {
+    if (typeof this._addon.multiverseRegisterColorRealm !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseRegisterColorRealm');
+    }
+    this._addon.multiverseRegisterColorRealm(realmId, r, g, b, a);
+  }
+
+  /** Unregisters a Realm from the Multiverse. */
+  multiverseUnregisterRealm(realmId: number): void {
+    if (typeof this._addon.multiverseUnregisterRealm !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseUnregisterRealm');
+    }
+    this._addon.multiverseUnregisterRealm(realmId);
+  }
+
+  /** Registers a custom WGSL post-processing shader with an ID. */
+  multiverseRegisterShader(shaderId: number, source: string): void {
+    if (typeof this._addon.multiverseRegisterShader !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseRegisterShader');
+    }
+    this._addon.multiverseRegisterShader(shaderId, source);
+  }
+
+  /** Creates an Invocation in the Multiverse linking a Realm to a Target. */
+  multiverseCreateInvocation(invocationId: number, desc: InvocationDesc | string): void {
+    if (typeof this._addon.multiverseCreateInvocation !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseCreateInvocation');
+    }
+    this._addon.multiverseCreateInvocation(
+      invocationId,
+      typeof desc === 'string' ? JSON.parse(desc) : desc
+    );
+  }
+
+  /** Destroys an Invocation in the Multiverse. */
+  multiverseDestroyInvocation(invocationId: number): void {
+    if (typeof this._addon.multiverseDestroyInvocation !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseDestroyInvocation');
+    }
+    this._addon.multiverseDestroyInvocation(invocationId);
+  }
+
+  /** Enables or disables an Invocation in the Multiverse. */
+  multiverseSetInvocationEnabled(invocationId: number, enabled: boolean): void {
+    if (typeof this._addon.multiverseSetInvocationEnabled !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseSetInvocationEnabled');
+    }
+    this._addon.multiverseSetInvocationEnabled(invocationId, enabled);
+  }
+
+  /** Updates the presentation order of an Invocation. */
+  multiverseSetInvocationZIndex(invocationId: number, zIndex: number): void {
+    if (typeof this._addon.multiverseSetInvocationZIndex !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseSetInvocationZIndex');
+    }
+    this._addon.multiverseSetInvocationZIndex(invocationId, zIndex);
+  }
+
+  /** Updates the viewport rectangle of an existing Invocation. */
+  multiverseSetInvocationViewport(invocationId: number, viewport: ViewportRect | string): void {
+    if (typeof this._addon.multiverseSetInvocationViewport !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseSetInvocationViewport');
+    }
+    this._addon.multiverseSetInvocationViewport(
+      invocationId,
+      typeof viewport === 'string' ? JSON.parse(viewport) : viewport
+    );
+  }
+
+  /** Updates the post-process filter chain for an Invocation. */
+  multiverseSetInvocationFilters(invocationId: number, filters: InvocationFilter[] | string): void {
+    if (typeof this._addon.multiverseSetInvocationFilters !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseSetInvocationFilters');
+    }
+    this._addon.multiverseSetInvocationFilters(
+      invocationId,
+      typeof filters === 'string' ? JSON.parse(filters) : filters
+    );
+  }
+
+  /** Updates the clear color of an Invocation. */
+  multiverseSetInvocationClearColor(
+    invocationId: number,
+    r: number,
+    g: number,
+    b: number,
+    a: number,
+    hasClear: boolean
+  ): void {
+    if (typeof this._addon.multiverseSetInvocationClearColor !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseSetInvocationClearColor');
+    }
+    this._addon.multiverseSetInvocationClearColor(invocationId, r, g, b, a, hasClear);
+  }
+
+  /** Updates the camera slot bound to an existing Invocation. */
+  multiverseSetInvocationCameraSlot(
+    invocationId: number,
+    cameraSlot: number,
+    hasSlot: boolean
+  ): void {
+    if (typeof this._addon.multiverseSetInvocationCameraSlot !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseSetInvocationCameraSlot');
+    }
+    this._addon.multiverseSetInvocationCameraSlot(invocationId, cameraSlot, hasSlot);
+  }
+
+  /** Binds a Target output texture to a Realm input slot. */
+  multiverseBindTargetTexture(binding: TargetTextureBinding | string): void {
+    if (typeof this._addon.multiverseBindTargetTexture !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseBindTargetTexture');
+    }
+    this._addon.multiverseBindTargetTexture(
+      typeof binding === 'string' ? JSON.parse(binding) : binding
+    );
+  }
+
+  /** Unbinds a Target texture from a Realm input slot. */
+  multiverseUnbindTargetTexture(realmId: number, slot: string): void {
+    if (typeof this._addon.multiverseUnbindTargetTexture !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseUnbindTargetTexture');
+    }
+    this._addon.multiverseUnbindTargetTexture(realmId, slot);
+  }
+
+  /** Updates the size of a window Target (e.g. on window resize). */
+  multiverseUpdateWindowSize(windowId: number, width: number, height: number): void {
+    if (typeof this._addon.multiverseUpdateWindowSize !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseUpdateWindowSize');
+    }
+    this._addon.multiverseUpdateWindowSize(windowId, width, height);
+  }
+
+  /** Resolves and returns the Multiverse execution schedule as structured data. */
+  multiverseResolve(): MultiverseSchedule {
+    if (typeof this._addon.multiverseResolve !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseResolve');
+    }
+    return this._addon.multiverseResolve();
+  }
+
+  /** Dispatches the Multiverse schedule for a frame. */
+  multiverseDispatch(frameId: number, deltaTime: number): void {
+    if (typeof this._addon.multiverseDispatch !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseDispatch');
+    }
+    this._addon.multiverseDispatch(frameId, deltaTime);
+  }
+
+  /** Clears all entities, materials, and scene resources in a Realm without unregistering it. */
+  realmClear(realmId: number): void {
+    if (typeof this._addon.realmClear !== 'function') {
+      throw new GalfusError('WASM method not implemented: realmClear');
+    }
+    this._addon.realmClear(realmId);
+  }
+
+  /** Destroys a Realm, frees all internal GPU resources, and unregisters it from the Multiverse. */
+  realmDestroy(realmId: number): void {
+    if (typeof this._addon.realmDestroy !== 'function') {
+      throw new GalfusError('WASM method not implemented: realmDestroy');
+    }
+    this._addon.realmDestroy(realmId);
+  }
+
+  /** Reads the resolved size (width, height) of a Multiverse Target into two uint32 out pointers. */
+  multiverseGetTargetSizeRaw(targetId: number, outWidth: any, outHeight: any): void {
+    if (typeof this._addon.multiverseGetTargetSizeRaw !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseGetTargetSizeRaw');
+    }
+    this._addon.multiverseGetTargetSizeRaw(targetId, outWidth, outHeight);
+  }
+
+  /** Sets the global Anti-Aliasing mode for the Multiverse. */
+  multiverseSetAntiAliasing(mode: string): void {
+    if (typeof this._addon.multiverseSetAntiAliasing !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseSetAntiAliasing');
+    }
+    this._addon.multiverseSetAntiAliasing(mode);
+  }
+
+  /** Gets the current global Anti-Aliasing mode of the Multiverse. */
+  multiverseGetAntiAliasing(): string {
+    if (typeof this._addon.multiverseGetAntiAliasing !== 'function') {
+      throw new GalfusError('WASM method not implemented: multiverseGetAntiAliasing');
+    }
+    return this._addon.multiverseGetAntiAliasing();
+  }
+
+  /** Allocates and initializes a shared GPU texture under a host logical ID with raw pixel bytes. */
+  resourceCreateTexture(
+    textureId: number,
+    desc: GpuTextureDesc | string,
+    data: any,
+    dataLen: number
+  ): void {
+    if (typeof this._addon.resourceCreateTexture !== 'function') {
+      throw new GalfusError('WASM method not implemented: resourceCreateTexture');
+    }
+    this._addon.resourceCreateTexture(
+      textureId,
+      typeof desc === 'string' ? JSON.parse(desc) : desc,
+      data,
+      dataLen
+    );
+  }
+
+  /** Updates a sub-rectangle of an existing logical texture with raw pixel bytes. */
+  resourceUpdateTexture(
+    textureId: number,
+    rect: TextureUpdateDesc | string,
+    data: any,
+    dataLen: number
+  ): void {
+    if (typeof this._addon.resourceUpdateTexture !== 'function') {
+      throw new GalfusError('WASM method not implemented: resourceUpdateTexture');
+    }
+    this._addon.resourceUpdateTexture(
+      textureId,
+      typeof rect === 'string' ? JSON.parse(rect) : rect,
+      data,
+      dataLen
+    );
+  }
+
+  /** Disposes a shared logical texture from GPU memory. */
+  resourceDisposeTexture(textureId: number): void {
+    if (typeof this._addon.resourceDisposeTexture !== 'function') {
+      throw new GalfusError('WASM method not implemented: resourceDisposeTexture');
+    }
+    this._addon.resourceDisposeTexture(textureId);
+  }
+
+  /** Allocates and initializes a shared GPU buffer under a host logical ID with raw byte contents. */
+  resourceCreateBuffer(
+    bufferId: number,
+    desc: BufferDesc | string,
+    data: any,
+    dataLen: number
+  ): void {
+    if (typeof this._addon.resourceCreateBuffer !== 'function') {
+      throw new GalfusError('WASM method not implemented: resourceCreateBuffer');
+    }
+    this._addon.resourceCreateBuffer(
+      bufferId,
+      typeof desc === 'string' ? JSON.parse(desc) : desc,
+      data,
+      dataLen
+    );
+  }
+
+  /** Updates byte contents of an existing logical buffer at a given offset with raw byte contents. */
+  resourceUpdateBuffer(bufferId: number, offset: number, data: any, dataLen: number): void {
+    if (typeof this._addon.resourceUpdateBuffer !== 'function') {
+      throw new GalfusError('WASM method not implemented: resourceUpdateBuffer');
+    }
+    this._addon.resourceUpdateBuffer(bufferId, offset, data, dataLen);
+  }
+
+  /** Disposes a shared logical buffer from GPU memory. */
+  resourceDisposeBuffer(bufferId: number): void {
+    if (typeof this._addon.resourceDisposeBuffer !== 'function') {
+      throw new GalfusError('WASM method not implemented: resourceDisposeBuffer');
+    }
+    this._addon.resourceDisposeBuffer(bufferId);
+  }
+
+  /** Creates and registers a new 3D Realm in the Multiverse. */
+  realm3dCreate(realmId: number): void {
+    if (typeof this._addon.realm3dCreate !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dCreate');
+    }
+    this._addon.realm3dCreate(realmId);
+  }
+
+  /** Destroys and unregisters a 3D Realm from the Multiverse. */
+  realm3dDestroy(realmId: number): void {
+    if (typeof this._addon.realm3dDestroy !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dDestroy');
+    }
+    this._addon.realm3dDestroy(realmId);
+  }
+
+  /** Registers or updates a 3D Camera with its spatial Transform in the 3D Realm. */
+  realm3dCreateCamera(
+    realmId: number,
+    cameraId: number,
+    camera: Camera3DDesc | string,
+    transform: Transform3DDesc | string
+  ): void {
+    if (typeof this._addon.realm3dCreateCamera !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dCreateCamera');
+    }
+    this._addon.realm3dCreateCamera(
+      realmId,
+      cameraId,
+      typeof camera === 'string' ? JSON.parse(camera) : camera,
+      typeof transform === 'string' ? JSON.parse(transform) : transform
+    );
+  }
+
+  /** Updates the transform of an existing Camera in the 3D Realm. */
+  realm3dSetCameraTransform(realmId: number, cameraId: number, transform: Transform3D): void {
+    if (typeof this._addon.realm3dSetCameraTransform !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dSetCameraTransform');
+    }
+    this._addon.realm3dSetCameraTransform(realmId, cameraId, transform);
+  }
+
+  /** Sets the optional world-space look-at point and up direction of an existing 3D Camera. */
+  realm3dSetCameraLookAt(realmId: number, cameraId: number, lookAt: CameraLookAt3D): void {
+    if (typeof this._addon.realm3dSetCameraLookAt !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dSetCameraLookAt');
+    }
+    this._addon.realm3dSetCameraLookAt(realmId, cameraId, lookAt);
+  }
+
+  /** Gets the current optional look-at configuration of an existing 3D Camera. */
+  realm3dGetCameraLookAt(realmId: number, cameraId: number): CameraLookAt3DStateDesc {
+    if (typeof this._addon.realm3dGetCameraLookAt !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dGetCameraLookAt');
+    }
+    return this._addon.realm3dGetCameraLookAt(realmId, cameraId);
+  }
+
+  /** Clears the optional look-at configuration of an existing 3D Camera. */
+  realm3dClearCameraLookAt(realmId: number, cameraId: number): void {
+    if (typeof this._addon.realm3dClearCameraLookAt !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dClearCameraLookAt');
+    }
+    this._addon.realm3dClearCameraLookAt(realmId, cameraId);
+  }
+
+  /** Registers or updates 3D geometry from canonical binary vertex and index buffers. */
+  realm3dCreateGeometry(
+    realmId: number,
+    geometryId: number,
+    topology: number,
+    vertexData: Uint8Array,
+    vertexDataLen: number,
+    indices: Uint32Array,
+    indexCount: number
+  ): void {
+    if (typeof this._addon.realm3dCreateGeometry !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dCreateGeometry');
+    }
+    this._addon.realm3dCreateGeometry(
+      realmId,
+      geometryId,
+      topology,
+      vertexData,
+      vertexDataLen,
+      indices,
+      indexCount
+    );
+  }
+
+  /** Uploads target-major packed MorphVertex3D records (48 bytes each) for an existing geometry. */
+  realm3dSetGeometryMorphTargets(
+    realmId: number,
+    geometryId: number,
+    targetData: Uint8Array,
+    targetDataLen: number,
+    targetCount: number
+  ): void {
+    if (typeof this._addon.realm3dSetGeometryMorphTargets !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dSetGeometryMorphTargets');
+    }
+    this._addon.realm3dSetGeometryMorphTargets(
+      realmId,
+      geometryId,
+      targetData,
+      targetDataLen,
+      targetCount
+    );
+  }
+
+  /** Creates a cube primitive centered at the origin. */
+  realm3dCreateCube(realmId: number, geometryId: number, size: number): void {
+    if (typeof this._addon.realm3dCreateCube !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dCreateCube');
+    }
+    this._addon.realm3dCreateCube(realmId, geometryId, size);
+  }
+
+  /** Creates a horizontal plane primitive centered at the origin. */
+  realm3dCreatePlane(realmId: number, geometryId: number, width: number, depth: number): void {
+    if (typeof this._addon.realm3dCreatePlane !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dCreatePlane');
+    }
+    this._addon.realm3dCreatePlane(realmId, geometryId, width, depth);
+  }
+
+  /** Creates a vertical quad primitive centered at the origin and facing +Z. */
+  realm3dCreateQuad(realmId: number, geometryId: number, width: number, height: number): void {
+    if (typeof this._addon.realm3dCreateQuad !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dCreateQuad');
+    }
+    this._addon.realm3dCreateQuad(realmId, geometryId, width, height);
+  }
+
+  /** Creates a UV sphere primitive centered at the origin. */
+  realm3dCreateSphere(
+    realmId: number,
+    geometryId: number,
+    radius: number,
+    rings: number,
+    sectors: number
+  ): void {
+    if (typeof this._addon.realm3dCreateSphere !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dCreateSphere');
+    }
+    this._addon.realm3dCreateSphere(realmId, geometryId, radius, rings, sectors);
+  }
+
+  /** Creates a cylinder primitive centered at the origin along the Y axis. */
+  realm3dCreateCylinder(
+    realmId: number,
+    geometryId: number,
+    radius: number,
+    height: number,
+    sectors: number
+  ): void {
+    if (typeof this._addon.realm3dCreateCylinder !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dCreateCylinder');
+    }
+    this._addon.realm3dCreateCylinder(realmId, geometryId, radius, height, sectors);
+  }
+
+  /** Creates a capsule primitive centered at the origin along the Y axis. */
+  realm3dCreateCapsule(
+    realmId: number,
+    geometryId: number,
+    radius: number,
+    cylinderHeight: number,
+    rings: number,
+    sectors: number
+  ): void {
+    if (typeof this._addon.realm3dCreateCapsule !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dCreateCapsule');
+    }
+    this._addon.realm3dCreateCapsule(realmId, geometryId, radius, cylinderHeight, rings, sectors);
+  }
+
+  /** Creates a pyramid primitive centered at the origin with its apex on +Y. */
+  realm3dCreatePyramid(
+    realmId: number,
+    geometryId: number,
+    width: number,
+    depth: number,
+    height: number
+  ): void {
+    if (typeof this._addon.realm3dCreatePyramid !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dCreatePyramid');
+    }
+    this._addon.realm3dCreatePyramid(realmId, geometryId, width, depth, height);
+  }
+
+  /** Creates a torus primitive centered at the origin in the XZ plane. */
+  realm3dCreateTorus(
+    realmId: number,
+    geometryId: number,
+    majorRadius: number,
+    minorRadius: number,
+    majorSegments: number,
+    minorSegments: number
+  ): void {
+    if (typeof this._addon.realm3dCreateTorus !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dCreateTorus');
+    }
+    this._addon.realm3dCreateTorus(
+      realmId,
+      geometryId,
+      majorRadius,
+      minorRadius,
+      majorSegments,
+      minorSegments
+    );
+  }
+
+  /** Registers or updates a 3D Material in the 3D Realm. */
+  realm3dCreateMaterial(
+    realmId: number,
+    materialId: number,
+    material: Material3DDesc | string
+  ): void {
+    if (typeof this._addon.realm3dCreateMaterial !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dCreateMaterial');
+    }
+    this._addon.realm3dCreateMaterial(
+      realmId,
+      materialId,
+      typeof material === 'string' ? JSON.parse(material) : material
+    );
+  }
+
+  /** Registers or updates a 3D Model instance in the 3D Realm. */
+  realm3dCreateModel(
+    realmId: number,
+    modelId: number,
+    model: Model3DDesc | string,
+    transform: Transform3DDesc | string
+  ): void {
+    if (typeof this._addon.realm3dCreateModel !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dCreateModel');
+    }
+    this._addon.realm3dCreateModel(
+      realmId,
+      modelId,
+      typeof model === 'string' ? JSON.parse(model) : model,
+      typeof transform === 'string' ? JSON.parse(transform) : transform
+    );
+  }
+
+  /** Updates the transform of an existing Model instance in the 3D Realm. */
+  realm3dSetModelTransform(realmId: number, modelId: number, transform: Transform3D): void {
+    if (typeof this._addon.realm3dSetModelTransform !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dSetModelTransform');
+    }
+    this._addon.realm3dSetModelTransform(realmId, modelId, transform);
+  }
+
+  /** Registers or updates an Instanced 3D Model in the 3D Realm. */
+  realm3dCreateInstancedModel(
+    realmId: number,
+    instancedModelId: number,
+    model: InstancedModel3DDesc | string
+  ): void {
+    if (typeof this._addon.realm3dCreateInstancedModel !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dCreateInstancedModel');
+    }
+    this._addon.realm3dCreateInstancedModel(
+      realmId,
+      instancedModelId,
+      typeof model === 'string' ? JSON.parse(model) : model
+    );
+  }
+
+  /** Uploads packed instance data: 32 f32 values per instance. */
+  realm3dSetInstancedModelData(
+    realmId: number,
+    instancedModelId: number,
+    data: Float32Array,
+    floatCount: number
+  ): void {
+    if (typeof this._addon.realm3dSetInstancedModelData !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dSetInstancedModelData');
+    }
+    this._addon.realm3dSetInstancedModelData(realmId, instancedModelId, data, floatCount);
+  }
+
+  /** Uploads the current f32 blend weights for an existing model. */
+  realm3dSetModelMorphWeights(
+    realmId: number,
+    modelId: number,
+    weights: Float32Array,
+    weightCount: number
+  ): void {
+    if (typeof this._addon.realm3dSetModelMorphWeights !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dSetModelMorphWeights');
+    }
+    this._addon.realm3dSetModelMorphWeights(realmId, modelId, weights, weightCount);
+  }
+
+  /** Uploads the f32 blend weights shared by every instance in an instanced model batch. */
+  realm3dSetInstancedModelMorphWeights(
+    realmId: number,
+    instancedModelId: number,
+    weights: Float32Array,
+    weightCount: number
+  ): void {
+    if (typeof this._addon.realm3dSetInstancedModelMorphWeights !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dSetInstancedModelMorphWeights');
+    }
+    this._addon.realm3dSetInstancedModelMorphWeights(
+      realmId,
+      instancedModelId,
+      weights,
+      weightCount
+    );
+  }
+
+  /** Registers or updates a 3D Light in the 3D Realm. */
+  realm3dCreateLight(
+    realmId: number,
+    lightId: number,
+    light: Light3DDesc | string,
+    transform: Transform3DDesc | string
+  ): void {
+    if (typeof this._addon.realm3dCreateLight !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dCreateLight');
+    }
+    this._addon.realm3dCreateLight(
+      realmId,
+      lightId,
+      typeof light === 'string' ? JSON.parse(light) : light,
+      typeof transform === 'string' ? JSON.parse(transform) : transform
+    );
+  }
+
+  /** Updates the transform of an existing Light in the 3D Realm. */
+  realm3dSetLightTransform(realmId: number, lightId: number, transform: Transform3D): void {
+    if (typeof this._addon.realm3dSetLightTransform !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dSetLightTransform');
+    }
+    this._addon.realm3dSetLightTransform(realmId, lightId, transform);
+  }
+
+  /** Sets global atmospheric environment properties for the 3D Realm. */
+  realm3dSetEnvironment(realmId: number, environment: EnvironmentRealm3DDesc | string): void {
+    if (typeof this._addon.realm3dSetEnvironment !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dSetEnvironment');
+    }
+    this._addon.realm3dSetEnvironment(
+      realmId,
+      typeof environment === 'string' ? JSON.parse(environment) : environment
+    );
+  }
+
+  /** Uploads packed 4x4 bone matrices for a model in the 3D Realm. */
+  realm3dUpdateBones(
+    realmId: number,
+    modelId: number,
+    data: Float32Array,
+    floatCount: number
+  ): void {
+    if (typeof this._addon.realm3dUpdateBones !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dUpdateBones');
+    }
+    this._addon.realm3dUpdateBones(realmId, modelId, data, floatCount);
+  }
+
+  /** Queues a 3D debug line segment between start and end with an RGBA color. */
+  realm3dDrawLine(
+    realmId: number,
+    x0: number,
+    y0: number,
+    z0: number,
+    x1: number,
+    y1: number,
+    z1: number,
+    r: number,
+    g: number,
+    b: number,
+    a: number
+  ): void {
+    if (typeof this._addon.realm3dDrawLine !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dDrawLine');
+    }
+    this._addon.realm3dDrawLine(realmId, x0, y0, z0, x1, y1, z1, r, g, b, a);
+  }
+
+  /** Queues a 3D debug Axis-Aligned Bounding Box (AABB) wireframe. */
+  realm3dDrawAabb(
+    realmId: number,
+    minX: number,
+    minY: number,
+    minZ: number,
+    maxX: number,
+    maxY: number,
+    maxZ: number,
+    r: number,
+    g: number,
+    b: number,
+    a: number
+  ): void {
+    if (typeof this._addon.realm3dDrawAabb !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dDrawAabb');
+    }
+    this._addon.realm3dDrawAabb(realmId, minX, minY, minZ, maxX, maxY, maxZ, r, g, b, a);
+  }
+
+  /** Clears any queued debug gizmos in the 3D Realm. */
+  realm3dClearGizmos(realmId: number): void {
+    if (typeof this._addon.realm3dClearGizmos !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dClearGizmos');
+    }
+    this._addon.realm3dClearGizmos(realmId);
+  }
+
+  /** Creates or updates a 3D particle emitter entity with an initial transform. */
+  realm3dCreateParticleEmitter(
+    realmId: number,
+    emitterId: number,
+    emitter: ParticleEmitter3DDesc | string,
+    transform: Transform3DDesc | string
+  ): void {
+    if (typeof this._addon.realm3dCreateParticleEmitter !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dCreateParticleEmitter');
+    }
+    this._addon.realm3dCreateParticleEmitter(
+      realmId,
+      emitterId,
+      typeof emitter === 'string' ? JSON.parse(emitter) : emitter,
+      typeof transform === 'string' ? JSON.parse(transform) : transform
+    );
+  }
+
+  /** Updates the spatial transform of an existing 3D particle emitter. */
+  realm3dSetParticleEmitterTransform(
+    realmId: number,
+    emitterId: number,
+    transform: Transform3D
+  ): void {
+    if (typeof this._addon.realm3dSetParticleEmitterTransform !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dSetParticleEmitterTransform');
+    }
+    this._addon.realm3dSetParticleEmitterTransform(realmId, emitterId, transform);
+  }
+
+  /** Triggers an immediate burst of particles from an existing 3D emitter. */
+  realm3dParticleEmitterBurst(realmId: number, emitterId: number, count: number): void {
+    if (typeof this._addon.realm3dParticleEmitterBurst !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dParticleEmitterBurst');
+    }
+    this._addon.realm3dParticleEmitterBurst(realmId, emitterId, count);
+  }
+
+  /** Destroys an existing 3D particle emitter entity. */
+  realm3dDestroyParticleEmitter(realmId: number, emitterId: number): void {
+    if (typeof this._addon.realm3dDestroyParticleEmitter !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dDestroyParticleEmitter');
+    }
+    this._addon.realm3dDestroyParticleEmitter(realmId, emitterId);
+  }
+
+  /** Registers or updates a 3D optical portal or planar mirror. */
+  realm3dCreatePortal(realmId: number, portalId: number, portal: Portal3DDesc | string): void {
+    if (typeof this._addon.realm3dCreatePortal !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dCreatePortal');
+    }
+    this._addon.realm3dCreatePortal(
+      realmId,
+      portalId,
+      typeof portal === 'string' ? JSON.parse(portal) : portal
+    );
+  }
+
+  /** Sets whether an existing 3D portal or mirror is active. */
+  realm3dSetPortalActive(realmId: number, portalId: number, active: boolean): void {
+    if (typeof this._addon.realm3dSetPortalActive !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dSetPortalActive');
+    }
+    this._addon.realm3dSetPortalActive(realmId, portalId, active);
+  }
+
+  /** Destroys an existing 3D portal or mirror. */
+  realm3dDestroyPortal(realmId: number, portalId: number): void {
+    if (typeof this._addon.realm3dDestroyPortal !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dDestroyPortal');
+    }
+    this._addon.realm3dDestroyPortal(realmId, portalId);
+  }
+
+  /** Destroys an existing 3D camera entity. */
+  realm3dDestroyCamera(realmId: number, cameraId: number): void {
+    if (typeof this._addon.realm3dDestroyCamera !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dDestroyCamera');
+    }
+    this._addon.realm3dDestroyCamera(realmId, cameraId);
+  }
+
+  /** Destroys an existing 3D material entity. */
+  realm3dDestroyMaterial(realmId: number, materialId: number): void {
+    if (typeof this._addon.realm3dDestroyMaterial !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dDestroyMaterial');
+    }
+    this._addon.realm3dDestroyMaterial(realmId, materialId);
+  }
+
+  /** Destroys an existing 3D geometry entity. */
+  realm3dDestroyGeometry(realmId: number, geometryId: number): void {
+    if (typeof this._addon.realm3dDestroyGeometry !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dDestroyGeometry');
+    }
+    this._addon.realm3dDestroyGeometry(realmId, geometryId);
+  }
+
+  /** Destroys an existing 3D model entity. */
+  realm3dDestroyModel(realmId: number, modelId: number): void {
+    if (typeof this._addon.realm3dDestroyModel !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dDestroyModel');
+    }
+    this._addon.realm3dDestroyModel(realmId, modelId);
+  }
+
+  /** Destroys an existing 3D instanced model entity. */
+  realm3dDestroyInstancedModel(realmId: number, instancedModelId: number): void {
+    if (typeof this._addon.realm3dDestroyInstancedModel !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dDestroyInstancedModel');
+    }
+    this._addon.realm3dDestroyInstancedModel(realmId, instancedModelId);
+  }
+
+  /** Destroys an existing 3D light entity. */
+  realm3dDestroyLight(realmId: number, lightId: number): void {
+    if (typeof this._addon.realm3dDestroyLight !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dDestroyLight');
+    }
+    this._addon.realm3dDestroyLight(realmId, lightId);
+  }
+
+  /** Reads the transform of an existing Model instance. */
+  realm3dGetModelTransform(realmId: number, modelId: number): Transform3D {
+    if (typeof this._addon.realm3dGetModelTransform !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dGetModelTransform');
+    }
+    return this._addon.realm3dGetModelTransform(realmId, modelId);
+  }
+
+  /** Reads the transform of an existing Camera instance. */
+  realm3dGetCameraTransform(realmId: number, cameraId: number): Transform3D {
+    if (typeof this._addon.realm3dGetCameraTransform !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dGetCameraTransform');
+    }
+    return this._addon.realm3dGetCameraTransform(realmId, cameraId);
+  }
+
+  /** Reads the world-space bounding box (min, max) of a 3D model into two 3-float out buffers. */
+  realm3dGetModelAabbRaw(realmId: number, modelId: number, outMin: any, outMax: any): void {
+    if (typeof this._addon.realm3dGetModelAabbRaw !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm3dGetModelAabbRaw');
+    }
+    this._addon.realm3dGetModelAabbRaw(realmId, modelId, outMin, outMax);
+  }
+
+  /** Creates and registers a new 2D Realm in the Multiverse. */
+  realm2dCreate(realmId: number): void {
+    if (typeof this._addon.realm2dCreate !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dCreate');
+    }
+    this._addon.realm2dCreate(realmId);
+  }
+
+  /** Destroys and unregisters a 2D Realm from the Multiverse. */
+  realm2dDestroy(realmId: number): void {
+    if (typeof this._addon.realm2dDestroy !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dDestroy');
+    }
+    this._addon.realm2dDestroy(realmId);
+  }
+
+  /** Creates or updates a 2D camera with an initial transform. */
+  realm2dCreateCamera(
+    realmId: number,
+    cameraId: number,
+    camera: Camera2DDesc | string,
+    transform: Transform2DDesc | string
+  ): void {
+    if (typeof this._addon.realm2dCreateCamera !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dCreateCamera');
+    }
+    this._addon.realm2dCreateCamera(
+      realmId,
+      cameraId,
+      typeof camera === 'string' ? JSON.parse(camera) : camera,
+      typeof transform === 'string' ? JSON.parse(transform) : transform
+    );
+  }
+
+  /** Updates the spatial transform of an existing 2D camera. */
+  realm2dSetCameraTransform(realmId: number, cameraId: number, transform: Transform2D): void {
+    if (typeof this._addon.realm2dSetCameraTransform !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dSetCameraTransform');
+    }
+    this._addon.realm2dSetCameraTransform(realmId, cameraId, transform);
+  }
+
+  /** Creates or updates a 2D material definition. */
+  realm2dCreateMaterial(
+    realmId: number,
+    materialId: number,
+    material: Material2DDesc | string
+  ): void {
+    if (typeof this._addon.realm2dCreateMaterial !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dCreateMaterial');
+    }
+    this._addon.realm2dCreateMaterial(
+      realmId,
+      materialId,
+      typeof material === 'string' ? JSON.parse(material) : material
+    );
+  }
+
+  /** Creates or updates a 2D instanced sprite with an initial transform. */
+  realm2dCreateSprite(
+    realmId: number,
+    spriteId: number,
+    sprite: Sprite2DDesc | string,
+    transform: Transform2DDesc | string
+  ): void {
+    if (typeof this._addon.realm2dCreateSprite !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dCreateSprite');
+    }
+    this._addon.realm2dCreateSprite(
+      realmId,
+      spriteId,
+      typeof sprite === 'string' ? JSON.parse(sprite) : sprite,
+      typeof transform === 'string' ? JSON.parse(transform) : transform
+    );
+  }
+
+  /** Updates the spatial transform of an existing 2D sprite. */
+  realm2dSetSpriteTransform(realmId: number, spriteId: number, transform: Transform2D): void {
+    if (typeof this._addon.realm2dSetSpriteTransform !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dSetSpriteTransform');
+    }
+    this._addon.realm2dSetSpriteTransform(realmId, spriteId, transform);
+  }
+
+  /** Creates or updates a 2D vector shape (Rectangle, Circle, Polygon) with an initial transform. */
+  realm2dCreateShape(
+    realmId: number,
+    shapeId: number,
+    shape: Shape2DDesc | string,
+    transform: Transform2DDesc | string
+  ): void {
+    if (typeof this._addon.realm2dCreateShape !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dCreateShape');
+    }
+    this._addon.realm2dCreateShape(
+      realmId,
+      shapeId,
+      typeof shape === 'string' ? JSON.parse(shape) : shape,
+      typeof transform === 'string' ? JSON.parse(transform) : transform
+    );
+  }
+
+  /** Updates the spatial transform of an existing 2D shape. */
+  realm2dSetShapeTransform(realmId: number, shapeId: number, transform: Transform2D): void {
+    if (typeof this._addon.realm2dSetShapeTransform !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dSetShapeTransform');
+    }
+    this._addon.realm2dSetShapeTransform(realmId, shapeId, transform);
+  }
+
+  /** Creates or updates a 2D point light with an initial transform. */
+  realm2dCreateLight(
+    realmId: number,
+    lightId: number,
+    light: Light2DDesc | string,
+    transform: Transform2DDesc | string
+  ): void {
+    if (typeof this._addon.realm2dCreateLight !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dCreateLight');
+    }
+    this._addon.realm2dCreateLight(
+      realmId,
+      lightId,
+      typeof light === 'string' ? JSON.parse(light) : light,
+      typeof transform === 'string' ? JSON.parse(transform) : transform
+    );
+  }
+
+  /** Updates the spatial transform of an existing 2D light. */
+  realm2dSetLightTransform(realmId: number, lightId: number, transform: Transform2D): void {
+    if (typeof this._addon.realm2dSetLightTransform !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dSetLightTransform');
+    }
+    this._addon.realm2dSetLightTransform(realmId, lightId, transform);
+  }
+
+  /** Updates global 2D polar shadow parameters. */
+  realm2dSetShadowConfig(realmId: number, config: Shadow2DConfigDesc | string): void {
+    if (typeof this._addon.realm2dSetShadowConfig !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dSetShadowConfig');
+    }
+    this._addon.realm2dSetShadowConfig(
+      realmId,
+      typeof config === 'string' ? JSON.parse(config) : config
+    );
+  }
+
+  /** Creates or updates a 2D particle emitter entity with an initial transform. */
+  realm2dCreateParticleEmitter(
+    realmId: number,
+    emitterId: number,
+    emitter: ParticleEmitter2DDesc | string,
+    transform: Transform2DDesc | string
+  ): void {
+    if (typeof this._addon.realm2dCreateParticleEmitter !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dCreateParticleEmitter');
+    }
+    this._addon.realm2dCreateParticleEmitter(
+      realmId,
+      emitterId,
+      typeof emitter === 'string' ? JSON.parse(emitter) : emitter,
+      typeof transform === 'string' ? JSON.parse(transform) : transform
+    );
+  }
+
+  /** Updates the spatial transform of an existing 2D particle emitter. */
+  realm2dSetParticleEmitterTransform(
+    realmId: number,
+    emitterId: number,
+    transform: Transform2D
+  ): void {
+    if (typeof this._addon.realm2dSetParticleEmitterTransform !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dSetParticleEmitterTransform');
+    }
+    this._addon.realm2dSetParticleEmitterTransform(realmId, emitterId, transform);
+  }
+
+  /** Triggers an immediate burst of particles from an existing 2D emitter. */
+  realm2dParticleEmitterBurst(realmId: number, emitterId: number, count: number): void {
+    if (typeof this._addon.realm2dParticleEmitterBurst !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dParticleEmitterBurst');
+    }
+    this._addon.realm2dParticleEmitterBurst(realmId, emitterId, count);
+  }
+
+  /** Destroys an existing 2D particle emitter entity. */
+  realm2dDestroyParticleEmitter(realmId: number, emitterId: number): void {
+    if (typeof this._addon.realm2dDestroyParticleEmitter !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dDestroyParticleEmitter');
+    }
+    this._addon.realm2dDestroyParticleEmitter(realmId, emitterId);
+  }
+
+  /** Destroys an existing 2D camera entity. */
+  realm2dDestroyCamera(realmId: number, cameraId: number): void {
+    if (typeof this._addon.realm2dDestroyCamera !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dDestroyCamera');
+    }
+    this._addon.realm2dDestroyCamera(realmId, cameraId);
+  }
+
+  /** Destroys an existing 2D material entity. */
+  realm2dDestroyMaterial(realmId: number, materialId: number): void {
+    if (typeof this._addon.realm2dDestroyMaterial !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dDestroyMaterial');
+    }
+    this._addon.realm2dDestroyMaterial(realmId, materialId);
+  }
+
+  /** Destroys an existing 2D sprite entity. */
+  realm2dDestroySprite(realmId: number, spriteId: number): void {
+    if (typeof this._addon.realm2dDestroySprite !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dDestroySprite');
+    }
+    this._addon.realm2dDestroySprite(realmId, spriteId);
+  }
+
+  /** Destroys an existing 2D shape entity. */
+  realm2dDestroyShape(realmId: number, shapeId: number): void {
+    if (typeof this._addon.realm2dDestroyShape !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dDestroyShape');
+    }
+    this._addon.realm2dDestroyShape(realmId, shapeId);
+  }
+
+  /** Destroys an existing 2D light entity. */
+  realm2dDestroyLight(realmId: number, lightId: number): void {
+    if (typeof this._addon.realm2dDestroyLight !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dDestroyLight');
+    }
+    this._addon.realm2dDestroyLight(realmId, lightId);
+  }
+
+  /** Reads the transform of an existing Sprite instance. */
+  realm2dGetSpriteTransform(realmId: number, spriteId: number): Transform2D {
+    if (typeof this._addon.realm2dGetSpriteTransform !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dGetSpriteTransform');
+    }
+    return this._addon.realm2dGetSpriteTransform(realmId, spriteId);
+  }
+
+  /** Reads the transform of an existing Camera instance. */
+  realm2dGetCameraTransform(realmId: number, cameraId: number): Transform2D {
+    if (typeof this._addon.realm2dGetCameraTransform !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dGetCameraTransform');
+    }
+    return this._addon.realm2dGetCameraTransform(realmId, cameraId);
+  }
+
+  /** Creates or updates a 2D SVG vector entity with an initial transform. */
+  realm2dCreateSvg(
+    realmId: number,
+    svgId: number,
+    svg: Svg2DDesc | string,
+    transform: Transform2DDesc | string
+  ): void {
+    if (typeof this._addon.realm2dCreateSvg !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dCreateSvg');
+    }
+    this._addon.realm2dCreateSvg(
+      realmId,
+      svgId,
+      typeof svg === 'string' ? JSON.parse(svg) : svg,
+      typeof transform === 'string' ? JSON.parse(transform) : transform
+    );
+  }
+
+  /** Reads the geometric bounds of an SVG element. */
+  realm2dGetSvgElementRect(
+    realmId: number,
+    svgId: number,
+    elementId: string
+  ): SvgElementRectResult {
+    if (typeof this._addon.realm2dGetSvgElementRect !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dGetSvgElementRect');
+    }
+    return this._addon.realm2dGetSvgElementRect(realmId, svgId, elementId);
+  }
+
+  /** Reads the shaped text clusters of an SVG text element. */
+  realm2dGetSvgTextLayout(realmId: number, svgId: number, elementId: string): SvgTextLayoutResult {
+    if (typeof this._addon.realm2dGetSvgTextLayout !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dGetSvgTextLayout');
+    }
+    return this._addon.realm2dGetSvgTextLayout(realmId, svgId, elementId);
+  }
+
+  /** Replaces the complete source XML markup string of an existing SVG entity. */
+  realm2dSetSvgSource(realmId: number, svgId: number, source: string): void {
+    if (typeof this._addon.realm2dSetSvgSource !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dSetSvgSource');
+    }
+    this._addon.realm2dSetSvgSource(realmId, svgId, source);
+  }
+
+  /** Sets or overwrites an XML attribute on the matching element ID in the SVG. */
+  realm2dSetSvgAttribute(
+    realmId: number,
+    svgId: number,
+    elementId: string,
+    name: string,
+    value: string
+  ): void {
+    if (typeof this._addon.realm2dSetSvgAttribute !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dSetSvgAttribute');
+    }
+    this._addon.realm2dSetSvgAttribute(realmId, svgId, elementId, name, value);
+  }
+
+  /** Removes an XML attribute from the matching element ID in the SVG. */
+  realm2dRemoveSvgAttribute(realmId: number, svgId: number, elementId: string, name: string): void {
+    if (typeof this._addon.realm2dRemoveSvgAttribute !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dRemoveSvgAttribute');
+    }
+    this._addon.realm2dRemoveSvgAttribute(realmId, svgId, elementId, name);
+  }
+
+  /** Updates the inner text content of the matching element ID in the SVG. */
+  realm2dSetSvgText(realmId: number, svgId: number, elementId: string, text: string): void {
+    if (typeof this._addon.realm2dSetSvgText !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dSetSvgText');
+    }
+    this._addon.realm2dSetSvgText(realmId, svgId, elementId, text);
+  }
+
+  /** Updates the spatial transform of an existing SVG entity. */
+  realm2dSetSvgTransform(realmId: number, svgId: number, transform: Transform2D): void {
+    if (typeof this._addon.realm2dSetSvgTransform !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dSetSvgTransform');
+    }
+    this._addon.realm2dSetSvgTransform(realmId, svgId, transform);
+  }
+
+  /** Reads the transform of an existing SVG entity. */
+  realm2dGetSvgTransform(realmId: number, svgId: number): Transform2D {
+    if (typeof this._addon.realm2dGetSvgTransform !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dGetSvgTransform');
+    }
+    return this._addon.realm2dGetSvgTransform(realmId, svgId);
+  }
+
+  /** Destroys an existing 2D SVG entity. */
+  realm2dDestroySvg(realmId: number, svgId: number): void {
+    if (typeof this._addon.realm2dDestroySvg !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dDestroySvg');
+    }
+    this._addon.realm2dDestroySvg(realmId, svgId);
+  }
+
+  /** Registers raw TTF/OTF font binary data from memory (zero filesystem access). Returns the detected font family name. */
+  realm2dLoadFontData(realmId: number, data: any, dataLen: number): string {
+    if (typeof this._addon.realm2dLoadFontData !== 'function') {
+      throw new GalfusError('WASM method not implemented: realm2dLoadFontData');
+    }
+    return this._addon.realm2dLoadFontData(realmId, data, dataLen);
+  }
+
+  /** Creates a new property transition with an initial value and timing configuration. */
+  animationCreateTransition(
+    transitionId: number,
+    initialValue: AnimValue | string,
+    config?: TransitionConfig | string
+  ): void {
+    if (typeof this._addon.animationCreateTransition !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationCreateTransition');
+    }
+    this._addon.animationCreateTransition(
+      transitionId,
+      typeof initialValue === 'string' ? JSON.parse(initialValue) : initialValue,
+      typeof config === 'string' ? JSON.parse(config) : config
+    );
+  }
+
+  /** Binds an existing transition to a realm entity or multiverse property target. */
+  animationBindTarget(transitionId: number, target: AnimationTarget | string): void {
+    if (typeof this._addon.animationBindTarget !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationBindTarget');
+    }
+    this._addon.animationBindTarget(
+      transitionId,
+      typeof target === 'string' ? JSON.parse(target) : target
+    );
+  }
+
+  /** Unbinds a target from a transition and releases its property lock. */
+  animationUnbindTarget(transitionId: number): void {
+    if (typeof this._addon.animationUnbindTarget !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationUnbindTarget');
+    }
+    this._addon.animationUnbindTarget(transitionId);
+  }
+
+  /** Triggers a smooth transition from the live value towards a new target value. */
+  animationTransitionTo(
+    transitionId: number,
+    targetValue: AnimValue | string,
+    config?: TransitionConfig | string
+  ): void {
+    if (typeof this._addon.animationTransitionTo !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationTransitionTo');
+    }
+    this._addon.animationTransitionTo(
+      transitionId,
+      typeof targetValue === 'string' ? JSON.parse(targetValue) : targetValue,
+      typeof config === 'string' ? JSON.parse(config) : config
+    );
+  }
+
+  /** Fast-path helper creating a scalar transition. */
+  animationCreateScalarTransition(
+    transitionId: number,
+    initialScalar: number,
+    duration: number,
+    delay: number,
+    easingId: number
+  ): void {
+    if (typeof this._addon.animationCreateScalarTransition !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationCreateScalarTransition');
+    }
+    this._addon.animationCreateScalarTransition(
+      transitionId,
+      initialScalar,
+      duration,
+      delay,
+      easingId
+    );
+  }
+
+  /** Fast-path helper smoothly transitioning a scalar property. */
+  animationTransitionToScalar(
+    transitionId: number,
+    targetScalar: number,
+    duration: number,
+    delay: number,
+    easingId: number
+  ): void {
+    if (typeof this._addon.animationTransitionToScalar !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationTransitionToScalar');
+    }
+    this._addon.animationTransitionToScalar(transitionId, targetScalar, duration, delay, easingId);
+  }
+
+  /** Fast-path transitioning a 3D Transform from 10 raw floats (pos, quat, scale). */
+  animationTransitionToTransform3d(
+    transitionId: number,
+    floats: any,
+    duration: number,
+    delay: number,
+    easingId: number
+  ): void {
+    if (typeof this._addon.animationTransitionToTransform3d !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationTransitionToTransform3d');
+    }
+    this._addon.animationTransitionToTransform3d(transitionId, floats, duration, delay, easingId);
+  }
+
+  /** Fast-path transitioning a 2D Transform from 6 raw floats (pos, rot, scale, z_layer). */
+  animationTransitionToTransform2d(
+    transitionId: number,
+    floats: any,
+    duration: number,
+    delay: number,
+    easingId: number
+  ): void {
+    if (typeof this._addon.animationTransitionToTransform2d !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationTransitionToTransform2d');
+    }
+    this._addon.animationTransitionToTransform2d(transitionId, floats, duration, delay, easingId);
+  }
+
+  /** Queries the current playback status and progress of a transition. */
+  animationGetState(transitionId: number): TransitionState {
+    if (typeof this._addon.animationGetState !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationGetState');
+    }
+    return this._addon.animationGetState(transitionId);
+  }
+
+  /** Queries the current evaluated value of a transition. */
+  animationGetValue(transitionId: number): AnimValue {
+    if (typeof this._addon.animationGetValue !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationGetValue');
+    }
+    return this._addon.animationGetValue(transitionId);
+  }
+
+  /** Destroys an animation transition by ID. */
+  animationDestroyTransition(transitionId: number): void {
+    if (typeof this._addon.animationDestroyTransition !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationDestroyTransition');
+    }
+    this._addon.animationDestroyTransition(transitionId);
+  }
+
+  /** Advances all active animation transitions by dt seconds and applies updates to Multiverse. */
+  animationStep(dt: number): void {
+    if (typeof this._addon.animationStep !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationStep');
+    }
+    this._addon.animationStep(dt);
+  }
+
+  /** Drains and returns all queued animation lifecycle events. */
+  animationPumpEvents(): AnimationEvent[] {
+    if (typeof this._addon.animationPumpEvents !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationPumpEvents');
+    }
+    return this._addon.animationPumpEvents();
+  }
+
+  /** Writes directly to a custom animation channel. */
+  animationSetCustomChannel(channelId: number, value: AnimValue | string): void {
+    if (typeof this._addon.animationSetCustomChannel !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationSetCustomChannel');
+    }
+    this._addon.animationSetCustomChannel(
+      channelId,
+      typeof value === 'string' ? JSON.parse(value) : value
+    );
+  }
+
+  /** Reads directly from a custom animation channel. */
+  animationGetCustomChannel(channelId: number): AnimValue {
+    if (typeof this._addon.animationGetCustomChannel !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationGetCustomChannel');
+    }
+    return this._addon.animationGetCustomChannel(channelId);
+  }
+
+  /** Creates a new path follower traversing a declarative SVG-like path. */
+  animationCreatePathFollow(
+    pathId: number,
+    commands: PathCommand[] | string,
+    config?: PathFollowConfig | string
+  ): void {
+    if (typeof this._addon.animationCreatePathFollow !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationCreatePathFollow');
+    }
+    this._addon.animationCreatePathFollow(
+      pathId,
+      typeof commands === 'string' ? JSON.parse(commands) : commands,
+      typeof config === 'string' ? JSON.parse(config) : config
+    );
+  }
+
+  /** Binds a path follower to an entity property target with conflict locking. */
+  animationBindPathFollowTarget(pathId: number, target: AnimationTarget | string): void {
+    if (typeof this._addon.animationBindPathFollowTarget !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationBindPathFollowTarget');
+    }
+    this._addon.animationBindPathFollowTarget(
+      pathId,
+      typeof target === 'string' ? JSON.parse(target) : target
+    );
+  }
+
+  /** Unbinds a target from a path follower and releases its property lock. */
+  animationUnbindPathFollowTarget(pathId: number): void {
+    if (typeof this._addon.animationUnbindPathFollowTarget !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationUnbindPathFollowTarget');
+    }
+    this._addon.animationUnbindPathFollowTarget(pathId);
+  }
+
+  /** Destroys a path follower by ID. */
+  animationDestroyPathFollow(pathId: number): void {
+    if (typeof this._addon.animationDestroyPathFollow !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationDestroyPathFollow');
+    }
+    this._addon.animationDestroyPathFollow(pathId);
+  }
+
+  /** Queries the current playback status and progress of a path follower. */
+  animationGetPathFollowState(pathId: number): PathFollowState {
+    if (typeof this._addon.animationGetPathFollowState !== 'function') {
+      throw new GalfusError('WASM method not implemented: animationGetPathFollowState');
+    }
+    return this._addon.animationGetPathFollowState(pathId);
+  }
+
+  /** Reads the inner physical size [width, height] of a Platform window. */
+  windowGetSize(windowId: number): [number, number] {
+    return this._addon.windowGetSize(windowId);
+  }
+
+  /** Reads the inner physical size [width, height] of a Platform window (alias for windowGetSize). */
+  platformGetWindowSize(windowId: number): [number, number] {
+    return this.windowGetSize(windowId);
+  }
+}
+
+/** Initializes the WASM module and returns the full browser engine API. */
+export async function initializeGalfusBrowser(
+  module: GalfusBrowserWasmModule
+): Promise<GalfusBrowser> {
+  await module.default();
+  return new GalfusBrowser(module);
+}