@cimplify/sdk 0.108.0 → 0.110.2

package/dist/{chunk-OWW5GUSB.js → chunk-JGBCIKJV.js}

@@ -5,12 +5,12 @@ var __typeError = (msg) => {
   throw TypeError(msg);
 };
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value), __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj)), __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value), __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value), __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 var __privateWrapper = (obj, member, setter, getter) => ({
   set _(value) {
     __privateSet(obj, member, value, setter);
@@ -20,6 +20,7 @@ var __privateWrapper = (obj, member, setter, getter) => ({
   }
 });
 
+exports.__export = __export;
 exports.__privateAdd = __privateAdd;
 exports.__privateGet = __privateGet;
 exports.__privateMethod = __privateMethod;

package/dist/chunk-JKGTBMU7.mjs

@@ -0,0 +1,25 @@
+// src/game/kit/identity/launch-pack.ts
+var LAUNCH_RIG = "kit-humanoid", LAUNCH_ITEMS = {
+  baseCharacter: "cimplify/base-character",
+  animations: "cimplify/humanoid-animations",
+  identity: "cimplify/identity-base",
+  materials: "cimplify/starter-materials"
+}, LAUNCH_FILES = {
+  baseCharacter: "base-character.glb",
+  animations: "animations.glb",
+  clips: "clips.json",
+  identity: "identity.cidb",
+  materials: "materials.json"
+}, LAUNCH_CLIPS = {
+  locomotion: ["walk", "walk_back", "walk_formal", "walk_carry", "jog", "jog_back", "run", "crouch_walk", "crouch_back", "swim", "jump", "fall", "land", "roll", "slide", "climb_up"],
+  strafe: ["walk", "strafe_forward_left", "strafe_left", "strafe_back_left", "walk_back", "strafe_back_right", "strafe_right", "strafe_forward_right"],
+  turn: ["turn_left_45", "turn_left_90", "turn_left_180", "turn_right_45", "turn_right_90", "turn_right_180"],
+  idle: ["idle", "idle_talk", "idle_fold_arms", "idle_phone", "crouch_idle", "swim_idle"],
+  emote: ["wave", "clap", "cheer", "bow", "point", "shrug", "salute", "nod", "look_around", "fist_pump", "dance", "yes", "no"],
+  sports: ["kick", "header", "throw_in", "throw", "punch_jab", "punch_cross", "keeper_ready", "dive_left", "dive_right", "keeper_smother", "keeper_hold"],
+  driving: ["drive", "steer_left", "steer_right", "honk"],
+  sitting: ["sit_down", "sit", "sit_talk", "sit_cheer", "sit_clap", "stand_up", "get_up"],
+  reaction: ["hit_chest", "hit_head", "stumble", "stagger", "fall_down"]
+}, LAUNCH_HAIR_STYLES = ["parted", "buzzed", "long", "buns", "buzzed_soft", "none"];
+
+export { LAUNCH_CLIPS, LAUNCH_FILES, LAUNCH_HAIR_STYLES, LAUNCH_ITEMS, LAUNCH_RIG };

package/dist/chunk-JR3TNEQC.js

@@ -0,0 +1,422 @@
+'use strict';
+
+var chunk3S6WPBZL_js = require('./chunk-3S6WPBZL.js');
+var chunk2V7IL4HC_js = require('./chunk-2V7IL4HC.js');
+
+// src/game/physics/vehicle-solver.ts
+var CHASSIS_T = 0, CHASSIS_Q = 3, CHASSIS_LINEAR = 7, CHASSIS_ANGULAR = 10, CHASSIS_COM = 13, CHASSIS_INV_MASS = 16, CHASSIS_INV_INERTIA = 19, CHASSIS_SLEEPING = 25, CHASSIS_WORDS = 26, HIT_TOI = 0, HIT_REACH = 0, HIT_NORMAL = 1, HIT_GROUND_VELOCITY = 4, HIT_GROUND_BODY = 7, HIT_WORDS = 8, NO_BODY = -1, DEFAULT_CAPACITY = 32, TYRE_ITERATIONS = 4, SLIP_SPEED_FLOOR = 0.5, AIRBORNE_SPIN_DAMPING = 0.5, ACKERMANN_EPSILON = 1e-4, RPM_PER_RADIAN_PER_SECOND = 9.549297, TWO_PI = Math.PI * 2, W_OMEGA = 0, W_SPIN = 1, W_STEER = 2, W_LENGTH = 3, W_CONTACT = 4, W_GROUND = 5, W_GROUND_BODY = 6, W_CENTER = 7, W_POINT = 10, W_NORMAL = 13, W_FORWARD = 16, W_RIGHT = 19, W_OFFSET = 22, W_GROUND_VELOCITY = 25, W_LOAD = 28, W_SLIP = 29, W_SLIP_ANGLE = 30, W_K_LONG = 31, W_K_LAT = 32, W_LIMIT_LONG = 33, W_LIMIT_LAT = 34, W_IMPULSE_LONG = 35, W_IMPULSE_LAT = 36, W_INERTIA = 37, W_BRAKE_LEFT = 38, W_STRIDE = 40, V_BODY = 0, V_STEER = 1, V_GEAR = 2, V_SHIFT = 3, V_RPM = 4, V_SPEED = 5, V_STRIDE = 8;
+function clamp(value, low, high) {
+  let lifted = value > low ? value : low;
+  return lifted < high ? lifted : high;
+}
+function curve(desc, at, io, slot) {
+  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 + chunk3S6WPBZL_js.CURVE_SLIP + k];
+    if (slip < s1) {
+      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 + 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) {
+    this.capacity = 0;
+    this.inputs = new Float32Array(0);
+    this.states = new Float32Array(0);
+    this.descs = new Float32Array(0);
+    this.runs = new Float64Array(0);
+    this.vehicles = new Float64Array(0);
+    this.active = new Int32Array(0);
+    this.activeCount = 0;
+    this.free = new Int32Array(0);
+    this.freeCount = 0;
+    this.chassis = new Float64Array((26));
+    this.origin = new Float64Array(3);
+    this.direction = new Float64Array(3);
+    this.hit = new Float64Array((8));
+    this.impulse = new Float64Array(3);
+    this.point = new Float64Array(3);
+    this.tmp = new Float64Array(12);
+    this.reg = new Float64Array((16));
+    this.world = world;
+  }
+  get count() {
+    return this.activeCount;
+  }
+  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 * 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;
+    }
+  }
+  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, 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[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 * 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++)
+      if (this.active[k] === vehicle) {
+        this.active[k] = this.active[--this.activeCount], this.free[this.freeCount++] = vehicle;
+        return;
+      }
+    throw new chunk2V7IL4HC_js.GameError("unknown_resource", `vehicle ${vehicle} does not exist`);
+  }
+  releaseBody(body) {
+    for (let k = this.activeCount - 1; k >= 0; k--) {
+      let id = this.active[k];
+      this.vehicles[id * (8) + (0)] === body && this.destroyVehicle(id);
+    }
+  }
+  vehicleInputs() {
+    return this.inputs;
+  }
+  vehicleStates() {
+    return this.states;
+  }
+  update(dt) {
+    this.reg[(0)] = dt;
+    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 * 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) {
+      if (!active) {
+        this.writeState(id);
+        return;
+      }
+      if (this.world.wakeChassis(body), !this.world.readChassis(body, c)) return;
+    }
+    let t = this.tmp;
+    this.rotate(AXES, (0), t, 0);
+    let ux = t[0], uy = t[1], uz = t[2];
+    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 + 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 + 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 + 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 * 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 + 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 > -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 + 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 !== 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)] = 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 * 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 + 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 + chunk3S6WPBZL_js.DESC_ANTI_ROLL];
+    if (antiRoll > 0)
+      for (let a = 0; a < wheels; a++) {
+        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 + 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 * 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 + chunk3S6WPBZL_js.DESC_ROLLING];
+    for (let w = 0; w < wheels; w++) {
+      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 + 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 * 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;
+      }
+      if (lift > 0) {
+        let depth = (runs[r + (22)] * ux + runs[r + (22) + 1] * uy + runs[r + (22) + 2] * uz) * lift;
+        runs[r + (22)] -= ux * depth, runs[r + (22) + 1] -= uy * depth, runs[r + (22) + 2] -= uz * depth;
+      }
+      let nx = runs[r + (13)], ny = runs[r + (13) + 1], nz = runs[r + (13) + 2], ax = runs[r + (16)], ay = runs[r + (16) + 1], az = runs[r + (16) + 2], along2 = ax * nx + ay * ny + az * nz;
+      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 + 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 + 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 * chunk3S6WPBZL_js.MAX_WHEELS + w) * (40);
+        if (runs[r + (4)] === 0 || runs[r + (28)] <= 0) continue;
+        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)
+          long = 0, lat = 0;
+        else {
+          let x = long / ll, y = lat / lt, excess = x * x + y * y;
+          if (excess > 1) {
+            let shrink = 1 / Math.sqrt(excess);
+            long *= shrink, lat *= shrink;
+          }
+        }
+        let dl = long - runs[r + (35)], dt2 = lat - runs[r + (36)];
+        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 * 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 + 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 + 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++)
+        c[(7) + axis] -= c[(7) + axis] * Math.min(amount * c[(16) + axis], 1);
+    }
+    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 * 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 * 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++)
+        this.impulse[axis] = -(runs[r + (16) + axis] * long + runs[r + (19) + axis] * lat + runs[r + (13) + axis] * load), this.point[axis] = runs[r + (10) + axis];
+      this.world.applyImpulseAtPoint(ground, this.impulse, this.point);
+    }
+    this.writeState(id);
+  }
+  drivetrain(id, d, wheels) {
+    let desc = this.descs, runs = this.runs, reg = this.reg, throttle = reg[(1)], gearRequest = reg[(2)], dt = reg[(0)];
+    reg[(3)] = 0;
+    let v = id * (8), share = 0, spin = 0;
+    for (let w = 0; w < wheels; w++) {
+      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 + 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 + 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 >= 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 + chunk3S6WPBZL_js.DESC_TORQUE_RPM + k];
+        if (rpm < r1) {
+          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 + chunk3S6WPBZL_js.DESC_ENGINE_BRAKING] * Math.max(span, 0);
+    this.ratio(d, gear | 0);
+    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 + 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 + 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 + chunk3S6WPBZL_js.DESC_DIFFERENTIAL_LOCK];
+    if (lock > 0)
+      for (let i = 0; i < wheels; i++) {
+        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 + 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 + 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 + 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 + chunk3S6WPBZL_js.DESC_CENTER_LOCK];
+    if (center > 0) {
+      let weight = 0, sum = 0;
+      for (let j = 0; j < wheels; j++) {
+        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 + 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 + 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 + 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 + chunk3S6WPBZL_js.DESC_WHEEL_COUNT], height = 0, grounded = 0;
+    for (let w = 0; w < wheels; w++) {
+      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) {
+      let push = impulse / (height / grounded);
+      c[(7)] += c[(16)] * t[9] * push, c[(7) + 1] += c[(16) + 1] * t[10] * push, c[(7) + 2] += c[(16) + 2] * t[11] * push;
+      return;
+    }
+    reg[(6)] = fx * impulse, reg[(7)] = fy * impulse, reg[(8)] = fz * impulse, this.inertiaApply(t, 6), c[(10)] += t[6], c[(10) + 1] += t[7], c[(10) + 2] += t[8];
+  }
+  ratio(d, gear) {
+    let desc = this.descs, reg = this.reg;
+    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);
+    out[at] = x + qw * tx + (qy * tz - qz * ty), out[at + 1] = y + qw * ty + (qz * tx - qx * tz), out[at + 2] = z + qw * tz + (qx * ty - qy * tx);
+  }
+  relativeVelocity(r, out) {
+    let c = this.chassis, runs = this.runs, ox = runs[r + (22)], oy = runs[r + (22) + 1], oz = runs[r + (22) + 2], wx = c[(10)], wy = c[(10) + 1], wz = c[(10) + 2];
+    out[0] = c[(7)] + (wy * oz - wz * oy) - runs[r + (25)], out[1] = c[(7) + 1] + (wz * ox - wx * oz) - runs[r + (25) + 1], out[2] = c[(7) + 2] + (wx * oy - wy * ox) - runs[r + (25) + 2];
+  }
+  inertiaApply(out, at) {
+    let c = this.chassis, reg = this.reg, x = reg[(6)], y = reg[(7)], z = reg[(8)], m11 = c[(19)], m12 = c[(19) + 1], m13 = c[(19) + 2], m22 = c[(19) + 3], m23 = c[(19) + 4], m33 = c[(19) + 5];
+    out[at] = m11 * x + m12 * y + m13 * z, out[at + 1] = m12 * x + m22 * y + m23 * z, out[at + 2] = m13 * x + m23 * y + m33 * z;
+  }
+  inverseMassAlong(r, axis) {
+    let c = this.chassis, runs = this.runs, reg = this.reg, dx = runs[r + axis], dy = runs[r + axis + 1], dz = runs[r + axis + 2], ox = runs[r + (22)], oy = runs[r + (22) + 1], oz = runs[r + (22) + 2], tx = oy * dz - oz * dy, ty = oz * dx - ox * dz, tz = ox * dy - oy * dx;
+    reg[(6)] = tx, reg[(7)] = ty, reg[(8)] = tz;
+    let t = this.tmp;
+    this.inertiaApply(t, 3), reg[(5)] = dx * c[(16)] * dx + dy * c[(16) + 1] * dy + dz * c[(16) + 2] * dz + tx * t[3] + ty * t[4] + tz * t[5];
+  }
+  applyImpulse(r) {
+    let c = this.chassis, runs = this.runs, reg = this.reg, ix = reg[(6)], iy = reg[(7)], iz = reg[(8)];
+    c[(7)] += c[(16)] * ix, c[(7) + 1] += c[(16) + 1] * iy, c[(7) + 2] += c[(16) + 2] * iz;
+    let ox = runs[r + (22)], oy = runs[r + (22) + 1], oz = runs[r + (22) + 2];
+    reg[(6)] = oy * iz - oz * iy, reg[(7)] = oz * ix - ox * iz, reg[(8)] = ox * iy - oy * ix;
+    let t = this.tmp;
+    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 * 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 * 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 + chunk3S6WPBZL_js.STATE_GROUNDED] = grounded;
+  }
+};
+
+exports.CHASSIS_ANGULAR = (10);
+exports.CHASSIS_COM = (13);
+exports.CHASSIS_INV_INERTIA = (19);
+exports.CHASSIS_INV_MASS = (16);
+exports.CHASSIS_LINEAR = (7);
+exports.CHASSIS_Q = (3);
+exports.CHASSIS_SLEEPING = (25);
+exports.CHASSIS_T = (0);
+exports.HIT_GROUND_BODY = (7);
+exports.HIT_GROUND_VELOCITY = (4);
+exports.HIT_NORMAL = (1);
+exports.HIT_REACH = (0);
+exports.HIT_TOI = (0);
+exports.NO_BODY = (-1);
+exports.VehicleSolver = VehicleSolver;

package/dist/chunk-JURRXY2J.mjs

@@ -0,0 +1,29 @@
+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 = {
+  low: 128 * MIB,
+  mid: 256 * MIB,
+  high: 512 * MIB
+}, ENGINE_HEAP_HEADROOM = 1.25, ENGINE_HEAP_GRANULE_BYTES = 4 * MIB, ENGINE_HEAP_REQUIREMENT = "engine_heap";
+function declared(declaration, tier) {
+  let value = declaration?.[tier];
+  return typeof value == "number" && Number.isFinite(value) && value > 0 ? value : null;
+}
+function engineHeapFor(declaration, tier) {
+  let ceiling = ENGINE_HEAP_CEILING_BYTES[tier], wanted = declared(declaration, tier);
+  return wanted === null ? { bytes: ceiling } : wanted > ceiling ? { refused: `this game needs ${Math.ceil(wanted / MIB)} MiB of engine memory and a ${tier} tier device allows ${ceiling / MIB} MiB` } : { bytes: wanted };
+}
+function declareEngineHeap(peaks) {
+  let out = {};
+  for (let tier of Object.keys(ENGINE_HEAP_CEILING_BYTES)) {
+    let peak = peaks[tier];
+    typeof peak != "number" || !(peak > 0) || (out[tier] = Math.ceil(peak * (1.25) / ENGINE_HEAP_GRANULE_BYTES) * ENGINE_HEAP_GRANULE_BYTES);
+  }
+  return out;
+}
+function engineHeapPages(bytes) {
+  return bytes === void 0 || !Number.isFinite(bytes) || bytes <= 0 ? DEFAULT_ENGINE_MEMORY_PAGES : Math.max(ENGINE_INITIAL_PAGES + 1, Math.ceil(bytes / WASM_PAGE_BYTES));
+}
+
+export { ENGINE_HEAP_CEILING_BYTES, ENGINE_HEAP_HEADROOM, ENGINE_HEAP_REQUIREMENT, declareEngineHeap, engineHeapFor, engineHeapPages };