@rig-c/parts 2.49.1 → 2.50.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/src/check.ts CHANGED
@@ -96,7 +96,7 @@ import { createHash } from 'node:crypto';
96
96
  import { createRequire } from 'node:module';
97
97
  import type { Candidate, Piece, Viewport as RootCoverageViewport } from '@rig-c/core/render-shared';
98
98
  import { fillHoles } from './raster/morph.ts';
99
- import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
99
+ import { closeSync, copyFileSync, cpSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from 'node:fs';
100
100
  import { diagnosticSegment, diagnosticSiblings } from './outputpaths.ts';
101
101
  import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
102
102
  import { measureRecomposite, type RecompositeFigures, recompositeRecord, scenePhrase, sourceInRig, figureSilhouette } from './assemble.ts';
@@ -4862,7 +4862,7 @@ export function motionSeamRequired(line: MotionSeamLine, rows: readonly MotionBa
4862
4862
  }
4863
4863
  const failed = problems.length - before;
4864
4864
  return { status: failed === 0 ? 'PASS' : 'FAIL', mode: 'gap-open', bar_px: 0, pairs: out, failed,
4865
- ...(cellEvidence.frames.length === 0 ? {} : { cells: { path: MOTION_CELLS_FILE, sha256: createHash('sha256').update(serializeCheckRows(cellEvidence)).digest('hex') } }) };
4865
+ ...(cellEvidence.frames.length === 0 ? {} : { cells: { path: MOTION_CELLS_FILE, sha256: hashMotionSeamCellSidecar(cellEvidence) } }) };
4866
4866
  }
4867
4867
 
4868
4868
  /** The inline partition counts the same cells as the sidecar, including unresolved setup slots. */
@@ -4873,7 +4873,7 @@ function motionCellClasses(cells: readonly MotionOpenCell[]): MotionOpenFrame['c
4873
4873
  }
4874
4874
 
4875
4875
  /** Refuse broken evidence links and partitions rather than silently consuming partial evidence. */
4876
- export function readMotionSeamCellSidecar(dir: string, required: MotionSeamRequired): MotionCellSidecar | null {
4876
+ export function readMotionSeamCellSidecar(dir: string, required: MotionSeamRequired, chunkBytes = 8 * 1024 * 1024): MotionCellSidecar | null {
4877
4877
  if (required.cells === undefined) return null;
4878
4878
  const bad = (object: string, detail: string): never => {
4879
4879
  refuseIfAny([{ code: 'FRAMES_SIDECAR', object, detail }]);
@@ -4882,53 +4882,53 @@ export function readMotionSeamCellSidecar(dir: string, required: MotionSeamRequi
4882
4882
  const reference = required.cells;
4883
4883
  if (reference.path !== MOTION_CELLS_FILE || !/^[a-f0-9]{64}$/.test(reference.sha256)) bad('SEAM_OVER_MOTION.required.cells', 'requires relative seam-cells.json path and a SHA-256 digest');
4884
4884
  const path = join(dir, reference.path);
4885
- let bytes: Buffer;
4886
- try { bytes = readFileSync(path); }
4887
- catch { return bad(path, 'referenced cell sidecar is missing or unreadable; unavailable is not zero'); }
4888
- const digest = createHash('sha256').update(bytes).digest('hex');
4889
- if (digest !== reference.sha256) bad(path, `SHA-256 is ${digest}; required ${reference.sha256}`);
4890
- let value: unknown;
4891
- try { value = JSON.parse(bytes.toString('utf8')) as unknown; }
4892
- catch { return bad(path, 'requires a JSON rig-parts-seam-cells/1 document'); }
4893
- if (!isRecord(value) || value.spec !== 'rig-parts-seam-cells/1' || !Array.isArray(value.frames)) return bad(path, 'requires rig-parts-seam-cells/1 frames');
4885
+ // Streamed frame-by-frame scan: hashes file chunks without building one whole-file
4886
+ // string, verifies the canonical rig-parts-seam-cells/1 frame layout, and summarizes
4887
+ // each frame's cells as it streams through the file.
4888
+ const summaries = scanMotionSeamCellSidecarFile(path, reference.sha256, bad, chunkBytes);
4894
4889
  const seen = new Set<number>();
4895
4890
  for (const pair of required.pairs) for (const frame of pair.open_frames ?? []) {
4896
4891
  const at = `${path} frames[${frame.cells_index}]`;
4897
- const read: unknown = value.frames[frame.cells_index];
4898
- if (!Number.isSafeInteger(frame.cells_index) || frame.cells_index < 0 || seen.has(frame.cells_index) || !isRecord(read) ||
4892
+ const summary = Number.isSafeInteger(frame.cells_index) && frame.cells_index >= 0 ? summaries[frame.cells_index] : undefined;
4893
+ const read = summary?.frame;
4894
+ if (summary === undefined || read === undefined || seen.has(frame.cells_index) ||
4899
4895
  read.pair !== pair.pair || read.animation !== frame.animation || read.index !== frame.index || read.time !== frame.time || read.px !== frame.px || read.cell !== frame.cell ||
4900
- JSON.stringify(read.box) !== JSON.stringify(frame.box) || !Array.isArray(read.cells) || read.cells.length !== frame.px) {
4896
+ JSON.stringify(read.box) !== JSON.stringify(frame.box) || summary.cellsLength !== frame.px) {
4901
4897
  bad(at, 'requires one matching pair-frame with cells.length === gapOpen px; unavailable is not zero');
4902
4898
  continue;
4903
4899
  }
4904
4900
  seen.add(frame.cells_index);
4905
- const classes = { figure: 0, background: 0, other: 0 };
4906
- for (const cell of read.cells) {
4907
- if (!isRecord(cell) || typeof cell.x !== 'number' || !Number.isFinite(cell.x) || typeof cell.y !== 'number' || !Number.isFinite(cell.y) ||
4908
- !(cell.setupTop === null || typeof cell.setupTop === 'string' && cell.setupTop.length > 0) ||
4909
- !(cell.setupUnder === null || typeof cell.setupUnder === 'string' && cell.setupUnder.length > 0) ||
4910
- !['figure', 'background', 'other'].includes(String(cell.class))) bad(at, 'requires finite world centres, setup names and figure/background/other classes');
4911
- else classes[cell.class as MotionOpenCell['class']]++;
4901
+ if (!summary.cellsValid) {
4902
+ bad(at, 'requires finite world centres, setup names and figure/background/other classes');
4912
4903
  }
4904
+ const classes = summary.classes;
4905
+ // Every cell in the sidecar frame was checked and tallied during the streamed
4906
+ // scan before its cell array was replaced by an on-demand slice reader, so
4907
+ // peak string length and retained heap stay bounded by a single frame.
4913
4908
  if (!frame.classes || !Object.values(frame.classes).every(n => Number.isSafeInteger(n) && n >= 0) ||
4914
4909
  frame.classes.figure + frame.classes.background + frame.classes.other !== frame.px ||
4915
4910
  frame.classes.figure !== classes.figure || frame.classes.background !== classes.background || frame.classes.other !== classes.other) {
4916
4911
  bad(at, `inline figure/background/other counts ${JSON.stringify(frame.classes)} must sum to gapOpen px ${frame.px} and match sidecar ${JSON.stringify(classes)}`);
4917
4912
  }
4918
4913
  }
4919
- if (seen.size !== value.frames.length) bad(path, `has ${value.frames.length} frame(s); inline rows reference ${seen.size} distinct frame(s)`);
4914
+ if (seen.size !== summaries.length) {
4915
+ bad(path, `has ${summaries.length} frame(s); inline rows reference ${seen.size} distinct frame(s)`);
4916
+ }
4920
4917
  // Every cell and its pair/frame identity was checked above after the digest matched.
4921
- return value as unknown as MotionCellSidecar;
4918
+ return {
4919
+ spec: 'rig-parts-seam-cells/1',
4920
+ frames: summaries.map(s => s.frame),
4921
+ };
4922
4922
  }
4923
4923
 
4924
4924
  /** Publish check.json and its cell evidence together, restoring previous bytes on refusal. */
4925
- export function publishMotionSeamCells(dir: string, required: MotionSeamRequired | undefined, evidence: MotionCellSidecar, publish: () => void): void {
4925
+ export function publishMotionSeamCells(dir: string, required: MotionSeamRequired | undefined, evidence: MotionCellSidecar, publish: () => void, onChunk?: (chunk: string, index: number) => void): void {
4926
4926
  const path = join(dir, MOTION_CELLS_FILE), check = join(dir, 'check.json');
4927
4927
  const previous = existsSync(path) ? readFileSync(path) : null;
4928
4928
  const previousCheck = existsSync(check) ? readFileSync(check) : null;
4929
4929
  try {
4930
4930
  if (required?.cells !== undefined) {
4931
- writeFileSync(path, serializeCheckRows(evidence));
4931
+ writeMotionSeamCellSidecar(path, evidence, onChunk);
4932
4932
  readMotionSeamCellSidecar(dir, required);
4933
4933
  }
4934
4934
  publish();
@@ -9973,3 +9973,228 @@ export function stretchLine(geo: IdleGeometry | null, path: string, problems: Pr
9973
9973
 
9974
9974
  /** The compiler's `build-report/1` (`--report`) written beside `build/` on the primary packed compile (issue #1394). */
9975
9975
  export const BUILD_REPORT_FILE = 'build-report.json';
9976
+
9977
+ /**
9978
+ * Issue #1406: stream `seam-cells.json` (`rig-parts-seam-cells/1`) frame by frame so peak
9979
+ * JS string length is a single frame while emitting the exact bytes `serializeCheckRows` writes.
9980
+ */
9981
+ export function streamMotionSeamCellSidecar(evidence: MotionCellSidecar, sink: (chunk: string) => void): void {
9982
+ if (evidence.frames.length === 0) {
9983
+ sink(`{\n "spec": ${JSON.stringify(evidence.spec)},\n "frames": [`);
9984
+ sink(']\n}\n');
9985
+ return;
9986
+ }
9987
+ sink(`{\n "spec": ${JSON.stringify(evidence.spec)},\n "frames": [\n`);
9988
+ for (let i = 0; i < evidence.frames.length; i++) {
9989
+ const suffix = i + 1 < evidence.frames.length ? ',\n' : '\n';
9990
+ sink(` ${JSON.stringify(evidence.frames[i], null, 1).replaceAll('\n', '\n ')}${suffix}`);
9991
+ }
9992
+ sink(' ]\n}\n');
9993
+ }
9994
+
9995
+ /** Compute the SHA-256 of the streamed `seam-cells.json` chunks without building a whole-document string. */
9996
+ export function hashMotionSeamCellSidecar(evidence: MotionCellSidecar): string {
9997
+ const hash = createHash('sha256');
9998
+ streamMotionSeamCellSidecar(evidence, (chunk) => { hash.update(chunk); });
9999
+ return hash.digest('hex');
10000
+ }
10001
+
10002
+ /** Write `seam-cells.json` chunk by chunk through one file descriptor; `onChunk` supports mid-stream failure controls. */
10003
+ export function writeMotionSeamCellSidecar(path: string, evidence: MotionCellSidecar, onChunk?: (chunk: string, index: number) => void): void {
10004
+ const fd = openSync(path, 'w');
10005
+ let index = 0;
10006
+ try {
10007
+ streamMotionSeamCellSidecar(evidence, (chunk) => {
10008
+ writeSync(fd, chunk);
10009
+ onChunk?.(chunk, index++);
10010
+ });
10011
+ } finally {
10012
+ closeSync(fd);
10013
+ }
10014
+ }
10015
+
10016
+ interface StreamedSidecarFrameSummary {
10017
+ frame: MotionCellFrame;
10018
+ cellsLength: number | null;
10019
+ cellsValid: boolean;
10020
+ classes: { figure: number; background: number; other: number };
10021
+ }
10022
+
10023
+ function summarizeStreamedFrame(path: string, parsed: Record<string, unknown>, startOffset: number, endOffset: number): StreamedSidecarFrameSummary {
10024
+ const cells = Array.isArray(parsed.cells) ? parsed.cells : null;
10025
+ let cellsValid = cells !== null;
10026
+ const classes = { figure: 0, background: 0, other: 0 };
10027
+ if (cells !== null) {
10028
+ for (const cell of cells) {
10029
+ if (!isRecord(cell) || typeof cell.x !== 'number' || !Number.isFinite(cell.x) || typeof cell.y !== 'number' || !Number.isFinite(cell.y) ||
10030
+ !(cell.setupTop === null || typeof cell.setupTop === 'string' && cell.setupTop.length > 0) ||
10031
+ !(cell.setupUnder === null || typeof cell.setupUnder === 'string' && cell.setupUnder.length > 0) ||
10032
+ !['figure', 'background', 'other'].includes(String(cell.class))) cellsValid = false;
10033
+ else classes[cell.class as MotionOpenCell['class']]++;
10034
+ }
10035
+ }
10036
+ const frame = { ...parsed } as unknown as MotionCellFrame;
10037
+ Object.defineProperty(frame, 'cells', {
10038
+ enumerable: true,
10039
+ configurable: true,
10040
+ get(): MotionOpenCell[] {
10041
+ const slice = Buffer.allocUnsafe(endOffset - startOffset);
10042
+ const fd = openSync(path, 'r');
10043
+ try { readSync(fd, slice, 0, slice.length, startOffset); }
10044
+ finally { closeSync(fd); }
10045
+ const loaded = (JSON.parse(slice.toString('utf8')) as { cells: MotionOpenCell[] }).cells;
10046
+ Object.defineProperty(frame, 'cells', { value: loaded, enumerable: true, configurable: true, writable: true });
10047
+ return loaded;
10048
+ },
10049
+ });
10050
+ return { frame, cellsLength: cells === null ? null : cells.length, cellsValid, classes };
10051
+ }
10052
+
10053
+ /**
10054
+ * Single-pass streamed reader for `seam-cells.json`: hashes raw byte chunks without allocating
10055
+ * a whole-file string or buffer, verifies the canonical streamed frame layout, and summarizes
10056
+ * each frame's cells one frame at a time.
10057
+ */
10058
+ function scanMotionSeamCellSidecarFile(path: string, expectedSha256: string, bad: (object: string, detail: string) => never, chunkBytes = 8 * 1024 * 1024): StreamedSidecarFrameSummary[] {
10059
+ let fd: number;
10060
+ try { fd = openSync(path, 'r'); }
10061
+ catch { return bad(path, 'referenced cell sidecar is missing or unreadable; unavailable is not zero'); }
10062
+ const hash = createHash('sha256');
10063
+ const step = Math.max(1, Math.floor(chunkBytes));
10064
+ const buf = Buffer.allocUnsafe(step);
10065
+ let totalBytes = 0;
10066
+ let state: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 = 0;
10067
+ let failure: 'json' | 'layout' | null = null;
10068
+ let carry: Buffer = Buffer.alloc(0);
10069
+ let carryStartOffset = 0;
10070
+ let frameChunks: Buffer[] = [];
10071
+ let frameStartOffset = 0;
10072
+ let frameBytes = 0;
10073
+ const summaries: StreamedSidecarFrameSummary[] = [];
10074
+ try {
10075
+ for (;;) {
10076
+ let n: number;
10077
+ try { n = readSync(fd, buf, 0, buf.length, totalBytes); }
10078
+ catch { return bad(path, 'referenced cell sidecar is missing or unreadable; unavailable is not zero'); }
10079
+ if (n === 0) break;
10080
+ const raw = buf.subarray(0, n);
10081
+ hash.update(raw);
10082
+ const rawStartOffset = totalBytes;
10083
+ totalBytes += n;
10084
+ if (failure !== null) continue;
10085
+ const chunk = carry.length === 0 ? raw : Buffer.concat([carry, raw]);
10086
+ const chunkBaseOffset = carry.length === 0 ? rawStartOffset : carryStartOffset;
10087
+ let lineStart = 0;
10088
+ while (lineStart < chunk.length && failure === null) {
10089
+ if (state === 4) {
10090
+ const runStart = lineStart;
10091
+ let closedFrame = false;
10092
+ while (lineStart < chunk.length) {
10093
+ const nl = chunk.indexOf(0x0a, lineStart);
10094
+ if (nl === -1) break;
10095
+ if (nl - lineStart >= 3 && chunk[lineStart] === 0x20 && chunk[lineStart + 1] === 0x20 && chunk[lineStart + 2] === 0x20) {
10096
+ if (frameBytes + (nl + 1 - runStart) > 0x7fff_ff00) { failure = 'layout'; closedFrame = true; break; }
10097
+ lineStart = nl + 1;
10098
+ continue;
10099
+ }
10100
+ if (lineStart > runStart) {
10101
+ const piece = Buffer.from(chunk.subarray(runStart, lineStart));
10102
+ frameChunks.push(piece);
10103
+ frameBytes += piece.length;
10104
+ }
10105
+ const closeLine = chunk.subarray(lineStart, nl).toString('utf8');
10106
+ const closeLineFileOffset = chunkBaseOffset + lineStart;
10107
+ lineStart = nl + 1;
10108
+ if (closeLine !== ' },' && closeLine !== ' }') { failure = 'layout'; closedFrame = true; break; }
10109
+ frameChunks.push(Buffer.from(' }'));
10110
+ const frameEndOffset = closeLineFileOffset + 3;
10111
+ const frameText = Buffer.concat(frameChunks).toString('utf8');
10112
+ frameChunks = [];
10113
+ frameBytes = 0;
10114
+ let parsed: unknown;
10115
+ try { parsed = JSON.parse(frameText) as unknown; }
10116
+ catch { failure = 'json'; closedFrame = true; break; }
10117
+ if (!isRecord(parsed) || ` ${JSON.stringify(parsed, null, 1).replaceAll('\n', '\n ')}` !== frameText) {
10118
+ failure = 'layout';
10119
+ closedFrame = true;
10120
+ break;
10121
+ }
10122
+ summaries.push(summarizeStreamedFrame(path, parsed, frameStartOffset, frameEndOffset));
10123
+ state = closeLine === ' },' ? 3 : 5;
10124
+ closedFrame = true;
10125
+ break;
10126
+ }
10127
+ if (!closedFrame) {
10128
+ if (lineStart > runStart) {
10129
+ const piece = Buffer.from(chunk.subarray(runStart, lineStart));
10130
+ frameChunks.push(piece);
10131
+ frameBytes += piece.length;
10132
+ if (frameBytes > 0x7fff_ff00) failure = 'layout';
10133
+ }
10134
+ break;
10135
+ }
10136
+ } else {
10137
+ const nl = chunk.indexOf(0x0a, lineStart);
10138
+ if (nl === -1) break;
10139
+ const lineFileOffset = chunkBaseOffset + lineStart;
10140
+ const line = chunk.subarray(lineStart, nl).toString('utf8');
10141
+ lineStart = nl + 1;
10142
+ if (state === 0) {
10143
+ if (line === '{') state = 1;
10144
+ else failure = 'layout';
10145
+ } else if (state === 1) {
10146
+ if (line === ' "spec": "rig-parts-seam-cells/1",') state = 2;
10147
+ else failure = 'layout';
10148
+ } else if (state === 2) {
10149
+ if (line === ' "frames": []') state = 6;
10150
+ else if (line === ' "frames": [') state = 3;
10151
+ else failure = 'layout';
10152
+ } else if (state === 3) {
10153
+ if (line === ' {') {
10154
+ frameChunks = [Buffer.from(' {\n')];
10155
+ frameBytes = 4;
10156
+ frameStartOffset = lineFileOffset;
10157
+ state = 4;
10158
+ } else failure = 'layout';
10159
+ } else if (state === 5) {
10160
+ if (line === ' ]') state = 6;
10161
+ else failure = 'layout';
10162
+ } else if (state === 6) {
10163
+ if (line === '}') state = 7;
10164
+ else failure = 'layout';
10165
+ } else {
10166
+ failure = 'layout';
10167
+ }
10168
+ }
10169
+ }
10170
+ if (failure === null) {
10171
+ if (lineStart < chunk.length) {
10172
+ carry = Buffer.from(chunk.subarray(lineStart));
10173
+ carryStartOffset = chunkBaseOffset + lineStart;
10174
+ if (carry.length > 4 * 1024 * 1024) failure = 'layout';
10175
+ } else {
10176
+ carry = Buffer.alloc(0);
10177
+ carryStartOffset = totalBytes;
10178
+ }
10179
+ }
10180
+ }
10181
+ } finally {
10182
+ closeSync(fd);
10183
+ }
10184
+ const digest = hash.digest('hex');
10185
+ if (digest !== expectedSha256) bad(path, `SHA-256 is ${digest}; required ${expectedSha256}`);
10186
+ if (failure !== null || state !== 7 || carry.length !== 0) {
10187
+ if (totalBytes <= 4 * 1024 * 1024) {
10188
+ let value: unknown;
10189
+ try { value = JSON.parse(readFileSync(path, 'utf8')) as unknown; }
10190
+ catch { return bad(path, 'requires a JSON rig-parts-seam-cells/1 document'); }
10191
+ if (!isRecord(value) || value.spec !== 'rig-parts-seam-cells/1' || !Array.isArray(value.frames)) {
10192
+ return bad(path, 'requires rig-parts-seam-cells/1 frames');
10193
+ }
10194
+ return bad(path, 'requires canonical rig-parts-seam-cells/1 streamed frame layout');
10195
+ }
10196
+ if (failure === 'json') return bad(path, 'requires a JSON rig-parts-seam-cells/1 document');
10197
+ return bad(path, 'requires canonical rig-parts-seam-cells/1 streamed frame layout');
10198
+ }
10199
+ return summaries;
10200
+ }
@@ -17,6 +17,10 @@ import { PartsError } from './errors.ts';
17
17
  import { parseConfig, parseEarlyConfig, parseProposalSections } from './config.ts';
18
18
  import type { ConfigEdit } from './meshdraft.ts';
19
19
 
20
+ /** Required point fields and optional shape fields of `meshes.<part>.contour.bust`, in the shorthand order `src/config.ts` validates (issues #475, #1428). */
21
+ const BUST_LANDMARK_FIELDS = ['apex_r', 'apex_l', 'cleavage'] as const;
22
+ export const BUST_SHAPE_FIELDS = ['alpha', 'clearance', 'bone_r', 'bone_l', 'spacing'] as const;
23
+
20
24
  export type ConfigJson = null | boolean | number | string | ConfigJson[] | ConfigObject;
21
25
  export interface ConfigObject { [key: string]: ConfigJson }
22
26
  export type ConfigWritePatch =
@@ -24,9 +28,17 @@ export type ConfigWritePatch =
24
28
  | { kind: 'neck-unit'; config: CharacterConfig }
25
29
  | { kind: 'head-box'; head_box: HeadBoxProposal['head_box'] }
26
30
  | { kind: 'assemble-plan'; plan: PlanProposal['plan']; extend_below_crop: PlanProposal['extend_below_crop'] }
27
- | { kind: 'proposal'; proposal: Proposal; sections: typeof PROPOSAL_CONFIG_SECTIONS }
31
+ | { kind: 'proposal'; proposal: Proposal; sections: typeof PROPOSAL_CONFIG_SECTIONS; bustShape?: PendingBustShape }
28
32
  /** Issues #671/#679: add unattached, resolvable entries; append skip explanations to the proposal's notes for the caller to print. */
29
- | { kind: 'proposal-missing'; proposal: Proposal; parts: ReadonlyArray<{ name: string; from: string }> };
33
+ | { kind: 'proposal-missing'; proposal: Proposal; parts: ReadonlyArray<{ name: string; from: string }> }
34
+ /** `bust-landmarks --write-config` (issue #1382): set or remove named shape fields of one part's existing
35
+ * `meshes.<part>.contour.bust`; a field with no value is removed, every other key is kept where it is. */
36
+ | { kind: 'bust-shape'; part: string; fields: ReadonlyArray<{ key: BustShapeKey; value?: number | string }> };
37
+ /** The `contour.bust` fields the landmarks file does not carry, the only ones a `bust-shape` patch writes. */
38
+ export type BustShapeKey = (typeof BUST_SHAPE_FIELDS)[number];
39
+ /** A reviewed shape `bust-landmarks` left pending in its sidecar (issue #1382): `propose --write-config` writes it
40
+ * onto the drafted chest carrier's `contour.bust`, after the three points, in the shorthand's key order. */
41
+ export interface PendingBustShape { part: string; fields: Partial<Record<BustShapeKey, number | string>> }
30
42
  export interface ConfigWriteChange {
31
43
  path: string;
32
44
  kind: 'added' | 'replaced' | 'removed';
@@ -148,6 +160,38 @@ export function mergeConfigProposal(raw: unknown, patch: ConfigWritePatch, recei
148
160
  if (patch.proposal[key] !== undefined) {
149
161
  const previous = config[key];
150
162
  config[key] = clone(patch.proposal[key], `proposal.${key}`);
163
+ if (key === 'meshes' && (object(previous) || patch.bustShape !== undefined) && object(config.meshes)) {
164
+ const carriers: string[] = [];
165
+ for (const [part, mesh] of Object.entries(config.meshes)) {
166
+ if (!object(mesh) || !object(mesh.contour) || !object(mesh.contour.bust)) continue;
167
+ carriers.push(part);
168
+ const draftedBust = mesh.contour.bust;
169
+ const prevMesh = object(previous) && own(previous, part) ? previous[part] : undefined;
170
+ const prevBust = object(prevMesh) && object(prevMesh.contour) && object(prevMesh.contour.bust) ? prevMesh.contour.bust : null;
171
+ const mergedBust: ConfigObject = {};
172
+ for (const k of BUST_LANDMARK_FIELDS) if (own(draftedBust, k)) mergedBust[k] = draftedBust[k];
173
+ // A pending reviewed shape (issue #1382) is the act's value for its fields; the rest keep what the config declares.
174
+ const pending = patch.bustShape?.part === part ? patch.bustShape.fields : undefined;
175
+ for (const k of BUST_SHAPE_FIELDS) {
176
+ const value = pending?.[k];
177
+ if (value !== undefined) mergedBust[k] = value;
178
+ else if (prevBust !== null && own(prevBust, k)) mergedBust[k] = prevBust[k];
179
+ }
180
+ mesh.contour.bust = mergedBust;
181
+ }
182
+ for (const [oldPart, prevMesh] of Object.entries(object(previous) ? previous : {})) {
183
+ if (carriers.includes(oldPart) || !object(prevMesh) || !object(prevMesh.contour) || !object(prevMesh.contour.bust)) continue;
184
+ const prevBust = prevMesh.contour.bust;
185
+ const dropped = BUST_SHAPE_FIELDS.filter((k) => own(prevBust, k));
186
+ if (dropped.length === 0) continue;
187
+ if (Array.isArray(patch.proposal.notes) && patch.proposal.notes.some((n) => n.startsWith(`${oldPart}: contour bust omitted for the declared reason: `))) continue;
188
+ const why = carriers.length > 0 ? `chest carrier is now ${carriers.join(', ')}` : `${oldPart} is no longer the chest carrier`;
189
+ const line = `${oldPart}: contour.bust shape field(s) ${dropped.join(', ')} dropped — ${why}`;
190
+ if (Array.isArray(patch.proposal.notes) && !Object.isFrozen(patch.proposal.notes) && !patch.proposal.notes.includes(line)) {
191
+ patch.proposal.notes.push(line);
192
+ }
193
+ }
194
+ }
151
195
  if (!equal(previous, config[key])) edits.push({ path: [key], value: config[key] });
152
196
  }
153
197
  }
@@ -231,7 +275,24 @@ export function mergeConfigProposal(raw: unknown, patch: ConfigWritePatch, recei
231
275
  }
232
276
  return { config, changes: added, edits };
233
277
  }
234
- default: return refuse('write-config', 'has no supported operation; edited-part-receipt, neck-unit, head-box, assemble-plan, proposal or proposal-missing is required');
278
+ case 'bust-shape': {
279
+ const at = `${field('config.meshes', patch.part)}.contour.bust`;
280
+ const meshes = config.meshes;
281
+ const mesh = object(meshes) && own(meshes, patch.part) ? meshes[patch.part] : undefined;
282
+ const contour = object(mesh) ? mesh.contour : undefined;
283
+ const bust = object(contour) ? contour.bust : undefined;
284
+ if (!object(contour) || !object(bust)) return refuse(at, 'is absent or not an object; an existing contour.bust is required before its shape fields are written');
285
+ const next = clone(bust, at) as ConfigObject;
286
+ for (const { key, value } of patch.fields) {
287
+ if (value === undefined) delete next[key];
288
+ else next[key] = value;
289
+ }
290
+ contour.bust = next;
291
+ // This patch owns the one bust object, never the mesh or its other contour fields.
292
+ if (!equal(bust as ConfigObject, next)) edits.push({ path: ['meshes', patch.part, 'contour', 'bust'], value: next });
293
+ break;
294
+ }
295
+ default: return refuse('write-config', 'has no supported operation; edited-part-receipt, neck-unit, head-box, assemble-plan, proposal, proposal-missing or bust-shape is required');
235
296
  }
236
297
  return { config, changes: changes(before, config), edits };
237
298
  }