@rig-c/parts 1.42.0 → 1.44.0

package/cli.ts

@@ -31,6 +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, TOLERANCE_FIGURE_DIVISOR } from './src/meshdraft.ts';
 import { 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';
 import { readPng, writePng } from './src/raster/png.ts';
 import { REQUIREMENTS_SENTENCE } from './src/requirements.ts';
@@ -344,6 +345,7 @@ usage:
 
   rig-parts remesh --rig <dir> --config <config.json> --parts <dir> --part <name>
                    --mesh <entry.json> --out <dir> [--requirements <file.json>]
+                   (or --delta <mesh-edit.json> in place of --mesh)
                    [--idle-keys ctl|direct] [--page-edges pot|free] [--pack-shape rect|polygon]
       Re-fit one part's mesh of a gated rig (the directory rig writes) under
       the mesh entry --mesh holds — what config.json would hold at
@@ -370,6 +372,42 @@ usage:
       SHA-256, the part's counts before and after, both checks and their
       scope) — no path and no clock, so the same request writes the same bytes.
       Prints the part's counts and a hash table of every file.
+      --delta, in place of --mesh (exactly one of the two): rig-c/review's
+      mesh edit (rig-review-mesh-edit/1, basis "setup", at most 300 ops of
+      move, add, remove, edge and unedge, crop px of the rig canvas), whose
+      source counts and source.hash must be the input part's
+      (REMESH_DELTA_SOURCE). The ops are replayed in order over the input's
+      own mesh — moved vertices rebound, added ones weighted from their
+      edge's or triangle's corners, removed ones' rings re-triangulated,
+      Delaunay restored by flips that keep the hull and every constraint —
+      and the result is held to the outline rules (REMESH_DELTA_JSON,
+      REMESH_DELTA_BASIS, REMESH_DELTA_OPS, REMESH_DELTA_OP naming ops[i],
+      REMESH_DELTA_TOPOLOGY). No config entry is built: the baseline is the
+      input itself; the splice, the gate and check are as for --mesh.
+
+  rig-parts retune --rig <dir> --config <config.json> --parts <dir> --out <dir>
+                   [--requirements <file.json>] [--idle-keys ctl|direct]
+                   [--page-edges pot|free] [--pack-shape rect|polygon]
+      Splice the constraints and the idle a config states onto a gated rig
+      (the directory rig writes) and write a new revision into --out, which
+      must not exist (RETUNE_OUT_FRESH); the input is never written. The
+      config is built once through the rig stage (RETUNE_CONFIG_REFUSED,
+      quoting each problem), and that build must state the input's stops,
+      bones, slots, skeleton, images, every invariant but detached and every
+      byte of motion.json but animations.idle (RETUNE_REQUEST_HELD): a moved
+      bone, a redrawn image, a stops change or an animations_from change is
+      no retune. No attachment is compared — the input's meshes are carried
+      over as bytes, repairs included, and a meshes change in the config is
+      never read (remesh is a mesh's producer). rig.json takes the build's
+      constraints and invariants.detached, motion.json its animations.idle,
+      every other byte is the input's (RETUNE_PRESERVED); rigc's build gate
+      passes over the revision (RETUNE_RIGC_GREEN); check measures every bar
+      on it that it measures on the input and fails none the input meets
+      (RETUNE_CHECK_HELD). --out receives the revision and ${RETUNE_FILE}
+      (spec "${RETUNE_SPEC}": the request, both versions, every input file's
+      SHA-256, what was held, which constraint fields and idle tracks changed,
+      both checks and their scope) — no path and no clock, so the same request
+      writes the same bytes. Prints what changed and a hash table of every file.
 
   rig-parts check --rig <dir> --out <dir> [--parts <dir>] [--source <painting.png>]
                     [--page-edges pot|free] [--pack-shape rect|polygon]
@@ -834,7 +872,8 @@ const TAKES = {
   build: { valued: ['--config', '--source', '--full', '--head', '--out', '--seam', '--project', '--page-edges', '--pack-shape', '--requirements', '--idle-keys', '--lead-in', '--alt', '--set'], switches: ['--loop', '--seam-pairs', '--keep-stills', '--all-sets'] },
   compose: { valued: ['--scene', '--out', '--requirements', '--accept'], switches: [] },
   'mesh-draft': { valued: ['--config', '--parts', '--out', '--requirements', '--idle-keys', '--page-edges', '--pack-shape'], switches: ['--more-triangles'] },
-  remesh: { valued: ['--rig', '--config', '--parts', '--part', '--mesh', '--out', '--requirements', '--idle-keys', '--page-edges', '--pack-shape'], switches: [] },
+  remesh: { valued: ['--rig', '--config', '--parts', '--part', '--mesh', '--delta', '--out', '--requirements', '--idle-keys', '--page-edges', '--pack-shape'], switches: [] },
+  retune: { valued: ['--rig', '--config', '--parts', '--out', '--requirements', '--idle-keys', '--page-edges', '--pack-shape'], switches: [] },
   painting: { valued: ['--keypoints', '--person'], switches: [] },
 } as const satisfies Record<string, { valued: readonly string[]; switches: readonly string[] }>;
 
@@ -1649,8 +1688,9 @@ function cmdMeshDraft(args: string[]): number {
 
 /** `remesh` (issue #495): one part of a gated rig re-fitted under a requested mesh entry, into a new revision. */
 function cmdRemesh(args: string[]): number {
-  const f = flags(args, 'remesh', ['--rig', '--config', '--parts', '--part', '--mesh', '--out']);
+  const f = flags(args, 'remesh', ['--rig', '--config', '--parts', '--part', '--out']);
   if (typeof f === 'string') return usage(f);
+  if (f.has('--mesh') === f.has('--delta')) return usage('remesh needs exactly one of --mesh, --delta');
   const keys = idleKeysOf(f.get('--idle-keys'));
   if (!isIdleKeys(keys)) return usage(keys);
   const edges = pageEdgesOf(f.get('--page-edges'));
@@ -1671,7 +1711,46 @@ function cmdRemesh(args: string[]): number {
   try {
     const req = f.get('--requirements');
     remeshStage(
-      { rig: f.get('--rig') as string, config: f.get('--config') as string, parts: f.get('--parts') as string, part: f.get('--part') as string, mesh: f.get('--mesh') as string, out: f.get('--out') as string, idleKeys: keys, pageEdges: edges, packShape: shape, ...(req === undefined ? {} : { requirements: req }) },
+      { rig: f.get('--rig') as string, config: f.get('--config') as string, parts: f.get('--parts') as string, part: f.get('--part') as string, ...(f.has('--mesh') ? { mesh: f.get('--mesh') as string } : { delta: f.get('--delta') as string }), out: f.get('--out') as string, idleKeys: keys, pageEdges: edges, packShape: shape, ...(req === undefined ? {} : { requirements: req }) },
+      runner,
+      bin,
+      { parts: version(), rigc: rigcVersion },
+      scratch,
+      console.log,
+    );
+    return EXIT_OK;
+  } catch (err) {
+    return printRefusal(err);
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+
+/** `retune` (issue #527): the constraints and the idle a config states, spliced onto a gated rig, into a new revision. */
+function cmdRetune(args: string[]): number {
+  const f = flags(args, 'retune', ['--rig', '--config', '--parts', '--out']);
+  if (typeof f === 'string') return usage(f);
+  const keys = idleKeysOf(f.get('--idle-keys'));
+  if (!isIdleKeys(keys)) return usage(keys);
+  const edges = pageEdgesOf(f.get('--page-edges'));
+  if (!isPageEdges(edges)) return usage(edges);
+  const shape = packShapeOf(f.get('--pack-shape'));
+  if (!isPackShape(shape)) return usage(shape);
+  let bin: string;
+  try {
+    bin = findRigc(import.meta.dir, process.env.PATH ?? '');
+  } catch (err) {
+    return printRefusal(err);
+  }
+  const runner = rigcRunner(bin);
+  const said = runner(['--version']);
+  const rigcVersion = said.status === 0 ? (said.out.trim().split('\n')[0] ?? '') : '';
+  if (rigcVersion === '') return printRefusal(new PartsError([{ code: 'RETUNE_RIGC_GREEN', object: 'rigc --version', detail: `exited ${said.status}${rigcRanClause(said)}; the provenance names the rigc that gated the revision, so its version is required` }]));
+  const scratch = mkdtempSync(join(tmpdir(), 'rig-parts-retune-'));
+  try {
+    const req = f.get('--requirements');
+    retuneStage(
+      { rig: f.get('--rig') as string, config: f.get('--config') as string, parts: f.get('--parts') as string, out: f.get('--out') as string, idleKeys: keys, pageEdges: edges, packShape: shape, ...(req === undefined ? {} : { requirements: req }) },
       runner,
       bin,
       { parts: version(), rigc: rigcVersion },
@@ -1756,6 +1835,7 @@ function main(argv: string[]): number | Promise<number> {
   if (command === 'compose') return cmdCompose(rest);
   if (command === 'mesh-draft') return cmdMeshDraft(rest);
   if (command === 'remesh') return cmdRemesh(rest);
+  if (command === 'retune') return cmdRetune(rest);
   if (command === 'painting') return cmdPainting(rest);
   if (command === 'guide') return cmdGuide(rest);
   const later = LATER.find(([name]) => name === command);

package/docs/AUTHORING.md

@@ -2924,6 +2924,12 @@ exits 0, and `mesh_draft.json` and the console name the reading and the amount.
 | <a id="REMESH_PRESERVED"></a>`REMESH_PRESERVED` | the spliced revision differs from the input outside the part's attachment and its report row; the file and the part that moved are named | a defect in this package: report it with the line |
 | <a id="REMESH_RIGC_GREEN"></a>`REMESH_RIGC_GREEN` | rigc's build gate refused the revision (its lines quoted), or `rigc --version` named no version for the provenance | read rigc's line; nothing was written |
 | <a id="REMESH_CHECK_HELD"></a>`REMESH_CHECK_HELD` | `check` on the revision did not measure a bar it measured on the input, or failed a bar the input met; the revision's own FAIL line is quoted | ask for a finer entry, or a different mode, for the part the line names |
+| <a id="REMESH_DELTA_JSON"></a>`REMESH_DELTA_JSON` | `--delta` is missing, does not parse, is not one object, its `schema` is not `rig-review-mesh-edit/1`, or `slot`, `skin`, `attachment` or `source` is not of its shape | export the mesh edit from rig-c/review as it writes it |
+| <a id="REMESH_DELTA_BASIS"></a>`REMESH_DELTA_BASIS` | the mesh edit's `basis` is not `"setup"`: it was drawn over a pose, and the producer binds setup positions, so it is refused rather than posed back (the basis found is quoted) | edit the mesh in setup space (rig-c/review #100) and export again |
+| <a id="REMESH_DELTA_OPS"></a>`REMESH_DELTA_OPS` | `ops` is not an array, or holds more than 300 ops — review's own cap per attachment | split the edit: apply the first part, then edit the revision |
+| <a id="REMESH_DELTA_SOURCE"></a>`REMESH_DELTA_SOURCE` | the mesh edit was not drawn over this part's mesh: its `slot` or `attachment` is not `--part`, its skin is not `default`, a `source` count (`vertexCount`, `triangleCount`, `hullLength`) or `source.hash` is not the input's (both figures quoted; the hash is SHA-256 of the part's entry in rigc's `skeleton.model.json` over the input); or the input's bindings are not where its uvs and `parts.json` place the image, so no position can be bound | export the edit from the revision you pass as `--rig` |
+| <a id="REMESH_DELTA_OP"></a>`REMESH_DELTA_OP` | one op, named `ops[i]` and quoted, does not apply at its place in the replay: an unknown kind, a non-finite number, an id out of range or already removed, a `from` that is not the live position within 0.001 px, a position outside the part's image, a split of an edge the producer's triangulation does not hold or outside its triangles, a free `add` outside every triangle, a move that folds its ring, a removal that leaves fewer than 3 vertices, ends a constraint or leaves a ring no ear clips, an `edge` that duplicates a constraint, is a hull edge, runs through a vertex or crosses the hull or a constraint, or an `unedge` of any edge this edit did not constrain | read the op the line names; an edge the producer flipped is not one review can unedge — redraw it with `edge`, or move the vertices |
+| <a id="REMESH_DELTA_TOPOLOGY"></a>`REMESH_DELTA_TOPOLOGY` | the replayed mesh breaks an outline rule (`contourTopologyProblems`' code quoted: one loop, the hull first, every triangle wound one way, no self-intersection, no coincident vertices), or holds more interior edges that are not locally Delaunay than the input did; or the input's own triangles are not wound one way | read the quoted code; the ops that made it are the edit's last ones |
 
 A remesh changes one part's mesh and nothing else: every file of the input but
 `rig.json` and `mesh_report.json` is copied as bytes, `rig.json` keeps every byte
@@ -2933,6 +2939,78 @@ names the input's SHA-256 per file, the request, both versions, the part's count
 before and after and both checks, and quotes `check`'s own physics line as the scope
 of the revision's check.
 
+**`--delta <mesh-edit.json>`** (in place of `--mesh`, exactly one of the two; issue
+#526) reads rig-c/review's mesh edit, `rig-review-mesh-edit/1`: `slot`, `skin`,
+`attachment`, `source` (`vertexCount`, `triangleCount`, `hullLength`, `hash`), `units`,
+`basis` and up to 300 `ops`, each one of `move {v, from, to}`, `add {at, onEdge?}`,
+`remove {v}`, `edge {a, b}` and `unedge {a, b}`. Positions are crop px of the rig canvas
+(x right, y down): a vertex's position is its part-local px (`uv × (width, height)`)
+plus the image's origin, `parts.json`'s `x, y` less the pad of 4. Vertex ids are the
+attachment's indices; an added vertex takes the next id; a removed id is never reused.
+`basis` must be `"setup"`. Review only records the ops; the producer retriangulates,
+replaying them in order over the input part's own mesh:
+
+- `move`: `from` must be the live position within 0.001 px; the uv and every binding's
+  bone-local `x, y` are recomputed from `to` through the setup frames, the shares kept.
+- `add` with `onEdge`: the edge is split, two triangles into four (one into two on a
+  hull edge, whose loop gains the vertex); its shares are the two ends' blended by the
+  parameter along the edge. Without `onEdge`: the triangle holding the point is split in
+  three (on an edge, as `onEdge`), its shares the corners' barycentric blend. Both are
+  rounded as the lattice rounds shares (5 places, the heaviest closing the sum).
+- `remove`: the vertex and its triangles go, and the ring is ear-clipped by exact
+  orientation; a hull vertex's two hull neighbours become adjacent.
+- `edge`: a constraint — an existing edge is marked, a missing one is made by flipping
+  the edges its segment crosses.
+- `unedge`: only an edge this edit constrained. Every other edge belongs to the
+  producer's triangulation, which differs from the one review drew as soon as a flip
+  runs, so an `unedge` of it is refused rather than guessed at.
+
+After every op the Delaunay condition is restored by edge flips that never flip a hull
+edge or a constraint, and the result is measured: the outline rules and no more
+non-Delaunay interior edges than the input had. The output writes the hull loop first,
+the other vertices after in id order, uvs to 6 places and bindings as `rig` writes them;
+every vertex the edit neither moves nor removes keeps its uv pair and weight entries
+byte for byte. No config entry is built — the baseline is the input itself, held to the
+edit by `source`'s counts and `source.hash` (rigc's build over the input) — and the
+part's `mesh_report.json` row is the input's with `vertices`, `triangles`, `hull`,
+`bones`, `max_influences` and `mean_influences` recomputed and `mode` "delta"; its other
+keys describe the mesh the edit was drawn over. The splice, the preserve assertion, the
+gate and `check` are the `--mesh` path's. A constraint is a statement about this
+revision's triangulation only: the rig spec has no field for it, so a later edit of the
+revision reads it as any other edge.
+
+### retune
+
+| rule | means | change |
+| --- | --- | --- |
+| <a id="RETUNE_OUT_FRESH"></a>`RETUNE_OUT_FRESH` | `--out` exists, or lies inside `--rig`: a revision is a new directory beside the input, never written over it | name a directory that does not exist yet |
+| <a id="RETUNE_INPUT_PRESENT"></a>`RETUNE_INPUT_PRESENT` | `--rig` is not the directory `rig` writes: `rig.json`, `motion.json`, `mesh_report.json` or `images/` is missing | point `--rig` at a `rig` output (`build`'s `rig/`, or a `remesh` or `retune` revision) |
+| <a id="RETUNE_INPUT_WRITTEN"></a>`RETUNE_INPUT_WRITTEN` | `rig.json` or `motion.json` is not the text this package's writer prints for its value (reformatted, or written by something else); the revision is spliced as text, so it could not carry every other byte over | use the files as `rig` wrote them |
+| <a id="RETUNE_CONFIG_REFUSED"></a>`RETUNE_CONFIG_REFUSED` | the rig stage refused the config as written — the loader, a mesh's own checks, an `auto` mesh's motion gate under the new idle, or rigc's gate; each problem is quoted, and nothing was written | change the field the quoted problem names |
+| <a id="RETUNE_REQUEST_HELD"></a>`RETUNE_REQUEST_HELD` | the config's build does not state the input's `stops`, `bones` (a bone moved, renamed, added, re-inherited, or a `<bone>_ctl` added or dropped), `slots`, `skeleton`, `images`, an image file, an `invariants` entry other than `detached`, or a byte of `motion.json` outside `animations.idle` (`animations_from`, the groups, the easings, the face deform); the first differing leaf is named | make it a config change and rebuild with `rig --config` |
+| <a id="RETUNE_PRESERVED"></a>`RETUNE_PRESERVED` | the spliced revision differs from the input outside `rig.json`'s `constraints` and `invariants.detached` and `motion.json`'s `animations.idle`; the file and the path that moved are named | a defect in this package: report it with the line |
+| <a id="RETUNE_RIGC_GREEN"></a>`RETUNE_RIGC_GREEN` | rigc's build gate refused the revision (its lines quoted), or `rigc --version` named no version for the provenance | read rigc's line; nothing was written |
+| <a id="RETUNE_CHECK_HELD"></a>`RETUNE_CHECK_HELD` | `check` on the revision did not measure a bar it measured on the input, or failed a bar the input met; the revision's own FAIL line is quoted | soften the constraint or the idle track the line names |
+
+A retune replaces a rig's physics and its idle and nothing else. The config is built
+once through the rig stage; from that build `rig.json` takes `constraints` and
+`invariants.detached` (which the rig stage derives from the constraints), and
+`motion.json` takes `animations.idle`. Every other byte is the input's: every
+attachment and image, every `mesh_report.json` row and every other animation, so a
+mesh the config does not reproduce — a `remesh` revision, or a repair accepted after
+the config was written — is carried over as it is. What the build must state as the
+input does is held, and a config that moves it is refused rather than half-applied:
+a `stops` change (it rewires bones, slots and weights onto the drawn links
+`<link>_d`, so it is outside what a retune holds byte for byte), a moved, renamed or
+re-`inherit`ed bone, a new control bone under `--idle-keys ctl`, a redrawn image, or a
+change to `animations_from`. No mesh is compared or written, so a `meshes` change in
+the config is left out of the revision — `retune.json`'s `held.not_compared` says so;
+`remesh` is the producer of a mesh. `retune.json` names the input's SHA-256 per file,
+what was held, which constraint fields changed (and which constraints were added or
+removed), how many idle tracks changed and the idle's duration before and after, both
+versions and both checks, and quotes `check`'s own physics line as the scope of the
+revision's check.
+
 ### rig-c's mesh refusals, quoted in a line
 
 rig-c's mesh library refuses a malformed input by throwing with a code of its own. This

package/docs/STABILITY.md

@@ -61,7 +61,8 @@ defaults are the help's too, and none is guessed from the art.
 | `build` | `--config`, `--source`, `--full`, `--out`; optional `--head` (as for `assemble`), `--seam`, `--project`, `--page-edges`, `--pack-shape`, `--loop`, `--lead-in`, `--requirements`, `--idle-keys`, `--seam-pairs`, `--keep-stills`, `--alt` (as for `assemble`, issue #454), `--set` or `--all-sets` (as for `check`, issue #454) |
 | `compose` | `--scene`, `--out`; optional `--requirements`, `--accept` |
 | `mesh-draft` | `--config`, `--parts`, `--out`; optional `--requirements`, `--idle-keys` (ctl, direct), `--page-edges` (pot, free), `--pack-shape` (rect, polygon), `--more-triangles` |
-| `remesh` | `--rig`, `--config`, `--parts`, `--part`, `--mesh`, `--out`; optional `--requirements`, `--idle-keys` (ctl, direct), `--page-edges` (pot, free), `--pack-shape` (rect, polygon) |
+| `remesh` | `--rig`, `--config`, `--parts`, `--part`, `--out`, and one of `--mesh` or `--delta` (issue #526); optional `--requirements`, `--idle-keys` (ctl, direct), `--page-edges` (pot, free), `--pack-shape` (rect, polygon) |
+| `retune` | `--rig`, `--config`, `--parts`, `--out`; optional `--requirements`, `--idle-keys` (ctl, direct), `--page-edges` (pot, free), `--pack-shape` (rect, polygon) |
 | `painting` | one positional path, the painting; `--keypoints`; optional `--person` |
 | `guide` | one positional argument: a rule name, `§<n>`, `§<n>.<m>` or `§<n>.<m>.<k>` |
 | (none) | `--version`, `--help` |
@@ -198,14 +199,15 @@ every number) are AUTHORING §3's tables, and the loader refuses any other by na
 | `proposal.json`, `render/landmarks*.png` | `propose` | the config's four rig sections, `constraints` with `--cloth` (issue #364: a physics constraint per tree link named `<bone>_physics`, a dangling end's `<bone>_translate`, and a skirt swing's transforms `<swing>_<tree>`), `turn` with `--full`/`--head`, `proposed_rig_scale` (issue #354), and `notes` |
 | `basis.json` | `propose` | spec `spine-parts-basis/1` |
 | `config.json`, `mesh_draft.json` | `mesh-draft` | `config.json` is the config read, byte for byte, but for each drafted part's `meshes` entry; `mesh_draft.json` is spec `rig-parts-mesh-draft/1`: `rules`, `lattice_check`, `draft_check`, `figure_overdraw`, and per lattice part `part`, `mode`, `lattice`, `candidate` (with `bridges` — `units`, `joins` of `span` and `area_px2`, `area_px2`, `overdraw`, and `faint` only when an island was left out as faint — only when the candidate is a bridged one, issue #326), `delta` (under `--more-triangles` only), `readings`, `gate` (each line's `reading`, `pass`, `text`, `margin`), `note`; and `not_compared` (issue #307), only when the config holds an `auto` or `contour` entry: per such entry, in config order, `part`, `mode` and `note` — the part was neither drafted nor compared, and a config of lattices alone writes no such key |
-| `rig.json`, `motion.json`, `mesh_report.json`, `images/`, `remesh.json` | `remesh` | the input revision's files, `rig.json` and `mesh_report.json` with the part's attachment and row replaced, every other file byte for byte; `remesh.json` is spec `rig-parts-remesh/1`: `request` (`part`, `mesh`, `mesh_sha256`, `idle_keys`, `page_edges`, `pack_shape`), `versions` (`parts`, `rigc`), `input` (`rig` — `path`, `bytes`, `sha256` per file — `config_sha256`, `parts_json_sha256`), `baseline` (`reproduced`, `not_compared`), `target` (`before`, `after`: `vertices`, `triangles`, `hull`), `preserved` (`identical`, `spliced`), `revision` (per file as `input.rig`), `check` (`input`, `revision`: `pass`, `measured`, `not_met`, `skipped`, `physics`; `scope`) |
+| `rig.json`, `motion.json`, `mesh_report.json`, `images/`, `remesh.json` | `remesh` | the input revision's files, `rig.json` and `mesh_report.json` with the part's attachment and row replaced (under `--delta` the row is the input's with its counts, `bones` and influences recomputed and `mode` "delta"), every other file byte for byte; `remesh.json` is spec `rig-parts-remesh/1`: `request` (`part`, `mesh`, `mesh_sha256`, `idle_keys`, `page_edges`, `pack_shape`; under `--delta`, issue #526: `part`, `delta` — the mesh edit as read — `delta_sha256`, `ops`, `applied` — `moved`, `added`, `removed`, `constrained` — `idle_keys`, `page_edges`, `pack_shape`), `versions` (`parts`, `rigc`), `input` (`rig` — `path`, `bytes`, `sha256` per file — `config_sha256`, `parts_json_sha256`), `baseline` (`reproduced`, `not_compared`; under `--delta` `reproduced` holds one sentence: no config is built, the input is the baseline), `target` (`before`, `after`: `vertices`, `triangles`, `hull`), `preserved` (`identical`, `spliced`), `revision` (per file as `input.rig`), `check` (`input`, `revision`: `pass`, `measured`, `not_met`, `skipped`, `physics`; `scope`) |
+| `rig.json`, `motion.json`, `mesh_report.json`, `images/`, `retune.json` | `retune` | the input revision's files, `rig.json` with `constraints` and `invariants.detached` replaced and `motion.json` with `animations.idle` replaced by the config's build, every other file byte for byte; `retune.json` is spec `rig-parts-retune/1`: `request` (`idle_keys`, `page_edges`, `pack_shape`), `versions` (`parts`, `rigc`), `input` (`rig` — `path`, `bytes`, `sha256` per file — `config_sha256`, `parts_json_sha256`), `held` (`compared`, `not_compared`), `changed` (`constraints` — each `name`, `type`, `fields` — `added`, `removed`, `idle`: `tracks_changed`, `duration` as before and after), `preserved` (`identical`, `spliced`), `revision` (per file as `input.rig`), `check` (`input`, `revision`: `pass`, `measured`, `not_met`, `skipped`, `physics`; `scope`) |
 | the scene report | `compose` | spec `spine-parts-scene-report/1` |
 | `idle.png`, `idle-indexed.png`, `idle.gif` | `loop`, `build --loop` | APNG and GIF encodings of the rendered idle |
 
 Files authors write for this package, each with a spec id the reader holds:
 `spine-parts-requirements/1` (`check --requirements`), `spine-parts-scene/1`
 (`compose --scene`), `spine-parts-keypoints/1` (`propose --keypoints`),
-`spine-parts-bonemap/1` (`compare --map`). The spec ids keep the package's former
+`spine-parts-bonemap/1` (`compare --map`); and one another tool writes, read as that tool defines it: rig-c/review's `rig-review-mesh-edit/1` (`remesh --delta`). The spec ids keep the package's former
 name on purpose: they name a file format, not the tool, and a file written before
 the rename still reads. They do not change at 1.0.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rig-c/parts",
-  "version": "1.42.0",
+  "version": "1.44.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": {