@workflow/web-shared 5.0.0-beta.12 → 5.0.0-beta.14

package/dist/components/ui/error-stack-block.d.ts

@@ -1,18 +1,25 @@
+export type StructuredErrorRecord = Record<string, unknown> & {
+    message?: string;
+    stack?: string;
+};
+/**
+ * Check whether `value` looks like a structured error object we can render
+ * with the error block. Some persisted workflow errors only include a
+ * `message`, while runtime errors usually also include `stack`.
+ */
+export declare function isStructuredError(value: unknown): value is StructuredErrorRecord;
 /**
- * Check whether `value` looks like a structured error object with a `stack`
- * field that we can render as pre-formatted text.
+ * Narrower guard kept for callers that specifically need a stack trace.
  */
-export declare function isStructuredErrorWithStack(value: unknown): value is Record<string, unknown> & {
+export declare function isStructuredErrorWithStack(value: unknown): value is StructuredErrorRecord & {
     stack: string;
 };
 /**
- * Renders an error with a `stack` field as a visually distinct error block.
- * Shows the error message with an alert icon at the top, separated from
- * the stack trace below.
+ * Renders a structured error as a visually distinct error block. Shows the
+ * error message with an alert icon at the top, separated from the stack trace
+ * or full message below.
  */
-export declare function ErrorStackBlock({ value, }: {
-    value: Record<string, unknown> & {
-        stack: string;
-    };
+export declare function ErrorStackBlock({ value }: {
+    value: StructuredErrorRecord;
 }): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=error-stack-block.d.ts.map

package/dist/components/ui/error-stack-block.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-stack-block.d.ts","sourceRoot":"","sources":["../../../src/components/ui/error-stack-block.tsx"],"names":[],"mappings":"AAKA;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAOtD;AAiBD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAC9B,KAAK,GACN,EAAE;IACD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CACpD,2CAuDA"}
+{"version":3,"file":"error-stack-block.d.ts","sourceRoot":"","sources":["../../../src/components/ui/error-stack-block.tsx"],"names":[],"mappings":"AAKA,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,qBAAqB,CAOhC;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,qBAAqB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAKpD;AAiBD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAAE,KAAK,EAAE,EAAE;IAAE,KAAK,EAAE,qBAAqB,CAAA;CAAE,2CA6D1E"}

package/dist/components/ui/error-stack-block.js

@@ -3,13 +3,21 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { AlertCircle } from 'lucide-react';
 import { CopyButton } from '../new-trace-viewer/components/copy-button';
 /**
- * Check whether `value` looks like a structured error object with a `stack`
- * field that we can render as pre-formatted text.
+ * Check whether `value` looks like a structured error object we can render
+ * with the error block. Some persisted workflow errors only include a
+ * `message`, while runtime errors usually also include `stack`.
  */
-export function isStructuredErrorWithStack(value) {
+export function isStructuredError(value) {
     return (value != null &&
         typeof value === 'object' &&
-        'stack' in value &&
+        (typeof value.message === 'string' ||
+            typeof value.stack === 'string'));
+}
+/**
+ * Narrower guard kept for callers that specifically need a stack trace.
+ */
+export function isStructuredErrorWithStack(value) {
+    return (isStructuredError(value) &&
         typeof value.stack === 'string');
 }
 /**
@@ -26,18 +34,21 @@ function deriveTitle(message) {
     return firstLine.trim();
 }
 /**
- * Renders an error with a `stack` field as a visually distinct error block.
- * Shows the error message with an alert icon at the top, separated from
- * the stack trace below.
+ * Renders a structured error as a visually distinct error block. Shows the
+ * error message with an alert icon at the top, separated from the stack trace
+ * or full message below.
  */
-export function ErrorStackBlock({ value, }) {
-    const stack = value.stack;
+export function ErrorStackBlock({ value }) {
+    const stack = typeof value.stack === 'string' ? value.stack : undefined;
     const message = typeof value.message === 'string' ? value.message : undefined;
-    // V8's `Error.stack` already starts with `Name: message`, so when the
-    // body shows the stack it includes the full multi-line message anyway.
-    // The header just needs the first line.
-    const title = message ? deriveTitle(message) : undefined;
-    const copyText = message ? `${message}\n\n${stack}` : stack;
+    const body = stack ?? message ?? '';
+    // V8's `Error.stack` already starts with `Name: message`; message-only
+    // errors use the message as the body so long single-line failures remain
+    // readable even when the header truncates.
+    const title = message ? deriveTitle(message) : deriveTitle(body);
+    const copyText = message && stack && !stack.includes(message)
+        ? `${message}\n\n${stack}`
+        : body;
     return (_jsxs("div", { className: "relative overflow-hidden rounded-md border", style: {
             borderColor: 'var(--ds-red-400)',
             background: 'var(--ds-red-100)',
@@ -45,13 +56,13 @@ export function ErrorStackBlock({ value, }) {
                     color: 'var(--ds-red-900)',
                     borderBottom: '1px solid var(--ds-red-400)',
                 }, children: [_jsx(AlertCircle, { className: "h-4 w-4 shrink-0" }), _jsx("p", { className: "text-xs font-semibold m-0 truncate", 
-                        // The full multi-line message is in the stack body below; the
-                        // header just shows the first line, single-line, with overflow
+                        // The full message or stack is in the body below; the header just
+                        // shows the first line, single-line, with overflow
                         // ellipsised so a long title doesn't push the copy button or
                         // wrap into the framed hint/docs lines.
-                        title: message, children: title })] })), _jsx("pre", { className: "px-3 py-2.5 text-xs font-mono whitespace-pre-wrap break-words overflow-auto m-0", style: {
+                        title: message, children: title })] })), body && (_jsx("pre", { className: "px-3 py-2.5 text-xs font-mono whitespace-pre-wrap break-words overflow-auto m-0", style: {
                     color: 'var(--ds-red-900)',
                     background: 'var(--ds-red-200)',
-                }, children: stack })] }));
+                }, children: body }))] }));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-stack-block.js","sourceRoot":"","sources":["../../../src/components/ui/error-stack-block.tsx"],"names":[],"mappings":"AAAA,YAAY,CAAC;;AAEb,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,4CAA4C,CAAC;AAOxE;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAC/B,KAAc;IAEd,OAAO,CACL,KAAK,IAAI,IAAI;QACb,OAAO,KAAK,KAAK,QAAQ;QACzB,CAAC,OAAQ,KAAiC,CAAC,OAAO,KAAK,QAAQ;YAC7D,OAAQ,KAAiC,CAAC,KAAK,KAAK,QAAQ,CAAC,CAChE,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,0BAA0B,CACxC,KAAc;IAEd,OAAO,CACL,iBAAiB,CAAC,KAAK,CAAC;QACxB,OAAQ,KAA+B,CAAC,KAAK,KAAK,QAAQ,CAC3D,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,WAAW,CAAC,OAAe;IAClC,MAAM,SAAS,GACb,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,OAAO,CAAC;IACxE,OAAO,SAAS,CAAC,IAAI,EAAE,CAAC;AAC1B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,EAAE,KAAK,EAAoC;IACzE,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACxE,MAAM,OAAO,GAAG,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;IAC9E,MAAM,IAAI,GAAG,KAAK,IAAI,OAAO,IAAI,EAAE,CAAC;IACpC,uEAAuE;IACvE,yEAAyE;IACzE,2CAA2C;IAC3C,MAAM,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IACjE,MAAM,QAAQ,GACZ,OAAO,IAAI,KAAK,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC;QAC1C,CAAC,CAAC,GAAG,OAAO,OAAO,KAAK,EAAE;QAC1B,CAAC,CAAC,IAAI,CAAC;IAEX,OAAO,CACL,eACE,SAAS,EAAC,4CAA4C,EACtD,KAAK,EAAE;YACL,WAAW,EAAE,mBAAmB;YAChC,UAAU,EAAE,mBAAmB;SAChC,aAED,KAAC,UAAU,IACT,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAC,YAAY,EACtB,SAAS,EAAC,mNAAmN,GAC7N,EAED,KAAK,IAAI,CACR,eACE,SAAS,EAAC,2CAA2C,EACrD,KAAK,EAAE;oBACL,KAAK,EAAE,mBAAmB;oBAC1B,YAAY,EAAE,6BAA6B;iBAC5C,aAED,KAAC,WAAW,IAAC,SAAS,EAAC,kBAAkB,GAAG,EAC5C,YACE,SAAS,EAAC,oCAAoC;wBAC9C,kEAAkE;wBAClE,mDAAmD;wBACnD,6DAA6D;wBAC7D,wCAAwC;wBACxC,KAAK,EAAE,OAAO,YAEb,KAAK,GACJ,IACA,CACP,EACA,IAAI,IAAI,CACP,cACE,SAAS,EAAC,iFAAiF,EAC3F,KAAK,EAAE;oBACL,KAAK,EAAE,mBAAmB;oBAC1B,UAAU,EAAE,mBAAmB;iBAChC,YAEA,IAAI,GACD,CACP,IACG,CACP,CAAC;AACJ,CAAC","sourcesContent":["'use client';\n\nimport { AlertCircle } from 'lucide-react';\nimport { CopyButton } from '../new-trace-viewer/components/copy-button';\n\nexport type StructuredErrorRecord = Record<string, unknown> & {\n  message?: string;\n  stack?: string;\n};\n\n/**\n * Check whether `value` looks like a structured error object we can render\n * with the error block. Some persisted workflow errors only include a\n * `message`, while runtime errors usually also include `stack`.\n */\nexport function isStructuredError(\n  value: unknown\n): value is StructuredErrorRecord {\n  return (\n    value != null &&\n    typeof value === 'object' &&\n    (typeof (value as Record<string, unknown>).message === 'string' ||\n      typeof (value as Record<string, unknown>).stack === 'string')\n  );\n}\n\n/**\n * Narrower guard kept for callers that specifically need a stack trace.\n */\nexport function isStructuredErrorWithStack(\n  value: unknown\n): value is StructuredErrorRecord & { stack: string } {\n  return (\n    isStructuredError(value) &&\n    typeof (value as StructuredErrorRecord).stack === 'string'\n  );\n}\n\n/**\n * Pull a short, single-line title out of an error message.\n *\n * Workflow's structured error messages are multi-line — the first line is\n * the headline (`Failed to serialize step return value`) and the rest are\n * `╰▶ hint:` / `╰▶ docs:` framed details. The full message belongs in the\n * body of the error block; the title should just be the headline so the\n * card stays scannable.\n */\nfunction deriveTitle(message: string): string {\n  const firstLine =\n    message.split('\\n').find((line) => line.trim().length > 0) ?? message;\n  return firstLine.trim();\n}\n\n/**\n * Renders a structured error as a visually distinct error block. Shows the\n * error message with an alert icon at the top, separated from the stack trace\n * or full message below.\n */\nexport function ErrorStackBlock({ value }: { value: StructuredErrorRecord }) {\n  const stack = typeof value.stack === 'string' ? value.stack : undefined;\n  const message = typeof value.message === 'string' ? value.message : undefined;\n  const body = stack ?? message ?? '';\n  // V8's `Error.stack` already starts with `Name: message`; message-only\n  // errors use the message as the body so long single-line failures remain\n  // readable even when the header truncates.\n  const title = message ? deriveTitle(message) : deriveTitle(body);\n  const copyText =\n    message && stack && !stack.includes(message)\n      ? `${message}\\n\\n${stack}`\n      : body;\n\n  return (\n    <div\n      className=\"relative overflow-hidden rounded-md border\"\n      style={{\n        borderColor: 'var(--ds-red-400)',\n        background: 'var(--ds-red-100)',\n      }}\n    >\n      <CopyButton\n        copyText={copyText}\n        ariaLabel=\"Copy error\"\n        className=\"absolute right-2 top-2 flex h-6 w-6 items-center justify-center rounded-md border border-red-400 bg-red-100 p-0 text-red-900 transition-transform transition-colors duration-100 hover:bg-red-200 active:scale-95\"\n      />\n\n      {title && (\n        <div\n          className=\"flex items-center gap-2 px-3 py-2.5 pr-10\"\n          style={{\n            color: 'var(--ds-red-900)',\n            borderBottom: '1px solid var(--ds-red-400)',\n          }}\n        >\n          <AlertCircle className=\"h-4 w-4 shrink-0\" />\n          <p\n            className=\"text-xs font-semibold m-0 truncate\"\n            // The full message or stack is in the body below; the header just\n            // shows the first line, single-line, with overflow\n            // ellipsised so a long title doesn't push the copy button or\n            // wrap into the framed hint/docs lines.\n            title={message}\n          >\n            {title}\n          </p>\n        </div>\n      )}\n      {body && (\n        <pre\n          className=\"px-3 py-2.5 text-xs font-mono whitespace-pre-wrap break-words overflow-auto m-0\"\n          style={{\n            color: 'var(--ds-red-900)',\n            background: 'var(--ds-red-200)',\n          }}\n        >\n          {body}\n        </pre>\n      )}\n    </div>\n  );\n}\n"]}

package/dist/index.d.ts

@@ -14,5 +14,5 @@ export type { DecodedStreamChunkSource } from './lib/stream-display';
 export type { ToastAdapter } from './lib/toast';
 export { ToastProvider, useToast } from './lib/toast';
 export type { StreamStep } from './lib/utils';
-export { extractConversation, formatDuration, identifyStreamSteps, isDoStreamStep, } from './lib/utils';
+export { extractConversation, formatDuration, formatDurationPrecise, identifyStreamSteps, isDoStreamStep, } from './lib/utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,aAAa,EACb,iBAAiB,GAClB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACtE,cAAc,cAAc,CAAC;AAC7B,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,sDAAsD,CAAC;AAC9D,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EACL,0BAA0B,EAC1B,8BAA8B,EAC9B,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,KAAK,mBAAmB,GACzB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,aAAa,EACb,yBAAyB,EACzB,yBAAyB,EACzB,gBAAgB,EAChB,yBAAyB,GAC1B,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,oBAAoB,EACpB,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,6BAA6B,CAAC;AACrC,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,wBAAwB,EACxB,kBAAkB,EAClB,iBAAiB,EACjB,UAAU,EACV,WAAW,EACX,eAAe,EACf,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AACrE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACtD,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,cAAc,GACf,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,mBAAmB,EACnB,iBAAiB,GAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,aAAa,EACb,iBAAiB,GAClB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACtE,cAAc,cAAc,CAAC;AAC7B,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,sDAAsD,CAAC;AAC9D,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EACL,0BAA0B,EAC1B,8BAA8B,EAC9B,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,KAAK,mBAAmB,GACzB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,aAAa,EACb,yBAAyB,EACzB,yBAAyB,EACzB,gBAAgB,EAChB,yBAAyB,GAC1B,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,oBAAoB,EACpB,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,6BAA6B,CAAC;AACrC,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,wBAAwB,EACxB,kBAAkB,EAClB,iBAAiB,EACjB,UAAU,EACV,WAAW,EACX,eAAe,EACf,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AACrE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACtD,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EACL,mBAAmB,EACnB,cAAc,EACd,qBAAqB,EACrB,mBAAmB,EACnB,cAAc,GACf,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -6,5 +6,5 @@ export { analyzeEvents, hasPendingHooksFromEvents, hasPendingStepsFromEvents, is
 export { materializeAll, materializeHooks, materializeSteps, materializeWaits, } from './lib/event-materialization';
 export { CLASS_INSTANCE_REF_TYPE, ClassInstanceRef, ENCRYPTED_PLACEHOLDER, extractStreamIds, getWebRevivers, hasEncryptedFields, hydrateResourceIO, hydrateResourceIOWithKey, isClassInstanceRef, isEncryptedMarker, isStreamId, isStreamRef, STREAM_REF_TYPE, truncateId, } from './lib/hydration';
 export { ToastProvider, useToast } from './lib/toast';
-export { extractConversation, formatDuration, identifyStreamSteps, isDoStreamStep, } from './lib/utils';
-//# sourceMappingURL=data:application/json;base64,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
+export { extractConversation, formatDuration, formatDurationPrecise, identifyStreamSteps, isDoStreamStep, } from './lib/utils';
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/utils.d.ts

@@ -21,6 +21,17 @@ export declare function cn(...inputs: ClassValue[]): string;
  * - >= 1m: shows decomposed format with whole seconds (e.g., "1m 13s", "2m 13s")
  */
 export declare function formatDuration(ms: number, compact?: boolean): string;
+/**
+ * Formats a duration in milliseconds without snapping to whole seconds.
+ *
+ * Unlike {@link formatDuration}, this never rounds a sub-minute value up to
+ * the next whole second (e.g. 1626ms renders as "1.63s", not "2s").
+ *
+ * - < 1s: shows whole milliseconds (e.g. "626ms")
+ * - 1s – 1m: shows seconds with two decimals (e.g. "1.63s", "45.20s")
+ * - >= 1m: decomposes into d/h/m with two-decimal seconds (e.g. "1m 13.45s")
+ */
+export declare function formatDurationPrecise(ms: number): string;
 /**
  * Returns a formatted pagination display string
  * @param currentPage - The current page number

package/dist/lib/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,IAAI,CAAC;AACvC,OAAO,EAAE,KAAK,UAAU,EAAQ,MAAM,MAAM,CAAC;AAG7C,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC;AAOD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,UAAQ,GAAG,MAAM,CAgDlE;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,OAAO,GACf,MAAM,CAKR;AAMD;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,OAAO,GAAG,YAAY,EAAE,GAAG,IAAI,CAmB7E;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,YAAY,EAAE,CAAC;CAC9B;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,UAAU,EAAE,CAc/D"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,IAAI,CAAC;AACvC,OAAO,EAAE,KAAK,UAAU,EAAQ,MAAM,MAAM,CAAC;AAG7C,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC;AAOD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,UAAQ,GAAG,MAAM,CAgDlE;AAUD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAqCxD;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,OAAO,GACf,MAAM,CAKR;AAMD;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,OAAO,GAAG,YAAY,EAAE,GAAG,IAAI,CAmB7E;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,YAAY,EAAE,CAAC;CAC9B;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,UAAU,EAAE,CAc/D"}

package/dist/lib/utils.js

@@ -66,6 +66,54 @@ export function formatDuration(ms, compact = false) {
     parts.push(`${seconds}s`);
     return parts.join(' ');
 }
+// Locale-aware formatter that always renders exactly two fraction digits.
+// Used for the seconds component of precise durations so values are never
+// snapped to a whole second (and thousands separators stay correct).
+const preciseSecondsFormatter = new Intl.NumberFormat(undefined, {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+});
+/**
+ * Formats a duration in milliseconds without snapping to whole seconds.
+ *
+ * Unlike {@link formatDuration}, this never rounds a sub-minute value up to
+ * the next whole second (e.g. 1626ms renders as "1.63s", not "2s").
+ *
+ * - < 1s: shows whole milliseconds (e.g. "626ms")
+ * - 1s – 1m: shows seconds with two decimals (e.g. "1.63s", "45.20s")
+ * - >= 1m: decomposes into d/h/m with two-decimal seconds (e.g. "1m 13.45s")
+ */
+export function formatDurationPrecise(ms) {
+    if (ms === 0) {
+        return '0s';
+    }
+    if (ms < MS_IN_SECOND) {
+        const roundedMs = Math.round(ms);
+        if (roundedMs < MS_IN_SECOND) {
+            return `${roundedMs}ms`;
+        }
+    }
+    const normalizedMs = Math.round(ms / 10) * 10;
+    if (normalizedMs < MS_IN_MINUTE) {
+        return `${preciseSecondsFormatter.format(normalizedMs / MS_IN_SECOND)}s`;
+    }
+    const days = Math.floor(normalizedMs / MS_IN_DAY);
+    const hours = Math.floor((normalizedMs % MS_IN_DAY) / MS_IN_HOUR);
+    const minutes = Math.floor((normalizedMs % MS_IN_HOUR) / MS_IN_MINUTE);
+    const seconds = (normalizedMs % MS_IN_MINUTE) / MS_IN_SECOND;
+    const parts = [];
+    if (days > 0) {
+        parts.push(`${days}d`);
+    }
+    if (hours > 0) {
+        parts.push(`${hours}h`);
+    }
+    if (minutes > 0) {
+        parts.push(`${minutes}m`);
+    }
+    parts.push(`${preciseSecondsFormatter.format(seconds)}s`);
+    return parts.join(' ');
+}
 /**
  * Returns a formatted pagination display string
  * @param currentPage - The current page number
@@ -124,4 +172,4 @@ export function identifyStreamSteps(steps) {
         };
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Step } from '@workflow/world';\nimport type { ModelMessage } from 'ai';\nimport { type ClassValue, clsx } from 'clsx';\nimport { twMerge } from 'tailwind-merge';\n\nexport function cn(...inputs: ClassValue[]) {\n  return twMerge(clsx(inputs));\n}\n\nconst MS_IN_SECOND = 1000;\nconst MS_IN_MINUTE = 60 * MS_IN_SECOND;\nconst MS_IN_HOUR = 60 * MS_IN_MINUTE;\nconst MS_IN_DAY = 24 * MS_IN_HOUR;\n\n/**\n * Formats a duration in milliseconds to a human-readable string.\n *\n * @param ms - Duration in milliseconds\n * @param compact - If true, returns a compact format (e.g., \"380ms\", \"2m 30s\").\n *                  If false (default), returns multi-part format (e.g., \"1m 13s\", \"2d 5h 3m 12s\").\n *\n * Compact format (timeline markers):\n * - < 1s: shows milliseconds (e.g., \"380ms\")\n * - < 1m: shows seconds (e.g., \"45s\")\n * - < 1h: shows minutes and seconds (e.g., \"2m 30s\")\n * - >= 1h: shows hours and minutes (e.g., \"2h 30m\")\n *\n * Full format:\n * - < 1s: shows milliseconds (e.g., \"380ms\")\n * - < 1m: shows seconds (e.g., \"45s\")\n * - >= 1m: shows decomposed format with whole seconds (e.g., \"1m 13s\", \"2m 13s\")\n */\nexport function formatDuration(ms: number, compact = false): string {\n  if (ms === 0) {\n    return '0s';\n  }\n\n  if (ms < MS_IN_SECOND) {\n    const roundedMs = Math.round(ms);\n    return roundedMs < MS_IN_SECOND ? `${roundedMs}ms` : '1s';\n  }\n\n  const roundedMs = Math.round(ms / MS_IN_SECOND) * MS_IN_SECOND;\n\n  if (roundedMs < MS_IN_MINUTE) {\n    return `${Math.floor(roundedMs / MS_IN_SECOND)}s`;\n  }\n\n  // Compact format: multi-unit without decimals (e.g. \"8m 20s\", \"2h 30m\")\n  if (compact) {\n    if (roundedMs < MS_IN_HOUR) {\n      const m = Math.floor(roundedMs / MS_IN_MINUTE);\n      const s = Math.floor((roundedMs % MS_IN_MINUTE) / MS_IN_SECOND);\n      return s > 0 ? `${m}m ${s}s` : `${m}m`;\n    }\n    const h = Math.floor(roundedMs / MS_IN_HOUR);\n    const m = Math.floor((roundedMs % MS_IN_HOUR) / MS_IN_MINUTE);\n    return m > 0 ? `${h}h ${m}m` : `${h}h`;\n  }\n\n  // Full format: decompose into larger units + whole seconds.\n  const days = Math.floor(roundedMs / MS_IN_DAY);\n  const hours = Math.floor((roundedMs % MS_IN_DAY) / MS_IN_HOUR);\n  const minutes = Math.floor((roundedMs % MS_IN_HOUR) / MS_IN_MINUTE);\n  const seconds = Math.floor((roundedMs % MS_IN_MINUTE) / MS_IN_SECOND);\n\n  const parts: string[] = [];\n\n  if (days > 0) {\n    parts.push(`${days}d`);\n  }\n  if (hours > 0) {\n    parts.push(`${hours}h`);\n  }\n  if (minutes > 0) {\n    parts.push(`${minutes}m`);\n  }\n  parts.push(`${seconds}s`);\n\n  return parts.join(' ');\n}\n\n/**\n * Returns a formatted pagination display string\n * @param currentPage - The current page number\n * @param totalPages - The total number of pages visited so far\n * @param hasMore - Whether there are more pages available\n * @returns Formatted string like \"Page 1 of 3+\" or \"Page 2 of 2\"\n */\nexport function getPaginationDisplay(\n  currentPage: number,\n  totalPages: number,\n  hasMore: boolean\n): string {\n  if (hasMore) {\n    return `Page ${currentPage} of ${totalPages}+`;\n  }\n  return `Page ${currentPage} of ${totalPages}`;\n}\n\n// ============================================================================\n// Durable Agent Utilities\n// ============================================================================\n\n/**\n * Check if a step is a doStreamStep (LLM call with conversation input)\n */\nexport function isDoStreamStep(stepName: string): boolean {\n  return stepName.endsWith('//doStreamStep');\n}\n\n/**\n * Extract the conversation from a hydrated doStreamStep input.\n * doStreamStep signature: (conversationPrompt, model, writable, tools, options)\n * So input[0] is the conversation.\n */\nexport function extractConversation(stepInput: unknown): ModelMessage[] | null {\n  if (!Array.isArray(stepInput) || stepInput.length === 0) {\n    return null;\n  }\n\n  const firstArg = stepInput[0];\n\n  if (!Array.isArray(firstArg)) {\n    return null;\n  }\n\n  // Validate it looks like ModelMessage[]\n  if (\n    !firstArg.every((msg) => msg && typeof msg === 'object' && 'role' in msg)\n  ) {\n    return null;\n  }\n\n  return firstArg as ModelMessage[];\n}\n\n/**\n * A doStreamStep with its conversation input extracted\n */\nexport interface StreamStep {\n  stepId: string;\n  stepName: string;\n  displayName: string;\n  conversation: ModelMessage[];\n}\n\n/**\n * Identifies all stream steps (doStreamStep) in a run and extracts their conversations.\n */\nexport function identifyStreamSteps(steps: Step[]): StreamStep[] {\n  return steps\n    .filter((step) => isDoStreamStep(step.stepName))\n    .map((step) => {\n      const functionName = step.stepName.split('//').pop() ?? 'unknown';\n      const conversation = extractConversation(step.input) ?? [];\n\n      return {\n        stepId: step.stepId,\n        stepName: step.stepName,\n        displayName: functionName,\n        conversation,\n      };\n    });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Step } from '@workflow/world';\nimport type { ModelMessage } from 'ai';\nimport { type ClassValue, clsx } from 'clsx';\nimport { twMerge } from 'tailwind-merge';\n\nexport function cn(...inputs: ClassValue[]) {\n  return twMerge(clsx(inputs));\n}\n\nconst MS_IN_SECOND = 1000;\nconst MS_IN_MINUTE = 60 * MS_IN_SECOND;\nconst MS_IN_HOUR = 60 * MS_IN_MINUTE;\nconst MS_IN_DAY = 24 * MS_IN_HOUR;\n\n/**\n * Formats a duration in milliseconds to a human-readable string.\n *\n * @param ms - Duration in milliseconds\n * @param compact - If true, returns a compact format (e.g., \"380ms\", \"2m 30s\").\n *                  If false (default), returns multi-part format (e.g., \"1m 13s\", \"2d 5h 3m 12s\").\n *\n * Compact format (timeline markers):\n * - < 1s: shows milliseconds (e.g., \"380ms\")\n * - < 1m: shows seconds (e.g., \"45s\")\n * - < 1h: shows minutes and seconds (e.g., \"2m 30s\")\n * - >= 1h: shows hours and minutes (e.g., \"2h 30m\")\n *\n * Full format:\n * - < 1s: shows milliseconds (e.g., \"380ms\")\n * - < 1m: shows seconds (e.g., \"45s\")\n * - >= 1m: shows decomposed format with whole seconds (e.g., \"1m 13s\", \"2m 13s\")\n */\nexport function formatDuration(ms: number, compact = false): string {\n  if (ms === 0) {\n    return '0s';\n  }\n\n  if (ms < MS_IN_SECOND) {\n    const roundedMs = Math.round(ms);\n    return roundedMs < MS_IN_SECOND ? `${roundedMs}ms` : '1s';\n  }\n\n  const roundedMs = Math.round(ms / MS_IN_SECOND) * MS_IN_SECOND;\n\n  if (roundedMs < MS_IN_MINUTE) {\n    return `${Math.floor(roundedMs / MS_IN_SECOND)}s`;\n  }\n\n  // Compact format: multi-unit without decimals (e.g. \"8m 20s\", \"2h 30m\")\n  if (compact) {\n    if (roundedMs < MS_IN_HOUR) {\n      const m = Math.floor(roundedMs / MS_IN_MINUTE);\n      const s = Math.floor((roundedMs % MS_IN_MINUTE) / MS_IN_SECOND);\n      return s > 0 ? `${m}m ${s}s` : `${m}m`;\n    }\n    const h = Math.floor(roundedMs / MS_IN_HOUR);\n    const m = Math.floor((roundedMs % MS_IN_HOUR) / MS_IN_MINUTE);\n    return m > 0 ? `${h}h ${m}m` : `${h}h`;\n  }\n\n  // Full format: decompose into larger units + whole seconds.\n  const days = Math.floor(roundedMs / MS_IN_DAY);\n  const hours = Math.floor((roundedMs % MS_IN_DAY) / MS_IN_HOUR);\n  const minutes = Math.floor((roundedMs % MS_IN_HOUR) / MS_IN_MINUTE);\n  const seconds = Math.floor((roundedMs % MS_IN_MINUTE) / MS_IN_SECOND);\n\n  const parts: string[] = [];\n\n  if (days > 0) {\n    parts.push(`${days}d`);\n  }\n  if (hours > 0) {\n    parts.push(`${hours}h`);\n  }\n  if (minutes > 0) {\n    parts.push(`${minutes}m`);\n  }\n  parts.push(`${seconds}s`);\n\n  return parts.join(' ');\n}\n\n// Locale-aware formatter that always renders exactly two fraction digits.\n// Used for the seconds component of precise durations so values are never\n// snapped to a whole second (and thousands separators stay correct).\nconst preciseSecondsFormatter = new Intl.NumberFormat(undefined, {\n  minimumFractionDigits: 2,\n  maximumFractionDigits: 2,\n});\n\n/**\n * Formats a duration in milliseconds without snapping to whole seconds.\n *\n * Unlike {@link formatDuration}, this never rounds a sub-minute value up to\n * the next whole second (e.g. 1626ms renders as \"1.63s\", not \"2s\").\n *\n * - < 1s: shows whole milliseconds (e.g. \"626ms\")\n * - 1s – 1m: shows seconds with two decimals (e.g. \"1.63s\", \"45.20s\")\n * - >= 1m: decomposes into d/h/m with two-decimal seconds (e.g. \"1m 13.45s\")\n */\nexport function formatDurationPrecise(ms: number): string {\n  if (ms === 0) {\n    return '0s';\n  }\n\n  if (ms < MS_IN_SECOND) {\n    const roundedMs = Math.round(ms);\n    if (roundedMs < MS_IN_SECOND) {\n      return `${roundedMs}ms`;\n    }\n  }\n\n  const normalizedMs = Math.round(ms / 10) * 10;\n\n  if (normalizedMs < MS_IN_MINUTE) {\n    return `${preciseSecondsFormatter.format(normalizedMs / MS_IN_SECOND)}s`;\n  }\n\n  const days = Math.floor(normalizedMs / MS_IN_DAY);\n  const hours = Math.floor((normalizedMs % MS_IN_DAY) / MS_IN_HOUR);\n  const minutes = Math.floor((normalizedMs % MS_IN_HOUR) / MS_IN_MINUTE);\n  const seconds = (normalizedMs % MS_IN_MINUTE) / MS_IN_SECOND;\n\n  const parts: string[] = [];\n\n  if (days > 0) {\n    parts.push(`${days}d`);\n  }\n  if (hours > 0) {\n    parts.push(`${hours}h`);\n  }\n  if (minutes > 0) {\n    parts.push(`${minutes}m`);\n  }\n  parts.push(`${preciseSecondsFormatter.format(seconds)}s`);\n\n  return parts.join(' ');\n}\n\n/**\n * Returns a formatted pagination display string\n * @param currentPage - The current page number\n * @param totalPages - The total number of pages visited so far\n * @param hasMore - Whether there are more pages available\n * @returns Formatted string like \"Page 1 of 3+\" or \"Page 2 of 2\"\n */\nexport function getPaginationDisplay(\n  currentPage: number,\n  totalPages: number,\n  hasMore: boolean\n): string {\n  if (hasMore) {\n    return `Page ${currentPage} of ${totalPages}+`;\n  }\n  return `Page ${currentPage} of ${totalPages}`;\n}\n\n// ============================================================================\n// Durable Agent Utilities\n// ============================================================================\n\n/**\n * Check if a step is a doStreamStep (LLM call with conversation input)\n */\nexport function isDoStreamStep(stepName: string): boolean {\n  return stepName.endsWith('//doStreamStep');\n}\n\n/**\n * Extract the conversation from a hydrated doStreamStep input.\n * doStreamStep signature: (conversationPrompt, model, writable, tools, options)\n * So input[0] is the conversation.\n */\nexport function extractConversation(stepInput: unknown): ModelMessage[] | null {\n  if (!Array.isArray(stepInput) || stepInput.length === 0) {\n    return null;\n  }\n\n  const firstArg = stepInput[0];\n\n  if (!Array.isArray(firstArg)) {\n    return null;\n  }\n\n  // Validate it looks like ModelMessage[]\n  if (\n    !firstArg.every((msg) => msg && typeof msg === 'object' && 'role' in msg)\n  ) {\n    return null;\n  }\n\n  return firstArg as ModelMessage[];\n}\n\n/**\n * A doStreamStep with its conversation input extracted\n */\nexport interface StreamStep {\n  stepId: string;\n  stepName: string;\n  displayName: string;\n  conversation: ModelMessage[];\n}\n\n/**\n * Identifies all stream steps (doStreamStep) in a run and extracts their conversations.\n */\nexport function identifyStreamSteps(steps: Step[]): StreamStep[] {\n  return steps\n    .filter((step) => isDoStreamStep(step.stepName))\n    .map((step) => {\n      const functionName = step.stepName.split('//').pop() ?? 'unknown';\n      const conversation = extractConversation(step.input) ?? [];\n\n      return {\n        stepId: step.stepId,\n        stepName: step.stepName,\n        displayName: functionName,\n        conversation,\n      };\n    });\n}\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@workflow/web-shared",
   "description": "Shared components for Workflow Observability UI",
-  "version": "5.0.0-beta.12",
+  "version": "5.0.0-beta.14",
   "private": false,
   "files": [
     "dist",
@@ -53,9 +53,9 @@
     "streamdown": "2.3.0",
     "tailwind-merge": "3.5.0",
     "tailwindcss": "4",
-    "@workflow/core": "5.0.0-beta.12",
+    "@workflow/core": "5.0.0-beta.14",
     "@workflow/utils": "5.0.0-beta.3",
-    "@workflow/world": "5.0.0-beta.7"
+    "@workflow/world": "5.0.0-beta.8"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.4",

package/src/components/event-list-view.tsx

@@ -10,20 +10,21 @@ import type {
 } from 'react';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Virtuoso, type VirtuosoHandle } from 'react-virtuoso';
-import { isEncryptedMarker } from '../lib/hydration';
 import {
-  parseExactWorkflowSearchId,
-  looksLikeWorkflowIdSearchInput,
   type ExactIdSearchResult,
   type ExactWorkflowSearchIdKind,
+  looksLikeWorkflowIdSearchInput,
+  parseExactWorkflowSearchId,
 } from '../lib/exact-event-search-id';
-import { DecryptButton } from './ui/decrypt-button';
-import { formatDuration } from '../lib/utils';
+import { isEncryptedMarker } from '../lib/hydration';
 import { useToast } from '../lib/toast';
+import { formatDuration } from '../lib/utils';
 import { DataInspector, DecryptClickContext } from './ui/data-inspector';
+import { DecryptButton } from './ui/decrypt-button';
 import {
   ErrorStackBlock,
-  isStructuredErrorWithStack,
+  isStructuredError,
+  type StructuredErrorRecord,
 } from './ui/error-stack-block';
 import { LoadMoreButton } from './ui/load-more-button';
 import { MenuDropdown } from './ui/menu-dropdown';
@@ -519,20 +520,20 @@ function deepParseJson(value: unknown): unknown {
 }
 
 /**
- * Extracts a structured error with a stack trace from event data, if present.
+ * Extracts a structured error from event data, if present.
  * Returns the error object to render with ErrorStackBlock, or null if not applicable.
  */
 function extractStructuredError(
   data: unknown,
   eventType?: string
-): (Record<string, unknown> & { stack: string }) | null {
+): StructuredErrorRecord | null {
   if (!eventType || !ERROR_EVENT_TYPES.has(eventType)) return null;
   if (data == null || typeof data !== 'object') return null;
   const record = data as Record<string, unknown>;
   // Check the nested `error` field first (the StructuredError)
-  if (isStructuredErrorWithStack(record.error)) return record.error;
-  // Some error formats put the stack at the top level of eventData
-  if (isStructuredErrorWithStack(record)) return record;
+  if (isStructuredError(record.error)) return record.error;
+  // Some error formats put the message/stack at the top level of eventData.
+  if (isStructuredError(record)) return record;
   return null;
 }
 

package/src/components/new-trace-viewer/components/event-list.tsx

@@ -1,8 +1,8 @@
 import { Circle } from 'lucide-react';
 import { useRef } from 'react';
 import { cn } from '../../../lib/utils';
-import type { Span } from '../../trace-viewer/types';
-import { formatDuration } from '../../trace-viewer/util/timing';
+import type { Span } from '../types';
+import { formatDurationPrecise } from '../../trace-viewer/util/timing';
 import {
   SleepIcon,
   StepForwardIcon,
@@ -53,8 +53,9 @@ const EventRow = ({
   onSelectSpan: (spanId: string) => void;
 }) => {
   const durationMs = getSpanDurationMs(span);
-  const isErrored =
-    (span.attributes.data as Record<string, unknown>).status === 'failed';
+  const workflowStatus = (span.attributes.data as Record<string, unknown>)
+    ?.status as string | undefined;
+  const isErrored = span.status.code === 2 || workflowStatus === 'failed';
   const { icon: Icon, className: tagClassName } = getEventStyle(
     span.resource,
     isErrored
@@ -85,7 +86,7 @@ const EventRow = ({
           </div>
           <div className="ml-2 shrink-0">
             <span className="text-label-14 text-gray-900 tabular-nums">
-              {formatDuration(durationMs)}
+              {formatDurationPrecise(durationMs)}
             </span>
           </div>
         </div>

package/src/components/new-trace-viewer/components/timeline.tsx

@@ -4,8 +4,12 @@ import { ArrowLeft, ArrowRight } from 'lucide-react';
 import type { CSSProperties, ReactNode } from 'react';
 import { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { cn } from '../../../lib/utils';
-import type { Span } from '../../trace-viewer/types';
-import { formatDuration, getHighResInMs } from '../../trace-viewer/util/timing';
+import type { Span } from '../types';
+import {
+  formatDuration,
+  formatDurationPrecise,
+  getHighResInMs,
+} from '../../trace-viewer/util/timing';
 import { isSpanDimmedBySearch, type SpanSearchResult } from '../search';
 import type { Segment, SegmentStatus, TimeMarker } from '../utils';
 import {
@@ -222,7 +226,7 @@ function SegmentBar({ segments }: { segments: VisibleSegment[] }): ReactNode {
   return (
     <div className="relative h-6 w-full">
       {segments.map((seg, i) => {
-        const label = formatDuration(seg.fullDurationMs);
+        const label = formatDurationPrecise(seg.fullDurationMs);
         // Only render the label when there's enough room for it without clipping.
         const showLabel = seg.pixelWidth >= Math.max(40, label.length * 6 + 12);
         // Beef up the queued segment when it's too narrow to read.
@@ -234,7 +238,7 @@ function SegmentBar({ segments }: { segments: VisibleSegment[] }): ReactNode {
 
         return (
           <div
-            key={`${seg.status}-${i}`}
+            key={i}
             className={cn(
               'absolute h-full rounded-[0.25rem]',
               SEGMENT_CLASSES[seg.status]
@@ -313,7 +317,7 @@ const TimelineBar = memo(function TimelineBar({
     ? (colors.errorBorder ?? 'var(--ds-red-500)')
     : colors.border;
 
-  const totalLabel = formatDuration(totalDurationMs);
+  const totalLabel = formatDurationPrecise(totalDurationMs);
   const showTotalLabel =
     geometry.visiblePixelWidth >= Math.max(40, totalLabel.length * 6 + 12);
 
@@ -421,7 +425,7 @@ export function TimelineHeader({
       <div className="relative h-full flex-1">
         {markers.map((m) => (
           <span
-            key={`${m.position}-${m.label}`}
+            key={String(m.value)}
             className="absolute bottom-1 font-mono text-xs font-normal leading-4 text-gray-900 whitespace-nowrap"
             style={{ left: `${m.position * 100}%` }}
           >
@@ -506,7 +510,7 @@ export function Timeline({
           // Skip the "0s" origin marker since the left edge already implies it.
           Math.abs(marker.value) > 0.000001 ? (
             <div
-              key={`${marker.position}-${marker.label}`}
+              key={String(marker.value)}
               className="absolute top-0 bottom-0 w-px bg-gray-alpha-300"
               style={{ left: `${marker.position * 100}%` }}
             />

package/src/components/new-trace-viewer/context.tsx

@@ -9,7 +9,7 @@ import {
   useMemo,
   useState,
 } from 'react';
-import type { Span } from '../trace-viewer/types';
+import type { Span } from './types';
 
 interface ActiveSpanContextValue {
   activeSpanId: string | null;

package/src/components/new-trace-viewer/icons.tsx

@@ -3,7 +3,7 @@ const WorkflowIcon = () => {
     <svg
       data-testid="geist-icon"
       height="16"
-      stroke-linejoin="round"
+      strokeLinejoin="round"
       style={{ color: 'currentColor' }}
       viewBox="0 0 16 16"
       width="16"
@@ -21,7 +21,7 @@ const WebhookIcon = () => {
     <svg
       data-testid="geist-icon"
       height="16"
-      stroke-linejoin="round"
+      strokeLinejoin="round"
       viewBox="0 0 16 16"
       width="16"
       style={{ color: 'currentColor' }}

package/src/components/new-trace-viewer/search.ts

@@ -1,4 +1,4 @@
-import type { Span } from '../trace-viewer/types';
+import type { Span } from './types';
 
 const ATTR_FILTER_REGEX = /(?:^|\s)(?<pair>(?<key>[\w.]+):(?<value>\S*))/g;
 

package/src/components/new-trace-viewer/trace-viewer.tsx

@@ -26,8 +26,8 @@ import {
   EntityDetailPanel,
   type SelectedSpanInfo,
 } from '../sidebar/entity-detail-panel';
-import { useSidebarDataOptional } from '../sidebar/sidebar-data-context';
-import type { Trace } from '../trace-viewer/types';
+import { useSidebarData } from '../sidebar/sidebar-data-context';
+import type { TraceWithMeta } from './types';
 import { formatDuration, getHighResInMs } from '../trace-viewer/util/timing';
 import { IconButton } from '../ui/icon-button';
 import { Spinner } from '../ui/spinner';
@@ -46,12 +46,11 @@ import {
   TooltipTrigger,
 } from '../ui/tooltip';
 import { ActiveSpanProvider, useActiveSpan } from './context';
-import { DetailPanel } from './detail-panel';
 import { searchSpans } from './search';
 import { computeRootBounds, computeTimeMarkers } from './utils';
 
 interface NewTraceViewerProps {
-  trace: Trace;
+  trace: TraceWithMeta;
   onLoadMore?: () => void | Promise<void>;
   hasMore?: boolean;
   isLoadingMore?: boolean;
@@ -141,10 +140,10 @@ function useAnimatedViewport(initial: Viewport) {
 
 function useSelectedSpanInfo(): SelectedSpanInfo | null {
   const { activeSpan } = useActiveSpan();
-  const sidebar = useSidebarDataOptional();
+  const sidebar = useSidebarData();
 
   return useMemo(() => {
-    if (!activeSpan || !sidebar) return null;
+    if (!activeSpan) return null;
 
     const correlationId = activeSpan.spanId;
     const rawEvents = correlationId
@@ -193,7 +192,7 @@ function NewTraceViewerContent({
   const { activeSpan, activeSpanId, setActiveSpan, clearActiveSpan } =
     useActiveSpan();
 
-  const sidebar = useSidebarDataOptional();
+  const sidebar = useSidebarData();
   const selectedSpan = useSelectedSpanInfo();
 
   const [searchQuery, setSearchQuery] = useState('');
@@ -674,7 +673,7 @@ function NewTraceViewerContent({
       </div>
 
       {/* Detail panel */}
-      {activeSpan && sidebar ? (
+      {activeSpan ? (
         <aside className="flex flex-col h-full max-h-full bg-background-100 border-l border-gray-alpha-400 overflow-auto">
           {/* Panel header */}
           <div className="flex items-center justify-between gap-2 shrink-0 px-4 pt-3 pb-3">
@@ -750,12 +749,6 @@ function NewTraceViewerContent({
             </ErrorBoundary>
           </div>
         </aside>
-      ) : activeSpan ? (
-        <DetailPanel
-          span={activeSpan}
-          rootStart={root.startTime}
-          onClose={clearActiveSpan}
-        />
       ) : null}
     </div>
   );

package/src/components/new-trace-viewer/types.ts

@@ -0,0 +1,2 @@
+export type { Span, SpanEvent, Trace } from '../trace-viewer/types';
+export type { TraceWithMeta } from '../../lib/trace-builder';

package/src/components/new-trace-viewer/utils.ts

@@ -1,4 +1,4 @@
-import type { Span, SpanEvent } from '../trace-viewer/types';
+import type { Span, SpanEvent } from './types';
 import { formatDuration, getHighResInMs } from '../trace-viewer/util/timing';
 
 // ---------------------------------------------------------------------------