@rig-c/review 0.9.0 → 0.10.0

package/src/rebuild.ts

@@ -25,11 +25,13 @@ import { bustMeshEntry, deriveBust, parseBustSpec, BustSpecError, type BustSpec
 import { modelMeshTriangles, remeshCounts, type RemeshCounts } from './mesh-entry.ts';
 import { patchRoute } from './retune-route.ts';
 import { producerHint } from './baseline-reach.ts';
-import { carriedCheck, RETUNE_CHECK_SINCE, RETUNE_FILE, retuneCheckSummary, revisionBinding } from './retune-check.ts';
+import { carriedCheck, carriedCheckSummary, type CarryingOp, provenanceFile, REMESH_CHECK_SINCE, RETUNE_CHECK_SINCE, revisionBinding } from './retune-check.ts';
 import { absolutizeBuildFiles, buildLines, buildNamedFiles, buildReadout, MAX_BUILD_READOUT, needsBuild, newBuildFile, recompositeFigures, type RecompositeFigures } from './build-route.ts';
 import { jsonDiff } from './config-patch.ts';
 import { CLOTH_KEYPOINTS_UNDECLARED, CLOTH_PATCH_MIXED, CLOTH_SOURCE_UNAVAILABLE, CLOTH_WRITE_SINCE, clothLinks, clothPatchKind, readClothTargets, writtenDiff, type ClothTagView, type WrittenDiff } from './cloth-recipe.ts';
 import { CHECK_ENVIRONMENT_SINCE, parseSchedule, ScheduleError, scheduleText } from './environment-schedule.ts';
+import { availableParallelism } from 'node:os';
+import { candidateRow, DENSITY_STRIP_SCHEMA, DensityStripError, stripLabels, stripPatches, stripShape, type DensityField, type StripRow } from './density-strip.ts';
 import { samplesClock } from './frame-clock.ts';
 import { cleanArgs, mapText, motionSummary, parseRetargetRequest, retargetArgs, retargetLines, retargetRecord, retargetRecordText, RetargetError, type MotionSummary, type RetargetLine, type RetargetRecord } from './retarget.ts';
 
@@ -400,7 +402,24 @@ export function assertNamedFilesHeld(before: unknown, after: unknown): void {
 /** The value of a flag in the patch's args, or the producer's default. */
 const flagValue = (args: readonly string[], flag: string, fallback: string) => { const i = args.indexOf(flag); return i >= 0 ? args[i + 1]! : fallback; };
 
-export interface RebuildOptions { stateDir: string; starts: readonly string[]; unchanged: () => Promise<void>; bones: readonly string[] | null }
+export interface RebuildOptions {
+  stateDir: string; starts: readonly string[]; unchanged: () => Promise<void>; bones: readonly string[] | null;
+  /** #173: how many strip candidates run at once (default max(1, floor(cores / 2))). */
+  stripConcurrency?: number;
+}
+/** #173: a density strip's scratch — one folder per package, holding at most the one strip on screen. */
+export const stripRoot = (stateDir: string, sourceHash: string) => join(stateDir, 'density-strip', sourceHash);
+export const defaultStripConcurrency = () => Math.max(1, Math.floor(availableParallelism() / 2));
+/** Deterministic: the package, the config bytes, every candidate's patch bytes in order and both tool versions. */
+export function stripId(input: { sourceHash: string; configHash: string; patches: readonly ConfigPatch[]; producer: string; compiler: string }): string {
+  return sha256(JSON.stringify([DENSITY_STRIP_SCHEMA, input.sourceHash, input.configHash, input.patches.map(patchText), input.producer, input.compiler]));
+}
+/** `GET /api/density-strip/<id>`: the strip, one row per candidate in the request's order, and the two labels. */
+export interface DensityStripView {
+  schema: typeof DENSITY_STRIP_SCHEMA; id: string; status: 'running' | 'done'; part: string; field: DensityField;
+  concurrency: number; configHash: string; producer: { package: string; version: string }; compiler: { package: string; version: string };
+  wallMs: number | null; rows: StripRow[]; labels: { fewest: number | null; widest: number | null };
+}
 export const baselineDir = (stateDir: string, key: string) => join(stateDir, 'baseline', key);
 
 const tool = (t: InstalledTool) => ({ package: t.package, version: t.version });
@@ -431,7 +450,7 @@ interface ApplySteps {
   /** #102: check the scratch rig after the compile. */
   check?: (summary: CheckSummary, wallMs: number | null) => void;
   /**
-   * #139: the check the producer op already ran on the spec it wrote, read instead of running check again: a summary
+   * #139 / #174: the check the producer op (retune, remesh) already ran on the spec it wrote, read instead of running check again: a summary
    * (recorded through `check`, no wall clock), a refusal line (nothing recorded, the build refused), or null — the op
    * carries none, so check runs as for any other Apply.
    */
@@ -440,24 +459,31 @@ interface ApplySteps {
   hashed?: () => Promise<void>;
   /** #112: the schedule check reads (`--environment environment.json`, written into the scratch directory first). */
   world?: ApplyWorld | null;
+  /**
+   * #173: a density strip's candidate — built and hashed and its result.json written exactly as an Apply's, but it does
+   * not land: no applied record, no stage, no scratch-root arrangement. Its build waits in the strip's own folder.
+   */
+  candidate?: boolean;
 }
 
 /**
- * #139: the check `rig-parts retune` ran on the revision it wrote into `spec`, as review's check summary, bound to the
- * revision's files by `retune.json`'s hash rows (`RETUNE_CHECK_STALE` refuses the Apply). Null — check runs as before —
- * when the Apply checks under an exported world (retune's check read the default one) or `retune.json` carries no
- * `line` / `status` (a producer before `RETUNE_CHECK_SINCE`).
+ * #139 / #174: the check `rig-parts retune` (or `remesh`) ran on the revision it wrote into `spec`, as review's check
+ * summary, bound to the revision's files by the provenance's hash rows (`RETUNE_CHECK_STALE` / `REMESH_CHECK_STALE`
+ * refuses the Apply). Null — check runs as before — when the Apply checks under an exported world (the op's check read
+ * the default one) or the provenance carries no `line` / `status` (a producer before `RETUNE_CHECK_SINCE` /
+ * `REMESH_CHECK_SINCE`, both 1.49.0).
  */
-async function retuneCarried(spec: string, world: ApplyWorld | null, push: (line: string) => void): Promise<{ summary: CheckSummary } | { refused: string } | null> {
-  if (world) { push('review: retune\'s own check read the default world and this Apply checks under the exported schedule, so check runs on the revision'); return null; }
-  const retune = JSON.parse(await readFile(join(spec, RETUNE_FILE), 'utf8')) as unknown;
-  const carried = carriedCheck(retune);
-  if (!carried) { push(`review: ${RETUNE_FILE} carries no check line or block statuses (@rig-c/parts before ${RETUNE_CHECK_SINCE}), so check runs on the revision`); return null; }
-  const stale = await revisionBinding(spec, retune);
+async function opCarried(op: CarryingOp, spec: string, world: ApplyWorld | null, push: (line: string) => void): Promise<{ summary: CheckSummary } | { refused: string } | null> {
+  const file = provenanceFile(op);
+  if (world) { push(`review: ${op}'s own check read the default world and this Apply checks under the exported schedule, so check runs on the revision`); return null; }
+  const provenance = JSON.parse(await readFile(join(spec, file), 'utf8')) as unknown;
+  const carried = carriedCheck(provenance, op);
+  if (!carried) { push(`review: ${file} carries no check line or block statuses (@rig-c/parts before ${op === 'retune' ? RETUNE_CHECK_SINCE : REMESH_CHECK_SINCE}), so check runs on the revision`); return null; }
+  const stale = await revisionBinding(spec, provenance, op);
   if (stale) return { refused: stale };
-  const rows = (retune as { revision: unknown[] }).revision.length;
-  push(`review: check not run again — ${RETUNE_FILE} carries retune's check of this revision, bound to it by ${rows} revision hash row(s): ${carried.line}`);
-  return { summary: retuneCheckSummary(carried) };
+  const rows = (provenance as { revision: unknown[] }).revision.length;
+  push(`review: check not run again — ${file} carries ${op}'s check of this revision, bound to it by ${rows} revision hash row(s): ${carried.line}`);
+  return { summary: carriedCheckSummary(carried, op) };
 }
 
 /** #115: what a build-routed patch runs with — the handoff's painting and runs, absolute; never from the client. */
@@ -511,6 +537,11 @@ async function hashBuild(build: string, id: string): Promise<RebuildBuild> {
 export function createRebuilds(p: ReviewPackage, options: RebuildOptions) {
   const jobs = new Map<string, RebuildJob | PatchJob | DeltaJob | RetargetJob>();
   let running: string | null = null;
+  /** #173: the density strip on screen (at most one per review): its candidates run beside each other, none of them applied. */
+  interface StripCandidate { value: number; id: string; entry: JsonValue; dir: string; job: PatchJob; applied: boolean }
+  let strip: { id: string; status: 'running' | 'done'; part: string; field: DensityField; concurrency: number; configHash: string; producer: { package: string; version: string }; compiler: { package: string; version: string }; started: number; wallMs: number | null; candidates: StripCandidate[] } | null = null;
+  /** One producer workload at a time per review: an Apply (or undo's re-run) or a strip; the line refusing the other. */
+  const busy = (): string | null => (running ? `REBUILD_BUSY: rebuild ${running} is still running` : strip?.status === 'running' ? `REBUILD_BUSY: density strip ${strip.id} is still running` : null);
   /** #166: the session's applied records, in order; the last is on the stage. The request bodies by job id. */
   const stack: AppliedEntry[] = [];
   const bodies = new Map<string, unknown>();
@@ -694,7 +725,7 @@ export function createRebuilds(p: ReviewPackage, options: RebuildOptions) {
     const v = object(input, 'undo');
     if (Object.keys(v).join(',') !== 'from' || typeof v.from !== 'string' || !/^[a-f0-9]{64}$/.test(v.from)) bad('expected exactly {from: <the build id on the stage>}');
     assertStateOutside();
-    if (running) return { status: 200, body: { status: 'refused', error: `REBUILD_BUSY: rebuild ${running} is still running`, producerLine: null } };
+    if (busy()) return { status: 200, body: { status: 'refused', error: busy(), producerLine: null } };
     const top = stack.at(-1);
     if (!top) throw new RebuildError('UNDO_NOTHING_APPLIED', 'no Apply is on the stage; the inspected build is');
     if (top.id !== v.from) throw new RebuildError('UNDO_STALE', `the stage's last Apply is ${top.id.slice(0, 12)}…, not ${String(v.from).slice(0, 12)}…; reload`);
@@ -806,13 +837,13 @@ export function createRebuilds(p: ReviewPackage, options: RebuildOptions) {
       job.build = await hashBuild(join(dir, 'build'), job.id);
       if (steps.hashed) await steps.hashed();
       // #166: an undo's re-run must reproduce the build its record names, file for file; otherwise it is refused, not guessed.
-      const changed = restoredDifference(job.id, job.build.files);
+      const changed = steps.candidate ? null : restoredDifference(job.id, job.build.files);
       if (changed) { job.producerLine = changed; job.status = 'refused'; push(`review: ${changed}`); return; }
-      latestId = job.id;
+      if (!steps.candidate) latestId = job.id;
       await writeFile(join(dir, 'result.json'), JSON.stringify({ ...job, status: 'built', reused: false }, null, 1) + '\n', { mode: 0o600 });
       // Each Apply replaces the previous scratch build of this package in the scratch root; #166 keeps the applied records'
-      // earlier builds beside it (keptRoot) for undo.
-      await landed({ ...job, status: 'built' });
+      // earlier builds beside it (keptRoot) for undo. #173: a strip candidate lands nowhere until its row is Applied.
+      if (!steps.candidate) await landed({ ...job, status: 'built' });
       // "built" is published last: a reader that sees it finds the scratch root already settled (no sibling mid-removal).
       job.status = 'built';
     } catch (error) {
@@ -845,7 +876,7 @@ export function createRebuilds(p: ReviewPackage, options: RebuildOptions) {
    * #102: the patched config → `rig-parts rig` (whole rig), `retune` (#136: the constraints and the idle spliced onto the
    * inspected rig) or `remesh` (one part's patched entry) → `<dir>/rig`; the tail adds the diff and check.
    */
-  function executePatch(job: PatchJob, dir: string, inputs: ProducerInputs, resolved: Resolved, patched: JsonValue, part: string | null, plan: BuildPlan | null = null, world: ApplyWorld | null = null, cloth: ClothPlan | null = null): Promise<void> {
+  function executePatch(job: PatchJob, dir: string, inputs: ProducerInputs, resolved: Resolved, patched: JsonValue, part: string | null, plan: BuildPlan | null = null, world: ApplyWorld | null = null, cloth: ClothPlan | null = null, candidate = false): Promise<void> {
     const args = job.request.patch.op.args, producer = resolved.producer;
     let counts: RemeshCounts | null = null;
     let built: ProcessResult | null = null;
@@ -957,9 +988,12 @@ export function createRebuilds(p: ReviewPackage, options: RebuildOptions) {
       ...(building ? {} : { check: (summary: CheckSummary, wallMs: number | null) => { job.wallMs.check = wallMs; job.check = summary; } }),
       // #139: a retune Apply reads the check retune ran on its revision (retune.json, bound by its hash rows) unless the
       // Apply checks under an exported world (retune's check reads the default one) or the producer carries no line.
-      ...(job.op === 'retune' ? { carried: (push: (line: string) => void) => retuneCarried(join(dir, 'rig'), world, push) } : {}),
+      // #174: a remesh patch the same, from remesh.json — remesh checked the revision with the request's pack flags,
+      // the ones `flags` reads for review's own check, and the same `--parts`; a patch passes no `--requirements`.
+      ...(job.op === 'retune' || job.op === 'remesh' ? { carried: (push: (line: string) => void) => opCarried(job.op as CarryingOp, join(dir, 'rig'), world, push) } : {}),
       hashed: async () => { if (counts) job.remesh = { ...counts, modelTriangles: modelMeshTriangles(JSON.parse(await readFile(join(dir, 'build', 'skeleton.model.json'), 'utf8')), counts.part) }; },
       world,
+      ...(candidate ? { candidate: true } : {}),
     });
   }
 
@@ -1024,9 +1058,10 @@ export function createRebuilds(p: ReviewPackage, options: RebuildOptions) {
     const id = patchId({ sourceHash: p.sourceHash, configHash: inputs.configHash, patch, producer: `${resolved.producer.package}@${resolved.producer.version}`, compiler: `${resolved.compiler.package}@${resolved.compiler.version}`, op, ...(plan ? { buildInputs: plan.inputsHash } : {}), ...(world ? { environment: world.record.sha256 } : {}), ...(clothPlan ? { cloth: p.handoff!.record.keypoints!.sha256 } : {}) });
     const current = jobs.get(id);
     if (current?.status === 'running') return { status: 202, body: snapshot(current) };
-    if (running) return { status: 200, body: { status: 'refused', error: `REBUILD_BUSY: rebuild ${running} is still running`, producerLine: null } };
+    if (busy()) return { status: 200, body: { status: 'refused', error: busy(), producerLine: null } };
     guardRestore(id);
     const dir = rebuildDir(options.stateDir, p.sourceHash, id);
+    await adopt(id);
     await unkeep(id);
     const reused = await reuse<PatchJob>(dir, id);
     if (reused) { jobs.set(id, reused); latestId = id; bodies.set(id, body); await landed(reused); return { status: 200, body: snapshot(reused) }; }
@@ -1039,6 +1074,114 @@ export function createRebuilds(p: ReviewPackage, options: RebuildOptions) {
     return { status: 202, body: snapshot(job) };
   }
 
+  /**
+   * #173 · `POST /api/density-strip` with `{patches}`: 2–5 Mesh-panel patches for one part that differ only at its density
+   * field (`src/density-strip.ts`). Each is checked as an Apply checks it (fresh config bytes, names, held files, the
+   * installed producer) and runs through the same patch runner — remesh, the compile, #174's carried check — into its own
+   * folder under `stripRoot`, at most `concurrency` at once. Nothing lands: no applied record, no stage, no undo entry.
+   * A new strip replaces the folder of the one before it; refused while an Apply runs (and an Apply is refused while a
+   * strip runs: `REBUILD_BUSY`).
+   */
+  async function startStrip(input: unknown): Promise<{ status: number; body: unknown }> {
+    let patches: ConfigPatch[];
+    try { patches = stripPatches(input).map(parseConfigPatch); }
+    catch (e) { if (e instanceof ConfigPatchError || e instanceof DensityStripError) throw new RebuildError(e.code, e.message.slice(e.code.length + 2)); throw e; }
+    let shape: ReturnType<typeof stripShape>;
+    try { shape = stripShape(patches); } catch (e) { if (e instanceof DensityStripError) throw new RebuildError(e.code, e.message.slice(e.code.length + 2)); throw e; }
+    assertStateOutside();
+    await options.unchanged();
+    const inputs = await producerInputs(p.handoff, p.handoffReason);
+    const original = JSON.parse(inputs.configText) as JsonValue;
+    const planned: { patch: ConfigPatch; patched: JsonValue }[] = [];
+    for (const patch of patches) {
+      let patched: JsonValue;
+      try { assertPatchFresh(patch, inputs.configHash); assertOpNames(original, patch.ops); patched = applyConfigPatch(original, patch.ops); remeshPart(patch); }
+      catch (e) { if (e instanceof ConfigPatchError) throw new RebuildError(e.code, e.message.slice(e.code.length + 2)); throw e; }
+      assertNamedFilesHeld(original, patched);
+      planned.push({ patch, patched });
+    }
+    const resolved = resolveProducer(options.starts);
+    if (!resolved.ok) return { status: 200, body: { status: 'refused', error: resolved.error, producerLine: resolved.error } };
+    const first = patches[0]!;
+    if (first.producer.name !== resolved.producer.package || first.producer.version !== resolved.producer.version) throw new RebuildError('EDIT_PRODUCER_MISMATCH', `the patch was made for ${first.producer.name} ${first.producer.version}; the installed producer is ${resolved.producer.package} ${resolved.producer.version}`);
+    const producer = `${resolved.producer.package}@${resolved.producer.version}`, compiler = `${resolved.compiler.package}@${resolved.compiler.version}`;
+    const id = stripId({ sourceHash: p.sourceHash, configHash: inputs.configHash, patches, producer, compiler });
+    if (strip?.id === id) return { status: strip.status === 'running' ? 202 : 200, body: stripView() };
+    const refusal = busy();
+    if (refusal) return { status: 200, body: { status: 'refused', error: refusal, producerLine: null } };
+    // Bounded disk: the strip on screen is the only one this package keeps; its predecessor's folder goes first.
+    const root = stripRoot(options.stateDir, p.sourceHash);
+    await rm(root, { recursive: true, force: true });
+    const concurrency = Math.max(1, Math.floor(options.stripConcurrency ?? defaultStripConcurrency()));
+    const candidates: StripCandidate[] = planned.map(({ patch }, i) => {
+      const cid = patchId({ sourceHash: p.sourceHash, configHash: inputs.configHash, patch, producer, compiler, op: 'remesh' });
+      const job: PatchJob = { schema: REBUILD_SCHEMA, kind: 'patch', id: cid, status: 'running', reused: false, op: 'remesh', request: { patch, patchSha256: patchSha256(patch), configHash: inputs.configHash }, producer: tool(resolved.producer), compiler: tool(resolved.compiler), lines: [], producerLine: null, exitCode: null, wallMs: { op: null, compile: null, check: null }, check: null, diff: null, files: null, remesh: null, build: null };
+      return { value: shape.values[i]!, id: cid, entry: shape.entries[i]!, dir: join(root, id, cid), job, applied: false };
+    });
+    const current = { id, status: 'running' as const, part: shape.part, field: shape.field, concurrency, configHash: inputs.configHash, producer: tool(resolved.producer), compiler: tool(resolved.compiler), started: performance.now(), wallMs: null, candidates };
+    strip = current;
+    // A bounded pool: each worker takes the next candidate in order; the strip is done when every candidate settled.
+    let next = 0;
+    const worker = async () => {
+      for (let i = next++; i < candidates.length; i = next++) {
+        const c = candidates[i]!;
+        await executePatch(c.job, c.dir, inputs, resolved, planned[i]!.patched, shape.part, null, null, null, true).catch(() => {});
+      }
+    };
+    void Promise.all(Array.from({ length: Math.min(concurrency, candidates.length) }, worker)).finally(() => {
+      if (strip === current) { (current as { status: 'running' | 'done' }).status = 'done'; (current as { wallMs: number | null }).wallMs = Math.round(performance.now() - current.started); }
+    });
+    return { status: 202, body: stripView() };
+  }
+  function stripView(): DensityStripView | null {
+    if (!strip) return null;
+    const s = strip;
+    const rows = s.candidates.map(c => candidateRow({ value: c.value, id: c.id, entry: c.entry, job: c.job, part: s.part, modelUrl: c.job.build ? `/density-strip/${s.id}/${c.id}/${c.job.build.model}` : null, applied: c.applied }));
+    return { schema: DENSITY_STRIP_SCHEMA, id: s.id, status: s.status, part: s.part, field: s.field, concurrency: s.concurrency, configHash: s.configHash, producer: s.producer, compiler: s.compiler, wallMs: s.wallMs, rows, labels: s.status === 'done' ? stripLabels(rows) : { fewest: null, widest: null } };
+  }
+  /** `GET /api/density-strip/<id>` (and `GET /api/density-strip`: the strip on screen, or null). */
+  function readStrip(id?: string): DensityStripView | null {
+    if (id !== undefined && strip?.id !== id) throw new RebuildError('DENSITY_STRIP_NOT_FOUND', id);
+    return stripView();
+  }
+  /** A candidate's job as it settled (its lines in full), for the row's log. */
+  function stripJob(id: string, cid: string): PatchJob {
+    const c = strip?.id === id ? strip.candidates.find(x => x.id === cid) : undefined;
+    if (!c) throw new RebuildError('DENSITY_STRIP_NOT_FOUND', `${id}/${cid}`);
+    return snapshot(c.job);
+  }
+  /** `POST /api/density-strip/close` with `{id}`: the strip's folder is removed; refused while its candidates run. */
+  async function closeStrip(input: unknown): Promise<{ status: number; body: unknown }> {
+    const v = object(input, 'density strip close');
+    if (Object.keys(v).join(',') !== 'id' || typeof v.id !== 'string' || !/^[a-f0-9]{64}$/.test(v.id)) throw new RebuildError('REBUILD_REQUEST_INVALID', 'expected exactly {id: <the strip id>}');
+    if (strip?.id !== v.id) throw new RebuildError('DENSITY_STRIP_NOT_FOUND', `${v.id.slice(0, 12)}… is not the strip on screen`);
+    if (strip.status === 'running') return { status: 200, body: { status: 'refused', error: `DENSITY_STRIP_BUSY: strip ${strip.id} is still running; close it when its candidates settle`, producerLine: null } };
+    const applied = strip.candidates.filter(c => c.applied).length;
+    strip = null;
+    await rm(stripRoot(options.stateDir, p.sourceHash), { recursive: true, force: true });
+    return { status: 200, body: { status: 'closed', id: v.id, applied } };
+  }
+  /** A served candidate file: only a built, not-applied candidate's hashed model and pages, read-only. */
+  async function stripFile(id: string, cid: string, name: string): Promise<string> {
+    const c = strip?.id === id ? strip.candidates.find(x => x.id === cid) : undefined;
+    if (!c || c.applied || c.job.status !== 'built' || !c.job.build || !Object.hasOwn(c.job.build.files, name)) throw new RebuildError('DENSITY_STRIP_NOT_FOUND', `${id}/${cid}/${name}`);
+    return safeFile(await realpath(join(c.dir, 'build')), packagePath(name));
+  }
+  /**
+   * #173: an Apply whose build id is a settled strip candidate's takes that candidate's build: the folder moves into the
+   * scratch root, where the ordinary reuse reads and re-hashes it and lands it as any Apply lands. The row then reads
+   * "applied" and is no longer served from the strip.
+   */
+  async function adopt(id: string): Promise<void> {
+    const c = strip && strip.status === 'done' ? strip.candidates.find(x => x.id === id && !x.applied && x.job.status === 'built') : undefined;
+    if (!c) return;
+    const to = rebuildDir(options.stateDir, p.sourceHash, id);
+    if (await exists(to)) return;
+    await mkdir(rebuildRoot(options.stateDir, p.sourceHash), { recursive: true, mode: 0o700 });
+    await rename(c.dir, to);
+    c.applied = true;
+  }
+
   /** #135: the delta → `rig-parts remesh --delta mesh-edit.json --part <part>` → `<dir>/rig`; the tail adds the per-file diff. */
   function executeDelta(job: DeltaJob, dir: string, inputs: ProducerInputs, resolved: Resolved, text: string): Promise<void> {
     const producer = resolved.producer, part = job.request.part;
@@ -1086,9 +1229,10 @@ export function createRebuilds(p: ReviewPackage, options: RebuildOptions) {
     const id = deltaId({ sourceHash: p.sourceHash, configHash: inputs.configHash, part: request.part, deltaText: text, producer: `${resolved.producer.package}@${resolved.producer.version}`, compiler: `${resolved.compiler.package}@${resolved.compiler.version}` });
     const current = jobs.get(id);
     if (current?.status === 'running') return { status: 202, body: snapshot(current) };
-    if (running) return { status: 200, body: { status: 'refused', error: `REBUILD_BUSY: rebuild ${running} is still running`, producerLine: null } };
+    if (busy()) return { status: 200, body: { status: 'refused', error: busy(), producerLine: null } };
     guardRestore(id);
     const dir = rebuildDir(options.stateDir, p.sourceHash, id);
+    await adopt(id);
     await unkeep(id);
     const reused = await reuse<DeltaJob>(dir, id);
     if (reused) { jobs.set(id, reused); latestId = id; bodies.set(id, input); await landed(reused); return { status: 200, body: snapshot(reused) }; }
@@ -1200,9 +1344,10 @@ export function createRebuilds(p: ReviewPackage, options: RebuildOptions) {
     const id = retargetId({ sourceHash: p.sourceHash, configHash: inputs.configHash, record, producer: `${resolved.producer.package}@${resolved.producer.version}`, compiler: `${resolved.compiler.package}@${resolved.compiler.version}` });
     const current = jobs.get(id);
     if (current?.status === 'running') return { status: 202, body: snapshot(current) };
-    if (running) return { status: 200, body: { status: 'refused', error: `REBUILD_BUSY: rebuild ${running} is still running`, producerLine: null } };
+    if (busy()) return { status: 200, body: { status: 'refused', error: busy(), producerLine: null } };
     guardRestore(id);
     const dir = rebuildDir(options.stateDir, p.sourceHash, id);
+    await adopt(id);
     await unkeep(id);
     const reused = await reuse<RetargetJob>(dir, id);
     if (reused) { jobs.set(id, reused); latestId = id; bodies.set(id, body); await landed(reused); return { status: 200, body: snapshot(reused) }; }
@@ -1237,9 +1382,10 @@ export function createRebuilds(p: ReviewPackage, options: RebuildOptions) {
     const id = designationId({ sourceHash: p.sourceHash, configHash: inputs.configHash, part: request.part, entry, producer: `${resolved.producer.package}@${resolved.producer.version}`, compiler: `${resolved.compiler.package}@${resolved.compiler.version}` });
     const current = jobs.get(id);
     if (current?.status === 'running') return { status: 202, body: snapshot(current) };
-    if (running) return { status: 200, body: { status: 'refused', error: `REBUILD_BUSY: rebuild ${running} is still running`, producerLine: null } };
+    if (busy()) return { status: 200, body: { status: 'refused', error: busy(), producerLine: null } };
     guardRestore(id);
     const dir = rebuildDir(options.stateDir, p.sourceHash, id);
+    await adopt(id);
     await unkeep(id);
     const reused = await reuse(dir, id);
     if (reused) { jobs.set(id, reused); latestId = id; bodies.set(id, input); await landed(reused); return { status: 200, body: snapshot(reused) }; }
@@ -1264,5 +1410,5 @@ export function createRebuilds(p: ReviewPackage, options: RebuildOptions) {
     return safeFile(await realpath(join(rebuildDir(options.stateDir, p.sourceHash, id), 'build')), packagePath(name));
   }
 
-  return { describe, start, read, file, running: () => running, baseline: settledBaseline, inspectedCheck: settledInspectedCheck, latest, undo, history };
+  return { describe, start, read, file, running: () => running, baseline: settledBaseline, inspectedCheck: settledInspectedCheck, latest, undo, history, startStrip, readStrip, stripJob, closeStrip, stripFile };
 }

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.
@@ -65,6 +66,17 @@ export async function startServer(p:ReviewPackage,options:{port?:number;stateDir
       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')));}
@@ -95,6 +107,14 @@ export async function startServer(p:ReviewPackage,options:{port?:number;stateDir
       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();},