@trillboards/edge-sdk 0.2.209 → 0.2.213

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.
Files changed (65) hide show
  1. package/deploy/windows/ci/test-alert-window-field.ps1 +252 -0
  2. package/deploy/windows/ci/test-published-install.ps1 +6 -2
  3. package/dist/AlertClips.d.ts +131 -0
  4. package/dist/AlertClips.d.ts.map +1 -0
  5. package/dist/AlertClips.js +476 -0
  6. package/dist/AlertClips.js.map +1 -0
  7. package/dist/CloudSensingManager.d.ts +27 -0
  8. package/dist/CloudSensingManager.d.ts.map +1 -1
  9. package/dist/CloudSensingManager.js +138 -16
  10. package/dist/CloudSensingManager.js.map +1 -1
  11. package/dist/ConnectorStatusClient.d.ts +10 -0
  12. package/dist/ConnectorStatusClient.d.ts.map +1 -1
  13. package/dist/ConnectorStatusClient.js +11 -1
  14. package/dist/ConnectorStatusClient.js.map +1 -1
  15. package/dist/DurableVlmCandidateSpool.d.ts +4 -0
  16. package/dist/DurableVlmCandidateSpool.d.ts.map +1 -1
  17. package/dist/DurableVlmCandidateSpool.js +13 -0
  18. package/dist/DurableVlmCandidateSpool.js.map +1 -1
  19. package/dist/EdgeAgent.js +1 -1
  20. package/dist/LocalVideoBuffer.d.ts +59 -0
  21. package/dist/LocalVideoBuffer.d.ts.map +1 -0
  22. package/dist/LocalVideoBuffer.js +214 -0
  23. package/dist/LocalVideoBuffer.js.map +1 -0
  24. package/dist/NativeReadiness.d.ts +9 -1
  25. package/dist/NativeReadiness.d.ts.map +1 -1
  26. package/dist/NativeReadiness.js +21 -5
  27. package/dist/NativeReadiness.js.map +1 -1
  28. package/dist/SensingProfileClient.d.ts +62 -5
  29. package/dist/SensingProfileClient.d.ts.map +1 -1
  30. package/dist/SensingProfileClient.js +76 -1
  31. package/dist/SensingProfileClient.js.map +1 -1
  32. package/dist/VideoSegmentUploader.d.ts +169 -5
  33. package/dist/VideoSegmentUploader.d.ts.map +1 -1
  34. package/dist/VideoSegmentUploader.js +543 -32
  35. package/dist/VideoSegmentUploader.js.map +1 -1
  36. package/dist/autoSense.d.ts.map +1 -1
  37. package/dist/autoSense.js +4 -0
  38. package/dist/autoSense.js.map +1 -1
  39. package/dist/cli.d.ts.map +1 -1
  40. package/dist/cli.js +3 -0
  41. package/dist/cli.js.map +1 -1
  42. package/dist/connectorUpdate.d.ts +22 -0
  43. package/dist/connectorUpdate.d.ts.map +1 -1
  44. package/dist/connectorUpdate.js +72 -8
  45. package/dist/connectorUpdate.js.map +1 -1
  46. package/dist/diagnose.d.ts +1 -1
  47. package/dist/diagnose.js +1 -1
  48. package/dist/localSenseE2eHarness.d.ts +1 -1
  49. package/dist/localSenseE2eHarness.d.ts.map +1 -1
  50. package/dist/localSenseE2eHarness.js +7 -4
  51. package/dist/localSenseE2eHarness.js.map +1 -1
  52. package/dist/localSensing.d.ts +58 -0
  53. package/dist/localSensing.d.ts.map +1 -1
  54. package/dist/localSensing.js +126 -16
  55. package/dist/localSensing.js.map +1 -1
  56. package/package.json +5 -5
  57. package/retained/ArchiveLifecycle.cjs +11 -5
  58. package/retained/RetainedCaptureClient.cjs +206 -49
  59. package/retained/WebsiteAdmissionCaptureClient.cjs +40 -8
  60. package/retained/__tests__/evidence-uploads.test.cjs +130 -0
  61. package/retained/__tests__/realtime-schedule.test.cjs +71 -11
  62. package/retained/__tests__/upgrade-backlog.test.cjs +239 -0
  63. package/retained/__tests__/website-admission-realtime.test.cjs +48 -9
  64. package/retained/manager.cjs +2 -0
  65. package/retained/website-api-capability.cjs +7 -1
@@ -0,0 +1,130 @@
1
+ 'use strict';
2
+ // Evidence-only uploads on the retained website path: a review withholds its
3
+ // photo only against an API that says it takes a review without one.
4
+ const { test } = require('node:test'), assert = require('node:assert/strict');
5
+ const fs = require('node:fs'), path = require('node:path'), http = require('node:http');
6
+ const release = path.join(__dirname, '..');
7
+
8
+ function capabilityServer(body) {
9
+ const server = http.createServer((req, res) => {
10
+ if (!req.url.startsWith('/v2/earner/cctv-retained/capabilities') || req.headers['x-device-token'] !== 'tok-cam') {
11
+ res.writeHead(403).end('{}');
12
+ return;
13
+ }
14
+ res.setHeader('Content-Type', 'application/json');
15
+ res.end(JSON.stringify(body));
16
+ });
17
+ return new Promise(resolve => server.listen(0, '127.0.0.1', () => resolve(server)));
18
+ }
19
+ const capability = { retainedReview: true, protocolVersion: 1, lateEvidenceAccepted: true,
20
+ timedModes: ['any', 'wait_recheck'], cameraId: 'screen1', maxBodyBytes: 2 * 1024 * 1024 };
21
+
22
+ test('the capability check reports an API that takes a review without its photo, and only that', async () => {
23
+ const { checkRetainedApi } = require('../website-api-capability.cjs');
24
+ const feed = { name: 'cam', screenId: 'screen1', deviceToken: 'tok-cam' };
25
+ const optional = { optional: true, sampleIntervalMs: 600000, missingImageReason: 'evidence_image_required' };
26
+ for (const [served, expected] of [[{ ...capability, evidenceImage: optional }, true], [capability, undefined],
27
+ [{ ...capability, evidenceImage: { ...optional, optional: 'yes' } }, undefined],
28
+ [{ ...capability, evidenceImage: true }, undefined], [{ ...capability, imagelessReview: true }, undefined]]) {
29
+ const server = await capabilityServer(served);
30
+ try {
31
+ const result = await checkRetainedApi('http://127.0.0.1:' + server.address().port, feed);
32
+ assert.equal(result.cameraId, 'screen1');
33
+ assert.equal(result.imagelessReview, expected);
34
+ } finally {
35
+ await new Promise(resolve => server.close(resolve));
36
+ }
37
+ }
38
+ });
39
+
40
+ test('the website factory hands each feed its own API answer about image-less reviews', async () => {
41
+ const names = [path.join(release, '../dist/localSensing'), path.join(release, '../dist/CloudSensingManager'),
42
+ path.join(release, 'website-api-capability.cjs')];
43
+ const modules = names.map(name => { const key = require.resolve(name); require(key); return { key, prior: require.cache[key].exports }; });
44
+ const directory = fs.mkdtempSync(path.join(require('node:os').tmpdir(), 'retained-evidence-uploads-'));
45
+ let seen = null;
46
+ try {
47
+ require.cache[modules[0].key].exports = { buildLocalSensingLoops: (config, deps) => {
48
+ seen = deps;
49
+ return config.cameras.map(feed => ({ name: feed.name, client: {
50
+ prepareReview: async () => {}, captureReviewContext: () => ({ profileState: 'inactive' }),
51
+ getEndpoint: () => 'https://example.invalid/v2/earner/audience-analyze' } }));
52
+ } };
53
+ require.cache[modules[1].key].exports = { resolveFeeds: config => config.cameras,
54
+ CloudSensingManager: class {
55
+ constructor(options) { this.options = options; this.candidates = { offer: () => 'buffered', withdraw: () => 'absent' };
56
+ this.frameGroupers = new Map(options.loops.map(loop => [loop.name, {}])); }
57
+ } };
58
+ // camera1's API takes image-less reviews; camera2's predates them.
59
+ require.cache[modules[2].key].exports = { checkRetainedApi: async (_base, feed) => ({ cameraId: feed.screenId,
60
+ ...(feed.name === 'camera1' ? { imagelessReview: true } : {}) }) };
61
+ delete require.cache[require.resolve(path.join(release, 'manager.cjs'))];
62
+ const { createWebsiteManager } = require(path.join(release, 'manager.cjs'));
63
+ const config = { apiBaseUrl: 'https://example.invalid', localSensing: { enabled: true, model: 'gemma' },
64
+ cameras: [{ name: 'camera1', screenId: 'screen1' }, { name: 'camera2', screenId: 'screen2' }],
65
+ pilot: { websiteManaged: true, requiresDetector: true, maxCapturesPerCamera: 100, maxBytesPerCamera: 100000 },
66
+ cloudSensing: { candidateBuffer: { continuousReview: { enabled: true, deliveryTarget: 'configured-api',
67
+ independentUploads: true, reviewWindowMs: 150000 } } } };
68
+ await createWebsiteManager(config, path.join(directory, 'state'));
69
+ assert.equal(typeof seen.imagelessReview, 'function');
70
+ assert.equal(seen.imagelessReview({ name: 'camera1' }), true);
71
+ assert.equal(seen.imagelessReview({ name: 'camera2' }), false);
72
+ assert.equal(seen.imagelessReview({ name: 'unknown' }), false);
73
+ } finally {
74
+ for (const module of modules) require.cache[module.key].exports = module.prior;
75
+ delete require.cache[require.resolve(path.join(release, 'manager.cjs'))];
76
+ fs.rmSync(directory, { recursive: true, force: true });
77
+ }
78
+ });
79
+
80
+ test('a feed in alert_windows mode cuts an alert window from its buffer and uploads it first, end to end on the built code', async () => {
81
+ const { CctvVideoRecorder, VideoSegmentUploader } = require(path.join(release, '../dist/VideoSegmentUploader'));
82
+ const { LocalVideoBuffer } = require(path.join(release, '../dist/LocalVideoBuffer'));
83
+ const { EventEmitter } = require('node:events');
84
+ const directory = fs.mkdtempSync(path.join(require('node:os').tmpdir(), 'retained-alert-window-'));
85
+ const calls = [];
86
+ try {
87
+ const provider = new EventEmitter();
88
+ provider.configs = [];
89
+ provider.setSegmentRecording = config => provider.configs.push(config);
90
+ provider.setSessionPriority = () => {};
91
+ const poster = async (url, _options, body) => {
92
+ const parsed = JSON.parse(body);
93
+ calls.push({ url, body: parsed });
94
+ if (url.endsWith('/video-segment-upload-url')) return { statusCode: 200, body: JSON.stringify({ uploadUrl: 'https://blob.example/x?sig=1' }) };
95
+ return { statusCode: 200, body: '{"indexed":true}' };
96
+ };
97
+ const uploader = new VideoSegmentUploader({ apiBaseUrl: 'https://api.example.com', deviceToken: 'tok', agentVersion: '0.2.210',
98
+ poster, putBlob: async () => ({ statusCode: 201, body: '' }), network: () => 'ethernet',
99
+ probe: () => ({ codec: 'h264', sampleEntry: 'avc1', width: 640, height: 360, frames: 300, durationMs: 30000, fps: 10,
100
+ videoBytes: 1000, hasAudio: false, audio: null }), log: () => {} });
101
+ const T = Date.now() - 120000;
102
+ const recorder = new CctvVideoRecorder({ provider, dir: path.join(directory, 'feed'), feedName: 'Register', uploader,
103
+ buffer: new LocalVideoBuffer({ volumeDir: directory, freeBytesFn: () => 1e9 }), log: () => {},
104
+ profileClient: { fetchProfile: async () => ({ video: { dailySeconds: 0, segmentSeconds: 60, ringSeconds: 3600,
105
+ mode: 'alert_windows', alerting: true, alertWindow: { beforeSeconds: 15, afterSeconds: 15 },
106
+ alertClips: [{ alertId: 'a'.repeat(64), triggerId: 'a'.repeat(64), capturedAtMs: T, beforeSeconds: 15, afterSeconds: 15 }] } }) },
107
+ cutWindow: async o => {
108
+ fs.mkdirSync(o.outDir, { recursive: true });
109
+ const file = path.join(o.outDir, o.request.triggerId + '.mp4');
110
+ fs.writeFileSync(file, 'clip');
111
+ return { clip: { file, metaFile: file.replace(/\.mp4$/, '.json'), captureStartMs: T - 15000, captureEndMs: T + 15000, sourceSegments: 3 } };
112
+ } });
113
+ provider.emit('opening');
114
+ for (let i = 0; i < 20 && !calls.some(c => c.url.endsWith('/video-segment-finalize')); i++) {
115
+ await new Promise(resolve => setTimeout(resolve, 20));
116
+ if (i === 2) provider.emit('segment', { file: path.join(directory, 'x.mp4'), startSec: 0, endSec: 10, captureStartMs: T + 10000, captureEndMs: T + 20000 });
117
+ }
118
+ const finalize = calls.find(c => c.url.endsWith('/video-segment-finalize'));
119
+ assert.ok(finalize, 'the alert window was uploaded');
120
+ assert.equal(finalize.body.trigger_kind, 'event');
121
+ assert.equal(finalize.body.trigger_id, 'a'.repeat(64));
122
+ assert.equal(finalize.body.capture_end_ms - finalize.body.capture_start_ms, 30000);
123
+ // No continuous segment ever left the box.
124
+ assert.equal(calls.filter(c => c.url.endsWith('/video-segment-finalize') && c.body.trigger_kind !== 'event').length, 0);
125
+ assert.equal(provider.configs.at(-1).segmentSeconds, 10);
126
+ recorder.stop();
127
+ } finally {
128
+ fs.rmSync(directory, { recursive: true, force: true });
129
+ }
130
+ });
@@ -6,7 +6,7 @@ const { test } = require('node:test');
6
6
  const assert = require('node:assert/strict');
7
7
  const fs = require('node:fs'), os = require('node:os'), path = require('node:path'), crypto = require('node:crypto');
8
8
  const { decode, encode } = require('jpeg-js');
9
- const { RetainedCaptureClient, RECHECK_ANCHOR_GRACE_MS } = require('../RetainedCaptureClient.cjs');
9
+ const { RetainedCaptureClient, RECHECK_ANCHOR_GRACE_MS, BACKLOG_REVIEW_BUDGET_MS, BACKLOG_MAX_STARTS } = require('../RetainedCaptureClient.cjs');
10
10
  const take = name => require(path.join(__dirname, '../../dist', name));
11
11
  const { DurableVlmCandidateSpool } = take('DurableVlmCandidateSpool');
12
12
  const routeReviewTiming = require(path.resolve(__dirname, '../../../../../trillboard-api/services/fein/routeReviewTiming.js'));
@@ -82,7 +82,8 @@ function rig(names, { freshnessMs = LIVE_BOUND_MS, inner } = {}) {
82
82
  const serve = async () => { const c = next(); return c ? finish(c) : null; };
83
83
  const restartSpool = () => { rigState.spool = new DurableVlmCandidateSpool(spoolOptions); rigState.spool.startRun();
84
84
  for (const archive of archives.values()) if (archive.realtime) archive.attachReviewQueue(rigState.spool); };
85
- const row = (name, id) => JSON.parse(fs.readFileSync(archives.get(name).file(id)));
85
+ // The record as a restart would load it: its file plus the archive's decision log.
86
+ const row = (name, id) => archives.get(name).durableRecord(id);
86
87
  return { root, state, rigState, archives, open, capture, pump, next, finish, serve, restartSpool, row, reviews,
87
88
  spool: () => rigState.spool, cleanup: () => fs.rmSync(root, { recursive: true, force: true }) };
88
89
  }
@@ -276,7 +277,7 @@ test('restart keeps retired frames retired; lifetime counts survive reclamation
276
277
  } finally { r.cleanup(); }
277
278
  });
278
279
 
279
- test('an upgraded archive drops its old oldest-first backlog in bounded steps and reviews the newest frame first', async () => {
280
+ test('an upgraded archive holds its old oldest-first backlog apart: unrewritten, never live work, reviewed only when idle', async () => {
280
281
  const r = rig([]);
281
282
  try {
282
283
  // The previous release: capture order, 40 selections a day old, 16 of them queued.
@@ -286,21 +287,80 @@ test('an upgraded archive drops its old oldest-first backlog in bounded steps an
286
287
  for (let i = 0; i < 40; i++) { backlog.push(r.capture('counter')); r.state.now += 1000; }
287
288
  for (const c of legacy.pendingOrderedCandidates()) legacy.offered(c, r.spool().offer(c));
288
289
  assert.equal(r.spool().getStats().buffered, 16);
290
+ const bytesBefore = backlog.map(row => fs.readFileSync(legacy.file(row.id), 'utf8'));
289
291
  // The upgrade: same disk, new release.
290
292
  r.state.now = Date.parse('2026-11-03T15:00:00Z');
291
293
  r.restartSpool();
292
- r.open('counter');
294
+ const archive = r.open('counter');
293
295
  const fresh = r.capture('counter');
294
296
  r.pump();
295
- assert.equal(r.spool().getStats().buffered, 1); // the 16 queued old frames left in the first pump
296
- assert.equal(backlog.filter(row => r.row('counter', row.id).disposition === 'expired_unreviewed').length, 16);
297
+ // The 16 recovered old copies left the queue; their originals did not change.
298
+ assert.equal(r.spool().getStats().buffered, 1);
299
+ assert.deepEqual(backlog.map(row => fs.readFileSync(archive.file(row.id), 'utf8')), bytesBefore);
300
+ assert.equal(backlog.every(row => r.row('counter', row.id).disposition === 'pending_review'), true);
301
+ assert.deepEqual(archive.getReviewScheduleStats(),
302
+ { freshnessMs: LIVE_BOUND_MS, pending: 41, selected: 41, reviewed: 0, shed: 0, expired: 0, backlog: 40 });
303
+ // Live work never waits on history.
297
304
  assert.equal((await r.serve()).spoolId, fresh.id);
298
- for (let i = 0; i < 3; i++) r.pump();
299
- // A day old: past the live-alert bound, whatever replaced it.
300
- assert.equal(backlog.every(row => r.row('counter', row.id).disposition === 'expired_unreviewed'), true);
301
305
  assert.deepEqual(r.reviews.map(x => x.evidenceId), [fresh.id]);
302
- assert.deepEqual(r.archives.get('counter').getReviewScheduleStats(),
303
- { freshnessMs: LIVE_BOUND_MS, pending: 0, selected: 41, reviewed: 1, shed: 0, expired: 40 });
306
+ // Idle: one historical original, oldest first, on a budget instead of a capture deadline.
307
+ const old = archive.pendingBacklogCandidate();
308
+ assert.equal(old.retainedId, backlog[0].id);
309
+ assert.equal(old.reviewDeadlineAtMs, r.state.now + BACKLOG_REVIEW_BUDGET_MS);
310
+ assert.equal(old.reviewPriority, undefined);
311
+ archive.offered(old, r.spool().offer(old));
312
+ assert.equal(archive.pendingBacklogCandidate(), null); // one queued per camera
313
+ // A live frame arriving now goes first: the manager withdraws the queued copy.
314
+ assert.equal(r.spool().withdraw(old.retainedId), 'withdrawn');
315
+ r.state.now += 1000; const live = r.capture('counter');
316
+ assert.equal((await r.serve()).spoolId, live.id);
317
+ // Idle again: the same original is offered again, reviewed, and leaves the backlog.
318
+ const again = archive.pendingBacklogCandidate();
319
+ assert.equal(again.retainedId, backlog[0].id);
320
+ archive.offered(again, r.spool().offer(again));
321
+ assert.equal((await r.serve()).spoolId, backlog[0].id);
322
+ assert.equal(r.row('counter', backlog[0].id).result.version, 1);
323
+ assert.equal(r.row('counter', backlog[0].id).reviewSchedule.slot, 'backlog');
324
+ assert.equal(r.row('counter', backlog[0].id).disposition, 'reviewed_and_received');
325
+ assert.deepEqual(archive.getReviewScheduleStats(),
326
+ { freshnessMs: LIVE_BOUND_MS, pending: 39, selected: 42, reviewed: 3, shed: 0, expired: 0, backlog: 39 });
327
+ // Restart: the rest is still backlog, still pending, still offered oldest first.
328
+ r.restartSpool();
329
+ const reopened = r.open('counter');
330
+ assert.equal(reopened.getReviewScheduleStats().backlog, 39);
331
+ assert.equal(reopened.pendingBacklogCandidate().retainedId, backlog[1].id);
332
+ } finally { r.cleanup(); }
333
+ });
334
+
335
+ test('a backlog frame whose review keeps getting cut waits for restart instead of holding the slot', async () => {
336
+ const { ReviewDeadlineExceededError } = take('continuousReview');
337
+ const cutting = { getEndpoint: () => ENDPOINT,
338
+ async reviewCandidate(req) { throw new ReviewDeadlineExceededError(req.reviewDeadlineAtMs); },
339
+ async analyze() { throw Error('No upload expected'); } };
340
+ const r = rig([], { inner: cutting });
341
+ try {
342
+ r.open('counter', { realtimeReview: undefined });
343
+ r.state.now -= 86400000;
344
+ const first = r.capture('counter'); r.state.now += 1000; const second = r.capture('counter');
345
+ r.state.now = Date.parse('2026-11-03T15:00:00Z');
346
+ r.restartSpool();
347
+ const archive = r.open('counter');
348
+ for (let attempt = 0; attempt < BACKLOG_MAX_STARTS; attempt++) {
349
+ const c = archive.pendingBacklogCandidate();
350
+ assert.equal(c.retainedId, first.id);
351
+ archive.offered(c, r.spool().offer(c));
352
+ const taken = r.spool().take(undefined, 'review');
353
+ // The model call starts and is cut at its budget; the manager retries the copy.
354
+ await assert.rejects(archive.reviewCandidate({ jpeg: taken.jpeg, capturedAt: taken.enqueuedAtMs,
355
+ evidenceId: taken.spoolId, reviewWindowMs: REVIEW_WINDOW_MS, reviewContext: taken.reviewContext,
356
+ reviewDeadlineAtMs: taken.reviewDeadlineAtMs, checkpointAnalysis() {} }), ReviewDeadlineExceededError);
357
+ r.spool().retry(taken);
358
+ r.state.now += BACKLOG_REVIEW_BUDGET_MS + 1;
359
+ r.spool().expire(); // its budget passed: the queue drops the copy
360
+ }
361
+ // Two cut starts: the next historical original goes instead; the first stays data.
362
+ assert.equal(archive.pendingBacklogCandidate().retainedId, second.id);
363
+ assert.equal(r.row('counter', first.id).disposition, 'pending_review');
304
364
  } finally { r.cleanup(); }
305
365
  });
306
366
 
@@ -0,0 +1,239 @@
1
+ 'use strict';
2
+ // The Texas upgrade, at its real size: five cameras each holding ~100k selected
3
+ // originals an older capture-order release never reviewed (88k/89k/100k/7.4k on
4
+ // 2026-11-07), on the actual website admission archive and the actual durable
5
+ // spool, with a simulated clock. Asserts what starved 0.2.206 cannot recur:
6
+ // a pump stays under 50 ms at p99, live reviews start within 10 s at p90, no
7
+ // schedule decision costs an fsync, the backlog stays on disk unrewritten, and
8
+ // it is reviewed only while the lane is idle.
9
+ //
10
+ // RETAINED_BACKLOG_PER_CAMERA (default 100000) and RETAINED_BACKLOG_DIR
11
+ // (default the OS temp dir) let a laptop run it smaller or on a RAM disk.
12
+ const { test } = require('node:test');
13
+ const assert = require('node:assert/strict');
14
+ const fs = require('node:fs'), os = require('node:os'), path = require('node:path'), crypto = require('node:crypto');
15
+ const { WebsiteAdmissionCaptureClient } = require('../WebsiteAdmissionCaptureClient.cjs');
16
+ const { DurableVlmCandidateSpool } = require('../../dist/DurableVlmCandidateSpool');
17
+ const { DECISION_LOG } = require('../RetainedCaptureClient.cjs');
18
+
19
+ const sha = bytes => crypto.createHash('sha256').update(bytes).digest('hex');
20
+ const PER_CAMERA = Number(process.env.RETAINED_BACKLOG_PER_CAMERA || 100000);
21
+ const CAMERAS = ['cam20', 'cam22', 'cam23', 'cam24', 'cam3'];
22
+ const LIVE_BOUND_MS = 180000, REVIEW_WINDOW_MS = 150000, REVIEW_MS = 1000, CAPTURE_MS = 500;
23
+ const ENDPOINT = 'http://127.0.0.1:18791/v2/earner/audience-analyze';
24
+ const UPGRADE_AT = Date.parse('2026-11-07T06:37:00Z');
25
+ const grouping = { mode: 'shadow', separateProfileWork: true, pixelDelta: 12, minChangedPixels: 12, quietIntervalMs: 10000, followUpMs: 5000 };
26
+ const jpegFixture = fs.readFileSync(path.join(__dirname, '../../src/__tests__/fixtures/cctv-cstore-empty.jpg'));
27
+ let tag = 0;
28
+ function original() {
29
+ const comment = Buffer.from('upgrade-backlog-original-' + ++tag);
30
+ const header = Buffer.alloc(4); header.writeUInt16BE(0xfffe); header.writeUInt16BE(comment.length + 2, 2);
31
+ return Buffer.concat([jpegFixture.subarray(0, 2), header, comment, jpegFixture.subarray(2)]);
32
+ }
33
+ const context = camera => ({ version: 1, profileState: 'active', camera,
34
+ prompt: 'Review only the captured website fields in their assigned camera areas.',
35
+ schema: { type: 'object', properties: { person_present: { type: 'boolean' } }, required: ['person_present'] },
36
+ retainedFieldContract: { version: 1, required: [{ field: 'person_present', type: 'boolean' }] },
37
+ producerFields: [], regions: [], operatingPoints: [], absenceWatchedFields: [] });
38
+ const archiveOptions = (camera, now) => ({ cameraId: camera, pairedCameraId: 'paired-' + camera, intervalMs: 500,
39
+ selectionMode: 'state-change-v1', groupingPolicy: grouping, archiveRetentionMs: 600000, offerWindow: 16,
40
+ realtimeReview: { freshnessMs: LIVE_BOUND_MS, now }, admissionNowMs: now });
41
+
42
+ // What an older release leaves: selected originals, oldest first, unanswered.
43
+ // They share one JPEG so the seed stays small on disk; ids are derived exactly
44
+ // as the archive derives them.
45
+ function seedBacklog(directory, camera, count, oldestAt) {
46
+ const jpeg = original(), digest = sha(jpeg);
47
+ fs.mkdirSync(path.join(directory, 'images'), { recursive: true });
48
+ fs.writeFileSync(path.join(directory, 'images', digest + '.jpg'), jpeg);
49
+ const reviewContext = context(camera), ids = [];
50
+ for (let i = 0; i < count; i++) {
51
+ const capturedAt = oldestAt + i * 5000;
52
+ const id = sha(Buffer.from(JSON.stringify([camera, capturedAt, digest, reviewContext]))).slice(0, 32);
53
+ fs.writeFileSync(path.join(directory, id + '.json'), JSON.stringify({ version: 1, id, cameraId: camera, capturedAt,
54
+ imageSha256: digest, imageBytes: jpeg.length, selected: true, reviewStage: 'active', disposition: 'pending_review',
55
+ selectionReason: 'missing_or_invalid_grouping', previousCaptureId: null, previousSelectedId: null,
56
+ candidate: { name: camera, enqueuedAtMs: capturedAt, captureMode: 'periodic', reason: 'motion', signature: null,
57
+ reviewKind: 'event', reviewContext }, result: null, acknowledged: false }));
58
+ ids.push(id);
59
+ }
60
+ return { ids, jpeg, oldestAt };
61
+ }
62
+
63
+ test('an upgrade onto ~100k-frame backlogs on five cameras keeps the pump and live review fast', { timeout: 30 * 60 * 1000 }, async t => {
64
+ const root = fs.mkdtempSync(path.join(process.env.RETAINED_BACKLOG_DIR || os.tmpdir(), 'upgrade-backlog-'));
65
+ t.after(() => fs.rmSync(root, { recursive: true, force: true }));
66
+ const state = { now: UPGRADE_AT - 86400000 };
67
+ const clock = () => state.now;
68
+ const reviews = [], uploads = [];
69
+ let lane = null; // the one model slot: { item, doneAt, startedAt }
70
+ const inner = { getEndpoint: () => ENDPOINT, captureReviewContext: () => null,
71
+ async reviewCandidate(req) {
72
+ if (!req.cachedAnalysis) reviews.push({ name: req.reviewContext.camera, evidenceId: req.evidenceId,
73
+ capturedAt: req.capturedAt, startedAt: lane.startedAt, slot: req.reviewSchedule?.slot ?? null });
74
+ req.checkpointAnalysis(req.cachedAnalysis ?? { version: 1, evidenceSha256: sha(req.jpeg), reviewedAtMs: state.now,
75
+ structured: { person_present: true } });
76
+ },
77
+ async analyze(req) {
78
+ uploads.push({ evidenceId: req.evidenceId, slot: req.reviewSchedule?.slot ?? null });
79
+ return { ok: true, body: { accepted: true, evidenceId: req.evidenceId, evidenceReview: { version: 1, capturedAtMs: req.capturedAt } } };
80
+ } };
81
+
82
+ // 1. The old release's disk: the backlog, plus its 16 queued capture-order copies per camera.
83
+ const seeded = new Map();
84
+ const spoolOptions = { directory: path.join(root, 'spool'), now: clock, reviewWindowMs: REVIEW_WINDOW_MS,
85
+ retentionMs: 86400000, priorityScheduling: true, preserveArchivedPending: true, maxPerFeed: 128, maxFrames: 512,
86
+ maxBytes: 512 * 1024 ** 2 };
87
+ let spool = new DurableVlmCandidateSpool(spoolOptions); spool.startRun();
88
+ for (const camera of CAMERAS) {
89
+ const directory = path.join(root, 'archive-' + camera);
90
+ // The archive's own POLICY.json, as the older release wrote it.
91
+ void new WebsiteAdmissionCaptureClient(inner, directory, { ...archiveOptions(camera, clock), realtimeReview: undefined });
92
+ const { ids, jpeg, oldestAt } = seedBacklog(directory, camera, PER_CAMERA, UPGRADE_AT - 30 * 86400000);
93
+ seeded.set(camera, ids);
94
+ // Its capture-order queue: the 16 oldest selections, as offered then.
95
+ for (let i = 0; i < 16; i++) spool.offer({ name: camera, jpeg, enqueuedAtMs: oldestAt + i * 5000,
96
+ captureMode: 'periodic', reason: 'motion', signature: null, reviewKind: 'event', retainedId: ids[i],
97
+ reviewContext: { ...context(camera), retainedCapture: { version: 1, id: ids[i], kind: 'retained_single_capture' } } });
98
+ }
99
+ assert.equal(spool.getStats().buffered, 16 * CAMERAS.length);
100
+ const sample = [...seeded.values()].map(ids => ids[Math.floor(ids.length / 2)]);
101
+ const sampleBytes = sample.map((id, i) => fs.readFileSync(path.join(root, 'archive-' + CAMERAS[i], id + '.json'), 'utf8'));
102
+
103
+ // 2. The upgrade: same disk, this release.
104
+ state.now = UPGRADE_AT;
105
+ spool = new DurableVlmCandidateSpool(spoolOptions); spool.startRun();
106
+ const archives = new Map(), loadMs = [];
107
+ for (const camera of CAMERAS) {
108
+ const started = process.hrtime.bigint();
109
+ const archive = new WebsiteAdmissionCaptureClient(inner, path.join(root, 'archive-' + camera), archiveOptions(camera, clock));
110
+ loadMs.push(Number(process.hrtime.bigint() - started) / 1e6);
111
+ archive.attachReviewQueue(spool); archives.set(camera, archive);
112
+ assert.equal(archive.getReviewScheduleStats().backlog, PER_CAMERA);
113
+ }
114
+ const offer = (archive, c) => { const result = spool.offer(c); archive.offered(c, result); return result; };
115
+
116
+ // The manager's pump: changed archives only, every archive once a second;
117
+ // then the backlog, only when no live frame waits and the lane is idle.
118
+ const dirty = new Set(CAMERAS); let sweepAt = 0, backlogHeld = null;
119
+ // Inside a pump, the archive may fsync only an admission selection (durable
120
+ // before its offer, one per new capture); the spool persists what it is
121
+ // offered. A retirement rewriting its record (`<id>.json.tmp`) is the
122
+ // 0.2.206 regression and must not happen.
123
+ const pumpMs = [], realFsync = fs.fsyncSync, realOpen = fs.openSync, opened = new Map();
124
+ let recordRewrites = 0, admissionFsyncs = 0;
125
+ const pump = () => {
126
+ fs.openSync = (file, ...rest) => { const fd = realOpen(file, ...rest); opened.set(fd, String(file)); return fd; };
127
+ fs.fsyncSync = fd => {
128
+ const file = opened.get(fd) ?? '';
129
+ if (file.startsWith(path.join(root, 'archive-')) && /[a-f0-9]{32}\.json\.tmp$/.test(file)) recordRewrites++;
130
+ if (file.endsWith('.admission-tmp')) admissionFsyncs++;
131
+ return realFsync(fd);
132
+ };
133
+ const started = process.hrtime.bigint();
134
+ try {
135
+ const sweep = state.now >= sweepAt; if (sweep) sweepAt = state.now + 1000;
136
+ for (const [camera, archive] of archives) {
137
+ if (!sweep && !dirty.has(camera)) continue;
138
+ dirty.delete(camera);
139
+ for (const c of archive.pendingOrderedCandidates()) assert.notEqual(offer(archive, c), 'rejected');
140
+ }
141
+ spool.expire();
142
+ const live = spool.peek(undefined, 'review', backlogHeld ? item => item.spoolId !== backlogHeld.id : undefined);
143
+ if (backlogHeld) {
144
+ const where = spool.holds(backlogHeld.id);
145
+ if (where === null) backlogHeld = null;
146
+ else if (where === 'queued' && live && spool.withdraw(backlogHeld.id) === 'withdrawn') backlogHeld = null;
147
+ }
148
+ if (!backlogHeld && !live && !lane) {
149
+ for (const [camera, archive] of archives) {
150
+ const c = archive.pendingBacklogCandidate();
151
+ if (!c) continue;
152
+ assert.equal(offer(archive, c), 'buffered');
153
+ backlogHeld = { camera, id: c.retainedId };
154
+ break;
155
+ }
156
+ }
157
+ } finally {
158
+ pumpMs.push(Number(process.hrtime.bigint() - started) / 1e6);
159
+ fs.fsyncSync = realFsync; fs.openSync = realOpen; opened.clear();
160
+ }
161
+ };
162
+ const request = (item, stage) => ({ jpeg: item.jpeg, capturedAt: item.enqueuedAtMs, evidenceId: item.spoolId,
163
+ reviewWindowMs: REVIEW_WINDOW_MS, reviewContext: item.reviewContext, cachedAnalysis: item.cachedAnalysis,
164
+ ...(stage === 'review' && item.reviewDeadlineAtMs !== undefined ? { reviewDeadlineAtMs: item.reviewDeadlineAtMs } : {}),
165
+ checkpointAnalysis: saved => spool.checkpoint(item, saved) });
166
+ // The model lane: one review at a time, REVIEW_MS each, uploaded when done.
167
+ const serveLane = async () => {
168
+ if (lane && state.now >= lane.doneAt) {
169
+ const archive = archives.get(lane.item.name);
170
+ await archive.reviewCandidate(request(lane.item, 'review'));
171
+ spool.readyForDelivery(lane.item);
172
+ const delivery = spool.take(undefined, 'delivery');
173
+ await archive.analyze(request(delivery, 'delivery'));
174
+ spool.complete(delivery);
175
+ dirty.add(lane.item.name);
176
+ lane = null;
177
+ }
178
+ if (!lane) {
179
+ const item = spool.take(undefined, 'review');
180
+ if (item) lane = { item, doneAt: state.now + REVIEW_MS, startedAt: state.now };
181
+ }
182
+ };
183
+
184
+ // 3. A busy store hour: every camera captures every 500 ms and every capture is due.
185
+ const live = [];
186
+ const runFor = async (ms, capturing) => {
187
+ for (const end = state.now + ms; state.now < end; state.now += 50) {
188
+ if (capturing && state.now % CAPTURE_MS === 0) {
189
+ for (const [camera, archive] of archives) {
190
+ archive.retainOrderedCapture({ name: camera, enqueuedAtMs: state.now, jpeg: original(), captureMode: 'periodic',
191
+ reason: 'motion', signature: null, reviewKind: 'event', reviewContext: context(camera) });
192
+ dirty.add(camera);
193
+ }
194
+ }
195
+ pump();
196
+ await serveLane();
197
+ }
198
+ };
199
+ await runFor(10 * 60 * 1000, true);
200
+ const busyReviews = reviews.filter(r => r.slot !== 'backlog');
201
+ const startAges = busyReviews.map(r => r.startedAt - r.capturedAt).sort((a, b) => a - b);
202
+ live.push(...startAges);
203
+ // 4. The store goes quiet: the lane idles, and only then is history reviewed.
204
+ const beforeQuiet = reviews.length;
205
+ await runFor(2 * 60 * 1000, false);
206
+ const historical = reviews.slice(beforeQuiet).filter(r => r.slot === 'backlog');
207
+ // 5. Activity resumes while a historical review may hold the slot.
208
+ const resumeFrom = reviews.length;
209
+ await runFor(60 * 1000, true);
210
+ const resumed = reviews.slice(resumeFrom).filter(r => r.slot !== 'backlog').map(r => r.startedAt - r.capturedAt);
211
+
212
+ const q = (values, p) => { const sorted = [...values].sort((a, b) => a - b); return sorted[Math.min(sorted.length - 1, Math.floor(p * sorted.length))]; };
213
+ t.diagnostic(`load ms per camera: ${loadMs.map(ms => ms.toFixed(0)).join(', ')}`);
214
+ t.diagnostic(`pumps ${pumpMs.length}: p50 ${q(pumpMs, 0.5).toFixed(2)} ms, p99 ${q(pumpMs, 0.99).toFixed(2)} ms, max ${Math.max(...pumpMs).toFixed(2)} ms`);
215
+ t.diagnostic(`live reviews ${live.length}: start age p50 ${q(live, 0.5)} ms, p90 ${q(live, 0.9)} ms; after resume p90 ${q(resumed, 0.9)} ms`);
216
+ t.diagnostic(`historical reviews while idle: ${historical.length}; record rewrites inside pumps: ${recordRewrites}; admission commits: ${admissionFsyncs}`);
217
+ const decisionLines = CAMERAS.map(camera => { try { return fs.readFileSync(path.join(root, 'archive-' + camera, DECISION_LOG), 'utf8').split('\n').filter(Boolean).length; } catch { return 0; } });
218
+ t.diagnostic(`logged retirements per camera: ${decisionLines.join(', ')}`);
219
+
220
+ assert(q(pumpMs, 0.99) < 50, `pump p99 ${q(pumpMs, 0.99)} ms`);
221
+ assert(live.length > 500, 'the busy hour reviewed live work');
222
+ assert(q(live, 0.9) <= 10000, `live start age p90 ${q(live, 0.9)} ms`);
223
+ assert(resumed.length > 0 && q(resumed, 0.9) <= 10000, `resumed start age p90 ${q(resumed, 0.9)} ms`);
224
+ assert.equal(busyReviews.length, beforeQuiet, 'no history while live work waited');
225
+ assert(historical.length > 0, 'an idle lane reviews history');
226
+ assert(historical.every(r => r.capturedAt < UPGRADE_AT), 'historical reviews are backlog frames');
227
+ assert.equal(recordRewrites, 0, 'retirements rewrite no record: they are one append per pump');
228
+ assert(decisionLines.every(lines => lines > 0), 'superseded live frames were retired through the log');
229
+ // The old queued copies left the spool; the originals did not change.
230
+ assert.deepEqual(sample.map((id, i) => fs.readFileSync(path.join(root, 'archive-' + CAMERAS[i], id + '.json'), 'utf8')), sampleBytes);
231
+ for (const [camera, archive] of archives) {
232
+ const stats = archive.getReviewScheduleStats();
233
+ assert.equal(stats.selected, stats.reviewed + stats.shed + stats.expired + stats.pending, camera);
234
+ // History leaves the backlog only by being reviewed; nothing expires or is pruned.
235
+ const reviewedHistory = reviews.filter(r => r.slot === 'backlog' && r.name === camera).length;
236
+ assert.equal(stats.backlog, PER_CAMERA - reviewedHistory, camera);
237
+ assert.equal(stats.expired, 0, camera);
238
+ }
239
+ });
@@ -11,6 +11,7 @@ const { RetainedCaptureClient, RECHECK_ANCHOR_GRACE_MS } = require('../RetainedC
11
11
  const { DurableVlmCandidateSpool } = require('../../dist/DurableVlmCandidateSpool');
12
12
  const admissionApi = require('../../../../../trillboard-api/services/retainedWebsiteReviewAdmission');
13
13
  const timing = require('../../../../../trillboard-api/services/fein/routeReviewTiming');
14
+ const { isHistoricalReview } = require('../../../../../trillboard-api/services/retainedCctvReviewProtocol');
14
15
  const sha = bytes => crypto.createHash('sha256').update(bytes).digest('hex');
15
16
  const clone = value => JSON.parse(JSON.stringify(value));
16
17
  const ENDPOINT = 'http://127.0.0.1:18791/v2/earner/audience-analyze';
@@ -135,16 +136,21 @@ function rig(t, names = ['phone'], { freshnessMs = LIVE_BOUND_MS } = {}) {
135
136
  && receipt?.version === 1 && receipt.capturedAtMs === item.enqueuedAtMs;
136
137
  let decision = null;
137
138
  if (accepted) {
138
- decision = timing.nextReviewTiming(route(item.name), { capturedAtMs: item.enqueuedAtMs,
139
- evidenceId: item.spoolId, matches: item.cachedAnalysis.structured.phone_use,
140
- contextId: 'controlled-' + item.name }, server.get(item.name));
141
- server.set(item.name, decision.state); spool.complete(item);
139
+ // The server stores a backlog review as data and never route-evaluates it.
140
+ if (!isHistoricalReview({ evidenceReview: { schedule: uploads.at(-1).schedule } })) {
141
+ decision = timing.nextReviewTiming(route(item.name), { capturedAtMs: item.enqueuedAtMs,
142
+ evidenceId: item.spoolId, matches: item.cachedAnalysis.structured.phone_use,
143
+ contextId: 'controlled-' + item.name }, server.get(item.name));
144
+ server.set(item.name, decision.state);
145
+ }
146
+ spool.complete(item);
142
147
  } else spool.retryDelivery(item, state.now);
143
148
  return { item, accepted, decision };
144
149
  }
145
150
  async function serve() { pump(); const item = await review(); const delivered = await upload();
146
151
  assert.equal(delivered.accepted, true); return item; }
147
- const row = (name, id) => JSON.parse(fs.readFileSync(archives.get(name).file(id)));
152
+ // The record as a restart would load it: its file plus the archive's decision log.
153
+ const row = (name, id) => archives.get(name).durableRecord(id);
148
154
  function assertOriginal(name, record) {
149
155
  const saved = row(name, record.id);
150
156
  assert.equal(sha(fs.readFileSync(archives.get(name).image(saved))), record.imageSha256);
@@ -395,8 +401,11 @@ test('an unknown legacy context remains a barrier while mixed known realtime off
395
401
  r.state.now = 200000; r.restart();
396
402
  const modern = r.capture('phone', 200000);
397
403
  const offered = r.pump();
398
- assert.equal(r.row('phone', oldKnown.id).disposition, 'expired_unreviewed',
404
+ assert.equal(r.row('phone', oldKnown.id).disposition, 'pending_review',
405
+ 'A known stale realtime original is held as backlog: kept, never rewritten');
406
+ assert(!offered.some(candidate => candidate.retainedId === oldKnown.id),
399
407
  'An ordered fallback cannot turn a known stale realtime original into late model work');
408
+ assert.equal(r.archives.get('phone').getReviewScheduleStats().backlog, 1);
400
409
  const knownOffer = offered.find(candidate => candidate.retainedId === recentKnown.id);
401
410
  assert(knownOffer);
402
411
  assert.equal(knownOffer.reviewDeadlineAtMs, recentKnown.capturedAt + LIVE_BOUND_MS);
@@ -443,7 +452,7 @@ test('bounded admission commits drain deferred originals with conserved unreview
443
452
 
444
453
  // Upgrade trigger: actual old base archives already contain selected/queued
445
454
  // records from several ordinary profiles. These are not unknown/ordered work.
446
- test('upgrade retires aged selected A/B contexts and reviews the fresh current website original now', async t => {
455
+ test('upgrade holds aged selected A/B contexts as backlog and reviews the fresh current website original now', async t => {
447
456
  const r = rig(t), directory = path.join(r.root, 'archive-phone');
448
457
  const legacy = new RetainedCaptureClient(r.clients.get('phone'), directory, {
449
458
  cameraId: 'phone', intervalMs: 500, offerWindow: 16, maxCaptures: 1000,
@@ -466,7 +475,7 @@ test('upgrade retires aged selected A/B contexts and reviews the fresh current w
466
475
  assert.equal(item.spoolId, fresh.id, 'Known A/B selections must not fall back to late capture-order review');
467
476
  assert.equal(item.reviewDeadlineAtMs, fresh.capturedAt + LIVE_BOUND_MS);
468
477
  for (const record of old) {
469
- assert.equal(r.row('phone', record.id).disposition, 'expired_unreviewed');
478
+ assert.equal(r.row('phone', record.id).disposition, 'pending_review');
470
479
  assert.equal(r.row('phone', record.id).result, null);
471
480
  r.assertOriginal('phone', record);
472
481
  }
@@ -474,7 +483,37 @@ test('upgrade retires aged selected A/B contexts and reviews the fresh current w
474
483
  await r.review(item); await r.upload();
475
484
  assert.deepEqual(r.calls.map(call => call.evidenceId), [fresh.id]);
476
485
  assert.deepEqual(r.archives.get('phone').getReviewScheduleStats(),
477
- { freshnessMs: LIVE_BOUND_MS, pending: 0, selected: 5, reviewed: 1, shed: 0, expired: 4 });
486
+ { freshnessMs: LIVE_BOUND_MS, pending: 4, selected: 5, reviewed: 1, shed: 0, expired: 0, backlog: 4 });
487
+ // Idle: the oldest held original is reviewed as history, never as a live frame.
488
+ const historical = r.archives.get('phone').pendingBacklogCandidate();
489
+ assert.equal(historical.retainedId, old[0].id);
490
+ assert.equal(r.spool.offer(historical, r.state.now), 'buffered'); r.archives.get('phone').offered(historical, 'buffered');
491
+ await r.review(); const delivered = await r.upload();
492
+ assert.equal(delivered.item.spoolId, old[0].id);
493
+ assert.equal(r.uploads.at(-1).schedule.slot, 'backlog');
494
+ assert.equal(r.row('phone', old[0].id).disposition, 'reviewed_and_received');
495
+ });
496
+
497
+ test('undecided originals past the bound at upgrade are held, then reviewed as history without moving live admission', async t => {
498
+ const r = rig(t);
499
+ // 0.2.206 archived these awaiting a rule decision it never made in time.
500
+ const stale = [r.capture('phone', 1000), r.capture('phone', 1500)];
501
+ assert(stale.every(record => record.disposition === 'awaiting_rule_decision'));
502
+ r.state.now = 400000; r.restart();
503
+ const archive = r.archives.get('phone');
504
+ assert.equal(archive.deferred.size, 0, 'Held originals are not per-pump admission work');
505
+ assert.equal(archive.getReviewScheduleStats().undecidedBacklog, 2);
506
+ const live = r.capture('phone', 400000); await r.serve();
507
+ assert.deepEqual(r.calls.map(call => call.evidenceId), [live.id]);
508
+ const admissionBefore = clone([...archive.states.values()]);
509
+ const historical = archive.pendingBacklogCandidate();
510
+ assert.equal(historical.retainedId, stale[0].id);
511
+ assert.equal(r.row('phone', stale[0].id).selectionReason, 'historical_backlog');
512
+ assert.equal(r.spool.offer(historical, r.state.now), 'buffered'); archive.offered(historical, 'buffered');
513
+ await r.review(); await r.upload();
514
+ assert.deepEqual(clone([...archive.states.values()]), admissionBefore, 'A historical answer never moves the live wait state');
515
+ assert.equal(r.row('phone', stale[1].id).disposition, 'awaiting_rule_decision');
516
+ assert.equal(archive.getReviewScheduleStats().undecidedBacklog, 1);
478
517
  });
479
518
 
480
519
  test('a fresh known semantic-context change keeps realtime deadlines and immutable original contexts', t => {
@@ -73,6 +73,8 @@ async function createWebsiteManager(input, stateDirectory, deps = {}) {
73
73
  'Stage pipeline is an isolated two-feed mixed-review experiment');
74
74
  const stages = pipeline ? new (require('./ModelStageScheduler.cjs').ModelStageScheduler)() : null;
75
75
  const loops = buildLocalSensingLoops(config, { ...deps, websiteManagedProfiles: websiteManaged,
76
+ // The paired API takes a review without its photo (capabilities `evidenceImage.optional`).
77
+ imagelessReview: feed => capabilities.get(feed.name)?.imagelessReview === true,
76
78
  profileClientFactory: deps.profileClientFactory ?? (feed => require('./pilot-profile-client.cjs').createPilotProfileClient(
77
79
  { apiBaseUrl: config.apiBaseUrl, deviceToken: feed.deviceToken, screenId: feed.screenId,
78
80
  connectorModelGrantScreens:feeds.filter(candidate=>candidate.deviceToken&&candidate.screenId).map(candidate=>String(candidate.screenId)) },
@@ -87,8 +87,14 @@ function requestCapability(url, feed) {
87
87
  // own review window in force.
88
88
  const maxCaptureAgeMs = Number.isSafeInteger(body.maxCaptureAgeMs) && body.maxCaptureAgeMs >= 0
89
89
  ? body.maxCaptureAgeMs : undefined;
90
+ // An API that takes a review without its photo says so
91
+ // (`evidenceImage.optional`); an older one does not, and every
92
+ // review then keeps its photo.
93
+ const imageOptional = body.evidenceImage !== null && typeof body.evidenceImage === 'object'
94
+ && body.evidenceImage.optional === true;
90
95
  finish(null, { cameraId: body.cameraId, protocolVersion: 1,
91
- ...(maxCaptureAgeMs === undefined ? {} : { maxCaptureAgeMs }) });
96
+ ...(maxCaptureAgeMs === undefined ? {} : { maxCaptureAgeMs }),
97
+ ...(imageOptional ? { imagelessReview: true } : {}) });
92
98
  } catch (error) { finish(failure(error.message, 'PILOT_CAPABILITY_CONTRACT')); }
93
99
  });
94
100
  });