@trillboards/edge-sdk 0.2.196 → 0.2.200

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 (60) hide show
  1. package/deploy/detector/pyproject.toml +1 -1
  2. package/deploy/detector/tests/test_colors_v2.py +79 -0
  3. package/deploy/detector/tests/test_detection_colors_wire.py +25 -0
  4. package/deploy/detector/tests/test_held_phone_customer_packaging.py +102 -0
  5. package/deploy/detector/trillboards_detector/_version.py +2 -2
  6. package/deploy/detector/trillboards_detector/colors.py +30 -11
  7. package/deploy/detector/trillboards_detector/server.py +1 -1
  8. package/deploy/litertlm/test_attention_token_budget.py +57 -0
  9. package/deploy/litertlm/trillboards_litertlm_shim.py +96 -1
  10. package/deploy/macos/build-macos-pkg.sh +14 -2
  11. package/deploy/windows/build-windows.ps1 +12 -2
  12. package/deploy/windows/ci/test-published-install.ps1 +167 -8
  13. package/deploy/windows/setup-detector.ps1 +4 -1
  14. package/dist/DetectionColors.d.ts +11 -4
  15. package/dist/DetectionColors.d.ts.map +1 -1
  16. package/dist/DetectionColors.js +5 -2
  17. package/dist/DetectionColors.js.map +1 -1
  18. package/dist/DetectorFields.d.ts +138 -4
  19. package/dist/DetectorFields.d.ts.map +1 -1
  20. package/dist/DetectorFields.js +101 -11
  21. package/dist/DetectorFields.js.map +1 -1
  22. package/dist/EdgeAgent.js +1 -1
  23. package/dist/LiteRtVlmProvider.d.ts.map +1 -1
  24. package/dist/LiteRtVlmProvider.js +10 -1
  25. package/dist/LiteRtVlmProvider.js.map +1 -1
  26. package/dist/PhoneEmbeddingClassifier.d.ts +28 -0
  27. package/dist/PhoneEmbeddingClassifier.d.ts.map +1 -0
  28. package/dist/PhoneEmbeddingClassifier.js +40 -0
  29. package/dist/PhoneEmbeddingClassifier.js.map +1 -0
  30. package/dist/RetainedFieldContract.d.ts +9 -1
  31. package/dist/RetainedFieldContract.d.ts.map +1 -1
  32. package/dist/RetainedFieldContract.js +19 -3
  33. package/dist/RetainedFieldContract.js.map +1 -1
  34. package/dist/ScopedVlmReview.d.ts +6 -2
  35. package/dist/ScopedVlmReview.d.ts.map +1 -1
  36. package/dist/ScopedVlmReview.js +55 -5
  37. package/dist/ScopedVlmReview.js.map +1 -1
  38. package/dist/SensingProfileClient.d.ts +6 -0
  39. package/dist/SensingProfileClient.d.ts.map +1 -1
  40. package/dist/SensingProfileClient.js +7 -0
  41. package/dist/SensingProfileClient.js.map +1 -1
  42. package/dist/diagnose.d.ts +1 -1
  43. package/dist/diagnose.js +1 -1
  44. package/dist/localSensing.d.ts +5 -2
  45. package/dist/localSensing.d.ts.map +1 -1
  46. package/dist/localSensing.js +56 -8
  47. package/dist/localSensing.js.map +1 -1
  48. package/package.json +3 -3
  49. package/retained/ProfileAuthorityClient.cjs +1 -1
  50. package/retained/RetainedCaptureClient.cjs +2 -1
  51. package/retained/WebsiteAdmissionCaptureClient.cjs +478 -0
  52. package/retained/WebsiteAdmissionState.cjs +75 -0
  53. package/retained/__tests__/actor-perception.test.cjs +1 -1
  54. package/retained/__tests__/actor-window.test.cjs +1 -1
  55. package/retained/__tests__/archive-lifecycle.test.cjs +1 -1
  56. package/retained/__tests__/runtime.test.cjs +30 -2
  57. package/retained/__tests__/website-admission-realtime.test.cjs +503 -0
  58. package/retained/__tests__/website-admission.test.cjs +806 -0
  59. package/retained/manager.cjs +4 -1
  60. package/retained/pilot-profile-client.cjs +2 -1
@@ -0,0 +1,503 @@
1
+ 'use strict';
2
+ // Actual WebsiteAdmission producer + actual durable spool + actual server timer.
3
+ // Only inference answers and receiver responses are controlled. No models,
4
+ // sockets, camera opens or services run. JPEG COM tags distinguish durable byte
5
+ // identities without claiming a pixel change or an extra model observation.
6
+ const { test } = require('node:test');
7
+ const assert = require('node:assert/strict');
8
+ const fs = require('node:fs'), os = require('node:os'), path = require('node:path'), crypto = require('node:crypto');
9
+ const { WebsiteAdmissionCaptureClient, readAdmission } = require('../WebsiteAdmissionCaptureClient.cjs');
10
+ const { RetainedCaptureClient, RECHECK_ANCHOR_GRACE_MS } = require('../RetainedCaptureClient.cjs');
11
+ const { DurableVlmCandidateSpool } = require('../../dist/DurableVlmCandidateSpool');
12
+ const admissionApi = require('../../../../../trillboard-api/services/retainedWebsiteReviewAdmission');
13
+ const timing = require('../../../../../trillboard-api/services/fein/routeReviewTiming');
14
+ const sha = bytes => crypto.createHash('sha256').update(bytes).digest('hex');
15
+ const clone = value => JSON.parse(JSON.stringify(value));
16
+ const ENDPOINT = 'http://127.0.0.1:18791/v2/earner/audience-analyze';
17
+ const LIVE_BOUND_MS = 180000, REVIEW_WINDOW_MS = 150000;
18
+ const sourceJpeg = fs.readFileSync(path.join(__dirname, '../../src/__tests__/fixtures/cctv-cstore-empty.jpg'));
19
+ assert.equal(sourceJpeg.readUInt16BE(0), 0xffd8);
20
+ let tag = 0;
21
+ function original() {
22
+ const comment = Buffer.from('controlled-website-realtime-original-' + ++tag);
23
+ const header = Buffer.alloc(4); header.writeUInt16BE(0xfffe); header.writeUInt16BE(comment.length + 2, 2);
24
+ return Buffer.concat([sourceJpeg.subarray(0, 2), header, comment, sourceJpeg.subarray(2)]);
25
+ }
26
+ function route(name) {
27
+ return { routeId: 'route-' + name, enabled: true, profileName: 'Synthetic phone ' + name, mode: 'threshold',
28
+ condition: { field: 'phone_use', op: 'eq', value: true }, reviewTimingMode: 'wait_recheck', reviewWaitSeconds: 10,
29
+ sustainWindowSeconds: 0, sustainMinSamples: 1, reFirePolicy: 'once_per_episode',
30
+ updatedAt: '2026-11-03T12:00:00.000Z', screenMongoIds: ['paired-' + name] };
31
+ }
32
+ function context(name, at, extra = {}) {
33
+ const websiteReviewAdmission = admissionApi.waitEndpointAdmission({
34
+ screenId: 'paired-' + name, profileId: 'profile-' + name, profileName: route(name).profileName,
35
+ fields: [{ field: 'phone_use', type: 'boolean' }], routes: [route(name)], defaultConfirmSamples: 1,
36
+ issuedAtMs: at, // phoneSearchIntervalMs deliberately omitted: default OFF.
37
+ });
38
+ assert(websiteReviewAdmission);
39
+ assert.equal(websiteReviewAdmission.phoneSearch, undefined);
40
+ const captured = { version: 1, profileState: 'active', camera: name,
41
+ prompt: 'Controlled scheduling fixture; no model evidence.',
42
+ schema: { type: 'object', properties: { phone_use: { type: 'boolean' } }, required: ['phone_use'] },
43
+ retainedFieldContract: { version: 1, required: [{ field: 'phone_use', type: 'boolean' }] },
44
+ producerFields: [], regions: [], operatingPoints: [], absenceWatchedFields: [],
45
+ websiteReviewAdmission, ...extra };
46
+ if (Object.hasOwn(extra, 'websiteReviewAdmission') && extra.websiteReviewAdmission === undefined)
47
+ delete captured.websiteReviewAdmission;
48
+ return captured;
49
+ }
50
+ function rig(t, names = ['phone'], { freshnessMs = LIVE_BOUND_MS } = {}) {
51
+ const root = fs.mkdtempSync(path.join(os.tmpdir(), 'website-admission-realtime-'));
52
+ const state = { now: 1000, answer: true, accepted: true, receiptVersion: 1 };
53
+ const archives = new Map(), clients = new Map(), current = new Map(), server = new Map();
54
+ const calls = [], uploads = [];
55
+ t.after(() => {
56
+ assert.equal(path.dirname(root), path.resolve(os.tmpdir()));
57
+ assert(path.basename(root).startsWith('website-admission-realtime-'));
58
+ fs.rmSync(root, { recursive: true, force: true });
59
+ });
60
+ let spool;
61
+ const spoolOptions = { directory: path.join(root, 'spool'), now: () => state.now,
62
+ reviewWindowMs: REVIEW_WINDOW_MS, retentionMs: 86400000, priorityScheduling: true,
63
+ preserveArchivedPending: true, maxFrames: 512, maxPerFeed: 128, maxBytes: 128 * 1024 ** 2,
64
+ retryInitialMs: 500 };
65
+ function open(name) {
66
+ let client = clients.get(name);
67
+ if (!client) {
68
+ client = {
69
+ getEndpoint: () => ENDPOINT,
70
+ captureReviewContext: () => current.get(name),
71
+ async reviewCandidate(req) {
72
+ if (!req.cachedAnalysis) calls.push({ name, evidenceId: req.evidenceId, capturedAt: req.capturedAt,
73
+ deadline: req.reviewDeadlineAtMs, jpegSha256: sha(req.jpeg) });
74
+ req.checkpointAnalysis(req.cachedAnalysis ?? { version: 1, evidenceSha256: sha(req.jpeg),
75
+ reviewedAtMs: state.now, structured: { phone_use: state.answer } });
76
+ },
77
+ async analyze(req) {
78
+ uploads.push({ name, evidenceId: req.evidenceId, capturedAt: req.capturedAt,
79
+ deadline: req.reviewDeadlineAtMs, schedule: clone(req.reviewSchedule ?? null),
80
+ saved: clone(req.cachedAnalysis) });
81
+ return { ok: state.accepted, body: { accepted: state.accepted, evidenceId: req.evidenceId,
82
+ evidenceReview: { version: state.receiptVersion, capturedAtMs: req.capturedAt } } };
83
+ },
84
+ };
85
+ clients.set(name, client);
86
+ }
87
+ const archive = new WebsiteAdmissionCaptureClient(client, path.join(root, 'archive-' + name), {
88
+ cameraId: name, pairedCameraId: 'paired-' + name, intervalMs: 500, offerWindow: 16,
89
+ maxCaptures: 1000, maxBytes: 128 * 1024 ** 2, archiveRetentionMs: 600000,
90
+ realtimeReview: { freshnessMs, now: () => state.now }, admissionNowMs: () => state.now,
91
+ });
92
+ archive.attachReviewQueue(spool); archives.set(name, archive); return archive;
93
+ }
94
+ function restart() {
95
+ spool = new DurableVlmCandidateSpool(spoolOptions); spool.startRun();
96
+ for (const name of names) open(name);
97
+ }
98
+ restart();
99
+ function capture(name, at, extra = {}) {
100
+ state.now = at;
101
+ const captured = context(name, at, extra); current.set(name, captured);
102
+ const archive = archives.get(name);
103
+ archive.retainOrderedCapture({ name, enqueuedAtMs: at, jpeg: original(), captureMode: 'periodic',
104
+ reason: 'motion', signature: String(at), reviewKind: 'event', reviewContext: captured });
105
+ return archive.previousCaptureRecord;
106
+ }
107
+ function pump() {
108
+ const offered = [];
109
+ for (const archive of archives.values()) for (const candidate of archive.pendingOrderedCandidates()) {
110
+ const result = spool.offer(candidate, state.now);
111
+ assert(['buffered', 'coalesced'].includes(result), 'Actual spool refused a producer offer: ' + result);
112
+ archive.offered(candidate, result); offered.push(candidate);
113
+ }
114
+ return offered;
115
+ }
116
+ function request(item, stage) {
117
+ return { evidenceId: item.spoolId, capturedAt: item.enqueuedAtMs, jpeg: item.jpeg,
118
+ reviewContext: item.reviewContext, cachedAnalysis: item.cachedAnalysis,
119
+ scopedVlmProgress: item.scopedVlmProgress,
120
+ ...(stage === 'review' && item.reviewDeadlineAtMs !== undefined
121
+ ? { reviewDeadlineAtMs: item.reviewDeadlineAtMs } : {}),
122
+ checkpointAnalysis: saved => spool.checkpoint(item, saved),
123
+ checkpointScopedReview: progress => spool.checkpointScopedReview(item, progress) };
124
+ }
125
+ async function review(item = spool.take(undefined, 'review')) {
126
+ assert(item, 'Actual spool must contain review work');
127
+ await archives.get(item.name).reviewCandidate(request(item, 'review'));
128
+ spool.readyForDelivery(item); return item;
129
+ }
130
+ async function upload() {
131
+ const item = spool.take(undefined, 'delivery'); assert(item, 'Actual spool must contain saved delivery work');
132
+ const response = await archives.get(item.name).analyze(request(item, 'delivery'));
133
+ const receipt = response.body?.evidenceReview;
134
+ const accepted = response.ok && response.body?.accepted === true && response.body.evidenceId === item.spoolId
135
+ && receipt?.version === 1 && receipt.capturedAtMs === item.enqueuedAtMs;
136
+ let decision = null;
137
+ 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);
142
+ } else spool.retryDelivery(item, state.now);
143
+ return { item, accepted, decision };
144
+ }
145
+ async function serve() { pump(); const item = await review(); const delivered = await upload();
146
+ assert.equal(delivered.accepted, true); return item; }
147
+ const row = (name, id) => JSON.parse(fs.readFileSync(archives.get(name).file(id)));
148
+ function assertOriginal(name, record) {
149
+ const saved = row(name, record.id);
150
+ assert.equal(sha(fs.readFileSync(archives.get(name).image(saved))), record.imageSha256);
151
+ assert.equal(saved.capturedAt, record.capturedAt);
152
+ assert.deepEqual(saved.candidate.reviewContext, record.candidate.reviewContext);
153
+ }
154
+ return { root, state, archives, clients, calls, uploads, capture, pump, review, upload, serve, restart,
155
+ request, row, assertOriginal, get spool() { return spool; } };
156
+ }
157
+
158
+ test('default-OFF search exposes the newest original beyond both the 16-offer and 32-admission windows', t => {
159
+ const r = rig(t), originals = [];
160
+ for (let i = 0; i < 65; i++) originals.push(r.capture('phone', 1000 + i * 500));
161
+ const latest = originals.at(-1);
162
+ assert.equal(readAdmission(latest.candidate.reviewContext, 'paired-phone', latest.capturedAt).phoneSearch, undefined);
163
+ const offered = r.pump();
164
+ assert.deepEqual(offered.map(c => c.retainedId), [latest.id], 'The producer must expose current work, not the oldest deferred row');
165
+ const item = r.spool.take(undefined, 'review');
166
+ assert.equal(item.spoolId, latest.id);
167
+ assert.equal(item.reviewDeadlineAtMs, latest.capturedAt + LIVE_BOUND_MS, 'No implicit ten-second model cap');
168
+ assert.equal(r.calls.length, 0);
169
+ for (const record of originals) {
170
+ r.assertOriginal('phone', record);
171
+ assert.equal(r.row('phone', record.id).phoneAdmissionDecision, undefined, 'Default-OFF search cannot acquire opt-in provenance');
172
+ }
173
+ });
174
+
175
+ test('a queued unstarted website selection is withdrawn when a newer original takes its slot', t => {
176
+ const r = rig(t), older = r.capture('phone', 1000); r.pump();
177
+ const latest = r.capture('phone', 1500); r.pump();
178
+ assert.equal(r.spool.take(undefined, 'review').spoolId, latest.id);
179
+ assert.equal(r.row('phone', older.id).disposition, 'shed_superseded');
180
+ assert.equal(r.spool.getStats().withdrawn, 1);
181
+ assert.equal(r.calls.length, 0);
182
+ r.assertOriginal('phone', older); r.assertOriginal('phone', latest);
183
+ });
184
+
185
+ test('an unfinished original is not retired and does not block another camera', async t => {
186
+ const r = rig(t, ['phone', 'door']); r.state.answer = false;
187
+ // A true first answer starts the real website wait and legitimately suppresses
188
+ // an interior frame. False isolates queue ownership/fairness from that timer.
189
+ const first = r.capture('phone', 1000); r.pump();
190
+ const taken = r.spool.take(undefined, 'review');
191
+ let release;
192
+ const gate = new Promise(resolve => { release = resolve; });
193
+ const native = r.clients.get('phone').reviewCandidate;
194
+ r.clients.get('phone').reviewCandidate = async req => { await gate; return native(req); };
195
+ const running = r.review(taken);
196
+ try {
197
+ const latest = r.capture('phone', 1500); r.capture('door', 1500); r.pump();
198
+ assert.equal(r.row('phone', first.id).disposition, 'pending_review');
199
+ const other = r.spool.take(undefined, 'review');
200
+ assert.equal(other.name, 'door');
201
+ await r.review(other); await r.upload();
202
+ assert.equal(r.spool.take(undefined, 'review'), null, 'One unfinished model result per camera');
203
+ release(); await running; await r.upload();
204
+ assert.equal((await r.serve()).spoolId, latest.id);
205
+ assert.equal(r.calls.filter(call => call.name === 'phone').length, 2);
206
+ } finally { release(); await running; }
207
+ });
208
+
209
+ test('a saved answer survives rejected receipt, restart and the age bound without another model call', async t => {
210
+ const r = rig(t), first = r.capture('phone', 1000); r.pump(); await r.review();
211
+ const saved = clone(r.row('phone', first.id).result);
212
+ r.state.receiptVersion = 2;
213
+ assert.equal((await r.upload()).accepted, false);
214
+ assert.equal(r.row('phone', first.id).acknowledged, false);
215
+ r.capture('phone', 11000); r.state.now = first.capturedAt + LIVE_BOUND_MS + 1;
216
+ r.restart(); r.pump();
217
+ assert.equal(r.spool.take(undefined, 'review'), null, 'An unaccepted answered anchor remains a delivery dependency');
218
+ r.state.receiptVersion = 1;
219
+ const delivered = await r.upload();
220
+ assert.equal(delivered.item.spoolId, first.id);
221
+ assert.equal(delivered.decision.state.anchorCapturedAtMs, first.capturedAt);
222
+ assert.equal(r.calls.length, 1);
223
+ assert.deepEqual(r.row('phone', first.id).result, saved);
224
+ assert.deepEqual(r.uploads[1].saved, r.uploads[0].saved);
225
+ assert.deepEqual(r.uploads[1].schedule, r.uploads[0].schedule, 'Receipt retries keep the frozen scheduling bytes');
226
+ assert.equal(r.uploads[1].deadline, undefined, 'Delivery of an answered capture has no inference deadline');
227
+ assert.equal(r.row('phone', first.id).disposition, 'reviewed_and_received');
228
+ });
229
+
230
+ test('actual website admission stamps and reserves its due endpoint; server confirms the original ten-second anchor', async t => {
231
+ const r = rig(t), first = r.capture('phone', 1000); await r.serve();
232
+ r.capture('phone', 1500); const due = r.capture('phone', 11000); r.pump();
233
+ const archive = r.archives.get('phone'), reservation = archive.followUpOf(r.row('phone', due.id));
234
+ assert.deepEqual(reservation, { version: 1, routeId: route('phone').routeId, anchorCapturedAtMs: first.capturedAt, waitMs: 10000 },
235
+ 'Urgent priority alone does not reserve the endpoint from latest-frame retirement');
236
+ const later = r.capture('phone', 11500); r.pump();
237
+ assert.equal(r.row('phone', due.id).disposition, 'pending_review');
238
+ const item = r.spool.take(undefined, 'review'); assert.equal(item.spoolId, due.id);
239
+ assert.equal(item.reviewPriority, 'urgent');
240
+ assert.equal(r.row('phone', due.id).ruleSelection.anchors[0].evidenceId, first.id);
241
+ await r.review(item); const delivered = await r.upload();
242
+ assert.equal(delivered.decision.eligible, true);
243
+ assert.equal(delivered.decision.confirmationBasis, 'first_and_follow_up');
244
+ assert.equal(delivered.decision.state.anchorCapturedAtMs, first.capturedAt);
245
+ assert.equal(r.calls.length, 2); r.assertOriginal('phone', later);
246
+ });
247
+
248
+ for (const [offset, reserved] of [[RECHECK_ANCHOR_GRACE_MS, true], [RECHECK_ANCHOR_GRACE_MS + 1, false]]) {
249
+ test('website reservation agrees with server at wait-plus-grace offset ' + offset, async t => {
250
+ assert.equal(RECHECK_ANCHOR_GRACE_MS, timing.RECHECK_ANCHOR_GRACE_MS);
251
+ const r = rig(t), first = r.capture('phone', 1000); await r.serve();
252
+ const endpoint = r.capture('phone', first.capturedAt + 10000 + offset); r.pump();
253
+ const actual = r.archives.get('phone').followUpOf(r.row('phone', endpoint.id));
254
+ assert.equal(!!actual, reserved);
255
+ const item = await r.review(), delivered = await r.upload();
256
+ assert.equal(item.spoolId, endpoint.id);
257
+ assert.equal(item.reviewPriority === 'urgent', reserved);
258
+ assert.equal(delivered.decision.eligible, reserved);
259
+ assert.equal(delivered.decision.state.anchorCapturedAtMs, reserved ? first.capturedAt : endpoint.capturedAt);
260
+ });
261
+ }
262
+
263
+ test('restart refuses an actual stale spool copy after durable website retirement', async t => {
264
+ const r = rig(t), older = r.capture('phone', 1000); r.pump();
265
+ const metadata = fs.readFileSync(path.join(r.root, 'spool', older.id + '.json'));
266
+ const jpeg = fs.readFileSync(path.join(r.root, 'spool', older.id + '.jpg'));
267
+ const latest = r.capture('phone', 1500); r.pump();
268
+ assert.equal(r.row('phone', older.id).disposition, 'shed_superseded');
269
+ // Recreate the exact old queue bytes, modelling an unlink that failed before
270
+ // restart. Do not invent a candidate or change the archive's retirement.
271
+ fs.writeFileSync(path.join(r.root, 'spool', older.id + '.json'), metadata);
272
+ fs.writeFileSync(path.join(r.root, 'spool', older.id + '.jpg'), jpeg);
273
+ r.restart();
274
+ assert.equal(r.archives.get('phone').entries.has(older.id), false);
275
+ const stale = r.spool.take(undefined, 'review'); assert.equal(stale.spoolId, older.id);
276
+ await assert.rejects(r.archives.get('phone').prepare(r.request(stale, 'review')), { code: 'RETAINED_EVIDENCE_RETIRED' });
277
+ assert.equal(r.spool.withdraw(stale.spoolId, { taken: true }), 'withdrawn');
278
+ r.pump();
279
+ assert.equal(r.spool.take(undefined, 'review').spoolId, latest.id);
280
+ assert.equal(r.calls.length, 0);
281
+ r.assertOriginal('phone', older);
282
+ assert.equal(r.archives.get('phone').getReviewScheduleStats().shed, 1);
283
+ });
284
+
285
+ test('three website cameras rotate fairly while one producer accumulates changed originals faster', async t => {
286
+ const r = rig(t, ['paint', 'door', 'lot']); r.state.answer = false;
287
+ const served = [];
288
+ for (let turn = 0; turn < 9; turn++) {
289
+ let latest;
290
+ for (let frame = 0; frame < 3; frame++) latest = r.capture('paint', r.state.now + 500);
291
+ r.capture('door', r.state.now); r.capture('lot', r.state.now);
292
+ const item = await r.serve(); served.push(item.name);
293
+ if (item.name === 'paint') assert.equal(item.spoolId, latest.id);
294
+ }
295
+ for (let turn = 0; turn < served.length; turn += 3)
296
+ assert.deepEqual(served.slice(turn, turn + 3).sort(), ['door', 'lot', 'paint']);
297
+ });
298
+
299
+ const exemptions = {
300
+ temporalReviewContract: { version: 1, cameraId: 'phone', field: 'phone_use', mode: 'any', minObservations: 1,
301
+ durationMs: 0, maxGapMs: 2000, unknownPolicy: 'reset_confirmation_keep_alert_latch' },
302
+ // Presence is deliberately the scheduling boundary, including an unknown
303
+ // future contract: these cases do not claim temporal/sequence validation.
304
+ orderedSequence: { version: 1, schedulingFixture: 'preserve-original-order' },
305
+ orderedCaptureContract: { version: 1, schedulingFixture: 'preserve-original-order' },
306
+ };
307
+ for (const [key, value] of Object.entries(exemptions)) {
308
+ test(key + ' preserves its oldest unresolved original without shedding/deadlines across restart', t => {
309
+ const r = rig(t, ['phone'], { freshnessMs: 1000 });
310
+ const originals = [1000, 1500, 2000].map(at => r.capture('phone', at, { [key]: value }));
311
+ r.state.now = 200000; r.pump();
312
+ const first = r.spool.take(undefined, 'review');
313
+ assert.equal(first.spoolId, originals[0].id);
314
+ assert.equal(first.reviewDeadlineAtMs, undefined);
315
+ assert.equal(r.spool.take(undefined, 'review'), null);
316
+ // Do not invent a temporal decision merely to readyForDelivery(). The
317
+ // unresolved observation is retried/recovered and remains the order barrier.
318
+ r.spool.retry(first); r.state.now += 6000; r.restart(); r.pump();
319
+ const recovered = r.spool.take(undefined, 'review');
320
+ assert.equal(recovered.spoolId, originals[0].id);
321
+ assert.equal(recovered.reviewDeadlineAtMs, undefined);
322
+ assert.equal(r.archives.get('phone').stats().pendingAdmission, 2);
323
+ assert.equal(r.calls.length, 0);
324
+ assert.equal(r.archives.get('phone').stats().reviewed, 0);
325
+ assert.equal(r.archives.get('phone').stats().shedUnreviewed, 0);
326
+ assert.equal(r.archives.get('phone').stats().expiredUnreviewed, 0);
327
+ for (const record of originals) r.assertOriginal('phone', record);
328
+ });
329
+ }
330
+
331
+
332
+ // Queue scheduling does not require permission to omit a website wait window.
333
+ const ordinaryCases = [
334
+ ['immediate boolean without a hint', () => ({ websiteReviewAdmission: undefined })],
335
+ ['ordinary count without a hint', () => ({ websiteReviewAdmission: undefined,
336
+ schema: { type: 'object', properties: { person_count: { type: 'integer' } }, required: ['person_count'] },
337
+ retainedFieldContract: { version: 1, required: [{ field: 'person_count', type: 'number' }] } })],
338
+ ['expired captured hint', () => ({ websiteReviewAdmission: context('phone', 0).websiteReviewAdmission })],
339
+ ['malformed captured hint', () => ({ websiteReviewAdmission: {
340
+ ...context('phone', 0).websiteReviewAdmission, revision: 'f'.repeat(64) } })],
341
+ ];
342
+ for (const [label, extra] of ordinaryCases) {
343
+ test(label + ' still exposes the newest frame without inventing wait/phone authority', t => {
344
+ const r = rig(t), capturedExtra = extra();
345
+ const first = r.capture('phone', 50000, capturedExtra);
346
+ const latest = r.capture('phone', 50500, capturedExtra);
347
+ assert.equal(readAdmission(latest.candidate.reviewContext, 'paired-phone', latest.capturedAt), null);
348
+ r.pump();
349
+ const item = r.spool.take(undefined, 'review');
350
+ assert.equal(item.spoolId, latest.id);
351
+ assert.equal(item.reviewDeadlineAtMs, latest.capturedAt + LIVE_BOUND_MS);
352
+ assert.equal(r.row('phone', first.id).disposition, 'shed_superseded');
353
+ for (const record of [first, latest]) {
354
+ const saved = r.row('phone', record.id);
355
+ assert.equal(saved.phoneAdmissionDecision, undefined);
356
+ assert.equal(saved.phoneAdmissionOmission, undefined);
357
+ assert.equal(saved.followUp, undefined);
358
+ assert.deepEqual(saved.ruleSelection.anchors, []);
359
+ r.assertOriginal('phone', record);
360
+ }
361
+ assert.equal(r.calls.length, 0);
362
+ });
363
+ }
364
+
365
+ test('known captured profile revisions use newest-frame scheduling without transferring their contexts', async t => {
366
+ const r = rig(t); r.state.answer = false;
367
+ const prior = { websiteReviewAdmission: undefined };
368
+ const first = r.capture('phone', 1000, prior);
369
+ const second = r.capture('phone', 1500, prior);
370
+ const changed = r.capture('phone', 2000, { ...prior, prompt: 'A different captured profile revision.' });
371
+ r.pump();
372
+ const current = r.spool.take(undefined, 'review');
373
+ assert.equal(current.spoolId, changed.id);
374
+ assert.equal(current.reviewDeadlineAtMs, changed.capturedAt + LIVE_BOUND_MS);
375
+ assert.equal(r.row('phone', first.id).disposition, 'shed_superseded');
376
+ assert.equal(r.row('phone', second.id).disposition, 'shed_superseded');
377
+ await r.review(current); await r.upload();
378
+ assert.deepEqual(r.calls.map(call => call.evidenceId), [changed.id]);
379
+ for (const record of [first, second, changed]) r.assertOriginal('phone', record);
380
+ });
381
+
382
+ test('an unknown legacy context remains a barrier while mixed known realtime offers retain honest age bounds', t => {
383
+ const r = rig(t), directory = path.join(r.root, 'archive-phone');
384
+ const legacy = new RetainedCaptureClient(r.clients.get('phone'), directory, {
385
+ cameraId: 'phone', intervalMs: 500, offerWindow: 16, maxCaptures: 1000,
386
+ maxBytes: 128 * 1024 ** 2, archiveRetentionMs: 600000,
387
+ });
388
+ r.archives.set('phone', legacy);
389
+ const oldKnown = r.capture('phone', 1000, { websiteReviewAdmission: undefined });
390
+ legacy.retainOrderedCapture({ name: 'phone', enqueuedAtMs: 1500, jpeg: original(), captureMode: 'periodic',
391
+ reason: 'motion', signature: 'unknown-legacy-context', reviewKind: 'event', reviewContext: null });
392
+ const unknown = legacy.previousCaptureRecord;
393
+ const recentKnown = r.capture('phone', 199500, { websiteReviewAdmission: undefined });
394
+ r.pump(); assert.equal(r.spool.getStats().buffered, 3);
395
+ r.state.now = 200000; r.restart();
396
+ const modern = r.capture('phone', 200000);
397
+ const offered = r.pump();
398
+ assert.equal(r.row('phone', oldKnown.id).disposition, 'expired_unreviewed',
399
+ 'An ordered fallback cannot turn a known stale realtime original into late model work');
400
+ const knownOffer = offered.find(candidate => candidate.retainedId === recentKnown.id);
401
+ assert(knownOffer);
402
+ assert.equal(knownOffer.reviewDeadlineAtMs, recentKnown.capturedAt + LIVE_BOUND_MS);
403
+ const item = r.spool.take(undefined, 'review');
404
+ assert.equal(item.spoolId, unknown.id);
405
+ assert.equal(item.reviewDeadlineAtMs, undefined);
406
+ assert.equal(r.row('phone', unknown.id).candidate.reviewContext, null);
407
+ assert.equal(r.row('phone', unknown.id).disposition, 'pending_review');
408
+ assert.equal(r.row('phone', modern.id).disposition, 'awaiting_rule_decision');
409
+ assert.equal(r.calls.length, 0);
410
+ r.assertOriginal('phone', oldKnown); r.assertOriginal('phone', recentKnown);
411
+ });
412
+
413
+ test('bounded admission commits drain deferred originals with conserved unreviewed lifetime counts', t => {
414
+ const r = rig(t), originals = [];
415
+ for (let i = 0; i < 65; i++) originals.push(r.capture('phone', 1000 + i * 500));
416
+ const actualWrite = fs.writeFileSync;
417
+ let commits = 0;
418
+ fs.writeFileSync = function (file, ...args) {
419
+ if (typeof file === 'string' && path.dirname(file) === path.join(r.root, 'archive-phone')
420
+ && /^[a-f0-9]{32}\.json\.(?:admission-tmp|tmp)$/.test(path.basename(file))) commits++;
421
+ return actualWrite.call(this, file, ...args);
422
+ };
423
+ try {
424
+ for (let pump = 0; pump < 6 && r.archives.get('phone').deferred.size; pump++) {
425
+ commits = 0; r.pump();
426
+ assert(commits <= 32, 'At most sixteen admission and sixteen base retirement commits per pump; observed ' + commits);
427
+ const stats = r.archives.get('phone').getReviewScheduleStats();
428
+ assert.equal(stats.selected, stats.reviewed + stats.shed + stats.expired + stats.pending);
429
+ assert.equal(stats.reviewed, 0, 'Bookkeeping cannot manufacture a model answer');
430
+ }
431
+ } finally { fs.writeFileSync = actualWrite; }
432
+ assert.equal(r.archives.get('phone').deferred.size, 0);
433
+ assert.deepEqual(r.archives.get('phone').getReviewScheduleStats(),
434
+ { freshnessMs: LIVE_BOUND_MS, pending: 1, selected: 65, reviewed: 0, shed: 64, expired: 0 });
435
+ assert.equal(r.spool.getStats().buffered, 1);
436
+ assert.equal(r.spool.take(undefined, 'review').spoolId, originals.at(-1).id);
437
+ for (const record of originals) {
438
+ assert.equal(r.row('phone', record.id).result, null);
439
+ r.assertOriginal('phone', record);
440
+ }
441
+ });
442
+
443
+
444
+ // Upgrade trigger: actual old base archives already contain selected/queued
445
+ // 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 => {
447
+ const r = rig(t), directory = path.join(r.root, 'archive-phone');
448
+ const legacy = new RetainedCaptureClient(r.clients.get('phone'), directory, {
449
+ cameraId: 'phone', intervalMs: 500, offerWindow: 16, maxCaptures: 1000,
450
+ maxBytes: 128 * 1024 ** 2, archiveRetentionMs: 600000,
451
+ });
452
+ r.archives.set('phone', legacy);
453
+ const a = { websiteReviewAdmission: undefined };
454
+ const b = { ...a, prompt: 'Controlled captured profile revision B; no model-selection override.' };
455
+ const old = [
456
+ r.capture('phone', 1000, a), r.capture('phone', 1500, b),
457
+ r.capture('phone', 2000, a), r.capture('phone', 2500, b),
458
+ ];
459
+ r.pump(); assert.equal(r.spool.getStats().buffered, old.length);
460
+ assert(old.every(record => record.selected));
461
+ // Recover the same physical archive and spool, with their real pre-deadline
462
+ // queue metadata. No fabricated selected rows or edited queue files.
463
+ r.state.now = 200000; r.restart();
464
+ const fresh = r.capture('phone', r.state.now, b); r.pump();
465
+ const item = r.spool.take(undefined, 'review');
466
+ assert.equal(item.spoolId, fresh.id, 'Known A/B selections must not fall back to late capture-order review');
467
+ assert.equal(item.reviewDeadlineAtMs, fresh.capturedAt + LIVE_BOUND_MS);
468
+ for (const record of old) {
469
+ assert.equal(r.row('phone', record.id).disposition, 'expired_unreviewed');
470
+ assert.equal(r.row('phone', record.id).result, null);
471
+ r.assertOriginal('phone', record);
472
+ }
473
+ assert.equal(r.spool.getStats().buffered, 0, 'Every old queued copy must leave before a take can start it');
474
+ await r.review(item); await r.upload();
475
+ assert.deepEqual(r.calls.map(call => call.evidenceId), [fresh.id]);
476
+ assert.deepEqual(r.archives.get('phone').getReviewScheduleStats(),
477
+ { freshnessMs: LIVE_BOUND_MS, pending: 0, selected: 5, reviewed: 1, shed: 0, expired: 4 });
478
+ });
479
+
480
+ test('a fresh known semantic-context change keeps realtime deadlines and immutable original contexts', t => {
481
+ const r = rig(t);
482
+ const before = r.capture('phone', 1000, { websiteReviewAdmission: undefined }); r.pump();
483
+ const current = r.capture('phone', 1500, { websiteReviewAdmission: undefined,
484
+ prompt: 'A different controlled captured question.',
485
+ modelSelection: { version: 1, selectionId: 'controlled-current-model',
486
+ models: [{ modelId: 'synthetic-current-context-only', format: 'litert-lm', sha256: 'c'.repeat(64) }] } });
487
+ r.pump();
488
+ const item = r.spool.take(undefined, 'review');
489
+ assert.equal(item.spoolId, current.id, 'A known profile change alone is not an unknown/ordered dependency');
490
+ assert.equal(item.reviewDeadlineAtMs, current.capturedAt + LIVE_BOUND_MS);
491
+ assert.equal(r.row('phone', before.id).disposition, 'shed_superseded');
492
+ assert.equal(r.spool.getStats().withdrawn, 1);
493
+ for (const record of [before, current]) {
494
+ const saved = r.row('phone', record.id);
495
+ assert.equal(saved.result, null);
496
+ assert.equal(saved.phoneAdmissionDecision, undefined);
497
+ assert.equal(saved.followUp, undefined);
498
+ assert.deepEqual(saved.ruleSelection.anchors, []);
499
+ r.assertOriginal('phone', record);
500
+ }
501
+ assert.notDeepEqual(before.candidate.reviewContext, current.candidate.reviewContext);
502
+ assert.equal(r.calls.length, 0);
503
+ });