@flare-engine/dynamics 0.4.8 → 0.4.11

package/README.md

@@ -46,19 +46,118 @@ going through an accessor.
 points, broadphase scratch buffers) lives in a pool owned by the `World` and is reused across calls,
 growing only when body count grows.
 
+## Record and replay
+
+Semi-implicit Euler with friction and restitution is not time-reversible, so a fall you want to
+scrub, reverse or replay at another speed is **baked once** into a `Timeline` and read back by
+sampling. `record` takes a writer callback instead of a body array, so the timeline never has to know
+what it is recording; with an `until` predicate it bakes in one call, without one it records a single
+frame, which suits a time-budgeted loop that calls it once per tick.
+`stepUntil(world, dt, { budgetMs: 6, done: isSettled })` is that loop: it steps until `done()` returns
+true, `maxSteps` is reached or the budget is spent (always at least once), and reports
+`{ steps, complete }`; `stepUntilInto` is the zero-alloc form.
+
+```ts
+import { createTimeline, createWorld, step } from '@flare-engine/dynamics';
+
+const world = createWorld(); // add a floor and some boxes as above
+const dt = 1 / 60;
+const timeline = createTimeline(world.bodies.length, dt); // stride 3: x, y, angle
+timeline.record(
+  (buf, base) => {
+    step(world, dt);
+    for (let i = 0; i < world.bodies.length; i++) {
+      const b = world.bodies[i]!;
+      buf[base + i * 3] = b.position.x;
+      buf[base + i * 3 + 1] = b.position.y;
+      buf[base + i * 3 + 2] = b.angle;
+    }
+  },
+  () => world.bodies.every((b) => Math.abs(b.velocity.y) < 1), // your own settle rule
+);
+
+const out = new Float32Array(timeline.elementCount * 3);
+timeline.sampleInto(0.5, out); // body i at out[i * 3 ..], lerped between frames
+```
+
+Storage is `Float32Array` on purpose — playback precision at half the bytes of f64 — and angles are
+kept exactly as written: `Body.angle` is cumulative and never wrapped, so a plain lerp is correct
+across multi-turn spins where a shortest-path lerp would unravel them. `sampleInto` allocates
+nothing; the one scratch buffer above serves the whole replay.
+
+## Sleeping
+
+Sleeping is off by default (see Limits). `createWorld({ sleep })` opts in: a dynamic body whose
+speed stays under `linearThreshold` (px/s) and whose angular speed stays under `angularThreshold`
+(rad/s) for `steps` consecutive steps has its velocities set to exactly 0 and is skipped by
+integration and by pair tests against other sleeping or static bodies. It wakes when an awake body
+that moved on the previous step touches it, when you write its `velocity`, `angularVelocity`,
+`position` or `angle`, or when you call `wakeBody`. `isSleeping(world, body)` reads one body (an
+`indexOf` over `world.bodies`); `isAtRest(world)` is true once every dynamic body sleeps, which makes
+it the stop rule for a `stepUntil` bake:
+
+```ts
+import {
+  addBody,
+  createBody,
+  createWorld,
+  isAtRest,
+  isSleeping,
+  stepUntil,
+  wakeBody,
+} from '@flare-engine/dynamics';
+
+const world = createWorld({
+  gravity: { x: 0, y: 1800 },
+  sleep: { linearThreshold: 14, angularThreshold: 1.5, steps: 30 },
+});
+addBody(
+  world,
+  createBody({ position: { x: 0, y: 100 }, half: { x: 500, y: 10 }, static: true }),
+);
+const box = addBody(world, createBody({ position: { x: 0, y: 0 }, half: { x: 5, y: 5 } }));
+
+const result = stepUntil(world, 1 / 120, {
+  budgetMs: 8,
+  maxSteps: 600,
+  done: () => isAtRest(world),
+});
+if (result.complete) console.log(isSleeping(world, box), box.velocity.y); // true 0
+
+wakeBody(world, box); // e.g. after removing the floor from world.bodies
+```
+
+Thresholds must clear the resting jitter described under Limits, which depends on body size and
+`dt`: in the package's own tests (half-5 boxes, `dt = 1/120`) a resting box peaks at about 5.8 px/s
+and 1.12 rad/s (the angular peak scales with 1 / half-width), so 14 / 1.5 sleeps it in 91 steps,
+while 0.6 rad/s never sees 30 quiet steps in a row. Measure your own scene before pinning values.
+
+What sleeping does not do:
+
+- **No islands.** A woken body wakes the sleepers it touches on the *next* step, so a landed box
+  wakes a stack one level per step, and a sleeper touched only by a body that is itself settling
+  (under the thresholds, counting down) stays asleep.
+- **A sleeper does not follow a moved static body.** Moving the floor under a sleeping box leaves
+  the box where it is; call `wakeBody` after moving or removing a support.
+- **Removing a body from `world.bodies` wakes the bodies that shift down a slot** and nothing else.
+  A sleeper whose support was removed without shifting it stays asleep in mid-air until `wakeBody`.
+  Inserting a body before a sleeper likewise wakes it (it re-sleeps after `steps` quiet steps).
+- **A world that never went through `createWorld`** (a spread copy or `structuredClone` handed to
+  `step`) is adopted with sleeping off; `isSleeping` and `isAtRest` are then false for any dynamic
+  body.
+
 ## Limits (v1)
 
-- **Resting bodies do not go perfectly still.** A box settling on a floor reaches a stable
-  *position* — in the package's own test scenario, position moves less than 0.1 units over 600
-  further steps — but `velocity` keeps a small, bounded oscillation (roughly 2.6 units/s in that same
-  scenario) at the penetration-slop equilibrium. This is inherent to a Baumgarte-biased
-  sequential-impulse solver run without sleeping, not a bug, and not something a bigger iteration
-  count or a tuning tweak resolves. Sleeping and resting-velocity damping are deliberately out of
-  scope for v1 (tracked as future work). If your use case needs pixel-exact stillness, clamp small
-  resting velocities at your own layer once a body's position has stabilized.
+- **Resting bodies do not go perfectly still unless you opt into sleeping.** A box settling on a
+  floor reaches a stable *position* — in the package's own test scenario, position moves less than
+  0.1 units over 600 further steps — but `velocity` keeps a small, bounded oscillation (roughly 2.6
+  units/s in that same scenario) at the penetration-slop equilibrium. This is inherent to a
+  Baumgarte-biased sequential-impulse solver, not a bug, and not something a bigger iteration count
+  or a tuning tweak resolves. `createWorld({ sleep })` (above) zeroes the velocity of bodies that
+  stay under your thresholds; resting-velocity damping stays out of scope.
 - **Boxes only.** No circle or polygon shapes.
-- **No joints, no sleeping, no CCD (continuous collision detection).** Fast-moving thin bodies can
-  tunnel through each other within a single step.
+- **No joints, no CCD (continuous collision detection).** Fast-moving thin bodies can tunnel
+  through each other within a single step.
 - **No ECS coupling.** `World`/`Body` are plain data; wire them into an ECS yourself if you use one.
 - **Broadphase is brute-force** (all-pairs AABB reject) — fine at small body counts, not a spatial
   partition. There is no broadphase beyond that pass.

package/dist/index.d.mts

@@ -34,28 +34,125 @@ interface BodyOptions {
 }
 export declare function createBody(opts: BodyOptions): Body;
 export declare function isStatic(b: Body): boolean;
+interface SleepOptions {
+  /** Linear speed below which a body counts as resting (same units as `velocity`, px/s). */
+  linearThreshold: number;
+  /** Angular speed below which a body counts as resting (rad/s). */
+  angularThreshold: number;
+  /** Consecutive under-threshold steps before a body is put to sleep (integer >= 1). */
+  steps: number;
+}
+/** Bake-once / scrub-often recorder for a fixed-step simulation. Friction +
+ *  restitution Euler is not time-reversible, so a fall is recorded once into a
+ *  pre-allocated `Float32Array` and replayed by sampling — reverse, scrub and
+ *  speed all read back through `sampleInto` instead of re-integrating.
+ *
+ *  Angles are stored exactly as written. `Body.angle` is cumulative and never
+ *  wrapped, so a plain lerp between adjacent frames is correct across
+ *  multi-turn spins; a shortest-path angle lerp would unravel them.
+ *
+ *  Float32 storage is deliberate: this is playback precision, not simulation
+ *  precision, at half the bytes of f64. */
+interface TimelineOptions {
+  /** Floats per element per frame. Default 3: `dx`, `dy`, `angle`. */
+  stride?: number;
+  /** Frame cap; the whole buffer is allocated at creation. Default 900. */
+  maxFrames?: number;
+}
+/** Fills one frame of `buf`: element `i` lives at `frameBase + i * stride`. */
+type TimelineWriter = (buf: Float32Array, frameBase: number) => void;
+interface Timeline {
+  readonly elementCount: number;
+  /** Frames recorded so far. */
+  readonly frameCount: number;
+  /** Recorded length in seconds: `(frameCount - 1) * dt`, 0 below two frames. */
+  readonly duration: number;
+  /** Writes frames until `until()` returns true or the buffer is full; without
+   *  `until`, exactly one frame. `record(write)` once per tick suits a chunked,
+   *  time-budgeted bake; `record(stepAndWrite, isSettled)` bakes in one call
+   *  when the writer also advances the simulation. No-op once full. */
+  record(writer: TimelineWriter, until?: () => boolean): void;
+  /** Lerps the two frames bracketing `progress` (clamped to [0, 1], NaN reads
+   *  as 0) into `out`, which must hold at least `elementCount * stride`
+   *  floats. Zero-alloc. All zeros before the first frame. */
+  sampleInto(progress: number, out: Float32Array): void;
+}
+export declare function createTimeline(elementCount: number, dt: number, opts?: TimelineOptions): Timeline;
 interface WorldOptions {
   /** Acceleration applied to every dynamic body each step (px/s²). */
   gravity?: Vec2;
   /** Sequential-impulse iterations per step. More = stiffer stacks. */
   iterations?: number;
+  /** Opt-in per-body sleeping; off when absent. See `step` and `isSleeping`. */
+  sleep?: SleepOptions;
 }
 interface World {
   bodies: Body[];
   gravity: Vec2;
   iterations: number;
 }
+interface StepUntilOptions {
+  /** Time budget in ms, compared against `now()` after every step. */
+  budgetMs: number;
+  /** Step cap per call (integer >= 1). */
+  maxSteps?: number;
+  /** Polled after each step; `true` ends the call with `complete: true`. */
+  done?: () => boolean;
+  /** Clock in ms. Default `performance.now`, else `Date.now`; inject for deterministic tests. */
+  now?: () => number;
+}
+interface StepUntilResult {
+  /** Steps taken by this call, always >= 1. */
+  steps: number;
+  /** `true` when `done()` ended the call; `false` for `maxSteps` or the budget. */
+  complete: boolean;
+}
+/** Throws `RangeError` when `opts.sleep` has a negative or non-finite
+ *  threshold or a `steps` that is not an integer >= 1. */
 export declare function createWorld(opts?: WorldOptions): World;
 export declare function addBody(world: World, body: Body): Body;
 /** Advance the world by `dt` seconds (fixed steps recommended).
  *
- *  Resting contacts settle to a stable *position* but retain a small, bounded
- *  velocity oscillation at the penetration-slop equilibrium — a sequential-
- *  impulse solver with Baumgarte bias and no sleeping does not converge
- *  velocity to exactly zero at rest, only the position does. This is
- *  inherent to the algorithm, not a bug; sleeping and damping are
- *  deliberately out of scope for v1. A consumer needing pixel-exact
- *  stillness should clamp small resting velocities at its own layer. */
+ *  By default (no `WorldOptions.sleep`) resting contacts settle to a stable
+ *  *position* but retain a small, bounded velocity oscillation at the
+ *  penetration-slop equilibrium — a sequential-impulse solver with Baumgarte
+ *  bias does not converge velocity to exactly zero at rest, only the position
+ *  does. `WorldOptions.sleep` opts into per-body sleeping: a dynamic body
+ *  under both thresholds for `steps` consecutive steps has its velocities
+ *  zeroed and is skipped by integration and by pair tests against other
+ *  resting bodies until an awake body touches it, the consumer writes its
+ *  velocity, position or angle, or `wakeBody` is called. There are no
+ *  islands, so a woken stack wakes one level per step, and a sleeper does not
+ *  follow a static body that is moved under it. Damping stays out of scope.
+ *
+ *  A world that never went through `createWorld` (a spread copy or a
+ *  `structuredClone`) is adopted on its first `step` with sleeping off. */
 export declare function step(world: World, dt: number): void;
-export type { Body, BodyOptions, World, WorldOptions };
+/** `true` when `body` is asleep in `world`. `false` when the world has
+ *  sleeping off or never went through `createWorld`, when `body` is not in
+ *  `world.bodies`, or when its slot has not been bound to it by a `step` yet.
+ *  O(n) in `world.bodies.length` (an `indexOf`); poll it per body, not per
+ *  contact. */
+export declare function isSleeping(world: World, body: Body): boolean;
+/** `true` when every dynamic body in `world.bodies` is asleep — vacuously
+ *  true with no dynamic bodies, `false` with sleeping off and at least one.
+ *  The bake stop rule for `stepUntil`: `done: () => isAtRest(world)`. */
+export declare function isAtRest(world: World): boolean;
+/** Wakes `body` if it is asleep in `world` (flag cleared, counter 0, its
+ *  velocities stay 0); the next `step` integrates it again. No-op otherwise,
+ *  including with sleeping off or a body not in `world.bodies`. Use it for a
+ *  sleeper whose support was removed from `world.bodies` or moved — nothing
+ *  else wakes it. */
+export declare function wakeBody(world: World, body: Body): void;
+/** Repeats `step(world, dt)` until, checked in this order after each step,
+ *  `done()` returns true (`complete: true`), `steps >= maxSteps`, or
+ *  `now() - start >= budgetMs` (both `complete: false`). Always takes at least
+ *  one step, so a zero budget still makes progress. Writes `out` and returns it;
+ *  the zero-alloc per-frame form of `stepUntil`. Throws `RangeError` for a
+ *  non-finite or non-positive `dt`, a negative or non-finite `budgetMs`, or a
+ *  `maxSteps` that is not an integer >= 1. */
+export declare function stepUntilInto(world: World, dt: number, opts: StepUntilOptions, out: StepUntilResult): StepUntilResult;
+/** Allocating form of `stepUntilInto`; see it for the stop rules. */
+export declare function stepUntil(world: World, dt: number, opts: StepUntilOptions): StepUntilResult;
+export type { Body, BodyOptions, SleepOptions, StepUntilOptions, StepUntilResult, Timeline, TimelineOptions, TimelineWriter, World, WorldOptions };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/body.ts","../src/world.ts"],"mappings":";UAOiB;;EAEf,UAAU;;EAEV,UAAU;;EAEV;;EAEA;;EAEA,MAAM;;EAEN;;EAEA;;EAEA;;EAEA;;UAGe;EACf,UAAU;EACV,MAAM;;EAEN;EACA,WAAW;EACX;EACA;EACA;EACA;;EAEA;;wBAGc,WAAW,MAAM,cAAc;wBA6B/B,SAAS,GAAG;UCzDX;;EAEf,UAAU;;EAEV;;UAGe;EACf,QAAQ;EACR,SAAS;EACT;;wBAQc,YAAY,OAAM,eAAoB;wBAUtC,QAAQ,OAAO,OAAO,MAAM,OAAO;;;;;;;;;;wBAwKnC,KAAK,OAAO,OAAO"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/body.ts","../src/pool.ts","../src/timeline.ts","../src/world.ts"],"mappings":";UAOiB;;EAEf,UAAU;;EAEV,UAAU;;EAEV;;EAEA;;EAEA,MAAM;;EAEN;;EAEA;;EAEA;;EAEA;;UAGe;EACf,UAAU;EACV,MAAM;;EAEN;EACA,WAAW;EACX;EACA;EACA;EACA;;EAEA;;wBAGc,WAAW,MAAM,cAAc;wBA6B/B,SAAS,GAAG;UC/DX;;EAEf;;EAEA;;EAEA;;;;;;;;;;;;;UCFe;;EAEf;;EAEA;;;KAIU,kBAAkB,KAAK,cAAc;UAEhC;WACN;;WAEA;;WAEA;;;;;EAKT,OAAO,QAAQ,gBAAgB;;;;EAI/B,WAAW,kBAAkB,KAAK;;wBAYpB,eACd,sBACA,YACA,OAAM,kBACL;UChCc;;EAEf,UAAU;;EAEV;;EAEA,QAAQ;;UAGO;EACf,QAAQ;EACR,SAAS;EACT;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA;;UAGe;;EAEf;;EAEA;;;;wBAmCc,YAAY,OAAM,eAAoB;wBAUtC,QAAQ,OAAO,OAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;wBA0RnC,KAAK,OAAO,OAAO;;;;;;wBAyDnB,WAAW,OAAO,OAAO,MAAM;;;;wBAW/B,SAAS,OAAO;;;;;;wBAkBhB,SAAS,OAAO,OAAO,MAAM;;;;;;;;wBAgB7B,cACd,OAAO,OACP,YACA,MAAM,kBACN,KAAK,kBACJ;;wBA+Ba,UAAU,OAAO,OAAO,YAAY,MAAM,mBAAmB"}

package/dist/index.d.ts

@@ -34,28 +34,125 @@ interface BodyOptions {
 }
 export declare function createBody(opts: BodyOptions): Body;
 export declare function isStatic(b: Body): boolean;
+interface SleepOptions {
+  /** Linear speed below which a body counts as resting (same units as `velocity`, px/s). */
+  linearThreshold: number;
+  /** Angular speed below which a body counts as resting (rad/s). */
+  angularThreshold: number;
+  /** Consecutive under-threshold steps before a body is put to sleep (integer >= 1). */
+  steps: number;
+}
+/** Bake-once / scrub-often recorder for a fixed-step simulation. Friction +
+ *  restitution Euler is not time-reversible, so a fall is recorded once into a
+ *  pre-allocated `Float32Array` and replayed by sampling — reverse, scrub and
+ *  speed all read back through `sampleInto` instead of re-integrating.
+ *
+ *  Angles are stored exactly as written. `Body.angle` is cumulative and never
+ *  wrapped, so a plain lerp between adjacent frames is correct across
+ *  multi-turn spins; a shortest-path angle lerp would unravel them.
+ *
+ *  Float32 storage is deliberate: this is playback precision, not simulation
+ *  precision, at half the bytes of f64. */
+interface TimelineOptions {
+  /** Floats per element per frame. Default 3: `dx`, `dy`, `angle`. */
+  stride?: number;
+  /** Frame cap; the whole buffer is allocated at creation. Default 900. */
+  maxFrames?: number;
+}
+/** Fills one frame of `buf`: element `i` lives at `frameBase + i * stride`. */
+type TimelineWriter = (buf: Float32Array, frameBase: number) => void;
+interface Timeline {
+  readonly elementCount: number;
+  /** Frames recorded so far. */
+  readonly frameCount: number;
+  /** Recorded length in seconds: `(frameCount - 1) * dt`, 0 below two frames. */
+  readonly duration: number;
+  /** Writes frames until `until()` returns true or the buffer is full; without
+   *  `until`, exactly one frame. `record(write)` once per tick suits a chunked,
+   *  time-budgeted bake; `record(stepAndWrite, isSettled)` bakes in one call
+   *  when the writer also advances the simulation. No-op once full. */
+  record(writer: TimelineWriter, until?: () => boolean): void;
+  /** Lerps the two frames bracketing `progress` (clamped to [0, 1], NaN reads
+   *  as 0) into `out`, which must hold at least `elementCount * stride`
+   *  floats. Zero-alloc. All zeros before the first frame. */
+  sampleInto(progress: number, out: Float32Array): void;
+}
+export declare function createTimeline(elementCount: number, dt: number, opts?: TimelineOptions): Timeline;
 interface WorldOptions {
   /** Acceleration applied to every dynamic body each step (px/s²). */
   gravity?: Vec2;
   /** Sequential-impulse iterations per step. More = stiffer stacks. */
   iterations?: number;
+  /** Opt-in per-body sleeping; off when absent. See `step` and `isSleeping`. */
+  sleep?: SleepOptions;
 }
 interface World {
   bodies: Body[];
   gravity: Vec2;
   iterations: number;
 }
+interface StepUntilOptions {
+  /** Time budget in ms, compared against `now()` after every step. */
+  budgetMs: number;
+  /** Step cap per call (integer >= 1). */
+  maxSteps?: number;
+  /** Polled after each step; `true` ends the call with `complete: true`. */
+  done?: () => boolean;
+  /** Clock in ms. Default `performance.now`, else `Date.now`; inject for deterministic tests. */
+  now?: () => number;
+}
+interface StepUntilResult {
+  /** Steps taken by this call, always >= 1. */
+  steps: number;
+  /** `true` when `done()` ended the call; `false` for `maxSteps` or the budget. */
+  complete: boolean;
+}
+/** Throws `RangeError` when `opts.sleep` has a negative or non-finite
+ *  threshold or a `steps` that is not an integer >= 1. */
 export declare function createWorld(opts?: WorldOptions): World;
 export declare function addBody(world: World, body: Body): Body;
 /** Advance the world by `dt` seconds (fixed steps recommended).
  *
- *  Resting contacts settle to a stable *position* but retain a small, bounded
- *  velocity oscillation at the penetration-slop equilibrium — a sequential-
- *  impulse solver with Baumgarte bias and no sleeping does not converge
- *  velocity to exactly zero at rest, only the position does. This is
- *  inherent to the algorithm, not a bug; sleeping and damping are
- *  deliberately out of scope for v1. A consumer needing pixel-exact
- *  stillness should clamp small resting velocities at its own layer. */
+ *  By default (no `WorldOptions.sleep`) resting contacts settle to a stable
+ *  *position* but retain a small, bounded velocity oscillation at the
+ *  penetration-slop equilibrium — a sequential-impulse solver with Baumgarte
+ *  bias does not converge velocity to exactly zero at rest, only the position
+ *  does. `WorldOptions.sleep` opts into per-body sleeping: a dynamic body
+ *  under both thresholds for `steps` consecutive steps has its velocities
+ *  zeroed and is skipped by integration and by pair tests against other
+ *  resting bodies until an awake body touches it, the consumer writes its
+ *  velocity, position or angle, or `wakeBody` is called. There are no
+ *  islands, so a woken stack wakes one level per step, and a sleeper does not
+ *  follow a static body that is moved under it. Damping stays out of scope.
+ *
+ *  A world that never went through `createWorld` (a spread copy or a
+ *  `structuredClone`) is adopted on its first `step` with sleeping off. */
 export declare function step(world: World, dt: number): void;
-export type { Body, BodyOptions, World, WorldOptions };
+/** `true` when `body` is asleep in `world`. `false` when the world has
+ *  sleeping off or never went through `createWorld`, when `body` is not in
+ *  `world.bodies`, or when its slot has not been bound to it by a `step` yet.
+ *  O(n) in `world.bodies.length` (an `indexOf`); poll it per body, not per
+ *  contact. */
+export declare function isSleeping(world: World, body: Body): boolean;
+/** `true` when every dynamic body in `world.bodies` is asleep — vacuously
+ *  true with no dynamic bodies, `false` with sleeping off and at least one.
+ *  The bake stop rule for `stepUntil`: `done: () => isAtRest(world)`. */
+export declare function isAtRest(world: World): boolean;
+/** Wakes `body` if it is asleep in `world` (flag cleared, counter 0, its
+ *  velocities stay 0); the next `step` integrates it again. No-op otherwise,
+ *  including with sleeping off or a body not in `world.bodies`. Use it for a
+ *  sleeper whose support was removed from `world.bodies` or moved — nothing
+ *  else wakes it. */
+export declare function wakeBody(world: World, body: Body): void;
+/** Repeats `step(world, dt)` until, checked in this order after each step,
+ *  `done()` returns true (`complete: true`), `steps >= maxSteps`, or
+ *  `now() - start >= budgetMs` (both `complete: false`). Always takes at least
+ *  one step, so a zero budget still makes progress. Writes `out` and returns it;
+ *  the zero-alloc per-frame form of `stepUntil`. Throws `RangeError` for a
+ *  non-finite or non-positive `dt`, a negative or non-finite `budgetMs`, or a
+ *  `maxSteps` that is not an integer >= 1. */
+export declare function stepUntilInto(world: World, dt: number, opts: StepUntilOptions, out: StepUntilResult): StepUntilResult;
+/** Allocating form of `stepUntilInto`; see it for the stop rules. */
+export declare function stepUntil(world: World, dt: number, opts: StepUntilOptions): StepUntilResult;
+export type { Body, BodyOptions, SleepOptions, StepUntilOptions, StepUntilResult, Timeline, TimelineOptions, TimelineWriter, World, WorldOptions };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/body.ts","../src/world.ts"],"mappings":";UAOiB;;EAEf,UAAU;;EAEV,UAAU;;EAEV;;EAEA;;EAEA,MAAM;;EAEN;;EAEA;;EAEA;;EAEA;;UAGe;EACf,UAAU;EACV,MAAM;;EAEN;EACA,WAAW;EACX;EACA;EACA;EACA;;EAEA;;wBAGc,WAAW,MAAM,cAAc;wBA6B/B,SAAS,GAAG;UCzDX;;EAEf,UAAU;;EAEV;;UAGe;EACf,QAAQ;EACR,SAAS;EACT;;wBAQc,YAAY,OAAM,eAAoB;wBAUtC,QAAQ,OAAO,OAAO,MAAM,OAAO;;;;;;;;;;wBAwKnC,KAAK,OAAO,OAAO"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/body.ts","../src/pool.ts","../src/timeline.ts","../src/world.ts"],"mappings":";UAOiB;;EAEf,UAAU;;EAEV,UAAU;;EAEV;;EAEA;;EAEA,MAAM;;EAEN;;EAEA;;EAEA;;EAEA;;UAGe;EACf,UAAU;EACV,MAAM;;EAEN;EACA,WAAW;EACX;EACA;EACA;EACA;;EAEA;;wBAGc,WAAW,MAAM,cAAc;wBA6B/B,SAAS,GAAG;UC/DX;;EAEf;;EAEA;;EAEA;;;;;;;;;;;;;UCFe;;EAEf;;EAEA;;;KAIU,kBAAkB,KAAK,cAAc;UAEhC;WACN;;WAEA;;WAEA;;;;;EAKT,OAAO,QAAQ,gBAAgB;;;;EAI/B,WAAW,kBAAkB,KAAK;;wBAYpB,eACd,sBACA,YACA,OAAM,kBACL;UChCc;;EAEf,UAAU;;EAEV;;EAEA,QAAQ;;UAGO;EACf,QAAQ;EACR,SAAS;EACT;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA;;UAGe;;EAEf;;EAEA;;;;wBAmCc,YAAY,OAAM,eAAoB;wBAUtC,QAAQ,OAAO,OAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;wBA0RnC,KAAK,OAAO,OAAO;;;;;;wBAyDnB,WAAW,OAAO,OAAO,MAAM;;;;wBAW/B,SAAS,OAAO;;;;;;wBAkBhB,SAAS,OAAO,OAAO,MAAM;;;;;;;;wBAgB7B,cACd,OAAO,OACP,YACA,MAAM,kBACN,KAAK,kBACJ;;wBA+Ba,UAAU,OAAO,OAAO,YAAY,MAAM,mBAAmB"}