@rig-c/parts 1.26.0 → 1.27.0

package/docs/AUTHORING.md

@@ -512,7 +512,10 @@ layers, as follows; every step is arithmetic on the declared bones and the layer
   upper pixel inside it, above the line, keeps alpha × (its distance above the line ÷ the band's
   height there): 0 on the line, 1 on the band's arc. Over art that stays opaque under it at any
   angle, the rest pose composites to the hard cut's bytes and no bend shows through the fade what
-  lies behind the limb. The `limb cap:` line adds `edge "feather": N px of "<upper>" faded …`, and
+  lies behind the limb. A pixel the fade lowers to alpha 8 or below (`OPAQUE_ALPHA_ABOVE`) leaves the
+  upper piece's region (its opacity is held by the lower piece's cap beneath), and the rest of the
+  ramp is kept through `pushBackFringe` when another limb crosses in front of the joint (issue #444).
+  The `limb cap:` line adds `edge "feather": N px of "<upper>" faded …`, and
   the record `edge`, `feather_radius` and `feathered_px`.
 - **`cut_band: N`** (issue #360, opt-in on the segment below a joint whose two segments take one
   part). The cut is placed rather than typed: of the lines parallel to the joint line at whole-pixel
@@ -1591,7 +1594,7 @@ What each rule drafts (`src/cloth.ts` holds them):
 | response | link j of an n-link path takes `wind` and `gravity` at j/(n − 1) of the way from the root value to the tip value; a single-link path takes the tip value. Each is a scalar **multiplier** of the environment the consumer sets (spine-core's skeleton `windX, windY`, `gravityX, gravityY`; rig-c 2.52.0's live track `setEnvironment`, rig-play 1.10.0's `environment()`): no direction is drafted | `wind`, `gravity` |
 | out of phase | the odd trees take `alternate_damping`, the even ones `damping` | `damping`, `alternate_damping` |
 | flutter | the last link of every path gets a second physics constraint, `<bone>_translate`, moving x and y by `translate`, with the link's stiffness and damping and **no** wind or gravity response. spine-core scales a translate spring's response by the skeleton's reference scale (100) and a rotation's by the link's length over it, so one response on both pushes an end about 100/length times further than it turns it (the table below) | `translate` |
-| part | `bottomwear` only (issue #402): the named `topwear` part takes the skirt's rule as the `bottomwear` parts do — trees from `hip` over its art below the hip, its waist line, and, as its art reaches above the chest, the chest segment the long-robe `bottomwear` keeps — in place of the two robe chains the topwear rule drafts; the prefix is `skirt` when it is the only skirt, `skirt_<part>` beside another. A `bottomwear` part lying on the named part's tree links rides them and drafts no trees of its own (issue #416, *What rides a dress* below) | `part` |
+| part / parts | `part` (a string on `bottomwear` only, issue #402): the named `topwear` part takes the skirt's rule as the `bottomwear` parts do — trees from `hip` over its art below the hip, its waist line, and, as its art reaches above the chest, the chest segment the long-robe `bottomwear` keeps — in place of the two robe chains the topwear rule drafts; the prefix is `skirt` when it is the only skirt, `skirt_<part>` beside another. A `bottomwear` part lying on the named part's tree links rides them and drafts no trees of its own (issue #416, *What rides a dress* below). `parts` (or `part` as a list, on any tag, issue #437): a non-empty list of distinct part names in root-to-tip order (`["hair_back", "hair_back_front"]`) that share one set of trees drafted from the root part's origin to the last part's tip, each part's mesh receiving only the link segments whose span crosses its opaque art (`spanCrosses > 0`) | `part`, `parts` |
 | swing | `bottomwear` only: a bone `<prefix>_swing` under `hip` at the centre of the root row, one link long, straight down, with physics (the trunk's stiffness, the root's response); each tree's first link takes the swing's rotation times its scale — a transform `<swing>_<k>`, local source and target, additive, the swing's setup rotation in hip's frame (−90: hip is drafted unturned) subtracted — and no physics of its own | `swing.scales` |
 
 Every link but a swing-driven first link gets `<bone>_physics` (`rotate` 1), and no
@@ -2630,7 +2633,8 @@ See-through with another seed.
 | <a id="CONFIG_CLOTH_RESPONSE_GROWS_TO_TIP"></a>`CONFIG_CLOTH_RESPONSE_GROWS_TO_TIP` | a `cloth` recipe's `wind` or `gravity` is `[root, tip]` with tip below root: the response grows from the root to the tip, where the motion accumulates down the chain | that pair |
 | <a id="CONFIG_CLOTH_ALTERNATE_DIFFERS"></a>`CONFIG_CLOTH_ALTERNATE_DIFFERS` | a `cloth` recipe's `alternate_damping` without `damping`, or equal to it: neighbouring trees are declared out of phase, and an alternate that alternates nothing declares nothing | `damping` beside it, a different value, or leave `alternate_damping` out |
 | <a id="CONFIG_CLOTH_SWING_SCALE_PER_TREE"></a>`CONFIG_CLOTH_SWING_SCALE_PER_TREE` | `swing` on a tag other than `bottomwear`, or `swing.scales` not one scale per tree (`chains`) | one scale per tree, in tree order across the skirt |
-| <a id="CONFIG_CLOTH_PART_ON_BOTTOMWEAR"></a>`CONFIG_CLOTH_PART_ON_BOTTOMWEAR` | `part` on a `cloth` recipe for a tag other than `bottomwear` (issue #402) | leave it out there; `part` hands the skirt's recipe to a `topwear` part that holds a skirt (a dress) |
+| <a id="CONFIG_CLOTH_PART_ON_BOTTOMWEAR"></a>`CONFIG_CLOTH_PART_ON_BOTTOMWEAR` | `part` as a string on a `cloth` recipe for a tag other than `bottomwear` (issue #402; a list of parts in `parts` or `part` is accepted on any tag, issue #437) | leave it out there, or pass a list of parts in root-to-tip order (`parts: [...]`); a single string `part` hands the skirt's recipe to a `topwear` part that holds a skirt (a dress) |
+| <a id="CONFIG_CLOTH_PARTS_UNIQUE"></a>`CONFIG_CLOTH_PARTS_UNIQUE` | a `cloth` recipe sets both `part` and `parts`, or its part list names the same part more than once (issue #437) | set at most one of `part` or `parts`, and list each part once in root-to-tip order |
 | <a id="CONFIG_CLOTH_SPRING_STABLE"></a>`CONFIG_CLOTH_SPRING_STABLE` | a `cloth` recipe's strength — declared, or the default 100 / 100 / 50 — whose spring is unstable at a damping the recipe runs at (`damping`, `alternate_damping`, or rig-c's 0.85 when `damping` is left out): k = strength·massInverse·step² at or past 2(1 + damping^(60·step)), step 1/60 and mass 1 (rig-c's defaults; the recipe sets neither). The detail gives k and the bound | a lower strength, or a higher damping |
 | <a id="CONFIG_TURN_BONE_FREE"></a>`CONFIG_TURN_BONE_FREE` | the config has `turn` and `bones` declares a bone named `turn`, the control the rig stage adds | rename that bone |
 | <a id="CONFIG_PROPOSED_RIG_SCALE"></a>`CONFIG_PROPOSED_RIG_SCALE` | `proposed_rig_scale` (the `scale_rig_per_source` `propose` drafted the rig sections at, issue #354) differs from `assemble.rig_scale`: the coordinates in `bones`, `meshes`, `limbs` and `motion` are in that rig canvas's pixels and do not scale when `assemble.rig_scale` changes | re-run `assemble` and `propose` at the new `assemble.rig_scale`, or restore `assemble.rig_scale` to `proposed_rig_scale` |
@@ -2714,7 +2718,7 @@ says why each requirement exists and what breaks without it.
 | <a id="PROPOSE_CUT_FROM_RECORDED"></a>`PROPOSE_CUT_FROM_RECORDED` | two parts share one layer and none of them records `cut_from`: a `parts.json` an `assemble` before 1.6.0 wrote with `assemble.cuts`. The records are in draw order, so which is the plan part and which the piece cannot be read off the file; the message names the parts and the layer. Every other reader still takes the file | `--parts`: re-run assemble (1.6.0+) to record `cut_from` |
 | <a id="PROPOSE_LIMB_PARTS"></a>`PROPOSE_LIMB_PARTS` | `parts.json` holds parts `config.limbs` cut at their joints (issue #349); the limbs are drafted from the parts before the cut, which the rules read by layer | `--parts` a build assembled with the config's `limbs` left out; keep the block the config holds (its caps and ranges are the author's). `propose --from-config` reads the config's bones on either build |
 | <a id="PROPOSE_CLOTH_DRAFTED"></a>`PROPOSE_CLOTH_DRAFTED` | with `--cloth` (issue #364): the config's `cloth` block holds a recipe for a tag the proposer drafts no chain on — no part has that tag, or every `back hair` part ends above the shoulders (a bun bone, no chain). A `bottomwear` recipe with no `bottomwear` part names every `topwear` part shaped like a skirt (issue #402) | leave that recipe out, or assemble the layer it is for, or declare the named part in `cloth.bottomwear.part` |
-| <a id="PROPOSE_CLOTH_PART"></a>`PROPOSE_CLOTH_PART` | with `--cloth` (issue #402): `cloth.bottomwear.part` names no part, a part or cut piece whose source is not `topwear` (a `bottomwear` part takes the recipe by its tag already), or a target whose box ends above the hip + 0.25 face heights, the topwear rule's waist line | name the `topwear` part or its cut skirt piece that holds the skirt, or leave `part` out |
+| <a id="PROPOSE_CLOTH_PART"></a>`PROPOSE_CLOTH_PART` | with `--cloth` (issues #402, #437): `cloth.bottomwear.part` (a string) names no part, a part or cut piece whose source is not `topwear` (a `bottomwear` part takes the recipe by its tag already), or a target whose box ends above the hip + 0.25 face heights, the topwear rule's waist line; or `cloth.<tag>.parts` (or `part` as a list, issue #437) names a part not in `parts.json`, a part no link of the drafted tree crosses (`spanCrosses == 0`), or parts out of root-to-tip depth order along the chain | name the `topwear` part or its cut skirt piece that holds the skirt (or leave `part` out), or list only parts in `parts.json` that the drafted tree links cross in root-to-tip order |
 | <a id="PROPOSE_CLOTH_BACK_HAIR_CHAINS"></a>`PROPOSE_CLOTH_BACK_HAIR_CHAINS` | with `--cloth` (issue #390): `cloth."back hair".chains` exceeds what the narrower side's opaque width at the eye-line root row holds at the part's mesh grid (`max(1, min(floor(w_r / grid), floor(w_l / grid)))`), or places a tree root outside the 15 px dilated art mask of the `back hair` part (e.g. an inner twin-tail root over the face where the hair has no pixel); the message names the part, each side's root-row width, the grid spacing, and any off-art root with its pixel alpha | lower `cloth."back hair".chains` to at most the max fit named in the message, or omit `chains` so `propose --cloth` derives the tree count per side from the root-row tail widths |
 | <a id="PROPOSE_ACCESSORY_BODY"></a>`PROPOSE_ACCESSORY_BODY` | an accessory has nothing above its pendant rows to hang its bone on | that part's plan entry, or author its bones by hand |
 | <a id="PROPOSE_TURN_RUN_GIVEN"></a><a id="PROPOSE_TURN_LAYER_PRESENT"></a><a id="PROPOSE_TURN_DEPTH_PRESENT"></a>`PROPOSE_TURN_RUN_GIVEN`, `PROPOSE_TURN_LAYER_PRESENT`, `PROPOSE_TURN_DEPTH_PRESENT` | with `--full`/`--head` (issue #251): a part came from a run whose layers were not given, the run given holds no layer of the part's tag, or its layer carries no `depth_median` while another part's layer carries one; a run with no depth on any part's layer (a PSD, or an export of one) is not refused — the turn is skipped, and the note says `turn: SKIP` and names the run (issue #359) | give the run the parts were assembled from, as the wrapper's `layers.json` |

package/docs/STABILITY.md

@@ -149,7 +149,7 @@ part name, `[i]` an entry of a list):
 - **meshes.<part>.auto.regions[i]** — required: `name`, `shape`, `maxEdgeLength`, `transition`, `grade`, `minArtSamples`, and `cx`, `cy`, `r` for a circle or `points` for a polygon; optional: `bone`, `band` (both or neither; with neither the region is density only)
 - **meshes.<part>.auto.boundaryRuns** — required: `maxVertices`
 - **meshes.<part>.auto.stimulus**, or each entry of it when a list — required: `chain`, `degrees`
-- **cloth.<tag>**, the tag bottomwear, back hair or front hair (issue #364; read by propose --cloth only) — required: `chains` (optional on `back hair`, issue #390), `links`, `wind`, `gravity`; optional: `split`, `length_ratio`, `strength`, `damping`, `alternate_damping`, `translate`, `swing` (on bottomwear only), `part` (on bottomwear only)
+- **cloth.<tag>**, the tag bottomwear, back hair or front hair (issue #364; read by propose --cloth only) — required: `chains` (optional on `back hair`, issue #390), `links`, `wind`, `gravity`; optional: `split`, `length_ratio`, `strength`, `damping`, `alternate_damping`, `translate`, `swing` (on bottomwear only), `part` (a string on bottomwear, or a list of parts in root-to-tip order on any tag, issue #437), `parts` (a list of parts in root-to-tip order on any tag, issue #437)
 - **cloth.<tag>.split** — required: `at`, `into`; optional: `hold_tip`
 - **cloth.<tag>.strength** — required: `trunk`, `branch`, `edge`
 - **cloth.<tag>.swing** — required: `scales`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rig-c/parts",
-  "version": "1.26.0",
+  "version": "1.27.0",
   "description": "AI-authored 2D character parts from one anime painting and its See-through layer decomposition: measured parts, weighted-mesh rig specs, verified through rig-c before anything is written. A CLI for agents that cannot see the image.",
   "type": "module",
   "bin": {

package/src/assemble.ts

@@ -1208,7 +1208,7 @@ function keepArtWhole(part: PlacedPart, cleared: Cleared[], holderAt: (q: number
  * hold the pixel after it); and every pixel at alpha >= `CORE_ALPHA`, which
  * is the seam override's.
  */
-export function pushBackFringe(parts: PlacedPart[], srcr: Raster, rule: SeamRule, silhouette: Mask | null): FringePushed[][] {
+export function pushBackFringe(parts: PlacedPart[], srcr: Raster, rule: SeamRule, silhouette: Mask | null, feathered: ReadonlyArray<Mask | null> | null = null): FringePushed[][] {
   const { width: W } = srcr;
   const { holder, cand } = seamCandidates(parts, srcr, rule, silhouette);
   const at = (i: number, d: number): number => {
@@ -1226,6 +1226,7 @@ export function pushBackFringe(parts: PlacedPart[], srcr: Raster, rule: SeamRule
     // cover itself the loop below has nothing to clear, and the seam override acts on the pixel as before.
     if (cand[d] === 0 || !shows(d)) continue;
     for (let i = holder[d] + 1; i < parts.length; i++) {
+      if (feathered?.[i]?.data[d] === 1) continue;
       const s = at(i, d);
       if (s < 0) continue;
       const img = parts[i].image.data;
@@ -1889,6 +1890,8 @@ interface Built {
   merged: number;
   /** The rig pixels this piece of the layer owns when the layer is cut, null when it is not: the counts are split by it. */
   region: Mask | null;
+  /** The rig pixels on an upper limb segment whose alpha `edge: "feather"` scaled down (issue #444). */
+  feathered?: Mask;
 }
 
 // ---------------------------------------------------------------------------
@@ -2263,6 +2266,9 @@ function cutLimbs(
       let featheredPx = 0;
       let band = 0;
       if (sg.edge === 'feather') {
+        const upperRegion = regions[upAt];
+        const upPiece = pieces[upAt] as Built;
+        const featheredMask = (upPiece.feathered ??= newMask(W, H));
         band = pyRound(Math.max(0, coveredRadius(line.at, radius, (x, y) => x >= 0 && y >= 0 && x < W && y < H && lower.data[(y * W + x) * 4 + 3] === 255)), 3);
         const fb = capBox(line.at, band);
         for (let y = Math.max(0, fb[1]); y < Math.min(H, fb[1] + fb[3]); y++) {
@@ -2276,6 +2282,11 @@ function cutLimbs(
             if (na === ua) continue;
             if (na === 0) upper.data.fill(0, p * 4, p * 4 + 4);
             else upper.data[p * 4 + 3] = na;
+            // Issue #444: a pixel the feather ramp fades to alpha <= OPAQUE_ALPHA_ABOVE is no longer opaque on the
+            // upper piece (its opacity is carried by the lower segment's opaque cap beneath), so it leaves the upper
+            // piece's region and its remaining ramp is marked feathered so pushBackFringe does not clear the fade.
+            if (na <= OPAQUE_ALPHA_ABOVE) upperRegion.data[p] = 0;
+            else featheredMask.data[p] = 1;
             featheredPx++;
           }
         }
@@ -2840,7 +2851,8 @@ export function assemble(input: AssembleInput): AssembleResult {
     const whole: PartRecord = { name, from: b.key, x: 0, y: 0, w: W, h: H, opaque_px: 0, projected_core_px: 0, source_px_taken: 0, refused_drift_px: 0, merged_px: 0, seam_override_px: 0 };
     return { record: whole, image: b.r };
   });
-  const pushedBy = pushBackFringe(stack, srcr, seamRule, seamRule === 'silhouette' ? silhouette : null);
+  const featheredInOrder: Array<Mask | null> = order.map((d) => ('patch' in d ? null : (pieceAt(d).b.feathered ?? null)));
+  const pushedBy = pushBackFringe(stack, srcr, seamRule, seamRule === 'silhouette' ? silhouette : null, featheredInOrder);
   // Issue #255: a part's drift refusals in a body, and who holds the body in the draw order (the push-back clears
   // only fringe below CORE_ALPHA, and the seam override only recolours, so the holders read here are final).
   const holderAt = new Int32Array(W * H).fill(-1);

package/src/cloth.ts

@@ -95,8 +95,10 @@ export interface ClothRecipe {
   gravity: [number, number];
   translate?: number;
   swing?: { scales: number[] };
-  /** `bottomwear` only: a `topwear` part or its named cut skirt piece the skirt's trees are drafted on. */
-  part?: string;
+  /** `bottomwear` only when a string (a `topwear` part or its cut skirt piece, issue #402); on any target when a list of parts the recipe's trees run through from root to tip (issue #437; the single-part form is the one-element list). */
+  part?: string | string[];
+  /** A list of parts the recipe's trees run through in order from root to tip, one chain across the union and each link weighted to the part whose pixels it crosses (issue #437; the single-part form is the one-element list). */
+  parts?: string[];
 }
 
 export type ClothRecipes = Partial<Record<ClothTarget, ClothRecipe>>;
@@ -469,3 +471,28 @@ export function tailOverlap(tail: Tail, part: Mask, box: { x: number; y: number;
   }
   return { counts, over, total };
 }
+
+/**
+ * Issue #437: how many interior pixel steps along `span` (`a -> b`, sampled at
+ * `(s + 0.5) / ceil(|b - a|)` for `s = 0 .. ceil(|b - a|) - 1`) land on an
+ * opaque pixel of `mask`. Consecutive vertical links `[y0, y1]`, `[y1, y2]`
+ * sample half-open row intervals `[y0, y1)`, `[y1, y2)` with no shared boundary
+ * pixel at the joint `y1`, so a link strictly on one side of a horizontal seam
+ * takes 0 pixels on the other part.
+ */
+export function spanCrosses(span: Pick<TailSpan, 'a' | 'b'>, mask: Mask): number {
+  const [x0, y0] = span.a;
+  const [x1, y1] = span.b;
+  const dx = x1 - x0;
+  const dy = y1 - y0;
+  const steps = Math.max(1, Math.ceil(Math.sqrt(dx * dx + dy * dy)));
+  let count = 0;
+  for (let s = 0; s < steps; s++) {
+    const t = (s + 0.5) / steps;
+    const x = Math.floor(x0 + t * dx);
+    const y = Math.floor(y0 + t * dy);
+    if (x >= 0 && x < mask.width && y >= 0 && y < mask.height && mask.data[y * mask.width + x] !== 0) count++;
+  }
+  return count;
+}
+

package/src/config.ts

@@ -2842,7 +2842,7 @@ function checkCloth(c: Check, v: Json): void {
   for (const tag of CLOTH_TARGETS) {
     if (!(tag in v)) continue;
     const path = `${at}.${JSON.stringify(tag)}`;
-    const r = c.object(path, v[tag], ['links', 'wind', 'gravity'], ['chains', 'split', 'length_ratio', 'strength', 'damping', 'alternate_damping', 'translate', 'swing', 'part']);
+    const r = c.object(path, v[tag], ['links', 'wind', 'gravity'], ['chains', 'split', 'length_ratio', 'strength', 'damping', 'alternate_damping', 'translate', 'swing', 'part', 'parts']);
     if (r === null) continue;
     if (tag !== 'back hair' && !('chains' in r)) c.fail('CONFIG_FIELD_PRESENT', `${path}.chains`, 'is absent and required');
     const chains = 'chains' in r && c.int(`${path}.chains`, r.chains, 1) ? (r.chains as number) : null;
@@ -2897,11 +2897,32 @@ function checkCloth(c: Check, v: Json): void {
     if ('translate' in r && c.number(`${path}.translate`, r.translate, 'unit') && r.translate === 0) {
       c.fail('CONFIG_FIELD_TYPE', `${path}.translate`, 'is 0; a mix above 0 and at most 1 is required (leave translate out for none)');
     }
+    const checkPartList = (fieldPath: string, list: Json): void => {
+      if (!c.array(fieldPath, list, true)) return;
+      const seen = new Set<string>();
+      (list as Json[]).forEach((item, i) => {
+        if (c.string(`${fieldPath}[${i}]`, item)) {
+          const s = item as string;
+          if (seen.has(s)) {
+            c.fail('CONFIG_CLOTH_PARTS_UNIQUE', `${fieldPath}[${i}]`, `repeats "${s}"; each part in the list must be named once, in order from root to tip`);
+          }
+          seen.add(s);
+        }
+      });
+    };
+    if ('part' in r && 'parts' in r) {
+      c.fail('CONFIG_CLOTH_PARTS_UNIQUE', `${path}.parts`, 'is declared beside part; declare either parts (a list of parts from root to tip) or part, not both');
+    }
     if ('part' in r) {
-      if (tag !== 'bottomwear') {
+      if (Array.isArray(r.part)) {
+        checkPartList(`${path}.part`, r.part);
+      } else if (tag !== 'bottomwear') {
         c.fail('CONFIG_CLOTH_PART_ON_BOTTOMWEAR', `${path}.part`, `is declared on "${tag}"; part hands the skirt's recipe (bottomwear) to a topwear part or its cut skirt piece (a dress) — leave it out here`);
       } else c.string(`${path}.part`, r.part);
     }
+    if ('parts' in r) {
+      checkPartList(`${path}.parts`, r.parts);
+    }
     if ('swing' in r) {
       if (tag !== 'bottomwear') {
         c.fail('CONFIG_CLOTH_SWING_SCALE_PER_TREE', `${path}.swing`, `is declared on "${tag}"; the shared swing is the skirt's (bottomwear) — leave it out here`);

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_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 { 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 { TEXTURE_STRETCH_CEILING } from './check.ts';
 
 // ---------------------------------------------------------------------------
@@ -1377,10 +1377,31 @@ export function proposeWithBasis(
   // Issue #364: the trees a cloth recipe drafts, their constraints, and the tags it was used on.
   const clothConstraints: ConfigConstraint[] = [];
   const clothUsed = new Set<ClothTarget>();
+  const multiPartClaimed = new Set<string>();
   const recipeOf = (tag: ClothTarget): ClothRecipe | null => cloth?.[tag] ?? null;
+  const declaredPartsOf = (tag: ClothTarget): { field: 'parts' | 'part'; list: PartRecord[] } | null => {
+    const rcp = recipeOf(tag);
+    if (rcp === null) return null;
+    const raw = rcp.parts !== undefined ? { field: 'parts' as const, names: rcp.parts } : Array.isArray(rcp.part) ? { field: 'part' as const, names: rcp.part } : null;
+    if (raw === null) return null;
+    const object = `config.cloth.${JSON.stringify(tag)}.${raw.field}`;
+    const list: PartRecord[] = [];
+    for (const name of raw.names) {
+      const q = P.recs.find((x) => x.name === name);
+      if (q === undefined) {
+        throw new PartsError([{ code: 'PROPOSE_CLOTH_PART', object, detail: `names "${name}", which is no part in parts.json; every part in the list must exist in parts.json` }]);
+      }
+      if (splitFrom(q.from)[0] === PAINTING_RUN) {
+        throw new PartsError([{ code: 'PROPOSE_CLOTH_PART', object, detail: `names "${name}", from ${q.from}; a painting patch has no layer tag and cannot be part of a cloth tree` }]);
+      }
+      list.push(q);
+    }
+    return { field: raw.field, list };
+  };
   // Issue #391: the tails the back hair recipe drafts, each with its mesh's spans, which an accessory wrapped round one rides.
   const tails: Tail[] = [];
-  const T = (p: PartRecord, tag: ClothTarget, r: ClothRecipe, input: TreeInput): TreeChain[] => {
+  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))];
     for (const t of trees) {
@@ -1389,8 +1410,8 @@ export function proposeWithBasis(
         t.parent,
         t.points,
         t.tip,
-        t.why.map((w) => placement('mask', w, { parts: [p.name], bones: [input.parent], constants })),
-        placement('mask', t.tipWhy, { parts: [p.name], bones: [input.parent], constants }),
+        t.why.map((w) => placement('mask', w, { parts: partNames, bones: [input.parent], constants })),
+        placement('mask', t.tipWhy, { parts: partNames, bones: [input.parent], constants }),
       );
     }
     clothUsed.add(tag);
@@ -1521,7 +1542,225 @@ export function proposeWithBasis(
   };
 
   // ---- back hair
+  const backHairParts = declaredPartsOf('back hair');
+  const backHairSingleSame =
+    backHairParts !== null &&
+    backHairParts.list.length === 1 &&
+    P.headFirst('back hair').length === 1 &&
+    backHairParts.list[0] === P.headFirst('back hair')[0] &&
+    SIDES.every(([s]) => {
+      const m = P.alpha(backHairParts.list[0]);
+      for (let y = 0; y < m.height; y++) {
+        for (let x = 0; x < m.width; x++) {
+          if ((s === 'r' ? x < axis : x >= axis) && m.data[y * m.width + x] !== 0) return true;
+        }
+      }
+      return false;
+    });
+  if (backHairSingleSame) {
+    const p0 = backHairParts.list[0];
+    if (p0.y + p0.h < neckY + 0.5 * fh) {
+      throw new PartsError([
+        {
+          code: 'PROPOSE_CLOTH_PART',
+          object: `config.cloth."back hair".${backHairParts.field}`,
+          detail: `names "${p0.name}" (${p0.from}, box y=${p0.y}..${p0.y + p0.h}), which ends above the shoulders (y=${pyFixed(neckY + 0.5 * fh, 1)}), where the proposer drafts a bun bone with no tree links — no tree link crosses "${p0.name}"`,
+        },
+      ]);
+    }
+  } else if (backHairParts !== null) {
+    const { field, list } = backHairParts;
+    const object = `config.cloth."back hair".${field}`;
+    const rawRcp = recipeOf('back hair') as ClothRecipe;
+    const p0 = list[0];
+    const m0 = P.alpha(p0);
+    const shoulderLine = neckY + 0.5 * fh;
+    const sideHasBelow = (m: Mask, s: 'r' | 'l', yMin: number): boolean => {
+      const r0 = Math.max(0, Math.ceil(yMin));
+      for (let y = r0; y < m.height; y++) {
+        for (let x = 0; x < m.width; x++) {
+          if ((s === 'r' ? x < axis : x >= axis) && m.data[y * m.width + x] !== 0) return true;
+        }
+      }
+      return false;
+    };
+    const activeSides = SIDES.filter(([s]) => list.some((q) => sideHasBelow(P.alpha(q), s, shoulderLine)));
+    if (activeSides.length === 0) {
+      throw new PartsError([
+        {
+          code: 'PROPOSE_CLOTH_PART',
+          object,
+          detail: `names "${p0.name}" (${p0.from}, box y=${p0.y}..${p0.y + p0.h}), which has no art below the shoulders (y=${pyFixed(shoulderLine, 1)}) — no back hair tree link crosses "${p0.name}"`,
+        },
+      ]);
+    }
+    const unionMask = newMask(P.W, P.H);
+    unionMask.data.set(m0.data);
+    for (let idx = 1; idx < list.length; idx++) {
+      const mq = P.alpha(list[idx]);
+      for (const [s] of activeSides) {
+        for (let y = 0; y < P.H; y++) {
+          let p0HasRow = false;
+          for (let x = 0; x < P.W; x++) {
+            if ((s === 'r' ? x < axis : x >= axis) && m0.data[y * P.W + x] !== 0) {
+              p0HasRow = true;
+              break;
+            }
+          }
+          if (p0HasRow) continue;
+          for (let x = 0; x < P.W; x++) {
+            if ((s === 'r' ? x < axis : x >= axis) && mq.data[y * P.W + x] !== 0) {
+              unionMask.data[y * P.W + x] = 1;
+            }
+          }
+        }
+      }
+    }
+    const uRows = rowsAny(unionMask);
+    const top = uRows.length > 0 ? uRows[0] : p0.y;
+    const bot = uRows.length > 0 ? uRows[uRows.length - 1] + 1 : p0.y + p0.h;
+    const [g, r] = gridR(p0);
+    const dilated = dilate(unionMask, 31);
+    const y0 = pyRound(eyeY);
+    const sideOpaqueWidth = (s: 'r' | 'l'): number => {
+      if (y0 < 0 || y0 >= unionMask.height) return 0;
+      let w = 0;
+      for (let x = 0; x < unionMask.width; x++) {
+        if ((s === 'r' ? x < axis : x >= axis) && unionMask.data[y0 * unionMask.width + x]) w++;
+      }
+      return w;
+    };
+    const prefixOf = (s: 'r' | 'l'): string => `hairback_${s}`;
+    const offRootsAt = (cnt: number, s: 'r' | 'l'): Array<{ bone: string; at: Point; alpha: number }> => {
+      const pref = prefixOf(s);
+      const im = P.images.get(p0.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(unionMask, eyeY, { frac: fc, side: s, axis }) ?? axis);
+        if (!isOn(dilated, rx, y0)) {
+          const lx = rx - p0.x;
+          const ly = y0 - p0.y;
+          const alpha = lx >= 0 && lx < p0.w && ly >= 0 && ly < p0.h ? im.data[(ly * p0.w + lx) * 4 + 3] : 0;
+          off.push({ bone: `${pref}${k}_0`, at: [rx, y0], alpha });
+        }
+      }
+      return off;
+    };
+    const sideWidths = activeSides.map(([s]) => sideOpaqueWidth(s));
+    const widthCap = Math.max(1, Math.min(...sideWidths.map((w) => Math.floor(w / g))));
+    let maxFit = 1;
+    for (let cnt = widthCap; cnt >= 1; cnt--) {
+      if (activeSides.every(([s]) => offRootsAt(cnt, s).length === 0)) {
+        maxFit = cnt;
+        break;
+      }
+    }
+    if (rawRcp.chains !== undefined) {
+      const offRoots = activeSides.flatMap(([s]) => offRootsAt(rawRcp.chains as number, s));
+      if (rawRcp.chains > widthCap || offRoots.length > 0) {
+        const wR = sideOpaqueWidth('r');
+        const wL = sideOpaqueWidth('l');
+        throw new PartsError([
+          {
+            code: 'PROPOSE_CLOTH_BACK_HAIR_CHAINS',
+            object: 'config.cloth."back hair".chains',
+            detail:
+              `declares ${rawRcp.chains} tree(s) per side on "${p0.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 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, {
+        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)`,
+        edges: side,
+      });
+      const made = treeConstraints(trees, rcp, null);
+      clothConstraints.push(...made);
+      n += made.length;
+      all.push(...trees);
+    }
+    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];
+      t.points.forEach((q, i) => spans.push({ bone: `${t.chain}${i}`, a: q, b: line[i + 1], link: true, depth: t.depths[i] }));
+    }
+    let prevMinD = -1;
+    let prevMaxD = -1;
+    const linkSummary: string[] = [];
+    for (let idx = 0; idx < list.length; idx++) {
+      const q = list[idx];
+      const mq = P.alpha(q);
+      const crossedLinks = spans.filter((sp) => sp.link && spanCrosses(sp, mq) > 0);
+      if (crossedLinks.length === 0) {
+        const linkDesc = spans
+          .filter((sp) => sp.link)
+          .map((sp) => `${sp.bone} [${sp.a[0]}, ${sp.a[1]}]->[${sp.b[0]}, ${sp.b[1]}]`)
+          .join(', ');
+        throw new PartsError([
+          {
+            code: 'PROPOSE_CLOTH_PART',
+            object,
+            detail: `names "${q.name}" (${q.from}, box x=${q.x}..${q.x + q.w}, y=${q.y}..${q.y + q.h}), which no link of the drafted tree crosses (${linkDesc}: 0 px on "${q.name}") — every part in ${field} must be crossed by at least one link of the tree`,
+          },
+        ]);
+      }
+      const minD = Math.min(...crossedLinks.map((sp) => sp.depth));
+      const maxD = Math.max(...crossedLinks.map((sp) => sp.depth));
+      if (idx > 0 && (minD < prevMinD || maxD < prevMaxD)) {
+        throw new PartsError([
+          {
+            code: 'PROPOSE_CLOTH_PART',
+            object,
+            detail: `names "${q.name}" after "${list[idx - 1].name}", and "${q.name}" is crossed at link depth ${minD}..${maxD} while "${list[idx - 1].name}" is crossed at depth ${prevMinD}..${prevMaxD} — list parts in order from root to tip`,
+          },
+        ]);
+      }
+      prevMinD = minD;
+      prevMaxD = maxD;
+      const [gq, rq] = q === p0 ? [g, r] : gridR(q);
+      const qSegs: Segment[] = [];
+      const crossedDesc: string[] = [];
+      for (const sp of spans) {
+        const px = spanCrosses(sp, mq);
+        if (px > 0) {
+          qSegs.push(sp.link ? sp.bone : [sp.bone, sp.a, sp.b]);
+          if (sp.link) crossedDesc.push(`${sp.bone} (${px} px)`);
+        }
+      }
+      linkSummary.push(`${q.name}: ${crossedDesc.join(', ')}`);
+      delete regions[q.name];
+      meshes[q.name] = { grid: gq, r: rcp.split?.hold_tip === true ? Math.max(rq, gq) : rq, segments: qSegs };
+      multiPartClaimed.add(q.name);
+    }
+    notes.push(
+      clothNote(
+        partNamesLabel,
+        'back hair',
+        all,
+        rcp,
+        n,
+        ` across ${list.length} parts in root-to-tip order (${linkSummary.join('; ')}), from head, rooted on the eye line and tipped 4 px above ${list[list.length - 1].name}'s bottom`,
+      ),
+    );
+    tails.push({ part: p0.name, mask: unionMask, spans });
+  }
   for (const p of P.headFirst('back hair')) {
+    if (multiPartClaimed.has(p.name)) continue;
     const [g, r] = gridR(p);
     const top = p.y;
     const bot = p.y + p.h;
@@ -1536,7 +1775,7 @@ export function proposeWithBasis(
       );
       meshes[p.name] = { grid: g, r, segments: [['head', rnd(head), rnd([axis, top + 13])], 'bun'] };
       tracks.push({ bone: 'bun', prop: 'rotate', amp: 0.8, period: 4.0, phase: 0.2 });
-    } else if (recipeOf('back hair') !== null) {
+    } 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)`
@@ -1660,6 +1899,7 @@ export function proposeWithBasis(
   const turned = 'none' in roll ? 'on the page' : `along the head's down axis (the eye line's perpendicular, roll ${pyFixed(roll.degrees, 3)} degrees)`;
   const rollBones = 'none' in roll ? [] : ['eye_r', 'eye_l'];
   for (const p of P.headFirst('front hair')) {
+    if (multiPartClaimed.has(p.name)) continue;
     const [g, r] = gridR(p);
     const mask = P.alpha(p);
     const top = p.y;
@@ -1805,7 +2045,7 @@ export function proposeWithBasis(
     // Every part with the tag (a plan may take both runs' layers): the biggest
     // gets the bone and chain, the rest ride the head rigidly. A stable sort,
     // as Python's `sorted` is.
-    const cands = [...P.byTag(tag)].sort((a, b) => b.opaque_px - a.opaque_px);
+    const cands = [...P.byTag(tag)].filter((q) => !multiPartClaimed.has(q.name)).sort((a, b) => b.opaque_px - a.opaque_px);
     // Issue #391: a layer of the tag lying on a tail the back hair recipe drafted rides the links it overlaps — the
     // spans of the tail its pixels over the tail's art fall nearest — and not head: its mesh names those bones and no
     // others, so every vertex weights by the rule the tail's own art does. The links are read off the overlap, never
@@ -2173,31 +2413,65 @@ export function proposeWithBasis(
 
   // Issue #402: the topwear part config.cloth.bottomwear.part names takes the skirt's rule and recipe below; every
   // other topwear shaped like a skirt is named in a note when a recipe is in play, never drafted on by its shape.
+  const bottomwearParts = declaredPartsOf('bottomwear');
+  const bottomwearSingleSame =
+    bottomwearParts !== null &&
+    bottomwearParts.list.length === 1 &&
+    bw.length === 1 &&
+    bottomwearParts.list[0] === bw[0];
   const namedSkirt = ((): PartRecord | null => {
-    const name = recipeOf('bottomwear')?.part;
-    if (name === undefined) return null;
-    const refuse = (detail: string): never => {
-      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 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)"}`,
-      );
+    const rawPart = recipeOf('bottomwear')?.part;
+    if (typeof rawPart === 'string') {
+      const name = rawPart;
+      const refuse = (detail: string): never => {
+        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 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)"}`,
+        );
+      }
+      const line = hip[1] + TOPWEAR_HANGS_FACE_HEIGHTS * fh;
+      if (q.y + q.h < line) {
+        return refuse(`names "${name}", whose box ends at y=${q.y + q.h}, above hip + ${TOPWEAR_HANGS_FACE_HEIGHTS} face heights (y=${pyFixed(line, 1)}), where the topwear rule reads a bodice that stops at the waist: no skirt hangs below the hip to hang trees on`);
+      }
+      return q;
     }
-    const line = hip[1] + TOPWEAR_HANGS_FACE_HEIGHTS * fh;
-    if (q.y + q.h < line) {
-      return refuse(`names "${name}", whose box ends at y=${q.y + q.h}, above hip + ${TOPWEAR_HANGS_FACE_HEIGHTS} face heights (y=${pyFixed(line, 1)}), where the topwear rule reads a bodice that stops at the waist: no skirt hangs below the hip to hang trees on`);
+    if (bottomwearParts !== null && bottomwearParts.list.length === 1 && !bottomwearSingleSame) {
+      const q = bottomwearParts.list[0];
+      const object = `config.cloth."bottomwear".${bottomwearParts.field}`;
+      const [run, tag] = splitFrom(q.from);
+      if (run === PAINTING_RUN || tag !== 'topwear') {
+        throw new PartsError([
+          {
+            code: 'PROPOSE_CLOTH_PART',
+            object,
+            detail: `names "${q.name}" (${q.from}, box x=${q.x}..${q.x + q.w}, y=${q.y}..${q.y + q.h}), which no link of the skirt's trees crosses`,
+          },
+        ]);
+      }
+      const line = hip[1] + TOPWEAR_HANGS_FACE_HEIGHTS * fh;
+      if (q.y + q.h < line) {
+        throw new PartsError([
+          {
+            code: 'PROPOSE_CLOTH_PART',
+            object,
+            detail: `names "${q.name}", whose box ends at y=${q.y + q.h}, above hip + ${TOPWEAR_HANGS_FACE_HEIGHTS} face heights (y=${pyFixed(line, 1)}), where the topwear rule reads a bodice that stops at the waist: no skirt hangs below the hip to hang trees on`,
+          },
+        ]);
+      }
+      return q;
     }
-    return q;
+    return null;
   })();
   const skirtHints = new Map<string, string>();
   if (cloth !== null) {
     for (const p of tw) {
-      if (p === namedSkirt) continue;
+      if (p === namedSkirt || multiPartClaimed.has(p.name)) continue;
       const hint = skirtInsideNote(p, P.alpha(p), hip[1], fh);
       if (hint !== null) skirtHints.set(p.name, hint);
     }
@@ -2205,7 +2479,7 @@ export function proposeWithBasis(
 
   // ---- outer robe (topwear)
   for (const p of tw) {
-    if (p === namedSkirt) continue;
+    if (p === namedSkirt || multiPartClaimed.has(p.name)) continue;
     const hint = skirtHints.get(p.name);
     if (hint !== undefined) notes.push(hint);
     const [g, r] = gridR(p);
@@ -2331,16 +2605,145 @@ export function proposeWithBasis(
     return { o, rides: tail.spans.some((sp, k) => sp.link && o.counts[k] > 0) };
   };
   const dressRecipe = recipeOf('bottomwear');
+  if (bottomwearParts !== null && bottomwearParts.list.length >= 2 && dressRecipe !== null) {
+    const { field, list } = bottomwearParts;
+    const object = `config.cloth."bottomwear".${field}`;
+    const p0 = list[0];
+    const m0 = P.alpha(p0);
+    const y0 = hip[1] + 20;
+    const unionMask = newMask(P.W, P.H);
+    unionMask.data.set(m0.data);
+    for (let idx = 1; idx < list.length; idx++) {
+      const mq = P.alpha(list[idx]);
+      for (let y = p0.y; y < P.H; y++) {
+        let p0HasRow = false;
+        for (let x = 0; x < P.W; x++) {
+          if (m0.data[y * P.W + x] !== 0) {
+            p0HasRow = true;
+            break;
+          }
+        }
+        if (p0HasRow) continue;
+        for (let x = 0; x < P.W; x++) {
+          if (mq.data[y * P.W + x] !== 0) unionMask.data[y * P.W + x] = 1;
+        }
+      }
+    }
+    const uRows = rowsAny(unionMask);
+    const bot = uRows.length > 0 ? uRows[uRows.length - 1] + 1 : p0.y + p0.h;
+    if (bot - 4 <= y0) {
+      throw new PartsError([
+        {
+          code: 'PROPOSE_CLOTH_PART',
+          object,
+          detail: `names "${p0.name}" (${p0.from}, box y=${p0.y}..${p0.y + p0.h}), which ends above the skirt root row (y=${pyFixed(y0, 1)}) — no skirt tree link crosses "${p0.name}"`,
+        },
+      ]);
+    }
+    const [g, r] = gridR(p0);
+    const { segs: fixedSegs, hangs } = skirtFrame(p0, m0);
+    if (hangs !== null) notes.push(hangs);
+    const prefix = 'skirt';
+    const partNamesLabel = list.map((q) => q.name).join(' -> ');
+    const trees = T(list, 'bottomwear', dressRecipe, {
+      ...skirtInput(p0, unionMask, prefix),
+      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) {
+      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];
+      const tipAt: [number, number] = [cx, first];
+      B(
+        swingName(prefix),
+        'hip',
+        at,
+        placement('mask', `the centre of ${partNamesLabel}'s art in the 24-row band at the root row (20 px below hip's y)`, { parts: list.map((q) => q.name), bones: ['hip'], constants: [konst('share_across', 0.5)] }),
+        tipAt,
+        placement('derived', `straight down from the swing's origin to the row of the first tree's second link (one link long)`, { bones: [`${trees[0].chain}0`] }),
+      );
+      swing = { bone: swingName(prefix), rest: roundTo((Math.atan2(-(rnd(tipAt)[1] - rnd(at)[1]), rnd(tipAt)[0] - rnd(at)[0]) * 180) / Math.PI, 6) };
+    }
+    const made = treeConstraints(trees, dressRecipe, swing);
+    clothConstraints.push(...made);
+    const spans: Array<TailSpan & { depth: number }> = [];
+    for (const s of fixedSegs) if (typeof s !== 'string') spans.push({ bone: s[0], a: s[1], b: s[2], link: false, depth: -1 });
+    for (const t of trees) {
+      const line = [...t.points, t.tip];
+      t.points.forEach((q, i) => spans.push({ bone: `${t.chain}${i}`, a: q, b: line[i + 1], link: true, depth: t.depths[i] }));
+    }
+    let prevMinD = -1;
+    let prevMaxD = -1;
+    const linkSummary: string[] = [];
+    for (let idx = 0; idx < list.length; idx++) {
+      const q = list[idx];
+      const mq = P.alpha(q);
+      const crossedLinks = spans.filter((sp) => sp.link && spanCrosses(sp, mq) > 0);
+      if (crossedLinks.length === 0) {
+        const linkDesc = spans
+          .filter((sp) => sp.link)
+          .map((sp) => `${sp.bone} [${sp.a[0]}, ${sp.a[1]}]->[${sp.b[0]}, ${sp.b[1]}]`)
+          .join(', ');
+        throw new PartsError([
+          {
+            code: 'PROPOSE_CLOTH_PART',
+            object,
+            detail: `names "${q.name}" (${q.from}, box x=${q.x}..${q.x + q.w}, y=${q.y}..${q.y + q.h}), which no link of the drafted tree crosses (${linkDesc}: 0 px on "${q.name}") — every part in ${field} must be crossed by at least one link of the tree`,
+          },
+        ]);
+      }
+      const minD = Math.min(...crossedLinks.map((sp) => sp.depth));
+      const maxD = Math.max(...crossedLinks.map((sp) => sp.depth));
+      if (idx > 0 && (minD < prevMinD || maxD < prevMaxD)) {
+        throw new PartsError([
+          {
+            code: 'PROPOSE_CLOTH_PART',
+            object,
+            detail: `names "${q.name}" after "${list[idx - 1].name}", and "${q.name}" is crossed at link depth ${minD}..${maxD} while "${list[idx - 1].name}" is crossed at depth ${prevMinD}..${prevMaxD} — list parts in order from root to tip`,
+          },
+        ]);
+      }
+      prevMinD = minD;
+      prevMaxD = maxD;
+      const [gq, rq] = q === p0 ? [g, r] : gridR(q);
+      const qSegs: Segment[] = idx === 0 ? [...fixedSegs] : [];
+      const crossedDesc: string[] = [];
+      for (const sp of spans) {
+        if (!sp.link) continue;
+        const px = spanCrosses(sp, mq);
+        if (px > 0) {
+          qSegs.push(sp.bone);
+          crossedDesc.push(`${sp.bone} (${px} px)`);
+        }
+      }
+      linkSummary.push(`${q.name}: ${crossedDesc.join(', ')}`);
+      delete regions[q.name];
+      meshes[q.name] = { grid: gq, r: dressRecipe.split?.hold_tip === true ? Math.max(rq, gq) : rq, segments: qSegs };
+      multiPartClaimed.add(q.name);
+    }
+    notes.push(
+      clothNote(
+        partNamesLabel,
+        'bottomwear',
+        trees,
+        dressRecipe,
+        made.length,
+        `${swing === null ? '' : ` on one shared swing, ${swing.bone} (each tree's first link takes its rotation times ${dressRecipe.swing?.scales.join('/')}, its setup rotation ${swing.rest} degrees subtracted)`} across ${list.length} parts in root-to-tip order (${linkSummary.join('; ')}) from hip, rooted 20 px below its y and tipped 4 px above ${list[list.length - 1].name}'s bottom, laid down the screen`,
+      ),
+    );
+  }
   const riders: PartRecord[] =
     namedSkirt === null || dressRecipe === null
       ? []
       : ((): PartRecord[] => {
           const mask = P.alpha(namedSkirt);
           const tail = dressTail(namedSkirt, skirtFrame(namedSkirt, mask).segs, draftTrees(skirtInput(namedSkirt, mask, 'skirt'), dressRecipe));
-          return bw.filter((q) => overLinks(tail, q).rides);
+          return bw.filter((q) => !multiPartClaimed.has(q.name) && overLinks(tail, q).rides);
         })();
   let dressDrafted: Tail | null = null;
-  const skirts = namedSkirt === null ? bw : [...bw.filter((q) => !riders.includes(q)), namedSkirt];
+  const skirts = (namedSkirt === null ? bw : [...bw.filter((q) => !riders.includes(q)), namedSkirt]).filter((q) => !multiPartClaimed.has(q.name));
   for (const p of skirts) {
     const [g, r] = gridR(p);
     const mask = P.alpha(p);