@rig-c/review 0.8.1 → 0.10.0

package/src/retune-check.ts

@@ -1,16 +1,18 @@
 /**
  * #139: a retune Apply reads the check retune already ran on its revision instead of running `rig-parts check` a second
- * time. `rig-parts retune` gates the revision and checks it (`checkStage` over the staged revision, the same `--parts`
- * and pack flags review passes) before it writes `retune.json`; from `@rig-c/parts` 1.49.0 (parts#541, its CHANGELOG:
- * "remesh,retune: the provenance carries check's final line and every block's status, as check itself reports") each
- * check side also carries `line` — check's own last line, composed by the one function check prints it from — and
- * `status` — every block's status as that tree's `check.json` records it, in the file's order. The writer
- * (`src/retune.ts`): `revision: hashRows(revision)` and `check: { ...sides, scope }` with
+ * time; #174: a remesh Apply reads remesh's check the same way. `rig-parts retune` and `rig-parts remesh` gate the revision
+ * and check it (`checkStage` over the staged revision, the same `--parts` and pack flags review passes) before they
+ * write their provenance; from `@rig-c/parts` 1.49.0 (parts#541, its CHANGELOG: "remesh,retune: the provenance carries
+ * check's final line and every block's status, as check itself reports") each check side also carries `line` — check's
+ * own last line, composed by the one function check prints it from — and `status` — every block's status as that
+ * tree's `check.json` records it, in the file's order. The writers (`src/retune.ts`, `src/remesh.ts`):
+ * `revision: hashRows(revision)` and `check: { ...sides, scope }` with
  * `sides = { input: checkSide(inCheck), revision: checkSide(revCheck) }`.
  *
  * The carried side is bound to the files by the `revision` hash rows: every row's file in the scratch revision must
- * hash to its row, none missing and none extra (`RETUNE_CHECK_STALE`). A `retune.json` without `line` and `status` (an
- * older producer) is not refused: the caller falls back to running check. Pure but for the binding's reads.
+ * hash to its row, none missing and none extra (`RETUNE_CHECK_STALE` / `REMESH_CHECK_STALE`). A provenance without
+ * `line` and `status` (an older producer) is not refused: the caller falls back to running check. Pure but for the
+ * binding's reads.
  */
 import { createHash } from 'node:crypto';
 import { readdir, readFile } from 'node:fs/promises';
@@ -19,9 +21,21 @@ import { CHECK_SUMMARY_SCHEMA, type CheckSummary } from './applied-context.ts';
 
 /** The first `@rig-c/parts` release whose `retune.json` check sides carry `line` and `status` (CHANGELOG 1.49.0, parts#541). */
 export const RETUNE_CHECK_SINCE = '1.49.0';
+/** The same release for `remesh.json` (one change carried both, parts#541). */
+export const REMESH_CHECK_SINCE = '1.49.0';
 /** retune's provenance file, at the revision's root (parts `RETUNE_FILE`). */
 export const RETUNE_FILE = 'retune.json';
+/** remesh's provenance file, at the revision's root (parts `PROVENANCE_FILE`). */
+export const REMESH_FILE = 'remesh.json';
 export const RETUNE_CHECK_STALE = 'RETUNE_CHECK_STALE';
+export const REMESH_CHECK_STALE = 'REMESH_CHECK_STALE';
+
+/** The producer ops whose provenance carries the check they ran on their revision. */
+export type CarryingOp = 'retune' | 'remesh';
+const FILE: Record<CarryingOp, string> = { retune: RETUNE_FILE, remesh: REMESH_FILE };
+const STALE: Record<CarryingOp, string> = { retune: RETUNE_CHECK_STALE, remesh: REMESH_CHECK_STALE };
+/** The op's provenance file name. */
+export const provenanceFile = (op: CarryingOp): string => FILE[op];
 
 const isObject = (v: unknown): v is Record<string, unknown> => !!v && typeof v === 'object' && !Array.isArray(v);
 /** check.json's bar keys as review's `checkSummary` reads them: an upper-case name. */
@@ -36,16 +50,17 @@ export interface CarriedCheck { pass: boolean; line: string; status: Record<stri
  * {@link RETUNE_CHECK_SINCE}). A side with one of them and not the other, or with a malformed one, throws: that is not
  * an older producer and not a check review can record.
  */
-export function carriedCheck(retune: unknown): CarriedCheck | null {
-  const side = isObject(retune) && isObject(retune.check) ? retune.check.revision : undefined;
+export function carriedCheck(provenance: unknown, op: CarryingOp = 'retune'): CarriedCheck | null {
+  const file = FILE[op];
+  const side = isObject(provenance) && isObject(provenance.check) ? provenance.check.revision : undefined;
   // No side at all carries neither field either: check runs, as for an older producer.
   if (!isObject(side)) return null;
   const hasLine = Object.hasOwn(side, 'line'), hasStatus = Object.hasOwn(side, 'status');
   if (!hasLine && !hasStatus) return null;
-  if (typeof side.line !== 'string' || !/^check: (PASS|FAIL)/.test(side.line)) throw new Error(`${RETUNE_FILE}: check.revision.line is not check's last line`);
-  if (!isObject(side.status) || !Object.values(side.status).every(s => typeof s === 'string' && STATUSES.has(s))) throw new Error(`${RETUNE_FILE}: check.revision.status is not {block: status}`);
-  if (side.status.gate !== 'PASS' && side.status.gate !== 'FAIL') throw new Error(`${RETUNE_FILE}: check.revision.status.gate is not PASS or FAIL`);
-  if (typeof side.pass !== 'boolean') throw new Error(`${RETUNE_FILE}: check.revision.pass is not a boolean`);
+  if (typeof side.line !== 'string' || !/^check: (PASS|FAIL)/.test(side.line)) throw new Error(`${file}: check.revision.line is not check's last line`);
+  if (!isObject(side.status) || !Object.values(side.status).every(s => typeof s === 'string' && STATUSES.has(s))) throw new Error(`${file}: check.revision.status is not {block: status}`);
+  if (side.status.gate !== 'PASS' && side.status.gate !== 'FAIL') throw new Error(`${file}: check.revision.status.gate is not PASS or FAIL`);
+  if (typeof side.pass !== 'boolean') throw new Error(`${file}: check.revision.pass is not a boolean`);
   return { pass: side.pass, line: side.line, status: side.status as Record<string, string> };
 }
 
@@ -55,19 +70,22 @@ export function carriedCheck(retune: unknown): CarriedCheck | null {
  * check` exits `r.figures.PASS ? EXIT_OK : EXIT_REFUSED`); `line` ← `line` (check's last line, byte for byte);
  * `bars` ← every upper-case entry of `status` (check.json's top-level blocks with a `status`, in the file's order; the
  * figure-read `gate`, `loop` and `seam` are lower-case and are not bars in check.json); `gate` ← `status.gate` is
- * `PASS` (`gate_spine_html_green === true`, the one way `barsNotMet` leaves `gate` out). `source` says where it came from.
+ * `PASS` (`gate_spine_html_green === true`, the one way `barsNotMet` leaves `gate` out). `source` says which op's check it is.
  */
-export function retuneCheckSummary(carried: CarriedCheck): CheckSummary {
+export function carriedCheckSummary(carried: CarriedCheck, source: CarryingOp): CheckSummary {
   const bars: Record<string, string> = {};
   for (const [name, status] of Object.entries(carried.status)) if (BAR.test(name)) bars[name] = status;
-  return { schema: CHECK_SUMMARY_SCHEMA, pass: carried.pass, exitCode: carried.pass ? 0 : 1, line: carried.line, bars, gate: carried.status.gate === 'PASS', source: 'retune' };
+  return { schema: CHECK_SUMMARY_SCHEMA, pass: carried.pass, exitCode: carried.pass ? 0 : 1, line: carried.line, bars, gate: carried.status.gate === 'PASS', source };
 }
 
+/** #139's name for {@link carriedCheckSummary} of a retune. */
+export const retuneCheckSummary = (carried: CarriedCheck): CheckSummary => carriedCheckSummary(carried, 'retune');
+
 /** The `revision` hash rows, or a refusal when they are not rows. */
-function revisionRows(retune: unknown): RetuneRevisionRow[] | string {
-  const rows = isObject(retune) ? retune.revision : undefined;
-  if (!Array.isArray(rows) || rows.length === 0) return `${RETUNE_CHECK_STALE}: ${RETUNE_FILE} names no revision hash rows; its check is bound to no files`;
-  for (const r of rows) if (!isObject(r) || typeof r.path !== 'string' || !r.path || typeof r.sha256 !== 'string' || !/^[0-9a-f]{64}$/.test(r.sha256)) return `${RETUNE_CHECK_STALE}: ${RETUNE_FILE} has a revision row that is not {path, bytes, sha256}`;
+function revisionRows(provenance: unknown, op: CarryingOp): RetuneRevisionRow[] | string {
+  const rows = isObject(provenance) ? provenance.revision : undefined;
+  if (!Array.isArray(rows) || rows.length === 0) return `${STALE[op]}: ${FILE[op]} names no revision hash rows; its check is bound to no files`;
+  for (const r of rows) if (!isObject(r) || typeof r.path !== 'string' || !r.path || typeof r.sha256 !== 'string' || !/^[0-9a-f]{64}$/.test(r.sha256)) return `${STALE[op]}: ${FILE[op]} has a revision row that is not {path, bytes, sha256}`;
   return rows as RetuneRevisionRow[];
 }
 
@@ -80,21 +98,23 @@ async function files(root: string): Promise<string[]> {
 
 /**
  * The binding: every `revision` row's file under `dir` hashes to its row, none is missing, and `dir` holds no file
- * but those rows and `retune.json`. Null when bound; otherwise the first mismatch as
- * `RETUNE_CHECK_STALE: <file> sha256 <in retune.json> … <on disk>` (`absent` on the side that has no such file).
+ * but those rows and the op's provenance file. Null when bound; otherwise the first mismatch as
+ * `RETUNE_CHECK_STALE: <file> sha256 <in retune.json> … <on disk>` (`REMESH_CHECK_STALE` … `remesh.json` for a remesh;
+ * `absent` on the side that has no such file).
  */
-export async function revisionBinding(dir: string, retune: unknown): Promise<string | null> {
-  const rows = revisionRows(retune);
+export async function revisionBinding(dir: string, provenance: unknown, op: CarryingOp = 'retune'): Promise<string | null> {
+  const rows = revisionRows(provenance, op), file = FILE[op];
+  const stale = (path: string, recorded: string, actual: string) => `${STALE[op]}: ${path} sha256 ${recorded} in ${file} … ${actual} on disk; ${op}'s check is not this revision's, so no build is recorded`;
   if (typeof rows === 'string') return rows;
   const onDisk = await files(dir), named = new Set(rows.map(r => r.path));
   for (const row of rows) {
     let actual = 'absent';
     if (onDisk.includes(row.path)) actual = createHash('sha256').update(await readFile(join(dir, ...row.path.split('/')))).digest('hex');
-    if (actual !== row.sha256) return `${RETUNE_CHECK_STALE}: ${row.path} sha256 ${row.sha256} in ${RETUNE_FILE} … ${actual} on disk; retune's check is not this revision's, so no build is recorded`;
+    if (actual !== row.sha256) return stale(row.path, row.sha256, actual);
   }
-  for (const path of onDisk) if (path !== RETUNE_FILE && !named.has(path)) {
+  for (const path of onDisk) if (path !== file && !named.has(path)) {
     const actual = createHash('sha256').update(await readFile(join(dir, ...path.split('/')))).digest('hex');
-    return `${RETUNE_CHECK_STALE}: ${path} sha256 absent in ${RETUNE_FILE} … ${actual} on disk; retune's check is not this revision's, so no build is recorded`;
+    return stale(path, 'absent', actual);
   }
   return null;
 }

package/src/server.ts

@@ -7,6 +7,7 @@ import {assertReviewUnchanged,referenceBinding,selectedReference,safeSelectedRef
 import {openGate,staleOpenStatus,accessGate,openNonceGate,stampOpen,type OpenIdentity} from './open-protocol.ts';
 import { readSession, saveSession } from './session.ts';
 import { createRebuilds, RebuildError } from './rebuild.ts';
+import { DENSITY_STRIP_LIMIT } from './density-strip.ts';
 import { createReadings } from './readings-run.ts';
 import { ReadingsError } from './readings.ts';
 import { BONES_CHECK_LIMIT, createBonesCheck } from './bones-check.ts';
@@ -17,7 +18,7 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 const headers={ 'X-Content-Type-Options':'nosniff','Cache-Control':'no-store','Content-Security-Policy':"default-src 'none'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' blob: data:; media-src 'self'; connect-src 'self'; font-src 'self'; base-uri 'none'; frame-ancestors 'none'; form-action 'none'",'Referrer-Policy':'no-referrer'};
 /** Request shapes the page or an edit card got wrong: 400. Everything else a refusal names is an outcome (200). */
-const MALFORMED=new Set(['REBUILD_REQUEST_INVALID','EDIT_PATCH_INVALID','EDIT_PATCH_OP_UNKNOWN','EDIT_PATCH_POINTER_INVALID','EDIT_PATCH_CMD_UNKNOWN','EDIT_PATCH_ARG_UNKNOWN','BONES_OP_OUT_OF_SCOPE','RETARGET_REQUEST_INVALID']);
+const MALFORMED=new Set(['REBUILD_REQUEST_INVALID','DENSITY_STRIP_REQUEST_INVALID','DENSITY_STRIP_FIELD','MESH_PATCH_SCOPE','EDIT_PATCH_INVALID','EDIT_PATCH_OP_UNKNOWN','EDIT_PATCH_POINTER_INVALID','EDIT_PATCH_CMD_UNKNOWN','EDIT_PATCH_ARG_UNKNOWN','BONES_OP_OUT_OF_SCOPE','RETARGET_REQUEST_INVALID']);
 function json(data:unknown,status=200){return Response.json(data,{status,headers});}
 async function bodyJson(req:Request,limit=1024*1024,what='Session payload exceeds 1 MiB'):Promise<unknown>{
   if(!/^application\/json(?:\s*;|$)/i.test(req.headers.get('content-type')??''))throw new Error('Expected application/json');
@@ -28,11 +29,11 @@ async function bodyJson(req:Request,limit=1024*1024,what='Session payload exceed
 }
 /** `capability` (open workers and foreground CLI serving) gates every non-GET request; tests may omit it.
  * `cwd` is where the producer is looked for after the package's own directories (review's working directory by default). */
-export async function startServer(p:ReviewPackage,options:{port?:number;stateDir?:string;open?:OpenIdentity;initialAnimation?:string;activity?:()=>void;control?:ControlIdentity;capability?:string;cwd?:string}={}){
+export async function startServer(p:ReviewPackage,options:{port?:number;stateDir?:string;open?:OpenIdentity;initialAnimation?:string;activity?:()=>void;control?:ControlIdentity;capability?:string;cwd?:string;stripConcurrency?:number}={}){
   const bundle=await buildWeb();
   const unchanged=()=>assertReviewUnchanged(p);
   const stateDir=options.stateDir??process.env.RIG_REVIEW_STATE_DIR??join(homedir(),'.local','state','rig-c-review'),starts=[p.root,options.cwd??process.cwd()];
-  const rebuilds=createRebuilds(p,{stateDir,starts,unchanged,bones:p.feedbackCatalog.bones});
+  const rebuilds=createRebuilds(p,{stateDir,starts,unchanged,bones:p.feedbackCatalog.bones,...(options.stripConcurrency?{stripConcurrency:options.stripConcurrency}:{})});
   // Readings (#108): rigc render's readings on the inspected build and on the latest scratch build, into scratch.
   const readings=createReadings(p,{stateDir,starts,unchanged,latest:rebuilds.latest});
   // Bones check (#109): propose --from-config and compare on a scratch copy of the patched handoff config.
@@ -59,6 +60,23 @@ export async function startServer(p:ReviewPackage,options:{port?:number;stateDir
       // A refusal is an outcome the page shows verbatim (200), so the managed front passes its text through; only a malformed request is a 400.
       catch(e){if(e instanceof RebuildError)return json({status:'refused',error:e.message,producerLine:null},MALFORMED.has(e.code)?400:200);throw e;}
     }
+    // #166: undo the last Apply — {from: <the build id on the stage>}; nothing is read from the client but that id.
+    if(req.method==='POST'&&url.pathname==='/api/rebuild/undo'){
+      if(req.headers.get('origin')!==origin)return json({error:'Same-origin Origin required'},403);
+      try{const result=await rebuilds.undo(await bodyJson(req,1024,'REBUILD_BODY_LIMIT: maximum 1 KiB'));return json(result.body,result.status);}
+      catch(e){if(e instanceof RebuildError)return json({status:'refused',error:e.message,producerLine:null},MALFORMED.has(e.code)?400:200);throw e;}
+    }
+    // #173: a density strip — 2–5 Mesh-panel patches built side by side, none applied; and closing it (its scratch removed).
+    if(req.method==='POST'&&url.pathname==='/api/density-strip'){
+      if(req.headers.get('origin')!==origin)return json({error:'Same-origin Origin required'},403);
+      try{const result=await rebuilds.startStrip(await bodyJson(req,DENSITY_STRIP_LIMIT,'DENSITY_STRIP_BODY_LIMIT: maximum 320 KiB'));return json(result.body,result.status);}
+      catch(e){if(e instanceof RebuildError)return json({status:'refused',error:e.message,producerLine:null},MALFORMED.has(e.code)?400:200);throw e;}
+    }
+    if(req.method==='POST'&&url.pathname==='/api/density-strip/close'){
+      if(req.headers.get('origin')!==origin)return json({error:'Same-origin Origin required'},403);
+      try{const result=await rebuilds.closeStrip(await bodyJson(req,1024,'DENSITY_STRIP_BODY_LIMIT: maximum 1 KiB'));return json(result.body,result.status);}
+      catch(e){if(e instanceof RebuildError)return json({status:'refused',error:e.message,producerLine:null},MALFORMED.has(e.code)?400:200);throw e;}
+    }
     if(req.method==='POST'&&url.pathname==='/api/bones-check'){
       if(req.headers.get('origin')!==origin)return json({error:'Same-origin Origin required'},403);
       try{return json(await bonesCheck.run(await bodyJson(req,BONES_CHECK_LIMIT,'BONES_CHECK_BODY_LIMIT: maximum 64 KiB')));}
@@ -88,6 +106,15 @@ export async function startServer(p:ReviewPackage,options:{port?:number;stateDir
       if(url.pathname==='/api/review'){await unchanged();return json({manifest:p.manifest,initialAnimation:options.initialAnimation??null,sourceHash:p.sourceHash,reviewedSource:p.reviewedSource,...(referenceBinding(p)?{referenceBinding:referenceBinding(p),explicitReference:{...referenceBinding(p)!.reference,url:'/review-reference'}}:{}),report:p.report,feedbackCatalog:p.feedbackCatalog,assetsBase:'/assets/',capabilities:{playback:!!p.manifest.model,modeling:false,motion:false,feedback:true,audio:true}});}
       if(url.pathname==='/api/session'){await unchanged();return json(await readSession(p,options.stateDir));}
       if(url.pathname==='/api/rebuild')return json(await rebuilds.describe());
+      if(url.pathname==='/api/rebuild/history')return json(await rebuilds.history());
+      if(url.pathname==='/api/density-strip')return json({strip:rebuilds.readStrip()});
+      const stripStatus=/^\/api\/density-strip\/([a-f0-9]{64})(?:\/([a-f0-9]{64}))?$/.exec(url.pathname);
+      if(stripStatus){try{return json(stripStatus[2]?rebuilds.stripJob(stripStatus[1]!,stripStatus[2]):rebuilds.readStrip(stripStatus[1]!));}catch(e){if(e instanceof RebuildError)return json({error:e.message},404);throw e;}}
+      const stripFile=/^\/density-strip\/([a-f0-9]{64})\/([a-f0-9]{64})\/(.+)$/.exec(url.pathname);
+      if(stripFile){
+        let full:string;try{full=await rebuilds.stripFile(stripFile[1]!,stripFile[2]!,decodeURIComponent(stripFile[3]!));}catch(e){return json({error:e instanceof Error?e.message:'Not found'},404);}
+        const file=Bun.file(full);return new Response(req.method==='HEAD'?null:file,{headers:{...headers,'Content-Security-Policy':"default-src 'none'; script-src 'none'; sandbox",'Content-Type':file.type||'application/octet-stream','Content-Length':String(file.size)}});
+      }
       const rebuildStatus=/^\/api\/rebuild\/([a-f0-9]{64})$/.exec(url.pathname);
       if(rebuildStatus){try{return json(rebuilds.read(rebuildStatus[1]!));}catch(e){if(e instanceof RebuildError)return json({error:e.message},404);throw e;}}
       if(url.pathname==='/api/requirements')return json(await requirements.describe());

package/web/cloth-panel.ts

@@ -12,6 +12,7 @@
  */
 import {ClothFieldError,fieldText,recipeFromFields,recipeOps,RECIPE_FIELDS,type ClothTagView,type RecipeField} from '../src/cloth-recipe.ts';
 import type {PatchOp} from '../src/config-patch.ts';
+import {itemApplied} from '../src/applied-blocks.ts';
 import type {CropWorldMapping} from '../src/chest-regions.ts';
 import type {OverlayPoint,OverlayProject,OverlayRegion} from './rig-overlays.ts';
 import type {ClothStatusView,PatchJobView,RebuildRefusal} from './rebuild-client.ts';
@@ -33,6 +34,10 @@ export interface ClothPanel {
  links():{tag:string;inspected:ClothTagView|null;drafted:ClothTagView|null};
  apply():Promise<PatchJobView|RebuildRefusal|null>;
  shown(job:PatchJobView|RebuildRefusal|null):void;
+ /** #172: the ops of the stage's applied record this block owns (`appliedBlockOps`); a pending op among them is marked applied. */
+ applied(ops:readonly PatchOp[]|null):void;
+ /** #172: the pending ops marked applied, by their op line. */
+ appliedItems():string[];
  status(text:string,error:boolean):void;busy(value:boolean):void;
  restore():void;clear():void;sync():void;dispose():void;
 }
@@ -43,7 +48,7 @@ const isObject=(v:unknown):v is Record<string,unknown>=>!!v&&typeof v==='object'
 export function bindClothPanel(deps:ClothPanelDeps):ClothPanel {
  const state=node('cloth-panel-state'),toggle=node<HTMLButtonElement>('cloth-links'),picker=node<HTMLSelectElement>('cloth-tag'),declared=node<HTMLInputElement>('cloth-declared'),fields=node('cloth-fields'),pending=node('cloth-pending-list');
  const applyButton=node<HTMLButtonElement>('cloth-apply'),resetButton=node<HTMLButtonElement>('cloth-reset'),statusOut=node('cloth-status'),readout=node('cloth-readout'),draft=node<HTMLTextAreaElement>('cloth-pending');
- let status:ClothStatusView|null=null,reason:string|null=null,selected='',active=false,busy=false;
+ let status:ClothStatusView|null=null,reason:string|null=null,selected='',active=false,busy=false,appliedOps:PatchOp[]=[];
  /** Per touched tag: every form field's text, and whether the tag's recipe is declared. */
  let edits=new Map<string,{declared:boolean;values:Record<string,string>}>();
  let drafted:ClothTagView[]=[];
@@ -78,7 +83,8 @@ export function bindClothPanel(deps:ClothPanelDeps):ClothPanel {
  function renderPending(){
   let ops:PatchOp[]=[],error:string|null=null;
   try{ops=allOps();}catch(err){if(err instanceof ClothFieldError)error=err.message;else throw err;}
-  const items=ops.map(o=>make('li',{},make('code',{textContent:`${o.op} ${o.path}`}),o.op==='remove'?'':` → ${JSON.stringify(o.value)}`));
+  // #172: an op is marked applied only while the stage's applied record holds it.
+  const items=ops.map(o=>{const on=itemApplied([o],appliedOps);return make('li',{className:on?'applied':''},make('code',{textContent:`${o.op} ${o.path}`}),`${o.op==='remove'?'':` → ${JSON.stringify(o.value)}`}${on?' · applied':''}`);});
   const revert=[...edits.keys()].filter(touched).map(tag=>{const b=make('button',{type:'button',textContent:`Revert ${tag}`,disabled:busy});b.onclick=()=>{edits.delete(tag);change();};return make('li',{},b);});
   pending.replaceChildren(...(error?[make('li',{className:'error',textContent:error})]:[]),...(items.length?items:[make('li',{className:'hint',textContent:'No pending ops.'})]),...revert);
   applyButton.disabled=busy||!items.length||!!error||!!reason||!!status?.reason;resetButton.disabled=busy;
@@ -156,6 +162,8 @@ export function bindClothPanel(deps:ClothPanelDeps):ClothPanel {
    drafted=job.status==='built'&&c?c.links:[];
    readout.replaceChildren(...lines);deps.changed();
   },
+  applied(ops){appliedOps=(ops??[]).map(o=>({...o}));renderPending();},
+  appliedItems(){return [...pending.querySelectorAll('li.applied code')].map(c=>c.textContent??'');},
   status:panelStatus,
   busy(value){busy=value;render();},
   restore(){restore();render();deps.changed();},

package/web/cuts-panel.ts

@@ -11,6 +11,7 @@
  */
 import {anchorAt,boneAnchors,configBones,setAnchor,type BoneAnchor,type BoneEdit} from '../src/bone-anchors.ts';
 import type {PatchOp} from '../src/config-patch.ts';
+import {itemApplied} from '../src/applied-blocks.ts';
 import type {CropWorldMapping} from '../src/chest-regions.ts';
 import {
  boxAt,CutEditError,cutOps,cutsDraft,cutsDraftText,cutsSource,dragPoint,rangeArc,rangeAt,setBox,setRange,setVertex,vertexAt,
@@ -42,6 +43,10 @@ export interface CutsPanel {
  overlayRegions():OverlayRegion[];overlayMarkers():OverlayMarker[];
  apply():Promise<PatchJobView|RebuildRefusal|null>;
  shown(job:PatchJobView|RebuildRefusal|null):void;
+ /** #172: the ops of the stage's applied record this block owns (`appliedBlockOps`); a pending op among them is marked applied. */
+ applied(ops:readonly PatchOp[]|null):void;
+ /** #172: the pending items marked applied, by their op line. */
+ appliedItems():string[];
  status(text:string,error:boolean):void;busy(value:boolean):void;
  restore():void;clear():void;sync():void;dispose():void;
 }
@@ -62,7 +67,7 @@ export function bindCutsPanel(deps:CutsPanelDeps):CutsPanel {
  const addForm=node('cuts-add');
  let config:unknown=null,source:CutsSource={cuts:[],patches:[],segments:[],plan:[],skipped:[]},anchors:BoneAnchor[]=[],buildReason:string|null=null,loaded=false;
  let edits=new Map<string,CutEdit>(),joints=new Map<string,BoneEdit>(),adds:CutAdd[]=[];
- let selected='',active=false,busy=false,space=false,hover:string|null=null;
+ let selected='',active=false,busy=false,space=false,hover:string|null=null,appliedOps:PatchOp[]=[];
  let drag:{id:string;pointer:number;start:RigPoint;from:RigPoint}|null=null;
  let placing:{kind:'cut'|'patch';points:RigPoint[]}|null=null;
 
@@ -121,12 +126,16 @@ export function bindCutsPanel(deps:CutsPanelDeps):CutsPanel {
  }
  function renderPending(){
   const items:HTMLElement[]=[];
+  // #172: an item is marked applied only while the stage's applied record holds every op it sends.
+  const opsOf=(build:()=>PatchOp[])=>{try{return build();}catch(error){if(error instanceof CutEditError)return [];throw error;}};
+  const item=(sent:PatchOp[],code:HTMLElement,text:string,revert:HTMLElement)=>{const on=itemApplied(sent,appliedOps);return make('li',{className:on?'applied':''},code,text+(on?' · applied':''),revert);};
   for(const e of edits.values()){const revert=make('button',{type:'button',textContent:'Revert',disabled:busy});revert.onclick=()=>{edits.delete(e.path);change();};
-   items.push(make('li',{},make('code',{textContent:`${e.kind==='range'&&e.value===null?'remove':e.kind==='range'&&e.from===null?'add':'replace'} ${e.path}`}),` ${e.from?fmt(e.from):'—'} → ${e.value?fmt(e.value):'—'} · ${e.name}`,revert));}
+   items.push(item(opsOf(()=>cutOps(new Map([[e.path,e]]),[],config)),make('code',{textContent:`${e.kind==='range'&&e.value===null?'remove':e.kind==='range'&&e.from===null?'add':'replace'} ${e.path}`}),` ${e.from?fmt(e.from):'—'} → ${e.value?fmt(e.value):'—'} · ${e.name}`,revert));}
   for(const e of joints.values()){const revert=make('button',{type:'button',textContent:'Revert',disabled:busy});revert.onclick=()=>{joints.delete(e.path);change();};
-   items.push(make('li',{},make('code',{textContent:`replace ${e.path}`}),` ${fmt(e.from)} → ${fmt(e.value)} · ${e.name} (a joint is its bone's origin)`,revert));}
+   items.push(item([{op:'replace',path:e.path,value:[...e.value],name:e.name}],make('code',{textContent:`replace ${e.path}`}),` ${fmt(e.from)} → ${fmt(e.value)} · ${e.name} (a joint is its bone's origin)`,revert));}
   adds.forEach((a,i)=>{const revert=make('button',{type:'button',textContent:'Revert',disabled:busy});revert.onclick=()=>{adds.splice(i,1);change();};
-   items.push(make('li',{},make('code',{textContent:`add /assemble/${a.kind==='cut'?'cuts':'patches'}/-`}),` ${a.kind==='cut'?`cut ${a.into} ← ${a.from}, ${a.polygon.length} point(s)`:`patch ${a.name} ${fmt(a.box)}`} · regions → ${a.bone}`,revert));});
+   const sent=opsOf(()=>{const before=cutOps(new Map(),adds.slice(0,i),config).length;return cutOps(new Map(),adds.slice(0,i+1),config).slice(before);});
+   items.push(item(sent,make('code',{textContent:`add /assemble/${a.kind==='cut'?'cuts':'patches'}/-`}),` ${a.kind==='cut'?`cut ${a.into} ← ${a.from}, ${a.polygon.length} point(s)`:`patch ${a.name} ${fmt(a.box)}`} · regions → ${a.bone}`,revert));});
   pending.replaceChildren(...(items.length?items:[make('li',{className:'hint',textContent:'No pending ops.'})]));
   applyButton.disabled=busy||!items.length||!!buildReason;resetButton.disabled=busy;
   toggle.disabled=!loaded;toggle.setAttribute('aria-pressed',String(active));
@@ -254,6 +263,8 @@ export function bindCutsPanel(deps:CutsPanelDeps):CutsPanel {
    const map=a?.recomposite.errorMap;
    readout.replaceChildren(...lines,...(map&&job.status==='built'?[make('figure',{className:'cuts-error-map'},make('img',{src:deps.route(map.url),alt:'Recomposite error map of the scratch build: red is painting no part holds, blue a part more than 40 off'}),make('figcaption',{textContent:`recomposite_error_rig.png · sha256 ${map.sha256.slice(0,12)}…`}))]:[]));
   },
+  applied(ops){appliedOps=(ops??[]).map(o=>({...o}));renderPending();},
+  appliedItems(){return [...pending.querySelectorAll('li.applied code')].map(c=>c.textContent??'');},
   status:panelStatus,
   busy(value){busy=value;render();},
   restore(){restore();render();deps.changed();},

package/web/density-strip-panel.ts

@@ -0,0 +1,89 @@
+/**
+ * Mesh panel · density strip (#173), page side: "N values from A to B" next to the selected part's density field
+ * (`grid` on a lattice entry, `contour.spacing` on a contour entry), Build strip, and the table — one row per
+ * candidate with `remesh.json`'s counts, the folds count, the part's TEXTURE_STRETCH severity and worst frame, every bar
+ * the part is measured on as a ratio against its floor or ceiling, and the verdict (PASS, or the producer's refusal
+ * verbatim). The two labels name rows; the table has no Apply. Load puts a built row on the stage as pending (the
+ * Mesh panel's Apply then applies it, reusing its build); Refine between builds the next strip inside two rows.
+ */
+import {barText,densityField,densityPath,refineValues,stripValues,type DensityField,type StripRow} from '../src/density-strip.ts';
+import {entryValue,type MeshEntry} from '../src/mesh-entry.ts';
+
+export interface DensityStripViewLike {
+ id:string;status:'running'|'done';part:string;field:DensityField;concurrency:number;wallMs:number|null;rows:StripRow[];labels:{fewest:number|null;widest:number|null};
+}
+export interface DensityStripHost {
+ part():string|null;
+ entry():MeshEntry|null;
+ build(values:number[]):Promise<void>;
+ load(index:number):Promise<void>;
+ back():Promise<void>;
+ close():Promise<void>;
+}
+export interface DensityStripPanel {
+ /** The selected part or its pending entry changed: the field line and the default range follow it. */
+ changed():void;
+ show(view:DensityStripViewLike|null,pending:number|null,busy:boolean):void;
+ status(text:string,error:boolean):void;
+}
+const node=<T extends HTMLElement>(id:string)=>{const found=document.getElementById(id);if(!found)throw new Error(`Missing UI element: ${id}`);return found as T;};
+const make=<K extends keyof HTMLElementTagNameMap>(tag:K,props:Record<string,unknown>={},...children:(Node|string)[]):HTMLElementTagNameMap[K]=>{const item=document.createElement(tag);Object.assign(item,props);item.append(...children);return item;};
+const fieldLabel=(f:DensityField)=>f==='grid'?'grid':'contour.spacing';
+
+export function bindDensityStrip(host:DensityStripHost):DensityStripPanel {
+ const fieldLine=node('density-strip-field'),n=node<HTMLInputElement>('density-strip-n'),from=node<HTMLInputElement>('density-strip-from'),to=node<HTMLInputElement>('density-strip-to');
+ const buildButton=node<HTMLButtonElement>('density-strip-build'),backButton=node<HTMLButtonElement>('density-strip-back'),closeButton=node<HTMLButtonElement>('density-strip-close');
+ const statusOut=node('density-strip-status'),table=node('density-strip-table');
+ let view:DensityStripViewLike|null=null,pending:number|null=null,busy=false,lastPart:string|null=null;
+ const status=(text:string,error:boolean)=>{statusOut.textContent=text;statusOut.title=text;statusOut.classList.toggle('error',error);};
+ /** The selected part's density field and its pending value, or the reason a strip cannot run on it. */
+ const current=():{part:string;field:DensityField;value:number}|{error:string}=>{
+  const part=host.part(),entry=host.entry();
+  if(!part||!entry)return {error:'Select a mesh part (grid or contour entry) to build a density strip.'};
+  try{const field=densityField(entry,part),value=entryValue(entry,densityPath(field));return typeof value==='number'?{part,field,value}:{error:`meshes.${part}.${fieldLabel(field)} is not a number`};}
+  catch(error){return {error:error instanceof Error?error.message:String(error)};}
+ };
+ function changed(){
+  const c=current();
+  if('error' in c){fieldLine.textContent=c.error;buildButton.disabled=true;lastPart=null;return;}
+  fieldLine.textContent=`${c.part} · ${fieldLabel(c.field)} (pending ${c.value}) · each value runs as its own replace /meshes/${c.part} patch through remesh, at most ${view?.concurrency??'cores/2'} at once`;
+  if(lastPart!==c.part){from.value=String(c.value);to.value=String(c.field==='grid'?Math.round(c.value*3):Math.round(c.value*2*100)/100);lastPart=c.part;}
+  buildButton.disabled=busy||view?.status==='running';
+ }
+ buildButton.onclick=()=>{
+  const c=current();if('error' in c){status(c.error,true);return;}
+  try{void host.build(stripValues(Number(from.value),Number(to.value),Number(n.value),c.field==='grid'));}catch(error){status(error instanceof Error?error.message:String(error),true);}
+ };
+ backButton.onclick=()=>{void host.back();};
+ closeButton.onclick=()=>{void host.close();};
+ const cell=(text:string,title=text,cls='')=>make('td',{textContent:text,title,className:cls});
+ function show(next:DensityStripViewLike|null,pendingIndex:number|null,isBusy:boolean){
+  view=next;pending=pendingIndex;busy=isBusy;changed();
+  backButton.disabled=pending===null||busy;closeButton.disabled=!view||view.status==='running'||busy;
+  if(!view){table.replaceChildren();return;}
+  const v=view,integer=v.field==='grid',head=make('tr',{},...[fieldLabel(v.field),'v / t (remesh.json)','folds','TEXTURE_STRETCH','bars (ratio vs floor / ceiling)','verdict',''].map(h=>make('th',{textContent:h,scope:'col'})));
+  const rows=v.rows.map((r,i)=>{
+   const labels:string[]=[];if(v.labels.fewest===i)labels.push('fewest triangles passing');if(v.labels.widest===i)labels.push('widest margin among ties');
+   const valueCell=make('td',{className:'density-strip-value'},make('strong',{textContent:String(r.value)}),...labels.map(l=>make('span',{className:'density-strip-label',textContent:l})));
+   const counts=r.counts?`v ${r.counts.vertices} · t ${r.counts.triangles}`:'—';
+   const stretch=r.stretch?`${r.stretch.severity}${r.stretch.frame?` @ ${r.stretch.frame}`:''}`:'—';
+   const bars=r.bars.length?make('td',{className:'density-strip-bars'},...r.bars.map(b=>make('div',{textContent:barText(b),title:`${b.bar} ${b.status}`,className:b.margin<1?'error':''}))):cell('—');
+   const verdictCell=cell(r.verdict,r.verdict,`density-strip-verdict${r.verdict==='PASS'?' pass':r.status==='running'?'':' error'}`);
+   const load=make('button',{type:'button',textContent:pending===i?'On stage':r.applied?'Applied':'Load',disabled:busy||!r.modelUrl||pending===i||v.status==='running'});
+   load.title=r.modelUrl?'Load this revision on the stage as pending — nothing is applied; the Mesh panel\'s Apply applies it':r.status==='running'?'Still building':r.applied?'Applied: it is an applied record now':'Refused: there is no revision to load';
+   load.setAttribute('aria-label',`Load ${fieldLabel(v.field)} ${r.value}`);load.onclick=()=>{void host.load(i);};
+   const actions=make('td',{className:'density-strip-actions'},load);
+   if(i<v.rows.length-1){
+    const refine=make('button',{type:'button',textContent:'Refine ↓',disabled:busy||v.status==='running'});
+    refine.title=`Build the next strip between ${r.value} and ${v.rows[i+1]!.value}`;refine.setAttribute('aria-label',`Refine between ${r.value} and ${v.rows[i+1]!.value}`);
+    refine.onclick=()=>{try{void host.build(refineValues(r.value,v.rows[i+1]!.value,Number(n.value)||5,integer));}catch(error){status(error instanceof Error?error.message:String(error),true);}};
+    actions.append(refine);
+   }
+   const tr=make('tr',{className:[pending===i?'pending':'',r.status==='refused'||r.status==='failed'?'refused':''].filter(Boolean).join(' ')},valueCell,cell(counts),cell(r.folds===null?'—':String(r.folds)),cell(stretch),bars,verdictCell,actions);
+   tr.dataset.candidate=r.id;return tr;
+  });
+  table.replaceChildren(make('table',{className:'density-strip-rows'},make('thead',{},head),make('tbody',{},...rows)));
+ }
+ changed();
+ return {changed,show,status};
+}