@rig-c/review 3.7.0 → 4.0.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/README.md +1 -1
- package/docs/DESIGN.md +145 -74
- package/docs/PANELS.md +20 -12
- package/docs/PARTS_VIEW.md +133 -76
- package/docs/REVIEW_PACKAGE.md +445 -99
- package/docs/STABILITY.md +132 -198
- package/docs/WORKFLOWS.md +41 -120
- package/package.json +4 -3
- package/skills/rig-review/SKILL.md +41 -27
- package/src/build.ts +10 -2
- package/src/cli.ts +17 -16
- package/src/comment-crops.ts +6 -1
- package/src/compare-html.ts +22 -24
- package/src/compare-server.ts +1 -1
- package/src/compare-session.ts +41 -3
- package/src/correction-handoff.ts +27 -4
- package/src/create-pin-gate.ts +3 -0
- package/src/direction-inspection.ts +6 -2
- package/src/feedback-export.ts +68 -1
- package/src/front.ts +5 -200
- package/src/handoff.ts +1 -1
- package/src/interview-routes.ts +1 -1
- package/src/interview-scene.ts +3 -3
- package/src/job-act.ts +77 -73
- package/src/job-api.ts +326 -13
- package/src/job-checkpoint-evidence.ts +113 -0
- package/src/job-cli.ts +27 -14
- package/src/job-contract.ts +284 -62
- package/src/job-front.ts +157 -58
- package/src/job-host.ts +23 -4
- package/src/job-session.ts +109 -24
- package/src/job-source.ts +209 -57
- package/src/job-store.ts +80 -6
- package/src/job-worker.ts +1 -47
- package/src/joined-project.ts +61 -4
- package/src/manifest.ts +32 -4
- package/src/open-workspace.ts +12 -12
- package/src/open.ts +19 -12
- package/src/parts-comment-crops.ts +126 -31
- package/src/parts-comment.ts +351 -28
- package/src/parts-server.ts +19 -7
- package/src/parts-view.ts +588 -109
- package/src/scene-inspection.ts +50 -0
- package/src/server.ts +31 -22
- package/src/session.ts +58 -0
- package/src/stage-comment.ts +48 -1
- package/src/stage-parts.ts +23 -11
- package/web/animation-inspection.ts +1 -1
- package/web/bones-panel.ts +1 -3
- package/web/catalog-en.ts +175 -39
- package/web/catalog-ko.ts +175 -39
- package/web/cloth-panel.ts +1 -2
- package/web/compare.css +3 -13
- package/web/compare.html +3 -3
- package/web/compare.ts +69 -64
- package/web/cuts-panel.ts +1 -3
- package/web/density-strip-panel.ts +1 -2
- package/web/direction-panel.ts +22 -6
- package/web/i18n.ts +13 -1
- package/web/idle-panel.ts +1 -2
- package/web/index.html +1 -5
- package/web/inspection-persistence.ts +2 -1
- package/web/inspector-blocks.ts +149 -40
- package/web/instance-access.ts +24 -5
- package/web/interview-panel.ts +224 -175
- package/web/job-rig-capture.ts +164 -21
- package/web/job-rig-screen.ts +337 -0
- package/web/job-session.ts +611 -1437
- package/web/main.ts +614 -151
- package/web/mesh-panel.ts +1 -2
- package/web/owner-workspace.ts +88 -109
- package/web/part-selection.ts +47 -6
- package/web/part-thumbnails.ts +20 -6
- package/web/parts-render.ts +26 -19
- package/web/parts-viewport-provider.ts +181 -7
- package/web/physics-panel.ts +1 -2
- package/web/readings-panel.ts +1 -2
- package/web/requirements-panel.ts +1 -3
- package/web/retained-frame-stage.ts +105 -0
- package/web/retarget-panel.ts +2 -3
- package/web/rig-fields-panel.ts +1 -2
- package/web/rig-host.ts +64 -0
- package/web/rig-viewport-provider.ts +65 -16
- package/web/scene-plates.ts +57 -4
- package/web/stage-comments.ts +103 -46
- package/web/styles.css +117 -63
- package/web/view-controls.ts +201 -12
- package/web/viewport-capture.ts +12 -2
- package/web/viewport-controller.ts +107 -27
- package/web/viewport-pair.ts +2 -1
- package/web/workspace-preferences.ts +5 -4
- package/web/workspace-ui.ts +151 -19
- package/src/front-worker.ts +0 -2
- package/src/interview-server.ts +0 -54
- package/src/job-hub.ts +0 -304
- package/src/job-image-set.ts +0 -50
- package/web/interview.css +0 -28
- package/web/interview.html +0 -17
- package/web/interview.ts +0 -40
- package/web/job-hub.css +0 -14
- package/web/job-hub.html +0 -5
- package/web/job-hub.ts +0 -179
- package/web/owner-workspace.css +0 -14
- package/web/owner-workspace.html +0 -5
- package/web/parts-flags.ts +0 -48
- package/web/parts.css +0 -104
- package/web/parts.html +0 -49
- package/web/parts.ts +0 -604
- package/web/stage-nav.ts +0 -136
package/src/job-source.ts
CHANGED
|
@@ -1,15 +1,17 @@
|
|
|
1
|
+
import {resolvePartsPaintingInRig} from './parts-view.ts';
|
|
2
|
+
import {checkpointEvidenceFields, checkpointEvidenceMetadata} from './job-checkpoint-evidence.ts';
|
|
1
3
|
import { randomUUID } from 'node:crypto';
|
|
2
4
|
import { type Dirent, lstatSync, readdirSync, realpathSync, type Stats } from 'node:fs';
|
|
3
5
|
import { mkdir, open, rm, writeFile } from 'node:fs/promises';
|
|
4
6
|
import { dirname, isAbsolute, join, posix, relative, resolve, sep } from 'node:path';
|
|
5
7
|
import { PNG } from 'pngjs';
|
|
6
8
|
import {
|
|
7
|
-
JOB_API_V3_SCHEMA,
|
|
9
|
+
JOB_API_V3_SCHEMA, JOB_PLAN_TEXT_FIELDS, JOB_PLAN_TEXT_SCHEMA,
|
|
8
10
|
JOB_PARTS_ENUMERATOR_RANGE,
|
|
9
11
|
} from './job-contract.ts';
|
|
10
12
|
import type {
|
|
11
|
-
|
|
12
|
-
JobSelector, JobSourceBinding, JobSubject,
|
|
13
|
+
JobCheckpointEvidence, JobFileIdentity, JobInterviewDiagnostics, JobInterviewRecord, JobModelSourceBinding, JobPartsEnumerator, JobPartsFileReference, JobPartsIdentity, JobPlanIdentity, JobPublishRequest,
|
|
14
|
+
JobSelector, JobSourceBinding, JobSubject, JobPlanTextProjection, JobPlanTextStep,
|
|
13
15
|
OptionContext, OptionSource, PackageResultV3, PlanContext, PlanSource, ProjectRecord, PublishRequestV3,
|
|
14
16
|
RecordFreeze, RecordOptionResult, RecordPlanResult, RecordPublicationReader, RecordPublishedContext,
|
|
15
17
|
RecordReaderInput, RecordResult, RecordSource, RecordSubject,
|
|
@@ -41,7 +43,6 @@ import {
|
|
|
41
43
|
validateRecordAskSubject,
|
|
42
44
|
} from './job-api.ts';
|
|
43
45
|
import { JobError, type JobSnapshotOwner } from './job-store.ts';
|
|
44
|
-
import { prepareJobImageSet } from './job-image-set.ts';
|
|
45
46
|
|
|
46
47
|
export interface JobRootIdentity {
|
|
47
48
|
readonly path: string;
|
|
@@ -55,7 +56,7 @@ export interface JobRootIdentity {
|
|
|
55
56
|
* referenced-image enumeration belongs to the public Parts #1163 surface.
|
|
56
57
|
*/
|
|
57
58
|
export interface JobPublishedContext {
|
|
58
|
-
readonly
|
|
59
|
+
readonly checkpointEvidence?: readonly JobCheckpointEvidence[];
|
|
59
60
|
readonly selector: JobSelector | null;
|
|
60
61
|
readonly plan: JobPlanIdentity | null;
|
|
61
62
|
readonly parts: JobPartsIdentity | null;
|
|
@@ -71,6 +72,8 @@ export type JobPublicationReader = (input: {
|
|
|
71
72
|
}) => Promise<JobPublishedContext>;
|
|
72
73
|
|
|
73
74
|
export interface JobRetainedSource {
|
|
75
|
+
/** Private base preimage for evidence-aware durable validation, absent historically. */
|
|
76
|
+
readonly checkpointEvidencePackageHash?: string;
|
|
74
77
|
readonly root: JobRootIdentity;
|
|
75
78
|
readonly record: JobFileIdentity | null;
|
|
76
79
|
readonly seals: readonly JobFileIdentity[];
|
|
@@ -230,30 +233,63 @@ function referenceRow(raw: unknown, row: number, hashed: boolean): JobPartsFileR
|
|
|
230
233
|
return {path, role, ...(hashed ? {sha256: item.sha256 as string} : {})};
|
|
231
234
|
}
|
|
232
235
|
|
|
236
|
+
/** Reuse the official-reference PNG admission and decoded-size bound for generic sidecar operands. */
|
|
237
|
+
function assertPartsReferencePng(data: Buffer, detail: string): void {
|
|
238
|
+
if (data.length < 33 || !data.subarray(0, 8).equals(Buffer.from('89504e470d0a1a0a', 'hex')) ||
|
|
239
|
+
data.readUInt32BE(8) !== 13 || data.toString('ascii', 12, 16) !== 'IHDR') {
|
|
240
|
+
throw new JobError('JOB_SOURCE_MISMATCH', `PARTS_REFERENCE_PNG_INVALID ${detail}`);
|
|
241
|
+
}
|
|
242
|
+
const width = data.readUInt32BE(16), height = data.readUInt32BE(20);
|
|
243
|
+
if (!width || !height) throw new JobError('JOB_SOURCE_MISMATCH', `PARTS_REFERENCE_PNG_INVALID ${detail}`);
|
|
244
|
+
if (width > Math.floor(maxFileBytes / 4 / height)) {
|
|
245
|
+
throw new JobError('JOB_SOURCE_UNRETAINABLE', `PARTS_REFERENCE_LIMIT ${detail}`);
|
|
246
|
+
}
|
|
247
|
+
try { PNG.sync.read(data); }
|
|
248
|
+
catch { throw new JobError('JOB_SOURCE_MISMATCH', `PARTS_REFERENCE_PNG_INVALID ${detail}`); }
|
|
249
|
+
}
|
|
250
|
+
|
|
251
|
+
function partsIdentityHeader(value: unknown): {raw: Record<string, unknown>; version: string} {
|
|
252
|
+
const raw = jobObject(value, ['enumeratorVersion', 'manifest', 'images']);
|
|
253
|
+
return {raw, version: jobPartsEnumeratorVersion(raw.enumeratorVersion)};
|
|
254
|
+
}
|
|
255
|
+
|
|
256
|
+
function partsManifest(value: unknown): JobFileIdentity {
|
|
257
|
+
try {
|
|
258
|
+
const raw = jobObject(value, ['path', 'sha256']);
|
|
259
|
+
const path = jobPath(raw.path);
|
|
260
|
+
if (posix.basename(path) !== 'parts.json') throw new Error('Manifest directory API');
|
|
261
|
+
return {path, sha256: jobSha(raw.sha256)};
|
|
262
|
+
} catch { throw new JobError('JOB_SOURCE_UNRETAINABLE', 'PARTS_REFERENCE_PATH_REFUSED manifest'); }
|
|
263
|
+
}
|
|
264
|
+
|
|
265
|
+
function partsReferenceList(value: unknown): unknown[] {
|
|
266
|
+
if (!Array.isArray(value) || value.length > maxSourceFiles) throw new JobError('JOB_SOURCE_UNRETAINABLE', 'PARTS_REFERENCE_LIMIT');
|
|
267
|
+
return value;
|
|
268
|
+
}
|
|
269
|
+
|
|
270
|
+
/** Pure declared identity decoder; official enumeration and native bytes remain preparation checks. */
|
|
271
|
+
export function parseJobPartsIdentity(value: unknown): JobPartsIdentity {
|
|
272
|
+
const {raw, version} = partsIdentityHeader(value);
|
|
273
|
+
const manifest = partsManifest(raw.manifest);
|
|
274
|
+
const images = partsReferenceList(raw.images).map((row, index) => referenceRow(row, index, true));
|
|
275
|
+
return {enumeratorVersion: version, manifest, images: images as JobPartsIdentity['images']};
|
|
276
|
+
}
|
|
277
|
+
|
|
233
278
|
/** Membership, order and duplicate semantics belong solely to the trusted public
|
|
234
279
|
* enumerator. Review compares its exact array and validates byte boundaries.
|
|
235
280
|
*/
|
|
236
281
|
async function prepareParts(root: string, snapshotRoot: string, claimed: JobPartsIdentity | null,
|
|
237
|
-
enumerator?: JobPartsEnumerator): Promise<{identity: JobPartsIdentity | null; bytes: Map<string, Buffer>}> {
|
|
282
|
+
declared: readonly JobFileIdentity[], enumerator?: JobPartsEnumerator): Promise<{identity: JobPartsIdentity | null; bytes: Map<string, Buffer>}> {
|
|
238
283
|
const bytes = new Map<string, Buffer>();
|
|
239
284
|
if (claimed === null) return {identity: null, bytes};
|
|
240
285
|
if (!enumerator) throw new JobError('JOB_SOURCE_UNRETAINABLE', 'PARTS_ENUMERATOR_UNAVAILABLE');
|
|
241
|
-
|
|
242
|
-
const version = jobPartsEnumeratorVersion(claimed.enumeratorVersion);
|
|
286
|
+
const {version} = partsIdentityHeader(claimed);
|
|
243
287
|
if (version !== jobPartsEnumeratorVersion(enumerator.version)) {
|
|
244
288
|
throw new JobError('JOB_SOURCE_UNRETAINABLE',
|
|
245
289
|
`PARTS_ENUMERATOR_VERSION_MISMATCH range="${JOB_PARTS_ENUMERATOR_RANGE}" received="${version}" installed="${enumerator.version}"`);
|
|
246
290
|
}
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
jobObject(claimed.manifest, ['path', 'sha256']);
|
|
250
|
-
manifestPath = jobPath(claimed.manifest.path);
|
|
251
|
-
if (posix.basename(manifestPath) !== 'parts.json') throw new Error('Manifest directory API');
|
|
252
|
-
jobSha(claimed.manifest.sha256);
|
|
253
|
-
} catch { throw new JobError('JOB_SOURCE_UNRETAINABLE', 'PARTS_REFERENCE_PATH_REFUSED manifest'); }
|
|
254
|
-
if (!Array.isArray(claimed.images) || claimed.images.length > maxSourceFiles) {
|
|
255
|
-
throw new JobError('JOB_SOURCE_UNRETAINABLE', 'PARTS_REFERENCE_LIMIT');
|
|
256
|
-
}
|
|
291
|
+
const {path: manifestPath} = partsManifest(claimed.manifest);
|
|
292
|
+
const claimedImages = partsReferenceList(claimed.images);
|
|
257
293
|
let manifestBytes: Buffer;
|
|
258
294
|
try { manifestBytes = sourceBytes(root, manifestPath); }
|
|
259
295
|
catch (error) {
|
|
@@ -278,11 +314,8 @@ async function prepareParts(root: string, snapshotRoot: string, claimed: JobPart
|
|
|
278
314
|
throw new JobError('JOB_SOURCE_MISMATCH', 'PARTS_ENUMERATION_REFUSED' + rule);
|
|
279
315
|
}
|
|
280
316
|
} finally { await rm(enumerationRoot, {recursive: true, force: true}); }
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
}
|
|
284
|
-
const official = references.map((raw, row) => referenceRow(raw, row, false));
|
|
285
|
-
const supplied = claimed.images.map((raw, row) => referenceRow(raw, row, true));
|
|
317
|
+
const official = partsReferenceList(references).map((raw, row) => referenceRow(raw, row, false));
|
|
318
|
+
const supplied = claimedImages.map((raw, row) => referenceRow(raw, row, true));
|
|
286
319
|
const difference = official.findIndex((row, i) => row.path !== supplied[i]?.path || row.role !== supplied[i]?.role);
|
|
287
320
|
if (difference !== -1 || official.length !== supplied.length) {
|
|
288
321
|
throw new JobError('JOB_SOURCE_MISMATCH',
|
|
@@ -315,17 +348,7 @@ async function prepareParts(root: string, snapshotRoot: string, claimed: JobPart
|
|
|
315
348
|
}
|
|
316
349
|
}
|
|
317
350
|
if (!decoded.has(path)) {
|
|
318
|
-
|
|
319
|
-
data.readUInt32BE(8) !== 13 || data.toString('ascii', 12, 16) !== 'IHDR') {
|
|
320
|
-
throw new JobError('JOB_SOURCE_MISMATCH', `PARTS_REFERENCE_PNG_INVALID ${detail}`);
|
|
321
|
-
}
|
|
322
|
-
const width = data.readUInt32BE(16), height = data.readUInt32BE(20);
|
|
323
|
-
if (!width || !height) throw new JobError('JOB_SOURCE_MISMATCH', `PARTS_REFERENCE_PNG_INVALID ${detail}`);
|
|
324
|
-
if (width > Math.floor(maxFileBytes / 4 / height)) {
|
|
325
|
-
throw new JobError('JOB_SOURCE_UNRETAINABLE', `PARTS_REFERENCE_LIMIT ${detail}`);
|
|
326
|
-
}
|
|
327
|
-
try { PNG.sync.read(data); }
|
|
328
|
-
catch { throw new JobError('JOB_SOURCE_MISMATCH', `PARTS_REFERENCE_PNG_INVALID ${detail}`); }
|
|
351
|
+
assertPartsReferencePng(data, detail);
|
|
329
352
|
bytes.set(path, data);
|
|
330
353
|
decoded.add(path);
|
|
331
354
|
}
|
|
@@ -335,6 +358,29 @@ async function prepareParts(root: string, snapshotRoot: string, claimed: JobPart
|
|
|
335
358
|
}
|
|
336
359
|
images.push({path: reference.path, role: reference.role, sha256});
|
|
337
360
|
}
|
|
361
|
+
// Inline declarations retain their historical admission behavior; fallback is never a rescue.
|
|
362
|
+
if (!Object.hasOwn(JSON.parse(manifestBytes.toString('utf8')), 'painting_in_rig')) {
|
|
363
|
+
try {
|
|
364
|
+
const resolved = await resolvePartsPaintingInRig(dirname(join(root, manifestPath)), manifestBytes,
|
|
365
|
+
async (absolute, kind) => {
|
|
366
|
+
const data = sourceBytes(root, rootRelative(root, absolute));
|
|
367
|
+
if (kind === 'painting') assertPartsReferencePng(data, 'painting_in_rig');
|
|
368
|
+
return data;
|
|
369
|
+
});
|
|
370
|
+
if (resolved.sidecar) for (const file of resolved.files) {
|
|
371
|
+
const path = rootRelative(root, file.declaredPath ?? file.abs);
|
|
372
|
+
if (!declared.some(row => row.path === path && row.sha256 === file.sha256)) {
|
|
373
|
+
throw new JobError('JOB_SOURCE_MISMATCH', 'PARTS_DIFFERENCE_PROVENANCE: sidecar and painting require generic file identities');
|
|
374
|
+
}
|
|
375
|
+
const data = sourceBytes(root, path);
|
|
376
|
+
if (jobHash(data) !== file.sha256) throw new JobError('JOB_SOURCE_MISMATCH');
|
|
377
|
+
bytes.set(path, data);
|
|
378
|
+
}
|
|
379
|
+
} catch (error) {
|
|
380
|
+
if (error instanceof JobError) throw error;
|
|
381
|
+
throw new JobError('JOB_SOURCE_MISMATCH', error instanceof Error ? error.message : 'PARTS_DIFFERENCE_PROVENANCE');
|
|
382
|
+
}
|
|
383
|
+
}
|
|
338
384
|
return {identity: {enumeratorVersion: version, manifest: {path: manifestPath, sha256: jobHash(manifestBytes)}, images}, bytes};
|
|
339
385
|
}
|
|
340
386
|
|
|
@@ -651,7 +697,7 @@ async function readRecordPublishedPhase(
|
|
|
651
697
|
return parseRecordPublishedContext(raw, input.result, input.record);
|
|
652
698
|
}
|
|
653
699
|
|
|
654
|
-
function readProjectRecordBytes(root: string, record: ProjectRecord): {
|
|
700
|
+
function readProjectRecordBytes(root: string, record: ProjectRecord, allowLegacySchema = false): {
|
|
655
701
|
readonly bytes: Buffer;
|
|
656
702
|
readonly project: Record<string, unknown>;
|
|
657
703
|
} {
|
|
@@ -659,15 +705,15 @@ function readProjectRecordBytes(root: string, record: ProjectRecord): {
|
|
|
659
705
|
try {
|
|
660
706
|
stat = lstatSync(join(root, record.path));
|
|
661
707
|
} catch {
|
|
662
|
-
throw new JobError('JOB_RECORD_MOVED');
|
|
708
|
+
throw new JobError(allowLegacySchema ? 'JOB_SOURCE_UNRETAINABLE' : 'JOB_RECORD_MOVED');
|
|
663
709
|
}
|
|
664
|
-
if (!stat.isFile()) throw new JobError('JOB_RECORD_MOVED');
|
|
710
|
+
if (!stat.isFile()) throw new JobError(allowLegacySchema ? 'JOB_SOURCE_UNRETAINABLE' : 'JOB_RECORD_MOVED');
|
|
665
711
|
if (stat.size > maxProjectBytes) throw new JobError('JOB_SOURCE_UNRETAINABLE');
|
|
666
712
|
let bytes: Buffer;
|
|
667
713
|
try {
|
|
668
714
|
bytes = sourceBytes(root, record.path);
|
|
669
715
|
} catch {
|
|
670
|
-
throw new JobError('JOB_RECORD_MOVED');
|
|
716
|
+
throw new JobError(allowLegacySchema ? 'JOB_SOURCE_UNRETAINABLE' : 'JOB_RECORD_MOVED');
|
|
671
717
|
}
|
|
672
718
|
if (jobHash(bytes) !== record.sha256) throw new JobError('JOB_RECORD_MOVED');
|
|
673
719
|
let project: Record<string, unknown>;
|
|
@@ -676,7 +722,7 @@ function readProjectRecordBytes(root: string, record: ProjectRecord): {
|
|
|
676
722
|
} catch {
|
|
677
723
|
throw new JobError('JOB_RECORD_INCOMPLETE');
|
|
678
724
|
}
|
|
679
|
-
if (project.schema !== 'rig-create/project@0') throw new JobError('JOB_RECORD_INCOMPLETE');
|
|
725
|
+
if (!allowLegacySchema && project.schema !== 'rig-create/project@0') throw new JobError('JOB_RECORD_INCOMPLETE');
|
|
680
726
|
return { bytes, project };
|
|
681
727
|
}
|
|
682
728
|
|
|
@@ -708,6 +754,83 @@ function readClosureFileBytes(root: string, file: JobFileIdentity): Buffer {
|
|
|
708
754
|
return bytes;
|
|
709
755
|
}
|
|
710
756
|
|
|
757
|
+
/** Delivery-only projection through the existing retained record reader. */
|
|
758
|
+
export function projectRetainedPlanText(retained: JobRetainedSourceV3): JobPlanTextProjection | undefined {
|
|
759
|
+
const {source, record} = retained;
|
|
760
|
+
const plan = source.plan;
|
|
761
|
+
if (!plan) return undefined;
|
|
762
|
+
let identity: {path: 'project.json'; sha256: string} | null = null;
|
|
763
|
+
const unavailable = (reason: Extract<JobPlanTextProjection, {status:'unavailable'}>['reason']): JobPlanTextProjection =>
|
|
764
|
+
({schema:JOB_PLAN_TEXT_SCHEMA, record:identity, status:'unavailable', reason});
|
|
765
|
+
if (!record || !source.projectHash) return unavailable('PLAN_TEXT_RECORD_UNAVAILABLE');
|
|
766
|
+
if (record.path !== 'project.json') return unavailable('PLAN_TEXT_RECORD_UNSUPPORTED');
|
|
767
|
+
const seals = retained.seals.filter(file => file.path === record.path);
|
|
768
|
+
if (record.sha256 !== source.projectHash || seals.length !== 1 || seals[0]!.sha256 !== record.sha256 ||
|
|
769
|
+
isRetainedRecordSource(retained) && (!retained.source.files.some(file => file.path === record.path && file.sha256 === record.sha256) ||
|
|
770
|
+
retained.source.record.path !== record.path || retained.source.record.sha256 !== record.sha256)) {
|
|
771
|
+
throw new JobError('JOB_SOURCE_MISMATCH', 'PLAN_TEXT_RECORD_MISMATCH');
|
|
772
|
+
}
|
|
773
|
+
identity = {path:'project.json', sha256:record.sha256};
|
|
774
|
+
let project: Record<string, unknown>;
|
|
775
|
+
try {project = readProjectRecordBytes(retained.snapshotRoot, identity, true).project;}
|
|
776
|
+
catch (error) {
|
|
777
|
+
if (error instanceof JobError && error.code === 'JOB_RECORD_MOVED')
|
|
778
|
+
throw new JobError('JOB_SOURCE_MISMATCH', 'PLAN_TEXT_RECORD_HASH_MISMATCH');
|
|
779
|
+
throw new JobError('JOB_SOURCE_UNRETAINABLE', 'PLAN_TEXT_RECORD_UNAVAILABLE');
|
|
780
|
+
}
|
|
781
|
+
if (project.schema !== 'rig-create/project@0') return unavailable('PLAN_TEXT_RECORD_UNSUPPORTED');
|
|
782
|
+
if (!Object.hasOwn(project, 'plan')) return unavailable('PLAN_TEXT_STEPS_ABSENT');
|
|
783
|
+
const rawPlan = asPlainObject(project.plan);
|
|
784
|
+
if (!rawPlan) return unavailable('PLAN_TEXT_STEPS_INVALID');
|
|
785
|
+
if (!Object.hasOwn(rawPlan, 'steps')) return unavailable('PLAN_TEXT_STEPS_ABSENT');
|
|
786
|
+
const rawSteps = rawPlan.steps;
|
|
787
|
+
if (!Array.isArray(rawSteps)) return unavailable('PLAN_TEXT_STEPS_INVALID');
|
|
788
|
+
if (plan.steps.length > 4096) return unavailable('PLAN_TEXT_LIMIT');
|
|
789
|
+
if (isRetainedRecordSource(retained) && (rawSteps.length !== plan.steps.length ||
|
|
790
|
+
rawSteps.some((raw, index) => asPlainObject(raw)?.id !== plan.steps[index]?.id)))
|
|
791
|
+
return unavailable('PLAN_TEXT_MAPPING_UNAVAILABLE');
|
|
792
|
+
const wanted = new Set(plan.steps.map(step => step.id));
|
|
793
|
+
const matched = new Map<string, Record<string, unknown> | null>();
|
|
794
|
+
for (const raw of rawSteps) {
|
|
795
|
+
const step = asPlainObject(raw);
|
|
796
|
+
if (typeof step?.id === 'string' && wanted.has(step.id))
|
|
797
|
+
matched.set(step.id, matched.has(step.id) ? null : step);
|
|
798
|
+
}
|
|
799
|
+
if (plan.steps.some(step => !matched.get(step.id))) return unavailable('PLAN_TEXT_MAPPING_UNAVAILABLE');
|
|
800
|
+
const steps = plan.steps.map<JobPlanTextStep>(step => {
|
|
801
|
+
const raw = matched.get(step.id)!;
|
|
802
|
+
const fields: Omit<JobPlanTextStep, 'id' | 'hash' | 'issues'> = {};
|
|
803
|
+
const issues: JobPlanTextStep['issues'] = [];
|
|
804
|
+
for (const field of JOB_PLAN_TEXT_FIELDS) {
|
|
805
|
+
const value = raw[field];
|
|
806
|
+
if (!Object.hasOwn(raw, field)) issues.push({field, reason:'absent'});
|
|
807
|
+
else if (field === 'rests_on') {
|
|
808
|
+
if (!Array.isArray(value) || value.some(item => typeof item !== 'string')) issues.push({field, reason:'invalid'});
|
|
809
|
+
else if (value.length > 4096) issues.push({field, reason:'limit'});
|
|
810
|
+
else fields.rests_on = value;
|
|
811
|
+
} else if (typeof value === 'string') fields[field] = value;
|
|
812
|
+
else issues.push({field, reason:'invalid'});
|
|
813
|
+
}
|
|
814
|
+
return {id:step.id, hash:step.hash, ...fields, issues};
|
|
815
|
+
});
|
|
816
|
+
const projection: JobPlanTextProjection = {schema:JOB_PLAN_TEXT_SCHEMA, record:identity, status:'projected', steps};
|
|
817
|
+
return Buffer.byteLength(JSON.stringify(projection)) > 512 * 1024 ? unavailable('PLAN_TEXT_LIMIT') : projection;
|
|
818
|
+
}
|
|
819
|
+
|
|
820
|
+
/** Keep the normal owner metadata budget, including the small fallback itself. */
|
|
821
|
+
export function planTextMetadata(retained: JobRetainedSourceV3, metadata: Record<string, unknown>): Record<string, unknown> {
|
|
822
|
+
const projection = projectRetainedPlanText(retained);
|
|
823
|
+
if (!projection) return metadata;
|
|
824
|
+
let result = {...metadata, planText:projection};
|
|
825
|
+
if (Buffer.byteLength(JSON.stringify(result)) > 2 * 1024 * 1024) {
|
|
826
|
+
result = {...metadata, planText:{schema:JOB_PLAN_TEXT_SCHEMA, record:projection.record,
|
|
827
|
+
status:'unavailable', reason:'PLAN_TEXT_LIMIT'}};
|
|
828
|
+
if (Buffer.byteLength(JSON.stringify(result)) > 2 * 1024 * 1024)
|
|
829
|
+
throw new JobError('JOB_BODY_LIMIT', 'PLAN_TEXT_LIMIT');
|
|
830
|
+
}
|
|
831
|
+
return result;
|
|
832
|
+
}
|
|
833
|
+
|
|
711
834
|
function decodeRetainedRecordProject(
|
|
712
835
|
snapshotRoot: string,
|
|
713
836
|
seals: readonly JobFileIdentity[],
|
|
@@ -859,6 +982,7 @@ export async function prepareJobRecordSource(options: {
|
|
|
859
982
|
if (inventory.files.length > maxSourceFiles) {
|
|
860
983
|
throw new JobError('JOB_SOURCE_UNRETAINABLE');
|
|
861
984
|
}
|
|
985
|
+
checkpointEvidenceMetadata(root.path, inventory.checkpointEvidence);
|
|
862
986
|
const snapshotRoot = join(options.stateRoot, 'snapshots', randomUUID());
|
|
863
987
|
const seals: JobFileIdentity[] = [];
|
|
864
988
|
let snapshotIdentity: { dev: number; ino: number } | null = null;
|
|
@@ -910,6 +1034,7 @@ export async function prepareJobRecordSource(options: {
|
|
|
910
1034
|
assertRetainedSnapshotIntact(snapshotRoot, seals, snapshotIdentity, 'JOB_SOURCE_UNRETAINABLE');
|
|
911
1035
|
assertEqualRecordContexts(inventory, retainedContext);
|
|
912
1036
|
const decoded = decodeRetainedRecordProject(snapshotRoot, seals, result, retainedContext);
|
|
1037
|
+
checkpointEvidenceMetadata(snapshotRoot, retainedContext.checkpointEvidence);
|
|
913
1038
|
const source = parseRecordSource(
|
|
914
1039
|
result.kind === 'option-set'
|
|
915
1040
|
? buildRecordSource({
|
|
@@ -1052,6 +1177,14 @@ export async function verifyJobRecordSourceFresh(options: {
|
|
|
1052
1177
|
return freshSource;
|
|
1053
1178
|
}
|
|
1054
1179
|
|
|
1180
|
+
/** Preserve the existing composite preimage, conditionally appending the declaration. */
|
|
1181
|
+
function packageSourceDigest(packageSourceHash: string, record: JobFileIdentity | null,
|
|
1182
|
+
source: Pick<JobModelSourceBinding, 'selector' | 'plan' | 'parts'>, files: readonly JobFileIdentity[],
|
|
1183
|
+
evidence: {readonly checkpointEvidence?: readonly JobCheckpointEvidence[]}): string {
|
|
1184
|
+
return jobHash(JSON.stringify({schema: 'rig-review-job-source/2', packageSourceHash, record,
|
|
1185
|
+
selector: source.selector, plan: source.plan, parts: source.parts, files, ...evidence}));
|
|
1186
|
+
}
|
|
1187
|
+
|
|
1055
1188
|
export async function prepareJobSource(options: {
|
|
1056
1189
|
readonly root: JobRootIdentity;
|
|
1057
1190
|
readonly stateRoot: string;
|
|
@@ -1168,6 +1301,8 @@ export async function prepareJobSource(options: {
|
|
|
1168
1301
|
}
|
|
1169
1302
|
if (requestDigest(context.selector) !== requestDigest(request.result.selector)) throw new JobError('JOB_SOURCE_MISMATCH');
|
|
1170
1303
|
const declared = publishedIdentities(context);
|
|
1304
|
+
const evidence = checkpointEvidenceFields(context, context.plan, context.subjects, declared);
|
|
1305
|
+
checkpointEvidenceMetadata(root.path, evidence.checkpointEvidence);
|
|
1171
1306
|
let review: Awaited<ReturnType<typeof loadReview>>;
|
|
1172
1307
|
try {
|
|
1173
1308
|
const target = checkedPath(root.path, request.result.path, lstatSync(join(root.path, request.result.path)).isDirectory());
|
|
@@ -1204,10 +1339,7 @@ export async function prepareJobSource(options: {
|
|
|
1204
1339
|
await mkdir(snapshotRoot, {mode: 0o700});
|
|
1205
1340
|
const info = lstatSync(snapshotRoot);
|
|
1206
1341
|
snapshotIdentity = {dev: info.dev, ino: info.ino};
|
|
1207
|
-
const
|
|
1208
|
-
path => sourceBytes(root.path, path));
|
|
1209
|
-
for (const image of imageSet?.imageSet.images ?? []) add(image.path, image.sha256);
|
|
1210
|
-
const parts = await prepareParts(root.path, snapshotRoot, context.parts, options.partsEnumerator);
|
|
1342
|
+
const parts = await prepareParts(root.path, snapshotRoot, context.parts, declared, options.partsEnumerator);
|
|
1211
1343
|
for (const [path, bytes] of parts.bytes) add(path, jobHash(bytes));
|
|
1212
1344
|
if (wanted.size > maxSourceFiles) throw new JobError('JOB_SOURCE_UNRETAINABLE', 'PARTS_REFERENCE_LIMIT');
|
|
1213
1345
|
let size = 0;
|
|
@@ -1243,11 +1375,10 @@ export async function prepareJobSource(options: {
|
|
|
1243
1375
|
const originalIdentity = (file: { path: string; sha256: string } | null): JobFileIdentity | null => file && ({
|
|
1244
1376
|
path: rootRelative(root.path, resolve(review.root, file.path)), sha256: file.sha256,
|
|
1245
1377
|
});
|
|
1246
|
-
|
|
1247
|
-
|
|
1248
|
-
|
|
1249
|
-
|
|
1250
|
-
})) : review.sourceHash,
|
|
1378
|
+
checkpointEvidenceMetadata(snapshotRoot, evidence.checkpointEvidence);
|
|
1379
|
+
const modelSource: Omit<JobModelSourceBinding, 'checkpointEvidence'> = {
|
|
1380
|
+
sourceHash: project || context.plan || context.parts ? packageSourceDigest(review.sourceHash, record,
|
|
1381
|
+
{selector: context.selector, plan: context.plan, parts: parts.identity}, seals, evidence) : review.sourceHash,
|
|
1251
1382
|
projectHash: project?.hash ?? null,
|
|
1252
1383
|
package: { id: review.manifest.id, revision: review.manifest.revision },
|
|
1253
1384
|
selector: context.selector,
|
|
@@ -1255,14 +1386,7 @@ export async function prepareJobSource(options: {
|
|
|
1255
1386
|
direction: originalIdentity(review.direction?.file ?? null),
|
|
1256
1387
|
optionSet: null, appliedResult: null, plan: context.plan, parts: parts.identity,
|
|
1257
1388
|
};
|
|
1258
|
-
let source: JobSourceBinding = modelSource;
|
|
1259
|
-
if (imageSet) {
|
|
1260
|
-
if (modelSource.model || modelSource.selector) throw new JobError('JOB_IMAGE_SET_INVALID');
|
|
1261
|
-
const {model, selector, ...common} = modelSource;
|
|
1262
|
-
source = {...common, subject: 'image-set', ...imageSet,
|
|
1263
|
-
sourceHash: jobHash(JSON.stringify({schema: 'rig-review-job-image-set/1',
|
|
1264
|
-
packageSourceHash: modelSource.sourceHash, record, imageSet: imageSet.imageSet}))};
|
|
1265
|
-
}
|
|
1389
|
+
let source: JobSourceBinding = {...modelSource, ...evidence};
|
|
1266
1390
|
const boundReview = { ...review, sourceHash: source.sourceHash };
|
|
1267
1391
|
const sealedByPath = new Map(seals.map(seal => [seal.path, seal.sha256]));
|
|
1268
1392
|
const retainedInterview = project
|
|
@@ -1282,12 +1406,13 @@ export async function prepareJobSource(options: {
|
|
|
1282
1406
|
: null;
|
|
1283
1407
|
const prepared: JobRetainedSource = {
|
|
1284
1408
|
root, record, seals, snapshotRoot, snapshotIdentity,
|
|
1409
|
+
...(evidence.checkpointEvidence ? {checkpointEvidencePackageHash: review.sourceHash} : {}),
|
|
1285
1410
|
manifestPath: retained.manifestPath,
|
|
1286
1411
|
source,
|
|
1287
1412
|
instanceKey: openKey({ mode: 'single', p: boundReview, inputs: { input: review.manifestPath },
|
|
1288
1413
|
contentHash: source.sourceHash, selection: null }, options.fingerprint),
|
|
1289
1414
|
label: review.manifest.title,
|
|
1290
|
-
visual:
|
|
1415
|
+
visual: review.manifest.model || review.manifest.references.length ? { status: 'available' } :
|
|
1291
1416
|
{ status: 'unavailable', code: 'MODEL_UNAVAILABLE' },
|
|
1292
1417
|
subjects: context.subjects,
|
|
1293
1418
|
questions: (project?.questions ?? []).map(question => {
|
|
@@ -1303,6 +1428,7 @@ export async function prepareJobSource(options: {
|
|
|
1303
1428
|
};
|
|
1304
1429
|
await options.afterSnapshot?.();
|
|
1305
1430
|
assertJobSourceCurrent(prepared);
|
|
1431
|
+
if (source.checkpointEvidence) assertRetainedSnapshotIntact(snapshotRoot, seals, snapshotIdentity);
|
|
1306
1432
|
return prepared;
|
|
1307
1433
|
} catch (error) {
|
|
1308
1434
|
if (snapshotIdentity) await removeOwnedJobSnapshot(options.stateRoot, {snapshotRoot, ...snapshotIdentity});
|
|
@@ -1310,3 +1436,29 @@ export async function prepareJobSource(options: {
|
|
|
1310
1436
|
throw new JobError('JOB_SOURCE_MISMATCH');
|
|
1311
1437
|
}
|
|
1312
1438
|
}
|
|
1439
|
+
|
|
1440
|
+
/** Authenticate the optional extension without opening live files or reclaimed snapshots. */
|
|
1441
|
+
export function assertStoredCheckpointEvidence(retained: JobRetainedSourceV3): void {
|
|
1442
|
+
if (!retained.source || typeof retained.source !== 'object' || Array.isArray(retained.source)) {
|
|
1443
|
+
throw new JobError('JOB_SOURCE_MISMATCH');
|
|
1444
|
+
}
|
|
1445
|
+
const hasEvidence = 'checkpointEvidence' in retained.source;
|
|
1446
|
+
if (isRetainedRecordSource(retained)) {
|
|
1447
|
+
const parsed = parseRecordSource(retained.source);
|
|
1448
|
+
if (!hasEvidence && !('checkpointEvidence' in retained.context)) return;
|
|
1449
|
+
const context = parseRecordPublishedContext(retained.context, retained.result, retained.record);
|
|
1450
|
+
if (requestDigest(parsed.checkpointEvidence ?? null) !== requestDigest(context.checkpointEvidence ?? null) ||
|
|
1451
|
+
requestDigest(parsed.subjects) !== requestDigest(retained.subjects) ||
|
|
1452
|
+
requestDigest(parsed.files) !== requestDigest(retained.seals)) throw new JobError('JOB_SOURCE_MISMATCH');
|
|
1453
|
+
return;
|
|
1454
|
+
}
|
|
1455
|
+
if (!hasEvidence && !('checkpointEvidencePackageHash' in retained)) return;
|
|
1456
|
+
const source = retained.source;
|
|
1457
|
+
if (!hasEvidence || !retained.record) throw new JobError('JOB_SOURCE_MISMATCH');
|
|
1458
|
+
const evidence = checkpointEvidenceFields(source, source.plan, retained.subjects, retained.seals);
|
|
1459
|
+
const packageSourceHash = jobSha(retained.checkpointEvidencePackageHash);
|
|
1460
|
+
const expected = packageSourceDigest(packageSourceHash, retained.record, source, retained.seals, evidence);
|
|
1461
|
+
if (expected !== source.sourceHash || requestDigest(evidence.checkpointEvidence) !== requestDigest(source.checkpointEvidence)) {
|
|
1462
|
+
throw new JobError('JOB_SOURCE_MISMATCH');
|
|
1463
|
+
}
|
|
1464
|
+
}
|
package/src/job-store.ts
CHANGED
|
@@ -2,6 +2,8 @@ import { Database, constants as sqliteConstants } from 'bun:sqlite';
|
|
|
2
2
|
import { randomUUID } from 'node:crypto';
|
|
3
3
|
import { chmodSync, lstatSync, mkdirSync, realpathSync } from 'node:fs';
|
|
4
4
|
import { join } from 'node:path';
|
|
5
|
+
import {createHash} from 'node:crypto';
|
|
6
|
+
import {validatePngCrop} from './comment-crops.ts';
|
|
5
7
|
import { JOB_API_SCHEMA, JOB_ACT_SCHEMA, type JobErrorCode, type JobEvent } from './job-contract.ts';
|
|
6
8
|
|
|
7
9
|
export class JobError extends Error {
|
|
@@ -63,6 +65,28 @@ interface JobRow {
|
|
|
63
65
|
|
|
64
66
|
const maximumDocumentBytes = 16 * 1024 * 1024;
|
|
65
67
|
|
|
68
|
+
/** Private representation only. Public act bytes are reconstructed without changing key order. */
|
|
69
|
+
export function jobCropReferences(value: unknown, save?: (sha256: string, bytes: Buffer) => void): string {
|
|
70
|
+
const paths = new WeakMap<object, string[]>(), references: [string[], string][] = [];
|
|
71
|
+
const text = JSON.stringify(value, function(key, item) {
|
|
72
|
+
if (save && (item === undefined || typeof item === 'function' || typeof item === 'symbol' ||
|
|
73
|
+
typeof item === 'bigint' || typeof item === 'number' && !Number.isFinite(item))) throw new JobError('JOB_STORAGE_FAILED');
|
|
74
|
+
const path = key === '' ? [] : [...(paths.get(this) ?? []), key];
|
|
75
|
+
if (item && typeof item === 'object') paths.set(item, path);
|
|
76
|
+
if (key === 'png' && typeof item === 'string' && item.startsWith('data:image/png;base64,') &&
|
|
77
|
+
this.path === `comment-crops/${this.sha256}.png`) {
|
|
78
|
+
if (save) save(this.sha256, validatePngCrop(this));
|
|
79
|
+
references.push([path, this.sha256]);
|
|
80
|
+
return 'job-crop:' + this.sha256;
|
|
81
|
+
}
|
|
82
|
+
return item;
|
|
83
|
+
});
|
|
84
|
+
if (!references.length) return text;
|
|
85
|
+
const packed = JSON.parse(text);
|
|
86
|
+
packed._jobCommentCrops = references;
|
|
87
|
+
return JSON.stringify(packed);
|
|
88
|
+
}
|
|
89
|
+
|
|
66
90
|
function encode(value: unknown): string {
|
|
67
91
|
try {
|
|
68
92
|
const text = JSON.stringify(value, (_key, item) => {
|
|
@@ -208,6 +232,9 @@ export class JobStore<Data> {
|
|
|
208
232
|
job_id TEXT NOT NULL, act_id TEXT NOT NULL, page_id TEXT NOT NULL, submission_id TEXT NOT NULL,
|
|
209
233
|
sha256 TEXT NOT NULL, binding TEXT NOT NULL, png BLOB NOT NULL, act_bytes BLOB NOT NULL,
|
|
210
234
|
PRIMARY KEY(job_id, act_id), UNIQUE(job_id, page_id, submission_id)
|
|
235
|
+
);
|
|
236
|
+
CREATE TABLE IF NOT EXISTS job_comment_crops (
|
|
237
|
+
sha256 TEXT PRIMARY KEY, png BLOB NOT NULL
|
|
211
238
|
);`);
|
|
212
239
|
this.captureStorage();
|
|
213
240
|
} catch {
|
|
@@ -272,7 +299,8 @@ export class JobStore<Data> {
|
|
|
272
299
|
const row = this.db.query<JobRow, [string]>(`SELECT jobs.*, job_closures.document AS closure
|
|
273
300
|
FROM jobs LEFT JOIN job_closures USING(job_id) WHERE job_id=?`).get(jobId);
|
|
274
301
|
if (!row) throw new JobError('JOB_UNKNOWN');
|
|
275
|
-
|
|
302
|
+
const stored = decode<Data>(row);
|
|
303
|
+
return {...stored, data: this.restoreCrops(stored.data)};
|
|
276
304
|
} catch (error) {
|
|
277
305
|
if (error instanceof JobError) throw error;
|
|
278
306
|
throw new JobError('JOB_STORAGE_FAILED', 'Stored job state is invalid');
|
|
@@ -282,7 +310,7 @@ export class JobStore<Data> {
|
|
|
282
310
|
activeByRootKey(rootKey: string): StoredJob<Data> | null {
|
|
283
311
|
try {
|
|
284
312
|
const row = this.db.query<JobRow, [string]>('SELECT * FROM jobs WHERE root_key=? AND active=1').get(rootKey);
|
|
285
|
-
return row ?
|
|
313
|
+
return row ? this.get(row.job_id) : null;
|
|
286
314
|
} catch {
|
|
287
315
|
throw new JobError('JOB_STORAGE_FAILED', 'Stored job state is invalid');
|
|
288
316
|
}
|
|
@@ -309,7 +337,7 @@ export class JobStore<Data> {
|
|
|
309
337
|
const current = this.db.query<JobRow, [string]>(
|
|
310
338
|
'SELECT * FROM jobs WHERE root_key=? AND active=1',
|
|
311
339
|
).get(rootKey);
|
|
312
|
-
if (current) return
|
|
340
|
+
if (current) return this.get(current.job_id);
|
|
313
341
|
const jobId = randomUUID();
|
|
314
342
|
const document = encode(initialize(jobId));
|
|
315
343
|
this.db.query('INSERT INTO jobs(job_id,root_key,revision,active,document) VALUES(?,?,0,1,?)')
|
|
@@ -336,7 +364,7 @@ export class JobStore<Data> {
|
|
|
336
364
|
if (expectedRevision !== null && current.revision !== expectedRevision) throw new JobError('JOB_GENERATION_STALE');
|
|
337
365
|
const next = operation(current);
|
|
338
366
|
const active = next.active ?? current.active;
|
|
339
|
-
const document = encode(next.data);
|
|
367
|
+
const document = encode(JSON.parse(this.saveCrops(next.data)));
|
|
340
368
|
if (next.snapshot) {
|
|
341
369
|
const snapshot = next.snapshot;
|
|
342
370
|
this.db.query(`INSERT INTO job_snapshot_owners
|
|
@@ -347,7 +375,8 @@ export class JobStore<Data> {
|
|
|
347
375
|
const still = next.still;
|
|
348
376
|
this.db.query(`INSERT INTO job_act_stills
|
|
349
377
|
(job_id,act_id,page_id,submission_id,sha256,binding,png,act_bytes) VALUES(?,?,?,?,?,?,?,?)`)
|
|
350
|
-
.run(jobId, still.actId, still.pageId, still.submissionId, still.sha256, still.binding, still.png,
|
|
378
|
+
.run(jobId, still.actId, still.pageId, still.submissionId, still.sha256, still.binding, still.png,
|
|
379
|
+
Buffer.from(this.saveCrops(JSON.parse(Buffer.from(still.actBytes).toString()))));
|
|
351
380
|
}
|
|
352
381
|
this.db.query('UPDATE jobs SET revision=?,active=?,document=? WHERE job_id=?')
|
|
353
382
|
.run(current.revision + 1, active ? 1 : 0, document, jobId);
|
|
@@ -356,9 +385,54 @@ export class JobStore<Data> {
|
|
|
356
385
|
}
|
|
357
386
|
|
|
358
387
|
readStill(jobId: string, actId: string): Pick<JobStoredStill, 'sha256' | 'png' | 'actBytes'> | null {
|
|
359
|
-
|
|
388
|
+
const stored = this.db.query<{sha256: string; png: Uint8Array; actBytes: Uint8Array}, [string, string]>(
|
|
360
389
|
'SELECT sha256,png,act_bytes AS actBytes FROM job_act_stills WHERE job_id=? AND act_id=?',
|
|
361
390
|
).get(jobId, actId);
|
|
391
|
+
if (!stored) return null;
|
|
392
|
+
let parsed: unknown;
|
|
393
|
+
try { parsed = JSON.parse(Buffer.from(stored.actBytes).toString()); }
|
|
394
|
+
catch { throw new JobError('JOB_STILL_CAPTURE_FAILED'); }
|
|
395
|
+
if (!Buffer.from(JSON.stringify(parsed)).equals(Buffer.from(stored.actBytes))) throw new JobError('JOB_STILL_CAPTURE_FAILED');
|
|
396
|
+
return {...stored, actBytes: Buffer.from(JSON.stringify(this.restoreCrops(parsed)))};
|
|
397
|
+
}
|
|
398
|
+
|
|
399
|
+
readCrop(sha256: string): Buffer {
|
|
400
|
+
const row = this.db.query<{png: Uint8Array}, [string]>('SELECT png FROM job_comment_crops WHERE sha256=?').get(sha256);
|
|
401
|
+
if (!row || createHash('sha256').update(row.png).digest('hex') !== sha256) throw new JobError('JOB_STORAGE_FAILED');
|
|
402
|
+
return Buffer.from(row.png);
|
|
403
|
+
}
|
|
404
|
+
|
|
405
|
+
private saveCrops(value: unknown): string {
|
|
406
|
+
this.db.exec('CREATE TABLE IF NOT EXISTS job_comment_crops (sha256 TEXT PRIMARY KEY, png BLOB NOT NULL)');
|
|
407
|
+
const saved = new Set<string>();
|
|
408
|
+
return jobCropReferences(value, (sha256, bytes) => {
|
|
409
|
+
if (saved.has(sha256)) return;
|
|
410
|
+
saved.add(sha256);
|
|
411
|
+
this.db.query('INSERT OR IGNORE INTO job_comment_crops(sha256,png) VALUES(?,?)').run(sha256, bytes);
|
|
412
|
+
if (!this.readCrop(sha256).equals(bytes)) throw new JobError('JOB_STORAGE_FAILED');
|
|
413
|
+
});
|
|
414
|
+
}
|
|
415
|
+
|
|
416
|
+
private restoreCrops<T>(value: T): T {
|
|
417
|
+
const packed = value as Record<string, unknown>, references = packed._jobCommentCrops;
|
|
418
|
+
if (references === undefined) return value;
|
|
419
|
+
if (!Array.isArray(references)) throw new JobError('JOB_STORAGE_FAILED');
|
|
420
|
+
delete packed._jobCommentCrops;
|
|
421
|
+
const cache = new Map<string, string>();
|
|
422
|
+
for (const [path, sha256] of references) {
|
|
423
|
+
if (!Array.isArray(path) || !path.every(key => typeof key === 'string') || path.at(-1) !== 'png' ||
|
|
424
|
+
typeof sha256 !== 'string' || !/^[a-f0-9]{64}$/.test(sha256)) throw new JobError('JOB_STORAGE_FAILED');
|
|
425
|
+
let owner: any = packed;
|
|
426
|
+
for (const key of path.slice(0, -1)) {
|
|
427
|
+
if (!owner || typeof owner !== 'object' || !Object.hasOwn(owner, key)) throw new JobError('JOB_STORAGE_FAILED');
|
|
428
|
+
owner = owner[key];
|
|
429
|
+
}
|
|
430
|
+
if (owner?.png !== 'job-crop:' + sha256 || owner.sha256 !== sha256 ||
|
|
431
|
+
owner.path !== `comment-crops/${sha256}.png`) throw new JobError('JOB_STORAGE_FAILED');
|
|
432
|
+
if (!cache.has(sha256)) cache.set(sha256, 'data:image/png;base64,' + this.readCrop(sha256).toString('base64'));
|
|
433
|
+
owner.png = cache.get(sha256);
|
|
434
|
+
}
|
|
435
|
+
return value;
|
|
362
436
|
}
|
|
363
437
|
|
|
364
438
|
/** Close never grows or rewrites the bounded historical document. */
|
package/src/job-worker.ts
CHANGED
|
@@ -1,8 +1,4 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import { createJobHostPorts } from './job-api.ts';
|
|
3
|
-
import { JobSession, type JobSessionOptions } from './job-session.ts';
|
|
4
|
-
import type { JobHostPorts } from './job-contract.ts';
|
|
5
|
-
import { JobError } from './job-store.ts';
|
|
1
|
+
import type {JobSessionOptions} from './job-session.ts';
|
|
6
2
|
|
|
7
3
|
export interface JobWorkerOptions extends JobSessionOptions {
|
|
8
4
|
readonly port?: number;
|
|
@@ -16,45 +12,3 @@ export interface JobWorkerOptions extends JobSessionOptions {
|
|
|
16
12
|
readonly fetchCapability: string;
|
|
17
13
|
}) => void | Promise<void>;
|
|
18
14
|
}
|
|
19
|
-
|
|
20
|
-
/** Backend host only. Lane B mounts these same ports in its managed front and
|
|
21
|
-
* supplies the owner UI. This listener serves semantic API requests only and
|
|
22
|
-
* never serves a private snapshot directory or starts a browser/producer.
|
|
23
|
-
*/
|
|
24
|
-
export async function startJobWorker(options: JobWorkerOptions): Promise<{
|
|
25
|
-
readonly session: JobSession;
|
|
26
|
-
readonly ports: JobHostPorts;
|
|
27
|
-
readonly origin: string;
|
|
28
|
-
readonly listenerIncarnation: string;
|
|
29
|
-
stop(): void;
|
|
30
|
-
}> {
|
|
31
|
-
const session = new JobSession(options);
|
|
32
|
-
const listenerIncarnation = randomUUID();
|
|
33
|
-
let ports: JobHostPorts;
|
|
34
|
-
let stopped = false;
|
|
35
|
-
const server = Bun.serve({
|
|
36
|
-
hostname: '127.0.0.1', port: options.port ?? 0, idleTimeout: 0,
|
|
37
|
-
fetch(request) {
|
|
38
|
-
const url = new URL(request.url);
|
|
39
|
-
if (url.pathname === `/jobs/${session.jobId}/api`) return ports.handleJobApi(request);
|
|
40
|
-
return Response.json({ error: 'JOB_REQUEST_INVALID' }, {
|
|
41
|
-
status: 404, headers: { 'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff' },
|
|
42
|
-
});
|
|
43
|
-
},
|
|
44
|
-
});
|
|
45
|
-
const origin = `http://127.0.0.1:${server.port}`;
|
|
46
|
-
ports = createJobHostPorts(session, origin);
|
|
47
|
-
const stop = () => {
|
|
48
|
-
if (stopped) return;
|
|
49
|
-
stopped = true;
|
|
50
|
-
server.stop(true);
|
|
51
|
-
session.dispose();
|
|
52
|
-
};
|
|
53
|
-
try {
|
|
54
|
-
await options.installWriterBinding?.({ ...session.writerGrant(), origin });
|
|
55
|
-
return { session, ports, origin, listenerIncarnation, stop };
|
|
56
|
-
} catch {
|
|
57
|
-
stop();
|
|
58
|
-
throw new JobError('JOB_AUTHORITY_REFUSED', 'Writer binding installation failed');
|
|
59
|
-
}
|
|
60
|
-
}
|