goudengine 0.0.827 → 0.0.830

package/dist/web/generated/web/index.g.js

@@ -2,8 +2,28 @@
 import { Color } from '../types/math.g.js';
 import { attachInputHandlers } from './input.g.js';
 export { Color, Vec2, Vec3 } from '../types/math.g.js';
-export { Key, MouseButton } from '../types/input.g.js';
+export { Key, MouseButton, PhysicsBackend2D } from '../types/input.g.js';
 export { Rect } from '../types/math.g.js';
+const PRELOAD_TEXTURE_EXTENSIONS = new Set(['png', 'jpg', 'jpeg', 'gif', 'bmp', 'webp', 'tga', 'dds']);
+const PRELOAD_FONT_EXTENSIONS = new Set(['ttf', 'otf', 'woff', 'woff2', 'fnt']);
+function detectPreloadKind(path) {
+    const ext = path.split('.').pop()?.toLowerCase() ?? '';
+    if (PRELOAD_TEXTURE_EXTENSIONS.has(ext))
+        return 'texture';
+    if (PRELOAD_FONT_EXTENSIONS.has(ext))
+        return 'font';
+    throw new Error(`Unsupported preload asset type for path: ${path}`);
+}
+function normalizePreloadAsset(asset) {
+    if (typeof asset === 'string') {
+        return { path: asset, kind: detectPreloadKind(asset) };
+    }
+    return { path: asset.path, kind: asset.kind ?? detectPreloadKind(asset.path) };
+}
+const WEB_RENDER_CAPABILITIES = { maxTextureUnits: 0, maxTextureSize: 0, supportsInstancing: false, supportsCompute: false, supportsMsaa: false };
+const WEB_PHYSICS_CAPABILITIES = { supportsContinuousCollision: false, supportsJoints: false, maxBodies: 0 };
+const WEB_AUDIO_CAPABILITIES = { supportsSpatial: true, maxChannels: 32 };
+const WEB_INPUT_CAPABILITIES = { supportsGamepad: false, supportsTouch: true, maxGamepads: 0 };
 let _wasmModule = null;
 export async function initWasm(wasmUrl) {
     if (_wasmModule)
@@ -18,6 +38,44 @@ function getWasm() {
         throw new Error('Wasm not loaded. Call initWasm() first.');
     return _wasmModule;
 }
+function toWasmUiNodeId(nodeId) {
+    return typeof nodeId === 'bigint' ? nodeId : BigInt(nodeId);
+}
+export class UiManager {
+    constructor(handle) {
+        this.handle = handle;
+    }
+    static async create(wasmUrl) {
+        await initWasm(wasmUrl);
+        const wasm = getWasm();
+        return new UiManager(new wasm.WasmUiManager());
+    }
+    destroy() { this.handle.free(); }
+    update() { this.handle.update(); }
+    render() { this.handle.render(); }
+    nodeCount() { return this.handle.node_count(); }
+    createNode(componentType) { return this.handle.create_node(componentType); }
+    removeNode(nodeId) { return this.handle.remove_node(toWasmUiNodeId(nodeId)); }
+    setParent(childId, parentId) { return this.handle.set_parent(toWasmUiNodeId(childId), toWasmUiNodeId(parentId)); }
+    getParent(nodeId) { return this.handle.get_parent(toWasmUiNodeId(nodeId)); }
+    getChildCount(nodeId) { return this.handle.get_child_count(toWasmUiNodeId(nodeId)); }
+    getChildAt(nodeId, index) { return this.handle.get_child_at(toWasmUiNodeId(nodeId), index); }
+    setWidget(nodeId, widgetKind) { return this.handle.set_widget(toWasmUiNodeId(nodeId), widgetKind); }
+    setStyle(nodeId, style) {
+        return this.handle.set_style(toWasmUiNodeId(nodeId), style.backgroundColor?.r, style.backgroundColor?.g, style.backgroundColor?.b, style.backgroundColor?.a, style.foregroundColor?.r, style.foregroundColor?.g, style.foregroundColor?.b, style.foregroundColor?.a, style.borderColor?.r, style.borderColor?.g, style.borderColor?.b, style.borderColor?.a, style.borderWidth, style.fontFamily, style.fontSize, style.texturePath, style.widgetSpacing);
+    }
+    setLabelText(nodeId, text) { return this.handle.set_label_text(toWasmUiNodeId(nodeId), text); }
+    setButtonEnabled(nodeId, enabled) { return this.handle.set_button_enabled(toWasmUiNodeId(nodeId), enabled); }
+    setImageTexturePath(nodeId, path) { return this.handle.set_image_texture_path(toWasmUiNodeId(nodeId), path); }
+    setSlider(nodeId, min, max, value, enabled) { return this.handle.set_slider(toWasmUiNodeId(nodeId), min, max, value, enabled); }
+    eventCount() { return this.handle.event_count(); }
+    eventRead(index) { return this.handle.event_read(index) ?? null; }
+    createPanel() { return this.createNode(0); }
+    createLabel(text) { const nodeId = this.createNode(2); this.setLabelText(nodeId, text); return nodeId; }
+    createButton(enabled = true) { const nodeId = this.createNode(1); this.setButtonEnabled(nodeId, enabled); return nodeId; }
+    createImage(path) { const nodeId = this.createNode(3); this.setImageTexturePath(nodeId, path); return nodeId; }
+    createSlider(min, max, value, enabled = true) { const nodeId = this.createNode(4); this.setSlider(nodeId, min, max, value, enabled); return nodeId; }
+}
 class WebEntity {
     constructor(_bits) {
         this._bits = _bits;
@@ -36,6 +94,14 @@ export class GoudGame {
         this.lastTs = 0;
         this._shouldClose = false;
         this._updateFn = null;
+        this._audioGlobalVolume = 1;
+        this._audioChannelVolumes = new Map();
+        this._activeAudioPlayers = new Set();
+        this.preloadedTextures = new Map();
+        this.preloadedFonts = new Map();
+        this.texturePathByHandle = new Map();
+        this.fontPathByHandle = new Map();
+        this.preloadInFlight = false;
         this.handle = handle;
         this.canvas = canvas;
     }
@@ -93,7 +159,11 @@ export class GoudGame {
     /** Signals the window to close */
     close() { this._shouldClose = true; this.stop(); }
     /** Releases all engine resources */
-    destroy() { this.stop(); this.handle.free(); }
+    destroy() {
+        this.stop();
+        this._activeAudioPlayers.clear();
+        this.handle.free();
+    }
     /** Starts a new render frame with the given clear color */
     beginFrame(r = 0, g = 0, b = 0, a = 1) {
         this.handle.set_clear_color(r, g, b, a);
@@ -109,6 +179,9 @@ export class GoudGame {
     run(update) {
         if (this.running)
             return;
+        if (this.preloadInFlight) {
+            throw new Error('game.preload(...) must finish before game.run() starts.');
+        }
         if (update.constructor.name === 'AsyncFunction') {
             console.warn('GoudEngine: game.run() callback should be synchronous. Async callbacks may cause borrow conflicts in WASM.');
         }
@@ -118,7 +191,9 @@ export class GoudGame {
         this.detachInput = attachInputHandlers(this.canvas, this.handle);
         this._startLoop(update);
     }
-    stop() {
+    stop(entity) {
+        if (entity !== undefined)
+            return 0;
         this.running = false;
         if (this.rafId) {
             cancelAnimationFrame(this.rafId);
@@ -162,14 +237,89 @@ export class GoudGame {
     }
     /** Loads a texture from a file path and returns its handle */
     async loadTexture(path) {
+        const cached = this.preloadedTextures.get(path);
+        if (cached !== undefined) {
+            return cached;
+        }
         const resp = await fetch(path);
         if (!resp.ok)
             throw new Error(`Failed to load texture: ${path} (HTTP ${resp.status})`);
         const bytes = new Uint8Array(await resp.arrayBuffer());
-        return this.handle.register_texture_from_bytes(bytes);
+        const handle = this.handle.register_texture_from_bytes(bytes);
+        this.preloadedTextures.set(path, handle);
+        this.texturePathByHandle.set(handle, path);
+        return handle;
     }
     /** Destroys a previously loaded texture */
-    destroyTexture(handle) { this.handle.destroy_texture(handle); }
+    destroyTexture(handle) {
+        const path = this.texturePathByHandle.get(handle);
+        if (path !== undefined) {
+            this.texturePathByHandle.delete(handle);
+            this.preloadedTextures.delete(path);
+        }
+        this.handle.destroy_texture(handle);
+    }
+    /** Loads a font from a file path and returns its handle */
+    async loadFont(path) {
+        const cached = this.preloadedFonts.get(path);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const resp = await fetch(path);
+        if (!resp.ok)
+            throw new Error(`Failed to load font: ${path} (HTTP ${resp.status})`);
+        const bytes = new Uint8Array(await resp.arrayBuffer());
+        const handle = this.handle.register_font_from_bytes(bytes);
+        this.preloadedFonts.set(path, handle);
+        this.fontPathByHandle.set(handle, path);
+        return handle;
+    }
+    /** Destroys a previously loaded font */
+    destroyFont(handle) {
+        const path = this.fontPathByHandle.get(handle);
+        if (path !== undefined) {
+            this.fontPathByHandle.delete(handle);
+            this.preloadedFonts.delete(path);
+        }
+        return this.handle.destroy_font(handle);
+    }
+    async preload(assets, options = {}) {
+        if (this.preloadInFlight) {
+            throw new Error('game.preload(...) is already in progress.');
+        }
+        this.preloadInFlight = true;
+        const handles = {};
+        try {
+            const normalized = assets.map(normalizePreloadAsset);
+            const total = normalized.length;
+            let loaded = 0;
+            for (const asset of normalized) {
+                const handle = asset.kind === 'font'
+                    ? await this.loadFont(asset.path)
+                    : await this.loadTexture(asset.path);
+                handles[asset.path] = handle;
+                loaded += 1;
+                const update = {
+                    loaded,
+                    total,
+                    progress: total === 0 ? 1 : loaded / total,
+                    path: asset.path,
+                    kind: asset.kind,
+                    handle,
+                };
+                options.onProgress?.(update);
+            }
+            return handles;
+        }
+        finally {
+            this.preloadInFlight = false;
+        }
+    }
+    /** Draws text using a loaded font */
+    drawText(fontHandle, text, x, y, fontSize = 16, alignment = 0, maxWidth = 0, lineSpacing = 1, direction = 0, color) {
+        const c = color ?? Color.white();
+        return this.handle.draw_text(fontHandle, text, x, y, fontSize, alignment, maxWidth, lineSpacing, direction, c.r, c.g, c.b, c.a);
+    }
     /** Draws a textured sprite */
     drawSprite(texture, x, y, width, height, rotation = 0, color) {
         const c = color ?? Color.white();
@@ -185,6 +335,164 @@ export class GoudGame {
         const c = color ?? Color.white();
         this.handle.draw_quad(x, y, width, height, c.r, c.g, c.b, c.a);
     }
+    /** Plays audio from raw bytes on the default channel */
+    audioPlay(data) {
+        const playerId = this.handle.audio_play(data);
+        if (playerId >= 0)
+            this._activeAudioPlayers.add(playerId);
+        return playerId;
+    }
+    /** Plays audio from raw bytes on the given channel */
+    audioPlayOnChannel(data, channel) {
+        const fn = this.handle.audio_play_on_channel;
+        const playerId = fn ? fn.call(this.handle, data, channel) : this.handle.audio_play(data);
+        if (playerId >= 0)
+            this._activeAudioPlayers.add(playerId);
+        return playerId;
+    }
+    /** Plays audio with explicit volume, speed, looping, and channel settings */
+    audioPlayWithSettings(data, volume, speed, looping, channel) {
+        const fn = this.handle.audio_play_with_settings;
+        const playerId = fn ? fn.call(this.handle, data, volume, speed, looping, channel) : this.handle.audio_play(data);
+        if (playerId < 0)
+            return playerId;
+        this._activeAudioPlayers.add(playerId);
+        if (!fn) {
+            this.handle.audio_set_player_volume(playerId, volume);
+            this.handle.audio_set_player_speed(playerId, speed);
+        }
+        return playerId;
+    }
+    /** Stops a playing audio player */
+    audioStop(playerId) {
+        const rc = this.handle.audio_stop(playerId);
+        if (rc === 0)
+            this._activeAudioPlayers.delete(playerId);
+        return rc;
+    }
+    /** Pauses a playing audio player */
+    audioPause(playerId) { return this.handle.audio_pause(playerId); }
+    /** Resumes a paused audio player */
+    audioResume(playerId) { return this.handle.audio_resume(playerId); }
+    /** Stops all active audio players */
+    audioStopAll() {
+        const rc = this.handle.audio_stop_all();
+        if (rc === 0)
+            this._activeAudioPlayers.clear();
+        return rc;
+    }
+    /** Sets the global audio volume */
+    audioSetGlobalVolume(volume) {
+        const fn = this.handle.audio_set_global_volume;
+        if (fn) {
+            const rc = fn.call(this.handle, volume);
+            if (rc === 0)
+                this._audioGlobalVolume = volume;
+            return rc;
+        }
+        this._audioGlobalVolume = volume;
+        return 0;
+    }
+    /** Gets the global audio volume */
+    audioGetGlobalVolume() {
+        const fn = this.handle.audio_get_global_volume;
+        return fn ? fn.call(this.handle) : this._audioGlobalVolume;
+    }
+    /** Sets the volume for a specific channel */
+    audioSetChannelVolume(channel, volume) {
+        const fn = this.handle.audio_set_channel_volume;
+        if (fn)
+            return fn.call(this.handle, channel, volume);
+        this._audioChannelVolumes.set(channel, volume);
+        return 0;
+    }
+    /** Gets the volume for a specific channel */
+    audioGetChannelVolume(channel) {
+        const fn = this.handle.audio_get_channel_volume;
+        if (fn)
+            return fn.call(this.handle, channel);
+        return this._audioChannelVolumes.get(channel) ?? this._audioGlobalVolume;
+    }
+    /** Returns non-zero when the player is still playing */
+    audioIsPlaying(playerId) {
+        const fn = this.handle.audio_is_playing;
+        if (fn)
+            return fn.call(this.handle, playerId);
+        return this._activeAudioPlayers.has(playerId) ? 1 : 0;
+    }
+    /** Returns the number of active audio players */
+    audioActiveCount() {
+        const fn = this.handle.audio_active_count;
+        return fn ? fn.call(this.handle) : this._activeAudioPlayers.size;
+    }
+    /** Cleans up finished audio players */
+    audioCleanupFinished() {
+        const fn = this.handle.audio_cleanup_finished;
+        return fn ? fn.call(this.handle) : 0;
+    }
+    /** Plays audio with 3D spatial attenuation */
+    audioPlaySpatial3d(data, sourceX, sourceY, sourceZ, listenerX, listenerY, listenerZ, maxDistance, rolloff) {
+        const playerId = this.handle.audio_play_spatial_3d(data, sourceX, sourceY, sourceZ, listenerX, listenerY, listenerZ, maxDistance, rolloff);
+        if (playerId >= 0)
+            this._activeAudioPlayers.add(playerId);
+        return playerId;
+    }
+    /** Updates 3D spatial attenuation for an active player */
+    audioUpdateSpatial3d(playerId, sourceX, sourceY, sourceZ, listenerX, listenerY, listenerZ, maxDistance, rolloff) {
+        return this.handle.audio_update_spatial_volume_3d(playerId, sourceX, sourceY, sourceZ, listenerX, listenerY, listenerZ, maxDistance, rolloff);
+    }
+    /** Sets the 3D listener position */
+    audioSetListenerPosition3d(x, y, z) { return this.handle.audio_set_listener_position_3d(x, y, z); }
+    /** Sets the 3D source position for an active player */
+    audioSetSourcePosition3d(playerId, x, y, z, maxDistance, rolloff) {
+        return this.handle.audio_set_source_position_3d(playerId, x, y, z, maxDistance, rolloff);
+    }
+    /** Sets the volume for an active player */
+    audioSetPlayerVolume(playerId, volume) { return this.handle.audio_set_player_volume(playerId, volume); }
+    /** Sets the playback speed for an active player */
+    audioSetPlayerSpeed(playerId, speed) { return this.handle.audio_set_player_speed(playerId, speed); }
+    /** Applies an immediate crossfade mix between two active players */
+    audioCrossfade(fromPlayerId, toPlayerId, mix) {
+        return this.handle.audio_crossfade(fromPlayerId, toPlayerId, mix);
+    }
+    /** Starts a timed crossfade from one player to a new audio asset */
+    audioCrossfadeTo(fromPlayerId, data, durationSec, channel) {
+        const fn = this.handle.audio_crossfade_to;
+        const playerId = fn ? fn.call(this.handle, fromPlayerId, data, durationSec, channel) : this.handle.audio_play(data);
+        if (playerId >= 0)
+            this._activeAudioPlayers.add(playerId);
+        if (!fn && playerId >= 0)
+            this.handle.audio_crossfade(fromPlayerId, playerId, 1.0);
+        return playerId;
+    }
+    /** Mixes a secondary audio asset with a primary player */
+    audioMixWith(primaryPlayerId, data, secondaryVolume, secondaryChannel) {
+        const fn = this.handle.audio_mix_with;
+        const playerId = fn ? fn.call(this.handle, primaryPlayerId, data, secondaryVolume, secondaryChannel) : this.handle.audio_play(data);
+        if (playerId >= 0)
+            this._activeAudioPlayers.add(playerId);
+        if (!fn && playerId >= 0) {
+            this.handle.audio_set_player_volume(playerId, secondaryVolume);
+            const mix = Math.max(0, Math.min(1, secondaryVolume));
+            this.handle.audio_crossfade(primaryPlayerId, playerId, mix);
+        }
+        return playerId;
+    }
+    /** Advances all active timed crossfades */
+    audioUpdateCrossfades(deltaSec) {
+        const fn = this.handle.audio_update_crossfades;
+        return fn ? fn.call(this.handle, deltaSec) : 0;
+    }
+    /** Returns the number of active timed crossfades */
+    audioActiveCrossfadeCount() {
+        const fn = this.handle.audio_active_crossfade_count;
+        return fn ? fn.call(this.handle) : 0;
+    }
+    /** Activates audio playback on platforms that require user gesture initialization */
+    audioActivate() {
+        const fn = this.handle.audio_activate;
+        return fn ? fn.call(this.handle) : 0;
+    }
     /** Returns true if the key is currently held down */
     isKeyPressed(key) { return this.handle.is_key_pressed(key); }
     /** Returns true if the key was pressed this frame */
@@ -236,6 +544,10 @@ export class GoudGame {
     entityCount() { return this.handle.entity_count(); }
     /** Returns true if the entity still exists */
     isAlive(entity) { return this.handle.is_alive(entity.toBits()); }
+    /** Clones an entity, creating a new entity with copies of all cloneable components */
+    cloneEntity(entity) { return new WebEntity(this.handle.clone_entity(entity.toBits())); }
+    /** Clones an entity and all its descendants recursively */
+    cloneEntityRecursive(entity) { return new WebEntity(this.handle.clone_entity_recursive(entity.toBits())); }
     /** Attaches a Transform2D component to the entity */
     addTransform2d(entity, t) { this.handle.add_transform2d(entity.toBits(), t.positionX, t.positionY, t.rotation, t.scaleX, t.scaleY); }
     /** Returns the entity's Transform2D, or null if absent */
@@ -274,6 +586,73 @@ export class GoudGame {
     hasName(entity) { return this.handle.has_name(entity.toBits()); }
     /** Removes the Name from the entity */
     removeName(entity) { return this.handle.remove_name(entity.toBits()); }
+    loadScene(_name, _json) {
+        throw new Error('Not supported in WASM mode');
+    }
+    unloadScene(_name) {
+        throw new Error('Not supported in WASM mode');
+    }
+    setActiveScene(_sceneId, _active) {
+        throw new Error('Not supported in WASM mode');
+    }
+    networkHost(protocol, port) {
+        return this.handle.network_host(protocol, port);
+    }
+    networkConnect(protocol, address, port) {
+        return this.handle.network_connect(protocol, address, port);
+    }
+    networkConnectWithPeer(protocol, address, port) {
+        const result = this.handle.network_connect_with_peer(protocol, address, port);
+        return { handle: result.handle, peerId: Number(result.peer_id) };
+    }
+    networkDisconnect(handle) {
+        return this.handle.network_disconnect(handle);
+    }
+    networkSend(handle, peerId, data, channel) {
+        return this.handle.network_send(handle, BigInt(peerId), data, channel);
+    }
+    networkReceive(handle) {
+        return this.handle.network_receive(handle);
+    }
+    networkReceivePacket(handle) {
+        const packet = this.handle.network_receive_packet(handle);
+        if (!packet)
+            return null;
+        return { peerId: Number(packet.peer_id), data: packet.data };
+    }
+    networkPoll(handle) {
+        return this.handle.network_poll(handle);
+    }
+    getNetworkStats(handle) {
+        const stats = this.handle.get_network_stats(handle);
+        return {
+            bytesSent: Number(stats.bytes_sent),
+            bytesReceived: Number(stats.bytes_received),
+            packetsSent: Number(stats.packets_sent),
+            packetsReceived: Number(stats.packets_received),
+            packetsLost: Number(stats.packets_lost),
+            rttMs: stats.rtt_ms,
+            sendBandwidthBytesPerSec: stats.send_bandwidth_bytes_per_sec,
+            receiveBandwidthBytesPerSec: stats.receive_bandwidth_bytes_per_sec,
+            packetLossPercent: stats.packet_loss_percent,
+            jitterMs: stats.jitter_ms,
+        };
+    }
+    networkPeerCount(handle) {
+        return this.handle.network_peer_count(handle);
+    }
+    setNetworkSimulation(handle, config) {
+        return this.handle.set_network_simulation(handle, config.oneWayLatencyMs, config.jitterMs, config.packetLossPercent);
+    }
+    clearNetworkSimulation(handle) {
+        return this.handle.clear_network_simulation(handle);
+    }
+    setNetworkOverlayHandle(handle) {
+        return this.handle.set_network_overlay_handle(handle);
+    }
+    clearNetworkOverlayHandle() {
+        return this.handle.clear_network_overlay_handle();
+    }
     /** AABB vs AABB collision test with contact */
     collisionAabbAabb(centerAx, centerAy, halfWa, halfHa, centerBx, centerBy, halfWb, halfHb) {
         const c = this.handle.collision_aabb_aabb(centerAx, centerAy, halfWa, halfHa, centerBx, centerBy, halfWb, halfHb);
@@ -332,5 +711,154 @@ export class GoudGame {
     disableDepthTest() { }
     clearDepth() { }
     disableBlending() { }
+    // TODO: wasm FPS overlay -- these stub methods satisfy the IGoudGame interface
+    getFpsStats() { return { currentFps: this.handle.fps, minFps: 0, maxFps: 0, avgFps: 0, frameTimeMs: 0 }; }
+    setFpsOverlayEnabled(_enabled) { }
+    setFpsUpdateInterval(_interval) { }
+    setFpsOverlayCorner(_corner) { }
+    getDebuggerSnapshotJson() { return this.handle.getDebuggerSnapshotJson(); }
+    getDebuggerManifestJson() { return '{}'; }
+    setDebuggerPaused(paused) { this.handle.dispatchDebuggerRequest(JSON.stringify({ verb: 'set_paused', paused })); }
+    stepDebugger(kind, count) { this.handle.dispatchDebuggerRequest(JSON.stringify(kind === 0 ? { verb: 'step', frames: count } : { verb: 'step', frames: 0, ticks: count })); }
+    setDebuggerTimeScale(scale) { this.handle.dispatchDebuggerRequest(JSON.stringify({ verb: 'set_time_scale', time_scale: scale })); }
+    setDebuggerDebugDrawEnabled(enabled) { this.handle.dispatchDebuggerRequest(JSON.stringify({ verb: 'set_debug_draw_enabled', enabled })); }
+    injectDebuggerKeyEvent(key, pressed) { this.handle.dispatchDebuggerRequest(JSON.stringify({ verb: 'inject_input', events: [{ device: 'keyboard', action: pressed ? 'press' : 'release', key: String(key) }] })); }
+    injectDebuggerMouseButton(button, pressed) { this.handle.dispatchDebuggerRequest(JSON.stringify({ verb: 'inject_input', events: [{ device: 'mouse', action: pressed ? 'press' : 'release', button: String(button) }] })); }
+    injectDebuggerMousePosition(position) { this.handle.dispatchDebuggerRequest(JSON.stringify({ verb: 'inject_input', events: [{ device: 'mouse', action: 'move', position: [position.x, position.y] }] })); }
+    injectDebuggerScroll(delta) { this.handle.dispatchDebuggerRequest(JSON.stringify({ verb: 'inject_input', events: [{ device: 'mouse', action: 'scroll', delta: [delta.x, delta.y] }] })); }
+    setDebuggerProfilingEnabled(enabled) { this.handle.dispatchDebuggerRequest(JSON.stringify({ verb: 'set_profiling_enabled', enabled })); }
+    setDebuggerSelectedEntity(entityId) { this.handle.dispatchDebuggerRequest(JSON.stringify({ verb: 'set_selected_entity', entity_id: entityId })); }
+    clearDebuggerSelectedEntity() { this.handle.dispatchDebuggerRequest(JSON.stringify({ verb: 'clear_selected_entity' })); }
+    getMemorySummary() { return { rendering: { currentBytes: 0, peakBytes: 0 }, assets: { currentBytes: 0, peakBytes: 0 }, ecs: { currentBytes: 0, peakBytes: 0 }, ui: { currentBytes: 0, peakBytes: 0 }, audio: { currentBytes: 0, peakBytes: 0 }, network: { currentBytes: 0, peakBytes: 0 }, debugger: { currentBytes: 0, peakBytes: 0 }, other: { currentBytes: 0, peakBytes: 0 }, totalCurrentBytes: 0, totalPeakBytes: 0 }; }
+    captureDebuggerFrame() {
+        const snapshot = this.handle.getDebuggerSnapshotJson();
+        let imagePng = new Uint8Array(0);
+        try {
+            const dataUrl = this.canvas.toDataURL('image/png');
+            const base64 = dataUrl.split(',')[1] ?? '';
+            const binary = atob(base64);
+            imagePng = new Uint8Array(binary.length);
+            for (let i = 0; i < binary.length; i++)
+                imagePng[i] = binary.charCodeAt(i);
+        }
+        catch { }
+        return { imagePng, metadataJson: '{}', snapshotJson: snapshot, metricsTraceJson: '{}' };
+    }
+    startDebuggerRecording() { this.handle.dispatchDebuggerRequest(JSON.stringify({ verb: 'start_recording' })); }
+    stopDebuggerRecording() { const r = this.handle.dispatchDebuggerRequest(JSON.stringify({ verb: 'stop_recording' })); const parsed = JSON.parse(r); return { manifestJson: parsed?.result?.manifest_json ?? '{}', data: new Uint8Array(parsed?.result?.data ?? []) }; }
+    startDebuggerReplay(recording) { this.handle.dispatchDebuggerRequest(JSON.stringify({ verb: 'start_replay', data: Array.from(recording) })); }
+    stopDebuggerReplay() { this.handle.dispatchDebuggerRequest(JSON.stringify({ verb: 'stop_replay' })); }
+    getDebuggerReplayStatusJson() { return this.handle.dispatchDebuggerRequest(JSON.stringify({ verb: 'get_replay_status' })); }
+    getDebuggerMetricsTraceJson() { return this.handle.dispatchDebuggerRequest(JSON.stringify({ verb: 'get_metrics_trace' })); }
+    // TODO: wasm animation -- these stub methods satisfy the IGoudGame interface
+    play(_entity) { return 0; }
+    setState(_entity, _stateName) { return 0; }
+    setParameterBool(_entity, _name, _value) { return 0; }
+    setParameterFloat(_entity, _name, _value) { return 0; }
+    animationLayerStackCreate(_entity) { return 0; }
+    animationLayerAdd(_entity, _name, _blendMode) { return 0; }
+    animationLayerSetWeight(_entity, _layerIndex, _weight) { return 0; }
+    animationLayerPlay(_entity, _layerIndex) { return 0; }
+    animationLayerSetClip(_entity, _layerIndex, _frameCount, _frameDuration, _mode) { return 0; }
+    animationLayerAddFrame(_entity, _layerIndex, _x, _y, _w, _h) { return 0; }
+    animationLayerReset(_entity, _layerIndex) { return 0; }
+    animationClipAddEvent(_entity, _frameIndex, _name, _payloadType, _payloadInt, _payloadFloat, _payloadString) { return 0; }
+    animationEventsCount() { return 0; }
+    animationEventsRead(_index) { return { entity: 0, name: '', frameIndex: 0, payloadType: 0, payloadInt: 0, payloadFloat: 0, payloadString: '' }; }
+    /** Casts a filtered ray and returns the full hit payload, or null when no hit is found (FFI: goud_physics_raycast_ex) */
+    physicsRaycastEx(_originX, _originY, _dirX, _dirY, _maxDist, _layerMask) { return null; }
+    /** Returns the number of queued physics collision events available to read (FFI: goud_physics_collision_events_count) */
+    physicsCollisionEventsCount() { throw new Error('Not supported in WASM mode'); }
+    /** Reads one queued physics collision event by index, or null when the index is out of range (FFI: goud_physics_collision_events_read) */
+    physicsCollisionEventsRead(_index) { return null; }
+    /** Registers or clears a physics collision callback function pointer. C# callers must keep the callback delegate alive for the full registration lifetime. Python and TypeScript wrappers support clear-only (`callbackPtr = 0`, `userData = 0`) for safety. (FFI: goud_physics_set_collision_callback) */
+    physicsSetCollisionCallback(_callbackPtr, _userData) { throw new Error('Not supported in WASM mode'); }
+    // Provider capability queries
+    getRenderCapabilities() { return WEB_RENDER_CAPABILITIES; }
+    getPhysicsCapabilities() { return WEB_PHYSICS_CAPABILITIES; }
+    getAudioCapabilities() { return WEB_AUDIO_CAPABILITIES; }
+    getInputCapabilities() { return WEB_INPUT_CAPABILITIES; }
+    getNetworkCapabilities() {
+        const caps = this.handle.get_network_capabilities();
+        return {
+            supportsHosting: caps.supports_hosting,
+            maxConnections: caps.max_connections,
+            maxChannels: caps.max_channels,
+            maxMessageSize: caps.max_message_size,
+        };
+    }
+    /** Checks if the hot-swap keyboard shortcut (F5) was pressed and cycles the render provider to null. Debug builds only. Returns true if a swap occurred. */
+    checkHotSwapShortcut() { throw new Error('Not supported in WASM mode'); }
+    /** Connect to a WebSocket debugger relay for MCP tool support. */
+    connectDebugger(wsUrl) {
+        const url = wsUrl ?? 'ws://127.0.0.1:9229';
+        this.handle.initDebugger?.('web-game');
+        const ws = new WebSocket(url);
+        ws.onopen = () => {
+            ws.send(JSON.stringify({ route_label: 'web-game', surface_kind: 'wasm_browser', capabilities: ['capture', 'control_plane', 'replay'] }));
+        };
+        ws.onmessage = (event) => {
+            const request = JSON.parse(event.data);
+            if (request.type === 'registration_ack')
+                return;
+            if (request.verb === 'capture_frame') {
+                const snapshot = this.handle.getDebuggerSnapshotJson?.() ?? '{}';
+                let imagePngBase64 = '';
+                try {
+                    imagePngBase64 = this.canvas.toDataURL('image/png').split(',')[1] ?? '';
+                }
+                catch { }
+                ws.send(JSON.stringify({ ok: true, result: { image_png_base64: imagePngBase64, snapshot_json: snapshot, metadata_json: '{}', metrics_trace_json: '{}' } }));
+                return;
+            }
+            const response = this.handle.dispatchDebuggerRequest?.(JSON.stringify(request)) ?? '{}';
+            ws.send(response);
+        };
+    }
+}
+/** Builder for configuring and creating a GoudGame instance with provider selection. */
+export class EngineConfig {
+    constructor() {
+        this._config = {};
+    }
+    /** Sets the window title */
+    setTitle(title) {
+        this._config.title = title;
+        return this;
+    }
+    /** Sets the window size in pixels */
+    setSize(width, height) {
+        this._config.width = width;
+        this._config.height = height;
+        return this;
+    }
+    /** Enables or disables the FPS debug overlay */
+    setFpsOverlay(_enabled) {
+        // FPS overlay is not yet supported in WASM; accepted for API parity.
+        return this;
+    }
+    /** Enables or disables physics debug visualization */
+    setPhysicsDebug(_enabled) {
+        return this;
+    }
+    /** Selects the 2D physics backend used by the built game */
+    setPhysicsBackend2D(_backend) {
+        return this;
+    }
+    /** Configures debugger runtime startup for the created game. */
+    setDebugger(debuggerConfig) {
+        this._config.debugger = debuggerConfig;
+        return this;
+    }
+    /** Consumes the config and creates a windowed GoudGame instance */
+    async build() {
+        const game = await GoudGame.create(this._config);
+        if (this._config.debugger?.enabled) {
+            game.handle.initDebugger?.(this._config.debugger.routeLabel ?? 'web');
+        }
+        return game;
+    }
+    /** Frees the config without building */
+    destroy() { }
 }
 //# sourceMappingURL=index.g.js.map