@ignifx/physics-2d 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -82,20 +82,9 @@ export declare function defaultPhysics2DSettings(): Physics2DSettings;
 //#endregion
 //#region src/material.d.ts
 /**
- * The `ignifx.physicsmaterial` asset, read by the 2D extension.
- *
- * ## Why the format is the 3D one
- *
- * `11-2d-toolkit.md` §8 lists a `PhysicsMaterial2D`, and `09-physics.md` §2.4 already defines
- * `{ "format": "ignifx.physicsmaterial", "friction": …, "staticFriction": …, "restitution": … }`.
- * Inventing a second document for the same two numbers would give artists two files to keep in
- * step, so this package reads **the same format and the same `.physicsmaterial.json` extension**,
- * ignoring `staticFriction` (Rapier 2D has one friction coefficient, `geometry/collider.d.ts`).
- * `@ignifx/physics` and `@ignifx/physics-2d` never run in one world — `IGX-1101` — so the two
- * loaders never collide.
- *
- * The 2D-only knobs, how two surfaces' friction and restitution are **combined**, are fields on the
- * collider rather than on the asset, so the document stays byte-identical to the 3D one.
+ * Read the shared `.physicsmaterial.json` format, ignoring `staticFriction` because Rapier has one
+ * friction coefficient. Combine rules stay on colliders. Only one physics extension runs per world,
+ * so the 2D and 3D loaders do not compete.
  */
 /**
  * The asset type name `.physicsmaterial.json` addresses resolve to.
@@ -184,23 +173,10 @@ export declare function parsePhysicsMaterial2D(address: string, document: JsonVa
 //#endregion
 //#region src/lite/rapier/world.d.ts
 /**
- * The Rapier 2D adapter (`docs/architecture/11-2d-toolkit.md` §8, ADR-0006). Everything the runtime
- * needs from `@dimforge/rapier2d-compat` is a function here, so the rest of `src/` never imports the
- * backend (`ignifx/no-lite-outside-adapter`, coding standards §4).
- *
- * ## Facts measured against `@dimforge/rapier2d-compat@0.20.0` (spike S6.2)
- *
- * - **The broadphase is only built by `World.step`.** Before the first step, `castRay` returns
- *   `null` and `KinematicCharacterController.computeColliderMovement` reports the full requested
- *   motion with no obstacles; a collider created after the last step is invisible until the next
- *   one. {@link primeWorld} runs a zero-length step, which builds the broadphase without
- *   integrating — but it is *not* free of side effects on a running simulation (a settled pile
- *   hashes differently), so the runtime primes only when the collider set changed.
- * - **`InteractionGroups` is one 32-bit number**: membership in the high 16 bits, filter in the low
- *   16 (`geometry/interaction_groups.d.ts`). Sixteen layers, not thirty-two.
- * - **`ActiveCollisionTypes.DEFAULT` excludes non-dynamic pairs**, so a kinematic character never
- *   reports entering a static sensor. Colliders that want events are given
- *   `ActiveCollisionTypes.ALL`.
+ * Keep Rapier calls inside the adapter (ADR-0006).
+ * Queries need a built broadphase. Prime after collider-set changes only: a zero-length step can
+ * still affect a running simulation. Interaction groups support sixteen layers; event-enabled
+ * colliders include non-dynamic pairs so characters can enter static sensors.
  */
 /**
  * Rapier's physics world.
@@ -265,29 +241,9 @@ type RapierShape2D = {
 //#endregion
 //#region src/components/collider.d.ts
 /**
- * The 2D collider contract (`docs/architecture/11-2d-toolkit.md` §8). Every collider shares an
- * offset, the trigger flag, a surface, a layer override, and the one-way platform flag, and answers
- * one question the body builder asks: which Rapier shapes it stands for.
- *
- * ## Corrections to §8
- *
- * - **The material is two fields, not a union.** A schema field has exactly one kind (ADR-0004), so
- *   {@link Collider2D.material} (an asset reference) and {@link Collider2D.inlineMaterial} (a
- *   record) are separate; the asset wins, the inline record is the fallback, and
- *   `physics2d.defaultMaterial` is the last resort. This is the same split `@ignifx/physics` makes.
- * - **Combine rules are collider fields.** Rapier combines two surfaces' friction and restitution
- *   with a per-collider rule (`dynamics/coefficient_combine_rule.d.ts`); the 3D
- *   `ignifx.physicsmaterial` document has no such field, so the knob lives here rather than
- *   forking the asset format.
- * - **A collider may stand for several Rapier colliders.** `TilemapCollider2D` produces one polygon
- *   per merged tile run, so {@link Collider2D.collectShapes} fills a list rather than returning one
- *   shape.
- *
- * ## Sizes and scale
- *
- * Sizes are authored in local metres and multiplied by the entity's lossy scale when the shapes are
- * built. Rapier cannot rescale a built shape, so a later scale change needs
- * {@link Collider2D.rebuild}.
+ * Build shapes from local metres multiplied by entity scale; call `rebuild` after changing scale.
+ * Material assets take precedence over inline values, then project defaults. Friction and restitution
+ * combine rules belong to each collider. A tilemap collider can produce several backend shapes.
  */
 /**
  * How two surfaces' coefficients are combined when they touch, mirroring Rapier's
@@ -390,26 +346,8 @@ export declare abstract class Collider2D extends Component implements ComponentH
 //#endregion
 //#region src/events.d.ts
 /**
- * The payloads the five physics callbacks receive in 2D (`docs/architecture/11-2d-toolkit.md` §8,
- * `09-physics.md` §4).
- *
- * ## The callbacks are the 3D names
- *
- * `11-2d-toolkit.md` §8 writes them as `onCollisionEnter2D`/`onTriggerEnter2D`. The kernel's
- * `PhysicsCallbackName` union has five members and no `2D` variants
- * (`packages/core/src/lifecycle/callbacks.ts`), and a world uses either `physics()` or
- * `physics2d()` — never both, which is what `IGX-1101` enforces. So a 2D game implements
- * `onCollisionEnter`, `onCollisionStay`, `onCollisionExit`, `onTriggerEnter`, and `onTriggerExit`,
- * and receives the 2D payloads below. §8 is corrected accordingly.
- *
- * ## Identities are native
- *
- * Rapier reports **both** colliders of every event (`pipeline/event_queue.d.ts`,
- * `drainCollisionEvents`), so `other` is never `null` for a live body and the ADR-0013 waiver that
- * 3D physics needs has no counterpart here.
- *
- * Every payload is **pooled**: the same instances are reused for every event of a step, so a script
- * that needs a value after its callback returns must copy it out (coding standards §7).
+ * 2D physics uses the same five collision and trigger callback names as 3D, without a `2D` suffix.
+ * Rapier supplies both collider identities. Payloads are pooled; copy values needed after a callback.
  */
 /**
  * One contact point of a 2D collision. Pooled with its owning {@link Collision2D}.
@@ -488,24 +426,9 @@ interface CharacterCollision2D {
 //#endregion
 //#region src/components/rigidbody.d.ts
 /**
- * The `Rigidbody2D` component (`docs/architecture/11-2d-toolkit.md` §8): what makes an entity's 2D
- * colliders a simulated, kinematic, or explicitly static Rapier body.
- *
- * ## Decisions §8 leaves open
- *
- * - **`mass` is exact, and `0` means "weigh the colliders".** Rapier derives a body's mass and
- *   angular inertia from each collider's *density* and area (`geometry/collider.d.ts`,
- *   `setDensity`), and `setAdditionalMass` adds mass without inertia. So a non-zero `mass` is
- *   applied by scaling every collider's density until the body weighs exactly that, which keeps the
- *   inertia distribution the shapes imply; `mass: 0` leaves Rapier's own density of 1 kg/m² alone.
- * - **`freezeRotation` is one boolean, not three.** A 2D body has one rotational degree of freedom
- *   (`dynamics/rigid_body.d.ts`, `lockRotations`).
- * - **Damping is per body here, unlike 3D.** Havok has no per-body damping; Rapier does
- *   (`setLinearDamping`, `setAngularDamping`), so `linearDamping` and `angularDamping` are real
- *   fields rather than upstream requests.
- * - **`collisionEvents` is a three-valued enum**, exactly as in `@ignifx/physics`: a schema field
- *   has one kind (ADR-0004), and `"auto"` recomputes from `ctx.entityImplements` whenever a
- *   component joins or leaves the entity.
+ * A nonzero mass rescales collider densities while preserving their inertia distribution.
+ * Zero keeps the default density of 1 kg/m². Rotation has one freeze flag; damping is per body.
+ * Automatic collision events follow callbacks as components join or leave the entity.
  */
 /**
  * How a 2D body moves.
@@ -675,27 +598,9 @@ export declare class Rigidbody2D extends Component implements ComponentHooks {
 //#endregion
 //#region src/components/character-controller.d.ts
 /**
- * The `CharacterController2D` component (`docs/architecture/11-2d-toolkit.md` §8): Rapier's
- * `KinematicCharacterController` (`control/character_controller.d.ts`) driven from `fixedUpdate`.
- *
- * ## How it is driven
- *
- * Call {@link CharacterController2D.move} from `fixedUpdate`. The requested displacements of one
- * step are summed and handed to Rapier's `computeColliderMovement` by the step system, so two
- * scripts moving the same character compose instead of fighting. Gravity is **not** applied by this
- * component: a bare controller is purely kinematic, exactly as the 3D one is, and the toolkit
- * controller scripts integrate gravity themselves.
- *
- * After the step the controller owns the entity's world X and Y. Z and `rotation2D` stay
- * user-controlled.
- *
- * ## The one addition to §8: `shape`
- *
- * §8 describes the controller as a capsule. Measured against `@dimforge/rapier2d-compat@0.20.0`
- * (spike S6.2), Rapier's autostep clears a 0.3 m step with a **box** character and refuses anything
- * above about 0.15 m with a capsule of radius 0.2 — so `stepOffset` is only usable with a box.
- * {@link CharacterController2D.shape} therefore chooses between the two, defaulting to `"capsule"`
- * as §8 says, and the limitation is documented in the skill and in ADR-0006's validation section.
+ * Sum `move` displacements during `fixedUpdate`; game scripts supply gravity.
+ * After the step the controller owns world X/Y, while Z and rotation remain user-controlled.
+ * Box shapes support taller autosteps than capsules; see ADR-0006's validation results.
  */
 /**
  * The collision shape a 2D character controller uses.
@@ -779,6 +684,10 @@ export declare class CharacterController2D extends Component implements Componen
   /**
    * Emitted once per obstacle the character hit during a step.
    *
+   * @remarks
+   * Trigger colliders are not obstacles — the character walks straight through them — so a sensor
+   * never appears here. Listen for `onTriggerEnter`/`onTriggerExit` on the entity's scripts instead.
+   *
    * @returns The signal, created on first access.
    */
   get onCollided(): Signal<CharacterCollision2D>;
@@ -970,25 +879,9 @@ export declare class EdgeCollider2D extends Collider2D {
 //#endregion
 //#region src/components/tilemap-collider.d.ts
 /**
- * `TilemapCollider2D` (`docs/architecture/11-2d-toolkit.md` §2.5, §8): the merged collision surface
- * of a `Tilemap`, turned into Rapier geometry.
- *
- * ## How it reaches the data
- *
- * `@ignifx/2d` is an **optional** peer of `@ignifx/physics-2d` (a physics-only 2D game needs no
- * sprite toolkit), so this component never imports the toolkit as a value — only the
- * `TilemapCollisionData` type. A game, or `@ignifx/2d`'s own tilemap loader, assigns
- * {@link TilemapCollider2D.collisionData}; the runtime compares the data's `version` at the start of
- * every fixed step and rebuilds the shapes when it changes, which is the same moment
- * `Tilemap.onCollisionChanged` fires and needs no signal subscription across the package boundary.
- *
- * ## Why closed polylines rather than polygons
- *
- * A merged run of solid tiles is not convex in general — an L of tiles merges into an L — and
- * Rapier's polygon shape is a **convex hull** (`geometry/shape.d.ts`, `ConvexPolygon`), which would
- * silently fill the notch. A closed `polyline` reproduces the outline exactly and is the shape
- * static level geometry wants; the trade-off is that a polyline is infinitely thin, so a body that
- * starts inside the tilemap is not pushed out.
+ * Read tile collision data through the optional 2D toolkit's type and rebuild when its version changes.
+ * Closed polylines preserve concave tile outlines that convex hulls would fill in. They are thin
+ * surfaces, so a body starting inside the map is not pushed out.
  */
 /**
  * The collision surface of a tilemap, as one static body's worth of Rapier shapes.
@@ -1446,7 +1339,7 @@ declare class Physics2DRuntime {
   teleportController(component: CharacterController2D, position: Vec2Like): void;
   /**
    * Restores the authoritative pose of every interpolated body, undoing the display pose the
-   * `PreRender` system wrote (`09-physics.md` §1).
+   * `Update` system wrote at the top of the previous frame's `Update` (`09-physics.md` §1).
    */
   restorePoses(): void;
   /**
@@ -1596,31 +1489,9 @@ export declare class Physics2DService {
 //#endregion
 //#region src/extension.d.ts
 /**
- * The `@ignifx/physics-2d` extension (`docs/architecture/11-2d-toolkit.md` §8,
- * `04-extensions.md` §1).
- *
- * ## Why `@ignifx/2d` is optional rather than required
- *
- * `00-overview.md` §2 draws `@ignifx/physics-2d` above `@ignifx/2d`, and the layering rule allows
- * the dependency. At runtime the only thing this package needs from the toolkit is the
- * `TilemapCollisionData` **type**, which is erased at build time, so a platformer that draws its own
- * graphics can register `physics2d()` on its own. The manifest therefore declares
- * `requires: []` and `optional: ["@ignifx/2d"]`, and `package.json` makes `@ignifx/2d` an optional
- * peer dependency.
- *
- * ## Why the world is built in `onStart`
- *
- * `register` runs before `createApp` builds the `World` (`packages/core/src/app/app.ts`,
- * `initialize`), and the Rapier world needs the world's layer table; Rapier's WebAssembly module
- * also has to be instantiated, which is asynchronous. So `register` declares everything against a
- * {@link Physics2DHost} holder and `onStart` fills the holder in.
- *
- * ## One physics extension per world
- *
- * `11-2d-toolkit.md` §8: "A world uses either `physics()` or `physics2d()`; registering both throws
- * `IGX-1101`". `@ignifx/physics` publishes its Havok simulation scene through
- * `ExtensionContext.setSimulationScene`, so `app.world.lite.simulationScene !== null` at `onStart`
- * is the test — and it needs no dependency on `@ignifx/physics`, which this package must not have.
+ * The 2D toolkit is optional; physics only needs its tile-collision data type.
+ * Create the Rapier world in `onStart`, once the world's layer table exists and WASM is ready.
+ * Reject a world already using 3D physics with `IGX-1101`.
  */
 /**
  * What `physics2d()` accepts.

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/settings.ts","../src/material.ts","../src/lite/rapier/world.ts","../src/components/collider.ts","../src/events.ts","../src/components/rigidbody.ts","../src/components/character-controller.ts","../src/components/colliders.ts","../src/components/tilemap-collider.ts","../src/errors.ts","../src/queries.ts","../src/runtime/body-record.ts","../src/runtime/runtime.ts","../src/runtime/host.ts","../src/service.ts","../src/extension.ts","../src/schemas.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/settings.ts","../src/material.ts","../src/lite/rapier/world.ts","../src/components/collider.ts","../src/events.ts","../src/components/rigidbody.ts","../src/components/character-controller.ts","../src/components/colliders.ts","../src/components/tilemap-collider.ts","../src/errors.ts","../src/queries.ts","../src/runtime/body-record.ts","../src/runtime/runtime.ts","../src/runtime/host.ts","../src/service.ts","../src/extension.ts","../src/schemas.ts"],"mappings":"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"}

package/dist/index.js

@@ -16,24 +16,9 @@ const Physics2DHostKey = createServiceKey("@ignifx/physics-2d:host");
 //#endregion
 //#region src/components/rigidbody.ts
 /**
-* The `Rigidbody2D` component (`docs/architecture/11-2d-toolkit.md` §8): what makes an entity's 2D
-* colliders a simulated, kinematic, or explicitly static Rapier body.
-*
-* ## Decisions §8 leaves open
-*
-* - **`mass` is exact, and `0` means "weigh the colliders".** Rapier derives a body's mass and
-*   angular inertia from each collider's *density* and area (`geometry/collider.d.ts`,
-*   `setDensity`), and `setAdditionalMass` adds mass without inertia. So a non-zero `mass` is
-*   applied by scaling every collider's density until the body weighs exactly that, which keeps the
-*   inertia distribution the shapes imply; `mass: 0` leaves Rapier's own density of 1 kg/m² alone.
-* - **`freezeRotation` is one boolean, not three.** A 2D body has one rotational degree of freedom
-*   (`dynamics/rigid_body.d.ts`, `lockRotations`).
-* - **Damping is per body here, unlike 3D.** Havok has no per-body damping; Rapier does
-*   (`setLinearDamping`, `setAngularDamping`), so `linearDamping` and `angularDamping` are real
-*   fields rather than upstream requests.
-* - **`collisionEvents` is a three-valued enum**, exactly as in `@ignifx/physics`: a schema field
-*   has one kind (ADR-0004), and `"auto"` recomputes from `ctx.entityImplements` whenever a
-*   component joins or leaves the entity.
+* A nonzero mass rescales collider densities while preserving their inertia distribution.
+* Zero keeps the default density of 1 kg/m². Rotation has one freeze flag; damping is per body.
+* Automatic collision events follow callbacks as components join or leave the entity.
 */
 /**
 * How a 2D body moves.
@@ -233,27 +218,9 @@ function rigidbody2DSchema() {
 //#endregion
 //#region src/components/character-controller.ts
 /**
-* The `CharacterController2D` component (`docs/architecture/11-2d-toolkit.md` §8): Rapier's
-* `KinematicCharacterController` (`control/character_controller.d.ts`) driven from `fixedUpdate`.
-*
-* ## How it is driven
-*
-* Call {@link CharacterController2D.move} from `fixedUpdate`. The requested displacements of one
-* step are summed and handed to Rapier's `computeColliderMovement` by the step system, so two
-* scripts moving the same character compose instead of fighting. Gravity is **not** applied by this
-* component: a bare controller is purely kinematic, exactly as the 3D one is, and the toolkit
-* controller scripts integrate gravity themselves.
-*
-* After the step the controller owns the entity's world X and Y. Z and `rotation2D` stay
-* user-controlled.
-*
-* ## The one addition to §8: `shape`
-*
-* §8 describes the controller as a capsule. Measured against `@dimforge/rapier2d-compat@0.20.0`
-* (spike S6.2), Rapier's autostep clears a 0.3 m step with a **box** character and refuses anything
-* above about 0.15 m with a capsule of radius 0.2 — so `stepOffset` is only usable with a box.
-* {@link CharacterController2D.shape} therefore chooses between the two, defaulting to `"capsule"`
-* as §8 says, and the limitation is documented in the skill and in ADR-0006's validation section.
+* Sum `move` displacements during `fixedUpdate`; game scripts supply gravity.
+* After the step the controller owns world X/Y, while Z and rotation remain user-controlled.
+* Box shapes support taller autosteps than capsules; see ADR-0006's validation results.
 */
 /**
 * The collision shape a 2D character controller uses.
@@ -349,6 +316,10 @@ var CharacterController2D = class CharacterController2D extends Component {
 	/**
 	* Emitted once per obstacle the character hit during a step.
 	*
+	* @remarks
+	* Trigger colliders are not obstacles — the character walks straight through them — so a sensor
+	* never appears here. Listen for `onTriggerEnter`/`onTriggerExit` on the entity's scripts instead.
+	*
 	* @returns The signal, created on first access.
 	*/
 	get onCollided() {
@@ -521,20 +492,9 @@ function physics2DError(code, message, options) {
 //#endregion
 //#region src/material.ts
 /**
-* The `ignifx.physicsmaterial` asset, read by the 2D extension.
-*
-* ## Why the format is the 3D one
-*
-* `11-2d-toolkit.md` §8 lists a `PhysicsMaterial2D`, and `09-physics.md` §2.4 already defines
-* `{ "format": "ignifx.physicsmaterial", "friction": …, "staticFriction": …, "restitution": … }`.
-* Inventing a second document for the same two numbers would give artists two files to keep in
-* step, so this package reads **the same format and the same `.physicsmaterial.json` extension**,
-* ignoring `staticFriction` (Rapier 2D has one friction coefficient, `geometry/collider.d.ts`).
-* `@ignifx/physics` and `@ignifx/physics-2d` never run in one world — `IGX-1101` — so the two
-* loaders never collide.
-*
-* The 2D-only knobs, how two surfaces' friction and restitution are **combined**, are fields on the
-* collider rather than on the asset, so the document stays byte-identical to the 3D one.
+* Read the shared `.physicsmaterial.json` format, ignoring `staticFriction` because Rapier has one
+* friction coefficient. Combine rules stay on colliders. Only one physics extension runs per world,
+* so the 2D and 3D loaders do not compete.
 */
 /**
 * The asset type name `.physicsmaterial.json` addresses resolve to.
@@ -681,29 +641,9 @@ function numberAt(object, key, fallback) {
 //#endregion
 //#region src/components/collider.ts
 /**
-* The 2D collider contract (`docs/architecture/11-2d-toolkit.md` §8). Every collider shares an
-* offset, the trigger flag, a surface, a layer override, and the one-way platform flag, and answers
-* one question the body builder asks: which Rapier shapes it stands for.
-*
-* ## Corrections to §8
-*
-* - **The material is two fields, not a union.** A schema field has exactly one kind (ADR-0004), so
-*   {@link Collider2D.material} (an asset reference) and {@link Collider2D.inlineMaterial} (a
-*   record) are separate; the asset wins, the inline record is the fallback, and
-*   `physics2d.defaultMaterial` is the last resort. This is the same split `@ignifx/physics` makes.
-* - **Combine rules are collider fields.** Rapier combines two surfaces' friction and restitution
-*   with a per-collider rule (`dynamics/coefficient_combine_rule.d.ts`); the 3D
-*   `ignifx.physicsmaterial` document has no such field, so the knob lives here rather than
-*   forking the asset format.
-* - **A collider may stand for several Rapier colliders.** `TilemapCollider2D` produces one polygon
-*   per merged tile run, so {@link Collider2D.collectShapes} fills a list rather than returning one
-*   shape.
-*
-* ## Sizes and scale
-*
-* Sizes are authored in local metres and multiplied by the entity's lossy scale when the shapes are
-* built. Rapier cannot rescale a built shape, so a later scale change needs
-* {@link Collider2D.rebuild}.
+* Build shapes from local metres multiplied by entity scale; call `rebuild` after changing scale.
+* Material assets take precedence over inline values, then project defaults. Friction and restitution
+* combine rules belong to each collider. A tilemap collider can produce several backend shapes.
 */
 /**
 * How two surfaces' coefficients are combined when they touch, mirroring Rapier's
@@ -789,19 +729,9 @@ var Collider2D = class extends Component {
 //#endregion
 //#region src/components/colliders.ts
 /**
-* The concrete 2D colliders (`docs/architecture/11-2d-toolkit.md` §8). Each maps to one Rapier
-* shape (`geometry/shape.d.ts`), sized in local metres and multiplied by the entity's lossy scale.
-*
-* ## The two point-list colliders
-*
-* - `PolygonCollider2D` builds a **convex** shape (`ColliderDesc.convexHull`). Rapier 2D also ships
-*   `convexDecomposition`, which needs a triangle mesh with an index buffer and runs V-HACD — far
-*   too heavy for a component field. Concave outlines are expressed as several
-*   `PolygonCollider2D`s on one entity, which is what a compound body is for, or as an
-*   `EdgeCollider2D` when the outline is open.
-* - `EdgeCollider2D` builds a `polyline`, the open chain a platformer's ground contour wants. A
-*   polyline is infinitely thin: a fast body can tunnel through it, and a character controller that
-*   starts *inside* one is not pushed out. Static level geometry is what it is for.
+* Polygon colliders use convex hulls; represent concave geometry with multiple colliders.
+* Edge colliders are thin, open polylines for static contours: fast bodies can tunnel through them,
+* and bodies starting inside are not pushed out.
 */
 /** A quarter turn in radians, which is how a horizontal capsule is expressed. */
 const QUARTER_TURN = Math.PI / 2;
@@ -1124,25 +1054,9 @@ function degenerate(entity, component, requirement) {
 //#endregion
 //#region src/components/tilemap-collider.ts
 /**
-* `TilemapCollider2D` (`docs/architecture/11-2d-toolkit.md` §2.5, §8): the merged collision surface
-* of a `Tilemap`, turned into Rapier geometry.
-*
-* ## How it reaches the data
-*
-* `@ignifx/2d` is an **optional** peer of `@ignifx/physics-2d` (a physics-only 2D game needs no
-* sprite toolkit), so this component never imports the toolkit as a value — only the
-* `TilemapCollisionData` type. A game, or `@ignifx/2d`'s own tilemap loader, assigns
-* {@link TilemapCollider2D.collisionData}; the runtime compares the data's `version` at the start of
-* every fixed step and rebuilds the shapes when it changes, which is the same moment
-* `Tilemap.onCollisionChanged` fires and needs no signal subscription across the package boundary.
-*
-* ## Why closed polylines rather than polygons
-*
-* A merged run of solid tiles is not convex in general — an L of tiles merges into an L — and
-* Rapier's polygon shape is a **convex hull** (`geometry/shape.d.ts`, `ConvexPolygon`), which would
-* silently fill the notch. A closed `polyline` reproduces the outline exactly and is the shape
-* static level geometry wants; the trade-off is that a polyline is infinitely thin, so a body that
-* starts inside the tilemap is not pushed out.
+* Read tile collision data through the optional 2D toolkit's type and rebuild when its version changes.
+* Closed polylines preserve concave tile outlines that convex hulls would fill in. They are thin
+* surfaces, so a body starting inside the map is not pushed out.
 */
 /**
 * The collision surface of a tilemap, as one static body's worth of Rapier shapes.
@@ -1286,21 +1200,9 @@ function segment(from, to, scale) {
 //#endregion
 //#region src/lite/rapier/module.ts
 /**
-* The one place `@dimforge/rapier2d-compat`'s WebAssembly is instantiated
-* (`docs/standards/coding-standards.md` §4, `CONSTITUTION.md` §3.4). Rapier is not Babylon Lite,
-* but it is a native/WASM backend under the same adapter rule, and the rule's allowed directory is
-* `src/lite/**` — hence `src/lite/rapier/`.
-*
-* ## Why `-compat`
-*
-* The `-compat` build inlines the WebAssembly module as base64 inside `rapier.mjs`, so it needs no
-* asset serving and works unchanged in Node and in the browser (spike S6.2, ADR-0006 Validation).
-* `init()` is what decodes and instantiates it; every other Rapier call before that throws.
-*
-* The import is static: `world.ts` and `service.ts` also import Rapier's classes statically, so a
-* dynamic import here alone would not move the 2 MB module out of an app's entry chunk (measured in
-* Phase 6). Splitting it needs the adapter to read every class off the loaded module instead, which
-* is the Phase 12 bundle work.
+* Initialise Rapier's embedded WebAssembly before making backend calls.
+* The compat build includes the binary, so both Node and browser apps need no separate asset.
+* Rapier classes are imported statically by the adapters; delaying `init` does not split that bundle.
 *
 * @internal
 */
@@ -2024,6 +1926,12 @@ var Physics2DHost = class {
 //#endregion
 //#region src/lite/rapier/character.ts
 /**
+* The obstacle filter every controller move uses. Sensors describe regions, not geometry, so they
+* are excluded from collide-and-slide; the pair is still reported by the world step, which is where
+* `onTriggerEnter`/`onTriggerExit` come from.
+*/
+const OBSTACLE_FLAGS = QueryFilterFlags.EXCLUDE_SENSORS;
+/**
 * Creates a character controller.
 *
 * @param world - The world.
@@ -2071,6 +1979,10 @@ function tuneController(controller, tuning) {
 /**
 * Runs one collide-and-slide move.
 *
+* @remarks
+* Sensors are excluded from the obstacle set ({@link OBSTACLE_FLAGS}), so a character walks into and
+* out of a trigger volume at full speed and the world step raises the intersection events.
+*
 * @param controller - The controller.
 * @param collider - The character's own collider.
 * @param desired - The displacement to attempt, in metres.
@@ -2085,11 +1997,11 @@ function computeControllerMovement(controller, collider, desired, groups, filter
 	if (filter === null) controller.computeColliderMovement(collider, {
 		x: desired.x,
 		y: desired.y
-	}, void 0, groups);
+	}, OBSTACLE_FLAGS, groups);
 	else controller.computeColliderMovement(collider, {
 		x: desired.x,
 		y: desired.y
-	}, void 0, groups, filter);
+	}, OBSTACLE_FLAGS, groups, filter);
 	controller.computedMovement(out);
 	return controller.computedGrounded();
 }
@@ -2430,7 +2342,7 @@ var Physics2DRuntime = class {
 	}
 	/**
 	* Restores the authoritative pose of every interpolated body, undoing the display pose the
-	* `PreRender` system wrote (`09-physics.md` §1).
+	* `Update` system wrote at the top of the previous frame's `Update` (`09-physics.md` §1).
 	*/
 	restorePoses() {
 		for (let index = 0; index < this.#records.length; index += 1) {
@@ -2497,8 +2409,9 @@ var Physics2DRuntime = class {
 		destroyWorld(this.#world);
 	}
 	/**
-	* Publishes the frame's counters and zeroes the accumulators. `PreRender` is where a frame's fixed
-	* steps are all done.
+	* Publishes the frame's counters and zeroes the accumulators. The top of `Update`, where the
+	* display pose is written, is the first point in a frame at which every fixed step of that frame
+	* is done.
 	*/
 	#publishCounters() {
 		this.#counters.set(this.#counters.index("bodies"), this.#records.length);
@@ -2951,6 +2864,10 @@ var Physics2DRuntime = class {
 	/**
 	* Reports every obstacle a controller hit and returns the most upward-facing normal.
 	*
+	* @remarks
+	* Sensors are filtered out of the move (`lite/rapier/character.ts`), so a trigger volume never
+	* shows up here and never contributes a ground normal.
+	*
 	* @param rapierController - Rapier's controller.
 	* @param component - The component.
 	* @returns The ground normal, or `null` when nothing was hit.
@@ -3250,26 +3167,43 @@ function now() {
 //#endregion
 //#region src/runtime/systems.ts
 /**
-* The three systems `docs/architecture/01-lifecycle-and-time.md` §3 step 4 and `09-physics.md` §1
-* put physics in the frame with — identical in 2D, except that Rapier is stepped directly and there
-* is no Babylon Lite simulation scene:
+* The three systems `docs/architecture/01-lifecycle-and-time.md` §3 and `09-physics.md` §1 put
+* physics in the frame with — identical in 2D, except that Rapier is stepped directly and there is
+* no Babylon Lite simulation scene:
 *
 * ```
 * Systems(FixedUpdate, -100)  restore the authoritative pose of interpolated bodies
 * scripts.fixedUpdate(dt)     forces, velocities, CharacterController2D.move()
 * Systems(FixedUpdate,  100)  step Rapier, snapshot poses, dispatch collision and trigger events
-* Systems(PreRender,  -500)   write lerp(prev, cur, time.fixedStepAlpha)
+* ── the fixed loop ends; time.fixedStepAlpha is final ──
+* Systems(Update,     -900)   write lerp(prev, cur, time.fixedStepAlpha)
+* scripts.update / lateUpdate, animation, rendering  — all read the display pose
 * ```
 *
+* **Why the display pose is written at the top of `Update` and not in `PreRender`** (2026-09-08).
+* It used to be written in `PreRender`, after `lateUpdate`. `Camera2DFollow` and every hand-written
+* follow camera run in `update`/`lateUpdate`, so they framed the character where the last fixed step
+* left it while the renderer drew it at `lerp(prev, cur, alpha)`: up to one fixed step of relative
+* judder every frame, which a pixel-perfect camera turns into a visibly shaking sprite because the
+* two poses are quantised independently. Writing the pose before `scripts.update` means scripts,
+* animation, camera rigs and the render sync all see the pose the frame presents, which is Unity's
+* model. The simulation is unaffected: the restore system at `FixedUpdate −100` runs before
+* `scripts.fixedUpdate`, so `fixedUpdate` and Rapier still see the authoritative pose.
+*
 * Everything here is `@internal`.
 */
 /** The `FixedUpdate` order the restore system runs at. */
 const PHYSICS_2D_RESTORE_ORDER = -100;
-/** The `PreRender` order the interpolation system runs at. */
-const PHYSICS_2D_INTERPOLATE_ORDER = -500;
 /**
-* Undoes the display pose the interpolation system wrote, so `fixedUpdate` and Rapier both see the
-* authoritative pose.
+* The `Update` order the interpolation system runs at. Negative, so it lands in
+* `Systems(Update, order < 0)` — after the fixed loop and lifecycle flush B, before
+* `scripts.update` — and low enough that a game's own `Update` systems can still be ordered in
+* front of it if they must see the authoritative pose.
+*/
+const PHYSICS_2D_INTERPOLATE_ORDER = -900;
+/**
+* Undoes the display pose the interpolation system wrote at the top of the previous `Update`, so
+* `fixedUpdate` and Rapier both see the authoritative pose.
 *
 * @internal
 */
@@ -3745,7 +3679,7 @@ const physics2d = defineExtension((options = {}) => {
 				order: 100
 			});
 			ctx.registerSystem(new Physics2DInterpolationSystem(host), {
-				phase: Phase.PreRender,
+				phase: Phase.Update,
 				order: PHYSICS_2D_INTERPOLATE_ORDER
 			});
 		},