@abreen/tada 1.13.7 → 1.14.1

package/build/utils/trace-layout.ts

@@ -5,6 +5,11 @@ import type {
   TraceLayout,
   TraceObjectLayout,
 } from '../types';
+import {
+  formatHeapObjectValue,
+  isInlineHeapObject,
+  type TraceHeapScalar,
+} from './trace-heap';
 
 /** Maximum number of array cells to display. */
 export const ARRAY_MAX_CELLS = 12;
@@ -24,6 +29,9 @@ const ROW_HEIGHT_RATIO = 2;
 /** Minimum width for a value box in a field object. */
 const MIN_VALUE_WIDTH = 40;
 
+/** Minimum width for each displayed array cell. */
+const MIN_ARRAY_CELL_WIDTH = 48;
+
 /** Information collected about a heap object across all trace steps. */
 export interface ObjectInfo {
   id: string;
@@ -32,14 +40,18 @@ export interface ObjectInfo {
   lastStep: number;
   /** Set of object IDs this object ever references (across all steps). */
   references: Set<string>;
+  /** Step indices where this object is actually present. */
+  activeSteps: Set<number>;
   /** Per-field reference targets (field name -> set of referenced object IDs). */
   fieldRefs: Map<string, Set<string>>;
   /** Max number of fields seen on this object (for field objects). */
   maxFields: number;
   /** Max number of elements seen on this object (for arrays). */
   maxElements: number;
-  /** String value (for string-valued objects). */
-  value: string | null;
+  /** Scalar value (for heap objects represented by a single value). */
+  value: TraceHeapScalar | null;
+  hasValue: boolean;
+  isInlineValue: boolean;
   isArray: boolean;
   isString: boolean;
   /** All field names ever seen on this object. */
@@ -74,10 +86,13 @@ export function scanSteps(steps: TraceStep[]): Map<string, ObjectInfo> {
           firstStep: stepIndex,
           lastStep: stepIndex,
           references: new Set(),
+          activeSteps: new Set(),
           fieldRefs: new Map(),
           maxFields: 0,
           maxElements: 0,
           value: null,
+          hasValue: false,
+          isInlineValue: false,
           isArray: false,
           isString: false,
           fieldNames: new Set(),
@@ -87,6 +102,7 @@ export function scanSteps(steps: TraceStep[]): Map<string, ObjectInfo> {
       }
 
       info.lastStep = stepIndex;
+      info.activeSteps.add(stepIndex);
 
       if ('elements' in obj) {
         info.isArray = true;
@@ -125,7 +141,9 @@ export function scanSteps(steps: TraceStep[]): Map<string, ObjectInfo> {
           }
         }
       } else if ('value' in obj) {
-        info.isString = true;
+        info.hasValue = true;
+        info.isString = obj.type === 'String';
+        info.isInlineValue ||= isInlineHeapObject(obj);
         info.value = obj.value;
       }
     }
@@ -229,17 +247,24 @@ export function getObjectSize(
   const charWidth = fontSize * CHAR_WIDTH_RATIO;
   const rowHeight = fontSize * ROW_HEIGHT_RATIO;
 
-  if (info.isString) {
-    const text = `"${info.value ?? ''}"`;
+  if (info.isInlineValue) {
+    const text = formatHeapObjectValue(info.type, info.value ?? '');
+    const textWidth = text.length * charWidth;
+    const minWidth = info.isString ? info.type.length * charWidth + 16 : 16;
+    const width = Math.max(minWidth, textWidth + 16);
+    return { width, height: rowHeight * 2 };
+  }
+
+  if (info.hasValue) {
+    const text = String(info.value ?? '');
     const textWidth = text.length * charWidth;
     const width = Math.max(info.type.length * charWidth + 16, textWidth + 16);
-    const height = rowHeight * 2; // header + value
-    return { width, height };
+    return { width, height: rowHeight * 2 };
   }
 
   if (info.isArray) {
     const cellCount = Math.min(info.maxElements, ARRAY_MAX_CELLS);
-    const cellWidth = Math.max(charWidth * 3, MIN_VALUE_WIDTH);
+    const cellWidth = Math.max(charWidth * 3, MIN_ARRAY_CELL_WIDTH);
     const width = Math.max(
       info.type.length * charWidth + 16,
       cellCount * cellWidth,
@@ -754,6 +779,13 @@ function layoutArrays(
         };
       });
 
+      const minPlacementX = Math.min(...placements.map(p => p.x));
+      if (minPlacementX < 0) {
+        for (const p of placements) {
+          p.x -= minPlacementX;
+        }
+      }
+
       const gap = Math.round(OBJ_GAP * 0.5);
       for (let j = 1; j < placements.length; j++) {
         const prev = placements[j - 1];
@@ -767,7 +799,7 @@ function layoutArrays(
       const refY = Math.round(yOffset + size.height + OBJ_GAP);
       let maxRefHeight = 0;
       for (const p of placements) {
-        result[p.id] = makeLayout(Math.round(Math.max(0, p.x)), refY, p.size);
+        result[p.id] = makeLayout(Math.round(p.x), refY, p.size);
         maxRefHeight = Math.max(maxRefHeight, p.height);
       }
 
@@ -789,7 +821,11 @@ function layoutOrphans(
   result: Record<string, TraceObjectLayout>,
   yOffset: number,
 ) {
-  type OrphanSlot = { ids: string[]; lastStep: number; maxHeight: number };
+  type OrphanSlot = {
+    ids: string[];
+    activeSteps: Set<number>;
+    maxHeight: number;
+  };
 
   const orphanIds = [...objects.keys()]
     .filter(id => !(id in result))
@@ -806,14 +842,23 @@ function layoutOrphans(
     const info = objects.get(id)!;
     const size = sizes.get(id)!;
 
-    let slot = slots.find(existing => existing.lastStep < info.firstStep);
+    let slot = slots.find(existing => {
+      for (const stepIndex of info.activeSteps) {
+        if (existing.activeSteps.has(stepIndex)) {
+          return false;
+        }
+      }
+      return true;
+    });
     if (!slot) {
-      slot = { ids: [], lastStep: info.lastStep, maxHeight: size.height };
+      slot = { ids: [], activeSteps: new Set(), maxHeight: size.height };
       slots.push(slot);
     } else {
-      slot.lastStep = info.lastStep;
       slot.maxHeight = Math.max(slot.maxHeight, size.height);
     }
+    for (const stepIndex of info.activeSteps) {
+      slot.activeSteps.add(stepIndex);
+    }
     slot.ids.push(id);
   }
 

package/build/utils/trace-python.ts

@@ -1,7 +1,10 @@
 import path from 'path';
 import { execFileSyncPython, resolvePythonCommand } from '../../python/command';
 
-export function runPythonTrace(pythonFilePath: string): string {
+export function runPythonTrace(
+  pythonFilePath: string,
+  tracedFilePaths: string[],
+): string {
   const pythonCommand = resolvePythonCommand();
   if (!pythonCommand) {
     throw new Error('Python is required to generate Python traces');
@@ -16,10 +19,11 @@ export function runPythonTrace(pythonFilePath: string): string {
     timeout: 60000,
     encoding: 'utf-8' as const,
     maxBuffer: 50 * 1024 * 1024,
+    cwd: path.dirname(pythonFilePath),
   };
 
   return execFileSyncPython(
-    [runnerPath, pythonFilePath],
+    [runnerPath, pythonFilePath, ...tracedFilePaths],
     options,
     pythonCommand,
   );

package/build/utils/trace-svg.ts

@@ -7,6 +7,7 @@ import type {
   TraceObjectLayout,
 } from '../types';
 import { ARRAY_MAX_CELLS, DEFAULT_FONT_SIZE } from './trace-layout';
+import { formatHeapObjectValue, isInlineHeapObject } from './trace-heap';
 
 /** Gap between stack area and heap area. */
 const SECTION_GAP = 60;
@@ -17,6 +18,9 @@ const PADDING = 8;
 /** Horizontal margin when routing stack-to-heap arrows. */
 const ARROW_MARGIN = 20;
 
+/** Approximate monospace character width for arrow targeting. */
+const CHAR_WIDTH_RATIO = 0.6;
+
 // ---------------------------------------------------------------------------
 // Escape & format helpers
 // ---------------------------------------------------------------------------
@@ -58,13 +62,9 @@ export function formatValue(val: TraceValue): string {
 }
 
 // ---------------------------------------------------------------------------
-// filterStep -- remove args from main(), hide objects reachable only via args
+// filterStep -- remove args from main(), hide unreachable heap objects
 // ---------------------------------------------------------------------------
 
-function isStringObject(obj: TraceHeapObject): boolean {
-  return 'value' in obj && obj.type === 'String';
-}
-
 export function filterStep(step: TraceStep): {
   stack: TraceStackFrame[];
   heap: Record<string, TraceHeapObject>;
@@ -84,38 +84,6 @@ export function filterStep(step: TraceStep): {
     return { ...frame, locals };
   });
 
-  // Find objects reachable only through the hidden 'args' variable
-  const argsOnly = new Set<string>();
-  for (const frame of step.stack) {
-    if (frame.method === 'main') {
-      const argsVal = frame.locals.args;
-      if (argsVal?.type === 'ref') {
-        const q = [argsVal.id];
-        while (q.length > 0) {
-          const id = q.shift()!;
-          if (argsOnly.has(id) || !step.heap[id]) {
-            continue;
-          }
-          argsOnly.add(id);
-          const obj = step.heap[id];
-          if ('elements' in obj) {
-            for (const el of obj.elements) {
-              if (el.type === 'ref') {
-                q.push(el.id);
-              }
-            }
-          } else if ('fields' in obj) {
-            for (const v of Object.values(obj.fields)) {
-              if (v.type === 'ref') {
-                q.push(v.id);
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-
   // Find objects reachable from visible (non-args) variables
   const reachable = new Set<string>();
   const queue: string[] = [];
@@ -126,6 +94,9 @@ export function filterStep(step: TraceStep): {
       }
     }
   }
+  for (const id of step.transientHeapRoots ?? []) {
+    queue.push(id);
+  }
   while (queue.length > 0) {
     const id = queue.shift()!;
     if (reachable.has(id) || !step.heap[id]) {
@@ -148,11 +119,10 @@ export function filterStep(step: TraceStep): {
     }
   }
 
-  // Keep heap objects that are reachable from visible variables, or that
-  // aren't exclusively reachable from the hidden 'args'
+  // Keep only heap objects reachable from visible variables.
   const heap: Record<string, TraceHeapObject> = {};
   const sortedIds = Object.keys(step.heap)
-    .filter(id => reachable.has(id) || !argsOnly.has(id))
+    .filter(id => reachable.has(id))
     .sort((a, b) => {
       const numA = parseInt(a.split('_').pop()!, 10);
       const numB = parseInt(b.split('_').pop()!, 10);
@@ -294,11 +264,12 @@ function svgHeapObject(
     `<g class="trace-obj" data-id="${escapeXml(id)}" transform="translate(${absX},${absY})">`,
   );
 
-  if ('value' in obj && isStringObject(obj)) {
-    // Strings: just quoted text, no box
+  if ('value' in obj && isInlineHeapObject(obj)) {
+    // Strings and Java boxed primitives are heap values, but render inline.
     parts.push(
-      `<text class="trace-val" x="0" y="${height / 2}" ` +
-        `dominant-baseline="central">${escapeXml(`"${obj.value}"`)}</text>`,
+      `<text class="trace-val" x="${width / 2}" y="${height / 2}" ` +
+        `text-anchor="middle" dominant-baseline="central">` +
+        `${escapeXml(formatHeapObjectValue(obj.type, obj.value))}</text>`,
     );
     parts.push('</g>');
     return parts.join('');
@@ -505,6 +476,43 @@ function rectBoundaryPoint(
   return { x: Math.round(cx + dx * scale), y: Math.round(cy + dy * scale) };
 }
 
+function heapTargetBoundaryPoint(
+  sx: number,
+  sy: number,
+  target: HeapObjInfo,
+  obj: TraceHeapObject | undefined,
+  dims: { fontSize: number },
+): { x: number; y: number } {
+  if (!obj || !('value' in obj) || !isInlineHeapObject(obj)) {
+    return rectBoundaryPoint(
+      sx,
+      sy,
+      target.absX,
+      target.absY,
+      target.width,
+      target.height,
+    );
+  }
+
+  const text = formatHeapObjectValue(obj.type, obj.value);
+  const textWidth = Math.max(
+    dims.fontSize,
+    text.length * dims.fontSize * CHAR_WIDTH_RATIO,
+  );
+  const textHeight = dims.fontSize * 1.2;
+  const textPadding = 4;
+  const rx = target.absX + (target.width - textWidth) / 2 - textPadding;
+  const ry = target.absY + (target.height - textHeight) / 2 - textPadding;
+  return rectBoundaryPoint(
+    sx,
+    sy,
+    rx,
+    ry,
+    textWidth + textPadding * 2,
+    textHeight + textPadding * 2,
+  );
+}
+
 /**
  * Get the center of the child-slot box for a given field.
  * The slot row has a small label at the top and a box below it.
@@ -547,14 +555,7 @@ function generateArrows(
     target: HeapObjInfo,
     style: 'fg' | 'dim' = 'fg',
   ): string {
-    const ep = rectBoundaryPoint(
-      sx,
-      sy,
-      target.absX,
-      target.absY,
-      target.width,
-      target.height,
-    );
+    const ep = heapTargetBoundaryPoint(sx, sy, target, heap[target.id], dims);
     const cpx = Math.round((sx + ep.x) / 2);
     const cls = style === 'fg' ? 'trace-arrow' : 'trace-arrow-dim';
     const marker = style === 'fg' ? 'trace-arrowhead' : 'trace-arrowhead-dim';
@@ -606,14 +607,7 @@ function generateArrows(
   // Non-structural heap arrow: cubic Bezier with auto-detected direction
   // (typically horizontal toward ref chains).
   function heapArrow(sx: number, sy: number, target: HeapObjInfo): string {
-    const ep = rectBoundaryPoint(
-      sx,
-      sy,
-      target.absX,
-      target.absY,
-      target.width,
-      target.height,
-    );
+    const ep = heapTargetBoundaryPoint(sx, sy, target, heap[target.id], dims);
     const dx = ep.x - sx;
     const dy = ep.y - sy;
     const dist = Math.sqrt(dx * dx + dy * dy);