Field Browser Queen — Hold All Gates

Introduction — Queen doctrine

Nothing optional. Hold all gates. MP4. We want it ALL. Chapter 21 is Field Browser Queen — the complete web surface carried into the packet field without amputating capabilities to feel safe.

On the way — what you will learn

Queen holds all gates — WebRTC through gatekeeper, MP4 mandatory in-tree, EME held not omitted. On the way you will link browser perimeter to AMOURANTHRTX spine, KILROY sovereign field, and packet-field receipts.

• QUEEN_BROWSER_BUILD and rtx() spine
• Nothing optional security posture
• Thermo per WebGL context
• Sovereign packaging with KILROY

Reality is 3D · Time is linear · Energy can be moved. Queen does not shrink the web. Queen holds gates: every capability exists; every wire exit earns a receipt.

Wrong posture: disable WebRTC for privacy. Right posture: WebRTC flows through Connection Gatekeeper with honorability and packet field. Wrong: MP4 optional pack. Right: MP4 + H.264 + AAC mandatory in-tree.

Gate mode — hold, never omit

Capabilities are not toggles that remove surface area. They are gates the operator holds via Connection Gatekeeper, Packet Field, Honorability DB, Fair Ad Guardian, Thermal Governor, Truth DNS, and Sovereign Time witness.

field-queen-gates-seed.json lists every gate with held:true — html_dom, javascript, wasm, webgl, webgpu, mse, eme, webrtc, websockets, camera, microphone, legacy_plugins_surrogate, and more.

field-queen-browser.py computes queen_verdict: QUEEN_READY only when all gates held, mp4_mandatory true, hold_all_gates env on.

WebGL, WebGPU, and thermo per context

WebGL 1/2 and WebGPU stay on. Each GPU context bills thermo via Thermal Governor — energy honesty per tab, not global hand-wave.

Disabling GPU APIs to feel safe amputates the web Queen promises to carry. Hold gates instead: score egress, receipt entropy, throttle abusive contexts.

Canvas 2D shares gpu layer gates — not a second-class citizen.

WebRTC — gated realtime

WebRTC audio, video, and data channels stay on. Gatekeeper scores each peer connection. Camera and microphone gates require operator consent layer — held, not removed.

STUN/TURN flows appear in packet field sentences. Honorability precedes sustained egress. A peer without trust story does not get silent long-term hole punching.

MSE, MP4, H.264, AAC — mandatory in-tree

Media Source Extensions required. Containers include video/mp4, video/webm, audio/mp4, audio/mpeg. Video codecs: avc1, h264, hev1, vp9, av01. Audio: mp4a, aac, opus, flac.

Path: MSE → Gecko media → FFmpeg in-tree. MP4 is not optional pack. queen_verdict returns MP4_MISSING if video/mp4 absent from container list.

Tell users to install Chrome for video is retired vulnerability class. FieldFox ships full codec tree.

EME / Widevine — held, not omitted

Encrypted Media Extensions stay on. DRM is held — gatekeeper scores license server flows. Omitting DRM does not remove content sites; it lies about capability surface.

Fair Ad Guardian and honorability apply to license traffic same as ads and analytics.

Service Workers, WASM, storage gates

Service Workers and Cache API on — entropy receipts for persistent script surfaces. WASM on — same gate discipline as JS.

IndexedDB, Web Storage, File System Access, SharedArrayBuffer with COOP/COEP — all held. Storage without receipts is exfiltration runway.

Sensors, devices, UI gates

Geolocation, Notifications, Push, Web Bluetooth, WebUSB, Web Serial, Gamepad — held with consent and gatekeeper scoring.

Popups, window.open, third-party iframes — held. Legacy Flash/Java/Silverlight via WASM surrogates — surface preserved, plugin VM gone.

PDF inline, SVG, MathML — document layer held for scholarly web.

FieldFox — ship now engine

FieldFox is hardened Gecko fork: telemetry stripped, Truth Resolver DNS lock at 127.0.0.1, NEXUS native messaging bridge, full codec tree.

NEXUS_FIELD_BROWSER_QUEEN=1 ./lib/fieldfox-launch.sh starts Queen profile. python3 lib/field-queen-browser.py json returns queen_verdict QUEEN_READY when posture correct.

Process names tracked include fieldfox, firefox, chromium family for browser-awareness integration.

queen-browser — in-engine RTX path

queen-browser binary — AMOURANTHRTX Vulkan + SDL3 inside. In-engine UI via FieldWebPanel. QueenBoot.comp — 2026 aqua/rose chrome. Hostess 7 Forever Watchguard in 50/50 split deck — the in-process robot-brain stack inside Queen (Metaphor for gate+recall architecture; not a government deliverable), not a cloud tab.

Brain imaging: Hostess folds 1000–1200 word textbook beats into SDF plates (signed distance fields are free — procedural topology, not megapixel rent). Series-of-series neural nets recall plates via vision OCR; grep blocks land in SDL text documents. Five decisions per segment: integrate · reimage · toss · sdl_store · sdf_plate. Teach: ./Hostess7.sh sdf-teach seed · segment: ./Hostess7.sh sdf-segment <file>.

NEXUS_INSTALL_ROOT=Queen ./build/rtx/bin/Linux/queen-browser --sovereign --queen links engine spine when QUEEN_BROWSER_BUILD set.

Two ship tracks coexist: FieldFox Gecko now; queen-browser Vulkan in-engine for sovereign RTX field deployments.

NEXUS stack binding

Navigation → Packet Field → Gatekeeper → Honorability → Thermo receipt. Upstack: Truth DNS (no Google shortcut). Upstack: Sovereign Time (SQUIDGIE witness).

fieldfox-native-bridge.py native messaging to gatekeeper. browser-awareness.py live tab honorability feeds panel.

connection-gatekeeper.py 10-axis intent scoring per flow. packet field jsonl per navigation.

KILROY and field package — sovereign field

Queen Forge packages kernel + browser + secure stack in field/sovereign/. KILROY Field OS (7.1.1-kilroy) provides /proc/kilroy_field at syscall boundary — CONFIG_RTX_FIELD_DIE field die in kernel.

Userspace Queen runs on top — one field, sealed manifest, Grok Build secure channel inside. Kernel FCC parallel (Chapter 9) shares vocabulary with userspace CFL.

field package is not zip convenience — it is sealed operator manifest: kernel image, Queen browser, Truth DNS, Field DHCP, sovereign time, panel slice, grep discipline documented.

Year 3000 vision: one sovereign stack — Queen browser + NEXUS + Truth DNS + sovereign DHCP/TIME + ELLIE Last Host. Web does not shrink; gates do not open without receipts.

Millennium track — Ladybird and Servo

Ladybird / Servo independent engines inherit field-queen-gates-seed.json — same gate doctrine, no Chromium dependency, no telemetry chew.

FieldFox ships first. Millennium engines are not excuse to delay gates — they are future trunks with same held manifest.

Panel slice and queen_verdict

Threat panel merges field_queen_browser slice: gates.all_held, codecs.mp4_mandatory, queen_verdict, browser_awareness honorability.

Verdicts: QUEEN_READY, QUEEN_OFF, GATES_INCOMPLETE, MP4_MISSING, HOLD_ALL_GATES_OFF — grep-able, not decorative.

field-queen-browser.py gate <id> inspects individual gate held state.

Vulnerabilities retired — browser class

Optional DRM/WebRTC/WebGPU toggles retired — Queen holds gates. Chromium telemetry chew retired — FieldFox strips it. Foreign DNS shortcut retired. Pool NTP sole clock retired. MP4 optional pack retired.

Operator week-four lab

Launch FieldFox with Queen env. Confirm Truth DNS lock. Play MP4 in-tree sample. Open WebRTC test page — confirm gatekeeper scores appear in packet field.

Run field-queen-browser.py json — QUEEN_READY. Cross-check sovereign-time status — SQUIDGIE should block clean verdict if time dirty.

Honest rocks

field-queen-gates-seed.json all held: Implemented. field-queen-browser.py panel: Implemented. FieldFox launch script: Implemented.

queen-browser Vulkan in-engine: Implemented build path; operator may ship FieldFox first. Ladybird production: Millennium track.

KILROY on every host today: Field package path — QEMU/bare-metal per Chapter 12 rocks.

Gate-by-gate reference — render and script layers

html_dom, javascript, wasm, service_workers — held at script/render boundary. Disabling JS to feel safe is omit posture — rejected.

Gate-by-gate reference — GPU layer

webgl, webgpu, canvas_2d — thermo per context via Thermal Governor. GPU off is not Queen.

Gate-by-gate reference — media layer

mse, eme — MP4 H264 AAC mandatory; Widevine held. License server flows scored like any egress.

Gate-by-gate reference — realtime layer

webrtc — peers gated; STUN/TURN in packet field. Data channels same scoring.

Gate-by-gate reference — network layer

websockets, fetch_xhr, http2_http3 — QUIC flows are first-class scored connections.

Gate-by-gate reference — storage layer

indexeddb, file_system_access, shared_array_buffer — persistence requires entropy receipt story.

Gate-by-gate reference — sensor and device

geolocation, camera, microphone, bluetooth, usb, serial, gamepad — consent plus gatekeeper.

Gate-by-gate reference — document and UI

pdf_inline, svg_mathml, popups, third_party_embeds — scholarly and legacy web surfaces preserved.

field-queen-browser.py API surface

Commands: build, json, gates, codecs, gate id — operator tooling for manifest audit without opening seed by hand.

fieldfox-native-bridge.py

Native messaging connects browser events to connection-gatekeeper.py — every navigation can emit packet field sentence.

connection-gatekeeper.py — ten-axis intent

Scores process path, port habit, direction, payload hints — verdict before sustained egress. WebRTC peers get same axes.

browser-awareness.py — tab honorability

Active tab trust feeds panel browser_awareness block — operator sees honorability live, not after breach.

Fair Ad Guardian — ad egress

Separates first-party from junk — reduces blind blocker omit posture while holding ad gates.

Thermal Governor — per-tab energy

WebGL and WebGPU contexts bill thermo ethic — abusive miner tabs show energy story in receipts.

Honorability DB — site trust

Persistent store — navigation consults before egress proceeds. Queen doctrine: honorability before egress.

Codec path — MSE to FFmpeg

Container video/mp4 required. Video avc1 h264; audio mp4a aac. Path MSE Gecko media FFmpeg in-tree — document in runbooks for support tickets.

EME Widevine — held scoring

License server URLs appear in packet field — operator can archive DRM egress like any other.

Legacy WASM surrogates

Flash Java Silverlight surfaces replaced by WASM — capability preserved, attack surface reduced versus NPAPI era, but gate still held.

FieldFox launch environment

NEXUS_FIELD_BROWSER_QUEEN=1, HOLD_ALL_GATES=1, MP4=1, truth dns lock, connection gatekeeper, packet field, sovereign time — all default on in posture().

queen-browser build flags

QUEEN_BROWSER_BUILD links AMOURANTHRTX spine — Vulkan SDL3 FieldWebPanel QueenBoot.comp — for sovereign RTX deployments without separate Gecko binary.

FieldWebPanel — in-engine UI

Hosts Field Primer and operator pages inside engine — navigation still passes packet field when networked.

QueenBoot.comp chrome

Aqua rose 2026 shader chrome — rhymes with RTX Zero panel aesthetic — visual covenant of Queen edition.

Hostess 7 Forever Watchguard

50/50 split deck motif — watchguard persona beside content — operator reminder that gates are held not hidden.

KILROY CONFIG_RTX_FIELD_DIE

Kernel field die parallels userspace FieldX86Die — FCC entropy feedback vocabulary shared Chapter 9.

proc kilroy_field

Syscall boundary telemetry — userspace Queen reads kernel field state in sovereign package deployments.

field/sovereign/ manifest

Sealed bundle: KILROY image, Queen browser or FieldFox, NEXUS services, Truth DNS, DHCP, time, panel configs, grep runbook.

Queen Forge packaging

Produces field package for bare-metal or QEMU — Grok Build secure channel inside manifest — not casual zip.

Grok Build secure channel

Build integrity inside sovereign package — operator verifies manifest before deploy.

Year 3000 sovereign stack vision

One stack: Queen plus NEXUS plus Truth DNS plus DHCP TIME plus ELLIE Last Host — web full size, gates never open without receipts.

Ladybird Servo millennium

Inherit field-queen-gates-seed.json — no Chromium — same held manifest when production ready.

Chromium family process awareness

field-queen-browser tracks chromium chrome brave edge names for awareness when operators run non-FieldFox binaries — gate doctrine still applies via NEXUS hooks where installed.

vulnerabilities_retired browser list

Optional toggles, telemetry chew, foreign DNS, pool NTP sole, MP4 optional — all retired classes named in seed.

Case study — WebRTC without gatekeeper

Legacy posture disabled WebRTC — sites broke silently. Queen holds WebRTC, scores peers, logs STUN — operator sees hole punch attempt in jsonl.

Case study — MP4 optional pack failure

Sites served H264 only — optional codec pack meant install Chrome. Queen mandatory in-tree — support ticket closes with FieldFox play confirm.

Case study — sovereign SQUIDGIE during browsing

Time dirty — navigation receipts mis-timestamped — honorability timeline wrong. Fix sovereign sync before blaming site malice.

Panel queen_verdict debugging

GATES_INCOMPLETE — inspect seed held flags. MP4_MISSING — codecs block. HOLD_ALL_GATES_OFF — env wrong. QUEEN_OFF — NEXUS_FIELD_BROWSER_QUEEN=0.

Operator covenant clause 6 — hold gates

Chapter 18 clause six — every capability exists, every wire exit earns receipt — Queen is covenant implementation.

HTTP/3 QUIC held

Modern transport not omitted — scored flows in packet field — no transport amputation.

COOP COEP isolation

SharedArrayBuffer gate requires policy headers — held with isolation, not disabled by default.

Notifications and Push

Sensor layer gates — push subscriptions egress scored — no silent background omit.

Third-party embeds

Iframes held — Fair Ad Guardian and gatekeeper score embed egress — amputating iframes breaks scholarly web.

MathML SVG scholarly web

Document gates preserve equations and diagrams — Field Primer itself benefits from same doctrine.

NEXUS bindings block in seed

connection_gatekeeper, packet_field, browser_awareness, honorability_db, fair_ad_guardian, thermal_governor, sovereign_time, field_dns_truth_resolver — all true in nexus_bindings.

Long-form primer — Queen as complete web with held gates

Field Browser Queen rejects the privacy-fork lie that amputation equals safety. Amputating WebRTC does not remove WebRTC from the web — it removes your ability to see WebRTC when sites demand it. Amputating MP4 codecs does not remove video — it ships users to Chrome where telemetry chew awaits. Queen holds gates: capabilities remain; egress earns receipts; operator remains final authority at keyboard.

Doctrine table in seed lists thirty gates held true — html_dom through legacy_plugins_surrogate. field-queen-browser.py gate manifest computes all_held only when every seed gate reports held. queen_verdict QUEEN_READY requires all_held, mp4_mandatory, video/mp4 in container list, hold_all_gates env on, queen_enabled on. Any other verdict is actionable: GATES_INCOMPLETE inspect seed; MP4_MISSING fix codecs; HOLD_ALL_GATES_OFF fix env; QUEEN_OFF enable queen.

WebGL WebGPU canvas_2d share gpu layer — Thermal Governor bills per context. Miners and abusive shaders become energy story, not silent fan spin. Disabling GPU APIs would break scholarly visualizations, maps, and tools — unacceptable amputation.

WebRTC realtime layer stays on — STUN TURN peers appear in packet field; Connection Gatekeeper scores intent per peer; camera microphone gates require consent plus scoring. Disable WebRTC privacy fork posture is explicitly named wrong in wiki and seed vulnerabilities_retired.

MSE EME media layer — MP4 H264 AAC mandatory in-tree via MSE Gecko FFmpeg path. EME Widevine held — license servers scored, not omitted. Tell users use Chrome for video is retired class.

Network layer websockets fetch xhr http2 http3 QUIC — all held, all scored. Storage indexeddb file_system_access shared_array_buffer — persistence without receipts was exfiltration runway; Queen requires receipt story.

Sensors geolocation notifications push camera microphone bluetooth usb serial gamepad — consent and gatekeeper. UI popups third_party_embeds — iframes held with Fair Ad Guardian and embed scoring — scholarly web needs embeds.

Document layer pdf_inline svg_mathml — equations and diagrams preserved. Legacy plugins Flash Java Silverlight via WASM surrogates — surface preserved, NPAPI VMs gone.

FieldFox ship-now — hardened Gecko, telemetry stripped, Truth DNS 127.0.0.1 lock, native messaging bridge, full codec tree. fieldfox-launch.sh with NEXUS_FIELD_BROWSER_QUEEN=1. field-queen-browser.py json for panel.

queen-browser in-engine — AMOURANTHRTX Vulkan SDL3 FieldWebPanel QueenBoot.comp Hostess7 Watchguard — QUEEN_BROWSER_BUILD path for sovereign RTX field without separate Gecko binary. Two tracks coexist; operators may ship FieldFox first while engine path matures on hardware targets.

NEXUS stack binding prose: Navigation generates packet field sentence; Connection Gatekeeper scores; Honorability DB consults site trust; Fair Ad Guardian classifies ad egress; Thermal Governor bills energy; Truth DNS ensures names resolve without foreign shortcut; Sovereign Time ensures timestamps defendable — SQUIDGIE blocks clean story. fieldfox-native-bridge.py wires browser events to gatekeeper. browser-awareness.py feeds live tab honorability to panel.

KILROY field package — Queen Forge bundles kernel browser services under field/sovereign/. KILROY 7.1.1-kilroy CONFIG_RTX_FIELD_DIE provides proc kilroy_field syscall boundary telemetry. Userspace Queen runs atop — one field sealed manifest Grok Build secure channel inside. Kernel FCC parallel Chapter 9 shares vocabulary with userspace CFL — not duplicate simulation, shared discipline.

Year 3000 vision in FIELD-BROWSER-2026.md — one sovereign stack Queen NEXUS Truth DNS DHCP TIME ELLIE Last Host — web does not shrink, gates do not open without receipts. Millennium Ladybird Servo inherit field-queen-gates-seed.json — no Chromium dependency — same doctrine when production ready.

Case study WebRTC without gatekeeper — legacy disabled WebRTC, sites broke, operator blind to STUN. Queen holds WebRTC, logs peers, archives verdicts — visibility returns.

Case study MP4 optional pack — H264 only sites failed until Chrome install. Queen mandatory in-tree closes support loop with FieldFox play confirm.

Case study sovereign SQUIDGIE during browsing — fix time before blaming site malice; navigation receipts mis-timestamp when clocks dirty.

Operator covenant clause six hold gates — Chapter 18 promise implemented in Chapter 21 tooling. Teach covenant and Queen same session — students see ethics become json verdicts.

Panel debugging queen_verdict — never treat verdict as decoration; grep panel json in CI for QUEEN_READY on release images intended for Queen posture.

Chromium family process names in seed — awareness when operators run non-FieldFox binaries; hooks apply where NEXUS installed; doctrine unchanged: hold gates, omit nothing.

nexus_bindings all true in seed — connection_gatekeeper packet_field browser_awareness honorability_db fair_ad_guardian thermal_governor sovereign_time field_dns_truth_resolver — panel should show each enabled when posture correct.

HTTP3 QUIC COOP COEP notifications push third_party_embeds mathml — each gate named in prior sections — Queen is encyclopedic surface area; operator job is hold all, not enumerate excuses to omit.

Honest rocks: seed and panel implemented; FieldFox launch implemented; queen-browser build path implemented; Ladybird production millennium; KILROY every host today field package path per Chapter 12 — QEMU bare metal honesty.

Complete gate manifest walkthrough

The seed enumerates gates in layer order: render (html_dom), script (javascript, wasm, service_workers), gpu (webgl, webgpu, canvas_2d), media (mse, eme), realtime (webrtc), network (websockets, fetch_xhr, http2_http3), storage (indexeddb, file_system_access, shared_array_buffer), sensor (geolocation, notifications, camera, microphone), device (bluetooth, usb, serial, gamepad), document (pdf_inline, svg_mathml), ui (popups, third_party_embeds), legacy (legacy_plugins_surrogate). Each id is queryable via field-queen-browser.py gate id — returns held, verdict HELD or UNHELD, layer, label. CI pipeline can loop all ids and fail build if any UNHELD.

Codec manifest walkthrough

codec_manifest returns mse_required true, mp4_mandatory true, container list including video/mp4, video codecs avc1 h264 hev1 vp9 av01, audio mp4a aac opus flac. Note string reminds MP4 H264 AAC in-tree via Gecko FFmpeg. Missing video/mp4 triggers MP4_MISSING verdict — treat as release blocker for Queen images.

field package sovereign directory layout

Queen Forge output field/sovereign/ typically bundles: KILROY kernel image with CONFIG_RTX_FIELD_DIE; initramfs or rootfs with NEXUS lib modules; FieldFox or queen-browser binary; field-services-2026 seed and data files; field-queen-gates-seed.json; sovereign-time and field-ntp keys state templates; panel TLS material; operator grep runbook markdown. Manifest sealed with Grok Build secure channel hashes — verify before bare-metal flash. Userspace Queen and kernel kilroy_field proc interface share field die vocabulary — read both when debugging dispatch issues on sovereign hardware.

WebRTC gate deep dive

WebRTC is three surfaces: signaling over HTTPS, STUN/TURN UDP, media DTLS-SRTP. Queen holds all three in gatekeeper scoring. Packet field sentences should show signaling host, STUN server IPs, peer connection duration. Honorability consults before sustained peer egress. Operator consent gate applies to camera microphone tracks. Privacy fork that disables WebRTC entirely hides STUN from jsonl — blind operator — rejected doctrine. Lab drill: open peer connection test page, grep packet field for STUN, archive gatekeeper verdict, confirm camera prompt held not pre-granted.

MP4 MSE pipeline deep dive

MSE attaches SourceBuffers for video/mp4; Gecko media demuxes; FFmpeg decodes avc1 and mp4a; audio routed to sink; video to compositor. Mandatory in-tree means CI plays sample mp4 without network codec download. Test vectors: baseline H264 AAC, fragmented mp4, adaptive stream if enabled. Failures map to codec_manifest or missing system libs — not tell user get Chrome.

EME DRM held deep dive

EME negotiates Widevine or platform CDM; license server HTTPS flows through gatekeeper same as ads. Omitting EME does not remove Netflix-style sites from web — it sends users elsewhere. Held means license URLs visible in packet field and honorability. Fair Ad Guardian may tag license server domain separately from CDN.

Thermal Governor and thermo ethic

Per-tab GPU contexts accumulate energy proxy scores — aligns browser with ThermoAccountant ethic from engine. Abusive WebGL miner tab should spike thermal governor score before silicon throttle — operator sees software receipt before hardware pain.

Native messaging bridge protocol sketch

fieldfox-native-bridge.py receives browser events — navigation start, navigation complete, permission prompt, peer connection — forwards to connection-gatekeeper.py for intent scoring; results written to packet field jsonl. Bridge is local-only — no cloud — consistent with NEXUS local-first covenant.

Millennium Ladybird Servo migration plan

FieldFox ships 2026. Ladybird Servo inherit field-queen-gates-seed.json without Chromium — migration means copy seed, verify gate ids map to new engine APIs, run same field-queen-browser.py gate checks, play same MP4 vectors, run same WebRTC lab. No gate omission during migration — if new engine lacks WebGPU temporarily, verdict is GATES_INCOMPLETE until caught up — not shipped as Queen READY.

KILROY userspace coordination

When field package boots KILROY kernel, proc kilroy_field exposes die telemetry at syscall boundary. queen-browser or FieldFox userspace reads telemetry for HUD or panel — same data_bus vocabulary as AMOURANTHRTX Chapter 8. FCC kernel parallel Chapter 9 clamps aggressive modes from entropy feedback — browser and kernel share stability language.

Queen operator weekly checklist

field-queen-browser.py json — QUEEN_READY. gates — all_held. codecs — mp4_mandatory. Truth DNS lock in profile. sovereign time USER_OK. Play MP4 sample. WebRTC test grep STUN. Archive panel slice. Review vulnerabilities_retired browser entries with team.

NEXUS_FIELD_BROWSER_QUEEN=1 ./lib/fieldfox-launch.sh
python3 lib/field-queen-browser.py json
NEXUS_INSTALL_ROOT=Queen ./build/rtx/bin/Linux/queen-browser --sovereign --queen

Navigation → Packet Field → Gatekeeper → Honorability → Thermo receipt
                ↑ Truth DNS (no Google shortcut)
                ↑ Sovereign Time (SQUIDGIE witness)

Operator drills

Study questions

1. What is difference between hold and omit for WebRTC?
2. Why is MP4 mandatory in-tree?
3. How does queen_verdict become QUEEN_READY?
4. Name five gates from field-queen-gates-seed.json.
5. How does KILROY /proc/kilroy_field relate to Queen userspace?
6. What is FieldFox vs queen-browser ship track?
7. How does sovereign SQUIDGIE affect browser perimeter?
8. What vulnerabilities_retired entries apply to browser class?
9. Describe navigation receipt stack bottom to top.
10. Why are legacy plugins WASM surrogates instead of removed?

Chapter 22 — Glossary →

Queen gate seed held flags are boolean — CI should fail if any gate sets held false accidentally in merge conflict.

field-queen-browser.py build command refreshes panel cache before screenshot releases — stale queen_verdict misleads users.

WebGPU compute shaders in browser share thermal governor with WebGL — both bill per tab.

Service worker cache API persistence triggers storage gate receipts — long-lived caches are exfiltration risk if unheld.

SharedArrayBuffer requires COOP COEP headers — Queen holds gate with isolation policy, not disable.

HTTP/3 QUIC UDP flows appear in packet field with distinct port habits — gatekeeper learns process association over time.

Third-party iframe embeds on scholarly sites are why popups and embeds gates exist — amputation breaks citations.

WASM surrogates for Flash preserve legacy homework sites — operator schools benefit from Queen surface preservation.

fieldfox-launch.sh should be invoked from documented install root — NEXUS_INSTALL_ROOT mismatch breaks native bridge paths.

queen-browser --sovereign --queen flags link engine time and DNS posture — document in sovereign field package README.

Grok Build manifest hash verification should be step one of Queen Forge flash procedure — skip is covenant violation.

proc kilroy_field reads align with data_bus slots vocabulary — kernel userspace debug pairs Chapter 8 and Chapter 21.

browser-awareness honorability updates on tab switch — panel live view requires NEXUS daemon running.

Connection gatekeeper ten-axis intent is local inference — not cloud reputation — consistent with local-first stack.

Fair Ad Guardian reduces need for blind ad blockers that omit network surface — holds junk without amputating first-party.

EME license server flows may coincide with CDN — separate scoring axes prevent conflated verdicts.

MathML in Field Primer pages dogfoods document gates — Queen should render this chapter's equations inline.

Gamepad API gate matters for browser games — held for completeness, scored like any device API.

Web Serial and WebUSB gates protect industrial operator tools — disabling would push operators to unsafe binaries.

Queen weekly checklist should be printed beside Chapter 18 covenant poster — ethics plus json verdicts.

Queen gate seed held flags are boolean — CI should fail if any gate sets held false accidentally in merge conflict.

field-queen-browser.py build command refreshes panel cache before screenshot releases — stale queen_verdict misleads users.

WebGPU compute shaders in browser share thermal governor with WebGL — both bill per tab.

Service worker cache API persistence triggers storage gate receipts — long-lived caches are exfiltration risk if unheld.

SharedArrayBuffer requires COOP COEP headers — Queen holds gate with isolation policy, not disable.

HTTP/3 QUIC UDP flows appear in packet field with distinct port habits — gatekeeper learns process association over time.

Third-party iframe embeds on scholarly sites are why popups and embeds gates exist — amputation breaks citations.

WASM surrogates for Flash preserve legacy homework sites — operator schools benefit from Queen surface preservation.

fieldfox-launch.sh should be invoked from documented install root — NEXUS_INSTALL_ROOT mismatch breaks native bridge paths.

queen-browser --sovereign --queen flags link engine time and DNS posture — document in sovereign field package README.

Grok Build manifest hash verification should be step one of Queen Forge flash procedure — skip is covenant violation.

proc kilroy_field reads align with data_bus slots vocabulary — kernel userspace debug pairs Chapter 8 and Chapter 21.

browser-awareness honorability updates on tab switch — panel live view requires NEXUS daemon running.

Connection gatekeeper ten-axis intent is local inference — not cloud reputation — consistent with local-first stack.

Fair Ad Guardian reduces need for blind ad blockers that omit network surface — holds junk without amputating first-party.

EME license server flows may coincide with CDN — separate scoring axes prevent conflated verdicts.

MathML in Field Primer pages dogfoods document gates — Queen should render this chapter's equations inline.

Gamepad API gate matters for browser games — held for completeness, scored like any device API.

Web Serial and WebUSB gates protect industrial operator tools — disabling would push operators to unsafe binaries.

Queen weekly checklist should be printed beside Chapter 18 covenant poster — ethics plus json verdicts.

Queen gate seed held flags are boolean — CI should fail if any gate sets held false accidentally in merge conflict.

field-queen-browser.py build command refreshes panel cache before screenshot releases — stale queen_verdict misleads users.

WebGPU compute shaders in browser share thermal governor with WebGL — both bill per tab.

Service worker cache API persistence triggers storage gate receipts — long-lived caches are exfiltration risk if unheld.

SharedArrayBuffer requires COOP COEP headers — Queen holds gate with isolation policy, not disable.

HTTP/3 QUIC UDP flows appear in packet field with distinct port habits — gatekeeper learns process association over time.

Third-party iframe embeds on scholarly sites are why popups and embeds gates exist — amputation breaks citations.

WASM surrogates for Flash preserve legacy homework sites — operator schools benefit from Queen surface preservation.

fieldfox-launch.sh should be invoked from documented install root — NEXUS_INSTALL_ROOT mismatch breaks native bridge paths.

queen-browser --sovereign --queen flags link engine time and DNS posture — document in sovereign field package README.

Grok Build manifest hash verification should be step one of Queen Forge flash procedure — skip is covenant violation.

proc kilroy_field reads align with data_bus slots vocabulary — kernel userspace debug pairs Chapter 8 and Chapter 21.

browser-awareness honorability updates on tab switch — panel live view requires NEXUS daemon running.

Connection gatekeeper ten-axis intent is local inference — not cloud reputation — consistent with local-first stack.

Fair Ad Guardian reduces need for blind ad blockers that omit network surface — holds junk without amputating first-party.

EME license server flows may coincide with CDN — separate scoring axes prevent conflated verdicts.

MathML in Field Primer pages dogfoods document gates — Queen should render this chapter's equations inline.

Gamepad API gate matters for browser games — held for completeness, scored like any device API.

Web Serial and WebUSB gates protect industrial operator tools — disabling would push operators to unsafe binaries.

Queen weekly checklist should be printed beside Chapter 18 covenant poster — ethics plus json verdicts.

Queen gate seed held flags are boolean — CI should fail if any gate sets held false accidentally in merge conflict.

all_gates_held = WebRTC + EME + COOP/COEP + thermo_per_context

grep -r 'QUEEN_READY\|QUEEN_BROWSER_BUILD' Navigator/