rig-c 2.32.0 → 2.32.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rig-c",
-  "version": "2.32.0",
+  "version": "2.32.2",
   "description": "AI-authored Spine 2D rigging and animation, verified before it is written. rigc compiles a rig spec into Spine 4.3 skeleton data, gates it with named assertions held to a spine-core round trip's verdicts, and emits nothing that fails. Output imports into the Spine editor. Ships as an agent skill.",
   "type": "module",
   "bin": {

package/src/meshcarriers.ts

@@ -30,12 +30,27 @@ export interface Carrier {
   bary: [number, number, number];
 }
 
+/**
+ * Issue #1323's faults in resolving several carriers, for the `mesh-compare` suite's controls: the rule before the
+ * issue (the per-coordinate support alone, `slackSupport` never read); the slack read as the narrowest triangle's
+ * rather than the widest's; and any shared vertex excused whatever the distance, so two triangles that both hold a
+ * sample well inside — an overlap — carry it by the first.
+ */
+export type CarrierPlant = 'slack-support-unread' | 'narrowest-slack' | 'any-shared-vertex';
+
 /**
  * Each sample's carrier in one mesh's UV triangulation — §3 and correction 4.
  * Throws `COMPARE_UV_CARRIER_NOT_UNIQUE` for a sample two triangles carry
- * other than across a vertex or edge they share.
+ * other than across a vertex or edge they share — where "across" is read, since
+ * issue #1323, to the distance the containment slack itself allows
+ * (`slackSupport`).
  */
 export function uvCarriers(uvs: readonly number[], triangles: readonly number[], samples: ReadonlyArray<{ uv: [number, number] }>, who: string): Array<Carrier | null> {
+  return uvCarriersWith(uvs, triangles, samples, who, null);
+}
+
+/** `uvCarriers` with a fault planted in resolving several carriers (`CarrierPlant`). Internal: on no entry. */
+export function uvCarriersWith(uvs: readonly number[], triangles: readonly number[], samples: ReadonlyArray<{ uv: [number, number] }>, who: string, plant: CarrierPlant | null): Array<Carrier | null> {
   const areas = triangleAreas(uvs, triangles);
   const band = areaBand(areas, uvs);
   const live: number[] = [];
@@ -101,7 +116,8 @@ export function uvCarriers(uvs: readonly number[], triangles: readonly number[],
       }
     });
   }
-  return samples.map((s, j) => resolveCarriers(s.uv[0], s.uv[1], hits[j] ?? [], who));
+  const uvOf = (v: number): readonly [number, number] => [uvs[v * 2], uvs[v * 2 + 1]];
+  return samples.map((s, j) => resolveCarriers(s.uv[0], s.uv[1], hits[j] ?? [], who, uvOf, plant));
 }
 
 /**
@@ -143,21 +159,32 @@ export function carrierIn(
 
 /**
  * The carrier of a sample from every triangle that contains it: none, the one, or — several — the first when they all
- * meet there at a shared vertex or edge; else `COMPARE_UV_CARRIER_NOT_UNIQUE` (correction 4).
+ * meet there at a shared vertex or edge; else `COMPARE_UV_CARRIER_NOT_UNIQUE` (correction 4). Where the per-coordinate
+ * support refuses, the support is read again to the slack's distance (issue #1323, {@link slackSupport}) when the
+ * corners' UVs are given (`uvOf`).
  */
-export function resolveCarriers(px: number, py: number, hits: readonly Carrier[], who: string): Carrier | null {
+export function resolveCarriers(
+  px: number,
+  py: number,
+  hits: readonly Carrier[],
+  who: string,
+  uvOf: ((v: number) => readonly [number, number]) | null = null,
+  plant: CarrierPlant | null = null,
+): Carrier | null {
   if (hits.length === 0) return null;
   if (hits.length === 1) return hits[0];
   // Several carriers are one hit only across a vertex or an edge they all share: the sample's support — the corners
   // it does not sit at zero weight on — is then the same vertex indices in each, and the carried point is theirs.
-  const support = (c: Carrier): string =>
+  const shared = (supportOf: (c: Carrier) => string): boolean => {
+    const first = supportOf(hits[0]);
+    return first.split(',').length <= 2 && hits.every((c) => supportOf(c) === first);
+  };
+  const byCoordinate = (c: Carrier): string =>
     c.corners
       .filter((_v, k) => c.bary[k] > CONTAINS)
       .sort((a, b) => a - b)
       .join(',');
-  const first = support(hits[0]);
-  const shared = first.split(',').length <= 2 && hits.every((c) => support(c) === first);
-  if (!shared) {
+  if (!shared(byCoordinate) && (uvOf === null || plant === 'slack-support-unread' || !shared(slackSupport(hits, uvOf, plant)))) {
     refuse(
       'COMPARE_UV_CARRIER_NOT_UNIQUE',
       `${who}: the sample at uv (${px}, ${py}) lies in ${hits.length} UV triangles — ${hits.map((c) => `triangle ${c.triangle} (vertices ${c.corners.join(', ')})`).join(' and ')} — that do not meet there at a shared vertex or edge; required one carrier per sample (correction 4: overlapping or folded UV triangles would carry it by an arbitrary one)`,
@@ -165,3 +192,48 @@ export function resolveCarriers(px: number, py: number, hits: readonly Carrier[]
   }
   return hits[0];
 }
+
+/**
+ * Issue #1323: a carrier's support read to the slack's distance rather than per coordinate — the corners the sample
+ * lies further than `CONTAINS × H` (UV units) inside of, measured from each corner's opposite edge, with `H` the widest
+ * triangle height among the hits: the furthest outside a triangle the containment test (`carrierIn`) admitted any of
+ * them at this sample.
+ *
+ * Why: the slack is per barycentric coordinate, so in distance it is `CONTAINS` times the height of the corner it is
+ * read against. A sample on a shared edge, a hair to one side — a pixel centre on a 45° or axis-parallel edge between
+ * whole-pixel vertices, put off it by the UVs' rounding — is admitted by the triangle it is outside of, while the
+ * triangle it is inside of, if it is a sliver, reads its third corner's coordinate above `CONTAINS` because its height
+ * is small: two per-coordinate supports, read as an overlap though the sample is within the slack of the edge both
+ * share. Measured on demo/bottomwear's reduction at source spacing 18: 1.35e-10 uv from the edge, coordinates −3.2e-10
+ * and +6.5e-8, heights 0.42 and 0.0021. Read in distance, both corners are within the slack and the support is the
+ * shared edge. A sample two triangles both hold further inside than that — an overlap or a fold — is still refused.
+ */
+function slackSupport(hits: readonly Carrier[], uvOf: (v: number) => readonly [number, number], plant: CarrierPlant | null): (c: Carrier) => string {
+  if (plant === 'any-shared-vertex') {
+    const common = hits[0].corners.filter((v) => hits.every((c) => c.corners.includes(v)));
+    return () => (common.length > 0 ? [...common].sort((a, b) => a - b).slice(0, 1).join(',') : 'none');
+  }
+  const heights = new Map<Carrier, [number, number, number]>();
+  let widest = 0;
+  let narrowest = Infinity;
+  for (const c of hits) {
+    const p = c.corners.map(uvOf);
+    const twice = Math.abs((p[1][0] - p[0][0]) * (p[2][1] - p[0][1]) - (p[2][0] - p[0][0]) * (p[1][1] - p[0][1]));
+    const h = [0, 1, 2].map((k) => {
+      const a = p[(k + 1) % 3];
+      const b = p[(k + 2) % 3];
+      return twice / Math.hypot(b[0] - a[0], b[1] - a[1]);
+    }) as [number, number, number];
+    heights.set(c, h);
+    widest = Math.max(widest, ...h);
+    narrowest = Math.min(narrowest, ...h);
+  }
+  const slack = CONTAINS * (plant === 'narrowest-slack' ? narrowest : widest);
+  return (c: Carrier): string => {
+    const h = heights.get(c)!;
+    return c.corners
+      .filter((_v, k) => c.bary[k] * h[k] > slack)
+      .sort((a, b) => a - b)
+      .join(',');
+  };
+}

package/src/meshcompare.ts

@@ -104,7 +104,7 @@ import {
   type WorstSample,
 } from './meshquality.ts';
 import { areaBand, stretchSingularValues, triangleAreas } from './areaband.ts';
-import { uvCarriers, type Carrier } from './meshcarriers.ts';
+import { uvCarriers, uvCarriersWith, type Carrier, type CarrierPlant } from './meshcarriers.ts';
 import { CoreInputError, readModel, underNoSkin, underSkin, type CompiledDocument } from './core/index.ts';
 import { poseRawAnimationEach, poseRawSetup, type RawPose } from './core/raw.ts';
 import { sampleTime } from './core/animation.ts';
@@ -186,7 +186,9 @@ export interface MotionComparisonInput {
  * Issue #1291's faults in carrying `motionAmplitude` into the setup measurement, for the `mesh-compare` suite's
  * negative controls: the amplitude not handed over; `null` handed over as the field left out; the field not validated
  * before the builds are read; `null` echoed for a field left out; and the load counted as a required row, so the
- * amplitude moves a verdict. `compareMeshesInMotion` plants none.
+ * amplitude moves a verdict. `compareMeshesInMotion` plants none. Issue #1323 adds `CarrierPlant`
+ * (`src/meshcarriers.ts`): a fault in resolving a sample's several carriers, planted in every `uvCarriers` the
+ * comparison reads.
  */
 export type ComparePlant =
   | 'amplitude-not-carried'
@@ -194,7 +196,8 @@ export type ComparePlant =
   | 'amplitude-unvalidated'
   | 'echo-when-unset'
   | 'amplitude-gates-acceptance'
-  | OverBoundPlant;
+  | OverBoundPlant
+  | CarrierPlant;
 
 /**
  * Issue #1315's faults in `overBound`, for the `mesh-compare` suite's negative controls: a listed sample's triangle
@@ -995,11 +998,14 @@ function compareMeshesInMotionWith(input: MotionComparisonInput, plant: CompareP
       }
       return { samples: out, art };
     });
-    const refCarriers = order.map((i, k) => uvCarriers(reference.meshes[i].uvs, reference.meshes[i].triangles, samplesOf[k].samples, `reference "${reference.id}", attachment ${nameOf(refs[i])}`));
+    const carrierPlant: CarrierPlant | null = plant === 'slack-support-unread' || plant === 'narrowest-slack' || plant === 'any-shared-vertex' ? plant : null;
+    const carriersOf = (uvs: readonly number[], triangles: readonly number[], samples: ReadonlyArray<{ uv: [number, number] }>, who: string): Array<Carrier | null> =>
+      uvCarriersWith(uvs, triangles, samples, who, carrierPlant);
+    const refCarriers = order.map((i, k) => carriersOf(reference.meshes[i].uvs, reference.meshes[i].triangles, samplesOf[k].samples, `reference "${reference.id}", attachment ${nameOf(refs[i])}`));
     const posedRef = poseBuild(reference.doc, order.map((i) => refs[i]), frames, walks);
 
     motionOf = (b: Build, isReference: boolean) => {
-      const carriers = isReference ? refCarriers : order.map((i, k) => uvCarriers(b.meshes[i].uvs, b.meshes[i].triangles, samplesOf[k].samples, `candidate "${b.id}", attachment ${nameOf(refs[i])}`));
+      const carriers = isReference ? refCarriers : order.map((i, k) => carriersOf(b.meshes[i].uvs, b.meshes[i].triangles, samplesOf[k].samples, `candidate "${b.id}", attachment ${nameOf(refs[i])}`));
       const posed = isReference ? posedRef : poseBuild(b.doc, order.map((i) => refs[i]), frames, walks);
       const built: Built[] = [];
       const perFrame: NonNullable<CandidateReport['perFrame']> = [];

package/src/meshreduce.ts

@@ -160,6 +160,8 @@ import {
   type Termination,
 } from './meshquality.ts';
 import { artRastersOf, stepRastersOf, type ArtRasters, type StepRasters } from './meshrasters.ts';
+import { areaBand, triangleAreas } from './areaband.ts';
+import { cropToSpineY } from './transform.ts';
 import {
   skinningContract,
   SkinningCarry,
@@ -1262,43 +1264,154 @@ function addVertex(run: Run, p: Pt): number {
   return id;
 }
 
+/**
+ * The two triangles a split of the edge a–b at the new vertex `m` makes of `tri`, winding kept, or null when `tri`
+ * does not have that edge — the one rule `splitEdge` writes and `degenerateInsertion` reads (issue #1311).
+ */
+function splitPieces(tri: readonly [number, number, number], a: number, b: number, m: number): [[number, number, number], [number, number, number]] | null {
+  const i = tri.indexOf(a);
+  const j = tri.indexOf(b);
+  if (i === -1 || j === -1) return null;
+  // Rotate so the edge is the triangle's first two corners, in its own winding.
+  const r = (j - i + 3) % 3 === 1 ? i : j;
+  const x = tri[r];
+  const y = tri[(r + 1) % 3];
+  const c = tri[(r + 2) % 3];
+  return [[x, m, c], [m, y, c]];
+}
+
 /** Split the edge between working ids a and b at `p`: each triangle on it becomes two, winding kept. */
 function splitEdge(run: Run, a: number, b: number, p: Pt): void {
   const m = addVertex(run, p);
   const next: Array<[number, number, number]> = [];
   for (const tri of run.work.triangles) {
-    const i = tri.indexOf(a);
-    const j = tri.indexOf(b);
-    if (i === -1 || j === -1) {
-      next.push(tri);
-      continue;
-    }
-    // Rotate so the edge is the triangle's first two corners, in its own winding.
-    const r = (j - i + 3) % 3 === 1 ? i : j;
-    const x = tri[r];
-    const y = tri[(r + 1) % 3];
-    const c = tri[(r + 2) % 3];
-    next.push([x, m, c], [m, y, c]);
+    const pieces = splitPieces(tri, a, b, m);
+    if (pieces === null) next.push(tri);
+    else next.push(...pieces);
   }
   run.work.triangles = next;
 }
 
-/** Insert `p` into the working triangle that holds it: on an edge, that edge is split; inside, the triangle becomes three. */
-function insertPoint(run: Run, p: Pt): boolean {
+/** Where `insertPoint` puts `p`: on an edge of the working triangle that holds it, inside that triangle, or nowhere. */
+type Placement = { kind: 'edge'; a: number; b: number } | { kind: 'inside'; tri: [number, number, number] } | null;
+
+function placementOf(run: Run, p: Pt): Placement {
   const { work } = run;
   for (const tri of work.triangles) {
     const l = barycentric(p, work.pos[tri[0]], work.pos[tri[1]], work.pos[tri[2]]);
     if (l === null || Math.min(...l) < -1e-9) continue;
     const onEdge = l.findIndex((v) => Math.abs(v) <= 1e-9);
-    if (onEdge !== -1) {
-      splitEdge(run, tri[(onEdge + 1) % 3], tri[(onEdge + 2) % 3], p);
-      return true;
-    }
-    const m = addVertex(run, p);
-    work.triangles = work.triangles.flatMap((t): Array<[number, number, number]> => (t === tri ? [[tri[0], tri[1], m], [tri[1], tri[2], m], [tri[2], tri[0], m]] : [t]));
-    return true;
+    if (onEdge !== -1) return { kind: 'edge', a: tri[(onEdge + 1) % 3], b: tri[(onEdge + 2) % 3] };
+    return { kind: 'inside', tri };
   }
-  return false;
+  return null;
+}
+
+/** The three triangles an insertion of the new vertex `m` inside `tri` makes of it — `insertPoint`'s rule. */
+function fanPieces(tri: readonly [number, number, number], m: number): Array<[number, number, number]> {
+  return [[tri[0], tri[1], m], [tri[1], tri[2], m], [tri[2], tri[0], m]];
+}
+
+/** Insert `p` where `placementOf` put it: on an edge, that edge is split; inside, the triangle becomes three. */
+function insertPoint(run: Run, p: Pt, at: Exclude<Placement, null>): void {
+  const { work } = run;
+  if (at.kind === 'edge') {
+    splitEdge(run, at.a, at.b, p);
+    return;
+  }
+  const m = addVertex(run, p);
+  work.triangles = work.triangles.flatMap((t): Array<[number, number, number]> => (t === at.tri ? fanPieces(at.tri, m) : [t]));
+}
+
+/** The vertex id the degenerate check reads for the vertex an insertion would add, before it exists. */
+const NEW_VERTEX = -1;
+
+/** A triangle an insertion would write that `MQ_DEGENERATE` reads as degenerate (issue #1311). */
+interface DegenerateWrite {
+  /** Working ids, `NEW_VERTEX` for the inserted one, in the triangle's own winding. */
+  corners: [number, number, number];
+  /** The smallest magnitude of its area over the three corners it can be read from, px². */
+  area: number;
+  /** `areaBand` of the mesh the insertion would leave, px². */
+  band: number;
+}
+
+/**
+ * Issue #1311: the first triangle an insertion of `p` would write whose area `MQ_DEGENERATE` reads as degenerate, or
+ * null. Read as the row reads it, over the mesh the insertion would leave: every point in the art frame's world (y up,
+ * `cropToSpineY` on the frame's height), every triangle's area by `triangleAreas`, and the band by `areaBand` over all of
+ * them — the larger of 1e-6 of the largest triangle and the float32 noise bound of the coordinates. The row reads a
+ * triangle from its smallest canonical index, which is not known before the mesh is canonicalised, so a fresh triangle
+ * is read from each of its three corners and the smallest magnitude is the one compared: a triangle that any reading
+ * puts within the band is refused. `fresh` uses `NEW_VERTEX` for the inserted vertex; `replaced` are the triangles it
+ * takes the place of.
+ */
+function degenerateInsertion(run: Run, p: Pt, replaced: ReadonlySet<readonly number[]>, fresh: ReadonlyArray<[number, number, number]>): DegenerateWrite | null {
+  const { work } = run;
+  const height = run.input.art.frame.height;
+  const slot = new Map<number, number>();
+  const world: number[] = [];
+  for (let id = 0; id < work.pos.length; id++) {
+    if (!work.alive[id]) continue;
+    slot.set(id, world.length / 2);
+    world.push(work.pos[id][0], cropToSpineY(work.pos[id][1], height));
+  }
+  slot.set(NEW_VERTEX, world.length / 2);
+  world.push(p[0], cropToSpineY(p[1], height));
+  const flat: number[] = [];
+  for (const tri of work.triangles) if (!replaced.has(tri)) for (const id of tri) flat.push(slot.get(id)!);
+  for (const tri of fresh) for (const id of tri) flat.push(slot.get(id)!);
+  const band = areaBand(triangleAreas(world, flat), world) * (run.plant === 'degenerate-band-widened' ? 1000 : 1);
+  for (const tri of fresh) {
+    const [i, j, k] = tri.map((id) => slot.get(id)!);
+    const area = Math.min(...triangleAreas(world, [i, j, k, j, k, i, k, i, j]).map(Math.abs));
+    if (area <= band) return { corners: tri, area, band };
+  }
+  return null;
+}
+
+/**
+ * Issue #1311: the refinement's stop when the insertion its rule chose would write a triangle `MQ_DEGENERATE` refuses —
+ * by name: the target row, the region, the insertion, the triangle's corners with their distance from the region's
+ * polygon, its area and the band required. The refinement writes no triangle the row refuses: a refined source that
+ * failed that row could take no step at all, and the failure would name a triangle rather than the insertion that made
+ * it.
+ */
+function degenerateStop(run: Run, canon: Canonical, target: MeasureRow, region: RefinementRegion, what: string, p: Pt, found: DegenerateWrite): PhaseEnd {
+  const corner = (id: number): string => {
+    const at = id === NEW_VERTEX ? p : run.work.pos[id];
+    const name = id === NEW_VERTEX ? 'the inserted vertex' : `vertex ${canon.indexOf.get(id)!}`;
+    const where = inClosedPolygon(at, region.polygon) ? 'in the polygon' : `${r6(distanceToBoundary(at, region.polygon))} px from the polygon`;
+    return `${name} (${at[0]}, ${at[1]}), ${where}`;
+  };
+  return {
+    kind: 'stuck',
+    constraint:
+      `${rowName(target)} (${what} at (${p[0]}, ${p[1]}) would write the triangle of ${found.corners.map(corner).join('; ')} — ` +
+      `area ${r6(found.area)} px², which MQ_DEGENERATE reads as degenerate: required an area above the row's band ${r6(found.band)} px² ` +
+      `(the larger of the float32 noise bound of the mesh's coordinates and 1e-6 of its largest triangle); ` +
+      `region "${region.name}" has a ${region.transition} px band, and the refinement writes no triangle the row refuses)`,
+  };
+}
+
+/** The triangles a split of a–b replaces, and what it writes in their place with `NEW_VERTEX` inserted. */
+function splitPlan(run: Run, a: number, b: number): { replaced: Set<readonly number[]>; fresh: Array<[number, number, number]> } {
+  const replaced = new Set<readonly number[]>();
+  const fresh: Array<[number, number, number]> = [];
+  for (const tri of run.work.triangles) {
+    const pieces = splitPieces(tri, a, b, NEW_VERTEX);
+    if (pieces === null) continue;
+    replaced.add(tri);
+    fresh.push(...pieces);
+  }
+  return { replaced, fresh };
+}
+
+/** Issue #1311: what a split of a–b at `p` would write that the row refuses, or null — always null under the control's plant. */
+function degenerateSplit(run: Run, a: number, b: number, p: Pt): DegenerateWrite | null {
+  if (run.plant === 'refinement-writes-degenerate') return null;
+  const { replaced, fresh } = splitPlan(run, a, b);
+  return degenerateInsertion(run, p, replaced, fresh);
 }
 
 type PhaseEnd =
@@ -1346,7 +1459,15 @@ export type ReductionPlant =
   | 'floor-half-a-pixel-short'
   | RetriangulationPlant
   | OrderPlant
-  | AmplitudePlant;
+  | AmplitudePlant
+  | RefinementPlant;
+
+/**
+ * Issue #1311's faults in the refinement: the insertion its rule chose written without asking whether it writes a
+ * triangle `MQ_DEGENERATE` refuses — the refinement as it was before the check; and the check reading the row's band
+ * a thousand times as wide, so it refuses insertions the row would pass.
+ */
+export type RefinementPlant = 'refinement-writes-degenerate' | 'degenerate-band-widened';
 
 /**
  * Issue #1283's faults in the triangulation post-pass: the pass run on a call that did not opt in; the pass skipped
@@ -1400,7 +1521,9 @@ export type AttemptObserver = (attempt: AttemptRecord) => void;
  * `MQ_TRANSITION` that the refinement can act on passes. One insertion per
  * measurement: the first failing region row in report order has its worst edge
  * split. A band no edge lies in leaves `MQ_TRANSITION` not-measurable (B1's
- * definition) and is not something an insertion is aimed at.
+ * definition) and is not something an insertion is aimed at. An insertion that
+ * would write a triangle `MQ_DEGENERATE` refuses is not made: the refinement
+ * stops there by name (issue #1311, `degenerateStop`).
  */
 function refineRegions(run: Run): PhaseEnd {
   const regions = new Map(run.input.targets.regions.map((r) => [r.name, r]));
@@ -1416,7 +1539,16 @@ function refineRegions(run: Run): PhaseEnd {
     const region = regions.get(target.object.region!)!;
     if (target.state === 'not-measurable') {
       const p: Pt = [r6(region.polygon[0][0]), r6(region.polygon[0][1])];
-      if (!insertPoint(run, p)) return { kind: 'stuck', constraint: `${rowName(target)} (the refinement found no triangle holding the region's first vertex)` };
+      const at = placementOf(run, p);
+      if (at === null) return { kind: 'stuck', constraint: `${rowName(target)} (the refinement found no triangle holding the region's first vertex)` };
+      const found =
+        run.plant === 'refinement-writes-degenerate'
+          ? null
+          : at.kind === 'edge'
+            ? degenerateSplit(run, at.a, at.b, p)
+            : degenerateInsertion(run, p, new Set([at.tri]), fanPieces(at.tri, NEW_VERTEX));
+      if (found !== null) return degenerateStop(run, canon, target, region, `inserting region "${region.name}"'s first vertex`, p, found);
+      insertPoint(run, p, at);
       followSkinning(run, 'insertion');
       if (accept(run, 'insertion', [])) return { kind: 'replayed' };
       continue;
@@ -1432,6 +1564,8 @@ function refineRegions(run: Run): PhaseEnd {
       if (inRegionOrBand(run.work.pos[outer], region)) continue;
       const q = outerSplit(run.work.pos[inner], run.work.pos[outer], region);
       if (q === null) continue;
+      const found = degenerateSplit(run, a, b, q);
+      if (found !== null) return degenerateStop(run, canon, target, region, `splitting edge ${ra}–${rb} where it leaves region "${region.name}"'s band`, q, found);
       splitEdge(run, a, b, q);
       followSkinning(run, 'insertion');
       exited = true;
@@ -1462,6 +1596,8 @@ function refineRegions(run: Run): PhaseEnd {
     }
     const p = splitPoint(run.work.pos[a], run.work.pos[b], region);
     if (p === null) return { kind: 'stuck', constraint: `${rowName(target)} (the refinement found no point of edge ${ra}–${rb} strictly between its ends inside region "${region.name}" or its band)` };
+    const found = degenerateSplit(run, a, b, p);
+    if (found !== null) return degenerateStop(run, canon, target, region, `splitting edge ${ra}–${rb} inside region "${region.name}" or its band`, p, found);
     splitEdge(run, a, b, p);
     followSkinning(run, 'insertion');
     if (accept(run, 'insertion', [])) return { kind: 'replayed' };

package/src/meshskinning.ts

@@ -1235,7 +1235,7 @@ export class SkinningCarry {
       }
       let carrier: Carrier | null;
       try {
-        carrier = resolveCarriers(this.su[j], this.sv[j], hits, `${this.who}: candidate (working vertex ids)`);
+        carrier = resolveCarriers(this.su[j], this.sv[j], hits, `${this.who}: candidate (working vertex ids)`, (v) => this.mesh.uv[v]);
       } catch (err) {
         if (!(err instanceof MeshReductionError)) throw err;
         if (pending.refused === null) pending.refused = `SKINNING_UV_CARRIER_NOT_UNIQUE: ${err.message}`;