feat(contract): D-CLS-RENDER — ClassView::render_rows (off-bits-skipped render surface) + Wikidata-HHTL plan

render_rows(class,mask)->Vec<RenderRow{label,predicate}>: the C2 presence-only render
surface (classes.md:49), template-agnostic (askama engine deferred to its crate-Wave).
Completes the contract side of the XML-parse stack. Review->fix: clippy -D warnings caught
a doc-list-indent lint -> reflowed. 497 contract lib green; clippy+fmt clean. Also records
the Wikidata-HHTL plan as the next arc: the classes.md-N4 second-domain falsifier that
reuses FieldMask/signature/ClassView; smallest slice = HHTL 16^n nibble router + OWL/DOLCE
facet template + mask-inherits-as-delta (defer the 115M streaming load).

https://claude.ai/code/session_01R9AWgFa65uPnLyS2my2d2R

Author: claude

.claude/board/EPIPHANIES.md

@@ -1,3 +1,14 @@
+## 2026-05-31 — SHIPPED D-CLS-RENDER + PLANNED Wikidata-HHTL (the N4 second-domain falsifier)
+
+**Status:** D-CLS-RENDER SHIPPED-in-PR; Wikidata-HHTL = PLANNED (next arc, the classes.md:N4 falsifier).
+
+**D-CLS-RENDER (shipped):** `ClassView::render_rows(class,mask) -> Vec<RenderRow{label,predicate}>` — the off-bits-skipped render surface (classes.md:49). Presence-ONLY (C2): a row appears iff its bit is set; the mask never changes meaning. Template-agnostic — an askama per-class template iterates these rows; the engine (F3=askama, OD ratified) is the deferred render-crate Wave (the plan's Wave-4 multi-agent, not a solo slice). Review->fix: clippy -D warnings caught a doc-list-indent lint (line starting with `+` read as a bullet) -> reflowed. 497 contract lib green; class_view clippy+fmt clean. Completes the CONTRACT side of the XML-parse stack: SoA=doc, ObjectView=XSD, ClassView=parser, FieldMask=presence, render_rows=the XSLT output rows.
+
+**Wikidata-HHTL — the next arc (planned, why it matters):** classes.md N4 = "don't freeze the SoA schema until >=2 genuinely different domains run through it"; faiss-homology closed-picture = "chess + Odoo + Wikidata-anatomy all run through the same Class+SoA+HHTL+CAM with no special-case." Odoo is domain-1 (D-CLS shipped). **Wikidata HHTL is the SECOND-DOMAIN FALSIFIER** that proves FieldMask/StructuralSignature/ClassView are universal, not Odoo-cosplaying. DIRECT REUSE: wikidata facet-bitmask = my `FieldMask`; shape = my `signature()`; (class_id, shape_hash, presence_bitmask) persisted row = exactly the D-CLS triple.
+
+**The right SMALLEST slice (not the 115M load — that's a streaming pipeline):** the wikidata-hhtl doc's bring-up = the **HHTL 16^n nibble router + OWL/DOLCE facet template**. Concretely shippable + reuses D-CLS: (a) `HhtlPath` (16^n nibble sequence = the P279/subClassOf Abstammungs-path, the ONE tree axis; bit-shift routing, O(1)); (b) the OWL-construct -> HHTL-form table as a typed mapping (subClassOf->path, closed-ObjectProperty->facet-bit=my FieldMask, DatatypeProperty->Quartett slot, disjointWith->collision-free additive); (c) mask-inherits-along-path-as-DELTA (the leaf stores only its increment over the parent — prevents the union disease). zero-dep contract types + a tiny falsifiable test (a 2-level P279 path + a facet, assert the leaf mask = parent-delta). DEFER: the streaming json.gz loader, the 115M scaling, the reasoning Derived store.
+
+**Cross-ref:** D-CLS arc (FM/RES/SIG/AUDIT/RENDER, the reused machinery); wikidata-hhtl-load.md (the pipeline); faiss-homology-cam-pq.md (facet u64 = SoA facet column = FieldMask; HHTL=IVF cell); classes.md N3/N4 + :49; cognitive-risc-core (HHTL=Schedule-layer bucket router).
 ## 2026-05-31 — SHIPPED-in-PR: D-CLS-AUDIT — curated-corpus shape-family audit (classes.md:42 CONFIRMED on real data, falsifiably) + clippy fix
 
 **Status:** SHIPPED-in-PR (#440 D-CLS Wave-2 input). Extends D-CLS-SIG from one lane to the full curated corpus.

.claude/board/STATUS_BOARD.md

@@ -572,6 +572,7 @@ Plan path: `.claude/plans/unified-soa-convergence-v1.md`. Handover `.claude/hand
 | D-CLS-RES | `class_resolver`: `RegistryClassView` impls `ClassView` over the live OntologyRegistry — the ontology-side 'parser' (class_id -> shape, DOLCE resolved LATE via classify_odoo from the cache URI, memoized over the O(n) registry scan) | lance-graph-ontology | 200 | LOW | **In PR** | #440 D-CLS; makes the contract trait live; field-set supplied (D-CLS audit deferred); 4 teeth-tests |
 | D-CLS-SIG | `class_signature`: deterministic structural-signature audit of curated OdooEntity consts (FNV-1a over kind+field-hist+method-hist+state-machine) -> shape-family group-by + `object_view()` derives the real ObjectView bit-basis (fills the D-CLS-RES placeholder) | lance-graph-ontology | 230 | LOW | **In PR** | #440 D-CLS; the HONEST D-CLS-3 (group-by-on-structural-hash, NOT aerial-cluster vaporware, classes.md:43); 4 teeth-tests over real l1 data |
 | D-CLS-AUDIT | `class_signature` corpus audit: `curated_entities()` (all 15 l-lanes, 64 consts) + `corpus_summary()` + falsifiable test that the real curated corpus collapses entities->fewer shape-families (classes.md:42 CONFIRMED on real data, not asserted) | lance-graph-ontology | 90 | LOW | **In PR** | #440 D-CLS Wave-2 input; +clippy fix (unused FieldMask import in class_resolver) |
+| D-CLS-RENDER | `ClassView::render_rows` + `RenderRow{label,predicate}` — the off-bits-skipped render surface (C2 presence-only; template-agnostic, askama engine deferred to its own crate-Wave) | lance-graph-contract | 50 | LOW | **In PR** | #440 D-CLS; the render LOGIC (classes.md:49), not the engine; +doc-lint fix |
 
 ---
 

crates/lance-graph-contract/src/class_view.rs

@@ -5,9 +5,9 @@
 //! Today OGIT (`lance-graph-ontology::OntologyRegistry`) is a **hashtable doing
 //! single lookups**: `uri → row`, `entity_type_id → row` — one key, one value,
 //! O(1), leaf. That is the *single* lookup. What a class needs is a **meta
-//! lookup**: `class_id → the whole shape` (ordered field set + labels + template
-//! + the presence-bit basis). The class composes many leaf lookups into one
-//! shape — the way an XSD schema composes element declarations.
+//! lookup**: `class_id → the whole shape` — the ordered field set, labels,
+//! template, and the presence-bit basis. The class composes many leaf lookups
+//! into one shape — the way an XSD schema composes element declarations.
 //!
 //! ```text
 //!   SoA row          =  the XML document   (agnostic bytes, no meaning)
@@ -159,6 +159,35 @@ pub trait ClassView {
             pos: 0,
         }
     }
+
+    /// The **render rows** for an instance: only the populated `(label, predicate)`
+    /// pairs, off-bits skipped (`cognitive-risc-classes.md`:49). This is the
+    /// template-agnostic render surface — an askama/jinja per-class template iterates
+    /// these rows; the engine choice (F3, askama) lives in the deferred render crate.
+    ///
+    /// Presence-only (C2): a row appears iff its bit is set; the mask NEVER changes a
+    /// row's meaning, only its presence. The labels are the meta-DTO's late resolution
+    /// (above the SoA), the mask is the SoA's structural delta.
+    fn render_rows<'a>(&'a self, class: ClassId, mask: FieldMask) -> Vec<RenderRow<'a>> {
+        self.project(class, mask)
+            .filter(|(_, present)| *present)
+            .map(|(f, _)| RenderRow {
+                label: f.label.as_str(),
+                predicate: f.predicate_iri.as_str(),
+            })
+            .collect()
+    }
+}
+
+/// One populated field to render — the late-resolved `label` + its `predicate` key.
+/// Produced only for set bits (off-bits are skipped), so a template never branches
+/// on presence (C2): it just iterates the rows it is given.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct RenderRow<'a> {
+    /// The display label, resolved late from the OGIT cache (above the SoA).
+    pub label: &'a str,
+    /// The field's predicate IRI (the stable key behind the label).
+    pub predicate: &'a str,
 }
 
 /// An iterator over a class's fields paired with their presence bit — the
@@ -265,4 +294,34 @@ mod tests {
         assert_eq!(classes.field_count(7), 3);
         assert_eq!(classes.field_count(999), 0); // unknown class
     }
+
+    #[test]
+    fn render_rows_skips_off_bits_presence_only() {
+        let classes = FakeClasses::new();
+        // Tax (pos 1) is off → it must NOT produce a render row (C2: off-bits skipped).
+        let rows = classes.render_rows(7, FieldMask::from_positions(&[0, 2]));
+        assert_eq!(rows.len(), 2, "only the 2 populated fields render");
+        assert_eq!(
+            rows[0],
+            RenderRow {
+                label: "Total",
+                predicate: "amount_total"
+            }
+        );
+        assert_eq!(
+            rows[1],
+            RenderRow {
+                label: "Partner",
+                predicate: "partner_id"
+            }
+        );
+        // Empty mask → zero rows (no template branch needed, just an empty iteration).
+        assert!(classes.render_rows(7, FieldMask::EMPTY).is_empty());
+        // Full mask → all 3 rows, in class order (the bit basis).
+        let all = classes.render_rows(7, FieldMask::from_positions(&[0, 1, 2]));
+        assert_eq!(
+            all.iter().map(|r| r.label).collect::<Vec<_>>(),
+            vec!["Total", "Tax", "Partner"]
+        );
+    }
 }

crates/lance-graph-contract/src/lib.rs

@@ -97,7 +97,7 @@ pub mod world_map;
 pub mod world_model;
 
 // Re-exports for the most commonly used collapse_gate types.
-pub use class_view::{ClassId, ClassProjection, ClassView, FieldMask};
+pub use class_view::{ClassId, ClassProjection, ClassView, FieldMask, RenderRow};
 pub use collapse_gate::{CollapseGateEmission, GateDecision, MailboxId, MergeMode};
 pub use kanban::{ExecTarget, KanbanColumn, KanbanMove, RubiconTransitionError};
 pub use soa_view::{MailboxSoaOwner, MailboxSoaView};