murow 0.0.73 → 0.1.1

package/dist/types/ecs/system-builder.d.ts

@@ -120,10 +120,23 @@ export declare class ExecutableSystem {
     private queryMask;
     private conditionPredicate?;
     private proxyEntity;
+    /**
+     * Indices of queried components that have `__sync` metadata. Cached at
+     * construction so `execute()` can flip dirty bits without re-checking
+     * each tick. Empty for systems whose query touches no synced components,
+     * which keeps the hot path zero-overhead.
+     */
+    private syncedComponentIndices;
     constructor(world: World, components: Component<any>[], userCallback: (entity: any, deltaTime: number, world: World) => void, fieldDescs: FieldDesc[], queryMaskKey: string, queryMask: number[], conditionPredicate?: (entity: any) => boolean);
     /**
      * Execute the system for all matching entities.
      *
+     * If the system's query includes any synced components, every entity
+     * touched by the system is marked dirty for those components after the
+     * callback runs (coarse strategy. the network layer assumes any
+     * entity that flowed through a system whose query included its synced
+     * component may have changed).
+     *
      * @param deltaTime - Time delta to pass to system callback
      */
     execute(deltaTime: number): void;

package/dist/types/ecs/world.d.ts

@@ -1,3 +1,4 @@
+import type { ArrayFromField, Schema } from "../core/binary-codec";
 import { Component } from "./component";
 import { ComponentStore } from "./component-store";
 import { EntityHandle } from "./entity-handle";
@@ -70,6 +71,21 @@ export declare class World extends WorldSystems {
     private queryMaskCache;
     private despawnedBuffer;
     private despawnedCount;
+    /**
+     * Per-component dirty bitmask, indexed by [componentIndex][entity>>>5].
+     * `null` for components without `__sync` metadata: no overhead when
+     * networking isn't in play. Higher-level packages might read these
+     * to build per-peer snapshot deltas.
+     */
+    private dirtyBitsByComponent;
+    /**
+     * Per-component field bundle: a frozen object whose keys are the
+     * component's field names and whose values are the same typed-array
+     * references returned by `getFieldArray`. Built once at registration,
+     * shared forever — `world.fields(C)` returns the same object on every
+     * call (zero garbage). Indexed by `component.__worldIndex`.
+     */
+    private fieldsByComponent;
     private worldId;
     constructor(config: WorldConfig);
     /**
@@ -150,6 +166,34 @@ export declare class World extends WorldSystems {
      * Invalidate all query caches (called on archetype changes).
      */
     private invalidateQueryCache;
+    /**
+     * Mark an entity dirty for a given component index. No-op for
+     * components without `__sync` metadata. Called internally by every
+     * write path (`add`, `set`, `update`, `system-builder` field setters).
+     */
+    markDirty(entity: Entity, componentIndex: number): void;
+    /**
+     * Test whether an entity is currently marked dirty for a component.
+     * Used by snapshot builders.
+     */
+    isDirty(entity: Entity, component: Component<any>): boolean;
+    /**
+     * Clear the dirty bit for an entity/component pair. Called by the
+     * snapshot builder after a delta for the entity has been acknowledged
+     * by all peers.
+     */
+    clearDirty(entity: Entity, component: Component<any>): void;
+    /**
+     * Iterate dirty entities for a synced component. Calls `cb` for each
+     * entity whose dirty bit is set. Returns immediately for unsynced
+     * components.
+     */
+    forEachDirty(component: Component<any>, cb: (entity: Entity) => void): void;
+    /**
+     * Clear all dirty bits across all components. Usually the snapshot
+     * pipeline clears bits per-entity as it processes them.
+     */
+    clearAllDirty(): void;
     /**
      * Add a component to an entity with initial data.
      */
@@ -223,8 +267,8 @@ export declare class World extends WorldSystems {
      *   const t = world.get(entity, Transform);
      *   const v = world.get(entity, Velocity);
      *   world.update(entity, Transform, {
-     *     x: t.x + v.vx * dt,
-     *     y: t.y + v.vy * dt
+     *     x: t.x + v.vx * deltaTime,
+     *     y: t.y + v.vy * deltaTime
      *   });
      * }
      * ```
@@ -289,12 +333,36 @@ export declare class World extends WorldSystems {
      * const velocityVy = world.getFieldArray(Velocity, 'vy');
      *
      * for (const entity of world.query(Transform, Velocity)) {
-     *   transformX[entity] += velocityVx[entity] * dt;
-     *   transformY[entity] += velocityVy[entity] * dt;
+     *   transformX[entity] += velocityVx[entity] * deltaTime;
+     *   transformY[entity] += velocityVy[entity] * deltaTime;
      * }
      * ```
      */
     getFieldArray<T extends object>(component: Component<T>, fieldName: keyof T): Float32Array | Int32Array | Uint32Array | Uint16Array | Uint8Array;
+    /**
+     * Get a typed-array bundle for every field of a component.
+     *
+     * Returns the same frozen object on every call - built once at component
+     * registration and shared forever. Each field name maps to its underlying
+     * typed array, with the EXACT element type inferred from the schema:
+     * `f32 -> Float32Array`, `u8 -> Uint8Array`, `u16 -> Uint16Array`, etc.
+     * No casts needed in caller code.
+     *
+     * Use this when you want RAW-speed per-entity reads/writes without the
+     * `world.update({...})` allocation + `for...in` overhead. Bypasses dirty
+     * tracking: for networked components, see `ctx.fields()` in `murow/netcode`
+     * which auto-marks dirty, or call `world.markDirty(entity, index)` yourself.
+     *
+     * @example
+     * ```ts
+     * const pos = world.fields(Position);   // pos.x, pos.z typed as Float32Array
+     * pos.x[entity] += velocity.x * dt;
+     * pos.z[entity] += velocity.z * dt;
+     * ```
+     */
+    fields<T extends object, S extends Schema<T>>(component: Component<T, S>): Readonly<{
+        [K in keyof S]: ArrayFromField<S[K]>;
+    }>;
     /**
      * Create an EntityHandle wrapper for fluent API usage.
      *

package/dist/types/game/loop/loop.d.ts

@@ -51,8 +51,8 @@ export declare class GameLoop<T extends GameLoopType = DriverType> {
 interface GameLoopOptions<T extends GameLoopType> {
     tickRate: number;
     type: T;
-    onTick?: (dt: number, tick: number, input: ReturnType<InputManager["snapshot"]>) => void;
-    onRender?: (dt: number, alpha: number, input: ReturnType<InputManager["peek"]>) => void;
+    onTick?: (deltaTime: number, tick: number, input: ReturnType<InputManager["snapshot"]>) => void;
+    onRender?: (deltaTime: number, alpha: number, input: ReturnType<InputManager["peek"]>) => void;
 }
 type BaseEvents = [
     [
@@ -64,6 +64,25 @@ type BaseEvents = [
             startedAt: number;
         }
     ],
+    [
+        "sync",
+        {
+            /**
+             * Current tick number.
+             */
+            tick: number;
+            /**
+             * Delta time since the last tick.
+             */
+            deltaTime: number;
+            /**
+             * Input snapshot at the start of the tick.
+             *
+             * **Only available in client loops.**
+             */
+            input: ReturnType<InputManager["snapshot"]>;
+        }
+    ],
     [
         "pre-tick",
         {

package/dist/types/net/adapters/bun-websocket.d.ts

@@ -63,7 +63,10 @@ export declare class BunWebSocketServerTransport implements ServerTransportAdapt
     getPeerIds(): string[];
     close(): void;
     /**
-     * Internal: Register a new peer (called from Bun server fetch handler)
+     * Internal: Register a new peer. Records the peer in the internal map
+     * but does NOT fire connection handlers: that's `_handlePeerConnection`'s
+     * job, called separately by the `open` callback. Splitting registration
+     * from notification keeps the handler count to exactly one per connect.
      */
     _registerPeer(socket: ServerWebSocket<unknown>): string;
     /**
@@ -76,7 +79,20 @@ export declare class BunWebSocketServerTransport implements ServerTransportAdapt
     _handlePeerDisconnection(peerId: string): void;
     _handlePeerConnection(peerId: string): void;
     /**
-     * Static factory method to create a Bun WebSocket server
+     * Static factory method to create a Bun WebSocket server.
+     *
+     * @param port - Port to listen on.
+     * @param opts - Optional configuration:
+     *   - `path`: If set, only requests to this URL pathname are upgraded
+     *     (e.g., `/ws`). Other paths fall through to `fetch`. Defaults to
+     *     accepting any path.
+     *   - `fetch`: Handler for non-upgrade HTTP requests on the same port.
+     *     Useful for serving a static bundle alongside the WS endpoint so
+     *     the whole app runs on one port. If omitted, non-upgrade requests
+     *     get a 400 response (matches the previous WS-only behavior).
      */
-    static create(port: number): BunWebSocketServerTransport;
+    static create(port: number, opts?: {
+        path?: string;
+        fetch?: (req: Request, server: Server<unknown>) => Response | Promise<Response>;
+    }): BunWebSocketServerTransport;
 }

package/dist/webgpu/cjs/index.js

@@ -4734,17 +4734,18 @@ var WebGPU3DRenderer = class extends import_renderer4.Base3DRenderer {
    * with another instance (e.g., when spawning all parts of a character).
    */
   addInstance(opts) {
+    const userPrefabId = isPrefab3D(opts.model) ? opts.model.id : null;
     if (isPrefab3D(opts.model) && opts.model.type === "composite") {
       return this.addCompositeInstance(opts, opts.model);
     }
     const modelOrGltf = isPrefab3D(opts.model) ? resolvePrefabHandle(opts.model) : opts.model;
     if ("parts" in modelOrGltf) {
-      return this.addGltfInstance(opts, modelOrGltf);
+      return this.addGltfInstance(opts, modelOrGltf, userPrefabId);
     }
     const modelHandle = modelOrGltf;
     const model = this.models[modelHandle.id];
     if (model?.skinned) {
-      return this.addSkinnedInstance(opts, modelHandle, model.skinIndex);
+      return this.addSkinnedInstance(opts, modelHandle, model.skinIndex, void 0, userPrefabId);
     }
     const slot = this.freeList.allocate();
     if (slot === -1)
@@ -4777,10 +4778,14 @@ var WebGPU3DRenderer = class extends import_renderer4.Base3DRenderer {
     const staticData = this.staticData;
     const self = this;
     let destroyed = false;
+    const posOut = [0, 0, 0];
+    const rotOut = [0, 0, 0];
+    const sclOut = [0, 0, 0];
     const handle = {
       slot,
       modelId: modelHandle.id,
       skinned: false,
+      prefabId: userPrefabId,
       setPosition(nx, ny, nz) {
         dynamicData[dynBase + DYN_CURR_PX] = nx;
         dynamicData[dynBase + DYN_CURR_PY] = ny;
@@ -4796,6 +4801,32 @@ var WebGPU3DRenderer = class extends import_renderer4.Base3DRenderer {
         staticData[statBase + STAT_SY] = ny;
         staticData[statBase + STAT_SZ] = nz;
       },
+      teleport(nx, ny, nz) {
+        dynamicData[dynBase + DYN_PREV_PX] = nx;
+        dynamicData[dynBase + DYN_PREV_PY] = ny;
+        dynamicData[dynBase + DYN_PREV_PZ] = nz;
+        dynamicData[dynBase + DYN_CURR_PX] = nx;
+        dynamicData[dynBase + DYN_CURR_PY] = ny;
+        dynamicData[dynBase + DYN_CURR_PZ] = nz;
+      },
+      get position() {
+        posOut[0] = dynamicData[dynBase + DYN_CURR_PX];
+        posOut[1] = dynamicData[dynBase + DYN_CURR_PY];
+        posOut[2] = dynamicData[dynBase + DYN_CURR_PZ];
+        return posOut;
+      },
+      get rotation() {
+        rotOut[0] = dynamicData[dynBase + DYN_CURR_RX];
+        rotOut[1] = dynamicData[dynBase + DYN_CURR_RY];
+        rotOut[2] = dynamicData[dynBase + DYN_CURR_RZ];
+        return rotOut;
+      },
+      get scale() {
+        sclOut[0] = staticData[statBase + STAT_SX];
+        sclOut[1] = staticData[statBase + STAT_SY];
+        sclOut[2] = staticData[statBase + STAT_SZ];
+        return sclOut;
+      },
       destroy() {
         if (destroyed)
           return;
@@ -4809,7 +4840,7 @@ var WebGPU3DRenderer = class extends import_renderer4.Base3DRenderer {
     };
     return handle;
   }
-  addGltfInstance(opts, gltf) {
+  addGltfInstance(opts, gltf, prefabId) {
     const childHandles = [];
     let firstSkinnedSlot;
     for (const part of gltf.parts) {
@@ -4817,7 +4848,7 @@ var WebGPU3DRenderer = class extends import_renderer4.Base3DRenderer {
       const model = this.models[part.id];
       let handle;
       if (model?.skinned) {
-        handle = this.addSkinnedInstance(partOpts, part, model.skinIndex, firstSkinnedSlot);
+        handle = this.addSkinnedInstance(partOpts, part, model.skinIndex, firstSkinnedSlot, prefabId);
         if (firstSkinnedSlot === void 0)
           firstSkinnedSlot = handle.slot;
       } else {
@@ -4826,8 +4857,10 @@ var WebGPU3DRenderer = class extends import_renderer4.Base3DRenderer {
       childHandles.push(handle);
     }
     const skinnedHandle = childHandles.find((h) => h.skinned);
+    const lead = childHandles[0];
     return {
       skinned: gltf.skinned,
+      prefabId,
       setPosition(x, y, z) {
         for (const h of childHandles)
           h.setPosition(x, y, z);
@@ -4840,6 +4873,19 @@ var WebGPU3DRenderer = class extends import_renderer4.Base3DRenderer {
         for (const h of childHandles)
           h.setScale(x, y, z);
       },
+      teleport(x, y, z) {
+        for (const h of childHandles)
+          h.teleport(x, y, z);
+      },
+      get position() {
+        return lead.position;
+      },
+      get rotation() {
+        return lead.rotation;
+      },
+      get scale() {
+        return lead.scale;
+      },
       play: skinnedHandle?.play ? (name, opts2) => {
         skinnedHandle.play(name, opts2);
       } : void 0,
@@ -4876,6 +4922,17 @@ var WebGPU3DRenderer = class extends import_renderer4.Base3DRenderer {
       rz: p.offset?.rotation?.[2] ?? 0
     }));
     const childHandles = [];
+    const posOut = [basePos[0], basePos[1], basePos[2]];
+    const rotOut = [baseRot[0], baseRot[1], baseRot[2]];
+    const sclOut = [1, 1, 1];
+    const initialScale = opts.scale;
+    if (typeof initialScale === "number") {
+      sclOut[0] = sclOut[1] = sclOut[2] = initialScale;
+    } else if (initialScale) {
+      sclOut[0] = initialScale[0];
+      sclOut[1] = initialScale[1];
+      sclOut[2] = initialScale[2];
+    }
     for (let i = 0; i < composite.parts.length; i++) {
       const part = composite.parts[i];
       const off = offsets[i];
@@ -4890,29 +4947,57 @@ var WebGPU3DRenderer = class extends import_renderer4.Base3DRenderer {
     }
     return {
       skinned: childHandles.some((h) => h.skinned),
+      prefabId: composite.id,
       setPosition(x, y, z) {
+        posOut[0] = x;
+        posOut[1] = y;
+        posOut[2] = z;
         for (let i = 0; i < childHandles.length; i++) {
           const o = offsets[i];
           childHandles[i].setPosition(x + o.px, y + o.py, z + o.pz);
         }
       },
       setRotation(x, y, z) {
+        rotOut[0] = x;
+        rotOut[1] = y;
+        rotOut[2] = z;
         for (let i = 0; i < childHandles.length; i++) {
           const o = offsets[i];
           childHandles[i].setRotation(x + o.rx, y + o.ry, z + o.rz);
         }
       },
       setScale(x, y, z) {
+        sclOut[0] = x;
+        sclOut[1] = y;
+        sclOut[2] = z;
         for (const h of childHandles)
           h.setScale(x, y, z);
       },
+      teleport(x, y, z) {
+        posOut[0] = x;
+        posOut[1] = y;
+        posOut[2] = z;
+        for (let i = 0; i < childHandles.length; i++) {
+          const o = offsets[i];
+          childHandles[i].teleport(x + o.px, y + o.py, z + o.pz);
+        }
+      },
+      get position() {
+        return posOut;
+      },
+      get rotation() {
+        return rotOut;
+      },
+      get scale() {
+        return sclOut;
+      },
       destroy() {
         for (const h of childHandles)
           h.destroy();
       }
     };
   }
-  addSkinnedInstance(opts, modelHandle, skinIndex, linkedSlot) {
+  addSkinnedInstance(opts, modelHandle, skinIndex, linkedSlot, prefabId = null) {
     const slot = this.skinnedFreeList.allocate();
     if (slot === -1)
       throw new Error(`Max skinned instances (${this.maxSkinnedInstances}) reached`);
@@ -4981,10 +5066,14 @@ var WebGPU3DRenderer = class extends import_renderer4.Base3DRenderer {
     const capturedBoneOffset = boneOffset;
     const capturedSkinIndex = skinIndex;
     let destroyed = false;
+    const posOut = [0, 0, 0];
+    const rotOut = [0, 0, 0];
+    const sclOut = [0, 0, 0];
     return {
       slot,
       modelId: modelHandle.id,
       skinned: true,
+      prefabId,
       setPosition(nx, ny, nz) {
         dynamicData[dynBase + DYN_CURR_PX] = nx;
         dynamicData[dynBase + DYN_CURR_PY] = ny;
@@ -5000,6 +5089,32 @@ var WebGPU3DRenderer = class extends import_renderer4.Base3DRenderer {
         staticData[statBase + SSTAT_SY] = ny;
         staticData[statBase + SSTAT_SZ] = nz;
       },
+      teleport(nx, ny, nz) {
+        dynamicData[dynBase + DYN_PREV_PX] = nx;
+        dynamicData[dynBase + DYN_PREV_PY] = ny;
+        dynamicData[dynBase + DYN_PREV_PZ] = nz;
+        dynamicData[dynBase + DYN_CURR_PX] = nx;
+        dynamicData[dynBase + DYN_CURR_PY] = ny;
+        dynamicData[dynBase + DYN_CURR_PZ] = nz;
+      },
+      get position() {
+        posOut[0] = dynamicData[dynBase + DYN_CURR_PX];
+        posOut[1] = dynamicData[dynBase + DYN_CURR_PY];
+        posOut[2] = dynamicData[dynBase + DYN_CURR_PZ];
+        return posOut;
+      },
+      get rotation() {
+        rotOut[0] = dynamicData[dynBase + DYN_CURR_RX];
+        rotOut[1] = dynamicData[dynBase + DYN_CURR_RY];
+        rotOut[2] = dynamicData[dynBase + DYN_CURR_RZ];
+        return rotOut;
+      },
+      get scale() {
+        sclOut[0] = staticData[statBase + SSTAT_SX];
+        sclOut[1] = staticData[statBase + SSTAT_SY];
+        sclOut[2] = staticData[statBase + SSTAT_SZ];
+        return sclOut;
+      },
       play(name, opts2) {
         const state = animStates[slot];
         if (state)

package/dist/webgpu/esm/index.js

@@ -4622,17 +4622,18 @@ var WebGPU3DRenderer = class extends Base3DRenderer {
    * with another instance (e.g., when spawning all parts of a character).
    */
   addInstance(opts) {
+    const userPrefabId = isPrefab3D(opts.model) ? opts.model.id : null;
     if (isPrefab3D(opts.model) && opts.model.type === "composite") {
       return this.addCompositeInstance(opts, opts.model);
     }
     const modelOrGltf = isPrefab3D(opts.model) ? resolvePrefabHandle(opts.model) : opts.model;
     if ("parts" in modelOrGltf) {
-      return this.addGltfInstance(opts, modelOrGltf);
+      return this.addGltfInstance(opts, modelOrGltf, userPrefabId);
     }
     const modelHandle = modelOrGltf;
     const model = this.models[modelHandle.id];
     if (model?.skinned) {
-      return this.addSkinnedInstance(opts, modelHandle, model.skinIndex);
+      return this.addSkinnedInstance(opts, modelHandle, model.skinIndex, void 0, userPrefabId);
     }
     const slot = this.freeList.allocate();
     if (slot === -1)
@@ -4665,10 +4666,14 @@ var WebGPU3DRenderer = class extends Base3DRenderer {
     const staticData = this.staticData;
     const self = this;
     let destroyed = false;
+    const posOut = [0, 0, 0];
+    const rotOut = [0, 0, 0];
+    const sclOut = [0, 0, 0];
     const handle = {
       slot,
       modelId: modelHandle.id,
       skinned: false,
+      prefabId: userPrefabId,
       setPosition(nx, ny, nz) {
         dynamicData[dynBase + DYN_CURR_PX] = nx;
         dynamicData[dynBase + DYN_CURR_PY] = ny;
@@ -4684,6 +4689,32 @@ var WebGPU3DRenderer = class extends Base3DRenderer {
         staticData[statBase + STAT_SY] = ny;
         staticData[statBase + STAT_SZ] = nz;
       },
+      teleport(nx, ny, nz) {
+        dynamicData[dynBase + DYN_PREV_PX] = nx;
+        dynamicData[dynBase + DYN_PREV_PY] = ny;
+        dynamicData[dynBase + DYN_PREV_PZ] = nz;
+        dynamicData[dynBase + DYN_CURR_PX] = nx;
+        dynamicData[dynBase + DYN_CURR_PY] = ny;
+        dynamicData[dynBase + DYN_CURR_PZ] = nz;
+      },
+      get position() {
+        posOut[0] = dynamicData[dynBase + DYN_CURR_PX];
+        posOut[1] = dynamicData[dynBase + DYN_CURR_PY];
+        posOut[2] = dynamicData[dynBase + DYN_CURR_PZ];
+        return posOut;
+      },
+      get rotation() {
+        rotOut[0] = dynamicData[dynBase + DYN_CURR_RX];
+        rotOut[1] = dynamicData[dynBase + DYN_CURR_RY];
+        rotOut[2] = dynamicData[dynBase + DYN_CURR_RZ];
+        return rotOut;
+      },
+      get scale() {
+        sclOut[0] = staticData[statBase + STAT_SX];
+        sclOut[1] = staticData[statBase + STAT_SY];
+        sclOut[2] = staticData[statBase + STAT_SZ];
+        return sclOut;
+      },
       destroy() {
         if (destroyed)
           return;
@@ -4697,7 +4728,7 @@ var WebGPU3DRenderer = class extends Base3DRenderer {
     };
     return handle;
   }
-  addGltfInstance(opts, gltf) {
+  addGltfInstance(opts, gltf, prefabId) {
     const childHandles = [];
     let firstSkinnedSlot;
     for (const part of gltf.parts) {
@@ -4705,7 +4736,7 @@ var WebGPU3DRenderer = class extends Base3DRenderer {
       const model = this.models[part.id];
       let handle;
       if (model?.skinned) {
-        handle = this.addSkinnedInstance(partOpts, part, model.skinIndex, firstSkinnedSlot);
+        handle = this.addSkinnedInstance(partOpts, part, model.skinIndex, firstSkinnedSlot, prefabId);
         if (firstSkinnedSlot === void 0)
           firstSkinnedSlot = handle.slot;
       } else {
@@ -4714,8 +4745,10 @@ var WebGPU3DRenderer = class extends Base3DRenderer {
       childHandles.push(handle);
     }
     const skinnedHandle = childHandles.find((h) => h.skinned);
+    const lead = childHandles[0];
     return {
       skinned: gltf.skinned,
+      prefabId,
       setPosition(x, y, z) {
         for (const h of childHandles)
           h.setPosition(x, y, z);
@@ -4728,6 +4761,19 @@ var WebGPU3DRenderer = class extends Base3DRenderer {
         for (const h of childHandles)
           h.setScale(x, y, z);
       },
+      teleport(x, y, z) {
+        for (const h of childHandles)
+          h.teleport(x, y, z);
+      },
+      get position() {
+        return lead.position;
+      },
+      get rotation() {
+        return lead.rotation;
+      },
+      get scale() {
+        return lead.scale;
+      },
       play: skinnedHandle?.play ? (name, opts2) => {
         skinnedHandle.play(name, opts2);
       } : void 0,
@@ -4764,6 +4810,17 @@ var WebGPU3DRenderer = class extends Base3DRenderer {
       rz: p.offset?.rotation?.[2] ?? 0
     }));
     const childHandles = [];
+    const posOut = [basePos[0], basePos[1], basePos[2]];
+    const rotOut = [baseRot[0], baseRot[1], baseRot[2]];
+    const sclOut = [1, 1, 1];
+    const initialScale = opts.scale;
+    if (typeof initialScale === "number") {
+      sclOut[0] = sclOut[1] = sclOut[2] = initialScale;
+    } else if (initialScale) {
+      sclOut[0] = initialScale[0];
+      sclOut[1] = initialScale[1];
+      sclOut[2] = initialScale[2];
+    }
     for (let i = 0; i < composite.parts.length; i++) {
       const part = composite.parts[i];
       const off = offsets[i];
@@ -4778,29 +4835,57 @@ var WebGPU3DRenderer = class extends Base3DRenderer {
     }
     return {
       skinned: childHandles.some((h) => h.skinned),
+      prefabId: composite.id,
       setPosition(x, y, z) {
+        posOut[0] = x;
+        posOut[1] = y;
+        posOut[2] = z;
         for (let i = 0; i < childHandles.length; i++) {
           const o = offsets[i];
           childHandles[i].setPosition(x + o.px, y + o.py, z + o.pz);
         }
       },
       setRotation(x, y, z) {
+        rotOut[0] = x;
+        rotOut[1] = y;
+        rotOut[2] = z;
         for (let i = 0; i < childHandles.length; i++) {
           const o = offsets[i];
           childHandles[i].setRotation(x + o.rx, y + o.ry, z + o.rz);
         }
       },
       setScale(x, y, z) {
+        sclOut[0] = x;
+        sclOut[1] = y;
+        sclOut[2] = z;
         for (const h of childHandles)
           h.setScale(x, y, z);
       },
+      teleport(x, y, z) {
+        posOut[0] = x;
+        posOut[1] = y;
+        posOut[2] = z;
+        for (let i = 0; i < childHandles.length; i++) {
+          const o = offsets[i];
+          childHandles[i].teleport(x + o.px, y + o.py, z + o.pz);
+        }
+      },
+      get position() {
+        return posOut;
+      },
+      get rotation() {
+        return rotOut;
+      },
+      get scale() {
+        return sclOut;
+      },
       destroy() {
         for (const h of childHandles)
           h.destroy();
       }
     };
   }
-  addSkinnedInstance(opts, modelHandle, skinIndex, linkedSlot) {
+  addSkinnedInstance(opts, modelHandle, skinIndex, linkedSlot, prefabId = null) {
     const slot = this.skinnedFreeList.allocate();
     if (slot === -1)
       throw new Error(`Max skinned instances (${this.maxSkinnedInstances}) reached`);
@@ -4869,10 +4954,14 @@ var WebGPU3DRenderer = class extends Base3DRenderer {
     const capturedBoneOffset = boneOffset;
     const capturedSkinIndex = skinIndex;
     let destroyed = false;
+    const posOut = [0, 0, 0];
+    const rotOut = [0, 0, 0];
+    const sclOut = [0, 0, 0];
     return {
       slot,
       modelId: modelHandle.id,
       skinned: true,
+      prefabId,
       setPosition(nx, ny, nz) {
         dynamicData[dynBase + DYN_CURR_PX] = nx;
         dynamicData[dynBase + DYN_CURR_PY] = ny;
@@ -4888,6 +4977,32 @@ var WebGPU3DRenderer = class extends Base3DRenderer {
         staticData[statBase + SSTAT_SY] = ny;
         staticData[statBase + SSTAT_SZ] = nz;
       },
+      teleport(nx, ny, nz) {
+        dynamicData[dynBase + DYN_PREV_PX] = nx;
+        dynamicData[dynBase + DYN_PREV_PY] = ny;
+        dynamicData[dynBase + DYN_PREV_PZ] = nz;
+        dynamicData[dynBase + DYN_CURR_PX] = nx;
+        dynamicData[dynBase + DYN_CURR_PY] = ny;
+        dynamicData[dynBase + DYN_CURR_PZ] = nz;
+      },
+      get position() {
+        posOut[0] = dynamicData[dynBase + DYN_CURR_PX];
+        posOut[1] = dynamicData[dynBase + DYN_CURR_PY];
+        posOut[2] = dynamicData[dynBase + DYN_CURR_PZ];
+        return posOut;
+      },
+      get rotation() {
+        rotOut[0] = dynamicData[dynBase + DYN_CURR_RX];
+        rotOut[1] = dynamicData[dynBase + DYN_CURR_RY];
+        rotOut[2] = dynamicData[dynBase + DYN_CURR_RZ];
+        return rotOut;
+      },
+      get scale() {
+        sclOut[0] = staticData[statBase + SSTAT_SX];
+        sclOut[1] = staticData[statBase + SSTAT_SY];
+        sclOut[2] = staticData[statBase + SSTAT_SZ];
+        return sclOut;
+      },
       play(name, opts2) {
         const state = animStates[slot];
         if (state)