@trillboards/edge-sdk 0.2.188 → 0.2.190

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 (45) hide show
  1. package/deploy/windows/apply-update.ps1 +100 -1
  2. package/deploy/windows/ci/test-field-self-update.ps1 +371 -0
  3. package/deploy/windows/ci/test-update-job-boundary.ps1 +207 -0
  4. package/dist/AudienceAnalyzeClient.d.ts +4 -0
  5. package/dist/AudienceAnalyzeClient.d.ts.map +1 -1
  6. package/dist/AudienceAnalyzeClient.js.map +1 -1
  7. package/dist/CloudSensingManager.d.ts +22 -0
  8. package/dist/CloudSensingManager.d.ts.map +1 -1
  9. package/dist/CloudSensingManager.js +31 -0
  10. package/dist/CloudSensingManager.js.map +1 -1
  11. package/dist/DurableVlmCandidateSpool.d.ts +12 -0
  12. package/dist/DurableVlmCandidateSpool.d.ts.map +1 -1
  13. package/dist/DurableVlmCandidateSpool.js +63 -7
  14. package/dist/DurableVlmCandidateSpool.js.map +1 -1
  15. package/dist/EdgeAgent.js +1 -1
  16. package/dist/LiteRtVlmProvider.d.ts +13 -0
  17. package/dist/LiteRtVlmProvider.d.ts.map +1 -1
  18. package/dist/LiteRtVlmProvider.js +26 -1
  19. package/dist/LiteRtVlmProvider.js.map +1 -1
  20. package/dist/VlmCandidateBuffer.d.ts +10 -0
  21. package/dist/VlmCandidateBuffer.d.ts.map +1 -1
  22. package/dist/VlmCandidateBuffer.js.map +1 -1
  23. package/dist/connectorUpdate.d.ts.map +1 -1
  24. package/dist/connectorUpdate.js +4 -2
  25. package/dist/connectorUpdate.js.map +1 -1
  26. package/dist/connectorUpdateApply.d.ts +37 -10
  27. package/dist/connectorUpdateApply.d.ts.map +1 -1
  28. package/dist/connectorUpdateApply.js +63 -17
  29. package/dist/connectorUpdateApply.js.map +1 -1
  30. package/dist/continuousReview.d.ts +22 -0
  31. package/dist/continuousReview.d.ts.map +1 -1
  32. package/dist/continuousReview.js +26 -1
  33. package/dist/continuousReview.js.map +1 -1
  34. package/dist/diagnose.d.ts +1 -1
  35. package/dist/diagnose.js +1 -1
  36. package/dist/localSensing.d.ts.map +1 -1
  37. package/dist/localSensing.js +10 -2
  38. package/dist/localSensing.js.map +1 -1
  39. package/package.json +3 -3
  40. package/retained/ArchiveLifecycle.cjs +9 -2
  41. package/retained/RetainedCaptureClient.cjs +140 -13
  42. package/retained/__tests__/realtime-schedule.test.cjs +337 -0
  43. package/retained/__tests__/runtime.test.cjs +8 -2
  44. package/retained/manager.cjs +8 -0
  45. package/retained/website-api-capability.cjs +7 -1
@@ -0,0 +1,337 @@
1
+ 'use strict';
2
+ // Realtime retained review: latest frame wins per camera, slots served round
3
+ // robin, wait/recheck endpoints reserved, nothing started past the live-alert
4
+ // bound. Real camera JPEGs, the real durable spool, the real server timing rule.
5
+ const { test } = require('node:test');
6
+ const assert = require('node:assert/strict');
7
+ const fs = require('node:fs'), os = require('node:os'), path = require('node:path'), crypto = require('node:crypto');
8
+ const { decode, encode } = require('jpeg-js');
9
+ const { RetainedCaptureClient, RECHECK_ANCHOR_GRACE_MS } = require('../RetainedCaptureClient.cjs');
10
+ const take = name => require(path.join(__dirname, '../../dist', name));
11
+ const { DurableVlmCandidateSpool } = take('DurableVlmCandidateSpool');
12
+ const routeReviewTiming = require(path.resolve(__dirname, '../../../../../trillboard-api/services/fein/routeReviewTiming.js'));
13
+
14
+ const sha = bytes => crypto.createHash('sha256').update(bytes).digest('hex');
15
+ const LIVE_BOUND_MS = 180000, REVIEW_WINDOW_MS = 150000, ENDPOINT = 'http://127.0.0.1:18791/v2/earner/audience-analyze';
16
+ const sources = ['cctv-cstore-empty.jpg', 'cctv-kitchen-people.jpg']
17
+ .map(name => decode(fs.readFileSync(path.join(__dirname, '../../src/__tests__/fixtures', name))));
18
+ let stamp = 0;
19
+ // A distinct original per capture: the real store frame with a tagged corner.
20
+ function original(which = 0) {
21
+ const source = sources[which], data = Buffer.from(source.data), tag = ++stamp;
22
+ for (let y = 0; y < 8; y++) for (let x = 0; x < 8; x++) {
23
+ const i = (y * source.width + x) * 4;
24
+ data[i] = tag * 31 % 255; data[i + 1] = tag * 67 % 255; data[i + 2] = tag * 97 % 255;
25
+ }
26
+ return Buffer.from(encode({ data, width: source.width, height: source.height }, 90).data);
27
+ }
28
+ const reviewContext = camera => ({ version: 1, profileState: 'active', camera,
29
+ schema: { type: 'object', properties: { person_present: { type: 'boolean' } }, required: ['person_present'] },
30
+ prompt: 'Is a person present?', producerFields: [], regions: [], operatingPoints: [], absenceWatchedFields: [] });
31
+
32
+ function rig(names, { freshnessMs = LIVE_BOUND_MS, inner } = {}) {
33
+ const root = fs.mkdtempSync(path.join(os.tmpdir(), 'realtime-schedule-'));
34
+ const state = { now: Date.parse('2026-11-03T15:00:00Z') }, clock = () => state.now;
35
+ const spoolOptions = { directory: path.join(root, 'spool'), now: clock, reviewWindowMs: REVIEW_WINDOW_MS,
36
+ retentionMs: 86400000, priorityScheduling: true, preserveArchivedPending: true, maxPerFeed: 128, maxFrames: 512 };
37
+ const rigState = { spool: new DurableVlmCandidateSpool(spoolOptions) };
38
+ rigState.spool.startRun();
39
+ const reviews = [];
40
+ const native = inner ?? { getEndpoint: () => ENDPOINT,
41
+ async reviewCandidate(req) {
42
+ // A saved answer is re-validated before upload; only a fresh one is a model call.
43
+ if (!req.cachedAnalysis) reviews.push({ camera: req.reviewContext.camera, evidenceId: req.evidenceId,
44
+ capturedAt: req.capturedAt, startedAt: state.now, deadline: req.reviewDeadlineAtMs });
45
+ req.checkpointAnalysis(req.cachedAnalysis ?? { version: 1, evidenceSha256: sha(req.jpeg), structured: { person_present: true } });
46
+ },
47
+ async analyze(req) {
48
+ return { ok: true, body: { accepted: true, evidenceId: req.evidenceId, evidenceReview: { version: 1, capturedAtMs: req.capturedAt } } };
49
+ } };
50
+ const archives = new Map();
51
+ const open = (name, options = {}) => {
52
+ const archive = new RetainedCaptureClient(native, path.join(root, 'archive-' + name), { cameraId: name,
53
+ archiveRetentionMs: 600000, realtimeReview: { freshnessMs, now: clock }, ...options });
54
+ if (archive.realtime) archive.attachReviewQueue(rigState.spool);
55
+ archives.set(name, archive);
56
+ return archive;
57
+ };
58
+ for (const name of names) open(name);
59
+ const capture = (name, which = 0) => {
60
+ const archive = archives.get(name);
61
+ archive.retainOrderedCapture({ name, enqueuedAtMs: state.now, jpeg: original(which), reviewContext: reviewContext(name),
62
+ captureMode: 'periodic', reason: 'motion', signature: null, reviewKind: 'event' });
63
+ return archive.previousCaptureRecord;
64
+ };
65
+ // CloudSensingManager.pumpCandidates: each archive offers, the spool holds.
66
+ const pump = () => { for (const archive of archives.values()) for (const c of archive.pendingOrderedCandidates()) archive.offered(c, rigState.spool.offer(c)); };
67
+ const next = () => { pump(); return rigState.spool.take(undefined, 'review'); };
68
+ // serveCandidate (review slot) + pumpDeliveries (upload), as the manager runs them.
69
+ const request = c => ({ jpeg: c.jpeg, capturedAt: c.enqueuedAtMs, evidenceId: c.spoolId, reviewWindowMs: REVIEW_WINDOW_MS,
70
+ reviewContext: c.reviewContext, ...(c.reviewDeadlineAtMs !== undefined ? { reviewDeadlineAtMs: c.reviewDeadlineAtMs } : {}),
71
+ checkpointAnalysis: result => rigState.spool.checkpoint(c, result) });
72
+ const finish = async c => {
73
+ const archive = archives.get(c.name);
74
+ await archive.reviewCandidate(request(c));
75
+ rigState.spool.readyForDelivery(c);
76
+ const delivery = rigState.spool.take(undefined, 'delivery');
77
+ assert.equal(delivery.spoolId, c.spoolId);
78
+ await archive.analyze({ ...request(delivery), cachedAnalysis: delivery.cachedAnalysis, checkpointAnalysis() {} });
79
+ rigState.spool.complete(delivery);
80
+ return c;
81
+ };
82
+ const serve = async () => { const c = next(); return c ? finish(c) : null; };
83
+ const restartSpool = () => { rigState.spool = new DurableVlmCandidateSpool(spoolOptions); rigState.spool.startRun();
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)));
86
+ return { root, state, rigState, archives, open, capture, pump, next, finish, serve, restartSpool, row, reviews,
87
+ spool: () => rigState.spool, cleanup: () => fs.rmSync(root, { recursive: true, force: true }) };
88
+ }
89
+ // What an admission layer does when it selects a wait/recheck endpoint.
90
+ function markFollowUp(archive, record, followUp) {
91
+ record.followUp = followUp;
92
+ fs.writeFileSync(archive.file(record.id), JSON.stringify(record));
93
+ }
94
+
95
+ test('a newer selection replaces the pending one: the replaced frame is shed, kept on disk, never reviewed', async () => {
96
+ const r = rig(['counter']);
97
+ try {
98
+ const first = r.capture('counter'); r.pump();
99
+ assert.equal(r.spool().getStats().buffered, 1);
100
+ r.state.now += 1000; const newest = r.capture('counter');
101
+ const served = await r.serve();
102
+ assert.equal(served.spoolId, newest.id);
103
+ assert.deepEqual(r.reviews.map(x => x.evidenceId), [newest.id]);
104
+ const shed = r.row('counter', first.id);
105
+ assert.equal(shed.disposition, 'shed_superseded');
106
+ assert.deepEqual(shed.scheduleOutcome, { version: 1, outcome: 'shed', decidedAtMs: r.state.now, slot: 'latest',
107
+ supersededBy: newest.id, supersededByCapturedAtMs: newest.capturedAt });
108
+ assert.equal(sha(fs.readFileSync(r.archives.get('counter').image(shed))), shed.imageSha256);
109
+ assert.equal(r.spool().getStats().withdrawn, 1);
110
+ assert.deepEqual(r.archives.get('counter').getReviewScheduleStats(),
111
+ { freshnessMs: LIVE_BOUND_MS, pending: 0, selected: 2, reviewed: 1, shed: 1, expired: 0 });
112
+ } finally { r.cleanup(); }
113
+ });
114
+
115
+ test('the frame the model is already reviewing is never shed; the newest waits behind it, then runs', async () => {
116
+ const r = rig(['counter']);
117
+ try {
118
+ const running = r.capture('counter'); const inFlight = r.next();
119
+ assert.equal(inFlight.spoolId, running.id);
120
+ r.state.now += 1000; const middle = r.capture('counter');
121
+ r.state.now += 1000; const newest = r.capture('counter');
122
+ r.pump();
123
+ assert.equal(r.row('counter', running.id).disposition, 'pending_review');
124
+ assert.equal(r.row('counter', middle.id).disposition, 'shed_superseded');
125
+ assert.equal(r.spool().take(undefined, 'review'), null); // one review per camera at a time
126
+ assert.equal(r.archives.get('counter').getReviewScheduleStats().pending, 2);
127
+ await r.archives.get('counter').reviewCandidate({ jpeg: inFlight.jpeg, capturedAt: inFlight.enqueuedAtMs,
128
+ evidenceId: inFlight.spoolId, reviewWindowMs: REVIEW_WINDOW_MS, reviewContext: inFlight.reviewContext,
129
+ checkpointAnalysis() {} });
130
+ // Answered and awaiting receipt is reviewed, not pending: selected 3 = reviewed 1 + shed 1 + pending 1.
131
+ assert.deepEqual(r.archives.get('counter').getReviewScheduleStats(),
132
+ { freshnessMs: LIVE_BOUND_MS, pending: 1, selected: 3, reviewed: 1, shed: 1, expired: 0 });
133
+ await r.finish(inFlight);
134
+ assert.equal((await r.serve()).spoolId, newest.id);
135
+ assert.deepEqual(r.reviews.map(x => x.evidenceId), [running.id, newest.id]);
136
+ } finally { r.cleanup(); }
137
+ });
138
+
139
+ test('camera slots are served round robin: a constantly changing camera cannot starve quiet ones', async () => {
140
+ const r = rig(['paint', 'door', 'lot']);
141
+ try {
142
+ let quietDue = r.state.now;
143
+ const served = [];
144
+ for (let review = 0; review < 12; review++) {
145
+ // Ten seconds of capture while the previous ~10 s review ran: the paint
146
+ // counter faces a changing screen and selects twice a second; the others
147
+ // select one quiet check every ten seconds.
148
+ for (let t = 0; t < 10000; t += 500) {
149
+ r.state.now += 500; r.capture('paint');
150
+ if (r.state.now >= quietDue) { r.capture('door', 1); r.capture('lot', 1); quietDue += 10000; }
151
+ }
152
+ const c = r.next();
153
+ served.push({ camera: c.name, ageMs: r.state.now - c.enqueuedAtMs });
154
+ await r.finish(c);
155
+ }
156
+ for (let i = 0; i + 3 <= served.length; i += 3) {
157
+ assert.deepEqual(served.slice(i, i + 3).map(s => s.camera).sort(), ['door', 'lot', 'paint']);
158
+ }
159
+ assert.equal(Math.max(...served.filter(s => s.camera === 'paint').map(s => s.ageMs)), 0); // its newest frame
160
+ assert(Math.max(...served.map(s => s.ageMs)) <= 10000);
161
+ const paint = r.archives.get('paint').getReviewScheduleStats();
162
+ assert.equal(paint.reviewed, 4);
163
+ assert.equal(paint.selected, paint.reviewed + paint.shed + paint.pending);
164
+ assert.equal(paint.expired, 0);
165
+ } finally { r.cleanup(); }
166
+ });
167
+
168
+ test('a wait/recheck endpoint keeps a reserved slot exactly while the server would pair it with its anchor', async () => {
169
+ // The connector mirrors the server rule rather than inventing one.
170
+ assert.equal(RECHECK_ANCHOR_GRACE_MS, routeReviewTiming.RECHECK_ANCHOR_GRACE_MS);
171
+ const policy = { reviewTimingMode: 'wait_recheck', reviewWaitSeconds: 60 };
172
+ const opened = routeReviewTiming.nextReviewTiming(policy, { capturedAtMs: 1000, evidenceId: 'anchor', matches: true, contextId: 'c' });
173
+ const at = ms => routeReviewTiming.nextReviewTiming(policy, { capturedAtMs: 1000 + ms, evidenceId: 'recheck', matches: true, contextId: 'c' }, opened.state);
174
+ assert.equal(at(60000 + RECHECK_ANCHOR_GRACE_MS).eligible, true);
175
+ assert.equal(at(60000 + RECHECK_ANCHOR_GRACE_MS + 1).eligible, false);
176
+
177
+ const r = rig(['phone', 'door']);
178
+ try {
179
+ const phone = r.archives.get('phone');
180
+ const anchor = r.capture('phone'); await r.serve();
181
+ const followUp = { version: 1, routeId: 'rt_phone', anchorCapturedAtMs: anchor.capturedAt, waitMs: 60000 };
182
+ r.state.now = anchor.capturedAt + 60000;
183
+ const recheck = r.capture('phone'); markFollowUp(phone, recheck, followUp);
184
+ r.state.now += 1000; const later = r.capture('phone'); r.capture('door', 1);
185
+ r.pump();
186
+ assert.equal(r.row('phone', recheck.id).disposition, 'pending_review'); // a newer frame cannot take its slot
187
+ const first = r.next();
188
+ assert.equal(first.spoolId, recheck.id); // ahead of the other camera's fresh frame
189
+ assert.equal(first.reviewPriority, 'urgent');
190
+ await r.finish(first);
191
+ assert.deepEqual([(await r.serve()).name, (await r.serve()).spoolId], ['door', later.id]);
192
+ // Past anchor + wait + grace the server starts a new wait instead: an ordinary frame.
193
+ r.state.now = anchor.capturedAt + 60000 + RECHECK_ANCHOR_GRACE_MS + 1;
194
+ const lapsed = r.capture('phone'); markFollowUp(phone, lapsed, followUp);
195
+ r.state.now += 1000; const newer = r.capture('phone'); r.pump();
196
+ assert.equal(r.row('phone', lapsed.id).disposition, 'shed_superseded');
197
+ assert.equal((await r.serve()).spoolId, newer.id);
198
+ } finally { r.cleanup(); }
199
+ });
200
+
201
+ test('nothing starts past the live-alert bound: the queue copy leaves and the archive counts it expired', async () => {
202
+ const r = rig(['lot']);
203
+ try {
204
+ const stale = r.capture('lot'); r.pump();
205
+ assert.equal(r.spool().peek(undefined, 'review').reviewDeadlineAtMs, stale.capturedAt + LIVE_BOUND_MS);
206
+ r.state.now = stale.capturedAt + LIVE_BOUND_MS;
207
+ assert.equal(r.spool().take(undefined, 'review'), null);
208
+ assert.equal(r.spool().getStats().expired, 1);
209
+ r.pump();
210
+ const row = r.row('lot', stale.id);
211
+ assert.equal(row.disposition, 'expired_unreviewed');
212
+ assert.deepEqual(row.scheduleOutcome, { version: 1, outcome: 'expired', decidedAtMs: r.state.now, slot: 'latest', freshnessMs: LIVE_BOUND_MS });
213
+ assert.deepEqual(r.archives.get('lot').pendingOrderedCandidates(), []);
214
+ assert.equal(r.reviews.length, 0);
215
+ assert.deepEqual(r.archives.get('lot').getReviewScheduleStats(),
216
+ { freshnessMs: LIVE_BOUND_MS, pending: 0, selected: 1, reviewed: 0, shed: 0, expired: 1 });
217
+ await assert.rejects(r.archives.get('lot').prepare({ evidenceId: stale.id }), /retired unreviewed/);
218
+ } finally { r.cleanup(); }
219
+ });
220
+
221
+ test('a review cut at its deadline counts as expired, even after a newer frame took the slot', async () => {
222
+ const r = rig(['counter']);
223
+ try {
224
+ const cut = r.capture('counter'); const taken = r.next();
225
+ assert.equal(taken.spoolId, cut.id);
226
+ r.state.now = cut.capturedAt + 170000; const newer = r.capture('counter');
227
+ r.state.now = cut.capturedAt + LIVE_BOUND_MS;
228
+ r.spool().retry(taken); // what the manager does after a ReviewDeadlineExceededError
229
+ r.pump();
230
+ assert.equal(r.row('counter', cut.id).disposition, 'expired_unreviewed');
231
+ assert.equal((await r.serve()).spoolId, newer.id);
232
+ assert.deepEqual(r.archives.get('counter').getReviewScheduleStats(),
233
+ { freshnessMs: LIVE_BOUND_MS, pending: 0, selected: 2, reviewed: 1, shed: 0, expired: 1 });
234
+ } finally { r.cleanup(); }
235
+ });
236
+
237
+ test('a server bound of 0 means no bound: nothing expires and no deadline is stamped', async () => {
238
+ const r = rig(['lot'], { freshnessMs: 0 });
239
+ try {
240
+ const row = r.capture('lot');
241
+ r.state.now += 10 * 86400000;
242
+ const c = r.next();
243
+ assert.equal(c.spoolId, row.id); assert.equal(c.reviewDeadlineAtMs, undefined);
244
+ await r.finish(c);
245
+ assert.equal(r.reviews[0].deadline, undefined);
246
+ } finally { r.cleanup(); }
247
+ });
248
+
249
+ test('restart keeps retired frames retired; lifetime counts survive reclamation and pre-existing lifecycle files', async () => {
250
+ const r = rig(['counter']);
251
+ try {
252
+ for (let i = 0; i < 4; i++) { r.capture('counter'); r.state.now += 1000; }
253
+ await r.serve(); // reviews the newest of four, sheds three
254
+ r.state.now += 1000; const stale = r.capture('counter'); r.pump();
255
+ r.state.now += LIVE_BOUND_MS; r.pump(); // the last selection ages out
256
+ const expected = { freshnessMs: LIVE_BOUND_MS, pending: 0, selected: 5, reviewed: 1, shed: 3, expired: 1 };
257
+ assert.deepEqual(r.archives.get('counter').getReviewScheduleStats(), expected);
258
+ r.restartSpool();
259
+ const reopened = r.open('counter');
260
+ assert.deepEqual(reopened.getReviewScheduleStats(), expected);
261
+ assert.deepEqual(reopened.pendingOrderedCandidates(), []);
262
+ assert.equal(r.row('counter', stale.id).disposition, 'expired_unreviewed');
263
+ // Ordinary retention retires the unreviewed originals; their counts persist.
264
+ r.state.now += 600001;
265
+ for (let i = 0; i < 3; i++) { r.capture('counter'); await r.serve(); r.state.now += 1000; }
266
+ const lifecycle = JSON.parse(fs.readFileSync(path.join(r.root, 'archive-counter', 'ARCHIVE-LIFECYCLE.json')));
267
+ assert.equal(lifecycle.pruned.shed, 3); assert.equal(lifecycle.pruned.expired, 1);
268
+ assert.deepEqual(r.open('counter').getReviewScheduleStats(), { ...expected, selected: 8, reviewed: 4 });
269
+ // An archive written before these counters existed loads with zero retired frames.
270
+ const legacyDir = path.join(r.root, 'archive-legacy');
271
+ fs.mkdirSync(legacyDir, { recursive: true });
272
+ fs.writeFileSync(path.join(legacyDir, 'ARCHIVE-LIFECYCLE.json'), JSON.stringify({ version: 1, pending: null,
273
+ pruned: { captures: 9, selected: 4, reviewed: 4, received: 4, inactive: 0, grouped: 2 } }));
274
+ assert.deepEqual(r.open('legacy').stats().shedUnreviewed, 0);
275
+ assert.equal(r.open('legacy').stats().captures, 9);
276
+ } finally { r.cleanup(); }
277
+ });
278
+
279
+ test('an upgraded archive drops its old oldest-first backlog in bounded steps and reviews the newest frame first', async () => {
280
+ const r = rig([]);
281
+ try {
282
+ // The previous release: capture order, 40 selections a day old, 16 of them queued.
283
+ const legacy = r.open('counter', { realtimeReview: undefined });
284
+ r.state.now -= 86400000;
285
+ const backlog = [];
286
+ for (let i = 0; i < 40; i++) { backlog.push(r.capture('counter')); r.state.now += 1000; }
287
+ for (const c of legacy.pendingOrderedCandidates()) legacy.offered(c, r.spool().offer(c));
288
+ assert.equal(r.spool().getStats().buffered, 16);
289
+ // The upgrade: same disk, new release.
290
+ r.state.now = Date.parse('2026-11-03T15:00:00Z');
291
+ r.restartSpool();
292
+ r.open('counter');
293
+ const fresh = r.capture('counter');
294
+ 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
+ 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
+ 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 });
304
+ } finally { r.cleanup(); }
305
+ });
306
+
307
+ test('shed and expired counts reach the review receipt the server stores; the deadline reaches the model call', async () => {
308
+ const calls = [], uploads = [];
309
+ const local = new (take('localSensing').LocalSensingClient)({
310
+ analyze: async request => { calls.push(request); return { person_present: true }; },
311
+ }, { getEndpoint: () => ENDPOINT,
312
+ analyzePreAnalyzed: async (result, options) => {
313
+ uploads.push({ result, options: JSON.parse(JSON.stringify(options)) });
314
+ return { ok: true, statusCode: 200, body: { accepted: true, evidenceId: options.evidenceId,
315
+ evidenceReview: { version: 1, capturedAtMs: options.capturedAt } } };
316
+ } });
317
+ const r = rig(['counter'], { inner: local });
318
+ try {
319
+ r.capture('counter'); r.state.now += 1000; r.capture('counter'); r.state.now += 1000;
320
+ const reviewed = r.capture('counter');
321
+ r.state.now += 2000;
322
+ const c = r.next();
323
+ assert.equal(c.spoolId, reviewed.id);
324
+ await r.finish(c);
325
+ assert.equal(calls.length, 1);
326
+ assert.equal(calls[0].deadlineAtMs, reviewed.capturedAt + LIVE_BOUND_MS);
327
+ const schedule = uploads[0].options.extra.evidenceReview.schedule;
328
+ assert.deepEqual(schedule, { version: 1, slot: 'latest', freshnessMs: LIVE_BOUND_MS, startedAtMs: r.state.now,
329
+ selected: 3, reviewed: 0, shed: 2, expired: 0 });
330
+ // An upload retry reports the same frozen facts, so the server's payload hash holds.
331
+ await r.archives.get('counter').analyze({ jpeg: c.jpeg, capturedAt: c.enqueuedAtMs, evidenceId: c.spoolId,
332
+ reviewWindowMs: REVIEW_WINDOW_MS, reviewContext: c.reviewContext, cachedAnalysis: r.row('counter', c.spoolId).result,
333
+ checkpointAnalysis() {} });
334
+ assert.deepEqual(uploads[1].options.extra.evidenceReview.schedule, schedule);
335
+ assert.equal(calls.length, 1);
336
+ } finally { r.cleanup(); }
337
+ });
@@ -250,7 +250,7 @@ test('real website factory retains the captured contract and builds one/two slot
250
250
  localProvider: { analyze: () => { throw Error('No model call allowed'); } }, producerOptions: {}, producerInjected: false } })) };
251
251
  require.cache[modules[1].key].exports = { resolveFeeds: config => config.cameras,
252
252
  CloudSensingManager: class {
253
- constructor(options) { this.options = options; this.candidates = { offer: () => 'buffered' };
253
+ constructor(options) { this.options = options; this.candidates = { offer: () => 'buffered', withdraw: () => 'absent' };
254
254
  this.frameGroupers = new Map(options.loops.map(loop => [loop.name, {}])); }
255
255
  async start() { starts++; throw Error('No live manager start allowed'); }
256
256
  } };
@@ -269,6 +269,9 @@ test('real website factory retains the captured contract and builds one/two slot
269
269
  const website = await createWebsiteManager(automatic, path.join(directory, 'website-managed'));
270
270
  assert.equal(website.manager.options.maxConcurrentAnalyses, 1);
271
271
  for (const client of website.clients) {
272
+ // An API that serves no live-alert bound leaves the connector's review window in force.
273
+ assert.equal(client.getReviewScheduleStats().freshnessMs, 150000);
274
+ assert.equal(client.reviewQueue, website.manager.candidates);
272
275
  const actual = client.captureReviewContext();
273
276
  assert.deepEqual(actual.retainedFieldContract, fieldContext.retainedFieldContract);
274
277
  assert.deepEqual(actual.modelSelection, fieldContext.modelSelection);
@@ -316,7 +319,7 @@ test('normal website startup resolves thirteen paired cameras with two active pr
316
319
  capabilities++;
317
320
  if (denied) { res.writeHead(403).end('{}'); return; }
318
321
  res.end(JSON.stringify({ retainedReview: true, protocolVersion: 1, lateEvidenceAccepted: true,
319
- timedModes: ['any', 'wait_recheck'], cameraId, maxBodyBytes: 2 * 1024 * 1024 })); return;
322
+ timedModes: ['any', 'wait_recheck'], cameraId, maxBodyBytes: 2 * 1024 * 1024, maxCaptureAgeMs: 120000 })); return;
320
323
  }
321
324
  if (!url.pathname.endsWith('/sensing-profile')) { res.writeHead(405).end('{}'); return; }
322
325
  profiles++;
@@ -349,6 +352,9 @@ test('normal website startup resolves thirteen paired cameras with two active pr
349
352
  localProviderFactory: () => ({ analyze: () => { models++; throw Error('No inference in startup fixture'); } }) };
350
353
  const runtime = await createWebsiteManager(input, path.join(directory, 'state'), deps);
351
354
  assert.equal(runtime.loops.length, 13); assert.equal(capabilities, 13); assert.equal(profiles, 13);
355
+ // The server's own live-alert bound, not a second connector constant, schedules every camera.
356
+ assert.deepEqual([...new Set(runtime.clients.map(client => client.getReviewScheduleStats().freshnessMs))], [120000]);
357
+ assert.equal(runtime.clients.every(client => client.reviewQueue === runtime.manager.candidates), true);
352
358
  assert.equal(runtime.clients.filter(client => client.isReviewActive()).length, 2);
353
359
  assert.equal(runtime.clients.filter(client => !client.isReviewActive()).length, 11);
354
360
  for (const client of runtime.clients.slice(0, 2)) {
@@ -53,6 +53,11 @@ async function createWebsiteManager(input, stateDirectory, deps = {}) {
53
53
  // Complete every check before constructing cameras/providers. A failed gate
54
54
  // does not start capture, submit historical images, or change account settings.
55
55
  for (const feed of feeds) capabilities.set(feed.name, await (deps.capabilityCheck ?? checkRetainedApi)(base, feed));
56
+ // One live-alert age bound: the value the server suppresses late alerts with
57
+ // (SENSING_LOCAL_MAX_CAPTURE_AGE_MS), or this connector's review window when
58
+ // an older API does not serve it. Realtime reviews never start past it.
59
+ const served = [...capabilities.values()].map(c => c.maxCaptureAgeMs).filter(Number.isSafeInteger);
60
+ const freshnessMs = served.length ? Math.min(...served) : options.reviewWindowMs;
56
61
  fs.mkdirSync(stateDirectory, { recursive: true });
57
62
  const grouping = { mode: 'shadow', separateProfileWork: true, pixelDelta: 12,
58
63
  minChangedPixels: 12, quietIntervalMs: 10000, followUpMs: 1000 };
@@ -128,6 +133,8 @@ async function createWebsiteManager(input, stateDirectory, deps = {}) {
128
133
  maxCaptures: config.pilot.maxCapturesPerCamera, maxBytes: config.pilot.maxBytesPerCamera,
129
134
  archiveRetentionMs: config.pilot.archiveRetentionMs ?? 600000,
130
135
  offerWindow: rule.mode === 'wait_recheck' ? 1 : 16, unclearRetryMs: 2000,
136
+ // Latest frame wins per camera; capture-order contracts keep their window.
137
+ realtimeReview: { freshnessMs },
131
138
  ...(rule.mode==='immediate'?{actorPerceiver:new SelectedActorPerceptionClient(binding)}:{}),
132
139
  });
133
140
  loop.client = client; clients.push(client);
@@ -137,6 +144,7 @@ async function createWebsiteManager(input, stateDirectory, deps = {}) {
137
144
  candidateBuffer: { ...config.cloudSensing.candidateBuffer, diskSpool: {
138
145
  directory: path.join(stateDirectory, 'spool'), maxFrames: 512, maxPerFeed: 128,
139
146
  maxBytes: 512 * 1024 ** 2, preserveArchivedPending: true }, pumpIntervalMs: 50 } });
147
+ for (const client of clients) client.attachReviewQueue(manager.candidates);
140
148
  // The native manager constructs a shadow grouper per feed. Match it to the
141
149
  // exact policy recorded in that feed's durable archive before capture starts.
142
150
  const { FrameGroupingShadow } = take('FrameGroupingShadow');
@@ -82,7 +82,13 @@ function requestCapability(url, feed) {
82
82
  && /^[A-Za-z0-9_-]{1,128}$/.test(body.cameraId)
83
83
  && body.maxBodyBytes === 2 * 1024 * 1024, 'Unsupported pilot API capability');
84
84
  assert(String(feed.screenId) === body.cameraId, 'Paired camera identity differs');
85
- finish(null, { cameraId: body.cameraId, protocolVersion: 1 });
85
+ // The server's live-alert age bound (SENSING_LOCAL_MAX_CAPTURE_AGE_MS;
86
+ // 0 = none). Absent from an older API, which leaves the connector's
87
+ // own review window in force.
88
+ const maxCaptureAgeMs = Number.isSafeInteger(body.maxCaptureAgeMs) && body.maxCaptureAgeMs >= 0
89
+ ? body.maxCaptureAgeMs : undefined;
90
+ finish(null, { cameraId: body.cameraId, protocolVersion: 1,
91
+ ...(maxCaptureAgeMs === undefined ? {} : { maxCaptureAgeMs }) });
86
92
  } catch (error) { finish(failure(error.message, 'PILOT_CAPABILITY_CONTRACT')); }
87
93
  });
88
94
  });