spine-rigc 0.2.1 → 0.3.0

package/src/compile.ts

@@ -25,10 +25,14 @@ import {
   parseRigSpec,
   type RigAttachment,
   type RigBone,
+  type RigBoundingBoxAttachment,
+  type RigClippingAttachment,
+  type RigEvent,
   type RigMeshAttachment,
   type RigMeshBinding,
   type RigRegionAttachment,
   type RigSpec,
+  type RigVertexGeometry,
 } from './rig.ts';
 import { buildRibbonMesh, buildRingMesh, encodeWeightedVertices, MeshError, type MeshBoneRef } from './mesh.ts';
 import { KEY_TIME_EPSILON } from './timelines.ts';
@@ -48,12 +52,16 @@ import type {
   FaceManifest,
   FaceManifestPart,
   MotionDrawOrderKey,
+  MotionEventKey,
   MotionSpec,
   MotionTrack,
   RigInfo,
   SpineAttachment,
   SpineBone,
+  SpineBoundingBoxAttachment,
+  SpineClippingAttachment,
   SpineConstraint,
+  SpineEvent,
   SpineMeshAttachment,
   SpineRegionAttachment,
   SpineSkeletonJson,
@@ -77,6 +85,52 @@ function r6(n: number): number {
   return v === 0 ? 0 : v;
 }
 
+/**
+ * A **key time** on that same 1e-6 s grid — rounded DOWN rather than to nearest.
+ *
+ * ## Why key times get their own quantiser
+ *
+ * Every other emitted number is a quantity, and for a quantity nearest is the
+ * least wrong answer. A key time is not a quantity: it is a **position against a
+ * sample grid a player will step**, and the two directions of a half-step error
+ * are not equally wrong. Rounded down, a key fires on the sample it was written
+ * for, half a millionth of a second early, and nothing can see it. Rounded up, it
+ * fires on the NEXT sample — a whole frame late — and on a stepped timeline that
+ * is the wrong picture rather than a slightly wrong value.
+ *
+ * The arithmetic is not exotic, it is the common case: `2/12 s` and `5/30 s` are
+ * both 0.16666666…, `r6` emits 0.166667, and 0.166667 is larger than either. The
+ * spineboy run's muzzle flare fired one 12 fps frame late for exactly that, with
+ * no error and no warning, until the run's own frame self-check caught it (issue
+ * #99). ⚠️ An attachment timeline is inherently stepped, so it is where this
+ * surfaces first — but a rotate key rounded up is a frame late too; it just hides
+ * inside the interpolation.
+ *
+ * ## Why this is not `Math.floor(n * 1e6)`
+ *
+ * `n * 1e6` is itself a rounded double: `0.7 * 1e6` is 699999.9999999999, and
+ * flooring it would move a time the grid represents **exactly** a whole step down.
+ * So the value is rounded to nearest first and stepped back only when the result
+ * genuinely overshoots the time it came from. A time already on the grid is
+ * therefore emitted unchanged, which is what keeps `A18_DETERMINISTIC_EMIT` and
+ * every committed artifact where they were.
+ *
+ * ## What it means for `KEY_TIME_EPSILON`
+ *
+ * The tolerance's job narrows rather than moves: an authored key can no longer
+ * land past its own `duration` by the compiler's own rounding, so `checkKeyTime`
+ * only refuses a key the author really did put past the end. The epsilon stays,
+ * because A09 re-checks the same rule on an emitted file read back through a
+ * Float32Array — where the grid is coarser and rounds both ways — and because a
+ * `duration` is not required to be on the grid either.
+ */
+function keyTime(n: number): number {
+  let units = Math.round(n * 1e6);
+  if (units / 1e6 > n) units -= 1;
+  const v = units / 1e6;
+  return v === 0 ? 0 : v;
+}
+
 /**
  * Rule 4, per timeline: no key may land past the animation's declared duration.
  *
@@ -86,6 +140,12 @@ function r6(n: number): number {
  * That is exactly how rung 6 lost a one-frame attachment reveal; the tolerance
  * story is in `KEY_TIME_EPSILON`.
  *
+ * ⚠️ It compares the **emitted** time, not the authored one, and since `keyTime`
+ * rounds down that can only be more forgiving than comparing the author's number
+ * — by less than one step of the grid. That is the honest side to err on: the
+ * emitted time is the one a player samples, and refusing a key that will in fact
+ * be reached would be refusing a correct animation.
+ *
  * This is a refusal rather than an assertion because the key is the thing to
  * change and the motion spec is the file it lives in: the message has to name
  * the track and the key, and by gate time both are gone — the emitted skeleton
@@ -638,6 +698,7 @@ export function compile(opts: CompileOptions): CompileResult {
           meshes,
           slotName: rigSlot.name,
           anchorBone: rigSlot.bone,
+          slotNames: new Set(rig.slots.map((s) => s.name)),
         });
       }
       tableFor(skinName)[rigSlot.name] = perSlot;
@@ -762,6 +823,12 @@ export function compile(opts: CompileOptions): CompileResult {
     const drawOrder = anim.drawOrder ? compileDrawOrder(anim.drawOrder, animName, anim.duration, slots) : null;
     if (drawOrder) for (const key of drawOrder) compiledDuration = Math.max(compiledDuration, key.time as number);
 
+    const eventKeys = anim.events ? compileEvents(anim.events, animName, anim.duration, rig.events ?? {}) : null;
+    // An event timeline counts towards the animation's length the same as any
+    // other: `readAnimation` takes the duration from the longest timeline it
+    // built, and `EventTimeline.getDuration()` is its last frame like the rest.
+    if (eventKeys) for (const key of eventKeys) compiledDuration = Math.max(compiledDuration, key.time as number);
+
     // Rule 4: the declared duration is verified, because skeleton JSON does not
     // carry one — the loader takes the max key time.
     //
@@ -781,6 +848,7 @@ export function compile(opts: CompileOptions): CompileResult {
     if (Object.keys(boneTimelines).length) animations[animName].bones = boneTimelines;
     if (Object.keys(physicsTimelines).length) animations[animName].physics = physicsTimelines;
     if (drawOrder) animations[animName].drawOrder = drawOrder;
+    if (eventKeys) animations[animName].events = eventKeys;
   }
 
   // -- 6. assemble -----------------------------------------------------------
@@ -795,11 +863,29 @@ export function compile(opts: CompileOptions): CompileResult {
   if (rig.skeleton?.referenceScale !== undefined) header.referenceScale = rig.skeleton.referenceScale;
   if (rig.skeleton?.images !== undefined) header.images = rig.skeleton.images;
 
+  // Event definitions. Emitted in the order the rig spec declares them — object
+  // key order is the spec's, not a set's, so A18 stays a contract.
+  const events: Record<string, SpineEvent> = {};
+  for (const [name, def] of Object.entries(rig.events ?? {})) {
+    const entry: SpineEvent = {};
+    if (def.int !== undefined) entry.int = def.int;
+    if (def.float !== undefined) entry.float = r6(def.float);
+    if (def.string !== undefined) entry.string = def.string;
+    if (def.audio !== undefined) entry.audio = def.audio;
+    if (def.volume !== undefined) entry.volume = r6(def.volume);
+    if (def.balance !== undefined) entry.balance = r6(def.balance);
+    events[name] = entry;
+  }
+
   const skeleton: SpineSkeletonJson = {
     skeleton: header,
     bones,
     slots,
     skins: [...skinTables.entries()].map(([name, attachments]) => ({ name, attachments })),
+    // Between `skins` and `animations`, which is where the editor writes it. A
+    // conditional spread rather than an assignment after the literal, so the key
+    // lands in that position instead of at the end.
+    ...(Object.keys(events).length ? { events } : {}),
     animations,
   };
   if (constraints.length) skeleton.constraints = constraints;
@@ -961,6 +1047,8 @@ interface AttachmentContext {
   meshes: CompileResult['meshes'];
   slotName: string;
   anchorBone: string;
+  /** Every slot the rig declares — a clipping attachment's `end` resolves here. */
+  slotNames: Set<string>;
 }
 
 /**
@@ -981,12 +1069,149 @@ function buildRigAttachment(
   const type = att.type ?? 'region';
   if (type === 'region') return buildRigRegion(att as RigRegionAttachment, placeholder, where, ctx);
   if (type === 'mesh') return buildRigMesh(att as RigMeshAttachment, where, ctx);
+  if (type === 'boundingbox') return buildRigBoundingBox(att as RigBoundingBoxAttachment, where, ctx);
+  if (type === 'clipping') return buildRigClipping(att as RigClippingAttachment, where, ctx);
   throw new NotImplementedError(
     `${where}: attachment type "${String(type)}" is in the Spine 4.3 format and rigc does not emit it yet. ` +
-      'Implemented: region, mesh. docs/SPEC_COVERAGE.md part 1-6 lists what the type would have to carry.',
+      'Implemented: region, mesh, boundingbox, clipping. ' +
+      'point, path and linkedmesh are deliberately deferred: not one of them appears anywhere in the benchmark ' +
+      'corpus (docs/SPEC_COVERAGE.md parts 3-1 and 4-2), so none is on the ladder\'s critical path. ' +
+      'docs/SPEC_COVERAGE.md part 1-6 lists what each type would have to carry.',
   );
 }
 
+/**
+ * Encode the polygon a bounding box or a clipping attachment carries.
+ *
+ * 🚨 `vertexCount` is required, and everything else here is a cross-check of it.
+ * The parser reads `map.vertexCount << 1` and hands that to `readVertices` as the
+ * length to expect (`:552`, `:632`) — so with the field absent it expects 0,
+ * takes the weighted branch, decodes the coordinate list as
+ * `boneCount, (index, x, y, weight) × n`, and returns an attachment holding
+ * whatever that garbage produced. It loads. It draws nothing (a bounding box
+ * never did) and clips nothing, or clips the wrong shape, in complete silence.
+ *
+ * The two encodings are the mesh's — `encodeNamedWeights` is the same function —
+ * because they are the same field with the same trap: `readVertices` decides
+ * weighted vs unweighted by a length comparison alone, and a coincidental match
+ * reads weight data as coordinates.
+ */
+function buildVertexGeometry(att: RigVertexGeometry, where: string, ctx: AttachmentContext): number[] {
+  const count = att.vertexCount;
+  if (typeof count !== 'number' || !Number.isInteger(count) || count < 3) {
+    throw new CompileError(
+      `${where}: vertexCount is ${JSON.stringify(count)}; a polygon needs at least 3 vertices, stated outright — ` +
+        'the field has no parser default, and an absent one reads as 0 and takes the polygon with it',
+    );
+  }
+  if (att.vertices && att.weights) {
+    throw new CompileError(
+      `${where}: geometry comes as "vertices" or as "weights", never both — "weights" is the by-name form of the same data`,
+    );
+  }
+  if (att.weights) {
+    if (att.boneIndexing === 'raw') {
+      throw new CompileError(`${where}: "boneIndexing": "raw" describes a "vertices" run; "weights" always binds by name`);
+    }
+    if (att.weights.length !== count) {
+      throw new CompileError(`${where}: weights cover ${att.weights.length} vertices but vertexCount is ${count}`);
+    }
+    return encodeNamedWeights(att.weights, where, ctx);
+  }
+  const raw = att.vertices;
+  if (!raw || raw.length === 0) {
+    throw new CompileError(`${where}: needs geometry — "vertices" (x, y per vertex) or "weights" (bound by name)`);
+  }
+  const unweighted = raw.length === count * 2;
+  if (!unweighted) {
+    if (att.boneIndexing !== 'raw') {
+      throw new CompileError(
+        `${where}: vertexCount ${count} wants ${count * 2} unweighted numbers and "vertices" holds ${raw.length}. ` +
+          'The parser reads that as a WEIGHTED run, whose bone INDEXES point into the emitted bone array — a list ' +
+          'the spec never writes, so inserting a bone rebinds every vertex in silence. ' +
+          'Give the bindings by name as "weights": [[{ "bone": …, "x": …, "y": …, "weight": … }, …], …], ' +
+          'fix vertexCount, or say "boneIndexing": "raw" on this attachment to keep the index form deliberately.',
+      );
+    }
+    // A raw run still has to decode to exactly `vertexCount` vertices, or the
+    // count and the polygon disagree and the parser believes the count.
+    let decoded = 0;
+    for (let i = 0; i < raw.length; decoded++) {
+      const bones = raw[i++];
+      if (!Number.isInteger(bones) || bones < 1) {
+        throw new CompileError(`${where}: the raw weighted run has a bone count of ${String(bones)} at index ${i - 1}`);
+      }
+      i += bones * 4;
+      if (i > raw.length) {
+        throw new CompileError(
+          `${where}: the raw weighted run is truncated — vertex ${decoded} claims ${bones} bone(s) and the array ends first`,
+        );
+      }
+    }
+    if (decoded !== count) {
+      throw new CompileError(`${where}: the raw weighted run decodes to ${decoded} vertices but vertexCount is ${count}`);
+    }
+    // Register the bones it binds so the mesh-bone reports stay complete.
+    for (let i = 0; i < raw.length; ) {
+      const bones = raw[i++];
+      for (let k = 0; k < bones; k++, i += 4) {
+        const bone = ctx.bones[raw[i]];
+        if (bone) ctx.meshBones.add(bone.name);
+      }
+    }
+  }
+  for (const n of raw) {
+    if (!Number.isFinite(n)) throw new CompileError(`${where}: the vertex array holds a non-finite value ${String(n)}`);
+  }
+  return raw.map(r6);
+}
+
+function buildRigBoundingBox(
+  att: RigBoundingBoxAttachment,
+  where: string,
+  ctx: AttachmentContext,
+): SpineBoundingBoxAttachment {
+  const out: SpineBoundingBoxAttachment = {
+    type: 'boundingbox',
+    vertexCount: att.vertexCount,
+    vertices: buildVertexGeometry(att, where, ctx),
+  };
+  if (att.color !== undefined) out.color = att.color;
+  return out;
+}
+
+function buildRigClipping(
+  att: RigClippingAttachment,
+  where: string,
+  ctx: AttachmentContext,
+): SpineClippingAttachment {
+  if (att.end !== undefined) {
+    // `skeletonData.findSlot` returns null on a miss and the parser assigns that
+    // null (`:626-627`), so a typo does not fail — the clip simply never ends and
+    // takes every slot below it out of the frame.
+    if (typeof att.end !== 'string' || !ctx.slotNames.has(att.end)) {
+      throw new CompileError(
+        `${where}: end names slot ${JSON.stringify(att.end)}, which this rig does not declare; ` +
+          'a miss loads as null and the clip then runs to the bottom of the draw order',
+      );
+    }
+  }
+  // Field order is the editor's here — `end`, `convex`, `inverse` before the
+  // geometry — via conditional spreads, because a key assigned after the literal
+  // lands at the end instead. Order carries no meaning in JSON; it is read by
+  // people, and this file's diff against a reference is read a lot.
+  const out: SpineClippingAttachment = {
+    type: 'clipping',
+    ...(att.end !== undefined ? { end: att.end } : {}),
+    ...(att.convex !== undefined ? { convex: att.convex } : {}),
+    ...(att.inverse !== undefined ? { inverse: att.inverse } : {}),
+    vertexCount: att.vertexCount,
+    vertices: buildVertexGeometry(att, where, ctx),
+  };
+  if (att.color !== undefined) out.color = att.color;
+  return out;
+}
+
 function buildRigRegion(
   att: RigRegionAttachment,
   placeholder: string,
@@ -1606,7 +1831,7 @@ function compileValueTrack(
   for (let i = 0; i < track.keys.length; i++) {
     const key = track.keys[i];
     const next = track.keys[i + 1];
-    const time = r6(key.t + shift);
+    const time = keyTime(key.t + shift);
     if (i > 0 && time <= (out[i - 1].time as number)) {
       throw new CompileError(`${where}: key times must strictly increase (at t=${key.t})`);
     }
@@ -1641,7 +1866,7 @@ function compileValueTrack(
         const handles = motion.easings?.[key.ease];
         if (!handles) throw new CompileError(`${where}: unknown easing "${key.ease}"`);
         if (!Array.isArray(next.v)) throw new CompileError(`${where}: next key value must be an array`);
-        const t2 = r6(next.t + shift);
+        const t2 = keyTime(next.t + shift);
         const curve: number[] = [];
         for (let c = 0; c < shape.fields.length; c++) {
           curve.push(...bezierForChannel(handles, time, t2, (key.v as number[])[c], (next.v as number[])[c]));
@@ -1703,7 +1928,7 @@ function compileDrawOrder(
   const out: SpineTimelineKey[] = [];
   for (let i = 0; i < keys.length; i++) {
     const key = keys[i];
-    const time = r6(key.t);
+    const time = keyTime(key.t);
     if (i > 0 && time <= (out[i - 1].time as number)) {
       throw new CompileError(`${where}: key times must strictly increase (at t=${key.t})`);
     }
@@ -1744,6 +1969,100 @@ function compileDrawOrder(
   return out;
 }
 
+/**
+ * The whole-animation event timeline (`animations.<a>.events`).
+ *
+ * Four refusals, and the reason each one is here is a different failure mode of
+ * `readAnimation`'s event branch (SkeletonJson.ts:1238-1261):
+ *
+ *   1. **The name must be declared.** `skeletonData.findEvent` returns null and
+ *      the parser throws `Event not found` — one of the format's few loud
+ *      failures, but it throws in the CONSUMER's process, which is late. Refused
+ *      here so the message can name the rig spec's `events` block instead.
+ *   2. **Key times must not go backwards.** The loop writes frame `i` from key
+ *      `i` in ARRAY order and never sorts, so a time that decreases produces an
+ *      `EventTimeline` whose frames are out of order. Nothing throws; the
+ *      timeline's search simply stops finding the firings behind the fold. Equal
+ *      times are legal and deliberate — two different events on the same frame is
+ *      an ordinary thing to want — so this is non-decreasing, not the strictly
+ *      increasing rule a value track lives under (a value track has one value per
+ *      time and two keys at one time is a contradiction; two firings are not).
+ *   3. **`volume`/`balance` need the event to carry `audio`.** `:1254-1257` reads
+ *      them only inside `if (event.data.audioPath)`, so on a silent event they
+ *      are dropped without a word.
+ *   4. **A key past the declared duration.** The same `checkKeyTime` every other
+ *      timeline goes through: a firing after the end never fires (issue #54 was
+ *      exactly this shape on an attachment reveal).
+ */
+function compileEvents(
+  keys: MotionEventKey[],
+  animName: string,
+  duration: number,
+  events: Record<string, RigEvent>,
+): SpineTimelineKey[] {
+  const where = `animation "${animName}" events`;
+  if (!keys.length) throw new CompileError(`${where}: no keys`);
+
+  const out: SpineTimelineKey[] = [];
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (typeof key.name !== 'string' || key.name.length === 0) {
+      throw new CompileError(`${where}: key ${i} has no "name"; an event key fires an event by name`);
+    }
+    const declared = events[key.name];
+    if (declared === undefined) {
+      const known = Object.keys(events);
+      throw new CompileError(
+        `${where} at t=${key.t}: event "${key.name}" is not declared in the rig spec's "events" block; ` +
+          (known.length ? `declared: ${known.join(', ')}` : 'that block is empty or absent'),
+      );
+    }
+    if (!Number.isFinite(key.t)) throw new CompileError(`${where}: key ${i} has a non-finite time ${String(key.t)}`);
+    const time = keyTime(key.t);
+    if (i > 0 && time < (out[i - 1].time as number)) {
+      throw new CompileError(
+        `${where}: key times must not go backwards (at t=${key.t}, after t=${String(out[i - 1].time)}) — ` +
+          'the parser writes frames in array order and never sorts them',
+      );
+    }
+    checkKeyTime(where, time, key.t, duration);
+
+    const entry: SpineTimelineKey = { time, name: key.name };
+    if (key.int !== undefined) {
+      if (!Number.isInteger(key.int)) {
+        throw new CompileError(`${where} at t=${key.t}: int ${String(key.int)} is not an integer`);
+      }
+      entry.int = key.int;
+    }
+    if (key.float !== undefined) {
+      if (!Number.isFinite(key.float)) {
+        throw new CompileError(`${where} at t=${key.t}: float ${String(key.float)} is not finite`);
+      }
+      entry.float = r6(key.float);
+    }
+    if (key.string !== undefined) {
+      if (typeof key.string !== 'string') {
+        throw new CompileError(`${where} at t=${key.t}: string ${JSON.stringify(key.string)} is not a string`);
+      }
+      entry.string = key.string;
+    }
+    for (const field of ['volume', 'balance'] as const) {
+      const v = key[field];
+      if (v === undefined) continue;
+      if (declared.audio === undefined) {
+        throw new CompileError(
+          `${where} at t=${key.t}: ${field} is set but event "${key.name}" declares no "audio"; ` +
+            `the parser reads ${field} only for an event with an audio path, so it would be dropped in silence`,
+        );
+      }
+      if (!Number.isFinite(v)) throw new CompileError(`${where} at t=${key.t}: ${field} ${String(v)} is not finite`);
+      entry[field] = r6(v);
+    }
+    out.push(entry);
+  }
+  return out;
+}
+
 function resolveTargets(track: MotionTrack, motion: MotionSpec, animName: string): string[] {
   const named = [track.slot, track.group, track.bone, track.physics].filter((v) => v !== undefined);
   if (named.length > 1) {
@@ -1803,7 +2122,7 @@ function compileTrack(
   for (let i = 0; i < track.keys.length; i++) {
     const key = track.keys[i];
     const next = track.keys[i + 1];
-    const time = r6(key.t + shift);
+    const time = keyTime(key.t + shift);
     if (i > 0 && time <= (out[i - 1].time as number)) {
       throw new CompileError(`${where}: key times must strictly increase (at t=${key.t})`);
     }
@@ -1843,7 +2162,7 @@ function compileTrack(
         if (!Array.isArray(next.v)) {
           throw new CompileError(`${where}: rgba key value must be [r,g,b,a]`);
         }
-        const t2 = r6(next.t + shift);
+        const t2 = keyTime(next.t + shift);
         // 4 numbers per channel, r g b a — 16 in total. Short arrays become NaN
         // curves with no error.
         const curve: number[] = [];

package/src/ladder.ts

@@ -103,7 +103,7 @@ export const LADDER: readonly Rung[] = [
   {
     id: 'spineboy',
     example: 'spineboy',
-    gates: 'IK, events, bounding box, clipping, unweighted meshes — and scale: 67 bones, 52 slots, 11 animations',
+    gates: 'IK, events, bounding box, clipping, unweighted meshes — and scale: ess 18 bones/20 slots/8 animations, pro 67 bones/52 slots/11 animations',
     skeletons: [
       { label: 'ess', file: 'spineboy-ess.json', atlas: 'spineboy.atlas', role: 'rung' },
       // `-pro` is reported and does not count. It is a harder rig than the

package/src/render.ts

@@ -909,6 +909,17 @@ export interface FrameGeometry {
   /** 1 where any piece drew, in `viewport.width * viewport.height` row-major order. */
   coverage: Uint8Array;
   footprints: Map<string, Footprint>;
+  /**
+   * Which owner drew each pixel last, or `-1` — `null` unless `owners` was given.
+   *
+   * "Last" is the composite's own rule: pieces arrive in draw order, so the owner
+   * left in a pixel is the one you would see there. That is deliberately the
+   * opposite of `footprints`, which measures each slot on its own pixels
+   * *ignoring* what covers it — a footprint answers "where is this part", and
+   * this mask answers "whose part is this pixel", and only the second one can be
+   * a partition.
+   */
+  owner: Int32Array | null;
 }
 
 /**
@@ -923,11 +934,19 @@ export interface FrameGeometry {
  * an occluded part merges into its occluder's component — and that is what the
  * matcher reports as ambiguity rather than as drift.
  */
-export function frameGeometry(frame: Frame, pages: Map<string, Plate>, viewport: Viewport): FrameGeometry {
+export function frameGeometry(
+  frame: Frame,
+  pages: Map<string, Plate>,
+  viewport: Viewport,
+  /** Slot name → owner id, when the caller also wants the per-pixel owner mask. */
+  owners?: Map<string, number>,
+): FrameGeometry {
   const coverage = new Uint8Array(viewport.width * viewport.height);
+  const owner = owners === undefined ? null : new Int32Array(viewport.width * viewport.height).fill(-1);
   const footprints = new Map<string, Footprint>();
   const project = projector(viewport);
   for (const piece of frame.pieces) {
+    const owned = owners === undefined ? -1 : (owners.get(piece.slot) ?? -1);
     let weight = 0;
     let sx = 0;
     let sy = 0;
@@ -937,6 +956,7 @@ export function frameGeometry(frame: Frame, pages: Map<string, Plate>, viewport:
     let maxY = -Infinity;
     rasterisePiece(pageFor(pages, piece), piece, project, viewport, (px, py, _r, _g, _b, a) => {
       coverage[py * viewport.width + px] = 1;
+      if (owner !== null && owned >= 0) owner[py * viewport.width + px] = owned;
       const w = a / 255;
       weight += w;
       sx += (px + 0.5) * w;
@@ -956,7 +976,7 @@ export function frameGeometry(frame: Frame, pages: Map<string, Plate>, viewport:
     // answer, and it keeps the map keyed by slot the way the report reads it.
     footprints.set(piece.slot, previous && previous.pixels > 0 ? mergeFootprints(previous, here) : here);
   }
-  return { coverage, footprints };
+  return { coverage, footprints, owner };
 }
 
 function mergeFootprints(a: Footprint, b: Footprint): Footprint {