@rig-c/parts 1.42.0 → 1.43.0

package/cli.ts

@@ -344,6 +344,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 +371,18 @@ 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 check --rig <dir> --out <dir> [--parts <dir>] [--source <painting.png>]
                     [--page-edges pot|free] [--pack-shape rect|polygon]
@@ -834,7 +847,7 @@ 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: [] },
   painting: { valued: ['--keypoints', '--person'], switches: [] },
 } as const satisfies Record<string, { valued: readonly string[]; switches: readonly string[] }>;
 
@@ -1649,8 +1662,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 +1685,7 @@ 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 },

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,46 @@ 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.
+
 ### 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,7 @@ 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) |
 | `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 +198,14 @@ 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`) |
 | 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.43.0",
   "description": "AI-authored 2D character parts from one anime painting and its See-through layer decomposition: measured parts, weighted-mesh rig specs, verified through rig-c before anything is written. A CLI for agents that cannot see the image.",
   "type": "module",
   "bin": {

package/src/remesh.ts

@@ -15,6 +15,11 @@
  * `motion` gate; for `contour` its tolerance, margin, spacing and `maxEdge`; for `grid` its spacing. There is no
  * second vocabulary for them, so there is no second loader.
  *
+ * `--delta <mesh-edit.json>` (issue #526), in place of `--mesh`: rig-c/review's mesh edit, ops over the input's own
+ * mesh, replayed by `src/remeshdelta.ts`. That path builds no config entry — steps 3 and 4 become the source checks
+ * (the edit's counts and `source.hash`, the SHA-256 of the part's entry in rigc's model document over the input) and
+ * the replay — and steps 5 to 8 are the same.
+ *
  * ## The steps, each one a refusal by name
  *
  * 1. **The input** ({@link readTree}): `--rig` holds `rig.json`, `motion.json`, `mesh_report.json` and `images/`, as
@@ -55,12 +60,16 @@
 import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join, relative, resolve, sep } from 'node:path';
-import { checkStage, gateThroughRigc, type Log, rigStage } from './build.ts';
+import { checkStage, gateThroughRigc, type Log, RIGC_MODEL_DOCUMENT, rigStage } from './build.ts';
 import { barsNotMet, type CheckReport, DEFAULT_PACK_SHAPE, DEFAULT_PAGE_EDGES, type PackShape, type PageEdges, rigcRanClause, type RigcRunner } from './check.ts';
 import { loadConfigAndAnimations } from './config.ts';
 import { PartsError, type Problem, problemLine, refuseIfAny } from './errors.ts';
 import { jsonValueSpan, scratchConfig } from './meshdraft.ts';
-import { DEFAULT_IDLE_KEYS, type IdleKeys, rigJsonText } from './rig.ts';
+import { computeExactFrameTransforms } from './coords.ts';
+import { type PartsFile } from './parts.ts';
+import { applyMeshEdit, type DeltaApplied, type DeltaPlant, deltaSourceProblems, type MeshEditDocument, readMeshEdit } from './remeshdelta.ts';
+import { DEFAULT_IDLE_KEYS, type IdleKeys, type MeshAttachment, rigJsonText, type RigSpec } from './rig.ts';
+import { pyRound } from './round.ts';
 
 /** The provenance file's spec. */
 export const REMESH_SPEC = 'rig-parts-remesh/1';
@@ -88,8 +97,10 @@ export interface RemeshInput {
   parts: string;
   /** The part to remesh: its slot and its attachment, as the rig stage names both. */
   part: string;
-  /** The request's mesh entry: a JSON file holding what `config.json` would hold at `meshes.<part>`. */
-  mesh: string;
+  /** The request's mesh entry: a JSON file holding what `config.json` would hold at `meshes.<part>`. Exactly one of `mesh`, `delta`. */
+  mesh?: string;
+  /** The request as rig-c/review's mesh edit (`rig-review-mesh-edit/1`, issue #526): ops over the input's own mesh. Exactly one of `mesh`, `delta`. */
+  delta?: string;
   /** The new revision's directory; it must not exist. */
   out: string;
   idleKeys?: IdleKeys;
@@ -106,6 +117,8 @@ export interface RemeshInput {
 export interface RemeshPlant {
   perturb?: string;
   skipPreserve?: boolean;
+  /** Issue #526's mutants, handed to the delta's replay (`src/remeshdelta.ts`). */
+  delta?: DeltaPlant;
 }
 
 /** The versions the provenance names: this package's and the rigc that gated the revision (its `--version` line). */
@@ -143,7 +156,9 @@ export interface CheckSide {
 /** `remesh.json` (spec {@link REMESH_SPEC}). */
 export interface RemeshProvenance {
   spec: typeof REMESH_SPEC;
-  request: { part: string; mesh: unknown; mesh_sha256: string; idle_keys: IdleKeys; page_edges: PageEdges; pack_shape: PackShape };
+  request:
+    | { part: string; mesh: unknown; mesh_sha256: string; idle_keys: IdleKeys; page_edges: PageEdges; pack_shape: PackShape }
+    | { part: string; delta: MeshEditDocument; delta_sha256: string; ops: number; applied: Omit<DeltaApplied, 'ops'>; idle_keys: IdleKeys; page_edges: PageEdges; pack_shape: PackShape };
   versions: RemeshVersions;
   input: { rig: HashRow[]; config_sha256: string; parts_json_sha256: string };
   baseline: { reproduced: string[]; not_compared: string };
@@ -232,7 +247,7 @@ export function targetProblems(rig: Json, motion: Json, configMeshes: Readonly<R
   const out: Problem[] = [];
   const att = targetAttachment(rig, part);
   if (!isRecord(att) || att.type !== 'mesh') {
-    out.push({ code: 'REMESH_TARGET_MESH', object: `rig.json skins.default.${part}.${part}`, detail: `is ${att === undefined ? 'absent' : isRecord(att) ? `a ${String(att.type)} attachment` : 'not an attachment'}; a mesh attachment is required — only a mesh is remeshed` });
+    out.push({ code: 'REMESH_TARGET_MESH', object: `rig.json skins.default.${part}.${part}`, detail: `is ${att === undefined ? 'absent' : isRecord(att) ? `a ${typeof att.type === 'string' ? att.type : 'region'} attachment` : 'not an attachment'}; a mesh attachment is required — only a mesh is remeshed` });
   }
   if (!(part in configMeshes)) {
     out.push({ code: 'REMESH_TARGET_MESH', object: `config meshes.${part}`, detail: `is absent (the config meshes ${Object.keys(configMeshes).join(', ') || 'nothing'}); the input's target must be a mesh the config states, so the baseline can reproduce it` });
@@ -474,6 +489,28 @@ export function readMeshRequest(path: string): { entry: Json; bytes: Uint8Array
   return { entry, bytes };
 }
 
+/** The request as rig-c/review's mesh edit (issue #526), read and held to its shape (`src/remeshdelta.ts`). */
+export function readDeltaRequest(path: string): { doc: MeshEditDocument; bytes: Uint8Array } {
+  if (!existsSync(path)) throw new PartsError([{ code: 'REMESH_DELTA_JSON', object: path, detail: 'no such file; the request\'s mesh edit (rig-c/review\'s rig-review-mesh-edit/1 document) is required' }]);
+  const bytes = new Uint8Array(readFileSync(path));
+  const { doc, problems } = readMeshEdit(text(bytes), path);
+  refuseIfAny(problems);
+  return { doc: doc as MeshEditDocument, bytes };
+}
+
+/**
+ * The hash rig-c/review binds a mesh edit to (`source.hash`): SHA-256 of `JSON.stringify` of the attachment's entry in
+ * rigc's model document (`skins[name "default"].attachments.<part>.<part>`), or null when the document holds none.
+ */
+export function modelAttachmentHash(modelText: string, part: string): string | null {
+  const model = JSON.parse(modelText) as { skins?: unknown };
+  const skin = Array.isArray(model.skins) ? (model.skins as unknown[]).find((s) => isRecord(s) && s.name === 'default') : undefined;
+  const atts = isRecord(skin) && isRecord(skin.attachments) ? skin.attachments : undefined;
+  const slot = atts !== undefined && isRecord(atts[part]) ? (atts[part] as Json) : undefined;
+  const entry = slot?.[part];
+  return entry === undefined ? null : createHash('sha256').update(JSON.stringify(entry)).digest('hex');
+}
+
 /** Step 1's tree rules: the files `rig` writes are present, and the two the splice rewrites are this writer's bytes. */
 export function inputTreeProblems(tree: FileTree, root: string): Problem[] {
   const out: Problem[] = [];
@@ -496,6 +533,35 @@ export function inputTreeProblems(tree: FileTree, root: string): Problem[] {
   return out;
 }
 
+/** A tree's images as the gate takes them (name under `images/`, bytes). */
+const pngsOf = (tree: FileTree): Array<readonly [string, Uint8Array]> => [...tree].filter(([k]) => k.startsWith('images/')).map(([k, b]) => [k.slice('images/'.length), b] as const);
+/** A tree's other files as text. */
+const textsOf = (tree: FileTree): Array<readonly [string, string]> => [...tree].filter(([k]) => !k.startsWith('images/')).map(([k, b]) => [k, text(b)] as const);
+
+/**
+ * The delta's `mesh_report.json` row (issue #526): the input's row, key for key, with `vertices`, `triangles`, `hull`,
+ * `bones` (the sorted set the new weights name), `max_influences` and `mean_influences` recomputed from the new
+ * attachment and `mode` "delta" (in place, or last when the row had none). Every other key is the input's and
+ * describes the mesh the delta was drawn over.
+ */
+export function deltaRow(row: Json, att: MeshAttachment): Json {
+  const n = att.uvs.length / 2;
+  const entries = att.weights.reduce((s, w) => s + w.length, 0);
+  const fresh: Json = {
+    vertices: n,
+    triangles: att.triangles.length / 3,
+    hull: att.hull,
+    bones: [...new Set(att.weights.flatMap((w) => w.map((e) => e.bone)))].sort(),
+    max_influences: Math.max(...att.weights.map((w) => w.length)),
+    mean_influences: pyRound(entries / n, 2),
+    mode: 'delta',
+  };
+  const out: Json = {};
+  for (const [k, v] of Object.entries(row)) out[k] = k in fresh ? fresh[k] : v;
+  if (!('mode' in out)) out.mode = 'delta';
+  return out;
+}
+
 /**
  * The stage: steps 1–8 of the module header. Writes `input.out` only when every step is green; refuses with every
  * problem of the first step that found one.
@@ -513,7 +579,9 @@ export function remeshStage(input: RemeshInput, rigc: RigcRunner, checkBin: stri
   if (outAt.startsWith(`${rigAt}${sep}`)) throw new PartsError([{ code: 'REMESH_OUT_FRESH', object: input.out, detail: `is inside the input ${input.rig}; a revision is written beside the input, never into it` }]);
   const tree = readTree(rigAt);
   refuseIfAny(inputTreeProblems(tree, input.rig));
-  const request = readMeshRequest(input.mesh);
+  if ((input.mesh === undefined) === (input.delta === undefined)) throw new Error('remeshStage: exactly one of mesh, delta is required');
+  const meshReq = input.mesh === undefined ? null : readMeshRequest(input.mesh);
+  const deltaReq = input.delta === undefined ? null : readDeltaRequest(input.delta);
   const configText = readFileSync(input.config, 'utf8');
   const { config: cfg } = loadConfigAndAnimations(input.config);
   const inRig = JSON.parse(text(tree.get('rig.json') as Uint8Array)) as Json;
@@ -521,41 +589,85 @@ export function remeshStage(input: RemeshInput, rigc: RigcRunner, checkBin: stri
   const inReport = JSON.parse(text(tree.get('mesh_report.json') as Uint8Array)) as Json[];
   // 2. The target.
   refuseIfAny(targetProblems(inRig, JSON.parse(inMotionText) as Json, cfg.meshes, part));
-  // The request is the config's to judge: spliced in and loaded, before anything is built.
-  const candConfig = scratchConfig(input.config, configText, join(scratch, 'candidate'), new Map([[part, request.entry]]));
-  loadConfigAndAnimations(candConfig);
-  const auto = 'auto' in request.entry;
-  const build = (name: string, config: string): Built => {
-    const out = join(scratch, name, 'rig');
-    rigStage({ config, parts: input.parts, out, idleKeys, pageEdges, packShape }, rigc, join(scratch, name, 'gate'), (l) => log(`[${name}:rig] ${l}`));
-    return readBuilt(out, part);
-  };
-  // 3. The baseline.
-  log(`rig-parts remesh: ${part} of ${input.rig}, ${tree.size} file(s); the baseline is the config as written`);
-  let base: Built;
-  try {
-    base = build('baseline', scratchConfig(input.config, configText, join(scratch, 'baseline'), new Map()));
-  } catch (err) {
-    if (!(err instanceof PartsError)) throw err;
-    throw new PartsError(err.problems.map((p) => ({ code: 'REMESH_BASELINE_MISMATCH', object: `${input.config} as written`, detail: `does not build, so it cannot reproduce the input: ${problemLine(p)}` })));
-  }
-  refuseIfAny(baselineProblems({ rig: inRig, motionText: inMotionText, report: inReport, image: tree.get(`images/${part}.png`) }, base, part, auto));
-  log(`  baseline: the config as written reproduces the input's ${part} (attachment, image, report row) and its bones${auto ? ' and motion' : ''}`);
-  // 4. The candidate.
-  let cand: Built;
-  try {
-    cand = build('candidate', candConfig);
-  } catch (err) {
-    if (!(err instanceof PartsError)) throw err;
-    throw new PartsError(err.problems.map((p) => ({ code: 'REMESH_CANDIDATE_REFUSED', object: `the request's meshes.${part} (${input.mesh})`, detail: `the producer refuses it, nothing is written: ${problemLine(p)}` })));
-  }
-  refuseIfAny(requestHeldProblems(base, cand, part));
-  const candRow = rowOf(cand.report, part);
-  if (candRow === undefined) throw new Error(`remesh: the candidate build wrote no mesh_report row for "${part}"`);
   const before = meshCounts(targetAttachment(inRig, part));
-  const after = meshCounts(targetAttachment(cand.rig, part));
+  let candAtt: unknown;
+  let candRow: Json;
+  let reproduced: string[];
+  let deltaRequest: RemeshProvenance['request'] | null = null;
+  if (meshReq !== null) {
+    const meshPath = input.mesh as string;
+    // The request is the config's to judge: spliced in and loaded, before anything is built.
+    const candConfig = scratchConfig(input.config, configText, join(scratch, 'candidate'), new Map([[part, meshReq.entry]]));
+    loadConfigAndAnimations(candConfig);
+    const auto = 'auto' in meshReq.entry;
+    const build = (name: string, config: string): Built => {
+      const out = join(scratch, name, 'rig');
+      rigStage({ config, parts: input.parts, out, idleKeys, pageEdges, packShape }, rigc, join(scratch, name, 'gate'), (l) => log(`[${name}:rig] ${l}`));
+      return readBuilt(out, part);
+    };
+    // 3. The baseline.
+    log(`rig-parts remesh: ${part} of ${input.rig}, ${tree.size} file(s); the baseline is the config as written`);
+    let base: Built;
+    try {
+      base = build('baseline', scratchConfig(input.config, configText, join(scratch, 'baseline'), new Map()));
+    } catch (err) {
+      if (!(err instanceof PartsError)) throw err;
+      throw new PartsError(err.problems.map((p) => ({ code: 'REMESH_BASELINE_MISMATCH', object: `${input.config} as written`, detail: `does not build, so it cannot reproduce the input: ${problemLine(p)}` })));
+    }
+    refuseIfAny(baselineProblems({ rig: inRig, motionText: inMotionText, report: inReport, image: tree.get(`images/${part}.png`) }, base, part, auto));
+    log(`  baseline: the config as written reproduces the input's ${part} (attachment, image, report row) and its bones${auto ? ' and motion' : ''}`);
+    // 4. The candidate.
+    let cand: Built;
+    try {
+      cand = build('candidate', candConfig);
+    } catch (err) {
+      if (!(err instanceof PartsError)) throw err;
+      throw new PartsError(err.problems.map((p) => ({ code: 'REMESH_CANDIDATE_REFUSED', object: `the request's meshes.${part} (${meshPath})`, detail: `the producer refuses it, nothing is written: ${problemLine(p)}` })));
+    }
+    refuseIfAny(requestHeldProblems(base, cand, part));
+    const row = rowOf(cand.report, part);
+    if (row === undefined) throw new Error(`remesh: the candidate build wrote no mesh_report row for "${part}"`);
+    candAtt = targetAttachment(cand.rig, part);
+    candRow = row;
+    reproduced = [`skins.default.${part}.${part}`, `images/${part}.png`, `mesh_report.json row "${part}"`, 'bones', ...(auto ? ['motion.json'] : [])];
+  } else {
+    // 3–4 on the delta path (issue #526): no config entry to build, so the baseline is the input itself, held to the
+    // delta by its source counts and its source.hash, and the candidate is the delta replayed over the input's mesh.
+    const deltaPath = input.delta as string;
+    const { doc, bytes } = deltaReq as { doc: MeshEditDocument; bytes: Uint8Array };
+    const inAtt = targetAttachment(inRig, part) as MeshAttachment;
+    refuseIfAny(deltaSourceProblems(doc, part, inAtt, deltaPath));
+    log(`rig-parts remesh: ${part} of ${input.rig}, ${tree.size} file(s); the request is a mesh edit of ${doc.ops.length} op(s), the baseline is the input itself`);
+    let model = null as string | null;
+    const inGate = gateThroughRigc(pngsOf(tree), textsOf(tree), rigc, join(scratch, 'gate-input'), { pageEdges, packShape }, (dir) => {
+      const p = join(dir, RIGC_MODEL_DOCUMENT);
+      model = existsSync(p) ? readFileSync(p, 'utf8') : null;
+    });
+    refuseIfAny(inGate.filter((g) => g.status !== 0).map((g) => ({ code: 'REMESH_RIGC_GREEN', object: `rigc ${g.label} over the input`, detail: `exited ${g.status}${g.lines.length > 0 ? `: ${g.lines.map((l) => l.trim()).join(' | ')}` : ''}${rigcRanClause(g)}; the delta's source.hash is read off the input's own build, and nothing was written` })));
+    if (model === null) throw new PartsError([{ code: 'REMESH_DELTA_SOURCE', object: `rigc's build over the input`, detail: `wrote no ${RIGC_MODEL_DOCUMENT}, so the delta's source.hash cannot be verified; nothing was written` }]);
+    const hash = modelAttachmentHash(model, part);
+    if (hash !== doc.source.hash) {
+      throw new PartsError([{ code: 'REMESH_DELTA_SOURCE', object: `${deltaPath} source.hash`, detail: `is ${doc.source.hash.slice(0, 16)}…; the input's ${part} in its ${RIGC_MODEL_DOCUMENT} hashes to ${hash === null ? 'nothing (no such entry)' : `${hash.slice(0, 16)}…`} — the delta was drawn over another mesh` }]);
+    }
+    log(`  source: ${part}'s entry in the input's ${RIGC_MODEL_DOCUMENT} hashes to ${hash.slice(0, 16)}…, the delta's source.hash; counts v=${before.vertices} t=${before.triangles} hull=${before.hull} as it states`);
+    const partsFile = JSON.parse(readFileSync(join(input.parts, 'parts.json'), 'utf8')) as PartsFile;
+    const rec = partsFile.parts.find((p) => p.name === part);
+    if (rec === undefined) throw new PartsError([{ code: 'REMESH_DELTA_SOURCE', object: `${input.parts}/parts.json`, detail: `names no part "${part}"; its box is where rig placed the image, which the delta's crop px are read against` }]);
+    const world = computeExactFrameTransforms((inRig as unknown as RigSpec).bones);
+    const r = applyMeshEdit({ part, attachment: inAtt, box: [rec.x, rec.y], rigSize: [partsFile.rig_size[0], partsFile.rig_size[1]], world }, doc, deltaPath, plant.delta);
+    if (Array.isArray(r)) throw new PartsError(r);
+    const row = rowOf(inReport, part);
+    if (row === undefined) throw new PartsError([{ code: 'REMESH_DELTA_SOURCE', object: `${input.rig}/mesh_report.json`, detail: `holds no row "${part}"; the delta's row is the input's with its counts recomputed` }]);
+    candAtt = r.attachment;
+    candRow = deltaRow(row, r.attachment);
+    const { ops, ...applied } = r.applied;
+    log(`  delta: ${ops} op(s) — moved ${applied.moved}, added ${applied.added}, removed ${applied.removed}, constrained ${applied.constrained}; ${r.untouched.length} source vertex(es) untouched; interior edges not locally Delaunay ${r.delaunay.before} -> ${r.delaunay.after}`);
+    reproduced = ['none built: the delta path builds no config entry, so the baseline is the input itself, held to the delta by source.vertexCount, source.triangleCount, source.hullLength and source.hash'];
+    deltaRequest = { part, delta: doc, delta_sha256: sha256(bytes), ops, applied, idle_keys: idleKeys, page_edges: pageEdges, pack_shape: packShape };
+  }
+  const after = meshCounts(candAtt);
   // 5–6. The splice and the preserve assertion.
-  let revision = splice(tree, part, targetAttachment(cand.rig, part), candRow);
+  let revision = splice(tree, part, candAtt, candRow);
   if (plant.perturb !== undefined) revision = perturbed(revision, plant.perturb);
   if (plant.skipPreserve !== true) refuseIfAny(preservedProblems(tree, revision, part));
   const spliced = ['rig.json', 'mesh_report.json'];
@@ -563,9 +675,7 @@ export function remeshStage(input: RemeshInput, rigc: RigcRunner, checkBin: stri
   log(`  ${part}: v=${before.vertices} t=${before.triangles} hull=${before.hull} -> v=${after.vertices} t=${after.triangles} hull=${after.hull}`);
   log(`  preserved: ${identical.length} file(s) byte-identical to the input; rig.json identical outside skins.default.${part}.${part}; mesh_report.json identical but the "${part}" row`);
   // 7. The gate and check.
-  const pngs = [...revision].filter(([k]) => k.startsWith('images/')).map(([k, b]) => [k.slice('images/'.length), b] as const);
-  const texts = [...revision].filter(([k]) => !k.startsWith('images/')).map(([k, b]) => [k, text(b)] as const);
-  const gate = gateThroughRigc(pngs, texts, rigc, join(scratch, 'gate'), { pageEdges, packShape });
+  const gate = gateThroughRigc(pngsOf(revision), textsOf(revision), rigc, join(scratch, 'gate'), { pageEdges, packShape });
   for (const g of gate) {
     log(`  rigc ${g.label}, the revision: exit ${g.status}`);
     for (const l of g.lines) log(`    ${l.trim()}`);
@@ -587,11 +697,11 @@ export function remeshStage(input: RemeshInput, rigc: RigcRunner, checkBin: stri
   // 8. The write.
   const provenance: RemeshProvenance = {
     spec: REMESH_SPEC,
-    request: { part, mesh: request.entry, mesh_sha256: sha256(request.bytes), idle_keys: idleKeys, page_edges: pageEdges, pack_shape: packShape },
+    request: deltaRequest ?? { part, mesh: (meshReq as { entry: Json }).entry, mesh_sha256: sha256((meshReq as { bytes: Uint8Array }).bytes), idle_keys: idleKeys, page_edges: pageEdges, pack_shape: packShape },
     versions,
     input: { rig: hashRows(tree), config_sha256: sha256(bytesOf(configText)), parts_json_sha256: sha256(new Uint8Array(readFileSync(join(input.parts, 'parts.json')))) },
     baseline: {
-      reproduced: [`skins.default.${part}.${part}`, `images/${part}.png`, `mesh_report.json row "${part}"`, 'bones', ...(auto ? ['motion.json'] : [])],
+      reproduced,
       not_compared: 'every other attachment, image and report row: carried over from the input as bytes, whether or not the config reproduces it',
     },
     target: { before, after },

package/src/remeshdelta.ts

@@ -0,0 +1,669 @@
+/**
+ * `rig-parts remesh --delta` (issue #526): the reader of rig-c/review's mesh edit, `rig-review-mesh-edit/1` — a typed
+ * list of vertex and edge ops a person drew over one part's mesh in review's Edit Mesh — and the producer half of that
+ * loop: the ops replayed, in order, over the input part's own triangulation, retriangulated here (review never
+ * retriangulates; its document says "the producer retriangulates"), and written back as a `mesh` attachment in this
+ * package's form. Pure: no I/O; `src/remesh.ts` reads the files and splices the result.
+ *
+ * ## The document
+ *
+ * `{ schema, slot, skin, attachment, source: { vertexCount, triangleCount, hullLength, hash }, units, basis, preview,
+ * ops }` as review writes it (`src/mesh-edit.ts`, `meshEditDocument`). Positions are crop px of the rig canvas, x
+ * right, y down: a vertex's crop position is its part-local px (`uv × (width, height)`) plus the part's origin
+ * (`parts.json` x − {@link PAD}, y − PAD, the origin `rig` placed the image at). Vertex ids are the attachment's
+ * indices; an added vertex takes the next id; a removed id is never reused. `basis` must be `"setup"` (rig-c/review
+ * #100): a posed basis would put setup vertices where a pose drew them, so it is refused rather than posed back.
+ *
+ * ## The ops, as the producer applies them
+ *
+ * - `move {v, from, to}`: `from` must be the live position (within {@link FROM_TOLERANCE_PX}); the uv and every
+ *   binding's bone-local x, y are recomputed from `to` through the setup frames; the shares are kept. Then the
+ *   Delaunay condition is restored by edge flips around it, never flipping a hull or constraint edge.
+ * - `add {at, onEdge}`: the edge split (two triangles to four; one to two on a hull edge, the hull loop gaining the
+ *   vertex), weights the two ends' shares blended by the parameter along the edge; `add {at}` without `onEdge`: the
+ *   triangle that holds it split in three (on an edge, as `onEdge`), weights the corners' shares by barycentric blend.
+ * - `remove {v}`: the vertex and its triangles dropped and the ring ear-clipped by exact orientation, then flipped;
+ *   a hull vertex's two hull neighbours become adjacent.
+ * - `edge {a, b}`: a constraint — the edge marked, or made by flipping the edges it crosses (edge recovery); one that
+ *   crosses the hull or another constraint is refused.
+ * - `unedge {a, b}`: only an edge this delta constrained; the producer owns every other edge of the triangulation.
+ *
+ * Every op that does not apply is refused by name with its index (`REMESH_DELTA_OP`), and the result is held to the
+ * outline rules and the Delaunay count by {@link contourTopologyProblems} and {@link delaunayViolations}
+ * (`REMESH_DELTA_TOPOLOGY`) — measured on the result, not trusted from the replay.
+ *
+ * ## Coordinates
+ *
+ * Two copies of every position are kept: the exact one (part-local px, a double), which the uv, the bindings and the
+ * `from` comparison read, and its snap to {@link GRID} units, which every predicate reads, so orientation and the
+ * in-circle test are exact (`src/contour.ts`). A vertex the delta neither moves nor removes keeps its uv pair and its
+ * weight entries byte for byte; only its index may change, since the hull loop is written first.
+ */
+import { contourTopologyProblems, delaunayViolations, GRID, inCircle } from './contour.ts';
+import { type BoneTransform, cropToSpineY, toBoneLocal } from './coords.ts';
+import type { Problem } from './errors.ts';
+import { type MeshAttachment, OFFSET_PLACES, PAD, roundShares, type WeightEntry } from './rig.ts';
+import { pyRound } from './round.ts';
+import type { Influence } from './weights.ts';
+
+/** The schema review writes (rig-c/review `src/mesh-edit.ts`, `MESH_EDIT_SCHEMA`). */
+export const MESH_EDIT_SCHEMA = 'rig-review-mesh-edit/1';
+
+/** The basis the reader accepts (rig-c/review #100: the editor works in setup space). */
+export const MESH_EDIT_BASIS = 'setup';
+
+/** Review's own cap on one attachment's ops (`MESH_EDIT_MAX_OPS`: the draft rides in one form field). */
+export const MESH_EDIT_MAX_OPS = 300;
+
+/**
+ * How far `move.from` may sit from the live position, in crop px: the uv is written to 6 places, which moves a
+ * vertex by up to 2.5e-4 px on the parts measured (the public demo's 9 meshes, 1,192 vertices), so 1e-3 holds every
+ * honest `from` and refuses a delta drawn over another mesh. The same tolerance holds the input's own bindings to
+ * the position its uv states ({@link applyMeshEdit}'s reading of the part's origin).
+ */
+export const FROM_TOLERANCE_PX = 1e-3;
+
+export type Vec = [number, number];
+export type MeshEditOp =
+  | { op: 'move'; v: number; from: Vec; to: Vec }
+  | { op: 'add'; at: Vec; onEdge?: [number, number] }
+  | { op: 'remove'; v: number }
+  | { op: 'edge'; a: number; b: number }
+  | { op: 'unedge'; a: number; b: number };
+
+export interface MeshEditDocument {
+  schema: typeof MESH_EDIT_SCHEMA;
+  slot: string;
+  skin: string;
+  attachment: string;
+  source: { vertexCount: number; triangleCount: number; hullLength: number; hash: string };
+  units: string;
+  basis: string;
+  preview: string;
+  ops: MeshEditOp[];
+}
+
+type Json = Record<string, unknown>;
+const isRecord = (v: unknown): v is Json => typeof v === 'object' && v !== null && !Array.isArray(v);
+const isVec = (v: unknown): v is Vec => Array.isArray(v) && v.length === 2 && v.every((n) => typeof n === 'number' && Number.isFinite(n));
+const isId = (v: unknown): v is number => typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+const OP_FIELDS: Record<MeshEditOp['op'], readonly string[]> = { move: ['op', 'v', 'from', 'to'], add: ['op', 'at', 'onEdge'], remove: ['op', 'v'], edge: ['op', 'a', 'b'], unedge: ['op', 'a', 'b'] };
+
+/**
+ * The document, read and held to its shape: `schema` (`REMESH_DELTA_JSON`), `basis` (`REMESH_DELTA_BASIS`), `ops` an
+ * array of at most {@link MESH_EDIT_MAX_OPS} (`REMESH_DELTA_OPS`), each op of a known kind with finite numbers and
+ * whole ids (`REMESH_DELTA_OP`). Every problem is collected and thrown once; whether an id is live is the replay's.
+ */
+export function readMeshEdit(text: string, object: string): { doc: MeshEditDocument | null; problems: Problem[] } {
+  const problems: Problem[] = [];
+  let value: unknown;
+  try {
+    value = JSON.parse(text);
+  } catch (err) {
+    return { doc: null, problems: [{ code: 'REMESH_DELTA_JSON', object, detail: `does not parse as JSON: ${(err as Error).message}` }] };
+  }
+  if (!isRecord(value)) return { doc: null, problems: [{ code: 'REMESH_DELTA_JSON', object, detail: `is ${Array.isArray(value) ? 'an array' : JSON.stringify(value)}; one ${MESH_EDIT_SCHEMA} document is required` }] };
+  if (value.schema !== MESH_EDIT_SCHEMA) problems.push({ code: 'REMESH_DELTA_JSON', object: `${object} schema`, detail: `is ${JSON.stringify(value.schema)}; "${MESH_EDIT_SCHEMA}" (rig-c/review's mesh edit) is required` });
+  for (const k of ['slot', 'skin', 'attachment']) if (typeof value[k] !== 'string') problems.push({ code: 'REMESH_DELTA_JSON', object: `${object} ${k}`, detail: `is ${JSON.stringify(value[k])}; a string is required` });
+  const src = value.source;
+  if (!isRecord(src) || !isId(src.vertexCount) || !isId(src.triangleCount) || !isId(src.hullLength) || typeof src.hash !== 'string') {
+    problems.push({ code: 'REMESH_DELTA_JSON', object: `${object} source`, detail: `is ${JSON.stringify(src)}; { vertexCount, triangleCount, hullLength: whole numbers, hash: a string } is required` });
+  }
+  if (value.basis !== MESH_EDIT_BASIS) {
+    problems.push({ code: 'REMESH_DELTA_BASIS', object: `${object} basis`, detail: `is ${JSON.stringify(value.basis)}; "${MESH_EDIT_BASIS}" is required — the producer binds setup positions, and a delta drawn over a pose (review before rig-c/review #100) is refused rather than posed back` });
+  }
+  const ops = value.ops;
+  if (!Array.isArray(ops)) problems.push({ code: 'REMESH_DELTA_OPS', object: `${object} ops`, detail: `is ${JSON.stringify(ops)}; an array of ops is required` });
+  else if (ops.length > MESH_EDIT_MAX_OPS) problems.push({ code: 'REMESH_DELTA_OPS', object: `${object} ops`, detail: `holds ${ops.length} ops; at most ${MESH_EDIT_MAX_OPS} (review's own cap per attachment) are read` });
+  else {
+    ops.forEach((op: unknown, i: number) => {
+      const bad = (why: string): void => {
+        problems.push({ code: 'REMESH_DELTA_OP', object: `${object} ops[${i}]`, detail: `${JSON.stringify(op)} ${why}` });
+      };
+      if (!isRecord(op) || typeof op.op !== 'string' || !(op.op in OP_FIELDS)) {
+        bad(`has an unknown op kind ${isRecord(op) ? JSON.stringify(op.op) : ''}; one of move, add, remove, edge, unedge is required`);
+        return;
+      }
+      const kind = op.op as MeshEditOp['op'];
+      const extra = Object.keys(op).filter((k) => !OP_FIELDS[kind].includes(k));
+      if (extra.length > 0) bad(`carries ${extra.join(', ')}, which a ${kind} op does not take`);
+      if (kind === 'move') {
+        if (!isId(op.v)) bad('needs a whole vertex id v');
+        if (!isVec(op.from) || !isVec(op.to)) bad('needs finite from and to pairs');
+      } else if (kind === 'add') {
+        if (!isVec(op.at)) bad('needs a finite at pair');
+        if (op.onEdge !== undefined && !(Array.isArray(op.onEdge) && op.onEdge.length === 2 && op.onEdge.every(isId))) bad('needs onEdge as a pair of whole vertex ids, when it is given');
+      } else if (kind === 'remove') {
+        if (!isId(op.v)) bad('needs a whole vertex id v');
+      } else if (!isId(op.a) || !isId(op.b)) bad('needs whole vertex ids a and b');
+      else if (op.a === op.b) bad('joins a vertex to itself');
+    });
+  }
+  return { doc: problems.length === 0 ? (value as unknown as MeshEditDocument) : null, problems };
+}
+
+/** The input the replay reads: the part's attachment, where `rig` placed it, and the setup frames of the rig's bones. */
+export interface DeltaInput {
+  part: string;
+  attachment: MeshAttachment;
+  /** `parts.json`'s box corner (x, y) for the part: the image sits at (x − PAD, y − PAD). */
+  box: Vec;
+  /** `parts.json`'s `rig_size`. */
+  rigSize: Vec;
+  /** Every bone's setup frame, as `computeExactFrameTransforms` gives it over `rig.json`'s bones. */
+  world: ReadonlyMap<string, BoneTransform>;
+}
+
+/** Planted faults for the selftest (issue #526) — never set by the CLI. */
+export interface DeltaPlant {
+  /** A move keeps its bindings' x, y (the bone-local recompute skipped). */
+  skipBind?: boolean;
+  /** The output keeps id order instead of writing the hull loop first. */
+  skipHullOrder?: boolean;
+  /** The result's topology gate is skipped. */
+  skipTopology?: boolean;
+}
+
+export interface DeltaApplied {
+  ops: number;
+  moved: number;
+  added: number;
+  removed: number;
+  constrained: number;
+}
+
+export interface DeltaResult {
+  attachment: MeshAttachment;
+  counts: { vertices: number; triangles: number; hull: number };
+  applied: DeltaApplied;
+  /** Source ids the delta neither moved nor removed: their uv pair and weight entries are the input's bytes. */
+  untouched: number[];
+  /** Interior edges not locally Delaunay, before and after (constraint edges not asked). */
+  delaunay: { before: number; after: number };
+  /** The output index of every live id, in id order (removed ids absent). */
+  index: Array<[number, number]>;
+}
+
+const placed6 = (v: number): number => {
+  const r = pyRound(v, OFFSET_PLACES);
+  return r === 0 ? 0 : r;
+};
+const ekey = (a: number, b: number): string => (a < b ? `${a}:${b}` : `${b}:${a}`);
+
+/** Thrown inside the replay; caught once by {@link applyMeshEdit} and turned into its problem. */
+class OpRefused extends Error {
+  constructor(
+    readonly code: string,
+    readonly at: string,
+    readonly why: string,
+  ) {
+    super(why);
+  }
+}
+
+/**
+ * The source checks a document is held to before any op is replayed: it names this part's attachment in the default
+ * skin, and its source counts are this attachment's (`REMESH_DELTA_SOURCE`, naming the field and both figures).
+ */
+export function deltaSourceProblems(doc: MeshEditDocument, part: string, att: MeshAttachment, object: string): Problem[] {
+  const out: Problem[] = [];
+  for (const k of ['slot', 'attachment'] as const) if (doc[k] !== part) out.push({ code: 'REMESH_DELTA_SOURCE', object: `${object} ${k}`, detail: `is "${doc[k]}"; the delta must name --part "${part}", whose slot and attachment the rig stage names after the part` });
+  if (doc.skin !== 'default') out.push({ code: 'REMESH_DELTA_SOURCE', object: `${object} skin`, detail: `is "${doc.skin}"; this package writes every mesh into the default skin, so "default" is required` });
+  const counts: Array<[string, number, number]> = [
+    ['vertexCount', doc.source.vertexCount, att.uvs.length / 2],
+    ['triangleCount', doc.source.triangleCount, att.triangles.length / 3],
+    ['hullLength', doc.source.hullLength, att.hull],
+  ];
+  for (const [k, said, is] of counts) if (said !== is) out.push({ code: 'REMESH_DELTA_SOURCE', object: `${object} source.${k}`, detail: `is ${said}; the input's ${part} has ${is} — the delta was drawn over another mesh` });
+  return out;
+}
+
+/**
+ * The replay: the document's ops over the input's mesh, in order, and the result held to the outline and Delaunay
+ * rules. Returns the problems (the first op that does not apply ends the replay, since every later op reads its
+ * state) or the new attachment.
+ */
+export function applyMeshEdit(input: DeltaInput, doc: MeshEditDocument, object: string, plant: DeltaPlant = {}): DeltaResult | Problem[] {
+  const att = input.attachment;
+  const { width: w, height: h } = att;
+  const ox = input.box[0] - PAD;
+  const oy = input.box[1] - PAD;
+  const CX = input.rigSize[0] / 2;
+  const H = input.rigSize[1];
+  const V0 = att.uvs.length / 2;
+  // Exact positions (part px) and their grid snaps, by id; the uv and weights to write, by id.
+  const PX: number[] = [];
+  const PY: number[] = [];
+  const X: number[] = [];
+  const Y: number[] = [];
+  const uv: Vec[] = [];
+  const wt: WeightEntry[][] = [];
+  const live: boolean[] = [];
+  const moved = new Set<number>();
+  const added = new Set<number>();
+  const removed = new Set<number>();
+  const snap = (v: number): number => Math.round(v * GRID);
+  const setPos = (id: number, x: number, y: number): void => {
+    PX[id] = x;
+    PY[id] = y;
+    X[id] = snap(x);
+    Y[id] = snap(y);
+  };
+  const bind = (shares: ReadonlyArray<{ bone: string; weight: number }>, x: number, y: number): WeightEntry[] =>
+    shares.map(({ bone, weight }) => {
+      const m = input.world.get(bone);
+      if (m === undefined) throw new OpRefused('REMESH_DELTA_SOURCE', `${input.part}'s weights`, `name bone "${bone}", which rig.json does not declare`);
+      const [bx, by] = toBoneLocal(m, ox + x - CX, cropToSpineY(oy + y, H));
+      return { bone, x: placed6(bx), y: placed6(by), weight };
+    });
+  const problems: Problem[] = [];
+  for (let i = 0; i < V0; i++) {
+    setPos(i, att.uvs[2 * i] * w, att.uvs[2 * i + 1] * h);
+    uv.push([att.uvs[2 * i], att.uvs[2 * i + 1]]);
+    wt.push(att.weights[i]);
+    live.push(true);
+  }
+  // The part's origin is read, not trusted: every input binding must be what its uv states at (ox, oy).
+  try {
+    for (let i = 0; i < V0 && problems.length === 0; i++) {
+      const again = bind(att.weights[i], PX[i], PY[i]);
+      const off = again.findIndex((e, k) => Math.abs(e.x - att.weights[i][k].x) > FROM_TOLERANCE_PX || Math.abs(e.y - att.weights[i][k].y) > FROM_TOLERANCE_PX);
+      if (off >= 0) {
+        const e = att.weights[i][off];
+        problems.push({ code: 'REMESH_DELTA_SOURCE', object: `rig.json skins.default.${input.part}.${input.part} vertex ${i}`, detail: `binds to "${e.bone}" at (${e.x}, ${e.y}); its uv at the part's origin (${ox}, ${oy}) binds at (${again[off].x}, ${again[off].y}) — the input's placement is not the one parts.json states, so no position the delta names can be bound` });
+      }
+    }
+  } catch (err) {
+    if (!(err instanceof OpRefused)) throw err;
+    problems.push({ code: err.code, object: err.at, detail: err.why });
+  }
+  if (problems.length > 0) return problems;
+
+  // Triangles in the replay's winding: orient > 0 in y-down grid units. The input's winding is measured and kept.
+  const orient = (a: number, b: number, c: number): number => (X[b] - X[a]) * (Y[c] - Y[a]) - (Y[b] - Y[a]) * (X[c] - X[a]);
+  let sign = 0;
+  for (let t = 0; t < att.triangles.length; t += 3) {
+    const s = Math.sign(orient(att.triangles[t], att.triangles[t + 1], att.triangles[t + 2]));
+    if (s === 0 || (sign !== 0 && s !== sign)) {
+      return [{ code: 'REMESH_DELTA_TOPOLOGY', object: `rig.json skins.default.${input.part}.${input.part} triangle ${t / 3}`, detail: s === 0 ? 'has zero area in the input; the replay needs every input triangle wound one way' : 'is wound against the triangles before it in the input; the replay needs every input triangle wound one way' }];
+    }
+    sign = s;
+  }
+  const tris: Array<[number, number, number] | null> = [];
+  const owner = new Map<string, number>();
+  const dkey = (a: number, b: number): string => `${a},${b}`;
+  const link = (t: number): void => {
+    const r = tris[t] as [number, number, number];
+    owner.set(dkey(r[0], r[1]), t);
+    owner.set(dkey(r[1], r[2]), t);
+    owner.set(dkey(r[2], r[0]), t);
+  };
+  const unlink = (t: number): void => {
+    const r = tris[t];
+    if (r === null || r === undefined) return;
+    // a key the triangle no longer owns (a flip's partner took it first) is left to its owner.
+    for (const k of [dkey(r[0], r[1]), dkey(r[1], r[2]), dkey(r[2], r[0])]) if (owner.get(k) === t) owner.delete(k);
+  };
+  const setTri = (t: number, a: number, b: number, c: number): void => {
+    unlink(t);
+    tris[t] = [a, b, c];
+    link(t);
+  };
+  for (let t = 0; t < att.triangles.length; t += 3) {
+    const [a, b, c] = [att.triangles[t], att.triangles[t + 1], att.triangles[t + 2]];
+    if (sign > 0) setTri(t / 3, a, b, c);
+    else setTri(t / 3, a, c, b);
+  }
+  const freeSlots: number[] = [];
+  const newTri = (a: number, b: number, c: number): number => {
+    const t = freeSlots.length > 0 ? (freeSlots.shift() as number) : tris.length;
+    setTri(t, a, b, c);
+    return t;
+  };
+  const dropTri = (t: number): void => {
+    unlink(t);
+    tris[t] = null;
+    freeSlots.push(t);
+    freeSlots.sort((p, q) => p - q);
+  };
+  const third = (t: number, a: number, b: number): number => {
+    const r = tris[t] as [number, number, number];
+    return r.find((x) => x !== a && x !== b) as number;
+  };
+  const hull: number[] = Array.from({ length: att.hull }, (_, i) => i);
+  const constrained = new Set<string>();
+  const isEdge = (a: number, b: number): boolean => owner.has(dkey(a, b)) || owner.has(dkey(b, a));
+  const isHullEdge = (a: number, b: number): boolean => isEdge(a, b) && (!owner.has(dkey(a, b)) || !owner.has(dkey(b, a)));
+  const starOf = (v: number): number[] => tris.flatMap((r, t) => (r !== null && r.includes(v) ? [t] : []));
+  const violations = (): number => {
+    const n = (r: readonly number[]): Vec[] => r.map((id) => [X[id] / GRID, Y[id] / GRID] as Vec);
+    const ids = X.map((_, i) => i);
+    const flat = tris.flatMap((r) => (r === null ? [] : r));
+    return delaunayViolations(n(ids), flat, [...constrained].map((k) => k.split(':').map(Number) as [number, number]));
+  };
+  const before = violations();
+
+  /** Lawson flips from the queued edges: an interior, unconstrained edge whose far vertex lies inside the circle is flipped. */
+  const legalize = (queue: Array<[number, number]>): void => {
+    let guard = 0;
+    while (queue.length > 0) {
+      if (++guard > 1_000_000) throw new Error('remeshdelta: edge flips did not settle');
+      const [a, b] = queue.pop() as [number, number];
+      if (constrained.has(ekey(a, b))) continue;
+      const t = owner.get(dkey(a, b));
+      const u = owner.get(dkey(b, a));
+      if (t === undefined || u === undefined) continue;
+      const c = third(t, a, b);
+      const d = third(u, b, a);
+      if (inCircle(X[a], Y[a], X[b], Y[b], X[c], Y[c], X[d], Y[d]) <= 0n) continue;
+      if (!(orient(a, d, c) > 0 && orient(b, c, d) > 0)) continue;
+      setTri(t, a, d, c);
+      setTri(u, b, c, d);
+      queue.push([a, d], [d, b], [b, c], [c, a]);
+    }
+  };
+  const edgesOf = (ts: readonly number[]): Array<[number, number]> =>
+    ts.flatMap((t) => {
+      const r = tris[t];
+      return r === null || r === undefined ? [] : ([[r[0], r[1]], [r[1], r[2]], [r[2], r[0]]] as Array<[number, number]>);
+    });
+  const liveCount = (): number => live.filter((x) => x).length;
+  const crop = (id: number): Vec => [PX[id] + ox, PY[id] + oy];
+  const inImage = (x: number, y: number): boolean => x >= 0 && x <= w && y >= 0 && y <= h;
+  const mustLive = (id: number, what: string): void => {
+    if (id >= live.length) throw new OpRefused('REMESH_DELTA_OP', '', `names ${what} ${id}, which is out of range (ids 0..${live.length - 1} exist at this op)`);
+    if (!live[id]) throw new OpRefused('REMESH_DELTA_OP', '', `names ${what} ${id}, which an earlier op removed`);
+  };
+  const blend = (parts: ReadonlyArray<readonly [number, number]>): Influence[] => {
+    const by = new Map<string, number>();
+    for (const [id, f] of parts) for (const e of wt[id]) by.set(e.bone, (by.get(e.bone) ?? 0) + e.weight * f);
+    const sum = [...by.values()].reduce((s, x) => s + x, 0);
+    return roundShares([...by].map(([bone, weight]) => ({ bone, weight: weight / sum })));
+  };
+  const addVertex = (x: number, y: number, shares: Influence[]): number => {
+    const id = live.length;
+    setPos(id, x, y);
+    live.push(true);
+    uv.push([pyRound(x / w, 6), pyRound(y / h, 6)]);
+    wt.push(bind(shares, x, y));
+    added.add(id);
+    return id;
+  };
+  /** The split of edge a–b at (x, y): its one or two triangles become two or four. */
+  const splitEdge = (a: number, b: number, x: number, y: number): void => {
+    const t = owner.get(dkey(a, b));
+    const u = owner.get(dkey(b, a));
+    const dx = PX[b] - PX[a];
+    const dy = PY[b] - PY[a];
+    const s = Math.min(1, Math.max(0, ((x - PX[a]) * dx + (y - PY[a]) * dy) / (dx * dx + dy * dy)));
+    const sx = snap(x);
+    const sy = snap(y);
+    const sides: Array<[number, number, number]> = [];
+    if (t !== undefined) sides.push([a, b, third(t, a, b)]);
+    if (u !== undefined) sides.push([b, a, third(u, b, a)]);
+    for (const [p, q, c] of sides) {
+      // the new point must be strictly inside the triangles' union on each side: (p, new, c) and (new, q, c) wound > 0.
+      const o1 = (sx - X[p]) * (Y[c] - Y[p]) - (sy - Y[p]) * (X[c] - X[p]);
+      const o2 = (X[q] - sx) * (Y[c] - sy) - (Y[q] - sy) * (X[c] - sx);
+      if (!(o1 > 0 && o2 > 0)) throw new OpRefused('REMESH_DELTA_OP', '', `puts the vertex at crop (${pyRound(x + ox, 4)}, ${pyRound(y + oy, 4)}), outside the triangles on edge ${a}-${b} (it would fold triangle ${p}, ${q}, ${c})`);
+    }
+    const id = addVertex(x, y, blend([[a, 1 - s], [b, s]]));
+    const made: number[] = [];
+    if (t !== undefined) {
+      const c = third(t, a, b);
+      setTri(t, a, id, c);
+      made.push(t, newTri(id, b, c));
+    }
+    if (u !== undefined) {
+      const d = third(u, b, a);
+      setTri(u, b, id, d);
+      made.push(u, newTri(id, a, d));
+    }
+    if (t === undefined || u === undefined) {
+      const ia = hull.indexOf(a);
+      const ib = hull.indexOf(b);
+      const n = hull.length;
+      if (ia < 0 || ib < 0 || ((ia + 1) % n !== ib && (ib + 1) % n !== ia)) throw new Error(`remeshdelta: boundary edge ${a}-${b} is not consecutive on the hull loop`);
+      const first = (ia + 1) % n === ib ? ia : ib;
+      hull.splice(first + 1, 0, id);
+    }
+    legalize(edgesOf(made));
+  };
+
+  const ops = doc.ops;
+  let constrainedCount = 0;
+  for (let i = 0; i < ops.length; i++) {
+    const op = ops[i];
+    try {
+      if (op.op === 'move') {
+        mustLive(op.v, 'vertex');
+        const [fx, fy] = crop(op.v);
+        if (Math.abs(fx - op.from[0]) > FROM_TOLERANCE_PX || Math.abs(fy - op.from[1]) > FROM_TOLERANCE_PX) {
+          throw new OpRefused('REMESH_DELTA_OP', '', `moves vertex ${op.v} from (${op.from[0]}, ${op.from[1]}); its live position is (${pyRound(fx, 4)}, ${pyRound(fy, 4)}) — from does not match within ${FROM_TOLERANCE_PX} px, so the delta was made over another mesh`);
+        }
+        const x = op.to[0] - ox;
+        const y = op.to[1] - oy;
+        if (!inImage(x, y)) throw new OpRefused('REMESH_DELTA_OP', '', `moves vertex ${op.v} to crop (${op.to[0]}, ${op.to[1]}), outside the part's image (crop ${ox}..${ox + w} x ${oy}..${oy + h}); the texture has no sample there`);
+        const keep: Vec = [PX[op.v], PY[op.v]];
+        const keepG: Vec = [X[op.v], Y[op.v]];
+        setPos(op.v, x, y);
+        const star = starOf(op.v);
+        const folded = star.find((t) => {
+          const r = tris[t] as [number, number, number];
+          return orient(r[0], r[1], r[2]) <= 0;
+        });
+        if (folded !== undefined) {
+          PX[op.v] = keep[0];
+          PY[op.v] = keep[1];
+          X[op.v] = keepG[0];
+          Y[op.v] = keepG[1];
+          throw new OpRefused('REMESH_DELTA_OP', '', `moves vertex ${op.v} across an edge of its own ring: triangle ${(tris[folded] as number[]).join(', ')} would fold; move it in smaller steps, or remove and add it`);
+        }
+        uv[op.v] = [pyRound(x / w, 6), pyRound(y / h, 6)];
+        if (plant.skipBind !== true) wt[op.v] = bind(wt[op.v], x, y);
+        moved.add(op.v);
+        legalize(edgesOf(star));
+      } else if (op.op === 'add') {
+        const x = op.at[0] - ox;
+        const y = op.at[1] - oy;
+        if (!inImage(x, y)) throw new OpRefused('REMESH_DELTA_OP', '', `adds a vertex at crop (${op.at[0]}, ${op.at[1]}), outside the part's image (crop ${ox}..${ox + w} x ${oy}..${oy + h}); the texture has no sample there`);
+        const sx = snap(x);
+        const sy = snap(y);
+        if (op.onEdge !== undefined) {
+          const [a, b] = op.onEdge;
+          mustLive(a, 'vertex');
+          mustLive(b, 'vertex');
+          if (a === b) throw new OpRefused('REMESH_DELTA_OP', '', `splits edge ${a}-${b}, which joins a vertex to itself`);
+          if (!isEdge(a, b)) throw new OpRefused('REMESH_DELTA_OP', '', `splits a missing edge ${a}-${b}: the producer's triangulation has no such edge at this op`);
+          splitEdge(a, b, x, y);
+        } else {
+          let placedIn = false;
+          for (let t = 0; t < tris.length && !placedIn; t++) {
+            const r = tris[t];
+            if (r === null) continue;
+            const [a, b, c] = r;
+            const ob = (p: number, q: number): number => (X[q] - X[p]) * (sy - Y[p]) - (Y[q] - Y[p]) * (sx - X[p]);
+            const o1 = ob(a, b);
+            const o2 = ob(b, c);
+            const o3 = ob(c, a);
+            if (o1 < 0 || o2 < 0 || o3 < 0) continue;
+            const zeros = [o1, o2, o3].filter((z) => z === 0).length;
+            if (zeros >= 2) {
+              const at = [a, b, c].find((id) => X[id] === sx && Y[id] === sy);
+              throw new OpRefused('REMESH_DELTA_OP', '', `adds a vertex at crop (${op.at[0]}, ${op.at[1]}), on vertex ${at ?? a}; distinct positions are required`);
+            }
+            placedIn = true;
+            if (zeros === 1) {
+              const [p, q] = o1 === 0 ? [a, b] : o2 === 0 ? [b, c] : [c, a];
+              splitEdge(p, q, x, y);
+              break;
+            }
+            const area = orient(a, b, c);
+            const id = addVertex(x, y, blend([[a, o2 / area], [b, o3 / area], [c, o1 / area]]));
+            setTri(t, a, b, id);
+            const t2 = newTri(b, c, id);
+            const t3 = newTri(c, a, id);
+            legalize(edgesOf([t, t2, t3]));
+          }
+          if (!placedIn) throw new OpRefused('REMESH_DELTA_OP', '', `adds a free vertex at crop (${op.at[0]}, ${op.at[1]}), outside every triangle of the mesh; a vertex outside the mesh is added on a hull edge (onEdge)`);
+        }
+      } else if (op.op === 'remove') {
+        const v = op.v;
+        mustLive(v, 'vertex');
+        const held = [...constrained].find((k) => k.split(':').map(Number).includes(v));
+        if (held !== undefined) throw new OpRefused('REMESH_DELTA_OP', '', `removes vertex ${v}, an end of constraint edge ${held.replace(':', '-')}; unedge it first`);
+        const onHull = hull.includes(v);
+        if (liveCount() - 1 < 3 || (onHull && hull.length - 1 < 3)) throw new OpRefused('REMESH_DELTA_OP', '', `removes vertex ${v}, which would leave ${onHull && hull.length - 1 < 3 ? `a hull of ${hull.length - 1}` : `${liveCount() - 1} vertices`}; at least 3 are required`);
+        const star = starOf(v);
+        const next = new Map<number, number>();
+        for (const t of star) {
+          const r = tris[t] as [number, number, number];
+          const k = r.indexOf(v);
+          next.set(r[(k + 1) % 3], r[(k + 2) % 3]);
+        }
+        const ys = new Set(next.values());
+        const starts = [...next.keys()].filter((x) => !ys.has(x));
+        const start = onHull ? starts[0] : (tris[star[0]] as number[])[((tris[star[0]] as number[]).indexOf(v) + 1) % 3];
+        if (start === undefined || (onHull && starts.length !== 1) || (!onHull && starts.length !== 0)) throw new OpRefused('REMESH_DELTA_OP', '', `removes vertex ${v}, whose ring is not one ${onHull ? 'open' : 'closed'} fan`);
+        const ring: number[] = [start];
+        for (let cur = start; next.has(cur); ) {
+          cur = next.get(cur) as number;
+          if (cur === start) break;
+          ring.push(cur);
+          if (ring.length > star.length + 1) throw new Error(`remeshdelta: the ring of vertex ${v} does not close`);
+        }
+        if (onHull) {
+          const n = hull.length;
+          const k = hull.indexOf(v);
+          if (ring[0] !== hull[(k + 1) % n] || ring[ring.length - 1] !== hull[(k - 1 + n) % n]) throw new OpRefused('REMESH_DELTA_OP', '', `removes hull vertex ${v}, whose fan does not run from one hull neighbour to the other`);
+        }
+        // ear clipping, exact: the polygon is wound > 0; the first ear in ring order is cut each time.
+        const poly = [...ring];
+        const made: Array<[number, number, number]> = [];
+        while (poly.length > 3) {
+          let cut = -1;
+          for (let j = 0; j < poly.length && cut < 0; j++) {
+            const p = poly[(j - 1 + poly.length) % poly.length];
+            const c = poly[j];
+            const q = poly[(j + 1) % poly.length];
+            if (orient(p, c, q) <= 0) continue;
+            const blocked = poly.some((r) => r !== p && r !== c && r !== q && orient(p, c, r) >= 0 && orient(c, q, r) >= 0 && orient(q, p, r) >= 0);
+            if (!blocked) cut = j;
+          }
+          if (cut < 0) throw new OpRefused('REMESH_DELTA_OP', '', `removes vertex ${v}, whose ring (${poly.join(', ')}) has no ear to clip: it cannot be triangulated without the vertex`);
+          made.push([poly[(cut - 1 + poly.length) % poly.length], poly[cut], poly[(cut + 1) % poly.length]]);
+          poly.splice(cut, 1);
+        }
+        if (poly.length === 3) {
+          if (orient(poly[0], poly[1], poly[2]) <= 0) throw new OpRefused('REMESH_DELTA_OP', '', `removes vertex ${v}, whose ring closes on a flat triangle (${poly.join(', ')})`);
+          made.push([poly[0], poly[1], poly[2]]);
+        }
+        for (const t of star) dropTri(t);
+        live[v] = false;
+        removed.add(v);
+        moved.delete(v);
+        if (onHull) hull.splice(hull.indexOf(v), 1);
+        const ts = made.map(([a, b, c]) => newTri(a, b, c));
+        legalize(edgesOf(ts));
+      } else if (op.op === 'edge') {
+        const { a, b } = op;
+        mustLive(a, 'vertex');
+        mustLive(b, 'vertex');
+        const key = ekey(a, b);
+        if (constrained.has(key)) throw new OpRefused('REMESH_DELTA_OP', '', `duplicates constraint edge ${a}-${b}`);
+        if (isHullEdge(a, b)) throw new OpRefused('REMESH_DELTA_OP', '', `constrains hull edge ${a}-${b}, which no flip ever removes`);
+        if (!isEdge(a, b)) {
+          const on = live.findIndex((l, k) => l && k !== a && k !== b && orient(a, b, k) === 0 && (X[k] - X[a]) * (X[b] - X[k]) + (Y[k] - Y[a]) * (Y[b] - Y[k]) > 0);
+          if (on >= 0) throw new OpRefused('REMESH_DELTA_OP', '', `constrains ${a}-${b}, whose segment runs through vertex ${on}; constrain ${a}-${on} and ${on}-${b}`);
+          const changed = new Set<number>();
+          let guard = 0;
+          for (;;) {
+            if (isEdge(a, b)) break;
+            if (++guard > 4 * tris.length + 16) throw new OpRefused('REMESH_DELTA_OP', '', `constrains ${a}-${b}, which edge flips could not recover`);
+            let crossing: { t: number; u: number; p: number; q: number } | null = null;
+            let flipped = false;
+            for (let t = 0; t < tris.length && !flipped; t++) {
+              const r = tris[t];
+              if (r === null) continue;
+              for (let k = 0; k < 3 && !flipped; k++) {
+                const p = r[k];
+                const q = r[(k + 1) % 3];
+                if (p === a || p === b || q === a || q === b) continue;
+                if (!(Math.sign(orient(a, b, p)) * Math.sign(orient(a, b, q)) < 0 && Math.sign(orient(p, q, a)) * Math.sign(orient(p, q, b)) < 0)) continue;
+                const u = owner.get(dkey(q, p));
+                if (u === undefined) throw new OpRefused('REMESH_DELTA_OP', '', `constrains ${a}-${b}, whose segment crosses hull edge ${p}-${q}: it would leave the mesh`);
+                if (constrained.has(ekey(p, q))) throw new OpRefused('REMESH_DELTA_OP', '', `constrains ${a}-${b}, whose segment crosses constraint edge ${p}-${q}`);
+                crossing ??= { t, u, p, q };
+                const c = third(t, p, q);
+                const d = third(u, q, p);
+                if (!(orient(p, d, c) > 0 && orient(q, c, d) > 0)) continue;
+                setTri(t, p, d, c);
+                setTri(u, q, c, d);
+                changed.add(t).add(u);
+                flipped = true;
+              }
+            }
+            if (!flipped) throw new OpRefused('REMESH_DELTA_OP', '', crossing === null ? `constrains ${a}-${b}, whose segment crosses no edge and is no edge: it runs outside the mesh` : `constrains ${a}-${b}: no edge it crosses can be flipped`);
+          }
+          constrained.add(key);
+          legalize(edgesOf([...changed]));
+        } else constrained.add(key);
+        constrainedCount++;
+      } else {
+        const { a, b } = op;
+        mustLive(a, 'vertex');
+        mustLive(b, 'vertex');
+        if (isHullEdge(a, b)) throw new OpRefused('REMESH_DELTA_OP', '', `unedges hull edge ${a}-${b}; the hull is the mesh's outline and is never removed`);
+        if (!constrained.has(ekey(a, b))) throw new OpRefused('REMESH_DELTA_OP', '', `unedges ${a}-${b}: unedge names an edge this delta did not constrain; the producer owns the triangulation`);
+        constrained.delete(ekey(a, b));
+        constrainedCount--;
+        legalize([[a, b]]);
+      }
+    } catch (err) {
+      if (!(err instanceof OpRefused)) throw err;
+      return [{ code: err.code, object: err.at === '' ? `${object} ops[${i}]` : err.at, detail: `${JSON.stringify(op)} ${err.why}` }];
+    }
+  }
+
+  // The output: the hull loop first, in order, then every other live vertex in id order.
+  const ids = X.map((_, i) => i).filter((i) => live[i]);
+  const order = plant.skipHullOrder === true ? ids : [...hull, ...ids.filter((i) => !hull.includes(i))];
+  const at = new Map(order.map((id, k) => [id, k]));
+  const triangles: number[] = [];
+  for (const r of tris) {
+    if (r === null) continue;
+    const [a, b, c] = r.map((id) => at.get(id) as number);
+    if (sign > 0) triangles.push(a, b, c);
+    else triangles.push(a, c, b);
+  }
+  const attachment: MeshAttachment = {
+    type: 'mesh',
+    image: att.image,
+    width: w,
+    height: h,
+    uvs: order.flatMap((id) => uv[id]),
+    triangles,
+    hull: hull.length,
+    weights: order.map((id) => wt[id]),
+  };
+  const after = violations();
+  if (plant.skipTopology !== true) {
+    const verts = order.map((id) => [X[id] / GRID, Y[id] / GRID] as Vec);
+    const topo = contourTopologyProblems(input.part, verts, triangles, hull.length);
+    const out: Problem[] = topo.map((p) => ({ code: 'REMESH_DELTA_TOPOLOGY', object: `the replayed ${input.part}`, detail: `${p.code}: ${p.detail}; the result is measured, not trusted, and nothing is written` }));
+    if (after > before) out.push({ code: 'REMESH_DELTA_TOPOLOGY', object: `the replayed ${input.part}`, detail: `has ${after} interior edge(s) not locally Delaunay (constraint edges not asked) where the input has ${before}; the replay may not add one, and nothing is written` });
+    if (out.length > 0) return out;
+  }
+  const untouched = X.map((_, i) => i).filter((i) => i < V0 && live[i] && !moved.has(i));
+  for (const id of untouched) {
+    if (JSON.stringify(uv[id]) !== JSON.stringify([att.uvs[2 * id], att.uvs[2 * id + 1]]) || JSON.stringify(wt[id]) !== JSON.stringify(att.weights[id])) throw new Error(`remeshdelta: untouched vertex ${id} changed`);
+  }
+  return {
+    attachment,
+    counts: { vertices: order.length, triangles: triangles.length / 3, hull: hull.length },
+    applied: { ops: ops.length, moved: moved.size, added: added.size, removed: removed.size, constrained: constrainedCount },
+    untouched,
+    delaunay: { before, after },
+    index: ids.map((id) => [id, at.get(id) as number]),
+  };
+}