Superseded 2026-09-05. The "classic way" this note reaches for exists and is measured:
HaloSimulation_tag_release.dllkeeps atag instancetable (pointer at RVA0x0182D1E8on CU4) whose 0x30-byte entries name every loaded tag, its group, its handle and its root block descriptor, resolved through a 16-slot segment table at RVA0x02C2CCC0. Both questions below are answered by one pointer-chase; seetag_table_and_string_ids.mdandcrates/blam-live/examples/tagtable_probe.rs. The scattered per-tag records of Finding 3 are those table entries. The census remains as the fallback for an unknown build.
Live mode has to answer two questions about the running game:
- Which tags are loaded, and what level is this?
- Where is a given tag's data buffer, so a field can be poked?
Today both are answered by the census — one ~13 GB scan of the process's
writable memory that fingerprints every loaded tag by its own bytes
(blam_live::census, apps/tag-editor/src-tauri/src/census.rs). It works and
is cached, but a scan is a blunt instrument. This note records what we learned
about doing it the classic way instead: a known engine global plus fixed
offsets, resolved once per build and chased by pointer thereafter — no scan.
Measured 2026-09-01 against the shipped build (…Meteorite-2607-CU3) in mission
a30, 369 tags verified loaded.
Update 2026-10-21: the build lock had read …Meteorite-2607-CU4 since
2026-08-18 (commit 0b02b919), so the CU3 label above is probably carried
forward; see build_lock.md.
Finding 1 — the loaded list needs no scan at all
Loaded Blam tags are UE UObjects named Blam<Group>TagDataAsset
(BlamBipedTagDataAsset, BlamWeaponTagDataAsset, …). The engine keeps every
live UObject in GUObjectArray, which this repo already resolves with a
stable UE4SS signature (signatures/GUObjectArray.lua; the AOB wildcards the
RIP-relative displacement and decodes it at runtime, so it survives updates —
see signatures/README.md).
Enumerating them is instant. Via the game bridge (UE4SS Lua):
FindAllOf("BlamBipedTagDataAsset") -- 25 biped assets, addresses in hand
116 asset UObjects across four classes came back with no measurable delay.
Implication: the tag editor (a separate process) can read GUObjectArray
over ReadProcessMemory — resolve the global once per build from the on-disk
exe (the tools/pe/aob_scan.py machinery already does AOB scans), walk the
FUObjectItem array, deref each UObject, read its class and object FName,
and filter to *TagDataAsset. That is a bounded read of a few MB, not a 13 GB
sweep, and it answers "what is loaded / which level" in well under a second —
and more reliably than fingerprinting the scenario tag. This is the recommended
next step and does not depend on Finding 2.
Update 2026-10-21: done the same day: crates/blam-live/src/objects.rs and
names.rs, wired into the tag editor's live mode in 0.16.0 (PRs #88, #89); see
guobjectarray_reader.md.
Finding 2 — the pokeable buffer is not reachable from the UObject
The obvious hope — UObject + fixed offset → data buffer — does not hold.
For all 32 name-matched biped/weapon/vehicle/scenario UObjects, the census's
verified buffer address (base, and base + r0 the resident-allocation start)
appears nowhere in the UObject's first 8 KB, and nowhere one pointer
hop away through any heap-pointer slot in that window. Zero of 32, both targets.
This confirms the long-standing comment in crates/blam-live/src/lib.rs: the
tag asset UObject holds its payload as unloaded bulk data. The buffer the
simulation actually reads lives in a separate Blam-side runtime structure,
not the UE wrapper. GUObjectArray gets you the list, but not the buffer.
Finding 3 — the buffers live in scattered per-tag records that store base
A pointer scan (sweep for aligned 64-bit values equal to a verified buffer
address) found 259 holders covering 240 of 369 tags. Every holder stored
base — the synthetic "payload byte 0" address (data_start − r0), never
base + r0. So the engine keeps each buffer positioned such that a field is
read at base + file_offset, exactly the addressing blam_live already uses.
That is strong independent confirmation the located address is the real thing.
The holders do not form one dense array (no fixed-stride table emerged).
They sit ~0x420–0x1040 bytes apart in heap regions — i.e. one runtime structure
of ~1–4 KB per loaded tag, each holding the buffer pointer plus metadata. The
8 bytes after the pointer are not the data-section length (r1 − r0); the
record layout past the pointer is not yet decoded.
What's left to make poke scan-free
The remaining unknown is the path from something static to those per-tag records. Two candidate routes, in order of promise:
- A Blam tag-cache root. The 259 records are presumably owned by a Blam
tag manager. Find its root (signature on the code that allocates or indexes
these records, or a
.dataglobal pointing at the record pool), then index by tag id / path. Chase:global → record[tag] → buffer. - A deeper UObject link. The
UObject → bufferpath may exist but be more than one hop, through the UE property graph rather than raw offsets — best walked with UE4SS reflection, then frozen into offsets once the shape is known.
Until then the census sweep stays as the fallback that needs no engine
knowledge, and Finding 1 removes the sweep from the common case (knowing what
is loaded). The scan probes that produced these numbers are not committed —
they were throwaway #[ignore]d tests reading a JSON dump of verified hits;
this note has enough to reconstruct them.
2026-09-01 — the tag-cache hunt (tag editor 0.16.0 branch)
Probes: tests/tag_cache.rs, tests/tag_cache_root.rs, tests/tag_cache_nodes.rs
(shared helpers in tests/common/). Same session as the census dump they read.
Settled: the buffer descriptor, decoded
Each resident tag's buffer is owned by a 32-byte descriptor:
+0x00 ptr the buffer — payload byte 0 (`base`), so field = ptr + file_offset
+0x08 u32 size — NOT the data length (r1-r0) and NOT r1; smaller than r1,
so not a byte length from `base` either. Undecoded.
+0x0C u32 always 1
+0x10 u64 always 0
+0x18 u8,u8 always 00 01, then 6 bytes of uninitialised padding
The +0xC == 1 / +0x10 == 0 / +0x18 == 00 01 constants held on every one of
167 descriptors and make the record shape-checkable. What Finding 3 above
called "scattered per-tag records" is this: the descriptors are individually
allocated from the engine's 32-byte small-block pools, so they sit at 32-byte
stride among unrelated 32-byte objects (one pool slot held UTF-16 text).
There is no tag array at this level — which is exactly why the 259 holders
never clustered.
Settled: one node per tag, above the descriptor
Scanning for pointers to the descriptors finds 173 holders for 167
descriptors — one node per tag, packed into five regions ~10 MB apart, with
slot addresses split almost exactly 50/50 between mod 32 = 0 and 16. That
alternation is the fingerprint of a fixed 48-byte element stride
(16·odd): the nodes are elements of one container. No node references the
tag's UObject (0 of 172 checked; 0 of 400 windows held any tag object),
consistent with the object graph being a shell.
Why a naive upward walk fails
Scanning for "who points at a node" returns holders inside the same five
regions — 1,595 at the next level, 15,916 after that, 57,421 after that. The
nodes point at each other (list/hash sibling links), so a scan that follows
every pointer chases siblings forever and never leaves the pool; no static
holder was reached in five levels. The fix, in tag_cache_nodes.rs, is to
exclude holders that live in the nodes' own pages — only external
references can be the owner — and to determine the node's true start by
scanning for slot − k over every plausible k and keeping the k whose
external holders form one clean container.
Settled: there is no owner chain to walk up (Phases D and E)
Decoding the slots that hold descriptor pointers (tag_cache_nodes.rs)
found no identity field of any kind — not the tag's FName id, not its
package's, not its class pointer, not a catalog index — and after excluding
same-pool siblings, one or two external holders in total, zero at the next
level. The dumps show what the slots really are: small inline pointer
buffers (5–10 entries, zero-padded) embedded in assorted objects, often
beside UTF-16 path strings, holding pointers to consecutively allocated
32-byte pool blocks. Four different objects reference one tag's descriptor.
These are per-consumer references, not a registry.
Mapping them as arrays (tag_cache_owner.rs) confirmed it the other way: the
walks ran through 25k–99k-element pointer-dense regions with descriptors at
0.3–1.5 % density, because the descriptor's {ptr, u32, 1, 0} shape is far
too common in UE (it matches refcount control blocks), and nothing points at
any mapped start. Upward walking from the buffer has no next step short of
disassembly.
The remaining top-down route: the Blam runtime shares /Script/ BlamSynchronization with the tag classes, so its manager is likely a
UObject — findable by class name through the object table, a root that
needs no static address. tag_cache_by_name.rs searches downward from every
live Blam* instance for anything reaching a descriptor, slot or buffer.
Phase F: the Blam runtime is exposed as UObjects — 107 classes
tag_cache_by_name.rs listed 107 Blam* classes with live instances. The
breadth-first search from them was useless as designed — with fanout
768·96·24 it visited 100k–380k objects per root, so every root reached
descriptors through meaningless three-hop paths and the ranking was noise
(save-game objects "reached" 80 descriptors). But the listing itself is the
find: among the singletons are BlamCookedTagReferencesEngineSubsystem
(named for exactly this), BlamEngineSynchronizationManager,
BlamEngineAssetManager, BlamEngineLoadingManagerEngineSubsystem,
BlamSynchronizationEngineGlueSubsystem and BlamScenario. A UObject
root is reachable by class name through the object table in a second — no
static address, no signature, relaunch-proof. tag_cache_subsystem.rs
follows each singleton's pointer fields one hop into a large window and
counts descriptors there; a registry shows as one field reaching most of
them.
Phase G: BlamCookedTagReferencesEngineSubsystem holds a 10,201-element array
Following each singleton's pointer fields one hop (tag_cache_subsystem.rs)
found no field reaching the descriptors — but the subsystem's own layout,
right after the 0x28-byte UObject header, is the find:
+0x030 TArray data 0x1a59ec30000, Num 10201, Max 10240
+0x040 TArray Num 13, Max 14
+0x050 0x1fff a hash mask — 8192 buckets
A 10,201-entry array in the subsystem named for cooked tag references
(catalog: 12,292 tags; present: 9,147). The one-hop probe read only the first
128 KB of it and the descriptor is plausibly a further hop from each element,
which is why it scored nothing. The root is reachable by class name
through the object table — no static address. tag_cache_registry.rs
decodes the array by correlating it with every per-tag identity.
Phase H: the 10,201-element array is TArray<FString> — the name index
Correlating the array against every per-tag identity found nothing, and the
raw dump says why: each 16-byte element is {TCHAR* Data; int32 Num; int32 Max} with Max rounded to 8 — an FString. The subsystem's array is the
cooked tag-reference path index, 10,201 strings, and the 160 KB read was
the whole of it. Its element position is the natural tag index for the
runtime to key on, so the buffer table should be a parallel array of the
same length. tag_cache_parallel.rs decodes the strings into an
index→catalog map and scans for every TArray header with a characteristic
Num (10,201 / 9,147 / 12,292 / 362) to find and inspect the parallel tables.
Settled: the runtime's tag name table, and a tag index for every tag
tag_cache_parallel.rs decoded the 10,201 FStrings: every one is a
/Game/Tags/... package path and 10,201 of 10,201 map to a catalog tag
through Catalog::tag_by_package. So `BlamCookedTagReferencesEngineSubsystem
- 0x30
is the runtime's tag name table, and its element position is a runtime **tag index** — 312 of the 362 census-resident tags sit in it. The root is found by class name through the object table; nothing static is needed. The index→catalog map is saved by the probe (MJOLNIR_NAMEINDEX_OUT`).
The first parallel-table scan drowned: Num values as small as 362 match
{Num, Max} lookalikes everywhere (12,411 headers), and the Num = 10201 /
12292 hits had non-pointer Data. tag_cache_position.rs uses the tag
index instead of scanning: a parallel table of stride E puts tag pos's
slot at B + pos·E + k, so the known slots' pairwise Δslot/Δpos must agree.
Settled: nothing is laid out by tag index; the subsystem is the reference graph
tag_cache_position.rs: with every descriptor, slot and buffer base given
its runtime tag index, the pairwise Δaddress/Δposition ratios agree on no
stride — best candidates hold for 1–6 of hundreds of pairs. There is no
parallel table of buffers, descriptors or slots indexed by tag position.
The subsystem's +0x40 array decoded to 13 elements of {u32 id; TArray; int32 -1; int32 idx} — thirteen loaded containers, each owning an array
of 4,300–6,900 entries whose Max (8188 or 5460) is exactly what fits 8- or
12-byte elements in a 64 KB block: ~75k entries in all, far more than 10,201
tags. That is a tag→tag reference graph, per container. So
BlamCookedTagReferencesEngineSubsystem is precisely its name — the tag
name table and the cooked reference graph — and not the data cache. Its
reference arrays reach no descriptor or buffer within one hop.
A second Num = 10201 array (0x1a5c47822c0) holds per-tag u64s in the
~2 MB range — sizes or offsets by tag index, not pointers.
The remaining hypothesis, consistent with every negative so far: there is
no central cache. Each descriptor is a shared block held by whatever
consumes the tag, living as long as something holds it.
tag_cache_holders.rs tests this by resolving each slot to the UObject
that contains it.
Settled: the holders are native, not UObjects
tag_cache_holders.rs resolved each of the 173 descriptor slots to the
nearest preceding UObject: 166 are not within 128 KB of any object, and
the seven that "resolved" are plainly false positives (a slot 0x11f20 bytes
past a Niagara module; a class default object at +0xff0). The descriptor
holders are native C++ structures. The Num = 10201 per-tag u64 array is
not chunk sizes either (0 of 10,201 match).
That reframes every earlier negative. The cache is native, so its root is a
static global in the image's own writable sections — which the upward walks
never reached (node links drowned them) and the UObject-rooted search could
not reach (it is not a UObject). tag_cache_static.rs starts from the true
top: every heap pointer in the exe's .data/.bss, followed one hop, kept
if the struct there points into one of the five known node regions, then
scored two hops down. Any survivor is exe + offset by construction.
FOUND: static roots into the node containers
tag_cache_static.rs — every heap pointer in the image's .data (259,923 of
them, 8 MB), one bounded hop each, kept where the struct points into a known
node region, scored two hops down. Two .data globals lead straight there:
| static | → struct | field | → node container | slots+descs in 64 KB |
|---|---|---|---|---|
exe+0xd3ec3a0 | T @ 0x1a5b2e4cb30 | +0x808 | 0x1aaec93cde0 | 28 |
exe+0xd3ee678 | T2 @ 0x1a5b2fb9b60 | +0x808 | 0x1aaf5fb07a0 | 20 |
The same field offset in both: one struct type, two instances, each owning
one of the two densest node regions. The long tail of "candidates" was an
artifact — those statics point at consecutive 80-byte records and their
decreasing field offsets all resolve to the same absolute slot
(0x1a5b2fba368) through overlapping 4 KB windows. The word after +0x808
is not a sane Num, so it is not a TArray header; a hash-map node store
is the likely shape. Chain so far: static → T → +0x808 → node container →
node → descriptor → buffer. tag_cache_decode.rs decodes T and the nodes,
testing node identity against the runtime tag index and the name table's
FString pointers — keys no earlier probe had.
Decoded: the root struct and the hash-map node
tag_cache_decode.rs, from both static roots. The root struct T holds an
array of 80-byte map records from +0x40, each with a head-node pointer
at +0x48 and a count at +0x18 (node pointers in T sit at +0x128, +0x3f8, +0x498, +0x718, +0x7b8, +0x808, +0x858, +0x8a8 — all ≡ 0x48 mod 0x50). The Phase L "consecutive 80-byte records" artifact was these.
A node, relative to the slot holding its descriptor, identical in every dump:
-0x70 link → node -0x18 0x1a5b35a2b80 (same in every node)
-0x60 link → node or 0 -0x10 0x1a5b204fce8 (same in every node)
-0x50 u64 KEY HASH -0x08 per-node key object*
-0x48 0x02000000 +0x00 descriptor*
-0x38 u32 (varies) +0x08 1
-0x20 0x7fffffff
Two sibling links, a 64-bit hash, two shared back-pointers, a key pointer,
then the descriptor: a hash-map node. The identity tests still found no
plain tag key in the node — it is behind the hash and/or the key object.
tag_cache_walk.rs traverses every record's chain from the static root
(bounded, no scan), dumps (hash, path) pairs for offline identification
(UE's FPackageId is CityHash64 of the lowercase UTF-16 package name — the
first candidate), and reads the key objects.
IDENTIFIED: the node key is FPackageId — CityHash64 of the lowercase UTF-16 package name
tag_cache_walk.rs walked every record's chain from both static roots —
each reaches the same ~44,290-node component (one global asset cache keyed
by package id; loaded tags are a subset) — and dumped (hash, tag) pairs.
hashtest.py then tried CityHash64 and FNV-1a 64 over eleven path forms:
MATCH x35: ('city64', 'utf16', 'pkg_lower')
Thirty-five node hashes equal CityHash64(lowercase UTF-16LE "/game/tags/ <short>-<group>") bit for bit — UE's FPackageId. A coincidental 64-bit
match is impossible, so the key is computable from the catalog alone. The
scan-free chase is therefore complete on paper:
.data global → T → 80-byte map record (+0x40, stride 0x50) → head node (+0x48)
→ walk links (-0x70 / -0x60; a link targets a node start, slot = node + 0x60)
→ node with hash (-0x50) == FPackageId(tag) → descriptor (+0x00)
→ descriptor.ptr = base → field at base + file_offset
tag_cache_lookup.rs is the acceptance test: walk once, index by hash, and
for every census-resident tag compute its id, look it up, and check the
descriptor's pointer equals the base the census found by sweeping 13 GB.
First acceptance run: the key resolves 8,591 tags; a package has several nodes
tag_cache_lookup.rs, first version: the walk from the two static roots
takes 0.1 s (44,312 nodes, 37,139 keys), and 8,591 of 12,292 catalog
tags resolve to a node by FPackageId — the key confirmed at scale. But
keeping one node per key resolved only 1 of 362 resident tags to its census
base; the "descriptors" it read were not descriptors (0x400000000, static
addresses). A package therefore has several nodes — its chunks — under one
package id, and only the bulk-data node holds the buffer descriptor. The
23 walk pairs that did not hash to their tag were the same effect from the
other side: nodes of other packages pointing at a shared descriptor. The
refined test keeps every node per key, validates each candidate by
descriptor shape and pointer, and reports which node field marks the holder.
PROVEN: 35 resident tags resolved to their exact buffer with no scan
tag_cache_lookup.rs, refined to keep every node per package id: walk
0.13 s; 8,591 catalog tags have a node; 35 of 362 census-resident tags
resolved by FPackageId to a descriptor whose pointer equals the census
base — zero wrong. The selector is unambiguous:
| field (rel. to slot) | descriptor-holding node | sibling nodes (452) |
|---|---|---|
+0x08 flag | 1 (35/35) | 0 (452/452) |
-0x48 | 0x2000000 | 0x1000000 (314) / 0x2000000 (138) |
-0x20 | 0x7fffffff | 0 (314) / 0x7fffffff (138) |
-0x08 key | non-null | null (314) / non-null (138) |
So a package's nodes are its chunks; the one with +0x08 == 1 holds the
live buffer descriptor. What is incomplete is coverage: the two roots reach
one ~44k-node component (244 holder nodes), and the other resident tags'
buffers live under other T instances. T carries a strong signature
(0x0000000400000000 at +0x48, +0x98, +0xe8), so tag_cache_roots.rs
enumerates every instance from .data and unions their coverage.
All roots enumerated: the map is a loader-side cache, ~10 % of resident buffers
tag_cache_roots.rs: the root signature that works is the shared pointer
every record carries at +0x30 (the mode over a known root's first 24
records; record 0 is not always a plain record). 22 .data pointers pass
it — four distinct T instances plus the 80-byte artifact — and the largest
(exe+0xd3eb080) reaches a 1.28M-node component: the global asset
cache. Union over all roots: 3,450 holder nodes, 220 catalog tags with a
live descriptor, 37 of 362 resident tags resolved exactly, 0 wrong.
So the static-rooted map is real and its lookup is exact, but it holds a
buffer only while the loader references it; in a settled mission most
buffers have been handed to the Blam simulation and dropped from the map.
The remaining ~90 % of resident buffers are referenced from consumer
structures. tag_cache_table.rs asks whether those holders — the slots
storing a base that are not descriptors (~95 of the 262 found by the
level-0 scan) — sit at a fixed stride by tag index: a Blam tag-instance
table, the classic table[index] → data.
Settled: there is no tag-instance table — the loader's map is the only index
tag_cache_table.rs: of 259 slots holding a resident buffer base, 92 are
not descriptors. None is in static data; they fit no stride by runtime
tag index (37 points, best agreement 1 pair) and none by catalog index (92
points, best 3 of 91 pairs — noise). Their contexts are assorted consumer
structures — one holds its tag's buffer as a plain TArray<u8> field
({Data = base, Num, Max}), others sit among per-object pointer tables.
So the engine keeps no central, index-addressable table of live tag
data. Buffers are owned by whatever consumes them; the loader's
FPackageId-keyed map is the only index, exact for what it references and
partial once loading settles. That is the end of what memory archaeology
can deliver, and it is enough: the map makes every buffer it references
instantly and exactly pokeable — likely most of them during and just after
a level load — and the byte-fingerprint sweep remains for the rest.
Wired: blam_live::cache behind the census
crates/blam-live/src/cache.rs carries the production primitives (root
discovery by a self-referential signature, revalidation of cached root
RVAs, the bounded node walk, and the FPackageId lookup;
package_id.rs is the hash). The tag editor's census runs a cache phase
after the object table: every catalog tag is looked up by id and each hit
is verified against the tag's own bytes like a sweep hit, then adopted as
an instant poke base. Root RVAs are cached per build in live state.
Addendum (2026-09-01): in-play bipeds defeat the fingerprint, not the poke
An end-to-end run in a30 (arm live → census → edit jump velocity in the
spartans biped) failed at the locate step: the census had 362 tags but not
the biped, and the single-tag fallback reported "12 candidates, best had 1
agreeing run". Diagnosis, measured:
- The biped's data section yields only 12 census runs (the anchor rule
needs a zero-free 8-byte key; unit/biped data is float-dense). Relaxing the
rule to allow zero bytes gave 21 runs — and only 6 of 41 matched anywhere.
The resident biped is rewritten so thoroughly that no 48-byte stretch
survives except two adjacent runs at
0x8afe/0x8b14that every biped shares. So all biped prints vote for all biped buffers, tie, and are dropped as ambiguous. That is why a mission census finds one biped (floodcarrier) out of a dozen resident. - Byte agreement cannot break the tie safely: against the eleven buffers the shared run found, the right tag leads by 0.725 vs 0.668 for spartans but marine vs keyes_marine tie at 0.762 vs 0.761 (first 2 KB).
- The buffer that best matched the spartans file is the player's biped:
writing 25.0 into its
jump velocityslot (base + 0x8896, stock 2.3) took the measured jump from 205 cm to 12,065 cm; restoring put it back. Layout is intact at file spacing; only the bytes are rewritten. - The pawn does not reach the buffer in two pointer hops from its UObject
(0x3000 / 0x1000 / 0x400 windows), and
BlamPawnexposes no reflected unit pointer — the Blam unit is behind a handle, as the census research already found for tag records.
Consequences: the poke path is proven end to end; the gap is claiming in-play unit-like tags. Options, in order of promise: (1) per-buffer assignment by discriminating offsets — score each rival tag only on the bytes where the rivals' files differ — instead of dropping ties; (2) the Blam object table (every spawned object → its tag definition), the classic exact route, still unlocated; (3) a hook in the UE4SS bridge that reports tag definition pointers from inside the process.
Update 2026-10-21: option (2) is found. The object table is the object
data array in the simulation thread's TLS block, and each object's datum starts
with its definition's tag handle (crates/blam-live/src/world.rs, mjolnir live objects, cli 0.3.0, PR #104; see game_state_reader.md). On a build with a
tag-table profile the census no longer fingerprints tags at all (the note at the
top).
2026-09-02 — why a weapon poke did nothing, and the two facts that fix it
A live edit of the magnum's zoom levels[0].magnification reported success —
"found the tag at 0x1B627BA0020" — and changed nothing in the game. Neither
did anything else edited on that weapon. Measured in a30 with the magnum and
assault rifle in play (probes: tests/weapon_*.rs, tests/live_poke_e2e.rs,
tests/census_e2e.rs).
The address was a false positive
Every candidate the 32-run locator can produce for the magnum is one buffer,
and only its last 2.6 KB match the file: the section-table tail (frgt,
isgt, lbgt, the weapon_thigh strings) that every weapon tag shares. The
rest of that 64 KB region is a u32 index table. Three runs "agreed" because
all three sat in that one identical stretch — agreement between runs from one
contiguous stretch is not independent evidence. The plain fraction was 56%,
comfortably over the 10% verify bar, because a data section is mostly zeros
and zeros match zeros. The user's writes landed in that index table.
Fact 1: the working copy keeps only the scalars
Per-field-type survival on the tags the census does find, and a dump of the
magnum's real resident copy once found: every scalar field of the root
element is byte-identical at its file offset (81/81 non-zero bytes), and every
reference is rewritten in place — string ids, tag references, block
indices, and block headers. A weapon's root element has no 48 contiguous
bytes left for the plain locator; the scalars sit in clumps between rewritten
references. blam_tag::view::scalar_mask classifies the bytes, and
blam_live::pick_stable_runs builds masked 48-byte runs whose 8-byte key is
entirely scalar and whose body compares only the scalar bytes. That finds the
magnum's root at 0x1b426af56e1 and the assault rifle's at 0x1b42b6a8331
in one 12-second sweep, root-element scalar match 100% on both.
Byte-perfect copies of weapon tags also exist — a census found nineteen at
100% — and they are not what the simulation reads (writing into them changes
nothing). The working copy is told apart by its block headers, below:
blam_live::runtime_form. Both the single-tag poke (blam_live::find) and
the census (census::judge) apply that test, and the census now carries ties
(CensusHit::rivals) instead of dropping them, so a working copy beside a
loader image is resolved rather than lost. Effect on a30: weapons found went
from 32 (mostly images and false positives) to 22 working copies including
the magnum and assault rifle; bipeds from 1 to 24.
Fact 2: block elements are relocated, and the header says where
In the file a block field is twelve bytes — count, then eight zeros — and its elements are packed later in the data section. In the resident copy those eight bytes are filled in:
+0 u32 count
+4 u32 offset of element 0 from a process-wide arena, in 4-BYTE UNITS
+8 u32 struct id (e4930e44 for `weapon_zoom_levels_block` in both weapons)
The arena base is 0x1b3de0a0000 on this launch: both melee damage parameters and barrels give exactly that when their elements (found by
their own scalar bytes within 512 KB of the root) have 4 * word subtracted.
It is one gigabyte below the committed heap region holding the tags, is in
no writable region itself, and no slot in the game image holds it — so it is
derived once per launch from the first tag with a data-rich block
(blam_live::derive_arena) and cached. blam_live::field_address chases the
headers along blam_tag::patch::route's hops.
Proof: the assault rifle's zoom levels[0].magnification (1.4) read back at
arena + 4 * 0x13588e58 + 4 = 0x1b42b6c3964; writing 8.0 there put 8.00x
on the HUD and the camera FOV at 85/8 = 10.6°; writing 1.4 put it back. The
same through the editor's own live::Live::poke and through mjolnir poke.
Update 2026-10-21: the arena is one of the tag module's sixteen segment
bases (table at RVA 0x02C2CCC0 on CU4; the top four bits of the encoded offset
pick the slot). Since tag editor 0.18.0 (first tagged in 0.20.0, PR #95) the
editor takes it from that table whenever the tag table was read
(blam_live::tagtable::Segments), and derive_arena is the fallback.
Gotchas met on the way
- Root-level fields still poke at
base + file offset; only nested ones need the arena. A tag whose root has no data-rich block cannot derive the arena by itself; the editor keeps the arena from whichever tag derived it first. - Near-identical tags (marine / keyes_marine / crewman) have identical root scalars and claim the same buffer; the overlap rule keeps one. A poke on the twin lands on the shared buffer.
- The UE console's keys are Tilde and Tab; a Tab sent by the input tool
opened it and it ate every click afterwards. Replacing the viewport's
UConsolewith a freshly constructed one (what the ConsoleEnabler mod does at startup) closed it. Update 2026-10-21: since mods-v0.7.0 the ConsoleEnabler mod (1.1.0) also rewrites the Tab entry inConsoleKeysto Tilde, so with it installed only Tilde opens the console.
Update 2026-09-07. The two globals the table read depends on (and the
six registry globals) no longer need measuring after an update: four code
anchors in the tag module recover them (signatures/README.md, "The tag
module's anchors"), and the derived profile matches the measured CU4 one
exactly. The sweep is now the fallback for a build where an anchor fails to
match once.