@rig-c/core 2.83.0 → 2.85.0

package/docs/AUTHORING.md

@@ -9186,7 +9186,7 @@ inside it, and a second copy of the leg on the same bone):
 bun cli.ts render --candidate path/to/spine --animation swing --seam skirt:leg,leg_front:leg [--skin …] [--fps 12]
 # rigc render
 # One seam line per pair, including no gap/no ghost or SKIP, followed by
-# exposure "<slot>" for each named member: frames, worst cell count and box.
+# exposure "<slot>" and joint contact: joined/separated/unavailable frames.
 ```
 
 The skirt swinging off the leg opens background between the leg's right edge and
@@ -9241,6 +9241,33 @@ table's vertices, and the atlas alpha:
   The rectangle controls derive eight real tear cells; a notched branch derives
   sixteen adjacent background cells excluded by this rule, including when both
   kinds occur in the same frame.
+- **jointContact** — a separate observation of **pair material connectivity**,
+  on that same half-opacity texel grid. It requires a setup band and exactly
+  one nonempty edge-connected material component for each named drawing, at
+  both setup and frame. `joined` means the two posed components overlap or
+  share a cell edge; `separated` means their union is disconnected. Sharing
+  only a corner is not edge contact. Every sampled frame is present, including
+  `unavailable` with a reason when a member is absent, the setup band is empty,
+  material is empty or has multiple islands, or a named slot draws multiple
+  fragments. No samples yields an empty list, not a successful observation.
+
+  **Raw gap measures swept support, not certified tearing.** An attached limb
+  can rotate well away from its parent and leave an external crescent of
+  background inside that support: `gap` can be positive while `jointContact`
+  is `joined`. Removing enough proximal material can leave initial overlap but
+  disconnect the same two drawings under the same attachment maps; that is
+  operational material separation, reported as `separated`. This uses no pivot
+  radius, anatomical assumption or new opacity threshold. The synthetic
+  rectangular controls use an independent endpoint set oracle and actual gated
+  builds rendered through both posers.
+
+  Contact does **not** infer anatomical joint intent. A joined pair can have a
+  local notch or hole, including a genuine local tear while other material
+  remains connected; contact cannot classify individual gap cells as harmless
+  background or tearing. A separated pair need not be artistically wrong and
+  can have zero raw gap outside the existing swept support. The grid cannot
+  resolve sub-cell contact. Other skeleton drawings and draw order do not
+  enter this pair-material observation. `unavailable` is never zero or PASS.
 - **ghost** — a cell one piece draws at the frame and the other does not, which
   the drawing piece, carrying it back, lands in the band, and which the other,
   carrying it back, finds neither drawing at the setup pose: the overlap swung
@@ -9336,6 +9363,7 @@ block carries the definitions above in words.
 | `pairs[].ghostA`, `pairs[].ghostB` | object | — | the same `{ frames, spans, worst }` shape for ghost cells drawn by `a` only and `b` only; an empty owner has `frames: []`, `spans: []`, `worst: null` |
 | `pairs[].gapOpen`, `pairs[].gapCovered` | object | — | the same `{ frames, spans, worst }` shape for gap cells with zero or positive rendered skeleton-composite alpha, respectively; an empty kind has `frames: []`, `spans: []`, `worst: null` |
 | `pairs[].exposureA`, `pairs[].exposureB` | object | — | `{ frames, spans, worst }` for the whole named slot’s positive-alpha cells on otherwise zero-alpha skeleton background; measured independently of the band, including SKIP pairs; not part of `opens` or `maxPx` |
+| `pairs[].jointContact.frames[]` | object | seconds for `time` | `{ index, time, status, reason }` for every sampled frame; `status` is `joined`, `separated` or `unavailable`; `reason` is `null` for measured contact and a named explanation for unavailable contact. Independent of raw gap/ghost, `opens` and `maxPx` |
 | `<kind>.frames[]` | hit[] | — | only the frames with a cell of that kind, in frame order |
 | `<kind>.spans[]` | array | — | `<kind>.frames` as runs of consecutive indices: `{ frames: [first, last], times: [first, last], maxPx }` — frame indices, seconds, px |
 | `<kind>.worst` | hit or `null` | — | the frame with the most cells, the earliest on a tie; `null` when none |
@@ -9362,6 +9390,18 @@ Clean stationary/shared-motion pair fields remain unchanged apart from exposure;
 the `reading` legend states the revised definitions. Historical measurements
 above pin their old reader and must not be treated as current measurements.
 
+The subsequent `jointContact` addition preserves **all** existing pair fields,
+raw gap/coverage/ghost/exposure numbers, `opens`, `maxPx` and their definitions.
+It appends one pair field, a legend entry and a contact clause to the printed
+line; `rigc-seam/1` is unchanged. Readers accepting additive keys can keep their
+existing policy. In particular, a consumer using raw `gapOpen` plus an owned
+ghost as its policy still uses those same numbers; adding contact does not
+change that verdict. Adopting material contact as a separate consumer policy
+requires an explicit choice. Readers comparing entire JSON objects or exact
+console lines must account for the added fields and clause. `stays closed` and
+`opens` in the existing clause continue to describe raw gap/ghost; use the
+separate contact clause for operational material separation.
+
 **Refused, nothing written:** a slot the skeleton does not have (with the slots it
 does), an entry without exactly one `:`, an empty entry or name, a slot paired with
 itself (a seam is between two drawings), a pair named twice in either order (the
@@ -12577,7 +12617,7 @@ pixel (`IN09`).
 | What does this bone move? | `--show art,mesh,weights:<bone> --dim` | the bone's weight over every region and mesh it moves, as a heat: a pixel whose centre lies in a triangle is painted the ramp's colour at the blend of its corners' weights — blue near 0, yellow at 0.5, red at 1 (the stops are in the legend) — and a weight of 0 is not painted, so the art shows where the bone does not reach. A region and an unweighted mesh are moved whole by their slot's bone. The weights are read off `skeleton.json`, the file both posers skin from; a bone that weights nothing paints nothing and the run says so on a line of its own |
 | Does this part's edge follow that bone? | `--show art,weights:<bone>,mesh --overlay-slot <part> --zoom slot:<part>` | the part's own triangles and the bone's weight over them alone, over the whole painting. Where slots stack — a neck under the face, the hair, a collar — every mesh crossing the box is drawn and the heat is the union of every slot the bone moves, so the part's edge has no pixel of its own until the others are left out. The legend's `meshes[]` gives the part's weight for the bone at every vertex, so "does the top row follow the head" is read as numbers as well as colour |
 | Is this rig's density where its motion is? | `--show art,density --dim` | each region and mesh filled by its **ratio** — its triangles per world unit² over the figure's — on one ramp, log-scaled and centred on 1×: grey is as dense as the figure, pink to magenta denser (4×, 16×), light to dark green sparser (1/4×, 1/16×), clamped past the end stops (the stops are in the legend). A part's area is its posed mesh's own, the sum of its triangles' areas at the pose drawn, not the image's box; a region is two triangles over its quad. Where parts overlap the pixel is the part drawn last, as in the art, so a part under others is read with `--overlay-slot <part>`. The figure's totals are always over every slot the pose shows — the filter picks what is drawn and listed, never what the figure is — and the legend's `density` gives each slot's attachment, kind, vertices, triangles, hull, area, triangles per area, ratio and the bones it is weighted to, in draw order. A measurement, not a verdict: no bar is drawn, and `A13_MESH_BUDGET` stays the one gate on counts |
-| Does a joint tear in this animation? | `render --seam <a>:<b> --animation <name>` (§8.8) | One line per pair: the frames where background opens inside the joint (gap) or the overlap band of one piece shows past its partner (ghost), with the worst frame's cell count and world box; `seam.json` carries every frame and its time, and the runs of frames. A pair whose drawings never overlap is a SKIP, said by name. A reading, not a verdict — the exit status never moves |
+| Does a pair lose material contact in this animation? | `render --seam <a>:<b> --animation <name>` (§8.8) | Raw swept-support gap and visible ghost counts, plus separate pair material contact: joined, separated or explicitly unavailable. Gap alone is not certified tearing; contact does not infer anatomical intent or rule out local notches. `seam.json` records the frames and times. A reading, not a verdict — the exit status never moves |
 | Which slot covers which in this animation? | `render --overlaps --animation <name>` (§8.9) | One `OVERLAP "<under>" under "<over>"` line per pair that moves: the frames it covers on, as runs, and the most pixels it covers and the frame of them; one line counting the layering the motion does not move. `overlaps.json` carries every frame's pairs with their pixel count and box, and `overlaps-f<NNNN>.png` draws each covered frame's contours, the covered part dashed. A reading, not a verdict — the draw-order key is the remedy |
 | Does anything fold in this animation? | `render --folds --animation <name>` (§8.3), then `inspect --show art,folds,mesh --animation <name> --at <the worst frame's time> --zoom folds` | `render --folds` prints one line per mesh with a triangle turned over against the setup pose: the frames, the worst frame's count, which triangles, their world box at that frame and their setup-pose area. The view fills those triangles at the pose drawn — every pixel whose centre a folded triangle holds — in the colour the legend's `folds` states, and the legend's `folds[]` names, per mesh, the folded triangles by index with the same box and area, and the setup pose's degenerate and inverted ones, which are never counted. A fold is usually a sliver a few units across, invisible in a picture of the whole mesh: `--zoom folds` frames the picture to the folded triangles' box. A thin sliver still needs pixels — raise `--max` when the fill is a line. A reading, not a verdict |
 | How is this part triangulated? | `--show art,mesh,hull --zoom slot:<slot>` | each mesh's triangle edges, and over them its hull — vertex 0 to 1 to … to `hull − 1` and back. Regions are not drawn: a region is not a mesh. The legend lists every vertex in world units and in pixels |
@@ -12752,6 +12792,57 @@ for `declared` and the run says so on a line of its own.
 - **Not a second poser.** Everything it draws is a pose `render` would have drawn at
   the same frame; where it disagrees with `render --geometry`, it is wrong (`IN04`).
 
+### Texture scale — warning-only region reading
+
+```bash
+rigc texture-scale --candidate build/ --json texture-scale.json
+```
+
+`REGION_TEXTURE_MINIFIED` names each drawn region attachment whose **smallest
+sampled draw scale is below 0.5 world units per stored texture pixel**, with its
+slot, attachment, atlas region/page/index, stored texture width and height, and
+the animation and time of that sample (`animation: null`, `time: 0` for setup).
+The strict threshold applies to the measured value: a nominal authored 0.5 can
+read just below 0.5 after runtime transforms and floating-point storage.
+It is a warning, never an assertion or a build refusal. This separate reading
+changes no build, atlas or rendered frame. Scale 1.0 and exactly 0.5 stay silent.
+
+The scale is the smallest singular value of the texture-pixel → world 2×2
+map read from posed region corners and their page UVs. It includes attachment
+size/scale, parent transforms, constraints, rotation, reflection, anisotropy,
+shear, trimming and atlas rotation. Raw bone scale alone cannot give this value.
+The consumer's camera, device pixels and viewport scaling are outside it.
+
+Setup is always read, then every animation under `--skin <name>` (without it,
+no skin is set). `--fps <n>` defaults to 60. The sorted sample schedule combines
+that grid, each timeline's float32 key times, key-interval midpoints and the
+animation endpoint. Physics is stepped along this schedule, using the render
+clock. The JSON (`rigc-texture-scale/1`) records the exact schedule, threshold,
+rate, skin, count of distinct drawn region attachments and `warnings`.
+`--json` must be outside the candidate directory (symlinks are resolved). An
+existing file is replaced only when it is already a `rigc-texture-scale/1`
+report; a source artifact is refused before posing and left byte-identical.
+Text and JSON report the **minimum among these samples**, not a continuous
+minimum: interpolated transforms, shear and constraints can reach narrower
+extrema between them. Increase the rate to investigate; silence is not proof
+that no unsampled extreme exists. A tie keeps the first observation, setup first.
+
+Only selected, active region attachments with positive combined alpha,
+nonempty clipped geometry and a source rectangle containing alpha are read.
+Meshes, unselected attachments, alpha-zero regions and wholly clipped regions
+are excluded. This is a geometric draw reading; it does not test occlusion by
+later slots or whether the visible clipped portion samples only transparent
+texels. The threshold identifies potential minification without mipmaps; it
+does not assert visible dither for every source texture.
+
+**Remedies:** area-downsample the source texture and preserve the region's world
+width and height (and its placement) when rebuilding, or enable mipmaps in the
+consumer. For example, a 730×400 texture drawn at 0.167 can be area-downsampled
+to 122×67 while retaining world dimensions 121.91×66.8; the new draw scale is
+about 1.0. This removes high-frequency aliasing in the planted fixture, not a
+guarantee about arbitrary artwork or every consumer filter. rigc never resizes
+art automatically and this reading changes no atlas mipmap settings.
+
 ## 14. Read a named mesh at setup
 
 `rig-c/core` promises `readSetupMesh(view, target)` and the types

package/package.json

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

package/src/cli/core_commands.ts

@@ -1,3 +1,4 @@
+import { textureScaleReading, textureScaleLines, TEXTURE_SCALE_FPS } from '../texture_scale.ts';
 import { extremesOf, extremesText, extremesPlate, extremesLine, extremesRefusal } from '../extremes.ts';
 /**
  * The bodies of the commands that reach nothing of spine-core — `explain`,
@@ -53,7 +54,7 @@ import { writeWhole } from './write_whole.ts';
 import { GUIDE_FILE, GUIDE_RULE_TABLES_ELSEWHERE, guideAnswer, refusalLine } from '../guide.ts';
 import { ATLAS_ABSENT, COMMANDS, type CommandRun, DelegateError, modelTextBeside, resolveBuild, type BuildGate, runBuild, PACKAGE_ROOT, DEFAULT_CHAINFIT_OUT, DEFAULT_POSE_OUT, DEFAULT_SKILLS_DIR, ExplainError, GuideError, printAlphaClips, meshBudget, meshDepthNote, meshFit, meshInfluenceNote, PAGE_GRID_UNLOCATED, readAnimationFlag, readJsonFile, readPageEdges, readPoserFlag, readSheetFormat, readSkeletonText, readVersion, resolveCut, resolveDrawable, runCheck, SkillsInstallError, STAGELESS_FRAMING, UsageError, writeJson, documentStageBeside } from './shared.ts';
 import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, realpathSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
-import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { spawnSync } from 'node:child_process';
 
 
@@ -1254,6 +1255,40 @@ export function physicsLine(stepped: readonly string[], declared: readonly strin
   return `${head} — ${idle.length} of the ${declared.length} declared took none: ${idle.map((n) => JSON.stringify(n)).join(', ')} (${why})`;
 }
 
+/** Warning-only reading, independent of build and of raster output. */
+export function cmdTextureScale(flags: Record<string, string>): void {
+  const accepted = ['candidate', 'atlas', 'skin', 'fps', 'poser', 'json', 'help'];
+  const stray = Object.keys(flags).filter(k => !accepted.includes(k));
+  if (stray.length > 0) throw new UsageError(`texture-scale takes no --${stray.join(', --')}; use texture-scale --help`);
+  if (flags.candidate === undefined) throw new UsageError('texture-scale needs --candidate <dir | skeleton.json>');
+  const fps = readPositiveNumber(flags, 'fps', TEXTURE_SCALE_FPS, 1);
+  const { skeletonPath, atlasPath, atlasText } = resolveDrawable(flags.candidate, flags.atlas);
+  if (flags.json !== undefined) {
+    const target = realpathAhead(flags.json);
+    const within = relative(realpathSync(dirname(skeletonPath)), target);
+    if (within === '' || (within !== '..' && !within.startsWith(`..${sep}`) && !isAbsolute(within))) {
+      throw new UsageError('--json must name a report outside the candidate directory; texture-scale never writes into a build');
+    }
+    if (existsSync(target)) {
+      let isReport = false;
+      if (statSync(target).isFile()) {
+        try { isReport = (JSON.parse(readFileSync(target, 'utf8')) as { spec?: unknown }).spec === 'rigc-texture-scale/1'; } catch { /* An existing non-report is never replaced. */ }
+      }
+      if (!isReport) throw new UsageError('--json target exists and is not a rigc-texture-scale/1 report; name a new file outside the candidate directory');
+    }
+  }
+  const skeletonText = readSkeletonText(skeletonPath);
+  const candidate = loadCandidate({ skeletonText, atlasText, atlasDir: dirname(atlasPath), label: skeletonPath },
+    { skeleton: skeletonPath, atlas: atlasPath }, posersAsked(flags));
+  readPoserFlag(flags);
+  const skin = readSkinFlag(flags, [...candidate.facts.skins]);
+  refuseUnchosen(candidate.choice);
+  const read = throughPoser(candidate.choice, poser => textureScaleReading(poser, candidate.pages, skeletonText, fps, skin));
+  console.log(`poser: ${read.note}`);
+  for (const line of textureScaleLines(read.value.report)) console.log(line);
+  if (flags.json !== undefined) writeJson(flags.json, read.value.report);
+}
+
 /** Where `inspect` writes when `--out` is not given, and the name it takes inside a directory `--out` names. */
 export const DEFAULT_INSPECT_OUT = 'inspect.png';
 
@@ -2679,6 +2714,7 @@ export const CORE_COMMAND_RUNS: Readonly<Record<string, CommandRun>> = {
   check: ({ flags }) => cmdCheck(flags),
   render: ({ flags }) => cmdRender(flags),
   inspect: ({ flags }) => cmdInspect(flags),
+  'texture-scale': ({ flags }) => cmdTextureScale(flags),
   pose: ({ flags }) => cmdPose(flags),
   chainfit: ({ flags }) => cmdChainFit(flags),
   guide: ({ flags, positional }) => cmdGuide(flags, positional),

package/src/cli/shared.ts

@@ -1073,7 +1073,7 @@ const FLAG_MEANINGS: Record<string, string> = {
     'per pair, the frames with a gap — background inside the carried overlap hull and a local sweep of the same setup band cell through both drawings — ' +
     'and the frames with a visible ghost after draw order — the band of one drawing showing where, from its partner\'s point of view, nothing was drawn at the setup pose — each with ' +
     `its cell count, area and world box. Cells are one texel of the coarser drawing, drawn at ${DRAWN_ALPHA} of 255 or more. One line per pair; a pair whose ` +
-    'drawings share no cell at the setup pose is a SKIP. exposureA/B count each named slot’s positive-alpha cells on otherwise empty skeleton background, even without a band or partner. A reading, not a gate: the exit status never moves. An unknown slot, a slot with itself, ' +
+    'drawings share no cell at the setup pose is a SKIP. Raw gap measures swept support, not certified tearing. jointContact separately reports pair material connectivity: joined, separated, or unavailable with a reason; it does not infer anatomical joint intent or rule out local notches. exposureA/B count each named slot’s positive-alpha cells on otherwise empty skeleton background, even without a band or partner. A reading, not a gate: the exit status never moves. An unknown slot, a slot with itself, ' +
     'a slot that draws on no frame, a malformed list and a pair named twice in either order are refused by name. Not with --slot/--hide',
   'angle-range':
     'also read, for each <bone>:<relative-to> pair, the range of the first bone\'s world direction against the second\'s over each set\'s ' +
@@ -1800,6 +1800,18 @@ export const COMMANDS: CommandDoc[] = [
       },
     },
   },
+  {
+    name: 'texture-scale',
+    runtime: false,
+    spineFormat: false,
+    usage: ['rigc texture-scale --candidate <dir | skeleton.json> [--skin <name>] [--fps 60] [--poser core|spine] [--json <out>]'],
+    flags: ['candidate', 'atlas', 'skin', 'fps', 'poser', 'json'],
+    overrides: {
+      fps: { meaning: 'sample setup and every animation at this rate (default 60), also including float32 key times, key-interval midpoints and endpoints; reports sampled minima, never continuous extrema' },
+      json: { meaning: 'write the report outside the candidate directory; an existing file is replaced only if it is a rigc-texture-scale/1 report' },
+    },
+    notes: ['REGION_TEXTURE_MINIFIED is a warning only: smallest singular value of texture-pixel to world map < 0.5. Names the region, texture size and sampled minimum with animation/time. Skips unselected, transparent and fully clipped regions; no occlusion or consumer camera test. Never changes a build. See docs/AUTHORING.md, Texture scale.'],
+  },
   {
     name: 'inspect',
     runtime: false,

package/src/render.ts

@@ -503,7 +503,7 @@ export function spinePoser(data: SkeletonData): Poser {
     slots: data.slots.map((slot) => ({ name: slot.name, bone: slot.boneData.name })),
     subset: (opts, skin) => slotSubsetOf(data, opts, skin),
     setup: (skin) => spinePosed(setupPosed(data, skin)),
-    animation: (name, skin, fps, count, visit, environment) => {
+    animation: (name, skin, fps, count, visit, environment, _channels, times) => {
       const skeleton = skeletonUnderSkin(data, skin);
       const state = new AnimationState(new AnimationStateData(data));
       // Not looping: the last frame sits at the animation's duration, and a looping
@@ -516,10 +516,11 @@ export function spinePoser(data: SkeletonData): Poser {
       const posed = spinePosed(skeleton);
       for (let i = 0; i <= count; i++) {
         if (i > 0) {
-          state.update(step);
+          const delta = times === undefined ? step : times[i] - times[i - 1];
+          state.update(delta);
           state.apply(skeleton);
           setSkeletonEnvironment(skeleton, environment?.(i));
-          skeleton.update(clock);
+          skeleton.update(times === undefined ? clock : physicsClockStep(delta));
           skeleton.updateWorldTransform(Physics.update);
         } else {
           state.apply(skeleton);
@@ -723,7 +724,7 @@ function drawPieces(skeleton: Skeleton, draw: DrawOptions): Piece[] {
       continue;
     }
     const drawn = subset === undefined || named === undefined || named.has(slot.data.name) === (subset.mode === 'slots');
-    const piece = drawn ? pieceOf(skeleton, slot, draw.texture, clipper) : null;
+    const piece = drawn ? pieceOf(skeleton, slot, draw.texture, clipper, draw.regionInfo) : null;
     if (piece !== null) pieces.push(piece);
     clipper?.clipEnd(slot);
   }
@@ -743,6 +744,7 @@ function pieceOf(
   slot: Slot,
   withTexture: boolean,
   clipper: SkeletonClipping | null,
+  withRegionInfo = false,
 ): Piece | null {
   const pose = slot.appliedPose;
   const attachment = pose.attachment;
@@ -765,7 +767,9 @@ function pieceOf(
   const darkPose = pose.darkColor;
   const dark: [number, number, number] | undefined =
     darkPose === null ? undefined : [darkPose.r, darkPose.g, darkPose.b];
-  const common = { tint, dark, slot: slot.data.name, page: region.page.name };
+  const common = { tint, dark, slot: slot.data.name, page: region.page.name,
+    ...(withRegionInfo && !isMesh ? { regionInfo: { attachment: attachment.name, region: region.name, index: region.index, width: region.width, height: region.height } } : {}),
+  };
   const texture = withTexture ? artUvsOf(attachment, region) : undefined;
   const uvs = attachment.sequence.getUVs(index);
 

package/src/render_core.ts

@@ -557,7 +557,9 @@ function pieces(
     const atlasRegion = draw.texture ? input.region(found.region) : null;
     if (draw.texture && atlasRegion === null) throw new CoreInputError(`slot "${d.slot}": atlas region "${found.region}" is not in the atlas`);
     const texture = atlasRegion === null ? undefined : artUvsOf(d, atlasRegion);
-    const common = { tint: tintOf(d), dark: darkOf(d), slot: d.slot, page: found.found.page.name };
+    const common = { tint: tintOf(d), dark: darkOf(d), slot: d.slot, page: found.found.page.name,
+      ...(draw.regionInfo && d.kind === 'region' ? { regionInfo: { attachment: d.attachment, region: found.region, index: input.region(found.region)?.index ?? -1, width: found.found.region.width, height: found.found.region.height } } : {}),
+    };
     const world = [...d.vertices];
     const piece: Piece =
       d.kind === 'mesh'
@@ -782,7 +784,7 @@ export function corePoser(
       const pose = poseRawSetup(input.doc, { through, ...observe });
       return corePosed(input, pose, through, [], values);
     },
-    animation: (name, skin, fps, count, visit, environment, channels) => {
+    animation: (name, skin, fps, count, visit, environment, channels, times) => {
       let values: ChannelValue[] | undefined;
       const observe = channels ? { readLocals: (bones: readonly import('./model.ts').ModelBone[], sliders: readonly import('./core/constraints_slider.ts').SliderApplication[]) => { values = localChannels(bones, sliders); } } : {};
       const input = inputOf(skin);
@@ -802,7 +804,7 @@ export function corePoser(
         if (ctx.time > 0 && ctx.states.get(r.name)?.lastTime === ctx.time) steppedNow.add(r.name);
         return moved;
       };
-      walk(input.doc, name, new Array<number>(count).fill(step), { through, physicsStep, ...observe }, (pose, i) => {
+      walk(input.doc, name, times === undefined ? new Array<number>(count).fill(step) : times.slice(1).map((t, i) => t - times[i]), { through, physicsStep, ...observe }, (pose, i) => {
         const stepped = [...steppedNow].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
         steppedNow.clear();
         if (drawFailed.length > 0) return;

package/src/render_shared.ts

@@ -324,6 +324,8 @@ export interface PinnedViewport {
 
 /** What every drawable has in common, whatever shape it is. */
 export interface PieceCommon {
+  /** Opt-in atlas identity for texture-scale; absent on ordinary renders. */
+  regionInfo?: { attachment: string; region: string; index: number; width: number; height: number };
   /**
    * World-space vertex positions, `x, y` per vertex.
    *
@@ -1101,6 +1103,8 @@ function coreFacts(skeletonText: string, atlasText: string | null, poser: Poser,
 
 /** What a sampler hands a posed frame's draw walk — `PoseOptions` with the subset already resolved. */
 export interface DrawOptions {
+  /** Texture-scale only: atlas identity and stored texture size on whole regions. */
+  regionInfo?: boolean;
   /** The slots drawn, resolved against the posed skeleton (`slotSubsetOf`); `undefined` draws every slot. */
   subset: SlotSubset | undefined;
   /** Every attachment whole, no clip applied — the framing box's reading. */
@@ -1159,8 +1163,11 @@ export interface Poser {
    * `i` from 0 to `count`, the pose at `i/fps`. The caller has checked `name`.
    * `environment(i)`, when given, is the change to the world the physics
    * answers set before the step that poses frame `i` (issue #1416).
+   * Optional `times` replaces the uniform grid with increasing absolute times
+   * starting at 0 (count = times.length - 1), stepped by adjacent differences.
+   * Used by texture-scale to include key times; ordinary renders are unchanged.
    */
-  animation(name: string, skin: string | undefined, fps: number, count: number, visit: (index: number, posed: Posed) => void, environment?: (index: number) => EnvironmentChange | undefined, channels?: boolean): void;
+  animation(name: string, skin: string | undefined, fps: number, count: number, visit: (index: number, posed: Posed) => void, environment?: (index: number) => EnvironmentChange | undefined, channels?: boolean, times?: readonly number[]): void;
   /** The rest table for the (slot, attachment) pairs `shown` holds — see `AttachmentRest`. */
   rest(skin: string | undefined, shown: readonly AttachmentPose[][]): AttachmentRest[];
 }

package/src/seam.ts

@@ -63,6 +63,13 @@
  * Shared transforms read closed. The outer-hull reach remains bounded: tears
  * outside the transported setup overlap are not certified absent by a zero.
  *
+ * `jointContact` separately observes material connectivity on that same grid.
+ * Initially overlapping, single-component drawings are joined if their posed
+ * union is edge-connected, separated otherwise. Missing bands or non-single
+ * components are unavailable. Joined does not rule out local holes or notches;
+ * separated does not infer artistic intent. Raw gap can include an external
+ * rotational crescent of a joined pair and is deliberately unchanged.
+ *
  * Pure: no clock, no randomness, no runtime. The pieces, the attachments and the
  * rest table are handed in by whichever poser drew the frames.
  */
@@ -159,6 +166,15 @@ export interface SeamKindReading {
   worst: SeamHit | null;
 }
 
+/** Connectivity of two initially overlapping single material components, at grid resolution. */
+export interface SeamContactFrame {
+  index: number;
+  time: number;
+  status: 'joined' | 'separated' | 'unavailable';
+  /** Non-null exactly when the observation is unavailable; never a measured zero. */
+  reason: string | null;
+}
+
 /** One pair's reading over one frame set. */
 export interface SeamPairReading {
   a: string;
@@ -186,6 +202,8 @@ export interface SeamPairReading {
   /** Positive-alpha cells contributed by the named slot where all OTHER slots have zero alpha. Independent of the band. */
   exposureA: SeamKindReading;
   exposureB: SeamKindReading;
+  /** Every sampled frame, including unavailable frames. Independent of raw gap/ghost and their summaries. */
+  jointContact: { frames: SeamContactFrame[] };
 }
 
 /** `seam.json`: one frame set's reading, every pair the flag names, in the flag's order. */
@@ -196,7 +214,7 @@ export interface SeamFile {
   skin?: string;
   fps: number;
   /** What the numbers mean, stated in the file so a reader does not need this module. */
-  reading: { read: string; cell: string; drawn: string; band: string; carried: string; gap: string; ghost: string; box: string; status: string; ghostA: string; ghostB: string; gapOpen: string; gapCovered: string; exposureA: string; exposureB: string };
+  reading: { read: string; cell: string; drawn: string; band: string; carried: string; gap: string; ghost: string; box: string; status: string; ghostA: string; ghostB: string; gapOpen: string; gapCovered: string; exposureA: string; exposureB: string; jointContact: string };
   pairs: SeamPairReading[];
 }
 
@@ -219,6 +237,8 @@ export interface SeamPlant {
   hiddenGhost?: boolean;
   /** Bridge unrelated overlap cells with the old global hull. */
   globalHull?: boolean;
+  /** Force a measured contact to one answer, ignoring the rendered material. */
+  contact?: 'joined' | 'separated';
   /** Wrong composite readings: half opacity, only the pair, or every gap forced to one kind. */
   gapCoverage?: 'half' | 'pair' | 'open' | 'covered';
   /** Report a pair with no band as read, rather than as a SKIP. */
@@ -473,8 +493,44 @@ function markHull(hull: ReadonlyArray<[number, number]>, grid: Grid, cells: Uint
   }
 }
 
+/** Count edge-connected components, stopping after the second: only exactly one is supported. */
+function components(cells: Uint8Array, width: number): number {
+  const seen = new Uint8Array(cells.length);
+  const queue = new Int32Array(cells.length);
+  let count = 0;
+  for (let k = 0; k < cells.length; k++) {
+    if (!cells[k] || seen[k]) continue;
+    if (++count === 2) return count;
+    let head = 0, tail = 1;
+    queue[0] = k; seen[k] = 1;
+    while (head < tail) {
+      const i = queue[head++];
+      const visit = (j: number): void => {
+        if (j >= 0 && j < cells.length && cells[j] && !seen[j]) { seen[j] = 1; queue[tail++] = j; }
+      };
+      if (i % width > 0) visit(i - 1);
+      if (i % width < width - 1) visit(i + 1);
+      visit(i - width); visit(i + width);
+    }
+  }
+  return count;
+}
+
+type Contact = Pick<SeamContactFrame, 'status' | 'reason'>;
+const unavailableContact = (reason: string): Contact => ({ status: 'unavailable', reason });
+
+/** Four neighbours mean a shared cell edge; diagonals alone do not connect material. No distance parameter. */
+function contactOf(restA: Uint8Array, restB: Uint8Array, drawnA: Uint8Array, drawnB: Uint8Array, width: number, plant: SeamPlant): Contact {
+  for (const [name, cells] of [['a setup', restA], ['b setup', restB], ['a frame', drawnA], ['b frame', drawnB]] as const) {
+    const n = components(cells, width);
+    if (n !== 1) return unavailableContact(`${name}: ${n === 0 ? 'no' : 'multiple'} edge-connected half-opacity material components; exactly one is required`);
+  }
+  const union = drawnA.map((v, k) => v || drawnB[k]);
+  return { status: plant.contact ?? (components(union, width) === 1 ? 'joined' : 'separated'), reason: null };
+}
+
 /** One frame's counts, or `null` when the two drawings share no cell at the setup pose. See the module comment. */
-function readFrame(A: Side, B: Side, cell: number, plant: SeamPlant, frame: SeamFrame, pages: ReadonlyMap<string, Plate>, grid: Grid, visibility: readonly Uint8Array[]): { gap: Cells; ghost: Cells; ghostA: Cells; ghostB: Cells; gapOpen: Cells; gapCovered: Cells } | null {
+function readFrame(A: Side, B: Side, cell: number, plant: SeamPlant, frame: SeamFrame, pages: ReadonlyMap<string, Plate>, grid: Grid, visibility: readonly Uint8Array[]): { gap: Cells; ghost: Cells; ghostA: Cells; ghostB: Cells; gapOpen: Cells; gapCovered: Cells; contact: Contact } | null {
   const { width, height } = grid.viewport;
   const restA = restPiece(A);
   const restB = restPiece(B);
@@ -520,6 +576,7 @@ function readFrame(A: Side, B: Side, cell: number, plant: SeamPlant, frame: Seam
   const hull = hullOf(carried);
   const drawnA = drawnCells(A.piece, A.page, grid.viewport);
   const drawnB = drawnCells(B.piece, B.page, grid.viewport);
+  const contact = contactOf(bandA, bandB, drawnA, drawnB, width, plant);
   const [visibleA, visibleB] = visibility;
   const posedIdsA = triangleIds(A.triangles, A.piece.world, grid);
   const posedIdsB = triangleIds(B.triangles, B.piece.world, grid);
@@ -536,7 +593,7 @@ function readFrame(A: Side, B: Side, cell: number, plant: SeamPlant, frame: Seam
   const gapCovered: Cells = { px: 0, box: null };
   let alphaCells: Uint8Array | null = null;
   const take = (into: Cells, qx: number, qy: number): void => takeCell(into, qx, qy, cell);
-  if (plant.never) return { gap, ghost, ghostA, ghostB, gapOpen, gapCovered };
+  if (plant.never) return { gap, ghost, ghostA, ghostB, gapOpen, gapCovered, contact };
   const inBand = (p: [number, number] | null): boolean => p !== null && p[0] >= bx0 - cell / 2 && p[0] <= bx1 + cell / 2 && p[1] >= by0 - cell / 2 && p[1] <= by1 + cell / 2;
   for (let py = 0; py < height; py++) {
     for (let px = 0; px < width; px++) {
@@ -570,7 +627,7 @@ function readFrame(A: Side, B: Side, cell: number, plant: SeamPlant, frame: Seam
       }
     }
   }
-  return { gap, ghost, ghostA, ghostB, gapOpen, gapCovered };
+  return { gap, ghost, ghostA, ghostB, gapOpen, gapCovered, contact };
 }
 
 const restKey = (slot: string, attachment: string): string => `${slot}\u0000${attachment}`;
@@ -634,9 +691,12 @@ export function seamsOf(
     const openGaps: SeamHit[] = [];
     const coveredGaps: SeamHit[] = [];
     const exposuresA: SeamHit[] = [], exposuresB: SeamHit[] = [];
+    const contacts: SeamContactFrame[] = [];
     for (const frame of frames) {
       const A = sideOf(frame, a);
       const B = sideOf(frame, b);
+      const contact = (reading: Contact): void => { contacts.push({ index: frame.index, time: frame.time, ...reading }); };
+      if (A === null || B === null) contact(unavailableContact('both named slots must draw on this frame'));
       const sides = [A, B].filter((side): side is Side => side !== null);
       if (sides.length === 0) continue;
       const sizes = sides.map((side) => texelSize(side.piece, side.rest, side.page));
@@ -652,7 +712,9 @@ export function seamsOf(
       drawn++;
       const cell = exposureCell;
       const read = readFrame(A, B, cell, plant, frame, pages, exposureGrid, exposure.map((m) => m.visible));
-      if (read === null) continue;
+      if (read === null) { contact(unavailableContact('no shared half-opacity cell at the setup pose; no band to identify a joint')); continue; }
+      const fragmented = [a, b].some(slot => frame.pieces.filter(p => p.slot === slot).length !== 1);
+      contact(fragmented ? unavailableContact('each named slot must draw exactly one fragment for material contact') : read.contact);
       banded++;
       for (const [cells, into] of [[read.gap, gaps], [read.ghost, ghosts], [read.ghostA, ghostsA], [read.ghostB, ghostsB], [read.gapOpen, openGaps], [read.gapCovered, coveredGaps]] as const) {
         if (cells.px > 0 && cells.box !== null) into.push({ index: frame.index, time: frame.time, px: cells.px, cell, area: cells.px * cell * cell, box: cells.box });
@@ -663,7 +725,7 @@ export function seamsOf(
     const opens = [...new Set([...gaps, ...ghosts].map((f) => f.index))].sort((x, y) => x - y);
     const maxPx = Math.max(0, ...gaps.map((f) => f.px), ...ghosts.map((f) => f.px));
     const status = banded === 0 && !plant.skipAsRead ? 'skip' : 'read';
-    return { a, b, drawn, banded, status, opens, maxPx, gap, ghost, ghostA: kindOf(ghostsA), ghostB: kindOf(ghostsB), gapOpen: kindOf(openGaps), gapCovered: kindOf(coveredGaps), exposureA: kindOf(exposuresA), exposureB: kindOf(exposuresB) };
+    return { a, b, drawn, banded, status, opens, maxPx, gap, ghost, ghostA: kindOf(ghostsA), ghostB: kindOf(ghostsB), gapOpen: kindOf(openGaps), gapCovered: kindOf(coveredGaps), exposureA: kindOf(exposuresA), exposureB: kindOf(exposuresB), jointContact: { frames: contacts } };
   });
 }
 
@@ -685,6 +747,7 @@ export const SEAM_READING: SeamFile['reading'] = {
   exposureA: 'positive-rendered-alpha cells from named slot a where removing every fragment of that slot leaves alpha 0 from all other skeleton slots, regardless of draw order; measured over the whole drawing even without a seam band or partner; same hit, span and worst units as gap',
   exposureB: 'the same background exposure for named slot b; swapping the pair exchanges exposureA and exposureB; exposure does not enter opens or maxPx and is not a change-from-setup measurement',
   gapCovered: 'the gap cells whose centre has positive rendered alpha from any skeleton drawing, including the pair; alpha 1..127 covers too — this is not the pair\'s half-opacity test, and no presentation background enters',
+  jointContact: 'every sampled frame: joined or separated only when a setup band exists and each named drawing has exactly one edge-connected half-opacity material component at setup and frame; joined means their frame union is edge-connected (overlap or shared cell edge), separated means it is not; diagonal contact alone is separated. Otherwise unavailable with a reason, including multiple fragments of a named slot. Uses the existing origin-aligned texel grid, alpha and attachment maps, independent of other slots and draw order. Raw gap measures swept support, not certified tearing. Contact is pair material connectivity, not anatomical joint intent; joined does not rule out local holes/notches. No statement about sub-cell contact; raw gap/ghost, opens/maxPx and exit status are unchanged',
 };
 
 /** The file for one frame set. */
@@ -730,5 +793,12 @@ function seamSummary(animation: string | null, fps: number, pair: SeamPairReadin
 
 /** The seam summary plus whole-drawing background exposures, including on SKIP pairs. */
 export function seamLine(animation: string | null, fps: number, pair: SeamPairReading): string {
-  return `${seamSummary(animation, fps, pair)}; ${kindText(`exposure ${JSON.stringify(pair.a)}`, pair.exposureA)}; ${kindText(`exposure ${JSON.stringify(pair.b)}`, pair.exposureB)}`;
+  const contacts = pair.jointContact.frames;
+  const contactText = contacts.length === 0 ? 'unavailable: no sampled frames' : null;
+  const summary = (status: SeamContactFrame['status']): string => {
+    const frames = contacts.filter(f => f.status === status);
+    return `${status} on ${frames.length} frame(s) [${indexRuns(frames.map(f => f.index))}]`;
+  };
+  const reasons = [...new Set(contacts.flatMap(f => f.reason === null ? [] : [f.reason]))];
+  return `${seamSummary(animation, fps, pair)}; ${kindText(`exposure ${JSON.stringify(pair.a)}`, pair.exposureA)}; ${kindText(`exposure ${JSON.stringify(pair.b)}`, pair.exposureB)}; joint contact: ${contactText ?? `${summary('joined')}, ${summary('separated')}, ${summary('unavailable')}`}${reasons.length ? ` (${reasons.join('; ')})` : ''}`;
 }

package/src/texture_scale.ts

@@ -0,0 +1,153 @@
+/** Warning-only region minification, in world units per stored texture pixel. */
+import type { Piece, Poser, Posed } from './render_shared.ts';
+import type { Plate } from '../tools/plate.ts';
+import { walkTimelines } from './timelines.ts';
+import { hypot2 } from './numeric.ts';
+
+export const TEXTURE_SCALE_WARNING = 'REGION_TEXTURE_MINIFIED';
+export const TEXTURE_SCALE_THRESHOLD = 0.5;
+export const TEXTURE_SCALE_FPS = 60;
+export const TEXTURE_SCALE_LIMIT =
+  'Minimum among sampled poses only: grid + float32 key times + key-interval midpoints + endpoint; ' +
+  'interpolated scale/shear/constraints can have smaller extrema between samples. ' +
+  'World units per texture pixel, before consumer camera/viewport; no occlusion test.';
+
+export interface RegionScale {
+  slot: string;
+  attachment: string;
+  region: string;
+  index: number;
+  page: string;
+  texture: { width: number; height: number };
+  smallestSampledScale: number;
+  animation: string | null;
+  time: number;
+}
+export interface TextureScaleReport {
+  spec: 'rigc-texture-scale/1';
+  threshold: number;
+  fps: number;
+  skin: string | null;
+  sampling: string;
+  samples: Array<{ animation: string | null; times: number[] }>;
+  drawnRegions: number;
+  warnings: Array<RegionScale & { name: typeof TEXTURE_SCALE_WARNING }>;
+}
+
+/** Stable 2x2 sigma-min: |det| / sigma-max avoids subtracting nearly equal eigenvalues. */
+export function smallestSingularValue(a: number, b: number, c: number, d: number): number {
+  const scale = Math.max(Math.abs(a), Math.abs(b), Math.abs(c), Math.abs(d));
+  if (scale === 0) return 0;
+  a /= scale; b /= scale; c /= scale; d /= scale;
+  const sum = a * a + b * b + c * c + d * d;
+  const disc = hypot2(a * a + c * c - b * b - d * d, 2 * (a * b + c * d));
+  return scale * Math.abs(a * d - b * c) / Math.sqrt((sum + disc) / 2);
+}
+
+/** Texel-space affine map from three corresponding quad corners; includes trim, rotation, reflection and shear. */
+export function regionDrawScale(piece: Piece, page: Pick<Plate, 'width' | 'height'>): number {
+  const [x0, y0, x1, y1, x2, y2] = piece.world;
+  const u0 = piece.uvs[0] * page.width, v0 = piece.uvs[1] * page.height;
+  const u1 = piece.uvs[2] * page.width - u0, v1 = piece.uvs[3] * page.height - v0;
+  const u2 = piece.uvs[4] * page.width - u0, v2 = piece.uvs[5] * page.height - v0;
+  const det = u1 * v2 - u2 * v1;
+  if (det === 0) throw new Error(`slot ${JSON.stringify(piece.slot)}: region has a singular texture rectangle`);
+  return smallestSingularValue(
+    ((x1 - x0) * v2 - (x2 - x0) * v1) / det,
+    ((x2 - x0) * u1 - (x1 - x0) * u2) / det,
+    ((y1 - y0) * v2 - (y2 - y0) * v1) / det,
+    ((y2 - y0) * u1 - (y1 - y0) * u2) / det,
+  );
+}
+
+/** A schedule, not an extrema solver. Key times use the same float32 storage as the poser. */
+export function textureScaleTimes(skeletonText: string, animation: string, duration: number, fps: number): number[] {
+  if (!Number.isFinite(fps) || fps < 1) throw new Error(`texture-scale fps ${fps}: expected a finite number >= 1`);
+  const root = JSON.parse(skeletonText) as { animations?: Record<string, unknown> };
+  const keys = new Set<number>([0, duration]);
+  walkTimelines({ animations: { [animation]: root.animations?.[animation] } }, (_p, _k, _n, rows) => {
+    for (const row of rows) {
+      const t = Math.fround((row as { time?: number }).time ?? 0);
+      if (Number.isFinite(t) && t >= 0 && t <= duration) keys.add(t);
+    }
+  });
+  const sorted = [...keys].sort((a, b) => a - b);
+  const times = new Set(sorted);
+  for (let i = 1; i < sorted.length; i++) times.add((sorted[i - 1] + sorted[i]) / 2);
+  for (let i = 0; i / fps < duration; i++) times.add(i / fps);
+  return [...times].sort((a, b) => a - b);
+}
+
+/** Has a submitted triangle of positive area; fully clipped or collapsed geometry draws nothing. */
+function hasArea(p: Piece): boolean {
+  const ts = p.kind === 'region' ? [0, 1, 2, 2, 3, 0] : p.triangles;
+  for (let i = 0; i < ts.length; i += 3) {
+    const a = ts[i] * 2, b = ts[i + 1] * 2, c = ts[i + 2] * 2;
+    if (Math.abs((p.world[b] - p.world[a]) * (p.world[c + 1] - p.world[a + 1]) -
+      (p.world[b + 1] - p.world[a + 1]) * (p.world[c] - p.world[a])) > 0) return true;
+  }
+  return false;
+}
+
+/** Excludes wholly transparent source rectangles; no per-frame raster or screen-space occlusion claim. */
+function hasAlpha(piece: Piece, page: Plate): boolean {
+  const us = [0, 2, 4, 6].map(i => piece.uvs[i] * page.width);
+  const vs = [1, 3, 5, 7].map(i => piece.uvs[i] * page.height);
+  const x0 = Math.max(0, Math.round(Math.min(...us))), x1 = Math.min(page.width, Math.round(Math.max(...us)));
+  const y0 = Math.max(0, Math.round(Math.min(...vs))), y1 = Math.min(page.height, Math.round(Math.max(...vs)));
+  for (let y = y0; y < y1; y++) for (let x = x0; x < x1; x++) if (page.data[(y * page.width + x) * 4 + 3] > 0) return true;
+  return false;
+}
+
+/** Streaming read: setup first, then animations in declaration order; ties keep the first observation. Never emits a build. */
+export function textureScaleReading(poser: Poser, pages: Map<string, Plate>, skeletonText: string, fps = TEXTURE_SCALE_FPS, skin?: string): { report: TextureScaleReport; regions: RegionScale[] } {
+  if (!Number.isFinite(fps) || fps < 1) throw new Error(`texture-scale fps ${fps}: expected a finite number >= 1`);
+  const readings = new Map<string, RegionScale>();
+  const slotBones = new Map(poser.slots.map(s => [s.name, s.bone]));
+  const alpha = new Map<string, boolean>();
+  const samples: TextureScaleReport['samples'] = [{ animation: null, times: [0] }];
+  const visit = (pose: Posed, animation: string | null, time: number): void => {
+    const unposed = new Set(pose.bones().filter(b => b.a === 0 && b.b === 0 && b.c === 0 && b.d === 0).map(b => b.name));
+    const drawn = new Map(pose.pieces({ subset: undefined, unclipped: false, texture: false }).map(p => [p.slot, p]));
+    for (const whole of pose.pieces({ subset: undefined, unclipped: true, texture: false, regionInfo: true })) {
+      if (unposed.has(slotBones.get(whole.slot) ?? '')) continue;
+      if (whole.kind !== 'region' || whole.regionInfo === undefined || !(whole.tint[3] > 0)) continue;
+      const visible = drawn.get(whole.slot);
+      if (visible === undefined || !hasArea(visible)) continue;
+      const info = whole.regionInfo;
+      const page = pages.get(whole.page);
+      if (page === undefined) throw new Error(`region ${JSON.stringify(info.region)}: page ${JSON.stringify(whole.page)} is absent`);
+      const key = JSON.stringify([whole.slot, info.attachment, whole.page, info.region, info.index]);
+      const sourceAlpha = alpha.get(key) ?? hasAlpha(whole, page);
+      alpha.set(key, sourceAlpha);
+      if (!sourceAlpha) continue;
+      const scale = regionDrawScale(whole, page);
+      if (!Number.isFinite(scale)) throw new Error(`region ${JSON.stringify(info.region)} at ${animation ?? 'setup'} t=${time}: draw scale ${scale} is not finite`);
+      const old = readings.get(key);
+      if (old === undefined || scale < old.smallestSampledScale) readings.set(key, {
+        slot: whole.slot, attachment: info.attachment, region: info.region, index: info.index, page: whole.page,
+        texture: { width: info.width, height: info.height }, smallestSampledScale: scale, animation, time,
+      });
+    }
+  };
+  visit(poser.setup(skin), null, 0);
+  for (const a of poser.animations) {
+    const times = textureScaleTimes(skeletonText, a.name, a.duration, fps);
+    samples.push({ animation: a.name, times });
+    poser.animation(a.name, skin, fps, times.length - 1, (i, posed) => visit(posed, a.name, times[i]), undefined, false, times);
+  }
+  const regions = [...readings.values()];
+  return { regions, report: {
+    spec: 'rigc-texture-scale/1', threshold: TEXTURE_SCALE_THRESHOLD, fps, skin: skin ?? null, sampling: TEXTURE_SCALE_LIMIT,
+    samples, drawnRegions: regions.length,
+    warnings: regions.filter(r => r.smallestSampledScale < TEXTURE_SCALE_THRESHOLD).map(r => ({ name: TEXTURE_SCALE_WARNING, ...r })),
+  } };
+}
+
+export function textureScaleLines(report: TextureScaleReport): string[] {
+  return [
+    `texture-scale: ${report.warnings.length} warning(s) / ${report.drawnRegions} drawn region attachment(s), threshold < ${report.threshold}, ${report.fps} fps + keys/midpoints/endpoints`,
+    report.sampling,
+    ...report.warnings.map(r => `WARN ${r.name}: region ${JSON.stringify(r.region)} slot ${JSON.stringify(r.slot)} attachment ${JSON.stringify(r.attachment)} texture ${r.texture.width}x${r.texture.height}, smallest sampled draw scale ${r.smallestSampledScale.toFixed(6)} at ${r.animation === null ? 'setup' : JSON.stringify(r.animation)} t=${r.time}s`),
+  ];
+}