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 runscripts/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/nulltest/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
});