rig-review 4.3.0 → 4.5.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/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "rig-review",
3
- "version": "4.3.0",
3
+ "version": "4.5.0",
4
4
  "type": "module",
5
5
  "description": "Local human rig inspection and structured feedback export",
6
6
  "license": "MIT",
package/src/job-front.ts CHANGED
@@ -5,10 +5,10 @@ import {checkpointEvidenceMetadata, readCheckpointEvidenceBytes} from './job-che
5
5
  import { JOB_API_SCHEMA, JOB_ACT_SCHEMA, type JobErrorCode, type JobHostPorts, type JobId, type JobPublicationMode, type JobResult, type JobReviewerBinding } from './job-contract.ts';
6
6
  import { createJobHostPorts, jobBody, jobHash, jobId, jobObject, jobPartsEnumeratorVersion } from './job-api.ts';
7
7
  import { JobSession } from './job-session.ts';
8
- import { assertJobRoot, assertRetainedSnapshotIntact, captureJobRoot, planTextMetadata, isRetainedRecordSource, type JobRootIdentity } from './job-source.ts';
8
+ import { assertJobRoot, assertRetainedSnapshotIntact, captureJobRoot, planTextMetadata, isRetainedRecordSource, loadRetainedJobReview, type JobRootIdentity } from './job-source.ts';
9
9
  import type { JobWorkerOptions } from './job-worker.ts';
10
10
  import { JobError, JobStore, jobCropReferences } from './job-store.ts';
11
- import { loadReview, safeFile, packagePath, type ReviewPackage } from './manifest.ts';
11
+ import { safeFile, packagePath, type ReviewPackage } from './manifest.ts';
12
12
  import { serveReference, assertReviewUnchanged } from './reference.ts';
13
13
  import {preparePartsComment} from './parts-comment-crops.ts';
14
14
  import { loadPartsView, partsViewJson, partsDifference, servedImage, type PartsViewPackage } from './parts-view.ts';
@@ -188,7 +188,8 @@ export function createJobFront(options: {
188
188
  });
189
189
  return new Response(body, { headers: { ...headers, 'Content-Type': 'application/x-ndjson' } });
190
190
  }
191
- if (url.search && !(route === '' && ['?lang=en', '?lang=ko'].includes(url.search))) {
191
+ const partsDifferenceQuery = /^publications\/[A-Za-z0-9][A-Za-z0-9._-]{0,127}\/instances\/[a-f0-9]{64}\/api\/stage-parts\/difference\/(0|[1-9]\d*)$/.test(route);
192
+ if (url.search && !partsDifferenceQuery && !(route === '' && ['?lang=en', '?lang=ko'].includes(url.search))) {
192
193
  return failure('JOB_REQUEST_INVALID', 400);
193
194
  }
194
195
  const instance = /^publications\/([A-Za-z0-9][A-Za-z0-9._-]{0,127})\/instances\/([a-f0-9]{64})\/(.*)$/.exec(route);
@@ -330,7 +331,7 @@ export function retainedPublicationRoutes(session: JobSession) {
330
331
  let pending = views.get(publicationId);
331
332
  if (!pending) {
332
333
  pending = (async () => {
333
- const review = await loadReview(retained.manifestPath);
334
+ const review = await loadRetainedJobReview(retained, session.attestation().fingerprint);
334
335
  const partsRoot = retained.source.parts
335
336
  ? dirname(join(retained.snapshotRoot, retained.source.parts.manifest.path)) : null;
336
337
  // Forward only retained producer files. Discovery never reads the live draft.
@@ -436,8 +437,14 @@ export function retainedPublicationRoutes(session: JobSession) {
436
437
  if(difference&&parts){
437
438
  const url=new URL(request.url),threshold=url.searchParams.get('threshold'),footprints=url.searchParams.get('footprints');
438
439
  if(!threshold||!/^\d{1,3}$/.test(threshold)||!['true','false'].includes(footprints??''))return failure('JOB_REQUEST_INVALID',400);
439
- const raster=await partsDifference(parts,Number(difference[1]),Number(threshold),footprints==='true'),png=new PNG({width:raster.width,height:raster.height});png.data=Buffer.from(raster.data);
440
- return new Response(request.method==='HEAD'?null:new Uint8Array(PNG.sync.write(png)),{headers:{...headers,'Content-Type':'image/png','X-Difference-Count':String(raster.count),'X-Difference-Covered':String(raster.covered),'X-Difference-Compared':String(raster.compared)}});
440
+ try {
441
+ const raster=await partsDifference(parts,Number(difference[1]),Number(threshold),footprints==='true'),png=new PNG({width:raster.width,height:raster.height});png.data=Buffer.from(raster.data);
442
+ return new Response(request.method==='HEAD'?null:new Uint8Array(PNG.sync.write(png)),{headers:{...headers,'Content-Type':'image/png','X-Difference-Count':String(raster.count),'X-Difference-Covered':String(raster.covered),'X-Difference-Compared':String(raster.compared)}});
443
+ } catch (error) {
444
+ const code = error instanceof Error ? /^(PARTS_DIFFERENCE_UNAVAILABLE|PARTS_DIFFERENCE_PNG):/.exec(error.message)?.[1] : undefined;
445
+ if (code) return failure(code, 400);
446
+ throw error;
447
+ }
441
448
  }
442
449
  const part = /^api\/stage-parts\/(image|page)\/(0|[1-9]\d*)$/.exec(path);
443
450
  if (part && parts) {
@@ -459,7 +466,8 @@ export function retainedPublicationRoutes(session: JobSession) {
459
466
  const code = error instanceof JobError ? error.code :
460
467
  error instanceof Error && error.message.startsWith('PARTS_COMMENT_STALE_SOURCE:')
461
468
  ? 'PARTS_COMMENT_STALE_SOURCE' : 'JOB_SOURCE_MISMATCH';
462
- const message = error instanceof JobError && /^(CHECKPOINT_EVIDENCE|PLAN_TEXT)_[A-Z_]+$/.test(error.message)
469
+ const message = error instanceof JobError && (/^(CHECKPOINT_EVIDENCE|PLAN_TEXT)_[A-Z_]+$/.test(error.message) ||
470
+ error.code === 'JOB_SOURCE_UNRETAINABLE' && error.message.startsWith('snapshot reload '))
463
471
  ? error.message : undefined;
464
472
  return failure(code, errorStatus[code as JobErrorCode] ?? 409, undefined, message);
465
473
  }
@@ -10,12 +10,11 @@ import {
10
10
  import { bindJobAsk, bindJobRecordAsk, finalizeJobAct, parseUISubmission, prepareJobRecordAct, prepareJobStill } from './job-act.ts';
11
11
  import { isRecordSource, parseRecordSource, parseCommentsAct, jobApiSchemaForMode, jobHash, jobPartsEnumeratorVersion, jobWaitLimitMs, requestDigest, sameCapability } from './job-api.ts';
12
12
  import {
13
- assertStoredCheckpointEvidence, assertJobRoot, assertJobSourceCurrent, assertRetainedSnapshotIntact, captureJobRoot, isRetainedRecordSource, prepareJobSource, jobSnapshotHash, removeOwnedJobSnapshot, verifyJobRecordSourceFresh,
13
+ assertStoredCheckpointEvidence, assertJobRoot, assertJobSourceCurrent, assertRetainedSnapshotIntact, captureJobRoot, isRetainedRecordSource, loadRetainedJobReview, prepareJobSource, jobSnapshotHash, removeOwnedJobSnapshot, verifyJobRecordSourceFresh,
14
14
  type JobPublicationReader, type JobRetainedSource, type JobRetainedSourceV3, type JobRootIdentity,
15
15
  } from './job-source.ts';
16
16
  import { JobError, JobStore, jobCropReferences, type JobSnapshotOwner, type StoredJob } from './job-store.ts';
17
17
  import { canonicalStatePath } from './state-dir.ts';
18
- import { loadReview } from './manifest.ts';
19
18
  import { loadPartsView } from './parts-view.ts';
20
19
  import { validateStoredPartsComment } from './parts-comment-crops.ts';
21
20
  import { commentPartsIssues } from './parts-comment.ts';
@@ -693,7 +692,7 @@ export class JobSession {
693
692
  assertRetainedSnapshotIntact(retained.snapshotRoot, retained.seals,
694
693
  retained.snapshotIdentity, 'JOB_ACT_SOURCE_STALE');
695
694
  try {
696
- const review = await loadReview(retained.manifestPath);
695
+ const review = await loadRetainedJobReview(retained, this.attestation().fingerprint);
697
696
  const painting = review.handoff?.source;
698
697
  const sealedPainting = painting && retained.seals.some(file =>
699
698
  file.path === relative(retained.snapshotRoot, painting).split(sep).join('/')) ? painting : undefined;
@@ -786,19 +785,35 @@ export class JobSession {
786
785
  };
787
786
  }
788
787
 
789
- private async next(after: string | null, waitMs: number, signal: AbortSignal): Promise<JobNextValue | NextValueV3> {
788
+ private async next(after: string | null, waitMs: number, signal: AbortSignal, observeWrites = false): Promise<JobNextValue | NextValueV3> {
790
789
  if (waitMs < 0 || waitMs > jobWaitLimitMs || !Number.isSafeInteger(waitMs)) throw new JobError('JOB_REQUEST_INVALID');
791
790
  if (signal.aborted) throw new JobError('JOB_REQUEST_INVALID', 'Request cancelled');
791
+ // Capture before reading events so a commit between the read and listener registration still wakes us.
792
+ const revision = observeWrites ? this.store.revision(this.jobId) : null;
792
793
  const ready = this.events(after);
793
794
  if (ready.status !== 'timeout' || !waitMs) return ready;
794
795
  await new Promise<void>((resolve, reject) => {
795
- const finish = () => { clearTimeout(timer); this.listeners.delete(finish); signal.removeEventListener('abort', abort); resolve(); };
796
- const abort = () => { clearTimeout(timer); this.listeners.delete(finish); signal.removeEventListener('abort', abort); reject(new JobError('JOB_REQUEST_INVALID', 'Request cancelled')); };
796
+ let poll: ReturnType<typeof setInterval> | undefined;
797
+ let settled = false;
798
+ const cleanup = () => { clearTimeout(timer); clearInterval(poll); this.listeners.delete(finish); signal.removeEventListener('abort', abort); };
799
+ const finish = () => { if (settled) return; settled = true; cleanup(); resolve(); };
800
+ const fail = (error: unknown) => { if (settled) return; settled = true; cleanup(); reject(error); };
801
+ const abort = () => fail(new JobError('JOB_REQUEST_INVALID', 'Request cancelled'));
802
+ const changed = () => {
803
+ try { if (this.store.revision(this.jobId) !== revision) finish(); }
804
+ catch (error) { fail(error); }
805
+ };
797
806
  const timer = setTimeout(finish, waitMs);
798
807
  this.listeners.add(finish);
799
808
  signal.addEventListener('abort', abort, { once: true });
800
- if (signal.aborted) abort();
801
- else if (this.events(after).status !== 'timeout') finish();
809
+ try {
810
+ if (signal.aborted) abort();
811
+ else if (observeWrites) {
812
+ // Other sessions commit to the same store but cannot notify this instance's listeners.
813
+ poll = setInterval(changed, 250);
814
+ changed();
815
+ } else if (this.events(after).status !== 'timeout') finish();
816
+ } catch (error) { fail(error); }
802
817
  });
803
818
  return this.events(after);
804
819
  }
@@ -808,7 +823,7 @@ export class JobSession {
808
823
  let after = input.after;
809
824
  while (!input.signal.aborted) {
810
825
  let value: JobNextValue | NextValueV3;
811
- try { value = await this.next(after, jobWaitLimitMs, input.signal); }
826
+ try { value = await this.next(after, jobWaitLimitMs, input.signal, true); }
812
827
  catch (error) {
813
828
  if (input.signal.aborted && error instanceof JobError && error.code === 'JOB_REQUEST_INVALID') return;
814
829
  throw error;
package/src/job-source.ts CHANGED
@@ -17,7 +17,7 @@ import type {
17
17
  RecordReaderInput, RecordResult, RecordSource, RecordSubject,
18
18
  } from './job-contract.ts';
19
19
  import { checkedPath, jsonObject, readProject, readRegular, type InterviewQuestion, type InterviewSet } from './interview-project.ts';
20
- import { loadReview } from './manifest.ts';
20
+ import { loadJobReview } from './manifest.ts';
21
21
  import { HandoffError } from './handoff.ts';
22
22
  import { openKey } from './open.ts';
23
23
  import { assertReviewUnchanged } from './reference.ts';
@@ -66,6 +66,18 @@ export interface JobPublishedContext {
66
66
  readonly files: readonly JobFileIdentity[];
67
67
  }
68
68
 
69
+ /** Reload only the identity recorded for this publication; old bindings are never relabelled. */
70
+ export async function loadRetainedJobReview(retained: JobRetainedSource, fingerprint: string) {
71
+ const review = await loadJobReview(retained.manifestPath, retained.root.path);
72
+ const found = openKey({mode: 'single', p: {...review, sourceHash: retained.source.sourceHash},
73
+ inputs: {input: join(retained.root.path, relative(retained.snapshotRoot, retained.manifestPath))},
74
+ contentHash: retained.source.sourceHash, selection: null}, fingerprint);
75
+ if (found !== retained.instanceKey) throw new JobError('JOB_SOURCE_UNRETAINABLE',
76
+ `snapshot reload instanceKey ${found} requires stored ${retained.instanceKey} ` +
77
+ `(handoff ${review.handoff?.record.config.path ?? 'none'})`);
78
+ return review;
79
+ }
80
+
69
81
  export type JobPublicationReader = (input: {
70
82
  readonly root: string;
71
83
  readonly record: JobFileIdentity;
@@ -1321,10 +1333,11 @@ export async function prepareJobSource(options: {
1321
1333
  const declared = publishedIdentities(context);
1322
1334
  const evidence = checkpointEvidenceFields(context, context.plan, context.subjects, declared);
1323
1335
  checkpointEvidenceMetadata(root.path, evidence.checkpointEvidence);
1324
- let review: Awaited<ReturnType<typeof loadReview>>;
1336
+ let review: Awaited<ReturnType<typeof loadJobReview>>;
1325
1337
  try {
1326
1338
  const target = checkedPath(root.path, request.result.path, lstatSync(join(root.path, request.result.path)).isDirectory());
1327
- review = await loadReview(target);
1339
+ // Resolve producer references from the designated job root for both copies.
1340
+ review = await loadJobReview(target, root.path);
1328
1341
  } catch (error) {
1329
1342
  throw new JobError('JOB_SOURCE_MISMATCH', error instanceof HandoffError ? error.message : undefined);
1330
1343
  }
@@ -1388,9 +1401,12 @@ export async function prepareJobSource(options: {
1388
1401
  options.afterDirectorySync?.(directory);
1389
1402
  }
1390
1403
  await assertReviewUnchanged(review);
1391
- const retained = await loadReview(join(snapshotRoot, request.result.path));
1404
+ const retained = await loadJobReview(join(snapshotRoot, request.result.path), root.path);
1392
1405
  if (retained.sourceHash !== review.sourceHash || requestDigest(retained.reviewedSource) !== requestDigest(review.reviewedSource)) {
1393
- throw new JobError('JOB_SOURCE_UNRETAINABLE');
1406
+ throw new JobError('JOB_SOURCE_UNRETAINABLE',
1407
+ `snapshot reload sourceHash ${retained.sourceHash} requires live ${review.sourceHash}; ` +
1408
+ `reviewedSource digest ${requestDigest(retained.reviewedSource)} requires ${requestDigest(review.reviewedSource)} ` +
1409
+ `(handoff snapshot ${retained.handoff?.record.config.path ?? 'none'}, live ${review.handoff?.record.config.path ?? 'none'})`);
1394
1410
  }
1395
1411
  const originalIdentity = (file: { path: string; sha256: string } | null): JobFileIdentity | null => file && ({
1396
1412
  path: rootRelative(root.path, resolve(review.root, file.path)), sha256: file.sha256,
package/src/job-store.ts CHANGED
@@ -294,6 +294,19 @@ export class JobStore<Data> {
294
294
  }
295
295
  }
296
296
 
297
+ /** Observe committed writes to one job without decoding its document or crops. */
298
+ revision(jobId: string): number {
299
+ try {
300
+ const row = this.db.query<{ revision: number }, [string]>('SELECT revision FROM jobs WHERE job_id=?').get(jobId);
301
+ if (!row) throw new JobError('JOB_UNKNOWN');
302
+ if (!Number.isSafeInteger(row.revision) || row.revision < 0) throw new JobError('JOB_STORAGE_FAILED');
303
+ return row.revision;
304
+ } catch (error) {
305
+ if (error instanceof JobError) throw error;
306
+ throw new JobError('JOB_STORAGE_FAILED', 'Stored job state is invalid');
307
+ }
308
+ }
309
+
297
310
  get(jobId: string): StoredJob<Data> {
298
311
  try {
299
312
  const row = this.db.query<JobRow, [string]>(`SELECT jobs.*, job_closures.document AS closure
package/src/manifest.ts CHANGED
@@ -1,6 +1,7 @@
1
1
  import {readSceneInspection,scenePlateBytes,type SceneInspection} from './scene-inspection.ts';
2
2
  import {DIRECTION_MAX_BYTES, readDirectionInspection, type DirectionInspection} from './direction-inspection.ts';
3
3
  import {discoverTurnDials} from './turn-pad.ts';
4
+ import {fileURLToPath} from 'node:url';
4
5
  import { createHash } from 'node:crypto';
5
6
  import { toolVersions } from './versions.ts';
6
7
  import type { FeedbackCatalog } from './feedback-validation.ts';
@@ -37,6 +38,8 @@ export interface ReviewPackage { scene?:SceneInspection; direction?:DirectionIns
37
38
  viewOnly?: boolean;
38
39
  /** Logical working directory passed at load/open time for resolving an external producer (`options.cwd`). */
39
40
  cwd?: string;
41
+ /** Explicit producer lookup roots, retained for source revalidation. */
42
+ handoffStarts?: readonly string[];
40
43
  /** #329: the handoff's source painting, served at a fixed route by its pinned hash; absent when the handoff knows none. */
41
44
  sourcePainting?: SourcePainting }
42
45
  function fail(field: string, expected: string): never { throw new Error(`${field}: expected ${expected}`); }
@@ -100,7 +103,7 @@ export function parseManifest(input: unknown): ReviewManifest {
100
103
  return manifest;
101
104
  }
102
105
  /** `options.handoff` are the explicit `--config …` flags; they win over the manifest block and discovery. */
103
- export async function loadReview(input: string, options: { handoff?: HandoffFlags; cwd?: string } = {}): Promise<ReviewPackage> {
106
+ export async function loadReview(input: string, options: { handoff?: HandoffFlags; cwd?: string; handoffStarts?: readonly string[] } = {}): Promise<ReviewPackage> {
104
107
  const inputPath=await realpath(resolve(input));const directory=(await stat(inputPath)).isDirectory();
105
108
  if(directory){try{await stat(resolve(inputPath,'review.json'));return loadReview(resolve(inputPath,'review.json'),options);}catch(e){if((e as NodeJS.ErrnoException).code!=='ENOENT')throw e;}
106
109
  // #149: a rig-parts build root without a model of its own opens as its check package, exactly as opening check/ does.
@@ -132,7 +135,7 @@ export async function loadReview(input: string, options: { handoff?: HandoffFlag
132
135
  }
133
136
  const reportPath=files.has('report.json')?'report.json':authoringPath('report.json');let report:ReportSeeds|null=null;let modelMetadata:Record<string,unknown>|null=null;let directionInput:unknown;
134
137
  // The handoff files are hashed beside the package: their record joins the reviewed identity (and so the session file).
135
- const {handoff,reason:handoffReason}=await resolveHandoff(root,manifest.producer,options.handoff,{starts:[options.cwd??process.cwd()]});
138
+ const {handoff,reason:handoffReason}=await resolveHandoff(root,manifest.producer,options.handoff,{starts:options.handoffStarts??[options.cwd??process.cwd()]});
136
139
  // #329: the source painting the handoff knows is the first reference, outside the package's own files.
137
140
  const painting=sourcePainting(manifest,handoff,directory);
138
141
  let scene:SceneInspection|undefined;
@@ -165,7 +168,7 @@ export async function loadReview(input: string, options: { handoff?: HandoffFlag
165
168
  const reviewedSource:ReviewedSource={packageRevision:manifest.revision,...await toolVersions(),rig:rigPath?{path:rigPath,sha256:fileHashes.get(rigPath)!}:null,motion:motionPath?{path:motionPath,sha256:fileHashes.get(motionPath)!}:null,...(handoff?{handoff:handoff.record}:{})};
166
169
  const direction=manifest.direction?readDirectionInspection(directionInput,{path:manifest.direction,sha256:fileHashes.get(manifest.direction)!},reviewedSource.rig):undefined;
167
170
  const feedbackCatalog:FeedbackCatalog={rig:manifest.id,bones:modelNames(modelMetadata,'bones'),slots:modelNames(modelMetadata,'slots'),animations:modelAnimations(modelMetadata),clock:report?.clock??null,clockAnimation:report?.animation??null,...(discoverTurnDials(modelMetadata).length?{turnDials:discoverTurnDials(modelMetadata)}:{})};
168
- return {...(scene?{scene}:{}),...(direction?{direction}:{}),...(manifest.sets?{setsHash:fileHashes.get(manifest.sets)!}:{}),referenceHashes:Object.fromEntries(manifest.references.map(r=>[r.id,r.id===painting?.id?painting.sha256:fileHashes.get(r.path)!])),root,manifestPath,manifest,sourceHash:hash.digest('hex'),reviewedSource,files,report,feedbackCatalog,handoff,handoffReason,...(handoff?.flags?{handoffInputs:handoff.flags}:{}),...(buildRoot?{buildRoot}:{}),...(painting?{sourcePainting:painting}:{}),...(options.cwd?{cwd:options.cwd}:{})};
171
+ return {...(scene?{scene}:{}),...(direction?{direction}:{}),...(manifest.sets?{setsHash:fileHashes.get(manifest.sets)!}:{}),referenceHashes:Object.fromEntries(manifest.references.map(r=>[r.id,r.id===painting?.id?painting.sha256:fileHashes.get(r.path)!])),root,manifestPath,manifest,sourceHash:hash.digest('hex'),reviewedSource,files,report,feedbackCatalog,handoff,handoffReason,...(handoff?.flags?{handoffInputs:handoff.flags}:{}),...(buildRoot?{buildRoot}:{}),...(painting?{sourcePainting:painting}:{}),...(options.cwd?{cwd:options.cwd}:{}),...(options.handoffStarts?{handoffStarts:options.handoffStarts}:{})};
169
172
  }
170
173
 
171
174
  /** #329: the reference id and served path of the handoff's source painting; the path is a name, never a package file. */
@@ -186,6 +189,11 @@ function sourcePainting(manifest:ReviewManifest,handoff:Handoff|null,folder:bool
186
189
  if(folder)manifest.checkpoints.unshift({id:reference.id,title:'Inspect '+reference.label,reference:reference.id,workspace:'motion'});
187
190
  return {id:reference.id,path:record.path,sha256:record.sha256};
188
191
  }
192
+ /** Job lookup is fixed to its designation and this Review install, never the operator's shell. */
193
+ export function loadJobReview(input: string, root: string): Promise<ReviewPackage> {
194
+ return loadReview(input, {cwd: root, handoffStarts: [root, fileURLToPath(new URL('..', import.meta.url))]});
195
+ }
196
+
189
197
  /**
190
198
  * #149: the `check/` package of a rig-parts build root ({@link isBuildRoot}), when the folder has neither of the two
191
199
  * adapter model paths itself (a folder that does keeps opening as before). Fixed names, no search.
@@ -1,5 +1,6 @@
1
1
  import {createHmac, randomUUID} from 'node:crypto';
2
2
  import {lstat, mkdir, rename, unlink, writeFile} from 'node:fs/promises';
3
+ import type {Stats} from 'node:fs';
3
4
  import {isAbsolute, join} from 'node:path';
4
5
  import {appRoot} from './build.ts';
5
6
  import {readOpenStatus, running, smallJson} from './open.ts';
@@ -10,12 +11,15 @@ import {WORKSPACE_BODY_LIMIT, WORKSPACE_SCHEMA, WORKSPACE_TARGETS_SCHEMA, WORKSP
10
11
 
11
12
  export function workspaceError(code: string): Error {return new Error(code);}
12
13
 
13
- export async function assertPrivate(path: string, directory: boolean) {
14
- const info = await lstat(path);
14
+ function assertPrivateInfo(info: Stats, directory: boolean) {
15
15
  if (!(directory ? info.isDirectory() : info.isFile()) || (info.mode & 0o077) !== 0 ||
16
16
  typeof process.getuid === 'function' && info.uid !== process.getuid() || !directory && info.nlink !== 1) throw workspaceError('WORKSPACE_STATE_INVALID');
17
17
  }
18
18
 
19
+ export async function assertPrivate(path: string, directory: boolean) {
20
+ assertPrivateInfo(await lstat(path), directory);
21
+ }
22
+
19
23
  export async function workspaceDirectory(stateDir: string) {
20
24
  const directory = join(canonicalStatePath(stateDir), 'owner-workspace');
21
25
  await mkdir(directory, {recursive: true, mode: 0o700});
@@ -24,7 +28,12 @@ export async function workspaceDirectory(stateDir: string) {
24
28
  }
25
29
 
26
30
  export async function readPrivate(path: string): Promise<unknown | null> {
27
- try {await assertPrivate(path, false); return await smallJson(path);}
31
+ try {
32
+ const info = await lstat(path);
33
+ // lstat can finish with nlink=0 during unlink. Establish that the path still
34
+ // opens before validating that snapshot; a vanished path remains ENOENT.
35
+ return await smallJson(path, () => assertPrivateInfo(info, false));
36
+ }
28
37
  catch (error) {if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null; throw workspaceError('WORKSPACE_STATE_INVALID');}
29
38
  }
30
39
 
package/src/open.ts CHANGED
@@ -73,7 +73,8 @@ export function openKey(p:OpenPackage,fingerprint:string):string {return digest(
73
73
  /** Handoff URL: the managed front's `/instances/<key>/` path (or the worker's own origin when direct). The
74
74
  * capability rides in the fragment, which browsers never send to a server; the page stores and strips it. */
75
75
  export function openUrl(record:Pick<RecordFile,'origin'|'key'|'contentHash'|'capability'>,front?:string):string {const url=new URL(front?`${front}/instances/${record.key}/`:record.origin);url.searchParams.set('input',record.contentHash);url.searchParams.set('handoff',record.key);url.hash='cap='+record.capability;return url.href;}
76
- export async function smallJson(file:string):Promise<unknown>{const handle=await openFile(file,constants.O_RDONLY|constants.O_NOFOLLOW|constants.O_NONBLOCK);try{const before=await handle.stat();if(!before.isFile()||before.size>65536)throw new Error('open state: bounded regular file required');const buffer=Buffer.alloc(before.size+1);let size=0;while(size<buffer.length){const next=await handle.read(buffer,size,buffer.length-size,size);if(!next.bytesRead)break;size+=next.bytesRead;}const after=await handle.stat();if(size!==before.size||before.size!==after.size||before.mtimeMs!==after.mtimeMs)throw new Error('open state: changed while reading');return JSON.parse(buffer.subarray(0,size).toString('utf8'));}finally{await handle.close();}}
76
+ /** Optional caller validation runs after open, before any content read, inside the close guard. */
77
+ export async function smallJson(file:string,validate?:()=>void):Promise<unknown>{const handle=await openFile(file,constants.O_RDONLY|constants.O_NOFOLLOW|constants.O_NONBLOCK);try{validate?.();const before=await handle.stat();if(!before.isFile()||before.size>65536)throw new Error('open state: bounded regular file required');const buffer=Buffer.alloc(before.size+1);let size=0;while(size<buffer.length){const next=await handle.read(buffer,size,buffer.length-size,size);if(!next.bytesRead)break;size+=next.bytesRead;}const after=await handle.stat();if(size!==before.size||before.size!==after.size||before.mtimeMs!==after.mtimeMs)throw new Error('open state: changed while reading');return JSON.parse(buffer.subarray(0,size).toString('utf8'));}finally{await handle.close();}}
77
78
  function recordValue(value:unknown,key:string):RecordFile|null {if(!value||typeof value!=='object')return null;const v=value as Partial<RecordFile>;return v.schema==='rig-review-open-instance/1'&&v.key===key&&/^[a-f0-9]{64}$/.test(v.contentHash??'')&&/^[a-f0-9]{64}$/.test(v.fingerprint??'')&&typeof v.nonce==='string'&&/^[a-f0-9-]{36}$/.test(v.nonce)&&typeof v.origin==='string'&&/^http:\/\/127\.0\.0\.1:[1-9]\d{0,4}$/.test(v.origin)&&Number(v.origin.slice(v.origin.lastIndexOf(':')+1))<=65535&&Number.isSafeInteger(v.pid)&&v.pid!>0&&(v.mode==='single'||v.mode==='compare')&&capabilityPattern.test(v.capability??'')?v as RecordFile:null;}
78
79
  export async function readRecord(file:string,key:string):Promise<RecordFile|null>{try{return recordValue(await smallJson(file),key);}catch(e){if(['ENOENT','ELOOP'].includes((e as NodeJS.ErrnoException).code??'')||e instanceof SyntaxError)return null;throw e;}}
79
80
  /** Hard byte ceiling and body deadline, including stalled or chunked responses. */
package/src/parts-view.ts CHANGED
@@ -1130,10 +1130,9 @@ export async function partsDifference(pkg: PartsViewPackage, index: number, thre
1130
1130
  }
1131
1131
  const decode = async (path: string) => {
1132
1132
  const bytes = await readFile(path);
1133
- if (bytes[24] !== 8 || bytes[25] !== 6) {
1134
- refuse('PARTS_DIFFERENCE_PNG', 'exact RGBA8 operands required');
1135
- }
1136
- return PNG.sync.read(bytes);
1133
+ // pngjs normalizes valid PNG colour types and bit depths from the bound bytes.
1134
+ try { return PNG.sync.read(bytes); }
1135
+ catch { return refuse('PARTS_DIFFERENCE_PNG', 'decodable PNG operands required'); }
1137
1136
  };
1138
1137
  const painting = await decode(pkg.paintingInRig!.abs);
1139
1138
  const part = await decode(pkg.imagePaths[index]!);
package/src/reference.ts CHANGED
@@ -28,8 +28,8 @@ export async function hashLocalVideo(input:string):Promise<{path:string;name:str
28
28
  const after=await stat(path);if(await realpath(input)!==path||before.dev!==after.dev||before.ino!==after.ino||before.size!==after.size||before.mtimeMs!==after.mtimeMs||before.ctimeMs!==after.ctimeMs)throw new Error('Reference inputs changed while hashing');
29
29
  return {path,name:basename(path),sha256:hash.digest('hex')};
30
30
  }
31
- export async function loadReferencedReview(input:string,reference?:string,handoff?:HandoffFlags,cwd?:string):Promise<ReviewPackage>{
32
- const base=await loadReview(input,{handoff,...(cwd?{cwd}:{})});if(reference===undefined)return base;
31
+ export async function loadReferencedReview(input:string,reference?:string,handoff?:HandoffFlags,cwd?:string,handoffStarts?:readonly string[]):Promise<ReviewPackage>{
32
+ const base=await loadReview(input,{handoff,...(cwd?{cwd}:{}),...(handoffStarts?{handoffStarts}:{})});if(reference===undefined)return base;
33
33
  const video=await hashLocalVideo(reference),id='open-reference-'+video.sha256;
34
34
  if(base.manifest.references.some(r=>r.id===id))throw new Error('reference: selected reference id collides with package reference');
35
35
  const binding:ReferenceBinding={packageSourceHash:base.sourceHash,reference:{id,name:video.name,sha256:video.sha256}};
@@ -39,7 +39,7 @@ export async function loadReferencedReview(input:string,reference?:string,handof
39
39
  export async function assertReviewUnchanged(p:ReviewPackage):Promise<void>{
40
40
  const assertCurrent=(p as BoundPackage)[sourceAssertion];
41
41
  if(assertCurrent)return assertCurrent();
42
- try{const current=await loadReferencedReview(p.manifestPath,selectedReference(p)?.path,p.handoffInputs,p.cwd);if(current.sourceHash!==p.sourceHash||!isDeepStrictEqual(current.reviewedSource,p.reviewedSource)||!isDeepStrictEqual(referenceBinding(current),referenceBinding(p)))throw new Error('source binding differs');}
42
+ try{const current=await loadReferencedReview(p.manifestPath,selectedReference(p)?.path,p.handoffInputs,p.cwd,p.handoffStarts);if(current.sourceHash!==p.sourceHash||!isDeepStrictEqual(current.reviewedSource,p.reviewedSource)||!isDeepStrictEqual(referenceBinding(current),referenceBinding(p)))throw new Error('source binding differs');}
43
43
  catch{throw new Error('Package inputs changed or are unavailable. Restart review to bind feedback to current inputs.');}
44
44
  }
45
45
  export async function safeSelectedReference(p:ReviewPackage):Promise<string>{
package/web/catalog-en.ts CHANGED
@@ -164,6 +164,8 @@ export const enCatalog: Readonly<Record<string, string>> = {
164
164
  "interview.delegate": "Delegate",
165
165
  "interview.open": "Open interview",
166
166
  "interview.close": "Close interview",
167
+ "interview.noteLabel": "Your note (optional)",
168
+ "interview.notePlaceholder": "Anything the choices don't cover",
167
169
  "PARTS_DIFFERENCE_PROVENANCE: declared path, lowercase SHA-256 and lanczos3-rgb-opaque required": "PARTS_DIFFERENCE_PROVENANCE: declared path, lowercase SHA-256 and lanczos3-rgb-opaque required",
168
170
  "PARTS_DIFFERENCE_PATH: literal portable inside-package path required": "PARTS_DIFFERENCE_PATH: literal portable inside-package path required",
169
171
  "PARTS_DIFFERENCE_PATH: declared painting must be readable inside the package": "PARTS_DIFFERENCE_PATH: declared painting must be readable inside the package",
@@ -175,6 +177,9 @@ export const enCatalog: Readonly<Record<string, string>> = {
175
177
  "PARTS_DIFFERENCE_UNAVAILABLE: declared painting_in_rig required; legacy records remain readable": "PARTS_DIFFERENCE_UNAVAILABLE: declared painting_in_rig required; legacy records remain readable",
176
178
  "PARTS_DIFFERENCE_UNAVAILABLE: known original part required": "PARTS_DIFFERENCE_UNAVAILABLE: known original part required",
177
179
  "PARTS_DIFFERENCE_PNG: exact RGBA8 operands required": "PARTS_DIFFERENCE_PNG: exact RGBA8 operands required",
180
+ "PARTS_DIFFERENCE_PNG: decodable PNG operands required": "PARTS_DIFFERENCE_PNG: decodable PNG operands required",
181
+ "PARTS_DIFFERENCE_PNG": "PARTS_DIFFERENCE_PNG",
182
+ "PARTS_DIFFERENCE_UNAVAILABLE": "PARTS_DIFFERENCE_UNAVAILABLE",
178
183
  "PARTS_DIFFERENCE_ALIGNMENT: integer native placement and exact PNG dimensions required": "PARTS_DIFFERENCE_ALIGNMENT: integer native placement and exact PNG dimensions required",
179
184
  "PARTS_DIFFERENCE_ALIGNMENT: nontransparent part pixel lies outside declared rig grid": "PARTS_DIFFERENCE_ALIGNMENT: nontransparent part pixel lies outside declared rig grid",
180
185
  "PARTS_COMPARISON_INVALID: part/overlay with opacity 0..1, or difference with integer threshold 0..255 required": "PARTS_COMPARISON_INVALID: part/overlay with opacity 0..1, or difference with integer threshold 0..255 required",
@@ -3524,7 +3529,7 @@ export const enCatalog: Readonly<Record<string, string>> = {
3524
3529
  "JOB_PUBLICATION_UNKNOWN": "JOB_PUBLICATION_UNKNOWN",
3525
3530
  "JOB_SNAPSHOT_RECLAIMED": "JOB_SNAPSHOT_RECLAIMED",
3526
3531
  "JOB_RECORD_INCOMPLETE": "JOB_RECORD_INCOMPLETE",
3527
- "JOB_RECORD_MOVED": "JOB_RECORD_MOVED",
3532
+ "JOB_RECORD_MOVED": "This review has been updated since you opened this page. Reload the page, or wait for the operator to reopen the review.",
3528
3533
  "JOB_REQUEST_INVALID": "JOB_REQUEST_INVALID",
3529
3534
  "JOB_API_SCHEMA_MISMATCH": "JOB_API_SCHEMA_MISMATCH",
3530
3535
  "JOB_STORED_SCHEMA_MISMATCH": "JOB_STORED_SCHEMA_MISMATCH",