@rig-c/parts 1.10.0 → 1.12.0

package/src/config.ts

@@ -92,6 +92,7 @@ import { type Problem, refuseIfAny } from './errors.ts';
 import { isSkeletonName, KEYPOINT_NAMES, type KeypointName, type PosePoints, SKELETON_NAMES, type SkeletonName } from './skeleton.ts';
 import { acceptedTagNames, AUTHOR_LABEL_RULE, AUTHOR_PREFIX, readLayerTag } from './tags.ts';
 import { TURN_BONE, type TurnSpec, turnNearest } from './turn.ts';
+import { FLOOR_FORMS, type FloorForm, type MeshInfluences } from './weights.ts';
 
 export type Point = [number, number];
 
@@ -275,6 +276,13 @@ export interface LatticeMeshSpec {
   exponent?: number;
   /** Absent: `"distance"`. */
   rule?: WeightRule;
+  /** The cap and the floor's form (issue #284); absent is 4 and the cut at 0.03, the rule as it always was. */
+  influences?: MeshInfluences;
+  /**
+   * The largest island, in art pixels, that may be left out of the lattice (issue #303) — the contour mode's
+   * `contour.stray`, with the same meaning (`latticeStray`, `src/mesh.ts`); absent leaves none out.
+   */
+  stray?: number;
 }
 
 export interface ContourMeshSpec {
@@ -285,6 +293,8 @@ export interface ContourMeshSpec {
   exponent?: number;
   /** Absent: `"distance"`. */
   rule?: WeightRule;
+  /** As the lattice's (issue #284). */
+  influences?: MeshInfluences;
   /** Rows of vertices across the part along the chains named here (issue #188); absent places none. */
   ribs?: RibsSpec;
 }
@@ -1660,7 +1670,7 @@ function checkMeshes(c: Check, v: Json, bones: Set<string>, chains: Map<string,
     const at = `config.meshes.${part}`;
     // The known keys keep their old order (grid, r, segments) with contour after them, and `r` and `segments` are
     // required in the place and words the object check uses, so a lattice mesh's refusals read as they did.
-    const m = c.object(at, spec, [], ['grid', 'r', 'segments', 'contour', 'auto', 'exponent', 'rule', 'ribs']);
+    const m = c.object(at, spec, [], ['grid', 'r', 'segments', 'contour', 'auto', 'exponent', 'rule', 'ribs', 'influences', 'stray']);
     if (m === null) continue;
     for (const key of ['r', 'segments']) if (!(key in m)) c.fail('CONFIG_FIELD_PRESENT', `${at}.${key}`, 'is absent and required');
     const modes = ['grid', 'contour', 'auto'].filter((k) => k in m);
@@ -1701,6 +1711,8 @@ function checkMeshes(c: Check, v: Json, bones: Set<string>, chains: Map<string,
       });
     }
     if ('ribs' in m) checkRibs(c, `${at}.ribs`, m, chains);
+    if ('influences' in m) checkMeshInfluences(c, `${at}.influences`, m);
+    if ('stray' in m) checkLatticeStray(c, `${at}.stray`, m);
     if ('auto' in m && typeof m.auto === 'object' && m.auto !== null && !Array.isArray(m.auto) && 'stimulus' in m.auto) {
       checkStimulus(c, `${at}.auto.stimulus`, (m.auto as Record<string, Json>).stimulus, m, chains);
     }
@@ -1746,6 +1758,44 @@ function checkStimulus(c: Check, at: string, v: Json, m: Record<string, Json>, c
   });
 }
 
+/**
+ * `meshes.<part>.influences` (issue #284): the lattice and contour modes' cut, the author's per mesh —
+ * `maxInfluences`, a whole number 1 or more or `null` (no cap), and `floor`, `"cut"` or `"continuous"` (`FloorForm`,
+ * `src/weights.ts`). Either may be absent (4, and the cut); an object naming neither is refused, since it would
+ * declare nothing. The automatic mode states its cap and floor in `auto.influences`, which rig-c's reduction is
+ * handed, so this field beside `auto` is refused by name (`CONFIG_INFLUENCES_MODE`) rather than read by nothing.
+ */
+function checkMeshInfluences(c: Check, at: string, m: Record<string, Json>): void {
+  if ('auto' in m) {
+    c.fail('CONFIG_INFLUENCES_MODE', at, `is ${show(m.influences)} on an automatic mesh (auto); the automatic mode states its cap and floor in auto.influences (maxInfluences, minWeight), which rig-c's reduction is handed — declare them there, or remove influences`);
+    return;
+  }
+  const l = c.object(at, m.influences, [], ['maxInfluences', 'floor']);
+  if (l === null) return;
+  if (!('maxInfluences' in l) && !('floor' in l)) c.fail('CONFIG_FIELD_TYPE', at, `is ${show(m.influences)}, which names neither maxInfluences nor floor; remove influences to keep the cap of 4 and the cut at 0.03`);
+  if ('maxInfluences' in l && l.maxInfluences !== null && !(typeof l.maxInfluences === 'number' && Number.isInteger(l.maxInfluences) && l.maxInfluences >= 1)) {
+    c.fail('CONFIG_FIELD_TYPE', `${at}.maxInfluences`, `is ${show(l.maxInfluences)}; an integer at or above 1, or null (no cap: every bone the mesh's segments name), is required`);
+  }
+  if ('floor' in l && !FLOOR_FORMS.includes(l.floor as FloorForm)) {
+    c.fail('CONFIG_FIELD_TYPE', `${at}.floor`, `is ${show(l.floor)}; "cut" (shares under 0.03 dropped, what an absent floor means) or "continuous" (0.03 subtracted from every share, those at or below 0 dropped) is required`);
+  }
+}
+
+/**
+ * `meshes.<part>.stray` (issue #303): the lattice's largest island, in art pixels, that may be left out — a whole
+ * number, 0 or more, as the contour mode's `contour.stray` is. The contour and automatic modes already state it in
+ * their own place (`contour.stray`, `auto.source.stray`), so beside either it is refused by name
+ * (`CONFIG_STRAY_MODE`) rather than read by nothing.
+ */
+function checkLatticeStray(c: Check, at: string, m: Record<string, Json>): void {
+  const elsewhere = 'contour' in m ? ['a contour mesh (contour)', 'contour.stray'] : 'auto' in m ? ['an automatic mesh (auto)', 'auto.source.stray'] : null;
+  if (elsewhere !== null && !('grid' in m)) {
+    c.fail('CONFIG_STRAY_MODE', at, `is ${show(m.stray)} on ${elsewhere[0]}; that mode states the largest island it may leave out in ${elsewhere[1]}, which its trace reads — declare it there, or remove stray`);
+    return;
+  }
+  c.int(at, m.stray, 0);
+}
+
 /**
  * `meshes.<part>.ribs` (issue #188): an object of chain name → `{ stations }`.
  * Each key must be a chain this mesh's `segments` name (a rib is placed along

package/src/heat.ts

@@ -44,10 +44,19 @@
  *   silhouette, or one whose every reached pixel is nearer another bone. A
  *   bone named in `segments` is a bone the author said may pull the layer;
  *   giving it 0 everywhere would be a silent answer to a question the
- *   config asked.
+ *   config asked. The rule is chosen per mesh (`meshes.<part>.rule`), so the
+ *   refusal names the third remedy too (issue #303): this part keeps the
+ *   distance rule — the one an author whose bone anchors the part from
+ *   outside its art (a torso bone on a neck) can take without moving a bone
+ *   another part placed or dropping the anchor.
  * - `RIG_HEAT_ISLAND_SOURCE`: a 4-connected island of the silhouette that no
  *   bone has a source in. With no fixed temperature the equation has no
- *   answer there; nothing nearest is borrowed.
+ *   answer there; nothing nearest is borrowed. When the caller can say the
+ *   island is dust that its `stray` would leave out ({@link HeatDust}: the
+ *   lattice, issue #303) the refusal names that field and the figure that
+ *   leaves the island out instead of a segment nobody would place on it; an
+ *   island above the dust line keeps the segment remedy, a real piece being
+ *   a real authoring question.
  * - `RIG_HEAT_CONVERGED`: above.
  *
  * Two runs on the same input write the same bytes: the claims, the sweep
@@ -55,6 +64,8 @@
  */
 import type { Point } from './config.ts';
 import { artMask, growSilhouette } from './contour.ts';
+import { DUST_MAX_PX, DUST_MAX_SHARE, isDust } from './mesh.ts';
+import { pyRound } from './round.ts';
 import type { Problem } from './errors.ts';
 import { connectedComponents, fillHoles, type Mask } from './raster/index.ts';
 import { capAndFloor, type Influence, type InfluenceLimits, type Segment, segmentDistance } from './weights.ts';
@@ -120,11 +131,34 @@ export interface HeatRow {
 
 const fmt = (v: number): string => String(Math.round(v * 1000) / 1000);
 
+/**
+ * What a mesh's `stray` can say about a silhouette island no bone reaches (issue #303), handed in by the mode that has
+ * the field (the lattice): the field's path, its declared figure (null when absent), and the part's art islands it
+ * reads — the art px (`isDust`'s share is of them) and the largest island's area, which `stray` never leaves out. It
+ * is read only when an island is refused, so a build that solves never computes it.
+ */
+export interface HeatDust {
+  field: string;
+  declared: number | null;
+  artPixels: number;
+  largest: number;
+}
+
+/** The refusal's remedy for an island of `area` px no bone reaches: the stray field when the island is dust it would leave out, else a segment. */
+function islandRemedy(area: number, dust: HeatDust | null): string {
+  if (dust !== null && isDust(area, dust.artPixels) && area < dust.largest) {
+    const now = dust.declared === null ? 'it is absent' : `it is ${dust.declared}`;
+    return `the island is dust — at most ${DUST_MAX_PX} px and at most ${pyRound(DUST_MAX_SHARE * 100, 6)} % of the part's ${dust.artPixels} art px, mesh-draft's dust line — which no bone is meant to sit on: declare ${dust.field} at ${area} or more (${now}), which leaves an island that small out of the mesh and the silhouette heat solves over`;
+  }
+  return `under rule "heat" every island needs a segment within ${HEAT_SOURCE_BAND} px of one of its pixel centres — nothing is borrowed from the nearest island`;
+}
+
 /**
  * Solve bone heat over `sil` (part-image pixels) for `segs` (rig px; the image is the rig less `(ox, oy)`).
- * `object` names the mesh in every refusal. Every problem found is returned at once.
+ * `object` names the mesh in every refusal. Every problem found is returned at once. `dust`, when the mesh's mode has
+ * a `stray` field, is read only to word an island refusal ({@link HeatDust}).
  */
-export function boneHeat(object: string, sil: Mask, segs: readonly Segment[], ox: number, oy: number, limits: HeatLimits = HEAT_LIMITS): HeatField | Problem[] {
+export function boneHeat(object: string, sil: Mask, segs: readonly Segment[], ox: number, oy: number, limits: HeatLimits = HEAT_LIMITS, dust: (() => HeatDust) | null = null): HeatField | Problem[] {
   const { width: w, height: h, data } = sil;
   const n = w * h;
   const bones: string[] = [];
@@ -166,19 +200,21 @@ export function boneHeat(object: string, sil: Mask, segs: readonly Segment[], ox
     problems.push({
       code: 'RIG_HEAT_BONE_SOURCE',
       object,
-      detail: `bone "${bone}" — its segment ${where} (rig px) ${why}, so it holds no source pixel; under rule "heat" every bound bone needs at least one: a silhouette pixel (${silPixels} px) whose centre lies within ${HEAT_SOURCE_BAND} px of the segment and nearer it than any other bound bone's. A bone with no source is not weighted 0 — move its segment onto the art, or take the bone out of segments`,
+      detail: `bone "${bone}" — its segment ${where} (rig px) ${why}, so it holds no source pixel; under rule "heat" every bound bone needs at least one: a silhouette pixel (${silPixels} px) whose centre lies within ${HEAT_SOURCE_BAND} px of the segment and nearer it than any other bound bone's. A bone with no source is not weighted 0 — move its segment onto the art, take the bone out of segments, or keep this part on the distance rule (rule "distance", or no rule, on this mesh: the rule is chosen per mesh)`,
     });
   });
   const cc = connectedComponents(sil, 4);
   const sourced = new Uint8Array(cc.count);
   for (let i = 0; i < n; i++) if (owner[i] >= 0) sourced[cc.labels[i]] = 1;
+  let dustRead: HeatDust | null = null;
   for (let c = 1; c < cc.count; c++) {
     if (sourced[c]) continue;
     const st = cc.stats[c];
+    if (dust !== null && dustRead === null) dustRead = dust();
     problems.push({
       code: 'RIG_HEAT_ISLAND_SOURCE',
       object,
-      detail: `the silhouette's 4-connected island of ${st.area} px at rig (${st.left + ox}, ${st.top + oy}) holds no bound bone's source pixel, so the heat equation has no fixed temperature there and no answer; under rule "heat" every island needs a segment within ${HEAT_SOURCE_BAND} px of one of its pixel centres — nothing is borrowed from the nearest island`,
+      detail: `the silhouette's 4-connected island of ${st.area} px at rig (${st.left + ox}, ${st.top + oy}) holds no bound bone's source pixel, so the heat equation has no fixed temperature there and no answer; ${islandRemedy(st.area, dustRead)}`,
     });
   }
   if (problems.length > 0) return problems;

package/src/mesh.ts

@@ -360,3 +360,64 @@ export function latticeMesh(part: string, art: Mask, grid: number, maxPasses: nu
   }
   return mesh;
 }
+
+/**
+ * Dust (issue #265, Stage B's rule; moved here from `src/meshdraft.ts` by issue #303, so the rig stage's heat refusal
+ * and `mesh-draft` read one line): an extra 4-connected island of the art of at most this many art px …
+ */
+export const DUST_MAX_PX = 4;
+
+/** … and at most this share of the part's art px. */
+export const DUST_MAX_SHARE = 0.001;
+
+/** Whether an island of `area` art px is dust in a part of `artPixels` art px ({@link DUST_MAX_PX}, {@link DUST_MAX_SHARE}). */
+export function isDust(area: number, artPixels: number): boolean {
+  return area <= DUST_MAX_PX && area <= DUST_MAX_SHARE * artPixels;
+}
+
+/** What a declared `meshes.<part>.stray` left out of a lattice's art (issue #303). */
+export interface LatticeStray {
+  /** The art the lattice is built over: `art` itself when nothing was left out. */
+  art: Mask;
+  /** Islands left out, and their art px. */
+  islands: number;
+  pixels: number;
+  /** The art px of the part before anything was left out. */
+  artPixels: number;
+  /** The area of the largest island; an island this large is never left out. */
+  largest: number;
+}
+
+/**
+ * The lattice's `stray` (issue #303), the contour mode's field with the same meaning — the largest island, in art
+ * pixels, that may be left out of the mesh — read over the same islands: the 4-connected islands of the art (alpha
+ * above {@link ART_ALPHA}). Every island of `stray` art px or fewer is cleared from the art the lattice and its heat
+ * silhouette are built over, except an island as large as the largest, which is never left out (two equal largest
+ * pieces both stay: leaving one would be a choice the declaration does not make). Unlike the contour mode, an island
+ * above the figure is not refused: the lattice bridges every island it keeps (step 2 above), so it is meshed as it
+ * always was. The part's image is not touched; `artCoverage` is read over all the art, the islands left out included.
+ */
+export function latticeStray(art: Mask, stray: number): LatticeStray {
+  const comp = connectedComponents(art, 4);
+  let largest = 0;
+  let artPixels = 0;
+  for (let l = 1; l < comp.count; l++) {
+    largest = Math.max(largest, comp.stats[l].area);
+    artPixels += comp.stats[l].area;
+  }
+  const out = new Uint8Array(comp.count);
+  let islands = 0;
+  let pixels = 0;
+  for (let l = 1; l < comp.count; l++) {
+    const a = comp.stats[l].area;
+    if (a <= stray && a < largest) {
+      out[l] = 1;
+      islands++;
+      pixels += a;
+    }
+  }
+  if (islands === 0) return { art, islands, pixels, artPixels, largest };
+  const data = new Uint8Array(art.data);
+  for (let i = 0; i < data.length; i++) if (out[comp.labels[i]] === 1) data[i] = 0;
+  return { art: { width: art.width, height: art.height, data }, islands, pixels, artPixels, largest };
+}

package/src/meshdraft.ts

@@ -14,7 +14,7 @@
  * - dust left out: an extra 4-connected island of the art (alpha above `ART_ALPHA`) of at most {@link DUST_MAX_PX} px
  *   and at most {@link DUST_MAX_SHARE} of the part's art is dust, and a `stray` equal to the largest such island leaves
  *   it out. A part with any other extra island holds a real piece, and keeps its lattice ({@link dustOf});
- * - `r`, `segments`, `exponent` and `rule` as the lattice entry states them.
+ * - `r`, `segments`, `exponent`, `rule` and `influences` as the lattice entry states them.
  *
  * The constants are the ones issue #265's stages measured (Stage A passed every bar at c = 37 on three examples; T 2
  * at the trailer's 1108 px figure is Stage A2's point; the dust rule is Stage B's). They are calibrated on three
@@ -68,7 +68,7 @@ import { BARS, type CheckReport, type PackShape, type PageEdges, type RigcRunner
 import { type CharacterConfig, type ContourMeshSpec, type LatticeMeshSpec, loadConfigAndAnimations, type Segment } from './config.ts';
 import { PartsError, type Problem, problemLine } from './errors.ts';
 import { IDLE_FPS } from './motion.ts';
-import { ART_ALPHA } from './mesh.ts';
+import { ART_ALPHA, DUST_MAX_PX, DUST_MAX_SHARE, isDust } from './mesh.ts';
 import { type PartsFile, readParts } from './parts.ts';
 import { alphaAbove, connectedComponents } from './raster/index.ts';
 import { readPng } from './raster/png.ts';
@@ -90,11 +90,11 @@ export const TOLERANCE_FIGURE_DIVISOR = 554;
 /** The heights of the three figures the two divisors were measured on, rig px (demo, the trailer, scarf). */
 export const CALIBRATION_HEIGHTS: readonly number[] = [1106, 1108, 1185];
 
-/** Dust: an extra island of at most this many art px (Stage B: 1–2 px dots were the measured case) … */
-export const DUST_MAX_PX = 4;
-
-/** … and at most this share of the part's art px. */
-export const DUST_MAX_SHARE = 0.001;
+/**
+ * Dust (Stage B: 1–2 px dots were the measured case): `src/mesh.ts` holds the line since issue #303, which the rig
+ * stage's heat refusal reads too; re-exported here, where it was first written.
+ */
+export { DUST_MAX_PX, DUST_MAX_SHARE } from './mesh.ts';
 
 /** The bend set's turn per link, degrees: the fallback Stage C stated, a physics constraint's reach not being derivable from it. */
 export const BEND_DEGREES = 15;
@@ -182,7 +182,7 @@ export function dustOf(image: Raster): DustReading {
   if (islands.length === 0) return { keep: `its image has no pixel with alpha above ${ART_ALPHA}`, islands };
   if (islands.length > 1 && islands[0] === islands[1]) return { keep: `its art is ${islands.length} islands (${islands.join(', ')} px) of which two share the largest count, so no one island is the largest`, islands };
   const extra = islands.slice(1);
-  const pieces = extra.filter((n) => !(n <= DUST_MAX_PX && n <= DUST_MAX_SHARE * art));
+  const pieces = extra.filter((n) => !isDust(n, art));
   if (pieces.length > 0) {
     return {
       keep: `its art is ${islands.length} islands (${islands.join(', ')} px); ${pieces.length} beside the largest ${pieces.length === 1 ? 'is a real piece' : 'are real pieces'}, not dust (at most ${DUST_MAX_PX} px and at most ${pyRound(DUST_MAX_SHARE * 100, 6)} % of the part's ${art} art px), and the contour mode meshes one island`,
@@ -200,6 +200,7 @@ export function candidateMesh(lattice: LatticeMeshSpec, rules: Pick<FigureRules,
     segments: lattice.segments,
     ...(lattice.exponent === undefined ? {} : { exponent: lattice.exponent }),
     ...(lattice.rule === undefined ? {} : { rule: lattice.rule }),
+    ...(lattice.influences === undefined ? {} : { influences: lattice.influences }),
   };
 }
 
@@ -692,7 +693,7 @@ export function meshDraftStage(input: MeshDraftInput, rigc: RigcRunner, checkBin
     const denseMeshes = new Map<string, LatticeMeshSpec>();
     for (const part of names) {
       const l = cfg.meshes[part] as LatticeMeshSpec;
-      denseMeshes.set(part, { grid: denseGrid(artPixels(images.get(part) as Raster)), r: l.r, segments: l.segments, ...(l.exponent === undefined ? {} : { exponent: l.exponent }), ...(l.rule === undefined ? {} : { rule: l.rule }) });
+      denseMeshes.set(part, { grid: denseGrid(artPixels(images.get(part) as Raster)), r: l.r, segments: l.segments, ...(l.exponent === undefined ? {} : { exponent: l.exponent }), ...(l.rule === undefined ? {} : { rule: l.rule }), ...(l.influences === undefined ? {} : { influences: l.influences }) });
     }
     const denseRig = buildRig({ ...cfg, meshes: { ...cfg.meshes, ...Object.fromEntries(denseMeshes) } }, parts, images, undefined, input.idleKeys).rig;
     const pngs: Array<[string, Uint8Array]> = readdirSync(join(draftedRig.rigDir, 'images')).sort().map((f) => [f, new Uint8Array(readFileSync(join(draftedRig.rigDir, 'images', f)))]);

package/src/rig.ts

@@ -153,15 +153,15 @@ 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 { DEFAULT_LIMITS, DISTANCE_EXPONENT, type Influence, influences, type Segment } from './weights.ts';
+import { DISTANCE_EXPONENT, type FloorForm, type Influence, influences, type InfluenceLimits, type MeshInfluences, meshLimits, type Segment } from './weights.ts';
 
 /** Transparent pixels added round every part image — the reference's `PAD`. */
 export const PAD = 4;
@@ -309,12 +309,47 @@ export function eyeLine(parts: PartsFile, eyeBones: ReadonlyMap<string, Point>):
 
 /**
  * The weights a contour vertex is written with: a vertex no region reaches is
- * rounded as the lattice rounds (each to 5 places, the last `1 − sum(others)`),
- * one a region reaches by {@link roundShares}.
+ * rounded as the lattice rounds ({@link latticeShares}), one a region reaches
+ * by {@link roundShares} — and so is every vertex of a mesh that declares the
+ * continuous floor (issue #284), whose shares, like a region's ramp, reach
+ * below 0.03 and may round to 0.
  */
-export function writtenShares(li: LocalInfluence): Influence[] {
-  if (li.region >= 0) return roundShares(li.influences);
-  const shares = li.influences.map(({ bone, weight }) => ({ bone, weight: pyRound(weight, 5) }));
+export function writtenShares(li: LocalInfluence, floor?: FloorForm): Influence[] {
+  if (li.region >= 0 || floor === 'continuous') return roundShares(li.influences);
+  return latticeShares(li.influences);
+}
+
+/**
+ * The refusal for a mesh some of whose vertices the cut leaves with no bone (issue #284): the first such vertex, with
+ * its capped shares before the floor, and how many more there are.
+ *
+ * When it can happen, by arithmetic: the capped shares of a vertex are normalised, so over k kept bones they sum to 1
+ * and the largest is at least 1/k. The cut keeps a share of at least 0.03 and the continuous floor one above 0.03, so a
+ * vertex keeps no bone only if 1/k ≤ 0.03, that is k ≥ 34 (1/33 = 0.0303… keeps its largest under both forms). At the
+ * default cap of 4 the largest share is at least 0.25, so a mesh that declares nothing never reaches this; only a
+ * declared cap of 34 or more, or `null`, over 34 or more bones whose shares are all at or below the floor does — and a
+ * share that is not a number (raw values summing to 0) lands here too rather than in the file. Rare, so refused by
+ * name rather than left to a crash in the rounding.
+ */
+export function nothingKeptProblem(part: string, floor: FloorForm | undefined, first: { vertex: number; at: Point; capped: readonly Influence[] }, more: number): Problem {
+  const largest = first.capped.length === 0 ? null : Math.max(...first.capped.map((e) => e.weight));
+  const form = floor === 'continuous' ? 'the continuous floor (0.03 subtracted from every share) keeps none at or below 0.03' : 'the cut drops every share below 0.03';
+  return {
+    code: 'RIG_INFLUENCES_KEPT',
+    object: `config.meshes.${part}.influences`,
+    detail: `vertex ${first.vertex} at rig (${first.at[0]}, ${first.at[1]})${more > 0 ? ` and ${more} more` : ''} keeps no bone: its ${first.capped.length} capped share(s) have the largest ${largest === null || !Number.isFinite(largest) ? String(largest) : pyRound(largest, 6)}, and ${form}; a largest share above 0.03 is required, which every vertex has when 33 or fewer bones are kept (the largest of k shares is at least 1/k) — declare maxInfluences 33 or less, or name fewer bones in segments`,
+  };
+}
+
+/**
+ * The lattice's rounding: each weight to 5 places, the last entry written as
+ * `1 − sum(others)`. Safe because under the cut every kept entry is at least
+ * `MIN_WEIGHT`, so the last cannot be taken negative; a mesh that declares the
+ * continuous floor is rounded by {@link roundShares} instead (issue #284, as
+ * Stage E wrote it: `docs/evidence/weight-cap.md`).
+ */
+export function latticeShares(list: readonly Influence[]): Influence[] {
+  const shares = list.map(({ bone, weight }) => ({ bone, weight: pyRound(weight, 5) }));
   let others = 0;
   for (let k = 0; k < shares.length - 1; k++) others += shares[k].weight;
   shares[shares.length - 1].weight = pyRound(1 - others, 5);
@@ -613,6 +648,12 @@ export interface LatticeMeshReport {
   grid: number;
   /** The distance rule's exponent the mesh declared (issue #161); absent when it declared none and ran at 2. */
   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;
 }
@@ -636,6 +677,8 @@ export interface ContourMeshReport {
   mode: 'contour';
   /** The distance rule's exponent the mesh declared (issue #161); absent when it declared none and ran at 2. */
   exponent?: number;
+  /** As the lattice row's (issue #284). */
+  influences?: MeshInfluences;
   /** Only when the mesh declared ribs (issue #188): what it declared and what was placed. Absent otherwise, so a mesh without ribs writes the row it always wrote. */
   ribs?: RibsRow;
   /** `maxEdge` only when the mesh declared it (issue #265), so a mesh without it writes the row it always wrote. */
@@ -1321,8 +1364,10 @@ export function buildRig(
     segs: Segment[],
     rule: WeightRule,
     ribSpec: { segments: ReadonlyArray<string | readonly [string, Point, Point]>; ribs?: RibsSpec },
+    declared: MeshInfluences | undefined,
     out: Problem[],
   ): { attachment: MeshAttachment; report: ContourMeshReport } | null => {
+    const limits = meshLimits(declared);
     const ox = p.x - PAD;
     const oy = p.y - PAD;
     const w = img.width;
@@ -1354,10 +1399,12 @@ export function buildRig(
     let infl = 0;
     let maxInfl = 0;
     let overlapped = false;
+    let emptied: { vertex: number; at: Point; capped: Influence[] } | null = null;
+    let emptiedMore = 0;
     cm.vertices.forEach(([vx, vy], vi) => {
       const wx = vx + ox;
       const wy = vy + oy;
-      const li = localInfluences([wx, wy], segs, r, regions, DEFAULT_LIMITS, exponent ?? DISTANCE_EXPONENT, heat === null ? undefined : heatInfluences(heat, [vx, vy], DEFAULT_LIMITS));
+      const li = localInfluences([wx, wy], segs, r, regions, limits, exponent ?? DISTANCE_EXPONENT, heat === null ? undefined : heatInfluences(heat, [vx, vy], limits));
       if ('first' in li) {
         if (!overlapped) {
           out.push({
@@ -1369,11 +1416,17 @@ export function buildRig(
         overlapped = true;
         return;
       }
+      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 }) };
+        else emptiedMore++;
+        return;
+      }
       if (li.region >= 0) {
         reached[li.region]++;
         if (li.g >= 1) whole[li.region]++;
       }
-      const shares = writtenShares(li);
+      const shares = writtenShares(li, limits.floor);
       const ent: WeightEntry[] = shares.map(({ bone, weight }) => {
         const [x, y] = toBoneLocal(world.get(bone) as BoneTransform, spineX(wx), spineY(wy));
         return { bone, x: places(x), y: places(y), weight };
@@ -1383,6 +1436,10 @@ export function buildRig(
       maxInfl = Math.max(maxInfl, ent.length);
     });
     if (overlapped) return null;
+    if (emptied !== null) {
+      out.push(nothingKeptProblem(p.name, limits.floor, emptied, emptiedMore));
+      return null;
+    }
     const uvs: number[] = [];
     for (const [x, y] of cm.vertices) uvs.push(pyRound(x / w, 6), pyRound(y / h, 6));
     const bones = new Set(segs.map((s) => s.bone));
@@ -1401,6 +1458,7 @@ export function buildRig(
         art_coverage: pyRound(rep.coveredArtPixels / (rep.artPixels + rep.strayPixels), 5),
         mode: 'contour',
         ...(exponent === undefined ? {} : { exponent }),
+        ...(declared === undefined ? {} : { influences: declared }),
         ...(ribSpec.ribs === undefined ? {} : { ribs: ribsRow(ribSpec.ribs, cm.ribs ?? []) }),
         params: { tolerance: spec.tolerance, margin: spec.margin, spacing: spec.spacing, ...(spec.maxEdge === undefined ? {} : { maxEdge: spec.maxEdge }), budget: spec.budget ?? null, stray: spec.stray ?? null },
         contour: rep,
@@ -1684,14 +1742,18 @@ export function buildRig(
       continue;
     }
     if ('contour' in mesh) {
-      const row = contourAttachment(p, img, file, mesh.contour, mesh.r, mesh.exponent, segs, mesh.rule ?? 'distance', mesh, problems);
+      const row = contourAttachment(p, img, file, mesh.contour, mesh.r, mesh.exponent, segs, mesh.rule ?? 'distance', mesh, mesh.influences, problems);
       if (row === null) continue;
       skin[p.name] = { [p.name]: row.attachment };
       slots.push({ name: p.name, bone: segs[0].bone, attachment: p.name });
       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);
@@ -1701,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;
@@ -1711,20 +1778,32 @@ export function buildRig(
     const weights: WeightEntry[][] = [];
     let infl = 0;
     let maxInfl = 0;
-    for (const [vx0, vy0] of lm.vertices) {
+    // issue #284: the mesh's declared cap and floor form, or DEFAULT_LIMITS itself when it declares none.
+    const limits: InfluenceLimits = meshLimits(mesh.influences);
+    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 ent: WeightEntry[] = (heat === null ? influences([wx, wy], segs, mesh.r, undefined, mesh.exponent ?? DISTANCE_EXPONENT) : heatInfluences(heat, [vx0, vy0], DEFAULT_LIMITS)).map(({ bone, weight }) => {
+      const shares = heat === null ? influences([wx, wy], segs, 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 }) };
+        else emptiedMore++;
+        continue;
+      }
+      const ent: WeightEntry[] = (limits.floor === 'continuous' ? roundShares(shares) : latticeShares(shares)).map(({ bone, weight }) => {
         const [x, y] = toBoneLocal(world.get(bone) as BoneTransform, spineX(wx), spineY(wy));
-        return { bone, x: places(x), y: places(y), weight: pyRound(weight, 5) };
+        return { bone, x: places(x), y: places(y), weight };
       });
-      let others = 0;
-      for (let k = 0; k < ent.length - 1; k++) others += ent[k].weight;
-      ent[ent.length - 1].weight = pyRound(1 - others, 5);
       weights.push(ent);
       infl += ent.length;
       maxInfl = Math.max(maxInfl, ent.length);
     }
+    if (emptied !== null) {
+      problems.push(nothingKeptProblem(p.name, limits.floor, emptied, emptiedMore));
+      continue;
+    }
     const uvs: number[] = [];
     for (const [x, y] of lm.vertices) uvs.push(pyRound(x / w, 6), pyRound(y / h, 6));
     skin[p.name] = { [p.name]: { type: 'mesh', image: file, width: w, height: h, uvs, triangles: lm.triangles, hull: lm.hull, weights } };
@@ -1737,9 +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) }),
     });
   }