@code-pushup/utils 0.113.0 → 0.113.1

package/src/lib/profiler/trace-file-utils.d.ts

@@ -1,6 +1,5 @@
 import type { PerformanceEntry, PerformanceMark, PerformanceMeasure } from 'node:perf_hooks';
-import type { UserTimingDetail } from '../user-timing-extensibility-api.type.js';
-import type { BeginEvent, CompleteEvent, EndEvent, InstantEvent, InstantEventArgs, InstantEventTracingStartedInBrowser, SpanEventArgs, TraceEvent, TraceEventContainer, TraceEventRaw, TraceMetadata, UserTimingTraceEvent } from './trace-file.type.js';
+import type { TraceEvent, TraceEventContainer, TraceMetadata, TracingStartedInBrowserOptions } from './trace-file.type.js';
 /**
  * Generates a unique ID for linking begin and end span events in Chrome traces.
  * @returns Object with local ID string for the id2 field
@@ -9,175 +8,125 @@ export declare const nextId2: () => {
     local: string;
 };
 /**
- * Generates a unique frame tree node ID from process and thread IDs.
+ * Generates a frame tree node ID from process and thread IDs.
  * @param pid - Process ID
  * @param tid - Thread ID
- * @returns Combined numeric ID
+ * @returns Frame tree node ID as a number
  */
 export declare const frameTreeNodeId: (pid: number, tid: number) => number;
 /**
- * Generates a frame name string from process and thread IDs.
+ * Generates a frame name from process and thread IDs.
  * @param pid - Process ID
  * @param tid - Thread ID
- * @returns Formatted frame name
+ * @returns Frame name string in format FRAME0P{pid}T{tid}
  */
 export declare const frameName: (pid: number, tid: number) => string;
 /**
  * Creates an instant trace event for marking a point in time.
- * @param opt - Event configuration options
- * @returns InstantEvent object
+ * @param name - Event name
+ * @param ts - Optional timestamp in microseconds
+ * @param opt - Optional event configuration
+ * @returns Instant trace event (ph: 'I')
  */
-export declare const getInstantEvent: (opt: {
-    name: string;
-    ts?: number;
-    pid?: number;
-    tid?: number;
-    args?: InstantEventArgs;
-}) => InstantEvent;
+export declare const instant: (name: string, ts?: number, opt?: Partial<TraceEvent>) => TraceEvent;
+/**
+ * Creates a pair of begin and end span events.
+ * @param name - Span name
+ * @param tsB - Begin timestamp in microseconds
+ * @param tsE - End timestamp in microseconds
+ * @param opt - Optional event configuration
+ * @param opt.tsMarkerPadding - Padding to apply to timestamps (default: 1)
+ * @returns Array of [begin event, end event]
+ */
+export declare const span: (name: string, tsB: number, tsE: number, opt?: Partial<TraceEvent> & {
+    tsMarkerPadding?: number;
+}) => TraceEvent[];
 /**
  * Creates a start tracing event with frame information.
  * This event is needed at the beginning of the traceEvents array to make tell the UI profiling has started, and it should visualize the data.
  * @param opt - Tracing configuration options
  * @returns StartTracingEvent object
  */
-export declare const getInstantEventTracingStartedInBrowser: (opt: {
-    url: string;
-    ts?: number;
-    pid?: number;
-    tid?: number;
-}) => InstantEventTracingStartedInBrowser;
+export declare const getInstantEventTracingStartedInBrowser: (opt: TracingStartedInBrowserOptions) => TraceEvent;
 /**
  * Creates a complete trace event with duration.
- * @param opt - Event configuration with name and duration
- * @returns CompleteEvent object
+ * @param name - Event name
+ * @param dur - Duration in microseconds
+ * @param opt - Optional event configuration
+ * @returns Complete trace event (ph: 'X')
  */
-export declare const getCompleteEvent: (opt: {
-    name: string;
-    dur: number;
-    ts?: number;
-    pid?: number;
-    tid?: number;
-}) => CompleteEvent;
-/** Options for creating span events */
-type SpanOpt = {
-    name: string;
-    id2: {
-        local: string;
-    };
-    ts?: number;
-    pid?: number;
-    tid?: number;
-    args?: SpanEventArgs;
-};
-/**
- * Creates a begin span event.
- * @param ph - Phase ('b' for begin)
- * @param opt - Span event options
- * @returns BeginEvent object
- */
-export declare function getSpanEvent(ph: 'b', opt: SpanOpt): BeginEvent;
-/**
- * Creates an end span event.
- * @param ph - Phase ('e' for end)
- * @param opt - Span event options
- * @returns EndEvent object
- */
-export declare function getSpanEvent(ph: 'e', opt: SpanOpt): EndEvent;
-/**
- * Creates a pair of begin and end span events.
- * @param opt - Span configuration with start/end timestamps
- * @returns Tuple of BeginEvent and EndEvent
- */
-export declare const getSpan: (opt: {
-    name: string;
-    tsB: number;
-    tsE: number;
-    id2?: {
-        local: string;
-    };
-    pid?: number;
-    tid?: number;
-    args?: SpanEventArgs;
-    tsMarkerPadding?: number;
-}) => [BeginEvent, EndEvent];
+export declare const complete: (name: string, dur: number, opt?: Partial<TraceEvent>) => TraceEvent;
 /**
  * Converts a PerformanceMark to an instant trace event.
  * @param entry - Performance mark entry
  * @param opt - Optional overrides for name, pid, and tid
- * @returns InstantEvent object
+ * @returns Instant trace event
  */
 export declare const markToInstantEvent: (entry: PerformanceMark, opt?: {
     name?: string;
     pid?: number;
     tid?: number;
-}) => InstantEvent;
+}) => TraceEvent;
 /**
  * Converts a PerformanceMeasure to a pair of span events.
  * @param entry - Performance measure entry
  * @param opt - Optional overrides for name, pid, and tid
- * @returns Tuple of BeginEvent and EndEvent
+ * @returns Array of [begin event, end event]
  */
 export declare const measureToSpanEvents: (entry: PerformanceMeasure, opt?: {
     name?: string;
     pid?: number;
     tid?: number;
-}) => [BeginEvent, EndEvent];
+}) => TraceEvent[];
 /**
- * Converts a PerformanceEntry to an array of UserTimingTraceEvents.
+ * Converts a PerformanceEntry to an array of trace events.
  * A mark is converted to an instant event, and a measure is converted to a pair of span events.
  * Other entry types are ignored.
  * @param entry - Performance entry
- * @returns UserTimingTraceEvent[]
+ * @returns Array of trace events
+ */
+export declare function entryToTraceEvents(entry: PerformanceEntry): TraceEvent[];
+/**
+ * Encodes a trace event by converting object details to JSON strings.
+ * @param e - Trace event with potentially object details
+ * @returns Trace event with string-encoded details
+ */
+export declare const encodeEvent: (e: TraceEvent) => TraceEvent;
+/**
+ * Decodes a trace event by parsing JSON string details back to objects.
+ * @param e - Trace event with potentially string-encoded details
+ * @returns Trace event with decoded object details
+ */
+export declare const decodeEvent: (e: TraceEvent) => TraceEvent;
+/**
+ * Serializes a trace event to a JSON string for storage.
+ * First encodes the event structure (converting object details to JSON strings),
+ * then stringifies the entire event.
+ * @param event - Trace event to serialize
+ * @returns JSON string representation of the encoded trace event
+ */
+export declare const serializeTraceEvent: (event: TraceEvent) => string;
+/**
+ * Deserializes a JSON string back to a trace event.
+ * First parses the JSON string, then decodes the event structure
+ * (parsing JSON string details back to objects).
+ * @param json - JSON string representation of a trace event
+ * @returns Decoded trace event
  */
-export declare function entryToTraceEvents(entry: PerformanceEntry): UserTimingTraceEvent[];
+export declare const deserializeTraceEvent: (json: string) => TraceEvent;
 /**
  * Creates trace metadata object with standard DevTools fields and custom metadata.
  * @param startDate - Optional start date for the trace, defaults to current date
  * @param metadata - Optional additional metadata to merge into the trace metadata
  * @returns TraceMetadata object with source, startTime, and merged custom metadata
  */
-export declare function getTraceMetadata(startDate?: Date, metadata?: Record<string, unknown>): {
-    source: string;
-    startTime: string;
-    hardwareConcurrency: number;
-    dataOrigin: string;
-};
+export declare function getTraceMetadata({ startDate, ...metadata }?: Partial<TraceMetadata>): TraceMetadata;
 /**
  * Creates a complete trace file container with metadata.
  * @param opt - Trace file configuration
  * @returns TraceEventContainer with events and metadata
  */
-export declare const getTraceFile: (opt: {
+export declare const createTraceFile: (opt: {
     traceEvents: TraceEvent[];
-    startTime?: string;
     metadata?: Partial<TraceMetadata>;
 }) => TraceEventContainer;
-/**
- * Decodes a JSON string detail property back to its original object form.
- * @param target - Object containing a detail property as a JSON string
- * @returns UserTimingDetail with the detail property parsed from JSON
- */
-export declare function decodeDetail(target: {
-    detail: string;
-}): UserTimingDetail;
-/**
- * Encodes object detail properties to JSON strings for storage/transmission.
- * @param target - UserTimingDetail object with detail property to encode
- * @returns UserTimingDetail with object details converted to JSON strings
- */
-export declare function encodeDetail(target: UserTimingDetail): UserTimingDetail;
-/**
- * Decodes a raw trace event with JSON string details back to typed UserTimingTraceEvent.
- * Parses detail properties from JSON strings to objects.
- * @param event - Raw trace event with string-encoded details
- * @returns UserTimingTraceEvent with parsed detail objects
- */
-export declare function decodeTraceEvent({ args, ...rest }: TraceEventRaw): UserTimingTraceEvent;
-/**
- * Encodes a UserTimingTraceEvent to raw format with JSON string details.
- * Converts object details to JSON strings for storage/transmission.
- * @param event - UserTimingTraceEvent with object details
- * @returns TraceEventRaw with string-encoded details
- */
-export declare function encodeTraceEvent({ args, ...rest }: UserTimingTraceEvent): TraceEventRaw;
-export {};

package/src/lib/profiler/trace-file-utils.js

@@ -1,6 +1,11 @@
+import os from 'node:os';
 import { threadId } from 'node:worker_threads';
 import { defaultClock } from '../clock-epoch.js';
-/** Global counter for generating unique span IDs within a trace */
+/**
+ * Trace-local monotonic span id counter.
+ * Chrome only requires uniqueness within a single trace file.
+ * Resetting per trace is intentional - we're not aiming for global uniqueness.
+ */
 // eslint-disable-next-line functional/no-let
 let id2Count = 0;
 /**
@@ -9,44 +14,58 @@ let id2Count = 0;
  */
 export const nextId2 = () => ({ local: `0x${++id2Count}` });
 /**
- * Provides default values for trace event properties.
- * @param opt - Optional overrides for process ID, thread ID, and timestamp
- * @param opt.pid - Process ID override, defaults to current process PID
- * @param opt.tid - Thread ID override, defaults to current thread ID
- * @param opt.ts - Timestamp override in microseconds, defaults to current epoch time
- * @returns Object containing pid, tid, and ts with defaults applied
- */
-const defaults = (opt) => ({
-    pid: opt?.pid ?? process.pid,
-    tid: opt?.tid ?? threadId,
-    ts: opt?.ts ?? defaultClock.epochNowUs(),
-});
-/**
- * Generates a unique frame tree node ID from process and thread IDs.
+ * Generates a frame tree node ID from process and thread IDs.
  * @param pid - Process ID
  * @param tid - Thread ID
- * @returns Combined numeric ID
+ * @returns Frame tree node ID as a number
  */
 export const frameTreeNodeId = (pid, tid) => Number.parseInt(`${pid}0${tid}`, 10);
 /**
- * Generates a frame name string from process and thread IDs.
+ * Generates a frame name from process and thread IDs.
  * @param pid - Process ID
  * @param tid - Thread ID
- * @returns Formatted frame name
+ * @returns Frame name string in format FRAME0P{pid}T{tid}
  */
 export const frameName = (pid, tid) => `FRAME0P${pid}T${tid}`;
 /**
- * Creates an instant trace event for marking a point in time.
- * @param opt - Event configuration options
- * @returns InstantEvent object
+ * Core factory for creating trace events with defaults.
+ * @param opt - Partial trace event with required name and ph
+ * @returns Complete TraceEvent with defaults applied
  */
-export const getInstantEvent = (opt) => ({
-    cat: 'blink.user_timing',
-    ph: 'i',
-    name: opt.name,
-    ...defaults(opt),
-    args: opt.args ?? {},
+const baseEvent = (opt) => ({
+    cat: opt.cat ?? 'blink.user_timing',
+    pid: opt.pid ?? process.pid,
+    tid: opt.tid ?? threadId,
+    ts: opt.ts ?? defaultClock.epochNowUs(),
+    ...opt,
 });
+/**
+ * Creates an instant trace event for marking a point in time.
+ * @param name - Event name
+ * @param ts - Optional timestamp in microseconds
+ * @param opt - Optional event configuration
+ * @returns Instant trace event (ph: 'I')
+ */
+export const instant = (name, ts, opt) => baseEvent({ name, ph: 'I', ts, ...opt });
+/**
+ * Creates a pair of begin and end span events.
+ * @param name - Span name
+ * @param tsB - Begin timestamp in microseconds
+ * @param tsE - End timestamp in microseconds
+ * @param opt - Optional event configuration
+ * @param opt.tsMarkerPadding - Padding to apply to timestamps (default: 1)
+ * @returns Array of [begin event, end event]
+ */
+export const span = (name, tsB, tsE, opt) => {
+    const id2 = opt?.id2 ?? nextId2();
+    const pad = opt?.tsMarkerPadding ?? 1;
+    const { tsMarkerPadding, ...eventOpt } = opt ?? {};
+    const args = eventOpt.args ?? {};
+    return [
+        baseEvent({ name, ph: 'b', ts: tsB + pad, id2, ...eventOpt, args }),
+        baseEvent({ name, ph: 'e', ts: tsE - pad, id2, ...eventOpt, args }),
+    ];
+};
 /**
  * Creates a start tracing event with frame information.
  * This event is needed at the beginning of the traceEvents array to make tell the UI profiling has started, and it should visualize the data.
@@ -54,18 +73,19 @@ export const getInstantEvent = (opt) => ({
  * @returns StartTracingEvent object
  */
 export const getInstantEventTracingStartedInBrowser = (opt) => {
-    const { pid, tid, ts } = defaults(opt);
-    const id = frameTreeNodeId(pid, tid);
+    const pid = opt.pid ?? process.pid;
+    const tid = opt.tid ?? threadId;
+    const ts = opt.ts ?? defaultClock.epochNowUs();
     return {
         cat: 'devtools.timeline',
-        ph: 'i',
+        ph: 'I',
         name: 'TracingStartedInBrowser',
         pid,
         tid,
         ts,
         args: {
             data: {
-                frameTreeNodeId: id,
+                frameTreeNodeId: frameTreeNodeId(pid, tid),
                 frames: [
                     {
                         frame: frameName(pid, tid),
@@ -83,93 +103,44 @@ export const getInstantEventTracingStartedInBrowser = (opt) => {
 };
 /**
  * Creates a complete trace event with duration.
- * @param opt - Event configuration with name and duration
- * @returns CompleteEvent object
+ * @param name - Event name
+ * @param dur - Duration in microseconds
+ * @param opt - Optional event configuration
+ * @returns Complete trace event (ph: 'X')
  */
-export const getCompleteEvent = (opt) => ({
+export const complete = (name, dur, opt) => baseEvent({
     cat: 'devtools.timeline',
     ph: 'X',
-    name: opt.name,
-    dur: opt.dur,
-    ...defaults(opt),
+    name,
+    dur,
     args: {},
+    ...opt,
 });
-/**
- * Creates a span event (begin or end).
- * @param ph - Phase ('b' or 'e')
- * @param opt - Span event options
- * @returns SpanEvent object
- */
-export function getSpanEvent(ph, opt) {
-    return {
-        cat: 'blink.user_timing',
-        ph,
-        name: opt.name,
-        id2: opt.id2,
-        ...defaults(opt),
-        args: opt.args?.data?.detail
-            ? { data: { detail: opt.args.data.detail } }
-            : {},
-    };
-}
-/**
- * Creates a pair of begin and end span events.
- * @param opt - Span configuration with start/end timestamps
- * @returns Tuple of BeginEvent and EndEvent
- */
-export const getSpan = (opt) => {
-    // tsMarkerPadding is here to make the measure slightly smaller so the markers align perfectly.
-    // Otherwise, the marker is visible at the start of the measure below the frame
-    //       No padding   Padding
-    // spans: ========   |======|
-    // marks: |      |
-    const pad = opt.tsMarkerPadding ?? 1;
-    // b|e need to share the same id2
-    const id2 = opt.id2 ?? nextId2();
-    return [
-        getSpanEvent('b', {
-            ...opt,
-            id2,
-            ts: opt.tsB + pad,
-        }),
-        getSpanEvent('e', {
-            ...opt,
-            id2,
-            ts: opt.tsE - pad,
-        }),
-    ];
-};
 /**
  * Converts a PerformanceMark to an instant trace event.
  * @param entry - Performance mark entry
  * @param opt - Optional overrides for name, pid, and tid
- * @returns InstantEvent object
+ * @returns Instant trace event
  */
-export const markToInstantEvent = (entry, opt) => getInstantEvent({
-    ...opt,
-    name: opt?.name ?? entry.name,
-    ts: defaultClock.fromEntry(entry),
-    args: entry.detail ? { detail: entry.detail } : undefined,
-});
+export const markToInstantEvent = (entry, opt) => instant(opt?.name ?? entry.name, defaultClock.fromEntry(entry), entry.detail
+    ? { args: { data: { detail: entry.detail } }, ...opt }
+    : { args: {}, ...opt });
 /**
  * Converts a PerformanceMeasure to a pair of span events.
  * @param entry - Performance measure entry
  * @param opt - Optional overrides for name, pid, and tid
- * @returns Tuple of BeginEvent and EndEvent
+ * @returns Array of [begin event, end event]
  */
-export const measureToSpanEvents = (entry, opt) => getSpan({
+export const measureToSpanEvents = (entry, opt) => span(opt?.name ?? entry.name, defaultClock.fromEntry(entry), defaultClock.fromEntry(entry, true), {
     ...opt,
-    name: opt?.name ?? entry.name,
-    tsB: defaultClock.fromEntry(entry),
-    tsE: defaultClock.fromEntry(entry, true),
-    args: entry.detail ? { data: { detail: entry.detail } } : undefined,
+    args: entry.detail ? { detail: entry.detail } : {},
 });
 /**
- * Converts a PerformanceEntry to an array of UserTimingTraceEvents.
+ * Converts a PerformanceEntry to an array of trace events.
  * A mark is converted to an instant event, and a measure is converted to a pair of span events.
  * Other entry types are ignored.
  * @param entry - Performance entry
- * @returns UserTimingTraceEvent[]
+ * @returns Array of trace events
  */
 export function entryToTraceEvents(entry) {
     if (entry.entryType === 'mark') {
@@ -180,18 +151,71 @@ export function entryToTraceEvents(entry) {
     }
     return [];
 }
+/**
+ * Creates a mapper function for transforming detail properties in args.
+ * @param fn - Transformation function to apply to detail values
+ * @returns Function that maps args object
+ */
+const mapArgs = (fn) => (args) => args && {
+    ...args,
+    ...(args.detail != null && { detail: fn(args.detail) }),
+    ...(args.data?.detail != null && {
+        data: { ...args.data, detail: fn(args.data.detail) },
+    }),
+};
+/**
+ * Encodes a trace event by converting object details to JSON strings.
+ * @param e - Trace event with potentially object details
+ * @returns Trace event with string-encoded details
+ */
+export const encodeEvent = (e) => {
+    const mappedArgs = mapArgs(d => typeof d === 'object' ? JSON.stringify(d) : d)(e.args);
+    return {
+        ...e,
+        ...(mappedArgs && { args: mappedArgs }),
+    };
+};
+/**
+ * Decodes a trace event by parsing JSON string details back to objects.
+ * @param e - Trace event with potentially string-encoded details
+ * @returns Trace event with decoded object details
+ */
+export const decodeEvent = (e) => {
+    const mappedArgs = mapArgs(d => (typeof d === 'string' ? JSON.parse(d) : d))(e.args);
+    return {
+        ...e,
+        ...(mappedArgs && { args: mappedArgs }),
+    };
+};
+/**
+ * Serializes a trace event to a JSON string for storage.
+ * First encodes the event structure (converting object details to JSON strings),
+ * then stringifies the entire event.
+ * @param event - Trace event to serialize
+ * @returns JSON string representation of the encoded trace event
+ */
+export const serializeTraceEvent = (event) => JSON.stringify(encodeEvent(event));
+/**
+ * Deserializes a JSON string back to a trace event.
+ * First parses the JSON string, then decodes the event structure
+ * (parsing JSON string details back to objects).
+ * @param json - JSON string representation of a trace event
+ * @returns Decoded trace event
+ */
+export const deserializeTraceEvent = (json) => decodeEvent(JSON.parse(json));
 /**
  * Creates trace metadata object with standard DevTools fields and custom metadata.
  * @param startDate - Optional start date for the trace, defaults to current date
  * @param metadata - Optional additional metadata to merge into the trace metadata
  * @returns TraceMetadata object with source, startTime, and merged custom metadata
  */
-export function getTraceMetadata(startDate, metadata) {
+export function getTraceMetadata({ startDate, ...metadata } = {}) {
+    const parsedStartDate = (startDate instanceof Date ? startDate : new Date()).toISOString();
     return {
         source: 'DevTools',
-        startTime: startDate?.toISOString() ?? new Date().toISOString(),
-        hardwareConcurrency: 1,
+        startTime: parsedStartDate,
         dataOrigin: 'TraceEvents',
+        hardwareConcurrency: os.availableParallelism(),
         ...metadata,
     };
 }
@@ -200,91 +224,9 @@ export function getTraceMetadata(startDate, metadata) {
  * @param opt - Trace file configuration
  * @returns TraceEventContainer with events and metadata
  */
-export const getTraceFile = (opt) => ({
-    traceEvents: opt.traceEvents,
+export const createTraceFile = (opt) => ({
+    traceEvents: opt.traceEvents.map(encodeEvent),
     displayTimeUnit: 'ms',
-    metadata: getTraceMetadata(opt.startTime ? new Date(opt.startTime) : new Date(), opt.metadata),
+    metadata: getTraceMetadata(opt.metadata),
 });
-/**
- * Processes the detail property of an object using a custom processor function.
- * @template T - Object type that may contain a detail property
- * @param target - Object containing the detail property to process
- * @param processor - Function to transform the detail value
- * @returns New object with processed detail property, or original object if no detail
- */
-function processDetail(target, processor) {
-    if (target.detail != null &&
-        (typeof target.detail === 'string' || typeof target.detail === 'object')) {
-        return { ...target, detail: processor(target.detail) };
-    }
-    return target;
-}
-/**
- * Decodes a JSON string detail property back to its original object form.
- * @param target - Object containing a detail property as a JSON string
- * @returns UserTimingDetail with the detail property parsed from JSON
- */
-export function decodeDetail(target) {
-    return processDetail(target, detail => typeof detail === 'string'
-        ? JSON.parse(detail)
-        : detail);
-}
-/**
- * Encodes object detail properties to JSON strings for storage/transmission.
- * @param target - UserTimingDetail object with detail property to encode
- * @returns UserTimingDetail with object details converted to JSON strings
- */
-export function encodeDetail(target) {
-    return processDetail(target, (detail) => typeof detail === 'object'
-        ? JSON.stringify(detail)
-        : detail);
-}
-/**
- * Decodes a raw trace event with JSON string details back to typed UserTimingTraceEvent.
- * Parses detail properties from JSON strings to objects.
- * @param event - Raw trace event with string-encoded details
- * @returns UserTimingTraceEvent with parsed detail objects
- */
-export function decodeTraceEvent({ args, ...rest }) {
-    if (!args) {
-        return rest;
-    }
-    const processedArgs = decodeDetail(args);
-    if ('data' in args && args.data && typeof args.data === 'object') {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        return {
-            ...rest,
-            args: {
-                ...processedArgs,
-                data: decodeDetail(args.data),
-            },
-        };
-    }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return { ...rest, args: processedArgs };
-}
-/**
- * Encodes a UserTimingTraceEvent to raw format with JSON string details.
- * Converts object details to JSON strings for storage/transmission.
- * @param event - UserTimingTraceEvent with object details
- * @returns TraceEventRaw with string-encoded details
- */
-export function encodeTraceEvent({ args, ...rest }) {
-    if (!args) {
-        return rest;
-    }
-    const processedArgs = encodeDetail(args);
-    if ('data' in args && args.data && typeof args.data === 'object') {
-        const result = {
-            ...rest,
-            args: {
-                ...processedArgs,
-                data: encodeDetail(args.data),
-            },
-        };
-        return result;
-    }
-    const result = { ...rest, args: processedArgs };
-    return result;
-}
 //# sourceMappingURL=trace-file-utils.js.map