@rig-c/parts 1.28.0 → 1.30.0

package/src/propose.ts

@@ -127,7 +127,8 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { drawText, GLYPH_H } from 'rig-c/tools/font5x7.ts';
-import { type BoneEntry, type ConfigConstraint, type Limb, type MeshSpec, parseConfig, type Point, type Segment, type SkeletonSections } from './config.ts';
+import { type BoneEntry, type ConfigConstraint, type ConfigStop, type Limb, type MeshSpec, parseConfig, type Point, type Segment, type SkeletonSections } from './config.ts';
+import { computeExactFrameTransforms, cropToSpineY, normaliseDegrees, toWorld } from './coords.ts';
 import { PartsError, type Problem, refuseIfAny } from './errors.ts';
 import { eyeLineDegrees, type FrameFeature, headAxes, type HeadAxes, headFrame, type HeadFrame } from './headframe.ts';
 import { type LayerSet, OPAQUE_ALPHA_ABOVE } from './layers.ts';
@@ -146,9 +147,9 @@ import { configRoles, type RoleOf } from './structure.ts';
 import { AUTHOR_NO_ROLE, isAuthorTag } from './tags.ts';
 import { TURN_BONE, TURN_CARRIER_TAG, TURN_PLACES, TURN_RIDER_OFFSET, TURN_RIDER_TAGS, turnFractions, turnNearest, turnPivot, turnRiderDepth, type TurnSpec } from './turn.ts';
 import { edgeLength } from './length.ts';
-import { limbWidth } from './limbs.ts';
+import { bonePlaces, limbCrossing, limbPolyline, limbWidth } from './limbs.ts';
 import { type BranchSqueezeFinding, branchSqueezes, chainSqueezes, type SqueezeFinding } from './squeeze.ts';
-import { RECIPE_BACK_HAIR_CHAINS, RECIPE_LENGTH_RATIO, chainConstraints, clothNote, type ClothRecipe, type ClothRecipes, type ClothTarget, CLOTH_TARGETS, draftTrees, spanCrosses, swingName, type Tail, tailOverlap, type TailOverlap, type TailSpan, treeConstraints, type TreeChain, type TreeInput } from './cloth.ts';
+import { backHairMasses, type BackHairMass, RECIPE_BACK_HAIR_CHAINS, RECIPE_LENGTH_RATIO, chainConstraints, clothNote, type ClothRecipe, type ClothRecipes, type ClothTarget, CLOTH_TARGETS, draftTrees, spanCrosses, swingName, type Tail, tailOverlap, type TailOverlap, type TailSpan, treeConstraints, type TreeChain, type TreeInput, type TreeMassInput } from './cloth.ts';
 import { TEXTURE_STRETCH_CEILING } from './check.ts';
 
 // ---------------------------------------------------------------------------
@@ -397,6 +398,7 @@ function konst(name: string, value: number): BasisConstant {
  * plan part and which as the piece (issue #230).
  */
 export function proposalAssemble(P: PartSet): Record<string, unknown> {
+  P = P.beforeLimbs();
   // A patch is not a plan entry; it goes back as the patches entry it came
   // from, so the loader holds it to its own rule (a region, never a mesh).
   // Its box, alpha and draw are the record's own box and placeholders the
@@ -492,6 +494,7 @@ export type TurnRuns = Partial<Record<'full' | 'head', LayerSet>>;
  * span away.
  */
 export function draftTurn(P: PartSet, runs: TurnRuns): { turn: TurnSpec | null; notes: string[] } {
+  P = P.beforeLimbs();
   const problems: Problem[] = [];
   const read: Array<{ part: string; run: 'full' | 'head'; tag: string; base: string | null; own: number; area: number; order: number; piece: boolean }> = [];
   const patches: string[] = [];
@@ -629,6 +632,7 @@ export class PartSet {
   readonly recs: readonly PartRecord[];
   readonly images: ReadonlyMap<string, Raster>;
   private readonly masks = new Map<string, Mask>();
+  private preLimbs: PartSet | null = null;
 
   constructor(file: PartsFile, images: ReadonlyMap<string, Raster>) {
     [this.W, this.H] = file.rig_size;
@@ -664,6 +668,170 @@ export class PartSet {
     return [...by.entries()].filter(([, names]) => names.length > 1).map(([from, parts]) => ({ from, parts }));
   }
 
+  /**
+   * Issue #440: limb records (`r.limb !== undefined`) that cannot be reassembled
+   * into their pre-limb source parts (`r.limb.of`) — a limb part handed to
+   * `propose` on its own or with an incomplete segment chain (fewer than two
+   * segments, a segment index missing from `0..n-1`, a lower segment without
+   * its `cap` record, or the source part `of` still present beside the limb
+   * parts). When every limb in `parts.json` is complete, returns `[]` and
+   * {@link beforeLimbs} reconstructs the pre-limb part set.
+   */
+  standaloneLimbParts(): PartRecord[] {
+    const limbed = this.recs.filter((r) => r.limb !== undefined);
+    if (limbed.length === 0) return [];
+    const nonLimbNames = new Set(this.recs.filter((r) => r.limb === undefined).map((r) => r.name));
+    const byLimb = new Map<string, PartRecord[]>();
+    for (const r of limbed) {
+      const l = r.limb as NonNullable<PartRecord['limb']>;
+      byLimb.set(l.name, [...(byLimb.get(l.name) ?? []), r]);
+    }
+    const badLimbs = new Set<string>();
+    const badOf = new Set<string>();
+    for (const [name, segs] of byLimb) {
+      const sorted = [...segs].sort((a, b) => (a.limb?.segment ?? 0) - (b.limb?.segment ?? 0));
+      const complete =
+        sorted.length >= 2 &&
+        sorted.every((s, i) => {
+          const l = s.limb as NonNullable<PartRecord['limb']>;
+          return l.segment === i && (i === 0 ? l.cap === undefined : l.cap !== undefined) && !nonLimbNames.has(l.of);
+        });
+      if (!complete) {
+        badLimbs.add(name);
+        for (const s of segs) badOf.add((s.limb as NonNullable<PartRecord['limb']>).of);
+      }
+    }
+    return limbed.filter((r) => {
+      const l = r.limb as NonNullable<PartRecord['limb']>;
+      return badLimbs.has(l.name) || badOf.has(l.of);
+    });
+  }
+
+  /**
+   * Issue #440: when `parts.json` came from an `assemble` run with `config.limbs`
+   * (every limb complete, {@link standaloneLimbParts} empty), reconstruct the
+   * pre-limb part set so `propose`, `draftTurn`, `checkProposal` and
+   * `checkBasis` read the whole layer each limb took in a single run. Without
+   * limb records (or when a standalone limb part will be refused by
+   * `PROPOSE_LIMB_PARTS`), returns `this`.
+   */
+  beforeLimbs(): PartSet {
+    if (this.preLimbs !== null) return this.preLimbs;
+    if (!this.recs.some((r) => r.limb !== undefined) || this.standaloneLimbParts().length > 0) {
+      this.preLimbs = this;
+      return this;
+    }
+    const segsByOf = new Map<string, PartRecord[]>();
+    const segByLimb = new Map<string, PartRecord>();
+    for (const r of this.recs) {
+      if (r.limb === undefined) continue;
+      segsByOf.set(r.limb.of, [...(segsByOf.get(r.limb.of) ?? []), r]);
+      segByLimb.set(`${r.limb.name}:${r.limb.segment}`, r);
+    }
+    const buildOf = (ofName: string): { rec: PartRecord; raster: Raster } => {
+      const segs = segsByOf.get(ofName) as PartRecord[];
+      const union = new Uint8Array(this.W * this.H);
+      for (const s of segs) {
+        const m = this.alpha(s);
+        const l = s.limb as NonNullable<PartRecord['limb']>;
+        const up = l.segment > 0 ? segByLimb.get(`${l.name}:${l.segment - 1}`) : undefined;
+        const dropUpperCap = up !== undefined && up.limb?.of !== ofName && (l.cap?.upper_px ?? 0) > 0 && (l.cap?.layer_px ?? 0) === 0 ? this.alpha(up) : null;
+        const box = l.cap?.box;
+        for (let y = s.y; y < s.y + s.h; y++) {
+          for (let x = s.x; x < s.x + s.w; x++) {
+            const p = y * this.W + x;
+            if (!m.data[p]) continue;
+            if (dropUpperCap !== null && box !== undefined && x >= box[0] && x < box[0] + box[2] && y >= box[1] && y < box[1] + box[3] && dropUpperCap.data[p]) continue;
+            union[p] = 1;
+          }
+        }
+      }
+      let x0 = this.W;
+      let y0 = this.H;
+      let x1 = -1;
+      let y1 = -1;
+      let opaquePx = 0;
+      for (let y = 0; y < this.H; y++) {
+        for (let x = 0; x < this.W; x++) {
+          if (!union[y * this.W + x]) continue;
+          if (x < x0) x0 = x;
+          if (x > x1) x1 = x;
+          if (y < y0) y0 = y;
+          if (y > y1) y1 = y;
+          opaquePx++;
+        }
+      }
+      const first = segs[0];
+      if (x1 < x0) {
+        x0 = first.x;
+        y0 = first.y;
+        x1 = first.x + first.w - 1;
+        y1 = first.y + first.h - 1;
+      }
+      const w = x1 - x0 + 1;
+      const h = y1 - y0 + 1;
+      const raster = newRaster(w, h);
+      for (let y = 0; y < h; y++) {
+        for (let x = 0; x < w; x++) {
+          if (union[(y0 + y) * this.W + x0 + x]) raster.data[(y * w + x) * 4 + 3] = 255;
+        }
+      }
+      const sum = (f: (r: PartRecord) => number): number => segs.reduce((acc, r) => acc + f(r), 0);
+      const hasVis = segs.every((r) => r.visible_px !== undefined && r.occluded_px !== undefined);
+      const rec: PartRecord = {
+        name: ofName,
+        from: first.from,
+        ...(first.cut_from === undefined ? {} : { cut_from: first.cut_from }),
+        x: x0,
+        y: y0,
+        w,
+        h,
+        opaque_px: opaquePx,
+        ...(hasVis ? { visible_px: sum((r) => r.visible_px as number), occluded_px: sum((r) => r.occluded_px as number) } : {}),
+        projected_core_px: sum((r) => r.projected_core_px),
+        source_px_taken: sum((r) => r.source_px_taken),
+        ...(segs.some((r) => r.visible_not_projected_px !== undefined) ? { visible_not_projected_px: sum((r) => r.visible_not_projected_px ?? 0) } : {}),
+        refused_drift_px: sum((r) => r.refused_drift_px),
+        merged_px: sum((r) => r.merged_px),
+        seam_override_px: sum((r) => r.seam_override_px),
+      };
+      return { rec, raster };
+    };
+    const recs: PartRecord[] = [];
+    const images = new Map<string, Raster>();
+    const emittedOf = new Set<string>();
+    for (const r of this.recs) {
+      if (r.limb === undefined) {
+        recs.push(r);
+        const im = this.images.get(r.name);
+        if (im !== undefined) images.set(r.name, im);
+        continue;
+      }
+      const seg0 = segByLimb.get(`${r.limb.name}:0`) as PartRecord;
+      const rootOf = (seg0.limb as NonNullable<PartRecord['limb']>).of;
+      if (emittedOf.has(rootOf)) continue;
+      const groupLimbs = new Set(
+        this.recs.filter((q) => q.limb !== undefined && q.limb.segment === 0 && q.limb.of === rootOf).map((q) => (q.limb as NonNullable<PartRecord['limb']>).name),
+      );
+      const minSegByOf = new Map<string, number>();
+      for (const q of this.recs) {
+        if (q.limb === undefined || !groupLimbs.has(q.limb.name)) continue;
+        const prev = minSegByOf.get(q.limb.of);
+        if (prev === undefined || q.limb.segment < prev) minSegByOf.set(q.limb.of, q.limb.segment);
+      }
+      const orderedOfs = [...minSegByOf.entries()].sort((a, b) => a[1] - b[1]).map(([n]) => n);
+      for (const ofName of orderedOfs) {
+        if (emittedOf.has(ofName)) continue;
+        emittedOf.add(ofName);
+        const built = buildOf(ofName);
+        recs.push(built.rec);
+        images.set(ofName, built.raster);
+      }
+    }
+    this.preLimbs = new PartSet({ rig_size: [this.W, this.H], scale_rig_per_source: this.rigScale, ghost_px: {}, parts: recs }, images);
+    return this.preLimbs;
+  }
+
   /** The See-through parts: every part but the `painting:` patches. */
   layered(): PartRecord[] {
     return this.recs.filter((p) => splitFrom(p.from)[0] !== PAINTING_RUN);
@@ -1226,8 +1394,10 @@ export function proposeWithBasis(
       detail: `share one layer and none of them records cut_from, so which is the plan part and which the piece an assemble.cuts entry took cannot be read off parts.json (it is in draw order, and a piece drawn "back" comes before its base); re-run assemble (1.6.0+) to record cut_from`,
     })),
   );
-  // Issue #349: limbs are drafted from the parts before their cut — the layer each limb takes is what the rules read.
-  const limbed = P.recs.filter((r) => r.limb !== undefined);
+  // Issue #349, #440: limbs are drafted from the parts before their cut — a complete assemble with config.limbs
+  // reconstructs its pre-limb parts here in the same run; a standalone or incomplete limb part handed to propose
+  // on its own is refused by name.
+  const limbed = P.standaloneLimbParts();
   refuseIfAny(
     limbed.length === 0
       ? []
@@ -1235,10 +1405,11 @@ export function proposeWithBasis(
           {
             code: 'PROPOSE_LIMB_PARTS',
             object: `parts ${limbed.map((r) => `"${r.name}"`).join(', ')}`,
-            detail: `were cut at their joints by config.limbs (from ${[...new Set(limbed.map((r) => `"${(r.limb as NonNullable<PartRecord['limb']>).of}"`))].join(', ')}), and propose drafts the limbs from the parts before the cut; assemble with the config's limbs left out, propose from that build, and keep the limbs block (and any caps, ranges) the config already holds — or read the config's bones with propose --from-config`,
+            detail: `were cut at their joints by config.limbs (from ${[...new Set(limbed.map((r) => `"${(r.limb as NonNullable<PartRecord['limb']>).of}"`))].join(', ')}), and propose drafts the limbs from the whole layer each limb takes; hand propose the complete assemble output (every segment of each limb, with its cap record) so the source part can be reconstructed in one run, or assemble with config.limbs left out — or read the config's bones with propose --from-config`,
           },
         ],
   );
+  P = P.beforeLimbs();
   const bones: BoneEntry[] = [];
   const records: BoneBasis[] = [];
   /** Issue #349: the limbs `--keypoints` drafts, and the parts they take (not made, so not given a mesh or a region). */
@@ -1403,7 +1574,7 @@ export function proposeWithBasis(
   const T = (p: PartRecord | readonly PartRecord[], tag: ClothTarget, r: ClothRecipe, input: TreeInput): TreeChain[] => {
     const partNames = Array.isArray(p) ? p.map((x) => x.name) : [(p as PartRecord).name];
     const trees = draftTrees(input, r);
-    const constants = [konst('cloth_chains', r.chains ?? RECIPE_BACK_HAIR_CHAINS), konst('cloth_links', r.links), konst('length_ratio', roundTo(r.length_ratio ?? RECIPE_LENGTH_RATIO, 6))];
+    const constants = [konst('cloth_chains', input.masses !== undefined ? input.masses.length : (r.chains ?? RECIPE_BACK_HAIR_CHAINS)), konst('cloth_links', r.links), konst('length_ratio', roundTo(r.length_ratio ?? RECIPE_LENGTH_RATIO, 6))];
     for (const t of trees) {
       C(
         t.chain,
@@ -1673,27 +1844,45 @@ export function proposeWithBasis(
         ]);
       }
     }
-    const rcp: ClothRecipe = { ...rawRcp, chains: rawRcp.chains ?? Math.min(RECIPE_BACK_HAIR_CHAINS, maxFit) };
+    const massesBySide = new Map<'r' | 'l', BackHairMass[]>(activeSides.map(([s]) => [s, backHairMasses(unionMask, s, axis, y0, shoulderLine, g)]));
+    const useMasses = rawRcp.chains === undefined;
     const all: TreeChain[] = [];
     let n = 0;
     const partNamesLabel = list.map((q) => q.name).join(' -> ');
     for (const [side] of activeSides) {
       const prefix = prefixOf(side);
-      const trees = T(list, 'back hair', rcp, {
+      const sideMasses = massesBySide.get(side) ?? [];
+      if (useMasses && sideMasses.length === 0) continue;
+      const sideRcp: ClothRecipe = { ...rawRcp, chains: useMasses ? sideMasses.length : (rawRcp.chains ?? Math.min(RECIPE_BACK_HAIR_CHAINS, maxFit)) };
+      const frame = `${partNamesLabel}'s art on the ${side} side of the eye axis (no art there in the band: the eye axis x)`;
+      const trees = T(list, 'back hair', sideRcp, {
         prefix,
         parent: 'head',
         rootY: eyeY,
         tipY: bot - 4,
         xAt: (y, f) => bandX(unionMask, y, { frac: f, side, axis }),
         fallbackX: () => axis,
-        frame: `${partNamesLabel}'s art on the ${side} side of the eye axis (no art there in the band: the eye axis x)`,
+        frame,
         edges: side,
+        masses: useMasses
+          ? sideMasses.map((m): TreeMassInput => ({
+              rootY: m.minY <= y0 ? eyeY : m.minY,
+              tipY: m.maxY >= bot - 12 ? bot - 4 : Math.max(m.minY + 4, m.maxY - 3),
+              xAt: (y, f) => bandX(m.mask, y, { frac: f, side, axis }),
+              fallbackX: m.minY <= y0 && sideMasses.length === 1 ? () => axis : (f) => pyRound(m.minX + f * (m.maxX - m.minX)),
+              frame,
+            }))
+          : undefined,
       });
-      const made = treeConstraints(trees, rcp, null);
+      const made = treeConstraints(trees, sideRcp, null);
       clothConstraints.push(...made);
       n += made.length;
       all.push(...trees);
     }
+    const rcp: ClothRecipe = {
+      ...rawRcp,
+      chains: useMasses ? Math.max(1, ...(activeSides.map(([s]) => (massesBySide.get(s) ?? []).length))) : (rawRcp.chains ?? Math.min(RECIPE_BACK_HAIR_CHAINS, maxFit)),
+    };
     const spans: Array<TailSpan & { depth: number }> = [{ bone: 'head', a: rnd(head), b: rnd([axis, top + 13]), link: false, depth: -1 }];
     for (const t of all) {
       const line = [...t.points, t.tip];
@@ -1778,9 +1967,11 @@ export function proposeWithBasis(
     } else if (recipeOf('back hair') !== null && (backHairParts === null || backHairSingleSame)) {
       // Issue #364: the recipe's trees, per side of the eye axis (twin tails are a side each), from the eye line to
       // 4 px above the part's bottom, in place of the two keyed chains.
-      // Issue #390: the tree count per side derives from the tail's opaque width at the root row (`floor(width / grid)`
-      // on each side, and every tree root inside the 15 px dilated art); a declared count that does not fit is refused
-      // by name (`PROPOSE_CLOTH_BACK_HAIR_CHAINS`).
+      // Issue #390: an explicit tree count per side that exceeds `floor(width / grid)` at the root row or roots a tree
+      // outside the 15 px dilated art is refused by name (`PROPOSE_CLOTH_BACK_HAIR_CHAINS`).
+      // Issue #445: when `chains` is omitted, the tree count on each side is the number of visible hair masses on that
+      // side (connected components below the root row, merged within one grid cell), one tree per mass, rooted at that
+      // mass's top row and inside its columns.
       const rawRcp = recipeOf('back hair') as ClothRecipe;
       const mask = P.alpha(p);
       const dilated = dilate(mask, 31);
@@ -1835,30 +2026,66 @@ export function proposeWithBasis(
           ]);
         }
       }
-      const rcp: ClothRecipe = { ...rawRcp, chains: rawRcp.chains ?? Math.min(RECIPE_BACK_HAIR_CHAINS, maxFit) };
+      const shoulderLine = neckY + 0.5 * fh;
+      const rMasses = backHairMasses(mask, 'r', axis, y0, shoulderLine, g);
+      const lMasses = backHairMasses(mask, 'l', axis, y0, shoulderLine, g);
+      const massesBySide = new Map<'r' | 'l', BackHairMass[]>([
+        ['r', rMasses],
+        ['l', lMasses],
+      ]);
+      const useMasses = rawRcp.chains === undefined;
       const segs: Segment[] = [['head', rnd(head), rnd([axis, top + 13])]];
       const all: TreeChain[] = [];
       let n = 0;
       for (const [side] of SIDES) {
         const prefix = prefixOf(side);
-        const trees = T(p, 'back hair', rcp, {
+        const sideMasses = massesBySide.get(side) ?? [];
+        if (useMasses && sideMasses.length === 0) continue;
+        const sideRcp: ClothRecipe = { ...rawRcp, chains: useMasses ? sideMasses.length : (rawRcp.chains ?? Math.min(RECIPE_BACK_HAIR_CHAINS, maxFit)) };
+        const frame = `${p.name}'s art on the ${side} side of the eye axis (no art there in the band: the eye axis x)`;
+        const trees = T(p, 'back hair', sideRcp, {
           prefix,
           parent: 'head',
           rootY: eyeY,
           tipY: bot - 4,
           xAt: (y, f) => bandX(mask, y, { frac: f, side, axis }),
           fallbackX: () => axis,
-          frame: `${p.name}'s art on the ${side} side of the eye axis (no art there in the band: the eye axis x)`,
+          frame,
           edges: side,
+          masses: useMasses
+            ? sideMasses.map((m): TreeMassInput => ({
+                rootY: m.minY <= y0 ? eyeY : m.minY,
+                tipY: m.maxY >= bot - 12 ? bot - 4 : Math.max(m.minY + 4, m.maxY - 3),
+                xAt: (y, f) => bandX(m.mask, y, { frac: f, side, axis }),
+                fallbackX: m.minY <= y0 && sideMasses.length === 1 ? () => axis : (f) => pyRound(m.minX + f * (m.maxX - m.minX)),
+                frame,
+              }))
+            : undefined,
         });
         for (const t of trees) segs.push(t.chain);
-        const made = treeConstraints(trees, rcp, null);
+        const made = treeConstraints(trees, sideRcp, null);
         clothConstraints.push(...made);
         n += made.length;
         all.push(...trees);
       }
-      notes.push(clothNote(p.name, 'back hair', all, rcp, n, ' per side of the eye axis, from head, rooted on the eye line and tipped 4 px above its bottom'));
-      meshes[p.name] = { grid: g, r: rcp.split?.hold_tip === true ? Math.max(r, g) : r, segments: segs };
+      const sameSideCounts = !useMasses || rMasses.length === lMasses.length;
+      const noteRcp: ClothRecipe = {
+        ...rawRcp,
+        chains: useMasses ? (sameSideCounts ? rMasses.length : rMasses.length + lMasses.length) : (rawRcp.chains ?? Math.min(RECIPE_BACK_HAIR_CHAINS, maxFit)),
+      };
+      notes.push(
+        clothNote(
+          p.name,
+          'back hair',
+          all,
+          noteRcp,
+          n,
+          sameSideCounts
+            ? ' per side of the eye axis, from head, rooted on the eye line and tipped 4 px above its bottom'
+            : ` (${rMasses.length} on the r side and ${lMasses.length} on the l side of the eye axis, one per visible hair mass), from head, rooted on each mass's top row and tipped 4 px above its bottom`,
+        ),
+      );
+      meshes[p.name] = { grid: g, r: rawRcp.split?.hold_tip === true ? Math.max(r, g) : r, segments: segs };
       // Issue #391: the spans are this mesh's segments, the head's fixed one and every tree link, in segment order.
       const spans: TailSpan[] = [{ bone: 'head', a: rnd(head), b: rnd([axis, top + 13]), link: false }];
       for (const t of all) {
@@ -2574,17 +2801,118 @@ export function proposeWithBasis(
       hangs: `${p.name} (${p.from}): its art starts ${pyFixed(artTop - chestAt, 1)} px below chest's origin, so it hangs from the waist — its mesh takes the hip line and its skirt chains, no chest segment, and the breath does not carry its root`,
     };
   };
-  // Where the recipe's trees hang on a skirt: from 20 px below the hip to 4 px above the part's bottom, across its art.
-  const skirtInput = (p: PartRecord, mask: Mask, prefix: string): TreeInput => ({
-    prefix,
-    parent: 'hip',
-    rootY: hip[1] + 20,
-    tipY: p.y + p.h - 4,
-    xAt: (y, f) => bandX(mask, y, { frac: f }),
-    fallbackX: (f) => p.x + f * p.w,
-    frame: `${p.name}'s art (no art in the band: that share of its box's width)`,
-    edges: 'both',
-  });
+  // Where the recipe's trees hang on a skirt: from 20 px below the hip to 4 px above the cloth's bottom under each column, across its art.
+  const skirtInput = (p: PartRecord, mask: Mask, prefix: string, r: ClothRecipe, bot = p.y + p.h, emitNotes = true): TreeInput => {
+    const y0 = hip[1] + 20;
+    const y0Int = Math.max(0, pyInt(y0));
+    const botInt = Math.min(mask.height, pyInt(bot));
+    const n = r.chains ?? RECIPE_BACK_HAIR_CHAINS;
+    const into = r.split === undefined ? 1 : r.split.into;
+    const traceLastOpaqueY = (f: number): number => {
+      let lastY = -1;
+      for (let y = y0Int; y < botInt; y++) {
+        const bx = bandX(mask, y, { frac: f }) ?? p.x + f * p.w;
+        const rx = Math.max(0, Math.min(mask.width - 1, pyRound(bx)));
+        if (mask.data[y * mask.width + rx] !== 0) {
+          lastY = y;
+        } else if (lastY >= y0Int) {
+          let gapContinues = false;
+          for (let yy = y + 1; yy <= Math.min(botInt - 1, y + 12); yy++) {
+            if (mask.data[yy * mask.width + rx] !== 0) {
+              gapContinues = true;
+              break;
+            }
+          }
+          if (!gapContinues) break;
+        }
+      }
+      return lastY;
+    };
+    const shares: number[] = [];
+    for (let k = 0; k < n; k++) {
+      shares.push((k + 0.5) / n);
+      if (into > 1) {
+        for (let b = 0; b < into; b++) shares.push((k + (b + 0.5) / into) / n);
+      }
+    }
+    const uniformBottom = shares.every((f) => {
+      const lastY = traceLastOpaqueY(f);
+      if (lastY >= botInt - 4) return true;
+      if (lastY < botInt - 36 || lastY < y0Int + 4) return false;
+      const txBot = Math.max(0, Math.min(mask.width - 1, pyRound(bandX(mask, bot - 4, { frac: f }) ?? p.x + f * p.w)));
+      for (let yy = Math.max(y0Int, botInt - 16); yy < botInt; yy++) {
+        if (mask.data[yy * mask.width + txBot] !== 0) return true;
+      }
+      return false;
+    });
+    const notedEmpty = new Set<number>();
+    const cappedXAt = (maxY: number) => (y: number, f: number): number | null => {
+      const yi = Math.min(maxY, Math.max(0, pyRound(y)));
+      const a = Math.max(0, pyInt(y - 12));
+      const b = Math.min(maxY + 1, pyInt(y + 12));
+      let x0 = mask.width;
+      let x1 = -1;
+      for (let yy = a; yy < b; yy++) {
+        for (let x = 0; x < mask.width; x++) {
+          if (mask.data[yy * mask.width + x] !== 0) {
+            if (x < x0) x0 = x;
+            if (x > x1) x1 = x;
+          }
+        }
+      }
+      const raw = x1 < x0 ? (bandX(mask, yi, { frac: f }) ?? p.x + f * p.w) : x0 + f * (x1 - x0);
+      const rx = Math.max(0, Math.min(mask.width - 1, pyRound(raw)));
+      if (mask.data[yi * mask.width + rx] !== 0) return raw;
+      let bestX: number | null = null;
+      let bestDist = mask.width + 1;
+      for (let x = 0; x < mask.width; x++) {
+        if (mask.data[yi * mask.width + x] !== 0) {
+          const d = Math.abs(x - rx);
+          if (d < bestDist) {
+            bestDist = d;
+            bestX = x;
+          }
+        }
+      }
+      return bestX ?? raw;
+    };
+    return {
+      prefix,
+      parent: 'hip',
+      rootY: y0,
+      tipY: bot - 4,
+      xAt: (y, f) => bandX(mask, y, { frac: f }),
+      fallbackX: (f) => p.x + f * p.w,
+      frame: `${p.name}'s art (no art in the band: that share of its box's width)`,
+      edges: 'both',
+      columnTip: (k, f) => {
+        const col0 = Math.floor(p.x + (k / n) * p.w);
+        const col1 = Math.max(col0, Math.ceil(p.x + ((k + 1) / n) * p.w) - 1);
+        let colMaxY = -1;
+        for (let y = y0Int; y < botInt; y++) {
+          for (let x = col0; x <= col1; x++) {
+            if (mask.data[y * mask.width + x] !== 0) colMaxY = y;
+          }
+        }
+        const fc = (k + 0.5) / n;
+        const trunkLastY = traceLastOpaqueY(fc);
+        if (colMaxY < y0Int + 4 || trunkLastY < y0Int + 4) {
+          if (emitNotes && !notedEmpty.has(k)) {
+            notedEmpty.add(k);
+            notes.push(
+              `${p.name} (${p === namedSkirt ? p.from : 'bottomwear'}): column ${k} of ${n} (x=${col0}..${col1}, share ${roundTo(fc, 6)}) holds no cloth below the root row y=${y0Int} — no tree drafted there`,
+            );
+          }
+          return null;
+        }
+        if (uniformBottom) return { tipY: bot - 4 };
+        const rawLastY = traceLastOpaqueY(f);
+        const lastY = rawLastY >= y0Int + 4 ? rawLastY : trunkLastY;
+        const tipY = Math.min(bot - 4, Math.max(y0Int + 4, lastY - 3));
+        return { tipY, xAt: cappedXAt(lastY) };
+      },
+    };
+  };
   // Issue #416: a bottomwear part lying on the trees of the dress config.cloth.bottomwear.part names (a ruffle hem
   // See-through returned on its own) rides the links it overlaps, as a layer wrapped round a tail does (issue #391),
   // and gets no trees of its own: one skirt carries one set of trees. The dress's mesh is the tail — its fixed
@@ -2646,12 +2974,12 @@ export function proposeWithBasis(
     const prefix = 'skirt';
     const partNamesLabel = list.map((q) => q.name).join(' -> ');
     const trees = T(list, 'bottomwear', dressRecipe, {
-      ...skirtInput(p0, unionMask, prefix),
+      ...skirtInput(p0, unionMask, prefix, dressRecipe, bot),
       tipY: bot - 4,
       frame: `${partNamesLabel}'s art (no art in the band: that share of ${p0.name}'s box width)`,
     });
     let swing: { bone: string; rest: number } | null = null;
-    if (dressRecipe.swing !== undefined) {
+    if (dressRecipe.swing !== undefined && trees.length > 0) {
       const cx = or(bandX(unionMask, y0, { frac: 0.5 }), p0.x + 0.5 * p0.w);
       const first = trees[0].points.length > 1 ? trees[0].points[1][1] : trees[0].tip[1];
       const at: [number, number] = [cx, y0];
@@ -2739,7 +3067,7 @@ export function proposeWithBasis(
       ? []
       : ((): PartRecord[] => {
           const mask = P.alpha(namedSkirt);
-          const tail = dressTail(namedSkirt, skirtFrame(namedSkirt, mask).segs, draftTrees(skirtInput(namedSkirt, mask, 'skirt'), dressRecipe));
+          const tail = dressTail(namedSkirt, skirtFrame(namedSkirt, mask).segs, draftTrees(skirtInput(namedSkirt, mask, 'skirt', dressRecipe, namedSkirt.y + namedSkirt.h, false), dressRecipe));
           return bw.filter((q) => !multiPartClaimed.has(q.name) && overLinks(tail, q).rides);
         })();
   let dressDrafted: Tail | null = null;
@@ -2756,11 +3084,11 @@ export function proposeWithBasis(
     if (skirtRecipe !== null) {
       const prefix = skirts.length === 1 ? 'skirt' : `skirt_${p.name}`;
       const fixed = [...segs];
-      const trees = T(p, 'bottomwear', skirtRecipe, skirtInput(p, mask, prefix));
+      const trees = T(p, 'bottomwear', skirtRecipe, skirtInput(p, mask, prefix, skirtRecipe));
       if (p === namedSkirt) dressDrafted = dressTail(p, fixed, trees);
       for (const t of trees) segs.push(t.chain);
       let swing: { bone: string; rest: number } | null = null;
-      if (skirtRecipe.swing !== undefined) {
+      if (skirtRecipe.swing !== undefined && trees.length > 0) {
         // One link long, straight down from the centre of the root row: the hip is drafted with no tip, so it is
         // unturned and the swing's setup rotation in its frame is its own direction, -90 degrees (Spine, y up).
         const cx = or(bandX(mask, y0, { frac: 0.5 }), p.x + 0.5 * p.w);
@@ -3144,7 +3472,10 @@ function artDistance(m: Mask, at: readonly [number, number]): number {
  * carries one: a part left to the rule beside parts placed from joints would
  * be read by two rules at once. Sides come from the joints, not from the eye
  * axis, so a figure seen from behind or lying across the axis is paired by
- * where its wrists are.
+ * where its wrists are. Issue #458: when pre-separated `handwear-r` and
+ * `handwear-l` parts cross so that `<s>_wrist` lies on the opaque art of its
+ * own side's `handwear-<s>` part and also within 15 px of the opposite side's
+ * `handwear-<other>` part, it resolves to its own side's part.
  *
  * Issue #199: a wrist on no part within that tolerance is measured to every
  * part by the same Chebyshev distance ({@link artDistance}). With
@@ -3171,7 +3502,18 @@ function armsFromJoints(P: PartSet, hw: readonly PartRecord[], joints: RigJoints
   const near = new Map(hw.map((p) => [p, dilate(P.alpha(p), 2 * WRIST_ON_PART_PX + 1)]));
   const arms: JointArm[] = [];
   for (const a of complete) {
-    const on = hw.filter((p) => isOn(near.get(p) as Mask, a.wrist[0], a.wrist[1]));
+    const raw = hw.filter((p) => isOn(near.get(p) as Mask, a.wrist[0], a.wrist[1]));
+    const ownTag = `handwear-${a.side}`;
+    const oppTag = `handwear-${a.side === 'r' ? 'l' : 'r'}`;
+    const own =
+      raw.length > 1 &&
+      raw.every((p) => {
+        const t = splitFrom(p.from)[1];
+        return t === ownTag || t === oppTag;
+      })
+        ? raw.filter((p) => splitFrom(p.from)[1] === ownTag && isOn(P.alpha(p), a.wrist[0], a.wrist[1]))
+        : [];
+    const on = own.length === 1 ? own : raw;
     if (on.length > 1) return { arms: null, why: `${a.side}_wrist at ${fmtAt(a.wrist)} lies on the art of ${on.length} handwear parts (${on.map((p) => p.name).join(', ')}), so it does not say which sleeve it ends` };
     if (on.length === 1) {
       arms.push({ ...a, part: on[0], snap: null });
@@ -3800,6 +4142,62 @@ export interface NearEmptyHandFinding {
     | { kind: 'forearm-width'; width: number };
 }
 
+/**
+ * Issue #445: back-hair cloth trees on one side of the eye axis whose count does not match the side's visible hair
+ * masses or whose link or tip leaves its mass's column range.
+ */
+export interface BackHairMassesFinding {
+  kind: 'back-hair-masses';
+  mesh: string;
+  side: 'r' | 'l';
+  trunks: string[];
+  masses: Array<{ minX: number; maxX: number; minY: number; maxY: number }>;
+  outside: Array<{ point: string; at: [number, number]; minX: number; maxX: number }>;
+}
+
+/**
+ * Issue #439: both arms overlap in one 8-connected component of a single handwear layer (`handwear-r` or `handwear-l`),
+ * resolved by declaring `config.seethrough.arm_split` (`x` or `line`, and `order`).
+ */
+export interface OverlappingArmsFinding {
+  kind: 'overlapping-arms';
+  part: string;
+  from: string;
+  rAt: [number, number];
+  lAt: [number, number];
+  opaquePx: number;
+}
+
+/**
+ * Issue #446: two limbs sharing one part (`from`) cross in an X at `at` with no `config.limbs.<limb>.split`
+ * declared on the covering limb, so `nearestLimb` cuts a straight line through the crossing.
+ */
+export interface CrossedLimbsFinding {
+  kind: 'crossed-limbs';
+  part: string;
+  from: string;
+  a: string;
+  b: string;
+  at: [number, number];
+}
+
+/**
+ * Issue #447: a stop's contact point `<chain>_touch` (`at` in `against`'s local frame) lies above the first stopped
+ * link's root (`links[0]` at `[x0, y0]`) in rig pixels (`ty < y0`, i.e. higher Spine y), so `<chain>_rest` aims
+ * upward into the upper half-plane (`|rest| > 90°`) and `|rest| + outward > 180°` wraps past ±180° (`RIG_STOP_BOUNDS`).
+ */
+export interface StopTouchAboveRootFinding {
+  kind: 'stop-touch-above-root';
+  chain: string;
+  firstLink: string;
+  rootAt: [number, number];
+  against: string;
+  at: [number, number];
+  touchAt: [number, number];
+  rest: number;
+  outward: number;
+}
+
 export type LintFinding =
   | OffArtFinding
   | OffLockFinding
@@ -3810,7 +4208,11 @@ export type LintFinding =
   | HipNearerNeckFinding
   | ChainNotAdvancingFinding
   | SqueezeLintFinding
-  | NearEmptyHandFinding;
+  | NearEmptyHandFinding
+  | BackHairMassesFinding
+  | OverlappingArmsFinding
+  | CrossedLimbsFinding
+  | StopTouchAboveRootFinding;
 
 /** Which rule set read the torso and the sleeve chains, under `--keypoints`. */
 export interface LintBasis {
@@ -3910,7 +4312,7 @@ export function coverageOutcome(c: BoneCoverage): CoverageOutcome {
  */
 export function lint(
   P: PartSet,
-  spec: { bones: readonly BoneEntry[]; meshes: Readonly<Record<string, MeshSpec>>; regions?: Readonly<Record<string, string>>; motion?: SkeletonSections['motion']; constraints?: readonly ConfigConstraint[] },
+  spec: { bones: readonly BoneEntry[]; meshes: Readonly<Record<string, MeshSpec>>; regions?: Readonly<Record<string, string>>; motion?: SkeletonSections['motion']; constraints?: readonly ConfigConstraint[]; limbs?: Readonly<Record<string, Limb>>; stops?: readonly ConfigStop[] },
   joints?: RigJoints,
 ): LintResult {
   const { byName } = expand(spec.bones);
@@ -4097,6 +4499,243 @@ export function lint(
       }
     }
   }
+  // Issue #439: when both arms overlap in one 8-connected component of a single handwear layer, name the overlap and
+  // the config.seethrough.arm_split declaration that separates them into two layers.
+  if (joints !== undefined && joints.joints.r_wrist.at !== null && joints.joints.l_wrist.at !== null) {
+    const hwParts = [...P.byTag('handwear-r', undefined, true), ...P.byTag('handwear-l', undefined, true)].filter((p) => p.limb === undefined);
+    if (hwParts.length === 1) {
+      const part = hwParts[0];
+      const rAt: [number, number] = [joints.joints.r_wrist.at[0], joints.joints.r_wrist.at[1]];
+      const lAt: [number, number] = [joints.joints.l_wrist.at[0], joints.joints.l_wrist.at[1]];
+      {
+        const cc = connectedComponents(P.alpha(part), 8);
+        const compsNear = (pt: readonly [number, number]): Set<number> => {
+          const hit = new Set<number>();
+          const px = pyInt(pt[0]);
+          const py = pyInt(pt[1]);
+          const x0 = Math.max(0, px - WRIST_ON_PART_PX);
+          const x1 = Math.min(P.W - 1, px + WRIST_ON_PART_PX);
+          const y0 = Math.max(0, py - WRIST_ON_PART_PX);
+          const y1 = Math.min(P.H - 1, py + WRIST_ON_PART_PX);
+          for (let y = y0; y <= y1; y++) {
+            for (let x = x0; x <= x1; x++) {
+              const l = cc.labels[y * P.W + x];
+              if (l > 0) hit.add(l);
+            }
+          }
+          return hit;
+        };
+        const rComps = compsNear(rAt);
+        const lComps = compsNear(lAt);
+        const shared = [...rComps].find((l) => lComps.has(l));
+        if (shared !== undefined) {
+          findings.push({
+            kind: 'overlapping-arms',
+            part: part.name,
+            from: part.from,
+            rAt,
+            lAt,
+            opaquePx: cc.stats[shared].area,
+          });
+        }
+      }
+    }
+  }
+  // Issue #445: back-hair cloth trees (trunks `hairback_..._<r|l><k>_` hung from head) are held to the visible hair
+  // masses on each side of the eye axis — one tree per mass, every link and tip inside that mass's column range.
+  const bhParts = P.headFirst('back hair').filter((p) => spec.meshes[p.name] !== undefined);
+  if (bhParts.length > 0) {
+    try {
+      const [fx0, fy0, fw, fh] = faceBoxOf(P).box;
+      const ewR = P.byTag('eyewhite-r')[0] ?? null;
+      const ewL = P.byTag('eyewhite-l')[0] ?? null;
+      const axis = ewR !== null && ewL !== null ? (center(ewR)[0] + center(ewL)[0]) / 2 : fx0 + fw / 2;
+      const eyeYs = [ewR, ewL].filter((x): x is PartRecord => x !== null).map((x) => center(x)[1]);
+      const eyeY = eyeYs.length > 0 ? npMean(eyeYs) : fy0 + 0.5 * fh;
+      const chin = fy0 + fh;
+      const neckp = P.headFirst('neck');
+      const neckY = joints?.joints.neck.at?.[1] ?? (neckp.length > 0 ? (chin + neckp[0].y + neckp[0].h) / 2 : chin + 0.12 * fh);
+      const shoulderLine = neckY + 0.5 * fh;
+      const y0 = pyRound(eyeY);
+      const seenGroups = new Set<string>();
+      for (const part of bhParts) {
+        const m = spec.meshes[part.name];
+        const segStrings = m.segments.filter((sp): sp is string => typeof sp === 'string');
+        const trunkMatch = segStrings.map((sp) => /^(hairback_(?:.+_)?)(r|l)(\d+)_$/.exec(sp)).find((x) => x !== null) ?? null;
+        if (trunkMatch === null) continue;
+        const basePrefix = trunkMatch[1];
+        if (seenGroups.has(basePrefix)) continue;
+        seenGroups.add(basePrefix);
+        const groupParts = bhParts.filter((q) =>
+          spec.meshes[q.name].segments.some((sp) => typeof sp === 'string' && sp.startsWith(basePrefix) && /^(r|l)\d+_$/.test(sp.slice(basePrefix.length))),
+        );
+        const mask = groupParts.length === 1 ? P.alpha(part) : newMask(P.W, P.H);
+        if (groupParts.length > 1) {
+          for (const q of groupParts) {
+            const mq = P.alpha(q);
+            for (let i = 0; i < mask.data.length; i++) if (mq.data[i]) mask.data[i] = 1;
+          }
+        }
+        const m0 = spec.meshes[groupParts[0].name];
+        const g = 'grid' in m0 ? m0.grid : partGrid(groupParts[0])[0];
+        for (const side of ['r', 'l'] as const) {
+          const trunkRe = new RegExp(`^${basePrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}${side}(\\d+)_$`);
+          const sideTrunks = spec.bones
+            .filter((b): b is Extract<BoneEntry, { chain: string }> => 'chain' in b && b.parent === 'head' && trunkRe.test(b.chain) && groupParts.some((q) => spec.meshes[q.name].segments.includes(b.chain)))
+            .sort((a, b) => Number(trunkRe.exec(a.chain)![1]) - Number(trunkRe.exec(b.chain)![1]));
+          if (sideTrunks.length === 0) continue;
+          const masses = backHairMasses(mask, side, axis, y0, shoulderLine, g);
+          const outside: Array<{ point: string; at: [number, number]; minX: number; maxX: number }> = [];
+          const sideMinX = masses.length > 0 ? Math.min(...masses.map((x) => x.minX)) : 0;
+          const sideMaxX = masses.length > 0 ? Math.max(...masses.map((x) => x.maxX)) : P.W - 1;
+          sideTrunks.forEach((tr, k) => {
+            const target = k < masses.length ? masses[k] : null;
+            const minX = target !== null ? target.minX : sideMinX;
+            const maxX = target !== null ? target.maxX : sideMaxX;
+            const treeBase = tr.chain.slice(0, -1);
+            const treeRe = new RegExp(`^${treeBase.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[a-z]*_$`);
+            const treeChains = spec.bones.filter((b): b is Extract<BoneEntry, { chain: string }> => 'chain' in b && treeRe.test(b.chain));
+            for (const c of treeChains) {
+              c.points.forEach((pt, idx) => {
+                const px = pyInt(pt[0]);
+                const py = pyInt(pt[1]);
+                if (px < minX || px > maxX) outside.push({ point: `${c.chain}${idx}`, at: [px, py], minX, maxX });
+              });
+              const tx = pyInt(c.tip[0]);
+              const ty = pyInt(c.tip[1]);
+              if (tx < minX || tx > maxX) outside.push({ point: `${c.chain} tip`, at: [tx, ty], minX, maxX });
+            }
+          });
+          if (sideTrunks.length !== masses.length || outside.length > 0) {
+            findings.push({
+              kind: 'back-hair-masses',
+              mesh: groupParts.map((q) => q.name).join(' -> '),
+              side,
+              trunks: sideTrunks.map((t) => t.chain),
+              masses: masses.map((x) => ({ minX: x.minX, maxX: x.maxX, minY: x.minY, maxY: x.maxY })),
+              outside,
+            });
+          }
+        }
+      }
+    } catch (err) {
+      if (!(err instanceof PartsError)) throw err;
+    }
+  }
+  // Issue #446: when two limbs sharing one part cross in an X without a per-limb split declared on the covering limb,
+  // nearest-bone splitting cuts a straight line through the crossing.
+  {
+    const baseP = P.beforeLimbs();
+    const places = bonePlaces(spec.bones);
+    if (spec.limbs !== undefined) {
+      const limbNames = Object.keys(spec.limbs);
+      const fromParts = [...new Set(limbNames.flatMap((l) => spec.limbs![l].segments.map((sg) => sg.from)))];
+      for (const src of fromParts) {
+        const on = limbNames.filter((l) => spec.limbs![l].segments.some((sg) => sg.from === src));
+        if (on.length < 2 || on.some((l) => spec.limbs![l].split !== undefined)) continue;
+        const valid = on.filter((l) => spec.limbs![l].segments.every((sg) => places.has(sg.bone)));
+        if (valid.length < 2) continue;
+        const rec = baseP.recs.find((r) => r.name === src);
+        for (let i = 0; i < valid.length; i++) {
+          const polyA = limbPolyline(spec.limbs[valid[i]], places);
+          for (let j = i + 1; j < valid.length; j++) {
+            const polyB = limbPolyline(spec.limbs[valid[j]], places);
+            const cross = limbCrossing(polyA, polyB);
+            if (cross !== null) {
+              findings.push({
+                kind: 'crossed-limbs',
+                part: src,
+                from: rec?.from ?? '',
+                a: valid[i],
+                b: valid[j],
+                at: cross,
+              });
+            }
+          }
+        }
+      }
+    } else {
+      const legR = spec.bones.find((b): b is Extract<BoneEntry, { chain: string }> => 'chain' in b && b.chain === 'leg_r' && b.points.length >= 2);
+      const legL = spec.bones.find((b): b is Extract<BoneEntry, { chain: string }> => 'chain' in b && b.chain === 'leg_l' && b.points.length >= 2);
+      if (legR !== undefined && legL !== undefined) {
+        const polyR: Array<[number, number]> = [...legR.points.map((p): [number, number] => [p[0], p[1]]), [legR.tip[0], legR.tip[1]]];
+        const polyL: Array<[number, number]> = [...legL.points.map((p): [number, number] => [p[0], p[1]]), [legL.tip[0], legL.tip[1]]];
+        const cross = limbCrossing(polyR, polyL);
+        if (cross !== null) {
+          const lwParts = baseP.byTag('legwear');
+          const shared = lwParts.find((p: PartRecord) => {
+            const near = dilate(baseP.alpha(p), 2 * WRIST_ON_PART_PX + 1);
+            return isOn(near, legR.tip[0], legR.tip[1]) && isOn(near, legL.tip[0], legL.tip[1]);
+          });
+          if (shared !== undefined) {
+            findings.push({
+              kind: 'crossed-limbs',
+              part: shared.name,
+              from: shared.from,
+              a: 'leg_r',
+              b: 'leg_l',
+              at: cross,
+            });
+          }
+        }
+      }
+    }
+  }
+  // Issue #447: when a stop's contact point `<chain>_touch` (`at` in `against`'s local frame) lies above the first
+  // stopped link's root (`links[0]`) in rig pixels (`ty < y0`, i.e. higher Spine y), `<chain>_rest` aims into the
+  // upper half-plane (`|rest| > 90°`) and `|rest| + outward > 180°` wraps past ±180° (`RIG_STOP_BOUNDS`).
+  if (spec.stops !== undefined && spec.stops.length > 0) {
+    const boneEnds = new Map<string, Point>();
+    const chainLinks = new Map<string, string[]>();
+    for (const e of spec.bones) {
+      if ('chain' in e) {
+        const names = e.points.map((_, k) => `${e.chain}${k}`);
+        chainLinks.set(e.chain, names);
+        e.points.forEach((_, k) => {
+          boneEnds.set(names[k], k + 1 < e.points.length ? e.points[k + 1] : e.tip);
+        });
+      } else if (e.tip !== undefined) {
+        boneEnds.set(e.name, e.tip);
+      }
+    }
+    for (const s of spec.stops) {
+      const links = s.links ?? chainLinks.get(s.chain) ?? [];
+      if (links.length === 0) continue;
+      const firstLink = links[0];
+      const rootBone = byName.get(firstLink);
+      const againstBone = byName.get(s.against);
+      if (rootBone === undefined || againstBone === undefined) continue;
+      const againstEnd = boneEnds.get(s.against);
+      let againstRot = 0;
+      if (againstEnd !== undefined) {
+        const dx = againstEnd[0] - againstBone.x;
+        const dy = cropToSpineY(againstEnd[1], P.H) - cropToSpineY(againstBone.y, P.H);
+        if (dx !== 0 || dy !== 0) againstRot = (Math.atan2(dy, dx) * 180) / Math.PI;
+      }
+      const frame = computeExactFrameTransforms([
+        { name: s.against, x: againstBone.x, y: cropToSpineY(againstBone.y, P.H), rotation: againstRot },
+      ]).get(s.against)!;
+      const [wx, wy] = toWorld(frame, s.at[0], s.at[1]);
+      const touchAt: [number, number] = [pyRound(wx * 10) / 10, pyRound(cropToSpineY(wy, P.H) * 10) / 10];
+      const aimDx = wx - rootBone.x;
+      const aimDy = wy - cropToSpineY(rootBone.y, P.H);
+      if (aimDx === 0 && aimDy === 0) continue;
+      const rest = pyRound(normaliseDegrees((Math.atan2(aimDy, aimDx) * 180) / Math.PI) * 100) / 100;
+      if (touchAt[1] < rootBone.y || Math.abs(rest) + s.outward > 180) {
+        findings.push({
+          kind: 'stop-touch-above-root',
+          chain: s.chain,
+          firstLink,
+          rootAt: [rootBone.x, rootBone.y],
+          against: s.against,
+          at: [s.at[0], s.at[1]],
+          touchAt,
+          rest,
+          outward: s.outward,
+        });
+      }
+    }
+  }
   // Issue #314: every pair of keyed chains a lattice mesh names, swung on the rig stage's own lattice and weights, held
   // to check's TEXTURE_STRETCH bar (src/squeeze.ts). Only with a motion: without one nothing swings.
   const partImages = new Map(P.recs.filter((p) => P.images.has(p.name)).map((p) => [p.name, { x: p.x, y: p.y, image: P.images.get(p.name) as Raster }]));
@@ -4133,7 +4772,23 @@ function findingBones(f: LintFinding, bones: readonly BoneEntry[]): string[] {
     case 'squeeze':
       return [...new Set(f.vertices.map((v) => v.weights[0]?.bone).filter((n): n is string => n !== undefined))];
     case 'near-empty-hand':
+    case 'overlapping-arms':
+    case 'crossed-limbs':
+    case 'stop-touch-above-root':
       return [];
+    case 'back-hair-masses': {
+      const out = new Set<string>();
+      for (const o of f.outside) {
+        if (!o.point.endsWith(' tip')) out.add(o.point);
+        else {
+          const chain = o.point.slice(0, -' tip'.length);
+          const e = bones.find((b) => 'chain' in b && b.chain === chain);
+          if (e !== undefined && 'chain' in e) out.add(`${chain}${e.points.length - 1}`);
+        }
+      }
+      if (out.size === 0) for (const t of f.trunks) out.add(`${t}0`);
+      return [...out];
+    }
     case 'chain-not-advancing': {
       if (!f.point.endsWith(' tip')) return [f.point];
       const chain = f.point.slice(0, -' tip'.length);
@@ -4308,6 +4963,23 @@ export function lintLine(f: LintFinding): string {
           : `forearm width ${pyFixed(f.basis.width, 1)} px squared`;
       return `LINT ${f.part} (${f.from}) holds ${f.opaquePx} opaque px while ${f.wrist} at ${fmtAt(f.wristAt)} says a hand is there — below the bar of ${f.bar} px (${why}): the hands may overlap in the other layer and leave finger slivers here`;
     }
+    case 'overlapping-arms':
+      return `LINT ${f.part} (${f.from}) holds both arms in one ${f.opaquePx} px component (r_wrist at ${fmtAt(f.rAt)}, l_wrist at ${fmtAt(f.lAt)}): declare config.seethrough.arm_split (x or line, and order: ["handwear-r", "handwear-l"] or ["handwear-l", "handwear-r"]) to separate the overlapping arms into two layers`;
+    case 'crossed-limbs':
+      return `LINT ${f.a} and ${f.b} on ${f.part}${f.from === '' ? '' : ` (${f.from})`} cross at ${fmtAt(f.at)} with no per-limb split: nearest-bone splitting cuts a straight line through the crossing; declare config.limbs.<covering>.split (line: [[x, y], ...] or edge: "painting") on the covering limb so the seam follows the limb`;
+    case 'stop-touch-above-root':
+      return `LINT stop on ${f.chain} (${f.firstLink} at ${fmtAt(f.rootAt)}) against ${f.against} (at ${fmtAt(f.at)}) places ${f.chain}_touch at ${fmtAt(f.touchAt)}, above ${f.firstLink}'s root (rest ${pyFixed(f.rest, 2)} deg, |rest| + outward ${pyFixed(Math.abs(f.rest) + f.outward, 2)} deg): stop against the descending limb bone below ${f.firstLink}, set links to start at a link below ${f.chain}_touch, or omit the stop on a rising limb`;
+    case 'back-hair-masses': {
+      const massDesc =
+        f.masses.length === 0
+          ? 'none'
+          : f.masses.map((m, i) => `mass ${i} columns x=${m.minX}..${m.maxX}, y=${m.minY}..${m.maxY}`).join('; ');
+      const outDesc =
+        f.outside.length === 0
+          ? ''
+          : `; outside mass columns: ${f.outside.map((o) => `${o.point} at ${pyIntList(o.at)} (outside x=${o.minX}..${o.maxX})`).join(', ')}`;
+      return `LINT ${f.trunks.join(', ')} on mesh ${pyRepr(f.mesh)} (side ${f.side}): ${f.trunks.length} tree(s) for ${f.masses.length} visible hair mass(es) (${massDesc})${outDesc} — draft one tree per visible hair mass, rooted at that mass's top row and inside its columns`;
+    }
     case 'chain-not-advancing':
       return `LINT ${f.point} at ${pyIntList(f.at)} does not advance from ${f.fromJoint} toward ${f.toJoint}: it falls ${pyFixed(f.t, 1)} px along that line and ${f.previous} ${pyFixed(f.tPrevious, 1)} px, and each must fall further than the one before`;
   }