Reflector rework: survive EQ bundle refactors (structural anchor + fuzzy matching) — discovery map + spec

[atapifire]

Tracking issue for the Reflector rework after EvilQuest's 2026-06-21 bundle refactor. KKonaOG and api are working ideas on this — collaborative. The window.gm trigger fix already shipped (#27); this issue is the durable redesign so EQ updates become a signature refresh, not an outage.

Discovery below was produced from the live in-world bundle (read-only CDP). Goal aligns with KKonaOG's plan: parse index.js / source structurally for the entry point, then build the reflector from there in a semi-agnostic way.

Why it broke (two independent things)

1. window.gm removed → our parse poller was gated on it → never parsed → dead client. Fixed in Fix: restore client against EvilQuest's bundle update (window.gm removed) #27 (gate now keys off "GameManager source present in captured modules").
2. ~23 manager signatures + enums broke. The matcher requires ALL signature methods (AND-match), so a single rename kills a hook. Two sub-cases: renamed (new signature) and restructured/merged (class dissolved into another → retarget consumers).

Recommended design

Trigger (separate from matching — this is what bricked everyone): parse on modules-captured-and-settled, never on a game global; re-run when the bundle changes mid-session (track module set / content hash).

Structural anchor for GameManager (KKonaOG's index.js idea — keep it): in the captured source GameManager is the class whose body has static get BaseUrl and is instantiated exactly once (new <GM>( appears 1×). Name-independent → renames can't break it. Runtime cross-check: GameManager.Instance.constructor.name.

Fuzzy, multi-signal matching for the rest (replace AND-match):

• score by member overlap (methods + getters across the prototype chain), accept ≥ ~60%;
• combine signals: member names + the existing contains source-text check + member-count band;
• assert exactly-one match, log ambiguity (fuzziness raises collision odds — fail loud, never silent).
  Verified: every signature below resolves to exactly 1 class at the 0.6 threshold on this build (survives a single rename).

Discovery map — VERIFIED RENAMED (drop-in signatures)

Manager	Fuzzy signature
GameManager	updateMinimap, worldObjectDisplayName, waitForCurrentLocalPlayerReady, setupContextMenu (+ static get BaseUrl anchor)
EntityManager	createRemotePlayer, createNpc, findNearestNpc, createGroundItem
SocketManager	openSockets, sendFrame, handleOpcodeMapping, consumePendingInputTicket
ChunkManager	getMapId, getMapWidth, ensureFloorLayer, getTerrainDetailStats
InputManager	handlePrimaryActionAt, pickGround, setObjectClickHandler, setGroundClickHandler
BankUIManager	openWithContents, updateBankSlot, sendWithdrawMode, makeWithdrawModeToggle
ChatManager	appendMessage, addPrivateMessage, installChatStyles, isScrolledToChatBottom

Discovery map — RESTRUCTURED / MERGED (retarget consumers, NOT a signature swap)

• ItemDefinitionManager → EntityManager (itemDefsCache: Map<id,{name,icon,model}>)
• NpcDefinitionManager → EntityManager (npcDefsCache)
• world ContextMenuManager → GameManager (setupContextMenu, openWorldContextMenuAt, showContextMenu, handleWorldContextMenuEvent)
• QuestDefinitionManager → GameManager (questDefsCache, verify)

➡️ Context menus need an integration rewrite in core, not a new signature.

Still to locate (use the recipe) + enums

Renamed beyond keyword scan: ItemManager, ContextMenuItemManager (inventory items), UIManager, HTMLUIManager, NameplateManager, SpellManager/SpellMenuManager/MagicSkillManager, ExperienceManager, GameLoop, MeshManager, etc.
Enums: Skills lost accuracy → new includes: ['hitpoints','defence','strength']; re-derive the other 10 by source-scanning their member strings.

Only GameManager + EntityManager are needed for our plugins (WorldMap, CollectionLog, Mining) — they reach everything else via those two + the inventory DOM. The rest is for core features (context menus, bank, chat, spells); prioritise by feature.

Recipe (so the remaining list is fill-in-the-table)

Read-only CDP, in-world. document.client = Map<minifiedName, class> (~519 live classes); window.__eqSourceModules = captured source.

// member union (catches getters + inherited)
const members=cls=>{const s=new Set();let p=cls&&cls.prototype;while(p&&p!==Object.prototype){Object.getOwnPropertyNames(p).forEach(n=>n!=='constructor'&&s.add(n));p=Object.getPrototypeOf(p);}return s;};
// verify a candidate signature is unique at a threshold
const uniq=(sig,thr)=>{let full=0,fuzzy=0;for(const[,cls]of document.client){const m=members(cls);if(!m.size)continue;const hit=sig.filter(s=>m.has(s)).length;if(hit===sig.length)full++;if(hit>=thr)fuzzy++;}return{full,fuzzy};}; // want {full:1,fuzzy:1} at thr=ceil(0.6*sig.length)

Identify a class via a live instance (obj.constructor.name) or a keyword scan; pick 4–6 distinctive members; confirm {full:1,fuzzy:1}; record it.

---

api + KKonaOG will iterate here. I'll drop follow-up comments (additional resolved signatures, enum strings, the re-run-on-bundle-change trigger notes) as we verify them against the live bundle.

[atapifire]

Bundle-structure findings for the index.js / structural approach (pulled live)

1. EQ's bundle is Vite code-split, and chunks are semantically named. The loaded chunks (from resource timing):

m0-<hash>.js              ← main bundle (467 classes, ~2.3MB)
index-<hash>.js           ← entry/boot glue (the "index.js")
GameManager-<hash>.js     ← GameManager lives in its OWN named chunk
ItemIcon-<hash>.js
ThumbnailRenderer-<hash>.js
babylon-core / babylon-loaders

The [name] part comes from EQ's source/manualChunks config and is stable across builds — only [hash] rotates. So /GameManager-[A-Za-z0-9_]+\.js/ is a clean, name-based handle for the game-manager asset — arguably better than any method signature for the entry point. (Structural cross-check still available inside the chunk: the GameManager class is instantiated exactly once and the chunk is dominated by that one class.)

2. GameManager loads LATE (on world-entry), not at boot. At the login screen its chunk isn't loaded yet (waitForCurrentLocalPlayerReady absent from captured modules); after login the captured set grows (4 → 6 modules) and the GameManager chunk appears. Implication: the reflector must ingest chunks continuously and re-parse/re-bind when the set grows — a one-shot parse always misses GameManager. (This is what actually bricked the old client: our parse was gated on window.gm, a stand-in for "the late chunk arrived." That's removed in #27, but the durable fix is continuous capture + re-run.)

3. __vite__mapDeps manifest is in the entry chunk — it's the static list of chunk filenames the entry knows about, a good "what chunks should exist" anchor. Note GameManager's chunk is pulled via a dynamic import (it showed in resource timing but not in the static mapDeps array I parsed), so follow dynamic import() too, not just the static manifest.

4. Gap to close in the capture layer: EvilLite's current capture stores module source but not the URL it came from (window.__eqSourceUrls doesn't exist). Recommend tracking {url, source} per captured chunk — then you can correlate source → GameManager-*.js directly instead of signature-scanning to find the entry, which makes the structural approach trivial.

Net: the most robust design = (a) continuous capture tagged with chunk URL, (b) find GameManager by chunk-name GameManager-*.js, (c) re-run on chunk-set growth, (d) fuzzy signatures for the leaf managers in m0-*.js. Verified live on the current build.

[atapifire]

Discovery map — completed pass (verified live against the current bundle)

Minified class keys rotate between parses (confirmed: ChunkManager went wo→Co, BankUI Uy→sx across two parses) — so ship signatures, not keys. Every signature below resolves to exactly 1 class and stays unique at the 0.6 fuzzy threshold (survives a single member rename): shown as full/fuzzy = 1/1.

VERIFIED RENAMED — drop-in fuzzy signatures

Class	Signature (member set)
GameManager	updateMinimap, worldObjectDisplayName, waitForCurrentLocalPlayerReady, setupContextMenu (+ chunk-name anchor GameManager-*.js)
EntityManager	createRemotePlayer, createNpc, findNearestNpc, createGroundItem
SocketManager	openSockets, sendFrame, handleOpcodeMapping, consumePendingInputTicket
ChunkManager	getMapId, getMapWidth, ensureFloorLayer, getTerrainDetailStats
InputManager	handlePrimaryActionAt, pickGround, setObjectClickHandler, setGroundClickHandler
BankUIManager	openWithContents, updateBankSlot, sendWithdrawMode, makeWithdrawModeToggle
ChatManager	appendMessage, addPrivateMessage, installChatStyles, isScrolledToChatBottom
GameCameraManager	setLockedMode, applyLockState, setLockedRadiusScale, lockedPitchRadiusRatio
MeshManager (object models)	loadAll, loadModelTemplate, getStump, cloneActiveMaterial
SidePanel (stats/quests/tools)	setQuestDefs, setQuestState, setRenown, setToolsControls
DialoguePanel	closeSession, cancelDialogue, advance, optionIndexFromKey
SmithingPanel	renderBarPicker, maxQuantityForRecipe, renderRecipesForBar
TradePanel	showIncomingRequest, updateOffer, updateAcceptState
DuelPanel	updateStake, removeStakeSlot, openSession

(Also present as panels on GameManager, not yet signature-verified: shopPanel, quantityInputPanel, spellbookPanel.)

ENUMS

Enum	Status	Signature includes:
InventoryActions	✅ intact	['use','inspect','drop']
EntityTypes	✅ intact	['Environment','Item']
GameInterfaces	✅ intact	['Inventory','Bank','Shop']
Skills	⚠ update	['hitpoints','defence','strength'] (was accuracy, gone)
SpellTypes	⚠ partial	combat/status present, teleport gone — re-derive 3rd
GameObjects	⚠ partial	oaktree present, caveentrance/caveexit gone
GameWorldActions	⚠ partial	attack present, talk_to gone
PlayerActions	❌ redo	IdleState/MovingState both gone
AppearanceTypes	❌ redo	HairID/BeardID/ShirtID gone
UISettings	❌ redo	UITheme/IsGameWindowFullScreen gone
RequirementTypes	❌ redo	availableinventoryspace/equippeditem gone

RESTRUCTURED / MERGED — retarget consumers, not a signature

• ItemDefinitionManager → EntityManager.itemDefsCache (also on GameManager)
• NpcDefinitionManager → EntityManager.npcDefsCache
• QuestDefinitionManager → GameManager.questDefsCache; object defs → GameManager.objectDefsCache
• GroundItemManager → EntityManager (groundItems, groundItemSprites, …)
• world ContextMenuManager → GameManager (setupContextMenu, openWorldContextMenuAt, …)

Still to locate (likely merged into GameManager's 607-member god-class or the 153-member SidePanel; or genuinely removed)

ItemManager (selected-item state), ContextMenuItemManager (inventory context items), UIManager/HTMLUIManager, NameplateManager, SpellManager/SpellMenuManager/MagicSkillManager, ExperienceManager, GameLoop, RangeManager, LoginScreen, PrivateChatMessageList, InventoryItemSpriteManager, SpriteSheetManager, ScreenMask, BlobLoader, AppearanceUtils. Use the recipe; for the gone ones, check whether the feature moved onto GameManager/SidePanel before re-deriving.

That's the bulk of what the client touches. api + KKonaOG: we're also building our own capture/trigger (onHeaders + {url,source} + continuous re-run + chunk-name anchor) to compare against KKonaOG's — will drop it here when ready.

[atapifire]

Our capture/trigger approach (for logic comparison with KKonaOG's rewrite)

We already do the onHeaders/protocol capture in main/windows/client/index.ts: intercept every .js, regex class X, inject document.client.set('X', X) (runtime class refs), push body into __eqSourceModules. Just added: index-aligned chunk URLs in __eqSourceUrls (atapifire/EvilLite@906be26) so the entry point can be found by chunk name instead of fingerprinting.

The consumer logic (full reference impl is in our repo .agents/proposals/reflector-approach.ts) — three pieces:

1. Structural anchor for GameManager (name-based, not signature):

function findGameManager() {
  // GameManager ships as assets/GameManager-<hash>.js — [name] stable, hash rotates
  const classes = classesInChunk(/\/GameManager-\w+\.js(\?|$)/);   // uses __eqSourceUrls
  return classes.sort((a,b)=>protoMembers(b).size-protoMembers(a).size)[0] ?? null; // dominant class
}

2. Fuzzy N-of-M matcher for the rest (loud on ambiguity):

function matchClass(name, sig) {
  const need = Math.ceil((sig.threshold ?? 0.6) * sig.members.length);
  const scored = [...document.client].map(([key,cls]) => {
    const m = protoMembers(cls);
    return { cls, key, score: sig.members.reduce((n,x)=>n+(m.has(x)?1:0),0) };
  }).filter(c => c.score >= need).sort((a,b)=>b.score-a.score);
  if (!scored.length)               { console.error('no match', name); return null; }
  if (scored[1] && scored[0].score===scored[1].score) { console.error('AMBIGUOUS', name); return null; } // refuse to bind on a tie
  return scored[0].cls;
}

3. Trigger — re-run on capture growth, gated on the ANCHOR not a global:

function tryBindHooks(signatures) {
  const count = window.__eqSourceModules?.length ?? 0;
  if (count === lastCount) return;            // nothing new
  lastCount = count;
  if (!gmBound) { const gm = findGameManager(); if (!gm) return; bind('GameManager', gm); gmBound = true; }
  for (const [name, sig] of Object.entries(signatures)) if (!bound(name)) { const c = matchClass(name, sig); if (c) bind(name, c); }
}

The only behavioral delta vs today's client.ts is point 3's gate: bind when GameManager-*.js is captured, instead of when window.gm exists (which EQ removed). Continuous re-run + instance-capture-on-first-call are already this shape.

Why this is robust: every-build minification → name-anchor + members don't care; method renames → fuzzy survives 1-in-3; late chunks → re-run on growth; entry point → chunk name, the most rename-proof signal. Residual risk is the capture layer (delivery/URL/format changes) — same dependency KKonaOG's rewrite has.

@KKonaOG — curious where your rewrite differs (esp. how you pick the GM asset from index.js vs our chunk-URL-name approach, and how you handle the late/dynamic GameManager chunk). Happy to converge on whichever's cleaner.

[atapifire]

Elusive managers — resolved: EQ consolidated them (architecture finding)

Chased every remaining one. The headline: most "managers" are no longer separate classes — EQ merged them into the 607-member GameManager god-class (and a few into EntityManager / the panels). Verified by inspecting GameManager's members directly:

Merged INTO GameManager (call its methods / hook GameManager — no separate signature):

Old class	Now (GameManager methods)
SpellManager	handleSpellCastBroadcast, handleAutocastChange, finishPendingSingleSpellCast, isSpellMovementLocked, predictSpellCastMovementToNpc
MagicSkillManager / SpellMenuManager	(same spell-cast surface on GameManager)
GameLoop	resetFramePaceScheduler, shouldRenderSceneFrame, updateFramePaceEstimate, queueFrameSpikeTelemetry, profileFrameSlice
RangeManager	getRangedProjectileReleaseMs, getProjectileLaunchPreview, getRangedProjectileImpactMs
NameplateManager	refreshNameplates, applyNpcNameplate, applyRemotePlayerNameplate, combatLevelDifferenceColor, updateFriendNameplateCache
world ContextMenuManager	setupContextMenu, openWorldContextMenuAt, showContextMenu (reported earlier)
login bootstrap	noteLoginBootstrapPacket, waitForLoginBootstrapPackets, tryResolveLoginReady

Merged INTO EntityManager: ItemDefinitionManager / NpcDefinitionManager / GroundItemManager (caches + ground-item methods).

Genuinely not found in-world (re-derive at point of need):

• LoginScreen — its UI only exists at the login screen (not loaded in-world); audit there if a plugin needs it.
• ItemManager (selected-item state), ContextMenuItemManager (inventory-item context), SpriteSheetManager, AppearanceUtils, ExperienceManager (player XP table) — not on GameManager and not reachable via instances; likely folded into the inventory/side panels or removed. None are blockers (our plugins don't use them; core can re-derive if/when a feature needs one).

Net conclusion for the rework

The reflector realistically needs GameManager + EntityManager + the ~12 verified leaf classes (Socket/Chunk/Input/Bank/Chat/Camera/Mesh + the panels) and the enum updates — not the original ~37 separate hooks. EQ's refactor collapsed the manager layer into GameManager, which is exactly why "everything runs through gm" — but we still hook each surviving class by signature (not gm-navigation) so we keep stable, independent handles. The discovery map across these three comments is now functionally complete; the only open items are the handful above, all re-derivable on demand with the recipe.

[atapifire]

Our full reflector implementation — built + verified live (for comparison)

Pushed to atapifire/EvilLite dev @20a8b8c. 4 clean files in core/src/reflector/ + capture-layer URL tracking. Runs cooperatively next to the legacy parse, so it's a safe side-by-side. Verified in-world: binds 14/14 classes (legacy bound 2), all plugins running.

The design (3 layers, no game-global dependency):

• Capture (main/windows/client/index.ts): intercept .js → document.client.set('X', X) + index-aligned __eqSourceModules/__eqSourceUrls.
• resolver.ts — match over document.client:
  • structural anchor: classesInChunk(/GameManager-\w+\.js/) → pin the entry point by chunk name (stable; only the hash rotates). No method-name dependency for the most important class.
  • fuzzy N-of-M: score member overlap, accept ≥60%, assert unique (fail loud on a tie). Survives a rename or two.
• reflectorRuntime.ts — re-run on captured-chunk growth (GameManager loads late, on world-entry), bind into gameHooks, capture each live Instance by wrapping one signature method.
• gameAccess.ts — plugin facade: game.socket, game.minimap, game.itemDefs, … one file that absorbs EQ's class reshuffling (e.g. minimap lives on GameManager now, item defs on EntityManager) so plugins never touch the reflector and never break on a reshuffle.

Live results:

modules: 6   urls: 6   gmChunkCaptured: true
bound (14): GameManager EntityManager SocketManager ChunkManager InputManager
            BankUIManager ChatManager GameCameraManager MeshManager
            DialoguePanel SmithingPanel TradePanel DuelPanel SidePanel
GameManager resolved via: chunk anchor   |   all game.* facade routes → live instances
plugins: Collection Log, Diagnostic, World Map — all started

@KKonaOG — this is the "our logic" you wanted to diff against your index.js-parse version. The two big design calls to compare: (1) entry point by chunk-name anchor vs parsing index.js's import graph, and (2) fuzzy N-of-M member matching vs whatever discrimination you're using for the leaves. Both of ours are verified unique on the current build. Happy to converge on whichever's cleaner — or merge the best of both.

[atapifire]

Plugin facade demo + how to test it

Wired WorldMap + CollectionLog through the game.* facade (core/reflector/gameAccess.ts) — the plugin-routes layer, end-to-end. Verified live: both plugins functional via the facade.

// before: document.highlite.gameHooks.GameManager?.Instance  (breaks on rename)
// after:
get gm()   { return game.manager; }            // WorldMap + CollectionLog
getChunkManager() { return game.chunks; }       // WorldMap
get em()   { return game.entities; }            // CollectionLog
itemDef(id){ return game.itemDefs?.get(id); }   // CollectionLog — semantic route; hides that
                                                //   EQ moved item defs onto EntityManager

Live check: WorldMap.gm ✓, WorldMap.getChunkManager() ✓, CollectionLog.em ✓, CollectionLog.itemName(11) → "Raw Chicken" ✓. The point: when EQ reshuffles again, only gameAccess.ts changes — these plugins (and any future plugin) stay untouched.

Where everything is — to test on your end

Repo / branch (everything's here): atapifire/EvilLite → branch dev (commits 20a8b8c reflector, 84ec9da facade demo, 906be26 capture URLs). It has: the EQ-bundle fix, the full runtime reflector, the facade, and both plugins wired to it.

To run it:

git clone -b dev https://github.com/atapifire/EvilLite
cd EvilLite/packages/core && yarn build
cd ../client && export PATH="$HOME/.local/bin:$PATH" && EQ_DEBUG=1 yarn dev

Log in, then inspect over CDP (:9222): Object.keys(document.highlite.gameHooks) → 14 classes; GameManager resolves via the GameManager-*.js chunk anchor.

Files to read (packages/core/src/reflector/): resolver.ts, signatures.runtime.ts, reflectorRuntime.ts, gameAccess.ts; capture in packages/client/src/main/windows/client/index.ts; wiring in packages/client/src/renderer/client/client.ts (search reflectorTick).

Open PRs to merge into CamelC0re/Client dev: #27 (EQ-bundle un-bricker — urgent), #21 (WorldMap terrain). The reflector rework on this issue is the durable replacement; #27 holds the line until it lands.

@KKonaOG — pull atapifire/EvilLite dev to diff against your rewrite; api + I will test on our end too. Let's converge the entry-point discovery (your index.js graph vs our chunk-name anchor) and the leaf matching (fuzzy N-of-M) into one.

[atapifire]

Import-graph-walk fallback — implemented + verified (the union of both approaches)

Added the import-graph walk as a fallback tier in our resolver.ts (atapifire/EvilLite dev @592f623). Entry-point discovery is now a 3-tier cascade:

1. chunk-name anchor — match GameManager-<hash>.js. Fast, but relies on Vite naming chunks after the source file.
2. import-graph walk (new) — if (1) misses, find the entry/boot chunk (it carries __vite__mapDeps), parse its dynamic import("./X.js") edges, narrow to the classes declared in those boot-imported chunks, and fuzzy-pick. This is KKonaOG's idea: find GM by what the entry boots, not by filename — so it survives EQ shipping hash-only chunk names.
3. all-classes fuzzy — last resort over the whole registry.

export function classesViaImportGraph(client) {
  // entry chunk = the one defining __vite__mapDeps (fallback: index-*.js by URL)
  let entryIdx = mods.findIndex(m => /__vite__mapDeps\s*=/.test(m));
  // chunk filenames it dynamically imports: import("./Foo-hash.js")
  const wanted = new Set([...mods[entryIdx].matchAll(/import\(\s*["']\.?\/?([^"']+\.js)["']\s*\)/g)].map(m => fileOf(m[1])));
  // -> live classes declared in exactly those boot-imported chunks
}

Verified live in-world (with tier 1 deliberately disregarded to exercise tier 2):

entry boot-imports: ThumbnailRenderer, deviceId, GameManager-*, babylon-core, m1
candidate classes:  494
GM via import-graph: key "Y", 4/4  →  IS the same object the reflector bound (matchesBound: true)
tier-1 still binds:  14/14 (no regression)

So our resolver now covers both discovery styles: the chunk-name anchor as the fast path, the import-graph walk as the robust fallback, both feeding the same fuzzy resolver for the leaves. @KKonaOG — this should fully line up with your index.js-parse approach now; the only nuance is we read the entry's dynamic import() edges rather than the static import graph, because GameManager is a dynamic chunk (loads on world-entry). Pull dev and diff — curious if your walk handles the dynamic-import case the same way.

[atapifire]

🧭 START HERE — index of this thread

TL;DR: EQ's bundle refactor broke the signature reflector two ways — window.gm removed (trigger) + ~35 signatures stale (matching). We built a resilient replacement and a full working implementation is live on atapifire/EvilLite @ branch dev (binds 14/14 classes, plugins routed through a clean facade, verified in-world). This is for api + KKonaOG to diff against KKonaOG's rewrite and converge.

The thread, in order

1. Bundle structure — Vite code-split; GameManager ships as GameManager-<hash>.js, loads late on world-entry.
2. Discovery map (verified) — the 14 surviving class signatures + enum status.
3. Our capture/trigger logic — onHeaders capture + __eqSourceUrls + the matcher.
4. Elusive managers → consolidation — EQ merged most managers INTO GameManager; the rest into EntityManager.
5. Full implementation, built + verified — resolver / signatures / orchestrator / facade.
6. Plugin facade demo + how to test — game.* routes; clone-and-run instructions + repo/branch/PR refs.
7. Import-graph-walk fallback — the 3-tier entry-point cascade (chunk-name → import-graph → fuzzy).

Current design (one paragraph)

Capture (main/.../index.ts) intercepts every .js, registers document.client.set(name, Class) + index-aligned __eqSourceModules/__eqSourceUrls. Resolve (core/src/reflector/resolver.ts) finds the entry point via a 3-tier cascade — chunk-name anchor → import-graph walk → all-classes fuzzy — and the leaf classes via fuzzy N-of-M (unique-or-fail). Orchestrate (reflectorRuntime.ts) re-runs on captured-chunk growth (no game-global gate), binds gameHooks, captures each Instance by wrapping one method. Plugins use the gameAccess.ts facade (game.socket/game.minimap/game.itemDefs) so EQ reshuffles only ever touch that one file.

Status

• ✅ Resilient reflector + facade live on atapifire/EvilLite dev (commits 906be26, 20a8b8c, 84ec9da, 592f623).
• ⏳ PR Fix: restore client against EvilQuest's bundle update (window.gm removed) #27 (EQ un-bricker) — should merge into dev now; holds the line until this rework lands.
• ⏳ KKonaOG's index.js-parse rewrite — to diff/converge here. Main thing to reconcile: dynamic-import handling for the (late-loading) GameManager chunk.