@rig-c/review 0.6.0 → 0.7.0

package/src/baseline.ts

@@ -0,0 +1,175 @@
+/**
+ * Baseline hold (#101): once per session, when the handoff and the producer both resolve, `rig-parts rig --config
+ * <config> --parts <parts> --out <scratch>/baseline` rebuilds the whole rig from the handoff into scratch under the review
+ * state directory, and what it writes (`PRODUCER_DOCUMENTS` and images/*, `src/producer-files.ts` — the same list the
+ * applied-state diff reads) is compared with the inspected rig directory, file by file. Reproduced means the handoff is what the inspected rig was built from, so an op that
+ * rebuilds the whole rig may run; otherwise the first differing path is named. Nothing is written into the package.
+ */
+import { createHash } from 'node:crypto';
+import { lstat, mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { Handoff } from './handoff.ts';
+import { isProducerFile, PRODUCER_DOCUMENTS, PRODUCER_IMAGES_DIR } from './producer-files.ts';
+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';
+
+export const BASELINE_SCHEMA = 'rig-review-baseline/1';
+export type BaselineStatus = 'running' | 'reproduced' | 'not-reproduced' | 'refused' | 'failed';
+export interface BaselineResult {
+  schema: typeof BASELINE_SCHEMA; key: string; status: BaselineStatus;
+  producer: { package: string; version: string };
+  /** The first path (relative to the package root) whose bytes differ or that only one side has; null when reproduced. */
+  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;
+  line: string; exitCode: number | null; wallMs: number | null;
+}
+const sha256 = (bytes: Uint8Array | string) => createHash('sha256').update(bytes).digest('hex');
+async function present(path: string): Promise<boolean> { try { await lstat(path); return true; } catch (e) { if ((e as NodeJS.ErrnoException).code === 'ENOENT') return false; throw e; } }
+
+/** A rig directory as {relative path: sha256}: its regular files and images/* (fixed places, not a search). */
+export async function rigTree(dir: string): Promise<Record<string, string>> {
+  const out: Record<string, string> = {};
+  for (const e of (await readdir(dir, { withFileTypes: true })).filter(e => e.isFile()).map(e => e.name).sort()) out[e] = sha256(await readFile(join(dir, e)));
+  const images = join(dir, PRODUCER_IMAGES_DIR);
+  if (await present(images)) for (const e of (await readdir(images, { withFileTypes: true })).filter(e => e.isFile()).map(e => e.name).sort()) out[`${PRODUCER_IMAGES_DIR}/${e}`] = sha256(await readFile(join(images, e)));
+  return out;
+}
+export const treeHash = (tree: Record<string, string>) => sha256(JSON.stringify(Object.keys(tree).sort().map(k => [k, tree[k]])));
+/**
+ * The first path, in sorted order, whose hash differs or that one side lacks; null when the two match. Compared: every
+ * file the baseline wrote, and on the inspected side the producer's documents and images (`isProducerFile`; a file there
+ * that rig never writes, such as a note, is not the producer's to reproduce).
+ */
+export function firstDifference(baseline: Record<string, string>, inspected: Record<string, string>): string | null {
+  const own = Object.keys(inspected).filter(isProducerFile);
+  for (const path of [...new Set([...Object.keys(baseline), ...own])].sort()) if (baseline[path] !== inspected[path]) return path;
+  if (!Object.keys(baseline).length) return 'rig.json';
+  return null;
+}
+/**
+ * The applied-state diff (#125): every producer document (`PRODUCER_DOCUMENTS`, the baseline's list) of a scratch rig
+ * directory against the inspected one, as JSON Pointers per file, and the images by hash only. A document neither side
+ * has is left out; one only one side has, or that does not parse as JSON on a side, differs at `""` (the whole
+ * document) unless its bytes are equal. Paths are capped at `MAX_DIFF_PATHS` per file; `count` is the full number.
+ */
+export async function producerDiff(inspectedDir: string, scratchDir: string): Promise<FilesDiff> {
+  const read = async (dir: string, name: string): Promise<{ bytes: Buffer | null; doc: unknown; parsed: boolean }> => {
+    let bytes: Buffer;
+    try { bytes = await readFile(join(dir, name)); } catch (e) { if ((e as NodeJS.ErrnoException).code === 'ENOENT') return { bytes: null, doc: undefined, parsed: false }; throw e; }
+    try { return { bytes, doc: JSON.parse(bytes.toString('utf8')) as unknown, parsed: true }; } catch { return { bytes, doc: undefined, parsed: false }; }
+  };
+  const documents: FilesDiff['documents'] = [];
+  for (const file of PRODUCER_DOCUMENTS) {
+    const before = await read(inspectedDir, file), after = await read(scratchDir, file);
+    if (!before.bytes && !after.bytes) continue;
+    const paths = before.parsed && after.parsed ? jsonDiff(before.doc, after.doc) : before.bytes && after.bytes && before.bytes.equals(after.bytes) ? [] : [''];
+    documents.push({ file, count: paths.length, paths: paths.slice(0, MAX_DIFF_PATHS) });
+  }
+  const images = async (dir: string) => Object.fromEntries(Object.entries(await rigTree(dir)).filter(([k]) => k.startsWith(`${PRODUCER_IMAGES_DIR}/`)));
+  const a = await images(inspectedDir), b = await images(scratchDir);
+  const names = [...new Set([...Object.keys(a), ...Object.keys(b)])].sort(), changed = names.filter(n => a[n] !== b[n]);
+  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 {
+  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}`;
+  return r.line;
+}
+/**
+ * For an op that rebuilds the whole rig (#102/#103): refuses unless the baseline reproduced the inspected rig.
+ * `remesh` does not call this; it holds its own REMESH_BASELINE_MISMATCH.
+ */
+export class BaselineError extends Error { constructor(readonly code: string, detail: string) { super(`${code}: ${detail}`); } }
+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);
+}
+
+/** Deterministic: the package, the handoff record and the producer. No clock. */
+export const baselineKey = (sourceHash: string, handoff: Handoff, producer: InstalledTool, compiler: InstalledTool) =>
+  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'>> {
+  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) } } };
+}
+
+/**
+ * Run (or reuse) the baseline into `dir`. `dir/result.json` holds a finished result; it is reused while the baseline
+ * output still hashes to what it recorded. The inspected rig is re-read every time.
+ */
+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 };
+  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);
+      if (now.hashes?.baseline.tree === stored.hashes?.baseline.tree) return { ...stored, ...now, line: baselineLine({ ...stored, ...now }) };
+    }
+  } catch { /* no reusable result */ }
+  await rm(dir, { recursive: true, force: true });
+  await mkdir(dir, { recursive: true, mode: 0o700 });
+  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 };
+  }
+  const compared = await compareBaseline(out, handoff.rig, show);
+  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 });
+  return result;
+}
+
+/**
+ * The inspected build's own check (#108, HQ ruling): once the baseline reproduces the inspected rig, `rig-parts check`
+ * runs on that baseline output — byte-identical to the inspected rig, so nothing reads or writes the package — into
+ * `<baseline dir>/inspected-check/`, with Apply's default pack flags (`--page-edges free --pack-shape polygon`). The
+ * summary is stored beside the baseline record (`inspected-check.json`) so a reload reads it instead of re-running.
+ * It is what the physics readout's BEFORE line quotes while the inspected build is on the stage.
+ */
+export const INSPECTED_CHECK_SCHEMA = 'rig-review-inspected-check/1';
+export type InspectedCheckStatus = 'running' | 'checked' | 'refused' | 'failed';
+export interface InspectedCheck {
+  schema: typeof INSPECTED_CHECK_SCHEMA; key: string; status: InspectedCheckStatus;
+  /** check's printed lines (the per-bar lines the readout quotes), capped. */
+  lines: string[]; check: CheckSummary | null;
+  /** The line to show: check's summary line, its named refusal verbatim, or "check running…". */
+  line: string; exitCode: number | null; wallMs: number | null;
+}
+export const INSPECTED_CHECK_FILE = 'inspected-check.json';
+export const INSPECTED_CHECK_RUNNING = 'check running… (rig-parts check of the inspected build, in the background)';
+export const inspectedCheckArgs = (parts: string): string[] => ['check', '--rig', 'baseline', '--out', 'inspected-check', '--parts', parts, '--page-edges', 'free', '--pack-shape', 'polygon'];
+export const runningInspectedCheck = (key: string): InspectedCheck => ({ schema: INSPECTED_CHECK_SCHEMA, key, status: 'running', lines: [], check: null, line: INSPECTED_CHECK_RUNNING, exitCode: null, wallMs: null });
+/** The stored record when it belongs to this baseline key and finished; null otherwise. */
+export async function storedInspectedCheck(dir: string, key: string): Promise<InspectedCheck | null> {
+  try {
+    const stored = JSON.parse(await readFile(join(dir, INSPECTED_CHECK_FILE), 'utf8')) as InspectedCheck;
+    return stored.schema === INSPECTED_CHECK_SCHEMA && stored.key === key && (stored.status === 'checked' || stored.status === 'refused') ? stored : null;
+  } catch { return null; }
+}
+/** Run (or reuse) the inspected build's check in `dir` (the baseline's directory, whose `baseline/` reproduced the inspected rig). */
+export async function runInspectedCheck(dir: string, key: string, parts: string, producer: InstalledTool): Promise<InspectedCheck> {
+  const stored = await storedInspectedCheck(dir, key);
+  if (stored) return stored;
+  await rm(join(dir, 'inspected-check'), { recursive: true, force: true });
+  const run = await runTool(producer.bin, inspectedCheckArgs(parts), { cwd: dir });
+  let json: unknown = null;
+  try { json = JSON.parse(await readFile(join(dir, 'inspected-check', 'check.json'), 'utf8')); } catch { /* check refused before writing it; its line says why */ }
+  const refusal = firstRefusal(run.lines), check = checkSummary(json, run.exitCode, run.lines, refusal);
+  const refused = json === null && run.exitCode !== 0;
+  const result: InspectedCheck = {
+    schema: INSPECTED_CHECK_SCHEMA, key, status: refused ? 'refused' : 'checked', lines: run.lines.slice(-4000), check: refused ? null : check,
+    line: refused ? refusal ?? `rig-parts check exited ${run.exitCode} without a named refusal` : check.line ?? `rig-parts check exited ${run.exitCode}`,
+    exitCode: run.exitCode, wallMs: run.wallMs,
+  };
+  await writeFile(join(dir, INSPECTED_CHECK_FILE), JSON.stringify(result, null, 1) + '\n', { mode: 0o600 });
+  return result;
+}

package/src/bone-anchors.ts

@@ -0,0 +1,123 @@
+/**
+ * Bone anchors (#109): the producer config's `bones` as the Setup Bones block edits them. A single bone is
+ * `{name, parent, at, tip?}` and a chain `{chain, parent, points, tip}` whose links are `<chain>0 … <chain>n`
+ * (rig-parts AUTHORING, `bones`); every coordinate is rig px, y down, the crop frame the chest and weights views map
+ * to the rig world. Each origin, chain point and tip is one anchor addressed by its JSON Pointer
+ * (`/bones/<i>/at`, `/bones/<i>/points/<k>`, `/bones/<i>/tip`); an edit is one `replace` op at that pointer naming the
+ * entry (a chain is named by its `chain`). A drag moves an anchor by a whole number of rig px, so a value the config
+ * writes in integers stays an integer. Pure: no IO, no DOM.
+ */
+import type {PatchOp} from './config-patch.ts';
+
+export type RigPoint=[number,number];
+export type AnchorKind='at'|'point'|'tip';
+/** One config `bones` entry as read: its index, its name (`name`, or `chain` for a chain) and its stated points. */
+export interface ConfigBone {index:number;name:string;chain:boolean;parent:string|null;at:RigPoint|null;points:RigPoint[];tip:RigPoint|null}
+/** One draggable anchor: where it sits in the config, which bone it belongs to and the value the config holds. */
+export interface BoneAnchor {path:string;index:number;name:string;kind:AnchorKind;link:number|null;value:RigPoint;label:string}
+/** A pending edit: one anchor's new value, with the config's value it was made from. */
+export interface BoneEdit {path:string;index:number;name:string;label:string;from:RigPoint;value:RigPoint}
+export class BoneAnchorError extends Error {constructor(readonly code:string,detail:string){super(`${code}: ${detail}`);}}
+
+const isObject=(v:unknown):v is Record<string,unknown>=>!!v&&typeof v==='object'&&!Array.isArray(v);
+const asPoint=(v:unknown):RigPoint|null=>Array.isArray(v)&&v.length===2&&v.every(n=>typeof n==='number'&&Number.isFinite(n))?[v[0] as number,v[1] as number]:null;
+
+/** The config's `bones` list read entry by entry; an entry with no name, or a malformed point, is named in `skipped`. */
+export function configBones(list:unknown):{bones:ConfigBone[];skipped:string[]} {
+ const bones:ConfigBone[]=[],skipped:string[]=[];
+ if(!Array.isArray(list))return {bones,skipped:list===undefined||list===null?[]:['bones is not a list']};
+ list.forEach((raw,index)=>{
+  if(!isObject(raw)){skipped.push(`bones[${index}] is not an object`);return;}
+  const chain=typeof raw.chain==='string'&&typeof raw.name!=='string',name=typeof raw.name==='string'?raw.name:typeof raw.chain==='string'?raw.chain:null;
+  if(!name){skipped.push(`bones[${index}] names no bone (no name or chain)`);return;}
+  const at=raw.at===undefined?null:asPoint(raw.at),tip=raw.tip===undefined?null:asPoint(raw.tip);
+  const points=Array.isArray(raw.points)?raw.points.map(asPoint):[];
+  if((raw.at!==undefined&&!at)||(raw.tip!==undefined&&!tip)||points.some(p=>!p)||(raw.points!==undefined&&!Array.isArray(raw.points))){skipped.push(`bones[${index}] "${name}" holds a point that is not [x, y]`);return;}
+  bones.push({index,name,chain,parent:typeof raw.parent==='string'?raw.parent:null,at,points:points as RigPoint[],tip});
+ });
+ return {bones,skipped};
+}
+
+/** Every anchor of every bone, in config order: a bone's origin then its tip; a chain's points then its tip. */
+export function boneAnchors(bones:readonly ConfigBone[]):BoneAnchor[] {
+ return bones.flatMap(b=>{
+  const out:BoneAnchor[]=[],base=`/bones/${b.index}`;
+  if(b.at)out.push({path:`${base}/at`,index:b.index,name:b.name,kind:'at',link:null,value:[...b.at],label:b.name});
+  b.points.forEach((p,k)=>out.push({path:`${base}/points/${k}`,index:b.index,name:b.name,kind:'point',link:k,value:[...p],label:`${b.name}${k}`}));
+  if(b.tip)out.push({path:`${base}/tip`,index:b.index,name:b.name,kind:'tip',link:null,value:[...b.tip],label:`${b.name} tip`});
+  return out;
+ });
+}
+
+/** Decimal places a value is written with (382.7 → 1, 416 → 0). */
+const places=(v:number)=>{const s=String(v),dot=s.indexOf('.');return dot<0||/e/i.test(s)?0:s.length-dot-1;};
+/** A pointer delta in rig px snapped to whole px (never -0). */
+export const snapDelta=(d:number)=>{const r=Math.round(d);return r===0?0:r;};
+/**
+ * A drag from `start` to `now` (both rig px) moves `from` by the delta snapped to whole px, written with the decimals
+ * `from` already has: an integer stays an integer, 382.7 + 7 is 389.7.
+ */
+export function dragAnchor(from:RigPoint,start:RigPoint,now:RigPoint):RigPoint {
+ return [0,1].map(i=>{const v=from[i]!+snapDelta(now[i]!-start[i]!);return Number(v.toFixed(places(from[i]!)));}) as RigPoint;
+}
+
+const same=(a:RigPoint,b:RigPoint)=>a[0]===b[0]&&a[1]===b[1];
+/** Set one anchor's value; a value equal to the config's removes its pending edit. */
+export function setAnchor(edits:ReadonlyMap<string,BoneEdit>,anchor:BoneAnchor,value:RigPoint):Map<string,BoneEdit> {
+ if(!value.every(Number.isFinite))throw new BoneAnchorError('BONES_VALUE_INVALID',`${anchor.label} must be two finite numbers`);
+ const next=new Map(edits);
+ if(same(value,anchor.value))next.delete(anchor.path);
+ else next.set(anchor.path,{path:anchor.path,index:anchor.index,name:anchor.name,label:anchor.label,from:[...anchor.value],value:[...value]});
+ return next;
+}
+/** Where each anchor stands now: its pending value, else the config's. */
+export const anchorAt=(anchor:BoneAnchor,edits:ReadonlyMap<string,BoneEdit>):RigPoint=>edits.get(anchor.path)?.value??anchor.value;
+/** The pending edits as config patch ops: `replace` at the anchor's pointer, naming the entry (bone resolved by name, index recorded). */
+export const boneOps=(edits:ReadonlyMap<string,BoneEdit>):PatchOp[]=>[...edits.values()].map(e=>({op:'replace',path:e.path,value:[...e.value],name:e.name}));
+
+export const BONES_DRAFT_SCHEMA='rig-review-bones-draft/1';
+export const draftText=(edits:ReadonlyMap<string,BoneEdit>)=>JSON.stringify({schema:BONES_DRAFT_SCHEMA,edits:[...edits.values()]});
+/** Edits back from a draft, kept only where the anchor still resolves (same pointer, same name, same config value). */
+export function draftEdits(text:string,anchors:readonly BoneAnchor[]):Map<string,BoneEdit> {
+ let doc:unknown;try{doc=JSON.parse(text);}catch{return new Map();}
+ if(!isObject(doc)||doc.schema!==BONES_DRAFT_SCHEMA||!Array.isArray(doc.edits))return new Map();
+ let edits=new Map<string,BoneEdit>();
+ for(const raw of doc.edits){
+  if(!isObject(raw))continue;const anchor=anchors.find(a=>a.path===raw.path),from=asPoint(raw.from),value=asPoint(raw.value);
+  if(!anchor||!from||!value||raw.name!==anchor.name||!same(from,anchor.value))continue;
+  edits=setAnchor(edits,anchor,value);
+ }
+ return edits;
+}
+
+const BONE_PATH=/^\/bones\/(0|[1-9][0-9]*)\/(at|tip|points\/(0|[1-9][0-9]*))$/;
+/** The Bones block's scope: every op replaces one anchor with a finite [x, y] and names its entry. */
+export function assertBoneOps(ops:readonly PatchOp[]):void {
+ for(const [i,op] of ops.entries()){
+  if(op.op!=='replace'||!BONE_PATH.test(op.path))throw new BoneAnchorError('BONES_OP_OUT_OF_SCOPE',`ops[${i}] ${op.op} ${op.path}: the Bones block replaces /bones/<i>/at, /bones/<i>/points/<k> or /bones/<i>/tip only (adding, removing or re-parenting bones is out of scope)`);
+  if(!asPoint(op.value))throw new BoneAnchorError('BONES_OP_OUT_OF_SCOPE',`ops[${i}] ${op.path}: the value must be [x, y] in rig px`);
+  if(typeof op.name!=='string')throw new BoneAnchorError('BONES_OP_OUT_OF_SCOPE',`ops[${i}] ${op.path}: the op must name its bone entry`);
+ }
+}
+
+/** Apply stays a choice: a LINT line blocks nothing, so only a running job or no pending edit disables it. */
+export const bonesApplyEnabled=(state:{busy:boolean;pending:number;lint:readonly string[]})=>!state.busy&&state.pending>0;
+
+/** `propose --from-config`'s lines, sorted: each LINT line, the LINT count line and the coverage lines, as printed. */
+export function proposeLines(lines:readonly string[]):{lint:string[];summary:string|null;coverage:string[]} {
+ const trimmed=lines.map(l=>l.trim());
+ return {lint:trimmed.filter(l=>/^LINT\s/.test(l)),summary:trimmed.find(l=>/^\d+ LINT line\(s\)/.test(l))??null,coverage:trimmed.filter(l=>/^coverage[\s:]/.test(l))};
+}
+export interface OriginRow {bone:string;distance:number|null;tip:number|null;text:string}
+/** `compare`'s per-bone origin and tip distances (null for a SKIP) and its summary lines (origin, tip, parent, length, direction). */
+export function compareOrigins(lines:readonly string[]):{origins:OriginRow[];summary:string[]} {
+ const origins:OriginRow[]=[],summary:string[]=[];
+ for(const raw of lines){
+  const line=raw.trim(),row=/^([^\s:]+): origin (?:(\d+(?:\.\d+)?) px|SKIP)/.exec(line);
+  if(row){const tip=/ · tip (\d+(?:\.\d+)?) px/.exec(line);origins.push({bone:row[1]!,distance:row[2]===undefined?null:Number(row[2]),tip:tip?Number(tip[1]):null,text:line});continue;}
+  if(/^(origin|tip|parent|length|direction): /.test(line))summary.push(line);
+ }
+ return {origins,summary};
+}
+/** The compare rows a reviewer reads after a move: every bone whose origin or tip moved, as printed. */
+export const movedRows=(rows:readonly OriginRow[])=>rows.filter(r=>(r.distance??0)>0||(r.tip??0)>0);

package/src/bones-check.ts

@@ -0,0 +1,105 @@
+/**
+ * `POST /api/bones-check` (#109): the Bones block's pending ops, checked before any Apply. The ops are applied to a
+ * scratch copy of the handoff config (written the way the patch runner writes it, `scratchConfigText`) under
+ * `<state>/bones-check/<package hash>/<ops hash>/`, then the installed producer reads it twice:
+ *  - `rig-parts propose --parts <handoff parts> --source <handoff source> --out propose --from-config config.json`:
+ *    its LINT lines, LINT count line and coverage lines, shown as printed (it exits 1 on any LINT; that blocks nothing);
+ *  - `rig-parts compare --left <handoff config> --right config.json`: each bone's origin distance and the summary lines.
+ * The client sends ops and the config hash only — never a path or a flag. Nothing is written into the package; the
+ * scratch directory is removed after the run.
+ */
+import { createHash } from 'node:crypto';
+import { isAbsolute, join, relative } from 'node:path';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import type { ReviewPackage } from './manifest.ts';
+import { firstRefusal, resolveProducer, runTool, type InstalledTool } from './producer.ts';
+import { applyConfigPatch, assertOpNames, assertPatchFresh, ConfigPatchError, CONFIG_PATCH_SCHEMA, parseConfigPatch, type JsonValue, type PatchOp } from './config-patch.ts';
+import { assertNamedFilesHeld, producerInputs, RebuildError, scratchConfigText } from './rebuild.ts';
+import { assertBoneOps, BoneAnchorError, compareOrigins, proposeLines, type OriginRow } from './bone-anchors.ts';
+
+export const BONES_CHECK_SCHEMA = 'rig-review-bones-check/1';
+export const BONES_CHECK_LIMIT = 64 * 1024;
+const MAX_LINES = 2000;
+const sha256 = (text: string) => createHash('sha256').update(text).digest('hex');
+
+/** What `propose --from-config` needs beyond the handoff config and parts, refused by name when the handoff lacks it. */
+export const BONES_SOURCE_UNAVAILABLE = 'MODELING_INPUT_UNAVAILABLE: source painting — propose --from-config reads the painting (--source) and the handoff declares none; declare it with rig-review open <dir> --config <path> --source <png> --full <dir> or the review.json "producer" block';
+export const proposeArgs = (r: { parts: string; source: string; config: string; out: string }): string[] => ['propose', '--parts', r.parts, '--source', r.source, '--out', r.out, '--from-config', r.config];
+export const compareArgs = (left: string, right: string): string[] => ['compare', '--left', left, '--right', right];
+
+export interface BonesLintResult {
+  status: 'ran' | 'unavailable';
+  exitCode: number | null; wallMs: number | null;
+  /** Each LINT line, the LINT count line and the coverage lines, as printed. */
+  lint: string[]; summary: string | null; coverage: string[];
+  /** The count line, a named refusal verbatim, or the unavailable line. */
+  line: string;
+}
+export interface BonesCompareResult { exitCode: number; wallMs: number; origins: OriginRow[]; summary: string[]; line: string }
+export interface BonesCheckResult {
+  schema: typeof BONES_CHECK_SCHEMA; status: 'checked';
+  request: { configHash: string; opsSha256: string; ops: PatchOp[] };
+  producer: { package: string; version: string };
+  propose: BonesLintResult; compare: BonesCompareResult;
+}
+
+/** `{ops, configHash}` only; each op a Bones-block op (`assertBoneOps`), typed as a config patch op. */
+export function parseBonesCheck(input: unknown): { ops: PatchOp[]; configHash: string } {
+  if (!input || typeof input !== 'object' || Array.isArray(input) || Object.keys(input).sort().join(',') !== 'configHash,ops') throw new RebuildError('REBUILD_REQUEST_INVALID', 'expected exactly {ops, configHash}');
+  const v = input as Record<string, unknown>;
+  if (typeof v.configHash !== 'string' || !/^[a-f0-9]{64}$/.test(v.configHash)) throw new RebuildError('REBUILD_REQUEST_INVALID', 'configHash');
+  let ops: PatchOp[];
+  try { ops = parseConfigPatch({ schema: CONFIG_PATCH_SCHEMA, config_sha256: v.configHash, ops: v.ops, producer: { name: 'check', version: 'check' }, op: { cmd: 'rig', args: [] } }).ops; }
+  catch (e) { if (e instanceof ConfigPatchError) throw new RebuildError(e.code, e.message.slice(e.code.length + 2)); throw e; }
+  try { assertBoneOps(ops); } catch (e) { if (e instanceof BoneAnchorError) throw new RebuildError(e.code, e.message.slice(e.code.length + 2)); throw e; }
+  return { ops, configHash: v.configHash };
+}
+
+/** One check at a time per review instance. */
+export function createBonesCheck(p: ReviewPackage, options: { stateDir: string; starts: readonly string[]; unchanged: () => Promise<void> }) {
+  let running = false;
+  async function run(input: unknown): Promise<BonesCheckResult> {
+    const { ops, configHash } = parseBonesCheck(input);
+    for (const root of [p.root, ...(p.handoff ? [p.handoff.root] : [])]) {
+      const inside = relative(root, options.stateDir);
+      if (inside === '' || !inside.startsWith('..') && !isAbsolute(inside)) throw new RebuildError('REBUILD_STATE_INSIDE_PACKAGE', 'the review state directory is inside the inspected package; set RIG_REVIEW_STATE_DIR outside it');
+    }
+    await options.unchanged();
+    const inputs = await producerInputs(p.handoff, p.handoffReason);
+    const original = JSON.parse(inputs.configText) as JsonValue;
+    let patched: JsonValue;
+    try { assertPatchFresh({ config_sha256: configHash }, inputs.configHash); assertOpNames(original, ops); patched = applyConfigPatch(original, ops); }
+    catch (e) { if (e instanceof ConfigPatchError) throw new RebuildError(e.code, e.message.slice(e.code.length + 2)); throw e; }
+    assertNamedFilesHeld(original, patched);
+    const resolved = resolveProducer(options.starts);
+    if (!resolved.ok) { const refusal = new RebuildError(resolved.error.split(/[ :]/)[0]!, ''); refusal.message = resolved.error; throw refusal; }
+    if (running) throw new RebuildError('BONES_CHECK_BUSY', 'a bones check is still running');
+    running = true;
+    const opsSha256 = sha256(JSON.stringify(ops)), dir = join(options.stateDir, 'bones-check', p.sourceHash, opsSha256);
+    try {
+      await rm(dir, { recursive: true, force: true });
+      await mkdir(dir, { recursive: true, mode: 0o700 });
+      await writeFile(join(dir, 'config.json'), scratchConfigText(inputs.config, patched), { mode: 0o600 });
+      const propose = await lint(resolved.producer, dir, inputs.parts, p.handoff?.source ?? null);
+      const cmp = await runTool(resolved.producer.bin, compareArgs(inputs.config, 'config.json'), { cwd: dir });
+      const read = compareOrigins(cmp.lines);
+      const compare: BonesCompareResult = { exitCode: cmp.exitCode, wallMs: cmp.wallMs, ...read, line: cmp.exitCode === 0 ? read.summary.find(l => l.startsWith('origin:')) ?? 'compare: no origin line' : firstRefusal(cmp.lines) ?? `rig-parts compare exited ${cmp.exitCode} without a named refusal` };
+      try { await options.unchanged(); } catch { throw new RebuildError('REBUILD_INPUTS_CHANGED', 'the package or its producer handoff changed during the check'); }
+      return { schema: BONES_CHECK_SCHEMA, status: 'checked', request: { configHash, opsSha256, ops }, producer: { package: resolved.producer.package, version: resolved.producer.version }, propose, compare };
+    } finally {
+      running = false;
+      await rm(dir, { recursive: true, force: true }).catch(() => {});
+    }
+  }
+  return { run };
+}
+
+/** `propose --from-config` on the scratch config, or the line naming the missing source painting. */
+async function lint(producer: InstalledTool, dir: string, parts: string, source: string | null): Promise<BonesLintResult> {
+  if (!source) return { status: 'unavailable', exitCode: null, wallMs: null, lint: [], summary: null, coverage: [], line: BONES_SOURCE_UNAVAILABLE };
+  const run = await runTool(producer.bin, proposeArgs({ parts, source, config: 'config.json', out: 'propose' }), { cwd: dir });
+  const read = proposeLines(run.lines.slice(0, MAX_LINES));
+  // Exit 1 with LINT lines is propose's verdict on the bones, not a refusal; exit 1 with none is a refusal, quoted.
+  const refusal = run.exitCode !== 0 && !read.lint.length ? firstRefusal(run.lines) ?? `rig-parts propose exited ${run.exitCode} without a named refusal` : null;
+  return { status: 'ran', exitCode: run.exitCode, wallMs: run.wallMs, ...read, line: refusal ?? read.summary ?? `rig-parts propose exited ${run.exitCode}` };
+}

package/src/build-route.ts

@@ -0,0 +1,109 @@
+/**
+ * Which config patches need `rig-parts build` (#115): the cut, patch and limb sections are read by the producer's
+ * assemble stage, which makes the parts from the painting and its See-through runs before the rig is built, so an edit
+ * there is invisible to `rig --config --parts` (it reads the parts the inspected build already assembled). rig-parts
+ * AUTHORING §3: `assemble.patches` and `assemble.cuts` are read by "assemble", and `limbs` by "assemble (the cut and the
+ * caps), rig (through `regions`), check (`LIMB_ONE_BONE`)"; with `limbs`, "`assemble` reads `bones` too" — a limb's
+ * joint is its lower bone's origin, so a bone edit on a config that declares limbs moves a cut and needs assemble as
+ * well. `rig-parts build` runs assemble, rig and check in one process and needs the painting (`--source`) and the
+ * See-through runs (`--full`, `--head`) the handoff declares.
+ *
+ * The assemble stage also reads files the config names relative to its own directory (rig-parts `src/build.ts`:
+ * `readUnders`, `readCaps`, and the alternates' `source` / `full` / `head` / `skeleton`). A patch may not name a new one
+ * (`EDIT_PATCH_PATH_HELD`): review never sends a path, so an `under` or a `cap` can only be one the config already
+ * names. Pure: no IO.
+ */
+import { parsePointer, type JsonValue, type PatchOp } from './config-patch.ts';
+
+/** The pointer prefixes whose ops only `build` carries. */
+export const BUILD_PATHS: readonly (readonly string[])[] = [['assemble'], ['limbs']];
+/** With `limbs` declared, a bone edit is also a cut edit (the joint is the bone's origin). */
+export const LIMB_BONE_PATH: readonly string[] = ['bones'];
+
+const isObject = (v: unknown): v is Record<string, unknown> => !!v && typeof v === 'object' && !Array.isArray(v);
+const under = (tokens: readonly string[], prefix: readonly string[]) => prefix.length <= tokens.length && prefix.every((t, i) => tokens[i] === t);
+
+/** True when a `rig` patch needs the build: any op under `/assemble` or `/limbs`, or under `/bones` on a config that declares `limbs`. */
+export function needsBuild(ops: readonly Pick<PatchOp, 'path'>[], config: unknown): boolean {
+  const limbs = isObject(config) && config.limbs !== undefined;
+  return ops.some(op => { const t = parsePointer(op.path); return BUILD_PATHS.some(p => under(t, p)) || (limbs && under(t, LIMB_BONE_PATH)); });
+}
+
+/** One config-relative file the assemble stage reads: where it is named and the value as written. */
+export interface BuildNamedFile { field: string; role: 'under' | 'cap' | 'source' | 'full' | 'head' | 'skeleton'; value: string; kind: 'file' | 'dir' }
+
+/** Every config-relative path the build's assemble stage reads (besides the two `rig` reads, `CONFIG_NAMED_FILES`). */
+export function buildNamedFiles(config: unknown): BuildNamedFile[] {
+  const out: BuildNamedFile[] = [];
+  if (!isObject(config)) return out;
+  const assemble = isObject(config.assemble) ? config.assemble : {};
+  const cuts = (list: unknown, at: string) => { if (Array.isArray(list)) list.forEach((q, i) => { if (isObject(q) && typeof q.under === 'string' && q.under) out.push({ field: `${at}[${i}].under`, role: 'under', value: q.under, kind: 'file' }); }); };
+  cuts(assemble.cuts, 'assemble.cuts');
+  if (Array.isArray(assemble.alternates)) assemble.alternates.forEach((a, i) => {
+    if (!isObject(a)) return;
+    for (const [role, kind] of [['source', 'file'], ['full', 'dir'], ['head', 'dir'], ['skeleton', 'file']] as const) if (typeof a[role] === 'string' && a[role]) out.push({ field: `assemble.alternates[${i}].${role}`, role, value: a[role] as string, kind });
+    cuts(a.cuts, `assemble.alternates[${i}].cuts`);
+  });
+  if (isObject(config.limbs)) for (const [limb, entry] of Object.entries(config.limbs)) {
+    if (!isObject(entry) || !Array.isArray(entry.segments)) continue;
+    entry.segments.forEach((sg, k) => { if (isObject(sg) && typeof sg.cap === 'string' && sg.cap) out.push({ field: `limbs.${limb}.segments[${k}].cap`, role: 'cap', value: sg.cap, kind: 'file' }); });
+  }
+  return out;
+}
+
+/**
+ * `null` when every file the patched config names for the assemble stage is one the handoff config already names in the
+ * same role (a cut may drop its `under`, a cut may go, an `under` may move to another cut — but no new path); else the
+ * first field that names a new one.
+ */
+export function newBuildFile(original: JsonValue, patched: JsonValue): string | null {
+  const held = new Set(buildNamedFiles(original).map(f => `${f.role}\u0000${f.value}`));
+  return buildNamedFiles(patched).find(f => !held.has(`${f.role}\u0000${f.value}`))?.field ?? null;
+}
+
+/** The patched config with every assemble-read path made absolute against the handoff config's directory (`resolve`). */
+export function absolutizeBuildFiles(doc: Record<string, unknown>, resolve: (value: string) => string): void {
+  const fix = (holder: unknown, key: string) => { if (isObject(holder) && typeof holder[key] === 'string' && holder[key]) holder[key] = resolve(holder[key] as string); };
+  const assemble = isObject(doc.assemble) ? doc.assemble : null;
+  const cuts = (list: unknown) => { if (Array.isArray(list)) for (const q of list) fix(q, 'under'); };
+  if (assemble) {
+    cuts(assemble.cuts);
+    if (Array.isArray(assemble.alternates)) for (const a of assemble.alternates) { for (const k of ['source', 'full', 'head', 'skeleton']) fix(a, k); if (isObject(a)) cuts(a.cuts); }
+  }
+  if (isObject(doc.limbs)) for (const entry of Object.values(doc.limbs)) if (isObject(entry) && Array.isArray(entry.segments)) for (const sg of entry.segments) fix(sg, 'cap');
+}
+
+/**
+ * The build's own lines, read for review (prefix `[assemble]`, `[rig]`, `[check]` stripped): every `FAIL` line (the
+ * refusals, verbatim), the `cut:` / `limb cut:` / `limb cap:` lines, `recomposite vs source`, the uncovered holes, the
+ * `seam:` and `seam pair` lines, and check's last `check: …` line.
+ */
+export interface BuildReadout { refusals: string[]; assemble: string[]; recomposite: string | null; seam: string[]; seamPairs: string[]; check: string | null }
+export const MAX_BUILD_READOUT = 64;
+const stripStage = (line: string) => line.replace(/^\s*\[[a-z]+\]\s?/, '').trim();
+export function buildReadout(lines: readonly string[]): BuildReadout {
+  const out: BuildReadout = { refusals: [], assemble: [], recomposite: null, seam: [], seamPairs: [], check: null };
+  for (const raw of lines) {
+    const line = stripStage(raw);
+    if (/^FAIL\s+[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+\b/.test(line)) { if (out.refusals.length < MAX_BUILD_READOUT) out.refusals.push(line); continue; }
+    if (/^(cut|limb cut|limb cap):\s/.test(line) || /^uncovered hole \d+:/.test(line)) { if (out.assemble.length < MAX_BUILD_READOUT) out.assemble.push(line); continue; }
+    if (/^recomposite vs source:/.test(line)) { out.recomposite = line; continue; }
+    // The base set's pairs only; an alternate set's own pairs read `seam pair (<set>) …`.
+    if (/^seam pair \d+ of \d+:/.test(line)) { if (out.seamPairs.length < MAX_BUILD_READOUT) out.seamPairs.push(line); continue; }
+    if (/^seam:\s/.test(line)) { out.seam.push(line); continue; }
+    if (/^check:\s/.test(line)) out.check = line;
+  }
+  return out;
+}
+/** The lines with the stage prefix stripped, for check's summary and the first-refusal reader. */
+export const buildLines = (lines: readonly string[]) => lines.map(stripStage);
+
+/** `parts.json`'s `recomposite` block figures (rig-parts AUTHORING §5), or null without one. */
+export interface RecompositeFigures { mean_abs: number; within_share: number; error_px: number; uncovered_error_px: number; hole_count: number }
+export function recompositeFigures(partsJson: unknown): RecompositeFigures | null {
+  const block = isObject(partsJson) && isObject(partsJson.recomposite) ? partsJson.recomposite : null;
+  if (!block) return null;
+  const keys = ['mean_abs', 'within_share', 'error_px', 'uncovered_error_px', 'hole_count'] as const;
+  if (!keys.every(k => typeof block[k] === 'number' && Number.isFinite(block[k]))) return null;
+  return Object.fromEntries(keys.map(k => [k, block[k] as number])) as unknown as RecompositeFigures;
+}