@rig-c/parts 1.23.0 → 1.25.0

package/src/cloth.ts

@@ -48,6 +48,9 @@
  *   hip, by the skirt's own rule, in place of the robe chains the topwear rule
  *   drafts; its art above the hip stays on the chest. The proposer never picks
  *   such a part by itself: it names a candidate, and the author declares it.
+ *   A `bottomwear` part lying on that part's tree links (a hem returned as a
+ *   layer of its own) rides them, as a layer on a tail does ({@link tailOverlap}),
+ *   and gets no trees of its own (issue #416): one skirt, one set of trees.
  * - **Swing** (`bottomwear` only). `swing.scales` declares one shared pendulum:
  *   a bone `<prefix>swing` under the attachment at the centre of the root row,
  *   one link long, with physics; each tree's first link takes the swing's
@@ -62,7 +65,9 @@
  * Pure: no clock, no randomness; every value is a function of its inputs.
  */
 import type { ConfigConstraint, Point } from './config.ts';
+import type { Mask } from './raster/types.ts';
 import { pyRound } from './round.ts';
+import { segmentDistance } from './weights.ts';
 
 /** The tags a `cloth` recipe may name: the parts the proposer drafts chains on that hang. */
 export const CLOTH_TARGETS = ['bottomwear', 'back hair', 'front hair'] as const;
@@ -79,7 +84,7 @@ export interface ClothStrength {
 export interface ClothRecipe {
   chains: number;
   links: number;
-  split?: { at: number; into: number };
+  split?: { at: number; into: number; hold_tip?: boolean };
   length_ratio?: number;
   strength?: ClothStrength;
   damping?: number;
@@ -255,7 +260,7 @@ export function draftTrees(input: TreeInput, r: ClothRecipe): TreeChain[] {
         depths: [],
         last: [],
       };
-      const edge = outerSide(k, b);
+      const edge = r.split?.hold_tip === true ? false : outerSide(k, b);
       for (let j = trunkLinks; j < r.links; j++) {
         ch.points.push(j === trunkLinks ? trunk.tip : pt(rows[j], fb));
         ch.why.push(j === trunkLinks ? `the fork: the trunk ${trunk.chain}'s tip` : `${rowRule(j)}, ${pyRound(fb, 6)} of the way across ${input.frame} in the 24-row band there (branch ${b} of ${into} of tree ${k})`);
@@ -381,10 +386,74 @@ export function clothNote(part: string, tag: ClothTarget, trees: readonly TreeCh
   const defaults: string[] = [];
   if (r.length_ratio === undefined) defaults.push(`length_ratio ${RECIPE_LENGTH_RATIO}`);
   if (r.strength === undefined) defaults.push(`strength ${RECIPE_STRENGTH.trunk}/${RECIPE_STRENGTH.branch}/${RECIPE_STRENGTH.edge}`);
-  const shape = r.split === undefined ? `${r.links} link(s) each` : `a ${r.split.at}-link trunk forking into ${r.split.into} branches, ${r.links} links root to tip`;
+  const shape = r.split === undefined ? `${r.links} link(s) each` : `a ${r.split.at}-link trunk forking into ${r.split.into} branches${r.split.hold_tip === true ? ' (tip held)' : ''}, ${r.links} links root to tip`;
   return (
     `${part} (${via === undefined ? tag : `${via}, which config.cloth."${tag}".part names`}): config.cloth."${tag}" -> ${r.chains} tree(s)${extra}, ${shape} (${trees.map((t) => t.chain).join(', ')}); ` +
     `${constraints} constraint(s), physics on every link, wind ${r.wind[0]} -> ${r.wind[1]} and gravity ${r.gravity[0]} -> ${r.gravity[1]} root to tip (multipliers of the consumer's environment; no direction is drafted), no idle key` +
     (defaults.length === 0 ? '' : `; the recipe's own defaults, measured on its synthetic fixture (AUTHORING §3): ${defaults.join(', ')}`)
   );
 }
+
+/**
+ * Issue #391: a part wrapped round a tail the recipe drafted rides that tail's links. One span of the tail: a segment
+ * of the back hair's mesh as the recipe drafts it — the head's fixed segment, or one tree link from its origin to the
+ * next link (the last to the chain's tip), named by the link's bone.
+ */
+export interface TailSpan {
+  bone: string;
+  a: Point;
+  b: Point;
+  /** Whether the span is a tree link (false: the head's fixed segment). */
+  link: boolean;
+}
+
+/** A tail the recipe drafted: the back hair part, its opaque mask on the rig canvas, and its mesh's spans in segment order. */
+export interface Tail {
+  part: string;
+  mask: Mask;
+  spans: TailSpan[];
+}
+
+/** Where a part's opaque pixels lie against a drafted tail. */
+export interface TailOverlap {
+  /** Per span, in the tail's order: the part's pixels over the tail's art whose nearest span it is. */
+  counts: number[];
+  /** The part's pixels over the tail's art (the sum of `counts`). */
+  over: number;
+  /** The part's opaque pixels in all. */
+  total: number;
+}
+
+/**
+ * Which span of the tail each of the part's pixels over the tail's art belongs to: every pixel where both masks are
+ * set is given to the span nearest it — the distance the weights read (`segmentDistance`, `src/weights.ts`), so a
+ * span here is the art the tail's own weights give mostly to that bone — the first in the tail's order on a tie. No
+ * threshold: a span the part touches by one pixel is one the part overlaps, and the counts are said in the note.
+ * Pure; the part's mask and the tail's are on the same canvas.
+ */
+export function tailOverlap(tail: Tail, part: Mask, box: { x: number; y: number; w: number; h: number }): TailOverlap {
+  const counts = tail.spans.map(() => 0);
+  let over = 0;
+  let total = 0;
+  const W = part.width;
+  for (let y = box.y; y < box.y + box.h; y++) {
+    for (let x = box.x; x < box.x + box.w; x++) {
+      const i = y * W + x;
+      if (part.data[i] === 0) continue;
+      total++;
+      if (tail.mask.data[i] === 0) continue;
+      over++;
+      let best = 0;
+      let bd = Infinity;
+      tail.spans.forEach((s, k) => {
+        const d = segmentDistance([x, y], s.a, s.b);
+        if (d < bd) {
+          bd = d;
+          best = k;
+        }
+      });
+      counts[best]++;
+    }
+  }
+  return { counts, over, total };
+}

package/src/config.ts

@@ -86,7 +86,7 @@
  */
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
-import { RIG_BONE_INHERIT, RIG_SKIN_CONSTRAINT_KEYS, type RigBoneInherit, type RigConstraint, type RigSkinConstraintKey } from 'rig-c/src/rig.ts';
+import { RIG_BONE_INHERIT, RIG_SKIN_CONSTRAINT_KEYS, type RigBoneInherit, type RigConstraint, type RigSkinConstraintKey, type RigStop } from 'rig-c/src/rig.ts';
 import { pyRound } from './round.ts';
 import { CLOTH_TARGETS, type ClothRecipes, RECIPE_STRENGTH, RIGC_DEFAULT_DAMPING, springStable } from './cloth.ts';
 import { GRID, MAX_SIDE } from './contour.ts';
@@ -648,6 +648,26 @@ export interface ConfigConstraint {
   [field: string]: unknown;
 }
 
+/**
+ * One entry of `config.stops` (issue #404): rig-c's `RigStop` (`rig-c` 2.56.0),
+ * a cloth chain's rotation clamped against a leg bone so the skirt cannot swing
+ * into the leg. `chain` names a chain declared in `config.bones`; `links` is
+ * the stopped links along it (when omitted, every link of `chain` in link
+ * order); `against` is the leg bone the point rides on; `at` is `[x, y]` in
+ * `against`'s local space; `inward` and `outward` are the first link's clamp
+ * bounds in degrees (positive away from `against`), and `lower` the lower
+ * links' bounds when more than one link is stopped.
+ */
+export interface ConfigStop {
+  chain: string;
+  links?: string[];
+  against: string;
+  at: Point;
+  inward: number;
+  outward: number;
+  lower?: { inward: number; outward: number };
+}
+
 /**
  * One segment of a limb (issue #349): the part it makes, the part whose
  * pixels it takes (`from`: a plan part or a cut's piece), and the one bone it
@@ -697,6 +717,8 @@ export interface CharacterConfig {
   regions: Record<string, string>;
   motion: Motion;
   constraints?: ConfigConstraint[];
+  /** Leg stops (issue #404, rig-c 2.56.0's `RigStop`): absent, no stop is added and no byte of any output moves. */
+  stops?: ConfigStop[];
   /** The turn control (issue #251, `src/turn.ts`): absent, no control is added and no byte of any output moves. */
   turn?: TurnSpec;
   /** The painting is a scene (issue #242): absent, no byte of any output moves. */
@@ -760,6 +782,23 @@ export function constraintForRig(c: ConfigConstraint): Record<string, unknown> {
   return out;
 }
 
+/**
+ * A stop as the rig stage hands it to rigc (issue #404): its fields in
+ * `RigStop` order, `links` expanded from `chain` when omitted, and any records
+ * (`x-…`) or annotations (`note`, `…_note`) left out.
+ */
+export function stopForRig(s: ConfigStop, links: readonly string[]): RigStop {
+  return {
+    chain: s.chain,
+    links: [...links],
+    against: s.against,
+    at: [s.at[0], s.at[1]],
+    inward: s.inward,
+    outward: s.outward,
+    ...(s.lower === undefined ? {} : { lower: { inward: s.lower.inward, outward: s.lower.outward } }),
+  };
+}
+
 /** The single-value bone properties a sine track may drive — rigc's one-channel bone timelines. */
 export const SINGLE_PROPS = ['rotate', 'translatex', 'translatey', 'scalex', 'scaley', 'shearx', 'sheary'] as const;
 export type SingleProp = (typeof SINGLE_PROPS)[number];
@@ -992,7 +1031,7 @@ export interface AssembleConfig {
   bones?: BoneEntry[];
 }
 
-const TOP_KEYS = ['key', 'generation', 'seethrough', 'assemble', 'limbs', 'bones', 'meshes', 'regions', 'motion', 'constraints', 'turn', 'scene', 'cloth'] as const;
+const TOP_KEYS = ['key', 'generation', 'seethrough', 'assemble', 'limbs', 'bones', 'meshes', 'regions', 'motion', 'constraints', 'stops', 'turn', 'scene', 'cloth'] as const;
 
 /**
  * The one partial entry point. It validates exactly what its door requires —
@@ -1202,6 +1241,7 @@ function parseConfigFrom(raw: Json, base: string | null): { config: CharacterCon
   if ('meshes' in t && 'regions' in t && 'assemble' in t) checkCoverage(c, [...parts, ...cuts], patches, t.meshes, t.regions, limbs);
   if ('motion' in t) checkMotion(c, t.motion, names.bones, names.chains, 'regions' in t ? t.regions : undefined);
   if ('constraints' in t) checkConstraints(c, t.constraints, names.bones, names.parents);
+  if ('stops' in t) checkStops(c, t.stops, names.bones, names.chains);
   if ('turn' in t) checkTurn(c, t.turn, attachedParts(t.meshes, t.regions), names.bones);
   if ('scene' in t) checkScene(c, t.scene);
   if ('cloth' in t) checkCloth(c, t.cloth);
@@ -1374,9 +1414,9 @@ export interface SkeletonSections {
  * both before writing (`checkProposal`). A key the loader would not take is
  * refused by name, as in a config. Refusals name the fields `proposal.…`.
  */
-export function parseProposalSections(raw: Json): SkeletonSections & { limbs?: Record<string, Limb>; constraints?: ConfigConstraint[] } {
+export function parseProposalSections(raw: Json): SkeletonSections & { limbs?: Record<string, Limb>; constraints?: ConfigConstraint[]; stops?: ConfigStop[] } {
   const c = new Check();
-  const top = c.object('config', raw, ['bones', 'meshes', 'regions', 'motion'], ['notes', 'limbs', 'constraints']);
+  const top = c.object('config', raw, ['bones', 'meshes', 'regions', 'motion'], ['notes', 'limbs', 'constraints', 'stops']);
   if (top !== null) {
     const names = 'bones' in top ? checkBones(c, top.bones) : { bones: new Set<string>([ROOT_BONE]), chains: new Map<string, number>(), parents: new Map<string, string>() };
     if ('limbs' in top) {
@@ -1389,10 +1429,11 @@ export function parseProposalSections(raw: Json): SkeletonSections & { limbs?: R
     if ('regions' in top) checkRegions(c, top.regions, names.bones);
     if ('motion' in top) checkMotion(c, top.motion, names.bones, names.chains, 'regions' in top ? top.regions : undefined);
     if ('constraints' in top) checkConstraints(c, top.constraints, names.bones, names.parents);
+    if ('stops' in top) checkStops(c, top.stops, names.bones, names.chains);
     if ('notes' in top && c.array('config.notes', top.notes, false)) (top.notes as Json[]).forEach((n, i) => c.string(`config.notes[${i}]`, n, false));
   }
   refuseIfAny(c.problems.map((p) => ({ ...p, object: p.object.replace(/^config\b/, 'proposal') })));
-  return raw as SkeletonSections & { limbs?: Record<string, Limb>; constraints?: ConfigConstraint[] };
+  return raw as SkeletonSections & { limbs?: Record<string, Limb>; constraints?: ConfigConstraint[]; stops?: ConfigStop[] };
 }
 
 /**
@@ -2614,6 +2655,65 @@ function checkConstraints(c: Check, v: Json, bones: Set<string>, parents: Map<st
   });
 }
 
+/**
+ * `config.stops` (issue #404): rig-c 2.56.0's `RigStop` entries, each holding
+ * a swinging chain off a leg bone (`against`). `chain` resolves against the
+ * chains `config.bones` declares; `links` (when given) and `against` resolve
+ * against the bones `config.bones` declares (`CONFIG_NAME_RESOLVES`).
+ */
+function checkStops(c: Check, v: Json, bones: Set<string>, chains: Map<string, number>): void {
+  const p = 'config.stops';
+  if (!c.array(p, v, false)) return;
+  const declaredBones = [...bones].join(', ');
+  const declaredChains = [...chains.keys()].join(', ') || 'none';
+  (v as Json[]).forEach((entry, i) => {
+    const at = `${p}[${i}]`;
+    const o = c.object(at, entry, ['chain', 'against', 'at', 'inward', 'outward'], ['links', 'lower']);
+    if (o === null) return;
+    let chainLinks: number | undefined;
+    if ('chain' in o && c.string(`${at}.chain`, o.chain)) {
+      chainLinks = chains.get(o.chain);
+      if (chainLinks === undefined) {
+        c.fail('CONFIG_NAME_RESOLVES', `${at}.chain`, `names "${o.chain}", which config.bones does not declare as a chain; the chains that exist: ${declaredChains}`);
+      }
+    }
+    let linkCount = chainLinks ?? 0;
+    if ('links' in o && c.array(`${at}.links`, o.links, true)) {
+      const list = o.links as Json[];
+      linkCount = list.length;
+      list.forEach((l, k) => {
+        if (c.string(`${at}.links[${k}]`, l) && !bones.has(l)) {
+          c.fail('CONFIG_NAME_RESOLVES', `${at}.links[${k}]`, `names "${l}", which config.bones does not declare; the bones that exist: ${declaredBones}`);
+        }
+      });
+    }
+    if ('against' in o && c.string(`${at}.against`, o.against) && !bones.has(o.against)) {
+      c.fail('CONFIG_NAME_RESOLVES', `${at}.against`, `names "${o.against}", which config.bones does not declare; the bones that exist: ${declaredBones}`);
+    }
+    if ('at' in o) c.point(`${at}.at`, o.at);
+    const inward = 'inward' in o && c.number(`${at}.inward`, o.inward) ? (o.inward as number) : null;
+    const outward = 'outward' in o && c.number(`${at}.outward`, o.outward) ? (o.outward as number) : null;
+    if (inward !== null && outward !== null && inward > outward) {
+      c.fail('CONFIG_FIELD_TYPE', `${at}.inward`, `is ${inward}, above outward ${outward}; inward <= outward is required`);
+    }
+    if ('lower' in o) {
+      const lo = c.object(`${at}.lower`, o.lower, ['inward', 'outward'], []);
+      if (lo !== null) {
+        const li = 'inward' in lo && c.number(`${at}.lower.inward`, lo.inward) ? (lo.inward as number) : null;
+        const loOut = 'outward' in lo && c.number(`${at}.lower.outward`, lo.outward) ? (lo.outward as number) : null;
+        if (li !== null && loOut !== null && li > loOut) {
+          c.fail('CONFIG_FIELD_TYPE', `${at}.lower.inward`, `is ${li}, above lower.outward ${loOut}; inward <= outward is required`);
+        }
+      }
+      if (linkCount === 1) {
+        c.fail('CONFIG_FIELD_TYPE', `${at}.lower`, `is ${show(o.lower)} on a 1-link stop; lower holds the links below the first, so leave lower out when links has 1 bone`);
+      }
+    } else if (linkCount > 1) {
+      c.fail('CONFIG_FIELD_PRESENT', `${at}.lower`, `is absent and required when the stop holds ${linkCount} links (more than 1); state lower: { inward, outward } for the links below the first`);
+    }
+  });
+}
+
 /** The parts `meshes` and `regions` attach, read off whatever they hold; `turn.depths` may name only these. */
 function attachedParts(meshes: Json, regions: Json): Set<string> {
   const out = new Set<string>();
@@ -2700,10 +2800,11 @@ function checkCloth(c: Check, v: Json): void {
     const chains = 'chains' in r && c.int(`${path}.chains`, r.chains, 1) ? (r.chains as number) : null;
     const links = 'links' in r && c.int(`${path}.links`, r.links, 1) ? (r.links as number) : null;
     if ('split' in r) {
-      const sp = c.object(`${path}.split`, r.split, ['at', 'into'], []);
+      const sp = c.object(`${path}.split`, r.split, ['at', 'into'], ['hold_tip']);
       if (sp !== null) {
         const sAt = 'at' in sp && c.int(`${path}.split.at`, sp.at, 1) ? (sp.at as number) : null;
         if ('into' in sp) c.int(`${path}.split.into`, sp.into, 2);
+        if ('hold_tip' in sp && typeof sp.hold_tip !== 'boolean') c.fail('CONFIG_FIELD_TYPE', `${path}.split.hold_tip`, `is ${show(sp.hold_tip)}; true or false is required`);
         if (sAt !== null && links !== null && sAt >= links) {
           c.fail('CONFIG_CLOTH_SPLIT_BEFORE_TIP', `${path}.split.at`, `is ${sAt} and links is ${links}; the trunk's ${sAt} link(s) would leave no link for the branches — split.at below links is required`);
         }

package/src/instruments.ts

@@ -137,6 +137,38 @@ export function heatField(frames: readonly Raster[]): Uint8Array {
   return d;
 }
 
+/**
+ * The breath alone (issue #411): each pixel's largest per-channel RGB change
+ * that the breath makes, read off the idle rendered twice on one grid — with
+ * its breath tracks (`withBreath`) and without them (`withoutBreath`). At
+ * frame t the breath's own change at a pixel is (with_t - with_0) -
+ * (without_t - without_0): motion that is the same in both renders (a keyed
+ * cloth swing, a physics response to the world, a head turn) cancels, and so
+ * does a constant offset the breath holds from frame 0 on, while physics that
+ * the breath sets moving stays. The field is that change's largest magnitude
+ * over the frames and the three channels, capped at 255 — {@link heatField}'s
+ * reading when the render without the breath does not move. Both lists hold
+ * the same number of frames of one size; the caller holds the grid.
+ */
+export function breathHeat(withBreath: readonly Raster[], withoutBreath: readonly Raster[]): Uint8Array {
+  const w0 = withBreath[0].data;
+  const o0 = withoutBreath[0].data;
+  const n = withBreath[0].width * withBreath[0].height;
+  const d = new Uint8Array(n);
+  withBreath.forEach((f, i) => {
+    const w = f.data;
+    const o = withoutBreath[i].data;
+    for (let p = 0; p < n; p++) {
+      for (let c = 0; c < 3; c++) {
+        const k = p * 4 + c;
+        const v = Math.min(255, Math.abs(w[k] - w0[k] - (o[k] - o0[k])));
+        if (v > d[p]) d[p] = v;
+      }
+    }
+  });
+  return d;
+}
+
 export interface RegionHeat {
   /** Pixels measured. */
   px: number;

package/src/limbs.ts

@@ -81,6 +81,17 @@
  *   cap's disc and the limb's width stay where the bone's origin puts them;
  *   only the line that splits the pixels between the two pieces moves, and
  *   the cap takes the disc's pixels on the upper side of that line.
+ * - **Overlapping hands** (issue #400, {@link assignOverlappingHands}). When
+ *   two forearm segments (`joint: "elbow"`, with a wrist end) share a part,
+ *   each hand's keypoint region is the disc of radius half its forearm's
+ *   length (`L / 2`) about its wrist, and its cuff is the line across the
+ *   forearm at `L - L / 2 = L / 2` from the elbow, where that disc meets the
+ *   bone's axis. When the two hand discs overlap, the overlapping hand region
+ *   goes to the front piece (the limb `config.limbs` declares later, which
+ *   `limbOrder` draws in front) in one piece, and the back piece ends at its
+ *   cuff; any 4-connected island on a forearm piece that leaves its own hand's
+ *   keypoint region is transferred to the other forearm piece, so no slivers
+ *   are cut out of the front hand for the back arm.
  */
 import type { BoneEntry, Limb } from './config.ts';
 
@@ -429,3 +440,163 @@ export function capBox(at: Pt, radius: number): [number, number, number, number]
 export function inDisc(at: Pt, radius: number, px: number, py: number): boolean {
   return (px + 0.5 - at[0]) ** 2 + (py + 0.5 - at[1]) ** 2 <= radius * radius;
 }
+
+/** A forearm segment on a shared part, for {@link assignOverlappingHands} (issue #400). */
+export interface ForearmShare {
+  /** The limb's index in `Object.keys(limbs)`. */
+  limb: number;
+  /** The forearm segment's index in `limbs[limb].segments`. */
+  seg: number;
+  /** The elbow bone origin, in rig px. */
+  elbow: Pt;
+  /** The wrist bone end (`tip`), in rig px. */
+  wrist: Pt;
+  /** Whether pixel `(x, y)` on `limb` falls on this forearm segment (`segmentOf === seg`). */
+  isSeg: (x: number, y: number) => boolean;
+}
+
+/**
+ * Issue #400: when two forearm segments (`back` and `front`, in `config.limbs`
+ * order so `front` is drawn over `back`) share a part, each hand's keypoint
+ * region is the disc of radius `r = L / 2` about its wrist (`L` the forearm
+ * bone's length), and `back`'s cuff is the line across the forearm at
+ * `L - r = L / 2` from `back.elbow`. When the two wrist discs overlap, `back`'s
+ * pixels past its cuff (or inside `front`'s hand disc) go to `front`'s forearm
+ * in one piece so `back` ends at its cuff; and any 4-connected island on a
+ * forearm piece that leaves its own hand's keypoint region goes to the other
+ * forearm piece. Mutates `own` and `segOverride` in place.
+ */
+export function assignOverlappingHands(back: ForearmShare, front: ForearmShare, W: number, H: number, own: Int32Array, segOverride: Int32Array): void {
+  const dx0 = back.wrist[0] - back.elbow[0];
+  const dy0 = back.wrist[1] - back.elbow[1];
+  const L0 = Math.sqrt(dx0 * dx0 + dy0 * dy0);
+  const dx1 = front.wrist[0] - front.elbow[0];
+  const dy1 = front.wrist[1] - front.elbow[1];
+  const L1 = Math.sqrt(dx1 * dx1 + dy1 * dy1);
+  if (L0 === 0 || L1 === 0) return;
+  const r0 = L0 / 2;
+  const r1 = L1 / 2;
+  const u0x = dx0 / L0;
+  const u0y = dy0 / L0;
+  const cuff0 = L0 - r0;
+  const proj0 = (x: number, y: number): number => (x + 0.5 - back.elbow[0]) * u0x + (y + 0.5 - back.elbow[1]) * u0y;
+  const onSeg = (f: ForearmShare, p: number): boolean => own[p] === f.limb && (segOverride[p] === f.seg || (segOverride[p] === -1 && f.isSeg(p % W, Math.floor(p / W))));
+  const wristsOverlap = (back.wrist[0] - front.wrist[0]) ** 2 + (back.wrist[1] - front.wrist[1]) ** 2 <= (r0 + r1) ** 2;
+  if (wristsOverlap) {
+    let cuffHasArt = false;
+    for (let y = 0; y < H && !cuffHasArt; y++) {
+      for (let x = 0; x < W && !cuffHasArt; x++) {
+        if (onSeg(back, y * W + x) && proj0(x, y) <= cuff0) cuffHasArt = true;
+      }
+    }
+    if (cuffHasArt) {
+      for (let y = 0; y < H; y++) {
+        for (let x = 0; x < W; x++) {
+          const p = y * W + x;
+          if (onSeg(back, p) && (proj0(x, y) > cuff0 || inDisc(front.wrist, r1, x, y)) && !inDisc(back.elbow, r0 / 2, x, y)) {
+            own[p] = front.limb;
+            segOverride[p] = front.seg;
+          } else if (own[p] === back.limb && inDisc(front.wrist, r1, x, y) && !inDisc(back.elbow, r0, x, y)) {
+            own[p] = front.limb;
+            segOverride[p] = front.seg;
+          }
+        }
+      }
+    }
+  }
+  const componentsOf = (f: ForearmShare): number[][] => {
+    const seen = new Uint8Array(W * H);
+    const comps: number[][] = [];
+    for (let p = 0; p < W * H; p++) {
+      if (seen[p] === 1 || !onSeg(f, p)) continue;
+      seen[p] = 1;
+      const comp: number[] = [p];
+      for (let h = 0; h < comp.length; h++) {
+        const q = comp[h];
+        const x = q % W;
+        const y = (q - x) / W;
+        for (const [nx, ny] of [
+          [x - 1, y],
+          [x + 1, y],
+          [x, y - 1],
+          [x, y + 1],
+        ]) {
+          if (nx < 0 || ny < 0 || nx >= W || ny >= H) continue;
+          const np = ny * W + nx;
+          if (seen[np] === 0 && onSeg(f, np)) {
+            seen[np] = 1;
+            comp.push(np);
+          }
+        }
+      }
+      comps.push(comp);
+    }
+    return comps;
+  };
+  const elbowDist2 = (comp: readonly number[], elbow: Pt): number => {
+    let best = Infinity;
+    for (const p of comp) {
+      const x = p % W;
+      const y = (p - x) / W;
+      const d = (x + 0.5 - elbow[0]) ** 2 + (y + 0.5 - elbow[1]) ** 2;
+      if (d < best) best = d;
+    }
+    return best;
+  };
+  const backComps = componentsOf(back);
+  if (backComps.length > 1) {
+    let main = 0;
+    let mainD = elbowDist2(backComps[0], back.elbow);
+    for (let i = 1; i < backComps.length; i++) {
+      const d = elbowDist2(backComps[i], back.elbow);
+      if (d < mainD) {
+        mainD = d;
+        main = i;
+      }
+    }
+    backComps.forEach((comp, i) => {
+      if (i === main) return;
+      const leavesBack = comp.some((p) => !inDisc(back.wrist, r0, p % W, Math.floor(p / W)));
+      const inFront = comp.some((p) => inDisc(front.wrist, r1, p % W, Math.floor(p / W)));
+      if (wristsOverlap || leavesBack || inFront) {
+        for (const p of comp) {
+          own[p] = front.limb;
+          segOverride[p] = front.seg;
+        }
+      }
+    });
+  }
+  const frontComps = componentsOf(front);
+  if (frontComps.length > 1) {
+    let main = 0;
+    let mainD = elbowDist2(frontComps[0], front.elbow);
+    for (let i = 1; i < frontComps.length; i++) {
+      const d = elbowDist2(frontComps[i], front.elbow);
+      if (d < mainD) {
+        mainD = d;
+        main = i;
+      }
+    }
+    frontComps.forEach((comp, i) => {
+      if (i === main) return;
+      const leavesFront = comp.some((p) => !inDisc(front.wrist, r1, p % W, Math.floor(p / W)));
+      const touchesBack = comp.some((p) => {
+        const x = p % W;
+        const y = (p - x) / W;
+        return (
+          (x > 0 && onSeg(back, p - 1)) ||
+          (x + 1 < W && onSeg(back, p + 1)) ||
+          (y > 0 && onSeg(back, p - W)) ||
+          (y + 1 < H && onSeg(back, p + W))
+        );
+      });
+      if (leavesFront && touchesBack) {
+        for (const p of comp) {
+          own[p] = back.limb;
+          segOverride[p] = back.seg;
+        }
+      }
+    });
+  }
+}
+