okengine 0.22.0 → 0.23.1

package/src/console/ui-next/src/features/flows/traces/trace-lanes.test.ts

@@ -0,0 +1,61 @@
+/**
+ * Unit tests for dense-trace lane grouping.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { RunEffect } from "@/client.ts";
+import { traceIsDense, traceLanes, TRACE_DENSE_MIN } from "./trace-lanes.ts";
+import { waterfallBars } from "./waterfall-bars.ts";
+
+function effect(
+  partial: Pick<RunEffect, "kind" | "resource" | "timestamp" | "duration">,
+): RunEffect {
+  return { reversibility: "none", ...partial };
+}
+
+describe("traceIsDense", () => {
+  test("stays flat at the threshold and groups above it", () => {
+    expect(traceIsDense(TRACE_DENSE_MIN)).toBe(false);
+    expect(traceIsDense(TRACE_DENSE_MIN + 1)).toBe(true);
+  });
+});
+
+describe("traceLanes", () => {
+  test("collapses repeated kind+resource and keeps first-seen order", () => {
+    const startedAt = 1_000;
+    const bars = waterfallBars(
+      [
+        effect({ kind: "read", resource: "sql:tasks", timestamp: 1_000, duration: 18 }),
+        effect({ kind: "read", resource: "sql:task_assignees", timestamp: 1_020, duration: 3 }),
+        effect({ kind: "send", resource: "task-overdue", timestamp: 1_024, duration: 4 }),
+        effect({ kind: "write", resource: "sql:inbox", timestamp: 1_028, duration: 3 }),
+        effect({ kind: "send", resource: "task-overdue", timestamp: 1_032, duration: 1 }),
+        effect({ kind: "write", resource: "sql:inbox", timestamp: 1_034, duration: 2 }),
+      ],
+      startedAt,
+      40,
+    );
+    const lanes = traceLanes(bars);
+    expect(lanes.map((lane) => lane.resource)).toEqual([
+      "sql:tasks",
+      "sql:task_assignees",
+      "task-overdue",
+      "sql:inbox",
+    ]);
+    expect(lanes[2]?.bars.map((bar) => bar.index)).toEqual([2, 4]);
+    expect(lanes[3]?.totalDurationMs).toBe(5);
+    expect(lanes[0]?.bars).toHaveLength(1);
+  });
+
+  test("does not merge different kinds on the same resource", () => {
+    const bars = waterfallBars(
+      [
+        effect({ kind: "read", resource: "sql:inbox", timestamp: 0, duration: 1 }),
+        effect({ kind: "write", resource: "sql:inbox", timestamp: 2, duration: 1 }),
+      ],
+      0,
+      10,
+    );
+    expect(traceLanes(bars)).toHaveLength(2);
+  });
+});

package/src/console/ui-next/src/features/flows/traces/trace-lanes.ts

@@ -0,0 +1,78 @@
+/**
+ * Collapse a long effect ledger into one lane per kind + resource.
+ *
+ * A loop that records hundreds of identical sends should read as one lane
+ * with every occurrence on it, not as hundreds of empty waterfall tracks.
+ */
+
+import type { WaterfallBar } from "./waterfall-bars.ts";
+
+/**
+ * Effect count above which the sheet groups waterfall tracks and event rows.
+ * Shorter runs keep one track and one row per effect.
+ */
+export const TRACE_DENSE_MIN = 24;
+
+/** One operation lane — every bar that shares kind and resource, first-seen order. */
+export type TraceLane = {
+  /** Stable key (`kind` + resource). */
+  readonly key: string;
+  /** Effect kind (drives color and label). */
+  readonly kind: WaterfallBar["kind"];
+  /** Effect resource ref. */
+  readonly resource: string;
+  /** Bars in ledger order. */
+  readonly bars: readonly WaterfallBar[];
+  /** Sum of clamped bar durations. */
+  readonly totalDurationMs: number;
+  /** Egress identity from the first bar that left the process. */
+  readonly external?: WaterfallBar["external"];
+};
+
+/**
+ * True when a run is long enough to group instead of listing every effect.
+ *
+ * @param count - Effect count
+ */
+export function traceIsDense(count: number): boolean {
+  return count > TRACE_DENSE_MIN;
+}
+
+/**
+ * Group waterfall bars by kind and resource, preserving first-seen order.
+ *
+ * @param bars - Positioned bars (ledger order)
+ */
+export function traceLanes(bars: readonly WaterfallBar[]): readonly TraceLane[] {
+  const order: string[] = [];
+  const groups = new Map<string, WaterfallBar[]>();
+  for (const bar of bars) {
+    const key = `${bar.kind}\0${bar.resource}`;
+    const list = groups.get(key);
+    if (list) {
+      list.push(bar);
+      continue;
+    }
+    groups.set(key, [bar]);
+    order.push(key);
+  }
+
+  return order.map((key) => {
+    const laneBars = groups.get(key)!;
+    const first = laneBars[0]!;
+    let totalDurationMs = 0;
+    let external = first.external;
+    for (const bar of laneBars) {
+      totalDurationMs += bar.durationMs;
+      if (!external && bar.external) external = bar.external;
+    }
+    return {
+      key,
+      kind: first.kind,
+      resource: first.resource,
+      bars: laneBars,
+      totalDurationMs,
+      ...(external !== undefined ? { external } : {}),
+    };
+  });
+}

package/src/console/ui-next/src/features/flows/traces/trace-nav.test.ts

@@ -0,0 +1,48 @@
+/**
+ * Trace header identity lines and previous / next neighbors.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { traceIdentityLines, traceNav } from "./trace-nav.ts";
+
+describe("traceIdentityLines", () => {
+  test("shows the run id", () => {
+    expect(traceIdentityLines({ id: "run-a", parentId: null })).toEqual([
+      { key: "run", label: "Run", value: "run-a" },
+    ]);
+  });
+
+  test("adds the parent id when the trace was called", () => {
+    expect(traceIdentityLines({ id: "child", parentId: "root" })).toEqual([
+      { key: "run", label: "Run", value: "child" },
+      { key: "parent", label: "Parent", value: "root" },
+    ]);
+  });
+});
+
+describe("traceNav", () => {
+  const runs = [{ id: "new" }, { id: "mid" }, { id: "old" }];
+
+  test("steps to the row above and the row below", () => {
+    expect(traceNav(runs, "mid")).toEqual({
+      index: 1,
+      total: 3,
+      previousId: "new",
+      nextId: "old",
+    });
+  });
+
+  test("disables the missing end", () => {
+    expect(traceNav(runs, "new").previousId).toBeNull();
+    expect(traceNav(runs, "old").nextId).toBeNull();
+  });
+
+  test("has no neighbors when the open trace is not in the list", () => {
+    expect(traceNav(runs, "missing")).toEqual({
+      index: -1,
+      total: 3,
+      previousId: null,
+      nextId: null,
+    });
+  });
+});

package/src/console/ui-next/src/features/flows/traces/trace-nav.ts

@@ -0,0 +1,57 @@
+/**
+ * Identity lines and list neighbors for the trace detail header.
+ */
+
+import type { RunRow } from "@/client.ts";
+
+/** One copyable identifier shown under the trace title. */
+export type TraceIdentityLine = {
+  readonly key: "run" | "parent";
+  readonly label: string;
+  readonly value: string;
+};
+
+/** Where the open trace sits in the list the sheet can step through. */
+export type TraceNav = {
+  /** Index in `runs`, or `-1` when the open trace is not in the list. */
+  readonly index: number;
+  readonly total: number;
+  /** Row above the open trace (newer, when the list is newest-first). */
+  readonly previousId: string | null;
+  /** Row below the open trace. */
+  readonly nextId: string | null;
+};
+
+/**
+ * Run id, plus parent id when the trace was called from another run.
+ *
+ * @param run - Open trace
+ */
+export function traceIdentityLines(
+  run: Pick<RunRow, "id" | "parentId">,
+): readonly TraceIdentityLine[] {
+  const lines: TraceIdentityLine[] = [{ key: "run", label: "Run", value: run.id }];
+  if (run.parentId) lines.push({ key: "parent", label: "Parent", value: run.parentId });
+  return lines;
+}
+
+/**
+ * Previous and next traces relative to the open one, in list order.
+ *
+ * @param runs - Ordered traces (Traces pane: newest first)
+ * @param currentId - Open trace id
+ */
+export function traceNav(runs: readonly { readonly id: string }[], currentId: string): TraceNav {
+  const index = runs.findIndex((run) => run.id === currentId);
+  if (index < 0) {
+    return { index: -1, total: runs.length, previousId: null, nextId: null };
+  }
+  const previous = index > 0 ? runs[index - 1] : undefined;
+  const next = index < runs.length - 1 ? runs[index + 1] : undefined;
+  return {
+    index,
+    total: runs.length,
+    previousId: previous?.id ?? null,
+    nextId: next?.id ?? null,
+  };
+}