seriesoftubes/scripts/lib/mcp-commands.js

816 lines
63 KiB
JavaScript

// Runs inside the game page before scripts/lib/mcp-page.js, in the game's own global scope: the typed command
// tables the MCP server's act tool dispatches through. Data and small helpers only, no state.
//
// Every action in ACT is in exactly one class (tests/mcp-commands.test.js fails otherwise, so a new action forces a
// decision): CMD, a game command with typed arguments; VIEW, which changes only what is on screen; BOUND, which only
// drafts an input another command reads; SESSION, which starts, retries or leaves a game or dismisses a coaching
// screen; or the server's DENY list (scripts/lib/mcp-page.js). CMD fields: args [name, domain|'string'|'boolean'|'integer', required]; bind(args) writes the UI
// a panel would set (bindsUI: the UI keys it touches, restored after a dry run); open/dom: the window an input lives
// in and the fields that must exist before dispatch; pass(args) reshapes the args for the action (confirmations);
// confirm 'arg' (passed through) or 'double' (the game arms a button first); decides (may end in a question); reads
// 'modal' (the window's text is the report); watch (extra fingerprint paths, #name filled from args); quote (the dry
// run, priced with the game's own helpers); doc.
window.__mcpCmds = (() => {
const API_DOMAINS={
// Tables from the catalog: an id in a list, a key in an object, or an index into a list.
cityId:{table:'CITIES',kind:'id'},
netId:{table:'NETS',kind:'id'},
cableId:{table:'CABLES',kind:'id'},
fabId:{table:'FAB',kind:'key'},
opticId:{table:'OPT',kind:'key'},
systemId:{table:'DF_SYS',kind:'key'},
designId:{table:'SEA_DESIGNS',kind:'key'},
upgradeId:{table:'SUB_UPGRADES',kind:'key'},
bizTypeId:{table:'BIZ_T',kind:'key'},
portTier:{table:'PORT',kind:'index'},
linkTier:{table:'LT',kind:'index'},
nniTier:{table:'NNI',kind:'index'},
vxcTier:{table:'VXC',kind:'index'},
routerModel:{table:'RG',kind:'index'},
scrubTier:{table:'SCRUB_TIERS',kind:'index'},
// Small fixed vocabularies the game itself checks by list membership.
// The link metric presets, plus "custom" for a hand-tuned number (ACT.setMetric).
metric:{kind:'enum',values:()=>[...Object.keys(MET),'custom']},
egress:{table:'PREF',kind:'key'},
routeMode:{table:'RT',kind:'key'},
site:{kind:'enum',values:['a','b','ab']},
step:{kind:'enum',values:[1,-1]},
connKind:{kind:'enum',values:['t','p','ix','c','nni']},
egressKind:{kind:'enum',values:['t','p','ix','c','nni','l2']},
peerPolicy:{table:'PPOL',kind:'enum'},
// The intern, their orders and the new-POP template (opsHire, opsToggle, opsParam…).
internId:{table:'INTERNS',kind:'key'},
opsKey:{table:'OPSK',kind:'key'},
opsPopKind:{kind:'enum',values:()=>OPS_POP.slice()},
opsTplKey:{kind:'enum',values:()=>OPS_TPL.slice()},
// The specialist's offers: a seat on a consortium cable, the charter, a vendor demo.
seatPairs:{kind:'enum',values:()=>SEAT_N.slice()},
charterKey:{table:'CHARTERS',kind:'key'},
// The link metric editor: a factor or an exact weight (metricMode, metricSet).
metricKind:{kind:'enum',values:['f','w']},
// The NOC's auto-mitigation switches (ddosAuto).
ddosKey:{kind:'enum',values:['rtbh','scrub']},
// Puzzle and architect builds: the tiers a puzzle may light, the router models it offers.
pztTier:{kind:'fn',ok:v=>PZ_TIERS.includes(+v)||AR_TIERS.includes(+v)},
pzRouterModel:{table:'PZ_RG',kind:'index'},
pzRouteMode:{kind:'enum',values:['normal','fast']},
// The bulk PNI order takes one network or null for every network at every shared POP (ACT.pniAll).
pniAllNet:{kind:'fn',ok:v=>v===null||(typeof v==='string'&&!!NET[v])},
dashTab:{kind:'enum',values:()=>DTABS.slice()},
dashSortKey:{kind:'enum',values:['name','asn','type','traffic','cost','lost']},
leftTab:{kind:'enum',values:['goals','deals','noc','nets']},
netFilter:{kind:'enum',values:['all','out']},
pniFilter:{kind:'enum',values:['all','t','worth','pni']},
listPage:{kind:'enum',values:['conn','cust','nets','pni']},
custSortKey:{kind:'enum',values:['mood','mo','name','city']},
connFilter:{kind:'enum',values:['all','k']},
connSortKey:{kind:'enum',values:['k','city','name','use','mo']},
dfSource:{kind:'enum',values:['lease','build','cable']},
cityIdArray:{kind:'array',of:'cityId'},
// Anything a panel can reach: an exchange city, a rival exchange id, one of your own exchanges.
ixId:{kind:'fn',ok:v=>isIx(v)},
// A PNI also takes tier:-1, the 1G courtesy port a network may offer (ACT.pni).
pniTier:{kind:'fn',ok:v=>v===-1||(Number.isInteger(v)&&v>=0&&v<PORT.length)},
// Keys are built at render time by confKey(), so they can only be resolved against the calendar.
confKey:{kind:'fn',ok:v=>typeof v==='string'&&upcomingConfs(75).some(c=>c.key===v)},
// traceroute goes to your own POPs and to networks; traceModal parses a net:/city: prefix.
traceTo:{kind:'fn',ok:v=>typeof v==='string'&&(NET[v]||isCity(v))},
// Entity ids (uid()) cannot be validated against a table: shape only. A wrong id is the game's
// to answer, honestly, with no_effect — never a refusal invented on this side of the wall.
entityId:{kind:'string'},
scnId:{table:'SCN',kind:'id'},
// A traceroute target in the modal's own terms.
};
/* Type names an arg can take instead of a domain: 'string' | 'boolean' | 'integer'. */
function apiDomCheck(dom,v){
const d=API_DOMAINS[dom];
// The game's own buttons ship truthiness as 0 and 1 (custOpen's {"sad":0}); accept the game's dialect.
if(dom==='boolean')return {ok:v===true||v===false||v===0||v===1};
if(!d)return {ok:dom==='integer'?Number.isInteger(v):typeof v===dom}; // 'string' | 'integer'
if(d.kind==='array')return {ok:Array.isArray(v)&&v.every(x=>apiDomCheck(d.of,x).ok)};
const t=d.table?API_CATALOG_TABLE(d.table):null;
if(d.kind==='id')return {ok:!!t&&t.some(x=>x&&x.id===v)};
if(d.kind==='string')return {ok:typeof v==='string'};
if(d.kind==='key'||d.kind==='enum'){
const vs=d.kind==='key'?Object.keys(t||{}):(t||(typeof d.values==='function'?d.values():d.values)||[]);
return {ok:vs.includes(v)};}
if(d.kind==='index')return {ok:Number.isInteger(v)&&v>=0&&v<(t?t.length:0)};
return {ok:!!d.ok&&d.ok(v)};
}
function apiDomValues(dom){
const d=API_DOMAINS[dom];if(!d)return null;
const t=d.table?API_CATALOG_TABLE(d.table):null;
if(d.kind==='array')return {of:d.of};
if(d.kind==='id')return t?t.map(x=>x.id):[];
if(d.kind==='key')return t?Object.keys(t):[];
if(d.kind==='enum')return t||(typeof d.values==='function'?d.values():d.values)||[];
if(d.kind==='index')return {from:0,to:(t?t.length:1)-1};
return null;
}
const API_CMD={
/* ---------- footprint: buildings, routers, POPs ---------- */
buildPop:{args:[['city','cityId']],
quote:a=>({setup:popCost(a.city),blocked:cnCity(a.city)&&!cnOk()?[tr('pops_transit_ix.you_need_a_license_first_foreign')]:[]}),
doc:'Open a POP in a city you do not have one in. Costs popCost(city).'},
launchBB:{args:[['city','cityId']],watch:['pops.#city'],
quote:a=>({setup:bbCost(a.city)}),
doc:'Launch broadband to the eyeballs of a city you have a POP in. The core revenue source; one per POP.'},
ad:{args:[['city','cityId']],watch:['pops.#city'],
quote:a=>({setup:8000}),
doc:'A 30-day ad campaign that boosts eyeball growth in a broadband city.'},
addRouter:{args:[['city','cityId']],watch:['pops.#city'],
quote:a=>{const p=S.pops[a.city];return {setup:p?routerCost(p.rgen||0,p.routers||1):0};},
doc:'Add a router to a POP, up to RMAX. Cost rises with the model and the count.'},
rmRouter:{args:[['city','cityId']],watch:['pops.#city'],
quote:a=>{const p=S.pops[a.city];return {setup:-((p&&tradeIn(p.rgen||0,1))||0),blocked:p&&portsUsed(a.city)>portsMax(a.city,undefined,p.routers-1)?[tr('routing_and_routers.unplug_something_first_used_ports',{used:fmtPorts(portsUsed(a.city)),max:portsMax(a.city,undefined,p.routers-1)})]:[]};},
doc:'Remove a router and sell it on eBuy for a trade-in. Refused while the rest cannot carry the ports.'},
upRouter:{args:[['city','cityId'],['g','routerModel',false]],watch:['pops.#city'],
quote:a=>{const p=S.pops[a.city];if(!p)return {};const g=a.g===undefined?mainRG(RG[p.rgen||0].cls+1):+a.g;
return {setup:swapCost(a.city,g),blocked:[(!RG[g]||g===(p.rgen||0))?'no such model':modelFits(a.city,g)||''].filter(Boolean)};},
doc:'Swap every router in a city for another model. Omit g for the next class up. One swap per day per city.'},
addGen:{args:[['city','cityId']],watch:['pops.#city'],quote:a=>({setup:GEN_COST,monthly:GEN_MO}),
doc:'Install a generator, so a power cut does not take the POP out.'},
addSite:{args:[['city','cityId']],watch:['pops.#city'],quote:a=>({setup:SITE2_COST,monthly:SITE2_MO}),
doc:'Add a second building in the city, so one dark data centre does not take everything down.'},
rmSite:{args:[['city','cityId']],confirm:'double',watch:['pops.#city'],
doc:'Remove the second building. Every port, PNI and cache there moves back to site A.'},
decomGo:{args:[['cities','cityIdArray']],bindsUI:['decom'],bind:a=>{UI.decom=new Set((a.cities||[]).filter(c=>S.pops[c]));},
doc:'Close POPs: cancels their ports, links, peerings and customers. Refuses to close every POP you have. Irreversible.'},
/* ---------- upstream (transit) ---------- */
buyTransit:{args:[['city','cityId'],['net','netId'],['tier','portTier']],
quote:a=>({setup:PORT[a.tier].setup,monthly:PORT[a.tier].tmo}),
doc:'Order a transit port from a network that sells in that city. Billed monthly on the 95th percentile. A higher tier on an existing port upgrades it.'},
lagT:{args:[['id','entityId'],['d','step']],watch:['transit.#id'],
quote:a=>{const t=S.transit.find(x=>x.id===a.id);return {setup:a.d>0&&t?PORT[t.tier].setup:0};},
doc:'Add or remove one LAG member on a transit port, up to LAG_MAX. Adding charges another port setup.'},
cancelTransit:{args:[['id','entityId']],confirm:'arg',pass:a=>({id:a.id,ok:1}),
doc:'Cancel a transit port.'},
togglePrem:{args:[['id','entityId']],watch:['transit.#id'],
doc:'Turn the premium upstream product on or off, where the network sells one in that city.'},
cleanPipe:{args:[['id','entityId']],watch:['transit.#id'],
quote:a=>{const t=S.transit.find(x=>x.id===a.id);return t?{monthly:cleanMo(t)}:{};},
doc:'Add or remove the upstream DDoS-scrubbing add-on. Monthly.'},
/* ---------- exchanges ---------- */
buyIx:{args:[['city','ixId'],['tier','portTier'],['signed','boolean',false]],decides:true,
quote:a=>({setup:ixPortMo(a.city,a.tier),monthly:ixPortMo(a.city,a.tier),blocked:[portOk(ixCity(a.city),a.tier)?'':tr('actions.your_router_can_t_take_a',{port:PORT[a.tier].n})].filter(Boolean)}),
doc:'Take a port on an internet exchange. Monthly. At a De-Kicks exchange the first order returns a personalised quote to answer. A remote port (no POP) is possible at 10G over a fabric.'},
lagIx:{args:[['city','ixId'],['d','step']],watch:['ixn'],
doc:'Add or remove one LAG member on an IX port. Not on your own exchange.'},
cancelIx:{args:[['city','ixId']],confirm:'arg',pass:a=>({city:a.city,ok:1}),decides:true,
doc:'Leave an exchange; drops every peering session there. De-Kicks may answer with a retention offer.'},
rs:{args:[['city','ixId']],watch:['rs'],
doc:'Toggle the route-server session, which peers you with everyone on the server at once.'},
foundIx:{args:[['city','cityId']],watch:['myIx.#city'],quote:a=>({setup:MYIX_COST,monthly:MYIX_MO}),
doc:'Found your own exchange in a city with no IX. Networks join over the following days.'},
myIxUp:{args:[['city','cityId']],watch:['myIx.#city'],
quote:a=>{const m=S.myIx[a.city];const f=m?(m.fab|0)+1:0,N=f<MYIX_FAB.length?MYIX_FAB[f]:null;return N?{setup:N.cost,monthly:N.mo}:{};},
doc:'Upgrade your own exchange\'s switch fabric. Each step has a level gate.'},
/* ---------- peering and PNIs ---------- */
peer:{args:[['city','ixId'],['net','netId']],
doc:'Ask one network at an exchange for a session. Rejected with the network\'s own reason if its policy says no.'},
unpeer:{args:[['city','ixId'],['net','netId']],
doc:'Drop a peering session.'},
peerAll:{args:[['city','ixId']],
doc:'Ask everyone at that exchange who would say yes. No effect if there is nobody new.'},
pni:{args:[['city','cityId'],['net','netId'],['tier','pniTier']],
quote:a=>{const t=a.tier===-1?0:a.tier,ex=S.pni.find(p=>p.city===a.city&&p.net===a.net),r=peerOk(a.net,'pni',a.city);
return {setup:a.tier===-1?PNI_G1_COST:(1500+PORT[t].setup/2)*((ex&&ex.n)||1),monthly:(a.tier===-1?Math.round(PORT[0].pni/2):PORT[t].pni)*((ex&&ex.n)||1),days:pniLead(a.net),
blocked:[r.ok?'':r.why,portOk(a.city,t)?'':tr('actions.your_router_can_t_take_a',{port:PORT[t].n}),
a.tier!==-1&&a.tier<pniMin(a.net)?tr('sites_peering_caches.net_does_not_do_port_pnis',{net:NET[a.net].name,port:PORT[t].n}):''].filter(Boolean)};},
doc:'Order a private interconnect. tier:-1 asks for the 1G courtesy PNI where a network offers one. Takes weeks to months; an existing PNI is augmented instead.'},
pniChase:{args:[['id','entityId']],watch:['pni.#id'],
doc:'Chase the provisioning ticket. 15% pulls the date in by 30 days; otherwise an excuse.'},
cancelPni:{args:[['id','entityId']],confirm:'arg',pass:a=>({id:a.id,ok:1}),
doc:'Cancel a PNI or its pending augment.'},
lagP:{args:[['id','entityId'],['d','step']],watch:['pni.#id'],
doc:'Add or remove a LAG member on a PNI. Adding is an augment with a lead time.'},
sacrif:{args:[['id','entityId']],watch:['pni.#id'],
doc:'Mark a PNI sacrificial, so attack traffic is steered into it.'},
peerPol:{args:[['p','peerPolicy']],watch:['ppol'],
doc:'Set your published peering policy: open, selective or closed. It answers every peering request for you: open accepts everyone, selective takes small networks on the exchange and newcomers with an up-to-date PeeringDB, closed declines them all. The NOC log sums the week up.'},
/* ---------- caches ---------- */
cache:{args:[['city','cityId'],['net','netId']],
quote:a=>{const n=NET[a.net];return {monthly:n&&n.cache?CACHE_MO:0,
blocked:n&&n.cache&&(R.demTo[a.net]||0)<n.cache.min?[tr('sites_peering_caches.net_says_not_yet_send_them',{net:n.name,min:n.cache.min})]:[]};},
doc:'Ask a CDN to ship you a cache. Monthly. Rejected until you send that network enough traffic.'},
rmCache:{args:[['id','entityId']],
doc:'Send a cache box back.'},
cacheSite:{args:[['city','cityId'],['net','netId'],['s','site']],watch:['caches'],
doc:'Move one of that CDN\'s boxes to the other building.'},
/* ---------- backbone links ---------- */
buildLink:{args:[['a','cityId'],['b','cityId'],['tier','linkTier'],['cable','cableId',false],['route','string',false],['premiumCrossing','boolean',false]],
bindsUI:['pending','route','via','cnPrem'],
bind:a=>{UI.pending={a:a.a,b:a.b};UI.route=a.route||'';UI.via=a.cable||'';UI.cnPrem=!!a.premiumCrossing;},
pass:a=>({tier:a.tier}),
quote:a=>{const A=a.a,B=a.b,tier=a.tier;
if(!waveOk(A,B,tier))return {blocked:[tr('links.a_wave_wave_needs_need_at',{wave:LT[tier].n,need:waveNeed(tier)})]};
const sib=pairLinks(A,B).filter(l=>l.kind!=='vxc'),jn=sib.length?routeJoin(A,B):null,border=cnCity(A)!==cnCity(B);
const mult=(sib.length&&!(jn&&jn.k===(landTrenches(A,B)[0]||{}).k)?DIVERSE:1)*(border?3*((a.premiumCrossing&&(A==='hkg'||B==='hkg'))?1.6:1):1);
const wr=waveRoute(A,B,mult,border);if(!wr)return {blocked:[tr('links.no_cable_available_for_that_route')]};
const blocked=[],so=soldOut(A,B,tier,wr.cab);
if(so)blocked.push(tr('links.no_wave_capacity_on_this_route',{wave:LT[tier].n,why:tr(so.why),n:Math.max(1,so.until-S.day)}));
const w=subWaveWhy(tier,wr.km,wr.sub);if(w)blocked.push(tr('links.no_wave_waves_on_this_cable',{wave:LT[tier].n,why:w}));
return {setup:Math.round(waveMo(wr.km,wr.sub,tier)*wr.wm)+(S.pops[B]?0:popCost(B)),monthly:Math.round(waveMo(wr.km,wr.sub,tier)*wr.wm),blocked};},
doc:'Lease a wave between two cities; opens a POP in b if there is none. A second wave on a pair costs 1.4x unless it joins an existing trench; cross-border into mainland China costs 3x. premiumCrossing applies only via Hong Kong.'},
upLink:{args:[['id','entityId'],['tier','linkTier']],watch:['links.#id'],
quote:a=>{const l=S.links.find(x=>x.id===a.id);if(!l)return {};
const blocked=[waveOk(l.a,l.b,a.tier)?'':tr('links.a_wave_wave_needs_need_at',{wave:LT[a.tier].n,need:waveNeed(a.tier)})];
const w=subWaveWhy(a.tier,l.km,l.sub);if(w)blocked.push(tr('links.no_wave_waves_on_this_cable',{wave:LT[a.tier].n,why:w}));
return {monthly:Math.round(waveMo(l.km,l.sub,a.tier)*(l.mult||1)),blocked:blocked.filter(Boolean)};},
doc:'Upgrade a leased wave in place. Upward only, and only if the span and cable support it.'},
rmLink:{args:[['id','entityId']],confirm:'double',
quote:a=>{const l=S.links.find(x=>x.id===a.id);return {setup:-((l&&cabBack(l))||0)};},
doc:'Decommission a link. A cancelled own-cable build refunds part of the money. Irreversible.'},
setMetric:{args:[['id','entityId'],['v','metric']],watch:['pairMet'],
doc:'Routing preference for the city pair this link belongs to (not the link): prefer, normal, avoid, backup, or custom (then metricMode and metricSet tune the number).'},
setCarry:{args:[['id','entityId'],['on','boolean']],watch:['transit.#id'],
doc:'Turn a transit port\'s Carry here on or off: it pulls that carrier\'s traffic (and its customers\') across your network from POPs that have no port of that carrier. Prefer, Backup only and RouteScript still win.'},
setStandby:{args:[['id','entityId'],['on','boolean']],watch:['links.#id'],
doc:'Hold a link in reserve: its capacity fills last.'},
/* ---------- fabrics and VXCs ---------- */
buyNni:{args:[['city','cityId'],['prov','fabId'],['tier','nniTier']],
quote:a=>({setup:NNI[a.tier]?NNI[a.tier].mo:undefined,monthly:NNI[a.tier]?NNI[a.tier].mo:undefined}),
doc:'Take a port on an interconnection fabric. Monthly. A higher tier upgrades unless the circuits on it already exceed the smaller port.'},
rmNni:{args:[['city','cityId'],['prov','fabId']],
doc:'Give the fabric port back. Rejected while circuits still use it.'},
buyVxc:{args:[['a','cityId'],['b','cityId'],['prov','fabId'],['t','vxcTier']],
quote:a=>({monthly:vxcMo(kmBetween(a.a,a.b),isSub(a.a,a.b),a.t)}),
doc:'Buy a virtual circuit between two fabric ports. Up in 59 seconds, which is the joke.'},
upVxc:{args:[['id','entityId'],['t','vxcTier']],watch:['links.#id'],
quote:a=>{const l=S.links.find(x=>x.id===a.id);return l&&l.kind==='vxc'?{monthly:vxcMo(l.km,l.sub,a.t)}:{};},
doc:'Grow a circuit. Needs headroom at both ends.'},
cancelVxc:{args:[['id','entityId']],confirm:'double',
doc:'Cancel a circuit; any remote IX ports it reached go with it.'},
setPref:{args:[['kind','connKind'],['id','entityId'],['v','egress']],watch:['transit.#id','pni.#id'],
doc:'Egress preference for one exit: high sends more traffic that way, low keeps it for backup.'},
siteSet:{args:[['k','connKind'],['id','entityId'],['s','site']],watch:['transit.#id','pni.#id'],
doc:'Put a transit port, PNI or IX port in building A, B or both. Choosing both with a single member adds a LAG member first, and charges for it.'},
/* ---------- dark fiber and own cable ---------- */
orderDf:{args:[['a','cityId'],['b','cityId'],['source','dfSource'],['system','systemId']],
bindsUI:['pending','dfSrc','dfSys'],bind:a=>{UI.pending={a:a.a,b:a.b};UI.dfSrc=a.source;UI.dfSys=a.system;},
quote:a=>{const A=a.a,B=a.b,sc=isSub(A,B)?subDfCable(A,B):null,km=sc?sc.km:kmBetween(A,B);
const building=a.source==='build'&&lvl()>=3&&!sc,sys=DF_SYS[a.system]&&DF_SYS[a.system].lvl<=lvl()?a.system:'lite';
const amps=ampCount(km),blocked=[];
if(isSub(A,B)&&!sc)blocked.push(tr('fiber_modals.nobody_sells_dark_fiber_on_a'));
else if(uaePair(A,B))blocked.push(tr('fiber_modals.no_dark_fiber_inside_the_uae'));
else if(landX(A,B)&&cnCity(A)===cnCity(B))blocked.push(tr('fiber_modals.nobody_sells_one_fiber_pair_across'));
else if(!dfAllowed(A,B))blocked.push(tr('fiber_modals.dark_fiber_across_the_chinese_border'));
if(lvl()<2)blocked.push(tr('fiber_modals.dark_fiber_unlocks_at_customer_level'));
return {setup:(building?dfBuildCost(km):0)+DF_SYS[sys].cost+amps*AMP_COST+(S.pops[B]?0:popCost(B)),
monthly:(building?Math.round(km*0.15):dfLeaseMo(km))+amps*AMP_MO,days:building?dfBuildDays(km):30,blocked};},
doc:'Get dark fiber: lease an IRU, dig your own (level 3+), or take a pair on a subsea cable. Then light it with a line system.'},
orderCable:{args:[['a','cityId'],['b','cityId'],['design','designId',false],['terminal','boolean',false],['engineering','boolean',false]],
bindsUI:['pending','seaDesign','seaterminal','seaengineering'],
bind:a=>{UI.pending={a:a.a,b:a.b};UI.seaDesign=a.design||'standard';UI.seaterminal=!!a.terminal;UI.seaengineering=!!a.engineering;},
quote:a=>{const why=ownCabWhy(a.a,a.b);if(why)return {blocked:[why]};
const design=own(SEA_DESIGNS,a.design)?a.design:'standard',up={terminal:!!a.terminal,engineering:!!a.engineering};
const q=seaQuote(a.a,a.b,design,up),lack=seaLack(q.km,up);
return {setup:q.cost+(S.pops[a.b]?0:popCost(a.b)),monthly:ownCabMo(q.km),days:q.days,
blocked:lack.map(k=>k==='design'?tr('own_cable.this_design_s_route_is_km',{km:q.km.toLocaleString()})
:tr('own_cable.km_km_is_too_far_for',{km:q.km.toLocaleString(),what:lack.length>1?tr('own_cable.a_and_b',{a:tr(SUB_UPGRADES[lack[0]].n),b:tr(SUB_UPGRADES[lack[1]].n)}):tr(SUB_UPGRADES[lack[0]].n)}))};},
doc:'Commission your own submarine cable. A ship sails; it takes months. The most expensive thing in the game.'},
subUpgrade:{args:[['id','entityId'],['k','upgradeId']],watch:['links.#id'],
quote:a=>{const l=S.links.find(x=>x.id===a.id);return l?{setup:subUpgradeCost(l,a.k),days:SUB_UPGRADES[a.k].days}:{};},
doc:'Add premium submarine terminals or extra optical engineering to your own subsea cable. Level 4+, once each.'},
crews:{args:[['id','entityId'],['all','boolean',false]],watch:['links.#id'],
quote:a=>{const l=S.links.find(x=>x.id===a.id);if(!l)return {};const n=a.all?crewSteps(l):1;return {setup:n*crewCost(l),days:30*n};},
doc:'Pay for more crews on a cable build: 30 days off per step. Only while more than a day of construction remains.'},
addCh:{args:[['id','entityId'],['o','opticId']],watch:['links.#id'],
quote:a=>{const l=S.links.find(x=>x.id===a.id);return l?{setup:chCost(l,a.o),blocked:[chWhy(l,a.o)].filter(Boolean)}:{};},
doc:'Light one channel on a dark-fiber span with a given optic; uses a spare from the shelf if you have one.'},
rmCh:{args:[['id','entityId'],['o','opticId']],watch:['links.#id'],
doc:'Unplug a channel; the optic goes on the spares shelf.'},
addPair:{args:[['id','entityId']],watch:['links.#id'],
quote:a=>{const l=S.links.find(x=>x.id===a.id);return l?{setup:pairCost(l)}:{};},
doc:'Light another fiber pair on your own cable. ROADM system, finished construction, current pair full.'},
upSys:{args:[['id','entityId']],watch:['links.#id'],
quote:a=>{const l=S.links.find(x=>x.id===a.id);return l?{setup:sysUpCost(l)}:{};},
doc:'Upgrade the line system: Rainbow to ROADMaster to C+L. Every channel goes down for a day.'},
regen:{args:[['id','entityId'],['d','step']],watch:['links.#id'],
quote:a=>{const l=S.links.find(x=>x.id===a.id);return l&&a.d>0?{setup:REGEN_COST+Math.round((l.ch||[]).reduce((x,c)=>x+optCost(c),0)*REGEN_CH)}:{setup:0};},
doc:'Add or remove a regeneration site on a terrestrial span, up to REGEN_MAX. Removing is refused if the optics then cannot reach.'},
spares:{args:[['id','entityId']],watch:['links.#id'],
doc:'Toggle keeping spare optics on site for this span, so a card failure is fixed in hours instead of days.'},
/* ---------- hardware ---------- */
hwLock:{args:[],quote:a=>({setup:hwLockCost()}),
doc:'Lock router, optic and build prices for a year, shortages included. Costs twice as much while a shortage runs.'},
buySpare:{args:[['o','opticId']],
quote:a=>({setup:optCost(a.o),blocked:[OPT[a.o]&&OPT[a.o].lvl>lvl()?tr('action_helpers.unlocks_at_customer_level_n',{n:OPT[a.o].lvl}):''].filter(Boolean)}),
doc:'Buy a spare optic for the shelf, up to 64 of a kind. The next channel of that type is then free of optic cost.'},
sellSpare:{args:[['o','opticId']],quote:a=>({setup:-spareValue(a.o)}),
doc:'Sell a spare on eBuy for 40% of list.'},
/* ---------- capacity broker ---------- */
listFiber:{args:[['id','entityId'],['w','integer'],['p','integer',false]],watch:['links.#id'],
doc:'List spare capacity on a dark-fiber span with a capacity broker as a standing listing: w alien waves, and p (own cables only) your spare fiber pair. The broker sells them off over time as carriers on that route want capacity; a busy route sells in days, a road to nowhere maybe once.'},
unlistFiber:{args:[['id','entityId']],watch:['links.#id'],
doc:'Take the listing down. What the broker already sold stays sold.'},
setChCount:{args:[['id','entityId'],['o','opticId'],['n','integer']],watch:['links.#id'],
quote:a=>{const l=S.links.find(x=>x.id===a.id);return l?{setup:opticCountCost(l,a.o,a.n)}:{};},
doc:'Set how many channels of one optic model a dark-fiber span carries, in one change. Added optics come from the spares shelf when you have them (regen cards still cost their share); removed ones go back to the shelf.'},
/* ---------- customers ---------- */
accept:{args:[['id','entityId']],
doc:'Sign a pending offer. Rejected without a POP in every city it needs, without free channels for a wave sale, or after an event\'s start date. Extra waves for a carrier you already serve grow that contract.'},
decline:{args:[['id','entityId']],
doc:'Throw an offer away.'},
dropBiz:{args:[['id','entityId']],confirm:'double',
doc:'Terminate a signed customer. Rejected once an event contract\'s event has started.'},
setRoute:{args:[['id','entityId'],['m','routeMode']],watch:['biz.#id'],
doc:'How a customer\'s traffic is routed: normal follows metrics, fast takes the lowest latency, scenic the quietest links.'},
/* ---------- traffic engineering ---------- */
buyTE:{args:[],quote:a=>({setup:TE_COST,monthly:TE_MO,blocked:coreTE()||(S&&S.te)?[]:[tr('core.auto_te_needs_an_rsvp_te_or')]}),
doc:'Buy the Auto-TE controller, which spills overflow onto alternate paths. Level 3+, and it needs an RSVP-TE-or-higher backbone.'},
teToggle:{args:[],watch:['te'],
doc:'Turn Auto-TE on or off.'},
teCheck:{args:[['script','string']],open:'teEdit',dom:['teSrc'],reads:'modal',
bind:a=>{$('teSrc').value=String(a.script);},
doc:'Parse and dry-run a RouteScript without deploying it. The parse errors, or served traffic and transit cost before and after, come back as the report. No state change.'},
teDeploy:{args:[['script','string']],open:'teEdit',dom:['teSrc'],watch:['te'],
bind:a=>{$('teSrc').value=String(a.script).slice(0,4000);},
quote:a=>({setup:0}),
doc:'Deploy a RouteScript, up to 4000 characters. Rejected with the parse errors. A deploy that cuts traffic by more than 10% says so in messages.'},
teClear:{args:[],watch:['te'],
doc:'Delete the script and fall back to plain Auto-TE.'},
traceRun:{args:[['from','cityId'],['to','traceTo']],open:'trace',dom:['trFrom','trTo'],reads:'modal',
bind:a=>{$('trFrom').value=a.from;$('trTo').value=(NET[a.to]?'net:':'city:')+a.to;},
doc:'Run a traceroute to a network or one of your own POPs. The hops come back as report text; they are not stored in the game state.'},
/* ---------- money ---------- */
takeLoan:{args:[['id','entityId']],
doc:'Accept a loan offer. Terms vary wildly by bank; the crypto one pays out 55-135% of face value. Equity banks take a share of the company.'},
declineLoan:{args:[['id','entityId']],
doc:'Throw a loan offer away.'},
repayLoan:{args:[['id','entityId']],confirm:'double',
quote:a=>{const l=S.loans.find(x=>x.id===a.id);return l?{setup:repayCost(l,BANKS[l.bank])}:{};},
doc:'Repay a loan early, or buy an equity investor out.'},
/* ---------- security, China, incidents ---------- */
buildScrub:{args:[['city','cityId'],['tier','scrubTier',false]],watch:['scrubs'],
quote:a=>{const T=SCRUB_TIERS[a.tier||0];return {setup:T?T.cost:undefined,monthly:T?T.mo:undefined};},
doc:'Build a scrubbing centre: 100G, 1T, 10T or 100T. Level-gated per tier; one per city.'},
scrubUp:{args:[['city','cityId'],['tier','scrubTier']],watch:['scrubs'],
quote:a=>({setup:Math.round(SCRUB_TIERS[a.tier].cost*0.6)}),
doc:'Upgrade a scrubbing centre, at 60% of the tier price. Upward only.'},
rmScrub:{args:[['city','cityId']],confirm:'double',watch:['scrubs'],
doc:'Tear a scrubbing centre down.'},
scrubMode:{args:[],watch:['scrubMode'],
doc:'Switch scrubbing between always-on and on-demand.'},
rtbh:{args:[['id','entityId',false]],watch:['ev'],
doc:'Announce a remote-triggered blackhole for the target under attack: it goes dark at your transits, most exchanges and about half your private peers, and everyone else is saved. Withdraw with unrtbh.'},
unrtbh:{args:[['id','entityId',false]],watch:['ev'],
doc:'Withdraw the blackhole.'},
ddosEngage:{args:[['id','entityId',false]],watch:['ev'],
doc:'Engage on-demand scrubbing now: start the diversion to the nearest active scrubbing centre instead of waiting for it to engage by itself.'},
ddosAuto:{args:[['k','ddosKey']],watch:['ddosAuto'],
doc:'Flip a NOC auto-mitigation switch: rtbh blackholes the target of a flood on its own, scrub engages on-demand scrubbing.'},
ddosTest:{args:[],watch:['ev'],
doc:'Sandbox only: send yourself a test flood, to try the tools on.'},
hackback:{args:[['id','entityId',false]],watch:['ev'],quote:a=>({setup:20000}),
doc:'Fire the Hackback 3000(tm) at the botnet. 35% it ends the attack; otherwise a fine and a story.'},
applyCn:{args:[],watch:['cnLic'],quote:a=>({setup:CN_LIC,days:45}),
doc:'File for a mainland China licence through a local partner. Required before a POP in mainland China. 45 days.'},
fixInc:{args:[['id','entityId']],watch:['inc'],
quote:a=>{const i=S.inc.find(x=>x.id===a.id);return i&&i.cost>0?{setup:i.cost}:{};},
doc:'Pay to rush a repair. A slow router reboot is cut to one day; anything else clears immediately.'},
/* ---------- conferences ---------- */
confGo:{args:[['key','confKey']],watch:['confReg'],
quote:a=>{const cf=upcomingConfs(75).find(x=>x.key===a.key);return cf?{setup:confCost(cf)}:{};},
doc:'Register for an upcoming conference. Keys come from catalog(\'conferences\'). Peering gets easier in that region for 45 days. Capacity conferences need level 3.'},
confSponsor:{args:[['key','confKey']],watch:['confReg'],
quote:a=>{const cf=upcomingConfs(75).find(x=>x.key===a.key);return cf&&confSp(cf)?{setup:CONF_SP-(S.confReg&&S.confReg[a.key]?CONF_COST:0)}:{};},
doc:'Sponsor it instead: your logo on every lanyard, a bigger effect, a bigger bill. Only where sponsorships are offered; upgrades an existing registration for the difference.'},
/* ---------- the NOC intern (standing orders) ---------- */
opsHire:{args:[['id','internId']],quote:a=>({setup:INTERN_MO}),watch:['ops'],
doc:'Hire the NOC intern. They run your standing orders once a game day and cost a salary a month. Level 2+, and only in a game with a clock.'},
opsFire:{args:[],confirm:'double',watch:['ops'],
doc:'Let the intern go. The standing orders stop; the rest of the month\'s salary is lost.'},
opsToggle:{args:[['k','opsKey']],watch:['ops'],
doc:'Pause or resume one standing order. Keys come from catalog(\'OPSK\'); the sheet in the game shows what each one does.'},
opsParam:{args:[['k','opsKey'],['p','string']],watch:['ops'],
doc:'Step one of a standing order\'s settings to its next value (the provider to prefer, the port size to order, the load ceiling…). The sheet steps the same way.'},
opsCap:{args:[['k','opsKey']],watch:['ops'],
doc:'Step the monthly budget of an order that has one: 10k, 25k, 50k, 100k, 250k, no limit.'},
opsFloor:{args:[],watch:['ops'],
doc:'Step the floor under your cash that the intern keeps clear when signing customers: 0, 50k, 250k, 1M, 5M.'},
opsPop:{args:[['k','opsPopKind'],['city','cityId']],watch:['ops'],
doc:'Add or remove one POP as an exception to an order: the intern never touches the POPs you except.'},
opsTpl:{args:[['k','opsTplKey']],watch:['ops'],
doc:'Toggle a piece of the one-tap new-POP template: broadband, a transit port, an IX port, the redundancy kit.'},
opsNewPop:{args:[['city','cityId']],watch:['pops.#city'],
quote:a=>{const q=S&&S.ops?opsTplQuote(a.city):null;return q?{setup:q.cost}:{};},
doc:'Open a city from the template in one go: the POP, then broadband, transit, an IX port and the redundancy kit as the template says — all or nothing on the price.'},
/* ---------- the bulk PNI order ---------- */
pniAll:{args:[['net','pniAllNet'],['tier','pniTier']],
quote:a=>{const b=pniBatch(a.net,a.tier);return b?{setup:b.cost,monthly:b.mo,blocked:(b.blocked||[]).map(q=>q.why).filter(Boolean)}:{};},
watch:['pni'],
doc:'Order PNIs with one network (net) or every network (net:null) at all shared POPs: missing connections are added, smaller ones upgraded, each at its own minimum size. The quote is the batch total, lead times as for one PNI.'},
/* ---------- backbone technology ---------- */
coreUp:{args:[],watch:['core'],
quote:a=>{const n=S&&S.core?S.core.lv+1:1;return n<=4?{setup:CORE_COST[n],blocked:[(lvl()||1)<CORE_REQ[n]?tr('core.needs_customer_level_n',{n:CORE_REQ[n]}):''].filter(Boolean)}:{};},
doc:'Buy the next backbone technology: IGP, LDP/MPLS, RSVP-TE, SR-MPLS, SRv6. One step at a time, level-gated; each step passes transit through a POP cheaper and RSVP-TE or higher unlocks Auto-TE.'},
coreLab:{args:[],watch:['core'],quote:a=>({setup:CORE_LAB}),
doc:'Build the interop lab in the NOC: it tests your vendors against each other first and cuts interop incidents by 60%.'},
coreSet:{args:[['v','integer']],watch:['core'],
doc:'Run the backbone at any level already paid for, 0 up to the highest bought.'},
/* ---------- the specialist's offers ---------- */
demoAsk:{args:[['k','string'],['id','string']],watch:['demo'],
doc:'Ask a vendor for a demo unit: a router, line system or optic one level above yours, delivered in about two weeks, at 60% over list until your level catches up. k and id name the thing (as the game\'s buttons pass them).'},
seatBuy:{args:[['n','seatPairs']],decides:true,watch:['seatOff','links'],
quote:a=>{const o=S&&S.seatOff;if(!o||!SEAT_N.includes(a.n))return {};const miss=[o.a,o.b].filter(c=>!S.pops[c]);
return {setup:seatCost(o.km,a.n)+miss.reduce((x,c)=>x+popCost(c),0),days:seatDays(o.km)};},
doc:'Take the consortium cable offer: own 1, 2 or 4 fiber pairs on a new subsea cable for your share of the build, and light them with your own optics. POPs open at both landings if you have none.'},
seatNo:{args:[],watch:['seatOff'],
doc:'Decline the consortium cable offer.'},
charter:{args:[['k','charterKey']],watch:['charter'],
doc:'Sign your first-month charter: global backbone (the classic game) or low-latency boutique (trading firms pay 40% more, and it has its own win). One choice per network, normal games only.'},
mkBanana:{args:[],watch:['monkey'],
quote:a=>({setup:mkBananaCost()}),
doc:'Throw the chaos monkey a banana and it leaves early. Only while it is in your network; the price scales with your revenue.'},
/* ---------- link tools ---------- */
metricMode:{args:[['id','entityId'],['k','metricKind']],watch:['pairMet'],
doc:'Set the custom routing metric of a link\'s city pair as a factor (k:"f", the preset way) or an exact cost weight (k:"w"). Starts from the current preset\'s value; edit the number with metricSet.'},
metricSet:{args:[['id','entityId'],['v','string']],dom:['metIn'],watch:['pairMet'],
bind:a=>{$('metIn').value=String(a.v);},
doc:'Write the custom metric\'s number for the link\'s city pair, in the mode metricMode set. Select the link first (view.selLink), so the panel is showing the input.'},
layShip:{args:[['id','entityId']],watch:['links.#id'],
quote:a=>{const l=S.links.find(x=>x.id===a.id),q=l&&layQuote(l);return q?{setup:q.cost}:{};},
doc:'Book a second lay ship on your own cable before laying starts: it lays from the other end and halves that part of the build.'},
/* ---------- standard POPs ---------- */
popStdSet:{args:[['city','cityId']],watch:['popStd'],
doc:'Make a POP\'s routers the standard: every new POP starts with that model and that number of routers while it is still empty.'},
popStdClear:{args:[],watch:['popStd'],
doc:'Stop setting a standard; new POPs go back to one basic router.'},
/* ---------- utilities ---------- */
utilityRouteServers:{args:[['city','cityId',false]],watch:['rs'],
doc:'Join the route server at every IX you have a port at. One call does what the button does.'},
utilityKit:{args:[['city','cityId'],['cost','integer',false]],watch:['pops.#city','caches'],
quote:a=>{const q=S?utilityKit(a.city):null;return q?{setup:q.cost,monthly:q.mo}:{};},
pass:a=>({city:a.city,cost:a.cost??((utilityKit(a.city)||{}).cost)}),
doc:'Install the POP redundancy kit in one go: generator, second building, a second router, and the cache boxes balanced between sites. Pass the quoted setup as cost; the game checks it still matches. Nothing to do reads as no_effect.'},
utilityCaches:{args:[['city','cityId'],['quote','string',false]],watch:['caches'],
quote:a=>{const q=S?utilityCaches(a.city):null;return q?{key:q.key}:{};},
pass:a=>({city:a.city,quote:a.quote??((utilityCaches(a.city)||{}).key)}),
doc:'Request a cache from each eligible provider at each site of the city, as many as demand asks for. Pass the quote\'s key back; the game checks the list has not moved under it.'},
utilityPeers:{args:[['city','cityId',false]],watch:['peers'],
doc:'Request peering with every eligible peer across every IX you have joined.'},
/* ---------- renaming ---------- */
renameGo:{args:[['name','string']],open:'rename',dom:['rnIn'],watch:['name'],
bind:a=>{$('rnIn').value=String(a.name).slice(0,24);},
doc:'Rename your network. act opens the menu\'s rename sheet and types the name in; it is trimmed to 24 characters.'},
/* ---------- puzzles and architect runs ---------- */
pzLinkTo:{args:[['a','cityId'],['b','cityId']],bindsUI:['pending'],decides:true,watch:['links'],
bind:a=>{UI.pending={a:a.a,b:a.b};},
doc:'Puzzles only: open the link picker between two cities. Answer the decision with pzLink.'},
pzLink:{args:[['tier','pztTier']],watch:['links'],
doc:'Puzzles only: light the pending link (from pzLinkTo) at a tier, on the picked route, in the picked trench.'},
pzTier:{args:[['id','entityId'],['tier','pztTier']],watch:['links.#id'],
doc:'Puzzles only: change a link\'s wave size.'},
pzRmLink:{args:[['id','entityId']],watch:['links.#id'],
doc:'Puzzles only: tear a link down.'},
pzPop:{args:[['city','cityId']],watch:['pops.#city'],
doc:'Puzzles only: open a POP in a puzzle city.'},
pzRmPop:{args:[['city','cityId']],watch:['pops.#city'],
doc:'Puzzles only: close a POP and the links that reach it.'},
pzRtAdd:{args:[['city','cityId']],watch:['pops.#city'],
doc:'Puzzles only: add a router to a POP, up to RMAX.'},
pzRtRm:{args:[['city','cityId']],watch:['pops.#city'],
doc:'Puzzles only: remove a router, if the ports still fit.'},
pzRtModel:{args:[['city','cityId'],['g','pzRouterModel']],watch:['pops.#city'],
doc:'Puzzles only: swap every router in a POP for another model.'},
pzRoute:{args:[['i','integer'],['m','pzRouteMode']],watch:['biz'],
doc:'Puzzles only: send one flow (index i, as state(\'biz\') lists them) along the metrics or the lowest-latency path.'},
pzUndo:{args:[],watch:['pops','links','pairMet'],
doc:'Puzzles only: undo the last build step, up to sixty of them.'},
pzReset:{args:[],watch:['pops','links','pairMet'],
doc:'Puzzles only: clear the whole build and start the puzzle over.'},
pzArGo:{args:[],watch:['ar'],
doc:'Architect runs only: run the chaos monkey\'s review of this brief, every tube snipped in turn.'},
pzArSkip:{args:[],watch:['ar'],
doc:'Architect runs only: fast-forward the review to the first cut that hurts.'},
pzArNext:{args:[],watch:['ar'],
doc:'Architect runs only: pass the review and sign the next brief. Rejected while the current one does not pass.'},
/* ---------- answering decisions ---------- */
dkAccept:{args:[],watch:['dk'],
doc:'Take the De-Kicks quote as offered and order the port.'},
dkHaggle:{args:[],watch:['dk'],
doc:'Haggle. 45% a better price, 30% a worse one, 25% sales stops returning your calls for a few days. Three attempts.'},
dkWalk:{args:[],watch:['dk'],
doc:'Walk away; the quote is remembered for 90 days.'},
dkStay:{args:[['city','ixId']],watch:['dk'],
doc:'Take the retention discount instead of leaving: 40% off for six months.'},
dkOptOut:{args:[['city','ixId'],['n','string']],confirm:'double',watch:['dk'],
doc:'Opt out of an add-on De-Kicks slipped onto the bill.'},
closeModal:{args:[],
doc:'Close the open window, answering nothing. Always available, so you are never stuck in front of one.'},
};
const API_VIEW={
help:{args:[],doc:'Open the how-to-play modal.'},
dash:{args:[],doc:'Open the NOC dashboard.'},
dashClose:{args:[],doc:'Close the NOC dashboard.'},
dashTab:{args:[['k','dashTab']],doc:'Switch the NOC dashboard tab.'},
dashSort:{args:[['k','dashSortKey']],doc:'Flip a dashboard column\'s sort.'},
dashLink:{args:[['id','entityId']],doc:'Jump from the dashboard to a link\'s panel.'},
bank:{args:[],doc:'Open the bank.'},
bankClose:{args:[],doc:'Close the bank.'},
closePanel:{args:[],doc:'Close the selection panel.'},
tab:{args:[['t','string']],doc:'Switch the city panel\'s tab.'},
leftTab:{args:[['t','leftTab']],doc:'Switch the left drawer and open it.'},
toggleLeft:{args:[],doc:'Open or close the left drawer.'},
netFocus:{args:[['id','netId']],doc:'Focus one network in the left drawer.'},
netFilter:{args:[['f','netFilter']],doc:'All networks, or only the out-of-reach ones.'},
meetGo:{args:[['city','cityId']],doc:'Go to a city and open where to meet networks there.'},
phoneTab:{args:[['t','leftTab']],doc:'Phone tab bar: switch bottom-sheet tab.'},
logOpen:{args:[['id','entityId']],doc:'Open the thing a notification refers to.'},
logAll:{args:[],doc:'Show every notification in the drawer.'},
focusCity:{args:[['city','cityId']],doc:'Select and centre a city.'},
selLink:{args:[['id','entityId']],doc:'Select a link.'},
custGo:{args:[['id','entityId']],doc:'Jump from the dashboard to a customer.'},
listMore:{args:[['k','listPage']],doc:'Show another page of the dashboard list.'},
custF:{args:[['v','string']],doc:'Filter the customers list.'},
custCity:{args:[['v','string']],doc:'Filter the customers list by city.'},
custSort:{args:[['k','custSortKey']],doc:'Flip the customers list sort.'},
custOpen:{args:[['sad','boolean',false]],doc:'Open the customers dashboard tab.'},
goConn:{args:[['city','cityId'],['k','connKind']],doc:'Open a city\'s connections tab.'},
goEgress:{args:[['city','cityId'],['k','egressKind']],doc:'Open a city\'s connections tab (l2 for the customer list).'},
connOpen:{args:[],doc:'Open the connections dashboard tab.'},
connF:{args:[['f','connFilter'],['v','string',false]],doc:'Filter the connections list.'},
connCity:{args:[['v','string']],doc:'Filter the connections list by city.'},
connNet:{args:[['v','string']],doc:'Filter the connections list by network.'},
connSort:{args:[['k','connSortKey']],doc:'Flip the connections list sort.'},
connFor:{args:[['net','netId']],doc:'Open the connections of one network.'},
linkCheck:{args:[['id','entityId']],doc:'Open the redundancy check for a link: what a single cut would drop, without changing anything.'},
findOpen:{args:[],doc:'Open the city finder (the 🔍 in the top bar).'},
findGo:{args:[['city','cityId']],doc:'Close the finder and jump to a city.'},
routingOpen:{args:[],doc:'Open the Routing & DDoS window: backbone, Auto-TE and DDoS settings (the button at the top of the NOC tab).'},
opsOpen:{args:[],doc:'Open the Ops sheet: the NOC intern\'s mood, weekly shift report and standing orders.'},
opsCity:{args:[['v','cityId',false]],doc:'Show one POP\'s standing-order exceptions in the Ops sheet.'},
utilities:{args:[['city','cityId',false]],doc:'Open the utilities sheet: route servers, the redundancy kit, caches and bulk peering, for one city or the whole network.'},
pniAllOpen:{args:[['net','pniAllNet']],doc:'Open the bulk PNI order sheet for one network (or every network with null).'},
pniFilter:{args:[['f','pniFilter']],doc:'Filter the PNI list: all, via transit, worth it, already PNI.'},
pniGrp:{args:[['g','string'],['o','boolean',false]],doc:'Fold or unfold one group of the PNI list.'},
pniSort:{args:[],doc:'Flip the PNI list sort between A-Z and worth-it-first.'},
puzzleMenu:{args:[],doc:'Open the puzzle list.'},
puzzleDoor:{args:[],doc:'From the title screen: open the puzzle list (keeps the typed name).'},
pzFinish:{args:[],doc:'Puzzles only: run the star count and show the results sheet.'},
pzMonkey:{args:[],doc:'Puzzles only: send the chaos monkey round the build to prove the N-1 star.'},
pzMkSkip:{args:[],doc:'Puzzles only: skip the monkey\'s tour to the verdict.'},
pzArAll:{args:[],doc:'Architect runs only: show every city on the map, not just the run\'s own.'},
tailTog:{args:[],doc:'Show or hide the long tail of small networks.'},
teEdit:{args:[],doc:'Open the RouteScript editor.'},
teClose:{args:[],doc:'Close the RouteScript editor.'},
teHelp:{args:[],doc:'Open the RouteScript reference.'},
teBack:{args:[],doc:'Back to the RouteScript editor.'},
models:{args:[],doc:'Open the router catalogue.'},
decomOpen:{args:[['city','cityId',false]],doc:'Open the decommissioning sheet.'},
scenarios:{args:[],doc:'Open the scenario picker. Start one with startScn.'},
helpClose:{args:[],doc:'Close the help modal.'},
whatsNewShow:{args:[],doc:'Open the release notes.'},
};
const API_BOUND={
leaseSwap:{command:'orderDf',note:'presets the dark-fiber modal on a leased pair'},
teOpt:{command:'teDeploy',arg:'script',note:'the optimiser drafts a script'},
teSlop:{command:'teDeploy',arg:'script',note:'the AI drafts a script'},
teExample:{command:'teDeploy',arg:'script',note:'the worked example'},
teRecipe:{command:'teDeploy',arg:'script',note:'a recipe from catalog(\'TE_RECIPES\')'},
trace:{command:'traceRun',arg:'from'},
decomToggle:{command:'decomGo',arg:'cities'},
openVxc:{command:'buyVxc',note:'opens the circuit picker from a fabric port ({from, prov}); buyVxc takes a, b, prov and t itself'},
connCancel:{command:'cancelTransit',note:'the connections list\'s cancel button: it arms, then dispatches cancelTransit, cancelPni, cancelIx, rmCache or rmNni'},
cnPrem:{command:'buildLink',arg:'premiumCrossing'},
addParallel:{command:'buildLink',note:'opens the link modal on the same pair',arg:'a/b'},
via:{command:'buildLink',arg:'cable'},
route:{command:'buildLink',arg:'route'},
dfMode:{command:'orderDf',note:'opens the dark-fiber modal',arg:'a/b'},
dfSrc:{command:'orderDf',arg:'source'},
dfSys:{command:'orderDf',arg:'system'},
seaDesign:{command:'orderCable',arg:'design'},
seaPackage:{command:'orderCable',arg:'terminal/engineering'},
ownCab:{command:'orderCable',note:'presets the own-cable flow'},
randomName:{command:'start',note:'drafts the title-screen name; new_game starts games'},
pickStart:{command:'start',note:'drafts the home city; new_game starts games'},
pickHome:{command:'start',note:'drafts the home city; new_game starts games'},
modeSet:{command:'start',note:'drafts the game mode; new_game starts games'},
presetSet:{command:'start',note:'drafts the difficulty preset; new_game starts games'},
chaosSet:{command:'start',note:'drafts the sandbox chaos dial; new_game starts games'},
rename:{command:'renameGo',note:'opens the rename sheet; renameGo opens it itself'},
pniAllSize:{command:'pniAll',arg:'tier',note:'steps the port size in the bulk sheet'},
utilityPick:{command:'utilities',note:'the sheet\'s city picker; pass city to utilities itself'},
pzAddPar:{command:'pzLink',note:'opens the puzzle picker on the same pair',arg:'tier'},
pzVia:{command:'pzLink',note:'picks the route (cable or land) for the pending link'},
pzDiv:{command:'pzLink',note:'same trench or a diverse one for the pending link'},
};
/* Starting, retrying and leaving scenarios, puzzles and architect runs, and the screens a player dismisses. They run
as their buttons run them; new_game, load_save and export_save are the other half of the session (mcp-page.js). */
const API_SESSION={
startScn:{args:[['id','scnId']],doc:'Start a scenario (ids from catalog SCN), replacing the current game.'},
startWeekly:{args:[],doc:'Start this week\'s weekly scenario, replacing the current game. The week follows the real date.'},
pzStart:{args:[['id','string']],doc:'Start a puzzle by id (the puzzle list, view.puzzleMenu, shows them), replacing the current game.'},
pzWeekly:{args:[],doc:'Start this week\'s weekly puzzle, replacing the current game.'},
pzArStart:{args:[['id','string']],doc:'Start an architect run by id (view.puzzleMenu lists them), replacing the current game.'},
pzRetry:{args:[],doc:'Puzzles and architect runs: start the same one over from scratch.'},
pzLeave:{args:[],doc:'Leave the running puzzle or architect run.'},
keepPlaying:{args:[],doc:'Dismiss the win screen and keep playing.'},
pitchSkip:{args:[],doc:'Skip the opening pitch; a game waiting behind it starts.'},
tutSkip:{args:[],doc:'Skip the tutorial coaching.'},
};
const API_STATE_DOC={
v:{type:'integer',doc:'Save format version.'},
name:{type:'string',doc:'Your network\'s name.'},
asn:{type:'integer',doc:'Your AS number.'},
home:{type:'string',doc:'The city you started in.'},
day:{type:'integer',doc:'Days since the company was founded.'},
cash:{type:'number',doc:'Cash on hand. Goes negative into the red; -100k is bankruptcy.'},
priceMul:{type:'number',doc:'Multiplier on transit prices (weekly modifier).'},
mode:{type:'string',doc:'normal | sandbox | scenario | puzzle.'},
rules:{type:'map',doc:'The rules this network locked in at its door: preset (oncall, freeze, bgp3am), the chaos dial, and what is switched off in Change Freeze. They stay for the network\'s whole life.'},
charter:{type:'string',doc:'The charter picked in the first month of a normal game: global | boutique.'},
chartSet:{type:'boolean',doc:'The charter has been picked; false while the choice is still open.'},
solWon:{type:'integer',doc:'The day the Speed of Light win landed (boutique charter), or 0.'},
lvl:{type:'integer',doc:'Customer level (unlocks customer types).'},
ltv:{type:'integer',doc:'Level at which Tier 1 vendors were visible (title-screen pick).'},
t1v:{type:'integer',doc:'Level at which Tier 1 transit was offered.'},
auV:{type:'integer',doc:'Australia content level gate.'},
seen:{type:'array',doc:'Network ids the deals panel has already shown. Vestigial: written by newGame, read nowhere.'},
pops:{type:'map',doc:'Your POPs by city id: day opened, broadband (bb), ad boost, downtime, routers, generator, second site.'},
links:{type:'array',doc:'Your links: waves, dark fiber (df), own cables and fabric circuits (vxc), each with an entity id.'},
transit:{type:'array',doc:'Transit ports: city, net, tier, LAG members, port history for 95th-percentile billing.'},
ixp:{type:'map',doc:'IX ports by exchange city; tier per port (may exceed 1 with LAG members in ixn).'},
rs:{type:'map',doc:'Route-server sessions by exchange city.'},
ixn:{type:'map',doc:'LAG members on IX ports by exchange city.'},
ixSite:{type:'map',doc:'Which building each IX port sits in (a, b or ab).'},
ixPref:{type:'map',doc:'Egress preference per IX port.'},
myIx:{type:'map',doc:'Exchanges you founded: name, members, join schedule, fabric step.'},
peers:{type:'map',doc:'Peering sessions, keyed "net@ix".'},
pairMet:{type:'map',doc:'Routing metric per city pair (prefer/avoid/backup/normal), keyed by pair.'},
pni:{type:'array',doc:'Private interconnects: city, net, tier, ready day, augments (up), LAG, sacrificial flag.'},
caches:{type:'array',doc:'CDN cache boxes: city, net, building.'},
nni:{type:'array',doc:'Fabric ports: city, provider, tier.'},
biz:{type:'array',doc:'Signed customers: type, cities, bandwidth, rate, mood, contract dates.'},
offers:{type:'array',doc:'Pending customer offers, each expiring on a day.'},
done:{type:'map',doc:'Goals landed, by goal id → day.'},
ach:{type:'map',doc:'Badges earned this game, by badge id → day.'},
inc:{type:'array',doc:'Open incidents: type, what they hit, until when, optional rush-repair price.'},
ddosStarts:{type:'array',doc:'The days the attacks of the last week started; at most 14 a week.'},
ev:{type:'map',doc:'Live world events: the running DDoS, route leaks, fabric failures, price shocks.'},
stats:{type:'map',doc:'Counters: incidents survived, loans taken, sharks, conferences attended, peak traffic…'},
log:{type:'array',doc:'The NOC notification feed, newest first, capped at 60; identical notices within a minute fold with a count.'},
nextFail:{type:'integer',doc:'The day the next failure fires.'},
nextEvent:{type:'integer',doc:'The day the next world event fires.'},
rng:{type:'integer',doc:'The scenario seed; it predicts every future random draw.'},
usedNames:{type:'array',doc:'Customer names already handed out.'},
spares:{type:'map',doc:'Spare optics on the shelf, by optic id.'},
scrubs:{type:'array',doc:'Scrubbing centres: city and tier.'},
scrubMode:{type:'string',doc:'always | ondemand.'},
cnLic:{type:'map',doc:'Mainland China licence: none | pending (with ready day) | ok.'},
ppol:{type:'string',doc:'Your published peering policy: open | selective | closed.'},
pdesk:{type:'map',doc:'This week\'s peering desk summary: sessions accepted and declined at which exchanges.'},
pdeskRep:{type:'map',doc:'Last week\'s peering desk summary, as the NOC log reported it.'},
ops:{type:'map',doc:'The NOC intern: who is hired, each standing order\'s on/off switch and settings, the monthly budget and what it spent, per-POP exceptions, the new-POP template and the weekly log.'},
core:{type:'map',doc:'Your backbone technology: lv bought, the level it runs at, the interop lab.'},
ddosAuto:{type:'map',doc:'The NOC\'s auto-mitigation switches: rtbh and scrub.'},
popStd:{type:'map',doc:'The standard POP: router model and count new POPs start with, or null for none.'},
demo:{type:'map',doc:'Vendor demo units on order, by "kind:id" → ready day.'},
seatOff:{type:'map',doc:'The pending consortium-cable seat offer: landings, km, name, expiry day.'},
monkey:{type:'map',doc:'The chaos monkey: next visit day, whether it is in your network now, days left, whether anyone noticed.'},
fleet:{type:'map',doc:'Cable-ship voyages by ship id: the cut it sails to, when it arrives, splices and comes home.'},
achP:{type:'map',doc:'Which rule set each badge was earned under (oncall, freeze, bgp), by badge id.'},
calV:{type:'integer',doc:'Calendar save-format marker: 1 once the real calendar (28-31-day months) applies.'},
pz:{type:'map',doc:'The running puzzle: its id, cities, flows to deliver, budget and stars.'},
ar:{type:'map',doc:'The running architect run: its HQ, brief index, gold sites, spend and the build it started from.'},
loans:{type:'array',doc:'Active loans: bank, balance, APR, term, share (equity banks).'},
loanOffers:{type:'array',doc:'Pending loan offers.'},
loanStrikes:{type:'integer',doc:'How many loan offers you have let lapse.'},
confReg:{type:'map',doc:'Conferences registered for, by key; "sp" when sponsoring.'},
hw:{type:'map',doc:'Hardware market: price shocks and any price lock.'},
capDeal:{type:'map',doc:'The pending capacity deal from a capacity conference.'},
cam:{type:'map',doc:'Map camera position. View state that save() happens to store inside S.'},
uiSpeed:{type:'number',doc:'The speed you left the game at. View state that save() stores inside S.'},
won:{type:'boolean',doc:'You reached Tier 1.'},
t1Now:{type:'boolean',doc:'Tier 1 right now, as of the last day; falling out of it is announced.'},
lost:{type:'boolean',doc:'The bank repossessed the routers.'},
neg:{type:'integer',doc:'Days in the red in a row.'},
hist:{type:'array',doc:'Daily history for the graphs: demand, served, exit split, revenue, cost, cash.'},
scn:{type:'map',doc:'The running scenario: id, rules, day limit, done/failed, and the day of the next scripted attack (nextDdos).'},
dk:{type:'map',doc:'De-Kicks state: per-exchange multipliers, add-ons, retention, the live quote (q) and the remembered one (lastQ).'},
grace:{type:'map',doc:'Courtesy transit after a merger wave, until a day.'},
merged:{type:'map',doc:'Networks merged into others this game.'},
tut:{type:'map',doc:'Tutorial progress.'},
conf:{type:'map',doc:'The conference glow: region and until when; sp when you sponsored.'},
phpDone:{type:'boolean',doc:'One-shot flag.'},
krExit:{type:'map',doc:'Korea exit state.'},
auNews:{type:'boolean',doc:'One-shot flag: the Australia news toast.'},
richTold:{type:'boolean',doc:'One-shot flag: the cash milestone toast.'},
};
const API_RESULTS_DOC={
nt:{type:'map',doc:'Traffic per network through transit, by net id.'},
tNet:{type:'map',doc:'Traffic per network you hand to each upstream, by "net@upstream".'},
reachNT:{type:'number',doc:'Networks reachable without transit.'},
teBlack:{type:'number',doc:'Traffic blackholed by RouteScript rules.'},
teMoved:{type:'number',doc:'Traffic Auto-TE spilled onto alternate paths.'},
egT:{type:'map',doc:'Egress split by exit kind (c/p/ix/t/l2) in Gbps.'},
egDesc:{type:'map',doc:'RouteScript drains per exit.'},
netEg:{type:'map',doc:'Per-network egress split: which exit carries which network.'},
ef:{type:'map',doc:'LAZY per-link exit breakdown: what crosses each link, per network, built only when a panel asks. What is in here depends on which panels have rendered.'},
l2:{type:'map',doc:'Layer-2 traffic per customer (L2VPN, SD-WAN, waves).'},
l2lat:{type:'map',doc:'Latency per L2 customer.'},
l2route:{type:'map',doc:'Which path an L2 customer\'s traffic takes.'},
l2split:{type:'map',doc:'L2 traffic split per path.'},
nodeLoad:{type:'map',doc:'Router forwarding load per city.'},
nodeCap:{type:'map',doc:'Router forwarding capacity per city.'},
div:{type:'map',doc:'Traffic diversity per customer (how split their paths are).'},
gfwLost:{type:'number',doc:'Traffic lost to the Great Firewall.'},
gfwCross:{type:'number',doc:'Traffic crossing into mainland China.'},
p95:{type:'map',doc:'95th-percentile transit readings per port.'},
peered:{type:'number',doc:'Share of traffic that stays on peering.'},
peerShare:{type:'number',doc:'Fraction of traffic served by peers (mood driver).'},
load:{type:'map',doc:'Load per link in Gbps.'},
useT:{type:'map',doc:'Transit use per port id.'},
useIx:{type:'map',doc:'IX use per exchange city.'},
usePni:{type:'map',doc:'PNI use per port id.'},
useCache:{type:'map',doc:'Cache use per box id.'},
cityDem:{type:'map',doc:'Eyeball + customer demand per city.'},
citySrv:{type:'map',doc:'Traffic served per city.'},
cityEye:{type:'map',doc:'Eyeballs online per city.'},
latF:{type:'map',doc:'Fraction of each city\'s traffic that goes far (over a threshold latency).'},
latFar:{type:'map',doc:'The far exit each slow city sends traffic through.'},
demTo:{type:'map',doc:'Your traffic destined to each network, in Gbps. The number CDN caches ask about.'},
served:{type:'number',doc:'Total traffic served, in Gbps.'},
demand:{type:'number',doc:'Total traffic demanded, in Gbps.'},
reach:{type:'number',doc:'Fraction of the internet you can reach (0..1).'},
sessions:{type:'number',doc:'Peering sessions up.'},
revMo:{type:'number',doc:'Revenue per month.'},
costMo:{type:'number',doc:'Cost per month.'},
cost:{type:'map',doc:'Monthly cost by category (transit, pni, ix, links…).'},
rev:{type:'map',doc:'Monthly revenue by source.'},
reachable:{type:'map',doc:'Networks reachable per net id.'},
cone:{type:'map',doc:'Which peer\'s customer cone carries each network you reach without transit of your own, by net id.'},
ddos:{type:'array',doc:'Per live attack: the target, its size, which ports it fills, what Flowspec and each scrubbing centre cleaned, and what reaches the target.'},
haul:{type:'array',doc:'Scrubbing detours: from the attacked city to each centre, one-way latency and how much they carry.'},
tgtF:{type:'map',doc:'The share of a targeted customer\'s traffic that survives the attack, by customer id.'},
bbF:{type:'map',doc:'The share of a city\'s broadband subscribers that survive an attack on them, by city id.'},
fsUse:{type:'map',doc:'Flowspec rules in use per city: used of the routers\' rule capacity.'},
bizDem:{type:'map',doc:'Business customers\' share of each city\'s demand, in Gbps (what RouteScript\'s protect customers serves first).'},
bizSrv:{type:'map',doc:'Of that business demand, what was served, per city.'},
graceNets:{type:'number',doc:'Networks reached over the courtesy route after a merger wave.'},
cityBlocked:{type:'map',doc:'Set up per city by the traffic computation; nothing fills it at present.'},
ddosHot:{type:'map',doc:'Cities whose ports a flood is filling, for the map\'s pulse. Keyed by city id.'},
};
/* One arg of a spec as the schema states it: the domain when there is one (catalog() resolves
it), the bare type otherwise, and the concrete value list or range where it is fixed. */
function apiArgSpec([name,dom,req]){
const a={name,required:req!==false};
if(API_DOMAINS[dom])a.domain=dom;else a.type=dom;
const v=apiDomValues(dom);
if(Array.isArray(v))a.values=v;else if(v&&v.from!==undefined)a.range=v;
return a;}
/* Dotted subtrees, no wildcards. An array walks by index (`biz.3`) or by entity id (`links[#id]`). */
function apiPath(o,p){
if(p===undefined||p===null||p==='')return o;
let v=o;
for(const k of String(p).split('.')){
if(v==null)return undefined;
if(Array.isArray(v)){const i=Number(k);
v=(Number.isInteger(i)&&String(i)===k&&i>=0&&i<v.length)?v[i]:v.find(x=>x&&typeof x==='object'&&x.id===k);}
else if(v instanceof Set)v=[...v];
else if(v instanceof Map)v=Object.fromEntries(v);
else if(typeof v==='object')v=v[k];
else return undefined;}
return v;}
function apiJson(v){
if(v instanceof Set)return [...v].map(apiJson);
if(v instanceof Map)return apiJson(Object.fromEntries(v));
if(v&&typeof v==='object')return Array.isArray(v)?v.map(apiJson):Object.fromEntries(Object.entries(v).map(([k,x])=>[k,apiJson(x)]));
if(typeof v==='function')return undefined;
return v;}
/* The tables the argument domains point at. Everything is a static reference except three,
each computed for a reason: BADGES hides unearned secrets like the badge wall; conferences
carries the keys confGo/confSponsor need, which exist in no field of S; TE_RECIPES renders
each recipe's script, because the source is a function and some read the live network. The
recipes' relevance score is not exposed: judging which one fits is the agent's job. */
const API_TABLES={CITIES,NETS,CABLES,XIX,PORT,LT,NNI,VXC,RG,OPT,DF_SYS,FAB,SCRUB_TIERS,BIZ_T,LEVELS,GOALS,SCN,BANKS,REQS,NSH,MET,PREF,RT,PPOL,CONFS,LAG_MAX,RMAX,REGEN_MAX,START_CASH,CONF_COST,CONF_SP,CAP_COST,CAP_LV,CONF_DAYS,SUB_UPGRADES,SEA_DESIGNS,TE_COST,TE_MO,MYIX_COST,CN_LIC,SITE2_COST,MYIX_FAB,INTERNS,OPSK,CHARTERS,SEAT_N,CORE_LV,CORE_COST,CORE_REQ,CORE_LAB,INTERN_MO,PZ_TIERS,AR_TIERS,PZ_RG};
const API_MADE={
BADGES:()=>!S?[]:BADGES.map(b=>{const on=S.ach&&S.ach[b.id]!==undefined,ever=!!hof()[b.id];
return b.secret&&!on&&!ever?{id:b.id,i:'❔',t:'???',d:tr('badges.a_secret_badge'),r:b.r,secret:true}:{...b,ever};}),
conferences:()=>!S?[]:upcomingConfs(75).map(cf=>({key:cf.key,name:cf.n,city:cf.c,day:cf.day,capacity:!!cf.cap,cost:confCost(cf),sponsorCost:confSp(cf)?CONF_SP:null})),
TE_RECIPES:()=>!S?[]:TE_RECIPES.map(r=>({id:r.id,name:tr(r.n),description:tr(r.d),script:r.src().join('\n')})),
};
function API_CATALOG_TABLE(name){return name in API_MADE?API_MADE[name]():API_TABLES[name];}
/* UI minus the render caches and pointer scratch, which are inputs to nothing.
Everything a command binds (pending, route, via, dfSrc, dfSys, seaDesign, cnPrem, decom,
teDraft, confirm) stays, so an agent can see what it was given. */
const API_UI_HIDDEN={_lh:1,_ph:1,_tb:1,_layer:1,layerAt:1,hover:1,drag:1,snap:1};
return {API_DOMAINS,API_CMD,API_VIEW,API_BOUND,API_SESSION,API_STATE_DOC,API_RESULTS_DOC,API_TABLES,API_MADE,API_UI_HIDDEN,
apiDomCheck,apiDomValues,apiArgSpec,apiPath,apiJson};
})();