@rig-c/review 0.8.1 → 0.10.0

package/src/baseline.ts

@@ -13,6 +13,7 @@ import { isProducerFile, PRODUCER_DOCUMENTS, PRODUCER_IMAGES_DIR } from './produ
 import { firstRefusal, runTool, type InstalledTool } from './producer.ts';
 import { checkSummary, MAX_DIFF_PATHS, type CheckSummary, type FilesDiff } from './applied-context.ts';
 import { jsonDiff } from './config-patch.ts';
+import { baselineReach, reachOps, type BaselineReach } from './baseline-reach.ts';
 
 export const BASELINE_SCHEMA = 'rig-review-baseline/1';
 export type BaselineStatus = 'running' | 'reproduced' | 'not-reproduced' | 'refused' | 'failed';
@@ -23,6 +24,8 @@ export interface BaselineResult {
   firstDifference: string | null;
   /** Both sides: the rig.json SHA-256 and the SHA-256 of the sorted {path: sha256} table of every compared file. */
   hashes: { baseline: { rigJson: string | null; tree: string }; inspected: { rigJson: string | null; tree: string } } | null;
+  /** #148: what Apply can still do when not reproduced (`src/baseline-reach.ts`); null otherwise. */
+  reach?: BaselineReach | null;
   line: string; exitCode: number | null; wallMs: number | null;
 }
 const sha256 = (bytes: Uint8Array | string) => createHash('sha256').update(bytes).digest('hex');
@@ -73,9 +76,9 @@ export async function producerDiff(inspectedDir: string, scratchDir: string): Pr
   return { documents, images: { changed: changed.length, unchanged: names.length - changed.length, names: changed.slice(0, MAX_DIFF_PATHS) } };
 }
 /** The editor bar's line. */
-export function baselineLine(r: Pick<BaselineResult, 'status' | 'firstDifference' | 'hashes' | 'line'>): string {
+export function baselineLine(r: Pick<BaselineResult, 'status' | 'firstDifference' | 'hashes' | 'line'> & { reach?: BaselineReach | null }): string {
   if (r.status === 'reproduced' && r.hashes) return `baseline: reproduced — rig.json ${r.hashes.baseline.rigJson?.slice(0, 12)}… = inspected ${r.hashes.inspected.rigJson?.slice(0, 12)}…`;
-  if (r.status === 'not-reproduced') return `baseline: not reproduced — ${r.firstDifference}`;
+  if (r.status === 'not-reproduced') return `baseline: not reproduced — ${r.firstDifference}${r.reach ? ` · ${r.reach.text}` : ''}`;
   return r.line;
 }
 /**
@@ -86,7 +89,7 @@ export class BaselineError extends Error { constructor(readonly code: string, de
 export function assertWholeRigBaseline(result: BaselineResult | null): void {
   if (!result) throw new BaselineError('EDIT_BASELINE_MISMATCH', 'no baseline was run: the handoff or the producer did not resolve');
   if (result.status === 'running') throw new BaselineError('EDIT_BASELINE_PENDING', 'the baseline rebuild is still running');
-  if (result.status !== 'reproduced') throw new BaselineError('EDIT_BASELINE_MISMATCH', result.firstDifference ?? result.line);
+  if (result.status !== 'reproduced') throw new BaselineError('EDIT_BASELINE_MISMATCH', result.firstDifference ? `${result.firstDifference}${result.reach ? ` — ${result.reach.text}` : ''}` : result.line);
 }
 
 /** Deterministic: the package, the handoff record and the producer. No clock. */
@@ -94,9 +97,11 @@ export const baselineKey = (sourceHash: string, handoff: Handoff, producer: Inst
   sha256(JSON.stringify([BASELINE_SCHEMA, sourceHash, handoff.record, `${producer.package}@${producer.version}`, `${compiler.package}@${compiler.version}`]));
 
 /** Compare a finished `<dir>/baseline` with the inspected rig; `show` turns a rig-relative path into the package-relative one. */
-export async function compareBaseline(out: string, inspectedRig: string, show: (rel: string) => string): Promise<Pick<BaselineResult, 'status' | 'firstDifference' | 'hashes'>> {
+export async function compareBaseline(out: string, inspectedRig: string, show: (rel: string) => string, producerVersion: string | null = null): Promise<Pick<BaselineResult, 'status' | 'firstDifference' | 'hashes' | 'reach'>> {
   const baseline = await rigTree(out), inspected = await rigTree(inspectedRig), first = firstDifference(baseline, inspected);
-  return { status: first === null ? 'reproduced' : 'not-reproduced', firstDifference: first === null ? null : show(first), hashes: { baseline: { rigJson: baseline['rig.json'] ?? null, tree: treeHash(baseline) }, inspected: { rigJson: inspected['rig.json'] ?? null, tree: treeHash(inspected) } } };
+  // #148: a build the config does not reproduce says, per op, what the producer will still take.
+  const reach = first === null ? null : await baselineReach(out, inspectedRig, baseline, inspected, show, reachOps(producerVersion));
+  return { status: first === null ? 'reproduced' : 'not-reproduced', firstDifference: first === null ? null : show(first), hashes: { baseline: { rigJson: baseline['rig.json'] ?? null, tree: treeHash(baseline) }, inspected: { rigJson: inspected['rig.json'] ?? null, tree: treeHash(inspected) } }, reach };
 }
 
 /**
@@ -106,11 +111,11 @@ export async function compareBaseline(out: string, inspectedRig: string, show: (
 export async function runBaseline(dir: string, key: string, handoff: Handoff, producer: InstalledTool, show: (rel: string) => string): Promise<BaselineResult> {
   const base = { schema: BASELINE_SCHEMA, key, producer: { package: producer.package, version: producer.version } } as const;
   const out = join(dir, 'baseline'), resultFile = join(dir, 'result.json');
-  if (!handoff.parts || !handoff.rig) return { ...base, status: 'refused', firstDifference: null, hashes: null, line: `baseline: unavailable — MODELING_INPUT_UNAVAILABLE: ${handoff.record.missing.join(', ')}`, exitCode: null, wallMs: null };
+  if (!handoff.parts || !handoff.rig) return { ...base, status: 'refused', firstDifference: null, hashes: null, reach: null, line: `baseline: unavailable — MODELING_INPUT_UNAVAILABLE: ${handoff.record.missing.join(', ')}`, exitCode: null, wallMs: null };
   try {
     const stored = JSON.parse(await readFile(resultFile, 'utf8')) as BaselineResult;
     if (stored.schema === BASELINE_SCHEMA && stored.key === key && (stored.status === 'reproduced' || stored.status === 'not-reproduced')) {
-      const now = await compareBaseline(out, handoff.rig, show);
+      const now = await compareBaseline(out, handoff.rig, show, producer.version);
       if (now.hashes?.baseline.tree === stored.hashes?.baseline.tree) return { ...stored, ...now, line: baselineLine({ ...stored, ...now }) };
     }
   } catch { /* no reusable result */ }
@@ -119,9 +124,9 @@ export async function runBaseline(dir: string, key: string, handoff: Handoff, pr
   const run = await runTool(producer.bin, ['rig', '--config', handoff.config, '--parts', handoff.parts, '--out', out], { cwd: dir });
   if (run.exitCode !== 0) {
     const named = firstRefusal(run.lines) ?? `rig-parts rig exited ${run.exitCode} without a named refusal`;
-    return { ...base, status: 'refused', firstDifference: null, hashes: null, line: `baseline: not run — ${named}`, exitCode: run.exitCode, wallMs: run.wallMs };
+    return { ...base, status: 'refused', firstDifference: null, hashes: null, reach: null, line: `baseline: not run — ${named}`, exitCode: run.exitCode, wallMs: run.wallMs };
   }
-  const compared = await compareBaseline(out, handoff.rig, show);
+  const compared = await compareBaseline(out, handoff.rig, show, producer.version);
   const result: BaselineResult = { ...base, ...compared, line: '', exitCode: 0, wallMs: run.wallMs };
   result.line = baselineLine(result);
   await writeFile(resultFile, JSON.stringify(result, null, 1) + '\n', { mode: 0o600 });

package/src/cli.ts

@@ -6,7 +6,7 @@ import { formatFeedbackIssues } from './feedback-export.ts';
 import {loadReferencedReview,selectedReference,assertReviewUnchanged} from './reference.ts';
 import {animationDiagnostic,selectAnimation} from './animation-selection.ts';
 import {shellWord} from './open-shell.ts';
-import {openReview,controlReview,loadOpenPackage,defaultStateDir,handoffFlags,type OpenInputs} from './open.ts';
+import {openReview,buildOpenDiagnostic,controlReview,loadOpenPackage,defaultStateDir,handoffFlags,type OpenInputs} from './open.ts';
 import {checkHandoffFlags,HANDOFF_FLAGS} from './handoff.ts';
 import { readFeedbackSession, readFeedbackCompareSession } from './session-history.ts';
 import { startServer } from './server.ts';
@@ -94,7 +94,7 @@ export async function main(args:string[],options:{stateDir?:string}={}){
   options={stateDir:options.stateDir??defaultStateDir()};if(args[0]==='--')args.shift();
   if(args[0]==='control')return controlCommand(args.slice(1),options.stateDir);
   if(args[0]==='open'){const openArgs=args.slice(1);if(commandHelpRequested(openArgs,'open')){console.log(usage);return;}const inputs=parseOpenInputs(openArgs);const result=await openReview(inputs,options);// Launcher contract (README): stdout is the URL line alone; stderr is diagnostic, control notice, retrieval, in that order.
-    console.log(result.url);if(result.selection)console.error(animationDiagnostic(result.selection));if(inputs.control)console.error('Inspection control enabled; query the current connected page with rig-review control and the same inputs.');console.error(`Review ${result.reused?'reused':'started'}; feedback: rig-review feedback ${[result.inputs.input,...(result.inputs.compare?['--compare',result.inputs.compare]:[]),...(result.inputs.reference?['--reference',result.inputs.reference]:[]),...(result.inputs.animation?['--animation',result.inputs.animation]:[]),...handoffWords(result.inputs)].map(shellWord).join(' ')}`);return;}
+    console.log(result.url);if(result.build)console.error(buildOpenDiagnostic(result.build));if(result.selection)console.error(animationDiagnostic(result.selection));if(inputs.control)console.error('Inspection control enabled; query the current connected page with rig-review control and the same inputs.');console.error(`Review ${result.reused?'reused':'started'}; feedback: rig-review feedback ${[result.inputs.input,...(result.inputs.compare?['--compare',result.inputs.compare]:[]),...(result.inputs.reference?['--reference',result.inputs.reference]:[]),...(result.inputs.animation?['--animation',result.inputs.animation]:[]),...handoffWords(result.inputs)].map(shellWord).join(' ')}`);return;}
   if(args[0]==='strip'){args.shift();if(args.includes('--help')){console.log(usage+'\nStrip: strip <package> --reference <declared-video-id> --animation <name> (--frames FIRST:LAST | --all-feedback) [--json] [--out path]\n       strip compare <a> <b> --reference <video> --animation <name> --basis a|b (--frames FIRST:LAST | --all-feedback) [--json] [--out path]');return;}return stripCommand(args,options);}let command:'review'|'check'|'feedback'='review';if(args[0]==='check'||args[0]==='feedback'){command=args.shift() as 'check'|'feedback';}
   if(args[0]==='--help'||args[0]==='-h'){console.log(usage);return;}
   let format:'json'|'issue'='json';if(command==='feedback'){const parsed=feedbackFormat(args);args=parsed.args;format=parsed.format;}

package/src/density-strip.ts

@@ -0,0 +1,201 @@
+/**
+ * Density strip (#173), pure: N ≤ 5 values of one part's density field — `grid` on a lattice entry, `contour.spacing`
+ * on a contour entry — each sent as the one existing Mesh-panel patch (`replace /meshes/<part>`, `remesh --part
+ * <part>`, #106) and built side by side. This module holds what needs no IO: the request's shape (the patches may
+ * differ only at the density field), the values of a strip and of a refined strip, and the row a settled candidate job
+ * reads as — `remesh.json`'s `target.after` counts, the producer's own check lines for the part (folds, stretch, every
+ * bar the part is measured on as a ratio against its floor or ceiling) and the verdict (PASS, or the refusal verbatim).
+ * The two labels ("fewest triangles passing", "widest margin among ties") name rows; nothing here applies one.
+ */
+import { applyConfigPatch, type ConfigPatch, type JsonValue } from './config-patch.ts';
+import { assertMeshPatch, MeshEntryError, meshMode, type MeshCounts } from './mesh-entry.ts';
+
+export const DENSITY_STRIP_SCHEMA = 'rig-review-density-strip/1';
+/** At most this many values per strip (the card's N ≤ 5); at least two (one value is an Apply). */
+export const MAX_STRIP_VALUES = 5, MIN_STRIP_VALUES = 2;
+/** `POST /api/density-strip`: five patches of at most 64 KiB each (the Apply body bound). */
+export const DENSITY_STRIP_LIMIT = MAX_STRIP_VALUES * 64 * 1024;
+/** The density field a strip runs over, by the entry's mode. */
+export type DensityField = 'grid' | 'contour.spacing';
+export const densityPath = (field: DensityField): readonly string[] => (field === 'grid' ? ['grid'] : ['contour', 'spacing']);
+
+export class DensityStripError extends Error { constructor(readonly code: string, detail: string) { super(`${code}: ${detail}`); } }
+const invalid = (detail: string): never => { throw new DensityStripError('DENSITY_STRIP_REQUEST_INVALID', detail); };
+const isObject = (v: unknown): v is Record<string, JsonValue> => !!v && typeof v === 'object' && !Array.isArray(v);
+
+/** The density field of an entry: `grid` for a lattice, `contour.spacing` for a contour; any other mode has none here. */
+export function densityField(entry: unknown, part: string): DensityField {
+  const mode = meshMode(entry, part);
+  if ('error' in mode) throw new DensityStripError('DENSITY_STRIP_FIELD', mode.error);
+  if (mode.mode === 'grid') return 'grid';
+  if (mode.mode === 'contour') return 'contour.spacing';
+  return invalid(`meshes.${part} is a ${mode.mode} entry; a strip runs over grid (lattice) or contour.spacing (contour) only`);
+}
+const valueAt = (entry: Record<string, JsonValue>, path: readonly string[]): JsonValue | undefined => path.reduce<JsonValue | undefined>((v, k) => (isObject(v) ? v[k] : undefined), entry);
+const without = (entry: Record<string, JsonValue>, path: readonly string[]): JsonValue => {
+  const out = structuredClone(entry); let holder: Record<string, JsonValue> = out;
+  for (const k of path.slice(0, -1)) holder = holder[k] as Record<string, JsonValue>;
+  delete holder[path.at(-1)!];
+  return out;
+};
+
+/** `{patches}` exactly, 2–5 of them (each still to be parsed as a config patch). */
+export function stripPatches(input: unknown): unknown[] {
+  if (!isObject(input) || Object.keys(input).join(',') !== 'patches') invalid('expected exactly {patches}');
+  const patches = (input as { patches: unknown }).patches;
+  if (!Array.isArray(patches) || patches.length < MIN_STRIP_VALUES || patches.length > MAX_STRIP_VALUES) invalid(`patches must hold ${MIN_STRIP_VALUES}–${MAX_STRIP_VALUES} config patches`);
+  return patches as unknown[];
+}
+
+export interface StripShape { part: string; field: DensityField; values: number[]; entries: JsonValue[] }
+/**
+ * The strip a list of parsed patches states: every one the Mesh panel's patch for one part (`MESH_PATCH_SCOPE`
+ * otherwise), the same config bytes, producer and flags, and entries that differ only at the part's density field,
+ * each at another value. Order is the request's.
+ */
+export function stripShape(patches: readonly ConfigPatch[]): StripShape {
+  const first = patches[0]!;
+  const part = first.op.args[first.op.args.indexOf('--part') + 1];
+  if (first.op.cmd !== 'remesh' || typeof part !== 'string') invalid('a strip is made of remesh patches (remesh --part <part>)');
+  const field = densityField(first.ops[0]?.value, part!);
+  const path = densityPath(field), entries: JsonValue[] = [], values: number[] = [];
+  let rest: string | null = null;
+  for (const [i, patch] of patches.entries()) {
+    try { assertMeshPatch(patch, part!); } catch (e) { if (e instanceof MeshEntryError) throw new DensityStripError(e.code, `patches[${i}]: ${e.message.slice(e.code.length + 2)}`); throw e; }
+    if (patch.config_sha256 !== first.config_sha256) invalid(`patches[${i}] was made against other config bytes than patches[0]`);
+    if (JSON.stringify(patch.producer) !== JSON.stringify(first.producer) || JSON.stringify(patch.op) !== JSON.stringify(first.op)) invalid(`patches[${i}] names another producer or other flags than patches[0]`);
+    const entry = patch.ops[0]!.value;
+    if (!isObject(entry) || densityField(entry, part!) !== field) invalid(`patches[${i}]: the entry is not a ${field === 'grid' ? 'grid' : 'contour'} entry like patches[0]`);
+    const value = valueAt(entry as Record<string, JsonValue>, path);
+    if (typeof value !== 'number' || !Number.isFinite(value)) invalid(`patches[${i}]: meshes.${part}.${field} is not a number`);
+    const others = JSON.stringify(without(entry as Record<string, JsonValue>, path));
+    if (rest === null) rest = others;
+    else if (others !== rest) throw new DensityStripError('DENSITY_STRIP_FIELD', `patches[${i}] differs from patches[0] outside meshes.${part}.${field}; a strip varies the density field only`);
+    if (values.includes(value as number)) invalid(`patches[${i}]: ${field} ${value} is already in the strip`);
+    values.push(value as number); entries.push(entry as JsonValue);
+  }
+  return { part: part!, field, values, entries };
+}
+
+/** n values from a to b inclusive, evenly spaced; a lattice's grid is a whole number (rounded, duplicates dropped). */
+export function stripValues(a: number, b: number, n: number, integer: boolean): number[] {
+  if (![a, b, n].every(Number.isFinite) || n < MIN_STRIP_VALUES || n > MAX_STRIP_VALUES || !Number.isInteger(n)) throw new DensityStripError('DENSITY_STRIP_VALUES', `N must be a whole number ${MIN_STRIP_VALUES}–${MAX_STRIP_VALUES}, and A and B numbers`);
+  const lo = Math.min(a, b), hi = Math.max(a, b);
+  const raw = Array.from({ length: n }, (_, k) => lo + ((hi - lo) * k) / (n - 1));
+  const out = [...new Set(raw.map(v => (integer ? Math.round(v) : Math.round(v * 1000) / 1000)))].sort((x, y) => x - y);
+  if (out.length < MIN_STRIP_VALUES) throw new DensityStripError('DENSITY_STRIP_VALUES', `${lo}…${hi} holds fewer than ${MIN_STRIP_VALUES} distinct ${integer ? 'whole ' : ''}values`);
+  return out;
+}
+/** "Refine between" two adjacent rows: up to n values strictly inside (a, b), evenly spaced. */
+export function refineValues(a: number, b: number, n: number, integer: boolean): number[] {
+  const lo = Math.min(a, b), hi = Math.max(a, b);
+  const raw = Array.from({ length: n }, (_, k) => lo + ((hi - lo) * (k + 1)) / (n + 1));
+  const out = [...new Set(raw.map(v => (integer ? Math.round(v) : Math.round(v * 1000) / 1000)))].filter(v => v > lo && v < hi).sort((x, y) => x - y);
+  if (out.length < MIN_STRIP_VALUES) throw new DensityStripError('DENSITY_STRIP_VALUES', `between ${lo} and ${hi} there are fewer than ${MIN_STRIP_VALUES} ${integer ? 'whole ' : ''}values to try`);
+  return out;
+}
+/** The entry with its density field at `value` (every other field as the base entry holds it, in its order). */
+export const entryAt = (entry: Record<string, JsonValue>, field: DensityField, value: number): JsonValue =>
+  applyConfigPatch(entry, [{ op: 'replace', path: densityPath(field).map(k => '/' + k).join(''), value }]);
+
+/** One bar the part is measured on, as the producer's check printed it: its figure against the bar's floor or ceiling. */
+export interface StripBar { bar: string; status: string; key: string; value: number; bound: number; kind: 'floor' | 'ceiling'; ratio: number; margin: number }
+export interface StripFigures {
+  /** `ANIMATIONS_DO_NOT_FOLD`'s folding mesh count, as printed. */
+  folds: number | null;
+  /** The part's `TEXTURE_STRETCH` severity and the frame of its worst triangle (the max or the min side, whichever is worse). */
+  stretch: { severity: number; frame: string | null } | null;
+  bars: StripBar[];
+}
+const NUM = '(-?\\d+(?:\\.\\d+)?(?:e[-+]?\\d+)?)';
+const escape = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * The check lines a candidate's figures are read from: the producer op's own check of its revision (remesh prints it
+ * as `[check-revision] …`, #174) when the job carries it, else the lines of the check review ran (no bracket prefix).
+ */
+export function revisionCheckLines(lines: readonly string[]): string[] {
+  const tagged = lines.filter(l => l.startsWith('[check-revision]')).map(l => l.slice('[check-revision]'.length));
+  return tagged.length ? tagged : lines.filter(l => !/^\s*\[/.test(l) && !l.startsWith('review:'));
+}
+/** The part's figures from check's bar lines (`  BAR: STATUS — detail`), the producer's numbers as printed. */
+export function stripFigures(lines: readonly string[], part: string): StripFigures {
+  const out: StripFigures = { folds: null, stretch: null, bars: [] };
+  const marker = new RegExp(`\\b(?:part|slot) ${escape(part)}, `, 'g');
+  for (const raw of revisionCheckLines(lines)) {
+    const m = /^\s*([A-Z][A-Z0-9_]+): (PASS|FAIL|SKIP|WARN|CLEAR|REPORTED) — (.*)$/.exec(raw);
+    if (!m) continue;
+    const [, bar, status, detail] = m as unknown as [string, string, string, string];
+    if (bar === 'ANIMATIONS_DO_NOT_FOLD') { const f = /(\d+) folding mesh\(es\)/.exec(detail); if (f) out.folds = Number(f[1]); }
+    // The part's own segment: the last time the line names it (TEXTURE_STRETCH names its worst slot first, then per mesh).
+    let at = -1; for (const hit of detail.matchAll(marker)) at = hit.index!;
+    if (at < 0) continue;
+    const end = detail.indexOf(' | ', at), segment = detail.slice(at, end < 0 ? undefined : end);
+    if (/^\S+ \S+, unmeasured\b/.test(segment)) continue;
+    if (bar === 'TEXTURE_STRETCH') {
+      const sev = new RegExp(`\\bseverity ${NUM}`).exec(segment), max = new RegExp(`\\bmax_ratio ${NUM}`).exec(segment), min = new RegExp(`\\bmin_ratio ${NUM}`).exec(segment);
+      const frames = [...segment.matchAll(/\b([A-Za-z0-9_-]+) frame (\d+)/g)].map(f => `${f[1]} frame ${f[2]}`);
+      if (sev) {
+        // The worst frame is the side the severity was taken from: the max ratio, or the inverse of the min ratio.
+        const s = Number(sev[1]), worstMin = !!(max && min && Number(min[1]) > 0 && Math.abs(1 / Number(min[1]) - s) < Math.abs(Number(max[1]) - s));
+        out.stretch = { severity: Number(sev[1]), frame: (worstMin ? frames[1] : frames[0]) ?? null };
+      }
+    }
+    for (const b of detail.matchAll(new RegExp(`\\b([a-z][a-z0-9_]*?)_(floor|ceiling) ${NUM}`, 'g'))) {
+      const key = b[1]!, kind = b[2] as 'floor' | 'ceiling', bound = Number(b[3]);
+      const v = new RegExp(`\\b${escape(key)} ${NUM}`).exec(segment);
+      if (!v || !(bound > 0)) continue;
+      const value = Number(v[1]), ratio = value / bound;
+      out.bars.push({ bar, status, key, value, bound, kind, ratio, margin: kind === 'floor' ? ratio : value > 0 ? bound / value : Infinity });
+    }
+  }
+  return out;
+}
+
+/** A settled candidate job, as much of it as a row reads. */
+export interface CandidateJobLike {
+  status: string; producerLine: string | null; lines: readonly string[];
+  remesh: { part: string; before: MeshCounts; after: MeshCounts; modelTriangles: number | null } | null;
+  check: { pass: boolean | null; line: string | null } | null;
+  build: { modelHash: string } | null;
+}
+export interface StripRow extends StripFigures {
+  value: number; id: string; status: string;
+  /** `remesh.json`'s `target.after` (null when the candidate wrote none: refused before it). */
+  counts: { vertices: number; triangles: number } | null;
+  modelTriangles: number | null;
+  /** PASS, or the producer's refusal (or check's line) verbatim. */
+  verdict: string;
+  /** Served for viewing while the strip holds it; null for a refused or running row. */
+  modelUrl: string | null; modelHash: string | null;
+  /** The candidate's build moved into the Apply scratch root when the reader Applied this row's patch. */
+  applied: boolean;
+  entry: JsonValue;
+}
+export function candidateRow(input: { value: number; id: string; entry: JsonValue; job: CandidateJobLike; part: string; modelUrl: string | null; applied: boolean }): StripRow {
+  const { job } = input, built = job.status === 'built';
+  const verdict = job.status === 'running' ? 'running' : built ? (job.check?.pass ? 'PASS' : job.check?.line ?? 'check: no summary') : job.producerLine ?? `REBUILD_${job.status.toUpperCase()}`;
+  return {
+    value: input.value, id: input.id, status: job.status, ...stripFigures(job.lines, input.part),
+    counts: job.remesh ? { vertices: job.remesh.after.vertices, triangles: job.remesh.after.triangles } : null,
+    modelTriangles: job.remesh?.modelTriangles ?? null, verdict,
+    modelUrl: built && !input.applied ? input.modelUrl : null, modelHash: built ? job.build?.modelHash ?? null : null,
+    applied: input.applied, entry: input.entry,
+  };
+}
+/** The narrowest margin of a row over every bar it is measured on (> 1: every bar met with room), or null with none. */
+export const rowMargin = (row: Pick<StripRow, 'bars'>): number | null => (row.bars.length ? Math.min(...row.bars.map(b => b.margin)) : null);
+/**
+ * The two labels, by row index: the passing row with the fewest triangles, and — when several passing rows tie on that
+ * count — the one among them with the widest narrowest margin. Labels only: nothing here applies a row.
+ */
+export function stripLabels(rows: readonly StripRow[]): { fewest: number | null; widest: number | null } {
+  const passing = rows.map((r, i) => ({ r, i })).filter(x => x.r.verdict === 'PASS' && x.r.counts);
+  if (!passing.length) return { fewest: null, widest: null };
+  const least = Math.min(...passing.map(x => x.r.counts!.triangles)), tied = passing.filter(x => x.r.counts!.triangles === least);
+  const fewest = tied[0]!.i;
+  if (tied.length < 2) return { fewest, widest: null };
+  const best = tied.reduce((a, b) => ((rowMargin(b.r) ?? -Infinity) > (rowMargin(a.r) ?? -Infinity) ? b : a));
+  return { fewest, widest: best.i };
+}
+/** A bar as the table shows it: `TIP_OVER_ROOT ratio 1.995 / floor 1.4725 = 1.355×`. */
+export const barText = (b: StripBar) => `${b.bar} ${b.key} ${b.value} / ${b.kind} ${b.bound} = ${b.ratio.toFixed(3)}×`;

package/src/front.ts

@@ -57,7 +57,14 @@ export function frontRoute(mode:'single'|'compare',method:string,path:string):Ro
  if((mode==='single'?/^\/assets\/[^/]/:/^\/compare-assets\/(a|b)\/[^/]/).test(path))return read?get:null;
  // Apply · Rebuild (single only): status, one typed request, a job's status and its served scratch build.
  if(mode==='single'&&path==='/api/rebuild')return read?get:method==='POST'?{mutation:true,limit:64*1024,timeoutMs:30000,control:false}:null;
+ // #166 (single only): the applied records, and undo of the last one ({from}).
+ if(mode==='single'&&path==='/api/rebuild/history')return read?get:null;
+ if(mode==='single'&&path==='/api/rebuild/undo')return method==='POST'?{mutation:true,limit:1024,timeoutMs:30000,control:false}:null;
  if(mode==='single'&&(/^\/api\/rebuild\/[a-f0-9]{64}$/.test(path)||/^\/rebuild\/[a-f0-9]{64}\/[^/]/.test(path)))return read?get:null;
+ // #173 (single only): a density strip (2–5 patches, 320 KiB), its status, a candidate's job, its served build, and closing it.
+ if(mode==='single'&&path==='/api/density-strip')return read?get:method==='POST'?{mutation:true,limit:320*1024,timeoutMs:30000,control:false}:null;
+ if(mode==='single'&&path==='/api/density-strip/close')return method==='POST'?{mutation:true,limit:1024,timeoutMs:30000,control:false}:null;
+ if(mode==='single'&&(/^\/api\/density-strip\/[a-f0-9]{64}(?:\/[a-f0-9]{64})?$/.test(path)||/^\/density-strip\/[a-f0-9]{64}\/[a-f0-9]{64}\/[^/]/.test(path)))return read?get:null;
  // Bones check (#109, single only): one typed request {ops, configHash}, answered in the response.
  if(mode==='single'&&path==='/api/bones-check')return method==='POST'?{mutation:true,limit:64*1024,timeoutMs:60000,control:false}:null;
  // Readings (#108, single only): one typed request, then its job's status.

package/src/handoff.ts

@@ -9,6 +9,13 @@
  * package root; for the `../config.json` step, the folder that holds `out/`); a symlink that leaves it is refused by name.
  * The record (paths relative to the package root, hashes, how it was found) is part of `reviewedSource`, so changing a
  * handoff file's bytes starts a new pending session.
+ *
+ * A rig-parts build root (#149, {@link isBuildRoot}) opens as its `check/` package. For that package the producer's own
+ * config for the build is the regular file `config.json` in the build root, else in the folder that holds it — the two
+ * places `rig-parts build --config <dir>/config.json --out <dir>/out` leaves it. The build writes no record of its
+ * config, so this is a location rule bounded by the build's own files, not a proof: the session baseline (the producer
+ * rebuilding the inspected rig from that config) is the check. Discovered there, or declared with `--config` at exactly
+ * one of those two files, the handoff's root is that file's folder and the parts directory is the build root.
  */
 import { createHash } from 'node:crypto';
 import { lstat, readdir, readFile, realpath, stat } from 'node:fs/promises';
@@ -19,6 +26,9 @@ export const HANDOFF_SCHEMA = 'rig-review-handoff/1';
 export const DISCOVERY_PLACES = ['config.json', 'rig/config.json', '../config.json (beside an opened out/)'] as const;
 export const HANDOFF_DECLARATION = 'rig-review open <dir> --config <path> [--parts <dir>] or the review.json "producer" block';
 export const MODELING_INPUT_UNAVAILABLE = `MODELING_INPUT_UNAVAILABLE: config.json — looked at ${DISCOVERY_PLACES.join(', ')}; declare it with ${HANDOFF_DECLARATION}`;
+/** #149: the places looked at for the check package of a rig-parts build root, after the in-folder ones. */
+export const BUILD_DISCOVERY_PLACES = ['../config.json (in the build root)', '../../config.json (beside the build root)'] as const;
+export const BUILD_MODELING_INPUT_UNAVAILABLE = `MODELING_INPUT_UNAVAILABLE: config.json — looked at ${[...DISCOVERY_PLACES.slice(0, 2), ...BUILD_DISCOVERY_PLACES].join(', ')}; declare it with ${HANDOFF_DECLARATION}`;
 /** Files the producer reads by the config's own naming, resolved against the config's directory (rig-parts `relativeConfigPaths`). */
 export const CONFIG_NAMED_FILES = [['motion', 'animations_from'], ['generation', 'control', 'skeleton']] as const;
 /** What `rig-parts rig` writes into its --out and remesh reads from --rig: the rig spec, its motion, the mesh report and the part images. */
@@ -56,6 +66,33 @@ const inside = (base: string, path: string, allowSelf = false) => { const rel =
 const code = (e: unknown) => (e as NodeJS.ErrnoException).code ?? '';
 async function exists(path: string): Promise<boolean> { try { await lstat(path); return true; } catch (e) { if (code(e) === 'ENOENT' || code(e) === 'ENOTDIR') return false; throw e; } }
 
+/** A path's own entry (never followed) is of this kind; absent or another kind is false. */
+async function entryIs(path: string, kind: 'file' | 'dir'): Promise<boolean> {
+  try { const info = await lstat(path); return kind === 'file' ? info.isFile() : info.isDirectory(); } catch (e) { if (code(e) === 'ENOENT' || code(e) === 'ENOTDIR') return false; throw e; }
+}
+/**
+ * #149: a rig-parts build root — the folder `rig-parts build --out` wrote — recognised by fixed names the build owns, never
+ * by a search: regular `parts.json` and `rig/rig.json`, a real (not symlinked) `check/` directory, and an existing
+ * `check/build/skeleton.model.json` entry (its validity is the package adapter's to refuse). A folder lacking any of
+ * these is not a build root.
+ */
+export async function isBuildRoot(dir: string): Promise<boolean> {
+  if (!(await entryIs(join(dir, 'parts.json'), 'file')) || !(await entryIs(join(dir, 'rig'), 'dir')) || !(await entryIs(join(dir, 'rig', 'rig.json'), 'file')) || !(await entryIs(join(dir, 'check'), 'dir'))) return false;
+  return exists(join(dir, 'check', 'build', 'skeleton.model.json'));
+}
+/** The producer's own config places for the build whose check package is `root` (canonical), or null when `root` is not one. */
+interface BuildPlace { config: string; base: string; field: string }
+async function buildPlaces(root: string): Promise<{ build: string; places: BuildPlace[] } | null> {
+  if (basename(root) !== 'check' || !(await isBuildRoot(dirname(root)))) return null;
+  const build = dirname(root);
+  return { build, places: [{ config: join(build, 'config.json'), base: build, field: '../config.json' }, { config: join(dirname(build), 'config.json'), base: dirname(build), field: '../../config.json' }] };
+}
+/** The path as written with its parent chain canonicalized (so /tmp → /private/tmp is not an escape); null when the parent is missing. */
+async function writtenPath(value: string): Promise<string | null> {
+  const lexical = resolve(value);
+  try { return join(await realpath(dirname(lexical)), basename(lexical)); } catch (e) { if (code(e) === 'ENOENT' || code(e) === 'ENOTDIR') return null; throw e; }
+}
+
 /**
  * One handoff path: it must exist, its canonical location must stay inside `base`, and it must be the expected kind.
  * `lexicalInside` says whether the path as written was inside the root, so a canonical escape is named a symlink escape.
@@ -175,13 +212,17 @@ export async function resolveHandoff(root: string, declared: HandoffDeclaration
   if (flags) {
     const problem = checkHandoffFlags(flags);
     if (problem) throw new HandoffError('HANDOFF_FLAGS_INVALID', problem.split(':')[0]!, problem);
-    const config = await flagPath(root, flags.config, '--config', 'file');
-    const parts = flags.parts !== undefined ? await flagPath(root, flags.parts, '--parts', 'dir') : join(dirname(config), 'out');
-    const source = flags.source !== undefined ? await flagPath(root, flags.source, '--source', 'file') : undefined;
-    const full = flags.full !== undefined ? await flagPath(root, flags.full, '--full', 'dir') : undefined;
-    const head = flags.head !== undefined ? await flagPath(root, flags.head, '--head', 'dir') : undefined;
-    const keypoints = flags.keypoints !== undefined ? await flagPath(root, flags.keypoints, '--keypoints', 'file') : undefined;
-    const handoff = await record(root, root, 'declared', 'open --config', config, parts, { source, full, head, keypoints }, flags.parts !== undefined);
+    // #149: a --config written as exactly one of the build's own config places takes that place's folder as its root.
+    const build = await buildPlaces(root), written = build ? await writtenPath(flags.config) : null;
+    const place = build?.places.find(p => p.config === written) ?? null, base = place?.base ?? root;
+    const config = await flagPath(base, flags.config, '--config', 'file');
+    if (place && config !== place.config) throw new HandoffError('HANDOFF_SYMLINK_ESCAPE', '--config', `${flags.config} is a symlink; only the build's own ${place.field} is taken`);
+    const parts = flags.parts !== undefined ? await flagPath(base, flags.parts, '--parts', 'dir') : place ? build!.build : join(dirname(config), 'out');
+    const source = flags.source !== undefined ? await flagPath(base, flags.source, '--source', 'file') : undefined;
+    const full = flags.full !== undefined ? await flagPath(base, flags.full, '--full', 'dir') : undefined;
+    const head = flags.head !== undefined ? await flagPath(base, flags.head, '--head', 'dir') : undefined;
+    const keypoints = flags.keypoints !== undefined ? await flagPath(base, flags.keypoints, '--keypoints', 'file') : undefined;
+    const handoff = await record(root, base, 'declared', 'open --config', config, parts, { source, full, head, keypoints }, flags.parts !== undefined);
     // Canonical absolute flags: the background worker and later reloads read exactly these.
     handoff.flags = { config, ...(flags.parts !== undefined ? { parts } : {}), ...(source ? { source } : {}), ...(full ? { full } : {}), ...(head ? { head } : {}), ...(keypoints ? { keypoints } : {}) };
     return { handoff, reason: null };
@@ -202,6 +243,17 @@ export async function resolveHandoff(root: string, declared: HandoffDeclaration
     const config = await contained(root, path, name, 'file', true);
     return { handoff: await record(root, root, 'discovered', 'discovery', config, join(dirname(path), 'out'), {}, false), reason: null };
   }
+  // #149: the check package of a rig-parts build root — the build's own config, in the build root, else beside it.
+  const build = await buildPlaces(root);
+  if (build) {
+    for (const place of build.places) {
+      if (!(await exists(place.config))) continue;
+      const config = await contained(place.base, place.config, place.field, 'file', true);
+      if (config !== place.config) throw new HandoffError('HANDOFF_SYMLINK_ESCAPE', place.field, `${place.config} is a symlink; only the build's own config file is discovered`);
+      return { handoff: await record(root, place.base, 'discovered', 'discovery', config, build.build, {}, false), reason: null };
+    }
+    return { handoff: null, reason: BUILD_MODELING_INPUT_UNAVAILABLE };
+  }
   // The last step: an opened `out/` whose config sits beside it, one level up. Outside the folder, so named.
   if (basename(root) === 'out') {
     const parent = dirname(root), path = join(parent, 'config.json');

package/src/manifest.ts

@@ -6,7 +6,7 @@ import { parseReport, type ReportSeeds } from './report.ts';
 import { readFile, realpath, stat, lstat, readdir } from 'node:fs/promises';
 import { createReadStream } from 'node:fs';
 import { basename, dirname, isAbsolute, relative, resolve, posix } from 'node:path';
-import { parseHandoffDeclaration, resolveHandoff, type Handoff, type HandoffDeclaration, type HandoffFlags, type HandoffRecord } from './handoff.ts';
+import { isBuildRoot, parseHandoffDeclaration, resolveHandoff, type Handoff, type HandoffDeclaration, type HandoffFlags, type HandoffRecord } from './handoff.ts';
 
 export type Json = null | boolean | number | string | Json[] | { [key: string]: Json };
 export interface Reference { id: string; label: string; type: 'image' | 'video' | 'pose'; path: string; width?: number; height?: number }
@@ -74,7 +74,9 @@ export function parseManifest(input: unknown): ReviewManifest {
 /** `options.handoff` are the explicit `--config …` flags; they win over the manifest block and discovery. */
 export async function loadReview(input: string, options: { handoff?: HandoffFlags } = {}): Promise<ReviewPackage> {
   const inputPath=await realpath(resolve(input));const directory=(await stat(inputPath)).isDirectory();
-  if(directory){try{await stat(resolve(inputPath,'review.json'));return loadReview(resolve(inputPath,'review.json'),options);}catch(e){if((e as NodeJS.ErrnoException).code!=='ENOENT')throw e;}}
+  if(directory){try{await stat(resolve(inputPath,'review.json'));return loadReview(resolve(inputPath,'review.json'),options);}catch(e){if((e as NodeJS.ErrnoException).code!=='ENOENT')throw e;}
+    // #149: a rig-parts build root without a model of its own opens as its check package, exactly as opening check/ does.
+    const check=await buildCheckPackage(inputPath);if(check)return loadReview(check,options);}
   const manifestPath=inputPath;const root=directory?inputPath:await realpath(dirname(inputPath));
   const manifest=directory?await folderManifest(root):parseManifest(JSON.parse(await readFile(manifestPath,'utf8')));
   const files = new Set([...(directory?[]:[relative(root,manifestPath)]),...manifest.references.map(v=>v.path),...manifest.authoring.map(v=>v.path),...manifest.audio.clips.map(v=>v.path)]);
@@ -112,9 +114,17 @@ export async function loadReview(input: string, options: { handoff?: HandoffFlag
   return {root,manifestPath,manifest,sourceHash:hash.digest('hex'),reviewedSource,files,report,feedbackCatalog,handoff,handoffReason,...(handoff?.flags?{handoffInputs:handoff.flags}:{})};
 }
 
+/**
+ * #149: the `check/` package of a rig-parts build root ({@link isBuildRoot}), when the folder has neither of the two
+ * adapter model paths itself (a folder that does keeps opening as before). Fixed names, no search.
+ */
+export async function buildCheckPackage(dir:string):Promise<string|null>{
+  for(const candidate of ['skeleton.model.json','build/skeleton.model.json']){try{await lstat(resolve(dir,candidate));return null;}catch(e){if(!['ENOENT','ENOTDIR'].includes((e as NodeJS.ErrnoException).code??''))throw e;}}
+  return await isBuildRoot(dir)?resolve(dir,'check'):null;
+}
 /** Same text for every command; `root` lets the open launcher name the refused input. */
 export class UnrecognizedOutputError extends Error {
-  constructor(readonly root:string){super('Output folder: no recognized skeleton.*, build/skeleton.model.json, motion.json, report.json, source video, pose sequence or contact strip');}
+  constructor(readonly root:string){super('Output folder: no recognized skeleton.*, build/skeleton.model.json, rig-parts build root (check/build/skeleton.model.json), motion.json, report.json, source video, pose sequence or contact strip');}
 }
 /** An adapter over an existing output directory; never writes a manifest there. */
 async function folderManifest(root:string):Promise<ReviewManifest>{

package/src/open.ts

@@ -16,7 +16,14 @@ import {selectAnimation,AnimationSelectionError,type AnimationSelection} from '.
 import {capabilityHeader,capabilityPattern,type OpenIdentity} from './open-protocol.ts';
 import {ensureFront,frontPort} from './front.ts';
 import {playPackagePath} from './versions.ts';
-import {HandoffError,HANDOFF_FLAGS,type HandoffFlags} from './handoff.ts';
+import {HandoffError,HANDOFF_FLAGS,isBuildRoot,type HandoffFlags,type HandoffRecord} from './handoff.ts';
+/** #149: an opened rig-parts build check package — its canonical path and the handoff record (or the refusal line). */
+export interface BuildOpen {package:string;handoff:HandoffRecord|null;reason:string|null}
+/** The stderr diagnostic for {@link BuildOpen}: the package opened, then how the config was found, its package-relative path and full SHA-256. */
+export function buildOpenDiagnostic(build:BuildOpen):string{
+ const h=build.handoff,how=!h?'':h.how==='declared'?`declared (${h.via})`:h.outside?'discovered outside the opened folder':'discovered';
+ return `Package: rig-parts build check package ${build.package}\n${h?`Handoff ${how}: ${h.config.path} sha256 ${h.config.sha256}${h.parts?` · parts ${h.parts}`:''}`:`Handoff: ${build.reason??'none'}`}`;
+}
 /** `direct` chooses how the page is reached (own port instead of the managed front); it is not part of the instance identity. */
 export interface OpenInputs {input:string;compare?:string;reference?:string;animation?:string;control?:boolean;direct?:boolean;config?:string;parts?:string;source?:string;full?:string;head?:string;keypoints?:string}
 /** The producer handoff flags (#101) among the inputs, or undefined when none was given. */
@@ -97,7 +104,7 @@ async function openRefusal(error:unknown,inputs:OpenInputs):Promise<unknown>{
 }
 /** Managed is the default: the printed URL goes through the one loopback front (127.0.0.1:4318, or
  * RIG_REVIEW_FRONT_PORT) so browser storage keeps one origin across reopens. `direct` keeps the worker's own port. */
-export async function openReview(inputs:OpenInputs,options:{stateDir?:string;idleMs?:number;direct?:boolean;frontPort?:number;frontIdleMs?:number}={}):Promise<{url:string;reused:boolean;nonce:string;inputs:OpenInputs;selection:AnimationSelection|null;direct:boolean}>{
+export async function openReview(inputs:OpenInputs,options:{stateDir?:string;idleMs?:number;direct?:boolean;frontPort?:number;frontIdleMs?:number}={}):Promise<{url:string;reused:boolean;nonce:string;inputs:OpenInputs;selection:AnimationSelection|null;direct:boolean;build:BuildOpen|null}>{
  const direct=options.direct??inputs.direct??false,port=direct?0:frontPort(options.frontPort);
  for(const path of [inputs.input,...(inputs.compare!==undefined?[inputs.compare]:[])])await assertOpenInput(path);
  if(inputs.compare!==undefined&&!inputs.reference)throw new Error('OPEN_REFERENCE_REQUIRED: compare: explicit --reference required');
@@ -108,7 +115,9 @@ export async function openReview(inputs:OpenInputs,options:{stateDir?:string;idl
  const control=join(stateDir,'open');await mkdir(control,{recursive:true,mode:0o700});const canonicalControl=await realpath(control);if((await lstat(control)).isSymbolicLink())throw new Error('open.state: control directory cannot be a symlink');
  const worker=await ensureWorker(p,key,fingerprint,stateDir,canonicalControl,options.idleMs??30*60*1000);
  const url=direct?openUrl(worker.row):openUrl(worker.row,await ensureFront({control:canonicalControl,port,fingerprint,idleMs:options.frontIdleMs}));
- return {url,reused:worker.reused,nonce:worker.row.nonce,inputs:p.inputs,selection:p.selection,direct};
+ // #149: the check package of a rig-parts build root says which package it opened and which config the handoff took.
+ const build=p.mode==='single'&&basename(p.p.root)==='check'&&await isBuildRoot(dirname(p.p.root))?{package:p.p.root,handoff:p.p.reviewedSource.handoff??null,reason:p.p.handoffReason}:null;
+ return {url,reused:worker.reused,nonce:worker.row.nonce,inputs:p.inputs,selection:p.selection,direct,build};
 }
 async function ensureWorker(p:OpenPackage,key:string,fingerprint:string,stateDir:string,canonicalControl:string,idleMs:number):Promise<{row:RecordFile;reused:boolean}>{
  const registry=join(canonicalControl,key+'.json'),claim=join(canonicalControl,key+'.claim'),nonce=randomUUID(),deadline=performance.now()+20000;