@aura3d/physics 1.5.1 → 2.0.0

package/dist/solverless-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solverless-entry.d.ts","sourceRoot":"","sources":["../../../../packages/physics/src/solverless-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,YAAY,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,SAAS,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAC5J,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,YAAY,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,YAAY,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AACrF,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,YAAY,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAMvD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAChF,YAAY,EAAE,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACjG,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,YAAY,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/solverless-entry.js

@@ -0,0 +1,40 @@
+/**
+ * WS-2.2 — the parts of `@aura3d/physics` that do NOT reach the rigid-body solver.
+ *
+ * ## Why this exists
+ *
+ * `createAuraApp` needs a handful of physics values at module scope: `Shape` to translate a declared
+ * collider, `PhysicsStepper` to drive a fixed timestep, `ScenePhysicsBridge` to push transforms, and
+ * `PhysicsDebugDraw` to draw colliders. Every one of those files is **cannon-free** — they import
+ * `PhysicsWorld` as a *type* only.
+ *
+ * But they were reached through `@aura3d/physics`, whose barrel is a chain of `export *`, and one of
+ * those re-exports is `PhysicsWorld` — which imports `cannon-es`. So a scene with **no bodies at all**
+ * downloaded the whole solver. Measured on scenario 1 (one cube, no physics): a **77,081-byte gzip
+ * chunk** on the critical path, of which `cannon-es` is 83,869 bytes raw.
+ *
+ * This is *not* the same defect as eager construction. `createAuraApp` already constructs its world
+ * lazily and carries a comment recording that eager construction cost 85 KB — that fix was correct and
+ * insufficient, because a lazy `new` still leaves a static `import`. A bundler keeps the module either
+ * way. Deferring the *import* is what actually removes the bytes.
+ *
+ * ## What is deliberately absent
+ *
+ * `PhysicsWorld`, `NarrowPhase`, `CharacterController`, `HitboxWorld`, `VehicleDynamics` and the
+ * fixture modules. Anything that simulates. `@aura3d/physics` still exports all of them, and
+ * `createAuraApp` loads the world through `await import("@aura3d/physics")` when a scene actually
+ * declares a body — so behaviour is unchanged and only the download moves.
+ */
+export { Shape } from "./Shape.js";
+export { EPSILON, vec3 } from "./Shape.js";
+export { PhysicsStepper } from "./PhysicsStepper.js";
+export { ScenePhysicsBridge } from "./ScenePhysicsBridge.js";
+export { PhysicsDebugDraw } from "./PhysicsDebugDraw.js";
+/*
+ * Mesh queries are geometry, not simulation. `MeshBVH` and `SurfaceQuery` import only `Shape`'s
+ * types, so grounding a vehicle or a character on a real mesh needs no solver — which is also WS-4.5's
+ * point about MeshBVH having responsibilities beyond physics contact.
+ */
+export { buildMeshBVH, raycastMesh, raycastMeshBruteForce } from "./MeshBVH.js";
+export { createMeshSurfaceQuery } from "./SurfaceQuery.js";
+//# sourceMappingURL=solverless-entry.js.map

package/dist/solverless-entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solverless-entry.js","sourceRoot":"","sources":["../../../../packages/physics/src/solverless-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD;;;;GAIG;AACH,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAEhF,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/solverless.d.ts

@@ -0,0 +1,37 @@
+/**
+ * WS-2.2 — the parts of `@aura3d/physics` that do NOT reach the rigid-body solver.
+ *
+ * ## Why this exists
+ *
+ * `createAuraApp` needs a handful of physics values at module scope: `Shape` to translate a declared
+ * collider, `PhysicsStepper` to drive a fixed timestep, `ScenePhysicsBridge` to push transforms, and
+ * `PhysicsDebugDraw` to draw colliders. These files import `PhysicsWorld` as a *type* only.
+ *
+ * But they were reached through `@aura3d/physics`, whose barrel is a chain of `export *`, and one of
+ * those re-exports is `PhysicsWorld`, which reaches the selected Rapier adapter. A scene with no
+ * physical bodies must not download or initialize that solver.
+ *
+ * This is *not* the same defect as eager construction. `createAuraApp` already constructs its world
+ * lazily and carries a comment recording that eager construction cost 85 KB — that fix was correct and
+ * insufficient, because a lazy `new` still leaves a static `import`. A bundler keeps the module either
+ * way. Deferring the *import* is what actually removes the bytes.
+ *
+ * ## What is deliberately absent
+ *
+ * `PhysicsWorld`, physical controllers, `HitboxWorld`, arcade vehicle telemetry, and fixture
+ * modules. This entry owns geometry/query helpers only; physical simulation uses `./world`.
+ */
+export { Shape } from "./Shape.js";
+export type { BoxShape, Bounds, CapsuleShape, ConvexHullShape, HeightfieldShape, MeshShape, PhysicsShape, PlaneShape, SphereShape, Vec3 } from "./Shape.js";
+export { EPSILON, vec3 } from "./Shape.js";
+export { PhysicsStepper } from "./PhysicsStepper.js";
+export type { PhysicsStepperResult } from "./PhysicsStepper.js";
+export { ScenePhysicsBridge } from "./ScenePhysicsBridge.js";
+export type { ScenePhysicsBinding, ScenePhysicsNode } from "./ScenePhysicsBridge.js";
+export { PhysicsDebugDraw } from "./PhysicsDebugDraw.js";
+export type { DebugLine } from "./PhysicsDebugDraw.js";
+export { buildMeshBVH, raycastMesh, raycastMeshBruteForce } from "./MeshBVH.js";
+export type { MeshBVH, MeshBVHBuildOptions, MeshRayHit, RaycastMeshOptions } from "./MeshBVH.js";
+export { createMeshSurfaceQuery } from "./SurfaceQuery.js";
+export type { MeshSurfaceQuery, MeshSurfaceQueryOptions, SurfaceSample } from "./SurfaceQuery.js";
+//# sourceMappingURL=solverless.d.ts.map

package/dist/solverless.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solverless.d.ts","sourceRoot":"","sources":["../../../../packages/physics/src/solverless.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,YAAY,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,SAAS,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAC5J,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,YAAY,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,YAAY,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AACrF,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,YAAY,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAMvD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAChF,YAAY,EAAE,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACjG,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,YAAY,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/solverless.js

@@ -0,0 +1,36 @@
+/**
+ * WS-2.2 — the parts of `@aura3d/physics` that do NOT reach the rigid-body solver.
+ *
+ * ## Why this exists
+ *
+ * `createAuraApp` needs a handful of physics values at module scope: `Shape` to translate a declared
+ * collider, `PhysicsStepper` to drive a fixed timestep, `ScenePhysicsBridge` to push transforms, and
+ * `PhysicsDebugDraw` to draw colliders. These files import `PhysicsWorld` as a *type* only.
+ *
+ * But they were reached through `@aura3d/physics`, whose barrel is a chain of `export *`, and one of
+ * those re-exports is `PhysicsWorld`, which reaches the selected Rapier adapter. A scene with no
+ * physical bodies must not download or initialize that solver.
+ *
+ * This is *not* the same defect as eager construction. `createAuraApp` already constructs its world
+ * lazily and carries a comment recording that eager construction cost 85 KB — that fix was correct and
+ * insufficient, because a lazy `new` still leaves a static `import`. A bundler keeps the module either
+ * way. Deferring the *import* is what actually removes the bytes.
+ *
+ * ## What is deliberately absent
+ *
+ * `PhysicsWorld`, physical controllers, `HitboxWorld`, arcade vehicle telemetry, and fixture
+ * modules. This entry owns geometry/query helpers only; physical simulation uses `./world`.
+ */
+export { Shape } from "./Shape.js";
+export { EPSILON, vec3 } from "./Shape.js";
+export { PhysicsStepper } from "./PhysicsStepper.js";
+export { ScenePhysicsBridge } from "./ScenePhysicsBridge.js";
+export { PhysicsDebugDraw } from "./PhysicsDebugDraw.js";
+/*
+ * Mesh queries are geometry, not simulation. `MeshBVH` and `SurfaceQuery` import only `Shape`'s
+ * types, so grounding a vehicle or a character on a real mesh needs no solver — which is also WS-4.5's
+ * point about MeshBVH having responsibilities beyond physics contact.
+ */
+export { buildMeshBVH, raycastMesh, raycastMeshBruteForce } from "./MeshBVH.js";
+export { createMeshSurfaceQuery } from "./SurfaceQuery.js";
+//# sourceMappingURL=solverless.js.map

package/dist/solverless.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solverless.js","sourceRoot":"","sources":["../../../../packages/physics/src/solverless.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEzD;;;;GAIG;AACH,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAEhF,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/world-entry.d.ts

@@ -0,0 +1,31 @@
+/**
+ * WS-2.2 — `PhysicsWorld` and the solver, as a narrow entry point.
+ *
+ * ## Why this exists rather than importing the barrel
+ *
+ * `app.physics` is documented and tested as being live **synchronously** for every app
+ * (`tests/unit/agent-api/lazy-physics-world.test.ts`), so `createAuraApp` must be able to construct a
+ * world without awaiting. That rules out loading the solver with `await import()` — R7 forbids breaking
+ * working semantics to chase a byte count, and an async-only `app.physics` would break every existing
+ * caller.
+ *
+ * So the solver is imported statically, but from **here** rather than from `@aura3d/physics`. The
+ * barrel is a chain of `export *` covering `HitboxWorld`, `CharacterController`, `KinematicBody`,
+ * `VehicleDynamics`, `NarrowPhase` and six fixture modules; importing it to get one class dragged all
+ * of them in. This entry exposes the solver and nothing else.
+ *
+ * Measured on scenario 1 (one cube, no bodies), the eager physics chunk:
+ *
+ *   via the barrel      77,081 B gzip   (cannon-es 83,869 raw + HitboxWorld 14,379 + KinematicBody
+ *                                        8,975 + CharacterController 8,531 + NarrowPhase 8,488 +
+ *                                        VehicleDynamics 8,125 + PhysicsSandboxFixtures 7,687 + ...)
+ *   via this entry      the solver only
+ *
+ * `cannon-es` itself stays on the critical path, and that is the honest remaining cost of a synchronous
+ * `app.physics`. Removing it requires deciding whether the public contract may become async — which is
+ * a **P4** question, not a P2 one, and one the physics bake-off has to answer anyway because Rapier is
+ * WASM and therefore asynchronous by construction.
+ */
+export { PhysicsWorld } from "./PhysicsWorld.js";
+export type { PhysicsBackend, PhysicsBackendPreference, PhysicsBackendSelection, PhysicsContinuousCollisionDescriptor, PhysicsContinuousCollisionSelection, PhysicsSnapshot, PhysicsStepStats, PhysicsWorldDescriptor } from "./PhysicsWorld.js";
+//# sourceMappingURL=world-entry.d.ts.map

package/dist/world-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-entry.d.ts","sourceRoot":"","sources":["../../../../packages/physics/src/world-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,YAAY,EACV,cAAc,EACd,wBAAwB,EACxB,uBAAuB,EACvB,oCAAoC,EACpC,mCAAmC,EACnC,eAAe,EACf,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,mBAAmB,CAAC"}

package/dist/world-entry.js

@@ -0,0 +1,30 @@
+/**
+ * WS-2.2 — `PhysicsWorld` and the solver, as a narrow entry point.
+ *
+ * ## Why this exists rather than importing the barrel
+ *
+ * `app.physics` is documented and tested as being live **synchronously** for every app
+ * (`tests/unit/agent-api/lazy-physics-world.test.ts`), so `createAuraApp` must be able to construct a
+ * world without awaiting. That rules out loading the solver with `await import()` — R7 forbids breaking
+ * working semantics to chase a byte count, and an async-only `app.physics` would break every existing
+ * caller.
+ *
+ * So the solver is imported statically, but from **here** rather than from `@aura3d/physics`. The
+ * barrel is a chain of `export *` covering `HitboxWorld`, `CharacterController`, `KinematicBody`,
+ * `VehicleDynamics`, `NarrowPhase` and six fixture modules; importing it to get one class dragged all
+ * of them in. This entry exposes the solver and nothing else.
+ *
+ * Measured on scenario 1 (one cube, no bodies), the eager physics chunk:
+ *
+ *   via the barrel      77,081 B gzip   (cannon-es 83,869 raw + HitboxWorld 14,379 + KinematicBody
+ *                                        8,975 + CharacterController 8,531 + NarrowPhase 8,488 +
+ *                                        VehicleDynamics 8,125 + PhysicsSandboxFixtures 7,687 + ...)
+ *   via this entry      the solver only
+ *
+ * `cannon-es` itself stays on the critical path, and that is the honest remaining cost of a synchronous
+ * `app.physics`. Removing it requires deciding whether the public contract may become async — which is
+ * a **P4** question, not a P2 one, and one the physics bake-off has to answer anyway because Rapier is
+ * WASM and therefore asynchronous by construction.
+ */
+export { PhysicsWorld } from "./PhysicsWorld.js";
+//# sourceMappingURL=world-entry.js.map

package/dist/world-entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-entry.js","sourceRoot":"","sources":["../../../../packages/physics/src/world-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/world.d.ts

@@ -0,0 +1,18 @@
+/**
+ * WS-2.2 — `PhysicsWorld` and the solver, as a narrow entry point.
+ *
+ * ## Why this exists rather than importing the barrel
+ *
+ * `app.physics` is documented and tested as being live **synchronously** for every app
+ * (`tests/unit/agent-api/lazy-physics-world.test.ts`), so `createAuraApp` must be able to construct a
+ * world without awaiting. That rules out loading the solver with `await import()` — R7 forbids breaking
+ * working semantics to chase a byte count, and an async-only `app.physics` would break every existing
+ * caller.
+ *
+ * The selected Rapier solver is imported statically from this narrow entry instead of the
+ * compatibility barrel. This preserves synchronous `app.physics` construction after the
+ * adapter module's one-time WASM initialization without pulling unrelated arcade or query APIs.
+ */
+export { PhysicsWorld } from "./PhysicsWorld.js";
+export type { PhysicsBackend, PhysicsBackendPreference, PhysicsBackendSelection, PhysicsContinuousCollisionDescriptor, PhysicsContinuousCollisionSelection, PhysicsSnapshot, PhysicsStepStats, PhysicsWorldDescriptor } from "./PhysicsWorld.js";
+//# sourceMappingURL=world.d.ts.map

package/dist/world.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../../../packages/physics/src/world.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,YAAY,EACV,cAAc,EACd,wBAAwB,EACxB,uBAAuB,EACvB,oCAAoC,EACpC,mCAAmC,EACnC,eAAe,EACf,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,mBAAmB,CAAC"}

package/dist/world.js

@@ -0,0 +1,17 @@
+/**
+ * WS-2.2 — `PhysicsWorld` and the solver, as a narrow entry point.
+ *
+ * ## Why this exists rather than importing the barrel
+ *
+ * `app.physics` is documented and tested as being live **synchronously** for every app
+ * (`tests/unit/agent-api/lazy-physics-world.test.ts`), so `createAuraApp` must be able to construct a
+ * world without awaiting. That rules out loading the solver with `await import()` — R7 forbids breaking
+ * working semantics to chase a byte count, and an async-only `app.physics` would break every existing
+ * caller.
+ *
+ * The selected Rapier solver is imported statically from this narrow entry instead of the
+ * compatibility barrel. This preserves synchronous `app.physics` construction after the
+ * adapter module's one-time WASM initialization without pulling unrelated arcade or query APIs.
+ */
+export { PhysicsWorld } from "./PhysicsWorld.js";
+//# sourceMappingURL=world.js.map

package/dist/world.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"world.js","sourceRoot":"","sources":["../../../../packages/physics/src/world.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC"}

package/package.json

@@ -1,17 +1,25 @@
 {
   "name": "@aura3d/physics",
-  "version": "1.5.1",
+  "version": "2.0.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "sideEffects": false,
   "dependencies": {
-    "cannon-es": "0.20.0"
+    "@aura3d/physics-rapier": "2.0.0"
   },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./solverless": {
+      "types": "./dist/solverless.d.ts",
+      "import": "./dist/solverless.js"
+    },
+    "./world": {
+      "types": "./dist/world.d.ts",
+      "import": "./dist/world.js"
     }
   },
   "description": "Deterministic rigid-body simulation, collision shapes, contacts, constraints, raycasts, fixed stepping, scene/ECS bridges, and debug draw extraction.",