@rig-c/parts 1.20.0 → 1.22.0

package/src/limbs.ts

@@ -41,6 +41,46 @@
  *   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.
+ * - **`cut_band: N`** (issue #360, item 14; opt-in on the segment below a
+ *   joint between two segments that take one part). The cut is placed, not
+ *   moved by hand: of the lines parallel to the joint line at whole-pixel
+ *   offsets `-N .. N` along the axis, the one that crosses the fewest stroke
+ *   pixels ({@link placeCut}). A line crosses the pixels a joint line runs
+ *   through, as {@link limbRun} reads them: the limb's art whose centre lies
+ *   within half a pixel of it, across the run of art through its point. A
+ *   **stroke pixel** is one of those, over the whole band, whose luma (the
+ *   integer BT.601 `(299 R + 587 G + 114 B + 500) / 1000` truncated, the
+ *   luma `recompositeErrorMap` in `src/assemble.ts` reads) is at or below the
+ *   Otsu split of their luma histogram ({@link otsuDarkMax}: the dark class
+ *   of the two that maximise the between-class variance). The split is
+ *   derived from the band's own art and no number is typed: art of one luma
+ *   has no split and so no stroke. A tie goes to the line nearer the joint,
+ *   then to the one on the upper side, so with no stroke in the band the
+ *   joint line itself is chosen. The bone does not move: the joint, the
+ *   cap's disc and the limb's width stay where the bone's origin puts them;
+ *   only the line that splits the pixels between the two pieces moves, and
+ *   the cap takes the disc's pixels on the upper side of that line.
  */
 import type { BoneEntry, Limb } from './config.ts';
 
@@ -144,11 +184,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++) {
@@ -159,6 +200,11 @@ export function limbWidth(line: JointLine, art: (x: number, y: number) => boolea
       ts.push(-dx * ay + dy * ax);
     }
   }
+  return runOfOffsets(ts);
+}
+
+/** The run through 0 of the offsets `ts` along a line ({@link limbRun}): sorted, the nearest within 1 px, grown while neighbours are at most 1.5 apart. Sorts `ts` in place. */
+function runOfOffsets(ts: number[]): [number, number] | null {
   if (ts.length === 0) return null;
   ts.sort((a, b) => a - b);
   let near = 0;
@@ -170,7 +216,204 @@ 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, offset = 0): number {
+  const h2 = radius * radius - across * across;
+  if (h2 <= 0) return 1;
+  // Issue #360 (cut_band): with the cut `offset` px along the axis, the fade runs from the cut's line to the arc.
+  if (offset !== 0) {
+    const span = offset + Math.sqrt(h2);
+    return span <= 0 ? 1 : Math.max(0, Math.min(1, (offset - along) / span));
+  }
+  return Math.max(0, Math.min(1, -along / Math.sqrt(h2)));
+}
+
+/** The integer BT.601 luma of a colour, `(299 R + 587 G + 114 B + 500) / 1000` truncated (the one `recompositeErrorMap` reads). */
+export function luma601(r: number, g: number, b: number): number {
+  return Math.floor((299 * r + 587 * g + 114 * b + 500) / 1000);
+}
+
+/**
+ * The Otsu split of a luma histogram (`hist[v]` pixels of luma `v`): the
+ * largest luma of the dark class, among the splits `luma <= T | luma > T`
+ * with a pixel on each side, that maximises the between-class variance
+ * `(T's dark sum · n − dark count · total sum)² / (dark count · light count)`
+ * (the variance times n², which ranks the splits alike). Compared exactly, in
+ * integers; a tie goes to the lower `T`. Null when no split has a pixel on
+ * each side — every pixel of one luma — or when every split's variance is 0.
+ */
+export function otsuDarkMax(hist: ArrayLike<number>): number | null {
+  let n = 0;
+  let sum = 0;
+  for (let v = 0; v < hist.length; v++) {
+    n += hist[v];
+    sum += v * hist[v];
+  }
+  const N = BigInt(n);
+  const S = BigInt(sum);
+  let best: number | null = null;
+  let bestNum = 0n;
+  let bestDen = 1n;
+  let n0 = 0;
+  let s0 = 0;
+  for (let t = 0; t + 1 < hist.length; t++) {
+    n0 += hist[t];
+    s0 += t * hist[t];
+    const n1 = n - n0;
+    if (n0 === 0 || n1 === 0) continue;
+    const d = BigInt(s0) * N - BigInt(n0) * S;
+    const num = d * d;
+    const den = BigInt(n0) * BigInt(n1);
+    if (num === 0n) continue;
+    if (best === null || num * bestDen > bestNum * den) {
+      best = t;
+      bestNum = num;
+      bestDen = den;
+    }
+  }
+  return best;
+}
+
+/** A joint line moved `offset` px along its axis (issue #360, `cut_band`): the same axis, through `at + offset · axis`. */
+export function shiftedLine(line: JointLine, offset: number): JointLine {
+  return offset === 0 ? line : { at: [line.at[0] + offset * line.axis[0], line.at[1] + offset * line.axis[1]], axis: line.axis };
+}
+
+/** One line of a cut's band (issue #360, `cut_band`): its offset along the axis from the joint, and the stroke pixels it crosses. */
+export interface CutCandidate {
+  offset: number;
+  crossed: number;
+}
+
+/** Where `cut_band` put the cut (module comment), or why it could not. */
+export type CutPlacement =
+  | {
+      ok: true;
+      /** The chosen line's offset along the axis from the joint (above 0: past it, toward the lower segment). */
+      offset: number;
+      line: JointLine;
+      crossed: number;
+      /** The stroke pixels the joint line itself crosses. */
+      jointCrossed: number;
+      /** The Otsu split's dark class's largest luma, or null when the band's art has no split (no stroke). */
+      strokeLumaMax: number | null;
+      /** The art pixels the band's lines cross, counted once each. */
+      bandPx: number;
+      candidates: CutCandidate[];
+    }
+  | { ok: false; offset: number };
+
+/**
+ * Place a joint's cut within `band` px of its line (module comment, `cut_band`):
+ * every whole offset `-band .. band` is a candidate line; each crosses the
+ * art pixels (`art`) whose centre lies within half a pixel of it, across the
+ * run of art through its point ({@link limbRun}); the stroke pixels are those
+ * at or below the Otsu split of the luma (`luma`) of every pixel the band's
+ * lines cross. The fewest stroke pixels wins, then the smaller offset, then the
+ * negative one (the upper side). `{ok: false, offset}` names the offset nearest
+ * the joint (the negative one on a tie) whose line crosses no run of art: the
+ * band reaches past the limb there, and a band of `|offset| - 1` would not.
+ */
+export function placeCut(
+  line: JointLine,
+  band: number,
+  art: (x: number, y: number) => boolean,
+  luma: (x: number, y: number) => number,
+  box: readonly [number, number, number, number],
+): CutPlacement {
+  const W = box[2] - box[0] + 1;
+  // One pass over the box: the art within band + 1 px of the joint line, a margin past every candidate's half pixel.
+  const near: Array<[number, number]> = [];
+  for (let y = box[1]; y <= box[3]; y++) {
+    for (let x = box[0]; x <= box[2]; x++) {
+      if (Math.abs(jointOffsets(line, x, y).along) <= band + 1 && art(x, y)) near.push([x, y]);
+    }
+  }
+  const crossedBy: Array<number[] | null> = [];
+  for (let t = -band; t <= band; t++) {
+    const l = shiftedLine(line, t);
+    // The pixels limbRun reads on this line, with their offsets across it.
+    const on = near.map(([x, y]) => ({ x, y, o: jointOffsets(l, x, y) })).filter((q) => Math.abs(q.o.along) <= 0.5);
+    const run = runOfOffsets(on.map((q) => q.o.across));
+    crossedBy.push(run === null ? null : on.filter((q) => q.o.across >= run[0] && q.o.across <= run[1]).map((q) => (q.y - box[1]) * W + (q.x - box[0])));
+  }
+  // A line off the limb's art is no candidate: the one nearest the joint is named (the upper side first on a tie).
+  const off = crossedBy.map((px, i) => (px === null ? i - band : null)).filter((t): t is number => t !== null);
+  if (off.length > 0) return { ok: false, offset: off.reduce((a, t) => (Math.abs(t) < Math.abs(a) ? t : a)) };
+  const lines = crossedBy as number[][];
+  const lumaAt = (p: number): number => luma(box[0] + (p % W), box[1] + Math.floor(p / W));
+  const seen = new Set<number>();
+  const hist = new Array<number>(256).fill(0);
+  for (const px of lines) {
+    for (const p of px) {
+      if (seen.has(p)) continue;
+      seen.add(p);
+      hist[lumaAt(p)]++;
+    }
+  }
+  const split = otsuDarkMax(hist);
+  const candidates = lines.map((px, i) => ({ offset: i - band, crossed: split === null ? 0 : px.filter((p) => lumaAt(p) <= split).length }));
+  let best = candidates[band];
+  for (const c of candidates) {
+    if (c.crossed < best.crossed || (c.crossed === best.crossed && (Math.abs(c.offset) < Math.abs(best.offset) || (Math.abs(c.offset) === Math.abs(best.offset) && c.offset < best.offset)))) best = c;
+  }
+  return { ok: true, offset: best.offset, line: shiftedLine(line, best.offset), crossed: best.crossed, jointCrossed: candidates[band].crossed, strokeLumaMax: split, bandPx: seen.size, candidates };
 }
 
 /** 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,66 @@ 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;
+  /**
+   * Issue #360 (item 14), written only under the segment's `cut_band`: the
+   * band; the chosen line's offset along the axis from the joint (above 0:
+   * past it, toward the lower segment) and a point it passes through; the
+   * stroke pixels it crosses and those the joint line crosses; the art
+   * pixels the band's lines cross, each once; and the stroke class's largest
+   * luma, absent when the band's art has no split (`placeCut` in
+   * `src/limbs.ts`). `at`, `width` and `radius` stay the joint's.
+   */
+  cut_band?: number;
+  cut_offset?: number;
+  cut_at?: [number, number];
+  cut_crossed?: number;
+  joint_crossed?: number;
+  band_px?: number;
+  stroke_luma_max?: 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',
+  'cut_band',
+  'cut_offset',
+  'cut_at',
+  'cut_crossed',
+  'joint_crossed',
+  'band_px',
+  'stroke_luma_max',
+] as const;
+/** The cap keys only `cut_band` writes (issue #360, item 14). */
+const CUT_KEYS = ['cut_offset', 'cut_at', 'cut_crossed', 'joint_crossed', 'band_px', 'stroke_luma_max'] 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 +530,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 +552,30 @@ 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)) &&
+          // Issue #360 (item 14): a placed cut carries its band, line and counts, the line inside the band; none of them rides alone.
+          ('cut_band' in co
+            ? isCount(co.cut_band) &&
+              co.cut_band >= 1 &&
+              Number.isInteger(co.cut_offset) &&
+              Math.abs(co.cut_offset as number) <= co.cut_band &&
+              pt(co.cut_at, 2) &&
+              isCount(co.cut_crossed) &&
+              isCount(co.joint_crossed) &&
+              isCount(co.band_px) &&
+              (co.cut_crossed as number) <= (co.joint_crossed as number) &&
+              (!('stroke_luma_max' in co) || (isCount(co.stroke_luma_max) && co.stroke_luma_max <= 255))
+            : CUT_KEYS.every((k) => !(k 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), cut_band? (with cut_offset inside the band, cut_at, cut_crossed at most joint_crossed, band_px, stroke_luma_max? 0..255)} 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.
  *