@rig-c/parts 1.25.0 → 1.26.0

package/src/headbox.ts

@@ -42,6 +42,20 @@ export const HEAD_LAYER_MIN_PX = 150;
 
 export type Box = [number, number, number, number];
 
+export interface HeadBoxOptions {
+  /** Whether `"back hair"` is included in the union (issue #351); default `true`. */
+  backHair?: boolean;
+}
+
+export interface HeadBoxWithoutBackHair {
+  /** The square box's side in source px without `"back hair"`. */
+  edge: number;
+  /** The box without `"back hair"` before clamping to the painting. */
+  unclamped: Box;
+  /** The box without `"back hair"` held inside the painting, or `null` when `edge` exceeds a canvas side. */
+  head_box: Box | null;
+}
+
 export interface HeadBoxProposal {
   /** The square box, inside the painting: what goes into `seethrough.head_box`. */
   head_box: Box;
@@ -49,8 +63,10 @@ export interface HeadBoxProposal {
   unclamped: Box;
   /** How far the box was moved to stay inside, in source px. */
   shift: [number, number];
-  /** The layers that contributed, with their opaque pixel counts after the clean-up. */
+  /** The layers that contributed, with their opaque pixel counts after the ghost clean-up. */
   layers: Array<[string, number]>;
+  /** Present when `"back hair"` contributed (with `backHair !== false`, issue #351): the box without `"back hair"`. */
+  without_back_hair?: HeadBoxWithoutBackHair;
 }
 
 /**
@@ -90,7 +106,7 @@ function cleanedOpaque(pixels: { width: number; height: number; data: Uint8Clamp
  * `source.w` x `source.h` pixels. Every refusal names the value found and the
  * value required.
  */
-export function proposeHeadBox(full: LayerSet, source: { w: number; h: number }): HeadBoxProposal {
+export function proposeHeadBox(full: LayerSet, source: { w: number; h: number }, opts?: HeadBoxOptions): HeadBoxProposal {
   const problems: Problem[] = [];
   if (!(Number.isInteger(source.w) && Number.isInteger(source.h) && source.w > 0 && source.h > 0)) {
     problems.push({ code: 'HEADBOX_CANVAS_SIZE', object: '--canvas', detail: `is ${source.w}x${source.h}; the painting's size in positive integer pixels is required` });
@@ -102,12 +118,14 @@ export function proposeHeadBox(full: LayerSet, source: { w: number; h: number })
 
   const pad = squarePad(source.w, source.h);
   const k = pad.side / full.canvas.w;
+  const includeBackHair = opts?.backHair !== false;
   // The union does not depend on the order the layers are read in; a name
   // that appears twice is last-wins in draw order (the reference's dict was
   // last-wins in manifest order, and no wrapper output read so far repeats one).
   const boxes = new Map<string, { left: number; top: number; xs: number[]; ys: number[] }>();
   for (const L of full.layers) {
     if (!(HEAD_LAYERS as readonly string[]).includes(L.name)) continue;
+    if (!includeBackHair && L.name === 'back hair') continue;
     const { xs, ys } = cleanedOpaque(L.pixels);
     if (xs.length < HEAD_LAYER_MIN_PX) continue;
     boxes.set(L.name, { left: L.left, top: L.top, xs, ys });
@@ -130,44 +148,60 @@ export function proposeHeadBox(full: LayerSet, source: { w: number; h: number })
     if (f.top + y > fy1) fy1 = f.top + y;
   }
   const cut = fy1 + 0.35 * (fy1 - fy0);
-  let x0 = Infinity;
-  let x1 = -Infinity;
-  let y0 = Infinity;
-  let y1 = -Infinity;
-  for (const b of boxes.values()) {
-    for (let i = 0; i < b.xs.length; i++) {
-      const y = b.top + b.ys[i];
-      if (y > cut) continue;
-      const x = b.left + b.xs[i];
-      if (x < x0) x0 = x;
-      if (x > x1) x1 = x;
-      if (y < y0) y0 = y;
-      if (y > y1) y1 = y;
+  const measureUnion = (entries: Iterable<{ left: number; top: number; xs: number[]; ys: number[] }>): { edge: number; unclamped: Box; shift: [number, number]; head_box: Box | null } => {
+    let x0 = Infinity;
+    let x1 = -Infinity;
+    let y0 = Infinity;
+    let y1 = -Infinity;
+    for (const b of entries) {
+      for (let i = 0; i < b.xs.length; i++) {
+        const y = b.top + b.ys[i];
+        if (y > cut) continue;
+        const x = b.left + b.xs[i];
+        if (x < x0) x0 = x;
+        if (x > x1) x1 = x;
+        if (y < y0) y0 = y;
+        if (y > y1) y1 = y;
+      }
     }
-  }
-  const size = Math.max(x1 - x0, y1 - y0) * 1.12;
-  const cx = (x0 + x1) / 2;
-  const cy = (y0 + y1) / 2;
-  // Each edge rounded as the reference rounds it; then the side is the larger
-  // of the two rounded extents, so the box is square, never holds less than
-  // the reference's, and equals it wherever the reference's was square.
-  const ex = [pyRound((cx - size / 2) * k), pyRound((cx + size / 2) * k)];
-  const ey = [pyRound((cy - size / 2) * k), pyRound((cy + size / 2) * k)];
-  const edge = Math.max(ex[1] - ex[0], ey[1] - ey[0]);
-  const bx = ex[0] - pad.left;
-  const by = ey[0] - pad.top;
-  const unclamped: Box = [bx, by, bx + edge, by + edge];
-  if (edge > source.w || edge > source.h) {
+    const size = Math.max(x1 - x0, y1 - y0) * 1.12;
+    const cx = (x0 + x1) / 2;
+    const cy = (y0 + y1) / 2;
+    // Each edge rounded as the reference rounds it; then the side is the larger
+    // of the two rounded extents, so the box is square, never holds less than
+    // the reference's, and equals it wherever the reference's was square.
+    const ex = [pyRound((cx - size / 2) * k), pyRound((cx + size / 2) * k)];
+    const ey = [pyRound((cy - size / 2) * k), pyRound((cy + size / 2) * k)];
+    const edge = Math.max(ex[1] - ex[0], ey[1] - ey[0]);
+    const bx = ex[0] - pad.left;
+    const by = ey[0] - pad.top;
+    const unclamped: Box = [bx, by, bx + edge, by + edge];
+    if (edge > source.w || edge > source.h) return { edge, unclamped, shift: [0, 0], head_box: null };
+    const hold = (lo: number, extent: number): number => (lo < 0 ? -lo : lo + edge > extent ? extent - edge - lo : 0);
+    const shift: [number, number] = [hold(bx, source.w), hold(by, source.h)];
+    const head_box: Box = [bx + shift[0], by + shift[1], bx + shift[0] + edge, by + shift[1] + edge];
+    return { edge, unclamped, shift, head_box };
+  };
+  const main = measureUnion(boxes.values());
+  const without = includeBackHair && boxes.has('back hair') ? measureUnion([...boxes.entries()].filter(([n]) => n !== 'back hair').map(([, b]) => b)) : null;
+  if (main.head_box === null) {
+    const hairNote =
+      without !== null && without.edge < main.edge
+        ? ` ("back hair" grew the side from ${without.edge} to ${main.edge} px; without it${without.head_box !== null ? `, [${without.head_box.join(', ')}] (${without.edge}x${without.edge}) fits —` : ''} pass --no-back-hair)`
+        : '';
     refuseIfAny([
       {
         code: 'HEADBOX_FITS_CANVAS',
         object: 'head box',
-        detail: `is ${edge}x${edge} source px, proposed at [${unclamped.join(', ')}]; the ${source.w}x${source.h} painting cannot hold it at that size, and shrinking it would cut the head`,
+        detail: `is ${main.edge}x${main.edge} source px, proposed at [${main.unclamped.join(', ')}]; the ${source.w}x${source.h} painting cannot hold it at that size, and shrinking it would cut the head${hairNote}`,
       },
     ]);
   }
-  const hold = (lo: number, extent: number): number => (lo < 0 ? -lo : lo + edge > extent ? extent - edge - lo : 0);
-  const shift: [number, number] = [hold(bx, source.w), hold(by, source.h)];
-  const head_box: Box = [bx + shift[0], by + shift[1], bx + shift[0] + edge, by + shift[1] + edge];
-  return { head_box, unclamped, shift, layers: [...boxes.entries()].map(([n, b]) => [n, b.xs.length]) };
+  return {
+    head_box: main.head_box as Box,
+    unclamped: main.unclamped,
+    shift: main.shift,
+    layers: [...boxes.entries()].map(([n, b]) => [n, b.xs.length]),
+    ...(without === null ? {} : { without_back_hair: { edge: without.edge, unclamped: without.unclamped, head_box: without.head_box } }),
+  };
 }

package/src/propose.ts

@@ -148,7 +148,7 @@ import { TURN_BONE, TURN_CARRIER_TAG, TURN_PLACES, TURN_RIDER_OFFSET, TURN_RIDER
 import { edgeLength } from './length.ts';
 import { limbWidth } from './limbs.ts';
 import { type BranchSqueezeFinding, branchSqueezes, chainSqueezes, type SqueezeFinding } from './squeeze.ts';
-import { RECIPE_LENGTH_RATIO, chainConstraints, clothNote, type ClothRecipe, type ClothRecipes, type ClothTarget, CLOTH_TARGETS, draftTrees, swingName, type Tail, tailOverlap, type TailOverlap, type TailSpan, treeConstraints, type TreeChain, type TreeInput } from './cloth.ts';
+import { RECIPE_BACK_HAIR_CHAINS, RECIPE_LENGTH_RATIO, chainConstraints, clothNote, type ClothRecipe, type ClothRecipes, type ClothTarget, CLOTH_TARGETS, draftTrees, swingName, type Tail, tailOverlap, type TailOverlap, type TailSpan, treeConstraints, type TreeChain, type TreeInput } from './cloth.ts';
 import { TEXTURE_STRETCH_CEILING } from './check.ts';
 
 // ---------------------------------------------------------------------------
@@ -278,20 +278,23 @@ export interface Proposal {
   constraints?: ConfigConstraint[];
   /** Only with `propose --full`/`--head` (issue #251, {@link draftTurn}); absent otherwise, so a proposal without them is the one written before it. */
   turn?: TurnSpec;
+  /** The `assemble.rig_scale` (`parts.json`'s `scale_rig_per_source`) its coordinates were drafted at (issue #354). */
+  proposed_rig_scale: number;
   notes: string[];
 }
 
 /**
  * Every section of a proposal that is a config section, in the order the
  * proposal writes them: what an author copies into the config (issue #375).
- * `notes` is the proposal's own and is copied nowhere. Two of them are written
- * only on request — `limbs` under `--keypoints`, `turn` under `--full`/`--head`
- * — and a `limbs` block left behind is refused at the next step, by the name of
- * every part it cuts. {@link checkProposal} reads the proposal through the config
- * loader by this list, the type below refuses a {@link Proposal} key it does not
- * hold, and the selftest's `TY18` holds every paste sentence in the documents to it.
+ * `notes` is the proposal's own and is copied nowhere. Three of them are written
+ * only on request — `limbs` under `--keypoints`, `constraints` under `--cloth`,
+ * `turn` under `--full`/`--head` — and a `limbs` block left behind is refused
+ * at the next step, by the name of every part it cuts. {@link checkProposal} reads
+ * the proposal through the config loader by this list, the type below refuses a
+ * {@link Proposal} key it does not hold, and the selftest's `TY18` holds every
+ * paste sentence in the documents to it.
  */
-export const PROPOSAL_CONFIG_SECTIONS = ['bones', 'meshes', 'regions', 'limbs', 'motion', 'constraints', 'turn'] as const satisfies ReadonlyArray<Exclude<keyof Proposal, 'notes'>>;
+export const PROPOSAL_CONFIG_SECTIONS = ['bones', 'meshes', 'regions', 'limbs', 'motion', 'constraints', 'turn', 'proposed_rig_scale'] as const satisfies ReadonlyArray<Exclude<keyof Proposal, 'notes'>>;
 
 /** A {@link Proposal} key that is neither `notes` nor in {@link PROPOSAL_CONFIG_SECTIONS}; `never` while the list is whole. */
 type UnlistedProposalSection = Exclude<keyof Proposal, 'notes' | (typeof PROPOSAL_CONFIG_SECTIONS)[number]>;
@@ -414,7 +417,7 @@ export function proposalAssemble(P: PartSet): Record<string, unknown> {
   const planned = run.filter((r) => r.cut_from === undefined && firstOf.get(r.from) === r.name);
   const pieces = run.filter((r) => r.cut_from !== undefined || firstOf.get(r.from) !== r.name);
   return {
-    rig_scale: 1,
+    rig_scale: P.rigScale,
     plan: planned.map((r) => [r.name, ...splitFrom(r.from)]),
     patches: painted.map((r) => ({ name: r.name, box: [r.x, r.y, r.x + r.w, r.y + r.h], alpha: 'box', draw: 'front' })),
     ...(pieces.length === 0
@@ -611,7 +614,7 @@ export function withTurn(p: Proposal, draft: { turn: TurnSpec | null; notes: str
     }
     turn = { pivot: turn.pivot, depths };
   }
-  return { bones: p.bones, meshes: p.meshes, regions: p.regions, ...(p.limbs === undefined ? {} : { limbs: p.limbs }), motion: p.motion, ...(p.constraints === undefined ? {} : { constraints: p.constraints }), ...(turn === null ? {} : { turn }), notes: [...p.notes, ...draft.notes] };
+  return { bones: p.bones, meshes: p.meshes, regions: p.regions, ...(p.limbs === undefined ? {} : { limbs: p.limbs }), motion: p.motion, ...(p.constraints === undefined ? {} : { constraints: p.constraints }), ...(turn === null ? {} : { turn }), proposed_rig_scale: p.proposed_rig_scale, notes: [...p.notes, ...draft.notes] };
 }
 
 // ---------------------------------------------------------------------------
@@ -622,12 +625,14 @@ export function withTurn(p: Proposal, draft: { turn: TurnSpec | null; notes: str
 export class PartSet {
   readonly W: number;
   readonly H: number;
+  readonly rigScale: number;
   readonly recs: readonly PartRecord[];
   readonly images: ReadonlyMap<string, Raster>;
   private readonly masks = new Map<string, Mask>();
 
   constructor(file: PartsFile, images: ReadonlyMap<string, Raster>) {
     [this.W, this.H] = file.rig_size;
+    this.rigScale = file.scale_rig_per_source;
     this.recs = file.parts;
     this.images = images;
   }
@@ -1377,7 +1382,7 @@ export function proposeWithBasis(
   const tails: Tail[] = [];
   const T = (p: PartRecord, tag: ClothTarget, r: ClothRecipe, input: TreeInput): TreeChain[] => {
     const trees = draftTrees(input, r);
-    const constants = [konst('cloth_chains', r.chains), konst('cloth_links', r.links), konst('length_ratio', roundTo(r.length_ratio ?? RECIPE_LENGTH_RATIO, 6))];
+    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))];
     for (const t of trees) {
       C(
         t.chain,
@@ -1534,13 +1539,69 @@ export function proposeWithBasis(
     } else if (recipeOf('back hair') !== null) {
       // 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.
-      const rcp = recipeOf('back hair') as ClothRecipe;
+      // 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`).
+      const rawRcp = recipeOf('back hair') as ClothRecipe;
       const mask = P.alpha(p);
+      const dilated = dilate(mask, 31);
+      const y0 = pyRound(eyeY);
+      const sideOpaqueWidth = (s: 'r' | 'l'): number => {
+        if (y0 < 0 || y0 >= mask.height) return 0;
+        let w = 0;
+        for (let x = 0; x < mask.width; x++) {
+          if ((s === 'r' ? x < axis : x >= axis) && mask.data[y0 * mask.width + x]) w++;
+        }
+        return w;
+      };
+      const prefixOf = (s: 'r' | 'l'): string => (P.headFirst('back hair').length === 1 ? `hairback_${s}` : `hairback_${p.name}_${s}`);
+      const offRootsAt = (cnt: number, s: 'r' | 'l'): Array<{ bone: string; at: Point; alpha: number }> => {
+        const pref = prefixOf(s);
+        const im = P.images.get(p.name) as Raster;
+        const off: Array<{ bone: string; at: Point; alpha: number }> = [];
+        for (let k = 0; k < cnt; k++) {
+          const fc = (k + 0.5) / cnt;
+          const rx = pyRound(bandX(mask, eyeY, { frac: fc, side: s, axis }) ?? axis);
+          if (!isOn(dilated, rx, y0)) {
+            const lx = rx - p.x;
+            const ly = y0 - p.y;
+            const alpha = lx >= 0 && lx < p.w && ly >= 0 && ly < p.h ? im.data[(ly * p.w + lx) * 4 + 3] : 0;
+            off.push({ bone: `${pref}${k}_0`, at: [rx, y0], alpha });
+          }
+        }
+        return off;
+      };
+      const wR = sideOpaqueWidth('r');
+      const wL = sideOpaqueWidth('l');
+      const widthCap = Math.max(1, Math.min(Math.floor(wR / g), Math.floor(wL / g)));
+      let maxFit = 1;
+      for (let cnt = widthCap; cnt >= 1; cnt--) {
+        if (offRootsAt(cnt, 'r').length === 0 && offRootsAt(cnt, 'l').length === 0) {
+          maxFit = cnt;
+          break;
+        }
+      }
+      if (rawRcp.chains !== undefined) {
+        const offRoots = [...offRootsAt(rawRcp.chains, 'r'), ...offRootsAt(rawRcp.chains, 'l')];
+        if (rawRcp.chains > widthCap || offRoots.length > 0) {
+          throw new PartsError([
+            {
+              code: 'PROPOSE_CLOTH_BACK_HAIR_CHAINS',
+              object: 'config.cloth."back hair".chains',
+              detail:
+                `declares ${rawRcp.chains} tree(s) per side on "${p.name}", and at the root row y=${y0} the tail is ${wR} px wide on the r side and ${wL} px on the l side on a ${g} px mesh grid (at most ${maxFit} tree(s) per side fit inside the art` +
+                (offRoots.length > 0 ? `; off the art: ${offRoots.map((o) => `${o.bone} at [${o.at[0]}, ${o.at[1]}] (alpha ${o.alpha})`).join(', ')}` : '') +
+                `) — set chains to at most ${maxFit}, or leave chains out to derive it from the tail's width`,
+            },
+          ]);
+        }
+      }
+      const rcp: ClothRecipe = { ...rawRcp, chains: rawRcp.chains ?? Math.min(RECIPE_BACK_HAIR_CHAINS, maxFit) };
       const segs: Segment[] = [['head', rnd(head), rnd([axis, top + 13])]];
       const all: TreeChain[] = [];
       let n = 0;
       for (const [side] of SIDES) {
-        const prefix = P.headFirst('back hair').length === 1 ? `hairback_${side}` : `hairback_${p.name}_${side}`;
+        const prefix = prefixOf(side);
         const trees = T(p, 'back hair', rcp, {
           prefix,
           parent: 'head',
@@ -2119,9 +2180,10 @@ export function proposeWithBasis(
       throw new PartsError([{ code: 'PROPOSE_CLOTH_PART', object: 'config.cloth."bottomwear".part', detail }]);
     };
     const q = P.recs.find((x) => x.name === name);
-    if (q === undefined) return refuse(`names "${name}", which is no part in parts.json; a topwear part whose art hangs below the hip (a dress) is required`);
-    if (q.cut_from !== undefined) return refuse(`names "${name}", a piece an assemble.cuts entry took from ${q.cut_from}; name the part the plan made, ${q.cut_from}, or leave part out`);
-    if (!tw.includes(q)) {
+    if (q === undefined) return refuse(`names "${name}", which is no part in parts.json; a topwear part or its cut skirt piece whose art hangs below the hip (a dress) is required`);
+    // An explicit name may select a topwear cut piece; automatic tag rules still exclude pieces.
+    const [run, tag] = splitFrom(q.from);
+    if (run === PAINTING_RUN || tag !== 'topwear') {
       return refuse(
         `names "${name}", from ${q.from}; ${splitFrom(q.from)[1] === 'bottomwear' ? 'a bottomwear part takes the recipe by its tag already — leave part out' : "only a topwear part takes the skirt's recipe by name (a skirt See-through returned inside topwear, a dress)"}`,
       );
@@ -2161,8 +2223,8 @@ export function proposeWithBasis(
             ['chest', rnd(along(hip, trunk.u, artExtent(mask, p, hip, trunk.u)[0])), rnd(along(hip, trunk.u, -20))],
             ['hip', rnd(along(hip, trunk.u, -20)), rnd(along(hip, trunk.u, 100))],
           ];
-    if (bw.length > 0 && bot < hip[1] + TOPWEAR_HANGS_FACE_HEIGHTS * fh) {
-      // A bodice that stops at the waist: robe chains down to the hem would fall off the art.
+    if ((bw.length > 0 || namedSkirt?.cut_from === p.name) && bot < hip[1] + TOPWEAR_HANGS_FACE_HEIGHTS * fh) {
+      // A bodice above bottomwear, including its explicitly named cut skirt: robe chains would fall off the art.
       meshes[p.name] = { grid: g, r, segments: segs };
       notes.push(`${p.name} ends at y=${bot} (hip ${pyFixed(hip[1], 0)}): no robe chains -- add a sash chain by hand if one hangs`);
       continue;
@@ -2515,7 +2577,7 @@ export function proposeWithBasis(
   }
   const constrained = clothConstraints.length === 0 ? {} : { constraints: clothConstraints };
   return {
-    proposal: { bones, meshes, regions, ...drafted, motion: blink === undefined ? { duration: IDLE_SECONDS, tracks: idleTracks } : { duration: IDLE_SECONDS, tracks: idleTracks, blink }, ...constrained, notes },
+    proposal: { bones, meshes, regions, ...drafted, motion: blink === undefined ? { duration: IDLE_SECONDS, tracks: idleTracks } : { duration: IDLE_SECONDS, tracks: idleTracks, blink }, ...constrained, proposed_rig_scale: P.rigScale, notes },
     basis: { frame, bones: records },
   };
 }

package/src/rig.ts

@@ -388,6 +388,57 @@ export function roundShares(list: readonly Influence[]): Influence[] {
   return kept;
 }
 
+/**
+ * Issue #392: on a lattice mesh whose segments include sibling branch chains
+ * forked from the same chain link with `r >= grid` (`split.hold_tip: true`),
+ * the distance rule still concentrates weights along the fork row where the
+ * trunk splits into branches and across adjacent trees' ruffled hem steps.
+ * Four Laplacian passes (`FORK_SMOOTH_PASSES`, self share 0.5, floor 0.005, cap
+ * 8 influences) diffuse each vertex's shares across its triangle neighbours
+ * before rounding with {@link roundShares}.
+ */
+export const FORK_SMOOTH_PASSES = 4;
+export const FORK_SMOOTH_SELF = 0.5;
+export const FORK_SMOOTH_FLOOR = 0.005;
+export const FORK_SMOOTH_MAX_INFLUENCES = 8;
+
+export function smoothForkShares(raw: ReadonlyArray<readonly Influence[]>, triangles: readonly number[]): Influence[][] {
+  const adj: number[][] = raw.map(() => []);
+  const addEdge = (u: number, v: number): void => {
+    if (!adj[u].includes(v)) adj[u].push(v);
+    if (!adj[v].includes(u)) adj[v].push(u);
+  };
+  for (let i = 0; i + 2 < triangles.length; i += 3) {
+    const a = triangles[i];
+    const b = triangles[i + 1];
+    const c = triangles[i + 2];
+    addEdge(a, b);
+    addEdge(b, c);
+    addEdge(c, a);
+  }
+  let cur: Influence[][] = raw.map((s) => [...s]);
+  for (let p = 0; p < FORK_SMOOTH_PASSES; p++) {
+    cur = cur.map((own, vi) => {
+      const nb = adj[vi];
+      if (nb.length === 0) return own;
+      const m = new Map<string, number>();
+      for (const { bone, weight } of own) m.set(bone, weight * FORK_SMOOTH_SELF);
+      const nbShare = (1 - FORK_SMOOTH_SELF) / nb.length;
+      for (const u of nb) {
+        for (const { bone, weight } of cur[u]) m.set(bone, (m.get(bone) ?? 0) + weight * nbShare);
+      }
+      const kept = [...m.entries()]
+        .filter(([, w]) => w >= FORK_SMOOTH_FLOOR)
+        .sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+        .slice(0, FORK_SMOOTH_MAX_INFLUENCES);
+      const sum = kept.reduce((s, [, w]) => s + w, 0);
+      return roundShares(kept.map(([bone, w]) => ({ bone, weight: w / sum })));
+    });
+  }
+  return cur;
+}
+
+
 interface Bone {
   name: string;
   parent: string | null;
@@ -957,7 +1008,8 @@ export function buildRig(
       }
       e.points.forEach(([x, y], k) => {
         const n = `${e.chain}${k}`;
-        B.set(n, { name: n, parent: k === 0 ? e.parent : names[names.length - 1], x, y });
+        const inherit = e.link_inherit?.[n];
+        B.set(n, { name: n, parent: k === 0 ? e.parent : names[names.length - 1], x, y, ...(inherit === undefined ? {} : { inherit }) });
         if (names.length > 0) child.set(names[names.length - 1], [x, y]);
         names.push(n);
       });
@@ -1854,6 +1906,7 @@ export function buildRig(
     const segsAt = dressSegsAt(p, segs);
     let emptied: { vertex: number; at: Point; capped: Influence[] } | null = null;
     let emptiedMore = 0;
+    const rawShares: Influence[][] = [];
     for (const [vi, [vx0, vy0]] of lm.vertices.entries()) {
       const wx = vx0 + ox;
       const wy = vy0 + oy;
@@ -1865,7 +1918,26 @@ export function buildRig(
         else emptiedMore++;
         continue;
       }
-      const ent: WeightEntry[] = (limits.floor === 'continuous' ? roundShares(shares) : latticeShares(shares)).map(({ bone, weight }) => {
+      rawShares.push(limits.floor === 'continuous' ? roundShares(shares) : latticeShares(shares));
+    }
+    if (emptied !== null) {
+      problems.push(nothingKeptProblem(p.name, limits.floor, emptied, emptiedMore));
+      continue;
+    }
+    const allChainLinks = new Set([...chains.values()].flat());
+    const forkCounts = new Map<string, number>();
+    for (const sp of mesh.segments) {
+      if (typeof sp !== 'string') continue;
+      const links = chains.get(sp);
+      const par = links !== undefined && links.length > 0 ? (B.get(links[0])?.parent ?? null) : null;
+      if (par !== null && allChainLinks.has(par)) forkCounts.set(par, (forkCounts.get(par) ?? 0) + 1);
+    }
+    const heldFork = heat === null && mesh.r >= mesh.grid && mesh.influences === undefined && [...forkCounts.values()].some((c) => c >= 2);
+    const finalShares = heldFork ? smoothForkShares(rawShares, lm.triangles) : rawShares;
+    for (const [vi, [vx0, vy0]] of lm.vertices.entries()) {
+      const wx = vx0 + ox;
+      const wy = vy0 + oy;
+      const ent: WeightEntry[] = finalShares[vi].map(({ bone, weight }) => {
         const [x, y] = toBoneLocal(world.get(bone) as BoneTransform, spineX(wx), spineY(wy));
         return { bone, x: places(x), y: places(y), weight };
       });
@@ -1873,10 +1945,6 @@ export function buildRig(
       infl += ent.length;
       maxInfl = Math.max(maxInfl, ent.length);
     }
-    if (emptied !== null) {
-      problems.push(nothingKeptProblem(p.name, limits.floor, emptied, emptiedMore));
-      continue;
-    }
     const uvs: number[] = [];
     for (const [x, y] of lm.vertices) uvs.push(pyRound(x / w, 6), pyRound(y / h, 6));
     skin[p.name] = { [p.name]: { type: 'mesh', image: file, width: w, height: h, uvs, triangles: lm.triangles, hull: lm.hull, weights } };