nordisk/facett

facett — Test-Matrix Fat-List Inventory

UPDATE 2026-07-22 — this inventory is now partly HISTORY. Read ## Round 2026-07-22 at the bottom first: the ~10 zero-cell panes have been backfilled, the P0 loose-viewport-multiple class is closed (including the canonical SCREEN_BOUND_K, which was already 1.0 in src — the tests were still capping at 6-8x), the vacuous near_plane_probe.rs and the file-existence composite emit are fixed, and the crate counts below are stale. The LAW and the WEAK-oracle taxonomy are unchanged and still govern.

Exhaustive enumeration of EVERY #[test], every functional_status / facett_core::testmatrix::emit* emitter, and every snapshot / robot-UI / golden-image surface in the facett workspace — judged against the TWO-AXIS LAW (input coverage × oracle exactness) from nornir/.nornir/agent-ui-test-fixing.md.

Scope: the 26 workspace members in facett/Cargo.toml (.claude/worktrees copies and target/ are excluded). Generated by read-only analysis of the actual assertion bodies — not from test names.

The law, in one line: every check is assert(invariant(f(input))). It is WEAK if it tests only ONE input value (Axis A fail) OR if its threshold is a loose multiple / tolerance / drew()-only / lit_px>0-only / literal-true rather than the EXACT contract bound (Axis B fail). The canonical failure was facett-map3d's SCREEN_BOUND_K = 4.0 + a half_h*8 extent cap that tolerated a triangle 8× the viewport while every green test sailed past the smear.

Summary table (per-crate counts)

Test counts are the per-crate #[test]/#[tokio::test] totals; emitter counts are facett_core::testmatrix::emit* call sites; WEAK is the count of flagged checks per the fix list at the bottom. Examples (fn main binaries: robot_drive.rs, quality_matrix.rs, *_demo.rs, selftest.rs, render_png.rs, nornir-bench.rs) are NOT counted as tests.

The emitter API (facett-core seam)

facett-core/src/testmatrix.rs wraps nornir_testmatrix::functional_status so leaf crates call facett_core::testmatrix::emit(component, check, ok, detail) (or emit_render(component, vertices, geometry) → ok = vertices>0 && geometry>0, or emit_non_blank(component, ratio, min_ratio, geometry) → ok = ratio>=min_ratio && geometry>0). All gated #[cfg(feature="testmatrix")]; release builds compile them out (no nornir-testmatrix dep edge). The umbrella and demo crates reach it via the re-export facett::core::testmatrix::emit*.

testmatrix.rs itself has one self-test (emit_render_writes_green_and_red_rows) that points the sink at a temp file and asserts a green + 3 red rows land with the right PASS/FAIL status — an inject-and-assert of the RED/green contract (STRONG).

Per-crate inventory

facett-core (~170 tests, 12 emitters)

The render backbone is the strongest in the workspace: gatling-vs-sequential and bucketed-vs-brute-force rasters are asserted byte-identical, blend is exact Porter-Duff (±1), SDF coverage is swept over aa∈{0.5,1,2,4} with exact band bounds. The WCAG theme gate (look/tests.rs) sweeps all 5 presets × light/dark with exact contrast bounds (body≥4.5, dim≥3.0, ui≥3.0, status≥4.5).

Tests (by file, compressed)

• a11y.rs (3): semantics button label/value; list-item selection; stable id is key-derived not index.
• caps.rs (6): NONE/ALL flags; builders flip exactly one; cuttable⇒copyable; const chain; JSON has all 10 flags.
• clip.rs (5): DataColumns→TSV; zero-copy Arc identity; typed transfer; image payload to viewer; text universal fallback.
• clipboard.rs (3): rows→TSV with/without header; poll decodes Copy/Paste/Cut in order.
• deckfx.rs (7): palette cycle wraps; pure next; fuzzy name resolve; index wrap; glow 0-when-off & bounded (mid swept); clear override; raven launch→perch ≤2px.
• edges.rs (4): spline endpoints exact; curvature lifts midpoint >5px; zero-curvature ≤1e-2 straight; soft edge Full>None>0 verts.
• effects.rs (3+): easings hit f(0)=0/f(1)=1 + clamp; ease_out_back peak>1; raven perch ±2px; particle burst determinism.
• focus.rs (5): hint labels deterministic; revolver IDENTITY when off; centres target <1px; directional move+hint; motion monotonic clamps.
• harness.rs (4): stamp shape; seq monotone; kind tags distinct; headless_render → drew()-only (state nodes=2 exact).
• labels3d.rs (4): subpixel snap; smoothing alpha 0/0.5/1; no bob over 20 frames (<1e-6); no-prior == snapped.
• lib.rs (9): scene builds; force layout finite/bounded; hash_color stable; deckfx off default; cycle walks Theme::ALL; raven launch/perch; palette picker no passive pin (regression); override applies in ui pass.
• nav.rs (5): zoom keeps pivot; zoom clamps; fit centres scale≈3.2; spatial focus nearest-in-direction; on-axis beats diagonal.
• overlay.rs (3): glass degrades Tint/Opaque; tint stronger on light; guest render verts>0-only (masked region NOT pixel-verified).
• rabbit.rs (4): outline 5 loops/silhouette 4; deterministic byte-identical; fits design box, ears up; mesh verts>100/tris>50/normals/indices valid.
• scroll_engine.rs (6): smooth converge ≤0.5; determinism; instant jump; momentum decays; fractional offset decoupled; clamps to extent.
• theme.rs (2): set/read round-trip; unique names + fuzzy lookup.
• trace.rs (2): writes JSONL with real payload (vertices==412); stamp shape. (uses /tmp — trace-sink test.)
• look/keymap.rs (5): every action bound in win/mac/dev; Copy same chord; mac/win differ on line-nav; serde+remap; consume only bound chord.
• look/metrics.rs (3): 4pt grid; interact height ≥24; device radii tight.
• look/oklch.rs (5): white/black extremes; contrast 21±0.1; symmetric & self==1; lighten raises luminance; blue octant.
• look/palette.rs (2): widget states progressively lighter; no override_text_color.
• look/policy.rs (3): effects None disables decorative; frosted→tint no blur; tint forced opaque.
• look/scroll.rs (4): windows solid/visible; macos floating/dormant invisible; device always opaque; to_scroll_style copies fields.
• look/tests.rs (8): WCAG gate all 5 presets L+D (exact bounds); presets distinct; serde+remap; apply publishes legacy palette; from_os fallback; device effects-off; win/mac parity; legacy bridge carries roles.
• look/typography.rs (2): scale steps monotone; text styles cover roles Heading>Body>Small.
• render/backend.rs (3): cpu_only/force_cpu→CpuVello; gpu feature-gated.
• render/camera.rs (3): input-feel constants; 2D affine ±1e-6; 3D orbit math exact (eye radius, near wider, behind culled, NEAR_PLANE==0.02, depth∈[0,1]).
• render/cpu/mod.rs (7): parallel raster bit-identical to sequential (lit>50000); ybucket byte-identical to brute force; blend source-over exact; premul round-trip ±1; ybucket span exact; circle lit center; ring band round-trips seam.
• render/cpu/scissor.rs (2): clip confines every vertex ±1e-3; ink_outside_rect==0.
• render/cpu/sdf.rs (7): coverage monotone; circle band >0.99/<0.01/edge 0.5±0.05; ring hole; markers differ; quad dispatch; line width edge 0.5±0.1; butt flush/round overshoots.
• render/gpu/buffer.rs (5): partition within budget never splits a way; oversized way own chunk; rebase relative; budget headroom; empty→none. (pure math, no GPU)
• render/gpu/mod.rs (1): CULL/DRAW wgsl byte-identical to facett-map (string compare).
• render/gpu/offscreen.rs (6): scissor math exact (covers/pinned/intersection/disjoint/callback-info); offscreen format pair. (no GPU)
• render/gpu/sdf_pipeline.rs (1): uniform/instance sizeof + WGSL contains. (no GPU)
• render/gpu/types.rs (2): struct sizes match WGSL; color32→f32 channels.
• render/layer.rs (3): z-order back-to-front; stable tie-break; empty no top.
• render/prim.rs (2): typed prims lower to right shape (inner clamped); line bounds inflate by hw+aa.
• tests/a11y.rs (2, kittest+AccessKit): button node queryable value==42; list-item selection toggle.
• tests/render_callchain_matrix.rs (7 + 1 wgpu): stage1 lower (swept r×aa); stage2 camera vs golden; stage3 layer order; stage4/5 SDF swept; stage8 scissor 0-ink; stage9 backend decide; raster matrix ~2400-case byte-identity sweep; stage10 GPU offscreen non-blank + CPU parity (wgpu).
• tests/gpu_sdf_parity.rs (1, wgpu): GPU vs CPU; ink>1000, circle red-dominant, mask disagreement <0.04.
• tests/sdf_primitives.rs (5, CPU): circle band swept; alpha monotone edge 0.5±0.06; ring hole swept; markers geometry; cpu canvas lit circle (lit>100).
• tests/thick_line.rs (4, CPU): line width swept edge 0.5±0.12; AA monotone; caps butt/round swept; diagonal band 3..=14px (lit>100).

Emitters

Snapshot/robot/golden

• kittest+AccessKit: tests/a11y.rs (semantic-tree query, no image).
• wgpu device: gpu_sdf_parity.rs, render_callchain_matrix.rs::stage10 (graceful skip w/o adapter; FACETT_REQUIRE_GPU=1 hard-fails parity).
• No golden-image PNG diffs. "Byte-identity" proofs are self-referential (gatling-vs-sequential, FNV fingerprint of two composites), not stored goldens.

facett-graph (11 tests, 9 emitters)

Tests

• src/depgraph.rs: toposort_columns_and_state — deps order left (cols[2]<cols[1]<cols[0]); state nodes=3/edges=2/cols=3.
• src/lib.rs: builds_scene_from_labeled_edges — 3 nodes, 2 edges, nodes[0]=="Person".
• tests/a11y.rs (kittest): nodes are Button-role by label; clicking "beta" selects then deselects.
• tests/callchain_matrix.rs: build counts/colours (72 cases); layout finite-in-rect circular/force (>300 cases); edge endpoints==node centres; render matrix 2304 cells exact state; empty vs populated separable.
• tests/robot_callchain.rs (wgpu): renders non-blank & confined (body_ratio>0.01); final PNG blob (bytes>1000).

Emitters

Snapshot/robot

• kittest+AccessKit: a11y.rs. wgpu golden PNG written (graph_final.png, byte-gated, skips w/o GPU): robot_callchain.rs.

facett-graph3d (23 tests, 4 emitters)

Tests

• src/lib.rs: sphere 200 nodes radius≈1±0.05; force 60 finite in [-1.05,1.05]; helix n==50; labels show@8 hide@200; label anchors ≤2px over 12 frames.
• src/logo3d.rs: logo mesh verts>100/tris>50; headless lit+depth (tris>50, clock==1.0); injected clock reproducible.
• tests/a11y_determinism.rs (kittest): canvas yaw==0.6 AccessKit value; clock determinism + steps.
• tests/gpu_offscreen.rs (wgpu): logo non-blank via offscreen+depth+blit (ratio>0.02).
• tests/rabbit3d_snapshot.rs (wgpu golden): lit+depth, ratio>0.05, shades≥8, golden PNG >5000 bytes.
• tests/render_callchain.rs: sphere unit shell (n∈{2,50,200,1000}, ±0.06); helix unit band; force finite+spread; state_json model (3 layouts×5 topos); ui drew per layout; robot yaw==1.4; robot non-blank; logo mesh real solid (3 depths); logo cpu lit; matrix ≥1000 cases; gpu geometry mirrors mesh.

Emitters

Snapshot/robot

• kittest+AccessKit: a11y_determinism.rs, render_callchain.rs (robot tests).
• wgpu golden PNG: rabbit3d_snapshot.rs. wgpu offscreen: gpu_offscreen.rs.

facett-graphview (18 tests, 1 emitter / 11 call sites)

Raw render engine (no Facet). No kittest/golden — its "robot" surface is the RGBA→ColorImage texture handoff.

Tests

• src/backend.rs: cpu_only→CpuVello; force_cpu overrides gpu; gpu only when feature on; env override forces cpu.
• src/l0.rs: model→3 quads/2 lines (SQUARE, fill ±1e-6, centers in 640×480); l0 path renders non-blank (rgba len exact, lit>0, colours>3).
• src/lib.rs: cpu render non-blank (colours>3); camera fit centres world ±1.0.
• tests/render_callchain.rs: world bounds contain chips (5 topo×{1,2,17,256}); camera fit clamps zoom [0.05,4] centre±1.0; project exact affine ±1e-4; decide monotone; lower counts==nodes/edges + attrs; cpu reference non-blank; l0 lane non-blank; matrix ≥1000 cases (raster stage = buffer-shape only); color dim+egui roundtrip; frame→non-blank egui texture (40-node star).

Emitters

Snapshot/robot

• None (no kittest/golden). examples/render_png.rs is a demo binary, not a test.

facett-geomap (43 tests, 12 emitters)

Tests

• src/lib.rs: mercator roundtrip ±1e-6; fit centres data; zoom/pan move viewport; state both layers; headless draws points+hotspots; empty hint; with_ways adds basemap+refits; point-only zero ways; basemap under points; caps scalable/themeable/resizable.
• src/osm2d.rs: grid culls to viewport (==1/==4 exact); zoom-to-cursor anchor fixed ±1e-6; zoom reduces visible; pan moves centre; local/remote ctors drawable (2000 pts); point stride grows zooming out; way LOD tightens; caps navigable; inertial pan glides+decays; gpu opt-in (feature); from_geometry; zoom tick eases; high-zoom clip preserves on-screen segment; dense fit caps to 40k budget; close-up draws every visible; empty hint.
• src/osm2d/clip.rs: polyline inside unchanged; extreme vertex (1e8) bounded ≤101; leave/reenter 2 runs; polygon inside unchanged; polygon extreme bounded; clip stage matrix (3 far × 3 in-rect).
• tests/a11y.rs (kittest): pane Image value==4.0; Malmö Button==320; Göteborg==210.
• tests/basemap_snapshot.rs (wgpu golden): ways 5/filled 5/ears 2; ratio>0.05; golden PNG >5000.
• tests/callchain_matrix.rs: camera roundtrip+anchor (ok==cases); fit contains data; point grid cull exact kept==⌈n/stride⌉; LOD stride monotone+budget; render matrix ≥1000 cells; empty vs populated separable.
• tests/robot_callchain.rs: pan/zoom changes state (z1>z0, vis1<vis0); pane queryable; non-blank confined (body>0.5, leak<0.02).

Emitters

Snapshot/robot

• kittest+AccessKit: a11y.rs, robot_callchain.rs. wgpu golden PNG written (never diffed): basemap_snapshot.rs.

facett-map (34 tests, 16 emitters)

Tests

• src/lib.rs: building height from tags (height/levels/units/none, multi-value exact); mercator centre; point-only map; way classify; state breaks down ways layer; filled silhouette; headless draws points+ways; filled ways; empty hint; index partitions by LOD.
• src/l0_points.rs (wgpu): points lower to core SDF circles (radius 1.3 exact); l0 render non-blank or graceful skip.
• src/style.rs: water/landuse area+fill vs roads line; road class widths motorway>primary>residential; palette water≠green.
• src/tessellate.rs: convex quad→2 tris area==4; concave area==shoelace (no spill); degenerate rings graceful.
• tests/a11y.rs (kittest): pane Image node value==3.0.
• tests/callchain_matrix.rs: projection monotone f32==f64; classify+ring-close fill; tessellation area==true (4 scales); LOD partition+cull monotone; fit bbox contains all; render matrix ≥1000 cells; empty vs populated separable.
• tests/rabbit_snapshot.rs (wgpu golden): ways 5/filled 5/ears 2; ratio>0.05; golden >5000.
• tests/render_proof.rs: populated non-blank (ratio≥0.01); empty detected as blank (catch_unwind is_err); basemap ways non-blank; multi-feature filled areas (water>0.05, green>0.005); tiny room non-blank.
• tests/robot_callchain.rs: pane queryable (value==point count); non-blank confined (body>0.5, leak<0.02).

Emitters

Snapshot/robot

• kittest+AccessKit: a11y.rs, robot_callchain.rs. wgpu golden PNGs written but NEVER diffed (only ratio/coverage gates): rabbit_snapshot.rs, render_proof.rs.

facett-map3d (57 tests, 20 emitters) — CANONICAL FAILURE REGION

src/lib.rs:504 still has const SCREEN_BOUND_K: f32 = 4.0; and the frustum_cull emit (lib.rs:963) caps max_extent_px <= half_h*8 + 1 — i.e. the exact half_h*8 loose multiple the law calls out. Every smear-guard test (no_spokes, clip_pipeline, matrix_grid, golden_248, the legacy frustum_scissor at half_h*6) uses the same loose viewport multiple, not the ~2×viewport contract bound.

Tests (compressed)

• src/camera.rs: eye on sphere r==4; presets known angles; orbit clamps; dolly clamps; damping converges; view_proj orders depth; perspective culls behind. (single-pose each)
• src/extrude.rs: ring→prism known size (±5e-3 of metric height); line→flat ribbon; rabbit→4 prisms; deterministic; concave caps no starburst; huge ring lies flat; buildings low+varied; flat cover no z-fight; ground lift stratifies; empty→terrain only.
• src/gpu.rs (wgpu, rect math): scissor covers/pinned/intersection/disjoint/callback-info — exact rect equality.
• src/lib.rs: N ways→N prisms in rect; buildings visible (span>40px); extrude height; synthetic rabbit; lit depth-sorted; injected clock; headless draws; local/remote ctors; from_geometry; empty terrain; orbit keeps visible; presets distinct; state_json camera; clip_poly confines to rect.
• tests/clip_pipeline.rs: dolled-in ink==0 only with fix (max_extent ≤ s*8); near-clip splits straddles; near-clip recovers geometry; project finite; cull monotone; shade ≥3 shades; depth-sort monotone; scissor 0-ink; composite PNG blob (lit>500, leak<0.0005).
• tests/frustum_scissor.rs: frustum bounded (ext ≤ half_h*6); paints no ink outside rect (leak<0.0005).
• tests/golden_248.rs (golden+sensitivity): at 248°, ink==0, lit>0, perceptual diff ≤2%, fixed_extent ≤ scale8, broken_extent > fixed1.4, injected wedge trips.
• tests/gpu_depth.rs (wgpu): depth buffer occludes (near_wins>0.8); depth-off breaks occlusion that depth-on fixes.
• tests/gpu_scissor.rs (wgpu): GPU path no ink outside rect (leak<0.0005).
• tests/matrix_grid.rs: ≥1000 pose×geometry cases; each finite & no_smear (≤scale*8+1) & front_of_eye & ink==0.
• tests/near_plane_probe.rs: NO ASSERTIONS — only eprintln diagnostics (vacuous).
• tests/no_spokes.rs: 4 presets×16 clocks; worst extent < half_h*8.
• tests/render_proof.rs (wgpu): lit+depth golden (ratio>0.05, shades≥8, PNG>5000).
• tests/robot_ui.rs (robot+wgpu): drives orbit/dolly to failing pose; lit>300, leak<0.0005, ground-clamp elev≥1.0.
• tests/zfight.rs (wgpu): fixed ground no flicker (ratio<0.02) vs coplanar control (>fixed+0.05).
• examples/selftest.rs: main binary (not a test).

Emitters

Snapshot/robot

• wgpu golden-image: golden_248.rs (true perceptual diff + sensitivity control — the ONLY real golden tripwire). render_proof writes a PNG but never diffs it.
• robot-UI: robot_ui.rs (drives camera, reads state_json + margin band).
• wgpu device: gpu_depth, gpu_scissor, zfight, golden_248.

facett-pipeline (27 tests, 14 emitters)

Tests

• src/model.rs: status roundtrip; builders/lookups (counts 0/1/1/0, rows 10); metrics emptiness; adapter→model (error "boom").
• src/lib.rs: counts+state; edge phase wraps [0,1); status glow per state; back-compat builders; renders headlessly; fit frames DAG + zoom culls; zoom-to-cursor anchor fixed <1e-2; pan exact + nav state; per-node throughput 3400/lag 2.5.
• tests/a11y_determinism.rs (kittest): DAG node Button value==640; clock determinism; idle flag.
• tests/callchain_matrix.rs: toposort monotone cycle-safe (>150 cases); scene x-monotone rows separated; camera fit/zoom/pan/cull; status counts/errors/idle; render matrix ≥1152 cells exact state; empty vs populated.
• tests/knut_facett_matrix.rs: knut connector 36 cells (counts cross-checked vs knut ViewerState, progress 10/16==0.625 exact); failed node detail surfaces.
• tests/robot_callchain.rs (wgpu): click selects stage; non-blank confined (body>0.3, leak<0.05); final PNG (bytes>1000).

Emitters

Snapshot/robot

• kittest+AccessKit: a11y_determinism.rs, robot_callchain.rs. wgpu PNG (byte-gated): robot_callchain.rs.

facett-syschart (15 tests, 10 emitters)

Tests

• src/lib.rs: select toggles; set badge/detail; state carries nodes/edges/selection; headless draws + detail; caps.
• tests/a11y.rs (kittest): node Button badge value==3/7; click selects by stable id then toggles off.
• tests/callchain_matrix.rs: placement finite/confined/monotone (>150 cases); edge endpoints resolve by id; selection id-keyed; render matrix ≥1008 cells; empty vs populated.
• tests/robot_callchain.rs (wgpu): click selects node; non-blank confined (body>0.01, leak<0.05); final PNG (bytes>1000).

Emitters

Snapshot/robot

• kittest+AccessKit: a11y.rs, robot_callchain.rs. wgpu PNG (byte-gated): robot_callchain.rs.

facett-demo (50 tests, 12 emitters)

The control/robot/mega matrices are exemplary (file-channel + AccessKit robot drive across every component × data × palette with exact state-pointer asserts). Weak spots are the PNG byte floors and the half_h*8 spoke cap inherited from map3d.

Tests (compressed)

• tests/gpu_chunk.rs (wgpu): chunked upload, each chunk ≤ forced cap.
• tests/mega_matrix.rs: component×data×palette all-cells-pass (≥224 cells); coverage gate matrix==legend (26); catches a fake; per-palette screenshot proof (PNG>5000).
• tests/osm3d_city.rs (wgpu): frames visible city (ratio>0.05); framing beats whole-country (×3).
• tests/osm3d_shot.rs: height stats vary (PNG saved, no pixel assert).
• tests/osm3d_spoke.rs: never projects spoke faces (worst < 8*half_h).
• tests/osm3d_zfight.rs (wgpu): ground no green flicker (<0.02).
• tests/osm_tabs.rs: 2D+3D tabs non-blank (geom/verts/visible >0).
• tests/region_picker.rs: 3 presets→clip args; cache-hit non-blank; host swaps region.
• tests/control_matrix.rs: file-channel drives every tab+verb (state-pointer asserts, coverage gate, JSONL roundtrip); wrong expectation→red; known commands routable.
• tests/robot_demo.rs (kittest): AccessKit drive every component+control (exact pointers, L0 oracle row); wrong expectation→red.
• tests/snapshot.rs (wgpu golden): populated demo PNG (size + >5000 bytes).
• tests/sens_check.rs: #[should_panic] oversized single-buffer upload.
• src/*: control roundtrip; synthetic_sdp DAG valid+wave monotone+deterministic; graphview tab L0 non-blank; data density hotspots + manual pages; osm_tabs both viewers; region_picker mappings+cache+polygon clip; lib demo_state every component populated + look switcher + preset colour + deck cycle + legible selector.

Emitters

(control_matrix.rs and robot_demo.rs write nornir_testmatrix::TestResultRows to JSONL directly, not via emit.)

Snapshot/robot

• kittest+AccessKit: robot_demo.rs. file-channel robot: control_matrix.rs.
• wgpu golden PNG (byte-gated only): snapshot.rs, mega_matrix screenshot proof. wgpu pixel-content: osm3d_city, osm3d_zfight.

facett (umbrella, 27 tests, 8 emitters)

Tests

• tests/coherence.rs: every component consumes active theme; representative chord same in every context; published keymap read identically.
• tests/compliance.rs: every component themeable; caps match 6-tuple matrix; registry covers all 19.
• tests/composition.rs: dataframe over map stays interactive; glass degrades per preset.
• tests/matrix.rs: mega matrix every component draws (geom>0); empty render no-panic; deck composes 4 states; deck caps additive; deck routes Copy→active (exact TSV); sci-fi renders all; state_json shapes exact.
• tests/perf.rs: graph/map render scale (drew); table scale (print-only no assert); osm read #[ignore].
• tests/three_preset.rs: all 5 presets pass contrast L+D; coherent chords; device effects-off diff; device soft edges fewer verts; device sunlight legible >12; deterministic two frames.
• tests/testmatrix_wiring.rs: rows roundtrip exact; summary tally (3/1/1); render matrix shows ✗.

Emitters

Snapshot/robot

• None — all headless ctx.run/headless_render + tessellation counts + state_json. No kittest/golden/PNG in this crate.

Small component crates (condensed)

facett-arrow (3): scene_from_edge_batch (3 nodes/2 edges); table maps cols/rows; missing_id_column errors. No emitters/snapshots.

facett-card (12 + 1 a11y): field kind inference (5 variants); subcards nest counts; read render state (8 fields exact); copy nested JSON; copy↔paste roundtrip; paste rejects garbage; scale clamps (boundary); caps; edit-mode toggle; themed render (drew()-only single theme); empty card. a11y kittest: chip Label value==3.0 + 2 hugin labels. Emitter a11y.rs:83 CardView/fc4_chip_and_avatar_nodes (exact, single fixture).

facett-console (9 + a11y): ANSI split runs; plain line one span; scrollback ring drops oldest (max 3); copy plain; animation deterministic (±1e-6); caps+serde; headless draws 40 lines; themed render (drew()-only single preset). a11y kittest: input value=="cargo test --all", scrollback value==2.0. Emitter a11y.rs:52 exact.

facett-docview (15): parse intrinsic size; rasterize non-blank (dark>1000); svg text renders (dark_ink>200); empty fontdb drops text (bug pin dark==0); clamp to MAX_TEX_DIM; state pages/toc/zoom; jump+clamp; zoom steps+fit; caps scale==zoom; headless render; render after jump; from_svgs skips bad; empty hint; lazy band fetch (0<fetched<100); lazy jump fetches target. No emitters/snapshots.

facett-filedialog (12 + a11y): sort dirs-first; arrow nav+confirm; confirm dir navigates; type filter; pick-folder dirs only; open-many; save typed name; cancel; copy cursored; caps+serde; headless; keymap ArrowDown moves cursor (real UI). a11y kittest: rows Button, selected Toggled::True. Emitter a11y.rs:65 exact, single fixture.

facett-form (14): valid default; reject bad (3 field errors); ymd accept/reject (5 values); dirty tracking; mark clean; copy JSON; paste roundtrip; paste rejects garbage; caps; cut keeps; take_submitted None-before-save (negative-only); headless clean/errors/dirty-after-paste. No emitters/snapshots.

facett-grid (67 + a11y/perf/snapshot): the flagship — type detection 100k; sort+multisort invariants; visible window 1M (count<64); selection→TSV exact; copy follows sort; scale row height; filter; caps; state contract; headless 5000 rows; themed all palettes (drew()-only); full edit lifecycle (begin/commit/invalid/escape/text, GridChange exact); validate all kinds; GUI commit end-to-end; zero-copy Arc identity; typed column copy/paste; keymap ArrowDown. arrow.rs: type maps + ISO date/timestamp (all precisions) + null. condfmt.rs: normalize/lerp exact, heat_color a()> relational. data.rs/selection.rs/sort.rs/viewport.rs: exact group/TSV/perm/window math. a11y kittest: header Button + cell value==20.0 + sort Toggled. perf.rs: window constant across sizes; timing slack thresholds; ingest <5s. snapshot.rs: wgpu golden — byte-floor only, no pixel diff. Emitters a11y.rs:60/85 exact; snapshot.rs:106 Grid.snapshot/flagship_png_non_trivial WEAK.

facett-icebergview (8): newest snapshot first; time-travel changes rows; state full list; paging windows (+ across batches); headless; empty hint; caps. All multi-value/exact. No emitters/snapshots.

facett-jobview (8): status roundtrip+active; default sort newest; toggle sort; kind filter; counts+state; fmt_elapsed buckets (5 exact); pull_source asserts pre-pull empty only; headless. No emitters/snapshots.

facett-menu (9): fuzzy subsequence; fuzzy prefers contiguous (relational >); rank filters disabled; rank keywords; cursor wraps; invoke+close; state hits+invoked; builders compose; disabled never matched. No emitters/snapshots/render.

facett-osm (6): decode point/linestring exact; read synthetic geoparquet; classify polygon vs line; read synthetic ways; read real Liechtenstein ways #[ignore] (>1000); read real nodes #[ignore] (>100000). No emitters/snapshots.

facett-plot (1): state_json reports series (line, 3 points). Thinnest crate — single chart, no Bars/empty/render. No emitters/snapshots.

facett-plotters (37 + 5 a11y): boxplot percentile (numpy type7), quartiles, outliers, empty, single, csv; candlestick classification, y-mapping, x-centers, bar roundtrip, range, csv; heatmap tile no-gaps, bounds row-major, range ignores nan, csv; ramp lerp/stops/clamp/degenerate; treemap area partition, proportional ±0.2, skip zero/neg, empty, single, disjoint; violin kde lengths, nonneg+peak, integrates ~1 ±0.05, empty, silverman, csv. 5 a11y kittest emitters (treemap/box/heatmap/candle/violin) all exact 2-value. Emitters a11y.rs:37/66/91/120/148 all STRONG.

facett-pop (3): totals (done 60/total 110); a11y rows progress fractions (0.5/1.0); idle flag two-state. Emitters a11y.rs:35/57 both exact 2-value (STRONG).

facett-table (14 + a11y): truncate cap; state shape; caps; copy all/selected (exact TSV); row identity index vs RowId; select toggles; cut==copy read-only; paste rejected; empty copies nothing; scale clamps. a11y kittest: selected Toggled::True/unselected False; row label no collision. Emitters a11y.rs:57 exact; a11y.rs:85 single-condition.

facett-video (8): frame count/bounds; playback advances injected clock (frame 12); loops (frame_index<10 loose); seek clamps; roi roundtrip; copy frame→viewer Image; state+caps; headless draws. No emitters/snapshots.

⚠ WEAK ORACLES — fix list

Every check below fails Axis A (single input) and/or Axis B (loose threshold / drew()-only / lit_px>0-only / literal-true / byte-floor). Grouped by severity. Actionable: tighten the threshold to the exact contract bound and/or sweep the input boundaries the function's own branches define, then prove the oracle goes RED on the broken code before claiming it fixed.

P0 — loose viewport multiples (the canonical smear class)

• facett-map3d/src/lib.rs:504 — SCREEN_BOUND_K = 4.0 is STILL the canonical-failure value; the screen-bound rect = viewport ± 4·half_h per side ⇒ admits a clipped face up to 8·half_h. Replace with the viewport bound (≈2·half_h) and justify the number.
• facett-map3d/src/lib.rs:964 (frustum_cull emit) — cap half_h*8 + 1 tolerates a triangle 8× the viewport. The exact contract is "no painted face exceeds the widget rect" → cap ≈ 2·half_h.
• facett-map3d/tests/no_spokes.rs:61/64 — worst < half_h*8 (the comment even says "never spans 4×" but tests 8×). Tighten to viewport.
• facett-map3d/tests/matrix_grid.rs:152/212 — no_smear cap scale*8.0+1.0 across all ≥1000 cases (Axis A is strong; Axis B blind — the exact 2026-06-21 failure mode: 1000 values × loose oracle = green-on-broken).
• facett-map3d/tests/golden_248.rs:284/340 — fixed_extent ≤ scale*8; sensitivity ratio broken > fixed*1.4 is a slack multiplier.
• facett-map3d/tests/clip_pipeline.rs:158/161/251 — caps s*8 / 360*8.
• facett-map3d/tests/frustum_scissor.rs:86 — legacy ext ≤ half_h*6.
• facett-demo/tests/osm3d_spoke.rs:61 — worst < 8*half_h (inherits the map3d cap on REAL OSM data — same loophole, real fixture).

P1 — literal-true / file-existence emits (matrix row decoupled from the real check)

• facett-map/tests/callchain_matrix.rs:224 — earclip_area_equals_shoelace emit ok is the literal true; the matrix row is unconditionally green (asserts gate via panic, but the row carries no boolean).
• facett-graph3d/tests/render_callchain.rs:45 — MANY call sites (sphere/helix/force/state_json/logo_mesh/matrix_cases) pass literal true; the matrix reads green regardless of the live oracle.
• facett-graphview/tests/render_callchain.rs:52 — most of the 11 call sites pass literal true (only cpu/l0 non-blank + matrix *_ok_all + texture carry the real ok).
• facett-map3d/tests/clip_pipeline.rs:407 — composite emit ok = png_path.exists() (a file was written), far weaker than the test body's lit_px>500 + leak<0.0005. Emit the real pixel result.
• facett (umbrella) matrix.rs:161 — geometry_count fallback _ => 1 means an unknown component auto-greens the emit_render geom>0 contract. Make unknown components RED (or 0).

P2 — drew()-only / verts>0-only / lit_px>0-only render proofs

• facett-core/src/harness.rs headless_render_captures_state_and_draws — render proof is drew()-only.
• facett-core/src/overlay.rs overlay_guest_renders_into_the_masked_region — verts>0-only; the masked-region claim is NOT pixel-verified.
• facett-core render_callchain_matrix.rs:437 (wgpu) headless_nonblank — lit_px>1000 single-scene magic floor.
• facett-card themed_read_render_draws, facett-console themed_render_works_for_a_look_preset — drew()-only, single theme/preset.
• facett-grid themed_render_works_for_every_palette — drew()-only (multi-theme on Axis A, but no state/pixel assert).
• facett-map3d/tests/near_plane_probe.rs probe_street_level_faces — NO assertions at all (only eprintln). Vacuous; violates inject-assert law.
• facett (umbrella) perf.rs perf_table_render_scale — print-only, no assert (the graph/map twins assert drew()).
• facett (umbrella) matrix.rs empty_components_render_without_panic — explicit no-panic-only.

P3 — loose tolerance / "big enough" floors

• facett-core gpu_sdf_parity.rs:126 + render_callchain_matrix.rs:468 — CPU↔GPU disagreement < 0.04 (4% of frame = ~2621 px) on a binary lit-mask only (alpha computed then discarded). Tighten and assert per-pixel color/alpha, not a coarse mask. Single hardcoded scene (no sweep) on both.
• facett-core >1000 / >50000 non-blank floors (gpu_sdf_parity:80, render_callchain:436/449) — magic floors not tied to expected coverage.
• Margin-leak frac < 0.0005 (map3d clip_pipeline/frustum_scissor/gpu_scissor/robot_ui) and < 0.02/< 0.05 (map/geomap/graph/pipeline/syschart robot_confined) — AA-slack epsilons; acknowledged but loose.
• body_ratio floors: syschart 0.01 and graph 0.01 are near-vacuous (1% painted passes); pipeline 0.3; map/geomap 0.5. Raise the 0.01 floors to the expected fill fraction.
• PNG bytes > 1000 / > 5000 byte-floors (graph/pipeline/syschart *_png, demo snapshot+mega_matrix, grid snapshot, map/geomap/map3d/graph3d goldens) — "is a non-trivial file", NOT a pixel/golden diff. Only facett-map3d/golden_248.rs does a real perceptual diff + sensitivity control. Add golden-image comparison or content asserts; goldens are otherwise write-only.
• empty_vs_populated_separable verts > empty×2 — loose ×2 multiplier in graph/map/geomap/pipeline/syschart/graphview callchain emits.
• facett-grid/tests/snapshot.rs:106 Grid.snapshot/flagship_png_non_trivial — bytes>5000 && img_w>=1000, the only golden in the small-crate set, but a size gate not a pixel diff; single fixture.
• facett-grid condfmt heat_color_warms (a()>), perf timing (<4×+200ns, <5s, <5ms), facett-menu fuzzy_prefers_contiguous (>), facett-plotters treemap ±0.2 / violin kde ±0.05 — relational/tolerance bounds (some justified for heuristics/stats/timing).
• facett-docview dark>1000 / dark_ink>200 / cache_size≥1 — non-blank-by-design floors.
• facett-video frame_index < 10 — loose loop check (should assert the exact wrapped index).

P4 — single-value input (Axis A only), exact bound otherwise

• facett-core a11y emitters (one node, value 42) and camera emit (one pose); most parity tests single-scene.
• facett-map3d/src/camera.rs + every pose test (golden_248, gpu_depth, gpu_scissor, zfight, frustum_scissor, robot_ui, render_proof, selftest) drive ONE fixed camera pose — matrix_grid.rs is the only real pose sweep (and its oracle is loose, see P0).
• a11y / snapshot single-fixture across graph, graph3d, geomap, card, console, filedialog, table, pop, plotters, syschart — one fixed scene each (fine for interaction proofs, but no boundary/degenerate variation in the a11y layer).
• facett-arrow missing_id_column_errors — is_err()-only, single degenerate input (no error-message contract).
• facett-jobview pull_source_feeds_via_jobs_call — asserts only the pre-pull empty state; never proves the source actually feeds.
• facett-form take_submitted_only_after_save — negative-only (None before save), no post-save positive path.
• facett-osm real-data tests are #[ignore] (env-gated, loose >1000/>100000 bounds) — not in the default matrix.
• facett-plot — the whole crate: 1 test, single line chart, no Bars/empty/render. Weakest coverage in the workspace.
• facett-syschart a11y.rs:89 + facett-graph a11y.rs:65 fc5 emits — ok encodes only the toggle-OFF end state (a never-selecting chart also emits green).
• facett-table a11y.rs:85 — single-condition row-label check.

Provenance

This inventory was produced by read-only static analysis of the actual assertion bodies (ripgrep + Read), not from test names. Counts may drift as the suite evolves; regenerate by re-walking Cargo.toml members, rg '#\[test\]', and rg 'testmatrix::emit' and re-reading the bodies. The two-axis law it is judged against lives in /run/media/rickard/T9/git/nornir/.nornir/agent-ui-test-fixing.md.

Round 2026-07-22 — what this inventory drove, and what it now says

1. The zero-cell panes are backfilled (14 crates)

Every crate that emitted no testmatrix row of either aspect now has one, and every one of them got it through the SHARED facett_core::testmatrix::probe_and_emit seam — one call per pane, no bespoke harness, no twinned sink (L5).

Each pane also got a shared local() fixture in src/, and the existing robot test now consumes it instead of twinning its own copy.

Two real bugs the backfill found

• facett-holger's dyn Facet drive seam was DEAD. The inherent RegistryBrowser::update_json worked, but the impl Facet never overrode update_json, so every message sent through the trait object — the path a FacetDeck and harness::probe_facet use — hit the trait's silent no-op default. Fixed + pinned by a trait-object test.
• Gantt::critical_path was non-deterministic. It scanned a HashMap, so two tasks tying on the finish date picked a winner by hash order and state_json differed between two identical boards in the same process. It now scans the tasks in declaration order (a tie resolves to the downstream task), pinned by a 64-iteration determinism test.

2. P0 — the loose viewport multiples are CLOSED

The inventory named SCREEN_BOUND_K = 4.0 as the canonical failure. In src it had already been tightened to 1.0; the tests had not followed, and that is what kept the class alive — a suite measuring a fixed renderer against a cap 4× looser than its contract.

The RED-when-broken proof is in the suite, not in prose. golden_248's sensitivity control now asserts BOTH halves at the smear-bait pose: the preserved pre-fix pipeline projects 1097 px, which breaches the new 601 px cap (so the tightened oracle detects the smear) and passes the historical 2880 px cap (so the old oracle was green on broken code). The loophole is demonstrated by an assertion.

Note for the next round: flipping SCREEN_BOUND_K back to 4.0 does not by itself trip these tests, because the full frustum clip (clip_tri_frustum) is now the binding constraint on the synthetic scenes — the screen bound is a second net. The fail-on-bug control therefore drives shade_faces_clip(.., near_clip = false), the preserved pre-fix pipeline, which is the defect the caps exist to catch.

3. P1/P2 — the decoupled and vacuous oracles

• facett-map3d/tests/near_plane_probe.rs had NO assertions at all (only eprintln!). It now asserts the street-level pose renders real geometry, that every face is viewport-bounded (scale*2+1), that zero vertices escape the rect after the live Sutherland–Hodgman clip — the exact quantity it used to print and never check — and carries its own fail-on-bug control (the pre-fix pipeline breaches the cap at the same pose: 1134 px vs 621 px).
• facett-map3d/tests/clip_pipeline.rs composite emitted png_path.exists() — the matrix row went green whenever a file landed on disk, regardless of whether the picture was blank or leaking. It now carries lit_px > 500 && leak_frac < 0.0005, the two quantities the test body asserts.

4. New coverage that did not exist

• facett-map3d-flight had no Facet and therefore no pane-level cell at all. tests/facet_robot.rs gives it one, plus the walk-mode contracts.
• facett-graph3d: opting_into_gpu_without_installing_the_renderer_still_draws_on_the_cpu — the instanced GPU lane was fail-dangerous: with_gpu(true) skips the CPU painter, so a host that opted in without installing the renderer rendered a blank pane. The lane is now gated on the install flag and falls back vertex-for-vertex; the test runs GPU-less.
• facett-geomap: tests/osm_pin_clusters.rs (pin clustering, a zoom sweep with a conservation oracle at every step) and tests/point_grid_locality.rs (the structural cause of the cull-locality bug the new bench found).
• facett-geomap/benches/heavy_navigator.rs — the crate had no benches.

5. Still open from the WEAK list

Unaddressed this round, in rough value order: the P1 literal-true emits in facett-graph3d/tests/render_callchain.rs, facett-graphview/tests/render_callchain.rs and facett-map/tests/callchain_matrix.rs:224; the umbrella's geometry_count _ => 1 auto-green fallback; the P3 PNG byte-floor goldens across the whole workspace (only golden_248 does a real perceptual diff); the body_ratio > 0.01 near-vacuous confinement floors in syschart/graph; and the CPU↔GPU disagreement < 0.04 binary-mask tolerance in facett-core.