@vworlds/box2d3-wasm 0.0.0-stage → 6.0.1

package/dist/entry.d.ts

@@ -0,0 +1,4 @@
+// these typings are provided in case you wish to bypass the NodeJS module specifier
+// (i.e. 'box2d-wasm') and import the entrypoint directly.
+import Box2D from './deluxe/Box2D.deluxe.js'
+export default Box2D;

package/dist/entry.mjs

@@ -0,0 +1,32 @@
+/**
+ * @import { MainModule, ModuleOptions } from './deluxe/Box2D.deluxe'
+ * @param {ModuleOptions} options
+ * @return {Promise<MainModule>}
+ */
+export default async (options, ...args) => {
+    /**
+     * This validation expression comes from wasm-feature-detect:
+     * https://github.com/GoogleChromeLabs/wasm-feature-detect
+     * 
+     * Copyright 2019 Google Inc. All Rights Reserved.
+     * Licensed under the Apache License, Version 2.0 (the "License");
+     * you may not use this file except in compliance with the License.
+     * You may obtain a copy of the License at
+     *     http://www.apache.org/licenses/LICENSE-2.0
+     * Unless required by applicable law or agreed to in writing, software
+     * distributed under the License is distributed on an "AS IS" BASIS,
+     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     * See the License for the specific language governing permissions and
+     * limitations under the License.
+     */
+    const hasSIMD = WebAssembly.validate(new Uint8Array([0,97,115,109,1,0,0,0,1,5,1,96,0,1,123,3,2,1,0,10,10,1,8,0,65,0,253,15,253,98,11]));
+    /** @type {{ 'default': (options?: unknown) => MainModule) }} */
+    const Box2DModule = await (
+      hasSIMD
+        ? import('./deluxe/Box2D.deluxe.mjs')
+        : import('./compat/Box2D.compat.mjs')
+    );
+    const { 'default': Box2DFactory } = Box2DModule;
+    // awaiting gives us a better stack trace (at the cost of an extra microtask)
+    return await Box2DFactory(options, ...args);
+  };

package/dist/fastpath.d.ts

@@ -0,0 +1,192 @@
+// Types for box2d3-wasm/fastpath: the b2x_ fast path (plain wasm exports, no embind).
+// Reference: docs/fastpath.md in the vworlds/box2d3-wasm repository.
+import type { MainModule } from "./deluxe/Box2D.deluxe.js";
+import type { FastPathBodyExports } from "./fastpath_body.gen.js";
+
+export type { FastPathBodyExports } from "./fastpath_body.gen.js";
+
+/**
+ * The hand-written b2x_ exports (src/fastpath.cpp), typed by parameter name. All arguments and
+ * results are plain numbers: ids are packed (see {@link FastPath.world} and {@link FastPath.rev}),
+ * pointers are byte addresses in wasm memory, floats cross as f32.
+ */
+export interface FastPathCoreExports {
+  /** JSON layout of every exposed struct (sizes and byte offsets from sizeof/offsetof); a C
+   * string at the returned address. Read it through {@link FastPath.layout}. */
+  _b2x_GetLayout(): number;
+  /** Fast-path API version (layout.constants.version). */
+  _b2x_GetVersion(): number;
+  /** Box2D's profile timers on (1, default) or off (0). Off: b2World_GetProfile reads zeros,
+   * results are unaffected, each step makes no JavaScript clock calls. Global to the module. */
+  _b2x_SetProfileTimers(enabled: number): void;
+  _b2x_GetProfileTimers(): number;
+  /** b2World_Step(world, timeStep, subStepCount). May grow memory. */
+  _b2x_World_Step(world: number, timeStep: number, subStepCount: number): void;
+  /** Move-event count of the last step. */
+  _b2x_World_GetMoveCount(world: number): number;
+  /**
+   * Write one b2xMove record (layout.move) per move event of the last step, in Box2D's event
+   * order, to `outPtr` (at most `capacity`). Returns the number of records the export produced;
+   * if it exceeds `capacity` only `capacity` were written: grow and call again (the events stay
+   * valid until the next step). `flags`: layout.constants.exportVelocity | exportDynamicOnly.
+   * Never grows memory.
+   */
+  _b2x_World_ExportMoves(world: number, outPtr: number, capacity: number, flags: number): number;
+  /** b2x_World_Step then b2x_World_ExportMoves in one crossing. */
+  _b2x_World_StepAndExportMoves(
+    world: number,
+    timeStep: number,
+    subStepCount: number,
+    outPtr: number,
+    capacity: number,
+    flags: number
+  ): number;
+  /** Write {ptr, count} (layout.span) of Box2D's own b2BodyMoveEvent array (layout.moveEvent). */
+  _b2x_World_GetMoveEventSpan(world: number, outPtr: number): void;
+  /** Write the begin/end/hit spans (layout.contactSpans) of Box2D's contact event arrays
+   * (layouts contactBegin, contactEnd, contactHit). Valid until the next step or world change. */
+  _b2x_World_GetContactSpans(world: number, outPtr: number): void;
+  /** Write the begin/end spans (layout.sensorSpans) of Box2D's sensor event arrays
+   * (layouts sensorBegin, sensorEnd). Valid until the next step or world change. */
+  _b2x_World_GetSensorSpans(world: number, outPtr: number): void;
+  /** Store an unsigned 32-bit integer in the body's user data; move records carry it. */
+  _b2x_Body_SetUserData(index1: number, rev: number, value: number): void;
+  _b2x_Body_GetUserData(index1: number, rev: number): number;
+  _b2x_Shape_SetUserData(index1: number, rev: number, value: number): void;
+  _b2x_Shape_GetUserData(index1: number, rev: number): number;
+  /** b2Body_SetTransform(id, {x, y}, b2Body_GetRotation(id)). */
+  _b2x_Body_SetPosition(index1: number, rev: number, x: number, y: number): void;
+  /** b2Body_SetTransform(id, b2Body_GetPosition(id), b2MakeRot(angle)). */
+  _b2x_Body_SetAngle(index1: number, rev: number, angle: number): void;
+  /** Write position, rotation and b2Rot_GetAngle (layout.pose) to `outPtr`. */
+  _b2x_Body_GetPose(index1: number, rev: number, outPtr: number): void;
+  /** Write awake, velocities, damping, local center, mass, gravity scale (layout.motion). */
+  _b2x_Body_GetMotion(index1: number, rev: number, outPtr: number): void;
+  _malloc(bytes: number): number;
+  _free(ptr: number): void;
+  wasmMemory: WebAssembly.Memory;
+}
+
+/** The module with every b2x_ export typed by parameter name, on top of the embind API. */
+export type FastPathModule = MainModule & FastPathCoreExports & FastPathBodyExports;
+
+/** A struct layout: `size` and field offsets, all in bytes, generated in C with sizeof/offsetof. */
+export type StructLayout<F extends string> = { size: number } & Record<F, number>;
+
+export interface FastPathLayout {
+  constants: {
+    version: number;
+    /** Export flag: fill vx/vy/w from b2Body_GetLinearVelocity / b2Body_GetAngularVelocity. */
+    exportVelocity: number;
+    /** Export flag: skip bodies that are not dynamic. */
+    exportDynamicOnly: number;
+    /** b2xMove.flags bit: the move event's fellAsleep. */
+    moveFellAsleep: number;
+    /** b2xMove.flags: (flags >> moveTypeShift) & 3 is the b2BodyType (0 static, 1 kinematic, 2 dynamic). */
+    moveTypeShift: number;
+    /** b2xMove.flags bit: the body id was valid at export (velocities are only read then). */
+    moveValid: number;
+  };
+  /** b2x_World_ExportMoves record. All fields 4-byte aligned. */
+  move: StructLayout<
+    "bodyIndex" | "rev" | "userData" | "flags" | "x" | "y" | "c" | "s" | "angle" | "vx" | "vy" | "w"
+  >;
+  /** b2x_Body_GetPose output. */
+  pose: StructLayout<"x" | "y" | "c" | "s" | "angle">;
+  /** b2x_Body_GetMotion output (`awake` is an int32 1/0). */
+  motion: StructLayout<
+    | "awake"
+    | "vx"
+    | "vy"
+    | "w"
+    | "linearDamping"
+    | "angularDamping"
+    | "localCenterX"
+    | "localCenterY"
+    | "mass"
+    | "gravityScale"
+  >;
+  span: StructLayout<"ptr" | "count">;
+  contactSpans: StructLayout<"beginPtr" | "beginCount" | "endPtr" | "endCount" | "hitPtr" | "hitCount">;
+  sensorSpans: StructLayout<"beginPtr" | "beginCount" | "endPtr" | "endCount">;
+  /** Box2D's b2BodyMoveEvent. `bodyWorld0`/`bodyGeneration` are uint16, `fellAsleep` a byte. */
+  moveEvent: StructLayout<
+    "userData" | "x" | "y" | "c" | "s" | "body" | "bodyWorld0" | "bodyGeneration" | "fellAsleep"
+  >;
+  contactBegin: StructLayout<ShapePairFields | "contact">;
+  contactEnd: StructLayout<ShapePairFields | "contact">;
+  contactHit: StructLayout<
+    ShapePairFields | "pointX" | "pointY" | "normalX" | "normalY" | "approachSpeed"
+  >;
+  sensorBegin: StructLayout<SensorPairFields>;
+  sensorEnd: StructLayout<SensorPairFields>;
+}
+
+type ShapePairFields =
+  | "shapeA"
+  | "shapeAWorld0"
+  | "shapeAGeneration"
+  | "shapeB"
+  | "shapeBWorld0"
+  | "shapeBGeneration";
+type SensorPairFields =
+  | "sensorShape"
+  | "sensorShapeWorld0"
+  | "sensorShapeGeneration"
+  | "visitorShape"
+  | "visitorShapeWorld0"
+  | "visitorShapeGeneration";
+
+export interface FastPath {
+  readonly module: FastPathModule;
+  readonly memory: WebAssembly.Memory;
+  readonly layout: FastPathLayout;
+  /**
+   * Whole-memory views. Memory can grow during any call that allocates in wasm (creating
+   * worlds/bodies/shapes/joints, stepping, embind calls returning by value, malloc). Call
+   * {@link sync} after such a call and before reading; re-read these properties after a sync.
+   */
+  readonly buffer: ArrayBufferLike;
+  readonly u8: Uint8Array;
+  readonly u16: Uint16Array;
+  readonly i32: Int32Array;
+  readonly u32: Uint32Array;
+  readonly f32: Float32Array;
+  /** Rebuild the views if memory grew since the last sync. Returns true when it rebuilt them. */
+  sync(): boolean;
+  /** Packed world id: index1 | generation << 16. */
+  world(worldId: { index1: number; generation: number }): number;
+  /** `rev` half of a packed body/shape/chain/joint id: world0 | generation << 16. */
+  rev(id: { world0: number; generation: number }): number;
+  /** malloc + sync. Throws on failure. */
+  alloc(bytes: number): number;
+  free(ptr: number): void;
+  createMoveExporter(initialCapacity?: number): MoveExporter;
+  /**
+   * Turn Box2D's profile timers on or off (b2World_GetProfile reads 0 while off). They never
+   * affect simulation results; off removes a JS clock call per timed section of every step.
+   */
+  setProfileTimers(enabled: boolean): void;
+}
+
+export interface MoveExporter {
+  /** Byte address of record 0. */
+  readonly ptr: number;
+  /** Word index of record 0 in the i32/u32/f32 views. */
+  readonly base: number;
+  /** Words per record. */
+  readonly stride: number;
+  readonly capacity: number;
+  /** Records written by the last export. */
+  readonly count: number;
+  /**
+   * Export the world's move events (one record each, Box2D's event order) and sync the views.
+   * `flags`: layout.constants.exportVelocity | exportDynamicOnly.
+   */
+  exportMoves(world: number, flags: number): number;
+  /** Step the world, then export, in one crossing. */
+  stepAndExportMoves(world: number, timeStep: number, subStepCount: number, flags: number): number;
+  dispose(): void;
+}
+
+export function createFastPath(module: MainModule): FastPath;

package/dist/fastpath.mjs

@@ -0,0 +1,143 @@
+// box2d3-wasm/fastpath: helpers for the b2x_ fast path (see fastpath.d.ts and docs/fastpath.md).
+//
+// The fast path is a set of plain wasm exports on the module (module._b2x_*). This helper parses
+// their struct layout (generated in C from sizeof/offsetof), keeps whole-memory typed views that
+// survive memory growth, packs embind ids into integers and manages export buffers. None of its
+// per-step methods allocate.
+
+export function createFastPath(module) {
+  const memory = module.wasmMemory;
+  if (!memory || typeof module._b2x_GetLayout !== "function") {
+    throw new Error("box2d3-wasm build without the b2x_ fast path");
+  }
+  const fp = {
+    module,
+    memory,
+    layout: undefined,
+    buffer: undefined,
+    u8: undefined,
+    u16: undefined,
+    i32: undefined,
+    u32: undefined,
+    f32: undefined,
+    sync() {
+      const buffer = memory.buffer;
+      if (buffer === fp.buffer) {
+        return false;
+      }
+      fp.buffer = buffer;
+      fp.u8 = new Uint8Array(buffer);
+      fp.u16 = new Uint16Array(buffer);
+      fp.i32 = new Int32Array(buffer);
+      fp.u32 = new Uint32Array(buffer);
+      fp.f32 = new Float32Array(buffer);
+      return true;
+    },
+    world(worldId) {
+      return worldId.index1 | (worldId.generation << 16);
+    },
+    rev(id) {
+      return id.world0 | (id.generation << 16);
+    },
+    alloc(bytes) {
+      const ptr = module._malloc(bytes);
+      if (ptr === 0) {
+        throw new Error(`b2x: out of memory allocating ${bytes} bytes`);
+      }
+      fp.sync();
+      return ptr;
+    },
+    free(ptr) {
+      module._free(ptr);
+    },
+    createMoveExporter(initialCapacity = 64) {
+      return new MoveExporter(fp, initialCapacity);
+    },
+    setProfileTimers(enabled) {
+      if (typeof module._b2x_SetProfileTimers === "function") {
+        module._b2x_SetProfileTimers(enabled ? 1 : 0);
+      }
+    },
+  };
+  fp.sync();
+  fp.layout = readLayout(fp, module._b2x_GetLayout());
+  if (fp.layout.constants.version !== module._b2x_GetVersion()) {
+    throw new Error("b2x layout version mismatch");
+  }
+  return fp;
+}
+
+function readLayout(fp, ptr) {
+  const u8 = fp.u8;
+  let end = ptr;
+  while (u8[end] !== 0) {
+    end++;
+  }
+  // slice() copies into a non-shared buffer, which TextDecoder accepts.
+  return JSON.parse(new TextDecoder().decode(u8.slice(ptr, end)));
+}
+
+/** Owns a growable wasm buffer of b2xMove records and fills it with one crossing per call. */
+class MoveExporter {
+  constructor(fp, initialCapacity) {
+    this.fp = fp;
+    this.capacity = Math.max(1, initialCapacity | 0);
+    this.ptr = fp.alloc(this.capacity * fp.layout.move.size);
+    /** Word index of record 0 in fp.i32 / fp.u32 / fp.f32. */
+    this.base = this.ptr >> 2;
+    /** Words per record. */
+    this.stride = fp.layout.move.size >> 2;
+    this.count = 0;
+  }
+
+  /** Export the moves of `world` (packed id). Returns the record count; views are synced. */
+  exportMoves(world, flags) {
+    const fp = this.fp;
+    let count = fp.module._b2x_World_ExportMoves(world, this.ptr, this.capacity, flags);
+    if (count > this.capacity) {
+      this.grow(count);
+      count = fp.module._b2x_World_ExportMoves(world, this.ptr, this.capacity, flags);
+    }
+    fp.sync();
+    this.count = count;
+    return count;
+  }
+
+  /** Step `world`, then export its moves, in one crossing. */
+  stepAndExportMoves(world, timeStep, subStepCount, flags) {
+    const fp = this.fp;
+    let count = fp.module._b2x_World_StepAndExportMoves(
+      world,
+      timeStep,
+      subStepCount,
+      this.ptr,
+      this.capacity,
+      flags
+    );
+    if (count > this.capacity) {
+      this.grow(count);
+      count = fp.module._b2x_World_ExportMoves(world, this.ptr, this.capacity, flags);
+    }
+    fp.sync();
+    this.count = count;
+    return count;
+  }
+
+  grow(minCapacity) {
+    const fp = this.fp;
+    let capacity = this.capacity;
+    while (capacity < minCapacity) {
+      capacity *= 2;
+    }
+    fp.free(this.ptr);
+    this.capacity = capacity;
+    this.ptr = fp.alloc(capacity * fp.layout.move.size);
+    this.base = this.ptr >> 2;
+  }
+
+  dispose() {
+    this.fp.free(this.ptr);
+    this.ptr = 0;
+    this.capacity = 0;
+  }
+}

package/dist/fastpath_body.gen.d.ts

@@ -0,0 +1,91 @@
+// GENERATED by scripts/gen_fastpath.py from box2d/include/box2d/box2d.h. Do not edit.
+/** Raw b2x_Body_* exports on the module: body id as (index1, rev). Struct results go to `out`. */
+export interface FastPathBodyExports {
+  /** 1 or 0 */
+  _b2x_Body_IsValid(index1: number, rev: number): number;
+  /** b2BodyType value */
+  _b2x_Body_GetType(index1: number, rev: number): number;
+  _b2x_Body_SetType(index1: number, rev: number, type: number): void;
+  /** out: x, y */
+  _b2x_Body_GetPosition(index1: number, rev: number, outPtr: number): void;
+  /** out: c, s */
+  _b2x_Body_GetRotation(index1: number, rev: number, outPtr: number): void;
+  /** out: px, py, qc, qs */
+  _b2x_Body_GetTransform(index1: number, rev: number, outPtr: number): void;
+  _b2x_Body_SetTransform(index1: number, rev: number, positionX: number, positionY: number, rotationC: number, rotationS: number): void;
+  /** out: x, y */
+  _b2x_Body_GetLocalPoint(index1: number, rev: number, worldPointX: number, worldPointY: number, outPtr: number): void;
+  /** out: x, y */
+  _b2x_Body_GetWorldPoint(index1: number, rev: number, localPointX: number, localPointY: number, outPtr: number): void;
+  /** out: x, y */
+  _b2x_Body_GetLocalVector(index1: number, rev: number, worldVectorX: number, worldVectorY: number, outPtr: number): void;
+  /** out: x, y */
+  _b2x_Body_GetWorldVector(index1: number, rev: number, localVectorX: number, localVectorY: number, outPtr: number): void;
+  /** out: x, y */
+  _b2x_Body_GetLinearVelocity(index1: number, rev: number, outPtr: number): void;
+  _b2x_Body_GetAngularVelocity(index1: number, rev: number): number;
+  _b2x_Body_SetLinearVelocity(index1: number, rev: number, linearVelocityX: number, linearVelocityY: number): void;
+  _b2x_Body_SetAngularVelocity(index1: number, rev: number, angularVelocity: number): void;
+  _b2x_Body_SetTargetTransform(index1: number, rev: number, targetPx: number, targetPy: number, targetQc: number, targetQs: number, timeStep: number): void;
+  /** out: x, y */
+  _b2x_Body_GetLocalPointVelocity(index1: number, rev: number, localPointX: number, localPointY: number, outPtr: number): void;
+  /** out: x, y */
+  _b2x_Body_GetWorldPointVelocity(index1: number, rev: number, worldPointX: number, worldPointY: number, outPtr: number): void;
+  _b2x_Body_ApplyForce(index1: number, rev: number, forceX: number, forceY: number, pointX: number, pointY: number, wake: number): void;
+  _b2x_Body_ApplyForceToCenter(index1: number, rev: number, forceX: number, forceY: number, wake: number): void;
+  _b2x_Body_ApplyTorque(index1: number, rev: number, torque: number, wake: number): void;
+  _b2x_Body_ApplyLinearImpulse(index1: number, rev: number, impulseX: number, impulseY: number, pointX: number, pointY: number, wake: number): void;
+  _b2x_Body_ApplyLinearImpulseToCenter(index1: number, rev: number, impulseX: number, impulseY: number, wake: number): void;
+  _b2x_Body_ApplyAngularImpulse(index1: number, rev: number, impulse: number, wake: number): void;
+  _b2x_Body_GetMass(index1: number, rev: number): number;
+  _b2x_Body_GetRotationalInertia(index1: number, rev: number): number;
+  /** out: x, y */
+  _b2x_Body_GetLocalCenterOfMass(index1: number, rev: number, outPtr: number): void;
+  /** out: x, y */
+  _b2x_Body_GetWorldCenterOfMass(index1: number, rev: number, outPtr: number): void;
+  _b2x_Body_SetMassData(index1: number, rev: number, massDataMass: number, massDataCenterX: number, massDataCenterY: number, massDataRotationalInertia: number): void;
+  /** out: mass, centerX, centerY, rotationalInertia */
+  _b2x_Body_GetMassData(index1: number, rev: number, outPtr: number): void;
+  _b2x_Body_ApplyMassFromShapes(index1: number, rev: number): void;
+  _b2x_Body_SetLinearDamping(index1: number, rev: number, linearDamping: number): void;
+  _b2x_Body_GetLinearDamping(index1: number, rev: number): number;
+  _b2x_Body_SetAngularDamping(index1: number, rev: number, angularDamping: number): void;
+  _b2x_Body_GetAngularDamping(index1: number, rev: number): number;
+  _b2x_Body_SetGravityScale(index1: number, rev: number, gravityScale: number): void;
+  _b2x_Body_GetGravityScale(index1: number, rev: number): number;
+  /** 1 or 0 */
+  _b2x_Body_IsAwake(index1: number, rev: number): number;
+  _b2x_Body_SetAwake(index1: number, rev: number, awake: number): void;
+  _b2x_Body_WakeTouching(index1: number, rev: number): void;
+  _b2x_Body_EnableSleep(index1: number, rev: number, enableSleep: number): void;
+  /** 1 or 0 */
+  _b2x_Body_IsSleepEnabled(index1: number, rev: number): number;
+  _b2x_Body_SetSleepThreshold(index1: number, rev: number, sleepThreshold: number): void;
+  _b2x_Body_GetSleepThreshold(index1: number, rev: number): number;
+  /** 1 or 0 */
+  _b2x_Body_IsEnabled(index1: number, rev: number): number;
+  _b2x_Body_Disable(index1: number, rev: number): void;
+  _b2x_Body_Enable(index1: number, rev: number): void;
+  _b2x_Body_SetMotionLocks(index1: number, rev: number, locks: number): void;
+  /** bits: 1 linearX, 2 linearY, 4 angularZ */
+  _b2x_Body_GetMotionLocks(index1: number, rev: number): number;
+  _b2x_Body_SetBullet(index1: number, rev: number, flag: number): void;
+  /** 1 or 0 */
+  _b2x_Body_IsBullet(index1: number, rev: number): number;
+  _b2x_Body_EnableContactEvents(index1: number, rev: number, flag: number): void;
+  _b2x_Body_EnableHitEvents(index1: number, rev: number, flag: number): void;
+  /** packed world id */
+  _b2x_Body_GetWorld(index1: number, rev: number): number;
+  _b2x_Body_GetShapeCount(index1: number, rev: number): number;
+  /** writes up to capacity (index1, rev) pairs to shapeArrayPtr; returns the count */
+  _b2x_Body_GetShapes(index1: number, rev: number, shapeArrayPtr: number, capacity: number): number;
+  _b2x_Body_GetJointCount(index1: number, rev: number): number;
+  /** writes up to capacity (index1, rev) pairs to jointArrayPtr; returns the count */
+  _b2x_Body_GetJoints(index1: number, rev: number, jointArrayPtr: number, capacity: number): number;
+  _b2x_Body_GetContactCapacity(index1: number, rev: number): number;
+  /** out: lowerX, lowerY, upperX, upperY */
+  _b2x_Body_ComputeAABB(index1: number, rev: number, outPtr: number): void;
+}
+
+/** Box2D b2Body_* functions without a generated wrapper: GetContactData, GetName, GetUserData, SetName, SetUserData. */
+export type FastPathBodySkipped = "GetContactData" | "GetName" | "GetUserData" | "SetName" | "SetUserData";

package/package.json

@@ -1,6 +1,50 @@
 {
   "name": "@vworlds/box2d3-wasm",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "6.0.1",
+  "description": "Box2D v3 for the web and Node as WebAssembly: a flat C-style embind API plus a zero-allocation fast path.",
+  "type": "module",
+  "main": "./dist/entry.mjs",
+  "module": "./dist/entry.mjs",
+  "types": "./dist/entry.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/entry.d.ts",
+      "default": "./dist/entry.mjs"
+    },
+    "./fastpath": {
+      "types": "./dist/fastpath.d.ts",
+      "default": "./dist/fastpath.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bash scripts/build.sh",
+    "build:docker": "bash scripts/build-in-docker.sh",
+    "test": "node tests/fastpath-differential.mjs deluxe && node tests/fastpath-differential.mjs compat && node tests/bindings.mjs deluxe && node tests/bindings.mjs compat && node tests/integration.mjs",
+    "test:stock": "node tests/stock-differential/run.mjs",
+    "gen": "python3 scripts/gen_fastpath.py",
+    "gen:check": "python3 scripts/gen_fastpath.py --check",
+    "check:bindings": "python3 scripts/check_bindings.py",
+    "demo:dev": "npm --prefix demo run dev",
+    "demo:build": "npm --prefix demo run build",
+    "check:pack": "node scripts/check-pack.mjs",
+    "test:release": "node --test scripts/release-version.test.mjs"
+  },
+  "author": "Alex Birch & Erik Sombroek",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vworlds/box2d3-wasm.git"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "box2d3-wasm": "5.2.0"
+  }
+}