@rig-c/parts 1.20.0 → 1.21.0

package/src/config.ts

@@ -213,6 +213,16 @@ export interface Cut {
    * pixels; it is read nowhere else. Absent: the base keeps only its band.
    */
   under?: string;
+  /**
+   * Issue #360 (item 11), optional, one value: `"colour"` — where the under
+   * fills a removed pixel, the base takes the under's colour and keeps the
+   * alpha the cut removed there, so the part's silhouette is the uncut
+   * layer's and never grows. The under is `under`'s image or the part's
+   * hidden-art layer (issue #359); a cut with neither is refused by the
+   * assemble stage (`ASSEMBLE_UNDER_FILL_SOURCE`). Absent: the base takes the
+   * under's colour and alpha, issue #193's rule.
+   */
+  under_fill?: 'colour';
 }
 
 export interface Assemble {
@@ -643,9 +653,15 @@ export interface ConfigConstraint {
  * pixels it takes (`from`: a plan part or a cut's piece), and the one bone it
  * rides with weight 1. Every segment after the first sits below a joint at
  * its bone's origin: `joint` names it, `range` is the bend the joint may take
- * from rest, `[min, max]` degrees (metadata: read by the stress readers, not
- * by rig-c), and `cap` an image, relative to the config's directory, of the
- * cap that overlaps the joint (`limbCaps` in `src/assemble.ts`).
+ * from rest, `[min, max]` degrees (carried into `parts.json` and posed by
+ * `check`'s `SEAM_OVER_RANGE`, issue #360; not read by rig-c), and `cap` an
+ * image, relative to the config's directory, of the cap that overlaps the
+ * joint (`limbCaps` in `src/assemble.ts`). Two opt-in fields shape the cut at
+ * the joint (issue #360, `src/limbs.ts`): `edge: "feather"` fades the upper
+ * piece out across the cap, and `cap_shape: "disc"` sizes the cap by the
+ * limb's half-width about the joint and fills it from the art, the upper
+ * segment's included. Absent, the cut
+ * is hard and the cap the layer's half-disc of half the limb's width.
  */
 export interface LimbSegment {
   part: string;
@@ -654,6 +670,8 @@ export interface LimbSegment {
   joint?: string;
   range?: [number, number];
   cap?: string;
+  edge?: 'feather';
+  cap_shape?: 'disc';
 }
 
 /** A limb (issue #349): its segments, upper first; each segment's bone is the child of the one before. */
@@ -1340,25 +1358,36 @@ export interface SkeletonSections {
 
 /**
  * A `proposal.json` as `propose` writes it — `bones`, `meshes`, `regions`,
- * `motion` and `notes` (strings) — under the full loader's own rules for the
- * four rig sections (issue #85). There is no plan to hold the meshes and
- * regions against, so the coverage rule (every plan part exactly one of a
- * mesh or a region) is the one rule not run; `propose` held its proposal to
- * it before writing (`checkProposal`). A key the loader would not take is
+ * `motion` and `notes` (strings), `limbs` when `propose --keypoints` drafted
+ * them (issue #349) and `constraints` when `propose --cloth` did (issue #364;
+ * both read here since issue #372, whose `wind` example tracks such a
+ * proposal) — under the full loader's own rules for those sections (issue
+ * #85). There is no plan to hold the meshes, regions and limbs against, so
+ * the coverage rule (every plan part exactly one of a mesh or a region) is
+ * not run, and a limb segment's `from` is held to no plan part (the parts
+ * the limbs take are the ones they name); `propose` held its proposal to
+ * both before writing (`checkProposal`). A key the loader would not take is
  * refused by name, as in a config. Refusals name the fields `proposal.…`.
  */
-export function parseProposalSections(raw: Json): SkeletonSections {
+export function parseProposalSections(raw: Json): SkeletonSections & { limbs?: Record<string, Limb>; constraints?: ConfigConstraint[] } {
   const c = new Check();
-  const top = c.object('config', raw, ['bones', 'meshes', 'regions', 'motion'], ['notes']);
+  const top = c.object('config', raw, ['bones', 'meshes', 'regions', 'motion'], ['notes', 'limbs', 'constraints']);
   if (top !== null) {
     const names = 'bones' in top ? checkBones(c, top.bones) : { bones: new Set<string>([ROOT_BONE]), chains: new Map<string, number>(), parents: new Map<string, string>() };
+    if ('limbs' in top) {
+      const taken = isPlainObject(top.limbs)
+        ? Object.values(top.limbs).flatMap((l) => (isPlainObject(l) && Array.isArray(l.segments) ? l.segments.flatMap((sg) => (isPlainObject(sg) && typeof sg.from === 'string' ? [sg.from] : [])) : []))
+        : [];
+      checkLimbs(c, top.limbs, { parts: [...new Set(taken)], patches: [], cuts: [] }, names);
+    }
     if ('meshes' in top) checkMeshes(c, top.meshes, names.bones, names.chains);
     if ('regions' in top) checkRegions(c, top.regions, names.bones);
     if ('motion' in top) checkMotion(c, top.motion, names.bones, names.chains, 'regions' in top ? top.regions : undefined);
+    if ('constraints' in top) checkConstraints(c, top.constraints, names.bones, names.parents);
     if ('notes' in top && c.array('config.notes', top.notes, false)) (top.notes as Json[]).forEach((n, i) => c.string(`config.notes[${i}]`, n, false));
   }
   refuseIfAny(c.problems.map((p) => ({ ...p, object: p.object.replace(/^config\b/, 'proposal') })));
-  return raw as SkeletonSections;
+  return raw as SkeletonSections & { limbs?: Record<string, Limb>; constraints?: ConfigConstraint[] };
 }
 
 /**
@@ -1548,7 +1577,9 @@ function checkAssemble(c: Check, v: Json, door: 'assemble' | 'full'): { parts: s
 /**
  * `assemble.cuts` (issue #170): each entry `{from, into, polygon, draw, overlap}`
  * and optionally `under` (issue #193, a non-empty path string; the assemble
- * stage reads the file), refused field by field. `from` must be a plan part — a cut of a patch or of
+ * stage reads the file) and `under_fill` (issue #360, the one value
+ * `"colour"`; whether the cut has an under to fill with is the assemble
+ * stage's to judge, since a hidden-art layer can be one), refused field by field. `from` must be a plan part — a cut of a patch or of
  * another cut's piece is refused, so every piece's provenance is one layer and
  * one polygon. `into` is a new part name: not a plan part, not a patch, not
  * another cut's. Returns the names the cuts make, in order.
@@ -1560,11 +1591,14 @@ function checkCuts(c: Check, v: Json, plan: string[], patches: string[]): string
   const seen = new Map<string, number>();
   (v as Json[]).forEach((entry, i) => {
     const at = `${p}[${i}]`;
-    const e = c.object(at, entry, ['from', 'into', 'polygon', 'draw', 'overlap'], ['under']);
+    const e = c.object(at, entry, ['from', 'into', 'polygon', 'draw', 'overlap'], ['under', 'under_fill']);
     if (e === null) return;
     if ('under' in e && !(typeof e.under === 'string' && e.under !== '')) {
       c.fail('CONFIG_FIELD_TYPE', `${at}.under`, `is ${show(e.under)}; a non-empty path to a PNG is required, relative to the config's directory — the image of what lies under the piece, in rig pixels over the polygon's bounding box`);
     }
+    if ('under_fill' in e && e.under_fill !== 'colour') {
+      c.fail('CONFIG_FIELD_TYPE', `${at}.under_fill`, `is ${show(e.under_fill)}; "colour" is required — the base takes the under's colour and keeps the alpha the cut removed, so its silhouette does not grow; leave under_fill out for the under's colour and alpha`);
+    }
     if ('overlap' in e && !(typeof e.overlap === 'number' && Number.isInteger(e.overlap) && e.overlap >= 0)) {
       c.fail('CONFIG_FIELD_TYPE', `${at}.overlap`, `is ${show(e.overlap)}; a non-negative integer of rig pixels is required — the band inside the cut's edge the part keeps under the piece, 0 for none`);
     }
@@ -2165,7 +2199,10 @@ interface LimbNames {
  * the joint, its origin); the first segment has no joint, every other names
  * one (`CONFIG_KEY_KNOWN`, `CONFIG_FIELD_PRESENT`); `range` two finite
  * degrees `[min, max]` with `min <= 0 <= max` (`CONFIG_LIMB_RANGE`: the range
- * is measured from rest, so rest is in it); `cap` a non-empty path. A limb
+ * is measured from rest, so rest is in it); `cap` a non-empty path; `edge`
+ * `"feather"` and `cap_shape` `"disc"` (issue #360), each the one value its
+ * field takes — absent is the hard cut and the layer's half-disc
+ * (`CONFIG_FIELD_TYPE` on any other). A limb
  * has two segments or more. With `names` null (no `bones`), bones are not
  * resolved. Returns the limb parts and the parts the limbs take.
  */
@@ -2190,13 +2227,13 @@ function checkLimbs(c: Check, v: Json, made: { parts: string[]; patches: string[
     const bones: Array<string | null> = [];
     segs.forEach((entry, i) => {
       const sat = `${at}.segments[${i}]`;
-      const e = c.object(sat, entry, ['part', 'from', 'bone'], ['joint', 'range', 'cap']);
+      const e = c.object(sat, entry, ['part', 'from', 'bone'], ['joint', 'range', 'cap', 'edge', 'cap_shape']);
       froms.push(null);
       bones.push(null);
       if (e === null) return;
       // The upper segment sits below no joint; every other sits below one, which it names.
       if (i === 0) {
-        for (const k of ['joint', 'range', 'cap'].filter((q) => q in e)) c.fail('CONFIG_KEY_KNOWN', `${sat}.${k}`, `is not a field on the upper segment; it sits below no joint, so ${k} belongs to the segment below the joint it names (segments[1] and on)`);
+        for (const k of ['joint', 'range', 'cap', 'edge', 'cap_shape'].filter((q) => q in e)) c.fail('CONFIG_KEY_KNOWN', `${sat}.${k}`, `is not a field on the upper segment; it sits below no joint, so ${k} belongs to the segment below the joint it names (segments[1] and on)`);
       } else if (!('joint' in e)) c.fail('CONFIG_FIELD_PRESENT', `${sat}.joint`, 'is absent and required; a segment after the first sits below a joint, at its bone\'s origin, and names it');
       if ('part' in e && c.string(`${sat}.part`, e.part)) {
         const name = e.part;
@@ -2234,6 +2271,13 @@ function checkLimbs(c: Check, v: Json, made: { parts: string[]; patches: string[
       if ('cap' in e && !(typeof e.cap === 'string' && e.cap !== '')) {
         c.fail('CONFIG_FIELD_TYPE', `${sat}.cap`, `is ${show(e.cap)}; a non-empty path to a PNG is required, relative to the config's directory — the cap's image over the box assemble's limb line prints`);
       }
+      // Issue #360: the cut's geometry at the joint, each field one value; absent is the hard cut and the layer's half-disc.
+      if ('edge' in e && e.edge !== 'feather') {
+        c.fail('CONFIG_FIELD_TYPE', `${sat}.edge`, `is ${show(e.edge)}; "feather" is required — the upper piece fades out across the cap instead of stopping at the joint line; leave edge out for the hard cut`);
+      }
+      if ('cap_shape' in e && e.cap_shape !== 'disc') {
+        c.fail('CONFIG_FIELD_TYPE', `${sat}.cap_shape`, `is ${show(e.cap_shape)}; "disc" is required — the cap a disc of the limb's half-width about the joint, filled from the art, the upper segment's included; leave cap_shape out for the layer's half-disc of half the limb's width`);
+      }
     });
     froms.forEach((f, i) => {
       if (f === null || i === 0 || froms[i - 1] === f) return;

package/src/limbs.ts

@@ -41,6 +41,27 @@
  *   shows no gap. The tool invents none of them: each is the config's cap
  *   image's where that image is not transparent, else the layer's where the
  *   limb has art there, else missing — counted, and named in the limb line.
+ * - **`cap_shape: "disc"`** (issue #360, items 10 and 12; opt-in on the
+ *   segment below the joint). The radius is the limb's half-width about the
+ *   joint, not half its width: the distance from the joint to the nearer end
+ *   of the same run along the joint line, each end half a pixel past its
+ *   centre ({@link halfWidthAbout}) — so the disc lies on the limb's art
+ *   across the line however far off the run's middle the bone sits. The cap
+ *   takes, after the image's and the layer's, the upper segment's art at a
+ *   pixel the lower's layer has none of: the whole half-disc comes from the
+ *   art. The upper piece's corner at the cut is kept where it is: on a joint
+ *   off the limb's middle, a corner trimmed to the disc leaves a notch at
+ *   rest when nothing takes it, or a stub out of the bent lower piece's
+ *   outline when the lower takes it (issue #360, unit B's sheets).
+ * - **`edge: "feather"`** (issue #360, item 9; opt-in on the segment below the
+ *   joint). The overlap band is the disc about the joint that the lower
+ *   piece covers at every turn ({@link coveredRadius}: the cap's disc, less
+ *   any pixel the cap is missing and a bilinear sample's reach). Inside it,
+ *   on the upper side of the line, the upper piece's alpha is scaled by
+ *   {@link featherWeight}: 0 on the line, 1 on the band's arc. The band fades
+ *   out across its width over art that stays opaque under it at any angle,
+ *   so at rest the two pieces composite to what they did and a bend never
+ *   shows through it what lies behind the limb.
  */
 import type { BoneEntry, Limb } from './config.ts';
 
@@ -144,11 +165,12 @@ export function segmentOf(lines: ReadonlyArray<JointLine | null>, first: number,
 }
 
 /**
- * The limb's width at a joint (module comment): `art(x, y)` says whether the
- * limb has art at a pixel; the box `[x0, y0, x1, y1]` (inclusive) bounds the
- * search. Null when no pixel of the run lies within 1 px of the joint.
+ * The limb's run of art along a joint line (module comment): the offsets
+ * along the line, from the joint, of the first and the last pixel centre of
+ * the run through the joint, `[first, last]` with `first <= last`. Null when
+ * no pixel of the run lies within 1 px of the joint.
  */
-export function limbWidth(line: JointLine, art: (x: number, y: number) => boolean, box: readonly [number, number, number, number]): number | null {
+export function limbRun(line: JointLine, art: (x: number, y: number) => boolean, box: readonly [number, number, number, number]): [number, number] | null {
   const [ax, ay] = line.axis;
   const ts: number[] = [];
   for (let y = box[1]; y <= box[3]; y++) {
@@ -170,7 +192,67 @@ export function limbWidth(line: JointLine, art: (x: number, y: number) => boolea
   let hi = near;
   while (lo > 0 && ts[lo] - ts[lo - 1] <= 1.5) lo--;
   while (hi + 1 < ts.length && ts[hi + 1] - ts[hi] <= 1.5) hi++;
-  return ts[hi] - ts[lo] + 1;
+  return [ts[lo], ts[hi]];
+}
+
+/** The limb's width at a joint (module comment): its run's first to last pixel centre, plus one pixel. Null with no run. */
+export function limbWidth(line: JointLine, art: (x: number, y: number) => boolean, box: readonly [number, number, number, number]): number | null {
+  const r = limbRun(line, art, box);
+  return r === null ? null : r[1] - r[0] + 1;
+}
+
+/**
+ * The limb's half-width about the joint (issue #360, `cap_shape: "disc"`): the
+ * distance from the joint to the nearer end of its run, each end half a pixel
+ * past its centre — `min(last + 0.5, 0.5 - first)`. Half the width when the
+ * joint sits in the middle of the run; less when it sits off it. Zero or below
+ * when the joint sits on the run's edge.
+ */
+export function halfWidthAbout(run: readonly [number, number]): number {
+  return Math.min(run[1] + 0.5, 0.5 - run[0]);
+}
+
+/** Where a pixel's centre lies from a joint: `along` the axis (above 0 past the line), and `across` it (the run's offset). */
+export function jointOffsets(line: JointLine, px: number, py: number): { along: number; across: number } {
+  const dx = px + 0.5 - line.at[0];
+  const dy = py + 0.5 - line.at[1];
+  return { along: dx * line.axis[0] + dy * line.axis[1], across: -dx * line.axis[1] + dy * line.axis[0] };
+}
+
+/**
+ * The radius the feathered edge fades over (issue #360, `edge: "feather"`):
+ * the disc about the joint the lower piece covers at every turn. It is the
+ * distance from the joint to the nearest pixel centre the lower piece does not
+ * hold at alpha 255 (`opaque` false; searched out to `radius` + 2), less
+ * sqrt(2), the farthest a bilinear sample reaches to its four texels — so a
+ * pixel within it, turned by any angle about the joint, still samples only
+ * the lower's opaque art — and at most `radius`. Zero or below: no pixel is
+ * covered at every turn, and nothing is feathered.
+ */
+export function coveredRadius(at: Pt, radius: number, opaque: (x: number, y: number) => boolean): number {
+  const [x0, y0, w, h] = capBox(at, radius + 2);
+  let near = radius + 2;
+  for (let y = y0; y < y0 + h; y++) {
+    for (let x = x0; x < x0 + w; x++) {
+      if (opaque(x, y)) continue;
+      const d = Math.sqrt((x + 0.5 - at[0]) ** 2 + (y + 0.5 - at[1]) ** 2);
+      if (d < near) near = d;
+    }
+  }
+  return Math.min(radius, near - Math.SQRT2);
+}
+
+/**
+ * The feathered edge's weight on the upper piece (issue #360, `edge:
+ * "feather"`) at a pixel inside the joint's disc on the upper side of its line:
+ * its distance above the line over the disc's height there,
+ * `-along / sqrt(radius² - across²)` — 0 on the line, 1 on the disc's arc, so
+ * the overlap band fades out across its width. 1 where the disc has no height.
+ */
+export function featherWeight(radius: number, along: number, across: number): number {
+  const h2 = radius * radius - across * across;
+  if (h2 <= 0) return 1;
+  return Math.max(0, Math.min(1, -along / Math.sqrt(h2)));
 }
 
 /** The box `[x, y, w, h]` (rig px) of the pixels whose centre lies within `radius` of `at`: the cap image's size and place. */

package/src/parts.ts

@@ -45,7 +45,8 @@
  * 1.6.0 has none, and still reads. `limb`, written only on a part a
  * `config.limbs` segment made (issue #349), names the limb, the segment's
  * index (0 the upper), the part it was cut from (`of`), the one bone it rides
- * and, below a joint, the joint and its cap ({@link LimbRecord}).
+ * and, below a joint, the joint, its declared `range` when there is one
+ * (issue #360) and its cap ({@link LimbRecord}).
  *
  * ⭐ **A patch is 100 % source.** Every pixel of a `painting:` part is the
  * painting's own, so it is all visible (the painting shows it; nothing of it
@@ -118,7 +119,9 @@ export interface PartRecord {
 /**
  * A limb segment's provenance (issue #349): the limb, the segment's index
  * (0 the upper), the part its pixels were cut from (`of`), the bone it rides
- * with weight 1, and, on a segment below a joint, the joint's name and its cap.
+ * with weight 1, and, on a segment below a joint, the joint's name, the
+ * `range` its config segment declares (issue #360: `[min, max]` degrees from
+ * rest, written only when declared; `check` poses the joint there) and its cap.
  */
 export interface LimbRecord {
   name: string;
@@ -126,6 +129,7 @@ export interface LimbRecord {
   of: string;
   bone: string;
   joint?: string;
+  range?: [number, number];
   cap?: CapRecord;
 }
 
@@ -147,10 +151,27 @@ export interface CapRecord {
   /** Issue #359: with `image_px`, the hidden-art layer the cap's image came from (`<run>:<layer>:hidden`), when it came from one rather than the config's cap file. */
   image_layer?: string;
   missing_px: number;
+  /**
+   * Issue #360, written only under the segment's `cap_shape: "disc"`: the
+   * shape; the cap's pixels taken from the upper segment's art where the
+   * lower's layer had none (`upper_px`). `radius` is then the half-width about the
+   * joint, at most half of `width`.
+   */
+  shape?: 'disc';
+  upper_px?: number;
+  /**
+   * Issue #360, written only under the segment's `edge: "feather"`: the edge,
+   * the radius of the band it fades over (the disc the lower piece covers at
+   * every turn, `coveredRadius` in `src/limbs.ts`), and the upper piece's
+   * pixels whose alpha it lowered.
+   */
+  edge?: 'feather';
+  feather_radius?: number;
+  feathered_px?: number;
 }
 
-const LIMB_KEYS = ['name', 'segment', 'of', 'bone', 'joint', 'cap'] as const;
-const CAP_KEYS = ['at', 'width', 'radius', 'box', 'layer_px', 'image_px', 'image_layer', 'missing_px'] as const;
+const LIMB_KEYS = ['name', 'segment', 'of', 'bone', 'joint', 'range', 'cap'] as const;
+const CAP_KEYS = ['at', 'width', 'radius', 'box', 'layer_px', 'image_px', 'image_layer', 'missing_px', 'shape', 'upper_px', 'edge', 'feather_radius', 'feathered_px'] as const;
 
 /** The limb record with its keys in the fixed order, so two runs write the same bytes. */
 function orderedLimb(l: LimbRecord): Record<string, unknown> {
@@ -470,6 +491,14 @@ function checkParts(raw: unknown, path: string): PartsFile {
       const below = isCount(q.segment) && q.segment > 0;
       if (below !== ('joint' in q) || below !== ('cap' in q)) fail('PARTS_FIELD_PRESENT', object, `segment ${show(q.segment)} with${'joint' in q ? '' : 'out'} a joint and with${'cap' in q ? '' : 'out'} a cap; a segment below a joint (index above 0) has both, the upper segment neither`);
       if ('joint' in q && !(typeof q.joint === 'string' && q.joint !== '')) fail('PARTS_FIELD_TYPE', `${object} "joint"`, `is ${show(q.joint)}; the joint's name is required`);
+      // Issue #360: a declared range rides below a joint only, and holds the loader's rule — two degrees, rest in it.
+      if ('range' in q) {
+        const r = q.range;
+        if (!below) fail('PARTS_FIELD_PRESENT', `${object} "range"`, `is on segment ${show(q.segment)}; a range is the bend of a joint, so only a segment below one (index above 0) carries it`);
+        else if (!(Array.isArray(r) && r.length === 2 && r.every((n) => typeof n === 'number' && Number.isFinite(n)) && (r[0] as number) <= 0 && 0 <= (r[1] as number))) {
+          fail('PARTS_FIELD_TYPE', `${object} "range"`, `is ${show(r)}; [min, max], two finite degrees from rest with min <= 0 <= max, is required — config.limbs' rule (CONFIG_LIMB_RANGE)`);
+        }
+      }
       if ('cap' in q) {
         const c = q.cap;
         const co = typeof c === 'object' && c !== null && !Array.isArray(c) ? (c as Record<string, unknown>) : null;
@@ -484,8 +513,17 @@ function checkParts(raw: unknown, path: string): PartsFile {
           isCount(co.layer_px) &&
           isCount(co.missing_px) &&
           (!('image_px' in co) || isCount(co.image_px)) &&
-          (!('image_layer' in co) || ('image_px' in co && typeof co.image_layer === 'string' && co.image_layer !== ''));
-        if (!ok) fail('PARTS_FIELD_TYPE', `${object} "cap"`, `is ${show(c)}; {at: [x, y], width, radius, box: [x, y, w, h], layer_px, image_px?, image_layer? (with image_px), missing_px} is required`);
+          (!('image_layer' in co) || ('image_px' in co && typeof co.image_layer === 'string' && co.image_layer !== '')) &&
+          // Issue #360: a disc cap carries its count, a feathered edge its band and count, and neither carries them alone.
+          ('shape' in co ? co.shape === 'disc' && isCount(co.upper_px) : !('upper_px' in co)) &&
+          ('edge' in co ? co.edge === 'feather' && typeof co.feather_radius === 'number' && Number.isFinite(co.feather_radius) && co.feather_radius >= 0 && isCount(co.feathered_px) : !('feather_radius' in co) && !('feathered_px' in co));
+        if (!ok) {
+          fail(
+            'PARTS_FIELD_TYPE',
+            `${object} "cap"`,
+            `is ${show(c)}; {at: [x, y], width, radius, box: [x, y, w, h], layer_px, image_px?, image_layer? (with image_px), missing_px, shape? ("disc", with upper_px), edge? ("feather", with feather_radius and feathered_px)} is required`,
+          );
+        }
       }
     }
   }

package/src/rig.ts

@@ -1911,6 +1911,16 @@ export function rigJsonText(value: unknown): string {
  * (`FLATTEN_REGION_UPRIGHT`) rather than flattened into an upright one the
  * oriented rig does not draw.
  *
+ * A transform constraint that reads its source's **local** rotation and adds
+ * it to its targets' local rotations (`localSource`, `localTarget`,
+ * `additive`: the cloth recipe's swing, issue #364) reads the source's setup
+ * rotation, which the flat form drops; spine-core takes the source's rotation
+ * less the `rotate` property's `offset`, so the flat form's offset is the
+ * offset less that setup rotation, and the targets turn by the same amount in
+ * both forms (issue #372: copied as written, the swing turned every skirt tree
+ * 90 degrees in the flat form of the `wind` example). Every other constraint
+ * is copied as written.
+ *
  * `sense` is the direction rotations are read in: 1, always, but for the
  * planted control that shows a flatten turning the wrong way is caught.
  */
@@ -1968,6 +1978,17 @@ export function flattenRig(rig: RigSpec, sense: 1 | -1 = 1): RigSpec {
   }
   refuseIfAny(problems);
   const flat: RigSpec = { ...rig, bones, skins: { default: skin } };
+  if (rig.constraints !== undefined) {
+    const setup = new Map(read.map((b) => [b.name, b.rotation]));
+    flat.constraints = rig.constraints.map((c) => {
+      const props = c.properties as Record<string, Record<string, unknown>> | undefined;
+      const rotate = props?.rotate;
+      const turned = typeof c.source === 'string' ? (setup.get(c.source) ?? 0) : 0;
+      if (c.type !== 'transform' || c.localSource !== true || c.localTarget !== true || c.additive !== true || rotate === undefined || turned === 0) return c;
+      const offset = typeof rotate.offset === 'number' ? rotate.offset : 0;
+      return { ...c, properties: { ...props, rotate: { ...rotate, offset: placed(offset - turned, OFFSET_PLACES) } } };
+    });
+  }
   if (rig.invariants?.axes !== undefined) {
     const { axes: _axes, ...rest } = rig.invariants;
     if (Object.keys(rest).length > 0) flat.invariants = rest;

package/src/structure.ts

@@ -15,7 +15,8 @@
  * - a **config**: an object with a `key`, read by the full config loader;
  * - a **proposal**: an object with `bones` and no `key` or `spec`, as
  *   `propose` writes it, read by `parseProposalSections` (the loader's rules
- *   for bones, meshes, regions and motion).
+ *   for bones, meshes, regions and motion, and for the constraints
+ *   `propose --cloth` writes).
  *
  * Anything else is refused by name. A file's name is never read.
  *