@reactor-team/js-sdk 2.6.0 → 2.7.0

package/dist/index.mjs

@@ -51,12 +51,6 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/types.ts
-function video(name, _options) {
-  return { name, kind: "video" };
-}
-function audio(name, _options) {
-  return { name, kind: "audio" };
-}
 var ConflictError = class extends Error {
   constructor(message) {
     super(message);
@@ -73,300 +67,175 @@ function isAbortError(error) {
 
 // src/core/types.ts
 import { z } from "zod";
-var SessionState = /* @__PURE__ */ ((SessionState2) => {
-  SessionState2[SessionState2["CREATED"] = 0] = "CREATED";
-  SessionState2[SessionState2["PENDING"] = 1] = "PENDING";
-  SessionState2[SessionState2["SUSPENDED"] = 2] = "SUSPENDED";
-  SessionState2[SessionState2["WAITING"] = 3] = "WAITING";
-  SessionState2[SessionState2["ACTIVE"] = 4] = "ACTIVE";
-  SessionState2[SessionState2["INACTIVE"] = 5] = "INACTIVE";
-  SessionState2[SessionState2["CLOSED"] = 6] = "CLOSED";
-  return SessionState2;
-})(SessionState || {});
-var ModelSchema = z.object({
-  name: z.string()
+
+// package.json
+var package_default = {
+  name: "@reactor-team/js-sdk",
+  version: "2.7.0",
+  description: "Reactor JavaScript frontend SDK",
+  main: "dist/index.js",
+  module: "dist/index.mjs",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.js"
+    }
+  },
+  files: [
+    "dist",
+    "README.md"
+  ],
+  scripts: {
+    build: "tsup",
+    dev: "tsup --watch",
+    test: "vitest run",
+    "test:watch": "vitest",
+    "test:unit": "vitest run __tests__/unit",
+    "test:integration": "vitest run __tests__/integration",
+    format: "prettier --write .",
+    "format:check": "prettier --check ."
+  },
+  keywords: [
+    "reactor",
+    "frontend",
+    "sdk"
+  ],
+  author: "Reactor Technologies, Inc.",
+  reactor: {
+    apiVersion: 1,
+    webrtcVersion: "1.0"
+  },
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/reactor-team/js-sdk"
+  },
+  packageManager: "pnpm@10.12.1",
+  devDependencies: {
+    "@roamhq/wrtc": "^0.8.0",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^20",
+    "@types/react": "^18.2.8",
+    "@types/ws": "^8.18.1",
+    prettier: "^3.6.2",
+    tsup: "^8.5.0",
+    typescript: "^5.8.3",
+    vitest: "^3.0.0"
+  },
+  dependencies: {
+    "@bufbuild/protobuf": "^2.0.0",
+    chalk: "^5.3.0",
+    inquirer: "^9.3.0",
+    "simple-git": "^3.24.0",
+    ws: "^8.18.3",
+    zod: "^4.0.5"
+  },
+  peerDependencies: {
+    react: "^17.0.0 || ^18.0.0 || ^19.0.0",
+    zustand: "^5.0.6"
+  }
+};
+
+// src/core/types.ts
+var REACTOR_SDK_VERSION = package_default.version;
+var REACTOR_API_VERSION = package_default.reactor.apiVersion;
+var REACTOR_WEBRTC_VERSION = package_default.reactor.webrtcVersion;
+var REACTOR_SDK_TYPE = "js";
+var API_VERSION_HEADER = "Reactor-API-Version";
+var API_ACCEPT_VERSION_HEADER = "Reactor-API-Accept-Version";
+var WEBRTC_VERSION_HEADER = "Reactor-WebRTC-Version";
+var VERSION_ERROR_CODES = {
+  426: "CLIENT_VERSION_TOO_OLD",
+  501: "SERVER_VERSION_TOO_OLD"
+};
+var ClientInfoSchema = z.object({
+  sdk_version: z.string(),
+  sdk_type: z.literal("js")
+});
+var TransportDeclarationSchema = z.object({
+  protocol: z.string(),
+  version: z.string()
+});
+var TrackCapabilitySchema = z.object({
+  name: z.string(),
+  kind: z.enum(["video", "audio"]),
+  direction: z.enum(["recvonly", "sendonly"])
+});
+var TrackMappingEntrySchema = TrackCapabilitySchema.extend({
+  mid: z.string()
 });
 var CreateSessionRequestSchema = z.object({
-  model: ModelSchema,
-  sdp_offer: z.string(),
-  extra_args: z.record(z.string(), z.any())
-  // Dictionary
+  model: z.object({ name: z.string() }),
+  client_info: ClientInfoSchema,
+  supported_transports: z.array(TransportDeclarationSchema),
+  extra_args: z.record(z.string(), z.any()).optional()
 });
-var CreateSessionResponseSchema = z.object({
-  session_id: z.uuidv4()
+var InitialSessionResponseSchema = z.object({
+  session_id: z.string(),
+  model: z.object({ name: z.string() }),
+  server_info: z.object({ server_version: z.string() }).optional(),
+  state: z.string(),
+  cluster: z.string().optional()
 });
-var SessionStatusResponseSchema = z.object({
-  session_id: z.uuidv4(),
-  state: SessionState
+var CommandCapabilitySchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  schema: z.record(z.string(), z.any()).optional()
 });
-var SessionInfoResponseSchema = SessionStatusResponseSchema.extend({
-  session_info: CreateSessionRequestSchema.extend({
-    session_id: z.uuidv4()
-  })
+var CapabilitiesSchema = z.object({
+  protocol_version: z.string(),
+  tracks: z.array(TrackCapabilitySchema),
+  commands: z.array(CommandCapabilitySchema).optional(),
+  emission_fps: z.number().nullable().optional()
 });
-var SDPParamsRequestSchema = z.object({
-  sdp_offer: z.string(),
-  extra_args: z.record(z.string(), z.any())
-  // Dictionary
+var SessionResponseSchema = z.object({
+  session_id: z.string(),
+  server_info: z.object({ server_version: z.string() }).optional(),
+  selected_transport: TransportDeclarationSchema.optional(),
+  model: z.object({ name: z.string(), version: z.string().optional() }),
+  capabilities: CapabilitiesSchema.optional(),
+  state: z.string(),
+  cluster: z.string().optional()
+});
+var CreateSessionResponseSchema = SessionResponseSchema.extend({
+  selected_transport: TransportDeclarationSchema,
+  capabilities: CapabilitiesSchema
+});
+var SessionInfoResponseSchema = z.object({
+  session_id: z.string(),
+  cluster: z.string().optional(),
+  state: z.string()
+});
+var TerminateSessionRequestSchema = z.object({
+  reason: z.string().optional()
+});
+var IceServerCredentialsSchema = z.object({
+  username: z.string(),
+  password: z.string()
 });
-var SDPParamsResponseSchema = z.object({
-  sdp_answer: z.string(),
-  extra_args: z.record(z.string(), z.any())
-  // Dictionary
+var IceServerSchema = z.object({
+  uris: z.array(z.string()),
+  credentials: IceServerCredentialsSchema.optional()
 });
 var IceServersResponseSchema = z.object({
-  ice_servers: z.array(
-    z.object({
-      uris: z.array(z.string()),
-      credentials: z.object({
-        username: z.string(),
-        password: z.string()
-      }).optional()
-    })
-  )
+  ice_servers: z.array(IceServerSchema)
+});
+var WebRTCSdpOfferRequestSchema = z.object({
+  sdp_offer: z.string(),
+  client_info: ClientInfoSchema.optional(),
+  track_mapping: z.array(TrackMappingEntrySchema)
+});
+var WebRTCSdpAnswerResponseSchema = z.object({
+  sdp_answer: z.string()
 });
-
-// src/utils/webrtc.ts
-var DEFAULT_DATA_CHANNEL_LABEL = "data";
-var FORCE_RELAY_MODE = false;
-var DEFAULT_MAX_MESSAGE_BYTES = 256 * 1024;
-function createPeerConnection(config) {
-  return new RTCPeerConnection({
-    iceServers: config.iceServers,
-    iceTransportPolicy: FORCE_RELAY_MODE ? "relay" : "all"
-  });
-}
-function createDataChannel(pc, label) {
-  return pc.createDataChannel(label != null ? label : DEFAULT_DATA_CHANNEL_LABEL);
-}
-function rewriteMids(sdp, trackNames) {
-  const lines = sdp.split("\r\n");
-  let mediaIdx = 0;
-  const replacements = /* @__PURE__ */ new Map();
-  let inApplication = false;
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].startsWith("m=")) {
-      inApplication = lines[i].startsWith("m=application");
-    }
-    if (!inApplication && lines[i].startsWith("a=mid:")) {
-      const oldMid = lines[i].substring("a=mid:".length);
-      if (mediaIdx < trackNames.length) {
-        const newMid = trackNames[mediaIdx];
-        replacements.set(oldMid, newMid);
-        lines[i] = `a=mid:${newMid}`;
-        mediaIdx++;
-      }
-    }
-  }
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].startsWith("a=group:BUNDLE ")) {
-      const parts = lines[i].split(" ");
-      for (let j = 1; j < parts.length; j++) {
-        const replacement = replacements.get(parts[j]);
-        if (replacement !== void 0) {
-          parts[j] = replacement;
-        }
-      }
-      lines[i] = parts.join(" ");
-      break;
-    }
-  }
-  return lines.join("\r\n");
-}
-function createOffer(pc, trackNames) {
-  return __async(this, null, function* () {
-    const offer = yield pc.createOffer();
-    let needsAnswerRestore = false;
-    if (trackNames && trackNames.length > 0 && offer.sdp) {
-      const munged = rewriteMids(offer.sdp, trackNames);
-      try {
-        yield pc.setLocalDescription(
-          new RTCSessionDescription({ type: "offer", sdp: munged })
-        );
-      } catch (e) {
-        yield pc.setLocalDescription(offer);
-        needsAnswerRestore = true;
-      }
-    } else {
-      yield pc.setLocalDescription(offer);
-    }
-    yield waitForIceGathering(pc);
-    const localDescription = pc.localDescription;
-    if (!localDescription) {
-      throw new Error("Failed to create local description");
-    }
-    let sdp = localDescription.sdp;
-    if (needsAnswerRestore && trackNames && trackNames.length > 0) {
-      sdp = rewriteMids(sdp, trackNames);
-    }
-    return { sdp, needsAnswerRestore };
-  });
-}
-function buildMidMapping(transceivers) {
-  var _a;
-  const localToRemote = /* @__PURE__ */ new Map();
-  const remoteToLocal = /* @__PURE__ */ new Map();
-  for (const entry of transceivers) {
-    const mid = (_a = entry.transceiver) == null ? void 0 : _a.mid;
-    if (mid) {
-      localToRemote.set(mid, entry.name);
-      remoteToLocal.set(entry.name, mid);
-    }
-  }
-  return { localToRemote, remoteToLocal };
-}
-function restoreAnswerMids(sdp, remoteToLocal) {
-  const lines = sdp.split("\r\n");
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].startsWith("a=mid:")) {
-      const remoteMid = lines[i].substring("a=mid:".length);
-      const localMid = remoteToLocal.get(remoteMid);
-      if (localMid !== void 0) {
-        lines[i] = `a=mid:${localMid}`;
-      }
-    }
-    if (lines[i].startsWith("a=group:BUNDLE ")) {
-      const parts = lines[i].split(" ");
-      for (let j = 1; j < parts.length; j++) {
-        const localMid = remoteToLocal.get(parts[j]);
-        if (localMid !== void 0) {
-          parts[j] = localMid;
-        }
-      }
-      lines[i] = parts.join(" ");
-    }
-  }
-  return lines.join("\r\n");
-}
-function setRemoteDescription(pc, sdp) {
-  return __async(this, null, function* () {
-    const sessionDescription = new RTCSessionDescription({
-      sdp,
-      type: "answer"
-    });
-    yield pc.setRemoteDescription(sessionDescription);
-  });
-}
-function getLocalDescription(pc) {
-  const desc = pc.localDescription;
-  if (!desc) return void 0;
-  return desc.sdp;
-}
-function transformIceServers(response) {
-  return response.ice_servers.map((server) => {
-    const rtcServer = {
-      urls: server.uris
-    };
-    if (server.credentials) {
-      rtcServer.username = server.credentials.username;
-      rtcServer.credential = server.credentials.password;
-    }
-    return rtcServer;
-  });
-}
-function waitForIceGathering(pc, timeoutMs = 5e3) {
-  return new Promise((resolve) => {
-    if (pc.iceGatheringState === "complete") {
-      resolve();
-      return;
-    }
-    const onGatheringStateChange = () => {
-      if (pc.iceGatheringState === "complete") {
-        pc.removeEventListener(
-          "icegatheringstatechange",
-          onGatheringStateChange
-        );
-        resolve();
-      }
-    };
-    pc.addEventListener("icegatheringstatechange", onGatheringStateChange);
-    setTimeout(() => {
-      pc.removeEventListener("icegatheringstatechange", onGatheringStateChange);
-      resolve();
-    }, timeoutMs);
-  });
-}
-function sendMessage(channel, command, data, scope = "application", maxBytes = DEFAULT_MAX_MESSAGE_BYTES) {
-  if (channel.readyState !== "open") {
-    throw new Error(`Data channel not open: ${channel.readyState}`);
-  }
-  const jsonData = typeof data === "string" ? JSON.parse(data) : data;
-  const inner = { type: command, data: jsonData };
-  const payload = { scope, data: inner };
-  const serialized = JSON.stringify(payload);
-  const byteLength = new TextEncoder().encode(serialized).byteLength;
-  if (byteLength > maxBytes) {
-    throw new Error(
-      `Data channel message too large: ${byteLength} bytes exceeds limit of ${maxBytes} bytes (command: "${command}")`
-    );
-  }
-  channel.send(serialized);
-}
-function parseMessage(data) {
-  if (typeof data === "string") {
-    try {
-      return JSON.parse(data);
-    } catch (e) {
-      return data;
-    }
-  }
-  return data;
-}
-function closePeerConnection(pc) {
-  pc.close();
-}
-function extractConnectionStats(report) {
-  let rtt;
-  let availableOutgoingBitrate;
-  let localCandidateId;
-  let framesPerSecond;
-  let jitter;
-  let packetLossRatio;
-  report.forEach((stat) => {
-    if (stat.type === "candidate-pair" && stat.state === "succeeded") {
-      if (stat.currentRoundTripTime !== void 0) {
-        rtt = stat.currentRoundTripTime * 1e3;
-      }
-      if (stat.availableOutgoingBitrate !== void 0) {
-        availableOutgoingBitrate = stat.availableOutgoingBitrate;
-      }
-      localCandidateId = stat.localCandidateId;
-    }
-    if (stat.type === "inbound-rtp" && stat.kind === "video") {
-      if (stat.framesPerSecond !== void 0) {
-        framesPerSecond = stat.framesPerSecond;
-      }
-      if (stat.jitter !== void 0) {
-        jitter = stat.jitter;
-      }
-      if (stat.packetsReceived !== void 0 && stat.packetsLost !== void 0 && stat.packetsReceived + stat.packetsLost > 0) {
-        packetLossRatio = stat.packetsLost / (stat.packetsReceived + stat.packetsLost);
-      }
-    }
-  });
-  let candidateType;
-  if (localCandidateId) {
-    const localCandidate = report.get(localCandidateId);
-    if (localCandidate == null ? void 0 : localCandidate.candidateType) {
-      candidateType = localCandidate.candidateType;
-    }
-  }
-  return {
-    rtt,
-    candidateType,
-    availableOutgoingBitrate,
-    framesPerSecond,
-    packetLossRatio,
-    jitter,
-    timestamp: Date.now()
-  };
-}
 
 // src/core/CoordinatorClient.ts
-var INITIAL_BACKOFF_MS = 500;
-var MAX_BACKOFF_MS = 15e3;
-var BACKOFF_MULTIPLIER = 2;
-var DEFAULT_MAX_ATTEMPTS = 6;
+var SESSION_POLL_INITIAL_BACKOFF_MS = 200;
+var SESSION_POLL_MAX_BACKOFF_MS = 1e4;
+var SESSION_POLL_BACKOFF_MULTIPLIER = 2;
+var SESSION_POLL_DEFAULT_MAX_ATTEMPTS = 20;
 var CoordinatorClient = class {
   constructor(options) {
     this.baseUrl = options.baseUrl;
@@ -375,7 +244,7 @@ var CoordinatorClient = class {
     this.abortController = new AbortController();
   }
   /**
-   * Aborts any in-flight HTTP requests and polling loops.
+   * Aborts any in-flight HTTP requests.
    * A fresh AbortController is created so the client remains reusable.
    */
   abort() {
@@ -383,69 +252,88 @@ var CoordinatorClient = class {
     this.abortController = new AbortController();
   }
   /**
-   * The current abort signal, passed to every fetch() and sleep() call.
+   * The current abort signal, passed to every fetch() call.
    * Protected so subclasses can forward it to their own fetch calls.
    */
   get signal() {
     return this.abortController.signal;
   }
   /**
-   * Returns the authorization header with JWT Bearer token
+   * Returns authorization + versioning headers for all coordinator requests.
    */
-  getAuthHeaders() {
+  getHeaders() {
     return {
-      Authorization: `Bearer ${this.jwtToken}`
+      Authorization: `Bearer ${this.jwtToken}`,
+      [API_VERSION_HEADER]: String(REACTOR_API_VERSION),
+      [API_ACCEPT_VERSION_HEADER]: String(REACTOR_API_VERSION)
     };
   }
   /**
-   * Fetches ICE servers from the coordinator.
-   * @returns Array of RTCIceServer objects for WebRTC peer connection configuration
+   * Checks an HTTP response for version mismatch errors (426, 501).
+   * Logs a clear message and throws with a descriptive error code.
    */
-  getIceServers() {
+  checkVersionMismatch(response) {
     return __async(this, null, function* () {
-      console.debug("[CoordinatorClient] Fetching ICE servers...");
-      const response = yield fetch(
-        `${this.baseUrl}/ice_servers?model=${this.model}`,
-        {
-          method: "GET",
-          headers: this.getAuthHeaders(),
-          signal: this.signal
-        }
-      );
-      if (!response.ok) {
-        throw new Error(`Failed to fetch ICE servers: ${response.status}`);
+      if (response.status === 426) {
+        const msg = `Client API version (${REACTOR_API_VERSION}) is too old. Server requires a newer version. Please upgrade @reactor-team/js-sdk.`;
+        console.error(`[Reactor]`, msg);
+        throw new Error(`${VERSION_ERROR_CODES[426]}: ${msg}`);
       }
-      const data = yield response.json();
-      const parsed = IceServersResponseSchema.parse(data);
-      const iceServers = transformIceServers(parsed);
-      console.debug(
-        "[CoordinatorClient] Received ICE servers:",
-        iceServers.length
-      );
-      return iceServers;
+      if (response.status === 501) {
+        const msg = `Server does not support API version ${REACTOR_API_VERSION}. The server may need to be updated.`;
+        console.error(`[Reactor]`, msg);
+        throw new Error(`${VERSION_ERROR_CODES[501]}: ${msg}`);
+      }
+    });
+  }
+  sleep(ms) {
+    return new Promise((resolve, reject) => {
+      const { signal } = this;
+      if (signal.aborted) {
+        reject(new AbortError("Sleep aborted"));
+        return;
+      }
+      const timer = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve();
+      }, ms);
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(new AbortError("Sleep aborted"));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
     });
   }
   /**
    * Creates a new session with the coordinator.
-   * Expects a 200 response and stores the session ID.
-   * @returns The session ID
+   * No SDP is sent — transport signaling is decoupled from session creation.
+   *
+   * The POST response is a slim acknowledgment (session_id, model name, status).
+   * Capabilities and transport details are populated later once the Runtime
+   * accepts the session — use {@link pollSessionReady} to wait for them.
    */
-  createSession(sdp_offer) {
+  createSession(extraArgs) {
     return __async(this, null, function* () {
       console.debug("[CoordinatorClient] Creating session...");
-      const requestBody = {
+      const requestBody = __spreadValues({
         model: { name: this.model },
-        sdp_offer,
-        extra_args: {}
-      };
+        client_info: {
+          sdk_version: REACTOR_SDK_VERSION,
+          sdk_type: REACTOR_SDK_TYPE
+        },
+        supported_transports: [
+          { protocol: "webrtc", version: REACTOR_WEBRTC_VERSION }
+        ]
+      }, extraArgs ? { extra_args: extraArgs } : {});
       const response = yield fetch(`${this.baseUrl}/sessions`, {
         method: "POST",
-        headers: __spreadProps(__spreadValues({}, this.getAuthHeaders()), {
+        headers: __spreadProps(__spreadValues({}, this.getHeaders()), {
           "Content-Type": "application/json"
         }),
         body: JSON.stringify(requestBody),
         signal: this.signal
       });
+      yield this.checkVersionMismatch(response);
       if (!response.ok) {
         const errorText = yield response.text();
         throw new Error(
@@ -453,339 +341,462 @@ var CoordinatorClient = class {
         );
       }
       const data = yield response.json();
-      this.currentSessionId = data.session_id;
+      const parsed = InitialSessionResponseSchema.parse(data);
+      this.currentSessionId = parsed.session_id;
       console.debug(
-        "[CoordinatorClient] Session created with ID:",
-        this.currentSessionId
+        "[CoordinatorClient] Session created:",
+        this.currentSessionId,
+        "state:",
+        parsed.state
       );
-      return data.session_id;
+      return parsed;
     });
   }
   /**
-   * Gets the current session information from the coordinator.
-   * @returns The session data (untyped for now)
+   * Polls GET /sessions/{id} until the Runtime has accepted the session
+   * and populated capabilities and selected_transport.
    */
-  getSession() {
+  pollSessionReady(opts) {
     return __async(this, null, function* () {
+      var _a;
       if (!this.currentSessionId) {
         throw new Error("No active session. Call createSession() first.");
       }
+      const maxAttempts = (_a = opts == null ? void 0 : opts.maxAttempts) != null ? _a : SESSION_POLL_DEFAULT_MAX_ATTEMPTS;
+      let backoffMs = SESSION_POLL_INITIAL_BACKOFF_MS;
+      let attempt = 0;
       console.debug(
-        "[CoordinatorClient] Getting session info for:",
-        this.currentSessionId
+        "[CoordinatorClient] Polling session until capabilities are available..."
       );
-      const response = yield fetch(
-        `${this.baseUrl}/sessions/${this.currentSessionId}`,
-        {
-          method: "GET",
-          headers: this.getAuthHeaders(),
-          signal: this.signal
+      while (true) {
+        if (this.signal.aborted) {
+          throw new AbortError("Session polling aborted");
         }
-      );
-      if (!response.ok) {
-        const errorText = yield response.text();
-        throw new Error(`Failed to get session: ${response.status} ${errorText}`);
-      }
-      const data = yield response.json();
-      return data;
-    });
-  }
+        if (attempt >= maxAttempts) {
+          throw new Error(
+            `Session polling exceeded maximum attempts (${maxAttempts}). The model may be unavailable or overloaded.`
+          );
+        }
+        attempt++;
+        const response = yield fetch(
+          `${this.baseUrl}/sessions/${this.currentSessionId}`,
+          {
+            method: "GET",
+            headers: this.getHeaders(),
+            signal: this.signal
+          }
+        );
+        yield this.checkVersionMismatch(response);
+        if (!response.ok) {
+          const errorText = yield response.text();
+          throw new Error(
+            `Failed to poll session: ${response.status} ${errorText}`
+          );
+        }
+        const data = yield response.json();
+        const partial = SessionResponseSchema.parse(data);
+        const terminalStates = [
+          "CLOSED" /* CLOSED */,
+          "INACTIVE" /* INACTIVE */
+        ];
+        if (terminalStates.includes(partial.state)) {
+          throw new Error(
+            `Session entered terminal state "${partial.state}" while waiting for capabilities`
+          );
+        }
+        if (partial.capabilities && partial.selected_transport) {
+          const full = CreateSessionResponseSchema.parse(data);
+          console.debug(
+            `[CoordinatorClient] Session ready after ${attempt} poll(s), transport: ${full.selected_transport.protocol}, tracks: ${full.capabilities.tracks.length}`
+          );
+          return full;
+        }
+        console.debug(
+          `[CoordinatorClient] Session poll ${attempt}/${maxAttempts} \u2014 state: ${partial.state}, waiting ${backoffMs}ms...`
+        );
+        yield this.sleep(backoffMs);
+        backoffMs = Math.min(
+          backoffMs * SESSION_POLL_BACKOFF_MULTIPLIER,
+          SESSION_POLL_MAX_BACKOFF_MS
+        );
+      }
+    });
+  }
   /**
-   * Terminates the current session by sending a DELETE request to the coordinator.
-   * No-op if no session has been created yet.
-   * @throws Error if the request fails (except for 404, which clears local state)
+   * Gets full session details from the coordinator.
+   * Returns the same shape as the creation response but with updated state.
    */
-  terminateSession() {
+  getSession() {
     return __async(this, null, function* () {
       if (!this.currentSessionId) {
-        return;
+        throw new Error("No active session. Call createSession() first.");
       }
-      console.debug(
-        "[CoordinatorClient] Terminating session:",
-        this.currentSessionId
-      );
       const response = yield fetch(
         `${this.baseUrl}/sessions/${this.currentSessionId}`,
         {
-          method: "DELETE",
-          headers: this.getAuthHeaders(),
+          method: "GET",
+          headers: this.getHeaders(),
           signal: this.signal
         }
       );
-      if (response.ok) {
-        this.currentSessionId = void 0;
-        return;
-      }
-      if (response.status === 404) {
-        console.debug(
-          "[CoordinatorClient] Session not found on server, clearing local state:",
-          this.currentSessionId
-        );
-        this.currentSessionId = void 0;
-        return;
+      yield this.checkVersionMismatch(response);
+      if (!response.ok) {
+        const errorText = yield response.text();
+        throw new Error(`Failed to get session: ${response.status} ${errorText}`);
       }
-      const errorText = yield response.text();
-      throw new Error(
-        `Failed to terminate session: ${response.status} ${errorText}`
-      );
+      const data = yield response.json();
+      return CreateSessionResponseSchema.parse(data);
     });
   }
   /**
-   * Get the current session ID
+   * Gets lightweight session status (session_id, cluster, status).
    */
-  getSessionId() {
-    return this.currentSessionId;
-  }
-  /**
-   * Sends an SDP offer to the server for reconnection.
-   * @param sessionId - The session ID to connect to
-   * @param sdpOffer - The SDP offer from the local WebRTC peer connection
-   * @returns The SDP answer if ready (200), or null if pending (202)
-   */
-  sendSdpOffer(sessionId, sdpOffer) {
+  getSessionInfo() {
     return __async(this, null, function* () {
-      console.debug(
-        "[CoordinatorClient] Sending SDP offer for session:",
-        sessionId
-      );
-      const requestBody = {
-        sdp_offer: sdpOffer,
-        extra_args: {}
-      };
+      if (!this.currentSessionId) {
+        throw new Error("No active session. Call createSession() first.");
+      }
       const response = yield fetch(
-        `${this.baseUrl}/sessions/${sessionId}/sdp_params`,
+        `${this.baseUrl}/sessions/${this.currentSessionId}/info`,
         {
-          method: "PUT",
-          headers: __spreadProps(__spreadValues({}, this.getAuthHeaders()), {
-            "Content-Type": "application/json"
-          }),
-          body: JSON.stringify(requestBody),
+          method: "GET",
+          headers: this.getHeaders(),
           signal: this.signal
         }
       );
-      if (response.status === 200) {
-        const answerData = yield response.json();
-        console.debug("[CoordinatorClient] Received SDP answer immediately");
-        return answerData.sdp_answer;
-      }
-      if (response.status === 202) {
-        console.debug(
-          "[CoordinatorClient] SDP offer accepted, answer pending (202)"
+      yield this.checkVersionMismatch(response);
+      if (!response.ok) {
+        const errorText = yield response.text();
+        throw new Error(
+          `Failed to get session info: ${response.status} ${errorText}`
         );
-        return null;
       }
-      const errorText = yield response.text();
-      throw new Error(
-        `Failed to send SDP offer: ${response.status} ${errorText}`
-      );
+      const data = yield response.json();
+      return SessionInfoResponseSchema.parse(data);
     });
   }
   /**
-   * Polls for the SDP answer with exponential backoff.
-   * Used for async reconnection when the answer is not immediately available.
-   * @param sessionId - The session ID to poll for
-   * @param maxAttempts - Optional maximum number of polling attempts before giving up
-   * @returns The SDP answer from the server
+   * Restarts an inactive session with a different compute unit.
+   * The session ID is preserved but a new transport must be established.
    */
-  pollSdpAnswer(_0) {
-    return __async(this, arguments, function* (sessionId, maxAttempts = DEFAULT_MAX_ATTEMPTS) {
+  restartSession() {
+    return __async(this, null, function* () {
+      if (!this.currentSessionId) {
+        throw new Error("No active session. Call createSession() first.");
+      }
       console.debug(
-        "[CoordinatorClient] Polling for SDP answer for session:",
-        sessionId
+        "[CoordinatorClient] Restarting session:",
+        this.currentSessionId
       );
-      let backoffMs = INITIAL_BACKOFF_MS;
-      let attempt = 0;
-      while (true) {
-        if (this.signal.aborted) {
-          throw new AbortError("SDP polling aborted");
-        }
-        if (attempt >= maxAttempts) {
-          throw new Error(
-            `SDP polling exceeded maximum attempts (${maxAttempts}) for session ${sessionId}`
-          );
-        }
-        attempt++;
-        console.debug(
-          `[CoordinatorClient] SDP poll attempt ${attempt}/${maxAttempts} for session ${sessionId}`
-        );
-        const response = yield fetch(
-          `${this.baseUrl}/sessions/${sessionId}/sdp_params`,
-          {
-            method: "GET",
-            headers: __spreadProps(__spreadValues({}, this.getAuthHeaders()), {
-              "Content-Type": "application/json"
-            }),
-            signal: this.signal
-          }
-        );
-        if (response.status === 200) {
-          const answerData = yield response.json();
-          console.debug("[CoordinatorClient] Received SDP answer via polling");
-          return { sdpAnswer: answerData.sdp_answer, attempts: attempt };
-        }
-        if (response.status === 202) {
-          console.warn(
-            `[CoordinatorClient] SDP answer pending (202), retrying in ${backoffMs}ms...`
-          );
-          yield this.sleep(backoffMs);
-          backoffMs = Math.min(backoffMs * BACKOFF_MULTIPLIER, MAX_BACKOFF_MS);
-          continue;
+      const response = yield fetch(
+        `${this.baseUrl}/sessions/${this.currentSessionId}`,
+        {
+          method: "PUT",
+          headers: this.getHeaders(),
+          signal: this.signal
         }
+      );
+      yield this.checkVersionMismatch(response);
+      if (!response.ok) {
         const errorText = yield response.text();
         throw new Error(
-          `Failed to poll SDP answer: ${response.status} ${errorText}`
+          `Failed to restart session: ${response.status} ${errorText}`
         );
       }
     });
   }
   /**
-   * Connects to the session by sending an SDP offer and receiving an SDP answer.
-   * If sdpOffer is provided, sends it first. If the answer is pending (202),
-   * falls back to polling. If no sdpOffer is provided, goes directly to polling.
-   * @param sessionId - The session ID to connect to
-   * @param sdpOffer - Optional SDP offer from the local WebRTC peer connection
-   * @param maxAttempts - Optional maximum number of polling attempts before giving up
-   * @returns The SDP answer and the number of polling attempts made (0 if answered immediately via PUT)
+   * Terminates the current session by sending a DELETE request.
+   * No-op if no session has been created yet.
+   * @param reason Optional termination reason
    */
-  connect(sessionId, sdpOffer, maxAttempts) {
+  terminateSession(reason) {
     return __async(this, null, function* () {
-      console.debug("[CoordinatorClient] Connecting to session:", sessionId);
-      if (sdpOffer) {
-        const answer = yield this.sendSdpOffer(sessionId, sdpOffer);
-        if (answer !== null) {
-          return { sdpAnswer: answer, sdpPollingAttempts: 0 };
-        }
+      if (!this.currentSessionId) {
+        return;
       }
-      const result = yield this.pollSdpAnswer(sessionId, maxAttempts);
-      return { sdpAnswer: result.sdpAnswer, sdpPollingAttempts: result.attempts };
-    });
-  }
-  /**
-   * Abort-aware sleep. Resolves after `ms` milliseconds unless the
-   * abort signal fires first, in which case it rejects with AbortError.
-   */
-  sleep(ms) {
-    return new Promise((resolve, reject) => {
-      const { signal } = this;
-      if (signal.aborted) {
-        reject(new AbortError("Sleep aborted"));
+      console.debug(
+        "[CoordinatorClient] Terminating session:",
+        this.currentSessionId
+      );
+      const body = reason ? { reason } : void 0;
+      const response = yield fetch(
+        `${this.baseUrl}/sessions/${this.currentSessionId}`,
+        __spreadProps(__spreadValues({
+          method: "DELETE",
+          headers: __spreadValues(__spreadValues({}, this.getHeaders()), body ? { "Content-Type": "application/json" } : {})
+        }, body ? { body: JSON.stringify(body) } : {}), {
+          signal: this.signal
+        })
+      );
+      if (response.ok) {
+        this.currentSessionId = void 0;
         return;
       }
-      const timer = setTimeout(() => {
-        signal.removeEventListener("abort", onAbort);
-        resolve();
-      }, ms);
-      const onAbort = () => {
-        clearTimeout(timer);
-        reject(new AbortError("Sleep aborted"));
-      };
-      signal.addEventListener("abort", onAbort, { once: true });
+      if (response.status === 404) {
+        console.debug(
+          "[CoordinatorClient] Session not found on server, clearing local state:",
+          this.currentSessionId
+        );
+        this.currentSessionId = void 0;
+        return;
+      }
+      const errorText = yield response.text();
+      throw new Error(
+        `Failed to terminate session: ${response.status} ${errorText}`
+      );
     });
   }
+  getSessionId() {
+    return this.currentSessionId;
+  }
 };
 
 // src/core/LocalCoordinatorClient.ts
 var LocalCoordinatorClient = class extends CoordinatorClient {
-  constructor(baseUrl) {
+  constructor(baseUrl, model) {
     super({
       baseUrl,
       jwtToken: "local",
-      model: "local"
+      model
     });
-    this.localBaseUrl = baseUrl;
+  }
+  getHeaders() {
+    return {
+      [API_VERSION_HEADER]: String(REACTOR_API_VERSION),
+      [API_ACCEPT_VERSION_HEADER]: String(REACTOR_API_VERSION)
+    };
   }
   /**
-   * Gets ICE servers from the local HTTP runtime.
-   * @returns The ICE server configuration
+   * Starts a session on the local runtime.
+   *
+   * Unlike the production coordinator, the local runtime returns the full
+   * response (capabilities, selected_transport) immediately — no polling needed.
    */
-  getIceServers() {
+  createSession(extraArgs) {
     return __async(this, null, function* () {
-      console.debug("[LocalCoordinatorClient] Fetching ICE servers...");
-      const response = yield fetch(`${this.localBaseUrl}/ice_servers`, {
-        method: "GET",
+      console.debug("[LocalCoordinatorClient] Starting session...");
+      const response = yield fetch(`${this.baseUrl}/start_session`, {
+        method: "POST",
+        headers: __spreadProps(__spreadValues({}, this.getHeaders()), {
+          "Content-Type": "application/json"
+        }),
+        body: JSON.stringify(__spreadValues({}, extraArgs ? { extra_args: extraArgs } : {})),
         signal: this.signal
       });
       if (!response.ok) {
-        throw new Error("Failed to get ICE servers from local coordinator.");
+        const errorText = yield response.text();
+        throw new Error(
+          `Failed to start session: ${response.status} ${errorText}`
+        );
       }
       const data = yield response.json();
-      const parsed = IceServersResponseSchema.parse(data);
-      const iceServers = transformIceServers(parsed);
+      this.cachedSessionResponse = CreateSessionResponseSchema.parse(data);
+      this.currentSessionId = this.cachedSessionResponse.session_id;
       console.debug(
-        "[LocalCoordinatorClient] Received ICE servers:",
-        iceServers.length
+        "[LocalCoordinatorClient] Session started:",
+        this.currentSessionId,
+        "transport:",
+        this.cachedSessionResponse.selected_transport.protocol,
+        "tracks:",
+        this.cachedSessionResponse.capabilities.tracks.length
       );
-      return iceServers;
+      return InitialSessionResponseSchema.parse(data);
     });
   }
   /**
-   * Creates a local session by posting to /start_session.
-   * @returns always "local"
+   * Returns the cached full session response immediately.
+   * The local runtime already provided everything in start_session.
    */
-  createSession(sdpOffer) {
+  pollSessionReady() {
     return __async(this, null, function* () {
-      console.debug("[LocalCoordinatorClient] Creating local session...");
-      this.sdpOffer = sdpOffer;
-      const response = yield fetch(`${this.localBaseUrl}/start_session`, {
-        method: "POST",
-        signal: this.signal
-      });
-      if (!response.ok) {
-        throw new Error("Failed to send local start session command.");
+      if (!this.cachedSessionResponse) {
+        throw new Error(
+          "No cached session response. Call createSession() first."
+        );
       }
-      console.debug("[LocalCoordinatorClient] Local session created");
-      return "local";
+      return this.cachedSessionResponse;
     });
   }
   /**
-   * Connects to the local session by posting SDP params to /sdp_params.
-   * Local connections are always immediate (no polling).
-   * @param sessionId - The session ID (ignored for local)
-   * @param sdpMessage - The SDP offer from the local WebRTC peer connection
-   * @returns The SDP answer and polling attempts (always 0 for local)
+   * Stops the session on the local runtime.
    */
-  connect(sessionId, sdpMessage) {
+  terminateSession() {
     return __async(this, null, function* () {
-      this.sdpOffer = sdpMessage || this.sdpOffer;
-      console.debug("[LocalCoordinatorClient] Connecting to local session...");
-      const sdpBody = {
-        sdp: this.sdpOffer,
-        type: "offer"
-      };
-      const response = yield fetch(`${this.localBaseUrl}/sdp_params`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(sdpBody),
-        signal: this.signal
-      });
-      if (!response.ok) {
-        if (response.status === 409) {
-          throw new ConflictError("Connection superseded by newer request");
-        }
-        throw new Error("Failed to get SDP answer from local coordinator.");
+      if (!this.currentSessionId) {
+        return;
       }
-      const sdpAnswer = yield response.json();
-      console.debug("[LocalCoordinatorClient] Received SDP answer");
-      return { sdpAnswer: sdpAnswer.sdp, sdpPollingAttempts: 0 };
+      console.debug(
+        "[LocalCoordinatorClient] Stopping session:",
+        this.currentSessionId
+      );
+      try {
+        yield fetch(`${this.baseUrl}/stop_session`, {
+          method: "POST",
+          headers: this.getHeaders(),
+          signal: this.signal
+        });
+      } catch (error) {
+        console.error("[LocalCoordinatorClient] Error stopping session:", error);
+      }
+      this.currentSessionId = void 0;
+      this.cachedSessionResponse = void 0;
     });
   }
-  terminateSession() {
-    return __async(this, null, function* () {
-      console.debug("[LocalCoordinatorClient] Stopping local session...");
-      yield fetch(`${this.localBaseUrl}/stop_session`, {
-        method: "POST",
-        signal: this.signal
-      });
+};
+
+// src/utils/webrtc.ts
+var DEFAULT_DATA_CHANNEL_LABEL = "data";
+var FORCE_RELAY_MODE = false;
+var DEFAULT_MAX_MESSAGE_BYTES = 256 * 1024;
+function createPeerConnection(config) {
+  return new RTCPeerConnection({
+    iceServers: config.iceServers,
+    iceTransportPolicy: FORCE_RELAY_MODE ? "relay" : "all"
+  });
+}
+function createDataChannel(pc, label) {
+  return pc.createDataChannel(label != null ? label : DEFAULT_DATA_CHANNEL_LABEL);
+}
+function createOffer(pc) {
+  return __async(this, null, function* () {
+    const offer = yield pc.createOffer();
+    yield pc.setLocalDescription(offer);
+    yield waitForIceGathering(pc);
+    const localDescription = pc.localDescription;
+    if (!localDescription) {
+      throw new Error("Failed to create local description");
+    }
+    return localDescription.sdp;
+  });
+}
+function setRemoteDescription(pc, sdp) {
+  return __async(this, null, function* () {
+    const sessionDescription = new RTCSessionDescription({
+      sdp,
+      type: "answer"
     });
+    yield pc.setRemoteDescription(sessionDescription);
+  });
+}
+function transformIceServers(response) {
+  return response.ice_servers.map((server) => {
+    const rtcServer = {
+      urls: server.uris
+    };
+    if (server.credentials) {
+      rtcServer.username = server.credentials.username;
+      rtcServer.credential = server.credentials.password;
+    }
+    return rtcServer;
+  });
+}
+function waitForIceGathering(pc, timeoutMs = 5e3) {
+  return new Promise((resolve) => {
+    if (pc.iceGatheringState === "complete") {
+      resolve();
+      return;
+    }
+    const onGatheringStateChange = () => {
+      if (pc.iceGatheringState === "complete") {
+        pc.removeEventListener(
+          "icegatheringstatechange",
+          onGatheringStateChange
+        );
+        resolve();
+      }
+    };
+    pc.addEventListener("icegatheringstatechange", onGatheringStateChange);
+    setTimeout(() => {
+      pc.removeEventListener("icegatheringstatechange", onGatheringStateChange);
+      resolve();
+    }, timeoutMs);
+  });
+}
+function sendMessage(channel, command, data, scope = "application", maxBytes = DEFAULT_MAX_MESSAGE_BYTES) {
+  if (channel.readyState !== "open") {
+    throw new Error(`Data channel not open: ${channel.readyState}`);
   }
-};
+  const jsonData = typeof data === "string" ? JSON.parse(data) : data;
+  const inner = { type: command, data: jsonData };
+  const payload = { scope, data: inner };
+  const serialized = JSON.stringify(payload);
+  const byteLength = new TextEncoder().encode(serialized).byteLength;
+  if (byteLength > maxBytes) {
+    throw new Error(
+      `Data channel message too large: ${byteLength} bytes exceeds limit of ${maxBytes} bytes (command: "${command}")`
+    );
+  }
+  channel.send(serialized);
+}
+function parseMessage(data) {
+  if (typeof data === "string") {
+    try {
+      return JSON.parse(data);
+    } catch (e) {
+      return data;
+    }
+  }
+  return data;
+}
+function closePeerConnection(pc) {
+  pc.close();
+}
+function extractConnectionStats(report) {
+  let rtt;
+  let availableOutgoingBitrate;
+  let localCandidateId;
+  let framesPerSecond;
+  let jitter;
+  let packetLossRatio;
+  report.forEach((stat) => {
+    if (stat.type === "candidate-pair" && stat.state === "succeeded") {
+      if (stat.currentRoundTripTime !== void 0) {
+        rtt = stat.currentRoundTripTime * 1e3;
+      }
+      if (stat.availableOutgoingBitrate !== void 0) {
+        availableOutgoingBitrate = stat.availableOutgoingBitrate;
+      }
+      localCandidateId = stat.localCandidateId;
+    }
+    if (stat.type === "inbound-rtp" && stat.kind === "video") {
+      if (stat.framesPerSecond !== void 0) {
+        framesPerSecond = stat.framesPerSecond;
+      }
+      if (stat.jitter !== void 0) {
+        jitter = stat.jitter;
+      }
+      if (stat.packetsReceived !== void 0 && stat.packetsLost !== void 0 && stat.packetsReceived + stat.packetsLost > 0) {
+        packetLossRatio = stat.packetsLost / (stat.packetsReceived + stat.packetsLost);
+      }
+    }
+  });
+  let candidateType;
+  if (localCandidateId) {
+    const localCandidate = report.get(localCandidateId);
+    if (localCandidate == null ? void 0 : localCandidate.candidateType) {
+      candidateType = localCandidate.candidateType;
+    }
+  }
+  return {
+    rtt,
+    candidateType,
+    availableOutgoingBitrate,
+    framesPerSecond,
+    packetLossRatio,
+    jitter,
+    timestamp: Date.now()
+  };
+}
 
-// src/core/GPUMachineClient.ts
+// src/core/WebRTCTransportClient.ts
 var PING_INTERVAL_MS = 5e3;
 var STATS_INTERVAL_MS = 2e3;
-var GPUMachineClient = class {
+var INITIAL_BACKOFF_MS = 200;
+var MAX_BACKOFF_MS = 15e3;
+var BACKOFF_MULTIPLIER = 2;
+var DEFAULT_MAX_POLL_ATTEMPTS = 6;
+var WebRTCTransportClient = class {
   constructor(config) {
     this.eventListeners = /* @__PURE__ */ new Map();
     this.status = "disconnected";
@@ -793,11 +804,17 @@ var GPUMachineClient = class {
     this.publishedTracks = /* @__PURE__ */ new Map();
     this.peerConnected = false;
     this.dataChannelOpen = false;
-    this.config = config;
+    var _a, _b;
+    this.baseUrl = config.baseUrl;
+    this.sessionId = config.sessionId;
+    this.jwtToken = config.jwtToken;
+    this.webrtcVersion = (_a = config.webrtcVersion) != null ? _a : REACTOR_WEBRTC_VERSION;
+    this.maxPollAttempts = (_b = config.maxPollAttempts) != null ? _b : DEFAULT_MAX_POLL_ATTEMPTS;
+    this.abortController = new AbortController();
   }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Event Emitter API
-  // ─────────────────────────────────────────────────────────────────────────────
+  // ─────────────────────────────────────────────────────────────────────────
+  // Event Emitter
+  // ─────────────────────────────────────────────────────────────────────────
   on(event, handler) {
     if (!this.eventListeners.has(event)) {
       this.eventListeners.set(event, /* @__PURE__ */ new Set());
@@ -812,130 +829,241 @@ var GPUMachineClient = class {
     var _a;
     (_a = this.eventListeners.get(event)) == null ? void 0 : _a.forEach((handler) => handler(...args));
   }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // SDP & Connection
-  // ─────────────────────────────────────────────────────────────────────────────
-  /**
-   * Creates an SDP offer based on the declared tracks.
-   *
-   * **RECEIVE** = client receives from the model (model → client) → `recvonly`
-   * **SEND**    = client sends to the model (client → model)     → `sendonly`
-   *
-   * Track names must be unique across both arrays. A name that appears in
-   * both `receive` and `send` will throw — use distinct names instead.
-   *
-   * The data channel is always created first (before transceivers).
-   * Must be called before connect().
-   */
-  createOffer(tracks) {
+  // ─────────────────────────────────────────────────────────────────────────
+  // HTTP Helpers
+  // ─────────────────────────────────────────────────────────────────────────
+  get signal() {
+    return this.abortController.signal;
+  }
+  get transportBaseUrl() {
+    return `${this.baseUrl}/sessions/${this.sessionId}/transport/webrtc`;
+  }
+  getHeaders() {
+    return {
+      Authorization: `Bearer ${this.jwtToken}`,
+      [WEBRTC_VERSION_HEADER]: this.webrtcVersion
+    };
+  }
+  checkVersionMismatch(response) {
+    return __async(this, null, function* () {
+      if (response.status === 426) {
+        const msg = `Client WebRTC version (${this.webrtcVersion}) is too old. Server requires a newer version. Please upgrade @reactor-team/js-sdk.`;
+        console.error(`[WebRTCTransport]`, msg);
+        throw new Error(`${VERSION_ERROR_CODES[426]}: ${msg}`);
+      }
+      if (response.status === 501) {
+        const msg = `Server does not support WebRTC version ${this.webrtcVersion}. The server may need to be updated.`;
+        console.error(`[WebRTCTransport]`, msg);
+        throw new Error(`${VERSION_ERROR_CODES[501]}: ${msg}`);
+      }
+    });
+  }
+  sleep(ms) {
+    return new Promise((resolve, reject) => {
+      const { signal } = this;
+      if (signal.aborted) {
+        reject(new AbortError("Sleep aborted"));
+        return;
+      }
+      const timer = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve();
+      }, ms);
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(new AbortError("Sleep aborted"));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Transport Signaling (HTTP)
+  // ─────────────────────────────────────────────────────────────────────────
+  fetchIceServers() {
+    return __async(this, null, function* () {
+      console.debug("[WebRTCTransport] Fetching ICE servers...");
+      const response = yield fetch(`${this.transportBaseUrl}/ice_servers`, {
+        method: "GET",
+        headers: this.getHeaders(),
+        signal: this.signal
+      });
+      yield this.checkVersionMismatch(response);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch ICE servers: ${response.status}`);
+      }
+      const data = yield response.json();
+      const parsed = IceServersResponseSchema.parse(data);
+      const iceServers = transformIceServers(parsed);
+      console.debug("[WebRTCTransport] Received ICE servers:", iceServers.length);
+      return iceServers;
+    });
+  }
+  sendSdpOffer(sdpOffer, trackMapping, method = "POST") {
+    return __async(this, null, function* () {
+      console.debug(
+        `[WebRTCTransport] Sending SDP offer (${method}) for session:`,
+        this.sessionId
+      );
+      const requestBody = {
+        sdp_offer: sdpOffer,
+        client_info: {
+          sdk_version: REACTOR_SDK_VERSION,
+          sdk_type: REACTOR_SDK_TYPE
+        },
+        track_mapping: trackMapping
+      };
+      const response = yield fetch(`${this.transportBaseUrl}/sdp_params`, {
+        method,
+        headers: __spreadProps(__spreadValues({}, this.getHeaders()), {
+          "Content-Type": "application/json"
+        }),
+        body: JSON.stringify(requestBody),
+        signal: this.signal
+      });
+      yield this.checkVersionMismatch(response);
+      if (response.status !== 202) {
+        const errorText = yield response.text();
+        throw new Error(
+          `Failed to send SDP offer: ${response.status} ${errorText}`
+        );
+      }
+      console.debug("[WebRTCTransport] SDP offer accepted (202)");
+    });
+  }
+  pollSdpAnswer() {
+    return __async(this, null, function* () {
+      console.debug("[WebRTCTransport] Polling for SDP answer...");
+      const pollStart = performance.now();
+      let backoffMs = INITIAL_BACKOFF_MS;
+      let attempt = 0;
+      while (true) {
+        if (this.signal.aborted) {
+          throw new AbortError("SDP polling aborted");
+        }
+        if (attempt >= this.maxPollAttempts) {
+          throw new Error(
+            `SDP polling exceeded maximum attempts (${this.maxPollAttempts})`
+          );
+        }
+        attempt++;
+        console.debug(
+          `[WebRTCTransport] SDP poll attempt ${attempt}/${this.maxPollAttempts}`
+        );
+        const response = yield fetch(`${this.transportBaseUrl}/sdp_params`, {
+          method: "GET",
+          headers: this.getHeaders(),
+          signal: this.signal
+        });
+        yield this.checkVersionMismatch(response);
+        if (response.status === 200) {
+          const data = yield response.json();
+          const parsed = WebRTCSdpAnswerResponseSchema.parse(data);
+          this.sdpPollingMs = performance.now() - pollStart;
+          this.sdpPollingAttempts = attempt;
+          console.debug(
+            `[WebRTCTransport] Received SDP answer via polling (${attempt} attempt(s), ${this.sdpPollingMs.toFixed(0)}ms)`
+          );
+          return parsed;
+        }
+        if (response.status === 202) {
+          console.debug(
+            `[WebRTCTransport] SDP answer pending, retrying in ${backoffMs}ms...`
+          );
+          yield this.sleep(backoffMs);
+          backoffMs = Math.min(backoffMs * BACKOFF_MULTIPLIER, MAX_BACKOFF_MS);
+          continue;
+        }
+        const errorText = yield response.text();
+        throw new Error(
+          `Failed to poll SDP answer: ${response.status} ${errorText}`
+        );
+      }
+    });
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Connection Lifecycle
+  // ─────────────────────────────────────────────────────────────────────────
+  connect(tracks) {
     return __async(this, null, function* () {
-      if (!this.peerConnection) {
-        this.peerConnection = createPeerConnection(this.config);
-        this.setupPeerConnectionHandlers();
-      }
-      this.dataChannel = createDataChannel(
-        this.peerConnection,
-        this.config.dataChannelLabel
-      );
+      this.setStatus("connecting");
+      this.resetTransportTimings();
+      const iceServers = yield this.fetchIceServers();
+      this.peerConnection = createPeerConnection({ iceServers });
+      this.setupPeerConnectionHandlers();
+      this.dataChannel = createDataChannel(this.peerConnection);
       this.setupDataChannelHandlers();
       this.transceiverMap.clear();
-      const entries = this.buildTransceiverEntries(tracks);
-      for (const entry of entries) {
-        const transceiver = this.peerConnection.addTransceiver(entry.kind, {
-          direction: entry.direction
+      for (const track of tracks) {
+        const transceiver = this.peerConnection.addTransceiver(track.kind, {
+          direction: track.direction
+        });
+        this.transceiverMap.set(track.name, {
+          name: track.name,
+          kind: track.kind,
+          direction: track.direction,
+          transceiver
         });
-        entry.transceiver = transceiver;
-        this.transceiverMap.set(entry.name, entry);
         console.debug(
-          `[GPUMachineClient] Transceiver added: "${entry.name}" (${entry.kind}, ${entry.direction})`
+          `[WebRTCTransport] Transceiver added: "${track.name}" (${track.kind}, ${track.direction})`
         );
       }
-      const trackNames = entries.map((e) => e.name);
-      const { sdp, needsAnswerRestore } = yield createOffer(
+      const sdpOffer = yield createOffer(this.peerConnection);
+      const trackMapping = this.buildTrackMapping(tracks);
+      yield this.sendSdpOffer(sdpOffer, trackMapping, "POST");
+      const answerResponse = yield this.pollSdpAnswer();
+      this.iceStartTime = performance.now();
+      yield setRemoteDescription(
         this.peerConnection,
-        trackNames
-      );
-      if (needsAnswerRestore) {
-        this.midMapping = buildMidMapping(entries);
-      } else {
-        this.midMapping = void 0;
-      }
-      console.debug(
-        "[GPUMachineClient] Created SDP offer with MIDs:",
-        trackNames,
-        needsAnswerRestore ? "(needs answer restore)" : "(native munging)"
+        answerResponse.sdp_answer
       );
-      return sdp;
+      console.debug("[WebRTCTransport] Remote description set");
     });
   }
-  /**
-   * Builds an ordered list of transceiver entries from the receive/send arrays.
-   *
-   * Each track produces exactly one transceiver — `recvonly` for receive,
-   * `sendonly` for send.  Bidirectional (`sendrecv`) transceivers are not
-   * supported; the same track name in both arrays is an error.
-   */
-  buildTransceiverEntries(tracks) {
-    const map = /* @__PURE__ */ new Map();
-    for (const t of tracks.receive) {
-      if (map.has(t.name)) {
-        throw new Error(
-          `Duplicate receive track name "${t.name}". Track names must be unique.`
-        );
-      }
-      map.set(t.name, { name: t.name, kind: t.kind, direction: "recvonly" });
-    }
-    for (const t of tracks.send) {
-      if (map.has(t.name)) {
-        throw new Error(
-          `Track name "${t.name}" appears in both receive and send. Bidirectional tracks are not supported \u2014 use distinct names for the inbound and outbound directions (e.g. "${t.name}_in" and "${t.name}_out").`
-        );
-      }
-      map.set(t.name, { name: t.name, kind: t.kind, direction: "sendonly" });
-    }
-    return Array.from(map.values());
-  }
-  /**
-   * Connects to the GPU machine using the provided SDP answer.
-   * createOffer() must be called first.
-   * @param sdpAnswer The SDP answer from the GPU machine
-   */
-  connect(sdpAnswer) {
+  reconnect(tracks) {
     return __async(this, null, function* () {
-      if (!this.peerConnection) {
-        throw new Error(
-          "[GPUMachineClient] Cannot connect - call createOffer() first"
-        );
+      this.setStatus("connecting");
+      this.stopPing();
+      this.stopStatsPolling();
+      if (this.dataChannel) {
+        this.dataChannel.close();
+        this.dataChannel = void 0;
       }
-      if (this.peerConnection.signalingState !== "have-local-offer") {
-        throw new Error(
-          `[GPUMachineClient] Invalid signaling state: ${this.peerConnection.signalingState}`
-        );
+      if (this.peerConnection) {
+        closePeerConnection(this.peerConnection);
+        this.peerConnection = void 0;
       }
-      this.setStatus("connecting");
-      this.iceStartTime = performance.now();
-      this.iceNegotiationMs = void 0;
-      this.dataChannelMs = void 0;
-      try {
-        let answer = sdpAnswer;
-        if (this.midMapping) {
-          answer = restoreAnswerMids(
-            answer,
-            this.midMapping.remoteToLocal
-          );
-        }
-        yield setRemoteDescription(this.peerConnection, answer);
-        console.debug("[GPUMachineClient] Remote description set");
-      } catch (error) {
-        console.error("[GPUMachineClient] Failed to connect:", error);
-        this.setStatus("error");
-        throw error;
+      this.peerConnected = false;
+      this.dataChannelOpen = false;
+      this.resetTransportTimings();
+      const iceServers = yield this.fetchIceServers();
+      this.peerConnection = createPeerConnection({ iceServers });
+      this.setupPeerConnectionHandlers();
+      this.dataChannel = createDataChannel(this.peerConnection);
+      this.setupDataChannelHandlers();
+      this.transceiverMap.clear();
+      for (const track of tracks) {
+        const transceiver = this.peerConnection.addTransceiver(track.kind, {
+          direction: track.direction
+        });
+        this.transceiverMap.set(track.name, {
+          name: track.name,
+          kind: track.kind,
+          direction: track.direction,
+          transceiver
+        });
       }
+      const sdpOffer = yield createOffer(this.peerConnection);
+      const trackMapping = this.buildTrackMapping(tracks);
+      yield this.sendSdpOffer(sdpOffer, trackMapping, "PUT");
+      const answerResponse = yield this.pollSdpAnswer();
+      this.iceStartTime = performance.now();
+      yield setRemoteDescription(
+        this.peerConnection,
+        answerResponse.sdp_answer
+      );
+      console.debug("[WebRTCTransport] Remote description set (reconnect)");
     });
   }
-  /**
-   * Disconnects from the GPU machine and cleans up resources.
-   */
   disconnect() {
     return __async(this, null, function* () {
       this.stopPing();
@@ -952,51 +1080,56 @@ var GPUMachineClient = class {
         this.peerConnection = void 0;
       }
       this.transceiverMap.clear();
-      this.midMapping = void 0;
       this.peerConnected = false;
       this.dataChannelOpen = false;
-      this.resetConnectionTimings();
+      this.resetTransportTimings();
       this.setStatus("disconnected");
-      console.debug("[GPUMachineClient] Disconnected");
+      console.debug("[WebRTCTransport] Disconnected");
     });
   }
-  /**
-   * Returns the current connection status.
-   */
+  abort() {
+    this.abortController.abort();
+    this.abortController = new AbortController();
+  }
   getStatus() {
     return this.status;
   }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Track Mapping
+  // ─────────────────────────────────────────────────────────────────────────
   /**
-   * Gets the current local SDP description.
+   * Builds the track_mapping array from capabilities + transceiver MIDs.
+   * Must be called after createOffer + setLocalDescription so that
+   * transceiver.mid is assigned.
    */
-  getLocalSDP() {
-    if (!this.peerConnection) return void 0;
-    return getLocalDescription(this.peerConnection);
-  }
-  isOfferStillValid() {
-    if (!this.peerConnection) return false;
-    return this.peerConnection.signalingState === "have-local-offer";
+  buildTrackMapping(tracks) {
+    return tracks.map((track) => {
+      var _a;
+      const entry = this.transceiverMap.get(track.name);
+      const mid = (_a = entry == null ? void 0 : entry.transceiver) == null ? void 0 : _a.mid;
+      if (mid == null) {
+        throw new Error(
+          `Cannot build track mapping: transceiver "${track.name}" has no MID. Was createOffer() called?`
+        );
+      }
+      return {
+        mid,
+        name: track.name,
+        kind: track.kind,
+        direction: track.direction
+      };
+    });
   }
-  // ─────────────────────────────────────────────────────────────────────────────
+  // ─────────────────────────────────────────────────────────────────────────
   // Messaging
-  // ─────────────────────────────────────────────────────────────────────────────
-  /**
-   * Returns the negotiated SCTP max message size (bytes) if available,
-   * otherwise `undefined` so `sendMessage` falls back to its built-in default.
-   */
+  // ─────────────────────────────────────────────────────────────────────────
   get maxMessageBytes() {
     var _a, _b, _c;
     return (_c = (_b = (_a = this.peerConnection) == null ? void 0 : _a.sctp) == null ? void 0 : _b.maxMessageSize) != null ? _c : void 0;
   }
-  /**
-   * Sends a command to the GPU machine via the data channel.
-   * @param command The command to send
-   * @param data The data to send with the command. These are the parameters for the command, matching the schema in the capabilities dictionary.
-   * @param scope The message scope – "application" (default) for model commands, "runtime" for platform-level messages.
-   */
   sendCommand(command, data, scope = "application") {
     if (!this.dataChannel) {
-      throw new Error("[GPUMachineClient] Data channel not available");
+      throw new Error("[WebRTCTransport] Data channel not available");
     }
     try {
       sendMessage(
@@ -1007,59 +1140,40 @@ var GPUMachineClient = class {
         this.maxMessageBytes
       );
     } catch (error) {
-      console.warn("[GPUMachineClient] Failed to send message:", error);
+      console.warn("[WebRTCTransport] Failed to send message:", error);
     }
   }
-  // ─────────────────────────────────────────────────────────────────────────────
+  // ─────────────────────────────────────────────────────────────────────────
   // Track Publishing
-  // ─────────────────────────────────────────────────────────────────────────────
-  /**
-   * Publishes a MediaStreamTrack to the named send track.
-   *
-   * @param name The declared track name (must exist in transceiverMap with a sendable direction).
-   * @param track The MediaStreamTrack to publish.
-   */
+  // ─────────────────────────────────────────────────────────────────────────
   publishTrack(name, track) {
     return __async(this, null, function* () {
       if (!this.peerConnection) {
         throw new Error(
-          `[GPUMachineClient] Cannot publish track "${name}" - not initialized`
+          `[WebRTCTransport] Cannot publish track "${name}" - not initialized`
         );
       }
       if (this.status !== "connected") {
         throw new Error(
-          `[GPUMachineClient] Cannot publish track "${name}" - not connected`
+          `[WebRTCTransport] Cannot publish track "${name}" - not connected`
         );
       }
       const entry = this.transceiverMap.get(name);
       if (!entry || !entry.transceiver) {
         throw new Error(
-          `[GPUMachineClient] Cannot publish track "${name}" - no transceiver (was it declared in tracks.send?)`
+          `[WebRTCTransport] Cannot publish track "${name}" - no transceiver (was it declared in capabilities?)`
         );
       }
       if (entry.direction === "recvonly") {
         throw new Error(
-          `[GPUMachineClient] Cannot publish track "${name}" - transceiver is recvonly`
-        );
-      }
-      try {
-        yield entry.transceiver.sender.replaceTrack(track);
-        this.publishedTracks.set(name, track);
-        console.debug(
-          `[GPUMachineClient] Track "${name}" published successfully`
-        );
-      } catch (error) {
-        console.error(
-          `[GPUMachineClient] Failed to publish track "${name}":`,
-          error
+          `[WebRTCTransport] Cannot publish track "${name}" - transceiver is recvonly`
         );
-        throw error;
       }
+      yield entry.transceiver.sender.replaceTrack(track);
+      this.publishedTracks.set(name, track);
+      console.debug(`[WebRTCTransport] Track "${name}" published successfully`);
     });
   }
-  /**
-   * Unpublishes the track with the given name.
-   */
   unpublishTrack(name) {
     return __async(this, null, function* () {
       const entry = this.transceiverMap.get(name);
@@ -1067,11 +1181,11 @@ var GPUMachineClient = class {
       try {
         yield entry.transceiver.sender.replaceTrack(null);
         console.debug(
-          `[GPUMachineClient] Track "${name}" unpublished successfully`
+          `[WebRTCTransport] Track "${name}" unpublished successfully`
         );
       } catch (error) {
         console.error(
-          `[GPUMachineClient] Failed to unpublish track "${name}":`,
+          `[WebRTCTransport] Failed to unpublish track "${name}":`,
           error
         );
         throw error;
@@ -1080,76 +1194,31 @@ var GPUMachineClient = class {
       }
     });
   }
-  /**
-   * Returns the currently published track for the given name.
-   */
-  getPublishedTrack(name) {
-    return this.publishedTracks.get(name);
-  }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Getters
-  // ─────────────────────────────────────────────────────────────────────────────
-  /**
-   * Returns the remote media stream from the GPU machine.
-   */
-  getRemoteStream() {
-    if (!this.peerConnection) return void 0;
-    const receivers = this.peerConnection.getReceivers();
-    const tracks = receivers.map((r) => r.track).filter((t) => t !== null);
-    if (tracks.length === 0) return void 0;
-    return new MediaStream(tracks);
-  }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Ping (Client Liveness)
-  // ─────────────────────────────────────────────────────────────────────────────
-  /**
-   * Starts sending periodic "ping" messages on the runtime channel so the
-   * server can detect stale connections quickly.
-   */
-  startPing() {
-    this.stopPing();
-    this.pingInterval = setInterval(() => {
-      var _a;
-      if (((_a = this.dataChannel) == null ? void 0 : _a.readyState) === "open") {
-        try {
-          sendMessage(this.dataChannel, "ping", {}, "runtime");
-        } catch (e) {
-        }
-      }
-    }, PING_INTERVAL_MS);
-  }
-  /**
-   * Stops the periodic ping.
-   */
-  stopPing() {
-    if (this.pingInterval !== void 0) {
-      clearInterval(this.pingInterval);
-      this.pingInterval = void 0;
-    }
-  }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Stats Polling (RTT)
-  // ─────────────────────────────────────────────────────────────────────────────
+  // ─────────────────────────────────────────────────────────────────────────
+  // Stats
+  // ─────────────────────────────────────────────────────────────────────────
   getStats() {
     return this.stats;
   }
-  /**
-   * Returns the ICE/data-channel durations recorded during the last connect(),
-   * or undefined if no connection has completed yet.
-   */
-  getConnectionTimings() {
+  getTransportTimings() {
+    var _a, _b;
     if (this.iceNegotiationMs == null || this.dataChannelMs == null) {
       return void 0;
     }
     return {
+      protocol: "webrtc",
+      sdpPollingMs: (_a = this.sdpPollingMs) != null ? _a : 0,
+      sdpPollingAttempts: (_b = this.sdpPollingAttempts) != null ? _b : 0,
       iceNegotiationMs: this.iceNegotiationMs,
       dataChannelMs: this.dataChannelMs
     };
   }
-  resetConnectionTimings() {
+  resetTransportTimings() {
     this.iceStartTime = void 0;
     this.iceNegotiationMs = void 0;
     this.dataChannelMs = void 0;
+    this.sdpPollingMs = void 0;
+    this.sdpPollingAttempts = void 0;
   }
   startStatsPolling() {
     this.stopStatsPolling();
@@ -1170,9 +1239,30 @@ var GPUMachineClient = class {
     }
     this.stats = void 0;
   }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Private Helpers
-  // ─────────────────────────────────────────────────────────────────────────────
+  // ─────────────────────────────────────────────────────────────────────────
+  // Ping (Client Liveness)
+  // ─────────────────────────────────────────────────────────────────────────
+  startPing() {
+    this.stopPing();
+    this.pingInterval = setInterval(() => {
+      var _a;
+      if (((_a = this.dataChannel) == null ? void 0 : _a.readyState) === "open") {
+        try {
+          sendMessage(this.dataChannel, "ping", {}, "runtime");
+        } catch (e) {
+        }
+      }
+    }, PING_INTERVAL_MS);
+  }
+  stopPing() {
+    if (this.pingInterval !== void 0) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = void 0;
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Internal Helpers
+  // ─────────────────────────────────────────────────────────────────────────
   checkFullyConnected() {
     if (this.peerConnected && this.dataChannelOpen) {
       this.setStatus("connected");
@@ -1190,7 +1280,7 @@ var GPUMachineClient = class {
     this.peerConnection.onconnectionstatechange = () => {
       var _a;
       const state = (_a = this.peerConnection) == null ? void 0 : _a.connectionState;
-      console.debug("[GPUMachineClient] Connection state:", state);
+      console.debug("[WebRTCTransport] Connection state:", state);
       if (state) {
         switch (state) {
           case "connected":
@@ -1223,21 +1313,21 @@ var GPUMachineClient = class {
       }
       trackName != null ? trackName : trackName = (_a = event.transceiver.mid) != null ? _a : `unknown-${event.track.id}`;
       console.debug(
-        `[GPUMachineClient] Track received: "${trackName}" (${event.track.kind}, mid=${event.transceiver.mid})`
+        `[WebRTCTransport] Track received: "${trackName}" (${event.track.kind}, mid=${event.transceiver.mid})`
       );
       const stream = (_b = event.streams[0]) != null ? _b : new MediaStream([event.track]);
       this.emit("trackReceived", trackName, event.track, stream);
     };
     this.peerConnection.onicecandidate = (event) => {
       if (event.candidate) {
-        console.debug("[GPUMachineClient] ICE candidate:", event.candidate);
+        console.debug("[WebRTCTransport] ICE candidate:", event.candidate);
       }
     };
     this.peerConnection.onicecandidateerror = (event) => {
-      console.warn("[GPUMachineClient] ICE candidate error:", event);
+      console.warn("[WebRTCTransport] ICE candidate error:", event);
     };
     this.peerConnection.ondatachannel = (event) => {
-      console.debug("[GPUMachineClient] Data channel received from remote");
+      console.debug("[WebRTCTransport] Data channel received from remote");
       this.dataChannel = event.channel;
       this.setupDataChannelHandlers();
     };
@@ -1245,7 +1335,7 @@ var GPUMachineClient = class {
   setupDataChannelHandlers() {
     if (!this.dataChannel) return;
     this.dataChannel.onopen = () => {
-      console.debug("[GPUMachineClient] Data channel open");
+      console.debug("[WebRTCTransport] Data channel open");
       if (this.iceStartTime != null && this.dataChannelMs == null) {
         this.dataChannelMs = performance.now() - this.iceStartTime;
       }
@@ -1254,16 +1344,16 @@ var GPUMachineClient = class {
       this.checkFullyConnected();
     };
     this.dataChannel.onclose = () => {
-      console.debug("[GPUMachineClient] Data channel closed");
+      console.debug("[WebRTCTransport] Data channel closed");
       this.dataChannelOpen = false;
       this.stopPing();
     };
     this.dataChannel.onerror = (error) => {
-      console.error("[GPUMachineClient] Data channel error:", error);
+      console.error("[WebRTCTransport] Data channel error:", error);
     };
     this.dataChannel.onmessage = (event) => {
       const rawData = parseMessage(event.data);
-      console.debug("[GPUMachineClient] Received message:", rawData);
+      console.debug("[WebRTCTransport] Received message:", rawData);
       try {
         if ((rawData == null ? void 0 : rawData.scope) === "application" && (rawData == null ? void 0 : rawData.data) !== void 0) {
           this.emit("message", rawData.data, "application");
@@ -1271,13 +1361,13 @@ var GPUMachineClient = class {
           this.emit("message", rawData.data, "runtime");
         } else {
           console.warn(
-            "[GPUMachineClient] Received message without envelope, treating as application"
+            "[WebRTCTransport] Received message without envelope, treating as application"
           );
           this.emit("message", rawData, "application");
         }
       } catch (error) {
         console.error(
-          "[GPUMachineClient] Failed to parse/validate message:",
+          "[WebRTCTransport] Failed to parse/validate message:",
           error
         );
       }
@@ -1289,46 +1379,24 @@ var GPUMachineClient = class {
 import { z as z2 } from "zod";
 var LOCAL_COORDINATOR_URL = "http://localhost:8080";
 var DEFAULT_BASE_URL = "https://api.reactor.inc";
-var TrackConfigSchema = z2.object({
-  name: z2.string(),
-  kind: z2.enum(["audio", "video"])
-});
 var OptionsSchema = z2.object({
   apiUrl: z2.string().default(DEFAULT_BASE_URL),
   modelName: z2.string(),
-  local: z2.boolean().default(false),
-  /**
-   * Tracks the client **RECEIVES** from the model (model → client).
-   * Each entry produces a `recvonly` transceiver.
-   * Names must be unique across both `receive` and `send`.
-   *
-   * When omitted, defaults to a single video track named `"main_video"`.
-   * Pass an explicit empty array to opt out of the default.
-   */
-  receive: z2.array(TrackConfigSchema).default([{ name: "main_video", kind: "video" }]),
-  /**
-   * Tracks the client **SENDS** to the model (client → model).
-   * Each entry produces a `sendonly` transceiver.
-   * Names must be unique across both `receive` and `send`.
-   */
-  send: z2.array(TrackConfigSchema).default([])
+  local: z2.boolean().default(false)
 });
 var Reactor = class {
   constructor(options) {
     this.status = "disconnected";
-    // Generic event map
+    this.tracks = [];
     this.eventListeners = /* @__PURE__ */ new Map();
     const validatedOptions = OptionsSchema.parse(options);
     this.coordinatorUrl = validatedOptions.apiUrl;
     this.model = validatedOptions.modelName;
     this.local = validatedOptions.local;
-    this.receive = validatedOptions.receive;
-    this.send = validatedOptions.send;
     if (this.local && options.apiUrl === void 0) {
       this.coordinatorUrl = LOCAL_COORDINATOR_URL;
     }
   }
-  // Event Emitter API
   on(event, handler) {
     if (!this.eventListeners.has(event)) {
       this.eventListeners.set(event, /* @__PURE__ */ new Set());
@@ -1345,10 +1413,6 @@ var Reactor = class {
   }
   /**
    * Sends a command to the model via the data channel.
-   *
-   * @param command The command name.
-   * @param data The command payload.
-   * @param scope "application" (default) for model commands, "runtime" for platform messages.
    */
   sendCommand(command, data, scope = "application") {
     return __async(this, null, function* () {
@@ -1359,7 +1423,7 @@ var Reactor = class {
         return;
       }
       try {
-        (_a = this.machineClient) == null ? void 0 : _a.sendCommand(command, data, scope);
+        (_a = this.transportClient) == null ? void 0 : _a.sendCommand(command, data, scope);
       } catch (error) {
         console.error("[Reactor] Failed to send message:", error);
         this.createError(
@@ -1372,10 +1436,9 @@ var Reactor = class {
     });
   }
   /**
-   * Publishes a MediaStreamTrack to a named send track.
-   *
-   * @param name The declared send track name (e.g. "webcam").
-   * @param track The MediaStreamTrack to publish.
+   * Publishes a MediaStreamTrack to a named sendonly track.
+   * The transceiver is already set up from capabilities — this just
+   * calls replaceTrack() on the sender.
    */
   publishTrack(name, track) {
     return __async(this, null, function* () {
@@ -1387,7 +1450,7 @@ var Reactor = class {
         return;
       }
       try {
-        yield (_a = this.machineClient) == null ? void 0 : _a.publishTrack(name, track);
+        yield (_a = this.transportClient) == null ? void 0 : _a.publishTrack(name, track);
       } catch (error) {
         console.error(`[Reactor] Failed to publish track "${name}":`, error);
         this.createError(
@@ -1399,16 +1462,11 @@ var Reactor = class {
       }
     });
   }
-  /**
-   * Unpublishes the track with the given name.
-   *
-   * @param name The declared send track name to unpublish.
-   */
   unpublishTrack(name) {
     return __async(this, null, function* () {
       var _a;
       try {
-        yield (_a = this.machineClient) == null ? void 0 : _a.unpublishTrack(name);
+        yield (_a = this.transportClient) == null ? void 0 : _a.unpublishTrack(name);
       } catch (error) {
         console.error(`[Reactor] Failed to unpublish track "${name}":`, error);
         this.createError(
@@ -1421,8 +1479,7 @@ var Reactor = class {
     });
   }
   /**
-   * Public method for reconnecting to an existing session, that may have been interrupted but can be recovered.
-   * @param options Optional connect options (e.g. maxAttempts for SDP polling)
+   * Reconnects to an existing session with a fresh transport.
    */
   reconnect(options) {
     return __async(this, null, function* () {
@@ -1434,31 +1491,26 @@ var Reactor = class {
         console.warn("[Reactor] Already connected, no need to reconnect.");
         return;
       }
+      if (this.tracks.length === 0) {
+        console.warn("[Reactor] No tracks available for reconnect.");
+        return;
+      }
       this.setStatus("connecting");
-      if (!this.machineClient) {
-        const iceServers = yield this.coordinatorClient.getIceServers();
-        this.machineClient = new GPUMachineClient({ iceServers });
-        this.setupMachineClientHandlers();
-      }
-      const sdpOffer = yield this.machineClient.createOffer({
-        send: this.send,
-        receive: this.receive
-      });
       try {
-        const { sdpAnswer } = yield this.coordinatorClient.connect(
-          this.sessionId,
-          sdpOffer,
-          options == null ? void 0 : options.maxAttempts
-        );
-        yield this.machineClient.connect(sdpAnswer);
+        if (!this.transportClient) {
+          this.transportClient = new WebRTCTransportClient({
+            baseUrl: this.coordinatorUrl,
+            sessionId: this.sessionId,
+            jwtToken: this.local ? "local" : "",
+            maxPollAttempts: options == null ? void 0 : options.maxAttempts
+          });
+          this.setupTransportHandlers();
+        }
+        yield this.transportClient.reconnect(this.tracks);
       } catch (error) {
         if (isAbortError(error)) return;
-        let recoverable = false;
-        if (error instanceof ConflictError) {
-          recoverable = true;
-        }
         console.error("[Reactor] Failed to reconnect:", error);
-        this.disconnect(recoverable);
+        this.disconnect(true);
         this.createError(
           "RECONNECTION_FAILED",
           `Failed to reconnect: ${error}`,
@@ -1469,14 +1521,12 @@ var Reactor = class {
     });
   }
   /**
-   * Connects to the coordinator and waits for a GPU to be assigned.
-   * Once a GPU is assigned, the Reactor will connect to the gpu machine via WebRTC.
-   * If no authentication is provided and not in local mode, an error is thrown.
-   * @param jwtToken Optional JWT token for authentication
-   * @param options Optional connect options (e.g. maxAttempts for SDP polling)
+   * Connects to the coordinator, creates a session, then establishes
+   * the transport using server-declared capabilities.
    */
   connect(jwtToken, options) {
     return __async(this, null, function* () {
+      var _a;
       console.debug("[Reactor] Connecting, status:", this.status);
       if (jwtToken == void 0 && !this.local) {
         throw new Error("No authentication provided and not in local mode");
@@ -1487,42 +1537,55 @@ var Reactor = class {
       this.setStatus("connecting");
       this.connectStartTime = performance.now();
       try {
-        console.debug(
-          "[Reactor] Connecting to coordinator with authenticated URL"
-        );
-        this.coordinatorClient = this.local ? new LocalCoordinatorClient(this.coordinatorUrl) : new CoordinatorClient({
+        this.coordinatorClient = this.local ? new LocalCoordinatorClient(this.coordinatorUrl, this.model) : new CoordinatorClient({
           baseUrl: this.coordinatorUrl,
           jwtToken,
-          // Safe: validated above
           model: this.model
         });
-        const iceServers = yield this.coordinatorClient.getIceServers();
-        this.machineClient = new GPUMachineClient({ iceServers });
-        this.setupMachineClientHandlers();
-        const sdpOffer = yield this.machineClient.createOffer({
-          send: this.send,
-          receive: this.receive
-        });
         const tSession = performance.now();
-        const sessionId = yield this.coordinatorClient.createSession(sdpOffer);
+        const initialResponse = yield this.coordinatorClient.createSession();
         const sessionCreationMs = performance.now() - tSession;
-        this.setSessionId(sessionId);
-        const tSdp = performance.now();
-        const { sdpAnswer, sdpPollingAttempts } = yield this.coordinatorClient.connect(
-          sessionId,
-          void 0,
-          options == null ? void 0 : options.maxAttempts
+        this.setSessionId(initialResponse.session_id);
+        console.debug(
+          "[Reactor] Session created:",
+          initialResponse.session_id,
+          "state:",
+          initialResponse.state
+        );
+        this.setStatus("waiting");
+        const tPoll = performance.now();
+        const sessionResponse = yield this.coordinatorClient.pollSessionReady();
+        const sessionPollingMs = performance.now() - tPoll;
+        this.sessionResponse = sessionResponse;
+        this.capabilities = sessionResponse.capabilities;
+        this.tracks = sessionResponse.capabilities.tracks;
+        this.emit("capabilitiesReceived", this.capabilities);
+        console.debug(
+          "[Reactor] Session ready, transport:",
+          sessionResponse.selected_transport.protocol,
+          "tracks:",
+          this.tracks.length
         );
-        const sdpPollingMs = performance.now() - tSdp;
+        const protocol = sessionResponse.selected_transport.protocol;
+        if (protocol !== "webrtc") {
+          throw new Error(`Unsupported transport protocol: ${protocol}`);
+        }
+        this.transportClient = new WebRTCTransportClient({
+          baseUrl: this.coordinatorUrl,
+          sessionId: sessionResponse.session_id,
+          jwtToken: this.local ? "local" : jwtToken,
+          webrtcVersion: (_a = sessionResponse.selected_transport.version) != null ? _a : REACTOR_WEBRTC_VERSION,
+          maxPollAttempts: options == null ? void 0 : options.maxAttempts
+        });
+        this.setupTransportHandlers();
+        const tTransport = performance.now();
+        yield this.transportClient.connect(this.tracks);
+        const transportConnectingMs = performance.now() - tTransport;
         this.connectionTimings = {
-          sessionCreationMs,
-          sdpPollingMs,
-          sdpPollingAttempts,
-          iceNegotiationMs: 0,
-          dataChannelMs: 0,
+          sessionCreationMs: sessionCreationMs + sessionPollingMs,
+          transportConnectingMs,
           totalMs: 0
         };
-        yield this.machineClient.connect(sdpAnswer);
       } catch (error) {
         if (isAbortError(error)) return;
         console.error("[Reactor] Connection failed:", error);
@@ -1545,18 +1608,14 @@ var Reactor = class {
     });
   }
   /**
-   * Sets up event handlers for the machine client.
-   *
-   * Each handler captures the client reference at registration time and
-   * ignores events if this.machineClient has since changed (e.g. after
-   * disconnect + reconnect), preventing stale WebRTC teardown events from
-   * interfering with a new connection.
+   * Sets up event handlers for the transport client.
+   * Each handler captures the client reference to ignore stale events.
    */
-  setupMachineClientHandlers() {
-    if (!this.machineClient) return;
-    const client = this.machineClient;
+  setupTransportHandlers() {
+    if (!this.transportClient) return;
+    const client = this.transportClient;
     client.on("message", (message, scope) => {
-      if (this.machineClient !== client) return;
+      if (this.transportClient !== client) return;
       if (scope === "application") {
         this.emit("message", message);
       } else if (scope === "runtime") {
@@ -1564,10 +1623,10 @@ var Reactor = class {
       }
     });
     client.on("statusChanged", (status) => {
-      if (this.machineClient !== client) return;
+      if (this.transportClient !== client) return;
       switch (status) {
         case "connected":
-          this.finalizeConnectionTimings(client);
+          this.finalizeConnectionTimings();
           this.setStatus("ready");
           break;
         case "disconnected":
@@ -1576,7 +1635,7 @@ var Reactor = class {
         case "error":
           this.createError(
             "GPU_CONNECTION_ERROR",
-            "GPU machine connection failed",
+            "Transport connection failed",
             "gpu",
             true
           );
@@ -1587,29 +1646,29 @@ var Reactor = class {
     client.on(
       "trackReceived",
       (name, track, stream) => {
-        if (this.machineClient !== client) return;
+        if (this.transportClient !== client) return;
         this.emit("trackReceived", name, track, stream);
       }
     );
     client.on("statsUpdate", (stats) => {
-      if (this.machineClient !== client) return;
+      if (this.transportClient !== client) return;
       this.emit("statsUpdate", __spreadProps(__spreadValues({}, stats), {
         connectionTimings: this.connectionTimings
       }));
     });
   }
   /**
-   * Disconnects from the coordinator and the gpu machine.
-   * Ensures cleanup completes even if individual disconnections fail.
+   * Disconnects from both the transport and the coordinator.
    */
   disconnect(recoverable = false) {
     return __async(this, null, function* () {
-      var _a;
+      var _a, _b;
       if (this.status === "disconnected" && !this.sessionId) {
         console.warn("[Reactor] Already disconnected");
         return;
       }
       (_a = this.coordinatorClient) == null ? void 0 : _a.abort();
+      (_b = this.transportClient) == null ? void 0 : _b.abort();
       if (this.coordinatorClient && !recoverable) {
         try {
           yield this.coordinatorClient.terminateSession();
@@ -1618,14 +1677,14 @@ var Reactor = class {
         }
         this.coordinatorClient = void 0;
       }
-      if (this.machineClient) {
+      if (this.transportClient) {
         try {
-          yield this.machineClient.disconnect();
+          yield this.transportClient.disconnect();
         } catch (error) {
-          console.error("[Reactor] Error disconnecting from GPU machine:", error);
+          console.error("[Reactor] Error disconnecting transport:", error);
         }
         if (!recoverable) {
-          this.machineClient = void 0;
+          this.transportClient = void 0;
         }
       }
       this.setStatus("disconnected");
@@ -1633,9 +1692,45 @@ var Reactor = class {
       if (!recoverable) {
         this.setSessionExpiration(void 0);
         this.setSessionId(void 0);
+        this.capabilities = void 0;
+        this.tracks = [];
+        this.sessionResponse = void 0;
       }
     });
   }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Getters
+  // ─────────────────────────────────────────────────────────────────────────
+  getSessionId() {
+    return this.sessionId;
+  }
+  getStatus() {
+    return this.status;
+  }
+  getState() {
+    return {
+      status: this.status,
+      lastError: this.lastError
+    };
+  }
+  getLastError() {
+    return this.lastError;
+  }
+  getCapabilities() {
+    return this.capabilities;
+  }
+  getSessionInfo() {
+    return this.sessionResponse;
+  }
+  getStats() {
+    var _a;
+    const stats = (_a = this.transportClient) == null ? void 0 : _a.getStats();
+    if (!stats) return void 0;
+    return __spreadProps(__spreadValues({}, stats), { connectionTimings: this.connectionTimings });
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Private State Management
+  // ─────────────────────────────────────────────────────────────────────────
   setSessionId(newSessionId) {
     console.debug(
       "[Reactor] Setting session ID:",
@@ -1648,9 +1743,6 @@ var Reactor = class {
       this.emit("sessionIdChanged", newSessionId);
     }
   }
-  getSessionId() {
-    return this.sessionId;
-  }
   setStatus(newStatus) {
     console.debug("[Reactor] Setting status:", newStatus, "from", this.status);
     if (this.status !== newStatus) {
@@ -1658,13 +1750,6 @@ var Reactor = class {
       this.emit("statusChanged", newStatus);
     }
   }
-  getStatus() {
-    return this.status;
-  }
-  /**
-   * Set the session expiration time.
-   * @param newSessionExpiration The new session expiration time in seconds.
-   */
   setSessionExpiration(newSessionExpiration) {
     console.debug(
       "[Reactor] Setting session expiration:",
@@ -1675,44 +1760,16 @@ var Reactor = class {
       this.emit("sessionExpirationChanged", newSessionExpiration);
     }
   }
-  /**
-   * Get the current state including status, error, and waiting info
-   */
-  getState() {
-    return {
-      status: this.status,
-      lastError: this.lastError
-    };
-  }
-  /**
-   * Get the last error that occurred
-   */
-  getLastError() {
-    return this.lastError;
-  }
-  getStats() {
-    var _a;
-    const stats = (_a = this.machineClient) == null ? void 0 : _a.getStats();
-    if (!stats) return void 0;
-    return __spreadProps(__spreadValues({}, stats), { connectionTimings: this.connectionTimings });
-  }
   resetConnectionTimings() {
     this.connectStartTime = void 0;
     this.connectionTimings = void 0;
   }
-  finalizeConnectionTimings(client) {
-    var _a, _b;
+  finalizeConnectionTimings() {
     if (!this.connectionTimings || this.connectStartTime == null) return;
-    const webrtcTimings = client.getConnectionTimings();
-    this.connectionTimings.iceNegotiationMs = (_a = webrtcTimings == null ? void 0 : webrtcTimings.iceNegotiationMs) != null ? _a : 0;
-    this.connectionTimings.dataChannelMs = (_b = webrtcTimings == null ? void 0 : webrtcTimings.dataChannelMs) != null ? _b : 0;
     this.connectionTimings.totalMs = performance.now() - this.connectStartTime;
     this.connectStartTime = void 0;
     console.debug("[Reactor] Connection timings:", this.connectionTimings);
   }
-  /**
-   * Create and store an error
-   */
   createError(code, message, component, recoverable, retryAfter) {
     this.lastError = {
       code,
@@ -1916,7 +1973,7 @@ function ReactorProvider(_a) {
     console.debug("[ReactorProvider] Reactor store created successfully");
   }
   const _a2 = connectOptions != null ? connectOptions : {}, { autoConnect = false } = _a2, pollingOptions = __objRest(_a2, ["autoConnect"]);
-  const { apiUrl, modelName, local, receive, send } = props;
+  const { apiUrl, modelName, local } = props;
   const maxAttempts = pollingOptions.maxAttempts;
   useEffect(() => {
     const handleBeforeUnload = () => {
@@ -1972,8 +2029,6 @@ function ReactorProvider(_a) {
         apiUrl,
         modelName,
         local,
-        receive,
-        send,
         jwtToken
       })
     );
@@ -2000,16 +2055,7 @@ function ReactorProvider(_a) {
         console.error("[ReactorProvider] Failed to disconnect:", error);
       });
     };
-  }, [
-    apiUrl,
-    modelName,
-    autoConnect,
-    local,
-    receive,
-    send,
-    jwtToken,
-    maxAttempts
-  ]);
+  }, [apiUrl, modelName, autoConnect, local, jwtToken, maxAttempts]);
   return /* @__PURE__ */ jsx(ReactorContext.Provider, { value: storeRef.current, children });
 }
 function useReactorStore(selector) {
@@ -2223,31 +2269,37 @@ function ReactorController({
     return () => clearInterval(interval);
   }, [status, commands, requestCapabilities]);
   useReactorInternalMessage((message) => {
+    var _a;
     if (message && typeof message === "object" && message.type === "modelCapabilities" && message.data && "commands" in message.data) {
       const commandsMessage = message.data;
-      setCommands(commandsMessage.commands);
+      const commandsRecord = {};
+      for (const cmd of commandsMessage.commands) {
+        commandsRecord[cmd.name] = {
+          description: cmd.description,
+          schema: (_a = cmd.schema) != null ? _a : {}
+        };
+      }
+      setCommands(commandsRecord);
       const initialValues = {};
       const initialExpanded = {};
-      Object.entries(commandsMessage.commands).forEach(
-        ([commandName, commandSchema]) => {
-          initialValues[commandName] = {};
-          initialExpanded[commandName] = false;
-          Object.entries(commandSchema.schema).forEach(
-            ([paramName, paramSchema]) => {
-              var _a, _b;
-              if (paramSchema.type === "number") {
-                initialValues[commandName][paramName] = (_a = paramSchema.minimum) != null ? _a : 0;
-              } else if (paramSchema.type === "string") {
-                initialValues[commandName][paramName] = "";
-              } else if (paramSchema.type === "boolean") {
-                initialValues[commandName][paramName] = false;
-              } else if (paramSchema.type === "integer") {
-                initialValues[commandName][paramName] = (_b = paramSchema.minimum) != null ? _b : 0;
-              }
+      Object.entries(commandsRecord).forEach(([commandName, commandSchema]) => {
+        initialValues[commandName] = {};
+        initialExpanded[commandName] = false;
+        Object.entries(commandSchema.schema).forEach(
+          ([paramName, paramSchema]) => {
+            var _a2, _b;
+            if (paramSchema.type === "number") {
+              initialValues[commandName][paramName] = (_a2 = paramSchema.minimum) != null ? _a2 : 0;
+            } else if (paramSchema.type === "string") {
+              initialValues[commandName][paramName] = "";
+            } else if (paramSchema.type === "boolean") {
+              initialValues[commandName][paramName] = false;
+            } else if (paramSchema.type === "integer") {
+              initialValues[commandName][paramName] = (_b = paramSchema.minimum) != null ? _b : 0;
             }
-          );
-        }
-      );
+          }
+        );
+      });
       setFormValues(initialValues);
       setExpandedCommands(initialExpanded);
     }
@@ -2838,7 +2890,7 @@ function fetchInsecureToken(_0) {
     const response = yield fetch(`${apiUrl}/tokens`, {
       method: "GET",
       headers: {
-        "X-API-Key": apiKey
+        "Reactor-API-Key": apiKey
       }
     });
     if (!response.ok) {
@@ -2857,15 +2909,14 @@ export {
   ReactorController,
   ReactorProvider,
   ReactorView,
+  WebRTCTransportClient,
   WebcamStream,
-  audio,
   fetchInsecureToken,
   isAbortError,
   useReactor,
   useReactorInternalMessage,
   useReactorMessage,
   useReactorStore,
-  useStats,
-  video
+  useStats
 };
 //# sourceMappingURL=index.mjs.map