@eyepop.ai/eyepop 3.25.2 → 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) {
@@ -9214,7 +9214,7 @@ var PredictionVersion = /* @__PURE__ */ ((PredictionVersion3) => {
   PredictionVersion3[PredictionVersion3["V3"] = 3] = "V3";
   return PredictionVersion3;
 })(PredictionVersion || {});
-var DEFAULT_PREDICTION_VERSION = 2 /* V2 */;
+var DEFAULT_PREDICTION_VERSION = 3 /* V3 */;
 var VideoMode = /* @__PURE__ */ ((VideoMode2) => {
   VideoMode2["STREAM"] = "stream";
   VideoMode2["BUFFER"] = "buffer";
@@ -10925,14 +10925,6 @@ var _SessionBackend = class _SessionBackend {
     }
     return this.ctx.options.pop || null;
   }
-  /**
-   * A select forward's results come only at V3. Only a Pop that selects asks
-   * for it, so a worker too old to know V3 - which also rejects that Pop - is
-   * never sent a version it would not accept.
-   */
-  predictionVersion() {
-    return popSelects(this.pop()) ? 3 /* V3 */ : DEFAULT_PREDICTION_VERSION;
-  }
   async changePop(pop) {
     if (this.ctx.options.popId == "transient" /* Transient */) {
       await this.changeTransientPop(pop);
@@ -11033,7 +11025,7 @@ var _SessionBackend = class _SessionBackend {
           return { stream: streamSource.stream, mimeType: streamSource.mimeType };
         })
       );
-      return this.start(new UploadGroupJob(sources, params, async () => this.session(), client, this.ctx.requestLogger, this.predictionVersion()));
+      return this.start(new UploadGroupJob(sources, params, async () => this.session(), client, this.ctx.requestLogger, DEFAULT_PREDICTION_VERSION));
     } catch (e) {
       limit.release();
       throw e;
@@ -11052,7 +11044,7 @@ var _SessionBackend = class _SessionBackend {
         stream,
         mimeType: mimeTypes?.[i] ?? null
       }));
-      return this.start(new UploadGroupJob(sources, params, async () => this.session(), client, this.ctx.requestLogger, this.predictionVersion()));
+      return this.start(new UploadGroupJob(sources, params, async () => this.session(), client, this.ctx.requestLogger, DEFAULT_PREDICTION_VERSION));
     } catch (e) {
       limit.release();
       throw e;
@@ -11067,7 +11059,7 @@ var _SessionBackend = class _SessionBackend {
     await limit.acquire();
     try {
       this.ctx.updateState();
-      return this.start(new LoadFromGroupJob(urls, params, async () => this.session(), client, this.ctx.requestLogger, this.predictionVersion()));
+      return this.start(new LoadFromGroupJob(urls, params, async () => this.session(), client, this.ctx.requestLogger, DEFAULT_PREDICTION_VERSION));
     } catch (e) {
       limit.release();
       throw e;
@@ -11111,14 +11103,14 @@ var _SessionBackend = class _SessionBackend {
         client,
         this.ctx.requestLogger,
         void 0,
-        this.predictionVersion()
+        DEFAULT_PREDICTION_VERSION
       ),
       true
     );
   }
   async uploadStream(source, params) {
     return await this.startConnected(
-      async (client) => new UploadJob(source.stream, source.mimeType, source.size, source.videoMode, params, async () => this.session(), client, this.ctx.requestLogger, void 0, this.predictionVersion()),
+      async (client) => new UploadJob(source.stream, source.mimeType, source.size, source.videoMode, params, async () => this.session(), client, this.ctx.requestLogger, void 0, DEFAULT_PREDICTION_VERSION),
       true
     );
   }
@@ -11143,7 +11135,7 @@ var _SessionBackend = class _SessionBackend {
         client,
         this.ctx.requestLogger,
         uploadBodyFactory,
-        this.predictionVersion()
+        DEFAULT_PREDICTION_VERSION
       );
     });
   }
@@ -11151,13 +11143,13 @@ var _SessionBackend = class _SessionBackend {
     if (source.url.startsWith("file://")) {
       return await this.uploadPath({ path: source.url.substring("file://".length) }, params);
     }
-    return await this.startConnected(async (client) => new LoadFromJob(source.url, params, async () => this.session(), client, this.ctx.requestLogger, this.predictionVersion()));
+    return await this.startConnected(async (client) => new LoadFromJob(source.url, params, async () => this.session(), client, this.ctx.requestLogger, DEFAULT_PREDICTION_VERSION));
   }
   async loadFromAssetUuid(source, params) {
-    return await this.startConnected(async (client) => new LoadFromAssetUuidJob(source.assetUuid, params, async () => this.session(), client, this.ctx.requestLogger, this.predictionVersion()));
+    return await this.startConnected(async (client) => new LoadFromAssetUuidJob(source.assetUuid, params, async () => this.session(), client, this.ctx.requestLogger, DEFAULT_PREDICTION_VERSION));
   }
   async loadMediaStream(source, params) {
-    return await this.startConnected(async (client) => new LoadMediaStreamJob(source.mediaStream, params, async () => this.session(), client, this.ctx.requestLogger, this.predictionVersion()));
+    return await this.startConnected(async (client) => new LoadMediaStreamJob(source.mediaStream, params, async () => this.session(), client, this.ctx.requestLogger, DEFAULT_PREDICTION_VERSION));
   }
   async reconnect() {
     if (this.ctx.options.popId == "transient" /* Transient */) {
@@ -11505,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;
@@ -11607,6 +11601,8 @@ var OpenSource = class {
     this.id = id;
     this.inbox = new Inbox();
     this.uploads = /* @__PURE__ */ new Map();
+    // The socket's ended count when the setSource went out.
+    this.endedBefore = 0;
   }
   close(error) {
     this.uploads.forEach((upload) => upload.end());
@@ -11619,14 +11615,60 @@ var PipelineSocket = class {
     this.sources = /* @__PURE__ */ new Map();
     this.commands = /* @__PURE__ */ new Map();
     this._closed = false;
+    // 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.
+    this.ended = 0;
+    // How many sources the socket had taken when it last refused queue_full: while as many are held,
+    // 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. */
+  freed() {
+    this.ended += 1;
+    this.wake();
+  }
+  /** A held source ended or was refused: wake the send waiting for room. */
+  wake() {
+    if (this.held.size === 0) {
+      this.cap = null;
+    }
+    const waiters = this._roomWaiters;
+    this._roomWaiters = [];
+    waiters.forEach((wake) => wake());
+  }
+  get hasRoom() {
+    return this.cap === null || this.held.size < this.cap;
+  }
+  /**
+   * Wait, while the socket is full, until a source ends, it closes or the job is cancelled. The
+   * caller sends in order, so one send waits here and each end lets one go, instead of every
+   * refused source sending its media again at once.
+   */
+  async room(job) {
+    while (!this.hasRoom && this.open && !job.cancelled) {
+      await Promise.race([new Promise((resolve) => this._roomWaiters.push(resolve)), job.whenCancelled]);
+    }
+  }
   get open() {
     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();
   }
   sendJson(message) {
     this.ws.send(JSON.stringify(message));
@@ -11645,6 +11687,8 @@ var PipelineJob = class {
     this._results = new Inbox();
     this._consumed = false;
     this._cancelled = false;
+    // Settles when the job is cancelled, so that a send waiting for room ends at once.
+    this.whenCancelled = new Promise((resolve) => this._markCancelled = resolve);
     this.openSource = null;
     // Stops the job's source on the pipeline, once it was sent.
     this.stopOnPipeline = null;
@@ -11684,6 +11728,7 @@ var PipelineJob = class {
       return;
     }
     this._cancelled = true;
+    this._markCancelled();
     this._results.push(null);
     this.openSource?.inbox.push(CANCELLED);
     this.stopOnPipeline?.();
@@ -11709,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;
@@ -11730,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;
     }
@@ -11754,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") {
@@ -11782,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() {
@@ -11844,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) {
@@ -11862,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);
@@ -11872,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));
@@ -11898,6 +11969,18 @@ var PipelineBackend = class {
     const type = message["type"];
     const id = message["id"];
     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") {
       const upload = source?.uploads.get(message["member"] ?? null);
       upload?.grant(Number(type === "send" ? message["credit"] : message["bytes"]));
@@ -11937,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 });
     });
@@ -11945,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;
       }
@@ -12056,7 +12156,12 @@ var PipelineBackend = class {
       }
     };
   }
-  /** Run the job's source to its end; a live source refused overloaded goes once more on a new socket. */
+  /**
+   * Run the job's source to its end. A live source refused overloaded goes once more on a new socket.
+   * A source refused queue_full goes again once another source on the socket ended, so it may go after
+   * jobs submitted later; with none of the endpoint's other sources open there, or with an upload from
+   * the caller's own stream, which cannot be read twice, the refusal stands.
+   */
   async run(job) {
     let retried = false;
     while (true) {
@@ -12067,9 +12172,9 @@ var PipelineBackend = class {
       const { socket, source } = sent;
       const uploading = source.uploads.size > 0 ? this.upload(socket, source, job) : Promise.resolve();
       let whip = null;
-      let overloaded;
+      let refused;
       try {
-        overloaded = await this.follow(job, source, () => {
+        refused = await this.follow(job, source, () => {
           if (job.mediaStream !== void 0) {
             const fail = (error) => {
               job.stopOnPipeline?.();
@@ -12087,9 +12192,19 @@ var PipelineBackend = class {
         await uploading;
         await whip?.close();
       }
-      if (!overloaded) {
+      if (refused === null) {
         return;
       }
+      if (refused === "queue_full") {
+        if (socket.accepted.size === 0 && socket.ended === source.endedBefore) {
+          throw new PipelineCommandError("queue_full", "the socket refused the source with none of its own open");
+        }
+        if (job.media.some((media) => media.once)) {
+          throw new PipelineCommandError("queue_full", "the socket refused an upload from a stream, which cannot be sent again");
+        }
+        socket.cap = Math.min(socket.accepted.size, socket.cap ?? socket.accepted.size) || null;
+        continue;
+      }
       if (retried || !job.live) {
         throw new PipelineCommandError("overloaded", "the pipeline API has no capacity for another live source");
       }
@@ -12103,12 +12218,27 @@ var PipelineBackend = class {
       return null;
     }
     const combined = await combinedMedia(job);
-    const 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 = () => {
       if (socket.open) {
@@ -12123,15 +12253,15 @@ var PipelineBackend = class {
     }
     return { socket, source };
   }
-  /** Hand the source's predictions to the job until it ends; true when the pipeline API was overloaded. */
+  /** Hand the source's predictions to the job until it ends; the refusal to retry on, overloaded or queue_full. */
   async follow(job, source, onResult) {
     while (true) {
       if (job.cancelled) {
-        return false;
+        return null;
       }
       const message = await source.inbox.next();
       if (message === CANCELLED) {
-        return false;
+        return null;
       }
       if (message instanceof Error) {
         throw message;
@@ -12145,12 +12275,12 @@ var PipelineBackend = class {
           break;
         case "end":
           if (message["reason"] === "eos") {
-            return false;
+            return null;
           }
           throw new PipelineSourceError(source.id, message["reason"] ?? "", message["message"] ?? "");
         case "error":
-          if (message["error"] === "overloaded") {
-            return true;
+          if (message["error"] === "overloaded" || message["error"] === "queue_full") {
+            return message["error"];
           }
           throw new PipelineCommandError(message["error"] ?? "", message["message"] ?? "");
         case "dropped":
@@ -12294,7 +12424,8 @@ function knownSize(body) {
   return void 0;
 }
 function bodyMedia(body, contentType, size) {
-  return { open: async () => body, contentType, size: size ?? knownSize(body) };
+  const once = !(typeof Blob !== "undefined" && body instanceof Blob) && !(body instanceof ArrayBuffer) && !ArrayBuffer.isView(body);
+  return { open: async () => body, contentType, size: size ?? knownSize(body), once };
 }
 function uploadGroup(media) {
   return { group: media.map((m) => ({ upload: { contentType: m.contentType } })) };
@@ -12382,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 = {
@@ -14356,6 +14490,7 @@ export {
   ModelType,
   MotionModel,
   PIPELINE_PATH,
+  PIPELINE_SOCKETS,
   PipelineBackend,
   PipelineCommandError,
   PipelineConfigurationError,