// The server-run engine (scripts/lib/mp-sim-engine.js, -worker.js, -realm.js; the server-sim design, sections 4.1-4.3,
// 5.3-5.10, 9): networks load, play days, take actions and what-ifs, and answer pulls and saves, every reply in the
// contract's shapes (tests/lib/mp-sim-shape.js); the capture table turns each kind of effect into an fx; failures go back
// to the mark (a throw in place, a timeout into a fresh realm, an exiting worker rejects everything pending); asks put
// everything back; actions report only the UI they changed; a session's day holds back loads; unwatched networks stay
// bounded; realms do not share their intrinsics; every call is answered, whatever a load holds; and a session whose load
// takes its worker down gets a worker of its own, then is given up, while the others keep their places.
// Review fixes: an arg that names a built-in is refused, and a realm whose built-ins changed is replaced; a mark that
// runs out of time undoes nothing; a fresh realm takes over the fx waiting for a page; a network whose realm cannot be
// built again is dropped and the host told; a day with bad lists is refused, never the worker's end; an exit blames the
// session that was running; a worker that cannot start backs off, then SIM_DOWN; the game is read once (a src/ that
// does not compile fails at start, a respawned worker runs the same game); a damaged route memory still loads, a save
// that is no server network does not; and the fake engine answers the same edge calls with the same codes.
const test = require('node:test');
const assert = require('node:assert/strict');
const fs = require('node:fs');
const os = require('node:os');
const path = require('node:path');
const { createEngine, snapWith } = require('../scripts/lib/mp-sim-engine');
const { checkEvent, checkFx, fixture } = require('./lib/mp-sim-shape');
const { MP, TEST, ROOMY, bigScenic, msg, begin, checked } = require('./lib/mp-sim-play');
const E = createEngine({ workers: 2, test: TEST, timeouts: ROOMY });
test.after(() => E.close());
const on = (X) => ({
day: (code, d, nets, o = {}) => X.day(code, { d, speed: 1, last: 1, alone: [], nets, ...o }).then(checked),
ev: async (code, nid, src) => { const r = await X.eval(code, nid, src); assert.equal(r.error, undefined, r.error); return r.value; },
});
const { day, ev } = on(E);
const updOf = (r) => JSON.parse(r.upd);
const wait = (ms) => new Promise((ok) => setTimeout(ok, ms));
// A call's answer within ms, or a failure that says it never came (a hung call would hang the test instead).
const within = (p, ms = 3000) => { let t; return Promise.race([p, new Promise((ok, no) => { t = setTimeout(() => no(new Error(`no answer within ${ms} ms`)), ms); })]).finally(() => clearTimeout(t)); };
const HOST = { clock: fixture('clock'), roster: fixture('roster'), since: { days: 0, again: 0 } };
test('a new network: begin, a snapshot, its welcome, actions, days, a what-if, views, prefs, a save and a card', async () => {
const code = 'NEWN3T', nid = 'neww0001';
const [L] = await E.load(code, [begin(nid, { tut: true })]);
checked(L);
assert.equal(L.day, 0);
assert.equal(L.saved.nid, nid, 'a new network is checkpointed at once');
assert.equal(JSON.parse(L.saved.txt).mp.sim, 1);
assert.equal(JSON.parse(L.saved.txt).tut, 0, 'the tutorial starts on the server');
// A page's first snapshot: v 0, the realm's half, a stream event once the host adds its own.
const P0 = checked(await E.pull(code, nid, { snap: true }));
assert.deepEqual([P0.v, P0.upd], [0, undefined]);
assert.deepEqual(checkEvent(JSON.parse(snapWith(P0.snap, HOST))), []);
assert.equal(JSON.parse(P0.snap).S.log[0].k, 'goal', 'the welcome is in the log');
// The welcome comes to that page with the first update: here the one-shots a page says on opening (greet).
const G = checked(await E.greet(code, nid));
assert.equal(G.v, 1);
assert.ok(updOf(G).fx.some(([k, p]) => k === 'toast' && p.k === 'goal' && /AS201234/.test(p.h)), 'the welcome toast');
// Actions: the update with the result is version v; the tutorial moves on the server.
const a1 = checked(await E.act(code, nid, msg('launchBB', { city: 'fra' })));
assert.deepEqual([a1.outcome, a1.v, a1.epoch], ['applied', 2, L.epoch]);
assert.ok(a1.ms > 0 && G.ms >= 0, 'the worker time of a call, for the rate limit');
const u1 = updOf(a1);
assert.equal(u1.from, 1);
assert.deepEqual(u1.acts.map((x) => x.rid), [JSON.parse(JSON.stringify(a1.rid))]);
assert.equal(u1.s.tut, 1, 'the first coach step is done');
assert.ok('cash' in u1.s && 'pops' in u1.s, 'the keys it changed');
assert.ok(!('links' in u1.s), 'and only those');
const net = await ev(code, nid, "return NETS.filter(n=>sellsAt(n,'fra'))[0].id");
assert.equal(checked(await E.act(code, nid, msg('buyTransit', { city: 'fra', net, tier: 1 }))).outcome, 'applied');
assert.equal(checked(await E.act(code, nid, msg('buyTransit', { city: 'nowhere', net, tier: 1 }))).outcome, 'no_effect');
// Refused by the game with a toast (and its log line): rejected, and the page hears why.
const cash = await ev(code, nid, 'const c=S.cash;S.cash=10;return c;');
const poor = checked(await E.act(code, nid, msg('buildPop', { city: 'syd' })));
assert.equal(poor.outcome, 'rejected');
assert.ok(updOf(poor).fx.some(([k, p]) => k === 'toast' && p.k === 'bad'), 'the refusal toast');
await ev(code, nid, `S.cash=${cash};return 1;`);
assert.equal(checked(await E.act(code, nid, msg('buildPop', { city: 'ams' }))).outcome, 'applied');
const link = checked(await E.act(code, nid, msg('buildLink', { tier: 0 }, { ui: { pending: { a: 'fra', b: 'ams' }, route: '', via: '', cnPrem: false } })));
assert.equal(link.outcome, 'applied');
assert.equal(updOf(link).acts[0].ui.closed, 1, 'the link window closes on the page');
// A draft that names no place is refused before the act runs.
const bad = checked(await E.act(code, nid, msg('buildLink', { tier: 0 }, { ui: { pending: { a: 'fra', b: 'atlantis' } } })));
assert.deepEqual([bad.outcome, /pending/.test(bad.why)], ['rejected', true]);
for (let d = 1; d <= 6; d++) { const D = await day(code, d, [nid]); assert.equal(D.nets[nid].day, d); }
const P1 = checked(await E.pull(code, nid, {}));
const u = updOf(P1);
assert.deepEqual([u.from, u.day, u.s.day], [bad.v, 6, 6], 'the days come after the last action\'s update');
assert.ok(u.r && u.r.tTop8, 'a new R after days, slim');
assert.equal(checked(await E.pull(code, nid, {})).upd, undefined, 'nothing new, no version');
// A what-if: the window it opened, the network as it was.
const lid = await ev(code, nid, 'return S.links[0].id');
const s0 = await ev(code, nid, 'return JSON.stringify(S)');
const K = checked(await E.ask(code, nid, msg('linkCheck', { id: lid }, { ctx: { w: 390, h: 844, coarse: true } })));
assert.match(K.modal.h, /redundancy|backhoe/i);
assert.equal(K.modal.c, 'link-check');
assert.equal(await ev(code, nid, 'return JSON.stringify(S)'), s0);
// Views: the selected link's flows and a city's PNI flows, per view.
const V = checked(await E.pull(code, nid, { views: [{ link: lid }, { peer: 'fra' }] }));
assert.deepEqual(Object.keys(V.subs).sort(), ['link:' + lid, 'peer:fra']);
assert.ok(Object.keys(V.subs['link:' + lid].ef).length <= 1, 'at most the link\'s own flow record');
const SB = checked(await E.sub(code, nid, { views: [{ link: lid }] }));
assert.deepEqual(Object.keys(SB.subs), ['link:' + lid]);
assert.equal(await E.prefs(code, nid, { prefs: { warnUnhappy: false } }), undefined);
assert.equal(await ev(code, nid, 'return pref("warnUnhappy")'), false);
const SV = checked(await E.save(code, nid));
assert.deepEqual([SV.day, SV.lost, typeof SV.rt.load], [6, false, 'object']);
const C = checked(await E.card(code, nid));
assert.deepEqual([C.card.day, C.card.asn, C.card.pops.sort()], [6, MP.asn, ['ams', 'fra']]);
assert.deepEqual(E.stats().realms >= 1, true);
checked(await E.unload(code, nid));
await assert.rejects(E.act(code, nid, msg('launchBB', { city: 'ams' })), (e) => e.code === 'NO_REALM');
});
test('a network that joins a session late begins on the session\'s date, with its head start; a start day that is none is refused', async () => {
const code = 'J01NER', nid = 'late0001';
const [L] = await E.load(code, [begin(nid, { day: 518 })]);
checked(L);
assert.equal(L.day, 518);
const sv = JSON.parse(L.saved.txt);
assert.deepEqual([sv.day, sv.day0, sv.nextFail, sv.nextEvent], [518, 518, 563, 558], 'its schedules count from its own start');
assert.equal(sv.cash, await ev(code, nid, 'return START_CASH+7000'), 'hardware costs 3.7% more by day 518: the bank adds $7k');
checked(await E.pull(code, nid, { snap: true }));
const G = checked(await E.greet(code, nid));
assert.ok(updOf(G).fx.some(([k, p]) => k === 'toast' && p.k === 'goal' && /Late to the party/.test(p.h) && p.a[0].act === 'bank'), 'the late welcome, with a button to the bank');
assert.ok(updOf(G).fx.some(([k, p]) => k === 'toast' && /AS201234/.test(p.h)), 'after the usual welcome');
const D = await day(code, 519, [nid]);
assert.equal(D.nets[nid].day, 519);
for (const bad of [-1, 1.5, '518']) {
const [B] = await E.load(code, [begin('latebad1', { day: bad })]);
checked(B);
assert.match(String(B.err), /start day/, JSON.stringify(bad));
}
await E.unload(code);
});
test('the capture table: every kind of effect comes out as an fx in its shape, at most 60 an update', async () => {
const code = 'CAPTVR', nid = 'capt0001';
checked((await E.load(code, [begin(nid)]))[0]);
checked(await E.pull(code, nid, { snap: true }));
checked(await E.act(code, nid, msg('launchBB', { city: 'fra' })));
await ev(code, nid, `UI.speed=1;toast('Hello world','good',[{l:'Open',act:'leftTab',args:{t:'noc'}}]);sfx('coin');haptic(8);floater(1,2,'+$5','#16A866');
track('probe',true);autoPause();showWin();showLose();showBaronWin();mkStart('fra');mkEnd(true,true);
S.stats.loans=1;checkBadges();return 1;`);
const u = updOf(checked(await E.pull(code, nid, {})));
const kinds = new Set(u.fx.map((f) => f[0]));
for (const k of ['toast', 'sfx', 'haptic', 'floater', 'track', 'pause', 'modal', 'mk', 'badge']) assert.ok(kinds.has(k), `fx ${k}`);
for (const f of u.fx) assert.deepEqual(checkFx(f), [], JSON.stringify(f));
assert.deepEqual(u.fx.filter((f) => f[0] === 'modal').map((f) => f[1]), ['win', 'lose', 'baron'], 'windows are fx, not opened');
assert.equal(await ev(code, nid, "return $('modal').hidden"), true);
const t = u.fx.find((f) => f[0] === 'toast' && f[1].h.startsWith('Hello'));
assert.deepEqual([t[1].k, t[1].a[0].act, t[1].tick], ['good', 'leftTab', false]);
assert.equal(await ev(code, nid, "return S.log.some(x=>x.h==='Hello')"), true, 'a toast is still a log line');
// Over 60: floaters go first; windows and badges stay.
await ev(code, nid, "for(let i=0;i<30;i++)floater(i,i,'x','#fff');for(let i=0;i<50;i++)sfx('click');showWin();return 1;");
const u2 = updOf(checked(await E.pull(code, nid, {})));
assert.equal(u2.fx.length, 60);
assert.deepEqual([u2.fx.filter((f) => f[0] === 'floater').length, u2.fx.filter((f) => f[0] === 'sfx').length], [9, 50], 'the 21 too many were the oldest floaters');
assert.deepEqual(u2.fx.filter((f) => f[0] === 'modal').map((f) => f[1]), ['win']);
await E.unload(code);
});
test('a timeout inside opsQuiet: the fresh realm has its toast and after, and the day is played', async (t) => {
// An engine with the server's own time limits: the injected endless loop is stopped by them.
const E = createEngine({ workers: 1, test: TEST });
t.after(() => E.close());
const { day, ev } = on(E);
const code = 'QV13T0', nid = 'quie0001';
checked((await E.load(code, [begin(nid)]))[0]);
checked(await E.act(code, nid, msg('launchBB', { city: 'fra' })));
const ep0 = checked(await E.pull(code, nid, {})).epoch;
// The intern's way of working (opsQuiet mutes toast, after, sfx and floater), stuck for ever in the middle of a day.
await ev(code, nid, '{const f=ddosTick;ddosTick=function(){f();opsQuiet(()=>{for(;;){}});};}return 1;');
const D = await day(code, 1, [nid]);
assert.deepEqual([D.nets[nid].day, D.nets[nid].retried, D.nets[nid].err], [1, true, undefined]);
const P = checked(await E.pull(code, nid, {}));
assert.notEqual(P.epoch, ep0, 'a fresh realm');
assert.deepEqual(await ev(code, nid, "return [/srvFx/.test(String(toast)),/routeIfChanged/.test(String(after)),/srvFx/.test(String(sfx)),/srvFx/.test(String(floater))]"), [true, true, true, true]);
const a = checked(await E.act(code, nid, msg('buildPop', { city: 'ams' })));
assert.equal(a.outcome, 'applied');
assert.ok(updOf(a).fx.some((f) => f[0] === 'toast' || f[0] === 'sfx'), 'its toasts reach the page again');
// And a throw inside opsQuiet (its finally ran) leaves the same realm working, put back in place.
await ev(code, nid, "{const f=ddosTick;let once=true;ddosTick=function(){f();if(once){once=false;opsQuiet(()=>{throw new Error('inside')});}};}return 1;");
const D2 = await day(code, 2, [nid]);
assert.deepEqual([D2.nets[nid].day, D2.nets[nid].retried], [2, true]);
assert.equal(checked(await E.pull(code, nid, {})).epoch, P.epoch);
assert.equal(await ev(code, nid, 'return /srvFx/.test(String(toast))'), true);
await E.unload(code);
});
test('a throw in an action puts the network back in place; with an attack on, R\'s attacks point into the restored S', async () => {
const code = 'THR0WN', nid = 'thrw0001';
checked((await E.load(code, [{ nid, env: { s: bigScenic(), uidN: 1000, rt: null }, lang: 'en', prefs: {} }]))[0]);
const ep = checked(await E.pull(code, nid, { snap: true })).epoch;
assert.ok(await ev(code, nid, 'const a=ddosAttack(true);a.until=S.day+5;return R.ddos.filter(m=>m.attack).length'), 'R holds the attack');
const s0 = await ev(code, nid, 'return JSON.stringify(S)');
await ev(code, nid, "{const f=ACT.buildPop;ACT.buildPop=a=>{f(a);throw new Error('after the change');};}return 1;");
const r = checked(await E.act(code, nid, msg('buildPop', { city: 'dus' })));
assert.deepEqual([r.outcome, /after the change/.test(r.why), r.epoch], ['error', true, ep]);
assert.equal(await ev(code, nid, 'return JSON.stringify(S)'), s0, 'S as it was');
assert.deepEqual(updOf(r).acts[0].ui, {}, 'the page is told, nothing else');
assert.equal(await ev(code, nid, 'return R.ddos.every(m=>!m.attack||m.attack===ddosFind(m.attack.id))&&R.ddos.some(m=>m.attack)'), true);
await E.unload(code);
});
test('an ask leaves S (the same object), R, the dice and uidN as they were, also during an attack', async () => {
const code = 'ASK3D0', nid = 'askd0001';
checked((await E.load(code, [{ nid, env: { s: bigScenic(), uidN: 1000, rt: null }, lang: 'en', prefs: {} }]))[0]);
await ev(code, nid, "const a=ddosAttack(true);a.until=S.day+5;S.te={on:true,day:S.day,script:''};compute();return 1;");
checked(await E.pull(code, nid, { snap: true })); checked(await E.pull(code, nid, {}));
const before = "window.__S0=S;window.__R0=R;window.__rng=S.rng;window.__u=uidN;window.__j=JSON.stringify(S);window.__hot=UI.hotMap;return 1;";
const same = 'return [S===__S0,R===__R0,S.rng===__rng,uidN===__u,JSON.stringify(S)===__j,R.ddos.some(m=>m.attack)&&R.ddos.every(m=>!m.attack||m.attack===ddosFind(m.attack.id)),UI.hotMap===__hot]';
const lid = await ev(code, nid, 'return S.links.find(l=>!linkDown(l)).id');
const script = await ev(code, nid, 'return TE_EXAMPLE');
for (const [act, args] of [['teSlop', {}], ['teCheck', { script }], ['linkCheck', { id: lid }], ['teSlop', {}]]) {
await ev(code, nid, before);
const r = checked(await E.ask(code, nid, msg(act, args)));
assert.ok(r.modal && r.modal.h.length > 20, `${act} answers with its window`);
if (act !== 'linkCheck') assert.equal(typeof r.ui.teDraft, 'string', `${act}: the draft`);
if (act === 'teSlop') assert.equal(r.ui.slop, r.ui.teDraft, 'the AI\'s script is the draft');
assert.deepEqual(await ev(code, nid, same), [true, true, true, true, true, true, true], act);
}
assert.equal(checked(await E.pull(code, nid, {})).upd, undefined, 'and nothing to send');
await E.unload(code);
});
test('ui.sel is reported only when the act changed it', async () => {
const code = 'SE1ECT', nid = 'selc0001';
checked((await E.load(code, [{ nid, env: { s: bigScenic(), uidN: 1000, rt: null }, lang: 'en', prefs: {} }]))[0]);
const lid = await ev(code, nid, "return S.links.find(l=>l.kind==='wave').id");
const rm = checked(await E.act(code, nid, msg('rmLink', { id: lid }, { confirmed: true, ctx: { sel: { type: 'link', id: lid }, tab: 'cust', left: 'goals', modal: false } })));
assert.equal(rm.outcome, 'applied');
assert.equal(updOf(rm).acts[0].ui.sel, null, 'the selected link is gone: the selection with it');
const net = await ev(code, nid, "return NETS.filter(n=>sellsAt(n,'fra')&&!S.transit.some(t=>t.city==='fra'&&t.net===n.id))[0].id");
const bt = checked(await E.act(code, nid, msg('buyTransit', { city: 'fra', net, tier: 1 }, { ctx: { sel: { type: 'city', id: 'fra' }, tab: 'up', left: 'goals', modal: false } })));
assert.equal(bt.outcome, 'applied');
assert.equal('sel' in updOf(bt).acts[0].ui, false, 'a city still selected: nothing to say');
// A selection that names nothing is no selection.
const x = checked(await E.act(code, nid, msg('buildPop', { city: 'dus' }, { ctx: { sel: { type: 'link', id: 'nope' }, tab: 'cust', left: 'goals', modal: false } })));
assert.equal(x.outcome, 'applied');
// A busy link's view: its flow record, and the descriptions of the ways in it names.
const busy = await ev(code, nid, 'return S.links.find(l=>(R.load[l.id]||0)>1&&R.ef[edgeKey(l)]&&Object.keys(R.ef[edgeKey(l)].eg||{}).length).id');
const V = checked(await E.sub(code, nid, { views: [{ link: busy }, { peer: 'fra' }] }));
const rec = V.subs['link:' + busy];
assert.equal(Object.keys(rec.ef).length, 1);
assert.ok(Object.keys(rec.egd).length > 0, 'with its ways in');
assert.ok(Object.keys(V.subs['peer:fra'].pf.fra).length > 0, 'and Frankfurt\'s PNI flows');
await E.unload(code);
});
test('a begin sent during a session\'s day waits for its dayDone; actions of another session do not', async () => {
const code = 'M1DDAY', a = 'midd0001', b = 'midd0002', other = '0TH3R5', o = 'othr0001';
checked((await E.load(code, [{ nid: a, env: { s: bigScenic(), uidN: 1000, rt: null }, lang: 'en', prefs: {} }]))[0]);
checked((await E.load(other, [begin(o)]))[0]);
const order = [];
const d = E.day(code, { d: 1, speed: 1, last: 1, alone: [], nets: [a] }).then((r) => { order.push('day'); return checked(r); });
const l = E.load(code, [begin(b)]).then((r) => { order.push('load'); return r; });
const D = await d, L = await l;
assert.deepEqual(order, ['day', 'load']);
assert.deepEqual(Object.keys(D.nets), [a], 'the day\'s networks were fixed when it started');
checked(L[0]);
assert.equal(L[0].day, 0);
await E.unload(code); await E.unload(other);
});
test('an unwatched network stays bounded: at most 200 fx, badges and windows kept (at most 32), a snapshot keeps them', async () => {
const code = 'VNWTCH', nid = 'unwt0001';
checked((await E.load(code, [begin(nid)]))[0]);
checked(await E.pull(code, nid, { snap: true }));
checked(await E.act(code, nid, msg('launchBB', { city: 'fra' })));
for (let d = 1; d <= 60; d++) await day(code, d, [nid]);
await ev(code, nid, "for(let i=0;i<500;i++)toast('note '+i);for(let i=0;i<40;i++)srvFx(['badge',{id:'b'+i,v:'oncall'}]);showLose();for(let i=0;i<300;i++)sfx('click');return 1;");
const [n, keep, last] = await ev(code, nid, "return [SIMR.fx.length,SIMR.fx.filter(f=>f[0]==='badge'||f[0]==='modal').length,SIMR.fx.filter(f=>f[0]==='modal').length]");
assert.ok(n <= 200, `${n} fx held`);
assert.equal(keep, 32);
assert.equal(last, 1, 'the newest window is kept');
const P = checked(await E.pull(code, nid, { snap: true }));
const snap = JSON.parse(P.snap);
assert.equal(snap.keep.length, 32);
assert.deepEqual(snap.keep.at(-1), ['modal', 'lose']);
assert.ok(JSON.parse(P.upd).fx.length <= 60);
assert.deepEqual(checkEvent(JSON.parse(snapWith(P.snap, HOST))), []);
await E.unload(code);
});
test('a loaded network that played unwatched: its first snapshot keeps the badges and windows, and no stale fx follow', async (t) => {
const code = 'VNSEEN', nid = 'unsn0001';
checked((await E.load(code, [{ nid, env: { s: bigScenic(), uidN: 1000, rt: null }, lang: 'en', prefs: {} }]))[0]);
for (let d = 1; d <= 8; d++) await day(code, d, [nid]);
// The badges it earned on those days stay too (the big fixture predates the traffic badges: it earns some at once).
const won = await ev(code, nid, "return SIMR.fx.filter(f=>f[0]==='badge').map(f=>f[1].id)");
t.diagnostic(`badges earned unwatched: ${won.join(', ') || 'none'}`);
await ev(code, nid, "for(let i=0;i<300;i++)toast('old news '+i);srvFx(['badge',{id:'debt',v:'oncall'}]);showWin();return 1;");
const P = checked(await E.pull(code, nid, { snap: true }));
assert.deepEqual(JSON.parse(P.snap).keep.map((f) => (f[0] === 'badge' ? f[1].id : f[0] + ':' + f[1])), [...won, 'debt', 'modal:win']);
assert.equal(JSON.parse(P.snap).v, P.v, 'the snapshot is at the version after the update to the streams there were');
assert.equal(checked(await E.pull(code, nid, {})).upd, undefined, 'nothing stale comes after the snapshot');
await E.unload(code);
});
test('alone, an auto-pause stops the realm\'s clock as the page\'s does: a second one that day finds it paused', async () => {
const code = 'PAVSE2', nid = 'paus0001';
checked((await E.load(code, [begin(nid)]))[0]);
assert.deepEqual(await ev(code, nid, 'SIMR.alone=true;SIMR.last=4;UI.speed=4;const a=autoPause(),b=autoPause();return [a,b,UI.speed,UI.resumeSpeed]'), [true, false, 0, 4]);
assert.deepEqual(await ev(code, nid, 'SIMR.alone=false;UI.speed=4;return [autoPause(),autoPause(),UI.speed]'), [false, false, 4], 'with others the world goes on');
const D = await day(code, 1, [nid], { alone: [nid], speed: 2, last: 2 });
assert.equal(D.nets[nid].day, 1);
assert.equal(await ev(code, nid, 'return UI.speed'), 2, 'the next day runs at the session\'s speed');
await E.unload(code);
});
test('a network whose save does not load is broken; the others of the session load', async () => {
const code = 'BR0K3N', ok = 'okok0001', bad = 'badd0002', zz = 'zzzz0003';
const L = await E.load(code, [{ nid: ok, env: { s: bigScenic(), uidN: 1000, rt: null }, lang: 'de', prefs: {} }, { nid: bad, env: { s: '{"v":1,"pops":', uidN: 1 }, lang: 'en', prefs: {} }, { ...begin(zz), lang: 'zz' }]);
L.forEach(checked);
assert.deepEqual([L[0].err, typeof L[1].err, L[2].err], [undefined, 'string', undefined]);
assert.deepEqual(Object.keys(L[1]).sort(), ['err', 'nid', 't']);
assert.equal(await ev(code, zz, 'return LANG'), 'en', 'a language without a dictionary here plays in English');
// The network's language is the realm's: the log speaks German.
checked(await E.act(code, ok, msg('buildPop', { city: 'dus' })));
assert.match(await ev(code, ok, 'return LANG+":"+S.log[0].t'), /^de:/);
await assert.rejects(E.act(code, bad, msg('buildPop', { city: 'dus' })), (e) => e.code === 'NO_REALM');
await E.unload(code);
});
test('a load call with a malformed network changes nothing, one without a save is broken, and every call still answers', async () => {
const code = 'MA1F0R', a = 'mala0001', b = 'malb0002';
const [A] = await E.load(code, [begin(a)]);
checked(A);
const env = { s: A.saved.txt, uidN: A.saved.uidN, rt: A.saved.rt };
// A network without a nid, or one twice: the call is refused whole, and a keeps the realm it had.
await assert.rejects(within(E.load(code, [{ nid: a, env, lang: 'en', prefs: {} }, { env, lang: 'en', prefs: {} }])), (e) => e.code === 'ERR');
assert.equal(checked(await within(E.pull(code, a, {}))).epoch, A.epoch, 'a as it was');
await assert.rejects(within(E.load(code, [begin(b), begin(b)])), (e) => e.code === 'ERR' && /twice/.test(e.message));
assert.equal(checked(await within(E.act(code, a, msg('launchBB', { city: 'ams' })))).epoch, A.epoch);
// a again with b, whose checkpoint the host could not read: b is broken, a loads (a new epoch).
const L = await within(E.load(code, [{ nid: a, env, lang: 'en', prefs: {} }, { nid: b, env: null, lang: 'en', prefs: {} }]));
L.forEach(checked);
assert.deepEqual([L[0].err, L[1].err], [undefined, 'no save to load']);
assert.notEqual(L[0].epoch, A.epoch);
// Every call of the session answers at once: a plays, b has no realm, unloads and loads go through.
assert.equal(checked(await within(E.act(code, a, msg('launchBB', { city: 'fra' })))).outcome, 'applied');
assert.equal(checked(await within(E.day(code, { d: 1, nets: [a, b] }))).nets[a].day, 1);
await assert.rejects(within(E.pull(code, b, {})), (e) => e.code === 'NO_REALM');
checked(await within(E.unload(code, a)));
checked((await within(E.load(code, [begin(a)])))[0]);
checked(await within(E.unload(code)));
// Nothing is left waiting, so the workers are idle (a job that can never run once kept one at 100% of a core).
await wait(100);
const c0 = process.cpuUsage();
await wait(1000);
const c = process.cpuUsage(c0), ms = (c.user + c.system) / 1000;
assert.ok(ms < 400, `${ms.toFixed(0)} ms of CPU over 1 s of quiet`);
});
test('an unload and a load sent back to back (a language change) keep the session on its worker', async () => {
const code = 'GERM4N', nid = 'lang0001';
checked((await E.load(code, [begin(nid)]))[0]);
const w = E.workerOf(code);
const u = E.unload(code), l = E.load(code, [{ ...begin(nid), lang: 'de' }]);
checked(await within(u));
checked((await within(l))[0]);
assert.equal(E.workerOf(code), w);
assert.equal(checked(await within(E.pull(code, nid, {}))).nid, nid, 'the network answers where it is');
checked((await E.load(code, [begin('lang0002')]))[0]);
assert.equal(E.workerOf(code), w, 'and the session\'s next network goes there too');
checked(await within(E.pull(code, nid, {})));
await E.unload(code);
});
test('a session whose load takes its worker down: twice, a worker of its own; once more, given up; the others keep their places', async () => {
const W = createEngine({ workers: 2, test: TEST, timeouts: ROOMY });
try {
const code = 'P01S0N', nid = 'pois0001', by = { BYST01: 'byst0001', BYST02: 'byst0002' };
for (const [c, n] of Object.entries(by)) checked((await W.load(c, [begin(n)]))[0]);
assert.deepEqual([W.workerOf('BYST01'), W.workerOf('BYST02')], [0, 1]);
// Its load crashes the worker (as a save that overflows the heap would): the worker it shares with BYST01.
const lost = [];
for (let i = 0; i < 2; i++) {
const p = W.load(code, [begin(nid)]);
assert.deepEqual([W.workerOf(code), W.dedicated(code)], [0, false], `attempt ${i + 1}: in the pool`);
W.killOf(code);
await assert.rejects(p, (e) => e.code === 'EXIT');
for (const [c, n] of Object.entries(by)) {
if (!(await W.pull(c, n, {}).then(() => false, (e) => e.code === 'NO_REALM'))) continue;
lost.push(c);
checked((await W.load(c, [begin(n)]))[0]);
assert.equal(W.dedicated(c), false, `${c} is not blamed: it goes back to the pool`);
}
}
assert.deepEqual(lost, ['BYST01', 'BYST01'], 'the bystander on that worker lost its realm each time, the other never');
// Twice within the hour: a worker of its own. An unload and a load back to back stay there, and answer.
checked((await W.load(code, [begin(nid)]))[0]);
assert.deepEqual([W.dedicated(code), W.stats().workers], [true, 3]);
const u = W.unload(code), l = W.load(code, [begin(nid)]);
checked(await within(u));
checked((await within(l))[0]);
checked(await within(W.pull(code, nid, {})));
assert.equal(W.dedicated(code), true);
// Once more, on its own worker: given up until a restart; its worker is not replaced, and the others play on.
const p = W.load(code, [begin('pois0002')]);
W.killOf(code);
await assert.rejects(p, (e) => e.code === 'EXIT');
await assert.rejects(W.load(code, [begin(nid)]), (e) => e.code === 'GAVE_UP');
for (const [c, n] of Object.entries(by)) checked(await within(W.pull(c, n, {})));
assert.deepEqual([W.stats().workers, W.dedicated('BYST01')], [2, false]);
} finally { await W.close(); }
});
test('a polluted prototype stays in its own realm, and that realm is replaced at its next call', async () => {
const code = 'P0WWVT', a = 'poll0001', b = 'poll0002';
(await E.load(code, [begin(a), begin(b)])).forEach(checked);
const ep = checked(await E.pull(code, a, {})).epoch;
assert.equal(await ev(code, a, 'Object.prototype.polluted=1;Array.prototype.evil=()=>1;return ({}).polluted'), 1);
assert.deepEqual(await ev(code, b, 'return [({}).polluted===undefined,[].evil===undefined]'), [true, true]);
assert.equal(({}).polluted, undefined, 'nor the host');
const D = await day(code, 1, [a, b]);
assert.deepEqual([D.nets[a].day, D.nets[a].retried, D.nets[b].day, D.nets[b].retried], [1, true, 1, undefined]);
assert.notEqual(checked(await E.pull(code, a, {})).epoch, ep, 'a fresh realm');
assert.deepEqual(await ev(code, a, 'return [({}).polluted===undefined,[].evil===undefined]'), [true, true]);
await E.unload(code);
});
test('an arg that names a built-in is refused; an act that changes the built-ins all the same leaves a fresh realm and the network as before', async () => {
const code = 'PR0T0S', nid = 'prot0001';
checked((await E.load(code, [begin(nid)]))[0]);
checked(await E.act(code, nid, msg('launchBB', { city: 'fra' })));
const ep = checked(await E.pull(code, nid, {})).epoch;
// The envelope refuses it (tests/mp-sim-contract.test.js); a body that got past it, the realm refuses too.
const r0 = checked(await E.act(code, nid, { ...msg('launchBB', { city: 'ams' }), args: { city: '__proto__' } }));
assert.deepEqual([r0.outcome, r0.why], ['rejected', 'an arg names a built-in']);
assert.equal(await ev(code, nid, 'for(const k in {})return k;return null;'), null);
// An act that writes through a prototype all the same (by hand here): the reply says so, the realm that saw it is
// never used again, and the network is as it was before the act.
const s0 = await ev(code, nid, 'return JSON.stringify(S)');
await ev(code, nid, '{const f=ACT.buildPop;ACT.buildPop=a=>{f(a);Object.prototype.bb={d:null};};}return 1;');
const r1 = checked(await E.act(code, nid, msg('buildPop', { city: 'ams' })));
assert.deepEqual([r1.t, r1.what, /built-ins of the realm changed: Object\.prototype\.bb/.test(r1.msg)], ['err', 'throw', true]);
const P = checked(await E.pull(code, nid, { snap: true }));
assert.notEqual(P.epoch, ep, 'a fresh realm');
assert.equal(await ev(code, nid, 'return JSON.stringify(S)'), s0, 'the act undone');
assert.equal(await ev(code, nid, "for(const k in {})return k;return ACT.buildPop.toString().includes('prototype')"), false, 'clean, with the game\'s own act');
assert.equal(checked(await E.act(code, nid, msg('buildPop', { city: 'ams' }))).outcome, 'applied', 'and it plays on');
// One that also throws (its finally blocks ran: S went back in place, the prototype did not): the same.
await ev(code, nid, "{const f=ACT.buildPop;ACT.buildPop=a=>{f(a);Array.prototype.evil=1;throw new Error('and threw');};}return 1;");
const r2 = checked(await E.act(code, nid, msg('buildPop', { city: 'dus' })));
assert.deepEqual([r2.t, /Array\.prototype\.evil/.test(r2.msg)], ['err', true]);
assert.deepEqual(await ev(code, nid, "for(const k in [])return k;return [!!S.pops.ams,!!S.pops.dus]"), [true, false]);
await E.unload(code);
});
test('a mark that runs out of time changes nothing: no applied action or day is undone, and the reply names the mark', async (t) => {
const W = createEngine({ workers: 1, test: TEST, timeouts: { ...ROOMY, mark: 300 } });
t.after(() => W.close());
const { ev } = on(W);
const code = 'MARKT0', nid = 'mark0001';
checked((await W.load(code, [begin(nid)]))[0]);
assert.equal(checked(await W.act(code, nid, msg('buildPop', { city: 'ams' }))).outcome, 'applied');
checked(await W.day(code, { d: 1, nets: [nid] }));
const ep = checked(await W.pull(code, nid, {})).epoch;
await ev(code, nid, 'srvMark=function(){for(;;){}};return 1;');
const r = checked(await W.act(code, nid, msg('buildPop', { city: 'dus' })));
assert.deepEqual([r.t, r.what, r.msg], ['err', 'timeout', 'marking the network took longer than 300 ms']);
assert.deepEqual(await ev(code, nid, 'return [S.day,!!S.pops.ams,!!S.pops.dus]'), [1, true, false], 'what was applied stays');
assert.notEqual(checked(await W.pull(code, nid, {})).epoch, ep, 'built again from its own save');
// A day whose mark runs out of time: built again from its own save, and the day plays in the fresh realm.
await ev(code, nid, 'srvMark=function(){for(;;){}};return 1;');
const D = checked(await W.day(code, { d: 2, nets: [nid] }));
assert.deepEqual([D.nets[nid].day, D.nets[nid].retried, D.nets[nid].err], [2, true, undefined]);
assert.deepEqual(await ev(code, nid, 'return [S.day,!!S.pops.ams]'), [2, true]);
});
test('a fresh realm after a timeout takes over the fx waiting for a page: badges, windows and toasts', async (t) => {
const W = createEngine({ workers: 1, test: TEST, timeouts: { ...ROOMY, day: 600, act: 400 } });
t.after(() => W.close());
const { ev } = on(W);
const code = 'FXKEEP', nid = 'fxkp0001';
checked((await W.load(code, [begin(nid)]))[0]);
checked(await W.pull(code, nid, { snap: true }));
const ep = checked(await W.pull(code, nid, {})).epoch;
const waiting = (id) => `srvFx(['badge',{id:'${id}',v:'oncall'}]);showWin();toast('still waiting');`;
const kept = (P) => { const k = JSON.parse(P.snap).keep.map((f) => (f[0] === 'badge' ? 'badge:' + f[1].id : f[0] + ':' + f[1])); return k; };
// A day that runs out of time once (the fx were waiting before it), then plays in a fresh realm.
await ev(code, nid, waiting('probe') + '{const f=ddosTick;let once=true;ddosTick=function(){f();if(once){once=false;for(;;){}}};}return 1;');
const D = checked(await W.day(code, { d: 1, nets: [nid] }));
assert.deepEqual([D.nets[nid].day, D.nets[nid].retried], [1, true]);
const P = checked(await W.pull(code, nid, { snap: true }));
assert.notEqual(P.epoch, ep);
assert.ok(kept(P).includes('badge:probe') && kept(P).includes('modal:win'), `kept: ${kept(P)}`);
assert.ok(JSON.parse(P.upd).fx.some(([k, p]) => k === 'toast' && p.h === 'still waiting'), 'and the toast');
// An action that runs out of time: the same, and its own fx are not among them.
await ev(code, nid, waiting('probe2') + "ACT.buildPop=()=>{toast('mine');for(;;){}};return 1;");
const r = checked(await W.act(code, nid, msg('buildPop', { city: 'ams' })));
assert.deepEqual([r.t, r.what], ['err', 'timeout']);
const P2 = checked(await W.pull(code, nid, { snap: true }));
assert.notEqual(P2.epoch, P.epoch);
assert.deepEqual(kept(P2), ['badge:probe2', 'modal:win']);
const fx2 = JSON.parse(P2.upd).fx;
assert.ok(fx2.some(([k, p]) => k === 'toast' && p.h === 'still waiting') && !fx2.some(([k, p]) => k === 'toast' && p.h === 'mine'));
});
test('a network whose realm cannot be built again is dropped: the host is told, its calls answer NO_REALM, the others play on', async (t) => {
const lost = [];
const W = createEngine({ workers: 1, test: TEST, timeouts: { ...ROOMY, act: 400 }, onLost: (c, nids, why) => lost.push([c, nids, why]) });
t.after(() => W.close());
const { ev } = on(W);
const code = 'DR0PPD', a = 'lost0001', b = 'lost0002';
(await W.load(code, [begin(a), begin(b)])).forEach(checked);
// Its marks are no saves that load (as a corrupt state would be), and an act runs for ever inside opsQuiet.
await ev(code, a, "{const m0=srvMark;srvMark=function(i){const r=m0(i);return r.slice(0,r.indexOf('\\n'))+'\\n{\"cash\":';};}ACT.buildPop=()=>opsQuiet(()=>{for(;;){}});return 1;");
const r = checked(await W.act(code, a, msg('buildPop', { city: 'ams' })));
assert.deepEqual([r.t, r.what, /the network was dropped/.test(r.msg)], ['err', 'timeout', true]);
assert.deepEqual(lost.map(([c, nids]) => [c, nids]), [[code, [a]]]);
assert.match(lost[0][2], /rebuilding the realm failed/);
assert.deepEqual([W.has(code, a), W.has(code, b)], [false, true]);
await assert.rejects(W.pull(code, a, {}), (e) => e.code === 'NO_REALM');
await assert.rejects(W.act(code, a, msg('buildPop', { city: 'ams' })), (e) => e.code === 'NO_REALM');
assert.deepEqual(Object.keys(checked(await W.day(code, { d: 1, nets: [a, b] })).nets), [b], 'stopped, not playing; the other plays on');
// The host loads it again from its checkpoint.
checked((await W.load(code, [begin(a)]))[0]);
assert.equal(W.has(code, a), true);
});
test('a day with lists that are not lists is refused whole; the worker and its other sessions go on', async () => {
const code = 'B4DDAY', nid = 'alon0001', other = 'BYSTD1', o = 'byst0009';
checked((await E.load(code, [begin(nid)]))[0]);
checked((await E.load(other, [begin(o)]))[0]);
const w = E.stats().workers;
for (const bad of [{ alone: {} }, { alone: 5 }, { nets: 'x' }]) await assert.rejects(within(E.day(code, { d: 1, nets: [nid], ...bad })), (e) => e.code === 'ERR', JSON.stringify(bad));
assert.equal(checked(await within(E.day(code, { d: 1, nets: [nid], alone: [nid, 7] }))).nets[nid].day, 1);
checked(await within(E.pull(other, o, {})));
assert.deepEqual([E.stats().workers, E.has(other, o)], [w, true]);
await E.unload(code); await E.unload(other);
});
test('an exit counts against the session the worker was running, not one whose load waited behind it; own workers are capped', async (t) => {
const W = createEngine({ workers: 1, test: TEST, timeouts: ROOMY, maxOwn: 1 });
t.after(() => W.close());
// Twice: the hog's call runs for ever while another session's load waits behind it, and the worker dies.
const hog = async (code, nid) => {
for (let i = 0; i < 2; i++) {
checked((await W.load(code, [begin(nid)]))[0]);
const p = W.eval(code, nid, 'for(;;){}', 60000), q = W.load('J01NER', [begin('join0001')]);
for (let k = 0; k < 300 && W.running(0) !== code; k++) await wait(10);
assert.equal(W.running(0), code, 'the worker runs the hog');
W.kill(0);
await assert.rejects(p, (e) => e.code === 'EXIT');
await assert.rejects(q, (e) => e.code === 'EXIT');
}
};
await hog('H0G001', 'hogg0001');
checked((await W.load('H0G001', [begin('hogg0001')]))[0]);
checked((await W.load('J01NER', [begin('join0001')]))[0]);
assert.deepEqual([W.dedicated('H0G001'), W.dedicated('J01NER')], [true, false], 'the hog has a worker of its own, the joiner none');
// Another like it: no third worker (maxOwn 1), given up.
await hog('H0G002', 'hogg0002');
await assert.rejects(W.load('H0G002', [begin('hogg0002')]), (e) => e.code === 'GAVE_UP');
assert.equal(W.stats().workers, 2);
checked(await within(W.pull('J01NER', 'join0001', {}).catch(() => W.load('J01NER', [begin('join0001')]).then((r) => r[0]))));
});
test('a worker that cannot start is not started again at once: after a few tries every call answers SIM_DOWN', async (t) => {
const logs = [];
const W = createEngine({ workers: 1, test: { ...TEST, startFail: true }, startBackoffMs: 10, log: (l, x) => logs.push(String(x)) });
t.after(() => W.close());
await assert.rejects(W.load('D0WN00', [begin('down0001')]), (e) => e.code === 'EXIT' || e.code === 'SIM_DOWN');
for (let k = 0; k < 200 && !logs.some((x) => /server-run play is down/.test(x)); k++) await wait(50);
await assert.rejects(W.load('D0WN00', [begin('down0001')]), (e) => e.code === 'SIM_DOWN');
await assert.rejects(W.pull('D0WN00', 'down0001', {}), (e) => e.code === 'SIM_DOWN');
await assert.rejects(W.day('D0WN00', { d: 1, nets: [] }), (e) => e.code === 'SIM_DOWN');
await wait(300);
assert.deepEqual([logs.filter((x) => /could not start/.test(x)).length, logs.filter((x) => /is down/.test(x)).length], [4, 1], 'five starts, then said once');
});
test('the game is read once: a src/ that does not compile fails at start, and a worker started later runs the same game', async (t) => {
const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'tubes-sim-src-'));
t.after(() => fs.rmSync(tmp, { recursive: true, force: true }));
fs.cpSync(path.join(__dirname, '..', 'src'), path.join(tmp, 'src'), { recursive: true });
const W = createEngine({ workers: 1, test: TEST, timeouts: ROOMY, root: tmp });
t.after(() => W.close());
assert.equal(W.simId, E.simId, 'the same src/, the same build id');
checked((await W.load('SAMEG4', [begin('same0001')]))[0]);
// The checkout changes under a running engine (a pull before the restart), and its worker dies.
fs.appendFileSync(path.join(tmp, 'src', 'game', '99-loop.js'), '\n;globalThis.__pulled=1;\n');
W.kill(0);
for (let k = 0; k < 200 && W.stats().realms; k++) await wait(10);
checked((await W.load('SAMEG4', [begin('same0001')]))[0]);
assert.equal((await W.eval('SAMEG4', 'same0001', 'return typeof globalThis.__pulled')).value, 'undefined', 'the game the engine names, not the one on disk');
fs.appendFileSync(path.join(tmp, 'src', 'game', '99-loop.js'), '\n}}}(\n');
assert.throws(() => createEngine({ workers: 1, root: tmp }), /does not compile/);
});
test('a checkpoint whose route memory is damaged still loads; a save that is no server network does not', async () => {
const code = 'RTDAMG', a = 'rtdm0001';
const [L] = await E.load(code, [begin(a)]);
checked(L);
const s = L.saved.txt, net = (nid, env) => ({ nid, env: { uidN: L.saved.uidN, ...env }, lang: 'en', prefs: {} });
const R = await E.load(code, [
net('rtdm0002', { s, rt: { efg: { x: { g: [1, 2], v: [1] } } } }),
net('rtdm0003', { s: JSON.stringify({ ...JSON.parse(s), mp: null }), rt: null }),
net('rtdm0004', { s: JSON.stringify({ ...JSON.parse(s), mode: 'sandbox' }), rt: null }),
]);
R.forEach(checked);
assert.equal(R[0].err, undefined, R[0].err);
assert.match(R[1].err, /not a server network/);
assert.match(R[2].err, /server networks are Normal games/);
assert.equal(checked(await E.day(code, { d: 1, nets: ['rtdm0002'] })).nets.rtdm0002.day, 1);
await E.unload(code);
});
test('the fake engine fails as the engine does: the same edge calls, the same codes', async (t) => {
const { createFakeEngine } = require('./lib/mp-sim-fake-engine');
const lostR = [], lostF = [];
const R = createEngine({ workers: 1, test: TEST, timeouts: ROOMY, onLost: (c, n, w) => lostR.push([c, n, w]) });
const F = createFakeEngine({ onLost: (c, n, w) => lostF.push([c, n, w]) });
t.after(() => R.close());
const code = 'PAR1TY', a = 'pari0001', b = 'pari0002';
const out = (p) => p.then((r) => (Array.isArray(r) ? r.map((x) => x.err || 'ok') : r && r.t === 'dayDone' ? Object.keys(r.nets) : 'ok'), (e) => 'rejected ' + e.code);
const same = async (what, f) => { const x = await out(f(R)), y = await out(f(F)); assert.deepEqual(y, x, what); return x; };
assert.equal(await same('an act with no realm', (X) => X.act(code, a, msg('buildPop', { city: 'ams' }))), 'rejected NO_REALM');
await same('a load of nothing', (X) => X.load(code, []));
await same('a network twice', (X) => X.load(code, [begin(a), begin(a)]));
await same('neither a save nor a begin', (X) => X.load(code, [{ nid: a, env: { day: 5 }, lang: 'en', prefs: {} }]));
await same('a day of a session that is not here', (X) => X.day('N0SVCH', { d: 1, nets: [a] }));
await same('a load', (X) => X.load(code, [begin(a)]));
await same('a day naming a network that is not loaded', (X) => X.day(code, { d: 1, nets: [a, b] }));
await same('nets that is no list', (X) => X.day(code, { d: 2, nets: 'x' }));
assert.deepEqual([R.has(code, a), F.has(code, a)], [true, true]);
// A worker that dies: a session with nothing pending loses its realms all the same; its next call answers NO_REALM.
R.kill(0); F.exit();
for (let k = 0; k < 200 && !lostR.length; k++) await wait(10);
assert.deepEqual(lostR, lostF);
assert.deepEqual(lostR, [[code, [a], 'exit']]);
assert.equal(await same('a call after the worker died', (X) => X.pull(code, a, {})), 'rejected NO_REALM');
await R.close(); await F.close();
await same('a load after close', (X) => X.load(code, [begin(a)]));
assert.equal(await same('a pull after close', (X) => X.pull(code, a, {})), 'rejected CLOSED');
});
test('a worker that exits rejects every call pending on it; the engine goes on with a new one', async () => {
const W = createEngine({ workers: 1, test: TEST, timeouts: ROOMY });
try {
const code = 'EX1T3D', nid = 'exit0001';
checked((await W.load(code, [{ nid, env: { s: bigScenic(), uidN: 1000, rt: null }, lang: 'en', prefs: {} }]))[0]);
const calls = [W.day(code, { d: 1, nets: [nid] }), W.act(code, nid, msg('buildPop', { city: 'dus' })), W.pull(code, nid, { snap: true }), W.save(code, nid)];
W.kill(0);
for (const p of calls) await assert.rejects(p, (e) => e.code === 'EXIT' && /worker exited/.test(e.message));
assert.deepEqual(W.stats(), { workers: 1, realms: 0, sessions: 0 }, 'its sessions are gone; a new worker took its place');
await assert.rejects(W.act(code, nid, msg('buildPop', { city: 'dus' })), (e) => e.code === 'NO_REALM');
// The host loads the session again (4.7).
checked((await W.load(code, [begin(nid)]))[0]);
assert.equal(W.stats().realms, 1);
} finally { await W.close(); }
});