[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_153":154,"_155":156},"routes/_app.x.$handle.$name",{"_11":12,"_13":14,"_15":16,"_18":19,"_17":-7,"_116":-5,"_20":117,"_22":118,"_119":120,"_121":122,"_25":123,"_24":-5,"_124":-5,"_125":-5,"_126":53,"_127":128,"_129":44,"_130":-5,"_131":-5,"_132":133},"routes/_app.x.$handle.$name.branch.$branch.code.$",{"_11":12,"_13":14,"_15":16,"_17":-7,"_18":19,"_20":21,"_22":23,"_24":-7,"_25":26,"_27":-5,"_28":-5,"_29":-5,"_30":-5,"_31":-5},"handle","hobbycoder7","name","Rbgrindapi","branchName","main","version","path","","project",{"_33":61,"_13":14,"_45":62,"_63":-5,"_64":53,"_65":66,"_67":66,"_68":69,"_70":-5,"_71":72,"_73":37,"_74":44,"_75":-5,"_76":-5,"_77":78,"_79":80,"_81":-5,"_82":-5,"_83":-5,"_84":-5,"_85":86,"_87":86,"_88":89,"_90":89,"_91":89,"_92":86,"_93":86,"_94":95,"_96":97,"_98":99,"_100":53},"tree",[56],"file","contents",[32],"upstream","pull","ahead","behind","envVars",{"_33":34,"_13":35,"_36":37,"_38":-5,"_39":40,"_41":42,"_43":44,"_45":46,"_17":47,"_48":49,"_50":51,"_52":53,"_54":-5,"_18":55},"id","083d577a-5e82-4ca8-ad45-f589fc56a22e","main.http.ts","fileId","4f197c9e-813f-11f1-adce-1607ee4eb77e","parentId","branchId","44f6494f-065c-4fba-8856-a426cb251299","branchVersion",9,"latest",true,"createdAt",["D",1784226119488],6,"fileType","http","content","// RB Grind — Random Grind (Val Town version)\n// Deploy entirely from your phone's browser at val.town — no CLI, no terminal,\n// no git needed. Paste this whole file into a new \"HTTP\" val and it's live.\n//\n// This engine logic (BASE, generateTrick, computeDisplay, the V3 naming engine,\n// aliases) is copied verbatim from rb-trick-gen-v3_05.jsx — same source of truth,\n// so results always match the app's Generator. If the app's engine changes later,\n// re-copy the block between BASE and the end of computeDisplay into this file.\n\n// ============ BEGIN ENGINE (copied from rb-trick-gen-v3_05.jsx) ============\nconst C = {\n bg:'#F5F0E8', surface:'#EDE8DC', border:'#D9D3C7',\n text:'#0D0B08', muted:'#6B6455', accent:'#1A3FD4',\n accentLight:'#E8EDFF', white:'#FFFFFF',\n};\n\n// ══ ENGINE (verified in isolation, 40/40 tests) ══════════════════════════════\nconst NEG_OK = new Set(['soul','acid','torquesoul','mizu','pornstar','mistrial','makio','sidewalk']);\nconst RT_OK = new Set(['soul','acid','torquesoul','mizu','pornstar','mistrial','makio','xgrind','sidewalk']);\n\nconst BASE = [\n { id:'soul', name:'Soul', fam:'soul', lead:'Fastslide', trail:'Makio', soulFoot:'trail', topLead:'BS Fastslide', topTrail:'Fishbrain' },\n { id:'acid', name:'Acid', fam:'soul', lead:'BS Backslide', trail:'Makio', soulFoot:'trail', topLead:'Backslide', topTrail:'Fishbrain' },\n { id:'torquesoul',name:'Torque Soul', fam:'soul', lead:'Torque', trail:'Makio', soulFoot:'trail', topLead:'BS Torque', topTrail:'Fishbrain' },\n { id:'mizu', name:'Mizu', fam:'soul', lead:'Makio', trail:'BS Pudslide', soulFoot:'lead', topLead:'Fishbrain', topTrail:'Pudslide' },\n { id:'pornstar', name:'Pornstar', fam:'soul', lead:'Makio', trail:'Torque', soulFoot:'lead', topLead:'Fishbrain', topTrail:'BS Torque' },\n { id:'mistrial', name:'Mistrial', fam:'soul', lead:'Makio', trail:'BS Backslide', soulFoot:'lead', topLead:'Fishbrain', topTrail:'Backslide' },\n { id:'makio', name:'Makio', fam:'soul', lead:null, trail:'Makio', soulFoot:'trail', topLead:null, topTrail:'Fishbrain' },\n { id:'xgrind', name:'X-Grind', fam:'soul', lead:'Fishbrain', trail:'Makio', soulFoot:'trail', noTop:true },\n { id:'teakettle', name:'Tea Kettle', fam:'soul', lead:'Rough Makio', trail:'Torque', soulFoot:'lead', gate:'rough', negName:'Negative Tea Kettle', noTop:true, noRT:true },\n { id:'hotdog', name:'Hot Dog', fam:'soul', lead:'Negative Makio',trail:'Negative Makio', soulFoot:'both', gate:'negative', noTop:true, noNeg:true, noRT:true },\n { id:'stubsoul', name:'Stub Soul', fam:'soul', lead:'Negative Makio',trail:'Makio', soulFoot:'trail', gate:'negative', noTop:true, noNeg:true, noRT:true },\n { id:'frontside', name:'Frontside', fam:'groove', lead:'Fastslide', trail:'Pudslide', bsLead:'BS Fastslide', bsTrail:'BS Pudslide' },\n { id:'farv', name:'Full Torque', fam:'groove', lead:'Torque', trail:'Pudslide', bsLead:'BS Torque', bsTrail:'BS Pudslide' },\n { id:'royale', name:'Royale', fam:'groove', lead:'Fastslide', trail:'Backslide', bsLead:'BS Fastslide', bsTrail:'BS Backslide' },\n { id:'cabdriver', name:'Cabdriver', fam:'groove', lead:'Torque', trail:'Backslide', bsLead:'BS Torque', bsTrail:'BS Backslide' },\n { id:'unity', name:'Unity', fam:'groove', lead:'Backslide', trail:'Torque', bsLead:'BS Backslide', bsTrail:'BS Torque' },\n { id:'savannah', name:'Savannah', fam:'groove', lead:'Backslide', trail:'Torque', bsLead:'BS Backslide', bsTrail:'BS Torque', fsName:'Savannah', bsName:'Backside Savannah', fsSub:'AO Unity', bsSub:'AO BS Unity' },\n { id:'pudslide', name:'Pudslide', fam:'groove', lead:null, trail:'Pudslide', bsLead:null, bsTrail:'BS Pudslide', def:false },\n { id:'fastslide', name:'Fastslide', fam:'groove', lead:'Fastslide', trail:null, bsLead:'BS Fastslide', bsTrail:null, def:false },\n { id:'torque_g', name:'Torque', fam:'groove', lead:'Torque', trail:null, bsLead:'BS Torque', bsTrail:null },\n { id:'backslide', name:'Backslide', fam:'groove', lead:null, trail:'Backslide', bsLead:null, bsTrail:'BS Backslide' },\n { id:'tabernacle',name:'Tabernacle', fam:'groove', lead:'Backslide', trail:'BS Pudslide',bsLead:'BS Backslide', bsTrail:'Pudslide', def:false },\n { id:'bynsoul', name:'Byn Soul', fam:'groove', lead:'Fastslide', trail:'BS Torque', bsLead:'BS Fastslide', bsTrail:'Torque', def:false },\n { id:'ufo', name:'UFO', fam:'groove', lead:'Fastslide', trail:'Pudslide', bsLead:'BS Fastslide', bsTrail:'BS Pudslide' },\n { id:'darkslide', name:'Darkslide', fam:'groove', lead:'BS Backslide', trail:'Backslide', bsLead:'Backslide', bsTrail:'BS Backslide', def:false },\n { id:'wheelbarrow',name:'Wheelbarrow', fam:'groove', lead:'Wheel', trail:'Backslide', bsLead:'Wheel', bsTrail:'BS Backslide', def:false },\n];\n\nconst SPECIAL = {\n 'ao|torquesoul':'Soyale', 'mizu|top':'Sweatstance', 'makio|top':'Fishbrain',\n 'ao|mizu|top':'Kindgrind',\n};\n\n// ═══ V3 POSE-ENGINE NAMING ═════════════════════════════════════════════════\n// Compact port of grindModel.js naming, keyed by the app's grind id + flags.\n// This is the real production namer (see \"V3 IS NOW THE NAMER\" below, ~line 513) —\n// computeDisplay calls V3.name() for the grind-name core and alias resolution.\nconst V3 = (() => {\n // base display names by id\n const NAME = {\n soul:'Soul', acid:'Acid', torquesoul:'Torque Soul', mizu:'Mizu', pornstar:'Pornstar',\n mistrial:'Mistrial', makio:'Makio', xgrind:'X-Grind', teakettle:'Tea Kettle',\n citric:'Citric Acid', hotdog:'Hot Dog', stubsoul:'Stub Soul', sidewalk:'Sidewalk',\n frontside:'Frontside', farv:'Full Torque', royale:'Royale', cabdriver:'Cab Driver',\n unity:'Unity', savannah:'Savannah', pudslide:'Pudslide', fastslide:'Fastslide',\n torque_g:'Torque', backslide:'Backslide', tabernacle:'Tabernacle', bynsoul:'Byn Soul',\n ufo:'UFO', darkslide:'Darkslide', wheelbarrow:'Wheelbarrow',\n };\n const ALIASES = {\n 'AO Torque Soul':'Soyale','AO Topside Mizu':'Kindgrind',\n 'Topside Makio':'Fishbrain','Topside Mizu':'Sweatstance',\n 'AO Unity':'Savannah','AO Backside Unity':'Backside Savannah',\n };\n const AO_PARTNER = { royale:'Full Torque', torque_g:'Backslide', fastslide:'Pudslide',\n backslide:'Torque', pudslide:'Fastslide', farv:'Royale' };\n const AO_SYMMETRIC = new Set(['frontside','cabdriver']);\n const HYBRID = { tabernacle:{rev:'backside',top:false}, darkslide:{rev:'backside',top:false,noTrue:true},\n bynsoul:{rev:'topside',top:true}, wheelbarrow:{rev:'backside',top:false} };\n const isSoul = id => ['soul','acid','torquesoul','mizu','pornstar','mistrial','makio',\n 'xgrind','teakettle','citric','hotdog','stubsoul','sidewalk'].includes(id);\n\n // alias resolver: peel topside then AO on miss, prefix peeled + mods\n function nameWithFlags(base, f={}) {\n const { ao, topside, negative, rough, tough } = f;\n const key = (a,t)=>[a?'AO':null,t?'Topside':null,base].filter(Boolean).join(' ');\n const peeled=[]; let core=ALIASES[key(ao,topside)];\n if(!core && topside){ const h=ALIASES[key(ao,false)]; if(h){core=h;peeled.push('Topside');} }\n if(!core && ao){ const h=ALIASES[key(false,topside)]; if(h){core=h;peeled.push('AO');} }\n if(!core) core=key(ao,topside);\n const mods=[]; if(negative)mods.push('Negative'); if(rough)mods.push('Rough'); if(tough)mods.push('Tough');\n return [...mods,...peeled,core].join(' ');\n }\n function validity(id, f={}) {\n if(f.christ && f.antichrist) return 'no Christ + Antichrist together';\n if(id==='hotdog'){ if(f.topside)return 'no Topside Hot Dog'; if(f.negative)return 'Hot Dog always negative'; }\n if(id==='xgrind' && f.negative) return 'no Negative X-Grind';\n if(HYBRID[id] && f.negative) return 'no Negative '+NAME[id];\n if(HYBRID[id] && f.topside && !HYBRID[id].top) return 'no Topside '+NAME[id];\n return null;\n }\n // Christ/Antichrist: per Jim's slot order they sit immediately before the BASE word,\n // AFTER any leading orientation tokens (AO / Backside / Topside). When an alias has\n // absorbed the orientation (e.g. Topside Makio -> Fishbrain) there is no leading token\n // left, so christ leads: \"Christ Fishbrain\". \"AO Fishbrain\" -> \"AO Christ Fishbrain\".\n // Rule A (Jim). Implemented by splitting off the leading orientation run and inserting.\n const ORIENT = new Set(['AO','Backside','Topside']);\n function christPrefix(str, f={}) {\n const label = f.christ ? 'Christ' : (f.antichrist ? 'Anti Christ' : null);\n if(!label) return str;\n const toks = str.split(' ');\n let i = 0;\n while(i < toks.length && ORIENT.has(toks[i])) i++; // skip the leading orientation run\n if(i >= toks.length) i = toks.length - 1; // all-orientation guard (never happens)\n toks.splice(i, 0, label);\n return toks.join(' ');\n }\n // main: id + flags → name (or a \"blocked\" note)\n // For grooves, `backside` (the FS/BS orientation) is distinct from soul AO.\n function name(id, f={}) {\n const v = validity(id,f); if(v) return '⚠ '+v;\n // christPrefix wraps the resolved name at the single exit below, so christ/antichrist\n // land right before the base/alias per the slot order (e.g. \"Christ Fishbrain\").\n return christPrefix(nameCore(id,f), f);\n }\n function nameCore(id, f={}) {\n const base = NAME[id] || id;\n if(!isSoul(id)) {\n // GROOVE / HYBRID\n if(HYBRID[id]) {\n // hybrids: soul-style naming. Reversal signalled via `backside`/`ao` from app.\n const r = HYBRID[id];\n let core = base;\n const reversed = f.backside || f.ao;\n // Byn Soul: treated soul-style. topside → \"Topside Byn Soul\";\n // reversed → \"AO Byn Soul\"; both → \"AO Topside Byn Soul\".\n if(id==='bynsoul') {\n const parts = [];\n if(reversed) parts.push('AO');\n if(f.topside) parts.push('Topside');\n parts.push('Byn Soul');\n return parts.join(' ');\n }\n // Tabernacle / Darkslide / Wheelbarrow: reversal → Backside X\n if(reversed && r.rev==='backside') core = 'Backside '+core;\n return core;\n }\n // pure groove: backside is an orientation prefix (or a special BS name).\n // AO handled by partner table only when NOT backside (rare in practice).\n let core = base;\n // special backside names: BS Frontside → \"Backside\"; Unity → \"Backside Unity\"\n const BS_SPECIAL = { frontside:'Backside', unity:'Backside Unity', savannah:'Backside Savannah' };\n if(f.backside) {\n core = BS_SPECIAL[id] || ('Backside '+base);\n return core;\n }\n // forward groove, no backside: just the base (AO-partner naming only applies\n // to true reverse-travel, which the app expresses via `away`/BS, so bare here)\n return core;\n }\n return nameWithFlags(base,f);\n }\n return { name, validity };\n})();\n// ═══════════════════════════════════════════════════════════════════════════\n\n// Book of Grinds reference links. URLs verified via search.\n// Special-name grinds have their own dedicated BoG pages — link those when shown.\nconst BOG_BASE = 'https://bookofgrinds.com/';\nconst BOG_INDEX = BOG_BASE + 'index.html';\nconst BOG_LINKS = {\n // Soul grinds\n soul: BOG_BASE+'02.0_Soul.html',\n acid: BOG_BASE+'05.0_Acid.html',\n torquesoul: BOG_BASE+'08.0_Torque_Soul.html',\n mizu: BOG_BASE+'03.0_Mizou.html',\n pornstar: BOG_BASE+'04.0_PStar.html',\n mistrial: BOG_BASE+'07.0_Mistrial.html',\n makio: BOG_BASE+'01.0_Makio.html',\n xgrind: BOG_BASE+'06.0_X_Grind.html',\n citric: BOG_BASE+'05.1_Citric_Acid.html',\n teakettle: BOG_BASE+'13.0_Tea_Kettle.html',\n hotdog: BOG_BASE+'11.0_Hot_Dog.html',\n stubsoul: BOG_BASE+'10.0_Stub_Soul.html',\n sidewalk: BOG_BASE+'04.1_Sidewalk.html',\n // Groove grinds\n frontside: BOG_BASE+'01.0_Frontside.html',\n farv: BOG_BASE+'04.0_Full_Torque.html',\n royale: BOG_BASE+'03.0_Royale.html',\n cabdriver: BOG_BASE+'09.0_Cab_driver.html',\n unity: BOG_BASE+'07.0_Unity.html',\n pudslide: BOG_BASE+'11.0_Pudslide.html',\n fastslide: BOG_BASE+'10.0_Fastslide.html',\n torque_g: BOG_BASE+'05.0_Torque.html',\n backslide: BOG_BASE+'06.0_Backslide.html',\n tabernacle: BOG_BASE+'12.0_Tabernacle.html',\n ufo: BOG_BASE+'08.0_UFO_(Low_FS_or_BS).html',\n darkslide: BOG_BASE+'14.0_Darkslide.html',\n wheelbarrow: BOG_BASE+'15.0_Wheelbarrow.html',\n savannah: BOG_BASE+'09.0_Savannah_(AO_Unity).html',\n};\n// Special-name grinds → their dedicated BoG pages (keyed by display name)\nconst BOG_SPECIAL = {\n 'Soyale': BOG_BASE+'04.0_Soyale_(AO_Torque_Soul).html',\n 'Sweatstance': BOG_BASE+'02.0_Sweatstance_(Topside_Mizou).html',\n 'Fishbrain': BOG_BASE+'01.0_Fishbrain_(Topside_Makio).html',\n 'Kindgrind': BOG_BASE+'03.0_Kindgrind_(AO_Topside_Mizou).html',\n 'AO Topside Mistrial': BOG_BASE+'07.0_Misfit_(AO_Topside_Mistrial).html',\n 'Topside Mistrial': BOG_BASE+'10.0_Overpuss_(Topside_Mistrial).html',\n 'Topside Pornstar': BOG_BASE+'05.0_Sunny_Day_(Topside_PStar).html',\n 'AO Topside Pornstar': BOG_BASE+'06.0_Cloudy_Night_(AO_Topside_PStar).html',\n 'Savannah': BOG_BASE+'09.0_Savannah_(AO_Unity).html',\n 'Backside Savannah': BOG_BASE+'09.1_Backside_Savannah_(AO_BS_Unity).html',\n 'Backside': BOG_BASE+'02.0_Backside.html',\n};\n// Resolve the best BoG link given the base trick and what's actually displayed.\nconst bogLink = (baseId, special) => {\n if(special && BOG_SPECIAL[special]) return BOG_SPECIAL[special];\n return BOG_LINKS[baseId] || BOG_INDEX;\n};\n\nconst byName = (a,b) => a.name.localeCompare(b.name);\nconst SOUL_TRICKS = BASE.filter(b=>b.fam==='soul').sort(byName);\nconst GROOVE_TRICKS = BASE.filter(b=>b.fam==='groove').sort(byName);\n\nconst roll = (pct) => Math.random()*100 < pct;\nconst pick = (a) => a[Math.floor(Math.random()*a.length)];\nconst prefixFoot = (l,p) => l ? `${p} ${l}` : l;\nconst isSingleFoot = (t) => !t.lead || !t.trail;\n// Entry degrees within [min,max]. Souls: 0/180/360/540 in range. Grooves: 90/270/450,\n// but the 90° lock is their floor — a range that reaches down to/below 90 (e.g. 0–0,\n// \"no spin\") still yields the basic 90° groove, since the lock is mandatory, not added spin.\n// A range that starts above 90 (e.g. 180–180) excludes grooves entirely (souls-only).\nconst validInDeg = (fam, min, max) => {\n if(fam==='soul') return [0,180,360,540].filter(d => d>=min && d<=max);\n let g = [90,270,450].filter(d => d>=min && d<=max);\n if(min <= 90 && !g.includes(90)) g = [90, ...g];\n return g;\n};\n// Exit degrees within [min,max]. 0 = \"no spin off\", valid for both families when in range.\nconst validOutDeg = (fam, min, max) => {\n const set = fam==='soul' ? [0,180,360,540] : [0,90,270,450];\n return set.filter(d => d>=min && d<=max);\n};\n\n// topside eligibility: souls generally, plus Byn Soul specifically (a groove that\n// takes topside per Jim's hybrid ruling — \"Byn Soul reversed = AO Byn Soul; it\n// takes topside not backside\". Previously gated to fam==='soul' only in both\n// generateTrick and enumerateVariants, which made \"Topside Byn Soul\" nameable but\n// unreachable/uncounted — fixed by sharing this single definition between them.\nconst topEligible = (b) => (b.fam==='soul' && !b.noTop) || b.id==='bynsoul';\nfunction generateTrick(F) {\n const { spins:SP, sliders:SL } = F;\n const pool = BASE.filter(b => {\n if(F.tricks[b.id] === false) return false;\n if(b.gate && SL[b.gate] <= 0) return false;\n // drop the trick if its family has no valid entry degree in the In-spin range\n if(validInDeg(b.fam, SP.inMin, SP.inMax).length === 0) return false;\n return true;\n });\n if(!pool.length) return null;\n\n // topside eligibility defined at module scope (topEligible, above) so both\n // generateTrick and enumerateVariants use the identical rule.\n\n // Population-fraction normalization: Switch is legal on every trick, while\n // Negative/Rough/Tough/Christ/Antichrist/Topside are only legal on a subset (souls,\n // single-foot grinds, etc). At equal slider values that dilutes the gated ones well\n // below their number while Switch lands at its full slider rate — Switch (and\n // anything stacked with it) then feels dramatically overrepresented. Scaling each\n // gated modifier's roll by 1/eligibleFraction (within the currently enabled pool)\n // makes every slider mean the same thing: \"this % of ALL generated tricks\",\n // uniformly, Switch included (which needs no scaling — already ~100% eligible).\n const frac = (test) => { const n = pool.filter(test).length; return n / pool.length; };\n const fTop = frac(topEligible) || 1;\n const fNeg = frac(b => NEG_OK.has(b.id) && !b.noNeg) || 1;\n const fRT = frac(b => RT_OK.has(b.id) && !b.noRT) || 1;\n const fCA = frac(b => isSingleFoot(b)) || 1;\n const scaledRoll = (slider, fEligible) => slider > 0 && roll(Math.min(100, slider / fEligible));\n\n const base = pick(pool);\n const fam = base.fam;\n const inDeg = pick(validInDeg(fam, SP.inMin, SP.inMax));\n const fakieIn = roll(SP.fakieIn);\n let away = fam==='soul' ? (SP.truespin ? Math.random()<0.5 : false) : Math.random()<0.5;\n let top = topEligible(base) && SL.topside>0 ? scaledRoll(SL.topside, fTop) : false;\n let neg = NEG_OK.has(base.id) && !base.noNeg && !top && SL.negative>0 ? scaledRoll(SL.negative, fNeg) : false;\n let rough=false, tough=false;\n if(RT_OK.has(base.id) && !base.noRT && !top) {\n const rHit = SL.rough>0 && scaledRoll(SL.rough, fRT);\n const tHit = SL.tough>0 && scaledRoll(SL.tough, fRT);\n if(rHit && tHit) (Math.random()<0.5 ? rough=true : tough=true);\n else { rough=rHit; tough=tHit; }\n }\n let christ=false, antichrist=false;\n if(!neg && !rough && !tough && isSingleFoot(base)) {\n const cHit = SL.christ>0 && scaledRoll(SL.christ, fCA);\n const aHit = SL.antichrist>0 && scaledRoll(SL.antichrist, fCA);\n if(cHit && aHit) (Math.random()<0.5 ? christ=true : antichrist=true);\n else { christ=cHit; antichrist=aHit; }\n }\n let sw = SL.switch>0 && roll(SL.switch); // always-eligible on every trick — no scaling needed\n // exit degrees in range; if none valid (range excludes 0 and all family degrees), no spin off\n const outOpts = validOutDeg(fam, SP.outMin, SP.outMax);\n const outDeg = outOpts.length ? pick(outOpts) : 0;\n const rewind = outDeg>0 && SP.rewindOut>0 && roll(SP.rewindOut);\n return { baseId:base.id, fam, entry:{inDeg,fakieIn,away,top}, mods:{neg,rough,tough,christ,antichrist,sw}, exit:{outDeg,rewind} };\n}\n\n// Enumerate EVERY trick variant the generator can currently produce, mirroring the exact\n// eligibility/blocking rules in generateTrick. Used to determine — deterministically — the\n// full space of possible tricks (so \"Pool Complete\" is exact, not a random-sampling guess,\n// even with rare modifiers). A probability of 0 means that modifier is off (only its absent\n// value is possible); >0 means both present and absent are possible.\nfunction enumerateVariants(F) {\n const { spins:SP, sliders:SL } = F;\n const out = [];\n const bases = BASE.filter(b => {\n if(F.tricks[b.id] === false) return false;\n if(b.gate && SL[b.gate] <= 0) return false;\n if(validInDeg(b.fam, SP.inMin, SP.inMax).length === 0) return false;\n return true;\n });\n const opts = (cond) => cond ? [false, true] : [false]; // [absent] or [absent, present]\n // Slider-aware version (v3.02 fix): at 100% a modifier is FORCED ON (drop the absent\n // case), at 1-99% both cases are possible, at 0% (or ineligible) only absent. Mirrors\n // generateTrick, where roll(100) is always true. `eligible` gates by base/rule.\n const optsP = (eligible, pct) => !eligible ? [false] : (pct >= 100 ? [true] : (pct > 0 ? [false, true] : [false]));\n // Mutually-exclusive pair (rough/tough, christ/antichrist). Returns [a,b] combos.\n // v3.02: if EITHER slider is 100%, the \"neither\" (plain) case is dropped — one of them\n // must appear. Both at 100% → keep both singles, drop plain (can't force both at once).\n // Below 100%, a possible modifier adds its single variant and plain stays in.\n const pairP = (eligA, pctA, eligB, pctB) => {\n const aPossible = eligA && pctA > 0;\n const bPossible = eligB && pctB > 0;\n const forced = (eligA && pctA >= 100) || (eligB && pctB >= 100);\n const combos = [];\n if(!forced) combos.push([false, false]);\n if(aPossible) combos.push([true, false]);\n if(bPossible) combos.push([false, true]);\n if(!combos.length) combos.push([false, false]); // neither eligible → plain only\n return combos;\n };\n const outDegs = (fam) => {\n const o = validOutDeg(fam, SP.outMin, SP.outMax);\n return o.length ? o : [0];\n };\n for(const base of bases) {\n const fam = base.fam;\n const inDegs = validInDeg(fam, SP.inMin, SP.inMax);\n const fakieOpts = opts(SP.fakieIn > 0);\n const awayOpts = fam==='soul' ? (SP.truespin ? [false,true] : [false]) : [false,true];\n const topOpts = optsP(topEligible(base), SL.topside);\n for(const inDeg of inDegs)\n for(const fakieIn of fakieOpts)\n for(const away of awayOpts)\n for(const top of topOpts) {\n // negative: only when eligible and not topside\n const negOpts = optsP(NEG_OK.has(base.id) && !base.noNeg && !top, SL.negative);\n for(const neg of negOpts) {\n // rough/tough: eligible, not topside; mutually exclusive on a single soul plate\n const rtEligible = RT_OK.has(base.id) && !base.noRT && !top;\n const rtCombos = pairP(rtEligible, SL.rough, rtEligible, SL.tough);\n for(const [rough,tough] of rtCombos) {\n // christ/antichrist: single-foot only, blocked by neg/rough/tough, mutually exclusive\n const caEligible = !neg && !rough && !tough && isSingleFoot(base);\n const caCombos = pairP(caEligible, SL.christ, caEligible, SL.antichrist);\n for(const [christ,antichrist] of caCombos)\n for(const sw of optsP(true, SL.switch))\n for(const outDeg of outDegs(fam))\n for(const rewind of (outDeg>0 && SP.rewindOut>0 ? [false,true] : [false])) {\n out.push({ baseId:base.id, fam, entry:{inDeg,fakieIn,away,top}, mods:{neg,rough,tough,christ,antichrist,sw}, exit:{outDeg,rewind} });\n }\n }\n }\n }\n }\n return out;\n}\n\n// grind-facing landing stance from approach + total rotation (0=forward, 1=fakie)\nfunction landFacing(fakieIn, totalDeg) {\n return ((fakieIn ? 1 : 0) + Math.round(totalDeg/180)) % 2;\n}\n\n// Returns the entry prefix word(s) WITHOUT the bare AO label (that's applied centrally),\n// plus flags: landsFakie (=AO position on a soul), isBS (groove backside), isZero,\n// namedDir (entry uses a direction word — Truespin/Inspin/Outspin — that already implies\n// the fakie landing, so the bare \"AO\" label is suppressed).\nfunction entryName(fam, e, detailed) {\n let word='', isBS=false, isZero=false, namedDir=false;\n const landsFakie = fam==='soul' && landFacing(e.fakieIn, e.inDeg) === 1;\n if(fam==='soul') {\n if(e.inDeg===0) {\n if(e.fakieIn) { word = detailed ? 'Zero Spin' : 'Zero'; isZero=true; }\n } else {\n // A 540 is a full 360 (back to square) plus a 180; the 180 component is what gets\n // named. Direction words (Truespin/Inspin/Outspin) show only at ODD half-rotations\n // (180, 540) — at 360 you're back to square, so no direction word. AO (fwd+toward)\n // is applied centrally. The degree is prefixed when >= 360.\n const deg = e.inDeg >= 360 ? String(e.inDeg) : '';\n const hasHalf = (e.inDeg / 180) % 2 === 1; // 180 or 540\n let dir = '';\n if(hasHalf) {\n if(!e.fakieIn && !e.away) dir = ''; // AO — added centrally\n else if(!e.fakieIn && e.away) { dir = detailed ? 'Truespin' : 'True'; namedDir=true; }\n else if(e.fakieIn && !e.away) { dir = 'Inspin'; namedDir=true; }\n else { dir = 'Outspin'; namedDir=true; }\n }\n // \"Fakie\" marks a backward approach, but only when no direction word already implies\n // it (Inspin/Outspin do). This covers the 360 case → \"Fakie 360 Soul\".\n const fk = (e.fakieIn && !namedDir) ? 'Fakie' : '';\n word = [fk, deg, dir].filter(Boolean).join(' ');\n }\n } else {\n // GROOVE: rail position (front/back) + backward-approach marker + degree at 270/450.\n // Backward approach at the bare 90 lock (no added spin) = \"Zero\" / \"Zero Spin\".\n // Backward approach with actual rotation (270/450) = \"Fakie\" (traveling fakie into the spin).\n const parts = [];\n if(e.fakieIn) {\n if(e.inDeg === 90) { parts.push(detailed ? 'Zero Spin' : 'Zero'); isZero = true; }\n else parts.push('Fakie');\n }\n if(e.inDeg !== 90) parts.push(String(e.inDeg));\n // Detail mode: label the spin DIRECTION (toward=Inspin, away=Outspin) after the\n // degree — display only, for readability. Only when there's an actual spin (not the\n // bare 90 lock). BS is kept separately below (backside is a distinct property).\n if(e.inDeg !== 90) parts.push(e.away ? 'Outspin' : 'Inspin');\n // Backside is the LANDED facing, not just the stored `away` flag. A groove's base\n // lock is 90 (frontside); every extra 180 of entry rotation flips FS<->BS. So a\n // forward 270 lands backside even with away=false. Combine the rotation flip with\n // the away flag (XOR).\n const rotFlip = (Math.round((e.inDeg - 90) / 180) % 2 + 2) % 2 === 1;\n const landsBackside = rotFlip !== !!e.away;\n if(landsBackside) { parts.push('BS'); isBS = true; }\n word = parts.join(' ');\n }\n return { word, landsFakie, isBS, isZero, namedDir };\n}\n\nfunction landingStance(entry, effectiveExitDeg) {\n const approach = entry.fakieIn ? 1 : 0;\n const total = entry.inDeg + effectiveExitDeg;\n const facing = (approach + Math.round(total/180)) % 2;\n return facing===0 ? 'to forward' : 'to fakie';\n}\n\nfunction exitName(fam, entry, exit, detailed) {\n if(exit.outDeg === 0) return '';\n const natural = fam==='soul' ? 180 : 90;\n const rewindDeg = fam==='soul' ? 180 : 270;\n if(exit.rewind) {\n const stance = landingStance(entry, natural);\n return detailed ? `${rewindDeg} rewind out ${stance}` : 'rewind out';\n }\n const stance = landingStance(entry, exit.outDeg);\n if(exit.outDeg === natural) return detailed ? `${exit.outDeg} out ${stance}` : stance;\n return detailed ? `${exit.outDeg} out ${stance}` : `${exit.outDeg} out`;\n}\n\nfunction computeDisplay(t, opts={}) {\n if(!t) return null;\n const { specialFirst=true, detailed=false, spellBackside=true } = opts;\n const base = BASE.find(b=>b.id===t.baseId);\n const { entry:e, mods:m, exit:x } = t;\n const fam = base.fam;\n const en = entryName(fam, e, detailed);\n const tags = [];\n if(e.top) tags.push('top');\n if(en.landsFakie && !en.isZero && !en.namedDir) tags.push('ao'); // AO only when no direction word already names it (Truespin/In/Out) and not a Zero\n const tagKey = [...tags, base.id].sort().join('|');\n const special = SPECIAL[tagKey] || null;\n\n let lead, trail;\n if(e.top && base.topLead!==undefined) { lead=base.topLead; trail=base.topTrail; }\n else if(en.isBS && base.bsLead!==undefined) { lead=base.bsLead; trail=base.bsTrail; }\n else { lead=base.lead; trail=base.trail; }\n const sf = base.soulFoot;\n const apply = (which,pre) => {\n if(which==='lead'||which==='both') lead=prefixFoot(lead,pre);\n if(which==='trail'||which==='both') trail=prefixFoot(trail,pre);\n };\n if(!e.top) {\n if(m.neg) apply(sf,'Negative');\n if(m.rough) apply(sf==='both'?'lead':sf,'Rough');\n if(m.tough) apply(sf==='both'?'trail':sf,'Tough');\n }\n\n // AO FOOT DISPLAY — when a soul is ridden alley-oop you've turned around, so the\n // foot that was leading now trails and vice-versa. The souling foot itself doesn't\n // change (AO keeps the same soul foot; only orientation reverses), so this is a pure\n // lead/trail relabel — same plate names, swapped positions — to show the feet as they\n // actually are when landed and grinding. Done AFTER modifier prefixes so Negative/\n // Rough/Tough land on the correct (soul) foot first, then the whole thing flips.\n if(en.landsFakie) { const tmp = lead; lead = trail; trail = tmp; }\n\n let core = base.name, usedNeg=false;\n if(m.neg && base.negName) { core=base.negName; usedNeg=true; }\n let customSub=null, word=en.word;\n if(base.fsName) {\n if(en.isBS) { core=base.bsName; customSub=base.bsSub; }\n else { core=base.fsName; customSub=base.fsSub; }\n // \"Backside Savannah\" already encodes BS — strip the BS token, keep Fakie/degree\n word = word.split(' ').filter(p => p !== 'BS').join(' ');\n }\n // A backside Frontside grind is just called a \"Backside\" — drop the redundant\n // \"Frontside\" word and the \"BS\" token (e.g. \"BS Frontside\" → \"Backside\").\n let backsideOverride = false;\n if(base.id==='frontside' && en.isBS) {\n core = 'Backside';\n word = word.split(' ').filter(p => p !== 'BS').join(' ');\n backsideOverride = true;\n }\n\n // Bare \"AO\" label: shown whenever a soul lands fakie (the grind position), regardless of\n // approach. \"Fakie\" (approach) and \"AO\" (grind position) are independent and can stack,\n // e.g. a fakie 360 → \"Fakie 360 AO Soul\". Suppressed only when a special name encodes the\n // position, the entry is Zero, or a direction word (Inspin/Outspin) already implies it.\n const showAO = en.landsFakie && !special && !en.isZero && !en.namedDir && !base.fsName;\n\n // ═══ V3 IS NOW THE NAMER ═══════════════════════════════════════════════\n // V3 owns the grind-name CORE (base + AO/backside + topside + negative + rough/\n // tough + alias resolution). The app keeps wrapping the spin word, Switch, Christ/\n // Antichrist, and the exit suffix around it — decorations V3 doesn't model.\n const _v3ao = fam==='soul' ? (en.landsFakie && !en.isZero && !en.namedDir) : false;\n const _v3backside = fam==='groove' ? en.isBS : false;\n const v3Core = V3.name(t.baseId, {\n ao:_v3ao, backside:_v3backside, topside:!!e.top,\n negative:!!m.neg, rough:!!m.rough, tough:!!m.tough,\n christ:!!m.christ, antichrist:!!m.antichrist,\n });\n // If V3 returns a validity block (⚠ …) fall back to the old core so nothing breaks.\n const v3Valid = v3Core && !v3Core.startsWith('⚠');\n\n const buildTech = () => {\n const p=[];\n if(m.sw) p.push('Switch');\n // V3 owns the Backside label, so strip a leading/standalone \"BS\" token from the\n // app's spin word to avoid \"BS Backside …\" doubling.\n let w = word;\n if(v3Valid && w) w = w.split(' ').filter(tok => tok !== 'BS').join(' ');\n if(w) p.push(w);\n if(v3Valid) {\n // V3 grind name — already includes AO/topside/neg/etc. AND the christ/antichrist\n // prefix (V3 owns it now; app no longer wraps it here).\n p.push(v3Core);\n } else {\n // fallback: old assembly (V3 returned invalid; app still names christ here).\n // Order preserved from the pre-parity code: christ/antichrist BEFORE the AO token.\n if(m.christ) p.push('Christ');\n if(m.antichrist) p.push('Anti Christ');\n if(showAO) p.push('AO');\n if(m.neg && !usedNeg) p.push('Negative');\n if(m.rough) p.push('Rough');\n if(m.tough) p.push('Tough');\n if(e.top) p.push('Topside');\n p.push(core);\n }\n return p.join(' ');\n };\n const buildSpecial = () => {\n const p=[];\n if(m.sw) p.push('Switch');\n // special name encodes AO/BS already; keep Fakie/degree tokens from the entry word\n const kept = word ? word.split(' ').filter(t => t!=='BS').join(' ') : '';\n if(kept) p.push(kept);\n if(m.neg) p.push('Negative');\n if(m.rough) p.push('Rough');\n if(m.tough) p.push('Tough');\n if(m.christ) p.push('Christ');\n if(m.antichrist) p.push('Anti Christ');\n p.push(special);\n return p.join(' ');\n };\n\n const exitSuffix = exitName(fam, e, x, detailed);\n let main, sub=null, specialName=null;\n if(v3Valid) {\n // V3 owns the name. It already resolved any alias (Soyale, Fishbrain, Savannah…),\n // so main = the V3-built tech string. specialName carries the alias/backside for\n // the BoG link routing when V3 produced one distinct from the plain base name.\n main = buildTech();\n const plain = (BASE.find(b=>b.id===t.baseId)||{}).name;\n if(v3Core && plain && v3Core !== plain && v3Core.indexOf(plain) === -1) specialName = v3Core;\n // Topside Pornstar / AO Topside Pornstar / Topside Mistrial / AO Topside Mistrial keep a\n // dedicated BoG page even though the literal name now contains the base name (Jim's\n // rename from Sunny Day/Cloudy Night/Overpuss/Misfit) — force the override past the\n // \"contains base name\" heuristic above so the link still resolves correctly.\n if(e.top && (t.baseId==='pornstar' || t.baseId==='mistrial')) specialName = v3Core;\n if(backsideOverride) specialName = 'Backside';\n if(customSub) sub = specialFirst ? customSub : null;\n } else if(special && !usedNeg) {\n specialName = special;\n if(specialFirst){ main=buildSpecial(); sub=buildTech(); }\n else { main=buildTech(); sub=buildSpecial(); }\n } else if(customSub) {\n specialName = core;\n main=buildTech();\n sub=specialFirst ? customSub : null;\n } else {\n main=buildTech();\n }\n if(backsideOverride) specialName = 'Backside'; // routes the BoG link to the Backside page\n if(exitSuffix) main = `${main} ${exitSuffix}`;\n // Detail OFF → abbreviate \"Backside\" to \"BS\" in the displayed name (Option A).\n // Exception: if \"Backside\" IS the whole name (a bare groove backside with no other\n // trick attached), keep it spelled out — a lone \"BS\" reads as a stray acronym.\n // Compound names (\"Backside UFO\") still abbreviate normally (\"BS UFO\").\n if(!spellBackside) {\n const abbr = s => { if(!s) return s; if(s === 'Backside') return s; return s.replace(/\\bBackside\\b/g, 'BS'); };\n main = abbr(main); sub = abbr(sub);\n }\n return { main, sub, lead, trail, specialName };\n}\n// ============= END ENGINE (copied from rb-trick-gen-v3_05.jsx) =============\n\n// Default filters — same values as the app's own makeInitFilters(false) defaults,\n// verified elsewhere in this project: all tricks enabled, all modifier sliders 5%,\n// spin range wide enough for full groove variety (inMax 270), fakieIn 10%.\nfunction defaultFilters() {\n return {\n tricks: Object.fromEntries(BASE.map(b => [b.id, true])),\n spins: { inMin:0, inMax:270, outMin:0, outMax:270, fakieIn:10, truespin:true, rewindOut:10, suMin:0, suMax:180, suRewind:10 },\n sliders: { switch:5, topside:5, negative:5, christ:5, antichrist:5, rough:5, tough:5 },\n };\n}\n\n// Query-param overrides, layered on top of the defaults above. Every param is\n// optional; bad/missing values just fall back to default rather than erroring —\n// a voice request should never come back empty because of a malformed URL.\n// ?mode=easy | hard preset slider baseline (see MODE_PRESETS below)\n// ?family=soul | groove restrict to one family\n// ?tricks=makio,soul,mizu restrict to an explicit trick allowlist (base ids)\n// ?switch=20&topside=0&... override any slider (0-100); valid keys:\n// switch, topside, negative, christ, antichrist, rough, tough\n// Precedence: default -> mode preset -> explicit slider params (explicit always wins,\n// so ?mode=hard&switch=0 means \"hard everything except switch is forced off\").\nconst SLIDER_KEYS = ['switch', 'topside', 'negative', 'christ', 'antichrist', 'rough', 'tough'];\nconst MODE_PRESETS = {\n // near-plain tricks: modifiers rarely show up, topside/christ/antichrist off\n // entirely (biggest single jumps in commitment); spins capped at the base lock\n // (souls: 0deg only, so no AO/Inspin/Outspin/Truespin at all; grooves: locked at\n // 90, so Backside is still possible but no 270s) and no spin-off exits.\n easy: {\n sliders: { switch:2, topside:0, negative:2, christ:0, antichrist:0, rough:2, tough:2 },\n spins: { inMin:0, inMax:0, outMin:0, outMax:0, fakieIn:5, truespin:false, rewindOut:0 },\n },\n // modifiers show up often and topside/christ/antichrist are back in the mix;\n // full spin range including souls up to 540 and grooves up to 450, higher\n // fakie-in and rewind-out rates, and spin-off exits back on.\n hard: {\n sliders: { switch:20, topside:25, negative:15, christ:15, antichrist:15, rough:15, tough:15 },\n spins: { inMin:0, inMax:540, outMin:0, outMax:540, fakieIn:25, truespin:true, rewindOut:25 },\n },\n};\nfunction filtersFromRequest(request) {\n const F = defaultFilters();\n let params;\n try { params = new URL(request.url).searchParams; } catch { return F; }\n\n const mode = params.get('mode');\n if (MODE_PRESETS[mode]) {\n Object.assign(F.sliders, MODE_PRESETS[mode].sliders);\n Object.assign(F.spins, MODE_PRESETS[mode].spins);\n }\n\n SLIDER_KEYS.forEach(k => {\n if (!params.has(k)) return;\n const v = Number(params.get(k));\n if (Number.isFinite(v) && v >= 0 && v <= 100) F.sliders[k] = v;\n });\n\n const fam = params.get('family');\n if (fam === 'soul' || fam === 'groove') {\n BASE.forEach(b => { if (b.fam !== fam) F.tricks[b.id] = false; });\n }\n\n if (params.has('tricks')) {\n const validIds = new Set(BASE.map(b => b.id));\n const requested = params.get('tricks').split(',').map(s => s.trim()).filter(id => validIds.has(id));\n // only apply the allowlist if at least one requested id was actually valid —\n // an all-typo list should fall back to \"everything enabled\", not \"nothing enabled\"\n if (requested.length) {\n const allow = new Set(requested);\n BASE.forEach(b => { if (!allow.has(b.id)) F.tricks[b.id] = false; });\n }\n }\n\n return F;\n}\n\nfunction randomGrindName(request) {\n const F = filtersFromRequest(request);\n let t = null, tries = 0;\n // generateTrick can rarely return null if a pool ends up empty mid-roll (e.g. an\n // overly narrow family+tricks combo); retry a few times rather than ever\n // returning a blank response to Siri.\n while (!t && tries < 10) { t = generateTrick(F); tries++; }\n if (!t) return \"Makio\"; // last-resort fallback — never say nothing\n return computeDisplay(t, { specialFirst: true, detailed: false, spellBackside: true }).main;\n}\n\n// Val Town HTTP val — plain text response, ready for Siri's \"Speak Text\" action.\n// Change the \"Try \" phrasing to whatever reads best out loud for you.\nexport default function (request) {\n const name = randomGrindName(request);\n return new Response(`Try ${name}`, {\n headers: { \"Content-Type\": \"text/plain; charset=utf-8\" },\n });\n}","deleted",false,"label",[35],{"_33":34,"_13":35,"_36":37,"_38":-5,"_39":40,"_41":42,"_43":44,"_45":57,"_17":47,"_48":49,"_50":51,"_52":53,"_54":-5,"_58":59,"_18":60},["D",1784226119488],"children",[],[35],"3d41a9f9-671d-4943-a6c6-ccc96bbcbdc4",["D",1784224433485],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","description","Rb grind shortcut api test","imageUrl","userId","60985218-9c16-4c39-a5ec-67c81d6a8158","pinnedFileId","pinPreview","pinMigrated","screenshotVersion","likeCount",0,"orgId","019f6c0f-93b6-777f-8d47-3c3cdc6c10f7","tursoName","tursoHostname","tursoMeasuredAt","pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_11":12,"_115":111},"org",{"_11":12,"_109":12,"_110":111,"_71":72,"_112":113,"_114":53},"branch",{"_17":42,"_13":16,"_33":40,"_101":61,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":14,"_108":12},"isOwned","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","displayName","avatar","https://avatars.githubusercontent.com/u/17491090?v=4","tier","free","canRestrictVals","profileImageUrl","adoptOrgId",{"_33":61,"_13":14,"_45":149,"_63":-5,"_64":53,"_65":66,"_67":66,"_68":69,"_70":-5,"_71":72,"_73":37,"_74":44,"_75":-5,"_76":-5,"_77":78,"_79":80,"_81":-5,"_82":-5,"_83":-5,"_84":-5,"_85":86,"_87":86,"_88":89,"_90":89,"_91":89,"_92":86,"_93":86,"_94":150,"_96":151,"_98":152,"_100":53},[146],"files",[146],"counts",{"_136":78,"_137":138,"_139":78,"_31":140,"_141":142},[134],"upstreamProject","upstreamBranch","emptyEnvVars","flags",[],"hasHttpFiles","grants","orgs","customDomains",{},{"_33":34,"_13":35,"_36":37,"_38":-5,"_39":40,"_41":42,"_43":44,"_45":46,"_17":47,"_48":49,"_50":51,"_52":53,"_54":-5,"_18":135},[35],"pulls","branches",1,"forks",{"_143":78,"_145":78},"connections",{"_143":78,"_144":78},"count","unfilledCount","emptyCount",{"_33":34,"_13":35,"_36":37,"_38":-5,"_39":40,"_41":42,"_43":44,"_45":57,"_17":47,"_48":49,"_50":51,"_52":53,"_54":-5,"_58":147,"_18":148},[],[35],["D",1784224433485],{"_11":12,"_115":111},{"_11":12,"_109":12,"_110":111,"_71":72,"_112":113,"_114":53},{"_17":42,"_13":16,"_33":40,"_101":61,"_102":-5,"_103":-5,"_104":-5,"_105":-5,"_106":-5,"_107":14,"_108":12},"ctx",{"_94":-5,"_131":186,"_187":188,"_189":190,"_191":53,"_192":53,"_193":53,"_194":44,"_195":-5,"_196":-7,"_197":-7,"_198":78,"_199":53,"_200":53,"_201":-5,"_202":53,"_203":53,"_204":53,"_205":-5},"ENV",{"_157":158,"_159":160,"_161":16,"_162":163,"_164":165,"_166":167,"_168":169,"_170":171,"_172":173,"_174":175,"_176":177,"_178":179,"_180":181,"_182":183,"_184":185},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","e87eb04e707cf64e7e532c8e8ec395f209e17f15","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]

Code