@dxos/react-ui-trace 0.11.1 → 0.13.0

package/src/session-timeline/types.ts

@@ -4,9 +4,14 @@
 
 import * as Schema from 'effect/Schema';
 
+import { palette } from '@dxos/ui-theme';
+
 export const LaneKind = Schema.Literals(['session', 'task']);
 export type LaneKind = Schema.Schema.Type<typeof LaneKind>;
 
+export const LaneHue = Schema.Literals([palette.neutral.hue, ...palette.hues.map((style) => style.hue)]);
+export type LaneHue = Schema.Schema.Type<typeof LaneHue>;
+
 export const LaneStatus = Schema.Literals(['pending', 'blocked', 'running', 'review', 'done', 'failed']);
 export type LaneStatus = Schema.Schema.Type<typeof LaneStatus>;
 
@@ -53,13 +58,22 @@ export const Lane = Schema.Struct({
   /** Epoch ms. */
   start: Schema.optional(Schema.Number),
   end: Schema.optional(Schema.Number),
+  /**
+   * Stretches inside `start`..`end` when the lane's task was put down — blocked on a question, say —
+   * and later picked up again; the lane is drawn as separate runs around them.
+   */
+  gaps: Schema.optional(Schema.Array(Schema.Struct({ start: Schema.Number, end: Schema.Number }))),
   parentId: Schema.optional(Schema.String),
   sessionId: Schema.optional(Schema.String),
   taskId: Schema.optional(Schema.String),
+  /** The task's hue, hashed from its mnemonic, so the lane matches the task's mnemonic chip. */
+  hue: Schema.optional(LaneHue),
   pid: Schema.optional(Schema.String),
   /** Lane ids this lane waits on (task dependencies). */
   blockedOn: Schema.optional(Schema.Array(Schema.String)),
   delegatedFrom: Schema.optional(DelegationSource),
+  /** Node in the supervisor lane this lane's result was folded back into. */
+  returnedTo: Schema.optional(DelegationSource),
   tokens: Schema.optional(TokenUsage),
   toolCalls: Schema.optional(Schema.Number),
 });

package/src/testing/simulated-agent.ts

@@ -6,6 +6,7 @@ import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
 import { type ProcessManager } from '@dxos/compute-runtime';
+import * as Operation from '@dxos/compute/Operation';
 import * as Process from '@dxos/compute/Process';
 import * as Trace from '@dxos/compute/Trace';
 import { EntityId } from '@dxos/keys';
@@ -106,7 +107,7 @@ type AgentStep = Schema.Schema.Type<typeof AgentStep>;
  * it one step, so the caller can interleave the agent's own trace events with the child operation
  * processes that {@link runScenario} spawns beneath it.
  */
-export const SimulatedAgent = Process.make(
+export const SimulatedAgent = Operation.makeDurable(
   {
     key: 'org.dxos.testing.process.agent',
     input: AgentStep,
@@ -196,7 +197,7 @@ type OperationInput = Schema.Schema.Type<typeof OperationInput>;
  * Storybook fixture: a {@link Process} that emits the `operation.start`/`operation.end` pair a real
  * operation process emits, with a simulated execution time in between.
  */
-export const SimulatedOperation = Process.make(
+export const SimulatedOperation = Operation.makeDurable(
   {
     key: 'org.dxos.testing.process.operation',
     input: OperationInput,

package/src/testing/test-trace.ts

@@ -8,8 +8,8 @@ import * as Process from '@dxos/compute/Process';
 import { Annotation } from '@dxos/echo';
 
 export const makeProcess = (
-  overrides: Partial<Process.Info> & Pick<Process.Info, 'pid' | 'state'> & { name: string },
-): Process.Info => ({
+  overrides: Partial<Process.Process> & Pick<Process.Process, 'pid' | 'state'> & { name: string },
+): Process.Process => ({
   parentPid: null,
   key: `test.process.${overrides.name}`,
   params: { name: overrides.name, annotations: Annotation.buildDictionary(() => {}) },

package/src/translations.ts

@@ -2,7 +2,7 @@
 // Copyright 2026 DXOS.org
 //
 
-import { type Resource } from '@dxos/react-ui';
+import type * as Theme from '@dxos/react-ui/Theme';
 
 export const translationKey = '@dxos/react-ui-trace';
 
@@ -12,6 +12,12 @@ export const translations = [
       [translationKey]: {
         'no-commits.message': 'No events yet',
 
+        'gantt-axis-time.label': 'Fit to time',
+        'gantt-axis-unit.label': 'One step per event',
+        'gantt-legend-stats.label': 'Show usage',
+        'gantt-legend-title.label': 'Show titles',
+        'gantt-chart.label': 'Timeline',
+
         'trace.label': 'Trace',
         'trace-processes.label': 'Processes',
         'trace-details.label': 'Details',
@@ -26,4 +32,4 @@ export const translations = [
       },
     },
   },
-] as const satisfies Resource[];
+] as const satisfies Theme.Resource[];

package/dist/types/src/execution-graph/remote-snapshot.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=remote-snapshot.test.d.ts.map

package/dist/types/src/execution-graph/remote-snapshot.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"remote-snapshot.test.d.ts","sourceRoot":"","sources":["../../../../src/execution-graph/remote-snapshot.test.ts"],"names":[],"mappings":""}

package/src/execution-graph/remote-snapshot.test.ts

@@ -1,116 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { describe, test } from 'vitest';
-
-import * as Trace from '@dxos/compute/Trace';
-import { Obj } from '@dxos/echo';
-
-import { buildExecutionGraph } from './execution-graph.ts';
-
-/**
- * Regression for sub-operations collapsing onto `main` when the event window in `buildSpanTree`
- * dropped the parent span's `operation.start`.
- *
- * The remote trace snapshot has 714 chronological events. The 4th `Run Routine` span hosts every
- * `Create object` / `Add schema` / `List schemas` / `Query` / `Add to context` sub-operation.
- * Its `operation.start` lives near the front of the stream (index 70). Before the fix, the
- * default `eventLimit = 300` would `slice(-300)` away that begin event, leaving the sub-ops'
- * `parentPid` lookup unsatisfied — they ended up as top-level collapsible spans rendering their
- * end commits on `main`.
- */
-describe('TracePanel remote snapshot', () => {
-  test('sub-operations land on their parent Routine branch, never on main', ({ expect }) => {
-    const messages = loadRemoteTraceMessages(REMOTE_SNAPSHOT);
-    const { commits } = buildExecutionGraph({ traceMessages: messages });
-
-    // Commits whose message starts with one of these names originate from sub-operations
-    // (Trace.OperationEnd) — every one should live on the Routine's branch, never on `main`.
-    const subOpPrefixes = ['Create object', 'Add schema', 'List schemas', 'Query', 'Add to context'];
-    const isSubOpEnd = (message: string | undefined): boolean =>
-      message !== undefined && subOpPrefixes.some((prefix) => message.startsWith(prefix));
-
-    const subOpCommits = commits.filter((commit) => isSubOpEnd(commit.message));
-    expect(subOpCommits.length).toBeGreaterThan(0);
-
-    const onMain = subOpCommits.filter((commit) => commit.branch === 'main');
-    expect(onMain).toEqual([]);
-
-    // All sub-op end commits share the parent Routine's pid as their branch.
-    const branches = new Set(subOpCommits.map((commit) => commit.branch));
-    expect(branches.size).toBe(1);
-    expect(branches.has('main')).toBe(false);
-  });
-
-  test('Routine end commits anchor to the previous main commit, not back to their own begin', ({ expect }) => {
-    // Regression: the multi-Routine snapshot has overlapping top-level Routine spans (R2 starts
-    // before R1 ends, R4 starts before R3 ends). Previously, R1.end's first parent was
-    // R1.begin (looked up by `beginCommitIdBySpan`), which drew an edge across R2.begin in the
-    // rendered timeline. The fix anchors end commits to the immediate predecessor on the
-    // parent branch (R2.begin) and treats the own-branch tail as a separate merge parent.
-    const messages = loadRemoteTraceMessages(MULTI_SNAPSHOT);
-    const { commits } = buildExecutionGraph({ traceMessages: messages });
-
-    const mainCommits = commits.filter((commit) => commit.branch === 'main');
-    // Sanity check: 4 begin + 4 end Run-Routine commits on main.
-    expect(mainCommits).toHaveLength(8);
-
-    // For each commit on main, its first parent (if any) must be a commit that appears
-    // *earlier* in the main commit sequence — no "skip-back" edges to an older begin commit.
-    const idToMainIndex = new Map(mainCommits.map((commit, index) => [commit.id, index]));
-    for (let index = 1; index < mainCommits.length; index += 1) {
-      const commit = mainCommits[index];
-      const onMainParents = (commit.parents ?? []).filter((parentId) => idToMainIndex.has(parentId));
-      expect(onMainParents.length).toBeGreaterThan(0);
-      for (const parentId of onMainParents) {
-        const parentIndex = idToMainIndex.get(parentId)!;
-        // Every parent on main must be the immediate predecessor (index - 1). An older parent
-        // would render an edge that crosses over the intervening commits.
-        expect(parentIndex).toBe(index - 1);
-      }
-    }
-  });
-});
-
-const REMOTE_SNAPSHOT = 'trace-timeline-remote.dx.json';
-const MULTI_SNAPSHOT = 'trace-timeline-multiple.dx.json';
-
-interface RawMessage {
-  meta?: Trace.Meta;
-  isEphemeral?: boolean;
-  events?: Array<{ type: string; timestamp: number; data: unknown }>;
-}
-
-const loadRemoteTraceMessages = (filename: string): Trace.Message[] => {
-  const snapshotPath = join(__dirname, '../testing/data', filename);
-  const json = JSON.parse(readFileSync(snapshotPath, 'utf8')) as unknown;
-
-  const messages: Trace.Message[] = [];
-  const visit = (node: unknown): void => {
-    if (Array.isArray(node)) {
-      node.forEach(visit);
-      return;
-    }
-    if (node === null || typeof node !== 'object') {
-      return;
-    }
-    const candidate = node as RawMessage & Record<string, unknown>;
-    if (Array.isArray(candidate.events) && candidate.meta && typeof candidate.meta === 'object') {
-      messages.push(
-        Obj.make(Trace.Message, {
-          meta: candidate.meta,
-          isEphemeral: candidate.isEphemeral ?? false,
-          events: candidate.events,
-        }),
-      );
-    }
-    for (const value of Object.values(node as Record<string, unknown>)) {
-      visit(value);
-    }
-  };
-  visit(json);
-  return messages;
-};