reze-engine 0.32.2 → 0.33.1

package/src/engine.ts

@@ -7,7 +7,6 @@ import { VMDLoader } from "./vmd-loader"
 import { CameraAnimation } from "./camera-animation"
 import { PmxLoader } from "./pmx-loader"
 import { RezePhysics } from "./physics"
-import { WorkerPhysics } from "./physics/worker-physics"
 import {
   createFetchAssetReader,
   createFileMapAssetReader,
@@ -347,11 +346,6 @@ export interface GizmoDragEvent {
 export type GizmoDragCallback = (event: GizmoDragEvent) => void
 
 export type EngineOptions = {
-  /** Run each model's physics on a dedicated Web Worker (default true where
-   *  Workers exist). Pipelined one frame deep: main-thread physics cost drops
-   *  to two small copies and multi-model scenes pay for the SLOWEST model
-   *  instead of the sum. false = classic main-thread stepping. */
-  physicsWorkers?: boolean
   world?: WorldOptions
   sun?: SunOptions
   camera?: CameraOptions
@@ -382,7 +376,6 @@ export interface EngineStats {
   jitter: number // ms — stddev of frame intervals (pacing evenness; high = janky at any mean fps)
   cpuAnimMs: number // ms/frame (EMA) — model updates: blending, IK, world matrices
   cpuPhysicsMs: number // ms/frame (EMA) — physics stepping across all instances
-  cpuPhysicsWorkerMs: number // ms/frame (EMA) — the SLOWEST worker's step cost. Background-thread time (often an efficiency core), parallel to the frame: it only matters if it exceeds the frame budget.
   cpuRenderMs: number // ms/frame (EMA) — the rest of the render thread: uniforms, encoding, submit
 }
 
@@ -436,7 +429,7 @@ interface ModelInstance {
   pickPerInstanceBindGroup: GPUBindGroup
   pickDrawCalls: PickDrawCall[]
   hiddenMaterials: Set<string>
-  physics: RezePhysics | WorkerPhysics | null
+  physics: RezePhysics | null
   vertexBufferNeedsUpdate: boolean
   gpuMorph: GpuMorph | null
   // Style groups applied to this model: group id → compiled install.
@@ -837,7 +830,6 @@ export class Engine {
     fps1PercentLow: 0,
     cpuAnimMs: 0,
     cpuPhysicsMs: 0,
-    cpuPhysicsWorkerMs: 0,
     cpuRenderMs: 0,
     jitter: 0,
   }
@@ -847,7 +839,6 @@ export class Engine {
   private viewTransform!: ViewTransformOptions
 
   constructor(canvas: HTMLCanvasElement, options?: EngineOptions) {
-    this.physicsWorkersEnabled = options?.physicsWorkers ?? true
     this.canvas = canvas
     const d = DEFAULT_ENGINE_OPTIONS
     this.world = {
@@ -3040,10 +3031,7 @@ export class Engine {
 
   dispose() {
     this.stopRenderLoop()
-    this.forEachInstance((inst) => {
-      inst.model.stopAnimation()
-      if (inst.physics instanceof WorkerPhysics) inst.physics.dispose()
-    })
+    this.forEachInstance((inst) => inst.model.stopAnimation())
     if (Engine.instance === this) Engine.instance = null
     if (this.camera) this.camera.detachControl()
 
@@ -3120,7 +3108,6 @@ export class Engine {
     const inst = this.modelInstances.get(name)
     if (!inst) return
     inst.model.stopAnimation()
-    if (inst.physics instanceof WorkerPhysics) inst.physics.dispose()
     for (const path of inst.textureCacheKeys) {
       const tex = this.textureCache.get(path)
       if (!tex) continue
@@ -3294,9 +3281,6 @@ export class Engine {
   // else on the render thread. The first question of any perf report.
   private cpuAnimMs = 0
   private cpuPhysicsMs = 0
-  /** EMA of worker-side step cost (all instances) — the off-thread physics bill. */
-  private cpuPhysicsWorkerMs = 0
-  private physicsWorkersEnabled = true
   private cpuRenderMs = 0
   private frameAnimMsRaw = 0
   private framePhysicsMsRaw = 0
@@ -3304,7 +3288,6 @@ export class Engine {
   private updateInstances(deltaTime: number): void {
     let animMs = 0
     let physicsMs = 0
-    let workerMs = 0
     this.forEachInstance((inst) => {
       const tAnim = performance.now()
       const verticesChanged = inst.model.update(deltaTime, this.ikEnabled)
@@ -3330,7 +3313,6 @@ export class Engine {
         const tPhys = performance.now()
         inst.physics.step(deltaTime, inst.model.getWorldMatrices(), inst.model.getBoneInverseBindMatrices())
         physicsMs += performance.now() - tPhys
-        if (inst.physics instanceof WorkerPhysics) workerMs = Math.max(workerMs, inst.physics.stepMs)
       }
       if (inst.vertexBufferNeedsUpdate) this.updateVertexBuffer(inst)
     })
@@ -3339,7 +3321,6 @@ export class Engine {
     const EMA = 0.1
     this.cpuAnimMs += (animMs - this.cpuAnimMs) * EMA
     this.cpuPhysicsMs += (physicsMs - this.cpuPhysicsMs) * EMA
-    this.cpuPhysicsWorkerMs += (workerMs - this.cpuPhysicsWorkerMs) * EMA
   }
 
   private updateVertexBuffer(inst: ModelInstance): void {
@@ -3451,17 +3432,7 @@ export class Engine {
     this.device.queue.writeBuffer(indexBuffer, 0, indices)
 
     const rbs = model.getRigidbodies()
-    let physics: RezePhysics | WorkerPhysics | null = null
-    if (rbs.length > 0) {
-      if (this.physicsWorkersEnabled && WorkerPhysics.supported()) {
-        try {
-          physics = await WorkerPhysics.create(rbs, model.getJoints(), model.getBoneInverseBindMatrices())
-        } catch (e) {
-          console.warn("[reze] physics worker unavailable — falling back to main-thread physics:", e)
-        }
-      }
-      if (!physics) physics = new RezePhysics(rbs, model.getJoints())
-    }
+    const physics = rbs.length > 0 ? new RezePhysics(rbs, model.getJoints()) : null
 
     const shadowBindGroup = this.device.createBindGroup({
       label: `${name}: shadow bind`,
@@ -5515,7 +5486,6 @@ export class Engine {
     this.stats.jitter = Math.round(stddev * 100) / 100
     this.stats.cpuAnimMs = Math.round(this.cpuAnimMs * 100) / 100
     this.stats.cpuPhysicsMs = Math.round(this.cpuPhysicsMs * 100) / 100
-    this.stats.cpuPhysicsWorkerMs = Math.round(this.cpuPhysicsWorkerMs * 100) / 100
     this.stats.cpuRenderMs = Math.round(this.cpuRenderMs * 100) / 100
   }
 }

package/src/physics/contact.ts

@@ -929,8 +929,13 @@ export function generateContacts(store: RigidBodyStore, a: number, b: number, po
     return
   }
   if (sA === RigidbodyShape.Capsule && sB === RigidbodyShape.Sphere) {
+    // Only flip a contact this call actually produced. The detector returns
+    // without emitting whenever the shapes are out of range, and flipping then
+    // reverses the normal of whatever unrelated contact happens to sit at the
+    // end of the pool — pushing those two bodies together instead of apart.
+    const before = pool.count
     detectSphereCapsule(store, b, a, pool)
-    flipLastNormal(pool)
+    if (pool.count > before) flipLastNormal(pool)
     return
   }
   if (sA === RigidbodyShape.Capsule && sB === RigidbodyShape.Capsule) {
@@ -942,8 +947,9 @@ export function generateContacts(store: RigidBodyStore, a: number, b: number, po
     return
   }
   if (sA === RigidbodyShape.Box && sB === RigidbodyShape.Sphere) {
+    const before = pool.count
     detectSphereBox(store, b, a, pool)
-    flipLastNormal(pool)
+    if (pool.count > before) flipLastNormal(pool)
     return
   }
   if (sA === RigidbodyShape.Capsule && sB === RigidbodyShape.Box) {
@@ -951,8 +957,9 @@ export function generateContacts(store: RigidBodyStore, a: number, b: number, po
     return
   }
   if (sA === RigidbodyShape.Box && sB === RigidbodyShape.Capsule) {
+    const before = pool.count
     detectCapsuleBox(store, b, a, pool)
-    flipLastNormal(pool)
+    if (pool.count > before) flipLastNormal(pool)
     return
   }
   // Box-box left unimplemented.

package/src/physics/physics.ts

@@ -266,10 +266,12 @@ export class RezePhysics {
     }
     if (this.timeAccum >= this.fixedTimeStep) {
       // Substep budget exhausted mid-catchup: drop the remaining time and
-      // snap kinematic bodies the rest of the way (zero velocity) so they
-      // don't start next frame lagging behind their bones.
+      // snap kinematic bodies the rest of the way so they don't start next
+      // frame lagging behind their bones. They keep the velocity their
+      // trajectory implies — the character did move, and cloth in contact
+      // needs to know that or it stops being dragged and starts juddering.
       this.timeAccum = 0
-      this.snapKinematicToTargets(false)
+      this.snapKinematicToTargets(false, true)
     }
 
     // MMD mode-2 bone alignment for pinned (depth-1) bodies: position
@@ -470,7 +472,27 @@ export class RezePhysics {
   // Snap kinematic bodies straight to the frame target with zero velocity.
   // Used on teleports (onlyFlagged) and when the substep budget runs out
   // mid-catchup (all).
-  private snapKinematicToTargets(onlyFlagged: boolean): void {
+  /**
+   * Put kinematic bodies exactly on their targets.
+   *
+   * `keepTrajectoryVelocity` decides what the cloth is then told about how
+   * those bodies got there, and the two callers want opposite answers.
+   *
+   * After a teleport the honest answer is "nothing" — a scrub is not motion
+   * and handing the solver the implied velocity is what used to fling cloth
+   * across the discontinuity.
+   *
+   * After the substep budget is exhausted it is the opposite. The body really
+   * did travel along its animated trajectory this frame; the simulation just
+   * could not afford to walk it there in steps. Zeroing there tells every
+   * dynamic body in contact that the character stopped dead, so cloth loses
+   * its drag and is teleported by the body instead of dragged by it — it stops
+   * flowing and starts juddering. That branch only fires on a device already
+   * running under its refresh rate, which is precisely where the simulation
+   * can least afford to also look broken. The trajectory velocity is already
+   * computed every frame in kinTargetVel; it just needs to survive.
+   */
+  private snapKinematicToTargets(onlyFlagged: boolean, keepTrajectoryVelocity = false): void {
     const N = this.store.count
     const positions = this.store.positions
     const orientations = this.store.orientations
@@ -480,6 +502,8 @@ export class RezePhysics {
     const boneIdx = this.store.boneIndex
     const tp = this.kinTargetPos
     const to = this.kinTargetOri
+    const tv = this.kinTargetVel
+    const tav = this.kinTargetAngVel
     const flags = this.teleportFlags
 
     for (let i = 0; i < N; i++) {
@@ -496,8 +520,13 @@ export class RezePhysics {
       orientations[i4 + 1] = to[i4 + 1]
       orientations[i4 + 2] = to[i4 + 2]
       orientations[i4 + 3] = to[i4 + 3]
-      lv[i3 + 0] = 0; lv[i3 + 1] = 0; lv[i3 + 2] = 0
-      av[i3 + 0] = 0; av[i3 + 1] = 0; av[i3 + 2] = 0
+      if (keepTrajectoryVelocity) {
+        lv[i3 + 0] = tv[i3 + 0]; lv[i3 + 1] = tv[i3 + 1]; lv[i3 + 2] = tv[i3 + 2]
+        av[i3 + 0] = tav[i3 + 0]; av[i3 + 1] = tav[i3 + 1]; av[i3 + 2] = tav[i3 + 2]
+      } else {
+        lv[i3 + 0] = 0; lv[i3 + 1] = 0; lv[i3 + 2] = 0
+        av[i3 + 0] = 0; av[i3 + 1] = 0; av[i3 + 2] = 0
+      }
     }
   }
 

package/src/physics/world.ts

@@ -93,8 +93,15 @@ export class World {
     //    it because it doesn't go through the velocity channel. Inverse-mass
     //    weighted so a kinematic body stays put and only the dynamic one
     //    translates.
-    const POS_CORRECTION_FACTOR = 0.4
-    const POS_SLOP = 0.005
+    // Softer and later than a rigid-body engine would use, deliberately. MMD
+    // cloth is a dense chain of small bodies resting on the character, and
+    // aggressive penetration recovery feeds those contacts energy that the
+    // joint springs hand straight back — the tips never settle. Measured on a
+    // 688-body model: resting peak velocity 1.79 → 1.10, and 12.9 → 6.6 under
+    // an idle animation, for a slop of two hundredths of a unit (under 2 mm at
+    // MMD scale) that no eye finds.
+    const POS_CORRECTION_FACTOR = 0.15
+    const POS_SLOP = 0.02
     for (let ci = 0; ci < contacts.count; ci++) {
       const c = contacts.get(ci)
       if (c.depth <= POS_SLOP) continue

package/src/pmx-loader.ts

@@ -84,10 +84,19 @@ export class PmxLoader {
   }
 
   private parseHeader() {
-    if (this.getString(3) !== "PMX") throw new Error("Not a PMX file")
-
-    // PMX: 1-byte alignment after signature
-    this.getUint8()
+    // The signature is four bytes. PMX 2.x writes "PMX ", but exporters in the
+    // wild also write "Pmx " — and a strict uppercase compare rejected those
+    // models outright. Compare case-insensitively and name what was actually
+    // found when it is something else, so a PMD (the older format, signature
+    // "Pmd") says so instead of "not a PMX file".
+    const signature = this.getString(4)
+    if (signature.slice(0, 3).toUpperCase() !== "PMX") {
+      const head = signature.slice(0, 3).toUpperCase()
+      if (head === "PMD") {
+        throw new Error("This is a PMD file (MMD's older format). Convert it to PMX in PMXEditor first.")
+      }
+      throw new Error(`Not a PMX file (signature "${signature.replace(/[^\x20-\x7e]/g, "?")}")`)
+    }
 
     // PMX: version (float32)
     const version = this.getFloat32()
@@ -1128,7 +1137,9 @@ export class PmxLoader {
   }
 
   private getString(len: number) {
-    const bytes = new Uint8Array(this.view.buffer, this.offset, len)
+    // byteOffset matters: a DataView built over a slice of a larger buffer has
+    // its own origin, and reading the raw buffer without it lands elsewhere.
+    const bytes = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, len)
     this.offset += len
     return String.fromCharCode(...bytes)
   }
@@ -1137,18 +1148,23 @@ export class PmxLoader {
     const len = this.getInt32()
     if (len <= 0) return ""
 
-    // Debug: log problematic string lengths
-    if (len > 1000 || len < -1000) {
-      throw new RangeError(`Suspicious string length: ${len} at offset ${this.offset - 4}`)
-    }
-
+    // No arbitrary length ceiling. A model's comment field carries credits and
+    // terms of use and routinely runs past a thousand bytes — roughly five
+    // hundred characters in UTF-16 — so a "this looks too long" heuristic
+    // rejected perfectly ordinary models from several distributors. The bounds
+    // check below is the real guard: a length that would read past the end of
+    // the file is corrupt, and any length that fits is the author's business.
     // Ensure we don't read beyond buffer bounds
-    if (this.offset + len > this.view.buffer.byteLength) {
+    if (this.offset + len > this.view.byteLength) {
       throw new RangeError(`String length ${len} exceeds buffer bounds at offset ${this.offset - 4}`)
     }
 
-    const bytes = new Uint8Array(this.view.buffer, this.offset, len)
+    let bytes = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, len)
     this.offset += len
+    // UTF-16 needs whole code units. A stray odd length (seen from a few
+    // exporters) made TextDecoder emit a replacement char and, worse, shifted
+    // nothing — better to drop the orphan byte than to carry it into the name.
+    if (this.encoding === 0 && len % 2 === 1) bytes = bytes.subarray(0, len - 1)
     return this.decoder.decode(bytes)
   }
 

package/dist/gpu-profile.d.ts

@@ -1,19 +0,0 @@
-export declare class GpuTimestamp {
-    enabled: boolean;
-    readonly supported: boolean;
-    private device;
-    private querySet;
-    private resolveBuffer;
-    private readbackBuffer;
-    private nextSlot;
-    private frameLabels;
-    private inFlight;
-    private pendingLabels;
-    constructor(device: GPUDevice);
-    private ensureCreated;
-    beginFrame(): void;
-    wrap(desc: GPURenderPassDescriptor, label: string): GPURenderPassDescriptor;
-    endFrame(encoder: GPUCommandEncoder): void;
-    afterSubmit(): void;
-}
-//# sourceMappingURL=gpu-profile.d.ts.map

package/dist/gpu-profile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"gpu-profile.d.ts","sourceRoot":"","sources":["../src/gpu-profile.ts"],"names":[],"mappings":"AAoBA,qBAAa,YAAY;IACvB,OAAO,UAAQ;IACf,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,QAAQ,CAA2B;IAC3C,OAAO,CAAC,aAAa,CAAyB;IAC9C,OAAO,CAAC,cAAc,CAAyB;IAC/C,OAAO,CAAC,QAAQ,CAAI;IACpB,OAAO,CAAC,WAAW,CAAe;IAClC,OAAO,CAAC,QAAQ,CAAQ;IAKxB,OAAO,CAAC,aAAa,CAAwB;gBAEjC,MAAM,EAAE,SAAS;IAK7B,OAAO,CAAC,aAAa;IAiBrB,UAAU,IAAI,IAAI;IAWlB,IAAI,CAAC,IAAI,EAAE,uBAAuB,EAAE,KAAK,EAAE,MAAM,GAAG,uBAAuB;IAqB3E,QAAQ,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAW1C,WAAW,IAAI,IAAI;CAwBpB"}

package/dist/gpu-profile.js

@@ -1,120 +0,0 @@
-// WebGPU timestamp-query profiling. Records pass durations into the same
-// profiler module as CPU phases (so the snapshot table mixes both with a
-// "gpu." prefix). Read-only — no effect on rendering output.
-//
-// Pattern (per spec):
-//   1. Each render pass declares timestampWrites { begin, end } slot indices.
-//   2. After all passes, encoder.resolveQuerySet writes uint64 ns timestamps
-//      into a QUERY_RESOLVE buffer.
-//   3. We copy the resolve buffer into a MAP_READ readback buffer.
-//   4. Submit. After the GPU finishes, mapAsync resolves; we read durations
-//      and record them.
-//
-// One readback buffer with an in-flight gate: if mapAsync hasn't resolved
-// from a previous frame, we skip the copy this frame (no contention, just
-// one frame of dropped sampling).
-import { profiler } from "./physics/profile";
-const MAX_PASSES_PER_FRAME = 64;
-export class GpuTimestamp {
-    constructor(device) {
-        this.enabled = false;
-        this.querySet = null;
-        this.resolveBuffer = null;
-        this.readbackBuffer = null;
-        this.nextSlot = 0;
-        this.frameLabels = [];
-        this.inFlight = false;
-        // Set inside endFrame() when a copy was queued this frame; consumed by
-        // afterSubmit() to kick mapAsync. mapAsync must run AFTER queue.submit —
-        // calling it before submit puts the buffer into "mapping pending" state,
-        // which makes the copy in the encoder illegal.
-        this.pendingLabels = null;
-        this.device = device;
-        this.supported = device.features.has("timestamp-query");
-    }
-    ensureCreated() {
-        if (this.querySet || !this.supported)
-            return;
-        const slots = MAX_PASSES_PER_FRAME * 2;
-        this.querySet = this.device.createQuerySet({ type: "timestamp", count: slots });
-        this.resolveBuffer = this.device.createBuffer({
-            label: "gpu-timestamp-resolve",
-            size: slots * 8,
-            usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC,
-        });
-        this.readbackBuffer = this.device.createBuffer({
-            label: "gpu-timestamp-readback",
-            size: slots * 8,
-            usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
-        });
-    }
-    // Called once at the top of each render() before any pass wrap.
-    beginFrame() {
-        if (!this.enabled || !this.supported)
-            return;
-        this.ensureCreated();
-        this.nextSlot = 0;
-        this.frameLabels = [];
-    }
-    // Wrap a render-pass descriptor with timestampWrites for `label`. If
-    // profiling is off / unsupported / out of slots, returns desc unchanged.
-    // The same label called multiple times (e.g. each bloom mip) is fine —
-    // the profiler accumulates by label.
-    wrap(desc, label) {
-        if (!this.enabled || !this.querySet)
-            return desc;
-        if (this.nextSlot + 2 > MAX_PASSES_PER_FRAME * 2)
-            return desc;
-        const begin = this.nextSlot;
-        const end = this.nextSlot + 1;
-        this.nextSlot += 2;
-        this.frameLabels.push(label);
-        return {
-            ...desc,
-            timestampWrites: {
-                querySet: this.querySet,
-                beginningOfPassWriteIndex: begin,
-                endOfPassWriteIndex: end,
-            },
-        };
-    }
-    // Call on the encoder after all passes, BEFORE encoder.finish(). Adds
-    // resolveQuerySet + copyBufferToBuffer commands. mapAsync is deferred to
-    // afterSubmit() — calling it before submit transitions the readback buffer
-    // into "mapping pending" state, which makes the queued copy illegal.
-    endFrame(encoder) {
-        if (!this.enabled || !this.querySet || this.frameLabels.length === 0)
-            return;
-        const count = this.frameLabels.length * 2;
-        encoder.resolveQuerySet(this.querySet, 0, count, this.resolveBuffer, 0);
-        if (this.inFlight)
-            return;
-        encoder.copyBufferToBuffer(this.resolveBuffer, 0, this.readbackBuffer, 0, count * 8);
-        this.pendingLabels = this.frameLabels.slice();
-    }
-    // Call AFTER device.queue.submit(). Kicks mapAsync if a copy was queued
-    // this frame; the .then() reads durations and unmaps.
-    afterSubmit() {
-        const labels = this.pendingLabels;
-        if (!labels)
-            return;
-        this.pendingLabels = null;
-        this.inFlight = true;
-        const readback = this.readbackBuffer;
-        void readback.mapAsync(GPUMapMode.READ).then(() => {
-            const arr = new BigInt64Array(readback.getMappedRange());
-            for (let i = 0; i < labels.length; i++) {
-                const start = arr[i * 2];
-                const end = arr[i * 2 + 1];
-                // Per spec, timestamps are nanoseconds.
-                const ms = Number(end - start) / 1e6;
-                if (ms >= 0 && ms < 1000)
-                    profiler.record("gpu." + labels[i], ms);
-            }
-            readback.unmap();
-            this.inFlight = false;
-        }, () => {
-            this.inFlight = false;
-        });
-    }
-}

package/dist/physics/physics.worker.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=physics.worker.d.ts.map

package/dist/physics/physics.worker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"physics.worker.d.ts","sourceRoot":"","sources":["../../src/physics/physics.worker.ts"],"names":[],"mappings":""}

package/dist/physics/physics.worker.js

@@ -1,52 +0,0 @@
-// Physics worker: owns ONE model's RezePhysics world. The host posts the
-// frame's bone world matrices as a transferable buffer; the worker steps the
-// simulation (identical math to the main-thread path — same class, same code)
-// and returns the buffer with the dynamic bones' matrices written back, plus
-// its own step cost for the host's stats.
-//
-// The incoming buffer is COPIED into a persistent local pose (and back out)
-// rather than wrapped: transferred ArrayBuffers get a fresh identity on every
-// hop, so wrappers could never be cached against them — and two ~20KB copies
-// per frame are microseconds.
-import { RezePhysics } from "./physics";
-import { Mat4 } from "../math";
-import { RigidbodyType } from "./types";
-const ctx = self;
-let physics = null;
-let inverseBind = new Float32Array(0);
-let pose = new Float32Array(0);
-let mats = [];
-ctx.onmessage = (e) => {
-    const msg = e.data;
-    if (msg.cmd === "init") {
-        physics = new RezePhysics(msg.rigidbodies, msg.joints);
-        inverseBind = msg.inverseBind;
-        const boneCount = inverseBind.length / 16;
-        pose = new Float32Array(boneCount * 16);
-        mats = new Array(boneCount);
-        for (let i = 0; i < boneCount; i++)
-            mats[i] = new Mat4(pose.subarray(i * 16, i * 16 + 16));
-        // The host copies back only the bones physics can write — the bones of
-        // dynamic bodies. Kinematic bones must NOT round-trip: in the pipelined
-        // protocol they would drag a stale (frame-old) pose over the live one.
-        const dynamicBones = [];
-        for (const rb of msg.rigidbodies) {
-            if (rb.type === RigidbodyType.Dynamic && rb.mass > 0 && rb.boneIndex >= 0)
-                dynamicBones.push(rb.boneIndex);
-        }
-        ctx.postMessage({ cmd: "ready", dynamicBones });
-        return;
-    }
-    if (!physics)
-        return;
-    const incoming = new Float32Array(msg.bones);
-    pose.set(incoming);
-    const t0 = performance.now();
-    if (msg.cmd === "step")
-        physics.step(msg.dt, mats, inverseBind);
-    else
-        physics.reset(mats);
-    const stepMs = performance.now() - t0;
-    incoming.set(pose);
-    ctx.postMessage({ cmd: "stepped", bones: msg.bones, stepMs }, [msg.bones]);
-};

package/dist/physics/profile.d.ts

@@ -1,18 +0,0 @@
-declare class PhysicsProfiler {
-    enabled: boolean;
-    private sums;
-    private counts;
-    begin(): number;
-    end(label: string, t0: number): void;
-    record(label: string, ms: number): void;
-    snapshot(): Record<string, {
-        avgMs: number;
-        calls: number;
-        totalMs: number;
-    }>;
-    reset(): void;
-}
-export declare const profiler: PhysicsProfiler;
-export type ProfileSnapshot = ReturnType<PhysicsProfiler["snapshot"]>;
-export {};
-//# sourceMappingURL=profile.d.ts.map

package/dist/physics/profile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"profile.d.ts","sourceRoot":"","sources":["../../src/physics/profile.ts"],"names":[],"mappings":"AAIA,cAAM,eAAe;IACnB,OAAO,UAAQ;IACf,OAAO,CAAC,IAAI,CAA8C;IAC1D,OAAO,CAAC,MAAM,CAA8C;IAE5D,KAAK,IAAI,MAAM;IAIf,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IASpC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAQvC,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAU7E,KAAK,IAAI,IAAI;CAId;AAED,eAAO,MAAM,QAAQ,iBAAwB,CAAA;AAC7C,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAA"}

package/dist/physics/profile.js

@@ -1,44 +0,0 @@
-// Per-phase wall-clock accumulator. Off by default — when `enabled` is false,
-// begin()/end() short-circuit so production has zero overhead. Toggle via
-// `RezePhysics.setProfileEnabled(true)` and read with `getProfile()`.
-class PhysicsProfiler {
-    constructor() {
-        this.enabled = false;
-        this.sums = Object.create(null);
-        this.counts = Object.create(null);
-    }
-    begin() {
-        return this.enabled ? performance.now() : 0;
-    }
-    end(label, t0) {
-        if (!this.enabled)
-            return;
-        const dt = performance.now() - t0;
-        this.sums[label] = (this.sums[label] ?? 0) + dt;
-        this.counts[label] = (this.counts[label] ?? 0) + 1;
-    }
-    // Direct accumulator for durations not measured via begin()/end() — used by
-    // GPU timestamp readback, which arrives async after the frame has ended.
-    record(label, ms) {
-        if (!this.enabled)
-            return;
-        this.sums[label] = (this.sums[label] ?? 0) + ms;
-        this.counts[label] = (this.counts[label] ?? 0) + 1;
-    }
-    // Snapshot since last reset(). avgMs is per call; totalMs is the cumulative
-    // window cost — divide by elapsed wall time to get a "% of frame budget".
-    snapshot() {
-        const out = {};
-        for (const k in this.sums) {
-            const total = this.sums[k];
-            const calls = this.counts[k];
-            out[k] = { avgMs: calls > 0 ? total / calls : 0, calls, totalMs: total };
-        }
-        return out;
-    }
-    reset() {
-        this.sums = Object.create(null);
-        this.counts = Object.create(null);
-    }
-}
-export const profiler = new PhysicsProfiler();

package/dist/physics/worker-physics.d.ts

@@ -1,28 +0,0 @@
-import type { Rigidbody, Joint } from "./types";
-import type { Mat4 } from "../math";
-export declare class WorkerPhysics {
-    private readonly worker;
-    private dynamicBones;
-    private readonly boneCount;
-    /** Transfer buffer when idle; null while a step is in flight. */
-    private buf;
-    /** Latest completed pose from the worker (copied out of the transfer buffer). */
-    private readonly result;
-    private hasResult;
-    private pendingDt;
-    private queuedReset;
-    /** Worker-side cost of the last completed step — for engine stats. */
-    stepMs: number;
-    private constructor();
-    static supported(): boolean;
-    static create(rigidbodies: Rigidbody[], joints: Joint[], inverseBind: Float32Array): Promise<WorkerPhysics>;
-    /** Same signature as RezePhysics.step — the engine cannot tell them apart.
-     *  (inverseBind was shipped to the worker at init; the param is unused.) */
-    step(dt: number, boneWorldMatrices: Mat4[], _inverseBind: Float32Array): void;
-    /** Reset rides the same pipeline: the next posted frame carries a reset
-     *  command instead of a step, and stale results stop applying immediately. */
-    reset(boneWorldMatrices: Mat4[]): void;
-    dispose(): void;
-    private onStepped;
-}
-//# sourceMappingURL=worker-physics.d.ts.map

package/dist/physics/worker-physics.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"worker-physics.d.ts","sourceRoot":"","sources":["../../src/physics/worker-physics.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAYnC,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;IAClC,iEAAiE;IACjE,OAAO,CAAC,GAAG,CAAoB;IAC/B,iFAAiF;IACjF,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,SAAS,CAAI;IACrB,OAAO,CAAC,WAAW,CAAQ;IAC3B,sEAAsE;IACtE,MAAM,SAAI;IAEV,OAAO;IAOP,MAAM,CAAC,SAAS,IAAI,OAAO;IAI3B,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,SAAS,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,WAAW,EAAE,YAAY,GAAG,OAAO,CAAC,aAAa,CAAC;IA6B3G;gFAC4E;IAC5E,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE,IAAI,EAAE,EAAE,YAAY,EAAE,YAAY,GAAG,IAAI;IAuB7E;kFAC8E;IAC9E,KAAK,CAAC,iBAAiB,EAAE,IAAI,EAAE,GAAG,IAAI;IAOtC,OAAO,IAAI,IAAI;IAIf,OAAO,CAAC,SAAS;CAQlB"}