seriesoftubes/scripts/weekly-architect.js
Frederic Jung dd6e4f4f8a
Fix CodeQL code-scanning alerts
- Values pasted into eval'd or inline-script code go through lit() (scripts/lib/js-literal.js), which escapes <, >, /, U+2028 and U+2029 after JSON.stringify
- build test and i18n-check read script tags with a DOM parser or a plain search, not HTML regexes
- mcp.js parses the Authorization header without a backtracking regex
2026-11-05 21:24:26 +01:00

242 lines
19 KiB
JavaScript

#!/usr/bin/env node
// The weekly Architect run generator, the twin of scripts/weekly-puzzle.js. Every Sunday .github/workflows/weekly-puzzle.yml
// runs it to publish site/architect/weekly/<key>.json, which the game fetches when Puzzles opens
// (src/game/60-features/98-architect-weekly.js). It plays the real game headless, so the briefs are judged by the game's
// own checklist and chaos monkey review.
//
// node scripts/weekly-architect.js the week starting on the coming (or current) Sunday 06:00 Berlin, if missing
// node scripts/weekly-architect.js --key 2026-W45 that week (--force replaces an existing file)
// node scripts/weekly-architect.js --next 3 this week and the next two
// node scripts/weekly-architect.js --check re-play every week not over yet; one whose reference no longer
// earns three stars is regenerated with rev + 1; then validate every file
// --page FILE / --dir DIR another build of the game / where the files live
//
// How a run is made: an HQ in a region the last weeks did not have, and its nearest cities as the sites to come. Then a
// reference architect plays it brief by brief, and each brief is designed against the network it has built so far, so
// every brief asks for something new: a site to connect, a site that one cut would strand made mission-critical, a ring
// it does not have yet, a latency cap its paths miss, a site that closes. The reference builds the cheapest fix it finds
// (connect to the nearest POP; for a site a cut strands, the cheapest tube from the stranded side to the rest on another
// trench or cable) until the game's review passes. Its tube count is the brief's plan, its spend plus a little the
// budget, and the whole run is then replayed from the file and must earn three stars.
const fs = require('node:fs');
const path = require('node:path');
const { game, world } = require('./weekly-puzzle');
const { lit } = require('./lib/js-literal');
const ROOT = path.join(__dirname, '..');
const SCHEMA = 1, HISTORY = 4, ATTEMPTS = 40, DEM_MAX = 380;
const NAMES = ['architect_weekly.name_all_roads_lead_to_hq', 'architect_weekly.name_the_hq_job', 'architect_weekly.name_hq_and_friends'];
const JOKES = ['architect_weekly.joke_hq_signed_the_lease', 'architect_weekly.joke_one_network_a_handful'];
const hash = (s) => { let h = 2166136261; for (let i = 0; i < s.length; i++) { h ^= s.charCodeAt(i); h = Math.imul(h, 16777619); } return h >>> 0; };
function rng(seed) { let a = seed >>> 0 || 1; return () => { a = (a + 0x6D2B79F5) >>> 0; let t = a; t = Math.imul(t ^ (t >>> 15), t | 1); t ^= t + Math.imul(t ^ (t >>> 7), t | 61); return ((t ^ (t >>> 14)) >>> 0) / 4294967296; }; }
const pick = (r, a) => a[Math.floor(r() * a.length)];
const shuffle = (r, a) => { a = a.slice(); for (let i = a.length - 1; i > 0; i--) { const j = Math.floor(r() * (i + 1)); [a[i], a[j]] = [a[j], a[i]]; } return a; };
const ceil10k = (x) => Math.ceil(x / 10000) * 10000;
const list = (dir) => (fs.existsSync(dir) ? fs.readdirSync(dir).filter((f) => /^\d{4}-W\d{2}\.json$/.test(f)).map((f) => f.slice(0, -5)).sort() : []);
const J = (ev, code) => JSON.parse(ev(`JSON.stringify(${code})`));
// ---------- playing the game ----------
// Load a run definition into the page as this week's, with the briefs known so far.
function stage(ev, key, hq, briefs) {
ev(`UI.arWk={key:'${key}',def:{id:arWkId('${key}'),key:'${key}',wk:true,n:'',j:'',hq:'${hq}',via:[],budget:2e7,briefs:${lit(briefs)},rev:1},at:Date.now()}`);
}
// Lay one tube the way a player does: a diverse trench when the pair already has one overland. The size is what all
// the traffic needs (100G, or 400G once there is more than 100G), smaller where a long cable cannot take it.
const tierFor = (ev) => (ev('S.pz.cities.reduce((a,c)=>a+(c===S.ar.hq?0:arDem(c)),0)') > 100 ? 2 : 1);
function lay(ev, a, b, via, tier) {
if (!ev(`!!S.pops['${a}']`)) [a, b] = [b, a];
const n = ev('S.links.length');
for (let t = tier == null ? tierFor(ev) : tier; t >= 0; t--) {
ev(`ACT.pzLinkTo({a:'${a}',b:'${b}'});ACT.pzVia({v:'${via}'});ACT.pzDiv({v:1});ACT.pzLink({tier:${t}});closeModal()`);
if (ev('S.links.length') === n + 1) return [a, b, via, t];
if (tier != null) break;
}
throw new Error(`could not lay ${a}-${b} ${via}`);
}
// One step of a reference, as the file keeps it: a tube [a, b, route, size], ['@rm', city] closing a POP, or
// ['@tier', n, size] resizing the n-th tube.
function step(ev, s) {
if (s[0] === '@rm') { ev(`ACT.pzRmPop({city:'${s[1]}'})`); return; }
if (s[0] === '@tier') { const n = ev(`(()=>{const l=S.links[${s[1]}];ACT.pzTier({id:l.id,tier:${s[2]}});return S.links[${s[1]}].tier;})()`); if (n !== s[2]) throw new Error(`could not resize tube ${s[1]}`); return; }
lay(ev, s[0], s[1], s[2], s[3]);
}
// Room for the traffic: upsize the busiest tube that is not cut (or, when it cannot grow, lay a second one beside it).
function makeRoom(ev, W, steps, cut) {
const ls = J(ev, `(()=>{${cut ? `for(const l of S.links)if(pzUnit(l)===${lit(cut)})l.cut=1;` : ''}compute();const o=S.links.map((l,i)=>({i,a:l.a,b:l.b,cut:!!l.cut,tier:l.tier,u:(R.load[l.id]||0)/capOf(l)})).filter(x=>!x.cut).sort((x,y)=>y.u-x.u);for(const l of S.links)l.cut=0;compute();return o;})()`);
for (const l of ls.slice(0, 3)) {
if (l.tier < 2) { const t = ev(`(()=>{const l=S.links[${l.i}];ACT.pzTier({id:l.id,tier:${l.tier + 1}});return S.links[${l.i}].tier;})()`); if (t === l.tier + 1) { steps.push(['@tier', l.i, t]); return; } }
const o = W.opts(l.a, l.b).filter((x) => !x.second).sort((x, y) => x.cost - y.cost)[0];
if (o) { try { steps.push(lay(ev, o.a, o.b, o.via)); return; } catch (e) { /* try the next tube */ } }
}
throw new Error('no room to be made');
}
// What the review would say: the first cut that strands a mission-critical site or leaves a site short.
const reviewFail = (ev) => J(ev, `(()=>{let f=null;for(const u of [...new Set(S.links.map(pzUnit))]){const x=arCut(u);for(const l of x.ls)l.cut=0;if(x.gold.length||x.short.length){f={u,gold:x.gold,short:x.short,dark:x.dark};break;}}compute();return f;})()`);
const passes = (ev) => ev('arShowStart();arShowSkip();S.ar.passed===pzSig()');
// The reference architect: fix what the checklist and the review find, cheapest first, until the brief passes.
function solveBrief(ev, W, steps) {
for (let guard = 0; guard < 24; guard++) {
for (const c of J(ev, 'S.pz.avoid.filter(c=>S.pops[c])')) { ev(`ACT.pzRmPop({city:'${c}'})`); steps.push(['@rm', c]); }
const e = J(ev, '(()=>{const e=arEval(),r=[...arReach(S.ar.hq,arAdj())];return {conn:e.conn,lat:e.lat,rings:e.rings,ready:e.ready,why:e.why,r,miss:e.sites.filter(s=>!s.ok).map(s=>s.c)};})()');
const best = (from, to, skip) => { let o = null; for (const a of from) for (const b of to) if (a !== b) for (const x of W.opts(a, b)) if (!x.second && x.unit !== skip && (!o || x.cost < o.cost)) o = x; return o; };
if (!e.conn) { const c = e.miss[0], o = best([c], e.r); if (!o) throw new Error(`no way to ${c}`); steps.push(lay(ev, o.a, o.b, o.via)); continue; }
if (e.lat && !e.lat.ok) { const os = W.opts(e.lat.a, e.lat.b).filter((x) => !x.second && x.ms <= e.lat.cap).sort((x, y) => x.cost - y.cost); if (!os.length) throw new Error('latency cap out of reach'); steps.push(lay(ev, os[0].a, os[0].b, os[0].via)); continue; }
const rg = e.rings.find((x) => !x.ok);
if (rg) { const cs = rg.cs, has = J(ev, 'S.links.map(l=>edgeKey(l))'); let done = false;
for (let i = 0; i < cs.length && !done; i++) { const a = cs[i], b = cs[(i + 1) % cs.length]; if (has.includes(ev(`edgeKey({a:'${a}',b:'${b}'})`))) continue; const o = best([a], [b]); if (o) { steps.push(lay(ev, o.a, o.b, o.via)); done = true; } }
if (!done) throw new Error('ring out of reach'); continue; }
if (!e.ready) { if (/thin/i.test(e.why) || J(ev, 'arEval().sites.some(s=>!s.full)')) { makeRoom(ev, W, steps, null); continue; } throw new Error(`not ready: ${e.why}`); }
const f = reviewFail(ev); if (!f) return;
if (f.short.length && !f.gold.length) { makeRoom(ev, W, steps, f.u); continue; }
// A cut strands a mission-critical site: join the stranded side to the rest another way.
const rest = J(ev, `Object.keys(S.pops).filter(c=>!${lit(f.dark)}.includes(c))`), o = best(f.dark, rest, f.u);
if (!o) throw new Error('no second way'); steps.push(lay(ev, o.a, o.b, o.via));
}
throw new Error('the brief would not pass');
}
// ---------- designing a run ----------
// The brief kinds after the first two. Each is designed against the reference network as it stands, or refused (null).
function design(kind, ev, W, r, s) {
const pops = J(ev, 'S.pz.cities'), gold = J(ev, 'S.ar.gold'), hq = s.hq, next = () => s.todo.shift(), dem = (c) => { const g = Math.min(s.room, pick(r, [10, 20, 20, 30])); s.room -= g; return { [c]: g }; };
const weak = J(ev, `S.pz.cities.filter(c=>c!==S.ar.hq&&!S.ar.gold.includes(c)&&[...new Set(S.links.map(pzUnit))].some(u=>arDark(u).includes(c)))`);
if (kind === 'gold') { if (!weak.length) return null; const c = weak.sort((a, b) => W.km(hq, b) - W.km(hq, a))[0]; return { gold: [c] }; }
if (kind === 'addgold') { if (!s.todo.length || s.room < 10) return null; const c = next(); return { add: [c], dem: dem(c), gold: [c] }; }
if (kind === 'move') { const c = pops.filter((x) => x !== hq && !gold.includes(x) && !(s.lat || []).includes(x)).sort((a, b) => W.km(hq, b) - W.km(hq, a))[0];
if (!c || !s.todo.length || s.room < 10) return null; const n = next(); return { drop: [c], add: [n], dem: dem(n), gold: [n] }; }
if (kind === 'lat') { let bestP = null;
for (const a of pops) for (const b of pops) { if (a >= b) continue; const cur = J(ev, `arLat('${a}','${b}')`), os = W.opts(a, b).filter((x) => !x.second); if (cur == null || !os.length) continue;
const ms = Math.min(...os.map((x) => x.ms)), cap = Math.ceil(ms * 1.12 * 10) / 10; if (cap < 2 || cap >= cur * 0.85) continue;
if (!bestP || cur / cap > bestP.k) bestP = { a, b, cap, k: cur / cap }; }
if (!bestP) return null; s.lat = [bestP.a, bestP.b]; return { lat: [bestP.a, bestP.b, bestP.cap] }; }
if (kind === 'grow') { const cs = pops.filter((c) => c !== hq).map((c) => [c, ev(`arDem('${c}')`)]).sort((x, y) => y[1] - x[1]); if (!cs.length || s.room < 60) return null;
const [c, d] = cs[0], g = d + Math.min(s.room, pick(r, [60, 90, 120])); s.room -= g - d; return { dem: { [c]: g } }; }
if (kind === 'ring') { const cs = pops.filter((c) => c !== hq).sort((a, b) => W.km(hq, a) - W.km(hq, b)).slice(0, 2); if (cs.length < 2) return null;
const ring = [hq, ...cs]; if (ev(`arRingOk(${lit(ring)})`)) return null; return { ring }; }
return null;
}
// Play a run from scratch: stage, start, then brief by brief design (when designing) or follow the file, solve, review, next.
function play(g, W, key, hq, plan, r, sites) {
const { ev } = g, briefs = [], steps = [], s = { hq, todo: sites.slice(), room: DEM_MAX, lat: null };
const first = () => { const c = s.todo.shift(), g0 = Math.min(s.room, pick(r, [20, 30, 40])); s.room -= g0; return { add: [c], dem: { [c]: g0 } }; };
for (let i = 0; i < plan.length; i++) {
let b = null;
if (plan[i] === 'add1') b = first();
else if (plan[i] === 'add2') { if (s.todo.length < 2) throw new Error('not enough sites'); const a = s.todo.shift(), c = s.todo.shift(), ga = Math.min(s.room, 20); s.room -= ga; const gc = Math.min(s.room, pick(r, [10, 20])); s.room -= gc; b = { add: [a, c], dem: { [a]: ga, [c]: gc } }; }
// A kind that cannot be made here gives way to one the run has not had yet, then to a new mission-critical site.
else for (const k of [plan[i], ...['lat', 'ring', 'move', 'grow', 'gold'].filter((x) => !plan.slice(0, i).includes(x) && x !== plan[i]), 'addgold']) { b = design(k, ev, W, r, s); if (b) { plan[i] = k; break; } }
if (!b) throw new Error(`brief ${i + 1}: nothing left to ask`);
b.tubes = 9; briefs.push(b); stage(ev, key, hq, briefs.map((x) => Object.assign({ t: '' }, x)));
if (i === 0) ev(`ACT.pzArStart({id:arWkId('${key}')})`); else ev('ACT.pzArNext()');
if (ev('S.ar.bi') !== i) throw new Error(`brief ${i + 1} did not start`);
const st = []; solveBrief(ev, W, st); steps.push(st);
b.tubes = ev('S.links.filter(l=>(l.br|0)===S.ar.bi).length');
if (!st.length) throw new Error(`brief ${i + 1} asks for nothing new`);
ev(`UI.arWk.def.briefs[${i}].tubes=${b.tubes}`);
if (!passes(ev)) throw new Error(`brief ${i + 1}: the review does not pass`);
}
return { briefs, steps, spend: ev('arSpend()') };
}
// Replay a file the way a player would, from its own reference: it must pass every brief and earn three stars.
function verify(g, j, key) {
const { ev } = g, def = J(ev, `arWkValid(${lit(j)},'${key}')`);
if (!def) return { ok: false, why: 'the game rejects it' };
if (!j.ref || !Array.isArray(j.ref.steps) || j.ref.steps.length !== def.briefs.length) return { ok: false, why: 'no reference' };
try {
ev(`UI.arWk={key:'${key}',def:arWkValid(${lit(j)},'${key}'),at:Date.now()}`);
ev(`ACT.pzArStart({id:arWkId('${key}')})`);
for (let i = 0; i < def.briefs.length; i++) {
for (const st of j.ref.steps[i]) step(ev, st);
if (!passes(ev)) return { ok: false, why: `brief ${i + 1} does not pass` };
if (i < def.briefs.length - 1) ev('ACT.pzArNext()');
}
const sp = ev('arSpend()'), stars = ev(`arStars(${sp})`);
ev('arStop(true)');
return stars === 3 ? { ok: true, spend: sp } : { ok: false, why: `the reference earns ${stars} stars (spend ${sp}, budget ${j.budget})` };
} catch (e) { return { ok: false, why: e.message }; }
}
function generate(g, key, dir) {
const { ev } = g, W = world(ev);
// The regions of the last weeks, so the HQ moves around the world.
const past = list(dir).filter((k) => k < key).map((k) => { try { return JSON.parse(fs.readFileSync(path.join(dir, k + '.json'), 'utf8')).hq; } catch (e) { return null; } });
const recent = past.slice(-HISTORY).map((c) => W.C[c] && W.C[c].reg), used = past.slice(-12);
for (let attempt = 0; attempt < ATTEMPTS; attempt++) {
const r = rng(hash(`architect|${key}|${attempt}`));
const hqs = W.cities.filter((c) => !used.includes(c.id) && (!recent.includes(c.reg) || attempt >= ATTEMPTS / 2));
const hq = pick(r, hqs).id;
const near = W.cities.filter((c) => c.id !== hq && c.reg === W.C[hq].reg && W.km(hq, c.id) < 2500).sort((a, b) => W.km(hq, a.id) - W.km(hq, b.id)).slice(0, 8).map((c) => c.id);
if (near.length < 6) continue;
const mid = shuffle(r, ['lat', 'ring', 'move', 'addgold', 'grow']).slice(0, r() < 0.5 ? 2 : 3);
const plan = ['add1', 'add2', 'gold', ...mid, 'gold'];
const sites = [...near.slice(0, 3), ...shuffle(r, near.slice(3))];
try {
const run = play(g, W, key, hq, plan, r, sites);
const jk = pick(r, JOKES), j = { v: SCHEMA, key, hq, budget: ceil10k(run.spend * 1.06), name: { l: pick(r, NAMES), p: { hq } }, joke: { l: jk, p: jk === JOKES[0] ? { hq } : {} }, briefs: run.briefs, ref: { spend: run.spend, steps: run.steps } };
const v = verify(g, j, key);
if (!v.ok) { if (process.env.DEBUG) console.warn(`${key} #${attempt}: ${v.why}`); continue; }
return j;
} catch (e) { if (process.env.DEBUG) console.warn(`${key} #${attempt} (${hq}): ${e.message}`); }
}
throw new Error(`${key}: no run survived verification`);
}
// --check: every file is what the game accepts, under its own name, and the weeks still to come earn three stars.
function check(g, dir, now = Date.now()) {
const { ev } = g, bad = [], keys = list(dir);
for (const k of keys) {
let j; try { j = JSON.parse(fs.readFileSync(path.join(dir, k + '.json'), 'utf8')); } catch (e) { bad.push(`${k}: not JSON`); continue; }
if (!ev(`!!arWkValid(${lit(j)},'${k}')`)) { bad.push(`${k}: the game rejects it`); continue; }
if (ev(`pzWeekStart('${k}')`) + 7 * 864e5 > now) { const v = verify(g, j, k); if (!v.ok) bad.push(`${k}: ${v.why}`); }
}
if (keys.length) {
let idx = null; try { idx = JSON.parse(fs.readFileSync(path.join(dir, 'index.json'), 'utf8')); } catch (e) { /* reported below */ }
if (!idx || idx.v !== SCHEMA || JSON.stringify(idx.weeks) !== JSON.stringify(keys)) bad.push('index.json does not list exactly the weekly files');
}
return bad;
}
// A release can change prices under weeks already out: a week not over yet whose reference no longer earns three stars
// is regenerated with its rev up, so players' stars for that week (only that week) start again. Past weeks stay.
function refresh(g, dir, now = Date.now()) {
const { ev } = g, fixed = [], bad = [];
for (const k of list(dir)) {
let j = null; try { j = JSON.parse(fs.readFileSync(path.join(dir, k + '.json'), 'utf8')); } catch (e) { /* regenerated below */ }
const valid = !!j && ev(`!!arWkValid(${lit(j)},'${k}')`), live = ev(`pzWeekStart('${k}')`) + 7 * 864e5 > now;
if (valid && (!live || verify(g, j, k).ok)) continue;
const rev = (j && Number.isInteger(j.rev) && j.rev >= 2 ? j.rev : 1) + 1;
try { writeWeek(dir, Object.assign(generate(g, k, dir), { rev })); fixed.push(`${k}: regenerated as rev ${rev}`); } catch (e) { bad.push(`${k}: could not regenerate (${e.message})`); }
}
let idx = null; try { idx = JSON.parse(fs.readFileSync(path.join(dir, 'index.json'), 'utf8')); } catch (e) { /* rewritten */ }
if (list(dir).length && (!idx || idx.v !== SCHEMA || JSON.stringify(idx.weeks) !== JSON.stringify(list(dir)))) { writeIndex(dir); fixed.push('index.json rewritten'); }
return { fixed, bad };
}
const writeIndex = (dir) => fs.writeFileSync(path.join(dir, 'index.json'), JSON.stringify({ v: SCHEMA, weeks: list(dir) }) + '\n');
const writeWeek = (dir, j) => { fs.mkdirSync(dir, { recursive: true }); fs.writeFileSync(path.join(dir, j.key + '.json'), JSON.stringify(j) + '\n'); writeIndex(dir); };
const say = (j) => `${j.key}: HQ ${j.hq}, ${j.briefs.length} briefs (${j.briefs.map((b) => Object.keys(b).filter((k) => k !== 'tubes' && (k !== 'dem' || !b.add)).map((k) => (k === 'dem' ? 'grow' : k)).join('+')).join(', ')}), budget ${j.budget}, reference ${j.ref.spend}`;
module.exports = { generate, verify, check, refresh, writeWeek, writeIndex, list, say, step };
if (require.main === module) {
const args = process.argv.slice(2), opt = (n, d) => { const i = args.indexOf(n); return i >= 0 ? args[i + 1] : d; };
const dir = path.resolve(ROOT, opt('--dir', 'site/architect/weekly')), g = game(opt('--page') && path.resolve(opt('--page')));
if (!g.ev("typeof arWkValid==='function'")) { console.log('This game has no weekly Architect runs yet.'); process.exit(0); }
if (args.includes('--check')) {
const r = refresh(g, dir);
for (const x of r.fixed) console.log(`fixed: ${x}`);
const bad = [...r.bad, ...check(g, dir)];
for (const b of bad) console.error(`error: ${b}`);
console.log(bad.length ? `${bad.length} problem(s)` : `${list(dir).length} weekly Architect run(s) OK`);
process.exit(bad.length ? 1 : 0);
}
const first = opt('--key') || g.ev(`pzWeekKey(Date.now()+12*3600e3)`), n = +opt('--next', 1);
for (let i = 0; i < n; i++) {
const key = g.ev(`pzKeyAdd('${first}',${i})`);
if (!key) { console.error(`error: ${first} is not a week`); process.exit(1); }
if (fs.existsSync(path.join(dir, key + '.json')) && !args.includes('--force')) { console.log(`${key}: already there`); continue; }
const j = generate(g, key, dir); writeWeek(dir, j); console.log(say(j));
}
}