goudengine 0.0.832 → 0.0.834

package/README.md

@@ -2,10 +2,9 @@
 
 [![npm](https://img.shields.io/npm/v/goudengine.svg)](https://www.npmjs.com/package/goudengine)
 
-> **Alpha** — This SDK is under active development. APIs change frequently. [Report issues](https://github.com/aram-devdocs/GoudEngine/issues) · [Contact](mailto:aram.devdocs@gmail.com)
+> **Alpha** -- This SDK is under active development. APIs change frequently. [Report issues](https://github.com/aram-devdocs/GoudEngine/issues)
 
-TypeScript bindings for GoudEngine with two targets: Node.js desktop (via napi-rs)
-and web browser (via wasm-bindgen). Published as `goudengine` on npm.
+TypeScript bindings for GoudEngine with two targets: Node.js desktop (napi-rs) and web browser (wasm-bindgen).
 
 ## Installation
 
@@ -13,17 +12,17 @@ and web browser (via wasm-bindgen). Published as `goudengine` on npm.
 npm install goudengine
 ```
 
-## Usage
+## Quick Start
 
-### Node.js (Desktop)
+### Node.js
 
 ```typescript
-import { GoudGame, Color, Transform2D } from "goudengine";
+import { GoudGame } from "goudengine";
 
 const game = new GoudGame(800, 600, "My Game");
 
-while (game.isRunning()) {
-  const dt = game.beginFrame();
+while (!game.shouldClose()) {
+  game.beginFrame(0.2, 0.2, 0.2, 1.0);
   // game logic here
   game.endFrame();
 }
@@ -31,306 +30,42 @@ while (game.isRunning()) {
 game.destroy();
 ```
 
-### Web (Browser)
+### Web
 
 ```typescript
-import { GoudGame, Color, Transform2D } from "goudengine/web";
+import { GoudGame } from "goudengine/web";
 
 const game = await GoudGame.create(800, 600, "My Game");
 // same API as Node
 ```
 
-## Networking
-
-Networking wrappers are available in both the Node and web builds.
-
-- `goudengine/node`: host + client
-- `goudengine/web`: WebSocket client only
-
-Use `new NetworkManager(gameOrContext)` with `GoudGame` or `GoudContext`. `host()` and `connect()` return `NetworkEndpoint`. `connect()` stores the default peer ID, so clients can call `send(...)`. Host endpoints reply with `sendTo(...)`.
-
-```typescript
-import { GoudContext, NetworkManager, NetworkProtocol } from "goudengine/node";
-
-const hostContext = new GoudContext();
-const clientContext = new GoudContext();
-
-const host = new NetworkManager(hostContext).host(NetworkProtocol.Tcp, 9000);
-const client = new NetworkManager(clientContext).connect(
-  NetworkProtocol.Tcp,
-  "127.0.0.1",
-  9000,
-);
-
-client.send(Buffer.from("ping"));
-
-while (true) {
-  host.poll();
-  client.poll();
-
-  const packet = host.receive();
-  if (!packet) {
-    continue;
-  }
-
-  host.sendTo(packet.peerId, Buffer.from("pong"));
-  break;
-}
-```
-
-Browser note:
-
-- On `goudengine/web`, use `NetworkProtocol.WebSocket`.
-- Browser hosting is not supported.
-- `connect()` returns before the socket is fully open, so poll until `peerCount() > 0` before sending.
-
-Example:
-
-```typescript
-import { GoudGame, NetworkManager, NetworkProtocol } from "goudengine/web";
-
-const game = await GoudGame.create({ width: 800, height: 600, title: "Web Net" });
-const endpoint = new NetworkManager(game).connect(
-  NetworkProtocol.WebSocket,
-  "ws://127.0.0.1:9001",
-  9001,
-);
-```
-
-Browser-specific limitations and workarounds are documented in the Web Platform Gotchas guide:
-[`docs/src/guides/web-platform-gotchas.md`](../../docs/src/guides/web-platform-gotchas.md).
-
-## Debugger Runtime
+## Documentation
 
-The debugger runtime is available on the desktop Node target. Enable it through `GoudContext` config, then use the raw JSON accessors or the thin parsed helpers from `goudengine/node`.
+See the [Getting Started guide](../../docs/src/getting-started/typescript.md) for installation, Node vs Web differences, sprites, input, and examples.
 
-```typescript
-import {
-  GoudContext,
-  parseDebuggerSnapshot,
-} from "goudengine/node";
-
-const ctx = new GoudContext({
-  debugger: {
-    enabled: true,
-    publishLocalAttach: true,
-    routeLabel: "ts-demo",
-  },
-});
-
-ctx.setDebuggerProfilingEnabled(true);
-
-const snapshot = parseDebuggerSnapshot(ctx);
-const manifestJson = ctx.getDebuggerManifestJson();
-const memory = ctx.getMemorySummary();
-
-ctx.setDebuggerSelectedEntity(42);
-ctx.clearDebuggerSelectedEntity();
-ctx.destroy();
-```
-
-The Node target also exposes pause, step, time-scale, debug-draw, input injection, capture, replay, and metrics methods on `GoudGame` and `GoudContext`. Capture, replay, and metrics stay Rust-owned and come back as raw artifact envelopes instead of TypeScript-specific debugger models.
-
-`goudengine/web` does not expose the debugger runtime in this batch. The browser build throws an explicit unsupported error for these methods instead of silently no-oping.
-
-See [`docs/src/guides/debugger-runtime.md`](../../docs/src/guides/debugger-runtime.md) for desktop-only scope, determinism limits, and the `goudengine-mcp` bridge workflow.
-
-## Features
-
-- 2D and 3D rendering with runtime renderer selection
-- Entity Component System (ECS) with Transform2D, Sprite, and more
-- Physics simulation (Rapier2D/3D): rigid bodies, colliders, raycasting, collision events
-- Audio playback with per-channel volume (Music, SFX, Ambience, UI, Voice) and spatial audio
-- Text rendering with TrueType/bitmap fonts, alignment, and word-wrapping
-- Sprite animation with state machine controller, multi-layer blending, and tweening
-- Scene management with transitions (instant, fade, custom)
-- UI component system with hierarchical node tree
-- Tiled map support for 2D worlds
-- Input handling (keyboard, mouse)
-- Dual targets: Node.js desktop (napi-rs) and web browser (wasm-bindgen)
-- Structured error diagnostics with error codes and recovery hints
-
-## Flappy Bird Example
-
-A condensed Node.js version showing the core patterns — game loop, physics, sprite rendering,
-and AABB collision. The web variant uses the same `game.ts` logic with a WASM-backed `GoudGame`.
-See the [full source](https://github.com/aram-devdocs/GoudEngine/tree/main/examples/typescript/flappy_bird)
-for the complete implementation including the web entry point.
-
-```typescript
-import { GoudGame } from "goudengine";
-
-const SCREEN_W = 288, SCREEN_H = 512;
-const GRAVITY = 9.8, JUMP_STRENGTH = -3.5;
-const PIPE_SPEED = 1.0, PIPE_SPAWN_INTERVAL = 1.5, PIPE_GAP = 100;
-const TARGET_FPS = 120;
-
-const game = new GoudGame({ width: SCREEN_W, height: SCREEN_H + 112, title: "Flappy Goud" });
-
-// Load textures — engine returns numeric handles
-const bgTex   = await game.loadTexture("assets/sprites/background-day.png");
-const pipeTex = await game.loadTexture("assets/sprites/pipe-green.png");
-const baseTex = await game.loadTexture("assets/sprites/base.png");
-const birdTex = [
-  await game.loadTexture("assets/sprites/bluebird-downflap.png"),
-  await game.loadTexture("assets/sprites/bluebird-midflap.png"),
-  await game.loadTexture("assets/sprites/bluebird-upflap.png"),
-];
-
-// Bird state
-let birdY = SCREEN_H / 2, velocity = 0;
-const birdX = SCREEN_W / 4;
-
-// Pipe state
-type Pipe = { x: number; gapY: number };
-let pipes: Pipe[] = [];
-let spawnTimer = 0;
-
-function reset() {
-  birdY = SCREEN_H / 2; velocity = 0; pipes = []; spawnTimer = 0;
-}
-
-function aabb(x1: number, y1: number, w1: number, h1: number,
-              x2: number, y2: number, w2: number, h2: number): boolean {
-  return x1 < x2 + w2 && x1 + w1 > x2 && y1 < y2 + h2 && y1 + h1 > y2;
-}
-
-while (!game.shouldClose()) {
-  game.beginFrame(0.4, 0.7, 0.9, 1.0);
-  const dt = game.deltaTime;
-
-  if (game.isKeyPressed(256)) { game.close(); break; }   // Escape
-  if (game.isKeyPressed(82))  { reset(); }                // R
-
-  // Bird physics
-  if (game.isKeyPressed(32) || game.isMouseButtonPressed(0))
-    velocity = JUMP_STRENGTH * TARGET_FPS;
-  velocity += GRAVITY * dt * TARGET_FPS;
-  birdY    += velocity * dt;
-
-  if (birdY + 24 > SCREEN_H || birdY < 0) { reset(); game.endFrame(); continue; }
-
-  // Pipe movement and collision
-  for (const p of pipes) {
-    p.x -= PIPE_SPEED * dt * TARGET_FPS;
-    const topY = p.gapY - PIPE_GAP - 320;
-    if (aabb(birdX, birdY, 34, 24, p.x, topY, 52, 320) ||
-        aabb(birdX, birdY, 34, 24, p.x, p.gapY + PIPE_GAP, 52, 320)) {
-      reset(); game.endFrame(); continue;
-    }
-  }
-  pipes = pipes.filter(p => p.x + 60 > 0);
-
-  spawnTimer += dt;
-  if (spawnTimer > PIPE_SPAWN_INTERVAL) {
-    spawnTimer = 0;
-    pipes.push({ x: SCREEN_W, gapY: PIPE_GAP + Math.random() * (SCREEN_H - 2 * PIPE_GAP) });
-  }
-
-  // Render — draw order sets depth
-  game.drawSprite(bgTex, 144, 256, 288, 512);
-  for (const p of pipes) {
-    const topY = p.gapY - PIPE_GAP - 320;
-    game.drawSprite(pipeTex, p.x + 26, topY + 160, 52, 320, Math.PI);
-    game.drawSprite(pipeTex, p.x + 26, p.gapY + PIPE_GAP + 160, 52, 320, 0);
-  }
-  game.drawSprite(birdTex[Math.floor(game.totalTime / 0.1) % 3], birdX + 17, birdY + 12, 34, 24);
-  game.drawSprite(baseTex, 168, SCREEN_H + 56, 336, 112);
-
-  game.endFrame();
-}
-
-game.destroy();
-```
-
-**Controls:** `Space` or left-click to flap, `R` to restart, `Escape` to quit.
-The web variant works the same way — import from `goudengine/web` and call `await GoudGame.create(...)`.
-
-## Web Platform Notes
-
-A few things to keep in mind when targeting the browser:
-
-- **Synchronous game loop callback** -- The `game.run()` callback must be
-  synchronous. Passing an `async` function triggers a console warning because
-  wasm-bindgen's `RefCell` borrow cannot be held across `await` points.
-- **Texture loading uses `fetch()`** -- `loadTexture(path)` calls `fetch()`
-  internally, so relative URLs resolve from the page's origin. Make sure your
-  asset paths are correct relative to your HTML file or use absolute URLs.
-- **`pause()` / `resume()`** -- You can pause the game loop without detaching
-  input handlers by calling `game.pause()`. Call `game.resume()` to restart.
-  `game.stop()` fully tears down the loop and input handlers.
-- **Tab visibility** -- `requestAnimationFrame` automatically pauses when the
-  browser tab is hidden. No extra handling is needed.
-- **Touch input** -- Touch events are automatically mapped to mouse button 0.
-  `touchstart` maps to `press_mouse_button(0)`, `touchend` maps to `release_mouse_button(0)`.
-- **More browser caveats** -- See the Web Platform Gotchas guide for async loop rules,
-  asset-loading caveats, and the current networking limitation on `goudengine/web`.
-
-## Node vs Web Targets
-
-The package uses conditional exports to select the right backend automatically:
-
-- **Node.js** -- Uses a native addon built with napi-rs. Calls the Rust engine
-  directly through N-API for near-native performance. Requires a `.node` binary
-  matching your platform.
-- **Web** -- Uses a WASM module built with wasm-bindgen. Runs in any modern
-  browser with WebAssembly support. Smaller binary, slightly lower performance.
-
-Both targets expose the same TypeScript API. Game code written against one target
-works on the other without changes.
-
-You can also import a specific target explicitly:
-
-```typescript
-import { GoudGame } from "goudengine/node";  // Force Node backend
-import { GoudGame } from "goudengine/web";   // Force Web backend
-```
-
-## Build from Source
-
-### Node.js native addon
-
-```bash
-cd sdks/typescript/native && npm run build
-```
-
-Or from the SDK root:
-
-```bash
-cd sdks/typescript
-npm run build:native    # Build napi-rs .node addon
-npm run build:ts        # Compile TypeScript sources
-npm run build           # Both of the above
-```
-
-### WASM module
-
-```bash
-cd sdks/typescript
-npm run build:web       # Build WASM + compile TS for web target
-npm run build:all       # Node + Web
-```
-
-### Tests
+## Testing
 
 ```bash
 cd sdks/typescript
 npm test                # node --test test/*.test.mjs
-npx c8 --reporter=text-summary npm test
 npm run typecheck       # tsc --noEmit for both targets
 ```
 
-The TypeScript SDK CI gate expects at least `80%` line coverage across the
-public SDK surface and publishes a Cobertura report from `c8`.
+Coverage gate: 80%+ line coverage for both Node and Web targets.
+
+## Platform Support
+
+| Target | Backend | Status |
+|--------|---------|--------|
+| Node.js | napi-rs native addon | Supported |
+| Web | wasm-bindgen WASM | Supported |
 
-## Codegen
+## Architecture
 
-Most source files under `native/src/` and `src/generated/` are auto-generated
-by the codegen pipeline. Files with a `.g.rs` or `.g.ts` suffix should not be
-edited by hand. Run `./codegen.sh` from the repository root to regenerate.
+This SDK is a thin wrapper -- all engine logic lives in Rust. Files with `.g.rs` or `.g.ts` suffix are auto-generated by the codegen pipeline. Do not hand-edit generated files. Run `./codegen.sh` to regenerate.
 
-## f64 vs f32
+## Links
 
-JavaScript `number` is always 64-bit. The Node SDK converts between `f64` (JS)
-and `f32` (Rust engine) at the napi boundary. The WASM target uses `f32` directly
-since wasm-bindgen supports it natively.
+- [Full documentation](../../docs/src/getting-started/typescript.md)
+- [Examples](https://github.com/aram-devdocs/GoudEngine/tree/main/examples/typescript)
+- [License: MIT](https://github.com/aram-devdocs/GoudEngine/blob/main/LICENSE)

package/dist/generated/index.g.d.ts

@@ -1,4 +1,4 @@
-export { GoudGame, GoudContext, EngineConfig, UiManager, PhysicsWorld2D, PhysicsWorld3D, Color, Vec2, Vec3, Key, MouseButton, PhysicsBackend2D } from './node/index.g.js';
+export { GoudGame, GoudContext, EngineConfig, UiManager, PhysicsWorld2D, PhysicsWorld3D, Color, Vec2, Vec3, Key, MouseButton, PhysicsBackend2D, RenderBackendKind, WindowBackendKind } from './node/index.g.js';
 export type { IGoudGame, IEngineConfig, IUiManager, IUiStyle, IUiEvent, UiNodeId, IPhysicsWorld2D, IPhysicsWorld3D, IEntity, IColor, IVec2, ITransform2DData, ISpriteData, IRenderStats, IContact, IFpsStats, IDebuggerConfig, IContextConfig, IMemoryCategoryStats, IMemorySummary, IPhysicsRaycastHit2D, IPhysicsCollisionEvent2D, IAnimationEventData, IRenderCapabilities, IPhysicsCapabilities, IAudioCapabilities, IInputCapabilities, INetworkCapabilities, INetworkStats, INetworkSimulationConfig } from './types/engine.g.js';
 export type { IGoudContext, INetworkConnectResult, INetworkPacket } from './node/index.g.js';
 export type { Rect } from './types/math.g.js';

package/dist/generated/index.g.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.g.d.ts","sourceRoot":"","sources":["../../src/generated/index.g.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,cAAc,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1K,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,eAAe,EAAE,cAAc,EAAE,oBAAoB,EAAE,cAAc,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,aAAa,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AACxgB,YAAY,EAAE,YAAY,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC7F,YAAY,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,eAAe,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACzM,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.g.d.ts","sourceRoot":"","sources":["../../src/generated/index.g.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,cAAc,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,WAAW,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAChN,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,eAAe,EAAE,cAAc,EAAE,oBAAoB,EAAE,cAAc,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,aAAa,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AACxgB,YAAY,EAAE,YAAY,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC7F,YAAY,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,eAAe,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACzM,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/generated/index.g.js

@@ -1,7 +1,7 @@
 "use strict";
 // This file is AUTO-GENERATED by GoudEngine codegen. DO NOT EDIT.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiagnosticMode = exports.RecoveryClass = exports.GoudInternalError = exports.GoudProviderError = exports.GoudSystemError = exports.GoudInputError = exports.GoudEntityError = exports.GoudGraphicsError = exports.GoudResourceError = exports.GoudContextError = exports.GoudError = exports.PhysicsBackend2D = exports.MouseButton = exports.Key = exports.Vec3 = exports.Vec2 = exports.Color = exports.PhysicsWorld3D = exports.PhysicsWorld2D = exports.UiManager = exports.EngineConfig = exports.GoudContext = exports.GoudGame = void 0;
+exports.DiagnosticMode = exports.RecoveryClass = exports.GoudInternalError = exports.GoudProviderError = exports.GoudSystemError = exports.GoudInputError = exports.GoudEntityError = exports.GoudGraphicsError = exports.GoudResourceError = exports.GoudContextError = exports.GoudError = exports.WindowBackendKind = exports.RenderBackendKind = exports.PhysicsBackend2D = exports.MouseButton = exports.Key = exports.Vec3 = exports.Vec2 = exports.Color = exports.PhysicsWorld3D = exports.PhysicsWorld2D = exports.UiManager = exports.EngineConfig = exports.GoudContext = exports.GoudGame = void 0;
 var index_g_js_1 = require("./node/index.g.js");
 Object.defineProperty(exports, "GoudGame", { enumerable: true, get: function () { return index_g_js_1.GoudGame; } });
 Object.defineProperty(exports, "GoudContext", { enumerable: true, get: function () { return index_g_js_1.GoudContext; } });
@@ -15,6 +15,8 @@ Object.defineProperty(exports, "Vec3", { enumerable: true, get: function () { re
 Object.defineProperty(exports, "Key", { enumerable: true, get: function () { return index_g_js_1.Key; } });
 Object.defineProperty(exports, "MouseButton", { enumerable: true, get: function () { return index_g_js_1.MouseButton; } });
 Object.defineProperty(exports, "PhysicsBackend2D", { enumerable: true, get: function () { return index_g_js_1.PhysicsBackend2D; } });
+Object.defineProperty(exports, "RenderBackendKind", { enumerable: true, get: function () { return index_g_js_1.RenderBackendKind; } });
+Object.defineProperty(exports, "WindowBackendKind", { enumerable: true, get: function () { return index_g_js_1.WindowBackendKind; } });
 var errors_g_js_1 = require("./errors.g.js");
 Object.defineProperty(exports, "GoudError", { enumerable: true, get: function () { return errors_g_js_1.GoudError; } });
 Object.defineProperty(exports, "GoudContextError", { enumerable: true, get: function () { return errors_g_js_1.GoudContextError; } });

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

@@ -1 +1 @@
-{"version":3,"file":"index.g.js","sourceRoot":"","sources":["../../src/generated/index.g.ts"],"names":[],"mappings":";AAAA,kEAAkE;;;AAElE,gDAA0K;AAAjK,sGAAA,QAAQ,OAAA;AAAE,yGAAA,WAAW,OAAA;AAAE,0GAAA,YAAY,OAAA;AAAE,uGAAA,SAAS,OAAA;AAAE,4GAAA,cAAc,OAAA;AAAE,4GAAA,cAAc,OAAA;AAAE,mGAAA,KAAK,OAAA;AAAE,kGAAA,IAAI,OAAA;AAAE,kGAAA,IAAI,OAAA;AAAE,iGAAA,GAAG,OAAA;AAAE,yGAAA,WAAW,OAAA;AAAE,8GAAA,gBAAgB,OAAA;AAI9I,6CAAyM;AAAhM,wGAAA,SAAS,OAAA;AAAE,+GAAA,gBAAgB,OAAA;AAAE,gHAAA,iBAAiB,OAAA;AAAE,gHAAA,iBAAiB,OAAA;AAAE,8GAAA,eAAe,OAAA;AAAE,6GAAA,cAAc,OAAA;AAAE,8GAAA,eAAe,OAAA;AAAE,gHAAA,iBAAiB,OAAA;AAAE,gHAAA,iBAAiB,OAAA;AAAE,4GAAA,aAAa,OAAA;AACjL,qDAAmD;AAA1C,iHAAA,cAAc,OAAA"}
+{"version":3,"file":"index.g.js","sourceRoot":"","sources":["../../src/generated/index.g.ts"],"names":[],"mappings":";AAAA,kEAAkE;;;AAElE,gDAAgN;AAAvM,sGAAA,QAAQ,OAAA;AAAE,yGAAA,WAAW,OAAA;AAAE,0GAAA,YAAY,OAAA;AAAE,uGAAA,SAAS,OAAA;AAAE,4GAAA,cAAc,OAAA;AAAE,4GAAA,cAAc,OAAA;AAAE,mGAAA,KAAK,OAAA;AAAE,kGAAA,IAAI,OAAA;AAAE,kGAAA,IAAI,OAAA;AAAE,iGAAA,GAAG,OAAA;AAAE,yGAAA,WAAW,OAAA;AAAE,8GAAA,gBAAgB,OAAA;AAAE,+GAAA,iBAAiB,OAAA;AAAE,+GAAA,iBAAiB,OAAA;AAIpL,6CAAyM;AAAhM,wGAAA,SAAS,OAAA;AAAE,+GAAA,gBAAgB,OAAA;AAAE,gHAAA,iBAAiB,OAAA;AAAE,gHAAA,iBAAiB,OAAA;AAAE,8GAAA,eAAe,OAAA;AAAE,6GAAA,cAAc,OAAA;AAAE,8GAAA,eAAe,OAAA;AAAE,gHAAA,iBAAiB,OAAA;AAAE,gHAAA,iBAAiB,OAAA;AAAE,4GAAA,aAAa,OAAA;AACjL,qDAAmD;AAA1C,iHAAA,cAAc,OAAA"}

package/dist/generated/node/index.g.d.ts

@@ -1,8 +1,8 @@
-import type { IGoudGame, IUiManager, IUiStyle, IUiEvent, UiNodeId, IEntity, IColor, IVec2, IVec3, ITransform2DData, ISpriteData, IRenderStats, IContact, IFpsStats, IDebuggerConfig, IContextConfig, IMemorySummary, IDebuggerCapture, IDebuggerReplayArtifact, IPhysicsRaycastHit2D, IPhysicsCollisionEvent2D, IAnimationEventData, IPreloadOptions, IRenderCapabilities, IPhysicsCapabilities, IAudioCapabilities, IInputCapabilities, INetworkCapabilities, INetworkStats, INetworkSimulationConfig, IPhysicsWorld2D, IPhysicsWorld3D, PreloadAssetInput } from '../types/engine.g.js';
-import { PhysicsBackend2D } from '../types/input.g.js';
+import type { IGoudGame, IUiManager, IUiStyle, IUiEvent, UiNodeId, IEntity, IColor, IVec2, IVec3, ITransform2DData, ISpriteData, IRenderStats, IContact, IFpsStats, IRenderMetrics, IDebuggerConfig, IContextConfig, IMemorySummary, IDebuggerCapture, IDebuggerReplayArtifact, IPhysicsRaycastHit2D, IPhysicsCollisionEvent2D, IAnimationEventData, IPreloadOptions, IRenderCapabilities, IPhysicsCapabilities, IAudioCapabilities, IInputCapabilities, INetworkCapabilities, INetworkStats, INetworkSimulationConfig, IPhysicsWorld2D, IPhysicsWorld3D, IP2pMeshConfig, IRollbackConfig, PreloadAssetInput, ISpriteCmd, ITextCmd } from '../types/engine.g.js';
+import { PhysicsBackend2D, RenderBackendKind, WindowBackendKind } from '../types/input.g.js';
 export { Color, Vec2, Vec3 } from '../types/math.g.js';
-export { Key, MouseButton, PhysicsBackend2D } from '../types/input.g.js';
-export type { IGoudGame, IUiManager, IUiStyle, IUiEvent, UiNodeId, IEntity, IColor, IVec2, IVec3, ITransform2DData, ISpriteData, IRenderStats, IContact, IFpsStats, IDebuggerConfig, IContextConfig, IMemoryCategoryStats, IMemorySummary, IDebuggerCapture, IDebuggerReplayArtifact, IPhysicsRaycastHit2D, IPhysicsCollisionEvent2D, IAnimationEventData, IRenderCapabilities, IPhysicsCapabilities, IAudioCapabilities, IInputCapabilities, INetworkCapabilities, INetworkStats, INetworkSimulationConfig, IPhysicsWorld2D, IPhysicsWorld3D } from '../types/engine.g.js';
+export { Key, MouseButton, PhysicsBackend2D, RenderBackendKind, WindowBackendKind } from '../types/input.g.js';
+export type { IGoudGame, IUiManager, IUiStyle, IUiEvent, UiNodeId, IEntity, IColor, IVec2, IVec3, ITransform2DData, ISpriteData, IRenderStats, IContact, IFpsStats, IRenderMetrics, IDebuggerConfig, IContextConfig, IMemoryCategoryStats, IMemorySummary, IDebuggerCapture, IDebuggerReplayArtifact, IPhysicsRaycastHit2D, IPhysicsCollisionEvent2D, IAnimationEventData, IRenderCapabilities, IPhysicsCapabilities, IAudioCapabilities, IInputCapabilities, INetworkCapabilities, INetworkStats, INetworkSimulationConfig, IPhysicsWorld2D, IPhysicsWorld3D, IP2pMeshConfig, IRollbackConfig } from '../types/engine.g.js';
 export interface INetworkConnectResult {
     handle: number;
     peerId: number;
@@ -83,10 +83,14 @@ export declare class GoudGame implements IGoudGame {
     get totalTime(): number;
     /** Number of frames processed */
     get frameCount(): number;
+    /** Interpolation alpha for render smoothing between fixed timesteps (0.0 to 1.0) */
+    get interpolationAlpha(): number;
     /** Returns true if the window close has been requested */
     shouldClose(): boolean;
     /** Signals the window to close */
     close(): void;
+    /** Requests a logical resize on the active native window */
+    setWindowSize(width: number, height: number): boolean;
     /** Releases all engine resources */
     destroy(): void;
     /** Starts a new render frame with the given clear color */
@@ -95,6 +99,12 @@ export declare class GoudGame implements IGoudGame {
     endFrame(): void;
     /** Runs the game loop. Calls the update callback each frame with delta time. Blocks until the window is closed. */
     run(update: (dt: number) => void): void;
+    /** Runs the game loop with a fixed timestep. fixedUpdate runs at the configured fixed rate, update runs once per visual frame. */
+    runWithFixedUpdate(fixedUpdate: (dt: number) => void, update: (dt: number) => void): void;
+    /** Sets the fixed timestep step size in seconds. Pass 0 to disable. */
+    setFixedTimestep(stepSize: number): void;
+    /** Sets the maximum fixed steps per frame to prevent spiral of death. */
+    setMaxFixedSteps(maxSteps: number): void;
     /** Loads a texture from a file path and returns its handle */
     loadTexture(path: string): Promise<number>;
     /** Destroys a previously loaded texture */
@@ -105,7 +115,11 @@ export declare class GoudGame implements IGoudGame {
     destroyFont(handle: number): boolean;
     /** Draws text using a loaded font */
     drawText(fontHandle: number, text: string, x: number, y: number, fontSize?: number, alignment?: number, maxWidth?: number, lineSpacing?: number, direction?: number, color?: IColor): boolean;
-    /** Draws a textured sprite */
+    /** Set the coordinate origin for subsequent DrawQuad and DrawSprite calls. Center (0) means (x,y) is the center of the shape (default). TopLeft (1) means (x,y) is the top-left corner. */
+    setCoordinateOrigin(origin: number): boolean;
+    /** Get the current coordinate origin setting. Returns 0 for Center, 1 for TopLeft. */
+    getCoordinateOrigin(): number;
+    /** Draws a textured sprite. Position (x,y) interpretation depends on the coordinate origin setting (center by default). */
     drawSprite(texture: number, x: number, y: number, width: number, height: number, rotation?: number, color?: IColor): void;
     /** Draws a colored rectangle */
     drawQuad(x: number, y: number, width: number, height: number, color?: IColor): void;
@@ -219,8 +233,44 @@ export declare class GoudGame implements IGoudGame {
     setFogEnabled(enabled: boolean): boolean;
     /** Renders all 3D objects */
     render3D(): boolean;
+    /** Creates a 3D material */
+    createMaterial(materialType: number, r: number, g: number, b: number, a: number, shininess: number, metallic: number, roughness: number, ao: number): number;
+    /** Updates a 3D material */
+    updateMaterial(materialId: number, materialType: number, r: number, g: number, b: number, a: number, shininess: number, metallic: number, roughness: number, ao: number): boolean;
+    /** Removes a 3D material */
+    removeMaterial(materialId: number): boolean;
+    /** Binds a material to an object */
+    setObjectMaterial(objectId: number, materialId: number): boolean;
+    /** Gets the material ID bound to an object */
+    getObjectMaterial(objectId: number): number;
+    /** Creates a skinned mesh from raw vertex data */
+    createSkinnedMesh(verticesPtr: number, vertexCount: number): number;
+    /** Removes a skinned mesh */
+    removeSkinnedMesh(meshId: number): boolean;
+    /** Sets the position of a skinned mesh */
+    setSkinnedMeshPosition(meshId: number, x: number, y: number, z: number): boolean;
+    /** Sets the rotation of a skinned mesh */
+    setSkinnedMeshRotation(meshId: number, x: number, y: number, z: number): boolean;
+    /** Sets the scale of a skinned mesh */
+    setSkinnedMeshScale(meshId: number, x: number, y: number, z: number): boolean;
+    /** Updates bone matrices for a skinned mesh */
+    setSkinnedMeshBones(meshId: number, matricesPtr: number, boneCount: number): boolean;
+    /** Adds a bloom pass to the post-processing pipeline */
+    addBloomPass(threshold: number, intensity: number): number;
+    /** Adds a Gaussian blur pass */
+    addBlurPass(radius: number): number;
+    /** Adds a color grading pass */
+    addColorGradePass(exposure: number, contrast: number, saturation: number): number;
+    /** Removes a post-processing pass by index */
+    removePostprocessPass(index: number): boolean;
+    /** Returns the number of post-processing passes */
+    postprocessPassCount(): number;
     /** Draws a sprite with source rectangle for sprite sheets */
-    drawSpriteRect(texture: number, x: number, y: number, width: number, height: number, rotation: number, srcX: number, srcY: number, srcW: number, srcH: number, color?: IColor): boolean;
+    drawSpriteRect(texture: number, x: number, y: number, width: number, height: number, rotation: number, srcX: number, srcY: number, srcW: number, srcH: number, color?: IColor, srcMode?: number): boolean;
+    /** Draws a batch of sprites in a single GPU pass for high performance */
+    drawSpriteBatch(cmds: ISpriteCmd[]): number;
+    /** Draws a batch of text labels in a single pass for high performance */
+    drawTextBatch(cmds: ITextCmd[]): number;
     /** Sets the rendering viewport */
     setViewport(x: number, y: number, width: number, height: number): void;
     /** Enables depth testing */
@@ -235,6 +285,8 @@ export declare class GoudGame implements IGoudGame {
     getRenderStats(): IRenderStats;
     /** Returns FPS statistics from the debug overlay rolling window */
     getFpsStats(): IFpsStats;
+    /** Returns per-frame render metrics including draw calls, culling stats, batch efficiency, and timing */
+    getRenderMetrics(): IRenderMetrics;
     /** Enables or disables the FPS debug overlay */
     setFpsOverlayEnabled(enabled: boolean): void;
     /** Sets how often FPS statistics are recomputed */
@@ -317,6 +369,12 @@ export declare class GoudGame implements IGoudGame {
     physicsCollisionEventsRead(index: number): IPhysicsCollisionEvent2D | 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: number, userData: number): number;
+    /** Returns the number of entities with a specific component type */
+    componentCount(typeIdHash: number): number;
+    /** Gets entity IDs for all entities with a specific component type */
+    componentGetEntities(typeIdHash: number, outEntities: number, maxCount: number): number;
+    /** Gets entity IDs and data pointers for all entities with a specific component type */
+    componentGetAll(typeIdHash: number, outEntities: number, outDataPtrs: number, maxCount: number): number;
     /** Queries the render provider's capabilities */
     getRenderCapabilities(): IRenderCapabilities;
     /** Queries the physics provider's capabilities */
@@ -409,6 +467,50 @@ export declare class GoudGame implements IGoudGame {
     audioActivate(): number;
     /** 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(): boolean;
+    /** Creates a P2P mesh host on the given port using the specified transport. */
+    p2pCreateMesh(protocol: number, port: number, config: IP2pMeshConfig): number;
+    /** Joins an existing P2P mesh at the given address. */
+    p2pJoinMesh(protocol: number, address: string, port: number, config: IP2pMeshConfig): number;
+    /** Leaves the P2P mesh and destroys the network instance. */
+    p2pLeaveMesh(handle: number): number;
+    /** Returns the number of connected peers in the mesh. */
+    p2pGetPeers(handle: number): number;
+    /** Returns the host peer's ID, or 0 on error. */
+    p2pGetHost(handle: number): number;
+    /** Creates a new rollback netcode session. Returns a positive handle on success. */
+    rollbackCreate(config: IRollbackConfig, localPlayer: number, playerIds: Uint8Array, statePtr: number, advanceFn: number, hashFn: number, cloneFn: number, freeFn: number): number;
+    /** Destroys a rollback session and frees all associated resources. */
+    rollbackDestroy(handle: number): number;
+    /** Advances the rollback simulation by one frame with the given local input. */
+    rollbackAdvanceFrame(handle: number, input: Uint8Array): number;
+    /** Receives a confirmed remote input for a specific player and frame. */
+    rollbackReceiveRemoteInput(handle: number, playerId: number, frame: number, input: Uint8Array): number;
+    /** Returns 1 if a rollback is pending, 0 otherwise. */
+    rollbackShouldRollback(handle: number): number;
+    /** Performs rollback and resimulation. Returns the number of frames resimulated. */
+    rollbackResimulate(handle: number): number;
+    /** Returns the latest confirmed frame. */
+    rollbackConfirmedFrame(handle: number): number;
+    /** Returns the current simulation frame. */
+    rollbackCurrentFrame(handle: number): number;
+    /** Checks for desync at the given frame. Returns 0=in sync, 1=desync, 2=frame not available. */
+    rollbackCheckDesync(handle: number, remoteHash: number, frame: number): number;
+    /** Creates an RPC framework instance. */
+    rpcCreate(timeoutMs: number, maxPayload: number): number;
+    /** Destroys an RPC framework instance. */
+    rpcDestroy(handle: number): number;
+    /** Registers an RPC handler with the given direction constraint. */
+    rpcRegister(handle: number, rpcId: number, name: string, direction: number): number;
+    /** Initiates an RPC call to a peer. Returns the call ID via out parameter. */
+    rpcCall(handle: number, peerId: number, rpcId: number, payload: Uint8Array): number;
+    /** Advances the RPC framework: checks timeouts and processes pending calls. */
+    rpcPoll(handle: number, deltaSecs: number): number;
+    /** Feeds raw incoming data to the RPC framework for processing. */
+    rpcProcessIncoming(handle: number, peerId: number, data: Uint8Array): number;
+    /** Attempts to retrieve the response for a pending RPC call. */
+    rpcReceiveResponse(handle: number, callId: number): Uint8Array;
+    /** Drains outbound RPC messages and copies the next one into the caller's buffer. */
+    rpcDrainOne(handle: number): Uint8Array;
     preload(assets: PreloadAssetInput[], options?: IPreloadOptions): Promise<Record<string, number>>;
     loadScene(name: string, json: string): number;
     unloadScene(name: string): boolean;
@@ -600,8 +702,8 @@ export declare class EngineConfig implements IEngineConfig {
     setSize(width: number, height: number): EngineConfig;
     /** Enables or disables vertical sync */
     setVsync(enabled: boolean): EngineConfig;
-    /** Enables or disables fullscreen mode */
-    setFullscreen(enabled: boolean): EngineConfig;
+    /** Sets the fullscreen mode (0=Windowed, 1=Borderless, 2=Exclusive) */
+    setFullscreen(mode: number): EngineConfig;
     /** Sets the target frames per second */
     setTargetFps(fps: number): EngineConfig;
     /** Enables or disables the FPS debug overlay */
@@ -610,6 +712,10 @@ export declare class EngineConfig implements IEngineConfig {
     setPhysicsDebug(enabled: boolean): EngineConfig;
     /** Selects the 2D physics backend used by the built game */
     setPhysicsBackend2D(backend: PhysicsBackend2D): EngineConfig;
+    /** Selects the native render backend used by the built game */
+    setRenderBackend(backend: RenderBackendKind): EngineConfig;
+    /** Selects the native window backend used by the built game */
+    setWindowBackend(backend: WindowBackendKind): EngineConfig;
     /** Configures debugger runtime startup for the created game. */
     setDebugger(debuggerConfig: IDebuggerConfig): EngineConfig;
     /** Consumes the config and creates a windowed GoudGame instance */
@@ -650,6 +756,10 @@ export declare class UiManager implements IUiManager {
     setImageTexturePath(nodeId: UiNodeId, path: string): number;
     /** Sets or creates a slider widget and updates range/value/enabled */
     setSlider(nodeId: UiNodeId, min: number, max: number, value: number, enabled: boolean): number;
+    /** Set absolute screen-space position for a UI node. Switches the node to absolute positioning mode. */
+    setNodePosition(nodeId: UiNodeId, x: number, y: number): number;
+    /** Set visibility for a UI node. Hidden nodes are not rendered. */
+    setNodeVisible(nodeId: UiNodeId, visible: boolean): number;
     /** Returns the number of UI events captured in the latest update tick */
     eventCount(): number;
     /** Reads one captured UI event by index */