diff --git a/src/components/DSValue.vue b/src/components/DSValue.vue
index d236df0..23b7c42 100644
--- a/src/components/DSValue.vue
+++ b/src/components/DSValue.vue
@@ -2,6 +2,8 @@
 import type { CppType, MemoryCell } from '~/composables/interpreter/types'
 import { computed } from 'vue'
 import AddressLink from '~/components/AddressLink.vue'
+import { formatType } from '~/composables/interpreter/helpers'
+import { structFieldOffset } from '~/composables/interpreter/memory'
 import { useInterpreterContext } from '~/composables/useInterpreterContext'
 
 const props = defineProps<{
@@ -10,6 +12,9 @@ const props = defineProps<{
   indexPrefix?: string
   /** Field address to highlight (from referenced-by hover or arrow hover) */
   highlightedFieldAddress?: number | null
+  /** Statement LHS/RHS addresses for per-field code highlighting */
+  statementLhsAddresses?: ReadonlySet<number>
+  statementRhsAddresses?: ReadonlySet<number>
 }>()
 
 const emit = defineEmits<{
@@ -19,18 +24,6 @@ const emit = defineEmits<{
 
 const context = useInterpreterContext()
 
-function formatType(type: CppType): string {
-  if (typeof type === 'string')
-    return type
-  if (type.type === 'pointer')
-    return `${formatType(type.to)}*`
-  if (type.type === 'array')
-    return `${formatType(type.of)}[${type.size}]`
-  if (type.type === 'struct')
-    return type.name
-  return '?'
-}
-
 // ---- Computed data ----
 
 /** Fresh cell value — re-reads from reactive memory each step */
@@ -78,11 +71,37 @@ const structFields = computed((): FieldEntry[] => {
   const structDef = context.structs[v.name]
   if (!structDef)
     return []
-  return Object.keys(structDef).map((name, i) => ({
-    name,
-    cell: context.memory.cells.get(v.base + 1 + i),
-    type: structDef[name],
-  }))
+  const entries: FieldEntry[] = []
+
+  /** Recursively flatten array elements with subscript prefix (handles n-d arrays) */
+  function flattenArray(prefix: string, elemType: CppType, cell: MemoryCell | undefined) {
+    if (!cell)
+      return
+    const arrVal = cell.value
+    if (typeof arrVal !== 'object' || arrVal.type !== 'array')
+      return
+    for (let i = 0; i < arrVal.length; i++) {
+      const elemCell = context.memory.cells.get(arrVal.base + 1 + i)
+      const subscript = `${prefix}[${i}]`
+      // Nested array: recurse
+      if (typeof elemType === 'object' && elemType.type === 'array' && elemCell) {
+        flattenArray(subscript, elemType.of, elemCell)
+      }
+      else {
+        entries.push({ name: subscript, cell: elemCell, type: elemType })
+      }
+    }
+  }
+
+  for (const [name, fieldType] of Object.entries(structDef)) {
+    const fieldCell = context.memory.cells.get(v.base + 1 + structFieldOffset(name, structDef))
+    if (typeof fieldType === 'object' && fieldType.type === 'array' && fieldCell) {
+      flattenArray(name, fieldType.of, fieldCell)
+      continue
+    }
+    entries.push({ name, cell: fieldCell, type: fieldType })
+  }
+  return entries
 })
 
 interface ArrayEntry {
@@ -135,7 +154,15 @@ const arrayElements = computed((): ArrayEntry[] => {
         />
       </template>
       <!-- Leaf element -->
-      <div v-else class="flex items-baseline justify-between gap-2 rounded px-1 py-0.5">
+      <div
+        v-else
+        class="flex items-baseline justify-between gap-2 rounded px-1 py-0.5"
+        :class="[
+          highlightedFieldAddress === elem.cell?.address ? 'bg-blue-500/15' : '',
+          statementLhsAddresses?.has(elem.cell?.address ?? -1) ? 'bg-blue-500/10' : '',
+          statementRhsAddresses?.has(elem.cell?.address ?? -1) && !statementLhsAddresses?.has(elem.cell?.address ?? -1) ? 'bg-green-500/10' : '',
+        ]"
+      >
         <span class="text-gray-500 font-mono">{{ elem.prefix }}</span>
         <DSValue
           v-if="elem.cell"
@@ -159,14 +186,18 @@ const arrayElements = computed((): ArrayEntry[] => {
       <template v-if="field.cell && typeof field.cell.value === 'object' && (field.cell.value.type === 'struct' || field.cell.value.type === 'array')">
         <div
           class="py-0.5 pl-3"
-          :class="highlightedFieldAddress === field.cell?.address ? 'bg-blue-500/15 rounded' : ''"
+          :class="[
+            highlightedFieldAddress === field.cell?.address ? 'bg-blue-500/15 rounded' : '',
+            statementLhsAddresses?.has(field.cell?.address ?? -1) ? 'bg-blue-500/10 rounded' : '',
+            statementRhsAddresses?.has(field.cell?.address ?? -1) && !statementLhsAddresses?.has(field.cell?.address ?? -1) ? 'bg-green-500/10 rounded' : '',
+          ]"
           :data-field-addr="field.cell?.address"
         >
           <span class="text-gray-500 font-mono">{{ field.name }}:</span>
           <div class="pl-2">
             <DSValue
               :cell="field.cell"
-
+              :highlighted-field-address="highlightedFieldAddress"
               @navigate="emit('navigate', $event)"
               @hover-node="emit('hoverNode', $event)"
             />
@@ -177,7 +208,11 @@ const arrayElements = computed((): ArrayEntry[] => {
       <div
         v-else
         class="flex items-baseline justify-between gap-4 rounded px-1 py-0.5 pl-3"
-        :class="highlightedFieldAddress === field.cell?.address ? 'bg-blue-500/15' : ''"
+        :class="[
+          highlightedFieldAddress === field.cell?.address ? 'bg-blue-500/15' : '',
+          statementLhsAddresses?.has(field.cell?.address ?? -1) ? 'bg-blue-500/10' : '',
+          statementRhsAddresses?.has(field.cell?.address ?? -1) && !statementLhsAddresses?.has(field.cell?.address ?? -1) ? 'bg-green-500/10' : '',
+        ]"
         :data-field-addr="field.cell?.address"
       >
         <span class="shrink-0 text-gray-500 font-mono">{{ field.name }}:</span>
@@ -185,6 +220,8 @@ const arrayElements = computed((): ArrayEntry[] => {
           v-if="field.cell"
           :cell="field.cell"
           :highlighted-field-address="highlightedFieldAddress"
+          :statement-lhs-addresses="statementLhsAddresses"
+          :statement-rhs-addresses="statementRhsAddresses"
           @navigate="emit('navigate', $event)"
           @hover-node="emit('hoverNode', $event)"
         />
diff --git a/src/components/DataStructureView.vue b/src/components/DataStructureView.vue
index d629790..7bc477c 100644
--- a/src/components/DataStructureView.vue
+++ b/src/components/DataStructureView.vue
@@ -1,9 +1,10 @@
 <script setup lang="ts">
-import type { ArrowAnchor, ArrowStyle, CppType, CppValue, FieldDirection, MemoryCell } from '~/composables/interpreter/types'
+import type { ArrowAnchor, ArrowStyle, FieldDirection, MemoryCell } from '~/composables/interpreter/types'
 import { computed, nextTick, onUpdated, shallowRef, watch } from 'vue'
 import CanvasArrow from '~/components/CanvasArrow.vue'
 import DSValue from '~/components/DSValue.vue'
-import { NULL_ADDRESS } from '~/composables/interpreter/types'
+import { formatAddr, formatType, formatValue } from '~/composables/interpreter/helpers'
+import { structTotalSize } from '~/composables/interpreter/memory'
 import { useInterpreterContext } from '~/composables/useInterpreterContext'
 import { usePannableCanvas } from '~/composables/usePannableCanvas'
 import { usePlacementEngine } from '~/composables/usePlacementEngine'
@@ -27,38 +28,6 @@ const emit = defineEmits<{
 const context = useInterpreterContext()
 const pointerGraph = usePointerGraph(context)
 
-// ---- Format helpers ----
-
-function formatAddr(addr: number): string {
-  return `0x${addr.toString(16).padStart(3, '0')}`
-}
-
-function formatValue(value: CppValue): string {
-  if (typeof value === 'number' || typeof value === 'boolean')
-    return String(value)
-  if (typeof value === 'object') {
-    if (value.type === 'pointer')
-      return value.address === NULL_ADDRESS ? 'NULL' : formatAddr(value.address)
-    if (value.type === 'struct')
-      return `${value.name} {...}`
-    if (value.type === 'array')
-      return `[${value.length}]`
-  }
-  return String(value)
-}
-
-function formatType(type: CppType): string {
-  if (typeof type === 'string')
-    return type
-  if (type.type === 'pointer')
-    return `${formatType(type.to)}*`
-  if (type.type === 'array')
-    return `${formatType(type.of)}[${type.size}]`
-  if (type.type === 'struct')
-    return type.name
-  return '?'
-}
-
 // ---- Standalone data items (in-scope stack + live heap) ----
 
 interface DataItem {
@@ -73,7 +42,7 @@ interface DataItem {
 }
 
 /** Addresses that are struct fields or array elements (sub-cells) */
-function getSubCellAddresses(): Set<number> {
+const subCellAddresses = computed(() => {
   const sub = new Set<number>()
   for (const cell of context.memory.cells.values()) {
     if (cell.dead)
@@ -82,8 +51,9 @@ function getSubCellAddresses(): Set<number> {
     if (typeof v === 'object' && v.type === 'struct') {
       const structDef = context.structs[v.name]
       if (structDef) {
-        for (let i = 0; i < Object.keys(structDef).length; i++)
-          sub.add(v.base + 1 + i)
+        const total = structTotalSize(structDef)
+        for (let i = 1; i < total; i++)
+          sub.add(v.base + i)
       }
     }
     else if (typeof v === 'object' && v.type === 'array') {
@@ -92,7 +62,7 @@ function getSubCellAddresses(): Set<number> {
     }
   }
   return sub
-}
+})
 
 function getKind(cell: MemoryCell): DataItem['kind'] {
   const t = cell.type
@@ -114,7 +84,7 @@ function getKind(cell: MemoryCell): DataItem['kind'] {
 
 const standaloneItems = computed((): DataItem[] => {
   const items: DataItem[] = []
-  const subCells = getSubCellAddresses()
+  const subCells = subCellAddresses.value
   const seen = new Set<number>()
 
   function addItem(name: string, cell: MemoryCell, dimmed: boolean, varName: string | null = null) {
@@ -240,13 +210,16 @@ const placement = usePlacementEngine({
 })
 placementRef = placement
 
-/** Map from struct base address to placement key */
+/** Reverse map: address → placement key (O(1) lookup) */
+const addressKeyMap = computed(() => {
+  const map = new Map<number, string>()
+  for (const item of standaloneItems.value)
+    map.set(item.address, `item-${item.address}`)
+  return map
+})
+
 function addressToKey(address: number): string | undefined {
-  for (const item of standaloneItems.value) {
-    if (item.address === address)
-      return `item-${item.address}`
-  }
-  return undefined
+  return addressKeyMap.value.get(address)
 }
 
 /**
@@ -306,8 +279,16 @@ function invalidateStaleTreePositions(
   for (const [parentKey, newChildren] of newParentToChildren) {
     const oldChildren = prevParentToChildren.get(parentKey)
     // Compare sets: different size or different members
-    if (!oldChildren || oldChildren.size !== newChildren.size
-      || [...newChildren].some(k => !oldChildren.has(k))) {
+    let childrenChanged = !oldChildren || oldChildren.size !== newChildren.size
+    if (!childrenChanged) {
+      for (const k of newChildren) {
+        if (!oldChildren!.has(k)) {
+          childrenChanged = true
+          break
+        }
+      }
+    }
+    if (childrenChanged) {
       for (const childKey of newChildren)
         toInvalidate.add(childKey)
       // Also invalidate old siblings that may have been removed from the group
@@ -351,10 +332,10 @@ function invalidateStaleTreePositions(
     prevParentToChildren.set(k, new Set(v))
 }
 
-/** Measure and place all visible items with tree-aware layout */
-function measureAndPlace() {
+/** Measure and place all visible items with tree-aware layout. Returns the queried elements for reuse. */
+function measureAndPlace(): NodeListOf<HTMLElement> | null {
   if (!contentRef.value)
-    return
+    return null
   // Step 1: Measure all DOM elements
   const els = contentRef.value.querySelectorAll<HTMLElement>('[data-place-key]')
   const measured = new Map<string, { w: number, h: number }>()
@@ -379,13 +360,24 @@ function measureAndPlace() {
     if (!rootKey || !measured.has(rootKey))
       continue
 
+    // Build adjacency map once per tree (O(edges) instead of O(nodes × edges))
+    const edgesByParent = new Map<number, typeof tree.edges>()
+    for (const edge of tree.edges) {
+      let list = edgesByParent.get(edge.fromAddress)
+      if (!list) {
+        list = []
+        edgesByParent.set(edge.fromAddress, list)
+      }
+      list.push(edge)
+    }
+
     // Place root normally
     const rootSize = measured.get(rootKey)!
     placement.placeNew(rootKey, rootSize.w, rootSize.h)
     treePlacedKeys.add(rootKey)
 
     // Recursively place children
-    placeTreeChildren(tree.rootAddress, rootKey, tree, measured, treePlacedKeys)
+    placeTreeChildren(tree.rootAddress, rootKey, edgesByParent, measured, treePlacedKeys)
   }
 
   // Step 2.5: Evict non-tree items whose positions now overlap with tree items.
@@ -408,13 +400,15 @@ function measureAndPlace() {
   for (const el of els)
     activeKeys.add(el.dataset.placeKey!)
   placement.retainOnly(activeKeys)
+
+  return els
 }
 
 /** Recursively place children of a tree node via placeRelative */
 function placeTreeChildren(
   parentAddress: number,
   parentKey: string,
-  tree: typeof pointerGraph.value.trees[number],
+  edgesByParent: Map<number, typeof pointerGraph.value.trees[number]['edges']>,
   measured: Map<string, { w: number, h: number }>,
   placedKeys: Set<string>,
 ) {
@@ -422,8 +416,8 @@ function placeTreeChildren(
   if (!parentNode)
     return
 
-  const childEdges = tree.edges.filter(e => e.fromAddress === parentAddress)
-  if (childEdges.length === 0)
+  const childEdges = edgesByParent.get(parentAddress)
+  if (!childEdges || childEdges.length === 0)
     return
 
   // Collect children with their direction, skipping already-placed nodes
@@ -455,7 +449,7 @@ function placeTreeChildren(
       const size = measured.get(child.key)!
       placement.placeRelative(child.key, parentKey, size.w, size.h, i, heights, dir, arrowSizeOverride)
       placedKeys.add(child.key)
-      placeTreeChildren(child.address, child.key, tree, measured, placedKeys)
+      placeTreeChildren(child.address, child.key, edgesByParent, measured, placedKeys)
     }
   }
 
@@ -467,7 +461,7 @@ function placeTreeChildren(
     const size = measured.get(child.key)!
     placement.placeNew(child.key, size.w, size.h)
     placedKeys.add(child.key)
-    placeTreeChildren(child.address, child.key, tree, measured, placedKeys)
+    placeTreeChildren(child.address, child.key, edgesByParent, measured, placedKeys)
   }
 }
 
@@ -480,8 +474,9 @@ const settlingKeys = new Set<string>()
 let prevActiveKeys = new Set<string>()
 
 onUpdated(() => nextTick(() => {
-  measureAndPlace()
-  animateEnterLeave()
+  const els = measureAndPlace()
+  if (els)
+    animateEnterLeave(els)
 
   // Auto-pan when content bounds changed and items are outside the visible viewport
   const bounds = placement.getContentBounds()
@@ -534,10 +529,9 @@ function getItemStyle(key: string) {
 // ---- DS item enter/leave animations (runs after placement in onUpdated) ----
 
 /** Animate fade-in for newly appeared items and fade-out for removed items. */
-function animateEnterLeave() {
+function animateEnterLeave(els: NodeListOf<HTMLElement>) {
   if (!contentRef.value)
     return
-  const els = contentRef.value.querySelectorAll<HTMLElement>('[data-place-key]')
   const currentKeys = new Set<string>()
 
   for (const el of els) {
@@ -873,6 +867,8 @@ const kindBg: Record<DataItem['kind'], string> = {
           <DSValue
             :cell="item.cell"
             :highlighted-field-address="highlightedFieldAddress"
+            :statement-lhs-addresses="statementLhsAddresses"
+            :statement-rhs-addresses="statementRhsAddresses"
             @navigate="emit('selectNode', $event)"
             @hover-node="emit('hoverNode', $event)"
           />
diff --git a/src/components/FieldTable.vue b/src/components/FieldTable.vue
index 696a2f7..0baf6da 100644
--- a/src/components/FieldTable.vue
+++ b/src/components/FieldTable.vue
@@ -3,7 +3,8 @@ import type { CppType, CppValue, MemoryCell } from '~/composables/interpreter/ty
 import { computed } from 'vue'
 import AddressLink from '~/components/AddressLink.vue'
 import DSValue from '~/components/DSValue.vue'
-import { NULL_ADDRESS } from '~/composables/interpreter/types'
+import { formatAddr, formatType, formatValue } from '~/composables/interpreter/helpers'
+import { structFieldOffset } from '~/composables/interpreter/memory'
 import { useInterpreterContext } from '~/composables/useInterpreterContext'
 
 const props = defineProps<{
@@ -19,32 +20,6 @@ const emit = defineEmits<{
 
 const context = useInterpreterContext()
 
-function formatValue(value: CppValue): string {
-  if (typeof value === 'number' || typeof value === 'boolean')
-    return String(value)
-  if (typeof value === 'object') {
-    if (value.type === 'pointer')
-      return value.address === NULL_ADDRESS ? 'NULL' : `0x${value.address.toString(16).padStart(3, '0')}`
-    if (value.type === 'struct')
-      return `${value.name} {...}`
-    if (value.type === 'array')
-      return `[${value.length}]`
-  }
-  return String(value)
-}
-
-function formatType(type: CppType): string {
-  if (typeof type === 'string')
-    return type
-  if (type.type === 'pointer')
-    return `${formatType(type.to)}*`
-  if (type.type === 'array')
-    return `${formatType(type.of)}[${type.size}]`
-  if (type.type === 'struct')
-    return type.name
-  return '?'
-}
-
 const structName = computed(() => {
   if (typeof props.cell.type === 'object' && props.cell.type.type === 'struct')
     return props.cell.type.name
@@ -88,7 +63,7 @@ const referencedBy = computed((): RefEntry[] => {
     if (cell.dead)
       continue
     if (typeof cell.value === 'object' && cell.value.type === 'pointer' && cell.value.address === targetAddr)
-      refs.push({ address: cell.address, label: `0x${cell.address.toString(16).padStart(3, '0')}` })
+      refs.push({ address: cell.address, label: formatAddr(cell.address) })
   }
   return refs
 })
@@ -100,20 +75,55 @@ const fields = computed((): FieldRow[] => {
   if (!structDef)
     return []
   const base = structBase.value
-  return Object.keys(structDef).map((name, i) => {
-    const addr = base + 1 + i
+  const rows: FieldRow[] = []
+
+  /** Recursively flatten array elements with subscript prefix (handles n-d arrays) */
+  function flattenArray(prefix: string, elemType: CppType, arrValue: { base: number, length: number }) {
+    for (let i = 0; i < arrValue.length; i++) {
+      const elemAddr = arrValue.base + 1 + i
+      const elemCell = context.memory.cells.get(elemAddr)
+      const elemValue = elemCell?.value ?? 0
+      const subscript = `${prefix}[${i}]`
+      // Nested array: recurse
+      if (typeof elemType === 'object' && elemType.type === 'array'
+        && typeof elemValue === 'object' && elemValue.type === 'array') {
+        flattenArray(subscript, elemType.of, elemValue)
+        continue
+      }
+      rows.push({
+        name: subscript,
+        type: elemType,
+        value: elemValue,
+        address: elemAddr,
+        isPointer: typeof elemValue === 'object' && elemValue.type === 'pointer',
+        pointerAddress: (typeof elemValue === 'object' && elemValue.type === 'pointer') ? elemValue.address : 0,
+        changed: props.changedAddresses.has(elemAddr),
+      })
+    }
+  }
+
+  for (const [name, fieldType] of Object.entries(structDef)) {
+    const addr = base + 1 + structFieldOffset(name, structDef)
     const fieldCell = context.memory.cells.get(addr)
     const value = fieldCell?.value ?? 0
-    return {
+
+    if (typeof fieldType === 'object' && fieldType.type === 'array'
+      && typeof value === 'object' && value.type === 'array') {
+      flattenArray(name, fieldType.of, value)
+      continue
+    }
+
+    rows.push({
       name,
-      type: structDef[name],
+      type: fieldType,
       value,
       address: addr,
       isPointer: typeof value === 'object' && value.type === 'pointer',
       pointerAddress: (typeof value === 'object' && value.type === 'pointer') ? value.address : 0,
       changed: props.changedAddresses.has(addr),
-    }
-  })
+    })
+  }
+  return rows
 })
 </script>
 
diff --git a/src/components/MemoryCell.vue b/src/components/MemoryCell.vue
index d83cc5a..f0c0439 100644
--- a/src/components/MemoryCell.vue
+++ b/src/components/MemoryCell.vue
@@ -2,6 +2,7 @@
 import type { CppType, CppValue, MemoryCell } from '~/composables/interpreter/types'
 import { computed } from 'vue'
 import AddressLink from '~/components/AddressLink.vue'
+import { formatAddr, formatType, formatValue, isPointerValue } from '~/composables/interpreter/helpers'
 import { NULL_ADDRESS } from '~/composables/interpreter/types'
 
 const props = defineProps<{
@@ -18,36 +19,6 @@ const emit = defineEmits<{
   clickCell: [address: number]
 }>()
 
-function formatValue(value: CppValue): string {
-  if (typeof value === 'number' || typeof value === 'boolean')
-    return String(value)
-  if (typeof value === 'object') {
-    if (value.type === 'pointer')
-      return value.address === NULL_ADDRESS ? 'NULL' : `0x${value.address.toString(16).padStart(3, '0')}`
-    if (value.type === 'struct')
-      return `${value.name} {...}`
-    if (value.type === 'array')
-      return `[${value.length}]`
-  }
-  return String(value)
-}
-
-function formatType(type: CppType): string {
-  if (typeof type === 'string')
-    return type
-  if (type.type === 'pointer')
-    return `${formatType(type.to)}*`
-  if (type.type === 'array')
-    return `${formatType(type.of)}[${type.size}]`
-  if (type.type === 'struct')
-    return type.name
-  return '?'
-}
-
-function isPointerValue(value: CppValue): value is { type: 'pointer', address: number } {
-  return typeof value === 'object' && value.type === 'pointer'
-}
-
 const structName = computed(() => {
   if (typeof props.cell.type === 'object' && props.cell.type.type === 'struct')
     return props.cell.type.name
@@ -69,7 +40,7 @@ const structName = computed(() => {
         <span v-if="structName" class="text-sm text-accent-cyan font-bold">{{ structName }}</span>
         <span v-else class="text-sm text-gray-600 dark:text-gray-400">{{ formatType(cell.type) }}</span>
       </div>
-      <span class="text-[10px] text-gray-500 font-mono">{{ `0x${cell.address.toString(16).padStart(3, '0')}` }}</span>
+      <span class="text-[10px] text-gray-500 font-mono">{{ formatAddr(cell.address) }}</span>
     </div>
 
     <!-- Struct with fields -->
diff --git a/src/components/MemoryMap.vue b/src/components/MemoryMap.vue
index bed2dd0..3d969b6 100644
--- a/src/components/MemoryMap.vue
+++ b/src/components/MemoryMap.vue
@@ -4,6 +4,8 @@ import { computed, shallowRef, useTemplateRef, watch } from 'vue'
 import AddressLink from '~/components/AddressLink.vue'
 import DSValue from '~/components/DSValue.vue'
 import MemoryCell from '~/components/MemoryCell.vue'
+import { formatAddr, formatType, formatValue, isPointerValue } from '~/composables/interpreter/helpers'
+import { structFieldOffset, structTotalSize } from '~/composables/interpreter/memory'
 import { NULL_ADDRESS } from '~/composables/interpreter/types'
 import { useInterpreterContext } from '~/composables/useInterpreterContext'
 
@@ -43,50 +45,15 @@ function getFieldValues(cell: MemoryCellType): Map<string, { type: CppType, valu
   if (!structDef)
     return undefined
   const map = new Map<string, { type: CppType, value: CppValue, address: number }>()
-  const fieldNames = Object.keys(structDef)
-  for (let i = 0; i < fieldNames.length; i++) {
-    const fieldAddr = base + 1 + i
+  for (const [fieldName, fieldType] of Object.entries(structDef)) {
+    const fieldAddr = base + 1 + structFieldOffset(fieldName, structDef)
     const fieldCell = context.memory.cells.get(fieldAddr)
     if (fieldCell)
-      map.set(fieldNames[i], { type: structDef[fieldNames[i]], value: fieldCell.value, address: fieldAddr })
+      map.set(fieldName, { type: fieldType, value: fieldCell.value, address: fieldAddr })
   }
   return map
 }
 
-function formatType(type: CppType): string {
-  if (typeof type === 'string')
-    return type
-  if (type.type === 'pointer')
-    return `${formatType(type.to)}*`
-  if (type.type === 'array')
-    return `${formatType(type.of)}[${type.size}]`
-  if (type.type === 'struct')
-    return type.name
-  return '?'
-}
-
-function formatAddr(addr: number): string {
-  return `0x${addr.toString(16).padStart(3, '0')}`
-}
-
-function formatValue(value: CppValue): string {
-  if (typeof value === 'number' || typeof value === 'boolean')
-    return String(value)
-  if (typeof value === 'object') {
-    if (value.type === 'pointer')
-      return value.address === NULL_ADDRESS ? 'NULL' : formatAddr(value.address)
-    if (value.type === 'struct')
-      return `${value.name} {...}`
-    if (value.type === 'array')
-      return `[${value.length}]`
-  }
-  return String(value)
-}
-
-function isPointerValue(value: CppValue): value is { type: 'pointer', address: number } {
-  return typeof value === 'object' && value.type === 'pointer'
-}
-
 function isArrayValue(value: CppValue): value is { type: 'array', base: number, length: number } {
   return typeof value === 'object' && value.type === 'array'
 }
@@ -226,8 +193,9 @@ const heapEntries = computed(() => {
     if (typeof v === 'object' && v.type === 'struct') {
       const structDef = context.structs[v.name]
       if (structDef) {
-        for (let i = 0; i < Object.keys(structDef).length; i++)
-          structFieldAddresses.add(v.base + 1 + i)
+        const total = structTotalSize(structDef)
+        for (let i = 1; i < total; i++)
+          structFieldAddresses.add(v.base + i)
       }
     }
     else if (typeof v === 'object' && v.type === 'array') {
@@ -335,7 +303,9 @@ watch(() => props.highlightedFieldAddress, (addr) => {
                   <div class="pl-2">
                     <DSValue
                       :cell="context.memory.cells.get(field.address)!"
-
+                      :highlighted-field-address="highlightedFieldAddress"
+                      :statement-lhs-addresses="statementLhsAddresses"
+                      :statement-rhs-addresses="statementRhsAddresses"
                       @navigate="handleClickPointer"
                       @hover-node="handleHoverPointerStack"
                     />
@@ -368,6 +338,9 @@ watch(() => props.highlightedFieldAddress, (addr) => {
             <template v-else-if="isArrayValue(entry.cell.value) || (typeof entry.cell.value === 'object' && entry.cell.value.type === 'struct')">
               <DSValue
                 :cell="entry.cell"
+                :highlighted-field-address="highlightedFieldAddress"
+                :statement-lhs-addresses="statementLhsAddresses"
+                :statement-rhs-addresses="statementRhsAddresses"
                 @navigate="handleClickPointer"
                 @hover-node="handleHoverPointerStack"
               />
diff --git a/src/composables/interpreter/declarations.ts b/src/composables/interpreter/declarations.ts
index 9e06600..3faa451 100644
--- a/src/composables/interpreter/declarations.ts
+++ b/src/composables/interpreter/declarations.ts
@@ -2,6 +2,7 @@ import type { Node as SyntaxNode } from 'web-tree-sitter'
 import type { MemoryManager } from './memory'
 import type { CppType, CppValue, InterpreterContext } from './types'
 import { asserts, castIfNull, checksDefined, getGeneratorReturn } from './helpers'
+import { structFieldOffset } from './memory'
 import { NULL_ADDRESS } from './types'
 
 // Circular dependency resolution: evaluate.ts calls processDeclaration,
@@ -143,12 +144,10 @@ export function* initializeValue(
             const fieldDefs = context.structs[type.name]
             const base = mem.allocStruct(type.name, fieldDefs, 'stack')
             // Recursively initialize nested struct/array fields
-            const fieldNames = Object.keys(fieldDefs)
-            for (let i = 0; i < fieldNames.length; i++) {
-              const fieldType = fieldDefs[fieldNames[i]]
+            for (const [fieldName, fieldType] of Object.entries(fieldDefs)) {
               if (typeof fieldType === 'object' && (fieldType.type === 'struct' || fieldType.type === 'array')) {
                 const fieldValue = yield* initializeValue(fieldType, context, mem)
-                mem.write(base + 1 + i, fieldValue)
+                mem.write(base + 1 + structFieldOffset(fieldName, fieldDefs), fieldValue)
               }
             }
             return { type: 'struct', name: type.name, base }
diff --git a/src/composables/interpreter/evaluate.ts b/src/composables/interpreter/evaluate.ts
index 4c03411..81639cd 100644
--- a/src/composables/interpreter/evaluate.ts
+++ b/src/composables/interpreter/evaluate.ts
@@ -174,9 +174,19 @@ function* processAssignment(
   const currentValue = mem.read(addr).value
   if (op !== '=') {
     op = op.slice(0, -1)
-    asserts(op in binaryOps, `Unsupported assignment operator: ${op}`)
-    asserts(typeof currentValue !== 'object' && typeof value !== 'object')
-    value = binaryOps[op](currentValue, castIfNull(type, value) as number | boolean)
+    // Pointer compound assignment (ptr += n, ptr -= n)
+    if (typeof currentValue === 'object' && currentValue.type === 'pointer' && typeof value === 'number') {
+      if (op === '+')
+        value = { type: 'pointer', address: currentValue.address + value }
+      else if (op === '-')
+        value = { type: 'pointer', address: currentValue.address - value }
+      else
+        asserts(false, `Unsupported pointer operator: ${op}`)
+    }
+    else {
+      asserts(op in binaryOps, `Unsupported assignment operator: ${op}`)
+      value = binaryOps[op](currentValue, castIfNull(type, value) as number | boolean)
+    }
   }
   const newValue = castIfNull(type, value)
   mem.write(addr, newValue)
@@ -281,6 +291,37 @@ export function* evaluate(
 
       const lhs = checksDefined(yield* evaluate(node.childForFieldName('left')!, context, mem))
       const rhs = checksDefined(yield* evaluate(node.childForFieldName('right')!, context, mem))
+
+      // Pointer arithmetic: ptr + int, int + ptr, ptr - int, ptr - ptr
+      const lPtr = lhs !== null && typeof lhs === 'object' && lhs.type === 'pointer'
+      const rPtr = rhs !== null && typeof rhs === 'object' && rhs.type === 'pointer'
+      if (lPtr || rPtr) {
+        if (op === '+') {
+          if (lPtr && typeof rhs === 'number')
+            return { type: 'pointer', address: (lhs as { address: number }).address + rhs }
+          if (rPtr && typeof lhs === 'number')
+            return { type: 'pointer', address: (rhs as { address: number }).address + lhs }
+        }
+        if (op === '-') {
+          if (lPtr && typeof rhs === 'number')
+            return { type: 'pointer', address: (lhs as { address: number }).address - rhs }
+          if (lPtr && rPtr)
+            return (lhs as { address: number }).address - (rhs as { address: number }).address
+        }
+        // Pointer comparison
+        if (lPtr && rPtr && (op === '<' || op === '>' || op === '<=' || op === '>=')) {
+          const la = (lhs as { address: number }).address
+          const ra = (rhs as { address: number }).address
+          if (op === '<')
+            return la < ra
+          if (op === '>')
+            return la > ra
+          if (op === '<=')
+            return la <= ra
+          return la >= ra
+        }
+      }
+
       asserts(op in binaryOps, `Unsupported binary operator: ${op}`)
       return binaryOps[op](lhs, rhs)
     }
@@ -297,8 +338,14 @@ export function* evaluate(
       const isPostfix = node.firstChild!.isNamed
       const op = node.childForFieldName('operator')!.text
       asserts(op === '++' || op === '--')
-      asserts(typeof cell.value !== 'object')
       const old = cell.value
+      // Pointer increment/decrement
+      if (typeof old === 'object' && old.type === 'pointer') {
+        const delta = op === '++' ? 1 : -1
+        const newVal: CppValue = { type: 'pointer', address: old.address + delta }
+        mem.write(addr, newVal)
+        return isPostfix ? old : newVal
+      }
       const newVal = binaryOps[op[0]](old, 1)
       mem.write(addr, newVal)
       return isPostfix ? old : newVal
@@ -368,6 +415,15 @@ export function* evaluate(
         throw new StackOverflowError(`Stack overflow: call depth exceeded ${MAX_CALL_DEPTH}`, node)
       const func = node.childForFieldName('function')!
       asserts(func.type === 'identifier')
+
+      // Built-in: breakpoint() pauses execution and stops play mode
+      if (func.text === 'breakpoint') {
+        setCurrentNode(node)
+        context.hitBreakpoint = true
+        yield
+        return null
+      }
+
       asserts(func.text in context.functions)
       const { params, body } = context.functions[func.text]
       const argumentsNode = node.childForFieldName('arguments')!.namedChildren
diff --git a/src/composables/interpreter/helpers.ts b/src/composables/interpreter/helpers.ts
index ef46cde..ae4f516 100644
--- a/src/composables/interpreter/helpers.ts
+++ b/src/composables/interpreter/helpers.ts
@@ -39,6 +39,40 @@ export function isTruthy(value: CppValue | null): boolean {
   }
 }
 
+export function formatType(type: CppType): string {
+  if (typeof type === 'string')
+    return type
+  if (type.type === 'pointer')
+    return `${formatType(type.to)}*`
+  if (type.type === 'array')
+    return `${formatType(type.of)}[${type.size}]`
+  if (type.type === 'struct')
+    return type.name
+  return '?'
+}
+
+export function formatAddr(addr: number): string {
+  return `0x${addr.toString(16).padStart(3, '0')}`
+}
+
+export function formatValue(value: CppValue): string {
+  if (typeof value === 'number' || typeof value === 'boolean')
+    return String(value)
+  if (typeof value === 'object') {
+    if (value.type === 'pointer')
+      return value.address === NULL_ADDRESS ? 'NULL' : formatAddr(value.address)
+    if (value.type === 'struct')
+      return `${value.name} {...}`
+    if (value.type === 'array')
+      return `[${value.length}]`
+  }
+  return String(value)
+}
+
+export function isPointerValue(value: CppValue): value is { type: 'pointer', address: number } {
+  return typeof value === 'object' && value.type === 'pointer'
+}
+
 export function castIfNull(type: CppType, value: CppValue | null): CppValue {
   if (value != null)
     return value
diff --git a/src/composables/interpreter/index.ts b/src/composables/interpreter/index.ts
index 920c974..a13f0a5 100644
--- a/src/composables/interpreter/index.ts
+++ b/src/composables/interpreter/index.ts
@@ -90,6 +90,7 @@ export function useCppInterpreter(tree: MaybeRefOrGetter<Tree | void>) {
     callStack: [] as { env: Record<string, import('./types').EnvEntry>[] }[],
     memory: mem.space,
     currentNode: undefined as import('web-tree-sitter').Node | undefined,
+    hitBreakpoint: false,
   })
 
   let gen: Generator | undefined
@@ -231,7 +232,7 @@ export function useCppInterpreter(tree: MaybeRefOrGetter<Tree | void>) {
     context.memory = { ...mem.space }
   }
 
-  function step() {
+  function step(): { done: boolean, breakpoint: boolean } {
     asserts(gen)
     try {
       const done = !!gen.next().done
@@ -239,9 +240,11 @@ export function useCppInterpreter(tree: MaybeRefOrGetter<Tree | void>) {
       // by the interpreter, bypassing Vue's reactive proxy)
       mem.space.version++
       context.memory = { ...mem.space }
+      const bp = !!context.hitBreakpoint
+      context.hitBreakpoint = false
       if (done)
         isActive.value = false
-      return done
+      return { done, breakpoint: bp }
     }
     catch (e) {
       isActive.value = false
diff --git a/src/composables/interpreter/memory.ts b/src/composables/interpreter/memory.ts
index 023e1e9..1577eae 100644
--- a/src/composables/interpreter/memory.ts
+++ b/src/composables/interpreter/memory.ts
@@ -45,6 +45,7 @@ export interface MemoryManager {
     fieldName: string,
     fieldDefs: Record<string, CppType>,
   ) => [CppType, number]
+  structFieldOffset: (fieldName: string, fieldDefs: Record<string, CppType>) => number
   reset: () => void
 }
 
@@ -58,6 +59,32 @@ function makeNullCell(): MemoryCell {
   }
 }
 
+/** Compute the number of cells a field type occupies (inline arrays expand) */
+function fieldCellCount(type: CppType): number {
+  if (typeof type === 'object' && type.type === 'array')
+    return 1 + type.size // header + elements
+  return 1
+}
+
+/** Compute the cell offset of fieldName within a struct (accounting for inline arrays) */
+export function structFieldOffset(fieldName: string, fieldDefs: Record<string, CppType>): number {
+  let offset = 0
+  for (const [name, type] of Object.entries(fieldDefs)) {
+    if (name === fieldName)
+      return offset
+    offset += fieldCellCount(type)
+  }
+  return -1
+}
+
+/** Compute the total number of cells a struct occupies (header + all fields) */
+export function structTotalSize(fieldDefs: Record<string, CppType>): number {
+  let size = 1 // header
+  for (const type of Object.values(fieldDefs))
+    size += fieldCellCount(type)
+  return size
+}
+
 export function createAddressSpace(): MemoryManager {
   const space: AddressSpace = {
     cells: new Map(),
@@ -107,7 +134,9 @@ export function createAddressSpace(): MemoryManager {
     region: MemoryRegion,
   ): number {
     const fields = Object.entries(fieldDefs)
-    const totalSize = 1 + fields.length // header + fields
+    let totalSize = 1 // header
+    for (const [, type] of fields)
+      totalSize += fieldCellCount(type)
     const base = allocRegion(totalSize, region)
 
     // Header cell
@@ -118,17 +147,43 @@ export function createAddressSpace(): MemoryManager {
       region,
       dead: false,
     })
-    // Field cells at base+1, base+2, ...
-    for (let i = 0; i < fields.length; i++) {
-      const [, fieldType] = fields[i]
-      const fieldAddress = base + 1 + i
-      space.cells.set(fieldAddress, {
-        address: fieldAddress,
-        type: fieldType,
-        value: defaultValue(fieldType),
-        region,
-        dead: false,
-      })
+
+    // Field cells with computed offsets (inline arrays are contiguous)
+    let offset = 1
+    for (const [, fieldType] of fields) {
+      if (typeof fieldType === 'object' && fieldType.type === 'array') {
+        // Inline array: header at base+offset, elements at base+offset+1..
+        const arrBase = base + offset
+        space.cells.set(arrBase, {
+          address: arrBase,
+          type: fieldType,
+          value: { type: 'array', base: arrBase, length: fieldType.size },
+          region,
+          dead: false,
+        })
+        for (let j = 0; j < fieldType.size; j++) {
+          const elemAddr = arrBase + 1 + j
+          space.cells.set(elemAddr, {
+            address: elemAddr,
+            type: fieldType.of,
+            value: defaultValue(fieldType.of),
+            region,
+            dead: false,
+          })
+        }
+        offset += 1 + fieldType.size
+      }
+      else {
+        const fieldAddress = base + offset
+        space.cells.set(fieldAddress, {
+          address: fieldAddress,
+          type: fieldType,
+          value: defaultValue(fieldType),
+          region,
+          dead: false,
+        })
+        offset += 1
+      }
     }
     return base
   }
@@ -212,12 +267,10 @@ export function createAddressSpace(): MemoryManager {
     fieldName: string,
     fieldDefs: Record<string, CppType>,
   ): [CppType, number] {
-    const fields = Object.keys(fieldDefs)
-    const index = fields.indexOf(fieldName)
-    if (index === -1)
+    const offset = structFieldOffset(fieldName, fieldDefs)
+    if (offset === -1)
       throw new Error(`Unknown field: ${fieldName}`)
-    const fieldAddress = structBase + 1 + index
-    return [fieldDefs[fieldName], fieldAddress]
+    return [fieldDefs[fieldName], structBase + 1 + offset]
   }
 
   function reset(): void {
@@ -228,5 +281,5 @@ export function createAddressSpace(): MemoryManager {
     space.cells.set(NULL_ADDRESS, makeNullCell())
   }
 
-  return { space, alloc, allocStruct, allocArray, read, write, free, readField, reset }
+  return { space, alloc, allocStruct, allocArray, read, write, free, readField, structFieldOffset, reset }
 }
diff --git a/src/composables/interpreter/types.ts b/src/composables/interpreter/types.ts
index fe6d0bb..9db9308 100644
--- a/src/composables/interpreter/types.ts
+++ b/src/composables/interpreter/types.ts
@@ -82,6 +82,8 @@ export interface InterpreterContext {
   callStack: { env: Record<string, EnvEntry>[] }[]
   memory: AddressSpace
   currentNode?: SyntaxNode
+  /** Set by breakpoint() builtin — signals play mode to pause */
+  hitBreakpoint?: boolean
 }
 
 export interface UseCppInterpreterReturn {
diff --git a/src/composables/useMonacoEditor.ts b/src/composables/useMonacoEditor.ts
index 8efa9ae..4aa64a4 100644
--- a/src/composables/useMonacoEditor.ts
+++ b/src/composables/useMonacoEditor.ts
@@ -4,11 +4,11 @@ import { useEventListener } from '@vueuse/core'
 // @ts-expect-error: no types
 import { constrainedEditor } from 'constrained-editor-plugin'
 import * as monaco from 'monaco-editor'
-import { computed, onMounted, onUnmounted, shallowRef, watch } from 'vue'
+import { computed, onMounted, onUnmounted, ref, shallowRef, watch } from 'vue'
 
 interface UseMonacoEditorOptions {
   container: Ref<HTMLElement | null>
-  prefixCode: Ref<string>
+  prefixCode?: Ref<string>
   code: Ref<string>
 }
 
@@ -38,7 +38,7 @@ export function findEnclosingFunction(node: SyntaxNode): SyntaxNode {
 }
 
 export function useMonacoEditor(options: UseMonacoEditorOptions) {
-  const { container, prefixCode, code } = options
+  const { container, prefixCode = ref(''), code } = options
 
   const editor = shallowRef<monaco.editor.IStandaloneCodeEditor>()
   const decorations = shallowRef<monaco.editor.IEditorDecorationsCollection>()
diff --git a/src/composables/usePlacementEngine.ts b/src/composables/usePlacementEngine.ts
index d5dfc53..a03c767 100644
--- a/src/composables/usePlacementEngine.ts
+++ b/src/composables/usePlacementEngine.ts
@@ -85,18 +85,6 @@ export function usePlacementEngine(options: PlacementOptions = {}) {
 
   // ---- Occupied rectangles ----
 
-  function getOccupied(excludeKey?: string): Rect[] {
-    const rects: Rect[] = []
-    for (const [k, pos] of positions) {
-      if (k === excludeKey)
-        continue
-      const size = sizes.get(k)
-      if (size)
-        rects.push({ x: pos.x, y: pos.y, w: size.w, h: size.h })
-    }
-    return rects
-  }
-
   function getOccupiedKeyed(excludeKey?: string): { key: string, rect: Rect }[] {
     const rects: { key: string, rect: Rect }[] = []
     for (const [k, pos] of positions) {
@@ -109,6 +97,10 @@ export function usePlacementEngine(options: PlacementOptions = {}) {
     return rects
   }
 
+  function getOccupied(excludeKey?: string): Rect[] {
+    return getOccupiedKeyed(excludeKey).map(item => item.rect)
+  }
+
   // ---- Placement ----
 
   /**
@@ -191,10 +183,14 @@ export function usePlacementEngine(options: PlacementOptions = {}) {
     }
     if (displaced.length > 0) {
       const container = options.containerSize?.()
+      const occupied = getOccupied()
       for (const k of displaced) {
         const s = sizes.get(k)
-        if (s)
-          positions.set(k, findEmptySpace(s.w, s.h, getOccupied(k), container))
+        if (!s)
+          continue
+        const newPos = findEmptySpace(s.w, s.h, occupied, container)
+        positions.set(k, newPos)
+        occupied.push({ x: newPos.x, y: newPos.y, w: s.w, h: s.h })
       }
     }
 
@@ -226,15 +222,16 @@ export function usePlacementEngine(options: PlacementOptions = {}) {
     // Place the target item
     positions.set(key, { x, y })
 
-    // Re-place displaced items
+    // Re-place displaced items using incremental occupied list
     const container = options.containerSize?.()
+    const occupied = getOccupied()
     for (const k of displaced) {
       const size = sizes.get(k)
       if (!size)
         continue
-      const occupied = getOccupied(k)
       const newPos = findEmptySpace(size.w, size.h, occupied, container)
       positions.set(k, newPos)
+      occupied.push({ x: newPos.x, y: newPos.y, w: size.w, h: size.h })
     }
 
     version.value++
@@ -250,11 +247,12 @@ export function usePlacementEngine(options: PlacementOptions = {}) {
     userDragged.clear()
 
     const container = options.containerSize?.()
+    const occupied: Rect[] = []
     for (const { key, w, h } of orderedKeys) {
       sizes.set(key, { w, h })
-      const occupied = getOccupied()
       const pos = findEmptySpace(w, h, occupied, container)
       positions.set(key, pos)
+      occupied.push({ x: pos.x, y: pos.y, w, h })
     }
 
     version.value++
diff --git a/src/composables/usePointerGraph.ts b/src/composables/usePointerGraph.ts
index 3b6c69b..83d09b6 100644
--- a/src/composables/usePointerGraph.ts
+++ b/src/composables/usePointerGraph.ts
@@ -1,5 +1,6 @@
 import type { ArrowStyle, FieldDirection, InterpreterContext } from '~/composables/interpreter/types'
 import { computed } from 'vue'
+import { structFieldOffset } from '~/composables/interpreter/memory'
 import { NULL_ADDRESS } from '~/composables/interpreter/types'
 
 interface PointerEdge {
@@ -13,16 +14,7 @@ interface PointerEdge {
   fallbackStyle?: ArrowStyle
 }
 
-interface DanglingEdge {
-  fromAddress: number
-  fromFieldAddress: number
-  fieldName: string
-  toAddress: number
-  direction: FieldDirection
-  color?: string
-  style?: ArrowStyle
-  fallbackStyle?: ArrowStyle
-}
+type DanglingEdge = PointerEdge
 
 interface GraphNode {
   address: number
@@ -94,61 +86,72 @@ export function usePointerGraph(context: Readonly<InterpreterContext>) {
       const fieldNames = Object.keys(structDef)
       for (let i = 0; i < fieldNames.length; i++) {
         const fieldType = structDef[fieldNames[i]]
-        // Only follow pointer fields that point to struct types
-        if (typeof fieldType !== 'object' || fieldType.type !== 'pointer')
-          continue
-        if (typeof fieldType.to !== 'object' || fieldType.to.type !== 'struct')
-          continue
+        const fieldAddr = base + 1 + structFieldOffset(fieldNames[i], structDef)
+        const meta = context.structFieldMeta[info.structName]?.[fieldNames[i]]
 
-        const fieldAddr = base + 1 + i
-        const fieldCell = context.memory.cells.get(fieldAddr)
-        if (!fieldCell)
-          continue
+        // Collect pointer-to-struct entries: either direct pointer or array of pointers
+        interface PtrEntry { ptrAddr: number, fieldName: string }
+        const ptrEntries: PtrEntry[] = []
 
-        const val = fieldCell.value
-        if (typeof val !== 'object' || val.type !== 'pointer' || val.address === NULL_ADDRESS)
+        if (typeof fieldType === 'object' && fieldType.type === 'pointer'
+          && typeof fieldType.to === 'object' && fieldType.to.type === 'struct') {
+          ptrEntries.push({ ptrAddr: fieldAddr, fieldName: fieldNames[i] })
+        }
+        else if (typeof fieldType === 'object' && fieldType.type === 'array'
+          && typeof fieldType.of === 'object' && fieldType.of.type === 'pointer'
+          && typeof fieldType.of.to === 'object' && fieldType.of.to.type === 'struct') {
+          // Array of pointers to structs — iterate elements
+          const fieldCell = context.memory.cells.get(fieldAddr)
+          if (fieldCell && typeof fieldCell.value === 'object' && fieldCell.value.type === 'array') {
+            for (let j = 0; j < fieldCell.value.length; j++)
+              ptrEntries.push({ ptrAddr: fieldCell.value.base + 1 + j, fieldName: `${fieldNames[i]}[${j}]` })
+          }
+        }
+
+        if (ptrEntries.length === 0)
           continue
 
-        const targetAddr = val.address
-        const meta = context.structFieldMeta[info.structName]?.[fieldNames[i]]
         const direction: FieldDirection = meta?.direction ?? 'right'
         const color = meta?.color
         const style = meta?.style
         const fallbackStyle = meta?.fallbackStyle
 
-        // Resolve target to struct base
-        const targetCell = context.memory.cells.get(targetAddr)
-        if (!targetCell) {
-          danglingEdges.push({ fromAddress: base, fromFieldAddress: fieldAddr, fieldName: fieldNames[i], toAddress: targetAddr, direction, color, style, fallbackStyle })
-          continue
-        }
+        for (const { ptrAddr, fieldName } of ptrEntries) {
+          const ptrCell = context.memory.cells.get(ptrAddr)
+          if (!ptrCell)
+            continue
+          const val = ptrCell.value
+          if (typeof val !== 'object' || val.type !== 'pointer' || val.address === NULL_ADDRESS)
+            continue
 
-        if (targetCell.dead) {
-          danglingEdges.push({ fromAddress: base, fromFieldAddress: fieldAddr, fieldName: fieldNames[i], toAddress: targetAddr, direction, color, style, fallbackStyle })
-          continue
-        }
+          const targetAddr = val.address
+          const targetCell = context.memory.cells.get(targetAddr)
+          if (!targetCell || targetCell.dead) {
+            danglingEdges.push({ fromAddress: base, fromFieldAddress: ptrAddr, fieldName, toAddress: targetAddr, direction, color, style, fallbackStyle })
+            continue
+          }
 
-        // Resolve to struct base
-        const targetBase = (typeof targetCell.value === 'object' && targetCell.value.type === 'struct')
-          ? targetCell.value.base
-          : targetAddr
+          const targetBase = (typeof targetCell.value === 'object' && targetCell.value.type === 'struct')
+            ? targetCell.value.base
+            : targetAddr
 
-        if (!nodes.has(targetBase))
-          continue
+          if (!nodes.has(targetBase))
+            continue
 
-        const edge: PointerEdge = {
-          fromAddress: base,
-          fromFieldAddress: fieldAddr,
-          fieldName: fieldNames[i],
-          toAddress: targetBase,
-          direction,
-          color,
-          style,
-          fallbackStyle,
-        }
+          const edge: PointerEdge = {
+            fromAddress: base,
+            fromFieldAddress: ptrAddr,
+            fieldName,
+            toAddress: targetBase,
+            direction,
+            color,
+            style,
+            fallbackStyle,
+          }
 
-        nodes.get(base)!.outEdges.push(edge)
-        nodes.get(targetBase)!.inEdges.push(edge)
+          nodes.get(base)!.outEdges.push(edge)
+          nodes.get(targetBase)!.inEdges.push(edge)
+        }
       }
     }
 
diff --git a/src/composables/useStatementAddresses.ts b/src/composables/useStatementAddresses.ts
index cce263f..270f58d 100644
--- a/src/composables/useStatementAddresses.ts
+++ b/src/composables/useStatementAddresses.ts
@@ -2,6 +2,7 @@ import type { Ref } from 'vue'
 import type { Node as SyntaxNode } from 'web-tree-sitter'
 import type { InterpreterContext } from '~/composables/interpreter/types'
 import { computed } from 'vue'
+import { structFieldOffset } from '~/composables/interpreter/memory'
 import { NULL_ADDRESS } from '~/composables/interpreter/types'
 
 /**
@@ -118,14 +119,15 @@ function collectIdentifierAddresses(
       resolveVarAddress(node.text, context, addrs)
       break
     case 'field_expression': {
-      // For `node->field` or `node.field`, resolve the base object AND the field
-      const arg = node.childForFieldName('argument')
-      if (arg)
-        collectIdentifierAddresses(arg, context, addrs)
-      // Also resolve the specific field address
+      // For `node->field` or `node.field`, resolve the specific field address
       resolveFieldAddress(node, context, addrs)
       break
     }
+    case 'subscript_expression': {
+      // For `arr[i]` or `node->keys[i]`, resolve the element address
+      resolveSubscriptAddress(node, context, addrs)
+      break
+    }
     case 'pointer_expression':
     case 'unary_expression':
     case 'update_expression':
@@ -238,11 +240,9 @@ function resolveFieldAddress(node: SyntaxNode, context: Readonly<InterpreterCont
     const structDef = context.structs[targetCell.value.name]
     if (!structDef)
       return
-    const fieldIdx = Object.keys(structDef).indexOf(fieldName)
-    if (fieldIdx >= 0) {
-      addrs.add(targetCell.value.base + 1 + fieldIdx)
-      addrs.add(val.address) // Also highlight the struct itself
-    }
+    const offset = structFieldOffset(fieldName, structDef)
+    if (offset >= 0)
+      addrs.add(targetCell.value.base + 1 + offset)
   }
   else if (operator.text === '.') {
     // Direct struct access
@@ -257,6 +257,99 @@ function resolveFieldAddress(node: SyntaxNode, context: Readonly<InterpreterCont
   }
 }
 
+/**
+ * For subscript_expression like `arr[i]` or `node->keys[i]`, resolve the
+ * actual array element address.
+ */
+/** Try to resolve an index expression to a number (literal or variable lookup) */
+function resolveIndex(node: SyntaxNode, context: Readonly<InterpreterContext>): number | undefined {
+  if (node.type === 'number_literal')
+    return Number.parseInt(node.text)
+  if (node.type === 'identifier') {
+    // Look up variable value
+    for (let i = context.envStack.length - 1; i >= 0; i--) {
+      if (node.text in context.envStack[i]) {
+        const val = context.memory.cells.get(context.envStack[i][node.text].address)?.value
+        return typeof val === 'number' ? val : undefined
+      }
+    }
+    if (node.text in context.globalEnv) {
+      const val = context.memory.cells.get(context.globalEnv[node.text].address)?.value
+      return typeof val === 'number' ? val : undefined
+    }
+  }
+  // Binary expression (e.g. j + 1): try to evaluate simple cases
+  if (node.type === 'binary_expression') {
+    const left = node.childForFieldName('left')
+    const right = node.childForFieldName('right')
+    const op = node.childForFieldName('operator')?.text
+    if (left && right && op) {
+      const l = resolveIndex(left, context)
+      const r = resolveIndex(right, context)
+      if (l !== undefined && r !== undefined) {
+        if (op === '+')
+          return l + r
+        if (op === '-')
+          return l - r
+      }
+    }
+  }
+  return undefined
+}
+
+function resolveSubscriptAddress(node: SyntaxNode, context: Readonly<InterpreterContext>, addrs: Set<number>) {
+  const arrayNode = node.childForFieldName('argument')
+  const indexNode = node.childForFieldName('indices')
+  if (!arrayNode || !indexNode)
+    return
+
+  const idxChild = indexNode.namedChildren[0]
+  if (!idxChild)
+    return
+  const idx = resolveIndex(idxChild, context)
+  if (idx === undefined)
+    return
+
+  // field_expression: node->keys[i]
+  if (arrayNode.type === 'field_expression') {
+    resolveFieldAddress(arrayNode, context, addrs)
+    const lastAddr = [...addrs].at(-1)
+    if (lastAddr === undefined)
+      return
+    const fieldCell = context.memory.cells.get(lastAddr)
+    if (!fieldCell)
+      return
+    const arrVal = fieldCell.value
+    if (typeof arrVal !== 'object' || arrVal.type !== 'array')
+      return
+    addrs.delete(lastAddr)
+    addrs.add(arrVal.base + 1 + idx)
+    return
+  }
+
+  // identifier: arr[i]
+  if (arrayNode.type === 'identifier') {
+    let varAddr: number | undefined
+    for (let i = context.envStack.length - 1; i >= 0; i--) {
+      if (arrayNode.text in context.envStack[i]) {
+        varAddr = context.envStack[i][arrayNode.text].address
+        break
+      }
+    }
+    if (varAddr === undefined && arrayNode.text in context.globalEnv)
+      varAddr = context.globalEnv[arrayNode.text].address
+    if (varAddr === undefined)
+      return
+    const cell = context.memory.cells.get(varAddr)
+    if (!cell)
+      return
+    const arrVal = cell.value
+    if (typeof arrVal !== 'object' || arrVal.type !== 'array')
+      return
+    addrs.add(arrVal.base + 1 + idx)
+  }
+}
+
 function extractBaseIdentifier(node: SyntaxNode): string | null {
   switch (node.type) {
     case 'identifier':
diff --git a/src/pages/index.vue b/src/pages/index.vue
index d46cc96..32f6204 100644
--- a/src/pages/index.vue
+++ b/src/pages/index.vue
@@ -33,8 +33,6 @@ const templates = Object.fromEntries(Object.entries(
 const templateNames = Object.keys(templates)
 const selectedTemplateName = useLocalStorage('selected-template', 'singly-insertBack')
 
-// No prefix code — all templates include their own struct definitions
-const prefixCode = computed(() => '')
 const code = useLocalStorage('code', templates[selectedTemplateName.value] ?? '')
 if (queryParams.has('code')) {
   const queryCode = queryParams.get('code')!
@@ -58,7 +56,6 @@ const {
   highlightVariable,
 } = useMonacoEditor({
   container: monacoContainer,
-  prefixCode,
   code,
 })
 
@@ -190,9 +187,9 @@ function handlePause() {
 function runStep() {
   try {
     snapshot()
-    const done = step()
+    const { done, breakpoint } = step()
     diff()
-    if (done)
+    if (done || breakpoint)
       pause()
   }
   catch (e) {
@@ -220,11 +217,11 @@ function handleStep() {
 
 const speedLabel = computed(() => {
   const ms = speedMs.value
-  if (ms <= 50)
-    return 'fast'
   if (ms <= 150)
-    return 'med'
+    return 'fast'
   if (ms <= 300)
+    return 'med'
+  if (ms <= 500)
     return 'slow'
   return 'slower'
 })
diff --git a/src/templates/general/bst-delete.cpp b/src/templates/general/bst-delete.cpp
index 90ff5b6..43092b4 100644
--- a/src/templates/general/bst-delete.cpp
+++ b/src/templates/general/bst-delete.cpp
@@ -75,5 +75,6 @@ int main() {
   // Delete node with two children
   root = deleteNode(root, 5);
 
+  breakpoint();
   return 0;
 }
diff --git a/src/templates/general/bst-freeAll.cpp b/src/templates/general/bst-freeAll.cpp
index ee42b4f..31c00e3 100644
--- a/src/templates/general/bst-freeAll.cpp
+++ b/src/templates/general/bst-freeAll.cpp
@@ -45,5 +45,6 @@ int main() {
 
   freeTree(root);
 
+  breakpoint();
   return 0;
 }
diff --git a/src/templates/general/bst-insert.cpp b/src/templates/general/bst-insert.cpp
index 44c69c3..bff56ee 100644
--- a/src/templates/general/bst-insert.cpp
+++ b/src/templates/general/bst-insert.cpp
@@ -32,5 +32,6 @@ int main() {
   root = insert(root, 1);
   root = insert(root, 4);
 
+  breakpoint();
   return 0;
 }
diff --git a/src/templates/general/bst-search.cpp b/src/templates/general/bst-search.cpp
index 48eeeb2..8a6c2bf 100644
--- a/src/templates/general/bst-search.cpp
+++ b/src/templates/general/bst-search.cpp
@@ -48,5 +48,6 @@ int main() {
   TreeNode *found = search(root, 4);
   TreeNode *notFound = search(root, 6);
 
+  breakpoint();
   return 0;
 }
diff --git a/src/templates/general/btree.cpp b/src/templates/general/btree.cpp
new file mode 100644
index 0000000..7d46ce6
--- /dev/null
+++ b/src/templates/general/btree.cpp
@@ -0,0 +1,58 @@
+// Simple B-tree (order 3) constructed manually.
+// Each node has up to 2 keys and 3 children.
+struct BTreeNode {
+  int numKeys;
+  int keys[3];
+  BTreeNode *children[4];
+};
+
+int main() {
+  // Root: keys [10, 20]
+  BTreeNode *root = new BTreeNode;
+  root->numKeys = 2;
+  root->keys[0] = 10;
+  root->keys[1] = 20;
+  root->keys[2] = 0;
+
+  // Left child: keys [3, 7]
+  BTreeNode *left = new BTreeNode;
+  left->numKeys = 2;
+  left->keys[0] = 3;
+  left->keys[1] = 7;
+  left->keys[2] = 0;
+  left->children[0] = nullptr;
+  left->children[1] = nullptr;
+  left->children[2] = nullptr;
+  left->children[3] = nullptr;
+
+  // Middle child: keys [14]
+  BTreeNode *mid = new BTreeNode;
+  mid->numKeys = 1;
+  mid->keys[0] = 14;
+  mid->keys[1] = 0;
+  mid->keys[2] = 0;
+  mid->children[0] = nullptr;
+  mid->children[1] = nullptr;
+  mid->children[2] = nullptr;
+  mid->children[3] = nullptr;
+
+  // Right child: keys [25, 30]
+  BTreeNode *right = new BTreeNode;
+  right->numKeys = 2;
+  right->keys[0] = 25;
+  right->keys[1] = 30;
+  right->keys[2] = 0;
+  right->children[0] = nullptr;
+  right->children[1] = nullptr;
+  right->children[2] = nullptr;
+  right->children[3] = nullptr;
+
+  // Wire up root's children
+  root->children[0] = left;
+  root->children[1] = mid;
+  root->children[2] = right;
+  root->children[3] = nullptr;
+
+  breakpoint();
+  return 0;
+}
diff --git a/src/templates/general/bubble-sort.cpp b/src/templates/general/bubble-sort.cpp
new file mode 100644
index 0000000..f6b1311
--- /dev/null
+++ b/src/templates/general/bubble-sort.cpp
@@ -0,0 +1,29 @@
+// Bubble sort on a small integer array.
+// Demonstrates array visualization with in-place swapping.
+int main() {
+  int arr[6];
+  arr[0] = 5;
+  arr[1] = 3;
+  arr[2] = 8;
+  arr[3] = 1;
+  arr[4] = 4;
+  arr[5] = 2;
+
+  int n = 6;
+  int i = 0;
+  while (i < n - 1) {
+    int j = 0;
+    while (j < n - 1 - i) {
+      if (arr[j] > arr[j + 1]) {
+        int temp = arr[j];
+        arr[j] = arr[j + 1];
+        arr[j + 1] = temp;
+      }
+      j = j + 1;
+    }
+    i = i + 1;
+  }
+
+  breakpoint();
+  return 0;
+}
diff --git a/src/templates/general/doubly-insertBack.cpp b/src/templates/general/doubly-insertBack.cpp
index dfc15ed..5852ad5 100644
--- a/src/templates/general/doubly-insertBack.cpp
+++ b/src/templates/general/doubly-insertBack.cpp
@@ -45,5 +45,6 @@ int main() {
   insertBack(&head, 2);
   insertBack(&head, 3);
 
+  breakpoint();
   return 0;
 }
diff --git a/src/templates/general/singly-delete.cpp b/src/templates/general/singly-delete.cpp
index 7aaf7ba..36b1bba 100644
--- a/src/templates/general/singly-delete.cpp
+++ b/src/templates/general/singly-delete.cpp
@@ -54,5 +54,6 @@ int main() {
   insertBack(&head, 4);
   deleteNode(&head, 3);
 
+  breakpoint();
   return 0;
 }
diff --git a/src/templates/general/singly-freeAll.cpp b/src/templates/general/singly-freeAll.cpp
index 0434103..fe88219 100644
--- a/src/templates/general/singly-freeAll.cpp
+++ b/src/templates/general/singly-freeAll.cpp
@@ -39,5 +39,6 @@ int main() {
   insertBack(&head, 30);
   freeAll(&head);
 
+  breakpoint();
   return 0;
 }
diff --git a/src/templates/general/singly-insertBack.cpp b/src/templates/general/singly-insertBack.cpp
index a60ed43..b0eadae 100644
--- a/src/templates/general/singly-insertBack.cpp
+++ b/src/templates/general/singly-insertBack.cpp
@@ -28,5 +28,6 @@ int main() {
   insertBack(&head, 2);
   insertBack(&head, 3);
 
+  breakpoint();
   return 0;
 }
diff --git a/src/templates/general/singly-insertFront.cpp b/src/templates/general/singly-insertFront.cpp
index 3a2064d..f0b2404 100644
--- a/src/templates/general/singly-insertFront.cpp
+++ b/src/templates/general/singly-insertFront.cpp
@@ -18,5 +18,6 @@ int main() {
   insertFront(&head, 2);
   insertFront(&head, 1);
 
+  breakpoint();
   return 0;
 }
diff --git a/src/templates/general/singly-loop.cpp b/src/templates/general/singly-loop.cpp
index cb73cc3..22518bf 100644
--- a/src/templates/general/singly-loop.cpp
+++ b/src/templates/general/singly-loop.cpp
@@ -36,5 +36,6 @@ int main() {
   }
   last->next = head->next;
 
+  breakpoint();
   return 0;
 }
diff --git a/src/templates/general/singly-reverse.cpp b/src/templates/general/singly-reverse.cpp
index 3294d50..ccd42b0 100644
--- a/src/templates/general/singly-reverse.cpp
+++ b/src/templates/general/singly-reverse.cpp
@@ -46,5 +46,6 @@ int main() {
   insertBack(&head, 5);
   reverse(&head);
 
+  breakpoint();
   return 0;
 }
diff --git a/src/templates/general/tree-cycle.cpp b/src/templates/general/tree-cycle.cpp
index 4b862ef..76500cb 100644
--- a/src/templates/general/tree-cycle.cpp
+++ b/src/templates/general/tree-cycle.cpp
@@ -29,5 +29,6 @@ int main() {
   // Introduce a cycle: c's left points back to a
   c->left = a;
 
+  breakpoint();
   return 0;
 }
diff --git a/src/templates/general/tree-dangling.cpp b/src/templates/general/tree-dangling.cpp
index 8cf4a7a..d4b7733 100644
--- a/src/templates/general/tree-dangling.cpp
+++ b/src/templates/general/tree-dangling.cpp
@@ -36,5 +36,6 @@ int main() {
   // root->left still points to the freed address.
   delete left;
 
+  breakpoint();
   return 0;
 }
diff --git a/src/templates/general/tree-rebuild.cpp b/src/templates/general/tree-rebuild.cpp
index da3780d..cd83248 100644
--- a/src/templates/general/tree-rebuild.cpp
+++ b/src/templates/general/tree-rebuild.cpp
@@ -30,5 +30,6 @@ int main() {
   root->left = nullptr;
   root->right->right = detached;
 
+  breakpoint();
   return 0;
 }
diff --git a/src/templates/general/tree-skewed.cpp b/src/templates/general/tree-skewed.cpp
index 3bce4bb..6f35c84 100644
--- a/src/templates/general/tree-skewed.cpp
+++ b/src/templates/general/tree-skewed.cpp
@@ -35,5 +35,6 @@ int main() {
   root = insert(root, 4);
   root = insert(root, 5);
 
+  breakpoint();
   return 0;
 }
diff --git a/test/e2e/visualization.spec.ts b/test/e2e/visualization.spec.ts
index 6beb40b..fe2eb47 100644
--- a/test/e2e/visualization.spec.ts
+++ b/test/e2e/visualization.spec.ts
@@ -5,7 +5,7 @@ async function stepN(page: import('@playwright/test').Page, n: number) {
   const btn = page.getByTestId('btn-step')
   for (let i = 0; i < n; i++) {
     await btn.click()
-    await page.waitForTimeout(60)
+    await page.waitForTimeout(100)
   }
 }
 
@@ -23,7 +23,7 @@ test.describe('memory map', () => {
     const stackColumn = page.getByTestId('stack-column')
     await expect(stackColumn).toBeVisible()
     const entries = stackColumn.locator('[data-testid^="stack-entry-"]')
-    await expect(entries.first()).toBeVisible()
+    await expect(entries.first()).toBeVisible({ timeout: 10_000 })
   })
 
   test('shows heap allocations after new ListNode', async ({ page }) => {
diff --git a/test/interpreter/evaluate.test.ts b/test/interpreter/evaluate.test.ts
index b1383db..070f0b9 100644
--- a/test/interpreter/evaluate.test.ts
+++ b/test/interpreter/evaluate.test.ts
@@ -1381,69 +1381,3 @@ describe('field annotations (@arrow-*)', () => {
     expect(context.structMeta.TreeNode).toEqual({ arrowSize: 40 })
   })
 })
-
-// ── Scope cleanup ────────────────────────────────────────────────
-
-describe('scope cleanup', () => {
-  it('marks function parameters dead on return', () => {
-    const { context } = safeRunProgram(`
-      void foo(int x, int y) {}
-      void main() {
-        foo(10, 20);
-      }
-    `)
-    // After foo returns, the stack cells for x and y should be dead
-    const liveCells = [...context.memory.cells.values()].filter(c => !c.dead && c.region === 'stack')
-    // Only main's variables should remain (none in this case)
-    expect(liveCells).toHaveLength(0)
-  })
-
-  it('marks struct field cells dead on delete', () => {
-    const { context } = safeRunProgram(`
-      struct Node { int data; Node *next; };
-      void main() {
-        Node *n = new Node;
-        n->data = 42;
-        n->next = nullptr;
-        delete n;
-      }
-    `)
-    // After delete, all 3 cells (header + data + next) should be dead
-    const liveHeap = [...context.memory.cells.values()].filter(c => !c.dead && c.region === 'heap')
-    expect(liveHeap).toHaveLength(0)
-  })
-
-  it('cleans up all locals after insertBack+freeAll', () => {
-    const { context } = safeRunProgram(`
-      struct ListNode { int data; ListNode *next; };
-      void insertBack(ListNode **head, int data) {
-        ListNode *node = new ListNode;
-        node->data = data;
-        node->next = nullptr;
-        if (*head == nullptr) { *head = node; return; }
-        ListNode *cur = *head;
-        while (cur->next != nullptr) { cur = cur->next; }
-        cur->next = node;
-      }
-      void freeAll(ListNode **head) {
-        ListNode *curr = *head;
-        while (curr != nullptr) {
-          ListNode *next = curr->next;
-          delete curr;
-          curr = next;
-        }
-        *head = nullptr;
-      }
-      void main() {
-        ListNode *head = nullptr;
-        insertBack(&head, 10);
-        insertBack(&head, 20);
-        insertBack(&head, 30);
-        freeAll(&head);
-      }
-    `)
-    // After program completes, all cells should be dead (including main's locals)
-    const liveCells = [...context.memory.cells.values()].filter(c => !c.dead && c.address !== 0)
-    expect(liveCells).toHaveLength(0)
-  })
-})
diff --git a/test/interpreter/programs.test.ts b/test/interpreter/programs.test.ts
index 187abdd..a4d0548 100644
--- a/test/interpreter/programs.test.ts
+++ b/test/interpreter/programs.test.ts
@@ -252,4 +252,234 @@ describe('interpreter integration tests', () => {
     const sumAddr = context.globalEnv.sum.address
     expect(mem.read(sumAddr).value).toBe(6)
   })
+
+  it('constructs a B-tree with array fields', () => {
+    const { mem } = runProgram(`
+      struct BTreeNode {
+        int numKeys;
+        int keys[3];
+        BTreeNode *children[4];
+      };
+      void main() {
+        BTreeNode *root = new BTreeNode;
+        root->numKeys = 2;
+        root->keys[0] = 10;
+        root->keys[1] = 20;
+        root->keys[2] = 0;
+        root->children[0] = nullptr;
+        root->children[1] = nullptr;
+        root->children[2] = nullptr;
+        root->children[3] = nullptr;
+      }
+    `)
+
+    // Find the BTreeNode struct on the heap
+    const heapCells = [...mem.space.cells.values()].filter(c =>
+      !c.dead && c.region === 'heap' && typeof c.value === 'object' && c.value.type === 'struct',
+    )
+    expect(heapCells.length).toBeGreaterThanOrEqual(1)
+    const rootCell = heapCells[0]
+    const rootBase = (rootCell.value as any).base
+
+    // Verify inline memory layout:
+    // BTreeNode { int numKeys; int keys[3]; BTreeNode *children[4]; }
+    // Layout: [header] [numKeys] [keys_hdr] [k0] [k1] [k2] [children_hdr] [c0] [c1] [c2] [c3]
+    // Offsets:  +0       +1       +2         +3   +4   +5   +6              +7   +8   +9   +10
+
+    // numKeys at offset 1
+    expect(mem.read(rootBase + 1).value).toBe(2)
+
+    // keys array header at offset 2 (inline, base === rootBase + 2)
+    const keysValue = mem.read(rootBase + 2).value
+    expect(typeof keysValue).toBe('object')
+    expect((keysValue as any).type).toBe('array')
+    expect((keysValue as any).base).toBe(rootBase + 2) // inline: array base IS the field address
+
+    // keys elements are contiguous after the header
+    expect(mem.read(rootBase + 3).value).toBe(10) // keys[0]
+    expect(mem.read(rootBase + 4).value).toBe(20) // keys[1]
+    expect(mem.read(rootBase + 5).value).toBe(0) // keys[2]
+
+    // children array header at offset 6
+    const childrenValue = mem.read(rootBase + 6).value
+    expect(typeof childrenValue).toBe('object')
+    expect((childrenValue as any).type).toBe('array')
+    expect((childrenValue as any).base).toBe(rootBase + 6)
+
+    // children[0..3] are pointers at offsets 7..10
+    const c0 = mem.read(rootBase + 7).value
+    expect(typeof c0).toBe('object')
+    expect((c0 as any).type).toBe('pointer')
+
+    // Total struct size: 1 (header) + 1 (numKeys) + 4 (keys) + 5 (children) = 11 cells
+    // All 11 cells should be in the same contiguous block
+    for (let i = 0; i < 11; i++) {
+      const cell = mem.space.cells.get(rootBase + i)
+      expect(cell).toBeDefined()
+      expect(cell!.region).toBe('heap')
+    }
+  })
+})
+
+describe('scope cleanup', () => {
+  it('marks function parameters dead on return', () => {
+    const { context } = runProgram(`
+      void foo(int x, int y) {}
+      void main() {
+        foo(10, 20);
+      }
+    `)
+    const liveCells = [...context.memory.cells.values()].filter(c => !c.dead && c.region === 'stack')
+    expect(liveCells).toHaveLength(0)
+  })
+
+  it('marks struct field cells dead on delete', () => {
+    const { context } = runProgram(`
+      struct Node { int data; Node *next; };
+      void main() {
+        Node *n = new Node;
+        n->data = 42;
+        n->next = nullptr;
+        delete n;
+      }
+    `)
+    const liveHeap = [...context.memory.cells.values()].filter(c => !c.dead && c.region === 'heap')
+    expect(liveHeap).toHaveLength(0)
+  })
+
+  it('cleans up all locals after insertBack+freeAll', () => {
+    const { context } = runProgram(`
+      struct ListNode { int data; ListNode *next; };
+      void insertBack(ListNode **head, int data) {
+        ListNode *node = new ListNode;
+        node->data = data;
+        node->next = nullptr;
+        if (*head == nullptr) { *head = node; return; }
+        ListNode *cur = *head;
+        while (cur->next != nullptr) { cur = cur->next; }
+        cur->next = node;
+      }
+      void freeAll(ListNode **head) {
+        ListNode *curr = *head;
+        while (curr != nullptr) {
+          ListNode *next = curr->next;
+          delete curr;
+          curr = next;
+        }
+        *head = nullptr;
+      }
+      void main() {
+        ListNode *head = nullptr;
+        insertBack(&head, 10);
+        insertBack(&head, 20);
+        insertBack(&head, 30);
+        freeAll(&head);
+      }
+    `)
+    const liveCells = [...context.memory.cells.values()].filter(c => !c.dead && c.address !== 0)
+    expect(liveCells).toHaveLength(0)
+  })
+})
+
+describe('pointer arithmetic', () => {
+  it('ptr + int offsets the address', () => {
+    const { context, mem } = runProgram(`
+      int sum = 0;
+      void main() {
+        int arr[3];
+        arr[0] = 10;
+        arr[1] = 20;
+        arr[2] = 30;
+        int *p = &arr[0];
+        sum = *(p + 1);
+      }
+    `)
+    expect(mem.read(context.globalEnv.sum.address).value).toBe(20)
+  })
+
+  it('ptr - int offsets the address backwards', () => {
+    const { context, mem } = runProgram(`
+      int result = 0;
+      void main() {
+        int arr[3];
+        arr[0] = 100;
+        arr[1] = 200;
+        arr[2] = 300;
+        int *p = &arr[2];
+        result = *(p - 2);
+      }
+    `)
+    expect(mem.read(context.globalEnv.result.address).value).toBe(100)
+  })
+
+  it('ptr - ptr gives integer difference', () => {
+    const { context, mem } = runProgram(`
+      int diff = 0;
+      void main() {
+        int arr[5];
+        arr[0] = 0;
+        arr[1] = 0;
+        arr[2] = 0;
+        arr[3] = 0;
+        arr[4] = 0;
+        int *p1 = &arr[1];
+        int *p2 = &arr[4];
+        diff = p2 - p1;
+      }
+    `)
+    expect(mem.read(context.globalEnv.diff.address).value).toBe(3)
+  })
+
+  it('pointer comparison works', () => {
+    const { context, mem } = runProgram(`
+      int result = 0;
+      void main() {
+        int arr[3];
+        arr[0] = 0;
+        arr[1] = 0;
+        arr[2] = 0;
+        int *a = &arr[0];
+        int *b = &arr[2];
+        if (a < b) { result = 1; }
+      }
+    `)
+    expect(mem.read(context.globalEnv.result.address).value).toBe(1)
+  })
+
+  it('pointer increment and decrement work', () => {
+    const { context, mem } = runProgram(`
+      int val = 0;
+      void main() {
+        int arr[3];
+        arr[0] = 10;
+        arr[1] = 20;
+        arr[2] = 30;
+        int *p = &arr[0];
+        p++;
+        p++;
+        val = *p;
+      }
+    `)
+    expect(mem.read(context.globalEnv.val.address).value).toBe(30)
+  })
+
+  it('iterates array with pointer loop', () => {
+    const { context, mem } = runProgram(`
+      int sum = 0;
+      void main() {
+        int arr[4];
+        arr[0] = 1;
+        arr[1] = 2;
+        arr[2] = 3;
+        arr[3] = 4;
+        int *p = &arr[0];
+        int *end = &arr[3] + 1;
+        while (p < end) {
+          sum = sum + *p;
+          p++;
+        }
+      }
+    `)
+    expect(mem.read(context.globalEnv.sum.address).value).toBe(10)
+  })
 })