lecodes-cli 0.16.2 → 0.17.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lecodes-cli",
-  "version": "0.16.2",
+  "version": "0.17.1",
   "dependencies": {
     "@letary/chisel": "^0.8.0",
     "jimp": "^1.6.1"
@@ -11,11 +11,12 @@
     "qrcode-terminal": "^0.12.0",
     "lecodes-3d-editor": "workspace:*",
     "lecodes-assets": "workspace:*",
-    "sdk": "workspace:*"
+    "sdk": "workspace:*",
+    "viewer-lite": "workspace:*"
   },
   "peerDependencies": {
     "lecodes-design": "^0.8.1",
-    "lecodes-renderer": "^0.8.4",
+    "lecodes-renderer": "^0.8.6",
     "lecodes-3d-editor": "^0.3.0",
     "lecodes-assets": "^0.1.0"
   },

package/runtime/sdk/gl/Animator.ts

@@ -394,7 +394,8 @@ export class Animator extends Aspect<"animator", Node> {
   /** Default crossfade seconds for play()/stop(). */
   fade = 0.2
   /** Root motion: strip the root bone's horizontal travel from the pose and move the NODE with it
-   *  instead (or drive its CharacterController when it has one) — for clips whose hips actually travel
+   *  instead (or drive its CharacterController — on this node or an ancestor — when it has one; the
+   *  vertical part stays on the bone, so a jump's height is the clip's) — for clips whose hips actually travel
    *  (Mixamo without "In Place", lunges, rolls). `true` = auto-detect the root bone (the shallowest bone
    *  a clip translates), or a bone name. Read at attach. */
   rootMotion?: boolean | string
@@ -528,8 +529,15 @@ export class Animator extends Aspect<"animator", Node> {
     if (this.rootMotion) this._applyRootMotion(dt)
   }
 
+  /** The CharacterController root motion feeds: on this node, or on the nearest ANCESTOR — the usual
+   *  rig is a capsule node holding Shape + CharacterController with the model parented under it,
+   *  shifted down so its feet sit at the capsule's bottom (the controller centers the shape on its node). */
   private _controller(): CharacterController | undefined {
-    return (this.node as unknown as { controller?: CharacterController }).controller
+    for (let n: Node | null = this.node; n; n = n.parent) {
+      const c = (n as unknown as { controller?: CharacterController }).controller
+      if (c) return c
+    }
+    return undefined
   }
 
   /** Root motion (last native frame's delta, node-local, horizontal): move the node, or feed the

package/runtime/sdk/gl/IK.ts

@@ -1,170 +1,174 @@
-// IK — precise character actions as late-phase aspects on BONES (docs/animation-plan.md §2.5).
-// They run after the animation wrote the pose (base anim or Animator) and before the skin is
-// flushed, so their bone writes land in the skin. Attach to the END bone of the chain; the chain is
-// walked up through parents — one instance per end effector, any Node hierarchy works.
-//
-//   const foot = hero.bone('LeftFoot')!
-//   foot.aspect(IK.TwoBone, { target: footTarget, pole: kneeHint })     // upLeg → leg → foot
-//   foot.ik.weight = grounded ? 1 : 0                                    // blend in/out
-//   hero.bone('Head')!.aspect(IK.LookAt, { target: camera, limit: 70 })  // head tracks the camera
-//
-// Pure SDK/JS: a handful of world-matrix reads + two quaternion writes per solve. A native solver can
-// slot in later behind the same API.
-
-import { Aspect } from "../core/Aspect"
-import { Vec3, type Vec3Like } from "../math/vec"
-import { Quat } from "../math/quat"
-import type { Node } from "./Node"
-
-type Target = Node | Vec3Like
-
-const targetPos = (t: Target | undefined): Vec3 | null => {
-  if (t === undefined || t === null) return null
-  const n = t as Node
-  if (typeof (n as { worldPosition?: unknown }).worldPosition === "object" && typeof n.id === "number") return n.worldPosition
-  return new Vec3(t as Vec3Like)
-}
-
-/** World rotation of a node (parent chain composed natively). */
-const worldRot = (n: Node): Quat => n.worldMatrix.rotation
-
-/** Write a WORLD rotation to a node by converting through the parent's world rotation. */
-const setWorldRot = (n: Node, q: Quat): void => {
-  const p = n.parent
-  n.quaternion = p ? worldRot(p).invert().mul(q).normalize() : q.normalize()
-}
-
-const clampAngle = (q: Quat, maxRad: number): Quat => {
-  // angle of a unit quaternion = 2·acos(|w|)
-  const w = Math.min(1, Math.abs(q.w))
-  const ang = 2 * Math.acos(w)
-  if (ang <= maxRad || ang < 1e-6) return q
-  const s = Math.sqrt(1 - w * w)
-  const axis = new Vec3(q.x / s, q.y / s, q.z / s)
-  return Quat.fromAxisAngle(axis, q.w < 0 ? -maxRad : maxRad)
-}
-
-/** Two-bone analytic IK (limbs). Attach to the END bone: `foot.aspect(IK.TwoBone, { target })`
- *  solves upper (grandparent) + mid (parent) so the end reaches `target`; `pole` steers the bend
- *  (knee/elbow) — a Node or world point. */
-class TwoBone extends Aspect<"ik", Node> {
-  static readonly aspect = "ik"
-
-  /** Where the end bone should be (Node or world position). */
-  target?: Target
-  /** Bend hint — the mid joint is pulled toward it (Node or world position). */
-  pole?: Target
-  /** 0–1 contribution (blend in/out, e.g. foot planting only while grounded). */
-  weight = 1
-  /** Solve every frame (default). Set false to drive `solve()` yourself. */
-  enabled = true
-
-  update(): void {
-    if (this.enabled) this.solve()
-  }
-
-  /** One solve at the current pose. Safe to call manually (e.g. from a later-ordered aspect). */
-  solve(): void {
-    const t = targetPos(this.target)
-    if (!t || this.weight <= 0) return
-    const end = this.node
-    const mid = end.parent
-    const root = mid?.parent
-    if (!mid || !root) return
-
-    const w = Math.min(1, this.weight)
-    const midLocal0 = mid.quaternion
-    const rootLocal0 = root.quaternion
-
-    const a = root.worldPosition, b = mid.worldPosition, c = end.worldPosition
-    const l1 = a.distanceTo(b), l2 = b.distanceTo(c)
-    if (l1 < 1e-6 || l2 < 1e-6) return
-    const eps = 1e-4
-    const toT = t.sub(a)
-    const d = Math.min(Math.max(toT.length(), eps), l1 + l2 - eps)
-
-    // 1. bend the mid joint to the angle the target distance demands (law of cosines)
-    const ba = a.sub(b), bc = c.sub(b)
-    const cur = ba.angle(bc)
-    const want = Math.acos(Math.min(1, Math.max(-1, (l1 * l1 + l2 * l2 - d * d) / (2 * l1 * l2))))
-    let axis = bc.cross(ba)
-    if (axis.lengthSq() < 1e-10) {
-      // straight limb: bend toward the pole (or any perpendicular)
-      const p = targetPos(this.pole)
-      const ref = p ? p.sub(b) : new Vec3(0, 0, 1)
-      axis = ba.cross(ref)
-      if (axis.lengthSq() < 1e-10) axis = ba.cross(new Vec3(0, 1, 0))
-      if (axis.lengthSq() < 1e-10) axis = ba.cross(new Vec3(1, 0, 0))
-    }
-    axis = axis.normalize()
-    // rotating mid by (want - cur) about `axis` opens/closes the angle between ba and bc
-    const midWorld = worldRot(mid)
-    setWorldRot(mid, Quat.fromAxisAngle(axis, want - cur).mul(midWorld))
-
-    // 2. swing the root so the end lands on the target direction
-    const c2 = end.worldPosition
-    const rootWorld = worldRot(root)
-    setWorldRot(root, Quat.fromTo(c2.sub(a), toT).mul(rootWorld))
-
-    // 3. pole: spin the root about the root→target axis so the mid joint lies toward the pole
-    const p = targetPos(this.pole)
-    if (p) {
-      const dir = toT.normalize()
-      const b2 = mid.worldPosition
-      const midProj = b2.sub(a).sub(dir.scale(b2.sub(a).dot(dir)))
-      const poleProj = p.sub(a).sub(dir.scale(p.sub(a).dot(dir)))
-      if (midProj.lengthSq() > 1e-10 && poleProj.lengthSq() > 1e-10) {
-        setWorldRot(root, Quat.fromTo(midProj, poleProj).mul(worldRot(root)))
-      }
-    }
-
-    // 4. weight: blend from the animated pose to the solved one
-    if (w < 1) {
-      root.quaternion = rootLocal0.slerp(root.quaternion, w)
-      mid.quaternion = midLocal0.slerp(mid.quaternion, w)
-    }
-  }
-}
-
-/** Aim a bone at a target (head / eyes / turret). Attach to the bone itself:
- *  `head.aspect(IK.LookAt, { target: camera, limit: 70 })`. `axis` is the bone's LOCAL forward
- *  (the direction that should point at the target) — rigs differ; default −Z, Mixamo heads look
- *  along +Z of the head bone in most exports, so pass `axis: [0, 0, 1]` there if it faces backwards. */
-class LookAt extends Aspect<"lookAt", Node> {
-  static readonly aspect = "lookAt"
-
-  target?: Target
-  /** The bone's local axis that should point at the target. */
-  axis: Vec3Like = [ 0, 0, -1 ]
-  /** Max deflection from the animated direction, in degrees (default 80). */
-  limit = 80
-  /** 0–1 contribution. */
-  weight = 1
-  enabled = true
-
-  update(): void {
-    if (this.enabled) this.solve()
-  }
-
-  solve(): void {
-    const t = targetPos(this.target)
-    if (!t || this.weight <= 0) return
-    const bone = this.node
-    const w = Math.min(1, this.weight)
-    const local0 = bone.quaternion
-    const from = bone.worldPosition
-    const dir = t.sub(from)
-    if (dir.lengthSq() < 1e-10) return
-    const rot = worldRot(bone)
-    const current = new Vec3(this.axis).rotate(rot)
-    let delta = Quat.fromTo(current, dir)
-    delta = clampAngle(delta, (this.limit * Math.PI) / 180)
-    setWorldRot(bone, delta.mul(rot))
-    if (w < 1) bone.quaternion = local0.slerp(bone.quaternion, w)
-  }
-}
-
-/** Inverse kinematics aspects — attach to bones (see file header). */
-export const IK = { TwoBone, LookAt }
-export type IKTwoBone = TwoBone
-export type IKLookAt = LookAt
+// IK — precise character actions as late-phase aspects on BONES (docs/animation-plan.md §2.5).
+// They run after the animation wrote the pose (base anim or Animator) and before the skin is
+// flushed, so their bone writes land in the skin. Attach to the END bone of the chain; the chain is
+// walked up through parents — one instance per end effector, any Node hierarchy works.
+//
+//   const foot = hero.bone('LeftFoot')!
+//   foot.aspect(IK.TwoBone, { target: footTarget, pole: kneeHint })     // upLeg → leg → foot
+//   foot.ik.weight = grounded ? 1 : 0                                    // blend in/out
+//   hero.bone('Head')!.aspect(IK.LookAt, { target: camera, limit: 70 })  // head tracks the camera
+//
+// Pure SDK/JS: a handful of world-matrix reads + two quaternion writes per solve. A native solver can
+// slot in later behind the same API.
+
+import { Aspect } from "../core/Aspect"
+import { Vec3, type Vec3Like } from "../math/vec"
+import { Quat } from "../math/quat"
+import type { Node } from "./Node"
+
+type Target = Node | Vec3Like
+
+const targetPos = (t: Target | undefined): Vec3 | null => {
+  if (t === undefined || t === null) return null
+  const n = t as Node
+  if (typeof (n as { worldPosition?: unknown }).worldPosition === "object" && typeof n.id === "number") return n.worldPosition
+  return new Vec3(t as Vec3Like)
+}
+
+/** World rotation of a node (parent chain composed natively). */
+const worldRot = (n: Node): Quat => n.worldMatrix.rotation
+
+/** Write a WORLD rotation to a node by converting through the parent's world rotation. */
+const setWorldRot = (n: Node, q: Quat): void => {
+  const p = n.parent
+  n.quaternion = p ? worldRot(p).invert().mul(q).normalize() : q.normalize()
+}
+
+const clampAngle = (q: Quat, maxRad: number): Quat => {
+  // angle of a unit quaternion = 2·acos(|w|)
+  const w = Math.min(1, Math.abs(q.w))
+  const ang = 2 * Math.acos(w)
+  if (ang <= maxRad || ang < 1e-6) return q
+  const s = Math.sqrt(1 - w * w)
+  const axis = new Vec3(q.x / s, q.y / s, q.z / s)
+  return Quat.fromAxisAngle(axis, q.w < 0 ? -maxRad : maxRad)
+}
+
+/** Two-bone analytic IK (limbs). Attach to the END bone: `foot.aspect(IK.TwoBone, { target })`
+ *  solves upper (grandparent) + mid (parent) so the end reaches `target`; `pole` steers the bend
+ *  (knee/elbow) — a Node or world point. */
+class TwoBone extends Aspect<"ik", Node> {
+  static readonly aspect = "ik"
+
+  /** Where the end bone should be (Node or world position). */
+  target?: Target
+  /** Bend hint — the mid joint is pulled toward it (Node or world position). */
+  pole?: Target
+  /** 0–1 contribution (blend in/out, e.g. foot planting only while grounded). */
+  weight = 1
+  /** Solve every frame (default). Set false to drive `solve()` yourself. */
+  enabled = true
+
+  update(): void {
+    if (this.enabled) this.solve()
+  }
+
+  /** One solve at the current pose. Safe to call manually (e.g. from a later-ordered aspect). */
+  solve(): void {
+    const t = targetPos(this.target)
+    if (!t || this.weight <= 0) return
+    const end = this.node
+    const mid = end.parent
+    const root = mid?.parent
+    if (!mid || !root) return
+
+    const w = Math.min(1, this.weight)
+    const midLocal0 = mid.quaternion
+    const rootLocal0 = root.quaternion
+
+    const a = root.worldPosition, b = mid.worldPosition, c = end.worldPosition
+    const l1 = a.distanceTo(b), l2 = b.distanceTo(c)
+    if (l1 < 1e-6 || l2 < 1e-6) return
+    const eps = 1e-4
+    const toT = t.sub(a)
+    const d = Math.min(Math.max(toT.length(), eps), l1 + l2 - eps)
+
+    // 1. bend the mid joint to the angle the target distance demands (law of cosines)
+    const ba = a.sub(b), bc = c.sub(b)
+    const cur = ba.angle(bc)
+    const want = Math.acos(Math.min(1, Math.max(-1, (l1 * l1 + l2 * l2 - d * d) / (2 * l1 * l2))))
+    // a positive rotation about ba × bc moves `bc` AWAY from `ba`, i.e. opens the joint — so rotating the
+    // mid bone by (want − cur) about it opens/closes exactly as needed. (bc × ba has the opposite sense:
+    // with it every already-bent limb — which is every animated limb — bends the wrong way; the straight
+    // case below picks its axis as ba × ref, the same sense as ba × bc for a limb barely bent toward ref.)
+    let axis = ba.cross(bc)
+    if (axis.lengthSq() < 1e-10) {
+      // straight limb: bend toward the pole (or any perpendicular)
+      const p = targetPos(this.pole)
+      const ref = p ? p.sub(b) : new Vec3(0, 0, 1)
+      axis = ba.cross(ref)
+      if (axis.lengthSq() < 1e-10) axis = ba.cross(new Vec3(0, 1, 0))
+      if (axis.lengthSq() < 1e-10) axis = ba.cross(new Vec3(1, 0, 0))
+    }
+    axis = axis.normalize()
+    // rotating mid by (want - cur) about `axis` opens/closes the angle between ba and bc
+    const midWorld = worldRot(mid)
+    setWorldRot(mid, Quat.fromAxisAngle(axis, want - cur).mul(midWorld))
+
+    // 2. swing the root so the end lands on the target direction
+    const c2 = end.worldPosition
+    const rootWorld = worldRot(root)
+    setWorldRot(root, Quat.fromTo(c2.sub(a), toT).mul(rootWorld))
+
+    // 3. pole: spin the root about the root→target axis so the mid joint lies toward the pole
+    const p = targetPos(this.pole)
+    if (p) {
+      const dir = toT.normalize()
+      const b2 = mid.worldPosition
+      const midProj = b2.sub(a).sub(dir.scale(b2.sub(a).dot(dir)))
+      const poleProj = p.sub(a).sub(dir.scale(p.sub(a).dot(dir)))
+      if (midProj.lengthSq() > 1e-10 && poleProj.lengthSq() > 1e-10) {
+        setWorldRot(root, Quat.fromTo(midProj, poleProj).mul(worldRot(root)))
+      }
+    }
+
+    // 4. weight: blend from the animated pose to the solved one
+    if (w < 1) {
+      root.quaternion = rootLocal0.slerp(root.quaternion, w)
+      mid.quaternion = midLocal0.slerp(mid.quaternion, w)
+    }
+  }
+}
+
+/** Aim a bone at a target (head / eyes / turret). Attach to the bone itself:
+ *  `head.aspect(IK.LookAt, { target: camera, limit: 70 })`. `axis` is the bone's LOCAL forward
+ *  (the direction that should point at the target) — rigs differ; default −Z, Mixamo heads look
+ *  along +Z of the head bone in most exports, so pass `axis: [0, 0, 1]` there if it faces backwards. */
+class LookAt extends Aspect<"lookAt", Node> {
+  static readonly aspect = "lookAt"
+
+  target?: Target
+  /** The bone's local axis that should point at the target. */
+  axis: Vec3Like = [ 0, 0, -1 ]
+  /** Max deflection from the animated direction, in degrees (default 80). */
+  limit = 80
+  /** 0–1 contribution. */
+  weight = 1
+  enabled = true
+
+  update(): void {
+    if (this.enabled) this.solve()
+  }
+
+  solve(): void {
+    const t = targetPos(this.target)
+    if (!t || this.weight <= 0) return
+    const bone = this.node
+    const w = Math.min(1, this.weight)
+    const local0 = bone.quaternion
+    const from = bone.worldPosition
+    const dir = t.sub(from)
+    if (dir.lengthSq() < 1e-10) return
+    const rot = worldRot(bone)
+    const current = new Vec3(this.axis).rotate(rot)
+    let delta = Quat.fromTo(current, dir)
+    delta = clampAngle(delta, (this.limit * Math.PI) / 180)
+    setWorldRot(bone, delta.mul(rot))
+    if (w < 1) bone.quaternion = local0.slerp(bone.quaternion, w)
+  }
+}
+
+/** Inverse kinematics aspects — attach to bones (see file header). */
+export const IK = { TwoBone, LookAt }
+export type IKTwoBone = TwoBone
+export type IKLookAt = LookAt

package/runtime/sdk/gl/InstancedMesh.ts

@@ -0,0 +1,132 @@
+// One geometry drawn many times — grass tufts, crates, debris, coins, a crowd of identical props —
+// with a transform per instance and a handful of draw calls. Hardware instancing (Filament's
+// InstanceBuffer): the engine applies each instance's local matrix, so any regular material works.
+//
+// Transforms live in a CPU-side Float32Array (16 floats per instance, column-major, local to this
+// node). `setAt` / `hideAt` / `setMatrixAt` edit it and track the dirty range; `commit()` uploads
+// that range in one bridge call — call it once per frame after your edits, not per instance.
+// The native side splits the instances into chunks of the platform's per-draw cap (64 native,
+// 8 on WebGL) on child entities, and keeps a bounding box per chunk so frustum culling stays on.
+
+import { Mat4, type Mat4Like } from "../math/mat4"
+import { Quat, type QuatLike } from "../math/quat"
+import { cx, cy, cz, type Vec3Like } from "../math/vec"
+import type { Geometry } from "./Geometry"
+import { Material } from "./Material"
+import type { MeshOptions } from "./Mesh"
+import { Node } from "./Node"
+
+/** One instance's placement, local to the InstancedMesh node. Omitted fields mean identity. */
+export type InstanceTransform = {
+  position?: Vec3Like
+  /** Quaternion; wins over `eulerAngles`. */
+  rotation?: QuatLike
+  /** Degrees (YXZ), like `Node.eulerAngles`. */
+  eulerAngles?: Vec3Like
+  scale?: Vec3Like | number
+}
+
+const DEG = Math.PI / 180
+
+export class InstancedMesh extends Node {
+  /** Instance capacity, fixed at construction. Unset instances are hidden. */
+  readonly count: number
+  private _geometry: Geometry
+  private _material: Material
+  private _data: Float32Array
+  private _lo = Infinity
+  private _hi = -1
+
+  constructor(geometry: Geometry, count: number, options: MeshOptions = {}) {
+    super()
+    if (!(count >= 1)) throw new Error("InstancedMesh: count must be ≥ 1")
+    this.count = Math.floor(count)
+    this._geometry = geometry
+    this._material = options.material ?? Material.unlit()
+    this._data = new Float32Array(16 * this.count)
+    _creator.createInstancedMesh(this.id, Material.idOf(this._material), geometry.vertices, geometry.normals, geometry.indices, geometry.uv, this.count)
+    if (options.position) this.position = options.position
+    if (options.eulerAngles) this.eulerAngles = options.eulerAngles
+    if (options.scale !== undefined) this.scale = typeof options.scale === "number" ? [ options.scale, options.scale, options.scale ] : options.scale
+    if (options.name !== undefined) this.name = options.name
+    if (options.castShadows !== undefined || options.receiveShadows !== undefined) {
+      _creator.setInstancedMeshShadows(this.id, options.castShadows ?? true, options.receiveShadows ?? true)
+    }
+  }
+
+  override get geometry(): Geometry { return this._geometry }
+
+  get material(): Material { return this._material }
+  set material(m: Material) {
+    this._material = m
+    _creator.setInstancedMeshMaterial(this.id, Material.idOf(m))
+  }
+
+  /** Shadow flags for all instances (both at once — the engine sets them per draw). */
+  setShadows(cast: boolean, receive = cast): this {
+    _creator.setInstancedMeshShadows(this.id, cast, receive)
+    return this
+  }
+
+  private _touch(i: number): void {
+    if (i < this._lo) this._lo = i
+    if (i > this._hi) this._hi = i
+  }
+
+  /** Place instance `i`. Pending until `commit()`. */
+  setAt(i: number, t: InstanceTransform): this {
+    if (i < 0 || i >= this.count) throw new RangeError(`InstancedMesh: index ${i} out of 0..${this.count - 1}`)
+    const rot = t.rotation ?? (t.eulerAngles
+      ? Quat.fromEuler(cx(t.eulerAngles) * DEG, cy(t.eulerAngles) * DEG, cz(t.eulerAngles) * DEG)
+      : Quat.identity)
+    const m = Mat4.compose(t.position ?? [ 0, 0, 0 ], rot, t.scale ?? 1).toArray()
+    this._data.set(m, i * 16)
+    this._touch(i)
+    return this
+  }
+
+  /** Place instance `i` from a 4×4 column-major matrix (local to this node). */
+  setMatrixAt(i: number, m: Mat4Like): this {
+    if (i < 0 || i >= this.count) throw new RangeError(`InstancedMesh: index ${i} out of 0..${this.count - 1}`)
+    const a = m instanceof Mat4 ? m.toArray() : m
+    for (let k = 0; k < 16; k++) this._data[i * 16 + k] = a[k]
+    this._touch(i)
+    return this
+  }
+
+  /** Hide instance `i` (a zero matrix — no geometry is emitted for it). */
+  hideAt(i: number): this {
+    if (i < 0 || i >= this.count) throw new RangeError(`InstancedMesh: index ${i} out of 0..${this.count - 1}`)
+    this._data.fill(0, i * 16, i * 16 + 16)
+    this._touch(i)
+    return this
+  }
+
+  /** Bulk write: `matrices` holds 16 floats per instance, starting at instance `offset`. */
+  setMatrices(matrices: ArrayLike<number>, offset = 0): this {
+    const n = Math.min(Math.floor(matrices.length / 16), this.count - offset)
+    if (n <= 0) return this
+    this._data.set(Array.prototype.slice.call(matrices, 0, n * 16), offset * 16)
+    this._touch(offset)
+    this._touch(offset + n - 1)
+    return this
+  }
+
+  /** The 4×4 of instance `i` as stored (a copy). */
+  matrixAt(i: number): Mat4 {
+    return Mat4.from(this._data.subarray(i * 16, i * 16 + 16))
+  }
+
+  /** Upload every change since the last commit (one bridge call covering the dirty range). */
+  commit(): this {
+    if (this._hi < this._lo) return this
+    const lo = this._lo, hi = this._hi
+    this._lo = Infinity
+    this._hi = -1
+    _creator.setInstanceTransforms(this.id, this._data.subarray(lo * 16, (hi + 1) * 16), lo)
+    return this
+  }
+
+  /** Whether edits are waiting for `commit()`. */
+  get dirty(): boolean { return this._hi >= this._lo }
+}