@rig-c/parts 1.11.0 → 1.13.0

package/src/propose.ts

@@ -136,6 +136,8 @@ import { configRoles, type RoleOf } from './structure.ts';
 import { AUTHOR_NO_ROLE, isAuthorTag } from './tags.ts';
 import { TURN_BONE, TURN_CARRIER_TAG, TURN_PLACES, TURN_RIDER_OFFSET, TURN_RIDER_TAGS, turnFractions, turnNearest, turnPivot, turnRiderDepth, type TurnSpec } from './turn.ts';
 import { edgeLength } from './length.ts';
+import { chainSqueezes, type SqueezeFinding } from './squeeze.ts';
+import { TEXTURE_STRETCH_CEILING } from './check.ts';
 
 // ---------------------------------------------------------------------------
 // the output shape — config-shaped, key order as the reference writes it
@@ -2905,7 +2907,10 @@ export interface ChainNotAdvancingFinding {
   toJoint: KeypointName;
 }
 
-export type LintFinding = OffArtFinding | OffLockFinding | HipAboveChestFinding | HipTooHighFinding | ChestNotBetweenFinding | HipNotPastChestFinding | HipNearerNeckFinding | ChainNotAdvancingFinding;
+/** Issue #314: two chains on one lattice whose own swing closes or opens an edge between them past check's TEXTURE_STRETCH bar (`src/squeeze.ts`). */
+export type SqueezeLintFinding = { kind: 'squeeze' } & SqueezeFinding;
+
+export type LintFinding = OffArtFinding | OffLockFinding | HipAboveChestFinding | HipTooHighFinding | ChestNotBetweenFinding | HipNotPastChestFinding | HipNearerNeckFinding | ChainNotAdvancingFinding | SqueezeLintFinding;
 
 /** Which rule set read the torso and the sleeve chains, under `--keypoints`. */
 export interface LintBasis {
@@ -2923,6 +2928,8 @@ export interface LintResult {
   lockUnread: string[];
   /** Single bones the torso checks read (`hip`, `chest`) that the bones do not hold: those checks did not run. */
   missingTorsoBones: string[];
+  /** Issue #314: the pairs of keyed chains on one mesh the squeeze check could not build a lattice for, and why. Empty when it read every pair or had none. */
+  squeezeUnread: string[];
   /** Present only under `--keypoints`: the rule set that read the torso and the chains. */
   basis?: LintBasis;
   /** One record per bone of the spec, in its bone order (chain links as `<chain><i>`): which checks read it, or why none did (issue #86). */
@@ -3130,8 +3137,21 @@ export function lint(
       }
     }
   }
+  // Issue #314: every pair of keyed chains a lattice mesh names, swung on the rig stage's own lattice and weights, held
+  // to check's TEXTURE_STRETCH bar (src/squeeze.ts). Only with a motion: without one nothing swings.
+  const sq = chainSqueezes({ bones: spec.bones, meshes: spec.meshes, motion: spec.motion }, new Map(P.recs.filter((p) => P.images.has(p.name)).map((p) => [p.name, { x: p.x, y: p.y, image: P.images.get(p.name) as Raster }])));
+  for (const { mesh, a, b } of sq.read) {
+    for (const [c, other] of [[a, b], [b, a]]) {
+      const e = spec.bones.find((x) => 'chain' in x && x.chain === c);
+      if (e !== undefined && 'chain' in e) e.points.forEach((_, i) => readBy(`${c}${i}`, `squeeze with ${other} on mesh ${pyRepr(mesh)}`));
+    }
+  }
+  for (const f of sq.findings) findings.push({ kind: 'squeeze', ...f });
+  const squeezeUnread = sq.unread;
   const coverage = lintCoverage(spec, byName, read, findings, unknownMeshes, basis);
-  return basis === undefined ? { findings, unknownMeshes, lockUnread, missingTorsoBones, coverage } : { findings, unknownMeshes, lockUnread, missingTorsoBones, basis, coverage };
+  return basis === undefined
+    ? { findings, unknownMeshes, lockUnread, missingTorsoBones, squeezeUnread, coverage }
+    : { findings, unknownMeshes, lockUnread, missingTorsoBones, squeezeUnread, basis, coverage };
 }
 
 /** The bones a finding names: the off-art link; hip and chest for a relation between them; a chain's last link for its tip. */
@@ -3148,6 +3168,8 @@ function findingBones(f: LintFinding, bones: readonly BoneEntry[]): string[] {
       return ['hip'];
     case 'chest-not-between':
       return ['chest'];
+    case 'squeeze':
+      return [...new Set(f.vertices.map((v) => v.weights[0]?.bone).filter((n): n is string => n !== undefined))];
     case 'chain-not-advancing': {
       if (!f.point.endsWith(' tip')) return [f.point];
       const chain = f.point.slice(0, -' tip'.length);
@@ -3313,11 +3335,42 @@ export function lintLine(f: LintFinding): string {
       return `LINT hip at ${pyIntList(f.hip)} is not past chest at ${pyIntList(f.chest)} on the way from the neck joint to the hip joints (hip at ${pyFixed(f.tHip, 2)}, chest at ${pyFixed(f.tChest, 2)} of the way): breathing and the skirt hang from the wrong end of the torso`;
     case 'hip-nearer-neck':
       return `LINT hip at ${pyIntList(f.hip)} is nearer the neck joint ${fmtAt(f.neck)} (${pyFixed(f.dNeck, 1)} px) than the midpoint of the hip joints ${fmtAt(f.hips)} (${pyFixed(f.dHips, 1)} px): a hip at the shoulders`;
+    case 'squeeze':
+      return squeezeLine(f);
     case 'chain-not-advancing':
       return `LINT ${f.point} at ${pyIntList(f.at)} does not advance from ${f.fromJoint} toward ${f.toJoint}: it falls ${pyFixed(f.t, 1)} px along that line and ${f.previous} ${pyFixed(f.tPrevious, 1)} px, and each must fall further than the one before`;
   }
 }
 
+/**
+ * The squeeze LINT line (issue #314): the pair and the mesh, the worst edge with both swinging and the bone each of
+ * its two vertices rides most, the bar it is held to (check's), each chain swung alone, the tips' distance and the
+ * amplitudes, and the remedies whose figure passes the bar — one sign when the amplitudes are opposed, dropping a
+ * chain when the other alone passes — or, when none does, that the amplitudes are too large for this lattice.
+ */
+function squeezeLine(f: SqueezeLintFinding): string {
+  const e = f.both.at;
+  const C = TEXTURE_STRETCH_CEILING;
+  const rides = f.vertices.map((v) => (v.weights.length === 0 ? `vertex ${v.vertex} rides no bone` : `vertex ${v.vertex} rides ${v.weights[0].bone} ${v.weights[0].weight}`)).join(', ');
+  const amps = (c: { amps: readonly number[] }): string => `[${c.amps.join(', ')}]`;
+  const remedies: string[] = [];
+  if (f.turned !== null && f.turned <= C) remedies.push(`give both the same sign (then ${pyFixed(f.turned, 3)})`);
+  if (f.aloneA <= C && f.aloneB <= C) remedies.push('drop one chain');
+  else if (f.aloneA <= C) remedies.push(`drop ${f.b.chain}, which alone is past the bar too`);
+  else if (f.aloneB <= C) remedies.push(`drop ${f.a.chain}, which alone is past the bar too`);
+  const said =
+    f.turned !== null
+      ? `their amplitudes are opposed (${f.a.chain} ${amps(f.a)}, ${f.b.chain} ${amps(f.b)}), so their tips swing towards each other and apart`
+      : `their amplitudes are ${f.a.chain} ${amps(f.a)} and ${f.b.chain} ${amps(f.b)}`;
+  const remedy = remedies.length > 0 ? remedies.join(', or ') : 'neither one sign nor either chain alone passes the bar: lower the amplitudes';
+  return (
+    `LINT ${f.a.chain} and ${f.b.chain} on mesh ${pyRepr(f.mesh)} ${e.ratio >= 1 ? 'stretch' : 'squeeze'} it: swung together, every other bone held, ` +
+    `edge ${e.edge.join('-')} of triangle ${e.triangle} ${e.ratio >= 1 ? 'opens' : 'closes'} to ${pyFixed(e.ratio, 3)} times its rest length at idle frame ${e.frame} (max(ratio, 1/ratio) ${pyFixed(f.both.severity, 3)}; ` +
+    `<= ${C} is required, check's TEXTURE_STRETCH bar) — ${rides}; alone, ${f.a.chain} reads ${pyFixed(f.aloneA, 3)} and ${f.b.chain} ${pyFixed(f.aloneB, 3)}. ` +
+    `Their tips are ${pyFixed(f.tipGap, 1)} px apart and ${said}: ${remedy}`
+  );
+}
+
 export interface Comparison {
   rows: Array<[string, number]>;
   onlyConfig: string[];

package/src/rig.ts

@@ -153,13 +153,13 @@ import {
 } from './automesh.ts';
 import { type ContourChainRibs, type ContourReport, contourMesh, type ContourRegion, type ContourRib } from './contour.ts';
 import { type LocalInfluence, localInfluences } from './localweights.ts';
-import { artCoverage, ART_ALPHA, latticeMesh, ONE_LOOP_PASSES } from './mesh.ts';
+import { artCoverage, ART_ALPHA, latticeMesh, latticeStray, ONE_LOOP_PASSES } from './mesh.ts';
 import { BLINK, blinkHoldMisses, blinkSpan, CONTROL_SUFFIX, controlledBones, IDLE_FPS, idleMotion, type MotionSpec, moveKeysToControls } from './motion.ts';
 import { PAINTING_RUN, type PartsFile, readFrom, tagOf } from './parts.ts';
 import { EYE_GROUP_TAGS } from './propose.ts';
 import { alphaAbove, crop, pad, type Raster } from './raster/index.ts';
 import { pyRound } from './round.ts';
-import { boneHeat, heatInfluences, heatRow, type HeatRow, latticeSilhouette, tracedSilhouette } from './heat.ts';
+import { boneHeat, type HeatDust, heatInfluences, HEAT_LIMITS, heatRow, type HeatRow, latticeSilhouette, tracedSilhouette } from './heat.ts';
 import { TURN_BONE, type TurnSpec, turnConstraintName, turnFractions, turnTwin } from './turn.ts';
 import { DISTANCE_EXPONENT, type FloorForm, type Influence, influences, type InfluenceLimits, type MeshInfluences, meshLimits, type Segment } from './weights.ts';
 
@@ -650,6 +650,10 @@ export interface LatticeMeshReport {
   exponent?: number;
   /** The cap and floor form the mesh declared, as declared (issue #284); absent when it declared none and ran at 4 and the cut. */
   influences?: MeshInfluences;
+  /** The `stray` the mesh declared (issue #303); absent when it declared none. */
+  stray?: number;
+  /** Only beside a declared `stray` (issue #303): the islands it left out of the lattice, their art px, and the part's art px. */
+  stray_cleared?: StrayCleared;
   /** Only under `rule: "heat"` (issue #161): the rule and the solve it ran. Absent otherwise, so a distance mesh writes the row it always wrote. */
   heat?: HeatRow;
 }
@@ -1745,7 +1749,11 @@ export function buildRig(
       meshReport.push(row.report);
       continue;
     }
-    const art = alphaAbove(img, ART_ALPHA);
+    const allArt = alphaAbove(img, ART_ALPHA);
+    // issue #303: under a declared `stray`, the islands it leaves out are cleared from the art the lattice and its heat
+    // silhouette are built over; absent, `art` is `allArt` itself and nothing downstream moves.
+    const stray = mesh.stray === undefined ? null : latticeStray(allArt, mesh.stray);
+    const art = stray === null ? allArt : stray.art;
     const lm = latticeMesh(p.name, art, mesh.grid, maxLoopPasses);
     if ('code' in lm) {
       problems.push(lm);
@@ -1755,7 +1763,12 @@ export function buildRig(
     const ox = p.x - PAD;
     const oy = p.y - PAD;
     // issue #161: under rule "heat", the field over the lattice's art (alpha above 8) with its holes filled.
-    const heat = mesh.rule === 'heat' ? boneHeat(`config.meshes.${p.name}`, latticeSilhouette(art), segs, ox, oy) : null;
+    // issue #303: an island no bone reaches is worded against the lattice's own `stray` when it is dust.
+    const dust = (): HeatDust => {
+      const read = stray ?? latticeStray(allArt, 0);
+      return { field: `config.meshes.${p.name}.stray`, declared: mesh.stray ?? null, artPixels: read.artPixels, largest: read.largest };
+    };
+    const heat = mesh.rule === 'heat' ? boneHeat(`config.meshes.${p.name}`, latticeSilhouette(art), segs, ox, oy, HEAT_LIMITS, dust) : null;
     if (Array.isArray(heat)) {
       problems.push(...heat);
       continue;
@@ -1803,10 +1816,11 @@ export function buildRig(
       bones: [...new Set(segs.map((s) => s.bone))].sort(),
       max_influences: maxInfl,
       mean_influences: pyRound(infl / lm.vertices.length, 2),
-      art_coverage: pyRound(artCoverage(lm, art), 5),
+      art_coverage: pyRound(artCoverage(lm, allArt), 5),
       grid: mesh.grid,
       ...(mesh.exponent === undefined ? {} : { exponent: mesh.exponent }),
       ...(mesh.influences === undefined ? {} : { influences: mesh.influences }),
+      ...(stray === null ? {} : { stray: mesh.stray as number, stray_cleared: { islands: stray.islands, pixels: stray.pixels, art_pixels: stray.artPixels } }),
       ...(heat === null ? {} : { heat: heatRow(heat) }),
     });
   }

package/src/squeeze.ts

@@ -0,0 +1,274 @@
+/**
+ * Two chains on one lattice that the idle swings into each other (issue #314).
+ *
+ * A pair of chains a mesh's `segments` both name is a squeeze when their own
+ * swing, every other bone held at the setup pose, closes (or opens) a lattice
+ * edge between the art each one carries past the bar `check`'s
+ * `TEXTURE_STRETCH` holds every edge to ({@link TEXTURE_STRETCH_CEILING}, on
+ * max(ratio, 1/ratio)). Read here from what `propose` and `--from-config` hold —
+ * the parts, the bones, the mesh's spec and the idle's chain tracks — so the
+ * squeeze is named before anything is built.
+ *
+ * What is built is the rig stage's own lattice and weights, by the rig stage's
+ * own functions: the part's image padded by {@link PAD}, its art (alpha above
+ * {@link ART_ALPHA}, less what a declared `stray` leaves out) cut into the
+ * lattice by `latticeMesh`, and each vertex weighted by `influences` under the
+ * mesh's `r`, `exponent` and `influences`, rounded as the lattice rounds — so
+ * the vertex and triangle numbers are the ones `rig.json` and `check` use. Only
+ * the lattice mode under the distance rule is read; a contour or automatic mesh,
+ * or `rule: "heat"`, is said not read, by name.
+ *
+ * Each chain's links are posed as the idle's sine states them —
+ * `amps[i] * sin(2 pi (t / period - (phase + lag * i)))` degrees on link `i`,
+ * `src/motion.ts` — turned down the chain (a link carries every link below it),
+ * at the frames `check` renders: `t = f / IDLE_FPS` for every whole frame up to
+ * the idle's duration. Every other bone stays where the setup pose has it, so a
+ * figure is the pair's own: the head's roll or the breath carry both chains
+ * alike and are not in it. A vertex moves as linear blend skinning moves it,
+ * each weight times where that bone's motion takes the vertex. The edge ratios
+ * are `check`'s own reader on these poses ({@link stretchFigures}).
+ *
+ * The pair is named when both swinging together pass the bar, with each
+ * chain swung alone beside it — so the remedy "drop one chain" carries the
+ * figure the other is left with, and a chain past the bar on its own reads as
+ * that. With the two chains' amplitudes opposed link for link (every `amps[i]`
+ * of one the other sign of the other's), the same reading is taken with the
+ * second chain's signs turned, so the remedy "give both the same sign" carries
+ * its own figure too. A remedy whose figure is past the bar is not offered.
+ */
+import { TEXTURE_STRETCH_CEILING } from './check.ts';
+import type { BoneEntry, MeshSpec, Motion, Point } from './config.ts';
+import { stretchFigures, stretchSeverity, type StretchAt } from './instruments.ts';
+import { edgeLength } from './length.ts';
+import { ART_ALPHA, latticeMesh, latticeStray } from './mesh.ts';
+import { IDLE_FPS, TIME_SLACK } from './motion.ts';
+import { pad } from './raster/composite.ts';
+import { alphaAbove, type Raster } from './raster/types.ts';
+import { latticeShares, PAD, roundShares } from './rig.ts';
+import { DISTANCE_EXPONENT, influences, meshLimits, type Segment } from './weights.ts';
+
+/** One chain of the pair as the finding prints it: its name, its `amps` as written, and its tip. */
+export interface SqueezeChain {
+  chain: string;
+  amps: number[];
+  tip: Point;
+}
+
+/** The worst edge of one reading: where, its ratio, and max(ratio, 1/ratio). */
+export interface SqueezeEdge {
+  at: StretchAt;
+  severity: number;
+}
+
+/** A pair named: both chains, the mesh, the worst edge with both swinging, and each alone (and turned, when opposed). */
+export interface SqueezeFinding {
+  mesh: string;
+  a: SqueezeChain;
+  b: SqueezeChain;
+  /** The two tips' distance at the setup pose, rig px. */
+  tipGap: number;
+  both: SqueezeEdge;
+  /** The two vertices of `both`'s edge, each with its two largest weights (bone, weight as rig.json writes it), and how many it has. */
+  vertices: Array<{ vertex: number; weights: Array<{ bone: string; weight: number }>; of: number }>;
+  /** The worst edge with the first chain swung alone, and with the second. */
+  aloneA: number;
+  aloneB: number;
+  /** Both opposed link for link: the worst edge with the second chain's signs turned. Null when they are not opposed. */
+  turned: number | null;
+}
+
+export interface SqueezeResult {
+  findings: SqueezeFinding[];
+  /** Pairs on one mesh this did not read, and why. */
+  unread: string[];
+  /** Every pair read: the mesh and the two chains. */
+  read: Array<{ mesh: string; a: string; b: string }>;
+}
+
+type ChainTrackLike = { chain: string; amps: number[]; period: number; phase: number; lag: number };
+
+/** Each frame's time, as `check` renders them: every whole frame at {@link IDLE_FPS} up to the idle's duration. */
+function frameTimes(duration: number): number[] {
+  const out: number[] = [];
+  for (let f = 0; f / IDLE_FPS <= duration + TIME_SLACK; f++) out.push(f / IDLE_FPS);
+  return out;
+}
+
+/**
+ * A chain's posed links at time `t`: per link, its setup origin, its posed origin, and the turn it carries (degrees,
+ * the sum of its own and every link above it). Positive is Spine's counter-clockwise (y up), which on the crop's y-down
+ * page turns a vector (dx, dy) to (dx cos + dy sin, -dx sin + dy cos).
+ */
+function posedLinks(pts: readonly Point[], track: ChainTrackLike, sign: 1 | -1, t: number): Array<{ rest: Point; at: [number, number]; turn: number }> {
+  const out: Array<{ rest: Point; at: [number, number]; turn: number }> = [];
+  let at: [number, number] = [pts[0][0], pts[0][1]];
+  let turn = 0;
+  for (let i = 0; i + 1 < pts.length; i++) {
+    const amp = i < track.amps.length ? track.amps[i] : 0;
+    turn += sign * amp * Math.sin(2 * Math.PI * (t / track.period - (track.phase + track.lag * i)));
+    out.push({ rest: pts[i], at, turn });
+    const rad = (turn * Math.PI) / 180;
+    const dx = pts[i + 1][0] - pts[i][0];
+    const dy = pts[i + 1][1] - pts[i][1];
+    at = [at[0] + dx * Math.cos(rad) + dy * Math.sin(rad), at[1] - dx * Math.sin(rad) + dy * Math.cos(rad)];
+  }
+  return out;
+}
+
+/** Where a bone's motion takes the point `v`: a link turns it about its origin and carries it to the link's posed origin. */
+function moved(link: { rest: Point; at: [number, number]; turn: number }, v: readonly [number, number]): [number, number] {
+  const rad = (link.turn * Math.PI) / 180;
+  const dx = v[0] - link.rest[0];
+  const dy = v[1] - link.rest[1];
+  return [link.at[0] + dx * Math.cos(rad) + dy * Math.sin(rad), link.at[1] - dx * Math.sin(rad) + dy * Math.cos(rad)];
+}
+
+/**
+ * Every pair of chains a lattice mesh's `segments` name, both keyed by a chain track, read as the module doc says.
+ * `images` holds each part's PNG by name, its `box` its parts.json box (rig px).
+ */
+export function chainSqueezes(
+  spec: { bones: readonly BoneEntry[]; meshes: Readonly<Record<string, MeshSpec>>; motion?: Motion },
+  parts: ReadonlyMap<string, { x: number; y: number; image: Raster }>,
+): SqueezeResult {
+  const findings: SqueezeFinding[] = [];
+  const unread: string[] = [];
+  const read: SqueezeResult['read'] = [];
+  const motion = spec.motion;
+  if (motion === undefined) return { findings, unread, read };
+  const tracks = new Map<string, ChainTrackLike>();
+  for (const t of motion.tracks) if ('chain' in t) tracks.set(t.chain, t);
+  const chains = new Map<string, { points: Point[]; tip: Point; parent: string }>();
+  for (const e of spec.bones) if ('chain' in e) chains.set(e.chain, { points: e.points, tip: e.tip, parent: e.parent });
+  // Every bone's parent, chain links as <chain><i>, so a bone under a link is carried by it.
+  const parent = new Map<string, string>();
+  for (const e of spec.bones) {
+    if ('chain' in e) e.points.forEach((_, i) => parent.set(`${e.chain}${i}`, i === 0 ? e.parent : `${e.chain}${i - 1}`));
+    else parent.set(e.name, e.parent);
+  }
+  const linkOf = new Map<string, [string, number]>();
+  for (const [c, e] of chains) e.points.forEach((_, i) => linkOf.set(`${c}${i}`, [c, i]));
+  // The nearest link at or above a bone, among the chains in `moving`.
+  const carrier = (bone: string, moving: ReadonlySet<string>): [string, number] | null => {
+    const seen = new Set<string>();
+    for (let b: string | undefined = bone; b !== undefined && !seen.has(b); b = parent.get(b)) {
+      const l = linkOf.get(b);
+      if (l !== undefined && moving.has(l[0])) return l;
+      seen.add(b);
+    }
+    return null;
+  };
+  const times = frameTimes(motion.duration);
+
+  for (const [mname, m] of Object.entries(spec.meshes)) {
+    const keyed = m.segments.filter((s): s is string => typeof s === 'string' && chains.has(s) && tracks.has(s));
+    if (keyed.length < 2) continue;
+    const pairs: Array<[string, string]> = [];
+    for (let i = 0; i < keyed.length; i++) for (let j = i + 1; j < keyed.length; j++) pairs.push([keyed[i], keyed[j]]);
+    const names = pairs.map(([a, b]) => `${a} and ${b}`).join(', ');
+    if ('contour' in m || 'auto' in m) {
+      unread.push(`mesh ${JSON.stringify(mname)} (${names}) is a ${'contour' in m ? 'contour' : 'automatic'} mesh; only a lattice is built here`);
+      continue;
+    }
+    if (m.rule === 'heat') {
+      unread.push(`mesh ${JSON.stringify(mname)} (${names}) is weighted by rule "heat"; only the distance rule is read here`);
+      continue;
+    }
+    const part = parts.get(mname);
+    if (part === undefined) continue;
+    // The rig stage's segments: a chain is its links, each from its origin to the next link or the tip.
+    const segs: Segment[] = [];
+    let unresolved: string | null = null;
+    for (const sp of m.segments) {
+      if (typeof sp !== 'string') {
+        segs.push({ bone: sp[0], a: [sp[1][0], sp[1][1]], b: [sp[2][0], sp[2][1]] });
+        continue;
+      }
+      const c = chains.get(sp);
+      if (c !== undefined) {
+        const line = [...c.points, c.tip];
+        c.points.forEach((q, i) => segs.push({ bone: `${sp}${i}`, a: [q[0], q[1]], b: [line[i + 1][0], line[i + 1][1]] }));
+        continue;
+      }
+      const single = spec.bones.find((e) => 'name' in e && e.name === sp);
+      if (single === undefined || !('name' in single) || single.tip === undefined) {
+        unresolved = `its segment "${sp}" is not a chain or a single bone with a tip`;
+        break;
+      }
+      segs.push({ bone: sp, a: [single.at[0], single.at[1]], b: [single.tip[0], single.tip[1]] });
+    }
+    if (unresolved !== null) {
+      unread.push(`mesh ${JSON.stringify(mname)} (${names}): ${unresolved}, so it has no weights to read`);
+      continue;
+    }
+    const img = pad(part.image, PAD, PAD, PAD, PAD, [0, 0, 0, 0]);
+    const allArt = alphaAbove(img, ART_ALPHA);
+    const art = m.stray === undefined ? allArt : latticeStray(allArt, m.stray).art;
+    const lm = latticeMesh(mname, art, m.grid);
+    if ('code' in lm) {
+      unread.push(`mesh ${JSON.stringify(mname)} (${names}): its lattice is refused (${lm.code}), so there is no triangle to read`);
+      continue;
+    }
+    const ox = part.x - PAD;
+    const oy = part.y - PAD;
+    const limits = meshLimits(m.influences);
+    const rest: Array<[number, number]> = lm.vertices.map(([x, y]) => [x + ox, y + oy]);
+    const weights = rest.map((p) => {
+      const shares = influences(p, segs, m.r, limits, m.exponent ?? DISTANCE_EXPONENT);
+      return shares.length === 0 ? [] : limits.floor === 'continuous' ? roundShares(shares) : latticeShares(shares);
+    });
+    const restFlat = rest.flatMap(([x, y]) => [x, y]);
+    const worst = (moving: ReadonlyMap<string, 1 | -1>): SqueezeEdge | null => {
+      const set = new Set(moving.keys());
+      const frames = times.map((t, index) => {
+        const posed = new Map<string, ReturnType<typeof posedLinks>>();
+        for (const [c, sign] of moving) {
+          const e = chains.get(c) as { points: Point[]; tip: Point };
+          posed.set(c, posedLinks([...e.points, e.tip], tracks.get(c) as ChainTrackLike, sign, t));
+        }
+        const vertices: number[] = [];
+        rest.forEach((v, vi) => {
+          let x = 0;
+          let y = 0;
+          for (const { bone, weight } of weights[vi]) {
+            const l = carrier(bone, set);
+            const to = l === null ? v : moved((posed.get(l[0]) as ReturnType<typeof posedLinks>)[l[1]], v);
+            x += weight * to[0];
+            y += weight * to[1];
+          }
+          vertices.push(x, y);
+        });
+        return { index, attachments: [{ slot: mname, attachment: mname, vertices }] };
+      });
+      const [fig] = stretchFigures([{ slot: mname, attachment: mname, vertices: restFlat, triangles: lm.triangles }], frames);
+      if (fig.max === null || fig.min === null) return null;
+      const sMax = stretchSeverity(fig.max.ratio);
+      const sMin = stretchSeverity(fig.min.ratio);
+      return sMin > sMax ? { at: fig.min, severity: sMin } : { at: fig.max, severity: sMax };
+    };
+    for (const [a, b] of pairs) {
+      read.push({ mesh: mname, a, b });
+      const both = worst(new Map([[a, 1], [b, 1]]));
+      if (both === null || both.severity <= TEXTURE_STRETCH_CEILING) continue;
+      const aloneA = (worst(new Map([[a, 1]])) as SqueezeEdge).severity;
+      const aloneB = (worst(new Map([[b, 1]])) as SqueezeEdge).severity;
+      const ta = tracks.get(a) as ChainTrackLike;
+      const tb = tracks.get(b) as ChainTrackLike;
+      const opposed = ta.amps.length === tb.amps.length && ta.amps.every((v, i) => v * tb.amps[i] < 0);
+      const ca = chains.get(a) as { tip: Point };
+      const cb = chains.get(b) as { tip: Point };
+      findings.push({
+        mesh: mname,
+        a: { chain: a, amps: [...ta.amps], tip: ca.tip },
+        b: { chain: b, amps: [...tb.amps], tip: cb.tip },
+        tipGap: edgeLength(ca.tip[0] - cb.tip[0], ca.tip[1] - cb.tip[1]),
+        both,
+        vertices: both.at.edge.map((vertex) => ({ vertex, weights: [...weights[vertex]].sort((p, q) => q.weight - p.weight).slice(0, 2), of: weights[vertex].length })),
+        aloneA,
+        aloneB,
+        turned: opposed ? (worst(new Map<string, 1 | -1>([[a, 1], [b, -1]])) as SqueezeEdge).severity : null,
+      });
+    }
+  }
+  return { findings, unread, read };
+}