@rig-c/parts 1.23.0 → 1.25.0

package/src/rig.ts

@@ -132,11 +132,11 @@
  * touches the disk, and the same inputs give the same bytes (key order is the
  * order the objects are built in, and every number is rounded by `pyRound`).
  */
-import { type AutoSpec, type BoneEntry, type WeightRule, type CharacterConfig, type ConfigConstraint, CONSTRAINT_FOLLOWS, constraintForRig, type ContourSpec, type Point, type RibsSpec, ROOT_BONE, weightsABone } from './config.ts';
+import { type AutoSpec, type BoneEntry, type WeightRule, type CharacterConfig, type ConfigConstraint, type ConfigStop, CONSTRAINT_FOLLOWS, constraintForRig, type ContourSpec, type Point, type RibsSpec, ROOT_BONE, stopForRig, weightsABone } from './config.ts';
 import { type BoneTransform, computeExactFrameTransforms, cropToSpineY, normaliseDegrees, toBoneLocal, toWorld } from './coords.ts';
 import { type Problem, refuseIfAny } from './errors.ts';
 import { eyeLineDegrees } from './headframe.ts';
-import type { RigBoneInherit } from 'rig-c/src/rig.ts';
+import type { RigBoneInherit, RigStop } from 'rig-c/src/rig.ts';
 import { f32 } from 'rig-c/compile';
 import type { MeshCounts, MeshQualityReport, MeshReductionInput, MotionAmplitude, ReducedMesh, Termination } from 'rig-c/mesh';
 import { type AmplitudeRow, amplitudeRow, partAmplitude, withAmplitude } from './autoamplitude.ts';
@@ -450,6 +450,12 @@ export interface RigSpec {
    * when the config has the field.
    */
   constraints?: Array<Record<string, unknown>>;
+  /**
+   * `config.stops` (issue #404), in the order written, each with its `links`
+   * expanded from `chain` when omitted and its records and annotations left out
+   * ({@link stopForRig}). Written only when the config has the field.
+   */
+  stops?: RigStop[];
   /**
    * `idleDrivesMeshes`: written only under `idleKeys: 'direct'`, and only when
    * the idle keys a mesh-driving bone. `detached`: written only when a
@@ -1033,6 +1039,17 @@ export function buildRig(
     if (!byPart.has(part)) fail('RIG_PART_PRESENT', `config.regions.${part}`, `names the part "${part}", which is not in parts.json; ${where(part)}`);
     if (!B.has(bone)) fail('RIG_NAME_RESOLVES', `config.regions.${part}`, `names the bone "${bone}", which config.bones does not declare`);
   }
+  if (cfg.stops !== undefined) {
+    cfg.stops.forEach((s, i) => {
+      const at = `config.stops[${i}]`;
+      if (!chains.has(s.chain)) fail('RIG_NAME_RESOLVES', `${at}.chain`, `names the chain "${s.chain}", which config.bones does not declare`);
+      const links = s.links ?? chains.get(s.chain) ?? [];
+      links.forEach((l, k) => {
+        if (!B.has(l)) fail('RIG_NAME_RESOLVES', `${at}.links[${k}]`, `names the bone "${l}", which config.bones does not declare`);
+      });
+      if (!B.has(s.against)) fail('RIG_NAME_RESOLVES', `${at}.against`, `names the bone "${s.against}", which config.bones does not declare`);
+    });
+  }
   for (const p of parts.parts) {
     const inM = p.name in cfg.meshes;
     const inR = p.name in cfg.regions;
@@ -1377,6 +1394,31 @@ export function buildRig(
       return [{ chain, points: line.map(([x, y]) => [x - ox, y - oy] as [number, number]), stations: declared.stations }];
     });
   };
+  // Issue #417: on a declared dress (a topwear mesh carrying chest, hip and hip-rooted skirt tree chains, as
+  // cloth.bottomwear.part drafts), skirt tree links carry no weight on vertices above the hip line (wy < hip.y): the
+  // bodice is weighted by the torso's own bones (chest, hip, and any local region like a bust) at any influences cap;
+  // below the hip line nothing changes.
+  const hipChainLinks = new Set<string>();
+  for (const links of chains.values()) {
+    for (const l of links) {
+      let cur: string | null = B.get(l)?.parent ?? null;
+      while (cur !== null && cur !== 'hip' && cur !== 'chest') cur = B.get(cur)?.parent ?? null;
+      if (cur === 'hip') hipChainLinks.add(l);
+    }
+  }
+  const dressSegsAt = (p: PartsFile['parts'][number], segs: Segment[]): ((wy: number) => Segment[]) => {
+    const hipBone = B.get('hip');
+    if (hipBone === undefined) return () => segs;
+    const isDress =
+      tagOf(p.from) === 'topwear' &&
+      segs.some((s) => s.bone === 'chest') &&
+      segs.some((s) => s.bone === 'hip') &&
+      segs.some((s) => hipChainLinks.has(s.bone));
+    if (!isDress) return () => segs;
+    const torso = segs.filter((s) => !hipChainLinks.has(s.bone));
+    if (torso.length === 0) return () => segs;
+    return (wy: number): Segment[] => (wy < hipBone.y ? torso : segs);
+  };
   // A contour mesh (issue #84): `src/contour.ts` over the padded image, every refusal collected with the others;
   // the weights by `src/localweights.ts`; slot, uvs, bind positions and by-name weights written as the lattice's.
   // The config's region numbers are rig px; the part image's are rig px less (p.x − PAD, p.y − PAD) — a
@@ -1420,6 +1462,7 @@ export function buildRig(
       out.push(...heat);
       return null;
     }
+    const segsAt = dressSegsAt(p, segs);
     const weights: WeightEntry[][] = [];
     const reached = regions.map(() => 0);
     const whole = regions.map(() => 0);
@@ -1431,7 +1474,8 @@ export function buildRig(
     cm.vertices.forEach(([vx, vy], vi) => {
       const wx = vx + ox;
       const wy = vy + oy;
-      const li = localInfluences([wx, wy], segs, r, regions, limits, exponent ?? DISTANCE_EXPONENT, heat === null ? undefined : heatInfluences(heat, [vx, vy], limits));
+      const vSegs = segsAt(wy);
+      const li = localInfluences([wx, wy], vSegs, r, regions, limits, exponent ?? DISTANCE_EXPONENT, heat === null ? undefined : heatInfluences(heat, [vx, vy], limits));
       if ('first' in li) {
         if (!overlapped) {
           out.push({
@@ -1445,7 +1489,7 @@ export function buildRig(
       }
       if (li.influences.length === 0) {
         // issue #284: a declared cut that keeps no bone (nothingKeptProblem says when that can be); a region's bone would be kept.
-        if (emptied === null) emptied = { vertex: vi, at: [wx, wy], capped: heat === null ? influences([wx, wy], segs, r, { maxInfluences: limits.maxInfluences, minWeight: 0 }, exponent ?? DISTANCE_EXPONENT) : heatInfluences(heat, [vx, vy], { maxInfluences: limits.maxInfluences, minWeight: 0 }) };
+        if (emptied === null) emptied = { vertex: vi, at: [wx, wy], capped: heat === null ? influences([wx, wy], vSegs, r, { maxInfluences: limits.maxInfluences, minWeight: 0 }, exponent ?? DISTANCE_EXPONENT) : heatInfluences(heat, [vx, vy], { maxInfluences: limits.maxInfluences, minWeight: 0 }) };
         else emptiedMore++;
         return;
       }
@@ -1551,7 +1595,7 @@ export function buildRig(
       out.push(...heat);
       return null;
     }
-    const sw = sourceWeights(source.vertices, ox, oy, segs, r, spec, exponent ?? DISTANCE_EXPONENT, heat);
+    const sw = sourceWeights(source.vertices, ox, oy, segs, r, spec, exponent ?? DISTANCE_EXPONENT, heat, dressSegsAt(p, segs));
     if ('overlap' in sw) {
       out.push({
         code: 'RIG_CONTOUR_REGIONS_OVERLAP',
@@ -1807,15 +1851,17 @@ export function buildRig(
     let maxInfl = 0;
     // issue #284: the mesh's declared cap and floor form, or DEFAULT_LIMITS itself when it declares none.
     const limits: InfluenceLimits = meshLimits(mesh.influences);
+    const segsAt = dressSegsAt(p, segs);
     let emptied: { vertex: number; at: Point; capped: Influence[] } | null = null;
     let emptiedMore = 0;
     for (const [vi, [vx0, vy0]] of lm.vertices.entries()) {
       const wx = vx0 + ox;
       const wy = vy0 + oy;
-      const shares = heat === null ? influences([wx, wy], segs, mesh.r, limits, mesh.exponent ?? DISTANCE_EXPONENT) : heatInfluences(heat, [vx0, vy0], limits);
+      const vSegs = segsAt(wy);
+      const shares = heat === null ? influences([wx, wy], vSegs, mesh.r, limits, mesh.exponent ?? DISTANCE_EXPONENT) : heatInfluences(heat, [vx0, vy0], limits);
       if (shares.length === 0) {
         // issue #284: a declared cut that keeps no bone (nothingKeptProblem says when that can be).
-        if (emptied === null) emptied = { vertex: vi, at: [wx, wy], capped: heat === null ? influences([wx, wy], segs, mesh.r, { maxInfluences: limits.maxInfluences, minWeight: 0 }, mesh.exponent ?? DISTANCE_EXPONENT) : heatInfluences(heat, [vx0, vy0], { maxInfluences: limits.maxInfluences, minWeight: 0 }) };
+        if (emptied === null) emptied = { vertex: vi, at: [wx, wy], capped: heat === null ? influences([wx, wy], vSegs, mesh.r, { maxInfluences: limits.maxInfluences, minWeight: 0 }, mesh.exponent ?? DISTANCE_EXPONENT) : heatInfluences(heat, [vx0, vy0], { maxInfluences: limits.maxInfluences, minWeight: 0 }) };
         else emptiedMore++;
         continue;
       }
@@ -1852,6 +1898,10 @@ export function buildRig(
     });
   }
   refuseIfAny(problems);
+  // ---- leg stops (issue #404) --------------------------------------------
+  // Only when the config has `stops`: each link after the first (and any bone hanging from a stopped link) hangs
+  // from the drawn link `<link>_d` above it, and slots and weights on a stopped link bind `<link>_d`.
+  const stops = cfg.stops === undefined ? null : applyStops(cfg.stops, chains, bones, slots, skin);
   // ---- the turn control (issue #251) -------------------------------------
   // Only when the config has `turn`: every other build adds nothing here, so no byte moves.
   const turned = cfg.turn === undefined ? null : applyTurn(cfg.turn, parts.parts.map((p) => p.name), bones, slots, skin, cfg.constraints ?? []);
@@ -1868,6 +1918,7 @@ export function buildRig(
   };
   if (cfg.constraints !== undefined) rig.constraints = cfg.constraints.map(constraintForRig);
   if (turned !== null) rig.constraints = [...(rig.constraints ?? []), ...turned.constraints];
+  if (stops !== null) rig.stops = stops;
   const detached = [...detachedRules(cfg.constraints ?? []), ...(turned?.detached ?? [])];
   if (idleKeys === 'direct' && meshKeyed.length > 0) rig.invariants = { idleDrivesMeshes: { why: IDLE_DRIVES_MESHES_WHY } };
   if (detached.length > 0) rig.invariants = { ...rig.invariants, detached };
@@ -1880,6 +1931,49 @@ export function buildRig(
   return { rig, motion, meshReport, images: outImages, controls, meshKeyed, idleKeys, loopPasses, autoMotion, faceAxis, turn: turned?.rows ?? null };
 }
 
+/**
+ * Re-parent every bone that hangs from a stopped link onto that link's drawn
+ * link `<link>_d`, move slots and mesh weights from a stopped link onto
+ * `<link>_d`, and return `rig.json`'s `stops` array (issue #404). At the setup
+ * pose `<link>_d` has the same world origin and rotation as `<link>`, so every
+ * local offset and bind coordinate is unchanged.
+ */
+function applyStops(
+  stops: readonly ConfigStop[],
+  chains: ReadonlyMap<string, readonly string[]>,
+  bones: RigBone[],
+  slots: RigSpec['slots'],
+  skin: RigSpec['skins']['default'],
+): RigStop[] {
+  const out: RigStop[] = [];
+  const drawn = new Map<string, string>();
+  for (const s of stops) {
+    const links = s.links ?? chains.get(s.chain) ?? [];
+    for (const l of links) drawn.set(l, `${l}_d`);
+    out.push(stopForRig(s, links));
+  }
+  for (const b of bones) {
+    const d = b.parent === undefined ? undefined : drawn.get(b.parent);
+    if (d !== undefined) b.parent = d;
+  }
+  for (const s of slots) {
+    const d = drawn.get(s.bone);
+    if (d !== undefined) s.bone = d;
+  }
+  for (const atts of Object.values(skin)) {
+    for (const att of Object.values(atts)) {
+      if (!('type' in att)) continue;
+      for (const v of att.weights) {
+        for (const w of v) {
+          const d = drawn.get(w.bone);
+          if (d !== undefined) w.bone = d;
+        }
+      }
+    }
+  }
+  return out;
+}
+
 /**
  * The JSON text of a rig output file. One space of indent, as the reference
  * wrote, and a closing newline; the key order is the order the objects were
@@ -1926,7 +2020,10 @@ export function rigJsonText(value: unknown): string {
  */
 export function flattenRig(rig: RigSpec, sense: 1 | -1 = 1): RigSpec {
   const problems: Problem[] = [];
-  const read = rig.bones.map((b) => ({ ...b, rotation: (b.rotation ?? 0) * sense }));
+  const undrawn = new Map<string, string>();
+  for (const s of rig.stops ?? []) for (const l of s.links) undrawn.set(`${l}_d`, l);
+  const realBone = (n: string): string => undrawn.get(n) ?? n;
+  const read = rig.bones.map((b) => ({ ...b, ...(b.parent === undefined ? {} : { parent: realBone(b.parent) }), rotation: (b.rotation ?? 0) * sense }));
   const world = computeExactFrameTransforms(read);
   const turn = new Map<string, number>();
   // A bone with a declared inherit mode (issue #348) is read off rig-c's poser, which honours the mode; every other is the sum, as before.
@@ -1934,11 +2031,11 @@ export function flattenRig(rig: RigSpec, sense: 1 | -1 = 1): RigSpec {
     turn.set(
       b.name,
       b.inherit === undefined
-        ? placed((b.parent === undefined ? 0 : (turn.get(b.parent) as number)) + (b.rotation ?? 0), OFFSET_PLACES)
+        ? placed((b.parent === undefined ? 0 : (turn.get(realBone(b.parent)) as number)) + (b.rotation ?? 0), OFFSET_PLACES)
         : placed(normaliseDegrees((world.get(b.name) as BoneTransform).worldRotation), OFFSET_PLACES),
     );
   }
-  const origin = (bone: string): BoneTransform => world.get(bone) as BoneTransform;
+  const origin = (bone: string): BoneTransform => world.get(realBone(bone)) as BoneTransform;
   const out = (m: BoneTransform, x: number, y: number): [number, number] => {
     const [wx, wy] = toWorld(m, x, y);
     return [placed(wx - m.worldX, FLAT_PLACES), placed(wy - m.worldY, FLAT_PLACES)];
@@ -1962,12 +2059,12 @@ export function flattenRig(rig: RigSpec, sense: 1 | -1 = 1): RigSpec {
         })) };
         continue;
       }
-      const left = normaliseDegrees((turn.get(bone) as number) + (att.rotation ?? 0));
+      const left = normaliseDegrees((turn.get(realBone(bone)) as number) + (att.rotation ?? 0));
       if (Math.abs(left) > 1e-6) {
         problems.push({
           code: 'FLATTEN_REGION_UPRIGHT',
           object: `skins.default.${slot}.${name}`,
-          detail: `rides "${bone}", turned ${turn.get(bone)} degrees, with rotation ${att.rotation ?? 'absent'}, so it is drawn turned ${placed(left, OFFSET_PLACES)} degrees; the flat form draws every region upright, so the region's rotation must cancel its bone's turn`,
+          detail: `rides "${bone}", turned ${turn.get(realBone(bone))} degrees, with rotation ${att.rotation ?? 'absent'}, so it is drawn turned ${placed(left, OFFSET_PLACES)} degrees; the flat form draws every region upright, so the region's rotation must cancel its bone's turn`,
         });
         continue;
       }
@@ -1989,6 +2086,9 @@ export function flattenRig(rig: RigSpec, sense: 1 | -1 = 1): RigSpec {
       return { ...c, properties: { ...props, rotate: { ...rotate, offset: placed(offset - turned, OFFSET_PLACES) } } };
     });
   }
+  if (rig.stops !== undefined) {
+    flat.stops = rig.stops.map((s) => ({ ...s, at: out(origin(s.against), s.at[0], s.at[1]) }));
+  }
   if (rig.invariants?.axes !== undefined) {
     const { axes: _axes, ...rest } = rig.invariants;
     if (Object.keys(rest).length > 0) flat.invariants = rest;

package/src/squeeze.ts

@@ -37,7 +37,7 @@
  * 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 type { BoneEntry, ConfigConstraint, 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';
@@ -77,6 +77,27 @@ export interface SqueezeFinding {
   turned: number | null;
 }
 
+/**
+ * Issue #403: two sibling branch tips forked from the same trunk link on a lattice mesh whose cell-boundary weights
+ * pin adjacent vertices to different branch links (or whose fork gives the two branches unequal spring strength), so
+ * the triangles where the two branches' cells meet are squeezed under the environment or a hip sway.
+ */
+export interface BranchSqueezeFinding {
+  mesh: string;
+  parent: string;
+  a: string;
+  b: string;
+  tipGap: number;
+  triangle: number;
+  edge: [number, number];
+  weightA: number;
+  weightB: number;
+  strengthA: number | null;
+  strengthB: number | null;
+  r: number;
+  grid: number;
+}
+
 export interface SqueezeResult {
   findings: SqueezeFinding[];
   /** Pairs on one mesh this did not read, and why. */
@@ -272,3 +293,142 @@ export function chainSqueezes(
   }
   return { findings, unread, read };
 }
+
+/**
+ * Issue #403: sibling branch chains forked from the same trunk link on a lattice mesh under the distance rule.
+ * When `m.r < m.grid` concentrates a cell-boundary edge's weights on each branch's tip link (above 0.85), or when
+ * physics constraints give two sibling branches of one fork unequal `strength` (such as `edge` 50 beside `branch` 100),
+ * the triangles where the two branches' cells meet squeeze under the environment or a hip sway. Returns one finding per
+ * unheld sibling pair on a fork; quiet on an unbranched mesh or when `split.hold_tip: true` holds the fork.
+ */
+export function branchSqueezes(
+  spec: { bones: readonly BoneEntry[]; meshes: Readonly<Record<string, MeshSpec>>; constraints?: readonly ConfigConstraint[] },
+  parts: ReadonlyMap<string, { x: number; y: number; image: Raster }>,
+): BranchSqueezeFinding[] {
+  const out: BranchSqueezeFinding[] = [];
+  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 });
+  const linkOf = new Set<string>();
+  for (const [c, e] of chains) e.points.forEach((_, i) => linkOf.add(`${c}${i}`));
+  const strengthOf = new Map<string, number>();
+  for (const c of spec.constraints ?? []) {
+    if (c.type === 'physics' && typeof c.bone === 'string' && c.rotate !== undefined && typeof c.strength === 'number') {
+      strengthOf.set(c.bone, c.strength);
+    }
+  }
+
+  for (const [mname, m] of Object.entries(spec.meshes)) {
+    if ('contour' in m || 'auto' in m || m.rule === 'heat') continue;
+    const byFork = new Map<string, string[]>();
+    for (const sp of m.segments) {
+      if (typeof sp !== 'string') continue;
+      const c = chains.get(sp);
+      if (c === undefined || !linkOf.has(c.parent)) continue;
+      const list = byFork.get(c.parent) ?? [];
+      list.push(sp);
+      byFork.set(c.parent, list);
+    }
+    const forks = [...byFork.entries()].filter(([, list]) => list.length >= 2);
+    if (forks.length === 0) continue;
+    const part = parts.get(mname);
+    if (part === undefined) continue;
+    const segs: Segment[] = [];
+    let unresolved = false;
+    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 = true;
+        break;
+      }
+      segs.push({ bone: sp, a: [single.at[0], single.at[1]], b: [single.tip[0], single.tip[1]] });
+    }
+    if (unresolved) 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) 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 topOf = (vi: number): { bone: string; weight: number } | null => {
+      const w = weights[vi];
+      if (w.length === 0) return null;
+      return [...w].sort((p, q) => q.weight - p.weight)[0];
+    };
+    for (const [parent, siblings] of forks) {
+      for (let i = 0; i + 1 < siblings.length; i++) {
+        const aChain = siblings[i];
+        const bChain = siblings[i + 1];
+        const ca = chains.get(aChain) as { points: Point[]; tip: Point };
+        const cb = chains.get(bChain) as { points: Point[]; tip: Point };
+        const aLast = `${aChain}${ca.points.length - 1}`;
+        const bLast = `${bChain}${cb.points.length - 1}`;
+        let best: { triangle: number; edge: [number, number]; weightA: number; weightB: number; y: number } | null = null;
+        for (let t = 0; t + 2 < lm.triangles.length; t += 3) {
+          const tri = [lm.triangles[t], lm.triangles[t + 1], lm.triangles[t + 2]];
+          const triIdx = t / 3;
+          const meanY = (rest[tri[0]][1] + rest[tri[1]][1] + rest[tri[2]][1]) / 3;
+          for (const [u, v] of [
+            [tri[0], tri[1]],
+            [tri[1], tri[2]],
+            [tri[2], tri[0]],
+          ] as const) {
+            const tu = topOf(u);
+            const tv = topOf(v);
+            if (tu === null || tv === null) continue;
+            const match =
+              tu.bone === aLast && tv.bone === bLast
+                ? { edge: [u, v] as [number, number], weightA: tu.weight, weightB: tv.weight }
+                : tu.bone === bLast && tv.bone === aLast
+                  ? { edge: [v, u] as [number, number], weightA: tv.weight, weightB: tu.weight }
+                  : null;
+            if (match === null) continue;
+            const peak = Math.max(match.weightA, match.weightB);
+            const bestPeak = best === null ? -1 : Math.max(best.weightA, best.weightB);
+            if (best === null || peak > bestPeak || (peak === bestPeak && meanY > best.y)) {
+              best = { triangle: triIdx, edge: match.edge, weightA: match.weightA, weightB: match.weightB, y: meanY };
+            }
+          }
+        }
+        if (best === null) continue;
+        const strengthA = strengthOf.get(aLast) ?? null;
+        const strengthB = strengthOf.get(bLast) ?? null;
+        const unequalStrength = strengthA !== null && strengthB !== null && strengthA !== strengthB;
+        const narrowReach = m.r < m.grid && Math.max(best.weightA, best.weightB) > 0.85;
+        if (!unequalStrength && !narrowReach) continue;
+        out.push({
+          mesh: mname,
+          parent,
+          a: aLast,
+          b: bLast,
+          tipGap: edgeLength(ca.tip[0] - cb.tip[0], ca.tip[1] - cb.tip[1]),
+          triangle: best.triangle,
+          edge: best.edge,
+          weightA: best.weightA,
+          weightB: best.weightB,
+          strengthA,
+          strengthB,
+          r: m.r,
+          grid: m.grid,
+        });
+      }
+    }
+  }
+  return out;
+}