@principal-ai/subsystems-core 0.29.0

package/dist/utils/PathMatcher.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Utility for matching file paths against glob patterns
+ * Used for associating logs with components based on source paths
+ */
+export declare class PathMatcher {
+    /**
+     * Check if a file path matches a glob pattern
+     *
+     * Supports:
+     * - Exact matches: "lib/lock-manager.ts"
+     * - Wildcards: "lib/*.ts"
+     * - Double wildcards: "lib/ ** /*.ts" (without spaces)
+     * - Character sets: "lib/[abc].ts"
+     *
+     * @param path File path to test
+     * @param pattern Glob pattern
+     * @returns True if path matches pattern
+     */
+    static matches(path: string, pattern: string): boolean;
+    /**
+     * Find all patterns that match a given path
+     *
+     * @param path File path to test
+     * @param patterns Array of glob patterns
+     * @returns Array of matching patterns
+     */
+    static findMatches(path: string, patterns: string[]): string[];
+    /**
+     * Convert a glob pattern to a regular expression
+     *
+     * @param pattern Glob pattern
+     * @returns Regular expression
+     */
+    private static globToRegex;
+    /**
+     * Convert a glob pattern to a regex string (without anchors)
+     * This allows for proper composition when handling alternatives
+     */
+    private static globToRegexString;
+    /**
+     * Escape special regex characters in a string
+     */
+    private static escapeRegex;
+    /**
+     * Check if a pattern might match multiple paths (contains wildcards)
+     */
+    static isGlob(pattern: string): boolean;
+    /**
+     * Get the base directory from a glob pattern (part before first wildcard)
+     *
+     * Example: "lib/services/\*\*\/\*.ts" becomes "lib/services"
+     */
+    static getBaseDir(pattern: string): string;
+}
+//# sourceMappingURL=PathMatcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PathMatcher.d.ts","sourceRoot":"","sources":["../../src/utils/PathMatcher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,qBAAa,WAAW;IACtB;;;;;;;;;;;;OAYG;WACW,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO;IAe7D;;;;;;OAMG;WACW,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAIrE;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,WAAW;IAM1B;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;IA4FhC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,WAAW;IAI1B;;OAEG;WACW,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAI9C;;;;OAIG;WACW,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;CAYlD"}

package/dist/utils/PathMatcher.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * Utility for matching file paths against glob patterns
+ * Used for associating logs with components based on source paths
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathMatcher = void 0;
+class PathMatcher {
+    /**
+     * Check if a file path matches a glob pattern
+     *
+     * Supports:
+     * - Exact matches: "lib/lock-manager.ts"
+     * - Wildcards: "lib/*.ts"
+     * - Double wildcards: "lib/ ** /*.ts" (without spaces)
+     * - Character sets: "lib/[abc].ts"
+     *
+     * @param path File path to test
+     * @param pattern Glob pattern
+     * @returns True if path matches pattern
+     */
+    static matches(path, pattern) {
+        // Normalize paths (convert backslashes to forward slashes)
+        path = path.replace(/\\/g, '/');
+        pattern = pattern.replace(/\\/g, '/');
+        // Exact match
+        if (path === pattern) {
+            return true;
+        }
+        // Convert glob pattern to regex
+        const regex = this.globToRegex(pattern);
+        return regex.test(path);
+    }
+    /**
+     * Find all patterns that match a given path
+     *
+     * @param path File path to test
+     * @param patterns Array of glob patterns
+     * @returns Array of matching patterns
+     */
+    static findMatches(path, patterns) {
+        return patterns.filter((pattern) => this.matches(path, pattern));
+    }
+    /**
+     * Convert a glob pattern to a regular expression
+     *
+     * @param pattern Glob pattern
+     * @returns Regular expression
+     */
+    static globToRegex(pattern) {
+        const regex = this.globToRegexString(pattern);
+        // Match entire string
+        return new RegExp('^' + regex + '$');
+    }
+    /**
+     * Convert a glob pattern to a regex string (without anchors)
+     * This allows for proper composition when handling alternatives
+     */
+    static globToRegexString(pattern) {
+        let regex = '';
+        let i = 0;
+        while (i < pattern.length) {
+            const char = pattern[i];
+            switch (char) {
+                case '*':
+                    // Check for **
+                    if (pattern[i + 1] === '*') {
+                        // ** matches any number of directories
+                        if (pattern[i + 2] === '/') {
+                            regex += '(?:.*/)?'; // Match zero or more path segments
+                            i += 3;
+                        }
+                        else {
+                            // ** at end of pattern
+                            regex += '.*';
+                            i += 2;
+                        }
+                    }
+                    else {
+                        // * matches anything except /
+                        regex += '[^/]*';
+                        i++;
+                    }
+                    break;
+                case '?':
+                    // ? matches any single character except /
+                    regex += '[^/]';
+                    i++;
+                    break;
+                case '[': {
+                    // [...] matches character set
+                    let j = i + 1;
+                    while (j < pattern.length && pattern[j] !== ']') {
+                        j++;
+                    }
+                    if (j < pattern.length) {
+                        const set = pattern.substring(i + 1, j);
+                        regex += '[' + set.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + ']';
+                        i = j + 1;
+                    }
+                    else {
+                        regex += '\\[';
+                        i++;
+                    }
+                    break;
+                }
+                case '{': {
+                    // {a,b,c} matches alternatives
+                    let k = i + 1;
+                    let depth = 1;
+                    while (k < pattern.length && depth > 0) {
+                        if (pattern[k] === '{')
+                            depth++;
+                        if (pattern[k] === '}')
+                            depth--;
+                        k++;
+                    }
+                    if (depth === 0) {
+                        const alternatives = pattern.substring(i + 1, k - 1).split(',');
+                        regex += '(?:' + alternatives.map((alt) => this.globToRegexString(alt)).join('|') + ')';
+                        i = k;
+                    }
+                    else {
+                        regex += '\\{';
+                        i++;
+                    }
+                    break;
+                }
+                // Escape special regex characters
+                case '.':
+                case '+':
+                case '^':
+                case '$':
+                case '(':
+                case ')':
+                case '|':
+                case '\\':
+                    regex += '\\' + char;
+                    i++;
+                    break;
+                default:
+                    regex += char;
+                    i++;
+            }
+        }
+        return regex;
+    }
+    /**
+     * Escape special regex characters in a string
+     */
+    static escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    /**
+     * Check if a pattern might match multiple paths (contains wildcards)
+     */
+    static isGlob(pattern) {
+        return /[*?[\]{]/.test(pattern);
+    }
+    /**
+     * Get the base directory from a glob pattern (part before first wildcard)
+     *
+     * Example: "lib/services/\*\*\/\*.ts" becomes "lib/services"
+     */
+    static getBaseDir(pattern) {
+        const firstWildcard = pattern.search(/[*?[\]{]/);
+        if (firstWildcard === -1) {
+            // No wildcards, return the directory part
+            return pattern.substring(0, pattern.lastIndexOf('/'));
+        }
+        // Return part before first wildcard
+        const beforeWildcard = pattern.substring(0, firstWildcard);
+        const lastSlash = beforeWildcard.lastIndexOf('/');
+        return lastSlash === -1 ? '' : beforeWildcard.substring(0, lastSlash);
+    }
+}
+exports.PathMatcher = PathMatcher;
+//# sourceMappingURL=PathMatcher.js.map

package/dist/utils/PathMatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PathMatcher.js","sourceRoot":"","sources":["../../src/utils/PathMatcher.ts"],"names":[],"mappings":"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"}

package/dist/utils/TraceToCanvas.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Trace to Canvas Converter
+ *
+ * Converts OpenTelemetry trace data (captured from test runs) into
+ * ExtendedCanvas format for visualization.
+ */
+import type { ExtendedCanvas } from '../types/canvas';
+import type { OtelSpanKind } from '../types/otel';
+/**
+ * Span data as exported from test runs
+ */
+export interface TraceSpan {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string | null;
+    name: string;
+    kind: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    resource?: Record<string, string | number | boolean>;
+    attributes?: Record<string, string | number | boolean>;
+    status?: {
+        code: string;
+        message?: string;
+    };
+    events?: Array<{
+        name: string;
+        timestamp: number;
+        attributes?: Record<string, string | number | boolean>;
+    }>;
+}
+/**
+ * Trace export format (from test setup)
+ */
+export interface TraceExport {
+    exportedAt: string;
+    serviceName: string;
+    spanCount: number;
+    spans: TraceSpan[];
+}
+/**
+ * Options for trace-to-canvas conversion
+ */
+export interface TraceToCanvasOptions {
+    /** Group spans by service into container nodes */
+    groupByService?: boolean;
+    /** Layout algorithm */
+    layout?: 'hierarchical' | 'timeline';
+    /** Node dimensions */
+    nodeWidth?: number;
+    nodeHeight?: number;
+    /** Spacing between nodes */
+    horizontalSpacing?: number;
+    verticalSpacing?: number;
+    /** Include span attributes in node data */
+    includeAttributes?: boolean;
+    /** Filter spans by minimum duration (ms) */
+    minDurationMs?: number;
+    /** Custom colors by span kind */
+    kindColors?: Partial<Record<OtelSpanKind, string>>;
+}
+/**
+ * Result of trace-to-canvas conversion
+ */
+export interface TraceCanvasResult {
+    canvas: ExtendedCanvas;
+    stats: {
+        traceCount: number;
+        spanCount: number;
+        serviceCount: number;
+        maxDepth: number;
+    };
+}
+/**
+ * Convert trace export to ExtendedCanvas
+ */
+export declare function traceToCanvas(traceExport: TraceExport, options?: TraceToCanvasOptions): TraceCanvasResult;
+/**
+ * Convert trace export to canvas and return as JSON string
+ */
+export declare function traceToCanvasJson(traceExport: TraceExport, options?: TraceToCanvasOptions): string;
+//# sourceMappingURL=TraceToCanvas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TraceToCanvas.d.ts","sourceRoot":"","sources":["../../src/utils/TraceToCanvas.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,cAAc,EAKf,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAMlD;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;IACvD,MAAM,CAAC,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,MAAM,CAAC,EAAE,KAAK,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;KACxD,CAAC,CAAC;CACJ;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,SAAS,EAAE,CAAC;CACpB;AAMD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,kDAAkD;IAClD,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB,uBAAuB;IACvB,MAAM,CAAC,EAAE,cAAc,GAAG,UAAU,CAAC;IAErC,sBAAsB;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,4BAA4B;IAC5B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,2CAA2C;IAC3C,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B,4CAA4C;IAC5C,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,iCAAiC;IACjC,UAAU,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;CACpD;AA8RD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,cAAc,CAAC;IACvB,KAAK,EAAE;QACL,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,YAAY,EAAE,MAAM,CAAC;QACrB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE,oBAAyB,GACjC,iBAAiB,CA4GnB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE,oBAAyB,GACjC,MAAM,CAGR"}

package/dist/utils/TraceToCanvas.js

@@ -0,0 +1,336 @@
+"use strict";
+/**
+ * Trace to Canvas Converter
+ *
+ * Converts OpenTelemetry trace data (captured from test runs) into
+ * ExtendedCanvas format for visualization.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceToCanvasJson = exports.traceToCanvas = void 0;
+const DEFAULT_OPTIONS = {
+    groupByService: true,
+    layout: 'hierarchical',
+    nodeWidth: 200,
+    nodeHeight: 60,
+    horizontalSpacing: 50,
+    verticalSpacing: 80,
+    includeAttributes: true,
+    minDurationMs: 0,
+    kindColors: {
+        SERVER: '#4f46e5',
+        CLIENT: '#0891b2',
+        PRODUCER: '#059669',
+        CONSUMER: '#059669',
+        INTERNAL: '#6b7280', // Gray
+    },
+};
+// ============================================================================
+// Conversion Logic
+// ============================================================================
+/**
+ * Map span kind to node shape
+ */
+function kindToShape(kind) {
+    const shapes = {
+        SERVER: 'hexagon',
+        CLIENT: 'diamond',
+        PRODUCER: 'rectangle',
+        CONSUMER: 'rectangle',
+        INTERNAL: 'circle',
+    };
+    return shapes[kind] ?? 'rectangle';
+}
+/**
+ * Get service name from span resource
+ */
+function getServiceName(span) {
+    return span.resource?.['service.name'] ?? 'unknown';
+}
+/**
+ * Format duration for display
+ */
+function formatDuration(ms) {
+    if (ms < 1)
+        return `${(ms * 1000).toFixed(0)}μs`;
+    if (ms < 1000)
+        return `${ms.toFixed(2)}ms`;
+    return `${(ms / 1000).toFixed(2)}s`;
+}
+/**
+ * Group spans by trace ID
+ */
+function groupByTraceId(spans) {
+    const traces = new Map();
+    for (const span of spans) {
+        const existing = traces.get(span.traceId) ?? [];
+        existing.push(span);
+        traces.set(span.traceId, existing);
+    }
+    return traces;
+}
+function buildSpanTree(spans) {
+    const spanMap = new Map(spans.map((s) => [s.spanId, s]));
+    const childMap = new Map();
+    // Group by parent
+    for (const span of spans) {
+        const parentId = span.parentSpanId ?? undefined;
+        const siblings = childMap.get(parentId) ?? [];
+        siblings.push(span);
+        childMap.set(parentId, siblings);
+    }
+    // Build tree recursively
+    function buildNode(span, depth, index) {
+        const children = (childMap.get(span.spanId) ?? [])
+            .sort((a, b) => a.startTime - b.startTime)
+            .map((child, i) => buildNode(child, depth + 1, i));
+        return { span, children, depth, index };
+    }
+    // Find roots (spans with no parent or parent not in this trace)
+    const roots = spans.filter((s) => !s.parentSpanId || !spanMap.has(s.parentSpanId));
+    return roots.sort((a, b) => a.startTime - b.startTime).map((root, i) => buildNode(root, 0, i));
+}
+function calculateHierarchicalLayout(trees, options) {
+    const positions = new Map();
+    const { nodeWidth, nodeHeight, horizontalSpacing, verticalSpacing } = options;
+    // Track width at each depth level
+    const depthWidths = new Map();
+    function layoutNode(node, offsetX) {
+        const { span, children, depth } = node;
+        // Get current x position for this depth
+        const currentX = depthWidths.get(depth) ?? offsetX;
+        const y = depth * (nodeHeight + verticalSpacing);
+        if (children.length === 0) {
+            // Leaf node
+            positions.set(span.spanId, { x: currentX, y });
+            depthWidths.set(depth, currentX + nodeWidth + horizontalSpacing);
+            return currentX + nodeWidth / 2;
+        }
+        // Layout children first
+        const childCenters = [];
+        for (const child of children) {
+            const center = layoutNode(child, currentX);
+            childCenters.push(center);
+        }
+        // Center parent above children
+        const minCenter = Math.min(...childCenters);
+        const maxCenter = Math.max(...childCenters);
+        const parentCenter = (minCenter + maxCenter) / 2;
+        const parentX = parentCenter - nodeWidth / 2;
+        positions.set(span.spanId, { x: Math.max(currentX, parentX), y });
+        // Update depth width if needed
+        const newWidth = Math.max(depthWidths.get(depth) ?? 0, parentX + nodeWidth + horizontalSpacing);
+        depthWidths.set(depth, newWidth);
+        return parentCenter;
+    }
+    // Layout each tree
+    let offsetX = 0;
+    for (const tree of trees) {
+        layoutNode(tree, offsetX);
+        // Add gap between traces
+        offsetX = Math.max(...Array.from(depthWidths.values())) + horizontalSpacing;
+    }
+    return positions;
+}
+/**
+ * Convert a single span to a canvas node
+ */
+function spanToNode(span, position, options) {
+    const { nodeWidth, nodeHeight, kindColors, includeAttributes } = options;
+    const statusCode = span.status?.code ?? 'UNSET';
+    return {
+        id: span.spanId,
+        type: 'text',
+        x: position.x,
+        y: position.y,
+        width: nodeWidth,
+        height: nodeHeight,
+        text: span.name,
+        color: statusCode === 'ERROR' ? 1 : undefined,
+        pv: {
+            nodeType: 'span',
+            name: span.name,
+            description: formatDuration(span.duration),
+            shape: kindToShape(span.kind),
+            fill: statusCode === 'ERROR' ? '#ef4444' : kindColors[span.kind],
+            states: {
+                [statusCode]: {
+                    color: statusCode === 'OK' ? '#22c55e' : statusCode === 'ERROR' ? '#ef4444' : '#6b7280',
+                    label: statusCode,
+                },
+            },
+            otel: {
+                kind: 'instance',
+                category: 'span',
+            },
+            ...(includeAttributes && span.attributes && Object.keys(span.attributes).length > 0
+                ? {
+                    dataSchema: Object.fromEntries(Object.entries(span.attributes).map(([key, value]) => [
+                        key,
+                        { type: typeof value, required: false },
+                    ])),
+                }
+                : {}),
+        },
+    };
+}
+/**
+ * Create edge between parent and child span
+ */
+function createEdge(parentSpanId, childSpanId, isCrossService) {
+    return {
+        id: `edge-${parentSpanId}-${childSpanId}`,
+        fromNode: parentSpanId,
+        toNode: childSpanId,
+        fromSide: 'bottom',
+        toSide: 'top',
+        toEnd: 'arrow',
+        pv: {
+            edgeType: 'span-child',
+            style: isCrossService ? 'dashed' : 'solid',
+            width: isCrossService ? 2 : 1,
+        },
+    };
+}
+/**
+ * Create service group node
+ */
+function createServiceGroup(serviceName, spans, positions, options) {
+    const serviceSpans = spans.filter((s) => getServiceName(s) === serviceName);
+    if (serviceSpans.length === 0)
+        return null;
+    const servicePositions = serviceSpans
+        .map((s) => positions.get(s.spanId))
+        .filter((p) => p !== undefined);
+    if (servicePositions.length === 0)
+        return null;
+    const minX = Math.min(...servicePositions.map((p) => p.x));
+    const maxX = Math.max(...servicePositions.map((p) => p.x));
+    const minY = Math.min(...servicePositions.map((p) => p.y));
+    const maxY = Math.max(...servicePositions.map((p) => p.y));
+    const padding = 20;
+    return {
+        id: `service-${serviceName}`,
+        type: 'group',
+        x: minX - padding,
+        y: minY - padding - 30,
+        width: maxX - minX + options.nodeWidth + padding * 2,
+        height: maxY - minY + options.nodeHeight + padding * 2 + 30,
+        label: serviceName,
+        pv: {
+            nodeType: 'service',
+            name: serviceName,
+            icon: 'server',
+        },
+    };
+}
+/**
+ * Convert trace export to ExtendedCanvas
+ */
+function traceToCanvas(traceExport, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    // Filter spans by duration
+    const spans = traceExport.spans.filter((s) => s.duration >= opts.minDurationMs);
+    if (spans.length === 0) {
+        return {
+            canvas: {
+                name: 'Empty Trace',
+                nodes: [],
+                edges: [],
+            },
+            stats: {
+                traceCount: 0,
+                spanCount: 0,
+                serviceCount: 0,
+                maxDepth: 0,
+            },
+        };
+    }
+    // Group by trace and build trees
+    const traceGroups = groupByTraceId(spans);
+    const allTrees = [];
+    for (const traceSpans of traceGroups.values()) {
+        allTrees.push(...buildSpanTree(traceSpans));
+    }
+    // Calculate layout
+    const positions = calculateHierarchicalLayout(allTrees, opts);
+    // Create span nodes
+    const spanNodes = spans.map((span) => {
+        const position = positions.get(span.spanId) ?? { x: 0, y: 0 };
+        return spanToNode(span, position, opts);
+    });
+    // Create edges
+    const spanMap = new Map(spans.map((s) => [s.spanId, s]));
+    const edges = spans
+        .filter((span) => span.parentSpanId && spanMap.has(span.parentSpanId))
+        .map((span) => {
+        const parent = spanMap.get(span.parentSpanId);
+        const isCrossService = getServiceName(span) !== getServiceName(parent);
+        return createEdge(span.parentSpanId, span.spanId, isCrossService);
+    });
+    // Create service groups if enabled
+    const serviceGroups = [];
+    if (opts.groupByService) {
+        const services = new Set(spans.map(getServiceName));
+        for (const service of services) {
+            const group = createServiceGroup(service, spans, positions, opts);
+            if (group)
+                serviceGroups.push(group);
+        }
+    }
+    // Calculate stats
+    const maxDepth = Math.max(...allTrees.flatMap(function getDepths(tree) {
+        return [tree.depth, ...tree.children.flatMap(getDepths)];
+    }));
+    // Build canvas
+    const canvas = {
+        name: `Trace: ${traceExport.serviceName}`,
+        nodes: [...serviceGroups, ...spanNodes],
+        edges,
+        pv: {
+            description: `Exported at ${traceExport.exportedAt}`,
+            nodeTypes: {
+                span: {
+                    description: 'OpenTelemetry span from trace',
+                    shape: 'rectangle',
+                },
+                service: {
+                    description: 'Service grouping',
+                    icon: 'server',
+                    shape: 'rectangle',
+                },
+            },
+            edgeTypes: {
+                'span-child': {
+                    label: 'Child span',
+                    directed: true,
+                },
+            },
+            display: {
+                layout: 'manual',
+                animations: {
+                    enabled: true,
+                    speed: 1,
+                },
+            },
+        },
+    };
+    return {
+        canvas,
+        stats: {
+            traceCount: traceGroups.size,
+            spanCount: spans.length,
+            serviceCount: new Set(spans.map(getServiceName)).size,
+            maxDepth,
+        },
+    };
+}
+exports.traceToCanvas = traceToCanvas;
+/**
+ * Convert trace export to canvas and return as JSON string
+ */
+function traceToCanvasJson(traceExport, options = {}) {
+    const { canvas } = traceToCanvas(traceExport, options);
+    return JSON.stringify(canvas, null, 2);
+}
+exports.traceToCanvasJson = traceToCanvasJson;
+//# sourceMappingURL=TraceToCanvas.js.map