@vsuryav/agent-sim 0.1.0

package/src/engine/ink/measure-element.ts

@@ -0,0 +1,23 @@
+import type { DOMElement } from './dom.js'
+
+type Output = {
+  /**
+   * Element width.
+   */
+  width: number
+
+  /**
+   * Element height.
+   */
+  height: number
+}
+
+/**
+ * Measure the dimensions of a particular `<Box>` element.
+ */
+const measureElement = (node: DOMElement): Output => ({
+  width: node.yogaNode?.getComputedWidth() ?? 0,
+  height: node.yogaNode?.getComputedHeight() ?? 0,
+})
+
+export default measureElement

package/src/engine/ink/measure-text.ts

@@ -0,0 +1,47 @@
+import { lineWidth } from './line-width-cache.js'
+
+type Output = {
+  width: number
+  height: number
+}
+
+// Single-pass measurement: computes both width and height in one
+// iteration instead of two (widestLine + countVisualLines).
+// Uses indexOf to avoid array allocation from split('\n').
+function measureText(text: string, maxWidth: number): Output {
+  if (text.length === 0) {
+    return {
+      width: 0,
+      height: 0,
+    }
+  }
+
+  // Infinite or non-positive width means no wrapping — each line is one visual line.
+  // Must check before the loop since Math.ceil(w / Infinity) = 0.
+  const noWrap = maxWidth <= 0 || !Number.isFinite(maxWidth)
+
+  let height = 0
+  let width = 0
+  let start = 0
+
+  while (start <= text.length) {
+    const end = text.indexOf('\n', start)
+    const line = end === -1 ? text.substring(start) : text.substring(start, end)
+
+    const w = lineWidth(line)
+    width = Math.max(width, w)
+
+    if (noWrap) {
+      height++
+    } else {
+      height += w === 0 ? 1 : Math.ceil(w / maxWidth)
+    }
+
+    if (end === -1) break
+    start = end + 1
+  }
+
+  return { width, height }
+}
+
+export default measureText

package/src/engine/ink/node-cache.ts

@@ -0,0 +1,54 @@
+import type { DOMElement } from './dom.js'
+import type { Rectangle } from './layout/geometry.js'
+
+/**
+ * Cached layout bounds for each rendered node (used for blit + clearing).
+ * `top` is the yoga-local getComputedTop() — stored so ScrollBox viewport
+ * culling can skip yoga reads for clean children whose position hasn't
+ * shifted (O(dirty) instead of O(mounted) first-pass).
+ */
+export type CachedLayout = {
+  x: number
+  y: number
+  width: number
+  height: number
+  top?: number
+}
+
+export const nodeCache = new WeakMap<DOMElement, CachedLayout>()
+
+/** Rects of removed children that need clearing on next render */
+export const pendingClears = new WeakMap<DOMElement, Rectangle[]>()
+
+/**
+ * Set when a pendingClear is added for an absolute-positioned node.
+ * Signals renderer to disable blit for the next frame: the removed node
+ * may have painted over non-siblings (e.g. an overlay over a ScrollBox
+ * earlier in tree order), so their blits from prevScreen would restore
+ * the overlay's pixels. Normal-flow removals are already handled by
+ * hasRemovedChild at the parent level; only absolute positioning paints
+ * cross-subtree. Reset at the start of each render.
+ */
+let absoluteNodeRemoved = false
+
+export function addPendingClear(
+  parent: DOMElement,
+  rect: Rectangle,
+  isAbsolute: boolean,
+): void {
+  const existing = pendingClears.get(parent)
+  if (existing) {
+    existing.push(rect)
+  } else {
+    pendingClears.set(parent, [rect])
+  }
+  if (isAbsolute) {
+    absoluteNodeRemoved = true
+  }
+}
+
+export function consumeAbsoluteRemovedFlag(): boolean {
+  const had = absoluteNodeRemoved
+  absoluteNodeRemoved = false
+  return had
+}

package/src/engine/ink/optimizer.ts

@@ -0,0 +1,93 @@
+import type { Diff } from './frame.js'
+
+/**
+ * Optimize a diff by applying all optimization rules in a single pass.
+ * This reduces the number of patches that need to be written to the terminal.
+ *
+ * Rules applied:
+ * - Remove empty stdout patches
+ * - Merge consecutive cursorMove patches
+ * - Remove no-op cursorMove (0,0) patches
+ * - Concat adjacent style patches (transition diffs — can't drop either)
+ * - Dedupe consecutive hyperlinks with same URI
+ * - Cancel cursor hide/show pairs
+ * - Remove clear patches with count 0
+ */
+export function optimize(diff: Diff): Diff {
+  if (diff.length <= 1) {
+    return diff
+  }
+
+  const result: Diff = []
+  let len = 0
+
+  for (const patch of diff) {
+    const type = patch.type
+
+    // Skip no-ops
+    if (type === 'stdout') {
+      if (patch.content === '') continue
+    } else if (type === 'cursorMove') {
+      if (patch.x === 0 && patch.y === 0) continue
+    } else if (type === 'clear') {
+      if (patch.count === 0) continue
+    }
+
+    // Try to merge with previous patch
+    if (len > 0) {
+      const lastIdx = len - 1
+      const last = result[lastIdx]!
+      const lastType = last.type
+
+      // Merge consecutive cursorMove
+      if (type === 'cursorMove' && lastType === 'cursorMove') {
+        result[lastIdx] = {
+          type: 'cursorMove',
+          x: last.x + patch.x,
+          y: last.y + patch.y,
+        }
+        continue
+      }
+
+      // Collapse consecutive cursorTo (only the last one matters)
+      if (type === 'cursorTo' && lastType === 'cursorTo') {
+        result[lastIdx] = patch
+        continue
+      }
+
+      // Concat adjacent style patches. styleStr is a transition diff
+      // (computed by diffAnsiCodes(from, to)), not a setter — dropping
+      // the first is only sound if its undo-codes are a subset of the
+      // second's, which is NOT guaranteed. e.g. [\e[49m, \e[2m]: dropping
+      // the bg reset leaks it into the next \e[2J/\e[2K via BCE.
+      if (type === 'styleStr' && lastType === 'styleStr') {
+        result[lastIdx] = { type: 'styleStr', str: last.str + patch.str }
+        continue
+      }
+
+      // Dedupe hyperlinks
+      if (
+        type === 'hyperlink' &&
+        lastType === 'hyperlink' &&
+        patch.uri === last.uri
+      ) {
+        continue
+      }
+
+      // Cancel cursor hide/show pairs
+      if (
+        (type === 'cursorShow' && lastType === 'cursorHide') ||
+        (type === 'cursorHide' && lastType === 'cursorShow')
+      ) {
+        result.pop()
+        len--
+        continue
+      }
+    }
+
+    result.push(patch)
+    len++
+  }
+
+  return result
+}