@cimplify/sdk 0.109.0 → 0.111.0

package/dist/{chunk-W77VO6LP.js → chunk-J5AJNY2N.js}

@@ -1,11 +1,11 @@
 'use strict';
 
-var chunkB54P6RL2_js = require('./chunk-B54P6RL2.js');
+var chunk2AQ237Y4_js = require('./chunk-2AQ237Y4.js');
 var chunkNH654HAT_js = require('./chunk-NH654HAT.js');
 var chunkWHYKAT7G_js = require('./chunk-WHYKAT7G.js');
-var chunk56BM75QX_js = require('./chunk-56BM75QX.js');
-var chunkHPKKCUHU_js = require('./chunk-HPKKCUHU.js');
-var chunk4CVB2ZTC_js = require('./chunk-4CVB2ZTC.js');
+var chunkH5DFSCJ6_js = require('./chunk-H5DFSCJ6.js');
+var chunk52YS45RR_js = require('./chunk-52YS45RR.js');
+var chunk5LH2QN3T_js = require('./chunk-5LH2QN3T.js');
 var chunkJGBCIKJV_js = require('./chunk-JGBCIKJV.js');
 
 // src/game/kit/blocks/pickups.ts
@@ -37,9 +37,9 @@ var KeepOut = class {
   }
   add(x, z, radius) {
     if (this.used * (3) >= this.circles.length) throw new chunkNH654HAT_js.KitError("capacity_exceeded", "the keep-out areas are full");
-    let fx = Math.trunc(x * chunk4CVB2ZTC_js.CENTERED_FIXED_UNITS), fz = Math.trunc(z * chunk4CVB2ZTC_js.CENTERED_FIXED_UNITS), fr = Math.trunc(radius * chunk4CVB2ZTC_js.CENTERED_FIXED_UNITS);
+    let fx = Math.trunc(x * chunk5LH2QN3T_js.CENTERED_FIXED_UNITS), fz = Math.trunc(z * chunk5LH2QN3T_js.CENTERED_FIXED_UNITS), fr = Math.trunc(radius * chunk5LH2QN3T_js.CENTERED_FIXED_UNITS);
     if (!(Math.abs(fx) < FIXED_LIMIT && Math.abs(fz) < FIXED_LIMIT && fr >= 0 && fr < FIXED_LIMIT))
-      throw new chunkNH654HAT_js.KitError("invalid_declaration", `keep-out areas must lie within ${FIXED_LIMIT / chunk4CVB2ZTC_js.CENTERED_FIXED_UNITS} m of the origin`);
+      throw new chunkNH654HAT_js.KitError("invalid_declaration", `keep-out areas must lie within ${FIXED_LIMIT / chunk5LH2QN3T_js.CENTERED_FIXED_UNITS} m of the origin`);
     let o = this.used * (3);
     return this.circles[o] = x, this.circles[o + 1] = z, this.circles[o + 2] = radius, this.fixed[o] = fx, this.fixed[o + 1] = fz, this.fixed[o + 2] = fr, squareInto(this.squares, this.used * (2), fr), this.used++;
   }
@@ -89,8 +89,8 @@ var KeepOut = class {
     p[o + 1] = y, this.activate(slot, kind);
   }
   respawn(slot, random, halfExtent, keepOut = null) {
-    if ((halfExtent | 0) !== halfExtent || halfExtent < 1 || halfExtent >= chunk4CVB2ZTC_js.CENTERED_MAX_EXTENT)
-      throw new chunkNH654HAT_js.KitError("invalid_declaration", `respawn needs a whole half extent from 1 to ${chunk4CVB2ZTC_js.CENTERED_MAX_EXTENT - 1}`);
+    if ((halfExtent | 0) !== halfExtent || halfExtent < 1 || halfExtent >= chunk5LH2QN3T_js.CENTERED_MAX_EXTENT)
+      throw new chunkNH654HAT_js.KitError("invalid_declaration", `respawn needs a whole half extent from 1 to ${chunk5LH2QN3T_js.CENTERED_MAX_EXTENT - 1}`);
     let p = this.positions, o = slot * (3), f = this.candidate;
     for (let tries = 0; tries < (64) && (random.centeredInto(p, o, halfExtent, f, 0), random.centeredInto(p, o + 2, halfExtent, f, 1), !(keepOut === null || keepOut.clearFixed(f, 0))); tries++)
       ;
@@ -155,11 +155,11 @@ var UNBOUND = -1, GOAL_X = 0, GOAL_Z = 1, DEFAULT_ARRIVE = 0.6, NEVER = 0, DEFAU
   }
   drive(game, rig, goal, frame) {
     let x = goal[(0)], z = goal[(1)], input = game.input;
-    this.slotX === (-1) && (this.slotX = input.virtualControl(chunkB54P6RL2_js.TOUCH_CONTROLS.moveX), this.slotY = input.virtualControl(chunkB54P6RL2_js.TOUCH_CONTROLS.moveY), this.slotJump = input.virtualControl(chunkB54P6RL2_js.TOUCH_CONTROLS.jump));
+    this.slotX === (-1) && (this.slotX = input.virtualControl(chunk2AQ237Y4_js.TOUCH_CONTROLS.moveX), this.slotY = input.virtualControl(chunk2AQ237Y4_js.TOUCH_CONTROLS.moveY), this.slotJump = input.virtualControl(chunk2AQ237Y4_js.TOUCH_CONTROLS.jump));
     let p = game.transforms.store.fields.position, o = game.transforms.row(rig.entity) * 3, wx = x - p[o], wz = z - p[o + 2], length = (wx * wx + wz * wz) ** 0.5;
     length > this.arrive ? (wx /= length, wz /= length) : (wx = 0, wz = 0);
-    let yaw = rig.camera.state[chunkHPKKCUHU_js.FOLLOW_YAW], sy = Math.sin(yaw), cy = Math.cos(yaw), stage = input.stage, t = chunk56BM75QX_js.templateFrameStamp(frame);
-    stage[chunk4CVB2ZTC_js.STAGE_X] = cy * wx - sy * wz, stage[chunk4CVB2ZTC_js.STAGE_TIME] = t, input.virtualStaged(this.slotX), stage[chunk4CVB2ZTC_js.STAGE_X] = -sy * wx - cy * wz, stage[chunk4CVB2ZTC_js.STAGE_TIME] = t, input.virtualStaged(this.slotY), this.jumpEvery > (0) && frame % this.jumpEvery === 0 && rig.motor.state[chunkHPKKCUHU_js.CHAR_SPEED] > 0 && (this.jumpHeld = this.jumpHold), stage[chunk4CVB2ZTC_js.STAGE_X] = this.jumpHeld > 0 ? 1 : 0, stage[chunk4CVB2ZTC_js.STAGE_TIME] = t, input.virtualStaged(this.slotJump), this.jumpHeld > 0 && this.jumpHeld--;
+    let yaw = rig.camera.state[chunk52YS45RR_js.FOLLOW_YAW], sy = Math.sin(yaw), cy = Math.cos(yaw), stage = input.stage, t = chunkH5DFSCJ6_js.templateFrameStamp(frame);
+    stage[chunk5LH2QN3T_js.STAGE_X] = cy * wx - sy * wz, stage[chunk5LH2QN3T_js.STAGE_TIME] = t, input.virtualStaged(this.slotX), stage[chunk5LH2QN3T_js.STAGE_X] = -sy * wx - cy * wz, stage[chunk5LH2QN3T_js.STAGE_TIME] = t, input.virtualStaged(this.slotY), this.jumpEvery > (0) && frame % this.jumpEvery === 0 && rig.motor.state[chunk52YS45RR_js.CHAR_SPEED] > 0 && (this.jumpHeld = this.jumpHold), stage[chunk5LH2QN3T_js.STAGE_X] = this.jumpHeld > 0 ? 1 : 0, stage[chunk5LH2QN3T_js.STAGE_TIME] = t, input.virtualStaged(this.slotJump), this.jumpHeld > 0 && this.jumpHeld--;
   }
 };
 
@@ -203,7 +203,7 @@ var COURIER = {
       let angle = c / COURIER.crates * Math.PI * 2, x = Math.cos(angle) * COURIER.parcelSpread * (0.5), z = Math.sin(angle) * COURIER.parcelSpread * (0.5);
       this.crates.set([x, COURIER.crateHalf, z], c * 3), staticBox(game, x, COURIER.crateHalf, z, COURIER.crateHalf, COURIER.crateHalf, COURIER.crateHalf), this.keepOut.add(x, z, COURIER.crateHalf + COURIER.pickupRadius);
     }
-    daylight(game), this.rig = chunkB54P6RL2_js.thirdPersonCharacter(game, { position: [0, 0, -COURIER.dropRadius * 2], register: false }), this.boxes = new chunkWHYKAT7G_js.BoxBatch(game, (16)), this.pickups.scatter((0), game.random, COURIER.parcelSpread, COURIER.parcelLift, this.keepOut);
+    daylight(game), this.rig = chunk2AQ237Y4_js.thirdPersonCharacter(game, { position: [0, 0, -COURIER.dropRadius * 2], register: false }), this.boxes = new chunkWHYKAT7G_js.BoxBatch(game, (16)), this.pickups.scatter((0), game.random, COURIER.parcelSpread, COURIER.parcelLift, this.keepOut);
   }
   fixedUpdate(game) {
     let rig = this.rig;
@@ -255,7 +255,7 @@ var COURIER = {
       let p = game.transforms.store.fields.position, o = game.transforms.row(rig.entity) * 3;
       d[4] = p[o], d[5] = p[o + 2];
     }
-    return chunk56BM75QX_js.digestFloats(d, (6));
+    return chunkH5DFSCJ6_js.digestFloats(d, (6));
   }
 };
 

package/dist/{chunk-UKA7LHIT.js → chunk-JR3TNEQC.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkBS65NRDW_js = require('./chunk-BS65NRDW.js');
+var chunk3S6WPBZL_js = require('./chunk-3S6WPBZL.js');
 var chunk2V7IL4HC_js = require('./chunk-2V7IL4HC.js');
 
 // src/game/physics/vehicle-solver.ts
@@ -10,21 +10,21 @@ function clamp(value, low, high) {
   return lifted < high ? lifted : high;
 }
 function curve(desc, at, io, slot) {
-  let slip = io[slot], n = desc[at + chunkBS65NRDW_js.CURVE_POINTS], peak = 0;
-  for (let k = 1; k < n; k++) desc[at + chunkBS65NRDW_js.CURVE_VALUE + k] > desc[at + chunkBS65NRDW_js.CURVE_VALUE + peak] && (peak = k);
-  if (slip <= desc[at + chunkBS65NRDW_js.CURVE_SLIP + peak]) {
-    io[slot] = desc[at + chunkBS65NRDW_js.CURVE_VALUE + peak];
+  let slip = io[slot], n = desc[at + chunk3S6WPBZL_js.CURVE_POINTS], peak = 0;
+  for (let k = 1; k < n; k++) desc[at + chunk3S6WPBZL_js.CURVE_VALUE + k] > desc[at + chunk3S6WPBZL_js.CURVE_VALUE + peak] && (peak = k);
+  if (slip <= desc[at + chunk3S6WPBZL_js.CURVE_SLIP + peak]) {
+    io[slot] = desc[at + chunk3S6WPBZL_js.CURVE_VALUE + peak];
     return;
   }
   for (let k = peak + 1; k < n; k++) {
-    let s1 = desc[at + chunkBS65NRDW_js.CURVE_SLIP + k];
+    let s1 = desc[at + chunk3S6WPBZL_js.CURVE_SLIP + k];
     if (slip < s1) {
-      let s0 = desc[at + chunkBS65NRDW_js.CURVE_SLIP + k - 1], v0 = desc[at + chunkBS65NRDW_js.CURVE_VALUE + k - 1];
-      io[slot] = v0 + (desc[at + chunkBS65NRDW_js.CURVE_VALUE + k] - v0) * ((slip - s0) / (s1 - s0));
+      let s0 = desc[at + chunk3S6WPBZL_js.CURVE_SLIP + k - 1], v0 = desc[at + chunk3S6WPBZL_js.CURVE_VALUE + k - 1];
+      io[slot] = v0 + (desc[at + chunk3S6WPBZL_js.CURVE_VALUE + k] - v0) * ((slip - s0) / (s1 - s0));
       return;
     }
   }
-  io[slot] = desc[at + chunkBS65NRDW_js.CURVE_VALUE + n - 1];
+  io[slot] = desc[at + chunk3S6WPBZL_js.CURVE_VALUE + n - 1];
 }
 var R_DT = 0, R_THROTTLE = 1, R_GEAR_REQUEST = 2, R_TORQUE = 3, R_RATIO = 4, R_RESULT = 5, R_IX = 6, R_IY = 7, R_IZ = 8, R_FX = 9, R_FY = 10, R_FZ = 11, R_CURVE = 12, R_VECTOR = 13, REG_WORDS = 16, AXIS_UP = 0, AXIS_FORWARD = 3, AXIS_LEFT = 6, AXES = Float64Array.of(0, 1, 0, 0, 0, 1, -1, 0, 0), VehicleSolver = class {
   constructor(world) {
@@ -54,9 +54,9 @@ var R_DT = 0, R_THROTTLE = 1, R_GEAR_REQUEST = 2, R_TORQUE = 3, R_RATIO = 4, R_R
   reserve(capacity) {
     if (!(capacity <= this.capacity)) {
       if (this.activeCount > 0) throw new chunk2V7IL4HC_js.GameError("invalid_argument", "vehicle capacity is fixed once vehicles exist");
-      this.capacity = capacity, this.inputs = new Float32Array(capacity * chunkBS65NRDW_js.INPUT_STRIDE);
-      for (let v = 0; v < capacity; v++) this.inputs[v * chunkBS65NRDW_js.INPUT_STRIDE + chunkBS65NRDW_js.INPUT_GEAR] = chunkBS65NRDW_js.GEAR_AUTO;
-      this.states = new Float32Array(capacity * chunkBS65NRDW_js.STATE_STRIDE), this.descs = new Float32Array(capacity * chunkBS65NRDW_js.VEHICLE_DESC_WORDS), this.runs = new Float64Array(capacity * chunkBS65NRDW_js.MAX_WHEELS * (40)), this.vehicles = new Float64Array(capacity * (8)), this.active = new Int32Array(capacity), this.free = new Int32Array(capacity);
+      this.capacity = capacity, this.inputs = new Float32Array(capacity * chunk3S6WPBZL_js.INPUT_STRIDE);
+      for (let v = 0; v < capacity; v++) this.inputs[v * chunk3S6WPBZL_js.INPUT_STRIDE + chunk3S6WPBZL_js.INPUT_GEAR] = chunk3S6WPBZL_js.GEAR_AUTO;
+      this.states = new Float32Array(capacity * chunk3S6WPBZL_js.STATE_STRIDE), this.descs = new Float32Array(capacity * chunk3S6WPBZL_js.VEHICLE_DESC_WORDS), this.runs = new Float64Array(capacity * chunk3S6WPBZL_js.MAX_WHEELS * (40)), this.vehicles = new Float64Array(capacity * (8)), this.active = new Int32Array(capacity), this.free = new Int32Array(capacity);
       for (let v = 0; v < capacity; v++) this.free[v] = capacity - 1 - v;
       this.freeCount = capacity;
     }
@@ -64,16 +64,16 @@ var R_DT = 0, R_THROTTLE = 1, R_GEAR_REQUEST = 2, R_TORQUE = 3, R_RATIO = 4, R_R
   createVehicle(body, desc) {
     if (this.capacity === 0 && this.reserve((32)), this.freeCount === 0) throw new chunk2V7IL4HC_js.GameError("capacity_exceeded", "vehicle capacity reached");
     let id = this.free[--this.freeCount];
-    this.descs.set(desc.subarray(0, chunkBS65NRDW_js.VEHICLE_DESC_WORDS), id * chunkBS65NRDW_js.VEHICLE_DESC_WORDS);
+    this.descs.set(desc.subarray(0, chunk3S6WPBZL_js.VEHICLE_DESC_WORDS), id * chunk3S6WPBZL_js.VEHICLE_DESC_WORDS);
     let v = id * (8);
-    this.vehicles.fill(0, v, v + (8)), this.vehicles[v + (0)] = body, this.vehicles[v + (2)] = 1, this.vehicles[v + (4)] = desc[chunkBS65NRDW_js.DESC_IDLE_RPM];
-    let wheels = desc[chunkBS65NRDW_js.DESC_WHEEL_COUNT];
-    for (let w = 0; w < chunkBS65NRDW_js.MAX_WHEELS; w++) {
-      let r = (id * chunkBS65NRDW_js.MAX_WHEELS + w) * (40);
-      this.runs.fill(0, r, r + (40)), this.runs[r + (5)] = chunkBS65NRDW_js.NO_GROUND, this.runs[r + (6)] = (-1), w < wheels && (this.runs[r + (3)] = desc[chunkBS65NRDW_js.DESC_HEADER + w * chunkBS65NRDW_js.WHEEL_DESC_WORDS + chunkBS65NRDW_js.WHEEL_DESC_REST]);
+    this.vehicles.fill(0, v, v + (8)), this.vehicles[v + (0)] = body, this.vehicles[v + (2)] = 1, this.vehicles[v + (4)] = desc[chunk3S6WPBZL_js.DESC_IDLE_RPM];
+    let wheels = desc[chunk3S6WPBZL_js.DESC_WHEEL_COUNT];
+    for (let w = 0; w < chunk3S6WPBZL_js.MAX_WHEELS; w++) {
+      let r = (id * chunk3S6WPBZL_js.MAX_WHEELS + w) * (40);
+      this.runs.fill(0, r, r + (40)), this.runs[r + (5)] = chunk3S6WPBZL_js.NO_GROUND, this.runs[r + (6)] = (-1), w < wheels && (this.runs[r + (3)] = desc[chunk3S6WPBZL_js.DESC_HEADER + w * chunk3S6WPBZL_js.WHEEL_DESC_WORDS + chunk3S6WPBZL_js.WHEEL_DESC_REST]);
     }
-    let input = id * chunkBS65NRDW_js.INPUT_STRIDE;
-    return this.inputs.fill(0, input, input + chunkBS65NRDW_js.INPUT_STRIDE), this.inputs[input + chunkBS65NRDW_js.INPUT_GEAR] = chunkBS65NRDW_js.GEAR_AUTO, this.states.fill(0, id * chunkBS65NRDW_js.STATE_STRIDE, (id + 1) * chunkBS65NRDW_js.STATE_STRIDE), this.active[this.activeCount++] = id, id;
+    let input = id * chunk3S6WPBZL_js.INPUT_STRIDE;
+    return this.inputs.fill(0, input, input + chunk3S6WPBZL_js.INPUT_STRIDE), this.inputs[input + chunk3S6WPBZL_js.INPUT_GEAR] = chunk3S6WPBZL_js.GEAR_AUTO, this.states.fill(0, id * chunk3S6WPBZL_js.STATE_STRIDE, (id + 1) * chunk3S6WPBZL_js.STATE_STRIDE), this.active[this.activeCount++] = id, id;
   }
   destroyVehicle(vehicle) {
     for (let k = 0; k < this.activeCount; k++)
@@ -100,8 +100,8 @@ var R_DT = 0, R_THROTTLE = 1, R_GEAR_REQUEST = 2, R_TORQUE = 3, R_RATIO = 4, R_R
     for (let k = 0; k < this.activeCount; k++) this.stepVehicle(this.active[k]);
   }
   stepVehicle(id) {
-    let reg = this.reg, dt = reg[(0)], v = id * (8), body = this.vehicles[v + (0)] | 0, d = id * chunkBS65NRDW_js.VEHICLE_DESC_WORDS, desc = this.descs, i = id * chunkBS65NRDW_js.INPUT_STRIDE, rawThrottle = this.inputs[i + chunkBS65NRDW_js.INPUT_THROTTLE], rawBrake = this.inputs[i + chunkBS65NRDW_js.INPUT_BRAKE], rawSteer = this.inputs[i + chunkBS65NRDW_js.INPUT_STEER], rawHandbrake = this.inputs[i + chunkBS65NRDW_js.INPUT_HANDBRAKE], throttle = rawThrottle > 0 ? rawThrottle < 1 ? rawThrottle : 1 : 0, brake = rawBrake > 0 ? rawBrake < 1 ? rawBrake : 1 : 0, steerInput = rawSteer > -1 ? rawSteer < 1 ? rawSteer : 1 : -1, handbrake = rawHandbrake > 0 ? rawHandbrake < 1 ? rawHandbrake : 1 : 0;
-    reg[(1)] = throttle, reg[(2)] = this.inputs[i + chunkBS65NRDW_js.INPUT_GEAR];
+    let reg = this.reg, dt = reg[(0)], v = id * (8), body = this.vehicles[v + (0)] | 0, d = id * chunk3S6WPBZL_js.VEHICLE_DESC_WORDS, desc = this.descs, i = id * chunk3S6WPBZL_js.INPUT_STRIDE, rawThrottle = this.inputs[i + chunk3S6WPBZL_js.INPUT_THROTTLE], rawBrake = this.inputs[i + chunk3S6WPBZL_js.INPUT_BRAKE], rawSteer = this.inputs[i + chunk3S6WPBZL_js.INPUT_STEER], rawHandbrake = this.inputs[i + chunk3S6WPBZL_js.INPUT_HANDBRAKE], throttle = rawThrottle > 0 ? rawThrottle < 1 ? rawThrottle : 1 : 0, brake = rawBrake > 0 ? rawBrake < 1 ? rawBrake : 1 : 0, steerInput = rawSteer > -1 ? rawSteer < 1 ? rawSteer : 1 : -1, handbrake = rawHandbrake > 0 ? rawHandbrake < 1 ? rawHandbrake : 1 : 0;
+    reg[(1)] = throttle, reg[(2)] = this.inputs[i + chunk3S6WPBZL_js.INPUT_GEAR];
     let active = throttle > 0 || brake > 0 || steerInput !== 0 || handbrake > 0, c = this.chassis;
     if (!this.world.readChassis(body, c)) return;
     if (c[(25)] !== 0) {
@@ -117,77 +117,77 @@ var R_DT = 0, R_THROTTLE = 1, R_GEAR_REQUEST = 2, R_TORQUE = 3, R_RATIO = 4, R_R
     this.rotate(AXES, (3), t, 0);
     let fx = t[0], fy = t[1], fz = t[2];
     reg[(9)] = fx, reg[(10)] = fy, reg[(11)] = fz;
-    let rate = desc[d + chunkBS65NRDW_js.DESC_STEER_RATE] * dt, steerDelta = steerInput * desc[d + chunkBS65NRDW_js.DESC_MAX_STEER] - this.vehicles[v + (1)];
+    let rate = desc[d + chunk3S6WPBZL_js.DESC_STEER_RATE] * dt, steerDelta = steerInput * desc[d + chunk3S6WPBZL_js.DESC_MAX_STEER] - this.vehicles[v + (1)];
     this.vehicles[v + (1)] += steerDelta > -rate ? steerDelta < rate ? steerDelta : rate : -rate;
-    let steer = this.vehicles[v + (1)], wheels = desc[d + chunkBS65NRDW_js.DESC_WHEEL_COUNT] | 0, runs = this.runs, ackermann = desc[d + chunkBS65NRDW_js.DESC_ACKERMANN], fixedZ = 0, fixedCount = 0, allZ = 0;
+    let steer = this.vehicles[v + (1)], wheels = desc[d + chunk3S6WPBZL_js.DESC_WHEEL_COUNT] | 0, runs = this.runs, ackermann = desc[d + chunk3S6WPBZL_js.DESC_ACKERMANN], fixedZ = 0, fixedCount = 0, allZ = 0;
     for (let w = 0; w < wheels; w++) {
-      let wd = d + chunkBS65NRDW_js.DESC_HEADER + w * chunkBS65NRDW_js.WHEEL_DESC_WORDS;
-      allZ += desc[wd + chunkBS65NRDW_js.WHEEL_DESC_POSITION + 2], desc[wd + chunkBS65NRDW_js.WHEEL_DESC_STEER] === 0 && (fixedZ += desc[wd + chunkBS65NRDW_js.WHEEL_DESC_POSITION + 2], fixedCount++);
+      let wd = d + chunk3S6WPBZL_js.DESC_HEADER + w * chunk3S6WPBZL_js.WHEEL_DESC_WORDS;
+      allZ += desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_POSITION + 2], desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_STEER] === 0 && (fixedZ += desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_POSITION + 2], fixedCount++);
     }
     let pivot = fixedCount > 0 ? fixedZ / fixedCount : allZ / Math.max(wheels, 1);
     for (let w = 0; w < wheels; w++) {
-      let r = (id * chunkBS65NRDW_js.MAX_WHEELS + w) * (40), wd = d + chunkBS65NRDW_js.DESC_HEADER + w * chunkBS65NRDW_js.WHEEL_DESC_WORDS;
-      this.rotate(desc, wd + chunkBS65NRDW_js.WHEEL_DESC_POSITION, t, 0);
-      let hx = c[(0)] + t[0], hy = c[(0) + 1] + t[1], hz = c[(0) + 2] + t[2], base = steer * desc[wd + chunkBS65NRDW_js.WHEEL_DESC_STEER], wheelAngle = base;
+      let r = (id * chunk3S6WPBZL_js.MAX_WHEELS + w) * (40), wd = d + chunk3S6WPBZL_js.DESC_HEADER + w * chunk3S6WPBZL_js.WHEEL_DESC_WORDS;
+      this.rotate(desc, wd + chunk3S6WPBZL_js.WHEEL_DESC_POSITION, t, 0);
+      let hx = c[(0)] + t[0], hy = c[(0) + 1] + t[1], hz = c[(0) + 2] + t[2], base = steer * desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_STEER], wheelAngle = base;
       if (ackermann > 0 && base !== 0) {
-        let reach2 = desc[wd + chunkBS65NRDW_js.WHEEL_DESC_POSITION + 2] - pivot, b = base > -chunkBS65NRDW_js.STEER_LIMIT ? base < chunkBS65NRDW_js.STEER_LIMIT ? base : chunkBS65NRDW_js.STEER_LIMIT : -chunkBS65NRDW_js.STEER_LIMIT, tangent = Math.sin(b) / Math.cos(b), denominator = desc[wd + chunkBS65NRDW_js.WHEEL_DESC_POSITION] * tangent + reach2;
+        let reach2 = desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_POSITION + 2] - pivot, b = base > -chunk3S6WPBZL_js.STEER_LIMIT ? base < chunk3S6WPBZL_js.STEER_LIMIT ? base : chunk3S6WPBZL_js.STEER_LIMIT : -chunk3S6WPBZL_js.STEER_LIMIT, tangent = Math.sin(b) / Math.cos(b), denominator = desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_POSITION] * tangent + reach2;
         denominator * reach2 > (1e-4) && (wheelAngle = base + (Math.atan(reach2 * tangent / denominator) - base) * ackermann);
       }
-      let angle = wheelAngle > -chunkBS65NRDW_js.STEER_LIMIT ? wheelAngle < chunkBS65NRDW_js.STEER_LIMIT ? wheelAngle : chunkBS65NRDW_js.STEER_LIMIT : -chunkBS65NRDW_js.STEER_LIMIT;
+      let angle = wheelAngle > -chunk3S6WPBZL_js.STEER_LIMIT ? wheelAngle < chunk3S6WPBZL_js.STEER_LIMIT ? wheelAngle : chunk3S6WPBZL_js.STEER_LIMIT : -chunk3S6WPBZL_js.STEER_LIMIT;
       runs[r + (2)] = wheelAngle;
       let s = Math.sin(angle), co = Math.cos(angle);
       reg[(13)] = -s, reg[(13) + 1] = 0, reg[(13) + 2] = co, this.rotate(reg, (13), runs, r + (16)), reg[(13)] = -co, reg[(13) + 2] = -s, this.rotate(reg, (13), runs, r + (19));
-      let radius = desc[wd + chunkBS65NRDW_js.WHEEL_DESC_RADIUS], rest = desc[wd + chunkBS65NRDW_js.WHEEL_DESC_REST], travel = desc[wd + chunkBS65NRDW_js.WHEEL_DESC_TRAVEL], shortest = rest - travel, longest = rest + travel, reach = longest + radius;
+      let radius = desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_RADIUS], rest = desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_REST], travel = desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_TRAVEL], shortest = rest - travel, longest = rest + travel, reach = longest + radius;
       this.origin[0] = hx, this.origin[1] = hy, this.origin[2] = hz, this.direction[0] = -ux, this.direction[1] = -uy, this.direction[2] = -uz;
       let hit = this.hit;
       hit[(0)] = reach;
       let collider = this.world.castWheel(body, this.origin, this.direction, hit);
-      if (collider !== chunkBS65NRDW_js.NO_GROUND) {
+      if (collider !== chunk3S6WPBZL_js.NO_GROUND) {
         let toi = hit[(0)], nx = hit[(1)], ny = hit[(1) + 1], nz = hit[(1) + 2];
         nx * nx + ny * ny + nz * nz < 0.5 && (nx = ux, ny = uy, nz = uz), runs[r + (4)] = 1, runs[r + (13)] = nx, runs[r + (13) + 1] = ny, runs[r + (13) + 2] = nz;
         let span = toi - radius;
         runs[r + (3)] = span > shortest ? span < longest ? span : longest : shortest, runs[r + (10)] = hx - ux * toi, runs[r + (10) + 1] = hy - uy * toi, runs[r + (10) + 2] = hz - uz * toi, runs[r + (5)] = collider, runs[r + (6)] = hit[(7)], runs[r + (25)] = hit[(4)], runs[r + (25) + 1] = hit[(4) + 1], runs[r + (25) + 2] = hit[(4) + 2];
       } else
-        runs[r + (4)] = 0, runs[r + (13)] = ux, runs[r + (13) + 1] = uy, runs[r + (13) + 2] = uz, runs[r + (3)] = longest, runs[r + (10)] = hx - ux * reach, runs[r + (10) + 1] = hy - uy * reach, runs[r + (10) + 2] = hz - uz * reach, runs[r + (5)] = chunkBS65NRDW_js.NO_GROUND, runs[r + (6)] = (-1), runs[r + (25)] = 0, runs[r + (25) + 1] = 0, runs[r + (25) + 2] = 0;
+        runs[r + (4)] = 0, runs[r + (13)] = ux, runs[r + (13) + 1] = uy, runs[r + (13) + 2] = uz, runs[r + (3)] = longest, runs[r + (10)] = hx - ux * reach, runs[r + (10) + 1] = hy - uy * reach, runs[r + (10) + 2] = hz - uz * reach, runs[r + (5)] = chunk3S6WPBZL_js.NO_GROUND, runs[r + (6)] = (-1), runs[r + (25)] = 0, runs[r + (25) + 1] = 0, runs[r + (25) + 2] = 0;
       let length = runs[r + (3)];
       runs[r + (7)] = hx - ux * length, runs[r + (7) + 1] = hy - uy * length, runs[r + (7) + 2] = hz - uz * length;
     }
     for (let w = 0; w < wheels; w++) {
-      let r = (id * chunkBS65NRDW_js.MAX_WHEELS + w) * (40), wd = d + chunkBS65NRDW_js.DESC_HEADER + w * chunkBS65NRDW_js.WHEEL_DESC_WORDS;
+      let r = (id * chunk3S6WPBZL_js.MAX_WHEELS + w) * (40), wd = d + chunk3S6WPBZL_js.DESC_HEADER + w * chunk3S6WPBZL_js.WHEEL_DESC_WORDS;
       if (runs[r + (4)] === 0) {
         runs[r + (28)] = 0;
         continue;
       }
       runs[r + (22)] = runs[r + (10)] - c[(13)], runs[r + (22) + 1] = runs[r + (10) + 1] - c[(13) + 1], runs[r + (22) + 2] = runs[r + (10) + 2] - c[(13) + 2], this.relativeVelocity(r, t);
-      let compression = -(t[0] * ux + t[1] * uy + t[2] * uz), damping = compression > 0 ? desc[wd + chunkBS65NRDW_js.WHEEL_DESC_COMPRESSION] : desc[wd + chunkBS65NRDW_js.WHEEL_DESC_RELAXATION], force = desc[wd + chunkBS65NRDW_js.WHEEL_DESC_STIFFNESS] * (desc[wd + chunkBS65NRDW_js.WHEEL_DESC_REST] - runs[r + (3)]) + damping * compression, maxForce = desc[wd + chunkBS65NRDW_js.WHEEL_DESC_MAX_FORCE];
+      let compression = -(t[0] * ux + t[1] * uy + t[2] * uz), damping = compression > 0 ? desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_COMPRESSION] : desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_RELAXATION], force = desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_STIFFNESS] * (desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_REST] - runs[r + (3)]) + damping * compression, maxForce = desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_MAX_FORCE];
       runs[r + (28)] = force > 0 ? force < maxForce ? force : maxForce : 0;
     }
-    let antiRoll = desc[d + chunkBS65NRDW_js.DESC_ANTI_ROLL];
+    let antiRoll = desc[d + chunk3S6WPBZL_js.DESC_ANTI_ROLL];
     if (antiRoll > 0)
       for (let a = 0; a < wheels; a++) {
-        let axle = desc[d + chunkBS65NRDW_js.DESC_HEADER + a * chunkBS65NRDW_js.WHEEL_DESC_WORDS + chunkBS65NRDW_js.WHEEL_DESC_AXLE];
-        if (axle !== chunkBS65NRDW_js.NO_AXLE)
+        let axle = desc[d + chunk3S6WPBZL_js.DESC_HEADER + a * chunk3S6WPBZL_js.WHEEL_DESC_WORDS + chunk3S6WPBZL_js.WHEEL_DESC_AXLE];
+        if (axle !== chunk3S6WPBZL_js.NO_AXLE)
           for (let b = a + 1; b < wheels; b++) {
-            if (desc[d + chunkBS65NRDW_js.DESC_HEADER + b * chunkBS65NRDW_js.WHEEL_DESC_WORDS + chunkBS65NRDW_js.WHEEL_DESC_AXLE] !== axle) continue;
-            let ra = (id * chunkBS65NRDW_js.MAX_WHEELS + a) * (40), rb = (id * chunkBS65NRDW_js.MAX_WHEELS + b) * (40), bar = (runs[rb + (3)] - runs[ra + (3)]) * antiRoll;
+            if (desc[d + chunk3S6WPBZL_js.DESC_HEADER + b * chunk3S6WPBZL_js.WHEEL_DESC_WORDS + chunk3S6WPBZL_js.WHEEL_DESC_AXLE] !== axle) continue;
+            let ra = (id * chunk3S6WPBZL_js.MAX_WHEELS + a) * (40), rb = (id * chunk3S6WPBZL_js.MAX_WHEELS + b) * (40), bar = (runs[rb + (3)] - runs[ra + (3)]) * antiRoll;
             runs[ra + (4)] !== 0 && (runs[ra + (28)] = Math.max(runs[ra + (28)] + bar, 0)), runs[rb + (4)] !== 0 && (runs[rb + (28)] = Math.max(runs[rb + (28)] - bar, 0));
           }
       }
     for (let w = 0; w < wheels; w++) {
-      let r = (id * chunkBS65NRDW_js.MAX_WHEELS + w) * (40);
+      let r = (id * chunk3S6WPBZL_js.MAX_WHEELS + w) * (40);
       if (runs[r + (4)] === 0 || runs[r + (28)] <= 0) continue;
       let amount = runs[r + (28)] * dt;
       reg[(6)] = runs[r + (13)] * amount, reg[(7)] = runs[r + (13) + 1] * amount, reg[(8)] = runs[r + (13) + 2] * amount, this.applyImpulse(r);
     }
     this.drivetrain(id, d, wheels);
-    let torque = reg[(3)], rolling = desc[d + chunkBS65NRDW_js.DESC_ROLLING];
+    let torque = reg[(3)], rolling = desc[d + chunk3S6WPBZL_js.DESC_ROLLING];
     for (let w = 0; w < wheels; w++) {
-      let r = (id * chunkBS65NRDW_js.MAX_WHEELS + w) * (40), wd = d + chunkBS65NRDW_js.DESC_HEADER + w * chunkBS65NRDW_js.WHEEL_DESC_WORDS, inertia = runs[r + (37)], wheelTorque = torque * desc[wd + chunkBS65NRDW_js.WHEEL_DESC_DRIVE] + desc[wd + chunkBS65NRDW_js.WHEEL_DESC_SIDE] * desc[d + chunkBS65NRDW_js.DESC_SKID_TORQUE] * steerInput, omega = runs[r + (0)] + wheelTorque / inertia * dt, braking = (brake * desc[wd + chunkBS65NRDW_js.WHEEL_DESC_BRAKE] + handbrake * desc[wd + chunkBS65NRDW_js.WHEEL_DESC_HANDBRAKE]) / inertia * dt, damping = runs[r + (4)] !== 0 ? rolling : (0.5);
+      let r = (id * chunk3S6WPBZL_js.MAX_WHEELS + w) * (40), wd = d + chunk3S6WPBZL_js.DESC_HEADER + w * chunk3S6WPBZL_js.WHEEL_DESC_WORDS, inertia = runs[r + (37)], wheelTorque = torque * desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_DRIVE] + desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_SIDE] * desc[d + chunk3S6WPBZL_js.DESC_SKID_TORQUE] * steerInput, omega = runs[r + (0)] + wheelTorque / inertia * dt, braking = (brake * desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_BRAKE] + handbrake * desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_HANDBRAKE]) / inertia * dt, damping = runs[r + (4)] !== 0 ? rolling : (0.5);
       omega -= omega * Math.min(damping * dt, 1), runs[r + (0)] = omega, runs[r + (38)] = braking, this.brakeTowardRest(r);
     }
-    let handbrakeGrip = 1 + (desc[d + chunkBS65NRDW_js.DESC_HANDBRAKE_GRIP] - 1) * handbrake, lift = desc[d + chunkBS65NRDW_js.DESC_FORCE_HEIGHT];
+    let handbrakeGrip = 1 + (desc[d + chunk3S6WPBZL_js.DESC_HANDBRAKE_GRIP] - 1) * handbrake, lift = desc[d + chunk3S6WPBZL_js.DESC_FORCE_HEIGHT];
     for (let w = 0; w < wheels; w++) {
-      let r = (id * chunkBS65NRDW_js.MAX_WHEELS + w) * (40), wd = d + chunkBS65NRDW_js.DESC_HEADER + w * chunkBS65NRDW_js.WHEEL_DESC_WORDS;
+      let r = (id * chunk3S6WPBZL_js.MAX_WHEELS + w) * (40), wd = d + chunk3S6WPBZL_js.DESC_HEADER + w * chunk3S6WPBZL_js.WHEEL_DESC_WORDS;
       if (runs[r + (35)] = 0, runs[r + (36)] = 0, runs[r + (4)] === 0) {
         runs[r + (29)] = 0, runs[r + (30)] = 0;
         continue;
@@ -200,16 +200,16 @@ var R_DT = 0, R_THROTTLE = 1, R_GEAR_REQUEST = 2, R_TORQUE = 3, R_RATIO = 4, R_R
       ax -= nx * along2, ay -= ny * along2, az -= nz * along2;
       let length = Math.sqrt(ax * ax + ay * ay + az * az), inv = length > 1e-12 ? 1 / length : 0;
       ax *= inv, ay *= inv, az *= inv, runs[r + (16)] = ax, runs[r + (16) + 1] = ay, runs[r + (16) + 2] = az, runs[r + (19)] = ay * nz - az * ny, runs[r + (19) + 1] = az * nx - ax * nz, runs[r + (19) + 2] = ax * ny - ay * nx, this.relativeVelocity(r, t);
-      let vl = t[0] * ax + t[1] * ay + t[2] * az, vt = t[0] * runs[r + (19)] + t[1] * runs[r + (19) + 1] + t[2] * runs[r + (19) + 2], floor = Math.max(Math.abs(vl), (0.5)), radius = desc[wd + chunkBS65NRDW_js.WHEEL_DESC_RADIUS], inertia = runs[r + (37)];
+      let vl = t[0] * ax + t[1] * ay + t[2] * az, vt = t[0] * runs[r + (19)] + t[1] * runs[r + (19) + 1] + t[2] * runs[r + (19) + 2], floor = Math.max(Math.abs(vl), (0.5)), radius = desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_RADIUS], inertia = runs[r + (37)];
       runs[r + (29)] = (runs[r + (0)] * radius - vl) / floor, runs[r + (30)] = Math.abs(vt) / floor, this.inverseMassAlong(r, (16)), runs[r + (31)] = reg[(5)] + radius * radius / inertia, this.inverseMassAlong(r, (19)), runs[r + (32)] = reg[(5)];
-      let grip = desc[wd + chunkBS65NRDW_js.WHEEL_DESC_HANDBRAKE] > 0 ? desc[wd + chunkBS65NRDW_js.WHEEL_DESC_GRIP] * handbrakeGrip : desc[wd + chunkBS65NRDW_js.WHEEL_DESC_GRIP], budget = runs[r + (28)] * dt * grip;
-      reg[(12)] = Math.abs(runs[r + (29)]), curve(desc, wd + chunkBS65NRDW_js.WHEEL_DESC_LONGITUDINAL, reg, (12)), runs[r + (33)] = reg[(12)] * budget, reg[(12)] = runs[r + (30)], curve(desc, wd + chunkBS65NRDW_js.WHEEL_DESC_LATERAL, reg, (12)), runs[r + (34)] = reg[(12)] * budget;
+      let grip = desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_HANDBRAKE] > 0 ? desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_GRIP] * handbrakeGrip : desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_GRIP], budget = runs[r + (28)] * dt * grip;
+      reg[(12)] = Math.abs(runs[r + (29)]), curve(desc, wd + chunk3S6WPBZL_js.WHEEL_DESC_LONGITUDINAL, reg, (12)), runs[r + (33)] = reg[(12)] * budget, reg[(12)] = runs[r + (30)], curve(desc, wd + chunk3S6WPBZL_js.WHEEL_DESC_LATERAL, reg, (12)), runs[r + (34)] = reg[(12)] * budget;
     }
     for (let iteration = 0; iteration < (4); iteration++)
       for (let w = 0; w < wheels; w++) {
-        let r = (id * chunkBS65NRDW_js.MAX_WHEELS + w) * (40);
+        let r = (id * chunk3S6WPBZL_js.MAX_WHEELS + w) * (40);
         if (runs[r + (4)] === 0 || runs[r + (28)] <= 0) continue;
-        let wd = d + chunkBS65NRDW_js.DESC_HEADER + w * chunkBS65NRDW_js.WHEEL_DESC_WORDS, radius = desc[wd + chunkBS65NRDW_js.WHEEL_DESC_RADIUS], inertia = runs[r + (37)];
+        let wd = d + chunk3S6WPBZL_js.DESC_HEADER + w * chunk3S6WPBZL_js.WHEEL_DESC_WORDS, radius = desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_RADIUS], inertia = runs[r + (37)];
         this.relativeVelocity(r, t);
         let vl = t[0] * runs[r + (16)] + t[1] * runs[r + (16) + 1] + t[2] * runs[r + (16) + 2], vt = t[0] * runs[r + (19)] + t[1] * runs[r + (19) + 1] + t[2] * runs[r + (19) + 2], long = runs[r + (35)] - (vl - runs[r + (0)] * radius) / runs[r + (31)], lat = runs[r + (32)] > 0 ? runs[r + (36)] - vt / runs[r + (32)] : runs[r + (36)], ll = runs[r + (33)], lt = runs[r + (34)];
         if (ll <= 0 || lt <= 0)
@@ -225,16 +225,16 @@ var R_DT = 0, R_THROTTLE = 1, R_GEAR_REQUEST = 2, R_TORQUE = 3, R_RATIO = 4, R_R
         runs[r + (35)] = long, runs[r + (36)] = lat, reg[(6)] = runs[r + (16)] * dl + runs[r + (19)] * dt2, reg[(7)] = runs[r + (16) + 1] * dl + runs[r + (19) + 1] * dt2, reg[(8)] = runs[r + (16) + 2] * dl + runs[r + (19) + 2] * dt2, this.applyImpulse(r), runs[r + (0)] -= dl * radius / inertia;
       }
     for (let w = 0; w < wheels; w++) {
-      let r = (id * chunkBS65NRDW_js.MAX_WHEELS + w) * (40);
+      let r = (id * chunk3S6WPBZL_js.MAX_WHEELS + w) * (40);
       runs[r + (38)] > 0 && this.brakeTowardRest(r);
     }
     this.lockDifferentials(id, d, wheels);
-    let along = c[(7)] * fx + c[(7) + 1] * fy + c[(7) + 2] * fz, downforce = desc[d + chunkBS65NRDW_js.DESC_DOWNFORCE];
+    let along = c[(7)] * fx + c[(7) + 1] * fy + c[(7) + 2] * fz, downforce = desc[d + chunk3S6WPBZL_js.DESC_DOWNFORCE];
     if (downforce > 0) {
       let push = -downforce * along * along * dt;
       c[(7)] += c[(16)] * ux * push, c[(7) + 1] += c[(16) + 1] * uy * push, c[(7) + 2] += c[(16) + 2] * uz * push;
     }
-    let drag = desc[d + chunkBS65NRDW_js.DESC_DRAG];
+    let drag = desc[d + chunk3S6WPBZL_js.DESC_DRAG];
     if (drag > 0) {
       let lx = c[(7)], ly = c[(7) + 1], lz = c[(7) + 2], amount = drag * Math.sqrt(lx * lx + ly * ly + lz * lz) * dt;
       for (let axis = 0; axis < 3; axis++)
@@ -242,12 +242,12 @@ var R_DT = 0, R_THROTTLE = 1, R_GEAR_REQUEST = 2, R_TORQUE = 3, R_RATIO = 4, R_R
     }
     this.vehicles[v + (5)] = c[(7)] * fx + c[(7) + 1] * fy + c[(7) + 2] * fz, this.lean(id, d);
     for (let w = 0; w < wheels; w++) {
-      let r = (id * chunkBS65NRDW_js.MAX_WHEELS + w) * (40), spin = runs[r + (1)] + runs[r + (0)] * dt;
+      let r = (id * chunk3S6WPBZL_js.MAX_WHEELS + w) * (40), spin = runs[r + (1)] + runs[r + (0)] * dt;
       spin > Math.PI ? spin -= TWO_PI : spin < -Math.PI && (spin += TWO_PI), runs[r + (1)] = spin;
     }
     this.world.writeChassis(body, c, active);
     for (let w = 0; w < wheels; w++) {
-      let r = (id * chunkBS65NRDW_js.MAX_WHEELS + w) * (40), ground = runs[r + (6)] | 0;
+      let r = (id * chunk3S6WPBZL_js.MAX_WHEELS + w) * (40), ground = runs[r + (6)] | 0;
       if (ground === (-1)) continue;
       let long = runs[r + (35)], lat = runs[r + (36)], load = runs[r + (28)] * dt;
       for (let axis = 0; axis < 3; axis++)
@@ -261,99 +261,99 @@ var R_DT = 0, R_THROTTLE = 1, R_GEAR_REQUEST = 2, R_TORQUE = 3, R_RATIO = 4, R_R
     reg[(3)] = 0;
     let v = id * (8), share = 0, spin = 0;
     for (let w = 0; w < wheels; w++) {
-      let wd = d + chunkBS65NRDW_js.DESC_HEADER + w * chunkBS65NRDW_js.WHEEL_DESC_WORDS, r = (id * chunkBS65NRDW_js.MAX_WHEELS + w) * (40), drive2 = desc[wd + chunkBS65NRDW_js.WHEEL_DESC_DRIVE];
-      share += drive2, spin += drive2 * runs[r + (0)], runs[r + (37)] = desc[wd + chunkBS65NRDW_js.WHEEL_DESC_INERTIA];
+      let wd = d + chunk3S6WPBZL_js.DESC_HEADER + w * chunk3S6WPBZL_js.WHEEL_DESC_WORDS, r = (id * chunk3S6WPBZL_js.MAX_WHEELS + w) * (40), drive2 = desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_DRIVE];
+      share += drive2, spin += drive2 * runs[r + (0)], runs[r + (37)] = desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_INERTIA];
     }
-    let idle = desc[d + chunkBS65NRDW_js.DESC_IDLE_RPM], maxRpm = desc[d + chunkBS65NRDW_js.DESC_MAX_RPM];
+    let idle = desc[d + chunk3S6WPBZL_js.DESC_IDLE_RPM], maxRpm = desc[d + chunk3S6WPBZL_js.DESC_MAX_RPM];
     if (share <= 0) {
       this.vehicles[v + (4)] = idle;
       return;
     }
-    let omega = spin / share, count = desc[d + chunkBS65NRDW_js.DESC_GEAR_COUNT], gear = this.vehicles[v + (2)];
+    let omega = spin / share, count = desc[d + chunk3S6WPBZL_js.DESC_GEAR_COUNT], gear = this.vehicles[v + (2)];
     this.ratio(d, gear | 0);
     let rpm = Math.abs(omega * reg[(4)]) * (9.549297);
     rpm = rpm < idle ? idle : rpm > maxRpm ? maxRpm : rpm;
     let previous = gear;
-    if (gearRequest >= chunkBS65NRDW_js.GEAR_AUTO ? gear <= 0 ? gear = 1 : this.vehicles[v + (3)] <= 0 && (rpm > desc[d + chunkBS65NRDW_js.DESC_SHIFT_UP] && gear < count ? gear += 1 : rpm < desc[d + chunkBS65NRDW_js.DESC_SHIFT_DOWN] && gear > 1 && (gear -= 1)) : Number.isFinite(gearRequest) && (gear = clamp(Math.trunc(clamp(gearRequest, -1, 8)), -1, count)), gear !== previous && (this.vehicles[v + (3)] = desc[d + chunkBS65NRDW_js.DESC_SHIFT_SECONDS], this.ratio(d, gear | 0), rpm = Math.abs(omega * reg[(4)]) * (9.549297), rpm = rpm < idle ? idle : rpm > maxRpm ? maxRpm : rpm), this.vehicles[v + (2)] = gear, this.vehicles[v + (4)] = rpm, this.vehicles[v + (3)] = Math.max(this.vehicles[v + (3)] - dt, 0), this.vehicles[v + (3)] > 0 || gear === 0) return;
-    let points = desc[d + chunkBS65NRDW_js.DESC_TORQUE_POINTS], curveTorque = desc[d + chunkBS65NRDW_js.DESC_TORQUE + points - 1];
-    if (rpm <= desc[d + chunkBS65NRDW_js.DESC_TORQUE_RPM]) curveTorque = desc[d + chunkBS65NRDW_js.DESC_TORQUE];
+    if (gearRequest >= chunk3S6WPBZL_js.GEAR_AUTO ? gear <= 0 ? gear = 1 : this.vehicles[v + (3)] <= 0 && (rpm > desc[d + chunk3S6WPBZL_js.DESC_SHIFT_UP] && gear < count ? gear += 1 : rpm < desc[d + chunk3S6WPBZL_js.DESC_SHIFT_DOWN] && gear > 1 && (gear -= 1)) : Number.isFinite(gearRequest) && (gear = clamp(Math.trunc(clamp(gearRequest, -1, 8)), -1, count)), gear !== previous && (this.vehicles[v + (3)] = desc[d + chunk3S6WPBZL_js.DESC_SHIFT_SECONDS], this.ratio(d, gear | 0), rpm = Math.abs(omega * reg[(4)]) * (9.549297), rpm = rpm < idle ? idle : rpm > maxRpm ? maxRpm : rpm), this.vehicles[v + (2)] = gear, this.vehicles[v + (4)] = rpm, this.vehicles[v + (3)] = Math.max(this.vehicles[v + (3)] - dt, 0), this.vehicles[v + (3)] > 0 || gear === 0) return;
+    let points = desc[d + chunk3S6WPBZL_js.DESC_TORQUE_POINTS], curveTorque = desc[d + chunk3S6WPBZL_js.DESC_TORQUE + points - 1];
+    if (rpm <= desc[d + chunk3S6WPBZL_js.DESC_TORQUE_RPM]) curveTorque = desc[d + chunk3S6WPBZL_js.DESC_TORQUE];
     else
       for (let k = 1; k < points; k++) {
-        let r1 = desc[d + chunkBS65NRDW_js.DESC_TORQUE_RPM + k];
+        let r1 = desc[d + chunk3S6WPBZL_js.DESC_TORQUE_RPM + k];
         if (rpm < r1) {
-          let r0 = desc[d + chunkBS65NRDW_js.DESC_TORQUE_RPM + k - 1], t0 = desc[d + chunkBS65NRDW_js.DESC_TORQUE + k - 1];
-          curveTorque = t0 + (desc[d + chunkBS65NRDW_js.DESC_TORQUE + k] - t0) * ((rpm - r0) / (r1 - r0));
+          let r0 = desc[d + chunk3S6WPBZL_js.DESC_TORQUE_RPM + k - 1], t0 = desc[d + chunk3S6WPBZL_js.DESC_TORQUE + k - 1];
+          curveTorque = t0 + (desc[d + chunk3S6WPBZL_js.DESC_TORQUE + k] - t0) * ((rpm - r0) / (r1 - r0));
           break;
         }
       }
-    let drive = rpm >= maxRpm ? 0 : throttle * curveTorque, span = (rpm - idle) / (maxRpm - idle), engine = drive - (1 - throttle) * desc[d + chunkBS65NRDW_js.DESC_ENGINE_BRAKING] * Math.max(span, 0);
+    let drive = rpm >= maxRpm ? 0 : throttle * curveTorque, span = (rpm - idle) / (maxRpm - idle), engine = drive - (1 - throttle) * desc[d + chunk3S6WPBZL_js.DESC_ENGINE_BRAKING] * Math.max(span, 0);
     this.ratio(d, gear | 0);
-    let ratio = reg[(4)], reflected = desc[d + chunkBS65NRDW_js.DESC_ENGINE_INERTIA] * ratio * ratio / share;
+    let ratio = reg[(4)], reflected = desc[d + chunk3S6WPBZL_js.DESC_ENGINE_INERTIA] * ratio * ratio / share;
     for (let w = 0; w < wheels; w++) {
-      let wd = d + chunkBS65NRDW_js.DESC_HEADER + w * chunkBS65NRDW_js.WHEEL_DESC_WORDS;
-      runs[(id * chunkBS65NRDW_js.MAX_WHEELS + w) * (40) + (37)] = desc[wd + chunkBS65NRDW_js.WHEEL_DESC_INERTIA] + reflected * desc[wd + chunkBS65NRDW_js.WHEEL_DESC_DRIVE];
+      let wd = d + chunk3S6WPBZL_js.DESC_HEADER + w * chunk3S6WPBZL_js.WHEEL_DESC_WORDS;
+      runs[(id * chunk3S6WPBZL_js.MAX_WHEELS + w) * (40) + (37)] = desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_INERTIA] + reflected * desc[wd + chunk3S6WPBZL_js.WHEEL_DESC_DRIVE];
     }
-    reg[(3)] = engine * ratio * desc[d + chunkBS65NRDW_js.DESC_EFFICIENCY] / share;
+    reg[(3)] = engine * ratio * desc[d + chunk3S6WPBZL_js.DESC_EFFICIENCY] / share;
   }
   brakeTowardRest(r) {
     let runs = this.runs, omega = runs[r + (0)], left = runs[r + (38)];
     Math.abs(omega) <= left ? (runs[r + (38)] = left - Math.abs(omega), runs[r + (0)] = 0) : (runs[r + (0)] = omega > 0 ? omega - left : omega + left, runs[r + (38)] = 0);
   }
   lockDifferentials(id, d, wheels) {
-    let desc = this.descs, runs = this.runs, lock = desc[d + chunkBS65NRDW_js.DESC_DIFFERENTIAL_LOCK];
+    let desc = this.descs, runs = this.runs, lock = desc[d + chunk3S6WPBZL_js.DESC_DIFFERENTIAL_LOCK];
     if (lock > 0)
       for (let i = 0; i < wheels; i++) {
-        let wi = d + chunkBS65NRDW_js.DESC_HEADER + i * chunkBS65NRDW_js.WHEEL_DESC_WORDS, axle = desc[wi + chunkBS65NRDW_js.WHEEL_DESC_AXLE];
-        if (desc[wi + chunkBS65NRDW_js.WHEEL_DESC_DRIVE] <= 0 || axle === chunkBS65NRDW_js.NO_AXLE) continue;
+        let wi = d + chunk3S6WPBZL_js.DESC_HEADER + i * chunk3S6WPBZL_js.WHEEL_DESC_WORDS, axle = desc[wi + chunk3S6WPBZL_js.WHEEL_DESC_AXLE];
+        if (desc[wi + chunk3S6WPBZL_js.WHEEL_DESC_DRIVE] <= 0 || axle === chunk3S6WPBZL_js.NO_AXLE) continue;
         let first = true;
         for (let j = 0; j < i; j++) {
-          let wj = d + chunkBS65NRDW_js.DESC_HEADER + j * chunkBS65NRDW_js.WHEEL_DESC_WORDS;
-          desc[wj + chunkBS65NRDW_js.WHEEL_DESC_AXLE] === axle && desc[wj + chunkBS65NRDW_js.WHEEL_DESC_DRIVE] > 0 && (first = false);
+          let wj = d + chunk3S6WPBZL_js.DESC_HEADER + j * chunk3S6WPBZL_js.WHEEL_DESC_WORDS;
+          desc[wj + chunk3S6WPBZL_js.WHEEL_DESC_AXLE] === axle && desc[wj + chunk3S6WPBZL_js.WHEEL_DESC_DRIVE] > 0 && (first = false);
         }
         if (!first) continue;
         let weight = 0, sum = 0;
         for (let j = i; j < wheels; j++) {
-          let wj = d + chunkBS65NRDW_js.DESC_HEADER + j * chunkBS65NRDW_js.WHEEL_DESC_WORDS;
-          if (desc[wj + chunkBS65NRDW_js.WHEEL_DESC_AXLE] !== axle || desc[wj + chunkBS65NRDW_js.WHEEL_DESC_DRIVE] <= 0) continue;
-          let r = (id * chunkBS65NRDW_js.MAX_WHEELS + j) * (40);
+          let wj = d + chunk3S6WPBZL_js.DESC_HEADER + j * chunk3S6WPBZL_js.WHEEL_DESC_WORDS;
+          if (desc[wj + chunk3S6WPBZL_js.WHEEL_DESC_AXLE] !== axle || desc[wj + chunk3S6WPBZL_js.WHEEL_DESC_DRIVE] <= 0) continue;
+          let r = (id * chunk3S6WPBZL_js.MAX_WHEELS + j) * (40);
           weight += runs[r + (37)], sum += runs[r + (37)] * runs[r + (0)];
         }
         let mean = sum / weight;
         for (let j = i; j < wheels; j++) {
-          let wj = d + chunkBS65NRDW_js.DESC_HEADER + j * chunkBS65NRDW_js.WHEEL_DESC_WORDS;
-          if (desc[wj + chunkBS65NRDW_js.WHEEL_DESC_AXLE] !== axle || desc[wj + chunkBS65NRDW_js.WHEEL_DESC_DRIVE] <= 0) continue;
-          let r = (id * chunkBS65NRDW_js.MAX_WHEELS + j) * (40);
+          let wj = d + chunk3S6WPBZL_js.DESC_HEADER + j * chunk3S6WPBZL_js.WHEEL_DESC_WORDS;
+          if (desc[wj + chunk3S6WPBZL_js.WHEEL_DESC_AXLE] !== axle || desc[wj + chunk3S6WPBZL_js.WHEEL_DESC_DRIVE] <= 0) continue;
+          let r = (id * chunk3S6WPBZL_js.MAX_WHEELS + j) * (40);
           runs[r + (0)] += (mean - runs[r + (0)]) * lock;
         }
       }
-    let center = desc[d + chunkBS65NRDW_js.DESC_CENTER_LOCK];
+    let center = desc[d + chunk3S6WPBZL_js.DESC_CENTER_LOCK];
     if (center > 0) {
       let weight = 0, sum = 0;
       for (let j = 0; j < wheels; j++) {
-        if (desc[d + chunkBS65NRDW_js.DESC_HEADER + j * chunkBS65NRDW_js.WHEEL_DESC_WORDS + chunkBS65NRDW_js.WHEEL_DESC_DRIVE] <= 0) continue;
-        let r = (id * chunkBS65NRDW_js.MAX_WHEELS + j) * (40);
+        if (desc[d + chunk3S6WPBZL_js.DESC_HEADER + j * chunk3S6WPBZL_js.WHEEL_DESC_WORDS + chunk3S6WPBZL_js.WHEEL_DESC_DRIVE] <= 0) continue;
+        let r = (id * chunk3S6WPBZL_js.MAX_WHEELS + j) * (40);
         weight += runs[r + (37)], sum += runs[r + (37)] * runs[r + (0)];
       }
       if (weight > 0) {
         let mean = sum / weight;
         for (let j = 0; j < wheels; j++) {
-          if (desc[d + chunkBS65NRDW_js.DESC_HEADER + j * chunkBS65NRDW_js.WHEEL_DESC_WORDS + chunkBS65NRDW_js.WHEEL_DESC_DRIVE] <= 0) continue;
-          let r = (id * chunkBS65NRDW_js.MAX_WHEELS + j) * (40);
+          if (desc[d + chunk3S6WPBZL_js.DESC_HEADER + j * chunk3S6WPBZL_js.WHEEL_DESC_WORDS + chunk3S6WPBZL_js.WHEEL_DESC_DRIVE] <= 0) continue;
+          let r = (id * chunk3S6WPBZL_js.MAX_WHEELS + j) * (40);
           runs[r + (0)] += (mean - runs[r + (0)]) * center;
         }
       }
     }
   }
   lean(id, d) {
-    let desc = this.descs, stiffness = desc[d + chunkBS65NRDW_js.DESC_LEAN_STIFFNESS], damping = desc[d + chunkBS65NRDW_js.DESC_LEAN_DAMPING];
+    let desc = this.descs, stiffness = desc[d + chunk3S6WPBZL_js.DESC_LEAN_STIFFNESS], damping = desc[d + chunk3S6WPBZL_js.DESC_LEAN_DAMPING];
     if (stiffness <= 0 && damping <= 0) return;
     let reg = this.reg, fx = reg[(9)], fy = reg[(10)], fz = reg[(11)], dt = reg[(0)], t = this.tmp;
     this.rotate(AXES, (6), t, 9);
-    let roll = -t[10], v = id * (8), maxSteer = desc[d + chunkBS65NRDW_js.DESC_MAX_STEER], steer = maxSteer > 0 ? this.vehicles[v + (1)] / maxSteer : 0, speed = Math.min(Math.abs(this.vehicles[v + (5)]) / desc[d + chunkBS65NRDW_js.DESC_LEAN_SPEED], 1), leanAngle = steer * desc[d + chunkBS65NRDW_js.DESC_LEAN_MAX] * speed, target = Math.sin(leanAngle > -chunkBS65NRDW_js.STEER_LIMIT ? leanAngle < chunkBS65NRDW_js.STEER_LIMIT ? leanAngle : chunkBS65NRDW_js.STEER_LIMIT : -chunkBS65NRDW_js.STEER_LIMIT), c = this.chassis, rate = c[(10)] * fx + c[(10) + 1] * fy + c[(10) + 2] * fz, impulse = (stiffness * (target - roll) - damping * rate) * dt;
+    let roll = -t[10], v = id * (8), maxSteer = desc[d + chunk3S6WPBZL_js.DESC_MAX_STEER], steer = maxSteer > 0 ? this.vehicles[v + (1)] / maxSteer : 0, speed = Math.min(Math.abs(this.vehicles[v + (5)]) / desc[d + chunk3S6WPBZL_js.DESC_LEAN_SPEED], 1), leanAngle = steer * desc[d + chunk3S6WPBZL_js.DESC_LEAN_MAX] * speed, target = Math.sin(leanAngle > -chunk3S6WPBZL_js.STEER_LIMIT ? leanAngle < chunk3S6WPBZL_js.STEER_LIMIT ? leanAngle : chunk3S6WPBZL_js.STEER_LIMIT : -chunk3S6WPBZL_js.STEER_LIMIT), c = this.chassis, rate = c[(10)] * fx + c[(10) + 1] * fy + c[(10) + 2] * fz, impulse = (stiffness * (target - roll) - damping * rate) * dt;
     this.rotate(AXES, (0), t, 0);
-    let wheels = desc[d + chunkBS65NRDW_js.DESC_WHEEL_COUNT], height = 0, grounded = 0;
+    let wheels = desc[d + chunk3S6WPBZL_js.DESC_WHEEL_COUNT], height = 0, grounded = 0;
     for (let w = 0; w < wheels; w++) {
-      let r = (id * chunkBS65NRDW_js.MAX_WHEELS + w) * (40);
+      let r = (id * chunk3S6WPBZL_js.MAX_WHEELS + w) * (40);
       this.runs[r + (4)] !== 0 && (height += (c[(13)] - this.runs[r + (10)]) * t[0] + (c[(13) + 1] - this.runs[r + (10) + 1]) * t[1] + (c[(13) + 2] - this.runs[r + (10) + 2]) * t[2], grounded++);
     }
     if (grounded > 0 && height > 0) {
@@ -365,7 +365,7 @@ var R_DT = 0, R_THROTTLE = 1, R_GEAR_REQUEST = 2, R_TORQUE = 3, R_RATIO = 4, R_R
   }
   ratio(d, gear) {
     let desc = this.descs, reg = this.reg;
-    gear > 0 ? reg[(4)] = desc[d + chunkBS65NRDW_js.DESC_RATIOS + gear - 1] * desc[d + chunkBS65NRDW_js.DESC_FINAL_DRIVE] : gear === -1 ? reg[(4)] = -desc[d + chunkBS65NRDW_js.DESC_REVERSE] * desc[d + chunkBS65NRDW_js.DESC_FINAL_DRIVE] : reg[(4)] = 0;
+    gear > 0 ? reg[(4)] = desc[d + chunk3S6WPBZL_js.DESC_RATIOS + gear - 1] * desc[d + chunk3S6WPBZL_js.DESC_FINAL_DRIVE] : gear === -1 ? reg[(4)] = -desc[d + chunk3S6WPBZL_js.DESC_REVERSE] * desc[d + chunk3S6WPBZL_js.DESC_FINAL_DRIVE] : reg[(4)] = 0;
   }
   rotate(vector, from, out, at) {
     let c = this.chassis, qx = c[(3)], qy = c[(3) + 1], qz = c[(3) + 2], qw = c[(3) + 3], x = vector[from], y = vector[from + 1], z = vector[from + 2], tx = 2 * (qy * z - qz * y), ty = 2 * (qz * x - qx * z), tz = 2 * (qx * y - qy * x);
@@ -394,14 +394,14 @@ var R_DT = 0, R_THROTTLE = 1, R_GEAR_REQUEST = 2, R_TORQUE = 3, R_RATIO = 4, R_R
     this.inertiaApply(t, 6), c[(10)] += t[6], c[(10) + 1] += t[7], c[(10) + 2] += t[8];
   }
   writeState(id) {
-    let dt = this.reg[(0)], s = this.states, o = id * chunkBS65NRDW_js.STATE_STRIDE, v = id * (8), runs = this.runs;
-    s[o + chunkBS65NRDW_js.STATE_SPEED] = this.vehicles[v + (5)], s[o + chunkBS65NRDW_js.STATE_RPM] = this.vehicles[v + (4)], s[o + chunkBS65NRDW_js.STATE_GEAR] = this.vehicles[v + (2)], s[o + chunkBS65NRDW_js.STATE_STEER] = this.vehicles[v + (1)], s[o + chunkBS65NRDW_js.STATE_SHIFTING] = this.vehicles[v + (3)] > 0 ? 1 : 0;
-    let wheels = this.descs[id * chunkBS65NRDW_js.VEHICLE_DESC_WORDS + chunkBS65NRDW_js.DESC_WHEEL_COUNT], grounded = 0;
+    let dt = this.reg[(0)], s = this.states, o = id * chunk3S6WPBZL_js.STATE_STRIDE, v = id * (8), runs = this.runs;
+    s[o + chunk3S6WPBZL_js.STATE_SPEED] = this.vehicles[v + (5)], s[o + chunk3S6WPBZL_js.STATE_RPM] = this.vehicles[v + (4)], s[o + chunk3S6WPBZL_js.STATE_GEAR] = this.vehicles[v + (2)], s[o + chunk3S6WPBZL_js.STATE_STEER] = this.vehicles[v + (1)], s[o + chunk3S6WPBZL_js.STATE_SHIFTING] = this.vehicles[v + (3)] > 0 ? 1 : 0;
+    let wheels = this.descs[id * chunk3S6WPBZL_js.VEHICLE_DESC_WORDS + chunk3S6WPBZL_js.DESC_WHEEL_COUNT], grounded = 0;
     for (let w = 0; w < wheels; w++) {
-      let r = (id * chunkBS65NRDW_js.MAX_WHEELS + w) * (40), at = o + chunkBS65NRDW_js.STATE_HEADER + w * chunkBS65NRDW_js.WHEEL_STRIDE;
-      s[at + chunkBS65NRDW_js.WHEEL_CENTER] = runs[r + (7)], s[at + chunkBS65NRDW_js.WHEEL_CENTER + 1] = runs[r + (7) + 1], s[at + chunkBS65NRDW_js.WHEEL_CENTER + 2] = runs[r + (7) + 2], s[at + chunkBS65NRDW_js.WHEEL_SPIN] = runs[r + (1)], s[at + chunkBS65NRDW_js.WHEEL_STEER] = runs[r + (2)], s[at + chunkBS65NRDW_js.WHEEL_LENGTH] = runs[r + (3)], s[at + chunkBS65NRDW_js.WHEEL_GROUND] = runs[r + (5)], s[at + chunkBS65NRDW_js.WHEEL_POINT] = runs[r + (10)], s[at + chunkBS65NRDW_js.WHEEL_POINT + 1] = runs[r + (10) + 1], s[at + chunkBS65NRDW_js.WHEEL_POINT + 2] = runs[r + (10) + 2], s[at + chunkBS65NRDW_js.WHEEL_SLIP] = runs[r + (29)], s[at + chunkBS65NRDW_js.WHEEL_SLIP_ANGLE] = runs[r + (30)], s[at + chunkBS65NRDW_js.WHEEL_LOAD] = runs[r + (28)], s[at + chunkBS65NRDW_js.WHEEL_OMEGA] = runs[r + (0)], s[at + chunkBS65NRDW_js.WHEEL_FORCE_LONG] = runs[r + (35)] / dt, s[at + chunkBS65NRDW_js.WHEEL_FORCE_LAT] = runs[r + (36)] / dt, runs[r + (4)] !== 0 && grounded++;
+      let r = (id * chunk3S6WPBZL_js.MAX_WHEELS + w) * (40), at = o + chunk3S6WPBZL_js.STATE_HEADER + w * chunk3S6WPBZL_js.WHEEL_STRIDE;
+      s[at + chunk3S6WPBZL_js.WHEEL_CENTER] = runs[r + (7)], s[at + chunk3S6WPBZL_js.WHEEL_CENTER + 1] = runs[r + (7) + 1], s[at + chunk3S6WPBZL_js.WHEEL_CENTER + 2] = runs[r + (7) + 2], s[at + chunk3S6WPBZL_js.WHEEL_SPIN] = runs[r + (1)], s[at + chunk3S6WPBZL_js.WHEEL_STEER] = runs[r + (2)], s[at + chunk3S6WPBZL_js.WHEEL_LENGTH] = runs[r + (3)], s[at + chunk3S6WPBZL_js.WHEEL_GROUND] = runs[r + (5)], s[at + chunk3S6WPBZL_js.WHEEL_POINT] = runs[r + (10)], s[at + chunk3S6WPBZL_js.WHEEL_POINT + 1] = runs[r + (10) + 1], s[at + chunk3S6WPBZL_js.WHEEL_POINT + 2] = runs[r + (10) + 2], s[at + chunk3S6WPBZL_js.WHEEL_SLIP] = runs[r + (29)], s[at + chunk3S6WPBZL_js.WHEEL_SLIP_ANGLE] = runs[r + (30)], s[at + chunk3S6WPBZL_js.WHEEL_LOAD] = runs[r + (28)], s[at + chunk3S6WPBZL_js.WHEEL_OMEGA] = runs[r + (0)], s[at + chunk3S6WPBZL_js.WHEEL_FORCE_LONG] = runs[r + (35)] / dt, s[at + chunk3S6WPBZL_js.WHEEL_FORCE_LAT] = runs[r + (36)] / dt, runs[r + (4)] !== 0 && grounded++;
     }
-    s[o + chunkBS65NRDW_js.STATE_GROUNDED] = grounded;
+    s[o + chunk3S6WPBZL_js.STATE_GROUNDED] = grounded;
   }
 };
 

package/dist/{chunk-P2O34BIO.mjs → chunk-JURRXY2J.mjs}

@@ -1,4 +1,4 @@
-import { DEFAULT_ENGINE_MEMORY_PAGES, ENGINE_INITIAL_PAGES, WASM_PAGE_BYTES } from './chunk-NBH64BDP.mjs';
+import { DEFAULT_ENGINE_MEMORY_PAGES, ENGINE_INITIAL_PAGES, WASM_PAGE_BYTES } from './chunk-A33OORT7.mjs';
 
 // src/interactives/engine-heap.ts
 var MIB = 1024 * 1024, ENGINE_HEAP_CEILING_BYTES = {

package/dist/{chunk-PKMVOVUA.mjs → chunk-K3HW5I2A.mjs}

@@ -2,7 +2,7 @@ import { writePosition } from './chunk-GPS2THCL.mjs';
 import { softCurrency, premiumCurrency, softItem, premiumItem, faucet, softExchange, grant, randomExchange, discloseOdds, fixedOffer } from './chunk-3DAD2LDF.mjs';
 import { ScreenShake, HitStop } from './chunk-2UN4SFLR.mjs';
 import { ScreenFlash } from './chunk-A7MQSN2V.mjs';
-import { templateFrameStamp, digestInts } from './chunk-KVZSYGTX.mjs';
+import { templateFrameStamp, digestInts } from './chunk-KGHJH5KJ.mjs';
 import { boxGeometry, sphereGeometry } from './chunk-GHPUYD4I.mjs';
 import { CharacterMove } from './chunk-HF5HPS4T.mjs';
 import { Vec3, Quat } from './chunk-XPG3N5CF.mjs';

package/dist/{chunk-BXUGKBMK.mjs → chunk-KDQOR4QQ.mjs}

@@ -1,5 +1,4 @@
-import { coreOfRest } from './chunk-BOTUAHP2.mjs';
-import { hex } from './chunk-URRZ2SMI.mjs';
+import { hex } from './chunk-V7ZRH3PY.mjs';
 import { wasmAvailable, compileApproved, approveCompiled } from './chunk-N4RGGDEL.mjs';
 
 // src/interactives/runtime/modules.ts
@@ -155,18 +154,6 @@ var PackageAssembler = class {
     for (let late of this.index?.late ?? NO_LATE_RUNTIMES) if (late.unit === unit) return late.chunk;
     return null;
   }
-  /** The late rest units whose engine core this guest holds: the rest of the core it booted, and only that. */
-  heldCoreRests() {
-    let index = this.index;
-    if (index === null) return [];
-    let held = /* @__PURE__ */ new Set();
-    for (let runtime of index.runtimes) this.wasm.has(runtime.chunk) && held.add(runtime.unit);
-    for (let alternative of index.alternatives ?? NO_ALTERNATIVES) this.wasm.has(alternative.chunk) && held.add(alternative.unit);
-    return (index.late ?? NO_LATE_RUNTIMES).filter((late) => {
-      let core = coreOfRest(late.unit);
-      return core !== null && held.has(core);
-    }).map((late) => late.unit);
-  }
   holdsWasm(digest) {
     return this.wasm.has(digest);
   }

package/dist/{chunk-KVZSYGTX.mjs → chunk-KGHJH5KJ.mjs}

@@ -1,4 +1,4 @@
-import { createGame } from './chunk-IHRMR3WV.mjs';
+import { createGame } from './chunk-KVFNRJOR.mjs';
 import { FRAME_NOW_MS_SLOT } from './chunk-IDLW4NWA.mjs';
 
 // src/game/kit/templates/template.ts

package/dist/{chunk-3AKWZF3X.mjs → chunk-KK6HYVBI.mjs}

@@ -1,4 +1,4 @@
-import { cageDisplacement, blendCage, styliseColours, quantiseIdentity, NEUTRAL_LEVEL, NEUTRAL_HAIR, toneFromColour, snapTone } from './chunk-ODL55PYL.mjs';
+import { cageDisplacement, blendCage, styliseColours, quantiseIdentity, NEUTRAL_LEVEL, NEUTRAL_HAIR, toneFromColour, snapTone } from './chunk-XD2PMH46.mjs';
 
 // src/game/kit/identity/fit.ts
 var FIT_ITERATIONS = 12, LANDMARK_NOISE = 0.01, RIDGE = 1e-9, PLANE = 2;

package/dist/{chunk-K6GK5B5J.js → chunk-KMKWGXMK.js}

@@ -1,9 +1,9 @@
 'use strict';
 
-var chunkUQYO3OM7_js = require('./chunk-UQYO3OM7.js');
+var chunk4ZDR72SG_js = require('./chunk-4ZDR72SG.js');
 
 // src/interactives/parts/format.ts
-var PART_MAGIC = 1414680643, PART_VERSION = 1, PART_HEADER_BYTES = 8, MANIFEST_MAGIC = 1296126019, MANIFEST_VERSION = 1, MANIFEST_HEADER_BYTES = 24, MANIFEST_PART_BYTES = chunkUQYO3OM7_js.DIGEST_BYTES + 8, SEGMENT_BYTES = 16, MAX_MANIFEST_PARTS = 65535, MAX_ASSET_BYTES = 512 * 1024 * 1024, PartKind = {
+var PART_MAGIC = 1414680643, PART_VERSION = 1, PART_HEADER_BYTES = 8, MANIFEST_MAGIC = 1296126019, MANIFEST_VERSION = 1, MANIFEST_HEADER_BYTES = 24, MANIFEST_PART_BYTES = chunk4ZDR72SG_js.DIGEST_BYTES + 8, SEGMENT_BYTES = 16, MAX_MANIFEST_PARTS = 65535, MAX_ASSET_BYTES = 512 * 1024 * 1024, PartKind = {
   data: 0,
   scene: 1,
   mesh_index: 2,
@@ -56,8 +56,8 @@ function encodeManifest(manifest) {
   v.setUint32(0, (1296126019), true), v.setUint8(4, (1)), v.setUint8(5, manifest.kind), v.setUint16(6, manifest.parts.length, true), v.setUint32(8, manifest.length, true), v.setUint32(12, manifest.segments.length, true), v.setUint32(16, manifest.literal.length, true);
   let at = (24);
   for (let part of manifest.parts) {
-    if (!chunkUQYO3OM7_js.unhexAt(part.digest, out, at, chunkUQYO3OM7_js.DIGEST_BYTES)) throw new PartFormatError(`part digest ${part.digest} is not 32 hex bytes`);
-    v.setUint8(at + chunkUQYO3OM7_js.DIGEST_BYTES, part.kind), v.setUint32(at + chunkUQYO3OM7_js.DIGEST_BYTES + 4, part.length, true), at += MANIFEST_PART_BYTES;
+    if (!chunk4ZDR72SG_js.unhexAt(part.digest, out, at, chunk4ZDR72SG_js.DIGEST_BYTES)) throw new PartFormatError(`part digest ${part.digest} is not 32 hex bytes`);
+    v.setUint8(at + chunk4ZDR72SG_js.DIGEST_BYTES, part.kind), v.setUint32(at + chunk4ZDR72SG_js.DIGEST_BYTES + 4, part.length, true), at += MANIFEST_PART_BYTES;
   }
   for (let s of manifest.segments)
     v.setUint8(at, s.op), v.setUint16(at + 2, s.op === SegmentOp.literal ? 0 : s.part, true), v.setUint32(at + 4, s.offset, true), v.setUint32(at + 8, s.length, true), v.setUint32(at + 12, s.op === SegmentOp.delta ? s.output : s.length, true), at += (16);
@@ -71,8 +71,8 @@ function decodeManifest(payload) {
   if (literalAt + literalBytes !== payload.length) throw new PartFormatError("the asset manifest's tables do not match its length");
   let parts = [], at = (24);
   for (let p = 0; p < partCount; p++) {
-    let partKind = v.getUint8(at + chunkUQYO3OM7_js.DIGEST_BYTES);
-    partKindName(partKind), parts.push({ digest: chunkUQYO3OM7_js.hexAt(payload, at, chunkUQYO3OM7_js.DIGEST_BYTES), kind: partKind, length: v.getUint32(at + chunkUQYO3OM7_js.DIGEST_BYTES + 4, true) }), at += MANIFEST_PART_BYTES;
+    let partKind = v.getUint8(at + chunk4ZDR72SG_js.DIGEST_BYTES);
+    partKindName(partKind), parts.push({ digest: chunk4ZDR72SG_js.hexAt(payload, at, chunk4ZDR72SG_js.DIGEST_BYTES), kind: partKind, length: v.getUint32(at + chunk4ZDR72SG_js.DIGEST_BYTES + 4, true) }), at += MANIFEST_PART_BYTES;
   }
   let segments = [];
   for (let s = 0; s < segmentCount; s++) {