rig-parts 1.55.0 → 1.55.1

package/cli.ts

@@ -31,7 +31,7 @@ import { basisLines, branchSqueezeLine, checkProposal, compare, compareLines, DE
 import { BASIS_FILE, BASIS_SPEC, basisFile, basisLine, coverageLines, serializeBasis } from './src/diagnostics.ts';
 import { BEND_DEGREES, BEND_WORST_SHARE, DUST_MAX_PX, DUST_MAX_SHARE, IDLE_BOUND_PX, MESH_DRAFT_REPORT, MESH_DRAFT_SPEC, meshDraftStage, MORE_TRIANGLES_FLAG, relativeConfigPaths, TOLERANCE_FIGURE_DIVISOR } from './src/meshdraft.ts';
 import { meshStatsStage } from './src/meshstats.ts';
-import { chainsLeftBehind, clothConfigEdits, editPaths, previousCount, writtenClothConfig } from './src/clothconfig.ts';
+import { chainsLeftBehind, clothConfigEdits, editPaths, plainCount, previousCount, writtenClothConfig } from './src/clothconfig.ts';
 import { INPUT_CHECK_FILE, INPUT_CHECK_SPEC, PROVENANCE_FILE, REMESH_SPEC, remeshStage } from './src/remesh.ts';
 import { RETUNE_FILE, RETUNE_SPEC, retuneStage } from './src/retune.ts';
 import { checkPainting } from './src/paintcheck.ts';
@@ -257,8 +257,11 @@ usage:
       entry equal to that previous recipe's draft is the recipe's, replaced
       (or removed) as one equal to the draft without the recipe is; an entry
       equal to none of the three drafts is still refused by name, its field
-      read against the previous recipe's draft. The write line counts the
-      entries the previous draft vouched for. Without --from nothing changes.
+      read against the previous recipe's draft. An entry the previous recipe
+      drafted that the recipe now leaves plain (a tag whose recipe was
+      dropped) goes back to the draft without the recipe (issue #630). The
+      write line counts the entries the previous draft vouched for and the
+      entries returned to the plain draft. Without --from nothing changes.
 
   rig-parts propose --parts <dir> --source <painting.png> --out <dir> --from-config <config.json>
       Draw the config's CURRENT bones instead (<out>/render/landmarks_config.png
@@ -1429,7 +1432,7 @@ function cmdPropose(args: string[]): number {
             // Issue #571: with --from, the same parts drafted a third time with the previous recipe.
             const previous = previousCloth === null ? null : proposeWithBasis(P, joints, wristSnap, gridRule, previousCloth).proposal;
             const edits = clothConfigEdits(drafted, plain, JSON.parse(text) as unknown, false, previous);
-            return { at: writeArg, input: text, text: writtenClothConfig(clothArg, text, edits), paths: editPaths(edits), vouched: previousCount(edits), relative: relativeConfigPaths(dirname(resolve(clothArg)), JSON.parse(text) as Record<string, unknown>) };
+            return { at: writeArg, input: text, text: writtenClothConfig(clothArg, text, edits), paths: editPaths(edits), vouched: previousCount(edits), returned: plainCount(edits), relative: relativeConfigPaths(dirname(resolve(clothArg)), JSON.parse(text) as Record<string, unknown>) };
           })();
     // Issue #572: the keyed chains CHAIN_LAG reads only once the recipe took its trees' idle keys — in the config written
     // against the --cloth config with --write-config, else in the proposal against the draft without the recipe.
@@ -1467,7 +1470,8 @@ function cmdPropose(args: string[]): number {
     printLint(P, prop, joints, [...draftLint, ...leftBehind.findings]);
     console.log(basisLine(bfile, out));
     if (written !== null && clothArg !== undefined) {
-      const from = fromArg === undefined ? '' : `; --from ${fromArg}: ${written.vouched} ${written.vouched === 1 ? 'entry' : 'entries'} taken as the previous recipe's draft`;
+      // Issue #630: the entries a recipe dropped since --from gives back to the draft without the recipe.
+      const from = fromArg === undefined ? '' : `; --from ${fromArg}: ${written.vouched} ${written.vouched === 1 ? 'entry' : 'entries'} taken as the previous recipe's draft, ${written.returned} ${written.returned === 1 ? 'entry' : 'entries'} returned to the plain draft`;
       console.log(
         written.paths.length > 0
           ? `wrote ${written.at}: ${clothArg}'s text with ${written.paths.join(', ')} spliced in from the draft; every other byte as read${from}`

package/docs/AUTHORING.md

@@ -370,7 +370,17 @@ the larger of the x and y gaps, every joint of those limbs and the origins of
 `hip`, `chest` and `neck` — and, when both legs are drafted, whose art breaks on the
 line from `r_knee` to `l_knee` and on the line from `r_ankle` to `l_ankle` (the
 reading `PAINTING_LEGS_APART` makes): a robe over both legs is one column there,
-and would be split into legs it does not have. The arms are the sleeve chains and
+and would be split into legs it does not have. Within 15 px is not on the art: each
+cut the draft makes on the layer — the trunk's at `chest` and `neck`, each arm's at
+its elbow, each leg's at its knee — must lie on that limb's own art within 1 px
+along its joint line, read by assemble's own test (the run `ASSEMBLE_LIMB_JOINT_ON_ART`
+refuses a cut without, each pixel the limb's whose bones pass nearest it), or the
+draft is a config assemble refuses (issue #629, selftest `PR560`). A part a cloth
+recipe names (`config.cloth.<tag>.part` or `.parts`) is no candidate either: it
+keeps the recipe's mesh — a limb takes every pixel of its part, so cut into limbs
+the recipe's trees would move no artwork — and a note names it and the recipe;
+when it is the only part that holds the joints, `PROPOSE_FIGURE_LAYER` refuses it by
+name (issue #631, `PR561`). The arms are the sleeve chains and
 `arm_<s>` limbs and the legs the `leg_<s>` chains and limbs above, on that part,
 and the trunk is a limb of its own, `trunk` — `trunk_hip` on `hip`, `trunk_chest`
 on `chest` below the joint at chest's origin, `trunk_neck` on `neck` past the
@@ -387,7 +397,8 @@ Two topwear parts that both hold everything are decided by their opaque px in th
 31x31 squares about those points (the square the 15 px tolerance reads), and the
 note adds both counts; a tie is refused, `PROPOSE_FIGURE_LAYER`. A topwear part that
 misses one gets no limb, keeps the topwear rule, and a `figure layer: …` note names
-the first point it misses or the line on which its legs are one column. With no
+the first point it misses, the line on which its legs are one column, or the cut
+whose joint line misses its art, with the nearest pixel on that line and how far. With no
 topwear part over 500 px nothing is said and nothing moves. A garment figure whose
 tags carry its limbs is drafted byte for byte as before: the public examples'
 proposals are unchanged. The fixture is `fixtures/mannequin.ts`: one `topwear`
@@ -1838,13 +1849,27 @@ recipe is: replaced by the draft, or removed where the draft no longer holds the
 refused, `PROPOSE_WRITE_CONFIG_CONFLICT`, the detail reading "it equals neither the draft,
 the draft without the recipe, nor the previous recipe's draft" and naming the first field
 that differs from the previous recipe's draft (the entry a person most likely edited
-from). The write line ends `--from <path>: n entries taken as the previous recipe's
-draft`. `meshes.<part>` and `regions.<part>` are unchanged by `--from`: a mesh the
-recipe drafts is replaced whole already, and one the two drafts agree at is not touched.
+from). **A dropped recipe (issue #630).** A change can remove one tag's recipe and
+keep another's (`back hair` taken out of `cloth`, `bottomwear` left in). That tag's
+entries are then the draft without the recipe again, so every entry the previous
+recipe drafted and the recipe now leaves to the plain draft goes back to it: its plain
+chains and their tracks inserted (beside their drafted neighbours, as above), its trees
+and their constraints removed, its `meshes.<part>` (and any `regions.<part>`) replaced
+by the plain draft's — where the input holds that entry as the previous recipe's draft
+wrote it, or lacks it in a section it holds. A hand edit to one of those entries is
+refused by name as any other, `PROPOSE_WRITE_CONFIG_CONFLICT` (`config.meshes.hair_back`
+in CL221, the field read against the previous recipe's draft); the tags the change keeps
+do not move. Before #630 the write exited 0 with the dropped tag's old mesh kept and its
+plain chains missing (CL222 keeps that writer as the selftest's mutant). The write line
+ends `--from <path>: n entries taken as the previous recipe's draft, m entries returned
+to the plain draft`. Apart from a dropped recipe's entries, `meshes.<part>` and
+`regions.<part>` are unchanged by `--from`: a mesh the recipe drafts is replaced whole
+already, and one all three drafts agree at is not touched.
 Without `--from` every rule and every byte is the writer's before #571; with a `--from`
 whose recipe equals `--cloth`'s the previous draft is the draft, and the written config
 is byte for byte the one written without it (CL209–CL212 hold each on the cloth fixture,
-CL213–CL215 on `wind`). The written config is the recipe's draft, not a verdict on it: on
+CL213–CL215 on `wind`; CL220–CL223 the dropped recipe on the cloth fixture, CL224 on
+`wind`, where dropping `back hair` writes the run's proposal value for value). The written config is the recipe's draft, not a verdict on it: on
 `wind`, `links` 3 → 4 writes the skirt entries of its proposal value for value, and that
 draft fails `CHECK_TIP_OVER_ROOT` on the skirt in `build`; 3 → 2 builds green (CL215). A `meshes.<part>` the
 recipe drafts is still the draft's whole, as a hand-edited lattice does not survive
@@ -3238,7 +3263,7 @@ says why each requirement exists and what breaks without it.
 | <a id="PROPOSE_FACE_PRESENT"></a>`PROPOSE_FACE_PRESENT` | no part comes from a `face` layer, and the face-less fallback cannot derive a face box either: it needs the head run's `neck` and at least one head-run `front hair`/`back hair` part whose top is above the neck's, and the message names the half that is missing. With both, `propose` does not refuse — it derives the box and says so in its first note (§5) | `assemble.plan`: take the face, or the head run's hair and neck |
 | <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 a standalone or incomplete limb part `config.limbs` cut at its joints (issues #349, #440) that cannot be reassembled into the source part `of` (a missing segment or `cap` record, or `of` still present beside the limb parts); a complete `assemble` output with `config.limbs` reconstructs its pre-limb parts in the same run | `--parts` a complete `assemble` output (every segment of each limb, with its `cap` record) or a build assembled with `config.limbs` left out; `propose --from-config` reads the config's bones on either build |
-| <a id="PROPOSE_FIGURE_LAYER"></a>`PROPOSE_FIGURE_LAYER` | with `--keypoints` (issue #577): a limb is drafted from the figure layer (no handwear or legwear part over 500 px for it), and two or more `topwear` parts each hold every joint and the trunk bones' origins within 15 px with the same opaque px in the 31x31 squares about them, so nothing says which is the figure (§3, *A figure of one material*) | leave the others out of `assemble.plan`, or give the arms and legs their own handwear and legwear layers |
+| <a id="PROPOSE_FIGURE_LAYER"></a>`PROPOSE_FIGURE_LAYER` | with `--keypoints` (issue #577): a limb is drafted from the figure layer (no handwear or legwear part over 500 px for it), and two or more `topwear` parts each hold every joint and the trunk bones' origins within 15 px with the same opaque px in the 31x31 squares about them, so nothing says which is the figure; or the only `topwear` parts that hold them are named by a cloth recipe (`config.cloth.<tag>.part` or `.parts`, issue #631), whose mesh a limb would take (§3, *A figure of one material*) | leave the others out of `assemble.plan`, or give the arms and legs their own handwear and legwear layers; for a recipe's part, take it out of the recipe |
 | <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` (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_WRITE_CONFIG_FRESH"></a>`PROPOSE_WRITE_CONFIG_FRESH` | with `--write-config` (issue #537): the out path exists, or is a file the run writes itself (`proposal.json`, `basis.json` under `--out`); the config is written to a new file, never over the `--cloth` config or an earlier one | name a file that does not exist yet, beside the `--cloth` config |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rig-parts",
-  "version": "1.55.0",
+  "version": "1.55.1",
   "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/clothconfig.ts

@@ -44,6 +44,11 @@ export interface ClothEdit extends ConfigEdit {
   label: string;
   /** Issue #571: the input's entry was the previous recipe's draft (`--from`), and only that made it the recipe's. */
   previous?: true;
+  /**
+   * Issue #630: the entry is written back to the draft without the recipe (`--from`): the previous recipe drafted it
+   * and the recipe now does not — a tag whose recipe was dropped while another was kept.
+   */
+  plain?: true;
 }
 
 /**
@@ -105,8 +110,23 @@ function shown(v: unknown): string {
  * recipe's as `I` equal to `P` is — an owned name is replaced, and a name in `V` and not in `D` is removed — and a
  * conflict is an `I` equal to none of `D`, `P` and `V`, its first differing field read against `V` where `V` holds the
  * name. Without `previous` every rule, and every word of the refusal, is the one above.
+ *
+ * Issue #630: with `V`, a name `D` holds equal to `P` that `V` lacks or holds differently — an entry the previous
+ * recipe drafted (or replaced) and this one leaves to the draft without the recipe, as for a tag whose recipe was
+ * dropped while another was kept — is owned too: inserted where the input lacks it, replaced where the input equals
+ * `V`, and a conflict where it equals neither. Such an edit carries `plain`. `keepDropped` is the selftest's mutant
+ * only (the writer before #630, which never owned it); no flag or environment reaches it.
  */
-function entryEdits(path: readonly string[], identity: (e: unknown) => string | null, drafted: readonly unknown[], plain: readonly unknown[], input: readonly unknown[], conflicts: Problem[], previous: readonly unknown[] | null): ClothEdit[] {
+function entryEdits(
+  path: readonly string[],
+  identity: (e: unknown) => string | null,
+  drafted: readonly unknown[],
+  plain: readonly unknown[],
+  input: readonly unknown[],
+  conflicts: Problem[],
+  previous: readonly unknown[] | null,
+  keepDropped = false,
+): ClothEdit[] {
   const section = path.join('.');
   const D = byName(drafted, identity, 'drafted', section);
   const P = byName(plain, identity, 'plain', section);
@@ -116,7 +136,10 @@ function entryEdits(path: readonly string[], identity: (e: unknown) => string |
   keys.forEach((k, i) => {
     if (k !== null) where.set(k, [...(where.get(k) ?? []), i]);
   });
-  const owned = [...D.keys()].filter((k) => !P.has(k) || canon(P.get(k)) !== canon(D.get(k)));
+  const recipes = new Set([...D.keys()].filter((k) => !P.has(k) || canon(P.get(k)) !== canon(D.get(k))));
+  // Issue #630: a plain entry the previous recipe drafted differently or took away, which this recipe leaves plain.
+  const returned = new Set(V === null || keepDropped ? [] : [...D.keys()].filter((k) => !recipes.has(k) && (!V.has(k) || canon(V.get(k)) !== canon(D.get(k)))));
+  const owned = [...D.keys()].filter((k) => recipes.has(k) || returned.has(k));
   const removed = [...P.keys(), ...(V === null ? [] : [...V.keys()].filter((k) => !P.has(k)))].filter((k) => !D.has(k));
   const replace: string[] = [];
   const remove: string[] = [];
@@ -166,7 +189,7 @@ function entryEdits(path: readonly string[], identity: (e: unknown) => string |
       vouched.add(k);
     } else conflict(k, at[0], false);
   }
-  const mark = (k: string): { previous?: true } => (vouched.has(k) ? { previous: true } : {});
+  const mark = (k: string): { previous?: true; plain?: true } => ({ ...(vouched.has(k) ? { previous: true as const } : {}), ...(returned.has(k) ? { plain: true as const } : {}) });
   const edits: ClothEdit[] = [];
   const work = [...keys];
   for (const k of replace) edits.push({ path: [...path, work.indexOf(k)], value: D.get(k), label: `${section}["${k}"] replaced`, ...mark(k) });
@@ -186,7 +209,7 @@ function entryEdits(path: readonly string[], identity: (e: unknown) => string |
         break;
       }
     }
-    edits.push({ path: [...path, pos], value: D.get(k), insert: true, label: `${section}["${k}"] inserted` });
+    edits.push({ path: [...path, pos], value: D.get(k), insert: true, label: `${section}["${k}"] inserted`, ...mark(k) });
     work.splice(pos, 0, k);
   }
   return edits;
@@ -206,10 +229,20 @@ function entryEdits(path: readonly string[], identity: (e: unknown) => string |
  * object entry (`meshes.<part>`, `regions.<part>`) the recipe drafts is replaced whole already, so `previous` changes
  * nothing there. Null — no `--from` — is the writer before #571, rule for rule and byte for byte.
  *
+ * Issue #630: where the two drafts agree and the previous draft differs — what the previous recipe drafted and this one
+ * leaves to the draft without the recipe, a tag whose recipe was dropped while another was kept — the entry goes back
+ * to the plain draft: in an array section by {@link entryEdits}' rule, and at any other entry (`meshes.<part>`,
+ * `regions.<part>`, a section the input holds whole) when the input equals the previous draft there or lacks the entry
+ * in an object it holds; an input equal to neither the draft nor the previous draft there is a hand edit, refused by
+ * name. Each such edit that writes the plain draft's value carries `plain` (a removal does not, as an array name the
+ * previous recipe drafted and the plain draft lacks is removed without it). A section the input lacks is left to the
+ * input, as before.
+ *
  * `whole` is the selftest's mutant only (issue #552): `bones`, `constraints` and `motion.tracks` replaced whole, as
- * the #537 writer did; no flag or environment reaches it.
+ * the #537 writer did; `keepDropped` is the selftest's mutant only (issue #630): the writer before it, which leaves a
+ * dropped recipe's entries as the previous draft wrote them. No flag or environment reaches either.
  */
-export function clothConfigEdits(drafted: Proposal, plain: Proposal, input: unknown, whole = false, previous: Proposal | null = null): ClothEdit[] {
+export function clothConfigEdits(drafted: Proposal, plain: Proposal, input: unknown, whole = false, previous: Proposal | null = null, keepDropped = false): ClothEdit[] {
   const edits: ClothEdit[] = [];
   const conflicts: Problem[] = [];
   const d = JSON.parse(JSON.stringify(drafted)) as Record<string, unknown>;
@@ -224,27 +257,56 @@ export function clothConfigEdits(drafted: Proposal, plain: Proposal, input: unkn
   const one = (path: readonly string[], a: unknown, b: unknown): void => {
     const s = arrayOf(path);
     const mine = valueAt(input, path);
-    if (s !== undefined && Array.isArray(b) && (a === undefined || Array.isArray(a)) && Array.isArray(mine)) edits.push(...entryEdits(path, s.identity, b, Array.isArray(a) ? a : [], mine, conflicts, prevAt(path)));
+    if (s !== undefined && Array.isArray(b) && (a === undefined || Array.isArray(a)) && Array.isArray(mine)) edits.push(...entryEdits(path, s.identity, b, Array.isArray(a) ? a : [], mine, conflicts, prevAt(path), keepDropped));
     else edits.push({ path, value: b, label: path.join('.') });
   };
   // Issue #571: an array section the two drafts agree at, where the previous draft differs — its entries the previous recipe drafted and this one does not.
+  // Issue #630: and any other entry there, which goes back to the draft (the plain draft's value, the two agreeing).
   const prevOnly = (path: readonly string[], b: unknown): void => {
+    if (v === null) return;
     const s = arrayOf(path);
     const mine = valueAt(input, path);
     const c = valueAt(v, path);
-    if (v === null || s === undefined || !Array.isArray(b) || !Array.isArray(mine) || canon(c) === canon(b)) return;
-    edits.push(...entryEdits(path, s.identity, b, b, mine, conflicts, prevAt(path)));
+    if (canon(c) === canon(b)) return;
+    if (s !== undefined && (Array.isArray(b) || b === undefined) && Array.isArray(mine)) {
+      const drafts = Array.isArray(b) ? b : [];
+      edits.push(...entryEdits(path, s.identity, drafts, drafts, mine, conflicts, prevAt(path), keepDropped));
+      return;
+    }
+    if (keepDropped || s !== undefined) return;
+    // The entry's own object must be the input's: a section the input lacks is the input's to lack, as before #630.
+    const holder = path.length === 1 ? input : valueAt(input, path.slice(0, -1));
+    if (!isPlain(holder) || (path.length === 1 && mine === undefined)) return;
+    const where = `config.${path.join('.')}`;
+    if (canon(mine) === canon(b)) return;
+    if (mine === undefined || canon(mine) === canon(c)) {
+      edits.push({ path, value: b, label: `${path.join('.')} ${b === undefined ? 'removed' : mine === undefined ? 'inserted' : 'replaced'}`, ...(b !== undefined ? { plain: true as const } : {}), ...(mine !== undefined ? { previous: true as const } : {}) });
+      return;
+    }
+    const field = firstField(mine, c);
+    const at = (e: unknown, f: string): string => (isPlain(e) && e[f] !== undefined ? `${f} ${shown(e[f])}` : `no ${f}`);
+    conflicts.push({
+      code: 'PROPOSE_WRITE_CONFIG_CONFLICT',
+      object: where,
+      detail: `${path.join('.')} is the previous recipe's, the recipe now leaves it to the draft without the recipe, and it was changed by hand: it equals neither the draft nor the previous recipe's draft: it holds ${field === null ? shown(mine) : at(mine, field)} where the previous recipe's draft writes ${c === undefined ? 'no such entry' : field === null ? shown(c) : at(c, field)} and the draft writes ${b === undefined ? 'no such entry' : field === null ? shown(b) : at(b, field)}, so the write would drop the hand edit; take the draft by removing the hand edit (or the entry), or keep the recipe for that part (its config.cloth block)`,
+    });
+  };
+  const prevKeys = (section: string, have: readonly string[]): string[] => {
+    const pv = v === null ? undefined : v[section];
+    return isPlain(pv) ? Object.keys(pv).filter((k) => !have.includes(k)) : [];
   };
   for (const section of PROPOSAL_CONFIG_SECTIONS) {
     const a = p[section];
     const b = d[section];
     if (JSON.stringify(a) === JSON.stringify(b)) {
-      if (isPlain(b)) for (const k of Object.keys(b)) prevOnly([section, k], b[k]);
+      if (isPlain(b)) for (const k of [...Object.keys(b), ...prevKeys(section, Object.keys(b))]) prevOnly([section, k], b[k]);
+      else if (b === undefined && isPlain(v === null ? undefined : v[section])) for (const k of prevKeys(section, [])) prevOnly([section, k], undefined);
       else prevOnly([section], b);
       continue;
     }
     if (isPlain(a) && isPlain(b)) {
-      for (const k of [...Object.keys(b), ...Object.keys(a).filter((k) => !(k in b))]) {
+      const keys = [...Object.keys(b), ...Object.keys(a).filter((k) => !(k in b))];
+      for (const k of [...keys, ...prevKeys(section, keys)]) {
         if (JSON.stringify(a[k]) !== JSON.stringify(b[k])) one([section, k], a[k], b[k]);
         else prevOnly([section, k], b[k]);
       }
@@ -278,6 +340,11 @@ export function previousCount(edits: readonly ClothEdit[]): number {
   return edits.filter((e) => e.previous === true).length;
 }
 
+/** Issue #630: how many edits wrote an entry back to the draft without the recipe — a dropped recipe's entries. */
+export function plainCount(edits: readonly ClothEdit[]): number {
+  return edits.filter((e) => e.plain === true).length;
+}
+
 /** What each edit names, in order: what the write line prints. */
 export function editPaths(edits: readonly ClothEdit[]): string[] {
   return edits.map((e) => e.label);

package/src/propose.ts

@@ -154,7 +154,7 @@ import { configRoles, type RoleOf } from './structure.ts';
 import { AUTHOR_NO_ROLE, isAuthorTag } from './tags.ts';
 import { TURN_BONE, TURN_CARRIER_TAG, TURN_PLACES, TURN_RIDER_OFFSET, TURN_RIDER_TAGS, turnFractions, turnNearest, turnPivot, turnRiderDepth, type TurnSpec } from './turn.ts';
 import { edgeLength } from './length.ts';
-import { bonePlaces, jointLine, limbCrossing, limbPolyline, limbRun, limbWidth, nearestLimb, nearestOnLine, offLineFigure, type Pt } from './limbs.ts';
+import { bonePlaces, jointLine, type JointLine, limbCrossing, limbPolyline, limbRun, limbWidth, nearestLimb, nearestOnLine, offLineFigure, type Pt } from './limbs.ts';
 import { type BranchSqueezeFinding, branchSqueezes, chainSqueezes, type SqueezeFinding } from './squeeze.ts';
 import { backHairMasses, type BackHairMass, backHairMassTrees, INFLUENCE_RADIUS_CELLS, 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, type TreeMassInput } from './cloth.ts';
 import { TEXTURE_STRETCH_CEILING } from './check.ts';
@@ -2588,7 +2588,18 @@ export function proposeWithBasis(
   // legwear part carries its limbs. With joints, when the tagged route has no part for a complete limb, the one topwear
   // part that holds every such limb's joints is the figure layer: the trunk and those limbs split it by the cut.
   const lwTagged = P.byTag('legwear', undefined, true).filter((p) => p.opaque_px > 500);
-  const figure = joints === undefined ? null : figureLayerOf(P, hw, lwTagged, joints, { hip, chest, neck: neckAt });
+  // Issue #631: a part a cloth recipe names is that recipe's mesh, so it is never the figure layer.
+  const clothNamed = new Map<string, string>();
+  for (const t of CLOTH_TARGETS) {
+    const r = cloth?.[t];
+    if (r === undefined) continue;
+    for (const [field, v] of [['part', r.part], ['parts', r.parts]] as const) {
+      if (v === undefined) continue;
+      for (const n of typeof v === 'string' ? [v] : v) if (!clothNamed.has(n)) clothNamed.set(n, `config.cloth.${JSON.stringify(t)}.${field}`);
+    }
+  }
+  const figure = joints === undefined ? null : figureLayerOf(P, hw, lwTagged, joints, { hip, chest, neck: neckAt }, clothNamed);
+  if (figure !== null) notes.push(...figure.cloth);
   if (figure !== null && figure.part === null) notes.push(figure.note);
   const figPart = figure === null ? null : figure.part;
   if (figure !== null && figPart !== null) {
@@ -3944,6 +3955,14 @@ function legsFromJoints(P: PartSet, lw: readonly PartRecord[], joints: RigJoints
  *   by `linePixels`): a garment hung over both legs is one column there, and
  *   would be split into legs it does not have. Only `topwear`: `bottomwear`
  *   would split a skirt into legs, and the head run's tags carry the head;
+ * - **and on the art at every cut** (issue #629): the trunk's at `chest` and
+ *   `neck`, each arm's at its elbow, each leg's at its knee, read by
+ *   assemble's own test (`ASSEMBLE_LIMB_JOINT_ON_ART`, {@link limbRun} on the
+ *   joint line) — the 15 px above does not put a joint line on the art;
+ * - **not a part a cloth recipe names** (issue #631, `clothNamed`: part name
+ *   to the field naming it): it keeps the recipe's mesh, and a note says so;
+ *   when only such parts hold the joints, `PROPOSE_FIGURE_LAYER` refuses them
+ *   by name — cut into limbs, the recipe's trees would move no artwork;
  * - **one candidate** is the figure layer;
  * - **several**: the one with the most opaque px in the
  *   `(2 x WRIST_ON_PART_PX + 1)`-square about each of those points, summed (the
@@ -3962,7 +3981,8 @@ function figureLayerOf(
   lw: readonly PartRecord[],
   joints: RigJoints,
   trunk: { hip: [number, number]; chest: [number, number]; neck: [number, number] },
-): { part: PartRecord | null; arms: boolean; legs: boolean; note: string } | null {
+  clothNamed: ReadonlyMap<string, string>,
+): { part: PartRecord | null; arms: boolean; legs: boolean; note: string; cloth: string[] } | null {
   const J = joints.joints;
   const given = (a: KeypointName, b: KeypointName, c: KeypointName): boolean => {
     const p = J[a].at;
@@ -3995,13 +4015,64 @@ function figureLayerOf(
         return `${p.name}'s art does not break on the line from ${a} to ${b}: the legs are one column there, as a garment over both legs is`;
       }
     }
+    return cutOffArt(p);
+  };
+  // Issue #629: each cut the draft would make on the layer — the trunk's at chest and neck, each arm's at its elbow,
+  // each leg's at its knee — read as assemble's cap reads it (`cutLimbs`, src/assemble.ts): the joint line through the
+  // lower bone's origin ({@link jointLine}), and the run of the limb's own art along it within 1 px ({@link limbRun}),
+  // each pixel the limb's whose polyline passes nearest it ({@link nearestLimb}), the limbs in the order the draft
+  // writes them. The points above lying within 15 px of the art does not put the joint line on it.
+  const cutOffArt = (p: PartRecord): string | null => {
+    const m = P.alpha(p);
+    const box = [0, 0, P.W - 1, P.H - 1] as const;
+    const arms = armSides.length > 0 ? (armsFromJoints(P, [p], joints, null, false).arms ?? []) : [];
+    const legs = legSides.length > 0 ? (legsFromJoints(P, [p], joints).chains ?? []) : [];
+    const [h, c, n] = [rnd(trunk.hip), rnd(trunk.chest), rnd(trunk.neck)];
+    const limbs: Array<{ limb: string; poly: Pt[]; cuts: Array<{ joint: string; line: JointLine | null }> }> = [
+      { limb: 'trunk', poly: [h, c, n], cuts: [{ joint: 'chest', line: jointLine(h, c, n) }, { joint: 'neck', line: jointLine(c, n, null) }] },
+      ...arms.map((a) => {
+        const [s, e, t] = [rnd(a.shoulder), rnd(a.elbow), rnd(a.tip)];
+        return { limb: `arm_${a.side}`, poly: [s, e, t], cuts: [{ joint: `${a.side}_elbow`, line: jointLine(s, e, t) }] };
+      }),
+      ...legs.map((g) => {
+        const [hp, k, an] = [rnd(g.hip), rnd(g.knee), rnd(g.ankle)];
+        return { limb: `leg_${g.side}`, poly: [hp, k, an], cuts: [{ joint: `${g.side}_knee`, line: jointLine(hp, k, an) }] };
+      }),
+    ];
+    const polys = limbs.map((l) => l.poly);
+    for (const [i, l] of limbs.entries()) {
+      const art = (x: number, y: number): boolean => x >= 0 && y >= 0 && x < P.W && y < P.H && m.data[y * P.W + x] === 1 && nearestLimb(polys, x, y) === i;
+      for (const { joint, line } of l.cuts) {
+        // A cut with no joint line is assemble's ASSEMBLE_LIMB_JOINT, named there; this reads only where the line is.
+        if (line === null || limbRun(line, art, box) !== null) continue;
+        return `${p.name}'s art is not on the ${joint} cut of ${l.limb}: the joint at [${line.at.join(', ')}] lies on none of ${l.limb}'s art within 1 px along its joint line (${offLineFigure(nearestOnLine(line, art, box))}), where assemble refuses the cut (ASSEMBLE_LIMB_JOINT_ON_ART)`;
+      }
+    }
     return null;
   };
   const read = tw.map((p) => ({ p, miss: misses(p) }));
-  const holds = read.filter((r) => r.miss === null).map((r) => r.p);
   const what = `every joint of ${limbNames.join(', ')} and the origins of hip, chest and neck`;
+  // Issue #631: a part a cloth recipe names explicitly is that recipe's mesh; a limb takes every pixel of its part, so as
+  // the figure layer its mesh would be dropped and the recipe's trees would control no artwork. It is no candidate.
+  const named = read.filter((r) => r.miss === null && clothNamed.has(r.p.name)).map((r) => r.p);
+  const holds = read.filter((r) => r.miss === null && !clothNamed.has(r.p.name)).map((r) => r.p);
+  const recipeOf = (p: PartRecord): string => clothNamed.get(p.name) as string;
+  if (named.length > 0 && holds.length === 0) {
+    throw new PartsError([
+      {
+        code: 'PROPOSE_FIGURE_LAYER',
+        object: `${named.length === 1 ? 'part' : 'parts'} ${named.map((p) => `"${p.name}"`).join(', ')} (topwear)`,
+        detail: `${why}, and only ${named.length === 1 ? 'it holds' : 'they hold'} within ${WRIST_ON_PART_PX} px ${what}, but ${named.map((p) => `${recipeOf(p)} names "${p.name}"`).join(' and ')}: a cloth recipe's part keeps the recipe's mesh, and a limb takes every pixel of its part, so cut into limbs the recipe's trees would control no artwork (issue #631); a figure layer no cloth recipe names is required — give the arms and legs their own handwear and legwear layers, or take the part out of the recipe`,
+      },
+    ]);
+  }
+  const cloth = named.map(
+    (p) =>
+      `${p.name} (${p.from}): not the figure layer, though its art holds within ${WRIST_ON_PART_PX} px ${what} — ${recipeOf(p)} names it, so it keeps the cloth recipe's mesh: a limb takes every pixel of its part, and cut into limbs the recipe's trees would control no artwork (issue #631)`,
+  );
   if (holds.length === 0) {
     return {
+      cloth,
       part: null,
       arms: false,
       legs: false,
@@ -4033,6 +4104,7 @@ function figureLayerOf(
   const fig = scored[0].p;
   const over = scored.length > 1 ? `; of the ${scored.length} topwear parts that hold them it has the most opaque px in the ${2 * half + 1}x${2 * half + 1} squares about those points, ${scored.map((c) => `${c.p.name} ${c.n}`).join(', ')}` : '';
   return {
+    cloth,
     part: fig,
     arms: armSides.length > 0,
     legs: legSides.length > 0,