@rig-c/parts 1.28.0 → 1.29.0

package/src/cloth.ts

@@ -65,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 { connectedComponents } from './raster/components.ts';
+import { dilate } from './raster/morph.ts';
+import { type Mask, newMask } from './raster/types.ts';
 import { pyRound } from './round.ts';
 import { segmentDistance } from './weights.ts';
 
@@ -80,7 +82,7 @@ export interface ClothStrength {
   edge: number;
 }
 
-/** One target's recipe, as `config.cloth.<tag>` declares it (`chains` may be omitted on `"back hair"`, where it is derived from the tail's width at the root row). */
+/** One target's recipe, as `config.cloth.<tag>` declares it (`chains` may be omitted on `"back hair"`, where it is derived from the visible hair masses below the root row, issue #445). */
 export interface ClothRecipe {
   chains?: number;
   links: number;
@@ -104,14 +106,12 @@ export interface ClothRecipe {
 export type ClothRecipes = Partial<Record<ClothTarget, ClothRecipe>>;
 
 /**
- * 📐 The recipe's default maximum back-hair tree count per side when `chains`
- * is omitted on `config.cloth."back hair"` (issue #390): 2 trees per side when
- * the tail's opaque width at the root row holds at least two mesh-grid cells
- * (`floor(width / grid) >= 2`, `fixtures/cloth.ts`: 48 px on a 14 px grid) and
- * every tree root lies inside the art, and fewer when the tail at the root row
- * is narrower or a root falls off the art (`examples/wind`: 45 px on the r side
- * and 61 px on the l side at y=162 on a 28 px grid, with inner roots at
- * [323, 162] and [496, 162] on alpha 0 -> 1 tree per side).
+ * 📐 The fallback tree count when `draftTrees` is called without `chains` or
+ * `masses` (issues #390, #445). When `chains` is omitted on
+ * `config.cloth."back hair"`, `propose` derives the count per side from the
+ * visible hair masses ({@link backHairMasses}): connected components of the
+ * back-hair part's alpha below the root row (merged when they touch within one
+ * grid cell), one tree per mass, rooted at that mass's own top row.
  */
 export const RECIPE_BACK_HAIR_CHAINS = 2;
 
@@ -185,6 +185,20 @@ export interface TreeChain {
 /** Which outer sides of the piece are edges: both (a skirt, a lock), or one side of the eye axis (back hair). */
 export type EdgeSides = 'both' | 'r' | 'l';
 
+/** Issue #445: one visible hair mass's own frame for a single tree rooted at that mass's top row. */
+export interface TreeMassInput {
+  rootY: number;
+  tipY: number;
+  xAt: (y: number, frac: number) => number | null;
+  fallbackX: (frac: number) => number;
+  frame: string;
+}
+
+export interface TreeColumnTip {
+  tipY: number;
+  xAt?: (y: number, frac: number) => number | null;
+}
+
 export interface TreeInput {
   /** The chains' name prefix: tree k's trunk is `<prefix><k>_`, its branches `<prefix><k><a|b|…>_`. */
   prefix: string;
@@ -199,6 +213,14 @@ export interface TreeInput {
   /** What the cell's frame is, for the rules: "skirt's art", "the r side of back's art". */
   frame: string;
   edges: EdgeSides;
+  /** Issue #445: when present, one entry per visible hair mass; tree k sits inside `masses[k]` rather than cell [k/n, (k+1)/n] of the whole side. */
+  masses?: readonly TreeMassInput[];
+  /**
+   * Issue #438: when present, resolves the tip row (and an optional `xAt` bounded to that column's cloth rows) for
+   * column `k` (`0 <= k < n`) and share `frac` (`0 <= frac <= 1`), or returns `null` when column `k` holds no cloth
+   * below `rootY` (skipping tree `k`).
+   */
+  columnTip?: (k: number, frac: number) => TreeColumnTip | null;
 }
 
 /** The rows the n links of a path start at, then its tip's: lengths in the ratio q^j, from root row to tip row. */
@@ -220,40 +242,71 @@ const LETTERS = 'abcdefghijklmnopqrstuvwxyz';
 
 /** The trees of one piece, in tree order, each trunk before its branches. */
 export function draftTrees(input: TreeInput, r: ClothRecipe): TreeChain[] {
-  const n = r.chains ?? RECIPE_BACK_HAIR_CHAINS;
+  const n = input.masses !== undefined ? input.masses.length : (r.chains ?? RECIPE_BACK_HAIR_CHAINS);
   const ratio = r.length_ratio ?? RECIPE_LENGTH_RATIO;
-  const rows = linkRows(input.rootY, input.tipY, r.links, ratio);
+  const baseRows = linkRows(input.rootY, input.tipY, r.links, ratio);
   const at = r.split === undefined ? r.links : r.split.at;
   const into = r.split === undefined ? 1 : r.split.into;
   const out: TreeChain[] = [];
-  const x = (y: number, f: number): number => input.xAt(y, f) ?? input.fallbackX(f);
-  const pt = (y: number, f: number): Point => [pyRound(x(y, f), 0), pyRound(y, 0)];
-  const rowRule = (j: number): string =>
-    `link ${j}'s row: ${j === 0 ? 'the root row' : `the root row + ${pyRound((rows[j] - rows[0]) / (rows[r.links] - rows[0]), 4)} of the span to the tip row`} (lengths in the ratio ${pyRound(ratio, 6)} last to first)`;
+  const activeTrees: number[] = [];
+  const trunkCols = new Map<number, TreeColumnTip | null>();
+  for (let k = 0; k < n; k++) {
+    if (input.masses === undefined && input.columnTip !== undefined) {
+      const col = input.columnTip(k, (k + 0.5) / n);
+      trunkCols.set(k, col);
+      if (col === null) continue;
+    }
+    activeTrees.push(k);
+  }
+  const firstTree = activeTrees.length > 0 ? activeTrees[0] : 0;
+  const lastTree = activeTrees.length > 0 ? activeTrees[activeTrees.length - 1] : n - 1;
   const outerSide = (k: number, b: number): boolean => {
-    const left = k === 0 && b === 0;
-    const right = k === n - 1 && b === into - 1;
+    const left = k === firstTree && b === 0;
+    const right = k === lastTree && b === into - 1;
     return input.edges === 'both' ? left || right : input.edges === 'r' ? left : right;
   };
-  for (let k = 0; k < n; k++) {
-    const fc = (k + 0.5) / n;
+  for (const k of activeTrees) {
+    const mass = input.masses?.[k];
+    const fc = mass === undefined ? (k + 0.5) / n : 0.5;
+    const trunkCol = trunkCols.get(k) ?? null;
+    const branchCols: Array<TreeColumnTip | null> = [];
+    if (into > 1 && mass === undefined && input.columnTip !== undefined) {
+      for (let b = 0; b < into; b++) {
+        branchCols.push(input.columnTip(k, (k + (b + 0.5) / into) / n));
+      }
+    }
+    const trunkTipY =
+      mass !== undefined
+        ? mass.tipY
+        : trunkCol === null
+          ? input.tipY
+          : branchCols.length > 0
+            ? Math.min(trunkCol.tipY, ...branchCols.map((bc) => bc?.tipY ?? trunkCol.tipY))
+            : trunkCol.tipY;
+    const rows = mass !== undefined ? linkRows(mass.rootY, mass.tipY, r.links, ratio) : trunkTipY === input.tipY ? baseRows : linkRows(input.rootY, trunkTipY, r.links, ratio);
+    const frame = mass === undefined ? input.frame : mass.frame;
+    const xWith = (col: TreeColumnTip | null, y: number, f: number): number =>
+      mass !== undefined ? (mass.xAt(y, f) ?? mass.fallbackX(f)) : ((col?.xAt ?? input.xAt)(y, f) ?? input.fallbackX(f));
+    const ptWith = (col: TreeColumnTip | null, y: number, f: number): Point => [pyRound(xWith(col, y, f), 0), pyRound(y, 0)];
+    const rowRuleFor = (pathRows: readonly number[], j: number): string =>
+      `link ${j}'s row: ${j === 0 ? 'the root row' : `the root row + ${pyRound((pathRows[j] - pathRows[0]) / (pathRows[r.links] - pathRows[0]), 4)} of the span to the tip row`} (lengths in the ratio ${pyRound(ratio, 6)} last to first)`;
     const trunkLinks = Math.min(at, r.links);
     const trunkEdge = into === 1 && outerSide(k, 0);
     const trunk: TreeChain = {
       chain: `${input.prefix}${k}_`,
       parent: input.parent,
       points: [],
-      tip: pt(rows[trunkLinks], fc),
+      tip: ptWith(trunkCol, rows[trunkLinks], fc),
       why: [],
-      tipWhy: `${trunkLinks === r.links ? 'the tip row' : `link ${trunkLinks}'s row, the fork`}, ${pyRound(fc, 6)} of the way across ${input.frame} (tree ${k} of ${n}, the centre of its cell)`,
+      tipWhy: `${trunkLinks === r.links ? 'the tip row' : `link ${trunkLinks}'s row, the fork`}, ${pyRound(fc, 6)} of the way across ${frame} (tree ${k} of ${n}, the centre of its cell)`,
       tree: k,
       roles: [],
       depths: [],
       last: [],
     };
     for (let j = 0; j < trunkLinks; j++) {
-      trunk.points.push(pt(rows[j], fc));
-      trunk.why.push(`${rowRule(j)}, ${pyRound(fc, 6)} of the way across ${input.frame} in the 24-row band there (tree ${k} of ${n}, the centre of its cell)`);
+      trunk.points.push(ptWith(trunkCol, rows[j], fc));
+      trunk.why.push(`${rowRuleFor(rows, j)}, ${pyRound(fc, 6)} of the way across ${frame} in the 24-row band there (tree ${k} of ${n}, the centre of its cell)`);
       trunk.roles.push(into === 1 ? (trunkEdge ? 'edge' : 'trunk') : 'trunk');
       trunk.depths.push(j);
       trunk.last.push(into === 1 && j === trunkLinks - 1);
@@ -261,14 +314,17 @@ export function draftTrees(input: TreeInput, r: ClothRecipe): TreeChain[] {
     out.push(trunk);
     if (into === 1) continue;
     for (let b = 0; b < into; b++) {
-      const fb = (k + (b + 0.5) / into) / n;
+      const fb = mass === undefined ? (k + (b + 0.5) / into) / n : (b + 0.5) / into;
+      const bCol = branchCols[b] ?? trunkCol;
+      const bTipY = bCol?.tipY ?? trunkTipY;
+      const bRows = bTipY === trunkTipY ? rows : linkRows(input.rootY, bTipY, r.links, ratio);
       const ch: TreeChain = {
         chain: `${input.prefix}${k}${LETTERS[b]}_`,
         parent: `${trunk.chain}${trunkLinks - 1}`,
         points: [],
-        tip: pt(rows[r.links], fb),
+        tip: ptWith(bCol, bRows[r.links], fb),
         why: [],
-        tipWhy: `the tip row, ${pyRound(fb, 6)} of the way across ${input.frame} (branch ${b} of ${into} of tree ${k}, the centre of its share of the cell)`,
+        tipWhy: `the tip row, ${pyRound(fb, 6)} of the way across ${frame} (branch ${b} of ${into} of tree ${k}, the centre of its share of the cell)`,
         tree: k,
         roles: [],
         depths: [],
@@ -276,8 +332,8 @@ export function draftTrees(input: TreeInput, r: ClothRecipe): TreeChain[] {
       };
       const edge = r.split?.hold_tip === true && r.strength === undefined ? 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})`);
+        ch.points.push(j === trunkLinks ? trunk.tip : ptWith(bCol, bRows[j], fb));
+        ch.why.push(j === trunkLinks ? `the fork: the trunk ${trunk.chain}'s tip` : `${rowRuleFor(bRows, j)}, ${pyRound(fb, 6)} of the way across ${frame} in the 24-row band there (branch ${b} of ${into} of tree ${k})`);
         ch.roles.push(edge ? 'edge' : 'branch');
         ch.depths.push(j);
         ch.last.push(j === r.links - 1);
@@ -496,3 +552,215 @@ export function spanCrosses(span: Pick<TailSpan, 'a' | 'b'>, mask: Mask): number
   return count;
 }
 
+/**
+ * Issue #445: one visible hair mass on a side (`r`: `x < axis`, `l`: `x >= axis`)
+ * of the back-hair part's alpha below the root row.
+ */
+export interface BackHairMass {
+  side: 'r' | 'l';
+  minX: number;
+  maxX: number;
+  minY: number;
+  maxY: number;
+  area: number;
+  mask: Mask;
+}
+
+/**
+ * Issue #445: the visible hair masses on one side of the eye axis (`r`: `x < axis`,
+ * `l`: `x >= axis`) — 8-connected components of the back-hair part's alpha below
+ * the root row (`y > y0`, after any undivided crown rows above `shoulderLine` that
+ * bridge continuously across `axis`, with row `y0` attached when a component touches
+ * `y0` at `y0 + 1`), merged when an above-shoulder crown/nape remnant sits beside a
+ * hanging tail on that side or when two components touch within one grid cell
+ * (`grid` px), sorted left-to-right by `minX`.
+ */
+export function backHairMasses(mask: Mask, side: 'r' | 'l', axis: number, y0: number, shoulderLine: number, grid: number): BackHairMass[] {
+  const W = mask.width;
+  const H = mask.height;
+  const onSide = (x: number): boolean => (side === 'r' ? x < axis : x >= axis);
+  const axL = Math.max(0, Math.floor(axis) - 1);
+  const axR = Math.min(W - 1, Math.floor(axis));
+  let yStart = Math.max(0, y0 + 1);
+  const shoulderRow = Math.min(H, Math.floor(shoulderLine));
+  while (yStart < shoulderRow && mask.data[yStart * W + axL] !== 0 && mask.data[yStart * W + axR] !== 0) {
+    yStart++;
+  }
+  const hasAnyFrom = (yFrom: number): boolean => {
+    for (let y = yFrom; y < H; y++) {
+      for (let x = 0; x < W; x++) {
+        if (onSide(x) && mask.data[y * W + x] !== 0) return true;
+      }
+    }
+    return false;
+  };
+  if (!hasAnyFrom(yStart)) yStart = Math.max(0, y0 + 1);
+  const sub = newMask(W, H);
+  for (let y = yStart; y < H; y++) {
+    for (let x = 0; x < W; x++) {
+      if (onSide(x) && mask.data[y * W + x] !== 0) sub.data[y * W + x] = 1;
+    }
+  }
+  const cc = connectedComponents(sub, 8);
+  const comps: Array<{ minX: number; maxX: number; minY: number; maxY: number; area: number; mask: Mask }> = [];
+  for (let i = 1; i < cc.count; i++) {
+    const st = cc.stats[i];
+    const m = newMask(W, H);
+    let minX = st.left;
+    let maxX = st.left + st.width - 1;
+    let minY = st.top;
+    const maxY = st.top + st.height - 1;
+    let area = st.area;
+    for (let y = st.top; y <= maxY; y++) {
+      for (let x = st.left; x <= maxX; x++) {
+        if (cc.labels[y * W + x] === i) m.data[y * W + x] = 1;
+      }
+    }
+    if (yStart === y0 + 1 && minY === y0 + 1 && y0 >= 0 && y0 < H) {
+      let touched = false;
+      for (let x = 0; x < W; x++) {
+        if (!onSide(x) || mask.data[y0 * W + x] === 0) continue;
+        if (
+          m.data[(y0 + 1) * W + x] !== 0 ||
+          (x > 0 && m.data[(y0 + 1) * W + (x - 1)] !== 0) ||
+          (x + 1 < W && m.data[(y0 + 1) * W + (x + 1)] !== 0)
+        ) {
+          m.data[y0 * W + x] = 1;
+          touched = true;
+        }
+      }
+      if (touched) {
+        for (let x = 1; x < W; x++) {
+          if (onSide(x) && mask.data[y0 * W + x] !== 0 && m.data[y0 * W + (x - 1)] !== 0) m.data[y0 * W + x] = 1;
+        }
+        for (let x = W - 2; x >= 0; x--) {
+          if (onSide(x) && mask.data[y0 * W + x] !== 0 && m.data[y0 * W + (x + 1)] !== 0) m.data[y0 * W + x] = 1;
+        }
+        minY = y0;
+        for (let x = 0; x < W; x++) {
+          if (m.data[y0 * W + x] !== 0) {
+            minX = Math.min(minX, x);
+            maxX = Math.max(maxX, x);
+            area++;
+          }
+        }
+      }
+    }
+    comps.push({ minX, maxX, minY, maxY, area, mask: m });
+  }
+  if (comps.length === 0) return [];
+  const par = comps.map((_, i) => i);
+  const find = ( idx: number): number => {
+    let cur = idx;
+    while (par[cur] !== cur) {
+      par[cur] = par[par[cur]];
+      cur = par[cur];
+    }
+    return cur;
+  };
+  const unite = (a: number, b: number): void => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) par[rb] = ra;
+  };
+  const dilatedCache = new Map<number, Mask>();
+  const dilatedOf = (idx: number): Mask => {
+    let d = dilatedCache.get(idx);
+    if (d === undefined) {
+      d = dilate(comps[idx].mask, Math.max(1, 2 * grid + 1));
+      dilatedCache.set(idx, d);
+    }
+    return d;
+  };
+  const touchesWithinGrid = (ia: number, ib: number): boolean => {
+    const a = comps[ia];
+    const b = comps[ib];
+    if (a.maxX + grid < b.minX || b.maxX + grid < a.minX || a.maxY + grid < b.minY || b.maxY + grid < a.minY) return false;
+    const da = dilatedOf(ia);
+    for (let y = b.minY; y <= b.maxY; y++) {
+      for (let x = b.minX; x <= b.maxX; x++) {
+        if (b.mask.data[y * W + x] !== 0 && da.data[y * W + x] !== 0) return true;
+      }
+    }
+    return false;
+  };
+  for (let i = 0; i < comps.length; i++) {
+    for (let j = i + 1; j < comps.length; j++) {
+      if (find(i) !== find(j) && touchesWithinGrid(i, j)) unite(i, j);
+    }
+  }
+  const groups = new Map<number, typeof comps>();
+  for (let i = 0; i < comps.length; i++) {
+    const r = find(i);
+    if (!groups.has(r)) groups.set(r, []);
+    (groups.get(r) as typeof comps).push(comps[i]);
+  }
+  const merged: BackHairMass[] = [];
+  for (const list of groups.values()) {
+    const m = newMask(W, H);
+    let minX = Infinity;
+    let maxX = -Infinity;
+    let minY = Infinity;
+    let maxY = -Infinity;
+    let area = 0;
+    for (const c of list) {
+      minX = Math.min(minX, c.minX);
+      maxX = Math.max(maxX, c.maxX);
+      minY = Math.min(minY, c.minY);
+      maxY = Math.max(maxY, c.maxY);
+      area += c.area;
+      for (let y = c.minY; y <= c.maxY; y++) {
+        for (let x = c.minX; x <= c.maxX; x++) {
+          if (c.mask.data[y * W + x] !== 0) m.data[y * W + x] = 1;
+        }
+      }
+    }
+    merged.push({ side, minX, maxX, minY, maxY, area, mask: m });
+  }
+  const hanging = merged.filter((c) => c.maxY + 1 >= shoulderLine);
+  const out = hanging.length > 0 ? hanging : merged;
+  for (const h of out) {
+    if (h.minY <= y0) {
+      for (let y = Math.max(0, y0 - 12); y < h.minY; y++) {
+        for (let x = h.minX; x <= h.maxX; x++) {
+          if (onSide(x) && mask.data[y * W + x] !== 0) h.mask.data[y * W + x] = 1;
+        }
+      }
+    }
+  }
+  if (hanging.length === 1 && hanging[0].minY <= y0) {
+    const h = hanging[0];
+    const upper = merged.filter((c) => c.maxY + 1 < shoulderLine);
+    if (upper.length > 0) {
+      const a = Math.max(0, y0 - 12);
+      const b = Math.min(H, Math.max(0, y0 + 12));
+      let uMinX = h.minX;
+      let uMaxX = h.maxX;
+      for (let yy = a; yy < b; yy++) {
+        for (let x = 0; x < W; x++) {
+          if (onSide(x) && mask.data[yy * W + x] !== 0) {
+            uMinX = Math.min(uMinX, x);
+            uMaxX = Math.max(uMaxX, x);
+          }
+        }
+      }
+      const rootMid = pyRound(uMinX + 0.5 * (uMaxX - uMinX), 0);
+      if (rootMid >= h.minX && rootMid <= h.maxX) {
+        for (const u of upper) {
+          for (let y = u.minY; y <= u.maxY; y++) {
+            for (let x = u.minX; x <= u.maxX; x++) {
+              if (u.mask.data[y * W + x] !== 0) h.mask.data[y * W + x] = 1;
+            }
+          }
+        }
+        for (let y = Math.max(0, y0 - 12); y < y0; y++) {
+          for (let x = 0; x < W; x++) {
+            if (onSide(x) && mask.data[y * W + x] !== 0) h.mask.data[y * W + x] = 1;
+          }
+        }
+      }
+    }
+  }
+  out.sort((a, b) => a.minX - b.minX);
+  return out;
+}

package/src/config.ts

@@ -139,9 +139,29 @@ export interface Generation {
   control?: Control;
 }
 
+export type ArmSplitTag = 'handwear-r' | 'handwear-l';
+export const ARM_SPLIT_TAGS: readonly ArmSplitTag[] = ['handwear-r', 'handwear-l'];
+
+/**
+ * Issue #439: an optional declaration on `config.seethrough` that separates
+ * overlapping arms in the full run into `handwear-r` (smaller image x, the
+ * character's right as they face the viewer) and `handwear-l` (larger image x,
+ * the character's left) in the draw order `order` states, back to front.
+ * Exactly one of `x` (an integer column on the full run's canvas) or `line`
+ * (a polyline of at least two `[x, y]` integer points on the full run's
+ * canvas) is given.
+ */
+export interface ArmSplit {
+  x?: number;
+  line?: Array<[number, number]>;
+  order: ['handwear-r', 'handwear-l'] | ['handwear-l', 'handwear-r'];
+}
+
 export interface SeeThrough {
   /** Square crop `[x0, y0, x1, y1]` in source pixels for the second, head-only run. */
   head_box?: [number, number, number, number];
+  /** Issue #439: arm separation when both arms overlap in the full run. */
+  arm_split?: ArmSplit;
   resolution: number;
   steps: number;
   seed: number;
@@ -701,9 +721,21 @@ export interface LimbSegment {
   cut_band?: number;
 }
 
+/**
+ * Issue #446: a per-limb split declared on the covering limb where two limbs
+ * share one part and cross: either `line` (a polyline of two or more `[x, y]`
+ * points in rig px along the covering limb's seam) or `edge: "painting"`
+ * (traces the covering limb's painted stroke or silhouette across the crossing).
+ */
+export interface LimbSplit {
+  line?: Array<[number, number]>;
+  edge?: 'painting';
+}
+
 /** A limb (issue #349): its segments, upper first; each segment's bone is the child of the one before. */
 export interface Limb {
   segments: LimbSegment[];
+  split?: LimbSplit;
 }
 
 export interface CharacterConfig {
@@ -1571,10 +1603,10 @@ function checkGeneration(c: Check, v: Json): void {
 }
 
 function checkSeeThrough(c: Check, v: Json): void {
-  const s = c.object('config.seethrough', v, ['resolution', 'steps', 'seed', 'offload'], ['head_box']);
+  const s = c.object('config.seethrough', v, ['resolution', 'steps', 'seed', 'offload'], ['head_box', 'arm_split']);
   if (s === null) return;
   const p = 'config.seethrough';
-  if ('resolution' in s) c.int(`${p}.resolution`, s.resolution, 1);
+  const res = 'resolution' in s && c.int(`${p}.resolution`, s.resolution, 1) ? (s.resolution as number) : null;
   if ('steps' in s) c.int(`${p}.steps`, s.steps, 1);
   if ('seed' in s) c.int(`${p}.seed`, s.seed, 0);
   if ('offload' in s && typeof s.offload !== 'boolean') c.fail('CONFIG_FIELD_TYPE', `${p}.offload`, `is ${show(s.offload)}; true or false is required`);
@@ -1589,6 +1621,55 @@ function checkSeeThrough(c: Check, v: Json): void {
       }
     }
   }
+  if ('arm_split' in s) checkArmSplit(c, `${p}.arm_split`, s.arm_split, res);
+}
+
+function checkArmSplit(c: Check, path: string, v: Json, resolution: number | null): void {
+  const a = c.object(path, v, ['order'], ['x', 'line']);
+  if (a === null) return;
+  if (!('x' in a) && !('line' in a)) {
+    c.fail('CONFIG_FIELD_PRESENT', path, 'has neither x nor line; a split column ("x") or a polyline ("line") is required to separate the arms');
+  } else if ('x' in a && 'line' in a) {
+    c.fail('CONFIG_FIELD_TYPE', `${path}.line`, 'is set alongside x; give either a split column ("x") or a polyline ("line"), not both');
+  }
+  if ('x' in a && c.number(`${path}.x`, a.x, 'non-negative')) {
+    const x = a.x as number;
+    if (resolution !== null && x > resolution) {
+      c.fail('CONFIG_FIELD_TYPE', `${path}.x`, `is ${x}; a column inside the ${resolution}x${resolution} run canvas (0 <= x <= ${resolution}) is required`);
+    }
+  }
+  if ('line' in a) {
+    const l = a.line;
+    if (!Array.isArray(l) || l.length < 2) {
+      c.fail('CONFIG_FIELD_TYPE', `${path}.line`, `is ${show(l)}; an array of at least 2 [x, y] points in run pixels is required`);
+    } else {
+      l.forEach((pt, i) => {
+        const ok = Array.isArray(pt) && pt.length === 2 && pt.every((n) => typeof n === 'number' && Number.isFinite(n));
+        if (!ok) {
+          c.fail('CONFIG_FIELD_TYPE', `${path}.line[${i}]`, `is ${show(pt)}; a point [x, y] in run pixels is required`);
+          return;
+        }
+        const [px, py] = pt as [number, number];
+        if (px < 0 || py < 0 || (resolution !== null && (px > resolution || py > resolution))) {
+          c.fail(
+            'CONFIG_FIELD_TYPE',
+            `${path}.line[${i}]`,
+            `is [${px}, ${py}]; ${resolution !== null ? `a point inside the ${resolution}x${resolution} run canvas (0 <= x, y <= ${resolution})` : 'x >= 0 and y >= 0'} is required`,
+          );
+        }
+      });
+    }
+  }
+  if ('order' in a) {
+    const o = a.order;
+    const valid =
+      Array.isArray(o) &&
+      o.length === 2 &&
+      ((o[0] === 'handwear-r' && o[1] === 'handwear-l') || (o[0] === 'handwear-l' && o[1] === 'handwear-r'));
+    if (!valid) {
+      c.fail('CONFIG_FIELD_TYPE', `${path}.order`, `is ${show(o)}; ["handwear-r", "handwear-l"] or ["handwear-l", "handwear-r"] (back to front) is required`);
+    }
+  }
 }
 
 function checkRunTag(c: Check, path: string, run: Json, tag: Json): void {
@@ -2309,10 +2390,39 @@ function checkLimbs(c: Check, v: Json, made: { parts: string[]; patches: string[
   }
   const sources = new Set([...made.parts, ...made.cuts]);
   const firstAt = new Map<string, string>();
+  const limbFroms = new Map<string, Set<string>>();
+  const splitLimbs: string[] = [];
   for (const [limb, spec] of Object.entries(v)) {
     const at = `config.limbs.${limb}`;
-    const o = c.object(at, spec, ['segments'], []);
-    if (o === null || !('segments' in o)) continue;
+    const o = c.object(at, spec, ['segments'], ['split']);
+    if (o === null) continue;
+    if ('split' in o) {
+      const sp = c.object(`${at}.split`, o.split, [], ['line', 'edge']);
+      if (sp !== null) {
+        const hasLine = 'line' in sp;
+        const hasEdge = 'edge' in sp;
+        if ((hasLine && hasEdge) || (!hasLine && !hasEdge)) {
+          c.fail('CONFIG_FIELD_TYPE', `${at}.split`, `is ${show(o.split)}; either "line" (a polyline of two or more [x, y] points in rig px) or "edge": "painting" is required, not both and not neither`);
+        } else if (hasLine) {
+          const pts = sp.line;
+          const ok =
+            Array.isArray(pts) &&
+            pts.length >= 2 &&
+            pts.every((p) => Array.isArray(p) && p.length === 2 && typeof p[0] === 'number' && Number.isFinite(p[0]) && typeof p[1] === 'number' && Number.isFinite(p[1]));
+          if (!ok) {
+            c.fail('CONFIG_FIELD_TYPE', `${at}.split.line`, `is ${show(pts)}; an array of two or more [x, y] points in rig px is required`);
+          } else {
+            const typed = pts as Array<[number, number]>;
+            if (typed.every((p) => p[0] === typed[0][0] && p[1] === typed[0][1])) {
+              c.fail('CONFIG_FIELD_TYPE', `${at}.split.line`, `is ${show(pts)}; a polyline with non-zero length is required — all points stand on [${typed[0].join(', ')}]`);
+            } else splitLimbs.push(limb);
+          }
+        } else if (sp.edge !== 'painting') {
+          c.fail('CONFIG_FIELD_TYPE', `${at}.split.edge`, `is ${show(sp.edge)}; "painting" is required — traces the covering limb's edge across the crossing from the painting's own stroke or silhouette`);
+        } else splitLimbs.push(limb);
+      }
+    }
+    if (!('segments' in o)) continue;
     if (!Array.isArray(o.segments) || o.segments.length < 2) {
       c.fail('CONFIG_FIELD_TYPE', `${at}.segments`, `is ${show(o.segments)}; an array of two segments or more, upper first, is required — a limb is cut at a joint, and a joint has a segment on each side`);
       continue;
@@ -2382,6 +2492,7 @@ function checkLimbs(c: Check, v: Json, made: { parts: string[]; patches: string[
         }
       }
     });
+    limbFroms.set(limb, new Set(froms.filter((f): f is string => f !== null)));
     froms.forEach((f, i) => {
       if (f === null || i === 0 || froms[i - 1] === f) return;
       const back = froms.slice(0, i - 1).lastIndexOf(f);
@@ -2399,6 +2510,20 @@ function checkLimbs(c: Check, v: Json, made: { parts: string[]; patches: string[
       });
     }
   }
+  for (const limb of splitLimbs) {
+    const myFroms = limbFroms.get(limb) ?? new Set<string>();
+    if (myFroms.size === 0) continue;
+    const sharers = [...limbFroms.entries()].filter(([other, fs]) => other !== limb && [...myFroms].some((f) => fs.has(f)));
+    if (sharers.length === 0) {
+      c.fail('CONFIG_FIELD_TYPE', `config.limbs.${limb}.split`, `is declared on "${limb}", whose from part(s) (${[...myFroms].map((f) => `"${f}"`).join(', ')}) no other limb takes; a per-limb split divides a part shared by two limbs`);
+    } else {
+      const otherSplit = sharers.find(([other]) => splitLimbs.includes(other));
+      if (otherSplit !== undefined) {
+        const sharedFrom = [...myFroms].find((f) => otherSplit[1].has(f)) as string;
+        c.fail('CONFIG_FIELD_TYPE', `config.limbs.${limb}.split`, `is declared on "${limb}" and on "${otherSplit[0]}", which both take "${sharedFrom}"; declare split on the covering limb alone`);
+      }
+    }
+  }
   return out;
 }
 

package/src/diagnostics.ts

@@ -79,6 +79,7 @@ export interface BasisFile {
  * `derived` placement names at least one bone; a constant is a finite number.
  */
 export function checkBasis(P: PartSet, proposal: Proposal, basis: ProposalBasis): void {
+  P = P.beforeLimbs();
   const problems: Problem[] = [];
   const names = [...expand(proposal.bones).byName.keys()];
   const bones = new Set(names);