Commit02eb9ce7Recorded19 Oct 2026Repositorysigil-http3

Prepare public-origin continuous IPv6 punch phone window

Changed
 scripts/continuous-punch-window.mjs     | 189 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 scripts/phantom-continuous-punch-run.sh |  22 ++++++++++++++++++
 scripts/prepare-punch-inputs.mjs        |  16 +++++++++++--
 scripts/punch-firewall.mjs              |   8 ++++---
 test/test-continuous-punch-window.mjs   |  33 +++++++++++++++++++++++++++
 5 files changed, 263 insertions(+), 5 deletions(-)
Diff
scripts/continuous-punch-window.mjsadded
@@ -0,0 +1,189 @@
+1
// Bounded UDP experiment for an explicitly configured page.
+2
import { createHash, randomBytes } from 'node:crypto';
+3
import { isIP } from 'node:net';
+4
import { copyFileSync, chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+5
import { hostname, networkInterfaces } from 'node:os';
+6
import { join, resolve } from 'node:path';
+7
import { fileURLToPath } from 'node:url';
+8
import { identity, inspectPlan, runTest, sameIdentity, stopRun } from './echo-lifecycle.mjs';
+9
import { preparePunchFirewall } from './punch-firewall.mjs';
+10
import { punchPorts, validateRendezvous } from './punch-prime.mjs';
+11
+12
const page = 'https://example.com/wt-spike/phone.html';
+13
const pause = ms => new Promise(done => setTimeout(done, ms));
+14
const digest = path => createHash('sha256').update(readFileSync(path)).digest('hex');
+15
function check(value, message) { if (!value) throw new Error(message); }
+16
function json(path) {
+17
check(lstatSync(path).size <= 65536, 'JSON receipt exceeds limit');
+18
return JSON.parse(readFileSync(path, 'utf8'));
+19
}
+20
function privateJson(path, value) {
+21
writeFileSync(path + '.next', JSON.stringify(value, null, 2) + '\n', { mode: 0o600 });
+22
renameSync(path + '.next', path);
+23
}
+24
function rootJson(path) {
+25
if (!existsSync(path)) return null;
+26
const info = lstatSync(path);
+27
check(info.isFile() && info.uid === 0 && !(info.mode & 0o022) && info.size <= 4096, 'Expected root-owned firewall proof');
+28
return json(path);
+29
}
+30
export function requestPrime(directory, rendezvousPath, controlFailed) {
+31
const info = lstatSync(directory);
+32
check(info.isDirectory() && info.uid === process.getuid() && !(info.mode & 0o077), 'Expected private owned run');
+33
check(controlFailed, 'control confirmation and failed valid control are required');
+34
const state = json(join(directory, 'state.json'));
+35
check(state.phase === 'control-ready' && Date.parse(state.expiresAt) > Date.now(), 'Control not active');
+36
const rendezvous = json(rendezvousPath);
+37
validateRendezvous(rendezvous, state.bindAddress);
+38
writeFileSync(join(directory, 'prime-request.json'), JSON.stringify({ schema: 1, confirmedControlFailed: true,
+39
requestedAt: new Date().toISOString(), rendezvous }, null, 2) + '\n', { flag: 'wx', mode: 0o600 });
+40
return { requested: true, seconds: 180, ports: punchPorts, sameListeningSocket: true };
+41
}
+42
+43
async function run() {
+44
+45
const bindAddress = process.env.HTTP3_IPV6_ADDRESS;
+46
check(isIP(bindAddress) === 6 && /^[23][0-9a-f:]+$/i.test(bindAddress), 'Expected current global /128');
+47
check(networkInterfaces()[process.env.HTTP3_INTERFACE]?.some(a => a.family === 'IPv6' && a.address === bindAddress && !a.internal),
+48
'configured /128 not assigned on expected physical interface');
+49
const input = json('build/punch-input-proof.json'), receipt = json('build/browser/capabilities.json');
+50
const original = resolve('tools/interop/build/native/bin/http3-preflight');
+51
check(input.continuous && input.job === 'http3-example' && input.binarySha256 === digest(original) &&
+52
receipt.binarySha256 === input.binarySha256 && receipt.quicRevision === readFileSync('quic.rev', 'utf8').trim() &&
+53
receipt.spikeSdkRevision === readFileSync('spike-sdk.rev', 'utf8').trim(), 'Continuous binary provenance mismatch');
+54
check(['ready', 'bidirectionalEcho', 'unidirectionalEcho', 'datagramEcho', 'chromeReaped', 'serverReaped']
+55
.every(key => receipt[key] === true) && receipt.traceProbe?.newTuple && receipt.traceProbe?.dropRecorded &&
+56
receipt.traceProbe?.connectionStillOpen && receipt.phonePageChecks?.offlineGate && receipt.phonePageChecks?.onlineRecovery,
+57
'Fresh exact-certificate browser/trace/offline gate missing');
+58
const directory = resolve('build/phone-punch'), native = join(directory, 'native-punch');
+59
mkdirSync(directory, { mode: 0o700 }); mkdirSync(native, { mode: 0o700 });
+60
const certificateDirectory = join(directory, 'certificate'); mkdirSync(certificateDirectory, { mode: 0o700 });
+61
for (const name of ['cert.pem', 'cert.der', 'key.pem', 'private.raw', 'certificate.json']) {
+62
copyFileSync(join('build/browser', name), join(certificateDirectory, name));
+63
chmodSync(join(certificateDirectory, name), 0o600);
+64
}
+65
const binary = join(directory, 'echo-server'); copyFileSync(original, binary); chmodSync(binary, 0o700);
+66
privateJson(join(directory, 'interop.json'), receipt);
+67
const supervisor = identity(process.pid); check(supervisor?.uid === process.getuid(), 'Cannot admit controller');
+68
const deadline = Date.now() + 1800000;
+69
const state = { schema: 1, kind: 'continuous-ipv6-punch', phase: 'preparing', supervisor,
+70
bindAddress, port: 43443, startedAt: new Date().toISOString(), expiresAt: new Date(deadline).toISOString(),
+71
binarySha256: input.binarySha256, sourceRevision: process.env.HTTP3_SOURCE_REVISION, binarySourceRevision: input.sourceRevision };
+72
const statePath = join(directory, 'state.json'), firewall = join(directory, 'firewall');
+73
preparePunchFirewall(firewall, { bindAddress, interfaceName: process.env.HTTP3_INTERFACE, supervisor, ruleComment: 'sigil-http3-example' });
+74
const cancellation = new AbortController();
+75
const stop = () => cancellation.abort();
+76
process.on('SIGTERM', stop); process.on('SIGINT', stop);
+77
const timer = setTimeout(stop, 1800000);
+78
const save = () => privateJson(statePath, state);
+79
function rootWindow() {
+80
if (rootJson(join(firewall, 'closed.json'))?.verifiedAbsent) return false;
+81
const opened = rootJson(join(firewall, 'opened.json'));
+82
return opened?.schema === 1 && opened.address === bindAddress && opened.port === 43443 &&
+83
opened.supervisorPID === supervisor.pid && opened.supervisorStart === supervisor.start &&
+84
opened.openedEpoch * 1000 >= Date.parse(state.startedAt) - 1000 && opened.expiresEpoch * 1000 > Date.now();
+85
}
+86
let serverDone, ended = false, failure;
+87
const previousPunchDirectory = process.env.HTTP3_PUNCH_DIRECTORY;
+88
const previousTestScope = process.env.HTTP3_PUNCH_TEST_LOOPBACK;
+89
try {
+90
save();
+91
const config = { schema: 1, testId: 'phone-continuous-punch-002', expectedHost: hostname(), scope: 'ipv6-direct',
+92
bindAddress, port: 43443, binary, binarySha256: input.binarySha256, certificateDirectory,
+93
authority: `[${bindAddress}]:43443`, origins: [new URL(page).origin], interopReceipt: join(directory, 'interop.json'),
+94
runDirectory: join(directory, 'server'), lifetimeSeconds: 1800 };
+95
const configPath = join(directory, 'config.json'); privateJson(configPath, config);
+96
const plan = inspectPlan(configPath); check(plan.ready, plan.blockers.join('; '));
+97
process.env.HTTP3_PUNCH_DIRECTORY = native;
+98
delete process.env.HTTP3_PUNCH_TEST_LOOPBACK;
+99
serverDone = runTest(configPath, { signal: cancellation.signal }).then(() => { ended = true; }, error => { ended = true; failure = error; });
+100
const readyUntil = Date.now() + 12000;
+101
while (!ended && !cancellation.signal.aborted && Date.now() < readyUntil) {
+102
const path = join(directory, 'server/state.json');
+103
if (existsSync(path) && json(path).phase === 'ready') { state.child = json(path).child; break; }
+104
await pause(50);
+105
}
+106
check(state.child && !ended && !cancellation.signal.aborted, 'Native control readiness failed');
+107
const phoneURL = page + '?' + new URLSearchParams({ host: bindAddress, port: '43443', hash: receipt.certificateSha256 });
+108
privateJson(join(directory, 'parameters.json'), { phoneURL, port: 43443, hash: receipt.certificateSha256,
+109
expiresAt: state.expiresAt, primePorts: punchPorts, primeSeconds: 180, maximumPrimePackets: 540,
+110
sameListeningSocket: true, openCommand: `sudo bash ${firewall}/open.sh`, closeCommand: `sudo bash ${firewall}/close.sh` });
+111
state.phase = 'awaiting-firewall'; save();
+112
console.log('RESULT continuous-control-listener-ready parameters=build/phone-punch/parameters.json awaiting-root-open');
+113
while (!ended && !cancellation.signal.aborted) {
+114
if (rootJson(join(firewall, 'closed.json'))?.verifiedAbsent) { state.reason = 'firewall-closed'; break; }
+115
if (state.phase === 'awaiting-firewall' && rootWindow()) {
+116
state.phase = 'control-ready'; state.controlReadyAt = new Date().toISOString(); save();
+117
console.log('RESULT continuous-control-ready no-prime=true');
+118
}
+119
if (state.phase !== 'awaiting-firewall' && !rootWindow()) { state.reason = 'firewall-window-ended'; break; }
+120
const requestPath = join(directory, 'prime-request.json');
+121
if (state.phase === 'control-ready' && existsSync(requestPath)) {
+122
const request = json(requestPath);
+123
check(request.schema === 1 && request.confirmedControlFailed, 'Missing control confirmation/control confirmation');
+124
const phone = validateRendezvous(request.rendezvous, bindAddress);
+125
check(rootWindow() && sameIdentity(state.child, identity(state.child.pid)), 'Root window/child identity changed');
+126
const log = readFileSync(join(directory, 'server/stdout.log'), 'utf8');
+127
check(!log.includes('event=udp-in') && !log.includes('HTTP3-AUTHENTICATED ') && !log.includes('event=trace-exhausted'),
+128
'Control has ingress; inspect rather than classifying/priming');
+129
privateJson(join(directory, 'control-result.json'), { failedOnPhoneConfirmed: true, ingress: 0,
+130
capturedAt: new Date().toISOString(), logSha256: digest(join(directory, 'server/stdout.log')), child: state.child });
+131
const nonce = randomBytes(16).toString('hex');
+132
writeFileSync(join(native, 'command.scm.next'), `(1 "${nonce}" "${phone}" 180)\n`, { flag: 'wx', mode: 0o600 });
+133
renameSync(join(native, 'command.scm.next'), join(native, 'command.scm'));
+134
state.phase = 'priming-starting'; state.primeNonce = nonce; state.primeRequestedAt = new Date().toISOString(); save();
+135
}
+136
if (state.phase === 'priming-starting') {
+137
check(Date.now() - Date.parse(state.primeRequestedAt) < 5000, 'Native prime acknowledgement deadline');
+138
const startedPath = join(native, 'started.json');
+139
if (existsSync(startedPath)) {
+140
const started = json(startedPath);
+141
const log = readFileSync(join(directory, 'server/stdout.log'), 'utf8');
+142
check(started.nonce === state.primeNonce && started.sourceHost === bindAddress && started.sourcePort === 43443 &&
+143
started.seconds === 180 && sameIdentity(state.child, identity(state.child.pid)), 'Native prime source/identity mismatch');
+144
if (/HTTP3-PUNCH .*event=send .*result=8/.test(log)) {
+145
state.phase = 'primed-ready'; state.primedReadyAt = new Date().toISOString();
+146
state.primingDeadline = new Date(Date.parse(state.primeRequestedAt) + 185000).toISOString(); save();
+147
console.log('RESULT continuous-PRIMED-READY same-listening-socket=true seconds<=180 ports=40000,40001,40002');
+148
}
+149
}
+150
}
+151
const finishedPath = join(native, 'finished.json');
+152
if (['priming-starting', 'primed-ready'].includes(state.phase) && existsSync(finishedPath)) {
+153
const finished = json(finishedPath);
+154
check(finished.nonce === state.primeNonce && finished.packets <= 540 && finished.elapsedMs <= 185000, 'Invalid native finish receipt');
+155
check(finished.reason === 'window-expired', 'Priming stopped early: ' + finished.reason);
+156
state.phase = 'priming-finished'; state.primeFinishedAt = new Date().toISOString(); save();
+157
console.log('RESULT continuous-priming-finished packets=' + finished.packets);
+158
}
+159
if (state.phase === 'primed-ready') check(Date.now() < Date.parse(state.primingDeadline), 'Native priming hard deadline exceeded');
+160
await pause(100);
+161
}
+162
if (failure) throw failure;
+163
} catch (error) { failure ??= error; }
+164
finally {
+165
clearTimeout(timer);
+166
writeFileSync(join(native, 'stop'), 'controller teardown\n', { mode: 0o600 });
+167
cancellation.abort();
+168
await serverDone;
+169
process.off('SIGTERM', stop); process.off('SIGINT', stop);
+170
if (previousPunchDirectory === undefined) delete process.env.HTTP3_PUNCH_DIRECTORY;
+171
else process.env.HTTP3_PUNCH_DIRECTORY = previousPunchDirectory;
+172
if (previousTestScope === undefined) delete process.env.HTTP3_PUNCH_TEST_LOOPBACK;
+173
else process.env.HTTP3_PUNCH_TEST_LOOPBACK = previousTestScope;
+174
const serverState = existsSync(join(directory, 'server/state.json')) ? json(join(directory, 'server/state.json')) : null;
+175
Object.assign(state, { phase: 'finished', endedAt: new Date().toISOString(), childReaped: serverState?.childReaped === true,
+176
error: failure?.message }); save();
+177
console.log('RESULT continuous-window-finished child-reaped=' + state.childReaped);
+178
}
+179
if (failure) throw failure;
+180
}
+181
if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+182
try {
+183
const [command, directory, rendezvous, confirmation] = process.argv.slice(2);
+184
if (command === 'run') await run();
+185
else if (command === 'stop') console.log(JSON.stringify(stopRun(resolve(directory))));
+186
else if (command === 'prime') console.log(JSON.stringify(requestPrime(resolve(directory), resolve(rendezvous), confirmation === '--control-failed')));
+187
else throw new Error('Usage: continuous-punch-window.mjs run | stop DIR | prime DIR RENDEZVOUS --control-failed');
+188
} catch (error) { console.error('RESULT continuous-punch-error ' + error.message); process.exitCode = 1; }
+189
}
scripts/phantom-continuous-punch-run.shadded
@@ -0,0 +1,22 @@
+1
#!/usr/bin/env bash
+2
set -euo pipefail
+3
cd "$(dirname "$0")/.."
+4
umask 077
+5
node --check scripts/continuous-punch-window.mjs
+6
node --check scripts/punch-firewall.mjs
+7
timeout --foreground 15 node --test test/test-continuous-punch-window.mjs
+8
export HTTP3_CONTINUOUS_PUNCH_RUN=1
+9
node scripts/prepare-punch-inputs.mjs
+10
export HTTP3_IPV6_ADDRESS
+11
HTTP3_IPV6_ADDRESS=$(node --input-type=module -e '
+12
import { networkInterfaces } from "node:os";
+13
const addresses = networkInterfaces()[process.env.HTTP3_INTERFACE]?.filter(a => a.family === "IPv6" && /^[23]/.test(a.address) && !a.internal);
+14
if (!addresses?.length) throw new Error("No assigned global IPv6");
+15
console.log(addresses[0].address);')
+16
export HTTP3_PREFLIGHT_SAN="IP:127.0.0.1,IP:::1,IP:$HTTP3_IPV6_ADDRESS,DNS:localhost"
+17
export HTTP3_PREFLIGHT_PREBUILT=1 HTTP3_PREFLIGHT_HTTPS_PAGE=1 HTTP3_PREFLIGHT_QUERY=1
+18
export HTTP3_SPIKE_SDK_JOB=http3-example HTTP3_SPIKE_TRACE=1 HTTP3_SPIKE_TRACE_PROBE=1
+19
HTTP3_PREFLIGHT_HOST=::1 bash scripts/phantom-browser-preflight.sh
+20
export HTTP3_SOURCE_REVISION
+21
HTTP3_SOURCE_REVISION=$(git rev-parse HEAD)
+22
exec node scripts/continuous-punch-window.mjs run
scripts/prepare-punch-inputs.mjsmodified
@@ -4,7 +4,8 @@ import { copyFileSync, chmodSync, mkdirSync, readFileSync, writeFileSync } from
4
import { resolve } from 'node:path';
5
import { hostname } from 'node:os';
6
−7
const job = 'http3-example';
+7
const continuous = process.env.HTTP3_CONTINUOUS_PUNCH_RUN === '1';
+8
const job = process.env.HTTP3_INPUT_JOB ?? 'http3-example';
9
const previous = process.env.HTTP3_INPUT_DIRECTORY ?? ((process.env.HTTP3_WORKSPACE_ROOT ?? (process.cwd() + '/build/workspaces')) + '/' + job);
10
const read = path => readFileSync(previous + path, 'utf8');
11
if (read('/rc').trim() !== '0' || !read('/src/build/spike-echo/trace-result.txt').includes('private-trace-native-browser-regressions=PASS') ||
@@ -12,6 +13,13 @@ if (read('/rc').trim() !== '0' || !read('/src/build/spike-echo/trace-result.txt'
13
throw new Error('Completed traced regression gate missing');
14
const receipt = JSON.parse(read('/src/build/browser/capabilities.json'));
15
const manifest = JSON.parse(read('/src/build/spike-echo/trace-manifest.json'));
+16
if (continuous) {
+17
const punch = JSON.parse(read('/src/build/continuous-punch-checks/result.json'));
+18
if (!punch.passed || !punch.results.bounded.samePID || !punch.results.bounded.ingressWhilePriming ||
+19
!punch.results.bounded.stoppedSendingStillListening || !punch.results.invalid.invalidWindowRejected ||
+20
!receipt.phonePageChecks?.offlineGate || !receipt.phonePageChecks?.onlineRecovery)
+21
throw new Error('Continuous punch or offline browser-control gate missing');
+22
}
23
if (receipt.quicRevision !== readFileSync('quic.rev', 'utf8').trim() || manifest.base !== receipt.quicRevision ||
24
receipt.spikeSdkRevision !== readFileSync('spike-sdk.rev', 'utf8').trim() ||
25
!receipt.traceProbe?.newTuple || !receipt.traceProbe?.dropRecorded || !receipt.chromeReaped || !receipt.serverReaped)
@@ -25,10 +33,14 @@ chmodSync('tools/interop/build/native/bin/http3-preflight', 0o700);
33
mkdirSync('build/punch-provenance', { recursive: true, mode: 0o700 });
34
for (const file of ['trace-result.txt', 'trace-manifest.json', 'trace.patch', 'test-sources.json'])
35
copyFileSync(previous + '/src/build/spike-echo/' + file, 'build/punch-provenance/' + file);
+36
if (continuous) {
+37
copyFileSync(previous + '/src/build/spike-echo/punch-manifest.json', 'build/punch-provenance/punch-manifest.json');
+38
copyFileSync(previous + '/src/build/continuous-punch-checks/result.json', 'build/punch-provenance/continuous-checks.json');
+39
}
40
const proof = { scope: 'spike-only-reused-traced-artifact', job, sourceRevision: receipt.sourceRevision,
41
binarySha256: receipt.binarySha256, quicRevision: receipt.quicRevision, sdkRevision: receipt.spikeSdkRevision,
42
traceManifestSha256: digest(previous + '/src/build/spike-echo/trace-manifest.json'),
43
tracePatchSha256: digest(previous + '/src/build/spike-echo/trace.patch'), tests: '154/154',
−32
preparedAt: new Date().toISOString() };
+44
continuous, preparedAt: new Date().toISOString() };
45
writeFileSync(resolve('build/punch-input-proof.json'), JSON.stringify(proof, null, 2) + '\n', { mode: 0o600 });
46
console.log('RESULT punch-inputs=VERIFIED reused-trace-job=' + job + ' no-native-build');
scripts/punch-firewall.mjsmodified
@@ -5,10 +5,12 @@ import { isIP } from 'node:net';
5
import { execFileSync } from 'node:child_process';
6
const quote = value => "'" + String(value).replaceAll("'", "'\\''") + "'";
7
−8
export function preparePunchFirewall(directory, { bindAddress, interfaceName, supervisor }) {
+8
export function preparePunchFirewall(directory, { bindAddress, interfaceName, supervisor,
+9
ruleComment = 'sigil-http3-example' }) {
10
if (isIP(bindAddress) !== 6 || !/^[23][0-9a-f:]+$/i.test(bindAddress) ||
11
!/^[-a-zA-Z0-9_.]+$/.test(interfaceName) || !Number.isInteger(supervisor?.pid) ||
−11
!/^[0-9]+$/.test(supervisor.start) || !Number.isInteger(supervisor.uid))
+12
!/^[0-9]+$/.test(supervisor.start) || !Number.isInteger(supervisor.uid) ||
+13
!/^sigil-http3-ipv6-punch-[0-9]{3}$/.test(ruleComment))
14
throw new Error('Invalid exact firewall target/controller');
15
mkdirSync(directory, { mode: 0o700 });
16
const common = `#!/usr/bin/env bash
@@ -17,7 +19,7 @@ set -euo pipefail
19
umask 022
20
firewall=/gnu/store/c3fa94c62chbj42q905zfi33x7z7kr9m-iptables-1.8.11/sbin/ip6tables
21
directory=${quote(directory)}
−20
rule=(-i ${quote(interfaceName)} -d ${quote(bindAddress + '/128')} -p udp --dport 43443 -m comment --comment sigil-http3-example -j ACCEPT)
+22
rule=(-i ${quote(interfaceName)} -d ${quote(bindAddress + '/128')} -p udp --dport 43443 -m comment --comment ${quote(ruleComment)} -j ACCEPT)
23
verify_close() {
24
local result
25
"$firewall" -w 5 -S INPUT >/dev/null
test/test-continuous-punch-window.mjsadded
@@ -0,0 +1,33 @@
+1
// Admission boundaries only; this test never creates a UDP socket/command.
+2
import assert from 'node:assert/strict';
+3
import { test } from 'node:test';
+4
import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+5
import { resolve, join } from 'node:path';
+6
import { requestPrime } from '../scripts/continuous-punch-window.mjs';
+7
test('control confirmation, valid phase and fresh non-home address precede a single request', () => {
+8
const directory = resolve('build/continuous-admission-checks');
+9
mkdirSync(directory, { mode: 0o700 });
+10
const statePath = join(directory, 'state.json'), rendezvousPath = join(directory, 'rendezvous.json');
+11
const state = { phase: 'control-ready', bindAddress: '2001:db8:1:2::1', expiresAt: new Date(Date.now() + 60000).toISOString() };
+12
const good = { cellularOnly: true, phoneIPv6: '2a00:1234:abcd:2345::1', observedAt: new Date().toISOString() };
+13
const save = (path, value) => writeFileSync(path, JSON.stringify(value), { mode: 0o600 });
+14
save(statePath, state); save(rendezvousPath, good);
+15
assert.throws(() => requestPrime(directory, rendezvousPath, false), /control confirmation/);
+16
save(statePath, { ...state, phase: 'awaiting-firewall' });
+17
assert.throws(() => requestPrime(directory, rendezvousPath, true), /Control not active/);
+18
save(statePath, { ...state, expiresAt: new Date(Date.now() - 1000).toISOString() });
+19
assert.throws(() => requestPrime(directory, rendezvousPath, true), /Control not active/);
+20
save(statePath, state);
+21
for (const invalid of [{ ...good, cellularOnly: false },
+22
{ ...good, phoneIPv6: '2001:db8:1:2::9' },
+23
{ ...good, observedAt: new Date(Date.now() - 600001).toISOString() }]) {
+24
save(rendezvousPath, invalid);
+25
assert.throws(() => requestPrime(directory, rendezvousPath, true));
+26
}
+27
assert.equal(existsSync(join(directory, 'prime-request.json')), false);
+28
save(rendezvousPath, good);
+29
assert.equal(requestPrime(directory, rendezvousPath, true).seconds, 180);
+30
assert.equal(JSON.parse(readFileSync(join(directory, 'prime-request.json'))).confirmedControlFailed, true);
+31
assert.throws(() => requestPrime(directory, rendezvousPath, true), /EEXIST/);
+32
assert.equal(existsSync(join(directory, 'command.scm')), false);
+33
});