@oxy.so/telemetry 1.2.0 → 2.0.0

package/dist/esm/socket.js

@@ -1,11 +1,26 @@
 import { normalizeInfrastructureRegion } from './collector.js';
 import { metadataFromHeaders } from './server.js';
 const CATEGORIES = {
-    auth: 'identity', session: 'identity', user: 'identity', profile: 'identity',
-    chat: 'ai', agent: 'ai', inference: 'ai', completion: 'ai',
-    message: 'communication', notification: 'communication', typing: 'communication',
-    media: 'media', audio: 'media', video: 'media', stream: 'media', player: 'media',
-    track: 'media', playback: 'media', playlist: 'media', room: 'media',
+    auth: 'identity',
+    session: 'identity',
+    user: 'identity',
+    profile: 'identity',
+    chat: 'ai',
+    agent: 'ai',
+    inference: 'ai',
+    completion: 'ai',
+    message: 'communication',
+    notification: 'communication',
+    typing: 'communication',
+    media: 'media',
+    audio: 'media',
+    video: 'media',
+    stream: 'media',
+    player: 'media',
+    track: 'media',
+    playback: 'media',
+    playlist: 'media',
+    room: 'media',
 };
 /** Event names are reduced locally to five categories; payloads are never read. */
 export function socketTrafficType(event) {
@@ -27,9 +42,16 @@ export function observeTrafficSocket(socket, collector, service, region, options
         const peer = options.getPeer?.();
         const peerService = peer && /^[a-z][a-z0-9-]{0,39}$/.test(peer.service) ? peer.service : undefined;
         const edgePop = metadataFromHeaders(socket.handshake.headers).edgePop;
-        const peerRegion = peerService ? normalizeInfrastructureRegion(peer?.region) : edgePop ? `edge-${edgePop}` : undefined;
+        const peerRegion = peerService
+            ? normalizeInfrastructureRegion(peer?.region)
+            : edgePop
+                ? `edge-${edgePop}`
+                : undefined;
         collector.record({
-            region, service, scope: peerService ? 'internal' : 'external', direction,
+            region,
+            service,
+            scope: peerService ? 'internal' : 'external',
+            direction,
             activityType: socketTrafficType(event),
             sourceRegion: direction === 'inbound' ? peerRegion : region,
             targetRegion: direction === 'inbound' ? region : peerRegion,
@@ -61,9 +83,16 @@ export function observeTrafficWebSocket(socket, collector, service, region, opti
         const peer = options.getPeer?.();
         const peerService = peer && /^[a-z][a-z0-9-]{0,39}$/.test(peer.service) ? peer.service : undefined;
         const edgePop = metadataFromHeaders(options.headers ?? {}).edgePop;
-        const peerRegion = peerService ? normalizeInfrastructureRegion(peer?.region) : edgePop ? `edge-${edgePop}` : undefined;
+        const peerRegion = peerService
+            ? normalizeInfrastructureRegion(peer?.region)
+            : edgePop
+                ? `edge-${edgePop}`
+                : undefined;
         collector.record({
-            service, region, scope: peerService ? 'internal' : 'external', direction,
+            service,
+            region,
+            scope: peerService ? 'internal' : 'external',
+            direction,
             activityType: options.activityType ?? 'communication',
             sourceRegion: direction === 'inbound' ? peerRegion : region,
             targetRegion: direction === 'inbound' ? region : peerRegion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxy.so/telemetry",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "description": "Framework-agnostic anonymous activity telemetry primitives for Oxy services.",
   "type": "module",
   "main": "dist/cjs/index.js",
@@ -19,9 +19,6 @@
       ],
       "socket": [
         "dist/types/socket.d.ts"
-      ],
-      "edge": [
-        "dist/types/edge.d.ts"
       ]
     }
   },
@@ -91,16 +88,6 @@
         "types": "./dist/types/socket.d.ts",
         "default": "./dist/cjs/socket.js"
       }
-    },
-    "./edge": {
-      "import": {
-        "types": "./dist/types/edge.d.ts",
-        "default": "./dist/esm/edge.js"
-      },
-      "require": {
-        "types": "./dist/types/edge.d.ts",
-        "default": "./dist/cjs/edge.js"
-      }
     }
   },
   "files": [
@@ -109,7 +96,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/oxyhq/sdk",
+    "url": "git+https://github.com/OxyHQ/oxy.git",
     "directory": "packages/telemetry"
   },
   "license": "SEE LICENSE IN LICENSE",
@@ -130,7 +117,6 @@
     "prepublishOnly": "node ../../scripts/assert-bun-publish.mjs && bun run typescript && bun run test && bun run build"
   },
   "devDependencies": {
-    "@biomejs/biome": "^1.9.4",
     "@types/jest": "^30.0.0",
     "jest": "^30.5.1",
     "jest-environment-jsdom": "^30.5.1",

package/src/__tests__/browser.test.ts

@@ -47,8 +47,15 @@ describe('browser telemetry', () => {
   it('rediscovers the edge after a VPN change without reloading the page', async () => {
     let now = 1_000;
     let edge = 'MAD';
-    const fetchTrace = jest.fn(async () => ({ ok: true, text: async () => `colo=${edge}\nip=203.0.113.8\nloc=ES` }));
-    const telemetry = createBrowserTelemetry({ location: { hostname: 'oxy.so', protocol: 'https:' }, now: () => now, fetchTrace });
+    const fetchTrace = jest.fn(async () => ({
+      ok: true,
+      text: async () => `colo=${edge}\nip=203.0.113.8\nloc=ES`,
+    }));
+    const telemetry = createBrowserTelemetry({
+      location: { hostname: 'oxy.so', protocol: 'https:' },
+      now: () => now,
+      fetchTrace,
+    });
     await expect(telemetry.getEdgeRegionHeader()).resolves.toEqual({ 'X-Oxy-Edge-Region': 'mad' });
     edge = 'NRT';
     now += 15_000;
@@ -58,13 +65,19 @@ describe('browser telemetry', () => {
 
   it('retries failed discovery on the next window instead of caching failure for the session', async () => {
     let now = 1_000;
-    const fetchTrace = jest.fn().mockRejectedValueOnce(new Error('offline')).mockResolvedValue({ ok: true, text: async () => 'colo=SYD' });
-    const telemetry = createBrowserTelemetry({ location: { hostname: 'oxy.so', protocol: 'https:' }, now: () => now, fetchTrace });
+    const fetchTrace = jest
+      .fn()
+      .mockRejectedValueOnce(new Error('offline'))
+      .mockResolvedValue({ ok: true, text: async () => 'colo=SYD' });
+    const telemetry = createBrowserTelemetry({
+      location: { hostname: 'oxy.so', protocol: 'https:' },
+      now: () => now,
+      fetchTrace,
+    });
     await expect(telemetry.getEdgeRegionHeader()).resolves.toEqual({});
     now += 15_000;
     await expect(telemetry.getEdgeRegionHeader()).resolves.toEqual({ 'X-Oxy-Edge-Region': 'syd' });
   });
-
 });
 
 describe('peekEdgeRegionHeader', () => {
@@ -75,7 +88,10 @@ describe('peekEdgeRegionHeader', () => {
       now: () => clock,
       location: { hostname: 'app.oxy.so', protocol: 'https:' },
       edgePeekRefreshMs: 1000,
-      fetchTrace: async () => ({ ok: true, text: async () => `colo=${pops.shift()?.toUpperCase()}\n` }),
+      fetchTrace: async () => ({
+        ok: true,
+        text: async () => `colo=${pops.shift()?.toUpperCase()}\n`,
+      }),
     });
 
     expect(telemetry.peekEdgeRegionHeader()).toEqual({});

package/src/__tests__/collector.test.ts

@@ -1,48 +1,95 @@
 /** @jest-environment node */
 import { EventEmitter } from 'node:events';
-import { createTrafficCollector, instrumentTrafficFetch, trafficMiddleware, trafficType, type TrafficAggregate } from '../collector';
+import {
+  createTrafficCollector,
+  instrumentTrafficFetch,
+  trafficMiddleware,
+  trafficType,
+  type TrafficAggregate,
+} from '../collector';
 
 describe('ecosystem activity collector', () => {
   it('reports all products independently of dashboard viewers and counts errors too', async () => {
     const batches: TrafficAggregate[][] = [];
-    const collector = createTrafficCollector(async events => { batches.push(events); });
+    const collector = createTrafficCollector(async (events) => {
+      batches.push(events);
+    });
     for (const service of ['website', 'mention', 'mercaria', 'alia', 'kaana']) {
       const response = new EventEmitter();
-      trafficMiddleware(collector, service, 'us-west-2')({ path: '/api/files/private-id', headers: { 'cf-ray': 'example-NRT', authorization: 'secret' } }, response, () => {});
+      trafficMiddleware(collector, service, 'us-west-2')(
+        {
+          path: '/api/files/private-id',
+          headers: { 'cf-ray': 'example-NRT', authorization: 'secret' },
+        },
+        response,
+        () => {},
+      );
       response.emit('finish');
       response.emit('close');
     }
     await collector.flush();
     expect(batches[0]).toHaveLength(10);
-    expect(batches[0].filter(event => event.direction === 'inbound')).toHaveLength(5);
-    expect(batches[0].every(event => event.activityType === 'media')).toBe(true);
+    expect(batches[0].filter((event) => event.direction === 'inbound')).toHaveLength(5);
+    expect(batches[0].every((event) => event.activityType === 'media')).toBe(true);
     expect(JSON.stringify(batches)).not.toMatch(/private-id|secret|authorization/);
   });
 
   it('keeps scope, direction and category independent for co-located internal services', async () => {
     const batches: TrafficAggregate[][] = [];
-    const collector = createTrafficCollector(async events => { batches.push(events); });
+    const collector = createTrafficCollector(async (events) => {
+      batches.push(events);
+    });
     const response = new EventEmitter();
-    const request = { path: '/v1/chat/completions', headers: { 'x-oxy-source-region': 'us-west-2' }, serviceApp: undefined as undefined | { appName: string } };
-    trafficMiddleware(collector, 'kaana', 'us-west-2')(request, response, () => { request.serviceApp = { appName: 'oxy-api' }; });
+    const request = {
+      path: '/v1/chat/completions',
+      headers: { 'x-oxy-source-region': 'us-west-2' },
+      serviceApp: undefined as undefined | { appName: string },
+    };
+    trafficMiddleware(collector, 'kaana', 'us-west-2')(request, response, () => {
+      request.serviceApp = { appName: 'oxy-api' };
+    });
     response.emit('finish');
     await collector.flush();
     expect(batches[0]).toEqual([
-      expect.objectContaining({ sourceRegion: 'us-west-2', targetRegion: 'us-west-2', sourceService: 'oxy-api', targetService: 'kaana', direction: 'inbound', scope: 'internal', activityType: 'ai' }),
-      expect.objectContaining({ sourceService: 'kaana', targetService: 'oxy-api', direction: 'outbound', scope: 'internal', activityType: 'ai' }),
+      expect.objectContaining({
+        sourceRegion: 'us-west-2',
+        targetRegion: 'us-west-2',
+        sourceService: 'oxy-api',
+        targetService: 'kaana',
+        direction: 'inbound',
+        scope: 'internal',
+        activityType: 'ai',
+      }),
+      expect.objectContaining({
+        sourceService: 'kaana',
+        targetService: 'oxy-api',
+        direction: 'outbound',
+        scope: 'internal',
+        activityType: 'ai',
+      }),
     ]);
   });
 
   it('does not fabricate a response on abort and excludes telemetry control traffic', async () => {
     const batches: TrafficAggregate[][] = [];
-    const collector = createTrafficCollector(async events => { batches.push(events); });
+    const collector = createTrafficCollector(async (events) => {
+      batches.push(events);
+    });
     for (const path of ['/health', '/api/ready', '/platform-stats/stream', '/internal/activity']) {
       const response = new EventEmitter();
-      trafficMiddleware(collector, 'website', 'us-west-2')({ path, headers: {} }, response, () => {});
+      trafficMiddleware(collector, 'website', 'us-west-2')(
+        { path, headers: {} },
+        response,
+        () => {},
+      );
       response.emit('finish');
     }
     const aborted = new EventEmitter();
-    trafficMiddleware(collector, 'mention', 'us-west-2')({ path: '/messages', headers: {} }, aborted, () => {});
+    trafficMiddleware(collector, 'mention', 'us-west-2')(
+      { path: '/messages', headers: {} },
+      aborted,
+      () => {},
+    );
     aborted.emit('close');
     await collector.flush();
     expect(batches[0]).toHaveLength(1);
@@ -51,41 +98,99 @@ describe('ecosystem activity collector', () => {
 
   it('tracks real outgoing calls and only reports the response when one arrived', async () => {
     const batches: TrafficAggregate[][] = [];
-    const collector = createTrafficCollector(async events => { batches.push(events); });
-    const fetcher = instrumentTrafficFetch(jest.fn(async () => new Response('ok', { headers: { 'X-Oxy-Region': 'eu-central-1' } })) as unknown as typeof fetch, collector, 'alia', 'us-west-2', url => url.hostname === 'api.oxy.so' ? { service: 'oxy-api', region: 'us-west-2' } : undefined);
+    const collector = createTrafficCollector(async (events) => {
+      batches.push(events);
+    });
+    const fetcher = instrumentTrafficFetch(
+      jest.fn(
+        async () => new Response('ok', { headers: { 'X-Oxy-Region': 'eu-central-1' } }),
+      ) as unknown as typeof fetch,
+      collector,
+      'alia',
+      'us-west-2',
+      (url) =>
+        url.hostname === 'api.oxy.so' ? { service: 'oxy-api', region: 'us-west-2' } : undefined,
+    );
     await fetcher('https://api.oxy.so/v1/chat/completions');
     await collector.flush();
-    expect(batches[0].map(event => event.direction)).toEqual(['outbound', 'inbound']);
-    expect(batches[0].every(event => event.scope === 'internal')).toBe(true);
+    expect(batches[0].map((event) => event.direction)).toEqual(['outbound', 'inbound']);
+    expect(batches[0].every((event) => event.scope === 'internal')).toBe(true);
     expect(batches[0][0].targetRegion).toBe('eu-central-1');
     expect(batches[0][1].sourceRegion).toBe('eu-central-1');
-    const failed = instrumentTrafficFetch(jest.fn(async () => { throw new Error('offline'); }) as unknown as typeof fetch, collector, 'alia', 'us-west-2', () => undefined);
+    const failed = instrumentTrafficFetch(
+      jest.fn(async () => {
+        throw new Error('offline');
+      }) as unknown as typeof fetch,
+      collector,
+      'alia',
+      'us-west-2',
+      () => undefined,
+    );
     await expect(failed('https://example.com/files')).rejects.toThrow('offline');
     await collector.flush();
     expect(batches[1]).toHaveLength(1);
-    expect(batches[1][0]).toMatchObject({ scope: 'external', direction: 'outbound', activityType: 'media' });
+    expect(batches[1][0]).toMatchObject({
+      scope: 'external',
+      direction: 'outbound',
+      activityType: 'media',
+    });
   });
 
   it('chunks a busy fleet into ingestible batches and preserves fetch extensions', async () => {
     const batches: TrafficAggregate[][] = [];
-    const collector = createTrafficCollector(async events => { batches.push(events); });
-    for (let index = 0; index < 300; index++) collector.record({ region: 'us-west-2', service: `service-${index}`, scope: 'internal', direction: 'inbound', activityType: 'platform' });
+    const collector = createTrafficCollector(async (events) => {
+      batches.push(events);
+    });
+    for (let index = 0; index < 300; index++)
+      collector.record({
+        region: 'us-west-2',
+        service: `service-${index}`,
+        scope: 'internal',
+        direction: 'inbound',
+        activityType: 'platform',
+      });
     await collector.flush();
-    expect(batches.map(batch => batch.length)).toEqual([256, 44]);
+    expect(batches.map((batch) => batch.length)).toEqual([256, 44]);
     const preconnect = jest.fn();
-    const baseFetch = Object.assign(jest.fn(async () => new Response()), { preconnect }) as unknown as typeof fetch;
-    const wrapped = instrumentTrafficFetch(baseFetch, collector, 'website', 'us-west-2', () => undefined);
+    const baseFetch = Object.assign(
+      jest.fn(async () => new Response()),
+      { preconnect },
+    ) as unknown as typeof fetch;
+    const wrapped = instrumentTrafficFetch(
+      baseFetch,
+      collector,
+      'website',
+      'us-west-2',
+      () => undefined,
+    );
     expect((wrapped as typeof baseFetch & { preconnect: unknown }).preconnect).toBe(preconnect);
   });
 
   it('keeps verified internal attribution when a request aborts', async () => {
     const batches: TrafficAggregate[][] = [];
-    const collector = createTrafficCollector(async events => { batches.push(events); });
+    const collector = createTrafficCollector(async (events) => {
+      batches.push(events);
+    });
     const response = new EventEmitter();
-    trafficMiddleware(collector, 'oxy-api', 'us-west-2')({ path: '/messages', headers: { 'x-oxy-source-region': 'eu-west-1' }, serviceApp: { appName: 'mention' } }, response, () => {});
+    trafficMiddleware(collector, 'oxy-api', 'us-west-2')(
+      {
+        path: '/messages',
+        headers: { 'x-oxy-source-region': 'eu-west-1' },
+        serviceApp: { appName: 'mention' },
+      },
+      response,
+      () => {},
+    );
     response.emit('close');
     await collector.flush();
-    expect(batches[0]).toEqual([expect.objectContaining({ scope: 'internal', direction: 'inbound', sourceRegion: 'eu-west-1', sourceService: 'mention' })]);
+    expect(batches[0]).toEqual([
+      expect.objectContaining({
+        scope: 'internal',
+        direction: 'inbound',
+        sourceRegion: 'eu-west-1',
+        sourceService: 'mention',
+      }),
+    ]);
   });
 
   it('classifies versioned media and inference endpoints without retaining the path', () => {

package/src/__tests__/server.test.ts

@@ -10,11 +10,13 @@ import {
 
 describe('server telemetry primitives', () => {
   it('prefers a validated forwarded PoP and accepts Cloudflare ray fallback', () => {
-    expect(metadataFromHeaders({
-      'x-oxy-edge-region': 'MAD',
-      'cf-ray': 'deadbeef-CDG',
-      'x-oxy-activity-id': 'anonymous-runtime-a1',
-    })).toEqual({ edgePop: 'mad', activityId: 'anonymous-runtime-a1' });
+    expect(
+      metadataFromHeaders({
+        'x-oxy-edge-region': 'MAD',
+        'cf-ray': 'deadbeef-CDG',
+        'x-oxy-activity-id': 'anonymous-runtime-a1',
+      }),
+    ).toEqual({ edgePop: 'mad', activityId: 'anonymous-runtime-a1' });
     expect(metadataFromHeaders({ 'cf-ray': 'deadbeef-CDG' })).toEqual({ edgePop: 'cdg' });
   });
 

package/src/__tests__/socket.test.ts

@@ -8,22 +8,42 @@ class TestSocket extends EventEmitter {
   nsp = { name: '/messages' };
   incoming = new Set<(event: string) => void>();
   outgoing = new Set<(event: string) => void>();
-  onAny(listener: (event: string) => void) { this.incoming.add(listener); }
-  onAnyOutgoing(listener: (event: string) => void) { this.outgoing.add(listener); }
-  offAny(listener: (event: string) => void) { this.incoming.delete(listener); }
-  offAnyOutgoing(listener: (event: string) => void) { this.outgoing.delete(listener); }
+  onAny(listener: (event: string) => void) {
+    this.incoming.add(listener);
+  }
+  onAnyOutgoing(listener: (event: string) => void) {
+    this.outgoing.add(listener);
+  }
+  offAny(listener: (event: string) => void) {
+    this.incoming.delete(listener);
+  }
+  offAnyOutgoing(listener: (event: string) => void) {
+    this.outgoing.delete(listener);
+  }
 }
 
 describe('socket traffic', () => {
   it('records real application directions and strips event identifiers and payloads', () => {
     const socket = new TestSocket();
     const events: TrafficFlow[] = [];
-    observeTrafficSocket(socket, { record: event => events.push(event) }, 'syra', 'us-west-2');
-    socket.incoming.forEach(listener => listener('player:private-track-id'));
-    socket.outgoing.forEach(listener => listener('message:private-user-id'));
+    observeTrafficSocket(socket, { record: (event) => events.push(event) }, 'syra', 'us-west-2');
+    socket.incoming.forEach((listener) => listener('player:private-track-id'));
+    socket.outgoing.forEach((listener) => listener('message:private-user-id'));
     expect(events).toEqual([
-      expect.objectContaining({ scope: 'external', direction: 'inbound', sourceRegion: 'edge-mad', targetRegion: 'us-west-2', activityType: 'media' }),
-      expect.objectContaining({ scope: 'external', direction: 'outbound', sourceRegion: 'us-west-2', targetRegion: 'edge-mad', activityType: 'communication' }),
+      expect.objectContaining({
+        scope: 'external',
+        direction: 'inbound',
+        sourceRegion: 'edge-mad',
+        targetRegion: 'us-west-2',
+        activityType: 'media',
+      }),
+      expect.objectContaining({
+        scope: 'external',
+        direction: 'outbound',
+        sourceRegion: 'us-west-2',
+        targetRegion: 'edge-mad',
+        activityType: 'communication',
+      }),
     ]);
     expect(JSON.stringify(events)).not.toMatch(/private|authorization|track-id|user-id/);
     socket.emit('disconnect');
@@ -34,11 +54,23 @@ describe('socket traffic', () => {
     const socket = new TestSocket();
     const events: TrafficFlow[] = [];
     let peer: { service: string; region: string } | undefined;
-    const stop = observeTrafficSocket(socket, { record: event => events.push(event) }, 'alia', 'us-west-2', { getPeer: () => peer });
+    const stop = observeTrafficSocket(
+      socket,
+      { record: (event) => events.push(event) },
+      'alia',
+      'us-west-2',
+      { getPeer: () => peer },
+    );
     peer = { service: 'mention', region: 'eu-west-1' };
-    socket.incoming.forEach(listener => listener('agent:update'));
-    expect(events[0]).toMatchObject({ scope: 'internal', sourceService: 'mention', sourceRegion: 'eu-west-1', activityType: 'ai' });
-    stop(); stop();
+    socket.incoming.forEach((listener) => listener('agent:update'));
+    expect(events[0]).toMatchObject({
+      scope: 'internal',
+      sourceService: 'mention',
+      sourceRegion: 'eu-west-1',
+      activityType: 'ai',
+    });
+    stop();
+    stop();
     expect(socket.listenerCount('disconnect')).toBe(0);
   });
 
@@ -61,32 +93,39 @@ describe('real Socket.IO transport', () => {
     const server = createServer();
     const sockets = new Server(server);
     const events: TrafficFlow[] = [];
-    sockets.on('connection', socket => {
-      observeTrafficSocket(socket, { record: flow => events.push(flow) }, 'syra', 'us-west-2');
+    sockets.on('connection', (socket) => {
+      observeTrafficSocket(socket, { record: (flow) => events.push(flow) }, 'syra', 'us-west-2');
       socket.on('player:seek', (_position, acknowledge) => {
         acknowledge('ok');
         sockets.emit('player:state', { privateTrackId: 'never-published' });
       });
     });
-    await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
     const address = server.address();
     if (!address || typeof address === 'string') throw new Error('Missing listener');
-    const client = io(`http://127.0.0.1:${address.port}`, { transports: ['websocket'], extraHeaders: { 'X-Oxy-Edge-Region': 'NRT' } });
+    const client = io(`http://127.0.0.1:${address.port}`, {
+      transports: ['websocket'],
+      extraHeaders: { 'X-Oxy-Edge-Region': 'NRT' },
+    });
     try {
-      await new Promise<void>((resolve, reject) => { client.once('connect', resolve); client.once('connect_error', reject); });
-      const received = new Promise<void>(resolve => client.once('player:state', () => resolve()));
+      await new Promise<void>((resolve, reject) => {
+        client.once('connect', resolve);
+        client.once('connect_error', reject);
+      });
+      const received = new Promise<void>((resolve) => client.once('player:state', () => resolve()));
       await client.emitWithAck('player:seek', 42);
       await received;
       expect(events).toHaveLength(2);
-      expect(events.map(flow => [flow.direction, flow.scope, flow.activityType])).toEqual([
-        ['inbound', 'external', 'media'], ['outbound', 'external', 'media'],
+      expect(events.map((flow) => [flow.direction, flow.scope, flow.activityType])).toEqual([
+        ['inbound', 'external', 'media'],
+        ['outbound', 'external', 'media'],
       ]);
       expect(events[0].sourceRegion).toBe('edge-nrt');
       expect(events[1].targetRegion).toBe('edge-nrt');
       expect(JSON.stringify(events)).not.toContain('never-published');
     } finally {
       client.disconnect();
-      await new Promise<void>(resolve => sockets.close(() => resolve()));
+      await new Promise<void>((resolve) => sockets.close(() => resolve()));
     }
   });
 });
@@ -97,21 +136,33 @@ describe('raw WebSocket transport', () => {
     const events: TrafficFlow[] = [];
     const original = jest.fn((_data: unknown, callback: (error?: Error) => void) => callback());
     const socket = Object.assign(new EventEmitter(), { readyState: 1, send: original });
-    const stop = observeTrafficWebSocket(socket, { record: flow => events.push(flow) }, 'alia', 'us-west-2', {
-      activityType: 'ai', getPeer: () => ({ service: 'alia-integrations', region: 'eu-west-1' }),
-    });
+    const stop = observeTrafficWebSocket(
+      socket,
+      { record: (flow) => events.push(flow) },
+      'alia',
+      'us-west-2',
+      {
+        activityType: 'ai',
+        getPeer: () => ({ service: 'alia-integrations', region: 'eu-west-1' }),
+      },
+    );
     const callback = jest.fn();
     socket.send({ privateBody: 'not-recorded' }, callback);
     socket.emit('message', Buffer.from('private-message'));
     expect(original).toHaveBeenCalledWith({ privateBody: 'not-recorded' }, callback);
     expect(callback).toHaveBeenCalledTimes(1);
-    expect(events.map(flow => flow.direction)).toEqual(['outbound', 'inbound']);
-    expect(events.every(flow => flow.scope === 'internal' && flow.activityType === 'ai')).toBe(true);
+    expect(events.map((flow) => flow.direction)).toEqual(['outbound', 'inbound']);
+    expect(events.every((flow) => flow.scope === 'internal' && flow.activityType === 'ai')).toBe(
+      true,
+    );
     expect(JSON.stringify(events)).not.toMatch(/private|not-recorded/);
-    original.mockImplementationOnce(() => { throw new Error('send failed'); });
+    original.mockImplementationOnce(() => {
+      throw new Error('send failed');
+    });
     expect(() => socket.send('', callback)).toThrow('send failed');
     expect(events).toHaveLength(2);
-    stop(); stop();
+    stop();
+    stop();
     expect(socket.send).toBe(original);
     expect(socket.listenerCount('message')).toBe(0);
   });