@eyepop.ai/eyepop 3.25.3 → 3.25.4

package/dist/eyepop.index.mjs

@@ -8935,7 +8935,7 @@ var Endpoint = class {
     this._expire_token_time = null;
     this._client = null;
     this._statusRetryHandlers = /* @__PURE__ */ new Map();
-    this._statusRetryHandlers.set(401, this.statusHandler401);
+    this._statusRetryHandlers.set(401, (statusCode) => this.statusHandler401(statusCode));
     this._limit = new Semaphore(this._options.jobQueueLength ?? 1024);
     this._state = "Idle" /* Idle */;
     this._message = null;
@@ -8951,7 +8951,7 @@ var Endpoint = class {
   }
   setStatusRetryHandlers(statusRetryHandlers = void 0) {
     this._statusRetryHandlers = new Map(statusRetryHandlers);
-    this._statusRetryHandlers.set(401, this.statusHandler401);
+    this._statusRetryHandlers.set(401, (statusCode) => this.statusHandler401(statusCode));
   }
   eyepopUrl() {
     if (this._options.eyepopUrl) {
@@ -11497,6 +11497,8 @@ if (isBrowser) {
 var PIPELINE_PATH = "/api/v1/pipeline";
 var SUBPROTOCOL = "eyepop.v1";
 var MAX_OPEN_SOURCES = 256;
+var PIPELINE_SOCKETS = 4;
+var EXTRA_SOCKET_RETRY_MS = 10 * 1e3;
 var COMBINED_UPLOAD_MAX_BYTES = 8 * 1024 * 1024;
 var CHUNK = 1;
 var COMBINED = 2;
@@ -11616,6 +11618,8 @@ var PipelineSocket = class {
     // The ids of sources sent on this socket that have neither ended nor been refused, as the
     // pipeline API counts them, cancelled ones included.
     this.held = /* @__PURE__ */ new Set();
+    // The held sources that are live. A live source never ends, so nothing queued behind it plays.
+    this.lives = /* @__PURE__ */ new Set();
     // The held sources the pipeline API took: only these end, so only these make room.
     this.accepted = /* @__PURE__ */ new Set();
     // The ends on this socket so far.
@@ -11624,6 +11628,7 @@ var PipelineSocket = class {
     // the next send waits. Null once none is held.
     this.cap = null;
     this._roomWaiters = [];
+    this.heartbeat = null;
     this.closed = new Promise((resolve) => this._markClosed = resolve);
   }
   /** A source ended or the socket closed: wake the send waiting for room. */
@@ -11657,6 +11662,10 @@ var PipelineSocket = class {
     return !this._closed && this.ws.readyState === 1;
   }
   markClosed() {
+    if (this.heartbeat !== null) {
+      clearInterval(this.heartbeat);
+      this.heartbeat = null;
+    }
     this._closed = true;
     this._markClosed();
     this.freed();
@@ -11745,14 +11754,14 @@ var PipelineBackend = class {
   constructor(ctx) {
     this.ctx = ctx;
     this._pipelineApiUrl = null;
-    this._socket = null;
+    this._sockets = [];
     this._connecting = null;
     // Every job's setSource and every changePop goes out through this chain, in the order submitted.
     this._sendChain = Promise.resolve();
     this._disconnecting = false;
     this._nextId = 0;
     this._warned = /* @__PURE__ */ new Set();
-    this._heartbeat = null;
+    this._noExtraSocketUntil = 0;
     // Reconnects at once since a source last played.
     this._reconnects = 0;
     this._currentPop = ctx.options.pop ?? null;
@@ -11766,13 +11775,9 @@ var PipelineBackend = class {
   async disconnect(closeEndpoint) {
     await closeEndpoint();
     this._disconnecting = true;
-    if (this._heartbeat !== null) {
-      clearInterval(this._heartbeat);
-      this._heartbeat = null;
-    }
-    const socket = this._socket;
-    this._socket = null;
-    if (socket !== null) {
+    const sockets = this._sockets;
+    this._sockets = [];
+    for (const socket of sockets) {
       socket.ws.close(1e3);
       await socket.closed;
     }
@@ -11790,21 +11795,55 @@ var PipelineBackend = class {
     this._sendChain = result.catch(() => void 0);
     return result;
   }
-  /** The open socket, or a new one with the last pop set on it. */
+  openSockets() {
+    return this._sockets.filter((socket) => socket.open);
+  }
+  /** An open socket, or a new one with the last pop set on it. */
   async ensureSocket() {
-    if (this._socket !== null && this._socket.open) {
-      return this._socket;
+    const open = this.openSockets()[0];
+    if (open !== void 0) {
+      return open;
     }
     if (this._connecting === null) {
-      this._connecting = this.openSocket().finally(() => this._connecting = null);
+      this._connecting = this.openSocket(true).finally(() => this._connecting = null);
     }
     return await this._connecting;
   }
-  async openSocket() {
+  /**
+   * The socket for the next job; the caller runs it in submission order. A live job goes on a socket
+   * of its own, an idle one or a new one, which `pipelineSockets` does not count. Any other job skips
+   * the sockets with a live source: a new one while every other socket has a source and fewer than
+   * `pipelineSockets` are open, else the one with room and the fewest sources.
+   */
+  async socketForJob(job) {
+    if (job.live) {
+      return this.openSockets().find((socket) => socket.held.size === 0) ?? await this.openSocket(true);
+    }
+    const sockets = this.openSockets().filter((socket) => socket.lives.size === 0);
+    if (sockets.length === 0) {
+      return await this.openSocket(true);
+    }
+    if (sockets.length < (this.ctx.options.pipelineSockets ?? PIPELINE_SOCKETS) && sockets.every((socket) => socket.held.size > 0) && Date.now() >= this._noExtraSocketUntil) {
+      try {
+        return await this.openSocket(false);
+      } catch (error) {
+        this._noExtraSocketUntil = Date.now() + EXTRA_SOCKET_RETRY_MS;
+        this.ctx.requestLogger.info("could not open another pipeline API socket: %s", error);
+      }
+    }
+    const rank = (socket) => (socket.hasRoom ? 0 : MAX_OPEN_SOURCES + 1) + socket.held.size;
+    return sockets.reduce((best, socket) => rank(socket) < rank(best) ? socket : best);
+  }
+  /** A new socket with the last pop set on it; `patient` waits through 503 with Retry-After. */
+  async openSocket(patient) {
     if (this.ctx.client() === null) {
       throw new PipelineSocketClosedError(void 0, "the endpoint is not connected");
     }
-    const ws = await this.upgrade(await this.socketUrl());
+    const ws = await this.upgrade(await this.socketUrl(), patient);
+    if (this._disconnecting) {
+      ws.close(1e3);
+      throw new PipelineSocketClosedError(void 0, "the endpoint disconnected");
+    }
     const socket = new PipelineSocket(ws);
     ws.onmessage = (event) => {
       if (typeof event.data === "string") {
@@ -11818,31 +11857,29 @@ var PipelineBackend = class {
     ws.onerror = () => {
     };
     ws.onclose = (event) => this.closed(socket, event.code, event.reason);
-    this._socket = socket;
-    this.startHeartbeat(ws);
+    this._sockets.push(socket);
+    this.startHeartbeat(socket);
     if (this._currentPop !== null) {
       try {
         await this.setPopOn(socket, this._currentPop);
       } catch (error) {
-        this._socket = null;
+        this._sockets = this._sockets.filter((other) => other !== socket);
         ws.close(1e3);
         throw error;
       }
     }
     return socket;
   }
-  startHeartbeat(ws) {
-    if (this._heartbeat !== null) {
-      clearInterval(this._heartbeat);
-    }
+  startHeartbeat(socket) {
+    const ws = socket.ws;
     const ping = ws.ping;
     if (typeof ping === "function") {
-      this._heartbeat = setInterval(() => {
+      socket.heartbeat = setInterval(() => {
         if (ws.readyState === 1) {
           ping.call(ws);
         }
       }, HEARTBEAT_MS);
-      this._heartbeat.unref?.();
+      socket.heartbeat.unref?.();
     }
   }
   async socketUrl() {
@@ -11880,7 +11917,7 @@ var PipelineBackend = class {
     return (await this.ctx.credentialHeader()).replace(/^Bearer /, "");
   }
   /** Open the socket, waiting through 503 with Retry-After and exchanging the API key again after a 401. */
-  async upgrade(url) {
+  async upgrade(url, patient) {
     const deadline = Date.now() + MAX_RETRY_MS;
     let rejected = false;
     while (true) {
@@ -11898,7 +11935,7 @@ var PipelineBackend = class {
           continue;
         }
         const wait = error.status === 503 && error.retryAfter !== void 0 ? Math.max(error.retryAfter, 1) * 1e3 : void 0;
-        if (wait === void 0 || Date.now() + wait > deadline) {
+        if (!patient || wait === void 0 || Date.now() + wait > deadline) {
           throw error;
         }
         this.ctx.requestLogger.info("the pipeline API answered 503, retrying in %d ms", wait);
@@ -11908,9 +11945,7 @@ var PipelineBackend = class {
   }
   closed(socket, code, reason) {
     socket.markClosed();
-    if (this._socket === socket) {
-      this._socket = null;
-    }
+    this._sockets = this._sockets.filter((other) => other !== socket);
     const error = new PipelineSocketClosedError(code, reason);
     socket.sources.forEach((source) => source.close(error));
     socket.commands.forEach((command) => command.reject(error));
@@ -11936,12 +11971,14 @@ var PipelineBackend = class {
     const source = typeof id === "string" ? socket.sources.get(id) : void 0;
     if (type === "end") {
       socket.held.delete(id);
+      socket.lives.delete(id);
       socket.accepted.delete(id);
       socket.freed();
     } else if (type === "result" && socket.held.has(id)) {
       socket.accepted.add(id);
     } else if (type === "error" && message["error"] !== "unknown_command") {
       socket.held.delete(id);
+      socket.lives.delete(id);
       socket.wake();
     }
     if (type === "send" || type === "credit") {
@@ -11983,6 +12020,10 @@ var PipelineBackend = class {
   command(socket, message) {
     const id = this.newId(message["type"]);
     return new Promise((resolve, reject) => {
+      if (!socket.open) {
+        reject(new PipelineSocketClosedError(void 0, "the socket closed"));
+        return;
+      }
       socket.commands.set(id, { resolve, reject });
       socket.sendJson({ ...message, id });
     });
@@ -11991,15 +12032,28 @@ var PipelineBackend = class {
   pop() {
     return this._currentPop;
   }
-  /** Set the pop on the socket's pipeline; a pop it refuses rejects, and the last pop it took stays. */
+  /**
+   * Set the pop on every open socket's pipeline; a pop the first refuses rejects, and the last pop it
+   * took stays. shortcut: a refusal from a later socket, which the first took, leaves the earlier ones
+   * on the new pop; a refusal is the pop's own fault, so every socket answers it alike.
+   */
   async changePop(pop) {
     if (this.ctx.client() === null) {
       this._currentPop = pop;
       return;
     }
     await this.inOrder(async () => {
-      if (this._socket !== null && this._socket.open) {
-        await this.setPopOn(this._socket, pop);
+      const sockets = this.openSockets();
+      if (sockets.length > 0) {
+        for (const socket of sockets) {
+          try {
+            await this.setPopOn(socket, pop);
+          } catch (error) {
+            if (!(error instanceof PipelineSocketClosedError)) {
+              throw error;
+            }
+          }
+        }
         this._currentPop = pop;
         return;
       }
@@ -12160,22 +12214,30 @@ var PipelineBackend = class {
   }
   /** Send the job's setSource; the caller runs it in submission order. */
   async setSource(job) {
-    if (job.cancelled) {
-      return null;
-    }
-    let socket = await this.ensureSocket();
-    await socket.room(job);
     if (job.cancelled) {
       return null;
     }
     const combined = await combinedMedia(job);
-    socket = await this.ensureSocket();
+    let socket;
+    while (true) {
+      socket = await this.socketForJob(job);
+      await socket.room(job);
+      if (job.cancelled) {
+        return null;
+      }
+      if (socket.open) {
+        break;
+      }
+    }
     const source = new OpenSource(this.newId("source"));
     if (combined === null) {
       uploadKeys(job).forEach((key) => source.uploads.set(key, new Credit()));
     }
     socket.sources.set(source.id, source);
     socket.held.add(source.id);
+    if (job.live) {
+      socket.lives.add(source.id);
+    }
     source.endedBefore = socket.ended;
     job.openSource = source;
     job.stopOnPipeline = () => {
@@ -12451,6 +12513,9 @@ var WorkerEndpoint = class extends Endpoint {
       if (options.jobQueueLength > MAX_OPEN_SOURCES) {
         throw new PipelineConfigurationError("job_queue_length", `jobQueueLength ${options.jobQueueLength} exceeds ${MAX_OPEN_SOURCES}, the open sources a pipeline API socket takes`);
       }
+      if (options.pipelineSockets !== void 0 && !(Number.isInteger(options.pipelineSockets) && options.pipelineSockets > 0)) {
+        throw new PipelineConfigurationError("pipeline_sockets", `pipelineSockets ${options.pipelineSockets} is not a positive whole number`);
+      }
     }
     super(options);
     const context = {
@@ -14425,6 +14490,7 @@ export {
   ModelType,
   MotionModel,
   PIPELINE_PATH,
+  PIPELINE_SOCKETS,
   PipelineBackend,
   PipelineCommandError,
   PipelineConfigurationError,