@principal-ai/control-tower-core 0.2.1 → 0.2.2

package/dist/telemetry/TelemetryCapture.js

@@ -0,0 +1,263 @@
+"use strict";
+/**
+ * Telemetry Capture and Replay System
+ *
+ * Allows capturing telemetry events during test execution and replaying them later.
+ * This enables:
+ * - Saving telemetry as test artifacts
+ * - Loading telemetry for visualization
+ * - Not depending on live emission during tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryPlayer = exports.TelemetryCapture = void 0;
+exports.saveTelemetryArtifact = saveTelemetryArtifact;
+exports.loadTelemetryArtifact = loadTelemetryArtifact;
+/**
+ * Telemetry Capture
+ *
+ * Captures telemetry events in memory and exports them as artifacts.
+ */
+class TelemetryCapture {
+    constructor(options = {}) {
+        this.events = [];
+        this.sequenceCounter = 0;
+        this.startTime = Date.now();
+        this.metadata = {
+            sessionId: options.sessionId || `session-${this.startTime}-${Math.random().toString(36).slice(2)}`,
+            startTime: this.startTime,
+            testName: options.testName,
+            testCategory: options.testCategory,
+            tags: options.tags,
+        };
+    }
+    /**
+     * Create an event handler for ControlTowerTelemetry
+     */
+    createEventHandler() {
+        return (nodeId, eventName, attributes) => {
+            this.captureEvent(nodeId, eventName, attributes);
+        };
+    }
+    /**
+     * Capture a telemetry event
+     */
+    captureEvent(nodeId, eventName, attributes) {
+        const event = {
+            timestamp: Date.now(),
+            nodeId,
+            eventName,
+            attributes: { ...attributes }, // Clone to avoid mutation
+            sequenceNumber: this.sequenceCounter++,
+        };
+        this.events.push(event);
+    }
+    /**
+     * Stop capturing and finalize metadata
+     */
+    stop() {
+        this.metadata.endTime = Date.now();
+    }
+    /**
+     * Export as artifact in OpenTelemetry spans format
+     */
+    export() {
+        if (!this.metadata.endTime) {
+            this.stop();
+        }
+        const duration = this.metadata.endTime - this.metadata.startTime;
+        // Create a single span containing all events
+        const span = {
+            id: this.metadata.sessionId,
+            name: this.metadata.testName || 'test-execution',
+            startTime: this.metadata.startTime,
+            endTime: this.metadata.endTime,
+            duration,
+            status: 'OK',
+            attributes: {
+                'test.category': this.metadata.testCategory,
+                'test.name': this.metadata.testName,
+                ...this.metadata.tags,
+            },
+            events: this.events.map(e => ({
+                time: e.timestamp,
+                name: e.eventName,
+                attributes: {
+                    'node.id': e.nodeId,
+                    ...e.attributes,
+                },
+            })),
+        };
+        return {
+            metadata: {
+                canvasName: this.metadata.tags?.canvas,
+                exportedAt: new Date(this.metadata.endTime).toISOString(),
+                source: this.metadata.testName,
+                framework: 'bun:test',
+                status: 'OK',
+                testCategory: this.metadata.testCategory,
+                tags: this.metadata.tags,
+            },
+            spans: [span],
+        };
+    }
+    /**
+     * Export as JSON string
+     */
+    exportJSON(pretty = true) {
+        return JSON.stringify(this.export(), null, pretty ? 2 : 0);
+    }
+    /**
+     * Get events captured so far
+     */
+    getEvents() {
+        return this.events;
+    }
+    /**
+     * Get event count
+     */
+    getEventCount() {
+        return this.events.length;
+    }
+    /**
+     * Clear all captured events
+     */
+    clear() {
+        this.events = [];
+        this.sequenceCounter = 0;
+    }
+}
+exports.TelemetryCapture = TelemetryCapture;
+/**
+ * Telemetry Player
+ *
+ * Replays captured telemetry events.
+ */
+class TelemetryPlayer {
+    constructor(artifact) {
+        this.currentIndex = 0;
+        this.artifact = artifact;
+    }
+    /**
+     * Load artifact from JSON string
+     */
+    static fromJSON(json) {
+        const artifact = JSON.parse(json);
+        return new TelemetryPlayer(artifact);
+    }
+    /**
+     * Load artifact from file
+     */
+    static fromFile(path) {
+        const fs = require('fs');
+        const json = fs.readFileSync(path, 'utf-8');
+        return TelemetryPlayer.fromJSON(json);
+    }
+    /**
+     * Get artifact metadata
+     */
+    getMetadata() {
+        return this.artifact.metadata;
+    }
+    /**
+     * Get all spans
+     */
+    getSpans() {
+        return this.artifact.spans;
+    }
+    /**
+     * Get all events from all spans
+     */
+    getAllEvents() {
+        return this.artifact.spans.flatMap(span => span.events);
+    }
+    /**
+     * Get summary statistics
+     */
+    getSummary() {
+        const allEvents = this.getAllEvents();
+        return {
+            totalSpans: this.artifact.spans.length,
+            totalEvents: allEvents.length,
+            status: this.artifact.metadata?.status || 'OK',
+        };
+    }
+    /**
+     * Get events for a specific node
+     */
+    getEventsByNode(nodeId) {
+        return this.getAllEvents().filter(e => e.attributes?.['node.id'] === nodeId);
+    }
+    /**
+     * Get events by name
+     */
+    getEventsByName(eventName) {
+        return this.getAllEvents().filter(e => e.name === eventName);
+    }
+    /**
+     * Get events in time range
+     */
+    getEventsInRange(startTime, endTime) {
+        return this.getAllEvents().filter(e => e.time >= startTime && e.time <= endTime);
+    }
+    /**
+     * Replay events with callback
+     */
+    replay(callback) {
+        for (const event of this.getAllEvents()) {
+            callback(event);
+        }
+    }
+    /**
+     * Replay events with timing (respects original timing)
+     */
+    async replayWithTiming(callback) {
+        const allEvents = this.getAllEvents();
+        if (allEvents.length === 0)
+            return;
+        const baseTime = allEvents[0].time;
+        for (const event of allEvents) {
+            const delay = event.time - baseTime;
+            await new Promise(resolve => setTimeout(resolve, delay));
+            await callback(event);
+        }
+    }
+    /**
+     * Get next event (for step-through debugging)
+     */
+    next() {
+        const allEvents = this.getAllEvents();
+        if (this.currentIndex >= allEvents.length) {
+            return null;
+        }
+        return allEvents[this.currentIndex++];
+    }
+    /**
+     * Reset player to beginning
+     */
+    reset() {
+        this.currentIndex = 0;
+    }
+    /**
+     * Check if more events available
+     */
+    hasNext() {
+        return this.currentIndex < this.getAllEvents().length;
+    }
+}
+exports.TelemetryPlayer = TelemetryPlayer;
+/**
+ * Helper to save artifact to file
+ */
+function saveTelemetryArtifact(artifact, path, pretty = true) {
+    const fs = require('fs');
+    const json = JSON.stringify(artifact, null, pretty ? 2 : 0);
+    fs.writeFileSync(path, json, 'utf-8');
+}
+/**
+ * Helper to load artifact from file
+ */
+function loadTelemetryArtifact(path) {
+    const fs = require('fs');
+    const json = fs.readFileSync(path, 'utf-8');
+    return JSON.parse(json);
+}

package/dist/telemetry/TelemetryCapture.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Telemetry Capture Tests
+ *
+ * Demonstrates how to capture and replay telemetry for narrative tests.
+ */
+export {};
+//# sourceMappingURL=TelemetryCapture.test.d.ts.map

package/dist/telemetry/TelemetryCapture.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TelemetryCapture.test.d.ts","sourceRoot":"","sources":["../../src/telemetry/TelemetryCapture.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/telemetry/TelemetryCapture.test.js

@@ -0,0 +1,396 @@
+"use strict";
+/**
+ * Telemetry Capture Tests
+ *
+ * Demonstrates how to capture and replay telemetry for narrative tests.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const bun_test_1 = require("bun:test");
+const TelemetryCapture_1 = require("./TelemetryCapture");
+const EventValidationIntegration_1 = require("./EventValidationIntegration");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+(0, bun_test_1.describe)('TelemetryCapture', () => {
+    let capture;
+    let telemetry;
+    (0, bun_test_1.beforeEach)(() => {
+        // Create capture for a narrative test
+        capture = new TelemetryCapture_1.TelemetryCapture({
+            testName: 'Client Connection Flow',
+            testCategory: 'Integration',
+            tags: { feature: 'client-lifecycle', version: '1.0.0' },
+        });
+        // Create telemetry with capture handler
+        const canvas = (0, EventValidationIntegration_1.loadControlTowerCanvas)();
+        telemetry = new EventValidationIntegration_1.ControlTowerTelemetry(canvas, {
+            strict: false,
+            onEvent: capture.createEventHandler(),
+        });
+    });
+    (0, bun_test_1.describe)('Event Capture', () => {
+        (0, bun_test_1.test)('should capture events with metadata', () => {
+            // Emit some events
+            telemetry.clientLifecycle('client.connected', {
+                'client.id': 'client-123',
+                'transport.type': 'websocket',
+                'connection.time': Date.now(),
+            });
+            telemetry.clientLifecycle('client.authenticated', {
+                'client.id': 'client-123',
+                'user.id': 'user-456',
+                'auth.method': 'jwt',
+            });
+            // Verify capture
+            const events = capture.getEvents();
+            (0, bun_test_1.expect)(events).toHaveLength(2);
+            (0, bun_test_1.expect)(events[0].nodeId).toBe('client-lifecycle');
+            (0, bun_test_1.expect)(events[0].eventName).toBe('client.connected');
+            (0, bun_test_1.expect)(events[0].sequenceNumber).toBe(0);
+            (0, bun_test_1.expect)(events[1].sequenceNumber).toBe(1);
+        });
+        (0, bun_test_1.test)('should include timestamps', () => {
+            const before = Date.now();
+            telemetry.messageHandler('message.received', {
+                'client.id': 'client-123',
+                'message.type': 'test',
+                'message.size': 100,
+            });
+            const after = Date.now();
+            const events = capture.getEvents();
+            (0, bun_test_1.expect)(events[0].timestamp).toBeGreaterThanOrEqual(before);
+            (0, bun_test_1.expect)(events[0].timestamp).toBeLessThanOrEqual(after);
+        });
+        (0, bun_test_1.test)('should clone attributes to prevent mutation', () => {
+            const attrs = {
+                'client.id': 'client-123',
+                'transport.type': 'websocket',
+                'connection.time': Date.now(),
+            };
+            telemetry.clientLifecycle('client.connected', attrs);
+            // Mutate original
+            attrs['transport.type'] = 'webrtc';
+            // Verify captured version is unchanged
+            const events = capture.getEvents();
+            (0, bun_test_1.expect)(events[0].attributes['transport.type']).toBe('websocket');
+        });
+    });
+    (0, bun_test_1.describe)('Artifact Export', () => {
+        (0, bun_test_1.test)('should export complete artifact', () => {
+            // Simulate a narrative test flow
+            telemetry.clientLifecycle('client.connected', {
+                'client.id': 'client-123',
+                'transport.type': 'websocket',
+                'connection.time': Date.now(),
+            });
+            telemetry.roomManager('room.created', {
+                'room.id': 'room-001',
+                'creator.id': 'client-123',
+                'config.max_events': 1000,
+            });
+            telemetry.roomManager('room.client_joined', {
+                'room.id': 'room-001',
+                'client.id': 'client-123',
+                'room.client_count': 1,
+            });
+            capture.stop();
+            const artifact = capture.export();
+            // Verify artifact structure
+            (0, bun_test_1.expect)(artifact.version).toBe('1.0.0');
+            (0, bun_test_1.expect)(artifact.metadata.testName).toBe('Client Connection Flow');
+            (0, bun_test_1.expect)(artifact.metadata.testCategory).toBe('Integration');
+            (0, bun_test_1.expect)(artifact.metadata.tags).toEqual({
+                feature: 'client-lifecycle',
+                version: '1.0.0',
+            });
+            (0, bun_test_1.expect)(artifact.events).toHaveLength(3);
+            (0, bun_test_1.expect)(artifact.summary.totalEvents).toBe(3);
+            (0, bun_test_1.expect)(artifact.summary.eventsByNode['client-lifecycle']).toBe(1);
+            (0, bun_test_1.expect)(artifact.summary.eventsByNode['room-manager']).toBe(2);
+        });
+        (0, bun_test_1.test)('should calculate summary statistics', () => {
+            // Multiple events from different nodes
+            telemetry.messageHandler('message.received', {
+                'client.id': 'client-123',
+                'message.type': 'test',
+            });
+            telemetry.messageHandler('message.received', {
+                'client.id': 'client-456',
+                'message.type': 'test',
+            });
+            telemetry.clientLifecycle('client.connected', {
+                'client.id': 'client-123',
+                'transport.type': 'websocket',
+                'connection.time': Date.now(),
+            });
+            const artifact = capture.export();
+            (0, bun_test_1.expect)(artifact.summary.totalEvents).toBe(3);
+            (0, bun_test_1.expect)(artifact.summary.eventsByNode['message-handler']).toBe(2);
+            (0, bun_test_1.expect)(artifact.summary.eventsByNode['client-lifecycle']).toBe(1);
+            (0, bun_test_1.expect)(artifact.summary.eventsByName['message.received']).toBe(2);
+            (0, bun_test_1.expect)(artifact.summary.eventsByName['client.connected']).toBe(1);
+        });
+        (0, bun_test_1.test)('should export as JSON', () => {
+            telemetry.clientLifecycle('client.connected', {
+                'client.id': 'client-123',
+                'transport.type': 'websocket',
+                'connection.time': Date.now(),
+            });
+            const json = capture.exportJSON();
+            const parsed = JSON.parse(json);
+            (0, bun_test_1.expect)(parsed.version).toBe('1.0.0');
+            (0, bun_test_1.expect)(parsed.events).toHaveLength(1);
+        });
+    });
+    (0, bun_test_1.describe)('File Persistence', () => {
+        let tempDir;
+        let artifactPath;
+        (0, bun_test_1.beforeEach)(() => {
+            tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'telemetry-test-'));
+            artifactPath = path.join(tempDir, 'test-artifact.json');
+        });
+        (0, bun_test_1.test)('should save and load artifacts', () => {
+            // Capture events
+            telemetry.clientLifecycle('client.connected', {
+                'client.id': 'client-123',
+                'transport.type': 'websocket',
+                'connection.time': Date.now(),
+            });
+            telemetry.clientLifecycle('client.authenticated', {
+                'client.id': 'client-123',
+                'user.id': 'user-456',
+                'auth.method': 'jwt',
+            });
+            // Save to file
+            const artifact = capture.export();
+            (0, TelemetryCapture_1.saveTelemetryArtifact)(artifact, artifactPath);
+            // Verify file exists
+            (0, bun_test_1.expect)(fs.existsSync(artifactPath)).toBe(true);
+            // Load from file
+            const loaded = (0, TelemetryCapture_1.loadTelemetryArtifact)(artifactPath);
+            (0, bun_test_1.expect)(loaded.version).toBe(artifact.version);
+            (0, bun_test_1.expect)(loaded.events).toHaveLength(2);
+            (0, bun_test_1.expect)(loaded.metadata.testName).toBe('Client Connection Flow');
+        });
+    });
+});
+(0, bun_test_1.describe)('TelemetryPlayer', () => {
+    let artifact;
+    (0, bun_test_1.beforeEach)(() => {
+        // Create a sample artifact
+        const capture = new TelemetryCapture_1.TelemetryCapture({
+            testName: 'Sample Test',
+            testCategory: 'Integration',
+        });
+        const canvas = (0, EventValidationIntegration_1.loadControlTowerCanvas)();
+        const telemetry = new EventValidationIntegration_1.ControlTowerTelemetry(canvas, {
+            onEvent: capture.createEventHandler(),
+        });
+        // Simulate events
+        telemetry.clientLifecycle('client.connected', {
+            'client.id': 'client-123',
+            'transport.type': 'websocket',
+            'connection.time': Date.now(),
+        });
+        telemetry.roomManager('room.created', {
+            'room.id': 'room-001',
+            'creator.id': 'client-123',
+        });
+        telemetry.roomManager('room.client_joined', {
+            'room.id': 'room-001',
+            'client.id': 'client-123',
+            'room.client_count': 1,
+        });
+        artifact = capture.export();
+    });
+    (0, bun_test_1.describe)('Playback', () => {
+        (0, bun_test_1.test)('should load artifact and provide metadata', () => {
+            const player = new TelemetryCapture_1.TelemetryPlayer(artifact);
+            const metadata = player.getMetadata();
+            (0, bun_test_1.expect)(metadata.testName).toBe('Sample Test');
+            (0, bun_test_1.expect)(metadata.testCategory).toBe('Integration');
+        });
+        (0, bun_test_1.test)('should provide all events', () => {
+            const player = new TelemetryCapture_1.TelemetryPlayer(artifact);
+            const events = player.getAllEvents();
+            (0, bun_test_1.expect)(events).toHaveLength(3);
+            (0, bun_test_1.expect)(events[0].eventName).toBe('client.connected');
+        });
+        (0, bun_test_1.test)('should filter events by node', () => {
+            const player = new TelemetryCapture_1.TelemetryPlayer(artifact);
+            const roomEvents = player.getEventsByNode('room-manager');
+            (0, bun_test_1.expect)(roomEvents).toHaveLength(2);
+            (0, bun_test_1.expect)(roomEvents[0].eventName).toBe('room.created');
+            (0, bun_test_1.expect)(roomEvents[1].eventName).toBe('room.client_joined');
+        });
+        (0, bun_test_1.test)('should filter events by name', () => {
+            const player = new TelemetryCapture_1.TelemetryPlayer(artifact);
+            const connectedEvents = player.getEventsByName('client.connected');
+            (0, bun_test_1.expect)(connectedEvents).toHaveLength(1);
+            (0, bun_test_1.expect)(connectedEvents[0].nodeId).toBe('client-lifecycle');
+        });
+        (0, bun_test_1.test)('should replay events with callback', () => {
+            const player = new TelemetryCapture_1.TelemetryPlayer(artifact);
+            const replayed = [];
+            player.replay(event => {
+                replayed.push(event.eventName);
+            });
+            (0, bun_test_1.expect)(replayed).toEqual([
+                'client.connected',
+                'room.created',
+                'room.client_joined',
+            ]);
+        });
+        (0, bun_test_1.test)('should support step-through playback', () => {
+            const player = new TelemetryCapture_1.TelemetryPlayer(artifact);
+            (0, bun_test_1.expect)(player.hasNext()).toBe(true);
+            const event1 = player.next();
+            (0, bun_test_1.expect)(event1?.eventName).toBe('client.connected');
+            const event2 = player.next();
+            (0, bun_test_1.expect)(event2?.eventName).toBe('room.created');
+            const event3 = player.next();
+            (0, bun_test_1.expect)(event3?.eventName).toBe('room.client_joined');
+            (0, bun_test_1.expect)(player.hasNext()).toBe(false);
+            (0, bun_test_1.expect)(player.next()).toBeNull();
+        });
+        (0, bun_test_1.test)('should reset playback', () => {
+            const player = new TelemetryCapture_1.TelemetryPlayer(artifact);
+            player.next();
+            player.next();
+            player.reset();
+            const event = player.next();
+            (0, bun_test_1.expect)(event?.eventName).toBe('client.connected');
+        });
+    });
+    (0, bun_test_1.describe)('File Loading', () => {
+        (0, bun_test_1.test)('should load from JSON string', () => {
+            const json = JSON.stringify(artifact);
+            const player = TelemetryCapture_1.TelemetryPlayer.fromJSON(json);
+            (0, bun_test_1.expect)(player.getAllEvents()).toHaveLength(3);
+        });
+        (0, bun_test_1.test)('should load from file', () => {
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'telemetry-test-'));
+            const artifactPath = path.join(tempDir, 'artifact.json');
+            (0, TelemetryCapture_1.saveTelemetryArtifact)(artifact, artifactPath);
+            const player = TelemetryCapture_1.TelemetryPlayer.fromFile(artifactPath);
+            (0, bun_test_1.expect)(player.getAllEvents()).toHaveLength(3);
+            (0, bun_test_1.expect)(player.getMetadata().testName).toBe('Sample Test');
+        });
+    });
+});
+(0, bun_test_1.describe)('Narrative Test Example', () => {
+    (0, bun_test_1.test)('should capture complete client connection flow', () => {
+        // This demonstrates a narrative test that captures telemetry
+        const capture = new TelemetryCapture_1.TelemetryCapture({
+            testName: 'Complete Client Connection Flow',
+            testCategory: 'Narrative Tests',
+            tags: {
+                feature: 'client-lifecycle',
+                scenario: 'happy-path',
+            },
+        });
+        const canvas = (0, EventValidationIntegration_1.loadControlTowerCanvas)();
+        const telemetry = new EventValidationIntegration_1.ControlTowerTelemetry(canvas, {
+            strict: false,
+            onEvent: capture.createEventHandler(),
+        });
+        // Simulate complete flow
+        const clientId = 'client-abc123';
+        const userId = 'user-xyz789';
+        const roomId = 'room-collab-001';
+        // 1. Client connects
+        telemetry.clientLifecycle('client.connected', {
+            'client.id': clientId,
+            'transport.type': 'websocket',
+            'connection.time': Date.now(),
+        });
+        // 2. Client authenticates
+        telemetry.clientLifecycle('client.authenticated', {
+            'client.id': clientId,
+            'user.id': userId,
+            'auth.method': 'jwt',
+        });
+        // 3. Create room
+        telemetry.roomManager('room.created', {
+            'room.id': roomId,
+            'creator.id': clientId,
+            'config.max_events': 1000,
+        });
+        // 4. Client joins room
+        telemetry.roomManager('room.client_joined', {
+            'room.id': roomId,
+            'client.id': clientId,
+            'room.client_count': 1,
+        });
+        // 5. Broadcast event
+        telemetry.eventBroadcaster('event.broadcast', {
+            'room.id': roomId,
+            'event.type': 'file_change',
+            'recipient.count': 1,
+        });
+        // 6. Acquire lock
+        telemetry.lockManager('lock.acquired', {
+            'lock.id': 'file:/src/index.ts',
+            'client.id': clientId,
+            'lock.type': 'file',
+            'queue.wait_time': 50,
+        });
+        // 7. Update presence
+        telemetry.presenceManager('presence.status_changed', {
+            'user.id': userId,
+            'status.from': 'offline',
+            'status.to': 'online',
+            'device.count': 1,
+        });
+        // Export artifact
+        capture.stop();
+        const artifact = capture.export();
+        // Verify narrative flow
+        (0, bun_test_1.expect)(artifact.events).toHaveLength(7);
+        (0, bun_test_1.expect)(artifact.metadata.testName).toBe('Complete Client Connection Flow');
+        (0, bun_test_1.expect)(artifact.summary.eventsByNode['client-lifecycle']).toBe(2);
+        (0, bun_test_1.expect)(artifact.summary.eventsByNode['room-manager']).toBe(2);
+        (0, bun_test_1.expect)(artifact.summary.eventsByNode['event-broadcaster']).toBe(1);
+        (0, bun_test_1.expect)(artifact.summary.eventsByNode['lock-manager']).toBe(1);
+        (0, bun_test_1.expect)(artifact.summary.eventsByNode['presence-manager']).toBe(1);
+        // This artifact can now be:
+        // 1. Saved to test/fixtures/narratives/client-connection-flow.json
+        // 2. Loaded in Storybook for visualization
+        // 3. Used for regression testing
+        // 4. Analyzed for performance metrics
+        console.log('Artifact summary:', artifact.summary);
+    });
+});