@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.
- package/deploy/windows/apply-update.ps1 +100 -1
- package/deploy/windows/ci/test-field-self-update.ps1 +371 -0
- package/deploy/windows/ci/test-update-job-boundary.ps1 +207 -0
- package/dist/AudienceAnalyzeClient.d.ts +4 -0
- package/dist/AudienceAnalyzeClient.d.ts.map +1 -1
- package/dist/AudienceAnalyzeClient.js.map +1 -1
- package/dist/CloudSensingManager.d.ts +22 -0
- package/dist/CloudSensingManager.d.ts.map +1 -1
- package/dist/CloudSensingManager.js +31 -0
- package/dist/CloudSensingManager.js.map +1 -1
- package/dist/DurableVlmCandidateSpool.d.ts +12 -0
- package/dist/DurableVlmCandidateSpool.d.ts.map +1 -1
- package/dist/DurableVlmCandidateSpool.js +63 -7
- package/dist/DurableVlmCandidateSpool.js.map +1 -1
- package/dist/EdgeAgent.js +1 -1
- package/dist/LiteRtVlmProvider.d.ts +13 -0
- package/dist/LiteRtVlmProvider.d.ts.map +1 -1
- package/dist/LiteRtVlmProvider.js +26 -1
- package/dist/LiteRtVlmProvider.js.map +1 -1
- package/dist/VlmCandidateBuffer.d.ts +10 -0
- package/dist/VlmCandidateBuffer.d.ts.map +1 -1
- package/dist/VlmCandidateBuffer.js.map +1 -1
- package/dist/connectorUpdate.d.ts.map +1 -1
- package/dist/connectorUpdate.js +4 -2
- package/dist/connectorUpdate.js.map +1 -1
- package/dist/connectorUpdateApply.d.ts +37 -10
- package/dist/connectorUpdateApply.d.ts.map +1 -1
- package/dist/connectorUpdateApply.js +63 -17
- package/dist/connectorUpdateApply.js.map +1 -1
- package/dist/continuousReview.d.ts +22 -0
- package/dist/continuousReview.d.ts.map +1 -1
- package/dist/continuousReview.js +26 -1
- package/dist/continuousReview.js.map +1 -1
- package/dist/diagnose.d.ts +1 -1
- package/dist/diagnose.js +1 -1
- package/dist/localSensing.d.ts.map +1 -1
- package/dist/localSensing.js +10 -2
- package/dist/localSensing.js.map +1 -1
- package/package.json +3 -3
- package/retained/ArchiveLifecycle.cjs +9 -2
- package/retained/RetainedCaptureClient.cjs +140 -13
- package/retained/__tests__/realtime-schedule.test.cjs +337 -0
- package/retained/__tests__/runtime.test.cjs +8 -2
- package/retained/manager.cjs +8 -0
- 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)) {
|
package/retained/manager.cjs
CHANGED
|
@@ -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
|
-
|
|
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
|
});
|