@opsydyn/effect-three 0.4.0 → 0.6.4

package/dist/{index-h3vf50fn.js → index-re3rrfwd.js}

@@ -55,6 +55,18 @@ __export(exports_lockstep, {
   welcomeDue: () => welcomeDue
 });
 
+// src/kernel/timeline.ts
+var exports_timeline = {};
+__export(exports_timeline, {
+  due: () => due,
+  extend: () => extend,
+  make: () => make3,
+  reach: () => reach,
+  restart: () => restart,
+  schedule: () => schedule,
+  until: () => until
+});
+
 // src/kernel/description.ts
 var handJoints2 = [
   "wrist",
@@ -564,7 +576,9 @@ var trailEquals = (a, b) => a === b || a !== null && b !== null && Object.is(a.w
 var edgesEquals = (a, b) => a === b || a !== null && b !== null && Object.is(a.threshold, b.threshold) && Object.is(a.color, b.color) && Object.is(a.width, b.width) && a.worldUnits === b.worldUnits && a.dashed === b.dashed && Object.is(a.dashSize, b.dashSize) && Object.is(a.gapSize, b.gapSize) && Object.is(a.opacity, b.opacity) && a.transparent === b.transparent;
 var lineLookEquals = (a, b) => a.segments === b.segments && Object.is(a.color, b.color) && Object.is(a.width, b.width) && a.worldUnits === b.worldUnits && a.dashed === b.dashed && Object.is(a.dashSize, b.dashSize) && Object.is(a.gapSize, b.gapSize) && Object.is(a.dashScale, b.dashScale) && Object.is(a.dashOffset, b.dashOffset) && Object.is(a.opacity, b.opacity) && a.transparent === b.transparent && (a.points === b.points || a.points.length === b.points.length && a.points.every((point, index) => vec3Equals2(point, b.points[index] ?? point))) && (a.vertexColors === b.vertexColors || a.vertexColors !== null && b.vertexColors !== null && a.vertexColors.length === b.vertexColors.length && a.vertexColors.every((color, index) => Object.is(color, b.vertexColors?.[index])));
 var shaderGridLookEquals = (a, b) => Object.is(a.size[0], b.size[0]) && Object.is(a.size[1], b.size[1]) && Object.is(a.cellSize, b.cellSize) && Object.is(a.cellThickness, b.cellThickness) && a.cellColor === b.cellColor && Object.is(a.sectionSize, b.sectionSize) && Object.is(a.sectionThickness, b.sectionThickness) && a.sectionColor === b.sectionColor && a.infinite === b.infinite && a.followCamera === b.followCamera && Object.is(a.fadeDistance, b.fadeDistance) && Object.is(a.fadeStrength, b.fadeStrength) && Object.is(a.fadeFrom, b.fadeFrom) && a.side === b.side;
-var physicsEquals2 = (a, b) => a === b || a !== null && b !== null && vec3Equals2(a.gravity, b.gravity) && a.paused === b.paused && Object.is(a.timeStep, b.timeStep) && a.interpolate === b.interpolate && a.debug === b.debug && jointsEqual(a.joints, b.joints);
+var assetEquals = (a, b) => b !== undefined && a.kind === b.kind && a.id === b.id && a.url === b.url && a.levels.length === b.levels.length && a.levels.every((level, i) => level === b.levels[i]);
+var assetsEqual2 = (a, b) => a === b || a.length === b.length && a.every((asset, i) => assetEquals(asset, b[i]));
+var physicsEquals2 = (a, b) => a === b || a !== null && b !== null && vec3Equals2(a.gravity, b.gravity) && a.paused === b.paused && Object.is(a.timeStep, b.timeStep) && a.interpolate === b.interpolate && a.until === b.until && a.run === b.run && a.snapshotAt === b.snapshotAt && a.keep === b.keep && (a.from === b.from || a.from !== null && b.from !== null && a.from.step === b.from.step && a.from.snapshot === b.from.snapshot) && a.debug === b.debug && jointsEqual(a.joints, b.joints);
 var xrAnchorEquals = (a, b) => b !== undefined && a.id === b.id && vec3Equals2(a.position, b.position) && vec3Equals2(a.rotation, b.rotation);
 var xrEquals2 = (a, b) => a === b || a !== null && b !== null && vec3Equals2(a.origin, b.origin) && Object.is(a.heading, b.heading) && a.referenceSpace === b.referenceSpace && Object.is(a.framebufferScale, b.framebufferScale) && a.hitTest === b.hitTest && a.showInputs === b.showInputs && (a.glide === b.glide || a.glide !== null && b.glide !== null && Object.is(a.glide.speed, b.glide.speed) && a.glide.turn === b.glide.turn && Object.is(a.glide.turnSpeed, b.glide.turnSpeed) && Object.is(a.glide.snapDegrees, b.glide.snapDegrees)) && a.planes === b.planes && a.meshes === b.meshes && a.domOverlay === b.domOverlay && a.anchors.length === b.anchors.length && a.anchors.every((anchor, i) => xrAnchorEquals(anchor, b.anchors[i]));
 var xrSpaceEquals = (a, b) => {
@@ -1175,6 +1189,11 @@ var physics2 = (options = {}) => ({
   paused: options.paused ?? false,
   timeStep: options.timeStep ?? 1 / 60,
   interpolate: options.interpolate ?? true,
+  until: options.until ?? null,
+  run: options.run ?? 0,
+  snapshotAt: options.snapshotAt ?? null,
+  from: options.from ?? null,
+  keep: options.keep ?? 0,
   debug: options.debug ?? false,
   joints: options.joints ?? noJoints
 });
@@ -1476,6 +1495,13 @@ var contactShadows2 = (options = {}) => {
 };
 var noOverlays = [];
 var noMeasures = [];
+var noAssets = [];
+var noLevels = [];
+var assetOf = (kind) => ({ id, url, levels }) => ({ kind, id, url, levels: levels ?? noLevels });
+var modelAsset2 = assetOf("model");
+var textureAsset2 = assetOf("texture");
+var environmentAsset2 = assetOf("environment");
+var fontAsset2 = assetOf("font");
 var defaultZIndexRange = [16777271, 0];
 var overlay2 = (options) => ({
   key: options.key,
@@ -1505,6 +1531,7 @@ var scene2 = (options) => ({
   physics: options.physics ?? null,
   xr: options.xr ?? null,
   measure: options.measure ?? noMeasures,
+  assets: options.assets ?? noAssets,
   render: options.render ?? defaultRenderSettings,
   resources: {
     geometries: options.resources?.geometries ?? noResources.geometries,
@@ -1549,6 +1576,10 @@ var indexScene2 = (description, behaviours = new Set) => {
   if (duplicateView !== undefined) {
     return { _tag: "Invalid", error: { _tag: "DuplicateViewKey", key: duplicateView } };
   }
+  const duplicateAsset = firstDuplicateInstance(description.assets.map((asset) => ({ key: asset.id })));
+  if (duplicateAsset !== undefined) {
+    return { _tag: "Invalid", error: { _tag: "DuplicateAssetId", id: duplicateAsset } };
+  }
   const duplicateOverlay = firstDuplicateInstance(description.overlays);
   if (duplicateOverlay !== undefined) {
     return { _tag: "Invalid", error: { _tag: "DuplicateOverlayKey", key: duplicateOverlay } };
@@ -2954,6 +2985,38 @@ var interactionBits2 = (groups) => {
   const filters = groups.filters === null ? 65535 : mask(groups.filters);
   return (mask(groups.memberships) << 16 | filters) >>> 0;
 };
+var run = (first, count) => Array.from({ length: count }, (_, i) => String.fromCharCode(first.charCodeAt(0) + i));
+var digits = [...run("A", 26), ...run("a", 26), ...run("0", 10), "+", "/"];
+var digitValues = new Map(digits.map((char, i) => [char, i]));
+var digit = (value) => digits[value] ?? "";
+var snapshotText2 = (bytes) => {
+  const out = [];
+  for (let at = 0;at < bytes.length; at += 3) {
+    const a = bytes[at] ?? 0;
+    const b = bytes[at + 1] ?? 0;
+    const c = bytes[at + 2] ?? 0;
+    const left = bytes.length - at;
+    out.push(digit(a >> 2), digit((a & 3) << 4 | b >> 4), left > 1 ? digit((b & 15) << 2 | c >> 6) : "=", left > 2 ? digit(c & 63) : "=");
+  }
+  return out.join("");
+};
+var snapshotBytes2 = (text) => {
+  const digits = text.replace(/=+$/, "");
+  const bytes = new Uint8Array(Math.floor(digits.length * 3 / 4));
+  let bits = 0;
+  let held = 0;
+  let at = 0;
+  for (const char of digits) {
+    bits = bits << 6 | (digitValues.get(char) ?? 0);
+    held += 6;
+    if (held >= 8) {
+      held -= 8;
+      bytes[at] = bits >> held & 255;
+      at += 1;
+    }
+  }
+  return bytes;
+};
 var toVec32 = (vector) => [vector.x, vector.y, vector.z];
 var size = new Vector36;
 var scaledPositions = (geometry, scale) => {
@@ -3475,7 +3538,7 @@ var createPicker2 = (graph) => {
   };
 };
 var none2 = [];
-var missTolerance = 2;
+var missTolerances = { mouse: 2, pen: 2, touch: 10 };
 var pointerOf = (input) => ("pointer" in input) && input.pointer !== undefined ? input.pointer : 0;
 var createPointerTracker2 = (picker) => {
   let position;
@@ -3512,7 +3575,7 @@ var createPointerTracker2 = (picker) => {
       }
       return;
     }
-    if (from?.button === event.button && travel(from, event.x, event.y) <= missTolerance) {
+    if (from?.button === event.button && travel(from, event.x, event.y) <= missTolerances[from.device]) {
       events.push({ _tag: "PointerMissed", button: event.button });
     }
   };
@@ -3663,7 +3726,13 @@ var createPointerTracker2 = (picker) => {
         moveGesture(id, event, events);
         break;
       case "PointerDown":
-        press = { key: hit?.key, button: event.button, x: event.x, y: event.y };
+        press = {
+          key: hit?.key,
+          button: event.button,
+          x: event.x,
+          y: event.y,
+          device: event.device ?? "mouse"
+        };
         pressing = true;
         dragged = false;
         if (hit !== undefined)
@@ -3852,6 +3921,8 @@ var createSceneLoop2 = (options) => {
         emit({ _tag: "Collision", ...collision });
       for (const force of graph.contactForces())
         emit({ _tag: "ContactForce", ...force });
+      for (const reached of graph.physicsReached())
+        emit({ _tag: "PhysicsReached", ...reached });
       const settings = graph.renderSettings();
       if (settings !== configured) {
         renderer.configure(settings);
@@ -4143,6 +4214,36 @@ var between = (a, b, alpha) => {
     quaternion: [from.x, from.y, from.z, from.w]
   };
 };
+var catchUpAfter = 0.25;
+var mostPerFrame = 1;
+var checksumBytes = new DataView(new ArrayBuffer(8));
+var mixByte = (hash, byte) => Math.imul(hash ^ byte, 16777619) >>> 0;
+var mixNumber = (hash, value) => {
+  checksumBytes.setFloat64(0, value);
+  let mixed = hash;
+  for (let i = 0;i < 8; i++)
+    mixed = mixByte(mixed, checksumBytes.getUint8(i));
+  return mixed;
+};
+var mixText = (hash, text) => {
+  let mixed = hash;
+  for (let i = 0;i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    mixed = mixByte(mixByte(mixed, code & 255), code >>> 8);
+  }
+  return mixed;
+};
+var checksumOf = (poses) => {
+  let hash = 2166136261;
+  for (const [id, { position, quaternion }] of poses.toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+    hash = mixText(hash, id);
+    for (const value of position)
+      hash = mixNumber(hash, value);
+    for (const value of quaternion)
+      hash = mixNumber(hash, value);
+  }
+  return hash.toString(16).padStart(8, "0");
+};
 var remade = (hosted, source, signature) => hosted.source.holder !== source.holder || hosted.source.body.collider !== source.body.collider || !collidersEqual(hosted.source.body.colliders, source.body.colliders) || hosted.signature !== signature;
 var resettled = (a, b) => !bodyEquals2({ ...a, impulse: null }, { ...b, impulse: null });
 var named = (a, b, ids) => {
@@ -4168,6 +4269,13 @@ var createBodyHost = (engine, scene) => {
   const debug = createPhysicsDebug(scene);
   let last;
   let accumulator = 0;
+  let steps = 0;
+  let reported;
+  let snapped;
+  let reached = [];
+  const kept = new Map;
+  let rushing = false;
+  let restored;
   const drawDebug = () => {
     if (world !== undefined && settings?.debug === true)
       debug.show(world.debugLines());
@@ -4183,9 +4291,37 @@ var createBodyHost = (engine, scene) => {
     joined.clear();
     accumulator = 0;
     last = undefined;
+    steps = 0;
+    reported = undefined;
+    snapped = undefined;
+    reached = [];
+  };
+  const make = (active, physics) => {
+    const { from } = physics;
+    const bytes = from === null ? undefined : from.snapshot === null ? kept.get(from.step) : snapshotBytes2(from.snapshot);
+    if (from === null || bytes === undefined || active.restoreWorld === undefined) {
+      kept.clear();
+      return active.createWorld(physics);
+    }
+    for (const step of kept.keys())
+      if (step > from.step || from.snapshot !== null)
+        kept.delete(step);
+    const made = active.restoreWorld(physics, bytes);
+    steps = from.step;
+    rushing = true;
+    restored = { bodies: new Set(made.bodies), joints: new Set(made.joints) };
+    return made.world;
+  };
+  const adopt = (active, source, signature) => {
+    const pose = active.pose(source.id) ?? source.described();
+    source.place(pose);
+    hosted.set(source.id, { source, signature, previous: pose, current: pose, shown: pose });
   };
+  let restarting = false;
   const add = (active, source, signature) => {
-    const pose = source.pose();
+    const pose = restarting ? source.described() : source.pose();
+    if (restarting)
+      source.place(pose);
     active.add(source.id, source.body, source.colliders(), pose);
     if (source.body.impulse !== null)
       active.applyImpulse(source.id, source.body.impulse.impulse);
@@ -4195,6 +4331,10 @@ var createBodyHost = (engine, scene) => {
   const syncBody = (active, source) => {
     const existing = hosted.get(source.id);
     const signature = source.signature();
+    if (existing === undefined && restored?.bodies.has(source.id) === true) {
+      adopt(active, source, signature);
+      return;
+    }
     if (existing === undefined || remade(existing, source, signature)) {
       if (existing !== undefined)
         active.remove(source.id);
@@ -4250,11 +4390,22 @@ var createBodyHost = (engine, scene) => {
   const sync = (physics, sources) => {
     if (physics === null || engine === undefined) {
       dispose();
+      kept.clear();
       return;
     }
+    restarting = settings !== null && settings.run !== physics.run;
+    if (restarting)
+      dispose();
     if (world === undefined)
-      world = engine.createWorld(physics);
-    else if (!physicsEquals2(settings && { ...settings, joints: physics.joints }, physics)) {
+      world = make(engine, physics);
+    else if (!physicsEquals2(settings && {
+      ...settings,
+      joints: physics.joints,
+      until: physics.until,
+      snapshotAt: physics.snapshotAt,
+      from: physics.from,
+      keep: physics.keep
+    }, physics)) {
       world.configure(physics);
     }
     settings = physics;
@@ -4271,7 +4422,22 @@ var createBodyHost = (engine, scene) => {
       world.remove(id);
       hosted.delete(id);
     }
+    if (restored !== undefined) {
+      for (const id of restored.bodies)
+        if (!seen.has(id))
+          world.remove(id);
+      for (const joint of physics.joints) {
+        if (restored.joints.has(joint.key))
+          joined.set(joint.key, joint);
+      }
+      for (const id of restored.joints) {
+        if (!joined.has(id))
+          world.removeJoint(id);
+      }
+      restored = undefined;
+    }
     syncJoints(world, physics.joints);
+    restarting = false;
     drawDebug();
   };
   const kinematicTargets = (active) => {
@@ -4280,11 +4446,8 @@ var createBodyHost = (engine, scene) => {
         active.moveKinematic(id, source.pose());
     }
   };
-  const step = (active, seconds) => {
-    for (const body of hosted.values())
-      body.previous = body.current;
-    kinematicTargets(active);
-    for (const collision of active.step(seconds)) {
+  const heard = (arrived, active) => {
+    for (const collision of arrived) {
       collisions.push({
         ...named(hosted.get(collision.a)?.source, hosted.get(collision.b)?.source, collision),
         started: collision.started
@@ -4297,22 +4460,99 @@ var createBodyHost = (engine, scene) => {
         ...payload
       });
     }
+  };
+  const step = (active, seconds) => {
+    for (const body of hosted.values())
+      body.previous = body.current;
+    kinematicTargets(active);
+    heard(active.step(seconds), active);
     for (const [id, body] of hosted)
       body.current = active.pose(id) ?? body.current;
+    steps += 1;
+  };
+  const collect = (active) => {
+    if (active.received === undefined)
+      return false;
+    const { collisions: arrived, pending } = active.received();
+    heard(arrived, active);
+    for (const [id, body] of hosted)
+      body.current = active.pose(id) ?? body.current;
+    return pending;
+  };
+  const free = (active, timeStep, delta) => {
+    accumulator += delta;
+    while (accumulator >= timeStep) {
+      step(active, timeStep);
+      accumulator -= timeStep;
+    }
+    collect(active);
+    return accumulator / timeStep;
+  };
+  const snapshotOwed = (physics, until) => physics.snapshotAt !== null && snapped !== physics.snapshotAt && steps <= physics.snapshotAt && physics.snapshotAt <= until;
+  const report = (active, physics, snapshot) => {
+    const wanted = snapshot || physics.keep > 0;
+    const bytes = wanted ? active.snapshot?.() : undefined;
+    if (wanted && active.snapshot !== undefined && bytes === undefined)
+      return false;
+    if (physics.keep > 0 && bytes !== undefined) {
+      kept.delete(steps);
+      kept.set(steps, bytes);
+      for (const step of kept.keys())
+        if (kept.size > physics.keep)
+          kept.delete(step);
+    }
+    const { run } = physics;
+    reached.push({
+      run,
+      step: steps,
+      checksum: checksumOf([...hosted.keys()].flatMap((id) => posed(active, id))),
+      ...snapshot && bytes !== undefined ? { snapshot: snapshotText2(bytes) } : {}
+    });
+    return true;
+  };
+  const driven = (active, physics, until, delta) => {
+    const { timeStep } = physics;
+    const snapping = snapshotOwed(physics, until);
+    const stop = snapping && physics.snapshotAt !== null ? physics.snapshotAt : until;
+    accumulator += delta;
+    const owed = Math.max(0, stop - steps);
+    const paced = Math.floor(accumulator / timeStep);
+    const behind = rushing || owed > Math.ceil(catchUpAfter / timeStep);
+    rushing = false;
+    const count = Math.min(owed, behind ? owed : paced, Math.ceil(mostPerFrame / timeStep));
+    for (let i = 0;i < count; i++)
+      step(active, timeStep);
+    accumulator = Math.max(0, accumulator - count * timeStep);
+    const pending = collect(active);
+    if (steps < stop)
+      return Math.min(1, accumulator / timeStep);
+    if (stop < until) {
+      if (!pending && report(active, physics, true))
+        snapped = stop;
+      return Math.min(1, accumulator / timeStep);
+    }
+    accumulator = 0;
+    if (steps === until && (reported !== until || snapping) && !pending && report(active, physics, snapping)) {
+      reported = until;
+      if (snapping)
+        snapped = until;
+    }
+    return 1;
+  };
+  const posed = (active, id) => {
+    const pose = active.pose(id);
+    return pose === undefined ? [] : [[id, pose]];
   };
   const 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)
+    if (world === undefined || settings === null || settings.paused)
+      return;
+    if (settings.until === null && !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;
+    const progress = settings.until === null ? free(world, settings.timeStep, delta) : driven(world, settings, settings.until, delta);
+    const alpha = settings.interpolate ? progress : 1;
     for (const body of hosted.values()) {
       if (body.source.body.type === "dynamic") {
         body.shown = between(body.previous, body.current, alpha);
@@ -4340,6 +4580,14 @@ var createBodyHost = (engine, scene) => {
       contactForces = [];
       return drained;
     },
+    drainReached: () => {
+      if (reached.length === 0)
+        return reached;
+      const drained = reached;
+      reached = [];
+      return drained;
+    },
+    owesSteps: () => world !== undefined && settings !== null && !settings.paused && settings.until !== null && (steps < settings.until || reported !== settings.until || snapshotOwed(settings, settings.until)),
     dispose
   };
 };
@@ -4851,6 +5099,7 @@ var createSceneGraph2 = (options = {}) => {
   const keys = new WeakMap;
   const spinning = new Set;
   const facing = new Set;
+  const facingOrder = [];
   const cameraTurn = new Quaternion6;
   const parentTurn = new Quaternion6;
   const sparkling = new Set;
@@ -4956,6 +5205,18 @@ var createSceneGraph2 = (options = {}) => {
     if (lockZ)
       object.rotation.z = 0;
   };
+  const depthOf = (object) => {
+    let depth = 0;
+    for (let parent = object.parent;parent !== null; parent = parent.parent)
+      depth += 1;
+    return depth;
+  };
+  const faceCameras = () => {
+    facingOrder.length = 0;
+    facing.forEach((entry) => facingOrder.push(entry));
+    facingOrder.sort((a, b) => depthOf(a.object) - depthOf(b.object));
+    facingOrder.forEach(faceCamera);
+  };
   const trailTarget = (object, local) => local ? trailPlace.copy(object.position) : object.getWorldPosition(trailPlace);
   const trackTrail = (entry, node) => {
     const current = trailing.get(entry);
@@ -5744,6 +6005,7 @@ var createSceneGraph2 = (options = {}) => {
     physics: null,
     xr: null,
     measure: [],
+    assets: [],
     render: parent.render,
     resources: parent.resources,
     children: texture.children
@@ -5887,6 +6149,8 @@ var createSceneGraph2 = (options = {}) => {
       invalidate();
     physicsDescription = next.physics;
     bodyHost.sync(next.physics, bodySources());
+    if (bodyHost.owesSteps())
+      invalidate();
     xrDescription = next.xr;
     if (next.measure.join("\x00") !== measured.join("\x00"))
       invalidate();
@@ -5922,7 +6186,7 @@ var createSceneGraph2 = (options = {}) => {
     bodyHost.tick(elapsed, animating);
     if (facing.size > 0) {
       camera.getWorldQuaternion(cameraTurn);
-      facing.forEach(faceCamera);
+      faceCameras();
     }
     edged.forEach(refreshEdges);
     if (animating)
@@ -6002,6 +6266,7 @@ var createSceneGraph2 = (options = {}) => {
     contactShadows: () => contactDescription,
     collisions: bodyHost.drainCollisions,
     contactForces: bodyHost.drainContactForces,
+    physicsReached: bodyHost.drainReached,
     xr: () => xrDescription,
     measured: () => measured,
     labelLayout: (key) => {
@@ -6024,7 +6289,7 @@ var createSceneGraph2 = (options = {}) => {
     tick,
     elapsedSeconds: () => elapsed,
     renderSettings: () => settings,
-    needsFrame: () => dirty || trailsMoving() || textureList.some((texture) => texture.graph.needsFrame()) || (hudHosted?.graph.needsFrame() ?? false) || animating && (spinning.size > 0 || moving.size > 0 || behaving.size > 0 || clipsRunning() || cameraMotion.moving() || viewsMoving() || shaking() || sparkling.size > 0 || bodyHost.needsFrame()),
+    needsFrame: () => dirty || trailsMoving() || textureList.some((texture) => texture.graph.needsFrame()) || (hudHosted?.graph.needsFrame() ?? false) || animating && (spinning.size > 0 || moving.size > 0 || behaving.size > 0 || clipsRunning() || cameraMotion.moving() || viewsMoving() || shaking() || sparkling.size > 0 || bodyHost.needsFrame()) || bodyHost.owesSteps(),
     drawn: () => {
       dirty = false;
     },
@@ -6057,8 +6322,507 @@ var createSceneGraph2 = (options = {}) => {
     dispose
   };
 };
+// src/kernel/preview.ts
+import {
+  Box2,
+  Color as Color5,
+  DirectionalLight as DirectionalLight2,
+  HemisphereLight as HemisphereLight2,
+  InstancedMesh as InstancedMesh2,
+  LinearSRGBColorSpace,
+  LineBasicMaterial as LineBasicMaterial2,
+  LineDashedMaterial,
+  Matrix3,
+  Matrix4 as Matrix45,
+  Mesh as Mesh3,
+  MeshBasicMaterial as MeshBasicMaterial3,
+  MeshLambertMaterial as MeshLambertMaterial2,
+  MeshNormalMaterial as MeshNormalMaterial2,
+  MeshPhongMaterial as MeshPhongMaterial2,
+  MeshStandardMaterial as MeshStandardMaterial2,
+  MeshToonMaterial,
+  Light,
+  Line,
+  PointLight as PointLight2,
+  Points,
+  Scene as Scene2,
+  Sprite,
+  PointsMaterial,
+  SpotLight as SpotLight2,
+  SpriteMaterial,
+  SRGBColorSpace,
+  Vector2 as Vector24,
+  Vector3 as Vector313,
+  AmbientLight as AmbientLight2
+} from "three";
+import {
+  Projector,
+  RenderableFace,
+  RenderableLine,
+  RenderableSprite
+} from "three/addons/renderers/Projector.js";
+
+// src/kernel/paintOrder.ts
+import { Sphere, Vector3 as Vector312 } from "three";
+var onPlane = 0.000001;
+var candidates = 8;
+var splitCost = 8;
+var planeOf = (points) => {
+  const [a, b, c] = points;
+  if (a === undefined || b === undefined || c === undefined)
+    return;
+  const normal = new Vector312().subVectors(b, a).cross(new Vector312().subVectors(c, a));
+  if (normal.lengthSq() === 0)
+    return;
+  normal.normalize();
+  return { normal, constant: normal.dot(a) };
+};
+var side = (plane, point) => plane.normal.dot(point) - plane.constant;
+var toleranceAt = (points) => onPlane * Math.max(1, ...points.map((point) => point.length()));
+var split = (plane, facet) => {
+  const sides = facet.points.map((point) => side(plane, point));
+  const tolerance = toleranceAt(facet.points);
+  if (sides.every((s) => Math.abs(s) <= tolerance))
+    return { on: facet };
+  if (sides.every((s) => s >= -tolerance))
+    return { front: facet };
+  if (sides.every((s) => s <= tolerance))
+    return { back: facet };
+  const front = [];
+  const back = [];
+  facet.points.forEach((point, i) => {
+    const next = facet.points[(i + 1) % facet.points.length] ?? point;
+    const here = sides[i] ?? 0;
+    const there = sides[(i + 1) % sides.length] ?? 0;
+    if (here >= -tolerance)
+      front.push(point);
+    if (here <= tolerance)
+      back.push(point);
+    if (here > tolerance && there < -tolerance || here < -tolerance && there > tolerance) {
+      const crossing = point.clone().lerp(next, here / (here - there));
+      front.push(crossing);
+      back.push(crossing.clone());
+    }
+  });
+  return {
+    ...front.length >= 3 ? { front: { ...facet, points: front } } : {},
+    ...back.length >= 3 ? { back: { ...facet, points: back } } : {}
+  };
+};
+function hidesNone(facet, facets, eye) {
+  const plane = planeOf(facet.points);
+  if (plane === undefined)
+    return true;
+  const tolerance = toleranceAt(facet.points);
+  return side(plane, eye) > tolerance && facets.every((other) => other === facet || other.points.every((point) => side(plane, point) <= tolerance));
+}
+var unitOf = (facets, marks, eye) => {
+  const points = [...facets.flatMap((facet) => facet.points), ...marks.map((mark) => mark.at)];
+  const bounds = new Sphere().setFromPoints(points);
+  const selfOrdered = facets.every((facet) => hidesNone(facet, facets, eye));
+  return { facets, marks, bounds, selfOrdered };
+};
+var sizeOf = (unit) => unit.facets.length + unit.marks.length;
+var sideOf = (plane, unit) => {
+  const distance = side(plane, unit.bounds.center);
+  const reach = unit.bounds.radius * (1 + onPlane) + onPlane;
+  return distance > reach ? 1 : distance < -reach ? -1 : 0;
+};
+var weigh = (plane, units) => {
+  let cut = 0;
+  let front = 0;
+  let back = 0;
+  for (const unit of units) {
+    const whole = sideOf(plane, unit);
+    if (whole > 0)
+      front += sizeOf(unit);
+    else if (whole < 0)
+      back += sizeOf(unit);
+    else {
+      const parts = unit.facets.map((facet) => split(plane, facet));
+      const ahead = parts.filter((part) => part.front !== undefined).length;
+      const behind = parts.filter((part) => part.back !== undefined).length;
+      if (ahead > 0 && behind > 0)
+        cut++;
+      front += ahead;
+      back += behind;
+    }
+  }
+  return splitCost * cut + Math.abs(front - back);
+};
+var partition = (plane, units) => {
+  const front = [];
+  const back = [];
+  const on = [];
+  for (const unit of units) {
+    const whole = sideOf(plane, unit);
+    if (whole > 0)
+      front.push(unit);
+    else if (whole < 0)
+      back.push(unit);
+    else {
+      const ahead = [];
+      const behind = [];
+      for (const facet of unit.facets) {
+        const parts = split(plane, facet);
+        if (parts.front !== undefined)
+          ahead.push(parts.front);
+        if (parts.back !== undefined)
+          behind.push(parts.back);
+        if (parts.on !== undefined)
+          on.push(parts.on);
+      }
+      const marksAhead = unit.marks.filter((mark) => side(plane, mark.at) >= 0);
+      const marksBehind = unit.marks.filter((mark) => side(plane, mark.at) < 0);
+      if (ahead.length + marksAhead.length > 0)
+        front.push({ ...unit, facets: ahead, marks: marksAhead });
+      if (behind.length + marksBehind.length > 0)
+        back.push({ ...unit, facets: behind, marks: marksBehind });
+    }
+  }
+  return { front, back, on };
+};
+var planeFor = (units) => {
+  const withFacets = units.filter((unit) => unit.facets.length > 0);
+  const count = Math.min(candidates, withFacets.length);
+  let best;
+  let lightest = Number.POSITIVE_INFINITY;
+  for (let i = 0;i < count; i++) {
+    const unit = withFacets[Math.floor(i * withFacets.length / count)];
+    const facet = unit?.facets[Math.floor(i * (unit?.facets.length ?? 0) / count)];
+    const plane = facet === undefined ? undefined : planeOf(facet.points);
+    if (plane === undefined)
+      continue;
+    const weight = weigh(plane, units);
+    if (weight < lightest) {
+      lightest = weight;
+      best = plane;
+    }
+  }
+  if (best !== undefined)
+    return best;
+  for (const unit of withFacets) {
+    for (const facet of unit.facets) {
+      const plane = planeOf(facet.points);
+      if (plane !== undefined)
+        return plane;
+    }
+  }
+  return;
+};
+var distanceFrom = (eye) => (mark) => mark.at.distanceToSquared(eye);
+var apart = (unit) => [
+  ...unit.facets.map((facet) => ({
+    facets: [facet],
+    marks: [],
+    bounds: new Sphere().setFromPoints([...facet.points]),
+    selfOrdered: true
+  })),
+  ...unit.marks.map((mark) => ({
+    facets: [],
+    marks: [mark],
+    bounds: new Sphere(mark.at.clone(), 0),
+    selfOrdered: true
+  }))
+];
+var paint = (units, eye, into) => {
+  const [only] = units;
+  if (only !== undefined && units.length === 1) {
+    if (only.selfOrdered && only.marks.length === 0) {
+      into.push(...only.facets);
+      return;
+    }
+    if (only.facets.length === 0) {
+      into.push(...only.marks.toSorted((a, b) => distanceFrom(eye)(b) - distanceFrom(eye)(a)));
+      return;
+    }
+    paint(apart(only), eye, into);
+    return;
+  }
+  const plane = planeFor(units);
+  if (plane === undefined) {
+    const marks = units.flatMap((unit) => unit.marks);
+    into.push(...marks.toSorted((a, b) => distanceFrom(eye)(b) - distanceFrom(eye)(a)));
+    return;
+  }
+  const { front, back, on } = partition(plane, units);
+  const facing = side(plane, eye) >= 0;
+  paint(facing ? back : front, eye, into);
+  into.push(...on);
+  paint(facing ? front : back, eye, into);
+};
+var paintOrder = (units, eye) => {
+  const into = [];
+  paint(units, eye, into);
+  return into;
+};
+
+// src/kernel/preview.ts
+var overdraw = 0.5;
+var black = new Color5(0, 0, 0);
+var irradianceAt = (lights, position, normal, into) => {
+  into.copy(black);
+  const lightPosition = new Vector313;
+  const toLight = new Vector313;
+  const direction = new Vector313;
+  for (const light of lights) {
+    const color = light.color.clone().multiplyScalar(light.intensity);
+    if (light instanceof AmbientLight2) {
+      into.add(color);
+    } else if (light instanceof HemisphereLight2) {
+      lightPosition.setFromMatrixPosition(light.matrixWorld).normalize();
+      const weight = 0.5 * normal.dot(lightPosition) + 0.5;
+      into.add(light.groundColor.clone().lerp(light.color, weight).multiplyScalar(light.intensity));
+    } else if (light instanceof DirectionalLight2) {
+      lightPosition.setFromMatrixPosition(light.matrixWorld);
+      direction.setFromMatrixPosition(light.target.matrixWorld);
+      toLight.subVectors(lightPosition, direction).normalize();
+      into.add(color.multiplyScalar(Math.max(normal.dot(toLight), 0)));
+    } else if (light instanceof PointLight2 || light instanceof SpotLight2) {
+      lightPosition.setFromMatrixPosition(light.matrixWorld);
+      toLight.subVectors(lightPosition, position);
+      const distance = toLight.length();
+      toLight.normalize();
+      const cone = light instanceof SpotLight2 ? spotAttenuation(light, toLight) : 1;
+      const falloff = distanceAttenuation(distance, light.distance, light.decay);
+      into.add(color.multiplyScalar(Math.max(normal.dot(toLight), 0) * cone * falloff));
+    }
+  }
+  return into;
+};
+var distanceAttenuation = (distance, cutoff, decay) => {
+  const falloff = 1 / Math.max(distance ** decay, 0.01);
+  return cutoff > 0 ? falloff * Math.min(Math.max(1 - (distance / cutoff) ** 4, 0), 1) ** 2 : falloff;
+};
+var smoothstep = (low, high, x) => {
+  const t = Math.min(Math.max((x - low) / (high - low), 0), 1);
+  return t * t * (3 - 2 * t);
+};
+var spotAttenuation = (light, toLight) => {
+  const direction = new Vector313().setFromMatrixPosition(light.matrixWorld).sub(new Vector313().setFromMatrixPosition(light.target.matrixWorld)).normalize();
+  return smoothstep(Math.cos(light.angle), Math.cos(light.angle * (1 - light.penumbra)), direction.dot(toLight));
+};
+var faceColor = (painter, face, material, centre) => {
+  if (material instanceof MeshBasicMaterial3) {
+    const color = material.color.clone();
+    return material.vertexColors ? color.multiply(face.color) : color;
+  }
+  if (material instanceof MeshNormalMaterial2) {
+    const normal = face.normalModel.clone().applyMatrix3(painter.normalView).normalize();
+    return new Color5(normal.x, normal.y, normal.z).multiplyScalar(0.5).addScalar(0.5);
+  }
+  if (material instanceof MeshLambertMaterial2 || material instanceof MeshPhongMaterial2 || material instanceof MeshStandardMaterial2 || material instanceof MeshToonMaterial) {
+    const diffuse = material.color.clone();
+    if (material.vertexColors)
+      diffuse.multiply(face.color);
+    return irradianceAt(painter.lights, centre, face.normalModel, new Color5).multiply(diffuse).multiplyScalar(1 / Math.PI).add(material.emissive.clone().multiplyScalar(material.emissiveIntensity));
+  }
+  return;
+};
+var styleOf = (color, colorSpace) => {
+  const shown = new Color5(Math.min(Math.max(color.r, 0), 1), Math.min(Math.max(color.g, 0), 1), Math.min(Math.max(color.b, 0), 1));
+  return `#${shown.getHexString(colorSpace)}`;
+};
+var opacityOf = (material) => material.transparent ? material.opacity : 1;
+var standInsFor = (object) => {
+  if (!(object instanceof InstancedMesh2)) {
+    const standIn = object.clone(false);
+    standIn.matrix.copy(object.matrixWorld);
+    return [{ standIn }];
+  }
+  const material = Array.isArray(object.material) ? object.material[0] : object.material;
+  if (material === undefined)
+    return [];
+  const matrix = new Matrix45;
+  const standIns = [];
+  for (let i = 0;i < object.count; i++) {
+    object.getMatrixAt(i, matrix);
+    const tinted = object.instanceColor === null ? undefined : material.clone();
+    if (tinted !== undefined && "color" in tinted && tinted.color instanceof Color5) {
+      tinted.color.multiply(object.getColorAt(i, new Color5));
+    }
+    const standIn = new Mesh3(object.geometry, tinted ?? material);
+    standIn.matrix.multiplyMatrices(object.matrixWorld, matrix);
+    standIn.renderOrder = object.renderOrder;
+    standIns.push(tinted === undefined ? { standIn } : { standIn, tinted });
+  }
+  return standIns;
+};
+var number = (precision) => (value) => String(Number(value.toFixed(precision)));
+var widened = (points) => {
+  const out = points.map((point) => point.clone());
+  for (const [i, from] of out.entries()) {
+    const to = out[(i + 1) % out.length];
+    const length = to === undefined ? 0 : from.distanceTo(to);
+    if (to === undefined || length === 0)
+      continue;
+    const step = new Vector24().subVectors(to, from).multiplyScalar(overdraw / length);
+    to.add(step);
+    from.sub(step);
+  }
+  return out;
+};
+var facetPaint = (fill, opacity) => opacity < 1 ? `fill="${fill}" fill-opacity="${String(Number(opacity.toFixed(2)))}"` : `fill="${fill}" stroke="${fill}"`;
+var centreOf2 = (object) => {
+  if (!(object instanceof Mesh3))
+    return new Vector313().setFromMatrixPosition(object.matrixWorld);
+  const geometry = object.geometry;
+  if (geometry.boundingSphere === null)
+    geometry.computeBoundingSphere();
+  return (geometry.boundingSphere?.center.clone() ?? new Vector313).applyMatrix4(object.matrixWorld);
+};
+var isDrawn = (object) => object instanceof Mesh3 || object instanceof Line || object instanceof Points || object instanceof Sprite;
+var previewSvg2 = (description, options) => {
+  const { width, height } = options;
+  const graph = createSceneGraph2({
+    ...options.store === undefined ? {} : { store: options.store },
+    ...options.behaviours === undefined ? {} : { behaviours: options.behaviours }
+  });
+  const applied = graph.reconcile(description);
+  if (applied._tag === "Invalid") {
+    graph.dispose();
+    return applied;
+  }
+  graph.resize(width, height);
+  graph.tick(options.at ?? 0);
+  const { scene, camera } = graph;
+  scene.updateMatrixWorld();
+  camera.updateMatrixWorld();
+  const lights = [];
+  const drawn = [];
+  scene.traverseVisible((object) => {
+    if (object instanceof Light)
+      lights.push(object);
+    else if (isDrawn(object))
+      drawn.push(object);
+  });
+  const colorSpace = graph.renderSettings().colorSpace === "linear" ? LinearSRGBColorSpace : SRGBColorSpace;
+  const painter = {
+    lights,
+    normalView: new Matrix3().getNormalMatrix(camera.matrixWorldInverse),
+    colorSpace
+  };
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  const at = number(options.precision ?? 1);
+  const eye = new Vector313().setFromMatrixPosition(camera.matrixWorld);
+  const ahead = camera.getWorldDirection(new Vector313);
+  const near = { normal: ahead, constant: ahead.dot(eye) + camera.near };
+  const xy = (x, y) => `${at(x * halfWidth)},${at(-y * halfHeight)}`;
+  function facetOf(face, material, centre, opacity) {
+    const color = faceColor(painter, face, material, centre);
+    if (color === undefined)
+      return;
+    const points = [face.v1, face.v2, face.v3].map((vertex) => vertex.positionWorld.clone());
+    const paint = facetPaint(styleOf(color, colorSpace), opacity);
+    return split(near, { _tag: "Facet", points, item: { paint, d: "" } }).front;
+  }
+  const projector = new Projector;
+  const holder = new Scene2;
+  const units = [];
+  const over = [];
+  const tinted = [];
+  for (const object of drawn) {
+    for (const { standIn, tinted: copy } of standInsFor(object)) {
+      if (copy !== undefined)
+        tinted.push(copy);
+      standIn.matrixAutoUpdate = false;
+      holder.add(standIn);
+      const projected = projector.projectScene(holder, camera, false, true);
+      holder.remove(standIn);
+      const centre = centreOf2(standIn);
+      const facets = [];
+      const marks = [];
+      const keep = (material, item) => {
+        if (!material.depthTest)
+          over.push({ renderOrder: standIn.renderOrder, item });
+        else if (item._tag === "Facet")
+          facets.push(item);
+        else
+          marks.push(item);
+      };
+      for (const element of projected.elements) {
+        const material = element.material;
+        if (material === null || material.opacity === 0)
+          continue;
+        const opacity = opacityOf(material);
+        const faded = opacity < 1 ? ` fill-opacity="${at(opacity)}"` : "";
+        if (element instanceof RenderableFace) {
+          const seen = facetOf(element, material, centre, opacity);
+          if (seen === undefined)
+            continue;
+          keep(material, seen);
+        } else if (element instanceof RenderableLine && material instanceof LineBasicMaterial2) {
+          const a = element.v1.positionScreen;
+          const b = element.v2.positionScreen;
+          const dashes = material instanceof LineDashedMaterial ? ` stroke-dasharray="${at(material.dashSize)},${at(material.gapSize)}"` : "";
+          const stroked = opacity < 1 ? ` stroke-opacity="${at(opacity)}"` : "";
+          keep(material, {
+            _tag: "Mark",
+            at: element.v1.positionWorld.clone().lerp(element.v2.positionWorld, 0.5),
+            item: {
+              paint: `fill="none" stroke="${styleOf(material.color, colorSpace)}"${stroked} stroke-width="${at(material.linewidth)}" stroke-linecap="${material.linecap}"${dashes}`,
+              d: `M${xy(a.x, a.y)}L${xy(b.x, b.y)}`
+            }
+          });
+        } else if (element instanceof RenderableSprite && (material instanceof SpriteMaterial || material instanceof PointsMaterial)) {
+          const size = material instanceof PointsMaterial ? material.size : 1;
+          const w = element.scale.x * halfWidth * size;
+          const h = element.scale.y * halfHeight * size;
+          const x = element.x * halfWidth;
+          const y = -element.y * halfHeight;
+          keep(material, {
+            _tag: "Mark",
+            at: new Vector313(element.x, element.y, element.z).unproject(camera),
+            item: {
+              paint: `fill="${styleOf(material.color, colorSpace)}"${faded}`,
+              d: `M${at(x - w / 2)},${at(y - h / 2)}h${at(w)}v${at(h)}h${at(-w)}z`
+            }
+          });
+        }
+      }
+      if (facets.length + marks.length > 0)
+        units.push(unitOf(facets, marks, eye));
+    }
+  }
+  for (const material of tinted)
+    material.dispose();
+  graph.dispose();
+  const ordered = [
+    ...paintOrder(units, eye),
+    ...over.toSorted((a, b) => a.renderOrder - b.renderOrder).map(({ item }) => item)
+  ];
+  const clip = new Box2(new Vector24(-halfWidth, -halfHeight), new Vector24(halfWidth, halfHeight));
+  const toPicture = (point) => {
+    const projectedPoint = point.clone().project(camera);
+    return new Vector24(projectedPoint.x * halfWidth, -projectedPoint.y * halfHeight);
+  };
+  function outlineOf(shape) {
+    if (shape._tag === "Mark")
+      return shape.item.d;
+    const corners = widened(shape.points.map(toPicture));
+    return new Box2().setFromPoints([...corners]).intersectsBox(clip) ? `M${corners.map((corner) => `${at(corner.x)},${at(corner.y)}`).join("L")}z` : undefined;
+  }
+  const groups = [];
+  for (const shape of ordered) {
+    const outline = outlineOf(shape);
+    const last = groups.at(-1);
+    if (outline === undefined)
+      continue;
+    if (last?.paint === shape.item.paint)
+      last.outlines.push(outline);
+    else
+      groups.push({ paint: shape.item.paint, outlines: [outline] });
+  }
+  const paths = groups.map(({ paint, outlines }) => `<path ${paint} d="${outlines.join("")}"/>`);
+  const background = options.background === undefined || options.background === null ? "" : `<rect x="${at(-halfWidth)}" y="${at(-halfHeight)}" width="${at(width)}" height="${at(height)}" fill="${styleOf(new Color5(options.background), colorSpace)}"/>`;
+  return {
+    _tag: "Preview",
+    svg: `<svg xmlns="http://www.w3.org/2000/svg" width="${at(width)}" height="${at(height)}" viewBox="${at(-halfWidth)} ${at(-halfHeight)} ${at(width)} ${at(height)}">${background}<g stroke-width="0.6" stroke-linejoin="round">${paths.join("")}</g></svg>`
+  };
+};
 // src/kernel/gizmo.ts
-import { Euler as Euler6, Quaternion as Quaternion7, Vector3 as Vector312 } from "three";
+import { Euler as Euler6, Quaternion as Quaternion7, Vector3 as Vector314 } from "three";
 var gizmo2 = (options = {}) => ({
   mode: options.mode ?? "translate",
   space: options.space ?? "world",
@@ -6073,9 +6837,9 @@ var gizmo2 = (options = {}) => ({
   grab: null
 });
 var axes = {
-  x: new Vector312(1, 0, 0),
-  y: new Vector312(0, 1, 0),
-  z: new Vector312(0, 0, 1)
+  x: new Vector314(1, 0, 0),
+  y: new Vector314(0, 1, 0),
+  z: new Vector314(0, 0, 1)
 };
 var turnOf = (rotation) => new Quaternion7().setFromEuler(new Euler6(rotation[0], rotation[1], rotation[2]));
 var spaceOf = (state, handle) => {
@@ -6104,30 +6868,30 @@ var dragPlane = (state, handle, start, eye, facingCamera) => {
   if (normal.lengthSq() < 0.000000000001)
     normal.copy(eye);
   normal.normalize();
-  const center = new Vector312(...start.position);
+  const center = new Vector314(...start.position);
   return { normal: toVec34(normal), constant: -normal.dot(center) };
 };
-var onPlane = (grab, ray) => {
+var onPlane2 = (grab, ray) => {
   const point = pointOnPlane2(ray, grab.plane);
   if (point === undefined)
     return;
-  return new Vector312(...point).sub(new Vector312(...grab.start.position));
+  return new Vector314(...point).sub(new Vector314(...grab.start.position));
 };
 var backwards = (camera) => {
-  const back = new Vector312(...camera.position).sub(new Vector312(...camera.lookAt));
-  return back.lengthSq() > 0.000000000001 ? back.normalize() : new Vector312(0, 0, 1);
+  const back = new Vector314(...camera.position).sub(new Vector314(...camera.lookAt));
+  return back.lengthSq() > 0.000000000001 ? back.normalize() : new Vector314(0, 0, 1);
 };
 var pressGizmo2 = (state, placement, handle, ray, camera) => {
-  const center = new Vector312(...placement.position);
+  const center = new Vector314(...placement.position);
   const facingCamera = backwards(camera);
-  const towardsEye = new Vector312(...camera.position).sub(center);
+  const towardsEye = new Vector314(...camera.position).sub(center);
   const distance = towardsEye.length();
   const eye = camera._tag === "Orthographic" || distance < 0.000000001 ? facingCamera.clone() : towardsEye.normalize();
   const plane = dragPlane(state, handle, placement, eye, facingCamera);
   const point = pointOnPlane2(ray, plane);
   if (point === undefined)
     return state;
-  const from = toVec34(new Vector312(...point).sub(center));
+  const from = toVec34(new Vector314(...point).sub(center));
   return { ...state, grab: { handle, start: placement, from, plane, eye: toVec34(eye), distance } };
 };
 var releaseGizmo2 = (state) => ({ ...state, grab: null });
@@ -6136,7 +6900,7 @@ var snapped = (value, step) => step === null ? value : Math.round(value / step)
 var includes = (handle, axis) => handle.includes(axis);
 var translated = (state, grab, end) => {
   const space = spaceOf(state, grab.handle);
-  const offset = end.clone().sub(new Vector312(...grab.from));
+  const offset = end.clone().sub(new Vector314(...grab.from));
   const turn = turnOf(grab.start.rotation);
   if (space === "local")
     offset.applyQuaternion(turn.clone().invert());
@@ -6147,7 +6911,7 @@ var translated = (state, grab, end) => {
   if (!includes(grab.handle, "z"))
     offset.z = 0;
   if (space === "local") {
-    const local = offset.add(new Vector312(...grab.start.position).applyQuaternion(turn.clone().invert()));
+    const local = offset.add(new Vector314(...grab.start.position).applyQuaternion(turn.clone().invert()));
     if (includes(grab.handle, "x"))
       local.x = snapped(local.x, state.translationSnap);
     if (includes(grab.handle, "y"))
@@ -6156,7 +6920,7 @@ var translated = (state, grab, end) => {
       local.z = snapped(local.z, state.translationSnap);
     return { ...grab.start, position: toVec34(local.applyQuaternion(turn)) };
   }
-  const position = offset.add(new Vector312(...grab.start.position));
+  const position = offset.add(new Vector314(...grab.start.position));
   if (includes(grab.handle, "x"))
     position.x = snapped(position.x, state.translationSnap);
   if (includes(grab.handle, "y"))
@@ -6166,8 +6930,8 @@ var translated = (state, grab, end) => {
   return { ...grab.start, position: toVec34(position) };
 };
 var scaled2 = (state, grab, end) => {
-  const from = new Vector312(...grab.from);
-  const factor = new Vector312(1, 1, 1);
+  const from = new Vector314(...grab.from);
+  const factor = new Vector314(1, 1, 1);
   if (grab.handle === "xyz") {
     const ratio = end.length() / Math.max(from.length(), 0.000000001) * (end.dot(from) < 0 ? -1 : 1);
     factor.setScalar(ratio);
@@ -6190,10 +6954,10 @@ var rotated = (state, grab, end) => {
   if (grab.handle !== "x" && grab.handle !== "y" && grab.handle !== "z")
     return grab.start;
   const space = spaceOf(state, grab.handle);
-  const offset = end.clone().sub(new Vector312(...grab.from));
+  const offset = end.clone().sub(new Vector314(...grab.from));
   const speed = 20 / Math.max(grab.distance, 0.000000001);
   const axis = axisIn(grab.handle, space, grab.start.rotation);
-  const across = axis.clone().cross(new Vector312(...grab.eye));
+  const across = axis.clone().cross(new Vector314(...grab.eye));
   const angle = snapped(across.lengthSq() < 0.000000000001 ? 0 : offset.dot(across.normalize()) * speed, state.rotationSnap);
   const start = turnOf(grab.start.rotation);
   const turn = space === "local" ? start.clone().multiply(new Quaternion7().setFromAxisAngle(axes[grab.handle], angle)) : new Quaternion7().setFromAxisAngle(axes[grab.handle], angle).multiply(start);
@@ -6204,7 +6968,7 @@ var dragGizmo2 = (state, ray) => {
   const grab = state.grab;
   if (grab === null)
     return;
-  const end = onPlane(grab, ray);
+  const end = onPlane2(grab, ray);
   if (end === undefined)
     return grab.start;
   if (state.mode === "translate")
@@ -6237,7 +7001,7 @@ var hideThreshold = 0.99;
 var screenScale = (state, at, camera) => {
   if (camera._tag === "Orthographic")
     return 480 / camera.zoom * state.size / 4;
-  const distance = new Vector312(...camera.position).distanceTo(new Vector312(...at));
+  const distance = new Vector314(...camera.position).distanceTo(new Vector314(...at));
   const spread = Math.min(1.9 * Math.tan(Math.PI * camera.fov / 360), 7);
   return distance * spread * state.size / 4;
 };
@@ -6326,7 +7090,7 @@ var planeHandles = (key, state) => {
 var gizmoNodes2 = (key, state, placement, camera) => {
   const space = spaceOf(state, state.grab?.handle ?? null);
   const scale = screenScale(state, placement.position, camera);
-  const eye = new Vector312(...camera.position).sub(new Vector312(...placement.position)).normalize();
+  const eye = new Vector314(...camera.position).sub(new Vector314(...placement.position)).normalize();
   const shown = { x: state.showX, y: state.showY, z: state.showZ };
   const visible = (axis) => shown[axis] && (state.mode === "rotate" || state.grab?.handle === axis || Math.abs(axisIn(axis, space, placement.rotation).dot(eye)) <= hideThreshold);
   return group2({
@@ -6349,7 +7113,7 @@ var gizmoNodes2 = (key, state, placement, camera) => {
   });
 };
 // src/kernel/boxSelect.ts
-import { OrthographicCamera as OrthographicCamera5, PerspectiveCamera as PerspectiveCamera4, Vector3 as Vector313 } from "three";
+import { OrthographicCamera as OrthographicCamera5, PerspectiveCamera as PerspectiveCamera4, Vector3 as Vector315 } from "three";
 var hostCamera2 = (camera, size) => {
   const host = camera._tag === "Perspective" ? new PerspectiveCamera4(camera.fov, size.width / size.height, camera.near, camera.far) : new OrthographicCamera5(size.width / -2, size.width / 2, size.height / 2, size.height / -2, camera.near, camera.far);
   if (host instanceof OrthographicCamera5 && camera._tag === "Orthographic") {
@@ -6365,7 +7129,7 @@ var between2 = (value, a, b) => value >= Math.min(a, b) && value <= Math.max(a,
 var boxSelect2 = (camera, size, from, to, candidates) => {
   const host = hostCamera2(camera, size);
   const inside = (candidate) => {
-    const seen = new Vector313(...candidate.at).project(host);
+    const seen = new Vector315(...candidate.at).project(host);
     return between2(seen.x, from.x, to.x) && between2(seen.y, from.y, to.y) && between2(seen.z, -1, 1);
   };
   return candidates.filter(inside).map((candidate) => candidate.key);
@@ -6505,6 +7269,43 @@ var remove = (state, peer, until) => ({
   members: state.members.map((member) => member.peer === peer && (member.until === null || until < member.until) ? { ...member, until } : member),
   received: state.received.filter((packet) => packet.peer !== peer || packet.turn < until)
 });
+// src/kernel/timeline.ts
+var make3 = (frontier = 0) => ({
+  inputs: [],
+  applied: 0,
+  reached: null,
+  frontier
+});
+var schedule = (timeline, step, input) => {
+  const at = timeline.inputs.findIndex((scheduled) => scheduled.step > step);
+  const index = at < 0 ? timeline.inputs.length : at;
+  return {
+    ...timeline,
+    inputs: [...timeline.inputs.slice(0, index), { step, input }, ...timeline.inputs.slice(index)]
+  };
+};
+var extend = (timeline, frontier) => frontier <= timeline.frontier ? timeline : { ...timeline, frontier };
+var reach = (timeline, step) => timeline.reached === step ? timeline : { ...timeline, reached: step };
+var due = (timeline) => {
+  const { reached } = timeline;
+  if (reached === null)
+    return { timeline, inputs: [] };
+  let applied = timeline.applied;
+  while ((timeline.inputs[applied]?.step ?? Infinity) <= reached)
+    applied += 1;
+  if (applied === timeline.applied)
+    return { timeline, inputs: [] };
+  return {
+    timeline: { ...timeline, applied },
+    inputs: timeline.inputs.slice(timeline.applied, applied).map((scheduled) => scheduled.input)
+  };
+};
+var until = (timeline) => Math.min(timeline.inputs[timeline.applied]?.step ?? Infinity, timeline.frontier);
+var restart = (timeline) => ({
+  ...timeline,
+  applied: 0,
+  reached: null
+});
 // src/kernel/describeScene.ts
 var extentOf = (geometry) => {
   switch (geometry._tag) {
@@ -6547,7 +7348,7 @@ var shapeOf = (geometry, description) => {
     return geometry;
   return description.resources.geometries.find((entry) => entry.id === geometry.id)?.geometry;
 };
-var sizeOf = (node, description) => {
+var sizeOf2 = (node, description) => {
   if (node._tag !== "Mesh")
     return null;
   const shape = shapeOf(node.geometry, description);
@@ -6576,7 +7377,7 @@ var thingsIn = (nodes, parent, description) => nodes.flatMap((node) => [
       key: node.key,
       kind: kindOf(node),
       position: "position" in node ? node.position : [0, 0, 0],
-      size: sizeOf(node, description),
+      size: sizeOf2(node, description),
       colour: colourOf(node),
       parent
     }
@@ -6618,17 +7419,17 @@ var describeScene2 = (description) => {
     staging: stagingOf(description)
   };
 };
-var number = (value) => String(Math.round(value * 100) / 100);
-var point2 = (at) => `(${at.map(number).join(", ")})`;
+var number2 = (value) => String(Math.round(value * 100) / 100);
+var point2 = (at) => `(${at.map(number2).join(", ")})`;
 var hex = (colour) => `#${colour.toString(16).padStart(6, "0")}`;
 var thingLine = (thing) => [
   `- ${thing.key}: ${thing.kind}`,
-  thing.size === null ? "" : `, ${thing.size.map(number).join(" × ")}`,
+  thing.size === null ? "" : `, ${thing.size.map(number2).join(" × ")}`,
   thing.colour === null ? "" : `, ${hex(thing.colour)}`,
   `, at ${point2(thing.position)}`,
   thing.parent === null ? "" : ` in ${thing.parent}`
 ].join("");
-var lightLine = (light) => `- ${light.key}: ${light.kind}, ${hex(light.colour)} × ${number(light.intensity)}${light.position === null ? "" : ` at ${point2(light.position)}`}`;
+var lightLine = (light) => `- ${light.key}: ${light.kind}, ${hex(light.colour)} × ${number2(light.intensity)}${light.position === null ? "" : ` at ${point2(light.position)}`}`;
 var formatSummary2 = (summary) => [
   `Camera: ${summary.camera.kind.toLowerCase()} at ${point2(summary.camera.position)}, looking at ${point2(summary.camera.lookAt)}`,
   `Things (${summary.things.length})${summary.bounds === null ? "" : `, within ${point2(summary.bounds.min)} to ${point2(summary.bounds.max)}`}:`,
@@ -6639,7 +7440,7 @@ var formatSummary2 = (summary) => [
 ].join(`
 `);
 // src/kernel/shots.ts
-import { Vector3 as Vector314 } from "three";
+import { Vector3 as Vector316 } from "three";
 var shotAngles2 = [
   "front",
   "back",
@@ -6659,8 +7460,8 @@ var directionOf = {
   low: [0.35, -0.02, 1]
 };
 var shotCamera2 = (camera, subject, angle, area = { width: 16, height: 10 }, margin = 1.3) => {
-  const centre = new Vector314(...subject.min).add(new Vector314(...subject.max)).multiplyScalar(0.5);
-  const from = new Vector314(...directionOf[angle]).normalize().add(centre);
+  const centre = new Vector316(...subject.min).add(new Vector316(...subject.max)).multiplyScalar(0.5);
+  const from = new Vector316(...directionOf[angle]).normalize().add(centre);
   const aimed = {
     ...camera,
     position: [from.x, from.y, from.z],
@@ -7071,7 +7872,7 @@ var tapeNodes2 = (key, state, look = {}) => {
   return group2({ key, children: [...span, ...ends] });
 };
 // src/kernel/pivot.ts
-import { Euler as Euler7, Quaternion as Quaternion8, Vector3 as Vector315 } from "three";
+import { Euler as Euler7, Quaternion as Quaternion8, Vector3 as Vector317 } from "three";
 var pivot2 = (options = {}) => ({
   scale: options.scale ?? 1,
   depthTest: options.depthTest ?? true,
@@ -7083,11 +7884,11 @@ var pivot2 = (options = {}) => ({
   grab: null
 });
 var unit = {
-  x: new Vector315(1, 0, 0),
-  y: new Vector315(0, 1, 0),
-  z: new Vector315(0, 0, 1)
+  x: new Vector317(1, 0, 0),
+  y: new Vector317(0, 1, 0),
+  z: new Vector317(0, 0, 1)
 };
-var planeOf = {
+var planeOf2 = {
   z: ["x", "y"],
   y: ["z", "x"],
   x: ["y", "z"]
@@ -7099,7 +7900,7 @@ var axisOf = (handle) => handle.split("-")[1];
 var frameOf = (handle, placement) => {
   const turn = turnOf2(placement.rotation);
   const axis = axisOf(handle);
-  const [first, second] = planeOf[axis];
+  const [first, second] = planeOf2[axis];
   const kind = kindOf2(handle);
   const flat = kind === "slider" || kind === "rotator";
   const e1 = (flat ? unit[first] : unit[axis]).clone().applyQuaternion(turn);
@@ -7123,8 +7924,8 @@ var pressPivot2 = (state, placement, handle, point) => {
 var releasePivot2 = (state) => ({ ...state, grab: null });
 var hoverPivot2 = (state, handle) => state.hovered === handle ? state : { ...state, hovered: handle };
 var offsetAlong = (point, direction, ray) => {
-  const origin = new Vector315(...ray.origin);
-  const toward = new Vector315(...ray.direction);
+  const origin = new Vector317(...ray.origin);
+  const toward = new Vector317(...ray.direction);
   const e1 = direction.dot(direction);
   const e2 = direction.dot(point) - direction.dot(origin);
   const e3 = direction.dot(toward);
@@ -7135,8 +7936,8 @@ var offsetAlong = (point, direction, ray) => {
   return -v1.dot(v2) / v1.dot(v1);
 };
 var meetPlane = (ray, at, normal) => {
-  const origin = new Vector315(...ray.origin);
-  const toward = new Vector315(...ray.direction);
+  const origin = new Vector317(...ray.origin);
+  const toward = new Vector317(...ray.direction);
   const facing = normal.dot(toward);
   if (facing === 0)
     return;
@@ -7148,15 +7949,15 @@ var angleBetween = (from, to, at, e1, e2) => {
   return Math.atan2(b.dot(e2), b.dot(e1)) - Math.atan2(a.dot(e2), a.dot(e1));
 };
 var vectorsOf = (grab) => ({
-  point: new Vector315(...grab.point),
-  e1: new Vector315(...grab.e1),
-  e2: new Vector315(...grab.e2),
-  normal: new Vector315(...grab.normal),
-  at: new Vector315(...grab.start.position)
+  point: new Vector317(...grab.point),
+  e1: new Vector317(...grab.e1),
+  e2: new Vector317(...grab.e2),
+  normal: new Vector317(...grab.normal),
+  at: new Vector317(...grab.start.position)
 });
 var moved2 = (start, by) => ({
   ...start,
-  position: toVec35(new Vector315(...start.position).add(by))
+  position: toVec35(new Vector317(...start.position).add(by))
 });
 var arrowDrag = (grab, ray) => {
   const { point, e1 } = vectorsOf(grab);
@@ -7335,7 +8136,7 @@ var pivotNodes2 = (key, state, placement) => group2({
   ]
 });
 // src/kernel/viewportGizmo.ts
-import { Euler as Euler8, Matrix4 as Matrix45, Quaternion as Quaternion9, Vector3 as Vector316 } from "three";
+import { Euler as Euler8, Matrix4 as Matrix46, Quaternion as Quaternion9, Vector3 as Vector318 } from "three";
 var colours3 = { x: 16719968, y: 2154368, z: 2130175 };
 var ink = 0;
 var directions = {
@@ -7347,7 +8148,7 @@ var directions = {
   "-z": [0, 0, -1]
 };
 var axes2 = ["x", "y", "z", "-x", "-y", "-z"];
-var cameraTurn = (camera) => new Quaternion9().setFromRotationMatrix(new Matrix45().lookAt(new Vector316(...camera.position), new Vector316(...camera.lookAt), new Vector316(0, 1, 0)));
+var cameraTurn = (camera) => new Quaternion9().setFromRotationMatrix(new Matrix46().lookAt(new Vector318(...camera.position), new Vector318(...camera.lookAt), new Vector318(0, 1, 0)));
 var gizmoTurn = (camera) => {
   const turn = new Euler8().setFromQuaternion(cameraTurn(camera).invert());
   return [turn.x, turn.y, turn.z];
@@ -7437,15 +8238,15 @@ var viewportAxisOf2 = (key, hit) => {
   return axes2.find((candidate) => candidate === axis);
 };
 var cameraAlong2 = (camera, axis) => {
-  const target = new Vector316(...camera.lookAt);
-  const distance = new Vector316(...camera.position).distanceTo(target);
-  const direction = new Vector316(...directions[axis]);
+  const target = new Vector318(...camera.lookAt);
+  const distance = new Vector318(...camera.position).distanceTo(target);
+  const direction = new Vector318(...directions[axis]);
   if (axis === "y" || axis === "-y")
     direction.z = 0.000001;
   const position = direction.normalize().multiplyScalar(distance).add(target);
   return { ...camera, position: [position.x, position.y, position.z] };
 };
-export { __export, handJoints2, clipTime2, clipRunning2, createPose2, resetPose2, float2, builtinBehaviours2, spinAngle2, writeRotation2, buildMaterial2, updateMaterial2, vec3Equals2, rotationEquals2, shapeEquals2, geometryRefEquals2, instanceEquals2, instancesEqual2, behaviourEquals2, animationEquals2, transitionEquals2, materialRefEquals2, cameraEquals2, renderSettingsEquals2, effectsEqual2, viewsEqual2, resourcesEqual2, overlaysEqual2, environmentEquals2, skyEquals2, contactShadowsEquals2, bodyEquals2, physicsEquals2, xrEquals2, capacityFor2, createPerformanceMonitor2, easeProgress2, startTween2, applyTween2, fixed2, spin2, billboard2, box2, sphere2, plane2, cylinder2, torus2, cone2, capsule2, roundedBox2, backdrop2, ring2, circle2, text2, instant2, ease2, basic2, lambert2, phong2, standard2, physical2, normalMaterial2, shadowMaterial2, grid2, shaderGrid2, sharedGeometry2, lentGeometry2, sharedMaterial2, group2, detailed2, line2, points2, sparkles2, stars2, catmullRomPoints2, catmullRomPointAt2, catmullRomColors2, cubicBezierPoints2, quadraticBezierPoints2, headSpace2, jointSpace2, controllerSpace2, anchorSpace2, planeSpace2, meshSpace2, xrMeshGeometryId2, xrMesh2, xrAnchor2, mesh2, trail2, edges2, body2, interactionGroups2, cuboidCollider2, ballCollider2, capsuleCollider2, cylinderCollider2, coneCollider2, velocityMotor2, positionMotor2, physics2, bodyRef2, joint2, fixedJoint2, sphericalJoint2, revoluteJoint2, prismaticJoint2, ropeJoint2, springJoint2, glide2, xr2, instance2, instances2, behave2, play2, borrowed2, label2, colorRange2, ambientLight2, directionalLight2, pointLight2, spotLight2, hemisphereLight2, perspectiveCamera2, orthographicCamera2, cameraShake2, bloom2, vignette2, film2, renderSettings2, view2, renderTexture2, environment2, sunPositionFromAngles2, sky2, contactShadows2, overlay2, hud2, scene2, emptyIndex2, indexScene2, changedFields2, diff2, createResourceStore2, createSceneClock2, createManualFrames2, createGatedFrames2, createFramePacer2, defaultOrbit2, orbitOptions2, rotateCamera2, dollyCamera2, panCamera2, dollyCameraToward2, orbit2, orbitKey2, autoRotated2, fitCamera2, clipCamera2, placeOverlays2, interactionBits2, colliderFor2, describedColliders2, collidersFor2, colliderSignature2, locomote2, teleport2, glided2, createXrTracker2, environmentPresets2, environmentPresetUrl2, stagePresets2, stage2, centerOffset2, stageBounds2, noModifiers2, pointOnPlane2, createPicker2, createPointerTracker2, createSceneLoop2, recordingRendererFactory2, createSceneGraph2, gizmo2, pressGizmo2, releaseGizmo2, hoverGizmo2, dragGizmo2, movedAlike2, gizmoHandleOf2, gizmoNodes2, boxSelect2, exports_history, exports_lockstep, thingsBounds2, describeScene2, formatSummary2, shotAngles2, shotCamera2, moods2, moodStaging2, inspectFields2, setAt2, sceneChanges2, formatChanges2, tape2, placeTapeEnd2, pointTape2, clearTape2, tapeLength2, tapeMiddle2, tapeNodes2, pivot2, pressPivot2, releasePivot2, hoverPivot2, dragPivot2, pivotHandleOf2, pivotNodes2, viewportGizmoNodes2, viewportAxisOf2, cameraAlong2 };
+export { __export, handJoints2, clipTime2, clipRunning2, createPose2, resetPose2, float2, builtinBehaviours2, spinAngle2, writeRotation2, buildMaterial2, updateMaterial2, vec3Equals2, rotationEquals2, shapeEquals2, geometryRefEquals2, instanceEquals2, instancesEqual2, behaviourEquals2, animationEquals2, transitionEquals2, materialRefEquals2, cameraEquals2, renderSettingsEquals2, effectsEqual2, viewsEqual2, resourcesEqual2, overlaysEqual2, environmentEquals2, skyEquals2, contactShadowsEquals2, bodyEquals2, assetsEqual2, physicsEquals2, xrEquals2, capacityFor2, createPerformanceMonitor2, easeProgress2, startTween2, applyTween2, fixed2, spin2, billboard2, box2, sphere2, plane2, cylinder2, torus2, cone2, capsule2, roundedBox2, backdrop2, ring2, circle2, text2, instant2, ease2, basic2, lambert2, phong2, standard2, physical2, normalMaterial2, shadowMaterial2, grid2, shaderGrid2, sharedGeometry2, lentGeometry2, sharedMaterial2, group2, detailed2, line2, points2, sparkles2, stars2, catmullRomPoints2, catmullRomPointAt2, catmullRomColors2, cubicBezierPoints2, quadraticBezierPoints2, headSpace2, jointSpace2, controllerSpace2, anchorSpace2, planeSpace2, meshSpace2, xrMeshGeometryId2, xrMesh2, xrAnchor2, mesh2, trail2, edges2, body2, interactionGroups2, cuboidCollider2, ballCollider2, capsuleCollider2, cylinderCollider2, coneCollider2, velocityMotor2, positionMotor2, physics2, bodyRef2, joint2, fixedJoint2, sphericalJoint2, revoluteJoint2, prismaticJoint2, ropeJoint2, springJoint2, glide2, xr2, instance2, instances2, behave2, play2, borrowed2, label2, colorRange2, ambientLight2, directionalLight2, pointLight2, spotLight2, hemisphereLight2, perspectiveCamera2, orthographicCamera2, cameraShake2, bloom2, vignette2, film2, renderSettings2, view2, renderTexture2, environment2, sunPositionFromAngles2, sky2, contactShadows2, modelAsset2, textureAsset2, environmentAsset2, fontAsset2, overlay2, hud2, scene2, emptyIndex2, indexScene2, changedFields2, diff2, createResourceStore2, createSceneClock2, createManualFrames2, createGatedFrames2, createFramePacer2, defaultOrbit2, orbitOptions2, rotateCamera2, dollyCamera2, panCamera2, dollyCameraToward2, orbit2, orbitKey2, autoRotated2, fitCamera2, clipCamera2, placeOverlays2, interactionBits2, snapshotText2, snapshotBytes2, colliderFor2, describedColliders2, collidersFor2, colliderSignature2, locomote2, teleport2, glided2, createXrTracker2, environmentPresets2, environmentPresetUrl2, stagePresets2, stage2, centerOffset2, stageBounds2, noModifiers2, pointOnPlane2, createPicker2, createPointerTracker2, createSceneLoop2, recordingRendererFactory2, createSceneGraph2, previewSvg2, gizmo2, pressGizmo2, releaseGizmo2, hoverGizmo2, dragGizmo2, movedAlike2, gizmoHandleOf2, gizmoNodes2, boxSelect2, exports_history, exports_lockstep, exports_timeline, thingsBounds2, describeScene2, formatSummary2, shotAngles2, shotCamera2, moods2, moodStaging2, inspectFields2, setAt2, sceneChanges2, formatChanges2, tape2, placeTapeEnd2, pointTape2, clearTape2, tapeLength2, tapeMiddle2, tapeNodes2, pivot2, pressPivot2, releasePivot2, hoverPivot2, dragPivot2, pivotHandleOf2, pivotNodes2, viewportGizmoNodes2, viewportAxisOf2, cameraAlong2 };
 
-//# debugId=9610D685ADCF1F6764756E2164756E21
-//# sourceMappingURL=index-h3vf50fn.js.map
+//# debugId=0311CB843C4BF34064756E2164756E21
+//# sourceMappingURL=index-re3rrfwd.js.map