murow 0.0.70 → 0.0.71

package/dist/webgpu/types/spritesheet/spritesheet.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Spritesheet — manages sprite UV coordinates and GPU texture.
+ * Supports grid-based spritesheets and texture-packer JSON.
+ *
+ * Texture creation uses the raw GPUDevice (accessed via root.device)
+ * since TypeGPU's texture API is unstable and we need copyExternalImageToTexture.
+ */
+import type { SpritesheetHandle, SpriteUV } from 'murow/renderer/types';
+export interface GridSpritesheetConfig {
+    image: string;
+    frameWidth: number;
+    frameHeight: number;
+}
+export interface TexturePackerFrame {
+    frame: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+}
+export interface TexturePackerData {
+    frames: Record<string, TexturePackerFrame>;
+    meta: {
+        size: {
+            w: number;
+            h: number;
+        };
+    };
+}
+export interface SpritesheetConfig {
+    image: string;
+    frameWidth?: number;
+    frameHeight?: number;
+    data?: string;
+}
+export declare class Spritesheet implements SpritesheetHandle {
+    readonly id: number;
+    readonly frameCount: number;
+    readonly texture: GPUTexture;
+    readonly textureView: GPUTextureView;
+    readonly sampler: GPUSampler;
+    private uvs;
+    private _width;
+    private _height;
+    constructor(id: number, texture: GPUTexture, textureView: GPUTextureView, sampler: GPUSampler, uvs: SpriteUV[], width: number, height: number);
+    getUV(spriteIndex: number): SpriteUV;
+    get width(): number;
+    get height(): number;
+}
+export declare function computeGridUVs(imageWidth: number, imageHeight: number, frameWidth: number, frameHeight: number): SpriteUV[];
+export declare function computeTexturePackerUVs(data: TexturePackerData): SpriteUV[];
+export declare function loadImage(url: string): Promise<ImageBitmap>;
+export declare function createTextureFromBitmap(device: GPUDevice, bitmap: ImageBitmap): {
+    texture: GPUTexture;
+    view: GPUTextureView;
+};

package/dist/webgpu/types/spritesheet/spritesheet.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,30 +1,14 @@
 {
   "name": "murow",
-  "version": "0.0.70",
+  "version": "0.0.71",
   "description": "A lightweight TypeScript game engine for server-authoritative multiplayer games",
-  "main": "dist/core.js",
-  "module": "dist/core.esm.js",
-  "types": "dist/core.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/core.esm.js",
-      "require": "./dist/core.js",
-      "types": "./dist/core.d.ts"
-    },
-    "./core": {
-      "import": "./dist/core.esm.js",
-      "require": "./dist/core.js",
-      "types": "./dist/core.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "src"
-  ],
+  "types": "dist/types/index.d.ts",
+  "type": "module",
+  "sideEffects": false,
   "scripts": {
     "build": "npm run build:types && npm run build:js",
-    "build:js": "esbuild src/core/index.ts --bundle --outfile=dist/core.js --format=cjs --platform=neutral --minify && esbuild src/core/index.ts --bundle --outfile=dist/core.esm.js --format=esm --platform=neutral --minify",
-    "build:types": "tsc --project tsconfig.json",
+    "build:js": "bun run esbuild.config.ts",
+    "build:types": "tsc --emitDeclarationOnly --project tsconfig.json",
     "dev": "npm run build:js -- --watch",
     "prepublishOnly": "npm run build",
     "test": "bun test ./src"
@@ -41,14 +25,100 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/mococa/murow.git"
+    "url": "https://github.com/moureau-dev/murow.git"
   },
   "bugs": {
-    "url": "https://github.com/mococa/murow/issues"
+    "url": "https://github.com/moureau-dev/murow/issues"
   },
   "devDependencies": {
     "@types/bun": "^1.1.16",
     "esbuild": "^0.19.0",
     "typescript": "^5.0.0"
-  }
-}
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/esm/index.js"
+    },
+    "./core": {
+      "types": "./dist/types/core/index.d.ts",
+      "import": "./dist/esm/core/index.js",
+      "require": "./dist/cjs/core/index.js",
+      "default": "./dist/esm/core/index.js"
+    },
+    "./core/*": {
+      "types": "./dist/types/core/*/index.d.ts",
+      "import": "./dist/esm/core/*/index.js",
+      "require": "./dist/cjs/core/*/index.js"
+    },
+    "./ecs": {
+      "types": "./dist/types/ecs/index.d.ts",
+      "import": "./dist/esm/ecs/index.js",
+      "require": "./dist/cjs/ecs/index.js",
+      "default": "./dist/esm/ecs/index.js"
+    },
+    "./ecs/*": {
+      "types": "./dist/types/ecs/*.d.ts",
+      "import": "./dist/esm/ecs/*.js",
+      "require": "./dist/cjs/ecs/*.js"
+    },
+    "./game": {
+      "types": "./dist/types/game/index.d.ts",
+      "import": "./dist/esm/game/index.js",
+      "require": "./dist/cjs/game/index.js",
+      "default": "./dist/esm/game/index.js"
+    },
+    "./game/*": {
+      "types": "./dist/types/game/*.d.ts",
+      "import": "./dist/esm/game/*.js",
+      "require": "./dist/cjs/game/*.js"
+    },
+    "./net": {
+      "types": "./dist/types/net/index.d.ts",
+      "import": "./dist/esm/net/index.js",
+      "require": "./dist/cjs/net/index.js",
+      "default": "./dist/esm/net/index.js"
+    },
+    "./net/*": {
+      "types": "./dist/types/net/*.d.ts",
+      "import": "./dist/esm/net/*.js",
+      "require": "./dist/cjs/net/*.js"
+    },
+    "./protocol": {
+      "types": "./dist/types/protocol/index.d.ts",
+      "import": "./dist/esm/protocol/index.js",
+      "require": "./dist/cjs/protocol/index.js",
+      "default": "./dist/esm/protocol/index.js"
+    },
+    "./protocol/*": {
+      "types": "./dist/types/protocol/*.d.ts",
+      "import": "./dist/esm/protocol/*.js",
+      "require": "./dist/cjs/protocol/*.js"
+    },
+    "./renderer": {
+      "types": "./dist/types/renderer/index.d.ts",
+      "import": "./dist/esm/renderer/index.js",
+      "require": "./dist/cjs/renderer/index.js",
+      "default": "./dist/esm/renderer/index.js"
+    },
+    "./renderer/*": {
+      "types": "./dist/types/renderer/*.d.ts",
+      "import": "./dist/esm/renderer/*.js",
+      "require": "./dist/cjs/renderer/*.js"
+    },
+    "./webgpu": {
+      "types": "./dist/webgpu/types/index.d.ts",
+      "import": "./dist/webgpu/esm/index.js",
+      "require": "./dist/webgpu/cjs/index.js"
+    }
+  },
+  "optionalDependencies": {
+    "acorn": "^8.16.0",
+    "tinyest": "^0.3.1",
+    "tinyest-for-wgsl": "^0.3.2",
+    "typegpu": "^0.10.2"
+  },
+  "files": ["dist"]
+}

package/dist/core/binary-codec/binary-codec.js

@@ -1,354 +0,0 @@
-/**
- * Internal symbol used to cache computed schema byte size.
- */
-const SCHEMA_SIZE = Symbol("schemaSize");
-/**
- * Computes and caches the total byte size of a schema.
- * @param schema Binary schema definition
- */
-function getSchemaSize(schema) {
-    const cached = schema[SCHEMA_SIZE];
-    if (cached !== undefined)
-        return cached;
-    let size = 0;
-    for (const k of Object.keys(schema)) {
-        size += schema[k].size;
-    }
-    schema[SCHEMA_SIZE] = size;
-    return size;
-}
-/**
- * Base codec implementation.
- * Handles schema-driven encoding/decoding.
- */
-export class BaseBinaryCodec {
-    /**
-     * Encodes an object into a binary buffer using the given schema.
-     *
-     * Allocates a right-sized buffer per call.
-     * Safe for concurrent and re-entrant usage.
-     *
-     * @param schema Binary schema definition
-     * @param data Object to encode
-     * @returns A Uint8Array containing the encoded bytes
-     */
-    static encodeInto(schema, data) {
-        const size = getSchemaSize(schema);
-        const buffer = new ArrayBuffer(size);
-        const view = new DataView(buffer);
-        let o = 0;
-        for (const k of Object.keys(schema)) {
-            const f = schema[k];
-            f.write(view, o, data[k]);
-            o += f.size;
-        }
-        return new Uint8Array(buffer);
-    }
-    /**
-     * Decodes a binary buffer into a target object using the given schema.
-     *
-     * Validates buffer size before reading.
-     * Does not mutate shared state.
-     *
-     * @param schema Binary schema definition
-     * @param buf Buffer containing encoded data
-     * @param target Target object to mutate
-     * @returns The mutated target object
-     */
-    static decodeInto(schema, buf, target) {
-        const expectedSize = getSchemaSize(schema);
-        if (buf.byteLength < expectedSize) {
-            throw new RangeError(`Buffer too small: expected ${expectedSize} bytes, got ${buf.byteLength}`);
-        }
-        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-        let o = 0;
-        for (const k of Object.keys(schema)) {
-            const f = schema[k];
-            target[k] = f.read(view, o);
-            o += f.size;
-        }
-        return target;
-    }
-}
-/**
- * Built-in binary primitive field definitions for multiplayer games.
- */
-export class BinaryPrimitives {
-    /**
-     * String field with UTF-8 encoding and 2-byte length prefix.
-     * @param maxLength Maximum number of bytes allowed
-     */
-    static string(maxLength) {
-        return {
-            size: maxLength + 2,
-            write(dv, o, v) {
-                const encoder = new TextEncoder();
-                const bytes = encoder.encode(v);
-                if (bytes.length > maxLength)
-                    throw new RangeError(`String too long, max ${maxLength} bytes`);
-                dv.setUint16(o, bytes.length, false);
-                for (let i = 0; i < bytes.length; i++)
-                    dv.setUint8(o + 2 + i, bytes[i]);
-                for (let i = bytes.length; i < maxLength; i++)
-                    dv.setUint8(o + 2 + i, 0);
-            },
-            read(dv, o) {
-                const length = dv.getUint16(o, false);
-                const bytes = new Uint8Array(length);
-                for (let i = 0; i < length; i++)
-                    bytes[i] = dv.getUint8(o + 2 + i);
-                return new TextDecoder().decode(bytes);
-            },
-            toNil: () => "",
-        };
-    }
-}
-/** Unsigned 8-bit integer */
-BinaryPrimitives.u8 = {
-    size: 1,
-    write: (dv, o, v) => dv.setUint8(o, v),
-    read: (dv, o) => dv.getUint8(o),
-    toNil: () => 0,
-};
-/** Unsigned 16-bit integer (big-endian) */
-BinaryPrimitives.u16 = {
-    size: 2,
-    write: (dv, o, v) => dv.setUint16(o, v, false),
-    read: (dv, o) => dv.getUint16(o, false),
-    toNil: () => 0,
-};
-/** Unsigned 32-bit integer (big-endian) */
-BinaryPrimitives.u32 = {
-    size: 4,
-    write: (dv, o, v) => dv.setUint32(o, v, false),
-    read: (dv, o) => dv.getUint32(o, false),
-    toNil: () => 0,
-};
-/** Signed 8-bit integer */
-BinaryPrimitives.i8 = {
-    size: 1,
-    write: (dv, o, v) => dv.setInt8(o, v),
-    read: (dv, o) => dv.getInt8(o),
-    toNil: () => 0,
-};
-/** Signed 16-bit integer (big-endian) */
-BinaryPrimitives.i16 = {
-    size: 2,
-    write: (dv, o, v) => dv.setInt16(o, v, false),
-    read: (dv, o) => dv.getInt16(o, false),
-    toNil: () => 0,
-};
-/** Signed 32-bit integer (big-endian) */
-BinaryPrimitives.i32 = {
-    size: 4,
-    write: (dv, o, v) => dv.setInt32(o, v, false),
-    read: (dv, o) => dv.getInt32(o, false),
-    toNil: () => 0,
-};
-/** 32-bit floating point number (IEEE 754, big-endian) */
-BinaryPrimitives.f32 = {
-    size: 4,
-    write: (dv, o, v) => dv.setFloat32(o, v, false),
-    read: (dv, o) => dv.getFloat32(o, false),
-    toNil: () => 0,
-};
-/** 64-bit floating point number (double, big-endian) */
-BinaryPrimitives.f64 = {
-    size: 8,
-    write: (dv, o, v) => dv.setFloat64(o, v, false),
-    read: (dv, o) => dv.getFloat64(o, false),
-    toNil: () => 0,
-};
-/** Boolean stored as 1 byte (0 = false, 1 = true) */
-BinaryPrimitives.bool = {
-    size: 1,
-    write: (dv, o, v) => dv.setUint8(o, v ? 1 : 0),
-    read: (dv, o) => dv.getUint8(o) !== 0,
-    toNil: () => false,
-};
-/** 2D vector of f32 (x, y) */
-BinaryPrimitives.vec2 = {
-    size: 8,
-    write(dv, o, v) {
-        dv.setFloat32(o, v.x, false);
-        dv.setFloat32(o + 4, v.y, false);
-    },
-    read(dv, o) {
-        return { x: dv.getFloat32(o, false), y: dv.getFloat32(o + 4, false) };
-    },
-    toNil: () => ({ x: 0, y: 0 }),
-};
-/** 3D vector of f32 (x, y, z) */
-BinaryPrimitives.vec3 = {
-    size: 12,
-    write(dv, o, v) {
-        dv.setFloat32(o, v.x, false);
-        dv.setFloat32(o + 4, v.y, false);
-        dv.setFloat32(o + 8, v.z, false);
-    },
-    read(dv, o) {
-        return {
-            x: dv.getFloat32(o, false),
-            y: dv.getFloat32(o + 4, false),
-            z: dv.getFloat32(o + 8, false),
-        };
-    },
-    toNil: () => ({ x: 0, y: 0, z: 0 }),
-};
-/** RGBA color packed as 4 u8 bytes */
-BinaryPrimitives.color = {
-    size: 4,
-    write(dv, o, v) {
-        dv.setUint8(o, v.r);
-        dv.setUint8(o + 1, v.g);
-        dv.setUint8(o + 2, v.b);
-        dv.setUint8(o + 3, v.a);
-    },
-    read(dv, o) {
-        return {
-            r: dv.getUint8(o),
-            g: dv.getUint8(o + 1),
-            b: dv.getUint8(o + 2),
-            a: dv.getUint8(o + 3),
-        };
-    },
-    toNil: () => ({ r: 0, g: 0, b: 0, a: 0 }),
-};
-/** 32-bit floating point number (IEEE 754, little-endian) */
-BinaryPrimitives.f32_le = {
-    size: 4,
-    write: (dv, o, v) => dv.setFloat32(o, v, true),
-    read: (dv, o) => dv.getFloat32(o, true),
-    toNil: () => 0,
-};
-/** 64-bit floating point number (double, little-endian) */
-BinaryPrimitives.f64_le = {
-    size: 8,
-    write: (dv, o, v) => dv.setFloat64(o, v, true),
-    read: (dv, o) => dv.getFloat64(o, true),
-    toNil: () => 0,
-};
-/** Unsigned 16-bit integer (little-endian) */
-BinaryPrimitives.u16_le = {
-    size: 2,
-    write: (dv, o, v) => dv.setUint16(o, v, true),
-    read: (dv, o) => dv.getUint16(o, true),
-    toNil: () => 0,
-};
-/** Unsigned 32-bit integer (little-endian) */
-BinaryPrimitives.u32_le = {
-    size: 4,
-    write: (dv, o, v) => dv.setUint32(o, v, true),
-    read: (dv, o) => dv.getUint32(o, true),
-    toNil: () => 0,
-};
-/** Signed 16-bit integer (little-endian) */
-BinaryPrimitives.i16_le = {
-    size: 2,
-    write: (dv, o, v) => dv.setInt16(o, v, true),
-    read: (dv, o) => dv.getInt16(o, true),
-    toNil: () => 0,
-};
-/** Signed 32-bit integer (little-endian) */
-BinaryPrimitives.i32_le = {
-    size: 4,
-    write: (dv, o, v) => dv.setInt32(o, v, true),
-    read: (dv, o) => dv.getInt32(o, true),
-    toNil: () => 0,
-};
-/**
- * 2D vector of f32 stored as a tuple [x, y] (little-endian).
- * Useful for compact math data or shader-friendly layouts.
- */
-BinaryPrimitives.vec2_le = {
-    size: 8,
-    write: (dv, o, v) => {
-        dv.setFloat32(o, v[0], true);
-        dv.setFloat32(o + 4, v[1], true);
-    },
-    read: (dv, o) => [
-        dv.getFloat32(o, true),
-        dv.getFloat32(o + 4, true),
-    ],
-    toNil: () => [0, 0],
-};
-/**
- * 3D vector of f32 stored as a tuple [x, y, z] (little-endian).
- * Commonly used for positions, velocities, or directions.
- */
-BinaryPrimitives.vec3_le = {
-    size: 12,
-    write: (dv, o, v) => {
-        dv.setFloat32(o, v[0], true);
-        dv.setFloat32(o + 4, v[1], true);
-        dv.setFloat32(o + 8, v[2], true);
-    },
-    read: (dv, o) => [
-        dv.getFloat32(o, true),
-        dv.getFloat32(o + 4, true),
-        dv.getFloat32(o + 8, true),
-    ],
-    toNil: () => [0, 0, 0],
-};
-/**
- * 4D vector of f32 stored as a tuple [x, y, z, w] (little-endian).
- * Useful for quaternions, colors in shaders, or homogeneous coordinates.
- */
-BinaryPrimitives.vec4_le = {
-    size: 16,
-    write: (dv, o, v) => {
-        dv.setFloat32(o, v[0], true);
-        dv.setFloat32(o + 4, v[1], true);
-        dv.setFloat32(o + 8, v[2], true);
-        dv.setFloat32(o + 12, v[3], true);
-    },
-    read: (dv, o) => [
-        dv.getFloat32(o, true),
-        dv.getFloat32(o + 4, true),
-        dv.getFloat32(o + 8, true),
-        dv.getFloat32(o + 12, true),
-    ],
-    toNil: () => [0, 0, 0, 0],
-};
-/**
- * Public codec API.
- * Re-exports primitives and exposes encode/decode helpers.
- */
-export class BinaryCodec extends BaseBinaryCodec {
-    /**
-     * Encodes an object into a binary buffer.
-     */
-    static encode(schema, data) {
-        return this.encodeInto(schema, data);
-    }
-    /**
-     * Decodes a binary buffer into an existing object.
-     */
-    static decode(schema, buf, target) {
-        return this.decodeInto(schema, buf, target);
-    }
-}
-/** Unsigned 8-bit integer field */
-BinaryCodec.u8 = BinaryPrimitives.u8;
-/** Unsigned 16-bit integer field */
-BinaryCodec.u16 = BinaryPrimitives.u16;
-/** Unsigned 32-bit integer field */
-BinaryCodec.u32 = BinaryPrimitives.u32;
-/** Signed 8-bit integer field */
-BinaryCodec.i8 = BinaryPrimitives.i8;
-/** Signed 16-bit integer field */
-BinaryCodec.i16 = BinaryPrimitives.i16;
-/** Signed 32-bit integer field */
-BinaryCodec.i32 = BinaryPrimitives.i32;
-/** 32-bit floating point field */
-BinaryCodec.f32 = BinaryPrimitives.f32;
-/** Boolean field */
-BinaryCodec.bool = BinaryPrimitives.bool;
-/** String field with length prefix */
-BinaryCodec.string = BinaryPrimitives.string;
-/** 2D vector field */
-BinaryCodec.vec2 = BinaryPrimitives.vec2;
-/** 3D vector field */
-BinaryCodec.vec3 = BinaryPrimitives.vec3;
-/** RGBA color field */
-BinaryCodec.color = BinaryPrimitives.color;

package/dist/core/binary-codec/index.js

@@ -1 +0,0 @@
-export * from './binary-codec';

package/dist/core/driver/driver.js

@@ -1,47 +0,0 @@
-import { ImmediateDriver, RafDriver, TimeoutDriver } from "./drivers";
-// Re-export driver classes for testing and direct usage
-export { ImmediateDriver, RafDriver, TimeoutDriver };
-/**
- * Factory function to create a loop driver for the specified environment.
- *
- * @param type - The environment type
- *   - `'client'`: Browser RAF driver (60 FPS, syncs with display)
- *   - `'server'`: Node.js setImmediate driver (maximum performance)
- *   - `'server-timeout'`: Node.js setTimeout driver (balanced with I/O)
- * @param update - Callback function invoked each frame with delta time in seconds
- * @returns A configured LoopDriver instance ready to start
- *
- * @example
- * ```typescript
- * // Client
- * const clientDriver = createDriver('client', (dt) => {
- *   game.update(dt);
- *   renderer.render();
- * });
- * clientDriver.start();
- *
- * // Server (maximum performance)
- * const serverDriver = createDriver('server', (dt) => {
- *   simulation.tick(dt);
- * });
- * serverDriver.start();
- *
- * // Server (balanced with I/O)
- * const balancedDriver = createDriver('server-timeout', (dt) => {
- *   simulation.tick(dt);
- *   handleNetworkIO();
- * });
- * balancedDriver.start();
- * ```
- */
-export function createDriver(type, update) {
-    if (type === 'server-immediate') {
-        return new ImmediateDriver(update);
-    }
-    else if (type === 'server-timeout') {
-        return new TimeoutDriver(update);
-    }
-    else {
-        return new RafDriver(update);
-    }
-}

package/dist/core/driver/drivers/immediate.js

@@ -1,61 +0,0 @@
-/**
- * Server-side game loop driver using setImmediate.
- *
- * This driver runs the game loop as fast as possible without blocking the event loop,
- * making it suitable for Node.js server environments where high tick rates are desired.
- *
- * Delta time is automatically calculated between iterations and passed to the update callback in seconds.
- *
- * **Note:** This driver requires Node.js as it uses `setImmediate` which is not available in browsers.
- *
- * @example
- * ```typescript
- * const driver = new ImmediateDriver((dt) => {
- *   world.tick(dt);
- *   broadcastState();
- * });
- * driver.start();
- * ```
- */
-export class ImmediateDriver {
-    /**
-     * @param update - Callback invoked each tick with delta time in seconds
-     */
-    constructor(update) {
-        this.update = update;
-        this.last = performance.now();
-        this.running = false;
-        /**
-         * Internal loop method that calculates delta time and schedules the next iteration.
-         *
-         * Delta time is provided in seconds.
-         */
-        this.loop = () => {
-            if (!this.running)
-                return;
-            const now = performance.now();
-            const dt = (now - this.last) / 1000;
-            this.last = now;
-            this.update(dt);
-            setImmediate(this.loop);
-        };
-    }
-    /**
-     * Starts the game loop using setImmediate.
-     *
-     * Resets timing to prevent large initial delta.
-     */
-    start() {
-        this.running = true;
-        this.last = performance.now();
-        this.loop();
-    }
-    /**
-     * Stops the game loop.
-     *
-     * Note: Does not cancel already queued setImmediate callbacks.
-     */
-    stop() {
-        this.running = false;
-    }
-}

package/dist/core/driver/drivers/index.js

@@ -1,3 +0,0 @@
-export * from "./immediate";
-export * from "./raf";
-export * from "./timeout";