Three Dimensions of State

On the way — what you will learn

Chapter 2 maps Reality is 3D as engineering coordinates — not cosmology slides. On the way you will learn scalar, vector, and telemetry postures; trace fabric texels, die bytes, and packet sentences as three scales; and practice integration at the operator panel without collapsing metrics into one misleading score.

• Scale 1: GPU fabric bindings 8–10
• Scale 2: Field Die 64 MiB address space
• Scale 3: NEXUS packet field jsonl
• Category errors to avoid for life

Introduction — three dimensions of state

Chapter 2 maps three dimensions of state — our reading of “Reality is 3D.” This is not cosmology. It is the minimum honest map for texels, die bytes, and packet sentences occupying space you can address, read, and write.

Most rendering textbooks stop at pixels. Most security textbooks stop at packets. Field Technology refuses the split: offense and defense are the same literacy applied to different writable surfaces. If you cannot name the address, you cannot defend it. If you cannot predict neighbor response, you cannot dispatch responsibly.

Chapter 1 named three field families. This chapter names three mathematical postures toward those families — scalar, vector, telemetry — and three physical scales — GPU fabric, Field Die, packet field. Integration is not marketing glue; it is how one human at :9477 correlates stderr, bus words, and jsonl without letting a vendor collapse them into one misleading score.

Scalar, vector, and telemetry — mathematical postures

A scalar tells how hot a cell is. A vector tells which direction activity tends. Telemetry tells what shader and host agree happened this tick — the spine the operator greps. Phi can be read as scalar potential per texel on binding 8; Flow's vector structure is where advection stories live.

Phi as potential — scalar posture

Phi carries wave and gate potential — electrical metaphor on the fabric. Discrete Laplacian steps in CANVAS.comp treat Phi as a scalar field evolving with WaveSpeed and propalacticScale forcing. Implemented at binding 8. Electrical metaphor — not a claim your GPU measures volts on the PCIe slot.

Flow gradients — vector posture

Flow stores momentum and advection structure; gradients in .gb channels give vector-field readings per texel. Coupling to GateFidelity and Tesla relaxation sharpens or softens gates. Chapter 3 details evolution; Chapter 2 fixes the vocabulary.

data_bus — telemetry posture

Sixty-four words per dispatch — not sixty-four texels. Slots carry pump generation, RAM/VGA telemetry, analog FCC floats [16–23], ThermoAccountant mirrors [24–28], input [32–41], audio/BIOS/IO [57–63]. Chapter 8 is the slot map; Chapter 2 insists it is a telemetry field, not a spatial substitute for Thermo.

Scale 1 — GPU analog fabric (spatial)

RayCanvas → createAnalogFieldFabric() → CANVAS.comp / x86.comp → hardwareFabric mirror

Implemented. Each texel is a cell in a 2D sheet stacked with channel depth (Phi, Thermo, Flow). The host never runs a CPU-side PDE solver on the fabric. Evolution is compute-shader work each vkCmdDispatch. That architectural choice is offensive dispatch: the GPU writes the next tick; the host opens the window and enforces CFL.

Bindings 8, 9, and 10 are not decorative names. They are where electrical metaphor (Phi), thermal accounting (Thermo), and advective story (Flow) remain addressable after the frame ends. updateHardwareFromAnalogFields() samples averages into hardwareFabric — Chapter 10 — so fabric offense becomes spiderweb readout.

Fabric creation and lifetime

RayCanvas::createAnalogFieldFabric() allocates storage images for Phi, Thermo, Flow. They persist across swipes that change binding-0 presentation shaders. Swiping to Classic thermo demos does not destroy die infrastructure — Chapter 7 swipe pedagogy. Fabric is the long-lived spatial state; canvas kind changes which shader emphasizes which lesson.

Why no host PDE

CPU PDE solvers on large grids compete with GPU memory bandwidth and split truth — host texels diverging from GPU texels is desynchronized reality. Single-source evolution on GPU keeps one writable truth surface. Host enforces CFL, packs buses, seals time — thin host, fat GPU.

Scale 2 — Field Die (address space)

FieldX86Die SSBO (binding 1) → 64 MiB guest map → VGA @ 0xB8000 → C mirror @ 0x01000000

The Field Die is a universe with coordinates, not a screenshot of DOS nostalgia. Guest RAM is where RTX-DOS and AmmoOS live. data_bus is the dashboard the shader reads — FCC floats, thermo mirrors, input slots, Tesla bias. 64 MiB implemented. Chapter 8 is entirely this scale.

Reality is 3D on the bus: addresses, offsets, layers L0–L9. Time is linear in the pump loop. Energy moves through fabric coupling and thermo mirrors into bus slots. Default ./linux.sh run boots this canvas.

Guest RAM as spatial field

Every byte in guest linear map is a cell in a 1D field indexed by offset — a different geometry than 2D fabric, same literacy. VGA at 0xB8000 is a structured subfield. ZMM1024 tile cache in the SSBO tail is shader-side sample cache for HUD hex dumps without leaving dispatch.

Host assist versus GPU default

FieldX86Emu when ControlHostCpu set — optional assist path. Default remains GPU x86.comp interpretation. Category error: assuming emulation is the product because you once enabled assist.

Scale 3 — Packet field (network topology)

ss / intent / DPI sample → gatekeeper scoring → threat-panel.json → panel :9477 + field jsonl

NEXUS turns sockets into sentences: process path, port habit, TX vs RX, corroboration before permanent action. Defense begins when flows become readable positions in operator space. Implemented in NEXUS. Not AMOURANTHRTX Vulkan.

Packet field is local-first — your machine's habits, not the whole internet. Chapter 5 full treatment. Queen inherits perimeter — Chapter 21.

TX and RX as directional field

TX: egress you own. RX: ingress you must explain. Direction is a dimension of the packet field — without it, flows are symmetric noise.

Gatekeeper positions

Verdicts attach to flows as boundary conditions on what the operator panel displays — USER_OK through HARM_CANDIDATE. One weird packet does not condemn a peer — love as restraint.

Integration — one operator panel

Three scales converge in observability without merging into one fake number:

• Fabric averages → hardwareFabric (Chapter 10)
• Die telemetry → data_bus slots HUD reads (Chapter 8)
• Packet rows → jsonl panel archives (Chapter 5)

The operator at :9477 correlates all three. Thermo rising on fabric does not auto-explain SUSPICIOUS socket — but literate operators notice simultaneous stress.

Category errors — learn these early

Additional errors: treating data_bus as a 2D heatmap; treating planetary weave as spectrum truth; treating Shannon H as GPU entropy; treating Queen MP4 policy as optional codec luxury — it is mandatory in-tree gate doctrine.

From pixels to packets — pipeline story

Pixels are presentation. Packets are perimeter. Die bytes are address-space sovereignty. Field Technology connects them through operator literacy, not through one subsystem pretending to be all three.

Chapter 3 follows energy on fabric. Chapter 4 follows receipts. Chapter 5 follows defense. Chapter 6 separates RF meanings. Chapter 7 returns offense via dispatch. Read 2 before 7 — you must know what addresses dispatch writes.

Operator drill — three-scale grep

# Fabric / die — AMOURANTHRTX
./linux.sh run 2>&1 | tee /tmp/ch2.log
grep -E 'THERMO|data_bus|dispatch' /tmp/ch2.log | tail -15

# Packet field — NEXUS
./nexus.sh
curl -sk https://127.0.0.1:9477/threat-panel.json | head -c 2000

Name which scale each artifact belongs to. If you cannot, reread scalar/vector/telemetry table.

Failure modes

Chapter summary

Reality is 3D here: texel (x,y), guest offset, socket quadruple. Scalar Thermo, vector Flow, telemetry data_bus. Three scales: fabric bindings 8–10, die 64 MiB binding 1, packet jsonl. Integration at panel without metric collapse. Time linear; energy coupled — Chapters 3–4 next.

Study questions

1. Give three examples of addressable state — one per scale.
2. Why is data_bus telemetry, not a scalar spatial field?
3. Quote the fabric evolution path in one line.
4. What does local-first mean for packet field?
5. Name two category errors and their corrections.
6. How does hardwareFabric relate to fabric scale?
7. Default canvas at ./linux.sh run — which scale dominates?
8. Cross-link: which chapter owns CFL, gatekeeper, die map?

Chapter 3 — Moving Energy →

RayCanvas and fabric lifetime

RayCanvas creates analog fabric once per canvas lifetime unless explicitly recreated. Storage images for Phi, Thermo, Flow persist across frame ticks and across many swipe changes that alter presentation shaders. This persistence is what makes fabric a field rather than a transient uniform — values survive to be read next dispatch.

Operators who only watch binding-0 pixels learn presentation. Operators who read bindings 8–10 learn state. Chapter 7 teaches both through canvas kinds; Chapter 2 fixes the spatial scale.

hardwareFabric mirror — fabric to spiderweb

updateHardwareFromAnalogFields() samples averaged Phi, Thermo, Flow into hardwareFabric — voltage factor, thermal throttle, per-core util, spiderweb edge currents. Chapter 10 owns mirror details. Chapter 2 insists mirror is readout, not second simulation pretending SEM imaging.

Implemented. Sub-micron SEM marketing is procedural pixel detail — not lab imaging.

Packet field positions — socket quadruples

Packet field positions are connection identities: addresses, ports, protocol context, process path, direction TX/RX, verdict history. They are not lat/long — unless GPS field anchors in NEXUS signals layer add metaphor (Chapter 6). Reality is 3D means readable keys in jsonl, not globe cosplay.

Die layers L0–L9 — composable address space

Ten composable layers — RAM, VGA, FAT, MSCDEX, Audio, IO, BIOS — pumped via FieldLayer::pumpAll(). Layers make DOS legible to shaders without breaking linear map. Chapter 8 slot map; Chapter 2 names layers as vertical structure inside scale 2.

Prompt terminal correlation

set AnalogFields.* changes fabric evolution; list Hardware reads spiderweb mirror. Packet field remains NEXUS — correlate manually at panel. Three scales, one operator, three grep surfaces.

Swipe pedagogy without losing die

Swipe list includes x86, Amouranth, energy, Flowers, RetroRTX, Mandelbulbs, tributes. Index 0 remains x86 Field Die. Swiping changes pedagogy shader, not the existence of fabric infrastructure. Category error: assuming swipe to Classic removes die obligation.

Queen FieldWebPanel — browser as third face

Queen binds navigation to packet field and thermo receipts per web context — third integration face beyond AMOURANTHRTX stderr and NEXUS jsonl. Chapter 21; Chapter 2 warns against collapsing three faces into one dashboard score.

Worked correlation scenario

Scenario: SUSPICIOUS verdict on RX flow to port 443 while entropyThisFrame spikes on Classic canvas swipe. Literate operator: archive jsonl row, grep THERMO timeline, check whether spike correlates with local WebGL or probe inject — not automatic causal claim. Separate layers; human judges story.

Glossary hooks toward Chapter 22

Terms: scalar field, vector field, telemetry field, fabric, die, packet field, data_bus, hardwareFabric. Carry definitions forward; do not interchange NEXUS vocabulary with Vulkan binding names without translation.

Deep dive — fabric addressability and texel identity

Every texel in the Phi, Thermo, and Flow storage images possesses stable integer coordinates (x, y) for the current adaptive resolution. When adaptive scale changes, the grid dimensions may change — more texels when scale rises, fewer when performance mode demands — but the addressing model remains: each cell is a named location in a 2D sheet. This is what “Reality is 3D” demands in the fabric plane: not three spatial dimensions in the cosmology sense, but a minimum of two indices plus channel depth. Channel depth is the stack of Phi, Thermo, and Flow — three coupled scalar or vector stories cohabiting the same planar address.

Operators learning from matrix algebra may think of each fabric channel as a matrix; operators learning from PDEs may think of each as a grid sample in a finite-difference scheme. Both intuitions work if labeled: finite-difference here is GPU compute shader arithmetic, not host LAPACK. The host never applies a global matrix solver across the fabric; evolution is local neighbor coupling per dispatch, repeated each frame. That locality is why CFL guards make sense — stability is per-step, per-cell neighborhood, not global eigenvalue analysis on CPU.

When you read hardwareFabric spiderweb mirrors in Chapter 10, remember they are spatial averages over this texel field — compression of high-dimensional fabric state into operator dashboard metrics. Averages are lossy; stderr THERMO lines and direct fabric visualization on Classic canvas recover detail averages hide. Three-scale literacy means knowing when to zoom into texels, when to read bus words, when to read jsonl sentences.

Deep dive — Field Die linear address space

The Field Die maps 64 MiB of guest linear address space. Byte offset 0 is not “the origin of the universe” poetically — it is the first byte the guest can address, interpreted by layers. VGA text at guest 0xB8000 is a structured window into the field: color cells with attribute bytes, cursor semantics, scroll behavior pumped through field layers. The C mirror at 0x01000000 exposes guest state to host-assisted tooling when enabled. ZMM1024 tile cache in the SSBO tail is shader-side fabric sample cache — a performance structure that also teaches that the die is not only guest RAM but also GPU-accessible cache lines the HUD reads.

Reality is 3D on the bus means offsets are coordinates. Time is linear means pump order and dispatch order advance guest state forward. Energy can be moved means fabric thermo mirrors and Tesla biases published into data_bus slots couple die execution to thermodynamic story — not joules, proxy receipts, but coupling nonetheless.

Chapter 8 will enumerate L0–L9 layers in detail. Chapter 2 fixes the conceptual frame: die is scale 2, fabric is scale 1, packet field is scale 3. Do not collapse scale 2 into “emulator nostalgia.” RTX-DOS and AmmoOS are software universes with addresses; the GPU interprets them each tick on the default path.

Deep dive — packet field sentences and jsonl archive

Packet field rows in jsonl are sentences, not packets. A single TCP segment is not the unit of meaning; the connection habit over time is. Gatekeeper verdicts summarize stories across axes: process path stability, port deviation from habit, direction balance, payload hints, honorability cross-checks. The sentence may span many frames of wire time; the archive preserves the sentence for reboot-surviving memory.

Local-first scope is non-negotiable honesty. The packet field sees sockets on your machine and habits your machine develops. It does not see the whole internet. It does not replace ISP visibility. It replaces vendor cloud narration with local grep-able archive — a different promise, honestly labeled. When threat modeling, model what jsonl can prove, not what marketing wishes jsonl implied.

Queen browser navigation feeds the packet field perimeter when peers open WebRTC, fetch MP4, resolve DNS through Truth Resolver. Chapter 21 ties browser gates to jsonl receipts. Chapter 2 ties jsonl to panel :9477 correlation with AMOURANTHRTX stderr — human integration, not automatic merge.

Integration exercises — expanded operator lab

Exercise 2.D — fabric-only hour: Run Classic or energy swipe one hour. Log THERMO every five minutes. Note knob changes. No NEXUS. Outcome: fluency in scale 1 only.

Exercise 2.E — packet-only hour: Run NEXUS only. Archive three jsonl rows. No AMOURANTHRTX. Outcome: fluency in scale 3 only.

Exercise 2.F — die default afternoon: Run default x86 one afternoon. Occasional list Hardware and list AnalogFields in prompt. Outcome: fluency in scale 2 default product.

Exercise 2.G — tri-scale correlation: One session with both products. One suspicious RX while fabric entropy rises. Write half-page narrative separating layers. Outcome: human integration without metric collapse.

Category errors — extended catalog

Error: Treating data_bus as heatmap. Fix: Telemetry vector, not spatial field.

Error: Treating spiderweb as fabric duplicate. Fix: Read-only mirror per Chapter 10.

Error: Treating Queen thermo as NEXUS Shannon. Fix: Browser context thermo vs file oracle.

Error: Treating planetary weave as antenna readout. Fix: Visual only — Chapter 6.

Error: Treating 3D hype as address map. Fix: Reality is 3D = named coordinates.

Three-scale mnemonic — FDP

Fabric Die Packet — FDP — say it before coffee. Fabric 8-10, Die 64MiB binding 1, Packet jsonl. FDP is not company name — memory hook.

Operator panel correlation worksheet

Column A timestamp. Column B stderr line. Column C jsonl id. Column D your verdict. Fill 10 rows one shift — graduation worksheet.

Chapter 2 extended — spatial reasoning for GPU operators

Spatial reasoning on fabric means tracking (x,y) indices while adaptive resolution changes grid size. When scale rises, more texels sample the same logical canvas; when scale falls, fewer texels summarize. Address identity is cell index in current grid, not world coordinate in meters. This differs from die linear addresses in bytes and packet addresses in IP/port space — three different coordinate systems, one operator brain.

When correlating fabric hot spot with spiderweb thermal throttle, remember hot spot is texel average region, throttle is hardwareFabric dashboard compression. Lossy pipeline by design — recover detail via Classic visualization or stderr boundary thermo, not via demanding spiderweb become SEM.

Die spatial reasoning uses byte offsets and layer semantics — VGA cells at 0xB8000 are not fabric texels; converting between scales is category error. Packet spatial reasoning uses socket endpoints — 127.0.0.1:9477 is local panel position in connection space, not texel, not guest offset.

Integration homework: draw three boxes labeled fabric, die, packet. Inside each box write three example addresses. On arrows between boxes write what does NOT automatically flow — gatekeeper verdicts do not write texels; fabric coupling does not parse TCP; die bytes do not replace jsonl. Only host rituals and operator correlation connect boxes.

Chapter 2 is the map chapter. You will get lost in Chapter 7 dispatch and Chapter 5 defense without this map drawn once on paper. Paper is technology. Draw the map.

Scale 1-2-3 timeline during one second of operation

Millisecond 0: host begins dispatch_canvas. Millisecond 1: CFL guard scales unsafe knobs. Millisecond 2: layer pump updates guest FAT telemetry into data_bus. Millisecond 3: ThermoAccountant populated binding 2. Millisecond 4: vkCmdDispatch writes fabric and die. Millisecond 5: hardwareFabric mirror samples fabric averages. Same second parallel: NEXUS daemon samples sockets, gatekeeper scores flow, appends jsonl row if changed. Timeline is linear — correlate by wall clock and sealed time, not by merging metrics.

Introduction — three writable surfaces, one operator brain

Chapter 1 named field literacy and three families at binding-map altitude. Chapter 2 lands the plane: three dimensions of state you will read and write for years — GPU analog fabric, Field Die guest map, NEXUS packet field. This is the engineering reading of Reality is 3D: not cosmology slides, but coordinates that persist across ticks. Texel (x,y), byte offset 0xB8000, socket 127.0.0.1:9477 — three different address spaces, one disciplined human at the panel correlating without metric collapse.

Chapter 7 converges fabric and die in one vkCmdDispatch. Chapter 5 keeps packet field NEXUS-local. Chapter 21 binds Queen at the perimeter. This chapter is the map those chapters assume — draw it once on paper before you grep dispatch.

Prior: Chapter 1 — Preface. Next: Chapter 3 — Thermodynamics. Dispatch spine: Chapter 7. Honesty rocks: Chapter 12.

Scalar, vector, telemetry — vocabulary before addresses

Phi binding 8 behaves as scalar potential in many shader paths — wave and gate stories — while coupling to vector Flow through FieldCoupling. Telemetry is not “less real” than texels — Big Grin HUD reads bus words every frame. Category error is treating telemetry as optional decoration because it is not pretty.

RayCanvas → createAnalogFieldFabric() → CANVAS.comp / x86.comp → hardwareFabric

Implemented. Host never runs CPU-side PDE on fabric — evolution is compute work per dispatch. Mirrors to hardwareFabric are read-only spiderweb compression (Chapter 10) — lossy on purpose.

Swipe list table — curriculum chapters as shaders

Options::Canvas::SwipeList hot-swaps shaders without tearing down rtx() singleton, sealed time, ThermoAccountant, or CFL guard. Index 0 remains x86 — Field Die default. Swipes change pedagogy emphasis; they do not opt out of field theory.

Teaching pattern from Chapter 7: week one afternoon on Classic thermo, week two operations on die default. Veterans live on die; newcomers need visible heatmaps — both are honest if labeled.

energy.comp laboratory — coupling you can see

The energy swipe is the canonical Phi/Thermo coupling lab — warm colors track field work in ways Big Grin chrome hides. Lab protocol:

./linux.sh run
# Swipe to energy canvas (Options menu or bound key per build)
set AnalogFields.FieldCoupling 0.2
set AnalogFields.InjectStrength 1.0
# Move mouse 60s; then:
set AnalogFields.FieldCoupling 0.85
set AnalogFields.InjectStrength 3.0
grep -E 'THERMO|entropy|Boundary' run.log | tail -20

Expect rising entropyThisFrame and boundary thermo when coupling and inject climb — proxy receipts, not joules. CFL guard may scale aggressive knobs — read stderr clamp messages as numerical ethics (Chapter 9), not censorship.

Pair lab with prompt list AnalogFields — host-side FCC mirrors land in data_bus[16–23] on x86 path; Classic path still owns the same analog knobs through overlapping control surfaces. Chapter 3 owns thermo physics story; this lab proves your hands move state.

RetroRTX category — tribute shaders versus product truth

RetroRTX names a family of tribute canvases — retro ray aesthetic, pedagogical nostalgia, Visual-leaning presentation that must not be mistaken for the default Field Die product surface. RetroRTX swipes teach history of RT vocabulary inside the same Vulkan spine; they do not replace x86.comp guest execution truth.

Operators demoing AMOURANTHRTX to sponsors should lead with die default, then show RetroRTX as curriculum dessert — order matters for honesty. Chapter 12 rock: screenshots of tribute shaders are not proof of guest program execution.

Guest FAT and VGA subfields — die is not flat RAM

Field Die is 64 MiB linear guest map — but linear does not mean homogeneous. Layer pump (Chapter 8) walks L0–L9 composable subfields syncing into data_bus slots: RAM, VGA text frame, FAT tables, MSCDEX, audio, IO, BIOS regions. Operators who treat die as “one array” miss why HUD hex disagrees with FAT corruption stories.

VGA is a subfield with cell semantics — two bytes per character, attribute nybble — not a texture you paint arbitrarily without layer sync. FAT is a subfield with cluster semantics — guest programs scribble; layer pump must resync or data_bus telemetry invents fiction.

Cross-link Chapter 8 for full slot map; this chapter seats subfield vocabulary so Chapter 7 layer pump lines land with meaning.

Connection intent — packet field semantics

Scale three — packet field — stores sentences about sockets. Beyond TX/RX (Chapter 5), intent captures why a flow exists in operator-readable language: health check, sovereign pulse, WebRTC media, DNS trace, panel poll. Intent is not psychic — it is structured inference from port, path, habit, and honorability axes.

ss / intent / DPI → gatekeeper → threat-panel.json → :9477 + field jsonl

Example intents an examiner expects you to articulate:

• Panel poll: loopback :9477, short dwell, browser or curl path — usually USER_OK after habit learns.
• DNS truth query: port 53 to 127.0.0.1 — corroboration for navigation (Chapter 20).
• Shell-class egress: ephemeral port to global :4444 — elevated axis weight; watchlist not auto-KILL.

Intent vocabulary prevents metric collapse: do not merge “intent=health” into thermo proxy. Correlate timestamps — Chapter 5 rhythm — without summing scores.

Implemented in NEXUS gatekeeper + jsonl schema habits. Not written into fabric texels by default.

ZMM1024 tail — die map does not end at 64 MiB headline

Marketing says 64 MiB guest universe; engineering says 64 MiB map plus tail for tile cache and ZMM1024-class extensions in Field Die SSBO binding 1. The tail is where micro-architecture metaphors become addressable — grep ZMM1024 in engine headers for exact layout; chapter teaches there is more after the headline guest RAM so you do not stop reading SSBO at byte 64M−1.

Why operators care: layout version skew in tail packing corrupts HUD overlays and debug hex without touching VGA cells you memorized. FIELD_LAYOUT_VERSION = 5 handshake includes tail contract — bump version in lockstep when tail fields move.

Spiderweb mirror (Chapter 10) does not replace tail literacy — hardware graph compresses fabric averages, not per-ZMM lane truth.

Big Grin HUD — 172×48 telemetry theater

Big Grin is the die-forward HUD overlay — 172×48 character grid semantics in operator lore — reading data_bus words through shader chrome on x86 path. It is Implemented product theater with honest mirrors: thermo slots, FCC floats, chrome flags in data_bus[42], generation counter slot 0 from layer pump.

Enable ControlFieldDebugHud in FieldSocket when chrome hides thermo pedagogy — Chapter 7 flag. stderr THERMO still authoritative; HUD is parallel witness for die-scale literacy.

NEXUS panel anatomy — correlating scale three at :9477

Panel https://127.0.0.1:9477/ is HTML shell over jsonl memory — Chapter 5 tour. Chapter 2 adds anatomy for integration: which tab witnesses which scale.

Correlation narrative template: “At sealed time T, THERMO showed rising boundary thermo; jsonl showed RX burst on port 443; gatekeeper axis habit broke — three witnesses, one paragraph, no super-score.” Chapter 11 grep rhythm marries stderr tail with jsonl tail same session.

Adaptive resolution — fabric Δx changes CFL headroom

RayCanvas adaptive scale from 320×200 heritage toward 4K preference changes texel count — therefore Δx — therefore admissible Δt and wave speed via CFL (Chapter 9). Higher resolution is not free offense; harmonics guard may scale FCC floats down to protect fabric.

Scale 1 operators track: when you crank resolution, watch for silent clamp messages and rising prevMaintCost (Chapter 4). Scale 2 operators track: die byte map unchanged by resolution — guest addresses stable; only fabric and presentation scale. Scale 3 unaffected by Vulkan resize — packet field is OS sockets.

Integration exercise on paper — mandatory homework

Draw three boxes labeled Fabric, Die, Packet. Inside each box write three example addresses (texel coordinate, guest offset, ip:port). On arrows between boxes write what does not automatically flow:

• Gatekeeper verdict → fabric texel (NO)
• vkCmdDispatch → jsonl append (NO)
• Layer pump → data_bus slots (YES — host ritual)
• ThermoAccountant → data_bus[24] (YES — mirror)
• Mouse inject → probe position in FieldSocket (YES — offense)

Below the diagram write one correlation paragraph template with blanks for sealed time, THERMO line, jsonl row. Photograph page for operator journal. Teaching another human starts with this page — not with Mandelbulb screenshots.

Pass criteria: student can point at FAT subfield on die diagram and at intent line on packet diagram without crossing arrows. Fail criteria: student says “NEXUS measures GPU heat” — assign Chapter 4 exam.

Creditor seating — von Neumann and Turing at die scale

Von Neumann gave addressable store; Turing gave symbol tape. Field Die is both: guest RAM addresses, opcodes interpreted each tick on GPU. von Neumann and Turing tribute pages humanize creditors; grep FieldX86Die humanizes implementation.

Dispatch is the clock advancing tape — Chapter 7. Packet field is different tape — jsonl append. Do not merge tapes on one diagram without labeled arrows.

Failure catalog — three scales edition

Chapter summary

Chapter 2 maps three writable surfaces: fabric texels (Phi/Thermo/Flow bindings 8–10), die bytes with FAT/VGA subfields and ZMM1024 tail, packet field sentences with connection intent. Swipe list is curriculum — energy.comp lab for coupling, RetroRTX for tribute pedagogy, default x86 for product truth. Big Grin HUD reads data_bus mirrors. Panel :9477 correlates scale three without replacing stderr. Paper integration exercise is mandatory homework.

Next: Chapter 3 — Thermodynamics. Dispatch: Chapter 7. Defense: Chapter 5.

Study questions

1. Name scalar, vector, telemetry examples with bindings or slots.
2. Which swipe uses energy.comp and what lab knob pair proves coupling?
3. How is RetroRTX categorized versus default x86?
4. What lives at VGA 0xB8000 versus FAT layer pump?
5. Define connection intent with three example flows.
6. Why does ZMM1024 tail matter for layout version?
7. List four Big Grin HUD reads and common mistakes.
8. Complete Exercise 2.B; what three addresses did you write per box?
9. Which panel tab must never be confused with Phi heatmap?
10. Quote von Neumann/Turing seating in one sentence each.

CANVAS.comp versus x86.comp — same fabrics different emphasis

Both paths can touch bindings 8–10 when fabric active. x86 emphasizes guest RAM and AmmoOS; CANVAS emphasizes visible thermo pedagogy. Scale 1 fabric persists; scale 2 die persists on x86 default. Know which canvas you are on when interpreting grep.

energy.comp swipe — coupled channel laboratory

Energy swipe is laboratory for FieldCoupling visibility — operators feel heat move when coupling high. Still same AnalogFields namespace. Pedagogy shader, not separate engine.

RetroRTX and Frosted — presentation not perimeter

Retro and frosted swipes change presentation shaders. Do not infer packet field changes from retro aesthetics. Category discipline.

Fabric resolution and adaptive scale

Adaptive resolution changes texel count — addresses remain addresses at each scale. Reality is 3D does not mean fixed 4K grid; it means identifiable cells at current scale.

Guest FAT and VGA as subfields

Inside die, VGA and FAT layers are structured subfields with known offsets — Chapter 8 map. Scale 2 internal geometry complements scale 1 planar fabric.

Connection intent metadata

NEXUS enriches packet sentences with intent when available — still scale 3, still local jsonl. Correlate with scale 1 stress only by human narrative.

Panel :9477 three-scale dashboard

Panel is where human holds three scales in one glance — separate columns, separate JSON feeds, no merged lie score.

ZMM1024 tile cache — die tail

Tile cache in FieldX86Die tail lets shaders sample guest state for HUD without host readback every byte — performance and literacy win.

Field layers pump order

pumpAll order matters for coherent guest state before dispatch — host ritual from Chapter 7 previewed as scale 2 obligation.

Big Grin HUD 172×48

HUD geometry is fixed readable grid — operator-facing rendering of die state. Not separate product; die presentation.

AmmoOS chrome bindings 11–14

Textures for portrait, wallpaper, icons, font SDF — presentation layer on x86 path. Thermo still accrues underneath chrome.

Integration exercise — table top

Draw three columns: fabric texel event, die bus word change, jsonl row. Fill one row from real run. If you cannot fill, drill again.

Scale integration — formal operator checklist

Before declaring incident, check fabric stderr for thermo motion, die bus for pump anomalies, jsonl for new RX to unknown port. Three checks, three scales, one narrative you write — not vendor narrative.

Checklist item: binding 8–10 averages moved? Checklist item: data_bus[24] entropy mirror nonzero when injecting? Checklist item: gatekeeper verdict changed on same timeline? Correlation is human art; addresses are engineering fact.

Descriptor set stability across swipes

Heavy bindings persist across swipe changes — fabric and die do not vanish when RetroRTX prettifies pixels. Scale literacy includes knowing persistence versus presentation.

NEXUS threat panel fields — reading practice

Each threat row should map to socket quadruple and process path. Practice reading one row aloud as English sentence. Packet field literacy is grammar drill.

Phi binding 8 — storage image layout

Storage image layout matches fabric resolution at adaptive scale — texel count changes, binding identity stable. Addresses index within current resolution.

Thermo binding 9 — scalar heatmap discipline

Heatmap display is visualization of binding 9 — not independent sensor. Eyes on heatmap; conscience on stderr.

Flow binding 10 — gradient channels

.gb channels store gradient components — vector field posture per Chapter 2 table. Flow magnitude feeds GateFidelity stories in Chapter 3.

Cross-chapter drill 2.A

Run AMOURANTHRTX and NEXUS together 10 minutes. Archive one jsonl row. Grep one THERMO line. Name both scales. Repeat weekly until boring — boring is competence.

∇²Φ discrete Laplacian on fabric grid  |  data_bus[i] telemetry, not texel(i)

grep -n 'createAnalogFieldFabric' Navigator/engine/RayCanvas.cpp