osint/fma: Z-order tile-pyramid layout — the address is the position

Re-bake the FMA heart slice so each part-of node carries its Morton
(Z-order) tile path in the GUID identity field: one 4×4 level per
part-of step (heart → chamber quadrant → wall → tissue → cell), via
osint_bake::morton::descend. Depth == class, so the path is fully
recoverable from identity + class alone.

FmaGraph deinterleaves that path nibble-by-nibble into a fixed nested
tile centre (coarser tier → larger dot), pins every node (physics off),
and lines the cross-cutting global types up along the pole above the
body. /fma now renders as the literal nested tile pyramid the cascade
descends, instead of a force-directed blob — position() is decode().

The walk reconstructs (x,y) level by level rather than flat-decoding the
multi-level code (a flat decode spreads the per-level axis bits across
nibbles and lands out of range). Edges reference the SoA array index,
never the identity, so storing the Morton code there is layout-only and
cannot perturb topology. decodeSoa now exposes the raw identity field
(additive; OSINT ignores it).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TzqvDqbFRzyx17EkLKBoZF

Author: claude

cockpit/public/fma.soa

@@ -27,6 +27,41 @@ const classColor = (c: number) => FMA_CLASS[c]?.color ?? '#8899aa';
 const REL = ['member-of', 'interfaces', 'part-of', 'is-a'];
 const REL_COLOR = ['#223040', '#223040', '#7fa6c4', CEILING_COLOR];
 
+// ── Z-order (Morton) tile layout ─────────────────────────────────────────────
+// The bake stores each part-of node's Morton tile path in the GUID identity (one
+// 4×4 level per part-of step, coarsest in the high nibble). Depth == class
+// (Organ 0 → Cell 4), so position is fully recoverable from identity + class:
+// walk the nibbles, decode each 4×4 cell, accumulate base-2, and the node lands
+// at the centre of its nested tile — the address literally *is* the coordinate.
+const MAX_DEPTH = 4; // cells are the deepest tier → a 2^4 = 16×16 finest grid
+const CELL = 90; // px per finest grid cell
+const POLE_Y = -2.4 * CELL; // the ceiling pole hovers above the body
+
+// inverse bit-interleave (gather even bits to the low half) — TS port of
+// `compact1by1` in osint-bake/src/morton.rs; decodes ONE 4×4 Morton cell.
+function compact1by1(n: number): number {
+  n &= 0x55555555;
+  n = (n | (n >> 1)) & 0x33333333;
+  n = (n | (n >> 2)) & 0x0f0f0f0f;
+  n = (n | (n >> 4)) & 0x00ff00ff;
+  n = (n | (n >> 8)) & 0x0000ffff;
+  return n >>> 0;
+}
+
+// Reconstruct a node's tile centre by walking its Morton path nibble-by-nibble
+// (NOT a flat decode — a multi-level code spreads the axis bits across nibbles).
+function tilePos(code: number, depth: number): { x: number; y: number; span: number } {
+  let gx = 0;
+  let gy = 0;
+  for (let k = 0; k < depth; k++) {
+    const nib = (code >> (4 * (depth - 1 - k))) & 0xf; // coarsest level first
+    gx = gx * 2 + compact1by1(nib); // each FMA level is a 2×2 branch (quad 0..1)
+    gy = gy * 2 + compact1by1(nib >> 1);
+  }
+  const span = 1 << (MAX_DEPTH - depth); // tile edge, in finest cells
+  return { x: (gx * span + span / 2) * CELL, y: (gy * span + span / 2) * CELL, span };
+}
+
 const OPTIONS: Options = {
   nodes: { shape: 'dot', borderWidth: 2.5, font: { color: '#d9e9f9', size: 13, strokeWidth: 3, strokeColor: PAGE_BG } },
   edges: {
@@ -36,11 +71,8 @@ const OPTIONS: Options = {
     smooth: { enabled: true, type: 'continuous', roundness: 0.2 },
     arrows: { to: { enabled: true, scaleFactor: 0.45 } },
   },
-  physics: {
-    solver: 'forceAtlas2Based',
-    forceAtlas2Based: { gravitationalConstant: -70, centralGravity: 0.008, springLength: 130, springConstant: 0.04, damping: 0.5, avoidOverlap: 0.5 },
-    stabilization: { iterations: 180, fit: true },
-  },
+  // positions are fixed Z-order tiles (see tilePos) — no force simulation.
+  physics: { enabled: false },
   interaction: { hover: true, tooltipDelay: 90, dragNodes: true },
   layout: { improvedLayout: false },
 };
@@ -93,18 +125,42 @@ export function FmaGraph() {
   useEffect(() => {
     if (!hostRef.current || !soa || !rel) return;
     const ceiling = (i: number) => soa.ceiling[i] === 1 || soa.cls[i] === 5;
-    const baseNode = (i: number) => ({
-      id: i,
-      label: soa.labels[i] || `#${i}`,
-      shape: ceiling(i) ? 'diamond' : 'dot',
-      color: {
-        background: ceiling(i) ? 'rgba(255,209,102,0.14)' : 'rgba(10,14,23,0.88)',
-        border: ceiling(i) ? CEILING_COLOR : classColor(soa.cls[i]),
-      },
-      size: ceiling(i) ? 22 : 13,
-      font: { color: ceiling(i) ? '#ffe9b0' : '#d9e9f9' },
-      title: `${soa.labels[i]}\n${ceiling(i) ? '◈ global type (leaf-limited, cross-cutting)' : FMA_CLASS[soa.cls[i]]?.name}`,
-    });
+
+    // Fixed Z-order position per node: part-of nodes deinterleave their Morton
+    // tile path (depth == class) into a nested tile centre; the cross-cutting
+    // global types line up along the pole above the body. The grid width spans
+    // 2^MAX_DEPTH finest cells, so the pole row is centred over that span.
+    const poleNodes = Array.from({ length: soa.nodeCount }, (_, i) => i).filter(ceiling);
+    const gridSpan = (1 << MAX_DEPTH) * CELL;
+    const posOf = (i: number): { x: number; y: number; size: number } => {
+      if (ceiling(i)) {
+        const k = poleNodes.indexOf(i);
+        const x = ((k + 0.5) / Math.max(poleNodes.length, 1)) * gridSpan;
+        return { x, y: POLE_Y, size: 22 };
+      }
+      const depth = soa.cls[i]; // Organ 0 → Cell 4
+      const { x, y } = tilePos(soa.identity[i], depth);
+      return { x, y, size: 30 - depth * 4 }; // coarser tier → larger dot
+    };
+
+    const baseNode = (i: number) => {
+      const p = posOf(i);
+      return {
+        id: i,
+        label: soa.labels[i] || `#${i}`,
+        x: p.x,
+        y: p.y,
+        fixed: { x: true, y: true }, // the address is the layout — pin it
+        shape: ceiling(i) ? 'diamond' : 'dot',
+        color: {
+          background: ceiling(i) ? 'rgba(255,209,102,0.14)' : 'rgba(10,14,23,0.88)',
+          border: ceiling(i) ? CEILING_COLOR : classColor(soa.cls[i]),
+        },
+        size: p.size,
+        font: { color: ceiling(i) ? '#ffe9b0' : '#d9e9f9' },
+        title: `${soa.labels[i]}\n${ceiling(i) ? '◈ global type (leaf-limited, cross-cutting)' : FMA_CLASS[soa.cls[i]]?.name}`,
+      };
+    };
     const baseEdge = (e: { s: number; t: number; r: number }, id: number) => ({
       id,
       from: e.s,
@@ -117,10 +173,9 @@ export function FmaGraph() {
     const visNodes = new DataSet<any>(Array.from({ length: soa.nodeCount }, (_, i) => baseNode(i)));
     const visEdges = new DataSet<any>(soa.edges.map((e, id) => baseEdge(e, id)));
     const net = new Network(hostRef.current, { nodes: visNodes, edges: visEdges }, OPTIONS);
-    net.once('stabilizationIterationsDone', () => {
-      net.setOptions({ physics: { enabled: false } });
-      setStatus(`${soa.nodeCount} nodes · ${soa.edgeCount} edges — click a tissue to see its dual membership`);
-    });
+    // fixed Z-order tiles, no simulation — just frame the nested pyramid.
+    net.once('afterDrawing', () => net.fit({ animation: false }));
+    setStatus(`${soa.nodeCount} nodes · ${soa.edgeCount} edges — Z-order tile pyramid; click a tissue for its dual membership`);
 
     const dim = () => {
       visNodes.update(Array.from({ length: soa.nodeCount }, (_, i) => ({ id: i, color: { background: 'rgba(10,14,23,0.5)', border: '#26323f' }, font: { color: '#566779' } })));

cockpit/src/FmaGraph.tsx

@@ -89,6 +89,10 @@ export interface Soa {
   tenants: Uint8Array | null;
   // per-node global-category flag (HEEL=HIP=0xFFFF ceiling pole): 1 = cross-cutting.
   ceiling: Uint8Array;
+  // per-node GUID identity field (bytes 14-15 LE). For basin-local nodes this is
+  // the plain identity; the FMA bake stores the node's Z-order (Morton) tile path
+  // here, so FmaGraph deinterleaves it into a fixed tile-pyramid position.
+  identity: Uint16Array;
 }
 
 /** One readable step of the reasoning traversal, streamed into the readout. */
@@ -129,10 +133,14 @@ export function decodeSoa(buf: ArrayBuffer): Soa {
   // the node is a cross-cutting GLOBAL category (the dual-use axes), not
   // basin-local. Read straight off the 16-byte GUID (HEEL @4, HIP @6).
   const ceiling = new Uint8Array(nodeCount);
+  // identity[i] = GUID bytes 14-15 (LE) — the basin-local identity, or the
+  // node's Morton tile-path when the bake stores a Z-order address there.
+  const identity = new Uint16Array(nodeCount);
   for (let i = 0; i < nodeCount; i++) {
     const heel = dv.getUint16(off + 4, true);
     const hip = dv.getUint16(off + 6, true);
     if (heel === 0xffff && hip === 0xffff) ceiling[i] = 1;
+    identity[i] = dv.getUint16(off + 14, true);
     cls[i] = dv.getUint8(off + 16);
     off += 17;
   }
@@ -162,7 +170,7 @@ export function decodeSoa(buf: ArrayBuffer): Soa {
     tenants = new Uint8Array(buf, off, nodeCount * 6);
     off += nodeCount * 6;
   }
-  return { nodeCount, edgeCount, cls, edges, labels, tenants, ceiling };
+  return { nodeCount, edgeCount, cls, edges, labels, tenants, ceiling, identity };
 }
 
 // vis-network options tuned to the Palantir look: hollow ring nodes (dark fill

cockpit/src/OsintGraph.tsx

@@ -19,6 +19,7 @@
 //! Run from the workspace root:  `cargo run -p osint-bake --bin fma`
 
 use lance_graph_contract::canonical_node::NodeGuid;
+use osint_bake::morton;
 use std::path::{Path, PathBuf};
 
 /// The CEILING global-category pole (HEEL=HIP=0xFFFF; sentinel through TWIG = leaf-grain).
@@ -38,6 +39,15 @@ const C_TYPE: u8 = 5; // the leaf-limited global type categories (ceiling pole)
 const REL_PART_OF: u8 = 2; // structure → its container (basin-local hierarchy)
 const REL_IS_A: u8 = 3; // structure → its cross-cutting global type (ceiling)
 
+/// Map a sibling index (0..4) to its 2×2 quadrant `(tx, ty)` inside one 4×4
+/// Morton level: 0→(0,0) 1→(1,0) 2→(0,1) 3→(1,1) — natural row-major placement.
+/// Every FMA branch is ≤4-way (4 chambers, 3 walls, 2 tissues, 2 cells), so each
+/// part-of step is exactly one `morton::descend`, and depth == class.
+fn quad(i: usize) -> (u16, u16) {
+    let i = i as u16;
+    (i & 1, (i >> 1) & 1)
+}
+
 struct Node {
     label: String,
     class: u8,
@@ -55,6 +65,12 @@ impl Builder {
     }
 
     /// A part-of (basin-local) node: HEEL=organ, HIP=chamber, TWIG=wall, LEAF=struct.
+    /// `morton` is the node's Z-order tile path (one 4×4 level per part-of step);
+    /// its low 16 bits land in the GUID identity field, so the address **is** the
+    /// layout coordinate — `FmaGraph` deinterleaves it back into a fixed position.
+    /// Edges reference the returned array index, never the identity, so storing the
+    /// Morton code here is layout-only and can't perturb the graph topology.
+    #[allow(clippy::too_many_arguments)]
     fn part_of_node(
         &mut self,
         label: &str,
@@ -64,16 +80,17 @@ impl Builder {
         wall: u16,
         leaf: u16,
         basin: u8,
+        morton: u32,
     ) -> usize {
         let i = self.nodes.len();
         let key = NodeGuid::new_v2(
             CLASSID_FMA,
-            organ,        // HEEL — organ tier
-            chamber,      // HIP  — chamber tier
-            wall,         // TWIG — wall/region tier
-            leaf,         // LEAF — structure tier
+            organ,           // HEEL — organ tier
+            chamber,         // HIP  — chamber tier
+            wall,            // TWIG — wall/region tier
+            leaf,            // LEAF — structure tier
             u16::from(basin),
-            i as u16,
+            morton as u16,   // identity — the Z-order tile path (position == address)
         );
         self.nodes.push(Node { label: label.to_string(), class, key });
         i
@@ -129,18 +146,24 @@ fn build_heart() -> Builder {
     // a couple of cell types per tissue (depth + scale; part-of only).
     let cells: [&str; 2] = ["cell A", "cell B"];
 
-    // ── the heart organ (basin-local root) ──
-    let heart = b.part_of_node("Heart", C_ORGAN, 1, 0, 0, 0, 0);
+    // ── the heart organ (basin-local root, root of the Z-order pyramid) ──
+    // Morton 0 = the whole 16×16 tile; each part-of step descends one 4×4 level.
+    let heart_m: u32 = 0;
+    let heart = b.part_of_node("Heart", C_ORGAN, 1, 0, 0, 0, 0, heart_m);
 
     let chambers = ["left atrium", "right atrium", "left ventricle", "right ventricle"];
     for (ci, chamber) in chambers.iter().enumerate() {
         let cnum = (ci as u16) + 1; // HIP 1..4
         let basin = (ci as u8) + 1; // one basin per chamber
-        let ch = b.part_of_node(chamber, C_CHAMBER, 1, cnum, 0, 0, basin);
+        let (ctx, cty) = quad(ci); // chamber → one of the 4 heart quadrants
+        let chamber_m = morton::descend(heart_m, ctx, cty);
+        let ch = b.part_of_node(chamber, C_CHAMBER, 1, cnum, 0, 0, basin, chamber_m);
         b.edge(ch, heart, REL_PART_OF);
 
         for (wi, (wall, tissues)) in walls.iter().enumerate() {
             let wnum = (wi as u16) + 1; // TWIG 1..3
+            let (wtx, wty) = quad(wi); // wall → a sub-tile of the chamber quadrant
+            let wall_m = morton::descend(chamber_m, wtx, wty);
             let w = b.part_of_node(
                 &format!("{chamber} {wall}"),
                 C_WALL,
@@ -149,11 +172,14 @@ fn build_heart() -> Builder {
                 wnum,
                 0,
                 basin,
+                wall_m,
             );
             b.edge(w, ch, REL_PART_OF);
 
             for (ti, (tissue, gtype)) in tissues.iter().enumerate() {
                 let leaf = (ti as u16) + 1;
+                let (ttx, tty) = quad(ti); // tissue → a sub-tile of the wall
+                let tissue_m = morton::descend(wall_m, ttx, tty);
                 let t = b.part_of_node(
                     &format!("{chamber} {tissue}"),
                     C_TISSUE,
@@ -162,13 +188,16 @@ fn build_heart() -> Builder {
                     wnum,
                     leaf,
                     basin,
+                    tissue_m,
                 );
                 b.edge(t, w, REL_PART_OF);
                 // THE dual membership: this basin-local tissue is-a the global type.
                 b.edge(t, type_idx[*gtype], REL_IS_A);
 
                 for (cells_i, cell) in cells.iter().enumerate() {
                     let cleaf = (ti as u16) * 8 + (cells_i as u16) + 16;
+                    let (xtx, xty) = quad(cells_i); // cell → the finest sub-tile
+                    let cell_m = morton::descend(tissue_m, xtx, xty);
                     let c = b.part_of_node(
                         &format!("{chamber} {tissue} {cell}"),
                         C_CELL,
@@ -177,6 +206,7 @@ fn build_heart() -> Builder {
                         wnum,
                         cleaf,
                         basin,
+                        cell_m,
                     );
                     b.edge(c, t, REL_PART_OF);
                 }
@@ -226,14 +256,18 @@ fn main() {
     let key = &b.nodes[tissue].key;
     println!("── FMA dual-membership proof ──");
     println!("node: {}", b.nodes[tissue].label);
+    // identity now carries the node's Z-order tile path (one 4×4 level per
+    // part-of step, coarsest in the high nibble). FmaGraph walks the nibbles to
+    // recover the nested-tile position; a flat decode would mis-spread the bits.
+    let morton_code = u32::from(key.identity_v2());
     println!(
-        "  part-of address (basin-local): HEEL={} HIP={} TWIG={} LEAF={} family={} identity={}",
+        "  part-of address (basin-local): HEEL={} HIP={} TWIG={} LEAF={} family={} morton=0x{:04x} (Z-order tile path)",
         key.heel(),
         key.hip(),
         key.twig(),
         key.leaf(),
         key.family_v2(),
-        key.identity_v2()
+        morton_code,
     );
     // its is-a edge → the leaf-limited global type (ceiling pole)
     let gtype = b