2526b6ac83
The Studio has an answer pane. It reads an answer in the view layer as it streams from the assistant, draws each statement when it arrives, runs the engine call each one is bound to, and seals the answer with a receipt that is checked again by re-running. A stored answer carries its receipt and is verified when it is read back. The correctness record is off by default. When it is turned on, it keeps one record per answer in the browser: the codes, the verdict level, the repairs, whether the answer was accepted, and the receipt id. Nothing is sent anywhere, and the records leave only when exported. The failures export as an eval corpus in the conformance format. A test shows that nothing is recorded while it is off. The engine adds a noise argument to @Sample and @Check, keeps root-listed names that have not arrived in the snapshot order, and gives a model the layer's rules with a worked example. The desktop app answers the same calls. macOS can read a running process's energy, for the model harness. Co-Authored-By: Claude Opus 5.5 <[email protected]>
62 lines
3.2 KiB
JavaScript
62 lines
3.2 KiB
JavaScript
// The correctness record (src/telemetry.js), without a browser: off by default,
|
||
// and while it is off nothing is recorded, nothing is written to storage, and the
|
||
// engine is not even asked; turned on, each answer is one record, the reader's
|
||
// decision is kept, and the failures go to the corpus call.
|
||
//
|
||
// node test/telemetry.test.mjs
|
||
import { telemetryStore, KEY } from '../src/telemetry.js';
|
||
|
||
let fails = 0;
|
||
const check = (ok, what) => { console.log(`${ok ? 'PASS' : 'FAIL'} ${what}`); if (!ok) fails += 1; };
|
||
|
||
// A storage that remembers every write.
|
||
function storage() {
|
||
const m = new Map();
|
||
const writes = [];
|
||
return { getItem: (k) => (m.has(k) ? m.get(k) : null), setItem: (k, v) => { writes.push(k); m.set(k, String(v)); }, removeItem: (k) => m.delete(k), writes, m };
|
||
}
|
||
// An engine that counts what it is asked, and answers as the real one does.
|
||
function engine() {
|
||
const asked = [];
|
||
return {
|
||
asked,
|
||
async telemetry(name, args) {
|
||
asked.push(name);
|
||
if (name === 'record') return { format: 'wai.quantum.telemetry/1', decision: 'pending', codes: [], repairs: [], ...args.fields };
|
||
return { format: 'wai.quantum-intent-conformance-bundle/1', cases: args.records.filter((r) => r.decision === 'rejected').map((r, i) => ({ name: `failure-${i + 1}` })) };
|
||
},
|
||
};
|
||
}
|
||
|
||
const s = storage();
|
||
const e = engine();
|
||
const t = telemetryStore({ engine: e, storage: s, now: () => 1 });
|
||
check(!t.on(), 'it is off by default');
|
||
for (let i = 0; i < 5; i++) check((await t.record({ program: 'OPENQASM 3.0;', codes: ['Q103'], verdict: { level: 'refused' } })) === null, `while off, an answer is not recorded (${i + 1})`);
|
||
t.decide(0, 'accepted');
|
||
check(t.records().length === 0, 'while off, the record is empty');
|
||
check(s.getItem(KEY) === null && s.writes.length === 0, 'while off, nothing is written to storage, not even a key');
|
||
check(e.asked.length === 0, 'while off, the engine is not asked to make a record');
|
||
|
||
t.set(true);
|
||
const id = await t.record({ program: 'OPENQASM 3.0;', verdict: { level: 'proof', holds: true } });
|
||
check(id === 0 && t.records().length === 1 && t.records()[0].at === 1 && t.records()[0].surface === 'studio', 'turned on, an answer is one record, with its time and surface');
|
||
t.decide(id, 'rejected');
|
||
check(t.records()[0].decision === 'rejected', 'the reader’s decision is kept');
|
||
check(JSON.parse(s.getItem(KEY)).records.length === 1, 'kept in this browser’s storage');
|
||
check((await t.corpus()).cases.length === 1 && e.asked.at(-1) === 'corpus', 'the failures go to the engine’s corpus');
|
||
|
||
t.set(false);
|
||
const writes = s.writes.length;
|
||
check((await t.record({ program: 'x' })) === null && t.records().length === 1 && e.asked.filter((n) => n === 'record').length === 1, 'turned off again, nothing more is recorded');
|
||
t.decide(0, 'accepted');
|
||
check(t.records()[0].decision === 'rejected' && s.writes.length === writes, 'and no decision is changed');
|
||
t.clear();
|
||
check(t.records().length === 0, 'the record can be deleted');
|
||
|
||
// A store read back from storage keeps its state.
|
||
const again = telemetryStore({ engine: e, storage: s });
|
||
check(!again.on() && again.records().length === 0, 'read back, it is as it was left');
|
||
|
||
console.log(fails ? `${fails} check(s) failed` : 'every check passed');
|
||
process.exit(fails ? 1 : 0);
|