SpiritBoot BIOS size and memory layout

This is the dedicated memory reference for SpiritBoot's audited merged main d4350b603452e029d0862fb48e7d4907e489e8ef, reconstructed Roswell tree 1277f2b7bf45a0992ef56d45d55815396d46ac8d. It covers the ROM container, live image, functions, tables, allocator backing, stacks, caches and boot lifetimes. The byte inventory and complete physical-owner census below are for its release64 image at the specified public guest checkpoint. The 128 MiB placement is source-verified; a matching complete 128 MiB runtime census is not claimed.

Reference comparison: Complex-BIOS-Size-and-Layout. Detailed side-by-side findings: Resident-Memory-Comparison. KiB means 1,024 bytes; pages are 4,096 bytes. Address intervals exclude their final address.

1. ROM file, prepared image and runtime RAM

Quantity	Size	Meaning
Audited release64 flash file	262,144 bytes / 256 KiB	Loader, packaged compressed image and ROM boot/reset content; not resident RAM usage.
Prepared image envelope before discard	512,000 bytes / 500 KiB	VA 0x84000000–0x8407d000, with section-alignment backing.
Resident image	417,792 bytes / 408 KiB / 102 pages	Header plus .text, .data, .rdata, .bss and PAGE.
Resident section content, excluding header/padding	403,256 bytes	Actual content ranges, not each section rounded separately.
Resident section tail padding	10,440 bytes	Sum of per-section page tails; recovering an interior gap does not necessarily release a page.
Discarded INIT/resource backing	94,208 bytes / 92 KiB / 23 pages	22 INIT pages and one resource page; already absent at this runtime checkpoint.
Total unavailable physical RAM after allocation guest	1,359,872 bytes / 1,328 KiB / 332 pages	Firmware plus hardware and title-owned allocations. Not firmware-only overhead.

The release64 artifact SHA256 is 101a3064574aff28242df614bdad1ecbea0b68d49ab18b71fb2ce365b89bd636. Its pinned build manifest and source reconstruction underpin the ledgers. Current work on unmerged branches is listed separately below, not folded into these numbers.

The ordinary ROM file stores a compressed prepared kernel image. Compressed bytes are not directly callable instructions. Writable state, active stacks and ordinary heap allocations require RAM; a future execute-in-place policy must place qualified immutable pages raw in ROM and preserve their virtual addresses.

2. Exact kernel section layout

Owner	Virtual content start–end	Content bytes	Runtime pages	Runtime KiB	Lifecycle
Header	0x84000000–0x84001000 backing	4,096 backing	1	4	Resident header backing.
.text	0x84001000–0x840514b4	328,884	81	324	Resident.
.data	0x84052000–0x84052810	2,064	1	4	Resident.
.rdata	0x84053000–0x84059508	25,864	7	28	Resident.
.bss	0x8405a000–0x84064ba8	43,944	11	44	Resident.
PAGE	0x84065000–0x840659c4	2,500	1	4	Resident.
INIT	0x84066000–0x8407be40	89,664	0	0	Already discarded: 22 original backing pages.
.rsrc	0x8407c000–0x8407cac8	2,760	0	0	Already discarded: 1 original backing pages.

The live physical image interval in this capture is 0x03400000–0x03466000. Content placed in INIT is already reclaimed; it cannot be counted again as a proposed saving. Former INIT pages can now back pool or title allocations.

Of the resident section content, 367,003 bytes have exact compiler-extent or declaration/body-size attribution and 36,253 bytes remain explicitly unattributed. The complete section partition counts each byte once. Metadata attribution itself has recovered no memory. Retaining a separate header page, ideal permission-agnostic packing of the section contents could eliminate at most eight KiB under the audited assumptions; that is not an implemented permission-safe layout change and cannot explain the 228 KiB image difference from Complex.

See Memory-Resident-Page-Atlas for every one of the 102 pages, captured PA, content owner, crossing functions/tables and unattributed remainder.

64 and 128 MiB boot placements

Structure / interval	64 MiB image	128 MiB image
Kernel virtual base	0x84000000	0x84000000
Prepared kernel physical base	0x03400000	0x04000000
Loader physical interval	0x03800000–0x03820000	0x07d00000–0x07f00000
Initial low page tables	0x03bc0000	0x07f00000
Initial kernel-alias tables	Low-table base + 0x4000	Same offset
Initial PCR page table	Low-table base + 0x15000	Same offset
Page directory	0x0000f000	Same
Initial PCR backing	0x00030000, 16-page boot span	Same
LoaderBlock / auxiliary bootstrap	0x00040000 / 0x00041000	Same

These are bootstrap placements, not permanent reservations of every listed range. Current main retires checked boot workspace after INIT discard and warm restoration. The source handles replacement mappings, persistence and physical ownership before reuse. See Boot-Memory-and-Lifecycle and Memory-ROM-and-Cold-Code. The optional 128 MiB/upper-reservation compatibility profile has a distinct policy; do not substitute its allocation rules for the measured release64 census.

3. Every unavailable physical page at the audited checkpoint

The unchanged public guest completed 576 allocations across 18 sizes and 40 thread lifetimes. The census pauses afterwards and translates the actual live mappings and owned allocator state. It finds 16,052 free plus 332 unavailable pages, exactly accounting all 16,384 pages of 64 MiB. Assertions reject duplicate owners and claims on free pages.

Physical owner	Pages	KiB
Resident kernel headers/sections	102	408
Page-supply links and pin state	24	96
Pool run/bitmap metadata	3	12
Installed page directory/tables	17	68
Residual PFN and working-set backing	2	8
Low boot reservations	6	24
NV2A padding	16	64
Pool window, cache included	86	344
Other system-PTE allocations	37	148
Title virtual allocations	37	148
Live contiguous allocations	2	8
Total unavailable	332	1,328

The title and hardware rows are not firmware waste. The system-PTE count agrees with the public stack counter, but the capture does not prove individual thread ownership or stack high-water depth. Contiguous allocations requested 264 and 572 bytes and each own one page; their alignment/lifetime requirements must be understood before calling the page tails unnecessary.

At the initial checkpoint SpiritBoot has 16,083 available pages versus Complex's retained 16,226, a 572 KiB availability gap. After this workload the gap is 696 KiB. Those are history-dependent total-availability comparisons, not two interchangeable firmware subtotals. The resident-image difference alone is 57 pages / 228 KiB.

Full physical intervals and classification proofs: Memory-Runtime-Physical-Owners.

4. Pool, cache and allocation ownership

Complete pool-window partition

Pool component	Bytes	Physical pages
Live small-object usable capacity	92,792	Shared bucket pages
Live small-object headers	3,432	Shared bucket pages
Free-slot backing on fully empty bucket pages	126,976	31
Free-slot backing on partly occupied bucket pages	14,368	Shared bucket pages
Bucket subtotal	237,568	58
Ordinary file-cache buffers	65,536	16
Private recursive write-back reserve	32,768	8
Shared CcZeroData zero page	4,096	1
Unresolved whole-page allocations	12,288	3
Total pool-window backing	352,256	86

There are 429 live small objects across 54 stored tags and 375 free slots. Their exact capacities/headers are known; the allocator does not retain every original request length, so exact per-object internal fragmentation is unknown. Tags share pages and are not additive ownership categories. The 28 non-bucket pages occupy ten backing runs; 25 pages have cache/zero-page owners resolved using exact production offsets and pointers.

The public statistic reports 70 pool pages plus 16 cache pages. Adding the private reserve again to the raw 86-page total would double-count it. The reserve enables recursive filesystem metadata reads while dirty blocks are flushed; it cannot be removed solely because it is not reported as ordinary cache capacity.

All object/tag rows, all bucket classes and whole-page runs: Memory-Allocation-Object-Ledger. Cache behavior/lifetime requirements: Cache-and-Pinning.

Metadata allocated outside the image

Backing	Exact allocated size at 64 MiB	Purpose / rule
NxpLinks backing	65,536 bytes / 16 pages	16,384 four-byte PFN link/owner records. Pointer global is not the allocation itself.
NxpPins backing	32,768 bytes / 8 pages	Per-PFN pin state. Live overflow and deferred-free semantics matter.
Pool run lengths + bitmap	12,288 bytes / 3 pages	Metadata for the 16 MiB pool VA window. VA aperture size is not committed RAM.

Dense pin-batch scratch is already removed on audited main. Boot decompression into a separate permanent one-MiB scratch image is also already removed; proposing either again would duplicate completed work.

5. Function footprints and why code remains resident

The build inventory contains 1,438 compiler input-section extents, 4,298 COFF symbol records and 531 compiled object/source edges. An emitted extent can include inlining, cloning or alignment; it is not always an original C function's isolated body. The ledger retains aliases, sections, source candidates and export/callback/direct-call retention evidence.

Memory-Function-and-Table-Ledger gives every measured emitted extent. Memory-Resident-Page-Atlas shows which extents actually share physical pages. Removing a function's bytes only reduces committed RAM when layout/lifetime changes permit a whole page to be returned.

Large resident examples, from the current compiled image

Function / emitted extent	Bytes	Owned source candidate	Retention reason
_VfatDispatchRequest.lto_priv.0	10,516	drivers/filesystems/vfatfs/misc.c	direct-edge reachable from runtime root
_AtaDispatchPnp@8	5,522	drivers/storage/ide/atapi/pdo.c	address-taken / callback or conservative constant root
_PciIdeXDispatchPnp@8	5,081	drivers/storage/ide/pciidex/pdo.c	address-taken / callback or conservative constant root
_AtaPortWorkerThread@4	3,764	drivers/storage/ide/atapi/portstate.c	address-taken / callback or conservative constant root
_IopParseDevice@40	3,281	ntoskrnl/io/iomgr/file.c	address-taken / callback or conservative constant root
_DoQuery.lto_priv.0	3,271	drivers/filesystems/vfatfs/dir.c	direct-edge reachable from runtime root
_NtSetInformationFile@20	2,824	ntoskrnl/io/iomgr/iofunc.c	direct-edge reachable from runtime root
_PspExitThread@4	2,818	ntoskrnl/ps/kill.c	direct-edge reachable from runtime root
_VfatWrite	2,816	drivers/filesystems/vfatfs/rw.c	direct-edge reachable from runtime root
_ObpLookupObjectName@44	2,671	ntoskrnl/ob/obname.c	direct-edge reachable from runtime root
_ObInsertObject@24	2,538	ntoskrnl/ob/obhandle.c	direct-edge reachable from runtime root
_TransferPktComplete@12	2,285	drivers/storage/class/classpnp/xferpkt.c	address-taken / callback or conservative constant root
_PartMgrPnp@8	2,171	drivers/storage/partmgr/partmgr.c	address-taken / callback or conservative constant root
_RawDispatch@8	2,048	ntoskrnl/io/iomgr/rawfs.c	address-taken / callback or conservative constant root
_wstreamout	2,040	Unavailable/ambiguous after LTO or assembly	direct-edge reachable from runtime root

Storage/PnP setup includes long-lived registered callbacks and private interface copies. A function named initialization is not automatically discardable if those pointers still call it. Conversely, exported stubs may be small but still retain the public address/ABI contract. Function cost, function byte size, runtime frequency and safe reclamation are separate questions.

No universally unused function is proved by this census. Absence from a game trace or a simple source call graph is insufficient. Assembly, interrupts, return addresses, indirect callbacks, public imports, error paths and warm reset require explicit consumer/lifetime checks. KiIdleLoop illustrates why an apparently initialization-only direct graph can hide a lasting runtime role. See Memory-Interrupt-Vector-Lifetimes for a concrete admission prerequisite discovered during this audit.

6. All currently proved static global/table bodies

The following 59 objects have compiler/declaration-proved body sizes. Addresses belong to this exact build. Bodies in INIT are already discarded. A pointer's body is not its heap backing, a next-symbol interval is not sizeof, and contained type bodies are not extra allocations. Tables share pages with functions/data; do not independently round each row to a physical page.

Object	Exact bytes	Section	Virtual start
XeInterruptShadows	4,192	.bss	0x84062760
NxcBlocks	1,360	.bss	0x8405f000
NxContigInitial	1,024	.bss	0x8405e000
PmSelected	2,048	.bss	0x840639e0
PmRestored	2,048	.bss	0x8405e4c0
PmStageDescriptors	20,200	INIT	0x84076f40
NxpPageState	4,096	.bss	0x84060ac0
NxpClassMap	257	.bss	0x840609a0
NxpFreeLists	28	.bss	0x840646a4
P0BootStackData	12,288	.bss	0x8405b000
KiDoubleFaultStackData	4,096	.bss	0x8405a000
table_00000102	128	.rdata	0x840570a0
table_40000002	144	.rdata	0x84057000
table_40000370	4	.rdata	0x84056fe4
table_40020056	4	.rdata	0x84056fe0
table_400200af	4	.rdata	0x84056fdc
table_80000001	156	.rdata	0x84056f40
table_80000288	8	.rdata	0x84056f20
table_80090300	288	.rdata	0x84056e00
table_80092010	16	.rdata	0x84056de4
table_80096004	4	.rdata	0x84056de0
table_80130001	20	.rdata	0x84056dcc
table_c0000001	1,644	.rdata	0x84056760
table_c0000202	1,584	.rdata	0x84056120
table_c0020001	396	.rdata	0x84055f80
table_c0030001	48	.rdata	0x84055f40
table_c0030059	36	.rdata	0x84055f00
table_c00a0001	216	.rdata	0x84055e20
table_c0130001	88	.rdata	0x84055dc0
table_c0150001	156	.rdata	0x84055d20
error_table	240	.rdata	0x84057140
VidpFontData	1,248	.rdata	0x840534c0
NxkrnlNlsCase	4,870	.rdata	0x84053c20
NxkExportDirectory	1,552	.rdata	0x840582e0
XeRunningTitlePathA	520	.bss	0x8405ece0
KiInitialThread	736	.bss	0x84064360
KiInitialProcess	632	.bss	0x84062060
KiTimerTableLock	64	.bss	0x84062400
KiProcessorBlock	128	.bss	0x8405e440
KiNode0	40	.bss	0x84062340
HalDispatchTable	96	.data	0x84052320
HalPrivateDispatchTable	80	.data	0x840522c0
KeTickCount	12	.bss	0x8406044c
KiTimerTableListHead	512	.bss	0x84061bc0
NxcMutex	32	.bss	0x8405f560
NxcLruList	8	.bss	0x8405f558
NxcMapList	8	.bss	0x8405f550
NxcFreeBcbs	4	.bss	0x84064684
XeEventTable	512	.bss	0x84060700
HalpIDTUsageFlags	256	.bss	0x8405f820
HalpIDTUsage	512	.bss	0x8405f620
HalpSpecialDismissTable	64	.data	0x840525c0
HalpSpecialDismissLevelTable	64	.rdata	0x840577e0
IopFileMapping	16	.rdata	0x84053a80
DesSBox	512	.rdata	0x840558c0
IdexChannelObject	264	.bss	0x840625c0
NxkEepromImage	256	.bss	0x84063820
XboxAlternateSignatureKeys	256	.bss	0x84064a40
XePublicKeyData	284	.bss	0x840648a0

Contained structure bodies — do not add again

Type	Body bytes
NXC_MAP	152
NXC_BLOCK	40
NXC_BCB	32
PRIVATE_CACHE_MAP	88
XBE_EVENT_ENTRY	8
IDTUsageFlags	1
IDTUsage	2
NX_IDE_CHANNEL	264

Some copied measurement translation units generated ignored-alignment-attribute warnings. Their constants establish body size, not requested or actual alignment. Runtime cache ownership additionally uses nine exact NXC_BLOCK field offsets. See Memory-Additional-Table-Lifetimes for method and consumer/lifetime notes. The older ledger's 34-table section is its initial snapshot; this page includes the later 25 global-body additions.

7. What can run from ROM or leave RAM?

Readonly code/data can be a backing-placement candidate without being unused. A valid execute-in-place design must store raw callable pages in ROM, keep existing kernel VAs, preserve exports and callback addresses, and leave all written pages in RAM. Compressing an image smaller does not accomplish that.

The unmerged ROM-backed prototype PR #118 uses a separate 512 KiB flash profile and an older source tree. Current section policy would nominate 89 readonly pages; excluding the known writable prefetch-code page leaves 88 pages / 352 KiB as a conditional upper bound. It is not current-main memory recovered or compatible title performance. Its older PGR2 failures remain a qualification gap.

Concrete constraints:

• Boot initialization patches RtlPrefetchMemoryNonTemporal; its containing 0x84002000 page must retain writable RAM backing under that policy.
• Interrupt templates are copied and modified in writable interrupt-object storage. A readonly original template does not make its dynamic objects immutable.
• Unicode case tables, status conversion tables, export metadata and boot-font bytes have live or possible runtime consumers. Readonly placement can preserve those consumers; blind INIT discard cannot.
• Title import resolution writes title thunk storage. Immutable kernel exports and mutable exported data have different requirements.
• Reset must reconstruct ROM mappings and preserve any title data that reused donated RAM shadows. A successful cold boot is insufficient proof.

Detailed address, mutation and reset proofs: Memory-ROM-and-Cold-Code.

8. Reduction work and status

Merged main already removes the extra decompressed kernel buffer, checked obsolete boot workspace, dense pin-batch scratch, private Xbox error-ring backing, dead-stack retention and eager hardware-SG DMA bounce backing. Their former addresses may now be used by other owners and cannot be counted as still-reserved memory.

Burst-aware idle pool reclamation (PR #131) is Ready for review with merge HOLD. Final exact-head ABBA/BAAB qualification completed eight Windows PGR2 and eight Deck Conker runs with unchanged inputs and manually checked start/end scenes. PGR2 was effectively neutral. Conker average guest cadence changed −0.24%, but median p95/p99 increased 8.78%/9.29%, with worse tails in both orderings. The earlier large cadence outlier did not recur at that magnitude in this balanced release campaign; its cause and the candidate-associated tail excursions remain unproved. Both standalone and refreshed native allocation guests returned 25 pool pages / 100 KiB after a 20-second idle observation, with the same 27 occupied bucket pages retained. The compiled candidate adds no static resident backing pages. That is post-activity memory recovery, not a new cold-start census or demonstrated FPS improvement.

Two focused diagnostics narrow the remaining concern. The first found no page retirement during the menu. A subsequent paired entry/RET diagnostic reproduced a larger slowdown: 18.646/s parent versus 14.858/s candidate, with all menu images accepted. Candidate trim elapsed totaled 1.988 ms across the authored menu, while measured timer/DPC elapsed did not rise. Renderer surface-update elapsed increased from 17.445 to 29.876 ms per renderer frame with nearly unchanged draw/upload/submission counts. These instrumented inclusive intervals are not exclusive CPU time or a new release-performance claim. Earlier allocation placement, renderer dependencies and host/driver effects remain unresolved. The full attribution update retains the failed direction; #131 is still unmerged.

Host CPU sampling then captured normal-speed main/candidate menus:18.377/18.640 guest flips/s over the authored segment. The same candidate kernel-probe diagnostic that previously measured14.858/s returned18.186/s on this observation, with surface-update cost near17.6ms rather than29.9ms. Its422 trim calls totaled2.167ms inclusive. These instrumented observations did not reproduce or explain the slow state; the prior balanced tail direction remains a merge blocker. One-Hz clocks and system-wide paging counters cannot assign causes to earlier runs. The host-profile update retains that distinction.

Interrupt admission correctness (PR #133) merged on October 10, 2026 as f60f8de605cbbdce2f22e4bc3489e1c1487dcb59, after focused host tests, storage/APC checks at 64 and 128 MiB and native PGR2/Conker compatibility controls. It adds no claimed memory saving. Neither change is included in the explicitly pinned d4350b60 image/owner totals above. Smaller driver service boundaries and worker/cache lifetimes remain independent investigations. No FPS gain follows from a byte count alone.

Memory-Lifetime-and-Reduction-Plan tracks candidates, already-completed work, expected byte/page scope and validation requirements.

Evidence and maintenance

Source is reconstructed from SpiritBoot's pinned ordered patches. Exact build inputs, compiler flags, static-root analysis, sizeof emissions, capture identity, disjoint page owners and object ledgers remain in the lab; original numerical tables are published in this wiki. Evidence payloads are not merged into product main.

Refresh this page from an explicit new main revision and a matched checkpoint. Do not mix a 128 MiB layout, a draft candidate, a post-burst census and a cold-start public statistic into one baseline.

Current-main ROM residency measurement

The memory-first requirement is now RAM footprint at or below the supplied Complex reference while preserving ordinary64 MiB compatibility. Up to1 MiB of flash is acceptable. Flash size and resident RAM remain separate quantities.

Refreshed draft PR118 is rebased on mainf60f8de605cbbdce2f22e4bc3489e1c1487dcb59, including the newer interrupt, DMA, dead-stack and error-log correctness changes. Its ROM profile currently uses a512 KiB file. The refreshed reconstructed source tree is217d95a9f06cea8505ea87fd58db66acac1c9d6c.

Both current-main RAM and refreshed ROM builds completed the unchanged allocation/lifetime guest:576 allocations,40 synchronized thread lifetimes, then a pause immediately after the guest's final END marker. Every unavailable physical RAM page is assigned exactly once; ROM-backed mappings are counted separately. The same local xemu, EEPROM, HDD seed and guest were used.

Matched final checkpoint	Current RAM firmware	Refreshed ROM firmware	Previously measured Complex
Unavailable physical pages	332	244	158
Unavailable RAM	1328 KiB	976 KiB	632 KiB
Resident kernel RAM, including header	408 KiB	56 KiB	180 KiB

The total includes title allocations and hardware reservations consistently. It is not a pure firmware subtotal. Current-main RAM results reproduce the earlier matched332-page total. Complex was not rerun for this refresh; its existing pinned result remains the comparison point.

The refreshed ROM profile moves80 text pages,7 readonly-data pages and1 PAGE page to flash, recovering352 KiB of RAM. Mutable data, BSS, the header and the excluded runtime-modified text page remain RAM. The new total is still344 KiB above Complex. Kernel-image parity is achieved in this probe; total-RAM parity and title compatibility are not.

Remaining ROM-profile owners:

Physical owner	RAM
Resident kernel/header	56 KiB
Page-supply links and pin state	96 KiB
Pool run/bitmap metadata	12 KiB
Installed page tables	68 KiB
Residual PFN/working-set backing	8 KiB
Low boot reservations	24 KiB
NV2A padding	64 KiB
Pool window, including cache	344 KiB
Other system-PTE backing, including stacks	148 KiB
Title virtual allocation backing	148 KiB
Live contiguous allocations	8 KiB
Total	976 KiB

Within the pool window,31 bucket pages /124 KiB contain no live objects. This is retention, not proof of a leak or permission to discard cache reserves. The page census is a mechanism measurement; it makes no FPS, audio or full game compatibility claim. PR118 remains draft and historical PGR2 failure#120 remains unresolved.

Directly measured ROM and pool integration

PR #135 reuses wholly empty slab backing when another size class needs a refill. Headers, public capacities, class sizes and live objects are preserved. It does not use #131's idle trim.

Same final allocation/lifetime checkpoint	Unavailable physical RAM	Gap from retained Complex
Retained Complex reference	632 KiB	—
Current main, RAM kernel	1328 KiB	696 KiB
Refreshed ROM kernel (#118)	976 KiB	344 KiB
Independent pool reuse, RAM kernel (#135)	1264 KiB	632 KiB
Directly built ROM + pool integration	912 KiB	280 KiB

All sides use the same final checkpoint; do not combine these with the older initial572 KiB gap. Integration treeee941fca1df6216d3e4080623b067f90d7c1d409 completes576 allocations and40 thread lifetimes, with zero unattributed pages. The combined 416 KiB recovery was directly measured. ROM size512 KiB is within the approved1 MiB allowance. Parity is not met; neither PR is declared title-qualified.

The2,093-event production allocation/free replay retains86 pool pages with existing classes,70 with empty-slab reuse. Uniform finer classes instead model117 or125 pages without reuse. These modeled alternatives are not implemented firmware: better nominal sizes can still produce worse physical packing.

Live stack owners

The paused owned thread list, using offsets compiled from exact production source, identifies four executive workers (48 KiB), one filesystem overflow worker (12 KiB), one ATA worker (12 KiB), the title thread (64 KiB), and initial idle stack (12 KiB). Their37 committed pages match the public stack count. The idle stack is already charged in resident image/BSS ownership; do not add it again. A terminated Phase1 thread has no mapped stack pages.

Xbox already omits the balance-manager thread and already has one filesystem overflow queue. The hypercritical worker serves thread teardown through a direct KiInsertQueue, bypassing ExQueueWorkItem. Counting only that public queueing function would incorrectly label the reaper unused. Issue #143 tracks the measured ownership and one-worker investigation. No worker is removed solely for being idle.

Current plain-main comparison and third reference

The new Retail-5838-BIOS-Size-and-Layout keeps the supplied retail kernel separate from Complex. SpiritBoot-Main-Emitted-Extent-Ledger records every exact emitted extent in the source/artifact bound to the plain-main capture at f60f8de605cb, excluding ROM/pool experiments. SpiritBoot-Main-Physical-Ownership accounts for all 332 unavailable pages at its completed guest checkpoint. Memory-Reduction-Targets compares those results, preserves historical revision boundaries, and links the updated reduction issues. The historical figures on this page are not silently replaced or upgraded.

Three BIOS comparison guide

Memory-Comparison-and-Removal-Guide reconciles the initial and post-activity gaps, distinguishes image from runtime backing, and lists the owner/lifetime proof needed for each saving. Memory-Three-BIOS-Public-API-Comparison places all 366 reference ordinals in one table, keeping inferred reference walks separate from exact owned compiler extents.