@rig-c/parts 1.9.1 → 1.11.0

package/src/rig.ts

@@ -161,7 +161,7 @@ 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 { 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,8 @@ 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;
   /** 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,9 +673,12 @@ 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;
-  params: { tolerance: number; margin: number; spacing: number; budget: number | null; stray: number | null };
+  /** `maxEdge` only when the mesh declared it (issue #265), so a mesh without it writes the row it always wrote. */
+  params: { tolerance: number; margin: number; spacing: number; maxEdge?: number; budget: number | null; stray: number | null };
   contour: ContourReport;
   regions: Array<{ name: string; bone: string; reached: number; whole: number }>;
   /** Only under `rule: "heat"` (issue #161), as the lattice row's. */
@@ -1320,8 +1360,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;
@@ -1335,7 +1377,7 @@ export function buildRig(
         : { name: rg.name, shape: 'polygon', points: rg.points.map(([x, y]) => [x - ox, y - oy] as [number, number]), spacing: rg.spacing, band: rg.band },
     );
     const ribs = chainRibs(ribSpec.segments, ribSpec.ribs, ox, oy);
-    const cm = contourMesh(p.name, { width: w, height: h, alpha }, { threshold: ART_ALPHA, tolerance: spec.tolerance, margin: spec.margin, spacing: spec.spacing, budget: spec.budget, stray: spec.stray, regions: inPart, ...(ribs.length === 0 ? {} : { ribs }) });
+    const cm = contourMesh(p.name, { width: w, height: h, alpha }, { threshold: ART_ALPHA, tolerance: spec.tolerance, margin: spec.margin, spacing: spec.spacing, ...(spec.maxEdge === undefined ? {} : { maxEdge: spec.maxEdge }), budget: spec.budget, stray: spec.stray, regions: inPart, ...(ribs.length === 0 ? {} : { ribs }) });
     if (Array.isArray(cm)) {
       out.push(...cm);
       return null;
@@ -1353,10 +1395,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({
@@ -1368,11 +1412,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 };
@@ -1382,6 +1432,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));
@@ -1400,8 +1454,9 @@ 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, budget: spec.budget ?? null, stray: spec.stray ?? null },
+        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,
         regions: regions.map((rg, k) => ({ name: rg.name, bone: rg.bone, reached: reached[k], whole: whole[k] })),
         ...(heat === null ? {} : { heat: heatRow(heat) }),
@@ -1683,7 +1738,7 @@ 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 });
@@ -1710,20 +1765,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 } };
@@ -1739,6 +1806,7 @@ export function buildRig(
       art_coverage: pyRound(artCoverage(lm, art), 5),
       grid: mesh.grid,
       ...(mesh.exponent === undefined ? {} : { exponent: mesh.exponent }),
+      ...(mesh.influences === undefined ? {} : { influences: mesh.influences }),
       ...(heat === null ? {} : { heat: heatRow(heat) }),
     });
   }

package/src/tags.ts

@@ -26,6 +26,22 @@
  * Nothing downstream classifies a part by its NAME. The role of a part — what
  * a proposer may do with it — is read from the tag it came from, which is why
  * `parts.json` records `from` for every part.
+ *
+ * ⭐ **An author-made layer** (issue #256) is a layer the author split or
+ * painted by hand outside the tool — a hand laid over a hip taken out of
+ * `handwear`, a loop of hair over a shoulder taken out of `back hair` — and
+ * added to a run. It is named `author:<label>` ({@link AUTHOR_PREFIX}), the
+ * label the author's own. It is not a See-through tag and carries no role:
+ * {@link readTag} never reads it, so no rule that reads roles from tags ever
+ * sees it, and every reader that admits a layer reads it through
+ * {@link readLayerTag}, which says `group: "author"`. Why a prefix and this
+ * one: a single reserved name would let a run hold one such layer (a tag
+ * names one layer, `LAYERS_NAME_UNIQUE`, and one layer makes one part); no
+ * v3 tag holds a colon, so the prefix cannot be read as a See-through tag or
+ * as one of its `-r`/`-l` halves; and `<origin>:<name>` is already how
+ * `parts.json` says "not a See-through layer" for a patch (`painting:<name>`).
+ * Every reader of a part's `from` splits at the first colon, so
+ * `full:author:hand` is the full run's layer `author:hand`.
  */
 
 export const BODY_TAGS = [
@@ -119,3 +135,73 @@ export function pairOf(name: string): string | null {
   if (t === null || t.side === null) return null;
   return `${t.base}-${t.side === 'r' ? 'l' : 'r'}`;
 }
+
+/** The prefix of an author-made layer's name (issue #256): `author:<label>`. */
+export const AUTHOR_PREFIX = 'author:';
+
+/** An author-made layer's name read: the label after {@link AUTHOR_PREFIX}, and no tag, so no role. */
+export interface AuthorTagReading {
+  /** The name as the layer carries it: `author:hand`. */
+  name: string;
+  /** What follows the prefix: the author's own word, read by nothing as a role. */
+  label: string;
+  group: 'author';
+}
+
+/** What a layer name reads as: a See-through v3 tag, or an author-made layer's name. */
+export type LayerTagReading = TagReading | AuthorTagReading;
+
+/** What an author-made layer's label must be, as a refusal quotes it. */
+export const AUTHOR_LABEL_RULE = 'a label that is not empty, does not start with "." or whitespace, does not end with whitespace, and holds no slash, backslash or colon';
+
+/**
+ * Whether `label` may follow {@link AUTHOR_PREFIX}. It becomes part of a part
+ * name the plan proposes and of a file name the wrapper form may look for
+ * (`parts/<name>.png`), so it is held to what a part name may be, and it holds
+ * no colon, so the name keeps exactly one.
+ */
+export function authorLabelOk(label: string): boolean {
+  return label !== '' && !label.startsWith('.') && label.trim() === label && !/[\\/:]/.test(label);
+}
+
+/** Read a layer name as an author-made layer's, or `null` when it is not one (no prefix, or a label {@link authorLabelOk} refuses). */
+export function readAuthorTag(name: string): AuthorTagReading | null {
+  if (!name.startsWith(AUTHOR_PREFIX)) return null;
+  const label = name.slice(AUTHOR_PREFIX.length);
+  return authorLabelOk(label) ? { name, label, group: 'author' } : null;
+}
+
+/** Read a layer name as a v3 tag or an author-made layer's name, or `null` when it is neither. */
+export function readLayerTag(name: string): LayerTagReading | null {
+  return readTag(name) ?? readAuthorTag(name);
+}
+
+/** Whether a tag string names an author-made layer. */
+export function isAuthorTag(name: string): boolean {
+  return readAuthorTag(name) !== null;
+}
+
+/**
+ * Why `name` is no layer tag, as the detail of a `*_TAG_KNOWN` refusal: an
+ * `author:` name whose label is refused says what the label must be; any
+ * other names the accepted v3 tags and the author form.
+ */
+export function layerTagRequirement(name: string): string {
+  if (name.startsWith(AUTHOR_PREFIX)) {
+    return `is an author-made layer's name with the label ${JSON.stringify(name.slice(AUTHOR_PREFIX.length))}; ${AUTHOR_LABEL_RULE} is required after "${AUTHOR_PREFIX}"`;
+  }
+  return `is not a See-through v3 tag; one of ${acceptedTagNames().join(', ')} is required, or "${AUTHOR_PREFIX}<label>" for a layer the author made`;
+}
+
+/**
+ * What every stage says of an author-made layer (issue #256), so it never
+ * reads as a See-through layer: `layers` prints it per layer, `assemble` per
+ * part, and `--propose-plan` and `propose` carry it in their notes.
+ */
+export const AUTHOR_NO_ROLE =
+  'an author-made layer, not a See-through one: no tag, so no role — it rides the bone the config gives it (config.regions.<part>, or a mesh in config.meshes), and its draw position is its place in config.assemble.plan';
+
+/** The `layers` line for an author-made layer. */
+export function authorLayerLine(name: string): string {
+  return `author-made: layer "${name}" — ${AUTHOR_NO_ROLE}`;
+}

package/src/turn.ts

@@ -30,6 +30,37 @@
  */
 import { pyRound } from './round.ts';
 
+/**
+ * The layers that ride on the face (issue #271): See-through makes no depth
+ * of their own for them, so `propose` does not read theirs. The eye group —
+ * eyewhite, irides, eyelash, eyebrow — is cut from one depth map predicted for
+ * the combined eyes layer (`compose_list` in See-through's
+ * `common/utils/inference_utils.py`, commit df019de), which is why
+ * `eyewhite-r` and `eyewhite-l` read the same median in every run measured
+ * for #251; nose and mouth are clamped by See-through to the face's median
+ * minus {@link TURN_RIDER_OFFSET} when they read behind it (the same file,
+ * lines 528-531). Their own medians disagreed across the two runs by up to
+ * 0.474 (demo `eyebrow-r`, #251's table), and the disagreement swapped their
+ * order against the face. Matched on the layer's base tag, either side.
+ */
+export const TURN_RIDER_TAGS: readonly string[] = ['eyewhite', 'irides', 'eyelash', 'eyebrow', 'nose', 'mouth'];
+
+/** The tag of the part the riders take their depth from. */
+export const TURN_CARRIER_TAG = 'face';
+
+/** See-through's own offset between a clamped face feature and the face (`face − 0.001`, the file named at {@link TURN_RIDER_TAGS}). */
+export const TURN_RIDER_OFFSET = 0.001;
+
+/**
+ * A rider's depth: its carrier's, {@link TURN_RIDER_OFFSET} nearer when the
+ * rider is drawn after the carrier (above it) and as much further when it is
+ * drawn before (under it), so the draw order the depths imply is the one
+ * parts.json holds.
+ */
+export function turnRiderDepth(carrier: number, above: boolean): number {
+  return above ? carrier - TURN_RIDER_OFFSET : carrier + TURN_RIDER_OFFSET;
+}
+
 /** The control bone the rig stage adds under `root` when the config has `turn`: nothing keys it, and its local x is the dial. */
 export const TURN_BONE = 'turn';
 

package/src/weights.ts

@@ -18,6 +18,13 @@
  * rounding. Ties in the sort keep the order the bones first appeared among the
  * segments (Python's `sorted` is stable, and so is `Array.prototype.sort`).
  *
+ * The cap and the floor's form are the author's per mesh in the lattice and
+ * contour modes (issue #284, `meshes.<part>.influences`): a declared
+ * `maxInfluences` (a whole number, or `null`: no cap) replaces the 4, and
+ * `floor: "continuous"` replaces the drop at 0.03 by the continuous floor
+ * ({@link FloorForm}). Absent, both are the constants above, and every byte is
+ * the one written before the field existed.
+ *
  * Distances are the reference's arithmetic, operation for operation — the
  * projection `t = clip(((p - a) . ab) / |ab|^2, 0, 1)` and `sqrt(dx^2 + dy^2)`,
  * not `Math.hypot`, whose last bit differs — because a weight rounded at the
@@ -31,12 +38,36 @@
  */
 import type { Point } from './config.ts';
 
-/** At most this many bones pull one vertex — Spine's usual budget and the reference's `[:4]`. */
+/**
+ * At most this many bones pull one vertex where a mesh declares no cap: the reference implementation's `[:4]`,
+ * carried over as a port constant, and nothing more. The format sets no limit — spine-core 4.3.13 reads a weighted
+ * vertex as a bone count followed by that many bindings, with no bound on the count (`SkeletonJson.js`,
+ * `SkeletonBinary.js`, and `computeWorldVertices` in `attachments/Attachment.js`) — and rig-c 2.40.0 neither refuses
+ * nor warns above four: its one assertion on a mesh's weights, `A20_MESH_WEIGHTS_COHERENT`, checks that they are
+ * coherent (every vertex bound, every weight finite and non-negative, each vertex summing to 1), not how many there
+ * are. Read and cited in `docs/evidence/weight-cap.md` (issue #284, Stage E). A mesh may declare its own cap
+ * (`meshes.<part>.influences.maxInfluences`).
+ */
 export const MAX_INFLUENCES = 4;
 
-/** A normalised weight under this is dropped before the final normalisation — the reference's `>= 0.03`. */
+/**
+ * A normalised weight under this is dropped before the final normalisation — the reference's `>= 0.03`. Under the
+ * continuous floor ({@link FloorForm}) it is subtracted from every kept share instead.
+ */
 export const MIN_WEIGHT = 0.03;
 
+/**
+ * The floor's form (issue #284): `"cut"` — the reference's, and what an absent form means: the capped shares,
+ * normalised, any under the floor dropped, the rest normalised again — or `"continuous"`: the capped shares,
+ * normalised, the floor subtracted from every one, those at or below zero dropped, the rest normalised again. Under
+ * the continuous floor a share reaches zero exactly where the cut would drop it, so a bone fades out of a vertex
+ * instead of leaving it in one step; this is Stage A's "continuous floor" (`tools/tear_survey.ts`), the form Stage E
+ * swept at every cap (`docs/evidence/weight-cap.md`).
+ */
+export type FloorForm = 'cut' | 'continuous';
+
+export const FLOOR_FORMS: readonly FloorForm[] = ['cut', 'continuous'];
+
 /**
  * The exponent of the distance rule where a mesh declares none: `1/(d + r)²`,
  * the reference's rule. At this value the weight is computed as
@@ -76,20 +107,42 @@ export interface Influence {
 
 /**
  * The cap and the floor `influences()` applies. The lattice and the contour
- * mode always run at {@link DEFAULT_LIMITS} (the reference's `[:4]` and
- * `>= 0.03`); the automatic mode (`src/automesh.ts`, issue #126) passes the
- * author's numbers instead, because rig-c's reduction is handed explicit
- * influence limits on every weighted call and the 0.03 floor is not one the
- * author wrote (P19). The arithmetic is the same either way, so with the
- * defaults every byte the two older modes write is unchanged.
+ * mode run at {@link DEFAULT_LIMITS} (the reference's `[:4]` and `>= 0.03`)
+ * unless the mesh declares `influences` (issue #284; {@link meshLimits}); the
+ * automatic mode (`src/automesh.ts`, issue #126) passes the author's numbers
+ * instead, because rig-c's reduction is handed explicit influence limits on
+ * every weighted call and the 0.03 floor is not one the author wrote (P19).
+ * The arithmetic is the same either way, so with the defaults every byte the
+ * two older modes write is unchanged.
  */
 export interface InfluenceLimits {
   maxInfluences: number;
   minWeight: number;
+  /** The floor's form; absent is `"cut"`, the arithmetic as it always was. */
+  floor?: FloorForm;
 }
 
 export const DEFAULT_LIMITS: InfluenceLimits = { maxInfluences: MAX_INFLUENCES, minWeight: MIN_WEIGHT };
 
+/** `meshes.<part>.influences` in the lattice and contour modes (issue #284): either field may be absent. */
+export interface MeshInfluences {
+  /** A whole number, 1 or more, or `null`, no cap — every bone the mesh's segments name is kept (the config's spelling of a bound declared absent, as `maxOvershoot` and `weightJump`). Absent: {@link MAX_INFLUENCES}. */
+  maxInfluences?: number | null;
+  /** Absent: `"cut"`. */
+  floor?: FloorForm;
+}
+
+/**
+ * The limits a lattice or contour mesh runs at: {@link DEFAULT_LIMITS} itself when it declares no `influences`, so
+ * nothing about such a mesh changes; otherwise its declared cap (`null` is a count no vertex reaches) and floor form,
+ * with the floor's value {@link MIN_WEIGHT} either way — the declaration chooses the form of the cut, not where it falls.
+ */
+export function meshLimits(declared: MeshInfluences | undefined): InfluenceLimits {
+  if (declared === undefined) return DEFAULT_LIMITS;
+  const cap = declared.maxInfluences;
+  return { maxInfluences: cap === undefined ? MAX_INFLUENCES : cap === null ? Number.MAX_SAFE_INTEGER : cap, minWeight: MIN_WEIGHT, floor: declared.floor ?? 'cut' };
+}
+
 /**
  * The influences on one vertex at `p` (rig pixels), before rounding, under
  * `w = 1/(d + r)^exponent`. The rig stage passes every mesh's exponent
@@ -110,14 +163,19 @@ export function influences(p: Point, segments: readonly Segment[], r: number, li
 
 /**
  * The cap and the floor, on raw per-bone values in first-appearance order: sorted (stable), the top
- * `maxInfluences` normalised, those under `minWeight` dropped, the rest normalised again. The distance rule
- * above and bone heat (`src/heat.ts`, issue #161) both end here, so the two rules share one cap and one floor.
+ * `maxInfluences` normalised, then the floor in its form ({@link FloorForm}) — under `"cut"` those under `minWeight`
+ * dropped, under `"continuous"` `minWeight` subtracted from each and those at or below zero dropped — and the rest
+ * normalised again. The distance rule above and bone heat (`src/heat.ts`, issue #161) both end here, so the two
+ * rules share one cap and one floor.
  */
 export function capAndFloor(raw: ReadonlyArray<readonly [string, number]>, limits: InfluenceLimits): Influence[] {
   const top = [...raw].sort((x, y) => y[1] - x[1]).slice(0, limits.maxInfluences);
   let s = 0;
   for (const [, v] of top) s += v;
-  const kept = top.map(([bone, v]) => ({ bone, weight: v / s })).filter((e) => e.weight >= limits.minWeight);
+  const kept =
+    limits.floor === 'continuous'
+      ? top.map(([bone, v]) => ({ bone, weight: v / s - limits.minWeight })).filter((e) => e.weight > 0)
+      : top.map(([bone, v]) => ({ bone, weight: v / s })).filter((e) => e.weight >= limits.minWeight);
   let s2 = 0;
   for (const e of kept) s2 += e.weight;
   return kept.map((e) => ({ bone: e.bone, weight: e.weight / s2 }));