@opsydyn/effect-three 0.0.0-stage → 0.1.0

package/dist/webgpu/index.js.map

@@ -0,0 +1,13 @@
+{
+  "version": 3,
+  "sources": ["../src/webgpu/contactShadows.ts", "../src/webgpu/shaderGrid.ts", "../src/webgpu/sky.ts", "../src/webgpu/index.ts"],
+  "sourcesContent": [
+    "/**\n * The WebGPU kit's contact shadow materials, in TSL: the WebGL kit's shadow-from-depth\n * output (colour `color · depth · 2`, alpha `1 − depth`) and three's horizontal and\n * vertical blur shaders (nine taps, their weights). The passes themselves are the\n * kernel's.\n *\n * @module\n */\nimport { type Color, NoBlending, Texture } from 'three';\nimport { depth, float, texture, uniform, uv, vec2 } from 'three/tsl';\nimport { MeshBasicNodeMaterial } from 'three/webgpu';\n\nimport {\n  type BlurPass,\n  createContactShadowPasses,\n  type ShadowMaterials,\n} from '../kernel/contactShadowPasses.ts';\nimport type { SceneRenderer } from '../kernel/renderer.ts';\nimport type { ContactShadowPasses, ShadowedScene } from '../kernel/renderKit.ts';\n\n/** A material writing exactly what its nodes say: no blending, depth or tone mapping. */\nconst plainMaterial = (): MeshBasicNodeMaterial => {\n  const material = new MeshBasicNodeMaterial();\n  material.transparent = true;\n  material.blending = NoBlending;\n  material.depthTest = false;\n  material.depthWrite = false;\n  material.toneMapped = false;\n  return material;\n};\n\nconst depthMaterial = (color: Color): MeshBasicNodeMaterial => {\n  const material = plainMaterial();\n  // Darkest where an object touches the plane: `depth` is linear for the orthographic camera.\n  material.colorNode = uniform(color).mul(depth).mul(2);\n  material.opacityNode = float(1).sub(depth);\n  return material;\n};\n\n/** three's `HorizontalBlurShader` and `VerticalBlurShader` taps: offset and weight. */\nconst taps = [\n  [-4, 0.051],\n  [-3, 0.0918],\n  [-2, 0.12245],\n  [-1, 0.1531],\n  [0, 0.1633],\n  [1, 0.1531],\n  [2, 0.12245],\n  [3, 0.0918],\n  [4, 0.051],\n] as const;\n\nconst blur = (direction: 'horizontal' | 'vertical'): BlurPass => {\n  const source = texture(new Texture());\n  const step = uniform(0);\n  const along = direction === 'horizontal' ? vec2(step, 0) : vec2(0, step);\n  const [first, ...rest] = taps.map(([offset, weight]) =>\n    source.sample(uv().add(along.mul(offset))).mul(weight),\n  );\n  const sum = rest.reduce((total, tap) => total.add(tap), first ?? source);\n  const material = plainMaterial();\n  material.colorNode = sum.rgb;\n  material.opacityNode = sum.a;\n  return {\n    material,\n    set: (map, amount) => {\n      source.value = map;\n      step.value = amount;\n    },\n  };\n};\n\nconst webgpuShadowMaterials: ShadowMaterials = {\n  depth: depthMaterial,\n  blur,\n  flippedTargets: true,\n};\n\n/** Creates the contact shadow passes for one scene graph and renderer, in TSL. */\nexport const createContactShadows = (\n  graph: ShadowedScene,\n  renderer: SceneRenderer,\n): ContactShadowPasses => createContactShadowPasses(graph, renderer, webgpuShadowMaterials);\n",
+    "/**\n * The WebGPU kit's shader grid: the WebGL kit's grid (Drei's `Grid`, `bf6f4ad`, MIT; after\n * Fyrestar's `THREE.InfiniteGridHelper` and threlte's `Grid`) written in TSL, so that\n * three's `WebGPURenderer` can draw it on either backend. Same lines, same fade, same\n * camera uniforms set in `onBeforeRender`.\n *\n * @module\n */\nimport {\n  BackSide,\n  Color,\n  DoubleSide,\n  FrontSide,\n  Mesh,\n  Plane,\n  PlaneGeometry,\n  type Side,\n  Vector3,\n} from 'three';\nimport {\n  abs,\n  distance,\n  float,\n  fract,\n  fwidth,\n  min,\n  mix,\n  modelWorldMatrix,\n  modelWorldMatrixInverse,\n  positionGeometry,\n  pow,\n  select,\n  uniform,\n  varying,\n  vec4,\n} from 'three/tsl';\nimport { MeshBasicNodeMaterial } from 'three/webgpu';\n\nimport type { MaterialSide, ShaderGridNode } from '../kernel/description.ts';\nimport type { HostedShaderGrid } from '../kernel/renderKit.ts';\n\nconst sides = { front: FrontSide, back: BackSide, double: DoubleSide } satisfies Record<\n  MaterialSide,\n  Side\n>;\n\n/** The grid's uniforms: one node each, written from the description. */\nconst createUniforms = () => ({\n  cellSize: uniform(0.5),\n  cellThickness: uniform(0.5),\n  cellColor: uniform(new Color()),\n  sectionSize: uniform(1),\n  sectionThickness: uniform(1),\n  sectionColor: uniform(new Color()),\n  fadeDistance: uniform(100),\n  fadeStrength: uniform(1),\n  fadeFrom: uniform(1),\n  infinite: uniform(0),\n  followCamera: uniform(0),\n  cameraOnPlane: uniform(new Vector3()),\n  planeOrigin: uniform(new Vector3()),\n});\n\ntype Uniforms = ReturnType<typeof createUniforms>;\n\n/** The grid's material: the WebGL kit's vertex and fragment shaders, as TSL nodes. */\nconst gridMaterial = (u: Uniforms): MeshBasicNodeMaterial => {\n  const material = new MeshBasicNodeMaterial({ transparent: true });\n  // The plane geometry lies in XY; the grid lies in XZ. Infinite grids reach the fade.\n  const lifted = positionGeometry.xzy.mul(\n    select(u.infinite.greaterThan(0.5), u.fadeDistance.add(1), 1),\n  );\n  // Following the camera slides the plane by its foot's offset, in the grid's own space.\n  const shift = modelWorldMatrixInverse.mul(vec4(u.cameraOnPlane.sub(u.planeOrigin), 0)).xyz;\n  const local = select(u.followCamera.greaterThan(0.5), lifted.add(shift), lifted);\n  material.positionNode = local;\n  const gridPosition = varying(local);\n  const worldPosition = varying(modelWorldMatrix.mul(vec4(local, 1)).xyz);\n  // 1 on a line of a grid with this spacing, 0 between, antialiased over a pixel.\n  const lines = (spacing: typeof u.cellSize, thickness: typeof u.cellThickness) => {\n    const at = gridPosition.xz.div(spacing);\n    const away = abs(fract(at.sub(0.5)).sub(0.5)).div(fwidth(at));\n    return float(1).sub(min(min(away.x, away.y).add(1).sub(thickness), 1));\n  };\n  const cell = lines(u.cellSize, u.cellThickness);\n  const section = lines(u.sectionSize, u.sectionThickness);\n  const away = distance(u.cameraOnPlane.mul(u.fadeFrom), worldPosition);\n  const fade = pow(float(1).sub(min(away.div(u.fadeDistance), 1)), u.fadeStrength);\n  const alpha = cell.add(section).mul(fade);\n  material.colorNode = mix(u.cellColor, u.sectionColor, min(1, u.sectionThickness.mul(section)));\n  material.opacityNode = mix(alpha.mul(0.75), alpha, section);\n  // Discard where there is no line, as the WebGL kit's shader does.\n  material.alphaTest = 1e-4;\n  return material;\n};\n\n/** Writes a node's settings into the uniforms and material. */\nconst writeUniforms = (\n  u: Uniforms,\n  material: MeshBasicNodeMaterial,\n  node: ShaderGridNode,\n): void => {\n  u.cellSize.value = node.cellSize;\n  u.cellThickness.value = node.cellThickness;\n  u.cellColor.value.setHex(node.cellColor);\n  u.sectionSize.value = node.sectionSize;\n  u.sectionThickness.value = node.sectionThickness;\n  u.sectionColor.value.setHex(node.sectionColor);\n  u.fadeDistance.value = node.fadeDistance;\n  u.fadeStrength.value = node.fadeStrength;\n  u.fadeFrom.value = node.fadeFrom;\n  u.infinite.value = node.infinite ? 1 : 0;\n  u.followCamera.value = node.followCamera ? 1 : 0;\n  material.side = sides[node.side];\n};\n\nconst up = new Vector3(0, 1, 0);\nconst origin = new Vector3();\nconst plane = new Plane();\nconst cameraPosition = new Vector3();\n\n/** The WebGPU kit's shader grid: a plane with the grid material, placed and updated. */\nexport const hostShaderGrid = (node: ShaderGridNode): HostedShaderGrid => {\n  const u = createUniforms();\n  const material = gridMaterial(u);\n  writeUniforms(u, material, node);\n  const mesh = new Mesh(new PlaneGeometry(...node.size), material);\n  // The shader moves vertices (infinite, following): the plane's own bounds mean nothing.\n  mesh.frustumCulled = false;\n  const place = (next: ShaderGridNode): void => {\n    mesh.position.fromArray(next.position);\n    mesh.rotation.fromArray([...next.rotation]);\n  };\n  place(node);\n  mesh.onBeforeRender = (_renderer, _scene, camera) => {\n    plane.setFromNormalAndCoplanarPoint(up, origin).applyMatrix4(mesh.matrixWorld);\n    plane.projectPoint(\n      cameraPosition.setFromMatrixPosition(camera.matrixWorld),\n      u.cameraOnPlane.value,\n    );\n    u.planeOrigin.value.set(0, 0, 0).applyMatrix4(mesh.matrixWorld);\n  };\n  return {\n    object: mesh,\n    update: (previous, next) => {\n      if (previous.size[0] !== next.size[0] || previous.size[1] !== next.size[1]) {\n        mesh.geometry.dispose();\n        mesh.geometry = new PlaneGeometry(...next.size);\n      }\n      writeUniforms(u, material, next);\n      place(next);\n    },\n    dispose: () => {\n      mesh.geometry.dispose();\n      material.dispose();\n    },\n  };\n};\n",
+    "/**\n * The WebGPU kit's sky: three.js's `SkyMesh` (`addons/objects/SkyMesh.js` at 0.186.1), the\n * same Preetham sky as the WebGL kit's `Sky`, written in TSL. Never picked.\n *\n * @module\n */\nimport { SkyMesh } from 'three/addons/objects/SkyMesh.js';\n\nimport type { Sky } from '../kernel/description.ts';\nimport type { HostedSky } from '../kernel/renderKit.ts';\n\n/** Writes a sky's description into the mesh's uniforms and scale. */\nconst writeSky = (mesh: SkyMesh, description: Sky): void => {\n  mesh.turbidity.value = description.turbidity;\n  mesh.rayleigh.value = description.rayleigh;\n  mesh.mieCoefficient.value = description.mieCoefficient;\n  mesh.mieDirectionalG.value = description.mieDirectionalG;\n  mesh.cloudCoverage.value = description.clouds;\n  mesh.sunPosition.value.fromArray(description.sunPosition);\n  mesh.scale.setScalar(description.distance);\n};\n\n/** Creates the sky mesh; the scene graph adds it and writes its description. */\nexport const hostSky = (): HostedSky => {\n  const mesh = new SkyMesh();\n  mesh.raycast = () => undefined;\n  return {\n    object: mesh,\n    update: (description) => writeSky(mesh, description),\n    dispose: () => {\n      mesh.geometry.dispose();\n      mesh.material.dispose();\n    },\n  };\n};\n",
+    "/**\n * The WebGPU render kit: the scene's shaded parts (the sky, the shader grid, contact\n * shadows) written in TSL, for three.js's `WebGPURenderer` on either of its backends.\n * The Foldkit adapter's `webgpuRendererFactory` carries it.\n *\n * @module\n */\nimport type { RenderKit } from '../kernel/renderKit.ts';\nimport { createContactShadows } from './contactShadows.ts';\nimport { hostShaderGrid } from './shaderGrid.ts';\nimport { hostSky } from './sky.ts';\n\nexport const webgpuKit: RenderKit = {\n  // troika's labels are WebGL materials; real WebGPU rejects their draw calls.\n  drawsLabels: false,\n  sky: hostSky,\n  shaderGrid: hostShaderGrid,\n  contactShadows: createContactShadows,\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "A69C3B6B3C01FA2F64756E2164756E21",
+  "names": []
+}

package/dist/webgpu/shaderGrid.d.ts

@@ -0,0 +1,5 @@
+import type { ShaderGridNode } from '../kernel/description.ts';
+import type { HostedShaderGrid } from '../kernel/renderKit.ts';
+/** The WebGPU kit's shader grid: a plane with the grid material, placed and updated. */
+export declare const hostShaderGrid: (node: ShaderGridNode) => HostedShaderGrid;
+//# sourceMappingURL=shaderGrid.d.ts.map

package/dist/webgpu/shaderGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shaderGrid.d.ts","sourceRoot":"","sources":["../../src/webgpu/shaderGrid.ts"],"names":[],"mappings":"AAsCA,OAAO,KAAK,EAAgB,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAkF/D,wFAAwF;AACxF,eAAO,MAAM,cAAc,SAAU,cAAc,KAAG,gBAmCrD,CAAC"}

package/dist/webgpu/sky.d.ts

@@ -0,0 +1,4 @@
+import type { HostedSky } from '../kernel/renderKit.ts';
+/** Creates the sky mesh; the scene graph adds it and writes its description. */
+export declare const hostSky: () => HostedSky;
+//# sourceMappingURL=sky.d.ts.map

package/dist/webgpu/sky.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sky.d.ts","sourceRoot":"","sources":["../../src/webgpu/sky.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAaxD,gFAAgF;AAChF,eAAO,MAAM,OAAO,QAAO,SAW1B,CAAC"}

package/package.json

@@ -1,6 +1,84 @@
 {
   "name": "@opsydyn/effect-three",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Effect-native declarative Three.js scenes: scoped resources, keyed reconciliation, testable frame loop.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/opsydyn/fold-kit-experiments.git",
+    "directory": "packages/effect-three"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "!dist/.tsbuildinfo",
+    "!dist/api-extractor",
+    "!dist/pack"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./kernel": {
+      "types": "./dist/kernel/index.d.ts",
+      "bun": "./src/kernel/index.ts",
+      "default": "./dist/kernel/index.js"
+    },
+    "./webgl": {
+      "types": "./dist/webgl/index.d.ts",
+      "bun": "./src/webgl/index.ts",
+      "default": "./dist/webgl/index.js"
+    },
+    "./webgpu": {
+      "types": "./dist/webgpu/index.d.ts",
+      "bun": "./src/webgpu/index.ts",
+      "default": "./dist/webgpu/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsc -b && tsc -p tsconfig.test.json",
+    "lint": "bunx --bun oxlint --config oxlint.strict.ts",
+    "check:boundaries": "bun scripts/check-boundaries.ts",
+    "check:single-effect": "bun scripts/check-single-effect.ts",
+    "check": "bun run lint && bun run check:boundaries && bun run check:single-effect",
+    "test": "bun test --pass-with-no-tests ./src ./test --coverage --coverage-reporter=lcov --coverage-dir=coverage && bun scripts/check-coverage.ts coverage/lcov.info",
+    "build": "tsc -b && bun build ./src/index.ts ./src/kernel/index.ts ./src/webgl/index.ts ./src/webgpu/index.ts --root ./src --outdir ./dist --target browser --packages external --splitting --sourcemap=linked",
+    "bench": "bun bench/index.ts",
+    "bench:check": "bun bench/index.ts --check",
+    "api:report": "api-extractor run --local",
+    "api:check": "api-extractor run",
+    "pack:check": "bun run build && publint && rm -rf dist/pack && bun pm pack --destination dist/pack && attw dist/pack/*.tgz --profile esm-only"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "0.18.5",
+    "@microsoft/api-extractor": "7.59.4",
+    "@opsydyn/oxlint-effect": "2.0.1",
+    "@types/bun": "1.4.3",
+    "@types/pngjs": "6.0.5",
+    "@types/three": "0.186.0",
+    "effect": "4.0.0",
+    "oxlint": "1.88.0",
+    "oxlint-tsgolint": "7.0.2004",
+    "pixelmatch": "8.0.0",
+    "playwright": "1.64.1",
+    "pngjs": "7.0.0",
+    "publint": "0.3.25",
+    "three": "0.186.1",
+    "typescript": "7.0.2"
+  },
+  "peerDependencies": {
+    "effect": "^4.0.0",
+    "three": ">=0.186.0 <0.187.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Effect-native declarative Three.js scenes.
+ *
+ * - Authoring: `scene`, `mesh`, `group`, `box`, `standard`, `spin` and friends.
+ * - Runtime: `SceneRuntime.make` inside a `Scope`, with `ResourceRegistry` and
+ *   `FrameSource` provided by the application.
+ *
+ * @module
+ */
+export * from './kernel/index.ts';
+export * from './runtime/index.ts';

package/src/kernel/animation.ts

@@ -0,0 +1,24 @@
+/**
+ * Clip playback as a pure function of scene time.
+ *
+ * @module
+ */
+import type { Animation } from './description.ts';
+
+/** Just under the clip's end: three wraps a looping action at exactly its duration. */
+const endEpsilon = 1e-6;
+
+/**
+ * The clip time to show `elapsed` seconds after playback started: wrapped for looping
+ * clips (backwards too, for negative speeds), held at the last frame otherwise.
+ */
+export const clipTime = (animation: Animation, duration: number, elapsed: number): number => {
+  if (duration <= 0) return 0;
+  const t = elapsed * animation.speed;
+  if (animation.loop) return ((t % duration) + duration) % duration;
+  return Math.min(Math.max(t, 0), duration - endEpsilon);
+};
+
+/** Whether playback still changes the pose: always for loops, until the end otherwise. */
+export const clipRunning = (animation: Animation, duration: number, elapsed: number): boolean =>
+  animation.loop || (animation.speed !== 0 && Math.abs(elapsed * animation.speed) < duration);

package/src/kernel/behaviours.ts

@@ -0,0 +1,36 @@
+/**
+ * Behaviours own animated properties (PLAN D4). Their output is a pure function of
+ * elapsed scene time, so a frame's result doesn't depend on how many frames ran before
+ * it: deterministic and frame-rate independent.
+ *
+ * @module
+ */
+import type { Euler } from 'three';
+
+import type { Rotation } from './description.ts';
+
+/** The spin angle in radians after `elapsedSeconds`. */
+export const spinAngle = (
+  spin: Extract<Rotation, { readonly _tag: 'Spin' }>,
+  elapsedSeconds: number,
+): number => spin.phase + spin.radiansPerSecond * elapsedSeconds;
+
+/** Writes a rotation into a three.js Euler without allocating. */
+export const writeRotation = (target: Euler, rotation: Rotation, elapsedSeconds: number): void => {
+  if (rotation._tag === 'Fixed') {
+    target.set(rotation.euler[0], rotation.euler[1], rotation.euler[2]);
+    return;
+  }
+  const angle = spinAngle(rotation, elapsedSeconds);
+  switch (rotation.axis) {
+    case 'x':
+      target.set(angle, 0, 0);
+      return;
+    case 'y':
+      target.set(0, angle, 0);
+      return;
+    case 'z':
+      target.set(0, 0, angle);
+      return;
+  }
+};

package/src/kernel/bodies.ts

@@ -0,0 +1,338 @@
+/**
+ * Rigid bodies for a scene graph's nodes: a physics world kept in step with the
+ * description, advanced on scene time, its poses written back to the nodes (or, for an
+ * instances node, to each instance's matrix).
+ *
+ * Behavioural reference: react-three-rapier at `ae5c3fe`, `src/components/Physics.tsx`:
+ * fixed steps from an accumulator, the frame delta clamped to 0.5 s, nothing stepped while
+ * paused, and each body placed between its last two simulated poses (`interpolate`),
+ * converted from world space into its parent's space.
+ *
+ * @module
+ */
+import { Euler, Quaternion, type Scene } from 'three';
+
+import { bodyId, type BodySource } from './bodySources.ts';
+import type { Body, Joint, Physics, Vec3 } from './description.ts';
+import { bodyEquals, collidersEqual, jointEquals, physicsEquals } from './equality.ts';
+import type { BodyPose, PhysicsEngine, PhysicsJoint, PhysicsWorld, Quat } from './physics.ts';
+import { createPhysicsDebug } from './physicsDebug.ts';
+
+/** Two bodies began (`started`) or stopped touching: their nodes' keys, and instances'. */
+export type BodyCollision = {
+  readonly a: string;
+  readonly aInstance?: string;
+  /** The part of body `a` that touched (a mesh's or collider's name), when it has one. */
+  readonly aPart?: string;
+  readonly b: string;
+  readonly bInstance?: string;
+  readonly bPart?: string;
+  readonly started: boolean;
+};
+
+/**
+ * Two bodies pushing on each other harder than a threshold: their nodes' keys (and
+ * instances'), and Rapier's contact force payload, as react-three-rapier's
+ * `onContactForce`.
+ */
+export type BodyContactForce = {
+  readonly a: string;
+  readonly aInstance?: string;
+  readonly aPart?: string;
+  readonly b: string;
+  readonly bInstance?: string;
+  readonly bPart?: string;
+  readonly totalForce: Vec3;
+  readonly totalForceMagnitude: number;
+  readonly maxForceDirection: Vec3;
+  readonly maxForceMagnitude: number;
+};
+
+type Hosted = {
+  source: BodySource;
+  /** What its colliders were made from; a change makes them again. */
+  signature: string;
+  previous: BodyPose;
+  current: BodyPose;
+  /** Where it was last placed, between `previous` and `current`. */
+  shown: BodyPose;
+};
+
+export type BodyHost = {
+  /** Brings the world in line with the description's physics and its bodies. */
+  readonly sync: (physics: Physics | null, sources: Iterable<BodySource>) => void;
+  /** Steps the world to scene time `elapsed` and moves dynamic bodies to their poses. */
+  readonly tick: (elapsed: number, animating: boolean) => void;
+  /** Whether the simulation still moves anything. */
+  readonly needsFrame: () => boolean;
+  /** Collisions since the last call. */
+  readonly drainCollisions: () => ReadonlyArray<BodyCollision>;
+  /** Contact forces over their thresholds since the last call. */
+  readonly drainContactForces: () => ReadonlyArray<BodyContactForce>;
+  readonly dispose: () => void;
+};
+
+const from = new Quaternion();
+const to = new Quaternion();
+const euler = new Euler();
+
+const quatOf = (angles: Vec3): Quat => {
+  from.setFromEuler(euler.fromArray([...angles]));
+  return [from.x, from.y, from.z, from.w];
+};
+
+/** A joint for the engine: a fixed joint's frames turned into quaternions. */
+const physicsJoint = ({ anchorA, anchorB, kind, contacts }: Joint): PhysicsJoint => ({
+  anchorA,
+  anchorB,
+  contacts,
+  kind:
+    kind._tag === 'Fixed'
+      ? { _tag: 'Fixed', frameA: quatOf(kind.frameA), frameB: quatOf(kind.frameB) }
+      : kind,
+});
+
+/** The pose `alpha` of the way from `a` to `b`: positions lerped, rotations slerped. */
+const between = (a: BodyPose, b: BodyPose, alpha: number): BodyPose => {
+  if (alpha >= 1) return b;
+  from.fromArray(a.quaternion);
+  to.fromArray(b.quaternion);
+  from.slerp(to, alpha);
+  return {
+    position: [
+      a.position[0] + (b.position[0] - a.position[0]) * alpha,
+      a.position[1] + (b.position[1] - a.position[1]) * alpha,
+      a.position[2] + (b.position[2] - a.position[2]) * alpha,
+    ],
+    quaternion: [from.x, from.y, from.z, from.w],
+  };
+};
+
+/** A change that needs a new body: another holder or kind, or colliders made otherwise. */
+const remade = (hosted: Hosted, source: BodySource, signature: string): boolean =>
+  hosted.source.holder !== source.holder ||
+  hosted.source.body.collider !== source.body.collider ||
+  !collidersEqual(hosted.source.body.colliders, source.body.colliders) ||
+  hosted.signature !== signature;
+
+/** Body settings other than its impulse differ. */
+const resettled = (a: Body, b: Body): boolean =>
+  !bodyEquals({ ...a, impulse: null }, { ...b, impulse: null });
+
+/** Bodies `a` and `b` (by id) named by their nodes, instances and parts, where they have them. */
+const named = (
+  a: BodySource | undefined,
+  b: BodySource | undefined,
+  ids: {
+    readonly a: string;
+    readonly b: string;
+    readonly aPart?: string;
+    readonly bPart?: string;
+  },
+): Pick<BodyCollision, 'a' | 'aInstance' | 'aPart' | 'b' | 'bInstance' | 'bPart'> => {
+  const aInstance = a?.instance;
+  const bInstance = b?.instance;
+  return {
+    a: a?.key ?? ids.a,
+    ...(aInstance === undefined ? {} : { aInstance }),
+    ...(ids.aPart === undefined ? {} : { aPart: ids.aPart }),
+    b: b?.key ?? ids.b,
+    ...(bInstance === undefined ? {} : { bInstance }),
+    ...(ids.bPart === undefined ? {} : { bPart: ids.bPart }),
+  };
+};
+
+/** Creates the body host for a scene. Without an engine, bodies are ignored. */
+export const createBodyHost = (engine: PhysicsEngine | undefined, scene: Scene): BodyHost => {
+  let world: PhysicsWorld | undefined;
+  let settings: Physics | null = null;
+  const hosted = new Map<string, Hosted>();
+  /** Joints made, by key. */
+  const joined = new Map<string, Joint>();
+  /** Bodies (re)made by the current sync: their joints went with the old ones. */
+  const fresh = new Set<string>();
+  let collisions: Array<BodyCollision> = [];
+  let contactForces: Array<BodyContactForce> = [];
+  const debug = createPhysicsDebug(scene);
+  let last: number | undefined;
+  let accumulator = 0;
+
+  /** Draws the world's lines while the description asks for them. */
+  const drawDebug = (): void => {
+    if (world !== undefined && settings?.debug === true) debug.show(world.debugLines());
+    else debug.hide();
+  };
+
+  const dispose = (): void => {
+    debug.hide();
+    world?.dispose();
+    world = undefined;
+    settings = null;
+    hosted.clear();
+    joined.clear();
+    accumulator = 0;
+    last = undefined;
+  };
+
+  const add = (active: PhysicsWorld, source: BodySource, signature: string): void => {
+    const pose = source.pose();
+    active.add(source.id, source.body, source.colliders(), pose);
+    if (source.body.impulse !== null) active.applyImpulse(source.id, source.body.impulse.impulse);
+    hosted.set(source.id, { source, signature, previous: pose, current: pose, shown: pose });
+    fresh.add(source.id);
+  };
+
+  const syncBody = (active: PhysicsWorld, source: BodySource): void => {
+    const existing = hosted.get(source.id);
+    const signature = source.signature();
+    if (existing === undefined || remade(existing, source, signature)) {
+      if (existing !== undefined) active.remove(source.id);
+      add(active, source, signature);
+      return;
+    }
+    const before = existing.source.body;
+    const { body } = source;
+    if (resettled(before, body)) active.update(source.id, body);
+    if (body.type !== 'kinematic' && existing.source.placement !== source.placement) {
+      const pose = source.described();
+      active.teleport(source.id, pose);
+      existing.previous = pose;
+      existing.current = pose;
+      existing.shown = pose;
+      source.place(pose);
+    } else if (body.type === 'dynamic') {
+      // A description change elsewhere (an instance's colour, say) may have rewritten it.
+      source.place(existing.shown);
+    }
+    if (body.impulse !== null && body.impulse.id !== before.impulse?.id) {
+      active.applyImpulse(source.id, body.impulse.impulse);
+    }
+    existing.source = source;
+  };
+
+  /** Makes each joint whose bodies both exist, again when either was remade or it changed. */
+  const syncJoints = (active: PhysicsWorld, joints: ReadonlyArray<Joint>): void => {
+    const seen = new Set<string>();
+    for (const joint of joints) {
+      seen.add(joint.key);
+      const a = bodyId(joint.a.key, joint.a.instance);
+      const b = bodyId(joint.b.key, joint.b.instance);
+      const ready = hosted.has(a) && hosted.has(b);
+      const made = joined.get(joint.key);
+      if (
+        made !== undefined &&
+        ready &&
+        !fresh.has(a) &&
+        !fresh.has(b) &&
+        jointEquals(made, joint)
+      ) {
+        continue;
+      }
+      if (made !== undefined) {
+        active.removeJoint(joint.key);
+        joined.delete(joint.key);
+      }
+      if (ready) {
+        active.addJoint(joint.key, physicsJoint(joint), a, b);
+        joined.set(joint.key, joint);
+      }
+    }
+    for (const key of joined.keys()) {
+      if (seen.has(key)) continue;
+      active.removeJoint(key);
+      joined.delete(key);
+    }
+  };
+
+  const sync: BodyHost['sync'] = (physics, sources) => {
+    if (physics === null || engine === undefined) {
+      dispose();
+      return;
+    }
+    if (world === undefined) world = engine.createWorld(physics);
+    // Joints are made below, not configured.
+    else if (!physicsEquals(settings && { ...settings, joints: physics.joints }, physics)) {
+      world.configure(physics);
+    }
+    settings = physics;
+    scene.updateMatrixWorld();
+    fresh.clear();
+    const seen = new Set<string>();
+    for (const source of sources) {
+      seen.add(source.id);
+      syncBody(world, source);
+    }
+    for (const id of hosted.keys()) {
+      if (seen.has(id)) continue;
+      world.remove(id);
+      hosted.delete(id);
+    }
+    syncJoints(world, physics.joints);
+    drawDebug();
+  };
+
+  const kinematicTargets = (active: PhysicsWorld): void => {
+    for (const [id, { source }] of hosted) {
+      if (source.body.type === 'kinematic') active.moveKinematic(id, source.pose());
+    }
+  };
+
+  const step = (active: PhysicsWorld, seconds: number): void => {
+    for (const body of hosted.values()) body.previous = body.current;
+    kinematicTargets(active);
+    for (const collision of active.step(seconds)) {
+      collisions.push({
+        ...named(hosted.get(collision.a)?.source, hosted.get(collision.b)?.source, collision),
+        started: collision.started,
+      });
+    }
+    for (const force of active.contactForces()) {
+      const { a, b, aPart, bPart, ...payload } = force;
+      contactForces.push({
+        ...named(hosted.get(a)?.source, hosted.get(b)?.source, force),
+        ...payload,
+      });
+    }
+    for (const [id, body] of hosted) body.current = active.pose(id) ?? body.current;
+  };
+
+  const tick: BodyHost['tick'] = (elapsed, animating) => {
+    const delta = last === undefined ? 0 : Math.min(0.5, Math.max(0, elapsed - last));
+    last = elapsed;
+    if (world === undefined || settings === null || settings.paused || !animating) return;
+    const timeStep = settings.timeStep;
+    accumulator += delta;
+    scene.updateMatrixWorld();
+    while (accumulator >= timeStep) {
+      step(world, timeStep);
+      accumulator -= timeStep;
+    }
+    const alpha = settings.interpolate ? accumulator / timeStep : 1;
+    for (const body of hosted.values()) {
+      if (body.source.body.type === 'dynamic') {
+        body.shown = between(body.previous, body.current, alpha);
+        body.source.place(body.shown);
+      }
+    }
+    if (settings.debug) drawDebug();
+  };
+
+  return {
+    sync,
+    tick,
+    needsFrame: () => world !== undefined && settings !== null && !settings.paused && world.awake(),
+    drainCollisions: () => {
+      if (collisions.length === 0) return collisions;
+      const drained = collisions;
+      collisions = [];
+      return drained;
+    },
+    drainContactForces: () => {
+      if (contactForces.length === 0) return contactForces;
+      const drained = contactForces;
+      contactForces = [];
+      return drained;
+    },
+    dispose,
+  };
+};