@sogni-ai/expo-client 1.0.0-alpha.2

package/dist/esm/lib/getUUID.js

@@ -0,0 +1,26 @@
+/**
+ * Generate a v4 UUID using crypto.getRandomValues, returned in uppercase form.
+ *
+ * Mac workers in the Sogni Supernet use uppercase UUIDs; the SDK keeps that
+ * convention end-to-end so wire-level comparisons stay simple.
+ *
+ * Requires `crypto.getRandomValues` (polyfilled in Expo via
+ * `expo-standard-web-crypto/polyfill`). SogniClient.create() verifies the
+ * polyfill is present and throws a clear error otherwise.
+ */
+export default function getUUID() {
+    const bytes = crypto.getRandomValues(new Uint8Array(16));
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+    return (hex.slice(0, 8) +
+        '-' +
+        hex.slice(8, 12) +
+        '-' +
+        hex.slice(12, 16) +
+        '-' +
+        hex.slice(16, 20) +
+        '-' +
+        hex.slice(20)).toUpperCase();
+}
+//# sourceMappingURL=getUUID.js.map

package/dist/esm/lib/getUUID.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getUUID.js","sourceRoot":"","sources":["../../../src/lib/getUUID.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,UAAU,OAAO;IAC7B,MAAM,KAAK,GAAG,MAAM,CAAC,eAAe,CAAC,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC;IACzD,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAE,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;IACrC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAE,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;IACrC,MAAM,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC/E,OAAO,CACL,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;QACf,GAAG;QACH,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC;QAChB,GAAG;QACH,GAAG,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC;QACjB,GAAG;QACH,GAAG,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC;QACjB,GAAG;QACH,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CACd,CAAC,WAAW,EAAE,CAAC;AAClB,CAAC"}

package/dist/esm/lib/utils.js

@@ -0,0 +1,19 @@
+import { jwtDecode } from 'jwt-decode';
+export function decodeToken(token) {
+    const data = jwtDecode(token);
+    return {
+        walletAddress: data.addr,
+        expiresAt: new Date(data.exp * 1000)
+    };
+}
+export function decodeRefreshToken(token) {
+    const data = jwtDecode(token);
+    return {
+        env: data.env,
+        expiresAt: new Date(data.exp * 1000)
+    };
+}
+export async function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=utils.js.map

package/dist/esm/lib/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,MAAM,UAAU,WAAW,CAAC,KAAa;IACvC,MAAM,IAAI,GAAG,SAAS,CAA0D,KAAK,CAAC,CAAC;IACvF,OAAO;QACL,aAAa,EAAE,IAAI,CAAC,IAAI;QACxB,SAAS,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC;KACrC,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,KAAa;IAC9C,MAAM,IAAI,GAAG,SAAS,CAA0D,KAAK,CAAC,CAAC;IACvF,OAAO;QACL,GAAG,EAAE,IAAI,CAAC,GAAG;QACb,SAAS,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC;KACrC,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,KAAK,CAAC,EAAU;IACpC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;AAC3D,CAAC"}

package/dist/esm/types/ErrorData.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ErrorData.js.map

package/dist/esm/types/ErrorData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorData.js","sourceRoot":"","sources":["../../../src/types/ErrorData.ts"],"names":[],"mappings":""}

package/dist/esm/types/json.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=json.js.map

package/dist/esm/types/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../../../src/types/json.ts"],"names":[],"mappings":""}

package/dist/esm/types/token.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=token.js.map

package/dist/esm/types/token.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.js","sourceRoot":"","sources":["../../../src/types/token.ts"],"names":[],"mappings":""}

package/dist/esm/version.js

@@ -0,0 +1,2 @@
+export const LIB_VERSION = '0.1.0';
+//# sourceMappingURL=version.js.map

package/dist/esm/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,WAAW,GAAG,OAAO,CAAC"}

package/dist/esm/wallet.js

@@ -0,0 +1,2 @@
+export { LIB_VERSION } from './version';
+//# sourceMappingURL=wallet.js.map

package/dist/esm/wallet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.js","sourceRoot":"","sources":["../../src/wallet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC"}

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@sogni-ai/expo-client",
+  "version": "1.0.0-alpha.2",
+  "description": "Sogni SDK for Expo/React Native - AI image, video & audio generation plus LLM chat via the Sogni Supernet",
+  "keywords": [
+    "sogni",
+    "expo",
+    "react-native",
+    "ai",
+    "image-generation",
+    "video-generation",
+    "stable-diffusion",
+    "flux",
+    "wan",
+    "ltx",
+    "text-to-image",
+    "text-to-video",
+    "generative-ai",
+    "llm",
+    "supernet"
+  ],
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/cjs/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/cjs/index.d.ts"
+    },
+    "./wallet": {
+      "import": "./dist/esm/wallet.js",
+      "require": "./dist/cjs/wallet.js",
+      "types": "./dist/cjs/wallet.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/",
+    "src/",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "clean": "rimraf ./dist",
+    "build": "npm run clean && npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc --project tsconfig.json",
+    "build:esm": "tsc --project tsconfig.esm.json",
+    "watch": "tsc --watch --project tsconfig.json",
+    "prepublishOnly": "npm run build",
+    "prettier": "prettier --check ./src",
+    "prettier:fix": "prettier --write ./src",
+    "release": "semantic-release",
+    "prepare": "husky"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Sogni-AI/expo-client.git"
+  },
+  "homepage": "https://github.com/Sogni-AI/expo-client#readme",
+  "bugs": {
+    "url": "https://github.com/Sogni-AI/expo-client/issues"
+  },
+  "author": "Sogni AI",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "jwt-decode": "^4.0.0",
+    "viem": "^2.21.0"
+  },
+  "peerDependencies": {
+    "expo": ">=50.0.0",
+    "expo-secure-store": ">=12.0.0",
+    "expo-standard-web-crypto": ">=2.0.0",
+    "react-native": ">=0.73.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.0.0",
+    "@commitlint/config-conventional": "^19.0.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "expo-secure-store": "^55.0.13",
+    "husky": "^9.1.7",
+    "prettier": "^3.3.3",
+    "rimraf": "^6.0.1",
+    "semantic-release": "^24.2.1",
+    "typescript": "^5.5.3"
+  }
+}

package/src/Account/index.ts

@@ -0,0 +1,118 @@
+import ApiClient, { ApiError, ApiResponse } from '../ApiClient';
+import TypedEventEmitter from '../lib/TypedEventEmitter';
+import { AccountSnapshot, Balances, MeData, emptyAccountSnapshot } from './types';
+
+interface AccountEvents {
+  change: AccountSnapshot;
+}
+
+/**
+ * Account API: current-user info, balance, logout.
+ *
+ * Phase 2 surface — `login()` and `signup()` are deferred to Phase 4
+ * because they require deterministic wallet derivation (Phase 4 wallet
+ * helper). For Phase 2, authenticate via API key in `SogniClient.create()`
+ * or pre-obtained tokens via `sogni.setTokens(...)`.
+ */
+class AccountApi extends TypedEventEmitter<AccountEvents> {
+  private _client: ApiClient;
+  private _snapshot: AccountSnapshot;
+
+  constructor(client: ApiClient) {
+    super();
+    this._client = client;
+    this._snapshot = emptyAccountSnapshot();
+
+    client.socket.on('connected', ({ network }) => {
+      this._update({ networkStatus: 'connected', network });
+    });
+    client.socket.on('disconnected', () => {
+      this._update({ networkStatus: 'disconnected', network: null });
+    });
+    client.socket.on('authenticated', (e) => {
+      this._update({
+        authenticated: true,
+        username: e.username,
+        walletAddress: e.walletAddress,
+        balance: e.balance
+      });
+    });
+    client.socket.on('balanceUpdate', (e) => {
+      this._update({ balance: e.balance });
+    });
+    client.socket.on('changeNetwork', (e) => {
+      this._update({ network: e.network });
+    });
+    client.on('authUpdated', (authenticated) => {
+      if (!authenticated) {
+        this._update(emptyAccountSnapshot());
+      }
+    });
+  }
+
+  /** Read-only snapshot of the current account state. */
+  get current(): Readonly<AccountSnapshot> {
+    return this._snapshot;
+  }
+
+  /** Subscribe to account state changes. Returns an unsubscribe function. */
+  onChange(listener: (snapshot: AccountSnapshot) => void): () => void {
+    return this.on('change', listener);
+  }
+
+  /** Fetch the current user's profile data from REST. Updates the snapshot. */
+  async me(): Promise<MeData> {
+    const res = await this._client.rest.get<ApiResponse<MeData>>('/v1/account/me');
+    this._update({
+      username: res.data.username,
+      email: res.data.currentEmail,
+      walletAddress: res.data.walletAddress
+    });
+    return res.data;
+  }
+
+  /**
+   * Force-refresh the current user's balance from REST. Balance also updates
+   * automatically via socket events — call this only when you need a synchronous
+   * fetch (e.g., on screen mount before the socket has reconnected).
+   */
+  async refreshBalance(): Promise<Balances> {
+    const res = await this._client.rest.get<ApiResponse<Balances>>('/v4/account/balance');
+    this._update({ balance: res.data });
+    return res.data;
+  }
+
+  /**
+   * Log out and clear all auth state. Closes the WebSocket and removes any
+   * persisted tokens. Safe to call even if not authenticated.
+   */
+  async logout(): Promise<void> {
+    try {
+      await this._client.rest.post('/v1/account/logout');
+    } catch (e) {
+      if (e instanceof ApiError && e.status === 401) {
+        this._client.logger.warn('Logout call rejected — probably already logged out');
+      } else {
+        throw e;
+      }
+    }
+    this._client.auth.clear();
+  }
+
+  private _update(partial: Partial<AccountSnapshot>) {
+    const next: AccountSnapshot = { ...this._snapshot, ...partial };
+    if (shallowEqual(next, this._snapshot)) return;
+    this._snapshot = next;
+    this.emit('change', this._snapshot);
+  }
+}
+
+function shallowEqual<T extends object>(a: T, b: T): boolean {
+  const keys = Object.keys(a) as (keyof T)[];
+  for (const k of keys) {
+    if (a[k] !== b[k]) return false;
+  }
+  return true;
+}
+
+export default AccountApi;

package/src/Account/types.ts

@@ -0,0 +1,41 @@
+import { Balances } from '../ApiClient/WebSocketClient/events';
+import { SupernetType } from '../ApiClient/WebSocketClient/types';
+
+export type { Balances };
+
+export interface MeData {
+  currentEmail: string;
+  username: string;
+  walletAddress: string;
+  emailVerified?: boolean;
+  discord2FA?: boolean;
+  discordLinked?: boolean;
+  discordServerMember?: boolean;
+  discordUsername?: string;
+  requestedUpdatedEmail?: string;
+}
+
+export interface AccountSnapshot {
+  authenticated: boolean;
+  networkStatus: 'connected' | 'disconnected' | 'connecting';
+  network: SupernetType | null;
+  balance: Balances;
+  walletAddress: string | null;
+  username: string | null;
+  email: string | null;
+}
+
+export function emptyAccountSnapshot(): AccountSnapshot {
+  return {
+    authenticated: false,
+    networkStatus: 'disconnected',
+    network: null,
+    balance: {
+      sogni: { settled: '0', credit: '0', debit: '0', net: '0' },
+      spark: { settled: '0', credit: '0', debit: '0', net: '0', premiumCredit: '0' }
+    },
+    walletAddress: null,
+    username: null,
+    email: null
+  };
+}

package/src/ApiClient/WebSocketClient/events.ts

@@ -0,0 +1,60 @@
+import { SupernetType } from './types';
+
+export interface BalanceData {
+  settled: string;
+  credit: string;
+  debit: string;
+  net: string;
+}
+
+export interface SparkBalanceData extends BalanceData {
+  premiumCredit: string;
+}
+
+export interface Balances {
+  sogni: BalanceData;
+  spark: SparkBalanceData;
+}
+
+export interface AuthenticatedEvent {
+  username: string;
+  walletAddress: string;
+  balance: Balances;
+  isMainnet: boolean;
+  accountWasMigrated: boolean;
+  hasUnclaimedAirdrop: boolean;
+  firstLoginAfterMigration: boolean;
+}
+
+export interface BalanceUpdateEvent {
+  balance: Balances;
+}
+
+export interface ChangeNetworkEvent {
+  network: SupernetType;
+}
+
+export interface ConnectedEvent {
+  network: SupernetType;
+}
+
+export interface DisconnectedEvent {
+  code?: number;
+  reason?: string;
+}
+
+export interface ToastMessageEvent {
+  level: 'info' | 'success' | 'warning' | 'error';
+  message: string;
+  stickyID?: string;
+}
+
+/** Public event map for WebSocketClient. */
+export interface SocketEventMap {
+  connected: ConnectedEvent;
+  disconnected: DisconnectedEvent;
+  authenticated: AuthenticatedEvent;
+  balanceUpdate: BalanceUpdateEvent;
+  changeNetwork: ChangeNetworkEvent;
+  toastMessage: ToastMessageEvent;
+}

package/src/ApiClient/WebSocketClient/index.ts

@@ -0,0 +1,224 @@
+import TypedEventEmitter from '../../lib/TypedEventEmitter';
+import { base64Decode, base64Encode } from '../../lib/base64';
+import { Logger } from '../../lib/DefaultLogger';
+import { AuthManager } from '../../lib/AuthManager';
+import { LIB_VERSION } from '../../version';
+import { ConnectionStatus, SupernetType } from './types';
+import { SocketEventMap } from './events';
+import {
+  normalizeAuthenticated,
+  normalizeBalanceUpdate,
+  normalizeChangeNetwork,
+  normalizeToastMessage
+} from './normalize';
+import { RawAuthenticated, RawBalanceUpdate, RawChangeNetwork, RawToastMessage } from './wireTypes';
+
+const PROTOCOL_VERSION = '3.0.0';
+const RECONNECT_DELAY_MS = 1000;
+const MAX_RECONNECT_ATTEMPTS = 5;
+
+/** RN WebSocket constructor accepts a third options argument with `headers`. */
+type WebSocketCtorOptions = { headers?: Record<string, string> } | undefined;
+type WebSocketCtor = new (
+  url: string,
+  protocols?: string | string[] | null,
+  options?: WebSocketCtorOptions
+) => WebSocket;
+
+class WebSocketClient extends TypedEventEmitter<SocketEventMap> {
+  readonly appId: string;
+  readonly appSource?: string;
+  readonly baseUrl: string;
+  protected _logger: Logger;
+  private _auth: AuthManager;
+  private _supernetType: SupernetType;
+  private socket: WebSocket | null = null;
+  private _status: ConnectionStatus = 'disconnected';
+  private _reconnectAttempts = 0;
+  private _wantConnected = false;
+
+  constructor(
+    baseUrl: string,
+    auth: AuthManager,
+    appId: string,
+    supernetType: SupernetType,
+    logger: Logger,
+    appSource?: string
+  ) {
+    super();
+    this.baseUrl = normalizeBaseUrl(baseUrl);
+    this._auth = auth;
+    this.appId = appId;
+    this.appSource = appSource?.trim() || undefined;
+    this._supernetType = supernetType;
+    this._logger = logger;
+  }
+
+  get supernetType(): SupernetType {
+    return this._supernetType;
+  }
+
+  get isConnected(): boolean {
+    return this._status === 'connected';
+  }
+
+  get status(): ConnectionStatus {
+    return this._status;
+  }
+
+  async connect(): Promise<void> {
+    this._wantConnected = true;
+    if (this.socket) {
+      this._cleanupSocket();
+    }
+    this._status = 'connecting';
+
+    const userAgent = `Sogni/${PROTOCOL_VERSION} (sogni-expo-client) ${LIB_VERSION}`;
+    const url = new URL(this.baseUrl);
+    url.protocol = url.protocol === 'https:' || url.protocol === 'wss:' ? 'wss:' : 'ws:';
+    url.searchParams.set('appId', this.appId);
+    if (this.appSource) url.searchParams.set('appSource', this.appSource);
+    url.searchParams.set('clientName', userAgent);
+    url.searchParams.set('clientType', 'artist');
+    url.searchParams.set('forceWorkerId', this._supernetType === 'fast' ? 'fast' : '');
+
+    const auth = await this._auth.socketAuth();
+    if (auth.queryParams) {
+      for (const [k, v] of Object.entries(auth.queryParams)) {
+        url.searchParams.set(k, v);
+      }
+    }
+
+    const options: WebSocketCtorOptions = auth.headers ? { headers: auth.headers } : undefined;
+    const Ctor = (globalThis as unknown as { WebSocket: WebSocketCtor }).WebSocket;
+    if (!Ctor) {
+      throw new Error('No global WebSocket available — are you running outside of React Native?');
+    }
+    const socket = new Ctor(url.toString(), undefined, options);
+    this.socket = socket;
+    socket.onopen = () => this._handleOpen();
+    socket.onmessage = (e) => this._handleMessage(e);
+    socket.onclose = (e) => this._handleClose(e);
+    socket.onerror = (e) => this._handleError(e);
+  }
+
+  disconnect(): void {
+    this._wantConnected = false;
+    if (!this.socket) return;
+    const socket = this.socket;
+    this._cleanupSocket();
+    try {
+      socket.close(1000, 'Client disconnected');
+    } catch (e) {
+      this._logger.warn('Error closing socket:', e);
+    }
+    this._status = 'disconnected';
+    this.emit('disconnected', { code: 1000, reason: 'Client disconnected' });
+  }
+
+  async switchNetwork(target: SupernetType): Promise<SupernetType> {
+    return new Promise<SupernetType>((resolve) => {
+      this.once('changeNetwork', ({ network }) => {
+        this._supernetType = network;
+        resolve(network);
+      });
+      void this.send('changeNetwork', target);
+    });
+  }
+
+  async send(messageType: string, data: unknown): Promise<void> {
+    if (!this.socket || this._status !== 'connected') {
+      throw new Error(`Cannot send ${messageType}: socket not connected`);
+    }
+    const envelope = JSON.stringify({
+      type: messageType,
+      data: base64Encode(JSON.stringify(data))
+    });
+    this._logger.debug('WebSocket send:', messageType, data);
+    this.socket.send(envelope);
+  }
+
+  private _handleOpen() {
+    this._status = 'connected';
+    this._reconnectAttempts = 0;
+    this.emit('connected', { network: this._supernetType });
+  }
+
+  private _handleClose(e: { code?: number; reason?: string }) {
+    const wasConnected = this._status === 'connected';
+    this._status = 'disconnected';
+    this._cleanupSocket();
+    this.emit('disconnected', { code: e.code, reason: e.reason });
+    if (this._wantConnected && wasConnected && e.code !== 1000) {
+      this._scheduleReconnect();
+    }
+  }
+
+  private _handleError(e: unknown) {
+    this._logger.error('WebSocket error:', e);
+  }
+
+  private _scheduleReconnect() {
+    if (this._reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+      this._logger.warn('WebSocket reconnect attempts exhausted');
+      return;
+    }
+    this._reconnectAttempts++;
+    setTimeout(() => {
+      if (this._wantConnected) {
+        void this.connect();
+      }
+    }, RECONNECT_DELAY_MS);
+  }
+
+  private _cleanupSocket() {
+    if (!this.socket) return;
+    const s = this.socket;
+    s.onopen = null;
+    s.onmessage = null;
+    s.onclose = null;
+    s.onerror = null;
+    this.socket = null;
+  }
+
+  private _handleMessage(e: MessageEvent) {
+    Promise.resolve(typeof e.data === 'string' ? e.data : (e.data as Blob).text())
+      .then((str: string) => {
+        const envelope = JSON.parse(str) as { type: string; data?: string };
+        const payload: any = envelope.data ? JSON.parse(base64Decode(envelope.data)) : null;
+        this._logger.debug('WebSocket recv:', envelope.type, payload);
+        this._dispatch(envelope.type, payload);
+      })
+      .catch((err) => this._logger.error('Failed to parse WebSocket message:', err));
+  }
+
+  private _dispatch(type: string, payload: any) {
+    switch (type) {
+      case 'authenticated':
+        this.emit('authenticated', normalizeAuthenticated(payload as RawAuthenticated));
+        break;
+      case 'balanceUpdate':
+        this.emit('balanceUpdate', normalizeBalanceUpdate(payload as RawBalanceUpdate));
+        break;
+      case 'changeNetwork':
+        this.emit('changeNetwork', normalizeChangeNetwork(payload as RawChangeNetwork));
+        break;
+      case 'toastMessage':
+        this.emit('toastMessage', normalizeToastMessage(payload as RawToastMessage));
+        break;
+      default:
+        // Phase 2 only handles a subset; later phases will add jobState, jobProgress, etc.
+        this._logger.debug('Unhandled WebSocket message type:', type);
+        break;
+    }
+  }
+}
+
+function normalizeBaseUrl(url: string): string {
+  const u = new URL(url);
+  if (u.protocol === 'http:' || u.protocol === 'ws:') u.protocol = 'http:';
+  else u.protocol = 'https:';
+  return u.toString();
+}
+
+export default WebSocketClient;