@eyepop.ai/eyepop 3.22.0 → 3.25.0

package/dist/eyepop.index.mjs

@@ -8666,6 +8666,667 @@ function accessTokenCredential(auth) {
   return nonEmptyCredential(auth.accessToken);
 }
 
+// types.ts
+var EndpointState = /* @__PURE__ */ ((EndpointState2) => {
+  EndpointState2["Idle"] = "Idle";
+  EndpointState2["Busy"] = "Busy";
+  EndpointState2["Authenticating"] = "Authenticating";
+  EndpointState2["FetchConfig"] = "FetchConfig";
+  EndpointState2["Error"] = "Error";
+  EndpointState2["NotAvailable"] = "NotAvailable";
+  return EndpointState2;
+})(EndpointState || {});
+
+// shims/http_client.ts
+var createHttpClient;
+function logLineFromRequest(input, init) {
+  const url = input instanceof Request ? input.url : input;
+  const method = input instanceof Request ? input.method : init?.method || (init?.body !== void 0 ? "POST" : "GET");
+  return `${method} ${url}`;
+}
+if ("document" in globalThis && "implementation" in globalThis.document) {
+  class BrowserHttpClient {
+    constructor(logger) {
+      this._logger = logger;
+    }
+    async fetch(input, init) {
+      const logLine = logLineFromRequest(input, init);
+      this._logger.debug(`Browser fetch() BEFORE ${logLine}`);
+      const response = await fetch(input, init);
+      this._logger.debug(`AFTER ${logLine} -> ${response.status}`);
+      return response;
+    }
+    async close() {
+    }
+    isFullDuplex() {
+      return false;
+    }
+  }
+  createHttpClient = async (logger) => {
+    return new BrowserHttpClient(logger);
+  };
+} else {
+  class NodeHttpClient {
+    constructor(agent, fetchFn, logger) {
+      this._agent = agent;
+      this._fetch = fetchFn;
+      this._logger = logger;
+    }
+    async fetch(input, init) {
+      init || (init = {});
+      init.dispatcher = this._agent;
+      const logLine = logLineFromRequest(input, init);
+      this._logger.debug(`Node fetch() BEFORE ${logLine}`);
+      const response = await this._fetch(input, init);
+      this._logger.debug(`AFTER ${logLine} -> ${response.status}`);
+      return response;
+    }
+    async close() {
+      return this._agent.close();
+    }
+    isFullDuplex() {
+      return false;
+    }
+  }
+  createHttpClient = async (logger) => {
+    const undici = __require("undici");
+    const agent = new undici.Agent({
+      keepAliveTimeout: 1e4,
+      connections: 5,
+      // two parallel streaming requests to the same host seem to deadlock with pipelining > 0
+      pipelining: 0
+    });
+    logger.debug("Using node fetch with undici agent as http client");
+    return new NodeHttpClient(agent, undici.fetch, logger);
+  };
+}
+
+// semaphore.ts
+var Semaphore = class {
+  /**
+   * Creates a semaphore.
+   * @param permits  The number of permits, i.e. strands of execution being allowed
+   * to run in parallel.
+   * This number can be initialized with a negative integer.
+   */
+  constructor(permits) {
+    this.promiseResolverQueue = [];
+    this.permits = permits;
+  }
+  /**
+   * Returns the number of available permits.
+   * @returns  The number of available permits.
+   */
+  getPermits() {
+    return this.permits;
+  }
+  /**
+   * Returns a promise used to wait for a permit to become available. This method should be awaited on.
+   * @returns  A promise that gets resolved when execution is allowed to proceed.
+   */
+  async wait() {
+    if (this.permits > 0) {
+      this.permits -= 1;
+      return Promise.resolve(true);
+    }
+    return new Promise((resolver) => this.promiseResolverQueue.push(resolver));
+  }
+  /**
+   * Alias for {@linkcode Semaphore.wait}.
+   * @returns  A promise that gets resolved when execution is allowed to proceed.
+   */
+  async acquire() {
+    return this.wait();
+  }
+  /**
+   * Same as {@linkcode Semaphore.wait} except the promise returned gets resolved with false if no
+   * permit becomes available in time.
+   * @param milliseconds  The time spent waiting before the wait is aborted. This is a lower bound,
+   * you shouldn't rely on it being precise.
+   * @returns  A promise that gets resolved to true when execution is allowed to proceed or
+   * false if the time given elapses before a permit becomes available.
+   */
+  async waitFor(milliseconds) {
+    if (this.permits > 0) {
+      this.permits -= 1;
+      return Promise.resolve(true);
+    }
+    let resolver = (_) => void 0;
+    const promise = new Promise((r) => {
+      resolver = r;
+    });
+    this.promiseResolverQueue.push(resolver);
+    setTimeout(() => {
+      const index = this.promiseResolverQueue.indexOf(resolver);
+      if (index !== -1) {
+        this.promiseResolverQueue.splice(index, 1);
+      } else {
+        console.warn(`Semaphore.waitFor couldn't find its promise resolver in the queue`);
+      }
+      resolver(false);
+    }, milliseconds);
+    return promise;
+  }
+  /**
+   * Synchronous function that tries to acquire a permit and returns true if successful, false otherwise.
+   * @returns  Whether a permit could be acquired.
+   */
+  tryAcquire() {
+    if (this.permits > 0) {
+      this.permits -= 1;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Acquires all permits that are currently available and returns the number of acquired permits.
+   * @returns  Number of acquired permits.
+   */
+  drainPermits() {
+    if (this.permits > 0) {
+      const permitCount = this.permits;
+      this.permits = 0;
+      return permitCount;
+    }
+    return 0;
+  }
+  /**
+   * Increases the number of permits by one. If there are other functions waiting, one of them will
+   * continue to execute in a future iteration of the event loop.
+   */
+  signal() {
+    this.permits += 1;
+    if (this.permits > 1 && this.promiseResolverQueue.length > 0) {
+      console.warn("Semaphore.permits should never be > 0 when there is someone waiting.");
+    } else if (this.permits === 1 && this.promiseResolverQueue.length > 0) {
+      this.permits -= 1;
+      const nextResolver = this.promiseResolverQueue.shift();
+      if (nextResolver) {
+        nextResolver(true);
+      }
+    }
+  }
+  /**
+   * Alias for {@linkcode Semaphore.signal}.
+   */
+  release() {
+    this.signal();
+  }
+  /**
+   * Schedules func to be called once a permit becomes available.
+   * Returns a promise that resolves to the return value of func.
+   * @typeparam T  The return type of func.
+   * @param func  The function to be executed.
+   * @return  A promise that gets resolved with the return value of the function.
+   */
+  async execute(func) {
+    await this.wait();
+    try {
+      return await func();
+    } finally {
+      this.signal();
+    }
+  }
+};
+
+// endpoint.ts
+import { pino } from "pino";
+
+// shims/browser_session.ts
+import { createAuth0Client } from "@auth0/auth0-spa-js";
+var authenticateBrowserSession;
+if ("document" in globalThis && "implementation" in globalThis.document) {
+  authenticateBrowserSession = async (auth0, options) => {
+    if (options.eyepopUrl == null) {
+      return Promise.reject("options.eyepopUrl cannot be null");
+    }
+    const auth0ClientOptions = {
+      clientId: auth0.clientId,
+      domain: auth0.domain,
+      authorizationParams: {
+        scope: auth0.scope,
+        audience: auth0.audience
+      }
+    };
+    const auth0Client = await createAuth0Client(auth0ClientOptions);
+    if (!await auth0Client.isAuthenticated()) {
+      await auth0Client.loginWithPopup();
+    }
+    const accessToken = await auth0Client.getTokenSilently();
+    if (!accessToken) {
+      return Promise.reject("auth0 login failed");
+    }
+    let session;
+    const workerOptions = options;
+    if (typeof workerOptions.popId != "undefined") {
+      const workerSession = {
+        eyepopUrl: options.eyepopUrl,
+        accessToken,
+        validUntil: Date.now() + 60 * 60 * 1e3,
+        popId: workerOptions.popId,
+        baseUrl: void 0,
+        pipelineId: void 0,
+        isPipelineMode: workerOptions.isPipelineMode,
+        authenticationHeaders: () => {
+          return { Authorization: `Bearer ${accessToken}` };
+        }
+      };
+      session = workerSession;
+    } else {
+      session = {
+        eyepopUrl: options.eyepopUrl,
+        accessToken,
+        validUntil: Date.now() + 60 * 60 * 1e3
+      };
+    }
+    return session;
+  };
+} else {
+  authenticateBrowserSession = (_auth0, _options) => {
+    return Promise.reject("auth0 login not supported server-side");
+  };
+}
+
+// endpoint.ts
+var Endpoint = class {
+  constructor(options) {
+    this._options = options;
+    this._token = null;
+    this._expire_token_time = null;
+    this._client = null;
+    this._statusRetryHandlers = /* @__PURE__ */ new Map();
+    this._statusRetryHandlers.set(401, this.statusHandler401);
+    this._limit = new Semaphore(this._options.jobQueueLength ?? 1024);
+    this._state = "Idle" /* Idle */;
+    this._message = null;
+    this._stateChangeHandler = null;
+    let rootLogger;
+    if (options.logger) {
+      rootLogger = options.logger;
+    } else {
+      rootLogger = pino();
+    }
+    this._logger = rootLogger.child({ module: "eyepop" });
+    this._requestLogger = this._logger.child({ module: "requests" });
+  }
+  setStatusRetryHandlers(statusRetryHandlers = void 0) {
+    this._statusRetryHandlers = new Map(statusRetryHandlers);
+    this._statusRetryHandlers.set(401, this.statusHandler401);
+  }
+  eyepopUrl() {
+    if (this._options.eyepopUrl) {
+      return this._options.eyepopUrl.replace(/\/+$/, "");
+    } else {
+      return "https://compute.eyepop.ai";
+    }
+  }
+  // TODO: deprecated Web API endpoint needed for POP_ID support
+  eyepopWebApiUrl() {
+    if (this._options.eyepopUrl) {
+      return this._options.eyepopUrl.replace(/\/+$/, "").replace(/compute\./, "web-api.");
+    } else {
+      return "https://api.eyepop.ai";
+    }
+  }
+  pendingJobs() {
+    return (this._options.jobQueueLength ?? 1024) - this._limit.getPermits();
+  }
+  state() {
+    return this._state;
+  }
+  lastMessage() {
+    return this._message;
+  }
+  onStateChanged(handler) {
+    this._stateChangeHandler = handler;
+    return this;
+  }
+  updateState(newState = void 0, message = void 0) {
+    const fromState = this._state;
+    if (newState == void 0) {
+      if (this._limit.getPermits() == this._options.jobQueueLength) {
+        newState = "Idle" /* Idle */;
+      } else {
+        newState = "Busy" /* Busy */;
+      }
+    }
+    this._state = newState;
+    this._message = message ? message : null;
+    if (this._stateChangeHandler) {
+      this._stateChangeHandler(fromState, this._state);
+    }
+  }
+  async connect() {
+    if (this._client) {
+      this._logger.warn("endpoint already connected");
+      return this;
+    }
+    if (!this._options.eyepopUrl) {
+      return Promise.reject("option eyepopUrl or environment variable EYEPOP_URL is required");
+    }
+    const auth = resolveAuth(this._options);
+    if (auth === void 0) {
+      return Promise.reject("cannot connect without defined auth option");
+    }
+    if (auth.session !== void 0) {
+      this._token = auth.session.accessToken;
+      this._expire_token_time = auth.session.validUntil / 1e3;
+    } else if (auth.oAuth2 !== void 0) {
+    } else if (accessTokenCredential(auth) !== void 0) {
+    } else if (apiKeyCredential(auth) !== void 0) {
+    } else if (auth.isLocal !== void 0) {
+    } else {
+      return Promise.reject("option apiKey/accessToken or environment variable EYEPOP_API_KEY is required");
+    }
+    if (this._options.platformSupport?.createHttpClient !== void 0) {
+      this._client = await this._options.platformSupport.createHttpClient(this._requestLogger);
+    } else {
+      this._client = await createHttpClient(this._requestLogger);
+    }
+    return await this.reconnect();
+  }
+  async disconnect(wait = true) {
+    if (wait && this._limit) {
+      for (let j = 0; j < this._options.jobQueueLength; j++) {
+        await this._limit.acquire();
+      }
+    }
+    this._limit = new Semaphore(this._options.jobQueueLength ?? 1024);
+    if (this._client) {
+      await this._client.close();
+      this._client = null;
+    }
+  }
+  async session() {
+    await this.currentAccessToken();
+    if (this._token == null || this._expire_token_time == null) {
+      return Promise.reject("endpoint not connected");
+    }
+    return {
+      eyepopUrl: this._options.eyepopUrl,
+      accessToken: this._token,
+      validUntil: this._expire_token_time * 1e3
+    };
+  }
+  statusHandler401(_statusCode) {
+    this._token = null;
+    this._expire_token_time = null;
+  }
+  async fetchWithRetry(fetcher, retries = 1) {
+    while (true) {
+      try {
+        const response = await fetcher();
+        if (response.ok) {
+          return response;
+        } else {
+          const handler = this._statusRetryHandlers.get(response.status);
+          if (handler != null) {
+            handler(response.status);
+            if (retries--) {
+              this._requestLogger.info("received %d response, retry", response.status);
+            } else {
+              return response;
+            }
+          } else {
+            return response;
+          }
+        }
+      } catch (error) {
+        const handler = this._statusRetryHandlers.get(404);
+        if (handler != null) {
+          handler(error);
+          if (retries--) {
+            this._requestLogger.info("error %s, retry", error);
+          } else {
+            return Promise.reject(`error ${error}`);
+          }
+        } else {
+          return Promise.reject(`error ${error}`);
+        }
+      }
+    }
+  }
+  async reconnect() {
+    throw new Error("reconnect() not implemented");
+  }
+  async authorizationHeader() {
+    if (resolveAuth(this._options)?.isLocal !== void 0) {
+      return `Implicit`;
+    }
+    return `Bearer ${await this.currentAccessToken()}`;
+  }
+  async currentAccessToken() {
+    const now = Date.now() / 1e3;
+    if (!this._token || this._expire_token_time < now) {
+      this.updateState("Authenticating" /* Authenticating */);
+      try {
+        const auth = resolveAuth(this._options);
+        if (!this._client) {
+          return Promise.reject("endpoint not connected");
+        } else if (auth?.isLocal !== void 0) {
+          this._token = "implicit";
+          this._expire_token_time = Number.MAX_VALUE;
+        } else if (auth?.session !== void 0) {
+          return Promise.reject("temporary access token expired");
+        } else if (auth?.oAuth2 !== void 0 && this._options.eyepopUrl) {
+          const session = await authenticateBrowserSession(auth.oAuth2, this._options);
+          this._token = session.accessToken;
+          this._expire_token_time = session.validUntil / 1e3;
+        } else if (accessTokenCredential(auth) !== void 0) {
+          this._token = accessTokenCredential(auth);
+          this._expire_token_time = Number.MAX_VALUE;
+        } else if (this._options.eyepopUrl) {
+          const credential = apiKeyCredential(auth);
+          if (credential === void 0) {
+            return Promise.reject("no valid auth option");
+          }
+          const headers = { Authorization: `Bearer ${credential}` };
+          const post_url = `${this.eyepopUrl()}/v1/auth/authenticate`;
+          const response = await this._client.fetch(post_url, {
+            method: "POST",
+            headers
+          });
+          if (response.status != 200) {
+            const message = await response.text();
+            return Promise.reject(`Unexpected status ${response.status}: ${message}`);
+          }
+          const data = await response.json();
+          const token = data;
+          this._token = token.access_token;
+          this._expire_token_time = now + token.expires_in - 60;
+        } else {
+          return Promise.reject("no valid auth option");
+        }
+      } finally {
+        this.updateState();
+      }
+    }
+    this._logger.debug("using access token, valid for at least %d seconds", this._expire_token_time - now);
+    return this._token;
+  }
+};
+
+// camera.ts
+var QUATERNION_TOLERANCE = 1e-3;
+function isFinite_(value) {
+  return value === void 0 || Number.isFinite(value);
+}
+function validateCamera(camera) {
+  if (camera.intrinsics !== void 0 && camera.hfovDegrees !== void 0) {
+    throw new Error("camera.intrinsics and camera.hfovDegrees are alternatives, supply one");
+  }
+  if (camera.intrinsics === void 0 && camera.hfovDegrees === void 0) {
+    throw new Error("camera requires either camera.intrinsics or camera.hfovDegrees");
+  }
+  if (camera.hfovDegrees !== void 0) {
+    if (!(camera.hfovDegrees > 0 && camera.hfovDegrees < 180)) {
+      throw new Error("camera.hfovDegrees must be a horizontal field of view in (0, 180) degrees");
+    }
+  } else {
+    const intrinsics = camera.intrinsics;
+    for (const [name, focal] of [
+      ["fx", intrinsics.fx],
+      ["fy", intrinsics.fy]
+    ]) {
+      if (!(focal > 0) || !Number.isFinite(focal)) {
+        throw new Error(`camera.intrinsics.${name} must be a positive, finite focal length`);
+      }
+    }
+    for (const [name, principal, extent] of [
+      ["cx", intrinsics.cx, "width"],
+      ["cy", intrinsics.cy, "height"]
+    ]) {
+      if (!(principal >= 0 && principal <= 1)) {
+        throw new Error(`camera.intrinsics.${name} must be within [0, 1] of the frame ${extent}`);
+      }
+    }
+  }
+  if (camera.distortion !== void 0) {
+    for (const name of ["k1", "k2", "p1", "p2", "k3"]) {
+      if (!isFinite_(camera.distortion[name])) {
+        throw new Error(`camera.distortion.${name} must be a finite number`);
+      }
+    }
+  }
+  if (camera.extrinsics !== void 0) {
+    const translation = camera.extrinsics.translation;
+    if (translation !== void 0) {
+      for (const axis of ["x", "y", "z"]) {
+        if (!Number.isFinite(translation[axis])) {
+          throw new Error(`camera.extrinsics.translation.${axis} must be a finite number`);
+        }
+      }
+    }
+    const rotation = camera.extrinsics.rotation;
+    if (rotation !== void 0) {
+      const norm = Math.sqrt(rotation.w ** 2 + rotation.x ** 2 + rotation.y ** 2 + rotation.z ** 2);
+      if (!(Math.abs(norm - 1) <= QUATERNION_TOLERANCE)) {
+        throw new Error("camera.extrinsics.rotation must be a unit quaternion");
+      }
+    }
+  }
+}
+
+// worker/worker_types.ts
+var PredictionVersion = /* @__PURE__ */ ((PredictionVersion3) => {
+  PredictionVersion3[PredictionVersion3["V1"] = 1] = "V1";
+  PredictionVersion3[PredictionVersion3["V2"] = 2] = "V2";
+  PredictionVersion3[PredictionVersion3["V3"] = 3] = "V3";
+  return PredictionVersion3;
+})(PredictionVersion || {});
+var DEFAULT_PREDICTION_VERSION = 2 /* V2 */;
+var VideoMode = /* @__PURE__ */ ((VideoMode2) => {
+  VideoMode2["STREAM"] = "stream";
+  VideoMode2["BUFFER"] = "buffer";
+  return VideoMode2;
+})(VideoMode || {});
+var PopComponentType = /* @__PURE__ */ ((PopComponentType2) => {
+  PopComponentType2["FORWARD"] = "forward";
+  PopComponentType2["INFERENCE"] = "inference";
+  PopComponentType2["TRACKING"] = "tracking";
+  PopComponentType2["CONTOUR_FINDER"] = "contour_finder";
+  PopComponentType2["COMPONENT_FINDER"] = "component_finder";
+  return PopComponentType2;
+})(PopComponentType || {});
+var ForwardOperatorType = /* @__PURE__ */ ((ForwardOperatorType2) => {
+  ForwardOperatorType2["FULL"] = "full";
+  ForwardOperatorType2["CROP"] = "crop";
+  ForwardOperatorType2["CROP_WITH_FULL_FALLBACK"] = "crop_with_full_fallback";
+  ForwardOperatorType2["SELECT_CROP"] = "select_crop";
+  ForwardOperatorType2["SELECT_FULL"] = "select_full";
+  return ForwardOperatorType2;
+})(ForwardOperatorType || {});
+var SelectMode = /* @__PURE__ */ ((SelectMode2) => {
+  SelectMode2["MOST_RELEVANT"] = "most_relevant";
+  return SelectMode2;
+})(SelectMode || {});
+function isSelectOperator(operator) {
+  return operator?.type === "select_crop" /* SELECT_CROP */ || operator?.type === "select_full" /* SELECT_FULL */;
+}
+var InferenceType = /* @__PURE__ */ ((InferenceType2) => {
+  InferenceType2["IMAGE_CLASSIFICATION"] = "image_classification";
+  InferenceType2["OBJECT_DETECTION"] = "object_detection";
+  InferenceType2["KEY_POINTS"] = "key_points";
+  InferenceType2["OCR"] = "ocr";
+  InferenceType2["MESH"] = "mesh";
+  InferenceType2["FEATURE_VECTOR"] = "feature_vector";
+  InferenceType2["SEMANTIC_SEGMENTATION"] = "semantic_segmentation";
+  InferenceType2["SEGMENTATION"] = "segmentation";
+  return InferenceType2;
+})(InferenceType || {});
+var MotionModel = /* @__PURE__ */ ((MotionModel2) => {
+  MotionModel2["RANDOM_WALK"] = "random_walk";
+  MotionModel2["CONSTANT_VELOCITY"] = "constant_velocity";
+  MotionModel2["CONSTANT_ACCELERATION"] = "constant_acceleration";
+  return MotionModel2;
+})(MotionModel || {});
+var ContourType = /* @__PURE__ */ ((ContourType2) => {
+  ContourType2["ALL_PIXELS"] = "all_pixels";
+  ContourType2["POLYGON"] = "polygon";
+  ContourType2["CONVEX_HULL"] = "convex_hull";
+  ContourType2["HOUGH_CIRCLES"] = "hough_circles";
+  ContourType2["CIRCLE"] = "circle";
+  ContourType2["TRIANGLE"] = "triangle";
+  ContourType2["RECTANGLE"] = "rectangle";
+  return ContourType2;
+})(ContourType || {});
+function validatePop(pop) {
+  if (pop.depthMap !== void 0) {
+    if (pop.depthMap.ability === void 0 === (pop.depthMap.abilityUuid === void 0)) {
+      throw new Error("depthMap requires exactly one of ability or abilityUuid");
+    }
+  }
+  if (pop.defaults?.camera !== void 0) {
+    validateCamera(pop.defaults.camera);
+  }
+  validateForwards(pop.components);
+}
+function popSelects(pop) {
+  const selects = (components) => (components ?? []).some((component) => isSelectOperator(component.forward?.operator) || selects(component.forward?.targets));
+  return selects(pop?.components);
+}
+function validateForwards(components) {
+  for (const component of components ?? []) {
+    const operator = component.forward?.operator;
+    if (operator !== void 0) {
+      validateSelectOperator(operator);
+    }
+    validateForwards(component.forward?.targets);
+  }
+}
+function validateSelectOperator(operator) {
+  if (!isSelectOperator(operator)) {
+    if (operator.select !== void 0) {
+      throw new Error("select is only valid with the select_crop or select_full operator");
+    }
+    return;
+  }
+  const select = operator.select;
+  if (select === void 0) {
+    throw new Error(`${operator.type} requires a select block`);
+  }
+  if (select.mode !== void 0 && select.mode !== "most_relevant" /* MOST_RELEVANT */) {
+    throw new Error(`select mode ${select.mode} is not supported, the only mode is ${"most_relevant" /* MOST_RELEVANT */}`);
+  }
+  if (select.relevancyModel !== void 0 && select.relevancyModelUuid !== void 0) {
+    throw new Error("select can only have one of relevancyModelUuid or relevancyModel");
+  }
+  if (select.minTrackLengthSeconds !== void 0 && select.minTrackLengthSeconds < 0) {
+    throw new Error("select minTrackLengthSeconds cannot be negative");
+  }
+  if (select.intervalSeconds !== void 0 && select.intervalSeconds <= 0) {
+    throw new Error("select intervalSeconds must be positive");
+  }
+  if (operator.crop !== void 0) {
+    if (operator.type !== "select_crop" /* SELECT_CROP */) {
+      throw new Error(`crop options are only valid with select_crop, not ${operator.type}`);
+    }
+    if (operator.crop.maxItems !== void 0) {
+      throw new Error("select_crop forwards one detection per selection, maxItems does not apply");
+    }
+  }
+}
+
 // compute/compute_session.ts
 var SESSION_DEAD = /* @__PURE__ */ new Set(["error" /* ERROR */, "failed" /* FAILED */, "stopped" /* STOPPED */, "pipeline_error" /* PIPELINE_ERROR */, "unknown" /* UNKNOWN */]);
 var CHECK_FOR_IS_READY_INTERVAL = 250;
@@ -8982,17 +9643,6 @@ var ComputeSessionClient = class {
   }
 };
 
-// types.ts
-var EndpointState = /* @__PURE__ */ ((EndpointState2) => {
-  EndpointState2["Idle"] = "Idle";
-  EndpointState2["Busy"] = "Busy";
-  EndpointState2["Authenticating"] = "Authenticating";
-  EndpointState2["FetchConfig"] = "FetchConfig";
-  EndpointState2["Error"] = "Error";
-  EndpointState2["NotAvailable"] = "NotAvailable";
-  return EndpointState2;
-})(EndpointState || {});
-
 // streaming.ts
 import { v4 as uuidv4 } from "uuid";
 var Stream = class _Stream {
@@ -9209,166 +9859,41 @@ function encodeMultipartFormData(parts, boundary) {
         if (!done) {
           controller.enqueue(value);
           return;
-        }
-        reader = null;
-        controller.enqueue(encoder.encode("\r\n"));
-        partIndex++;
-      }
-      if (partIndex >= parts.length) {
-        controller.enqueue(encoder.encode(`--${boundary}--\r
-`));
-        controller.close();
-        return;
-      }
-      const part = parts[partIndex];
-      let header = `--${boundary}\r
-Content-Disposition: form-data; name="${part.name}"\r
-`;
-      if (part.contentType) {
-        header += `Content-Type: ${part.contentType}\r
-`;
-      }
-      header += "\r\n";
-      controller.enqueue(encoder.encode(header));
-      if (typeof part.content === "string") {
-        controller.enqueue(encoder.encode(part.content));
-        controller.enqueue(encoder.encode("\r\n"));
-        partIndex++;
-      } else {
-        reader = toPartStream(part.content).getReader();
-      }
-    },
-    async cancel(reason) {
-      await reader?.cancel(reason);
-      const firstUnstartedPart = reader ? partIndex + 1 : partIndex;
-      await Promise.all(parts.slice(firstUnstartedPart).map((part) => cancelMultipartContent(part.content, reason)));
-    }
-  });
-}
-
-// camera.ts
-var QUATERNION_TOLERANCE = 1e-3;
-function isFinite_(value) {
-  return value === void 0 || Number.isFinite(value);
-}
-function validateCamera(camera) {
-  if (camera.intrinsics !== void 0 && camera.hfovDegrees !== void 0) {
-    throw new Error("camera.intrinsics and camera.hfovDegrees are alternatives, supply one");
-  }
-  if (camera.intrinsics === void 0 && camera.hfovDegrees === void 0) {
-    throw new Error("camera requires either camera.intrinsics or camera.hfovDegrees");
-  }
-  if (camera.hfovDegrees !== void 0) {
-    if (!(camera.hfovDegrees > 0 && camera.hfovDegrees < 180)) {
-      throw new Error("camera.hfovDegrees must be a horizontal field of view in (0, 180) degrees");
-    }
-  } else {
-    const intrinsics = camera.intrinsics;
-    for (const [name, focal] of [
-      ["fx", intrinsics.fx],
-      ["fy", intrinsics.fy]
-    ]) {
-      if (!(focal > 0) || !Number.isFinite(focal)) {
-        throw new Error(`camera.intrinsics.${name} must be a positive, finite focal length`);
-      }
-    }
-    for (const [name, principal, extent] of [
-      ["cx", intrinsics.cx, "width"],
-      ["cy", intrinsics.cy, "height"]
-    ]) {
-      if (!(principal >= 0 && principal <= 1)) {
-        throw new Error(`camera.intrinsics.${name} must be within [0, 1] of the frame ${extent}`);
-      }
-    }
-  }
-  if (camera.distortion !== void 0) {
-    for (const name of ["k1", "k2", "p1", "p2", "k3"]) {
-      if (!isFinite_(camera.distortion[name])) {
-        throw new Error(`camera.distortion.${name} must be a finite number`);
-      }
-    }
-  }
-  if (camera.extrinsics !== void 0) {
-    const translation = camera.extrinsics.translation;
-    if (translation !== void 0) {
-      for (const axis of ["x", "y", "z"]) {
-        if (!Number.isFinite(translation[axis])) {
-          throw new Error(`camera.extrinsics.translation.${axis} must be a finite number`);
-        }
-      }
-    }
-    const rotation = camera.extrinsics.rotation;
-    if (rotation !== void 0) {
-      const norm = Math.sqrt(rotation.w ** 2 + rotation.x ** 2 + rotation.y ** 2 + rotation.z ** 2);
-      if (!(Math.abs(norm - 1) <= QUATERNION_TOLERANCE)) {
-        throw new Error("camera.extrinsics.rotation must be a unit quaternion");
-      }
-    }
-  }
-}
-
-// worker/worker_types.ts
-var PredictionVersion = /* @__PURE__ */ ((PredictionVersion3) => {
-  PredictionVersion3[PredictionVersion3["V1"] = 1] = "V1";
-  PredictionVersion3[PredictionVersion3["V2"] = 2] = "V2";
-  return PredictionVersion3;
-})(PredictionVersion || {});
-var DEFAULT_PREDICTION_VERSION = 2 /* V2 */;
-var VideoMode = /* @__PURE__ */ ((VideoMode2) => {
-  VideoMode2["STREAM"] = "stream";
-  VideoMode2["BUFFER"] = "buffer";
-  return VideoMode2;
-})(VideoMode || {});
-var PopComponentType = /* @__PURE__ */ ((PopComponentType2) => {
-  PopComponentType2["FORWARD"] = "forward";
-  PopComponentType2["INFERENCE"] = "inference";
-  PopComponentType2["TRACKING"] = "tracking";
-  PopComponentType2["CONTOUR_FINDER"] = "contour_finder";
-  PopComponentType2["COMPONENT_FINDER"] = "component_finder";
-  return PopComponentType2;
-})(PopComponentType || {});
-var ForwardOperatorType = /* @__PURE__ */ ((ForwardOperatorType2) => {
-  ForwardOperatorType2["FULL"] = "full";
-  ForwardOperatorType2["CROP"] = "crop";
-  ForwardOperatorType2["CROP_WITH_FULL_FALLBACK"] = "crop_with_full_fallback";
-  return ForwardOperatorType2;
-})(ForwardOperatorType || {});
-var InferenceType = /* @__PURE__ */ ((InferenceType2) => {
-  InferenceType2["IMAGE_CLASSIFICATION"] = "image_classification";
-  InferenceType2["OBJECT_DETECTION"] = "object_detection";
-  InferenceType2["KEY_POINTS"] = "key_points";
-  InferenceType2["OCR"] = "ocr";
-  InferenceType2["MESH"] = "mesh";
-  InferenceType2["FEATURE_VECTOR"] = "feature_vector";
-  InferenceType2["SEMANTIC_SEGMENTATION"] = "semantic_segmentation";
-  InferenceType2["SEGMENTATION"] = "segmentation";
-  return InferenceType2;
-})(InferenceType || {});
-var MotionModel = /* @__PURE__ */ ((MotionModel2) => {
-  MotionModel2["RANDOM_WALK"] = "random_walk";
-  MotionModel2["CONSTANT_VELOCITY"] = "constant_velocity";
-  MotionModel2["CONSTANT_ACCELERATION"] = "constant_acceleration";
-  return MotionModel2;
-})(MotionModel || {});
-var ContourType = /* @__PURE__ */ ((ContourType2) => {
-  ContourType2["ALL_PIXELS"] = "all_pixels";
-  ContourType2["POLYGON"] = "polygon";
-  ContourType2["CONVEX_HULL"] = "convex_hull";
-  ContourType2["HOUGH_CIRCLES"] = "hough_circles";
-  ContourType2["CIRCLE"] = "circle";
-  ContourType2["TRIANGLE"] = "triangle";
-  ContourType2["RECTANGLE"] = "rectangle";
-  return ContourType2;
-})(ContourType || {});
-function validatePop(pop) {
-  if (pop.depthMap !== void 0) {
-    if (pop.depthMap.ability === void 0 === (pop.depthMap.abilityUuid === void 0)) {
-      throw new Error("depthMap requires exactly one of ability or abilityUuid");
+        }
+        reader = null;
+        controller.enqueue(encoder.encode("\r\n"));
+        partIndex++;
+      }
+      if (partIndex >= parts.length) {
+        controller.enqueue(encoder.encode(`--${boundary}--\r
+`));
+        controller.close();
+        return;
+      }
+      const part = parts[partIndex];
+      let header = `--${boundary}\r
+Content-Disposition: form-data; name="${part.name}"\r
+`;
+      if (part.contentType) {
+        header += `Content-Type: ${part.contentType}\r
+`;
+      }
+      header += "\r\n";
+      controller.enqueue(encoder.encode(header));
+      if (typeof part.content === "string") {
+        controller.enqueue(encoder.encode(part.content));
+        controller.enqueue(encoder.encode("\r\n"));
+        partIndex++;
+      } else {
+        reader = toPartStream(part.content).getReader();
+      }
+    },
+    async cancel(reason) {
+      await reader?.cancel(reason);
+      const firstUnstartedPart = reader ? partIndex + 1 : partIndex;
+      await Promise.all(parts.slice(firstUnstartedPart).map((part) => cancelMultipartContent(part.content, reason)));
     }
-  }
-  if (pop.defaults?.camera !== void 0) {
-    validateCamera(pop.defaults.camera);
-  }
+  });
 }
 
 // worker/webrtc_whip.ts
@@ -9821,8 +10346,8 @@ var UploadJob = class extends AbstractJob {
   get [Symbol.toStringTag]() {
     return "uploadJob";
   }
-  constructor(stream, mimeType, size, videoMode, params, getSession, client, requestLogger, uploadBodyFactory) {
-    super(params, getSession, client, requestLogger);
+  constructor(stream, mimeType, size, videoMode, params, getSession, client, requestLogger, uploadBodyFactory, version = DEFAULT_PREDICTION_VERSION) {
+    super(params, getSession, client, requestLogger, version);
     this._uploadStream = stream;
     this._uploadBodyFactory = uploadBodyFactory;
     this._mimeType = mimeType;
@@ -10015,8 +10540,8 @@ var UploadJob = class extends AbstractJob {
   }
 };
 var LoadFromJob = class extends AbstractJob {
-  constructor(location, params, getSession, client, requestLogger) {
-    super(params, getSession, client, requestLogger);
+  constructor(location, params, getSession, client, requestLogger, version = DEFAULT_PREDICTION_VERSION) {
+    super(params, getSession, client, requestLogger, version);
     this._location = location;
   }
   get [Symbol.toStringTag]() {
@@ -10062,8 +10587,8 @@ var UploadGroupJob = class extends AbstractJob {
   get [Symbol.toStringTag]() {
     return "uploadGroupJob";
   }
-  constructor(sources, params, getSession, client, requestLogger) {
-    super(params, getSession, client, requestLogger);
+  constructor(sources, params, getSession, client, requestLogger, version = DEFAULT_PREDICTION_VERSION) {
+    super(params, getSession, client, requestLogger, version);
     if (sources.length === 0) {
       throw new Error("upload group requires at least one source");
     }
@@ -10124,8 +10649,8 @@ var LoadFromGroupJob = class extends AbstractJob {
   get [Symbol.toStringTag]() {
     return "loadFromGroupJob";
   }
-  constructor(urls, params, getSession, client, requestLogger) {
-    super(params, getSession, client, requestLogger);
+  constructor(urls, params, getSession, client, requestLogger, version = DEFAULT_PREDICTION_VERSION) {
+    super(params, getSession, client, requestLogger, version);
     if (urls.length === 0) {
       throw new Error("load from group requires at least one url");
     }
@@ -10170,8 +10695,8 @@ var LoadFromGroupJob = class extends AbstractJob {
   }
 };
 var LoadFromAssetUuidJob = class extends AbstractJob {
-  constructor(assetUuid, params, getSession, client, requestLogger) {
-    super(params, getSession, client, requestLogger);
+  constructor(assetUuid, params, getSession, client, requestLogger, version = DEFAULT_PREDICTION_VERSION) {
+    super(params, getSession, client, requestLogger, version);
     this._assetUuid = assetUuid;
   }
   get [Symbol.toStringTag]() {
@@ -10211,1378 +10736,1755 @@ var LoadFromAssetUuidJob = class extends AbstractJob {
   }
 };
 var LoadMediaStreamJob = class extends AbstractJob {
-  constructor(mediaStream, params, getSession, client, requestLogger) {
-    super(params, getSession, client, requestLogger);
+  constructor(mediaStream, params, getSession, client, requestLogger, version = DEFAULT_PREDICTION_VERSION) {
+    super(params, getSession, client, requestLogger, version);
     this._mediaStream = mediaStream;
   }
   get [Symbol.toStringTag]() {
     return "loadLiveIngressJob";
   }
-  async startJob() {
-    const session = await this._getSession();
-    if (!session.baseUrl) {
-      return Promise.reject("session.baseUrl must not ne null");
-    }
-    const whip = new WebrtcWhip(
-      this._mediaStream,
-      async () => {
-        return session;
-      },
-      this._client,
-      true,
-      this._requestLogger
-    );
-    whip.start().then((_) => {
-      this._requestLogger.debug("direct whip for ingressId=%s successful", whip.ingressId());
-    }).catch((reason) => {
-      this._controller.abort(reason);
-    });
-    const body = {
-      sourceType: "WHIP",
-      whipIngressId: whip.ingressId(),
-      params: this._params.componentParams,
-      roi: this._params.roi,
-      fps: this._params.fps,
-      camera: this._params.camera,
-      version: this._version
-    };
-    if (this._params.motionDetect) {
-      Object.assign(body, this._params.motionDetect);
-    }
-    const headers = {
-      ...session.authenticationHeaders(),
-      Accept: "application/jsonl",
-      "Content-Type": "application/json"
-    };
-    const patchUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=preempt&processing=sync`;
-    return await this._client.fetch(patchUrl, {
-      headers,
-      method: "PATCH",
-      body: JSON.stringify(body),
-      signal: this._controller.signal,
-      // @ts-ignore
-      eyepop: { responseStreaming: true }
-    });
-  }
-};
-
-// shims/local_file.ts
-var resolvePath;
-if ("document" in globalThis && "implementation" in globalThis.document) {
-  resolvePath = async (_source, _logger) => {
-    throw new DOMException("resolving a path to a file is not supported in browser");
-  };
-} else {
-  let iteratorToStream = function(iterator) {
-    return new ReadableStream({
-      async pull(controller) {
-        const { value, done } = await iterator.next();
-        if (done) {
-          controller.close();
-        } else {
-          controller.enqueue(new Uint8Array(value));
-        }
-      }
-    });
-  };
-  iteratorToStream2 = iteratorToStream;
-  async function* nodeStreamToIterator(stream) {
-    for await (const chunk of stream) {
-      yield chunk;
-    }
-  }
-  resolvePath = async (source, _) => {
-    const mime = require_mime_types();
-    const filehandle = __require("fs/promises");
-    const fd = await filehandle.open(source.path, "r");
-    const stream = fd.createReadStream();
-    const iterator = nodeStreamToIterator(stream);
-    const webStream = iteratorToStream(iterator);
-    const mimeType = source.mimeType ? source.mimeType : mime.lookup(source.path) || "image/*";
-    return {
-      stream: webStream,
-      mimeType
-    };
-  };
-}
-var iteratorToStream2;
-
-// shims/http_client.ts
-var createHttpClient;
-function logLineFromRequest(input, init) {
-  const url = input instanceof Request ? input.url : input;
-  const method = input instanceof Request ? input.method : init?.method || (init?.body !== void 0 ? "POST" : "GET");
-  return `${method} ${url}`;
-}
-if ("document" in globalThis && "implementation" in globalThis.document) {
-  class BrowserHttpClient {
-    constructor(logger) {
-      this._logger = logger;
-    }
-    async fetch(input, init) {
-      const logLine = logLineFromRequest(input, init);
-      this._logger.debug(`Browser fetch() BEFORE ${logLine}`);
-      const response = await fetch(input, init);
-      this._logger.debug(`AFTER ${logLine} -> ${response.status}`);
-      return response;
-    }
-    async close() {
-    }
-    isFullDuplex() {
-      return false;
-    }
-  }
-  createHttpClient = async (logger) => {
-    return new BrowserHttpClient(logger);
-  };
-} else {
-  class NodeHttpClient {
-    constructor(agent, fetchFn, logger) {
-      this._agent = agent;
-      this._fetch = fetchFn;
-      this._logger = logger;
-    }
-    async fetch(input, init) {
-      init || (init = {});
-      init.dispatcher = this._agent;
-      const logLine = logLineFromRequest(input, init);
-      this._logger.debug(`Node fetch() BEFORE ${logLine}`);
-      const response = await this._fetch(input, init);
-      this._logger.debug(`AFTER ${logLine} -> ${response.status}`);
-      return response;
-    }
-    async close() {
-      return this._agent.close();
-    }
-    isFullDuplex() {
-      return false;
-    }
-  }
-  createHttpClient = async (logger) => {
-    const undici = __require("undici");
-    const agent = new undici.Agent({
-      keepAliveTimeout: 1e4,
-      connections: 5,
-      // two parallel streaming requests to the same host seem to deadlock with pipelining > 0
-      pipelining: 0
-    });
-    logger.debug("Using node fetch with undici agent as http client");
-    return new NodeHttpClient(agent, undici.fetch, logger);
-  };
-}
-
-// semaphore.ts
-var Semaphore = class {
-  /**
-   * Creates a semaphore.
-   * @param permits  The number of permits, i.e. strands of execution being allowed
-   * to run in parallel.
-   * This number can be initialized with a negative integer.
-   */
-  constructor(permits) {
-    this.promiseResolverQueue = [];
-    this.permits = permits;
-  }
-  /**
-   * Returns the number of available permits.
-   * @returns  The number of available permits.
-   */
-  getPermits() {
-    return this.permits;
-  }
-  /**
-   * Returns a promise used to wait for a permit to become available. This method should be awaited on.
-   * @returns  A promise that gets resolved when execution is allowed to proceed.
-   */
-  async wait() {
-    if (this.permits > 0) {
-      this.permits -= 1;
-      return Promise.resolve(true);
-    }
-    return new Promise((resolver) => this.promiseResolverQueue.push(resolver));
-  }
-  /**
-   * Alias for {@linkcode Semaphore.wait}.
-   * @returns  A promise that gets resolved when execution is allowed to proceed.
-   */
-  async acquire() {
-    return this.wait();
-  }
-  /**
-   * Same as {@linkcode Semaphore.wait} except the promise returned gets resolved with false if no
-   * permit becomes available in time.
-   * @param milliseconds  The time spent waiting before the wait is aborted. This is a lower bound,
-   * you shouldn't rely on it being precise.
-   * @returns  A promise that gets resolved to true when execution is allowed to proceed or
-   * false if the time given elapses before a permit becomes available.
-   */
-  async waitFor(milliseconds) {
-    if (this.permits > 0) {
-      this.permits -= 1;
-      return Promise.resolve(true);
-    }
-    let resolver = (_) => void 0;
-    const promise = new Promise((r) => {
-      resolver = r;
-    });
-    this.promiseResolverQueue.push(resolver);
-    setTimeout(() => {
-      const index = this.promiseResolverQueue.indexOf(resolver);
-      if (index !== -1) {
-        this.promiseResolverQueue.splice(index, 1);
-      } else {
-        console.warn(`Semaphore.waitFor couldn't find its promise resolver in the queue`);
-      }
-      resolver(false);
-    }, milliseconds);
-    return promise;
-  }
-  /**
-   * Synchronous function that tries to acquire a permit and returns true if successful, false otherwise.
-   * @returns  Whether a permit could be acquired.
-   */
-  tryAcquire() {
-    if (this.permits > 0) {
-      this.permits -= 1;
-      return true;
+  async startJob() {
+    const session = await this._getSession();
+    if (!session.baseUrl) {
+      return Promise.reject("session.baseUrl must not ne null");
     }
-    return false;
-  }
-  /**
-   * Acquires all permits that are currently available and returns the number of acquired permits.
-   * @returns  Number of acquired permits.
-   */
-  drainPermits() {
-    if (this.permits > 0) {
-      const permitCount = this.permits;
-      this.permits = 0;
-      return permitCount;
+    const whip = new WebrtcWhip(
+      this._mediaStream,
+      async () => {
+        return session;
+      },
+      this._client,
+      true,
+      this._requestLogger
+    );
+    whip.start().then((_) => {
+      this._requestLogger.debug("direct whip for ingressId=%s successful", whip.ingressId());
+    }).catch((reason) => {
+      this._controller.abort(reason);
+    });
+    const body = {
+      sourceType: "WHIP",
+      whipIngressId: whip.ingressId(),
+      params: this._params.componentParams,
+      roi: this._params.roi,
+      fps: this._params.fps,
+      camera: this._params.camera,
+      version: this._version
+    };
+    if (this._params.motionDetect) {
+      Object.assign(body, this._params.motionDetect);
     }
-    return 0;
+    const headers = {
+      ...session.authenticationHeaders(),
+      Accept: "application/jsonl",
+      "Content-Type": "application/json"
+    };
+    const patchUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=preempt&processing=sync`;
+    return await this._client.fetch(patchUrl, {
+      headers,
+      method: "PATCH",
+      body: JSON.stringify(body),
+      signal: this._controller.signal,
+      // @ts-ignore
+      eyepop: { responseStreaming: true }
+    });
   }
-  /**
-   * Increases the number of permits by one. If there are other functions waiting, one of them will
-   * continue to execute in a future iteration of the event loop.
-   */
-  signal() {
-    this.permits += 1;
-    if (this.permits > 1 && this.promiseResolverQueue.length > 0) {
-      console.warn("Semaphore.permits should never be > 0 when there is someone waiting.");
-    } else if (this.permits === 1 && this.promiseResolverQueue.length > 0) {
-      this.permits -= 1;
-      const nextResolver = this.promiseResolverQueue.shift();
-      if (nextResolver) {
-        nextResolver(true);
+};
+
+// shims/local_file.ts
+var resolvePath;
+if ("document" in globalThis && "implementation" in globalThis.document) {
+  resolvePath = async (_source, _logger) => {
+    throw new DOMException("resolving a path to a file is not supported in browser");
+  };
+} else {
+  let iteratorToStream = function(iterator) {
+    return new ReadableStream({
+      async pull(controller) {
+        const { value, done } = await iterator.next();
+        if (done) {
+          controller.close();
+        } else {
+          controller.enqueue(new Uint8Array(value));
+        }
       }
+    });
+  };
+  iteratorToStream2 = iteratorToStream;
+  async function* nodeStreamToIterator(stream) {
+    for await (const chunk of stream) {
+      yield chunk;
     }
   }
-  /**
-   * Alias for {@linkcode Semaphore.signal}.
-   */
-  release() {
-    this.signal();
+  resolvePath = async (source, _) => {
+    const mime = require_mime_types();
+    const filehandle = __require("fs/promises");
+    const fd = await filehandle.open(source.path, "r");
+    const size = (await fd.stat()).size;
+    const stream = fd.createReadStream();
+    const iterator = nodeStreamToIterator(stream);
+    const webStream = iteratorToStream(iterator);
+    const mimeType = source.mimeType ? source.mimeType : mime.lookup(source.path) || "image/*";
+    return {
+      stream: webStream,
+      mimeType,
+      size
+    };
+  };
+}
+var iteratorToStream2;
+
+// worker/worker_options.ts
+var TransientPopId = /* @__PURE__ */ ((TransientPopId2) => {
+  TransientPopId2["Transient"] = "transient";
+  return TransientPopId2;
+})(TransientPopId || {});
+
+// worker/session_backend.ts
+var _SessionBackend = class _SessionBackend {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this._baseUrl = null;
+    this._pipelineId = null;
+    this._popName = null;
+    this._sessionAccessToken = null;
+    this._sessionAccessTokenValidUntil = null;
+    // The account the connected compute session runs under, as compute-api reports it.
+    this._accountId = void 0;
+    this._pipeline = null;
+    this._pipelineCreatePromise = null;
   }
-  /**
-   * Schedules func to be called once a permit becomes available.
-   * Returns a promise that resolves to the return value of func.
-   * @typeparam T  The return type of func.
-   * @param func  The function to be executed.
-   * @return  A promise that gets resolved with the return value of the function.
-   */
-  async execute(func) {
-    await this.wait();
-    try {
-      return await func();
-    } finally {
-      this.signal();
+  async disconnect(closeEndpoint) {
+    await this.deleteOwnPipeline();
+    await closeEndpoint();
+  }
+  async deleteOwnPipeline() {
+    const client = this.ctx.client();
+    if (this.ctx.options.popId == "transient" /* Transient */ && this._pipelineId && client) {
+      const deleteUrl = `${this._baseUrl}/pipelines/${this._pipelineId}`;
+      const headers = {
+        Authorization: await this.authorizationHeader()
+      };
+      let response = await client.fetch(deleteUrl, {
+        method: "DELETE",
+        headers
+      });
+      if (response?.status != 204) {
+        const message = await response?.text();
+        this.ctx.logger.info(`stopping pipeline failed, status ${response?.status}: ${message}`);
+      }
     }
   }
-};
-
-// endpoint.ts
-import { pino } from "pino";
-
-// shims/browser_session.ts
-import { createAuth0Client } from "@auth0/auth0-spa-js";
-var authenticateBrowserSession;
-if ("document" in globalThis && "implementation" in globalThis.document) {
-  authenticateBrowserSession = async (auth0, options) => {
-    if (options.eyepopUrl == null) {
-      return Promise.reject("options.eyepopUrl cannot be null");
+  onStatus(statusCode) {
+    if (statusCode == 404) {
+      this._pipelineId = null;
+      this._baseUrl = null;
     }
-    const auth0ClientOptions = {
-      clientId: auth0.clientId,
-      domain: auth0.domain,
-      authorizationParams: {
-        scope: auth0.scope,
-        audience: auth0.audience
+  }
+  async session() {
+    let session = null;
+    if (this._baseUrl == null) {
+      await this.reconnect();
+      if (this._baseUrl == null) {
+        return Promise.reject("endpoint not connected");
       }
-    };
-    const auth0Client = await createAuth0Client(auth0ClientOptions);
-    if (!await auth0Client.isAuthenticated()) {
-      await auth0Client.loginWithPopup();
-    }
-    const accessToken = await auth0Client.getTokenSilently();
-    if (!accessToken) {
-      return Promise.reject("auth0 login failed");
     }
-    let session;
-    const workerOptions = options;
-    if (typeof workerOptions.popId != "undefined") {
-      const workerSession = {
-        eyepopUrl: options.eyepopUrl,
-        accessToken,
-        validUntil: Date.now() + 60 * 60 * 1e3,
-        popId: workerOptions.popId,
-        baseUrl: void 0,
-        pipelineId: void 0,
-        authenticationHeaders: () => {
-          return { Authorization: `Bearer ${accessToken}` };
-        }
-      };
-      session = workerSession;
-    } else {
+    if (this._sessionAccessToken) {
       session = {
-        eyepopUrl: options.eyepopUrl,
-        accessToken,
-        validUntil: Date.now() + 60 * 60 * 1e3
+        eyepopUrl: this.ctx.options.eyepopUrl,
+        accessToken: this._sessionAccessToken,
+        validUntil: this._sessionAccessTokenValidUntil || Number.MAX_VALUE
       };
-    }
-    return session;
-  };
-} else {
-  authenticateBrowserSession = (_auth0, _options) => {
-    return Promise.reject("auth0 login not supported server-side");
-  };
-}
-
-// endpoint.ts
-var Endpoint = class {
-  constructor(options) {
-    this._options = options;
-    this._token = null;
-    this._expire_token_time = null;
-    this._client = null;
-    this._statusRetryHandlers = /* @__PURE__ */ new Map();
-    this._statusRetryHandlers.set(401, this.statusHandler401);
-    this._limit = new Semaphore(this._options.jobQueueLength ?? 1024);
-    this._state = "Idle" /* Idle */;
-    this._message = null;
-    this._stateChangeHandler = null;
-    let rootLogger;
-    if (options.logger) {
-      rootLogger = options.logger;
     } else {
-      rootLogger = pino();
+      session = await this.ctx.credentialSession();
+    }
+    return {
+      eyepopUrl: session.eyepopUrl,
+      accessToken: session.accessToken,
+      validUntil: session.validUntil,
+      popId: this.ctx.options.popId,
+      accountId: this._accountId ?? this.ctx.options.accountId,
+      baseUrl: this._baseUrl,
+      pipelineId: this._pipelineId || void 0,
+      isPipelineMode: false,
+      authenticationHeaders: () => this._authenticationHeaders(session)
+    };
+  }
+  popName() {
+    return this._popName;
+  }
+  pop() {
+    if (this._pipeline) {
+      return this._pipeline.pop || null;
     }
-    this._logger = rootLogger.child({ module: "eyepop" });
-    this._requestLogger = this._logger.child({ module: "requests" });
+    return this.ctx.options.pop || null;
   }
-  setStatusRetryHandlers(statusRetryHandlers = void 0) {
-    this._statusRetryHandlers = new Map(statusRetryHandlers);
-    this._statusRetryHandlers.set(401, this.statusHandler401);
+  /**
+   * 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;
   }
-  eyepopUrl() {
-    if (this._options.eyepopUrl) {
-      return this._options.eyepopUrl.replace(/\/+$/, "");
-    } else {
-      return "https://compute.eyepop.ai";
+  async changePop(pop) {
+    if (this.ctx.options.popId == "transient" /* Transient */) {
+      await this.changeTransientPop(pop);
+      return;
     }
-  }
-  // TODO: deprecated Web API endpoint needed for POP_ID support
-  eyepopWebApiUrl() {
-    if (this._options.eyepopUrl) {
-      return this._options.eyepopUrl.replace(/\/+$/, "").replace(/compute\./, "web-api.");
+    const client = this.ctx.client();
+    const baseUrl = this._baseUrl;
+    if (!baseUrl || !client) {
+      return Promise.reject("endpoint not connected, use connect()");
+    }
+    let response = await this.ctx.fetchWithRetry(async () => {
+      const session = await this.session();
+      let headers = {
+        "Content-Type": "application/json",
+        ...this._authenticationHeaders(session)
+      };
+      const patch_url = `${session.baseUrl}/pipelines/${session.pipelineId}/pop`;
+      return await client.fetch(patch_url, {
+        method: "PATCH",
+        body: JSON.stringify(pop),
+        headers
+      });
+    });
+    if (response.status != 204) {
+      const message = await response.text();
+      throw new Error(`Unexpected status ${response.status}: ${message}`);
+    }
+    this.ctx.options.pop = pop;
+    if (this._pipeline) {
+      this._pipeline.pop = pop;
     } else {
-      return "https://api.eyepop.ai";
+      this._pipeline = {
+        id: this._pipelineId || "unknown",
+        state: "idle",
+        startTime: (/* @__PURE__ */ new Date()).toString(),
+        pop
+      };
     }
   }
-  pendingJobs() {
-    return (this._options.jobQueueLength ?? 1024) - this._limit.getPermits();
-  }
-  state() {
-    return this._state;
+  _authenticationHeaders(session) {
+    return resolveAuth(this.ctx.options)?.isLocal !== void 0 ? {} : { Authorization: `Bearer ${session.accessToken}` };
   }
-  lastMessage() {
-    return this._message;
+  async submit(work) {
+    switch (work.kind) {
+      case "source":
+        return await this.process(work.source, work.params);
+      case "uploadGroup":
+        return await this.uploadGroup(work.paths, work.params);
+      case "uploadStreamGroup":
+        return await this.uploadStreamGroup(work.streams, work.mimeTypes, work.params);
+      case "loadFromGroup":
+        return await this.loadFromGroup(work.urls, work.params);
+    }
   }
-  onStateChanged(handler) {
-    this._stateChangeHandler = handler;
-    return this;
+  async process(source, params) {
+    if (source.file !== void 0) {
+      return this.uploadFile(source, params);
+    } else if (source.stream !== void 0) {
+      return this.uploadStream(source, params);
+    } else if (source.path !== void 0) {
+      return this.uploadPath(source, params);
+    } else if (source.url !== void 0) {
+      return this.loadFrom(source, params);
+    } else if (source.assetUuid !== void 0) {
+      return this.loadFromAssetUuid(source, params);
+    } else if (source.mediaStream !== void 0) {
+      return this.loadMediaStream(source, params);
+    } else {
+      return Promise.reject("unknown source type");
+    }
   }
-  updateState(newState = void 0, message = void 0) {
-    const fromState = this._state;
-    if (newState == void 0) {
-      if (this._limit.getPermits() == this._options.jobQueueLength) {
-        newState = "Idle" /* Idle */;
-      } else {
-        newState = "Busy" /* Busy */;
+  start(job) {
+    return job.start(
+      () => {
+        this.ctx.jobDone();
+      },
+      (statusCode) => {
+        if (statusCode == 404) {
+          this.onStatus(statusCode);
+        } else if (statusCode == 401) {
+          this.ctx.forgetCredential();
+        }
       }
+    );
+  }
+  async uploadGroup(paths, params) {
+    const client = this.ctx.client();
+    const limit = this.ctx.limit();
+    if (!this._baseUrl || !this._pipelineId || !client) {
+      throw new Error("endpoint not connected, use connect()");
     }
-    this._state = newState;
-    this._message = message ? message : null;
-    if (this._stateChangeHandler) {
-      this._stateChangeHandler(fromState, this._state);
+    await limit.acquire();
+    try {
+      this.ctx.updateState();
+      const sources = await Promise.all(
+        paths.map(async (path2) => {
+          const streamSource = await this.resolvePath({ path: path2 });
+          return { stream: streamSource.stream, mimeType: streamSource.mimeType };
+        })
+      );
+      return this.start(new UploadGroupJob(sources, params, async () => this.session(), client, this.ctx.requestLogger, this.predictionVersion()));
+    } catch (e) {
+      limit.release();
+      throw e;
     }
   }
-  async connect() {
-    if (this._client) {
-      this._logger.warn("endpoint already connected");
-      return this;
+  async uploadStreamGroup(streams, mimeTypes, params) {
+    const client = this.ctx.client();
+    const limit = this.ctx.limit();
+    if (!this._baseUrl || !this._pipelineId || !client) {
+      throw new Error("endpoint not connected, use connect()");
     }
-    if (!this._options.eyepopUrl) {
-      return Promise.reject("option eyepopUrl or environment variable EYEPOP_URL is required");
+    await limit.acquire();
+    try {
+      this.ctx.updateState();
+      const sources = streams.map((stream, i) => ({
+        stream,
+        mimeType: mimeTypes?.[i] ?? null
+      }));
+      return this.start(new UploadGroupJob(sources, params, async () => this.session(), client, this.ctx.requestLogger, this.predictionVersion()));
+    } catch (e) {
+      limit.release();
+      throw e;
     }
-    const auth = resolveAuth(this._options);
-    if (auth === void 0) {
-      return Promise.reject("cannot connect without defined auth option");
+  }
+  async loadFromGroup(urls, params) {
+    const client = this.ctx.client();
+    const limit = this.ctx.limit();
+    if (!this._baseUrl || !this._pipelineId || !client) {
+      throw new Error("endpoint not connected, use connect()");
     }
-    if (auth.session !== void 0) {
-      this._token = auth.session.accessToken;
-      this._expire_token_time = auth.session.validUntil / 1e3;
-    } else if (auth.oAuth2 !== void 0) {
-    } else if (accessTokenCredential(auth) !== void 0) {
-    } else if (apiKeyCredential(auth) !== void 0) {
-    } else if (auth.isLocal !== void 0) {
-    } else {
-      return Promise.reject("option apiKey/accessToken or environment variable EYEPOP_API_KEY is required");
+    await limit.acquire();
+    try {
+      this.ctx.updateState();
+      return this.start(new LoadFromGroupJob(urls, params, async () => this.session(), client, this.ctx.requestLogger, this.predictionVersion()));
+    } catch (e) {
+      limit.release();
+      throw e;
     }
-    if (this._options.platformSupport?.createHttpClient !== void 0) {
-      this._client = await this._options.platformSupport.createHttpClient(this._requestLogger);
-    } else {
-      this._client = await createHttpClient(this._requestLogger);
+  }
+  async resolvePath(source) {
+    if (this.ctx.options.platformSupport?.resolvePath) {
+      return await this.ctx.options.platformSupport.resolvePath(source, this.ctx.logger);
     }
-    return await this.reconnect();
+    return await resolvePath(source, this.ctx.logger);
   }
-  async disconnect(wait = true) {
-    if (wait && this._limit) {
-      for (let j = 0; j < this._options.jobQueueLength; j++) {
-        await this._limit.acquire();
+  /** Start a job once the transient pipeline runs and a queue permit is held; the permit is released if it cannot start. */
+  async startConnected(makeJob, rejectsWithText = false) {
+    await this.ensureTransientPipelineStarted();
+    const client = this.ctx.client();
+    const limit = this.ctx.limit();
+    if (!this._baseUrl || !this._pipelineId || !client) {
+      if (rejectsWithText) {
+        return Promise.reject("endpoint not connected, use connect()");
       }
+      throw new Error("endpoint not connected, use connect()");
     }
-    this._limit = new Semaphore(this._options.jobQueueLength ?? 1024);
-    if (this._client) {
-      await this._client.close();
-      this._client = null;
+    await limit.acquire();
+    try {
+      this.ctx.updateState();
+      return this.start(await makeJob(client));
+    } catch (e) {
+      limit.release();
+      throw e;
     }
   }
-  async session() {
-    await this.currentAccessToken();
-    if (this._token == null || this._expire_token_time == null) {
-      return Promise.reject("endpoint not connected");
-    }
-    return {
-      eyepopUrl: this._options.eyepopUrl,
-      accessToken: this._token,
-      validUntil: this._expire_token_time * 1e3
-    };
+  async uploadFile(source, params) {
+    return await this.startConnected(
+      async (client) => new UploadJob(
+        source.file,
+        source.file.type,
+        source.file.size,
+        source.videoMode,
+        params,
+        async () => this.session(),
+        client,
+        this.ctx.requestLogger,
+        void 0,
+        this.predictionVersion()
+      ),
+      true
+    );
   }
-  statusHandler401(_statusCode) {
-    this._token = null;
-    this._expire_token_time = null;
+  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()),
+      true
+    );
   }
-  async fetchWithRetry(fetcher, retries = 1) {
-    while (true) {
-      try {
-        const response = await fetcher();
-        if (response.ok) {
-          return response;
-        } else {
-          const handler = this._statusRetryHandlers.get(response.status);
-          if (handler != null) {
-            handler(response.status);
-            if (retries--) {
-              this._requestLogger.info("received %d response, retry", response.status);
-            } else {
-              return response;
-            }
-          } else {
-            return response;
-          }
+  async uploadPath(source, params) {
+    return await this.startConnected(async (client) => {
+      const streamSource = await this.resolvePath(source);
+      let firstStreamPending = true;
+      const uploadBodyFactory = async () => {
+        if (firstStreamPending) {
+          firstStreamPending = false;
+          return streamSource.stream;
         }
-      } catch (error) {
-        const handler = this._statusRetryHandlers.get(404);
-        if (handler != null) {
-          handler(error);
-          if (retries--) {
-            this._requestLogger.info("error %s, retry", error);
-          } else {
-            return Promise.reject(`error ${error}`);
-          }
-        } else {
-          return Promise.reject(`error ${error}`);
+        return (await this.resolvePath(source)).stream;
+      };
+      return new UploadJob(
+        streamSource.stream,
+        streamSource.mimeType,
+        streamSource.size,
+        source.videoMode,
+        params,
+        async () => this.session(),
+        client,
+        this.ctx.requestLogger,
+        uploadBodyFactory,
+        this.predictionVersion()
+      );
+    });
+  }
+  async loadFrom(source, params) {
+    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()));
+  }
+  async loadFromAssetUuid(source, params) {
+    return await this.startConnected(async (client) => new LoadFromAssetUuidJob(source.assetUuid, params, async () => this.session(), client, this.ctx.requestLogger, this.predictionVersion()));
+  }
+  async loadMediaStream(source, params) {
+    return await this.startConnected(async (client) => new LoadMediaStreamJob(source.mediaStream, params, async () => this.session(), client, this.ctx.requestLogger, this.predictionVersion()));
+  }
+  async reconnect() {
+    if (this.ctx.options.popId == "transient" /* Transient */) {
+      await this.getComputeSession();
+      if (this.ctx.options.pop) {
+        this.setTransientPipelinePop();
+      }
+    } else if (this.ctx.options.sessionUuid) {
+      await this.getComputeSession();
+    } else {
+      await this.startWebApiSessionWithPopId();
+    }
+    this.ctx.updateState();
+  }
+  async startWebApiSessionWithPopId() {
+    const client = this.ctx.client();
+    if (!client) {
+      throw new Error("endpoint not initialized");
+    }
+    const config_url = `${this.ctx.eyepopWebApiUrl()}/pops/${this.ctx.options.popId}/config?auto_start=false`;
+    const headers = {
+      Authorization: await this.authorizationHeader()
+    };
+    this.ctx.updateState("FetchConfig" /* FetchConfig */);
+    let response = await client.fetch(config_url, { headers });
+    if (response.status == 401) {
+      this.ctx.requestLogger.debug("GET %s: 401, about to retry with fresh access token", config_url);
+      this.ctx.forgetCredential();
+      const headers2 = {
+        Authorization: await this.authorizationHeader()
+      };
+      this.ctx.updateState("FetchConfig" /* FetchConfig */);
+      response = await client.fetch(config_url, {
+        headers: headers2
+      });
+    }
+    if (response.status != 200) {
+      const message = await response.text();
+      if (response.status == 429) {
+        this.ctx.updateState("NotAvailable" /* NotAvailable */, message);
+      } else {
+        this.ctx.updateState("Error" /* Error */, message);
+      }
+      throw new Error(`Unexpected status ${response.status}: ${message}`);
+    }
+    let config = await response.json();
+    if (!config.base_url && this.ctx.options.autoStart) {
+      const auto_start_config_url = `${this.ctx.eyepopWebApiUrl()}/pops/${this.ctx.options.popId}/config?auto_start=true`;
+      this.ctx.requestLogger.debug("pop was not running, trying to autostart with: %s", auto_start_config_url);
+      const headers2 = {
+        Authorization: await this.authorizationHeader()
+      };
+      response = await client.fetch(auto_start_config_url, {
+        headers: headers2
+      });
+      if (response.status != 200) {
+        this.ctx.updateState("Error" /* Error */);
+        const message = await response.text();
+        throw new Error(`Unexpected status ${response.status}: ${message}`);
+      }
+      config = await response.json();
+    }
+    const baseUrl = new URL(config.base_url, this.ctx.eyepopUrl());
+    this._baseUrl = baseUrl.toString();
+    if (this._baseUrl) {
+      this._baseUrl = this._baseUrl.replace(/\/+$/, "");
+      this._pipelineId = config.pipeline_id;
+      this._popName = config.name;
+      if (!this._pipelineId || !this._baseUrl) {
+        throw new Error("Pop not started");
+      }
+      const get_url = `${this._baseUrl}/pipelines/${this._pipelineId}`;
+      const headers2 = {
+        Authorization: await this.authorizationHeader()
+      };
+      let response2 = await client.fetch(get_url, {
+        method: "GET",
+        headers: headers2
+      });
+      if (response2.status > 200) {
+        const message = await response2.text();
+        throw new Error(`Unexpected status ${response2.status}: ${message}`);
+      }
+      this._pipeline = await response2.json();
+      if (this.ctx.options.stopJobs) {
+        const body = { sourceType: "NONE" };
+        const headers3 = {
+          Authorization: await this.authorizationHeader(),
+          "Content-Type": "application/json"
+        };
+        const stop_url = `${this._baseUrl}/pipelines/${this._pipeline.id}/source?mode=preempt&processing=sync`;
+        let response3 = await client.fetch(stop_url, {
+          method: "PATCH",
+          headers: headers3,
+          body: JSON.stringify(body)
+        });
+        if (response3.status >= 300) {
+          const message = await response3.text();
+          throw new Error(`Unexpected status ${response3.status}: ${message}`);
         }
       }
     }
   }
-  async reconnect() {
-    throw new Error("reconnect() not implemented");
+  sessionReadyTimeoutMs() {
+    const seconds = this.ctx.options.sessionReadyTimeoutSeconds;
+    return typeof seconds == "number" && Number.isFinite(seconds) && seconds > 0 ? seconds * 1e3 : _SessionBackend.WAIT_FOR_IS_READY;
   }
-  async authorizationHeader() {
-    if (resolveAuth(this._options)?.isLocal !== void 0) {
-      return `Implicit`;
+  async getComputeSession() {
+    const client = this.ctx.client();
+    if (!client) {
+      throw new Error("endpoint not initialized");
     }
-    return `Bearer ${await this.currentAccessToken()}`;
-  }
-  async currentAccessToken() {
-    const now = Date.now() / 1e3;
-    if (!this._token || this._expire_token_time < now) {
-      this.updateState("Authenticating" /* Authenticating */);
-      try {
-        const auth = resolveAuth(this._options);
-        if (!this._client) {
-          return Promise.reject("endpoint not connected");
-        } else if (auth?.isLocal !== void 0) {
-          this._token = "implicit";
-          this._expire_token_time = Number.MAX_VALUE;
-        } else if (auth?.session !== void 0) {
-          return Promise.reject("temporary access token expired");
-        } else if (auth?.oAuth2 !== void 0 && this._options.eyepopUrl) {
-          const session = await authenticateBrowserSession(auth.oAuth2, this._options);
-          this._token = session.accessToken;
-          this._expire_token_time = session.validUntil / 1e3;
-        } else if (accessTokenCredential(auth) !== void 0) {
-          this._token = accessTokenCredential(auth);
-          this._expire_token_time = Number.MAX_VALUE;
-        } else if (this._options.eyepopUrl) {
-          const credential = apiKeyCredential(auth);
-          if (credential === void 0) {
-            return Promise.reject("no valid auth option");
-          }
-          const headers = { Authorization: `Bearer ${credential}` };
-          const post_url = `${this.eyepopUrl()}/v1/auth/authenticate`;
-          const response = await this._client.fetch(post_url, {
-            method: "POST",
-            headers
-          });
-          if (response.status != 200) {
-            const message = await response.text();
-            return Promise.reject(`Unexpected status ${response.status}: ${message}`);
-          }
-          const data = await response.json();
-          const token = data;
-          this._token = token.access_token;
-          this._expire_token_time = now + token.expires_in - 60;
-        } else {
-          return Promise.reject("no valid auth option");
-        }
-      } finally {
-        this.updateState();
-      }
+    let resolved;
+    try {
+      resolved = await new ComputeSessionClient({
+        computeUrl: this.ctx.eyepopUrl(),
+        httpClient: client,
+        authorizationHeader: () => this.computeAuthorizationHeader(),
+        sessionUuid: this.ctx.options.sessionUuid,
+        sessionName: this.ctx.options.sessionName,
+        accountId: this.ctx.options.accountId,
+        pipelineImage: this.ctx.options.pipelineImage,
+        pipelineVersion: this.ctx.options.pipelineVersion,
+        pop: this.ctx.options.pop,
+        readyTimeoutMs: this.sessionReadyTimeoutMs(),
+        logger: this.ctx.logger,
+        requestLogger: this.ctx.requestLogger
+      }).resolve();
+    } catch (error) {
+      this.ctx.updateState("Error" /* Error */);
+      throw error;
     }
-    this._logger.debug("using access token, valid for at least %d seconds", this._expire_token_time - now);
-    return this._token;
-  }
-};
-
-// worker/worker_options.ts
-var TransientPopId = /* @__PURE__ */ ((TransientPopId2) => {
-  TransientPopId2["Transient"] = "transient";
-  return TransientPopId2;
-})(TransientPopId || {});
-
-// worker/worker_endpoint.ts
-var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
-  constructor(options) {
-    super(options);
-    this.setStatusRetryHandlers(/* @__PURE__ */ new Map([[404, (statusCode) => this.statusHandler404(statusCode)]]));
-    this._baseUrl = null;
-    this._pipelineId = null;
-    this._popName = null;
-    this._sessionAccessToken = null;
-    this._sessionAccessTokenValidUntil = null;
-    this._accountId = void 0;
+    this._sessionAccessToken = resolved.accessToken;
+    this._sessionAccessTokenValidUntil = resolved.accessTokenValidUntil;
+    this._baseUrl = resolved.session.session_endpoint;
+    this._accountId = resolved.session.account_uuid || void 0;
     this._pipeline = null;
-    this._pipelineCreatePromise = null;
-  }
-  options() {
-    return this._options;
+    this._pipelineId = resolved.pipelineId;
+    if (this.ctx.options.pop) {
+      this.setTransientPipelinePop();
+    }
   }
-  async disconnect(wait = true) {
-    if (this.options().popId == "transient" /* Transient */ && this._pipelineId) {
-      const deleteUrl = `${this._baseUrl}/pipelines/${this._pipelineId}`;
-      const headers = {
+  async startTransientPipeline() {
+    const client = this.ctx.client();
+    const baseUrl = this._baseUrl;
+    if (client == null || baseUrl == null) {
+      throw new Error("endpoint not initialized");
+    }
+    let pop;
+    if (this.ctx.options.pop) {
+      pop = this.ctx.options.pop;
+    } else if (this._pipeline && this._pipeline.pop) {
+      pop = this._pipeline.pop;
+    } else {
+      throw new Error("Cannot start a transient pipeline without a pop");
+    }
+    const body = {
+      pop,
+      source: {
+        sourceType: "NONE"
+      },
+      idleTimeoutSeconds: 30,
+      logging: ["out_meta"],
+      videoOutput: "no_output"
+    };
+    const post_url = `${baseUrl.replace(/\/+$/, "")}/pipelines`;
+    const response = await this.ctx.fetchWithRetry(async () => {
+      let headers = {
+        Accept: "application/json",
+        "Content-Type": "application/json",
         Authorization: await this.authorizationHeader()
       };
-      let response = await this._client?.fetch(deleteUrl, {
-        method: "DELETE",
+      return client.fetch(post_url, {
+        method: "POST",
+        body: JSON.stringify(body),
         headers
       });
-      if (response?.status != 204) {
-        const message = await response?.text();
-        this._logger.info(`stopping pipeline failed, status ${response?.status}: ${message}`);
-      }
+    });
+    if (response.status != 200) {
+      const message = await response.text();
+      throw new Error(`Unexpected status ${response.status} starting transient pipeline: ${message.slice(0, 300)}`);
     }
-    return super.disconnect(wait);
-  }
-  statusHandler404(_) {
-    this._pipelineId = null;
-    this._baseUrl = null;
+    const result = await response.json();
+    return result["id"];
   }
-  async session() {
-    let session = null;
-    if (this._baseUrl == null) {
+  async ensureTransientPipelineStarted() {
+    if (this.ctx.options.popId != "transient" /* Transient */ || this._pipelineId) {
+      return;
+    }
+    if (!this.ctx.options.pop) {
+      return;
+    }
+    if (!this._baseUrl) {
       await this.reconnect();
-      if (this._baseUrl == null) {
-        return Promise.reject("endpoint not connected");
+    }
+    if (this._pipelineId) {
+      return;
+    }
+    if (this.ctx.options.pop) {
+      await this.reconnect();
+      if (!this._pipelineId) {
+        throw new Error("Compute session did not provide a pipeline for the requested pop");
       }
+      return;
     }
-    if (this._sessionAccessToken) {
-      session = {
-        eyepopUrl: this.options().eyepopUrl,
-        accessToken: this._sessionAccessToken,
-        validUntil: this._sessionAccessTokenValidUntil || Number.MAX_VALUE
-      };
-    } else {
-      session = await super.session();
+    if (!this._pipelineCreatePromise) {
+      this._pipelineCreatePromise = this.startTransientPipeline();
+    }
+    try {
+      this._pipelineId = await this._pipelineCreatePromise;
+      this.setTransientPipelinePop();
+    } finally {
+      this._pipelineCreatePromise = null;
     }
-    return {
-      eyepopUrl: session.eyepopUrl,
-      accessToken: session.accessToken,
-      validUntil: session.validUntil,
-      popId: this.options().popId,
-      accountId: this._accountId ?? this.options().accountId,
-      baseUrl: this._baseUrl,
-      pipelineId: this._pipelineId || void 0,
-      authenticationHeaders: () => this._authenticationHeaders(session)
-    };
   }
-  popName() {
-    return this._popName;
+  async changeTransientPop(pop) {
+    if (!this.ctx.client()) {
+      throw new Error("endpoint not initialized");
+    }
+    const previousPop = this.ctx.options.pop;
+    const previousBaseUrl = this._baseUrl;
+    const previousSessionAccessToken = this._sessionAccessToken;
+    const previousSessionAccessTokenValidUntil = this._sessionAccessTokenValidUntil;
+    if (this._pipelineId) {
+      await this.deleteTransientPipeline(this._pipelineId);
+      this._pipelineId = null;
+    }
+    this._pipeline = null;
+    try {
+      this.ctx.options.pop = pop;
+      await this.getComputeSession();
+    } catch (error) {
+      this.ctx.options.pop = previousPop;
+      this._pipeline = null;
+      this._pipelineId = null;
+      this._baseUrl = previousPop ? null : previousBaseUrl;
+      this._sessionAccessToken = previousSessionAccessToken;
+      this._sessionAccessTokenValidUntil = previousSessionAccessTokenValidUntil;
+      throw error;
+    }
+    if (!this._pipelineId) {
+      throw new Error("Compute session did not provide a pipeline for the requested pop");
+    }
+    this.setTransientPipelinePop();
   }
-  pop() {
-    if (this._pipeline) {
-      return this._pipeline.pop || null;
+  async deleteTransientPipeline(pipelineId) {
+    const client = this.ctx.client();
+    if (!client || !this._baseUrl) {
+      return;
+    }
+    const deleteUrl = `${this._baseUrl}/pipelines/${pipelineId}`;
+    const headers = {
+      Authorization: await this.authorizationHeader()
+    };
+    let response = await client.fetch(deleteUrl, {
+      method: "DELETE",
+      headers
+    });
+    if (response.status >= 300) {
+      const message = await response.text();
+      this.ctx.logger.info(`stopping pipeline failed, status ${response.status}: ${message}`);
     }
-    return this.options().pop || null;
   }
-  async changePop(pop) {
-    validatePop(pop);
-    if (this.options().popId == "transient" /* Transient */) {
-      await this.changeTransientPop(pop);
-      return;
+  async authorizationHeader() {
+    if (this._sessionAccessToken) {
+      return `Bearer ${this._sessionAccessToken}`;
     }
-    const client = this._client;
-    const baseUrl = this._baseUrl;
-    if (!baseUrl || !client) {
-      return Promise.reject("endpoint not connected, use connect()");
+    return this.ctx.credentialHeader();
+  }
+  async computeAuthorizationHeader() {
+    const auth = resolveAuth(this.ctx.options);
+    if (auth?.isLocal !== void 0) {
+      return "Implicit";
     }
-    let response = await this.fetchWithRetry(async () => {
-      const session = await this.session();
-      let headers = {
-        "Content-Type": "application/json",
-        ...this._authenticationHeaders(session)
-      };
-      const patch_url = `${session.baseUrl}/pipelines/${session.pipelineId}/pop`;
-      return await client.fetch(patch_url, {
-        method: "PATCH",
-        body: JSON.stringify(pop),
-        headers
-      });
-    });
-    if (response.status != 204) {
-      const message = await response.text();
-      throw new Error(`Unexpected status ${response.status}: ${message}`);
+    const credential = apiKeyCredential(auth) ?? accessTokenCredential(auth);
+    if (credential !== void 0) {
+      return `Bearer ${credential}`;
     }
-    this.options().pop = pop;
-    if (this._pipeline) {
-      this._pipeline.pop = pop;
-    } else {
+    return this.ctx.credentialHeader();
+  }
+  setTransientPipelinePop() {
+    const pop = this.ctx.options.pop;
+    if (pop && this._pipelineId) {
       this._pipeline = {
-        id: this._pipelineId || "unknown",
+        id: this._pipelineId,
         state: "idle",
         startTime: (/* @__PURE__ */ new Date()).toString(),
         pop
       };
     }
   }
-  _authenticationHeaders(session) {
-    return resolveAuth(this._options)?.isLocal !== void 0 ? {} : { Authorization: `Bearer ${session.accessToken}` };
+};
+_SessionBackend.WAIT_FOR_IS_READY = 60 * 1e3;
+var SessionBackend = _SessionBackend;
+
+// shims/websockets.ts
+var createWebSocket;
+var UpgradeError = class extends Error {
+  constructor(message, status, retryAfter) {
+    super(message);
+    this.name = "UpgradeError";
+    this.status = status;
+    this.retryAfter = retryAfter;
   }
-  /**
-   * @deprecated Pop ids are only retained for backwards compatibility.
-   * Configure transient sessions with `WorkerOptions.pop`.
-   */
-  popId() {
-    return this.options().popId || null;
+};
+var openAuthorizedWebSocket;
+var isBrowser = "document" in globalThis && "implementation" in globalThis.document;
+if (isBrowser) {
+  createWebSocket = (url, protocols) => {
+    return new WebSocket(url, protocols);
+  };
+  openAuthorizedWebSocket = (url, protocol, token) => {
+    const protocols = token === void 0 ? [protocol] : [protocol, `eyepop.bearer.${token}`];
+    const ws = new WebSocket(url, protocols);
+    ws.binaryType = "arraybuffer";
+    return new Promise((resolve, reject) => {
+      ws.onopen = () => resolve(ws);
+      ws.onerror = () => reject(new UpgradeError(`could not open ${url}`));
+    });
+  };
+} else {
+  createWebSocket = (url, protocols) => {
+    const ws = __require("ws");
+    return new ws.WebSocket(url, protocols);
+  };
+  openAuthorizedWebSocket = (url, protocol, token) => {
+    const ws = __require("ws");
+    const headers = token === void 0 ? {} : { Authorization: `Bearer ${token}` };
+    const socket = new ws.WebSocket(url, [protocol], { headers, maxPayload: 0 });
+    socket.binaryType = "arraybuffer";
+    return new Promise((resolve, reject) => {
+      socket.once("open", () => resolve(socket));
+      socket.once("unexpected-response", (_request, response) => {
+        const retryAfter = Number.parseFloat(response.headers?.["retry-after"]);
+        reject(new UpgradeError(`the pipeline API answered the upgrade ${response.statusCode}`, response.statusCode, Number.isFinite(retryAfter) ? retryAfter : void 0));
+        response.resume();
+        socket.terminate();
+      });
+      socket.once("error", (error) => reject(new UpgradeError(`could not open ${url}: ${error.message}`)));
+    });
+  };
+}
+
+// worker/pipeline_backend.ts
+var PIPELINE_PATH = "/api/v1/pipeline";
+var SUBPROTOCOL = "eyepop.v1";
+var MAX_OPEN_SOURCES = 256;
+var COMBINED_UPLOAD_MAX_BYTES = 8 * 1024 * 1024;
+var CHUNK = 1;
+var COMBINED = 2;
+var CHUNK_BYTES = 64 * 1024;
+var HEARTBEAT_MS = 20 * 1e3;
+var MAX_RETRY_MS = 30 * 1e3;
+var RECONNECT_AT_ONCE = /* @__PURE__ */ new Set(["1008 credential_expired", "1011 overloaded", "1001 shutting_down"]);
+var MAX_RECONNECT_DELAY_MS = 30 * 1e3;
+var PipelineConfigurationError = class extends Error {
+  constructor(problem, message, options = []) {
+    super(message);
+    this.name = "PipelineConfigurationError";
+    this.problem = problem;
+    this.options = options;
   }
-  async process(param1, param2) {
-    if (param1.source !== void 0) {
-      return await this.processV2(param1);
-    } else {
-      return await this.processV1(param1, param2);
-    }
+};
+var PipelineSocketClosedError = class extends Error {
+  constructor(code, reason) {
+    super(`the pipeline API closed the socket: ${code ?? ""} ${reason}`.trim());
+    this.name = "PipelineSocketClosedError";
+    this.code = code;
+    this.reason = reason;
   }
-  async processV1(source, params) {
-    if (source.file !== void 0) {
-      return this.uploadFile(source, { componentParams: params });
-    } else if (source.stream !== void 0) {
-      return this.uploadStream(source, { componentParams: params });
-    } else if (source.path !== void 0) {
-      return this.uploadPath(source, { componentParams: params });
-    } else if (source.url !== void 0) {
-      return this.loadFrom(source, { componentParams: params });
-    } else if (source.assetUuid !== void 0) {
-      return this.loadFromAssetUuid(source, { componentParams: params });
-    } else if (source.mediaStream !== void 0) {
-      return this.loadMediaStream(source, { componentParams: params });
-    } else {
-      return Promise.reject("unknown source type");
-    }
+};
+var PipelineCommandError = class extends Error {
+  constructor(error, detail = "") {
+    super(`the pipeline API refused the command: ${error} ${detail}`.trim());
+    this.name = "PipelineCommandError";
+    this.error = error;
+    this.detail = detail;
   }
-  /**
-   * Reject a source's calibration before any work is started for it.
-   *
-   * Called by every entry point that takes ProcessParams rather than at the
-   * one boundary they share, because they have none: the group methods build
-   * their jobs directly instead of going through processV2. It runs before
-   * the concurrency limit is acquired, so a request that can never be sent
-   * does not hold a slot.
-   */
-  validateProcessParams(params) {
-    if (params.camera !== void 0) {
-      validateCamera(params.camera);
-    }
+};
+var PipelineSourceError = class extends Error {
+  constructor(sourceId, reason, detail = "") {
+    super(`Error in source ${sourceId}: ${reason} ${detail}`.trim());
+    this.name = "PipelineSourceError";
+    this.sourceId = sourceId;
+    this.reason = reason;
+    this.detail = detail;
   }
-  async processV2(request) {
-    this.validateProcessParams(request);
-    if (request.source.file !== void 0) {
-      return this.uploadFile(request.source, request);
-    } else if (request.source.stream !== void 0) {
-      return this.uploadStream(request.source, request);
-    } else if (request.source.path !== void 0) {
-      return this.uploadPath(request.source, request);
-    } else if (request.source.url !== void 0) {
-      return this.loadFrom(request.source, request);
-    } else if (request.source.assetUuid !== void 0) {
-      return this.loadFromAssetUuid(request.source, request);
-    } else if (request.source.mediaStream !== void 0) {
-      return this.loadMediaStream(request.source, request);
+};
+var CANCELLED = /* @__PURE__ */ Symbol("cancelled");
+var Inbox = class {
+  constructor() {
+    this._items = [];
+    this._waiter = null;
+  }
+  push(item) {
+    const waiter = this._waiter;
+    if (waiter) {
+      this._waiter = null;
+      waiter(item);
     } else {
-      return Promise.reject("unknown source type");
+      this._items.push(item);
     }
   }
-  async uploadGroup(paths, params = {}) {
-    if (paths.length === 0) {
-      throw new Error("upload group requires at least one path");
+  next() {
+    const item = this._items.shift();
+    if (item !== void 0) {
+      return Promise.resolve(item);
     }
-    this.validateProcessParams(params);
-    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      throw new Error("endpoint not connected, use connect()");
+    return new Promise((resolve) => this._waiter = resolve);
+  }
+};
+var UploadEnded = class extends Error {
+};
+var Credit = class {
+  constructor() {
+    this._credit = 0;
+    this._ended = false;
+    this._waiter = null;
+  }
+  grant(n) {
+    this._credit += n;
+    this.wake();
+  }
+  end() {
+    this._ended = true;
+    this.wake();
+  }
+  async take(most) {
+    while (this._credit <= 0 && !this._ended) {
+      await new Promise((resolve) => this._waiter = resolve);
     }
-    await this._limit.acquire();
-    try {
-      this.updateState();
-      const sources = await Promise.all(
-        paths.map(async (path2) => {
-          let streamSource;
-          if (this._options.platformSupport?.resolvePath) {
-            streamSource = await this._options.platformSupport.resolvePath({ path: path2 }, this._logger);
-          } else {
-            streamSource = await resolvePath({ path: path2 }, this._logger);
-          }
-          return { stream: streamSource.stream, mimeType: streamSource.mimeType };
-        })
-      );
-      const job = new UploadGroupJob(sources, params, async () => this.session(), this._client, this._requestLogger);
-      return job.start(
-        () => {
-          this.jobDone(job);
-        },
-        (statusCode) => {
-          this.jobStatus(job, statusCode);
-        }
-      );
-    } catch (e) {
-      this._limit.release();
-      throw e;
+    if (this._ended) {
+      throw new UploadEnded();
     }
+    const n = Math.min(most, this._credit);
+    this._credit -= n;
+    return n;
   }
-  async uploadStreamGroup(streams, mimeTypes, params = {}) {
-    if (streams.length === 0) {
-      throw new Error("upload stream group requires at least one stream");
+  wake() {
+    const waiter = this._waiter;
+    this._waiter = null;
+    waiter?.();
+  }
+};
+var OpenSource = class {
+  constructor(id) {
+    this.id = id;
+    this.inbox = new Inbox();
+    this.uploads = /* @__PURE__ */ new Map();
+  }
+  close(error) {
+    this.uploads.forEach((upload) => upload.end());
+    this.inbox.push(error);
+  }
+};
+var PipelineSocket = class {
+  constructor(ws) {
+    this.ws = ws;
+    this.sources = /* @__PURE__ */ new Map();
+    this.commands = /* @__PURE__ */ new Map();
+    this._closed = false;
+    this.closed = new Promise((resolve) => this._markClosed = resolve);
+  }
+  get open() {
+    return !this._closed && this.ws.readyState === 1;
+  }
+  markClosed() {
+    this._closed = true;
+    this._markClosed();
+  }
+  sendJson(message) {
+    this.ws.send(JSON.stringify(message));
+  }
+  sendBytes(data) {
+    this.ws.send(data);
+  }
+};
+var PipelineJob = class {
+  constructor(source, media, live, params, mediaStream = void 0) {
+    this.source = source;
+    this.media = media;
+    this.live = live;
+    this.params = params;
+    this.mediaStream = mediaStream;
+    this._results = new Inbox();
+    this._consumed = false;
+    this._cancelled = false;
+    this.openSource = null;
+    // Stops the job's source on the pipeline, once it was sent.
+    this.stopOnPipeline = null;
+  }
+  get cancelled() {
+    return this._cancelled;
+  }
+  command(id) {
+    const command = { type: "setSource", id, ...this.source };
+    if (this.params.componentParams !== void 0) {
+      command["params"] = this.params.componentParams;
     }
-    if (mimeTypes !== void 0 && mimeTypes.length !== streams.length) {
-      throw new Error("mimeTypes must have the same length as streams");
+    if (this.params.roi !== void 0) {
+      command["roi"] = this.params.roi;
     }
-    this.validateProcessParams(params);
-    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      throw new Error("endpoint not connected, use connect()");
+    if (this.params.camera !== void 0) {
+      command["camera"] = this.params.camera;
     }
-    await this._limit.acquire();
-    try {
-      this.updateState();
-      const sources = streams.map((stream, i) => ({
-        stream,
-        mimeType: mimeTypes?.[i] ?? null
-      }));
-      const job = new UploadGroupJob(sources, params, async () => this.session(), this._client, this._requestLogger);
-      return job.start(
-        () => {
-          this.jobDone(job);
-        },
-        (statusCode) => {
-          this.jobStatus(job, statusCode);
-        }
-      );
-    } catch (e) {
-      this._limit.release();
-      throw e;
+    if (this.params.fps !== void 0) {
+      command["fps"] = this.params.fps;
     }
+    return command;
   }
-  async loadFromGroup(urls, params = {}) {
-    if (urls.length === 0) {
-      throw new Error("load from group requires at least one url");
-    }
-    this.validateProcessParams(params);
-    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      throw new Error("endpoint not connected, use connect()");
-    }
-    await this._limit.acquire();
-    try {
-      this.updateState();
-      const job = new LoadFromGroupJob(urls, params, async () => this.session(), this._client, this._requestLogger);
-      return job.start(
-        () => {
-          this.jobDone(job);
-        },
-        (statusCode) => {
-          this.jobStatus(job, statusCode);
-        }
-      );
-    } catch (e) {
-      this._limit.release();
-      throw e;
+  predicted(prediction) {
+    if (!this._cancelled) {
+      this._results.push(prediction);
     }
   }
-  async uploadFile(source, params) {
-    await this.ensureTransientPipelineStarted();
-    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      return Promise.reject("endpoint not connected, use connect()");
-    }
-    await this._limit.acquire();
-    try {
-      this.updateState();
-      const job = new UploadJob(
-        source.file,
-        source.file.type,
-        source.file.size,
-        source.videoMode,
-        params,
-        async () => {
-          return this.session();
-        },
-        this._client,
-        this._requestLogger
-      );
-      return job.start(
-        () => {
-          this.jobDone(job);
-        },
-        (statusCode) => {
-          this.jobStatus(job, statusCode);
-        }
-      );
-    } catch (e) {
-      this._limit.release();
-      throw e;
+  finish(error = null) {
+    if (error !== null) {
+      this._results.push(error);
     }
+    this._results.push(null);
   }
-  async uploadStream(source, params) {
-    await this.ensureTransientPipelineStarted();
-    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      return Promise.reject("endpoint not connected, use connect()");
-    }
-    await this._limit.acquire();
-    try {
-      this.updateState();
-      const job = new UploadJob(
-        source.stream,
-        source.mimeType,
-        source.size,
-        source.videoMode,
-        params,
-        async () => {
-          return this.session();
-        },
-        this._client,
-        this._requestLogger
-      );
-      return job.start(
-        () => {
-          this.jobDone(job);
-        },
-        (statusCode) => {
-          this.jobStatus(job, statusCode);
-        }
-      );
-    } catch (e) {
-      this._limit.release();
-      throw e;
+  cancel() {
+    if (this._cancelled) {
+      return;
     }
+    this._cancelled = true;
+    this._results.push(null);
+    this.openSource?.inbox.push(CANCELLED);
+    this.stopOnPipeline?.();
   }
-  async uploadPath(source, params) {
-    await this.ensureTransientPipelineStarted();
-    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      throw new Error("endpoint not connected, use connect()");
+  async *[Symbol.asyncIterator]() {
+    if (this._consumed) {
+      throw new Error("Cannot iterate over a consumed stream");
     }
-    await this._limit.acquire();
-    try {
-      this.updateState();
-      const resolveStreamSource = async () => {
-        if (this._options.platformSupport?.resolvePath) {
-          return await this._options.platformSupport.resolvePath(source, this._logger);
-        }
-        return await resolvePath(source, this._logger);
-      };
-      const streamSource = await resolveStreamSource();
-      let firstStreamPending = true;
-      const uploadBodyFactory = async () => {
-        if (firstStreamPending) {
-          firstStreamPending = false;
-          return streamSource.stream;
-        }
-        return (await resolveStreamSource()).stream;
-      };
-      const job = new UploadJob(
-        streamSource.stream,
-        streamSource.mimeType,
-        streamSource.size,
-        source.videoMode,
-        params,
-        async () => {
-          return this.session();
-        },
-        this._client,
-        this._requestLogger,
-        uploadBodyFactory
-      );
-      return job.start(
-        () => {
-          this.jobDone(job);
-        },
-        (statusCode) => {
-          this.jobStatus(job, statusCode);
-        }
-      );
-    } catch (e) {
-      this._limit.release();
-      throw e;
+    this._consumed = true;
+    while (true) {
+      const item = await this._results.next();
+      if (item === null) {
+        return;
+      }
+      if (item instanceof Error) {
+        throw item;
+      }
+      yield item;
     }
   }
-  async loadFrom(source, params) {
-    if (source.url.startsWith("file://")) {
-      return await this.uploadPath(
-        {
-          path: source.url.substring("file://".length)
-        },
-        params
-      );
+};
+var PipelineBackend = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this._pipelineApiUrl = null;
+    this._socket = null;
+    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;
+    // Reconnects at once since a source last played.
+    this._reconnects = 0;
+    this._currentPop = ctx.options.pop ?? null;
+  }
+  // Connection
+  async reconnect() {
+    this._disconnecting = false;
+    await this.inOrder(() => this.ensureSocket());
+    this.ctx.updateState();
+  }
+  async disconnect(closeEndpoint) {
+    await closeEndpoint();
+    this._disconnecting = true;
+    if (this._heartbeat !== null) {
+      clearInterval(this._heartbeat);
+      this._heartbeat = null;
     }
-    await this.ensureTransientPipelineStarted();
-    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      throw new Error("endpoint not connected, use connect()");
+    const socket = this._socket;
+    this._socket = null;
+    if (socket !== null) {
+      socket.ws.close(1e3);
+      await socket.closed;
     }
-    await this._limit.acquire();
-    try {
-      this.updateState();
-      const job = new LoadFromJob(
-        source.url,
-        params,
-        async () => {
-          return this.session();
-        },
-        this._client,
-        this._requestLogger
-      );
-      return job.start(
-        () => {
-          this.jobDone(job);
-        },
-        (statusCode) => {
-          this.jobStatus(job, statusCode);
-        }
-      );
-    } catch (e) {
-      this._limit.release();
-      throw e;
+  }
+  onStatus(_statusCode) {
+  }
+  popName() {
+    return null;
+  }
+  async authorizationHeader() {
+    return this.ctx.credentialHeader();
+  }
+  inOrder(work) {
+    const result = this._sendChain.then(work);
+    this._sendChain = result.catch(() => void 0);
+    return result;
+  }
+  /** The 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;
     }
+    if (this._connecting === null) {
+      this._connecting = this.openSocket().finally(() => this._connecting = null);
+    }
+    return await this._connecting;
   }
-  async loadFromAssetUuid(source, params) {
-    await this.ensureTransientPipelineStarted();
-    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      throw new Error("endpoint not connected, use connect()");
+  async openSocket() {
+    if (this.ctx.client() === null) {
+      throw new PipelineSocketClosedError(void 0, "the endpoint is not connected");
     }
-    await this._limit.acquire();
-    try {
-      this.updateState();
-      const job = new LoadFromAssetUuidJob(
-        source.assetUuid,
-        params,
-        async () => {
-          return this.session();
-        },
-        this._client,
-        this._requestLogger
-      );
-      return job.start(
-        () => {
-          this.jobDone(job);
-        },
-        (statusCode) => {
-          this.jobStatus(job, statusCode);
+    const ws = await this.upgrade(await this.socketUrl());
+    const socket = new PipelineSocket(ws);
+    ws.onmessage = (event) => {
+      if (typeof event.data === "string") {
+        try {
+          this.dispatch(socket, JSON.parse(event.data));
+        } catch (error) {
+          this.ctx.logger.warn("unreadable message from the pipeline API: %s", error);
         }
-      );
-    } catch (e) {
-      this._limit.release();
-      throw e;
+      }
+    };
+    ws.onerror = () => {
+    };
+    ws.onclose = (event) => this.closed(socket, event.code, event.reason);
+    this._socket = socket;
+    this.startHeartbeat(ws);
+    if (this._currentPop !== null) {
+      try {
+        await this.setPopOn(socket, this._currentPop);
+      } catch (error) {
+        this._socket = null;
+        ws.close(1e3);
+        throw error;
+      }
     }
+    return socket;
   }
-  async loadMediaStream(source, params) {
-    await this.ensureTransientPipelineStarted();
-    if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      throw new Error("endpoint not connected, use connect()");
+  startHeartbeat(ws) {
+    if (this._heartbeat !== null) {
+      clearInterval(this._heartbeat);
     }
-    await this._limit.acquire();
-    try {
-      this.updateState();
-      const job = new LoadMediaStreamJob(
-        source.mediaStream,
-        params,
-        async () => {
-          return this.session();
-        },
-        this._client,
-        this._requestLogger
-      );
-      return job.start(
-        () => {
-          this.jobDone(job);
-        },
-        (statusCode) => {
-          this.jobStatus(job, statusCode);
+    const ping = ws.ping;
+    if (typeof ping === "function") {
+      this._heartbeat = setInterval(() => {
+        if (ws.readyState === 1) {
+          ping.call(ws);
         }
-      );
-    } catch (e) {
-      this._limit.release();
-      throw e;
+      }, HEARTBEAT_MS);
+      this._heartbeat.unref?.();
     }
   }
-  jobDone(_) {
-    this._limit?.release();
-    this.updateState();
+  async socketUrl() {
+    if (this._pipelineApiUrl === null) {
+      const base = this.ctx.options.isLocalMode ? this.ctx.eyepopUrl() : new URL(await this.configuredPipelineApiUrl(), this.ctx.eyepopUrl() + "/").toString();
+      this._pipelineApiUrl = checkedUrl(base);
+    }
+    return "ws" + this._pipelineApiUrl.slice("http".length) + PIPELINE_PATH;
   }
-  jobStatus(_, statusCode) {
-    if (statusCode == 404) {
-      this.statusHandler404(statusCode);
-    } else if (statusCode == 401) {
-      this.statusHandler401(statusCode);
+  async configuredPipelineApiUrl() {
+    const client = this.ctx.client();
+    if (client === null) {
+      throw new Error("endpoint not connected");
+    }
+    let configUrl = `${this.ctx.eyepopUrl()}/v1/configs`;
+    const accountId = this.ctx.options.accountId;
+    if (accountId) {
+      configUrl += `?account_uuid=${encodeURIComponent(accountId)}`;
+    }
+    const response = await this.ctx.fetchWithRetry(async () => client.fetch(configUrl, { headers: { Authorization: await this.ctx.credentialHeader() } }));
+    if (!response.ok) {
+      throw new Error(`Unexpected status ${response.status} for GET ${configUrl}: ${await response.text()}`);
+    }
+    const config = await response.json();
+    const url = config?.["pipeline_api_url"];
+    if (!url) {
+      throw new PipelineConfigurationError("no_pipeline_api_url", `${configUrl} has no pipeline_api_url: this compute API serves no pipeline API`);
+    }
+    return url;
+  }
+  async token() {
+    if (resolveAuth(this.ctx.options)?.isLocal !== void 0) {
+      return void 0;
     }
+    return (await this.ctx.credentialHeader()).replace(/^Bearer /, "");
   }
-  async reconnect() {
-    if (this.options().popId == "transient" /* Transient */) {
-      await this.getComputeSession();
-      if (this.options().pop) {
-        this.setTransientPipelinePop();
+  /** Open the socket, waiting through 503 with Retry-After and exchanging the API key again after a 401. */
+  async upgrade(url) {
+    const deadline = Date.now() + MAX_RETRY_MS;
+    let rejected = false;
+    while (true) {
+      try {
+        this.ctx.requestLogger.debug("before upgrade %s", url);
+        return await openAuthorizedWebSocket(url, SUBPROTOCOL, await this.token());
+      } catch (error) {
+        if (!(error instanceof UpgradeError)) {
+          throw error;
+        }
+        if (error.status === 401 && !rejected) {
+          this.ctx.requestLogger.debug("the pipeline API answered 401, authenticating again");
+          rejected = true;
+          this.ctx.forgetCredential();
+          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) {
+          throw error;
+        }
+        this.ctx.requestLogger.info("the pipeline API answered 503, retrying in %d ms", wait);
+        await new Promise((resolve) => setTimeout(resolve, wait));
       }
-    } else if (this.options().sessionUuid) {
-      await this.getComputeSession();
-    } else {
-      await this.startWebApiSessionWithPopId();
     }
-    this.updateState();
-    return Promise.resolve(this);
   }
-  async startWebApiSessionWithPopId() {
-    if (!this._client) {
-      throw new Error("endpoint not initialized");
+  closed(socket, code, reason) {
+    socket.markClosed();
+    if (this._socket === socket) {
+      this._socket = null;
     }
-    const config_url = `${this.eyepopWebApiUrl()}/pops/${this.options().popId}/config?auto_start=false`;
-    const headers = {
-      Authorization: await this.authorizationHeader()
-    };
-    this.updateState("FetchConfig" /* FetchConfig */);
-    let response = await this._client.fetch(config_url, { headers });
-    if (response.status == 401) {
-      this._requestLogger.debug("GET %s: 401, about to retry with fresh access token", config_url);
-      this.statusHandler401(response.status);
-      const headers2 = {
-        Authorization: await this.authorizationHeader()
-      };
-      this.updateState("FetchConfig" /* FetchConfig */);
-      response = await this._client.fetch(config_url, {
-        headers: headers2
-      });
+    const error = new PipelineSocketClosedError(code, reason);
+    socket.sources.forEach((source) => source.close(error));
+    socket.commands.forEach((command) => command.reject(error));
+    socket.commands.clear();
+    if (this._disconnecting) {
+      return;
     }
-    if (response.status != 200) {
-      const message = await response.text();
-      if (response.status == 429) {
-        this.updateState("NotAvailable" /* NotAvailable */, message);
-      } else {
-        this.updateState("Error" /* Error */, message);
+    this.ctx.requestLogger.debug("the pipeline API closed the socket: %s %s", code, reason);
+    if (RECONNECT_AT_ONCE.has(`${code} ${reason}`)) {
+      if (reason === "credential_expired") {
+        this.ctx.forgetCredential();
       }
-      throw new Error(`Unexpected status ${response.status}: ${message}`);
-    }
-    let config = await response.json();
-    if (!config.base_url && this.options().autoStart) {
-      const auto_start_config_url = `${this.eyepopWebApiUrl()}/pops/${this.options().popId}/config?auto_start=true`;
-      this._requestLogger.debug("pop was not running, trying to autostart with: %s", auto_start_config_url);
-      const headers2 = {
-        Authorization: await this.authorizationHeader()
-      };
-      response = await this._client.fetch(auto_start_config_url, {
-        headers: headers2
+      const delay = this._reconnects === 0 ? 0 : Math.min(1e3 * 2 ** (this._reconnects - 1), MAX_RECONNECT_DELAY_MS);
+      this._reconnects += 1;
+      new Promise((resolve) => setTimeout(resolve, delay)).then(() => this._disconnecting ? void 0 : this.inOrder(() => this.ensureSocket())).catch((error2) => {
+        this.ctx.requestLogger.info("could not reopen the pipeline API socket: %s", error2);
       });
-      if (response.status != 200) {
-        this.updateState("Error" /* Error */);
-        const message = await response.text();
-        throw new Error(`Unexpected status ${response.status}: ${message}`);
+    }
+  }
+  dispatch(socket, message) {
+    const type = message["type"];
+    const id = message["id"];
+    const source = typeof id === "string" ? socket.sources.get(id) : void 0;
+    if (type === "send" || type === "credit") {
+      const upload = source?.uploads.get(message["member"] ?? null);
+      upload?.grant(Number(type === "send" ? message["credit"] : message["bytes"]));
+      return;
+    }
+    const command = typeof id === "string" ? socket.commands.get(id) : void 0;
+    if (command !== void 0) {
+      socket.commands.delete(id);
+      if (type === "error") {
+        command.reject(new PipelineCommandError(message["error"] ?? "", message["message"] ?? ""));
+      } else {
+        command.resolve(message);
       }
-      config = await response.json();
+      return;
     }
-    const baseUrl = new URL(config.base_url, this.eyepopUrl());
-    this._baseUrl = baseUrl.toString();
-    if (this._baseUrl) {
-      this._baseUrl = this._baseUrl.replace(/\/+$/, "");
-      this._pipelineId = config.pipeline_id;
-      this._popName = config.name;
-      if (!this._pipelineId || !this._baseUrl) {
-        throw new Error("Pop not started");
+    if (source !== void 0) {
+      if (type === "start") {
+        this._reconnects = 0;
       }
-      const get_url = `${this._baseUrl}/pipelines/${this._pipelineId}`;
-      const headers2 = {
-        Authorization: await this.authorizationHeader()
-      };
-      let response2 = await this._client.fetch(get_url, {
-        method: "GET",
-        headers: headers2
-      });
-      if (response2.status > 200) {
-        const message = await response2.text();
-        throw new Error(`Unexpected status ${response2.status}: ${message}`);
+      if (type === "end") {
+        source.uploads.forEach((upload) => upload.end());
       }
-      this._pipeline = await response2.json();
-      if (this.options().stopJobs) {
-        const body = { sourceType: "NONE" };
-        const headers3 = {
-          Authorization: await this.authorizationHeader(),
-          "Content-Type": "application/json"
-        };
-        const stop_url = `${this._baseUrl}/pipelines/${this._pipeline.id}/source?mode=preempt&processing=sync`;
-        let response3 = await this._client.fetch(stop_url, {
-          method: "PATCH",
-          headers: headers3,
-          body: JSON.stringify(body)
-        });
-        if (response3.status >= 300) {
-          const message = await response3.text();
-          throw new Error(`Unexpected status ${response3.status}: ${message}`);
-        }
+      source.inbox.push(message);
+    } else if (type === "error") {
+      if (id === void 0) {
+        this.ctx.logger.warn("the pipeline API refused a message: %s %s", message["error"], message["message"]);
+      } else {
+        this.ctx.requestLogger.debug("the pipeline API refused a command for %s: %s %s", id, message["error"], message["message"]);
       }
     }
   }
-  sessionReadyTimeoutMs() {
-    const seconds = this.options().sessionReadyTimeoutSeconds;
-    return typeof seconds == "number" && Number.isFinite(seconds) && seconds > 0 ? seconds * 1e3 : _WorkerEndpoint.WAIT_FOR_IS_READY;
+  newId(prefix) {
+    this._nextId += 1;
+    return `${prefix}-${this._nextId}`;
   }
-  async getComputeSession() {
-    if (!this._client) {
-      throw new Error("endpoint not initialized");
+  /** Send a command that is answered by `result` or `error` under its id. */
+  command(socket, message) {
+    const id = this.newId(message["type"]);
+    return new Promise((resolve, reject) => {
+      socket.commands.set(id, { resolve, reject });
+      socket.sendJson({ ...message, id });
+    });
+  }
+  // Pop
+  pop() {
+    return this._currentPop;
+  }
+  /** Set the pop on the socket's pipeline; a pop it refuses rejects, and the last pop it took stays. */
+  async changePop(pop) {
+    if (this.ctx.client() === null) {
+      this._currentPop = pop;
+      return;
     }
-    let resolved;
-    try {
-      resolved = await new ComputeSessionClient({
-        computeUrl: this.eyepopUrl(),
-        httpClient: this._client,
-        authorizationHeader: () => this.computeAuthorizationHeader(),
-        sessionUuid: this.options().sessionUuid,
-        sessionName: this.options().sessionName,
-        accountId: this.options().accountId,
-        pipelineImage: this.options().pipelineImage,
-        pipelineVersion: this.options().pipelineVersion,
-        pop: this.options().pop,
-        readyTimeoutMs: this.sessionReadyTimeoutMs(),
-        logger: this._logger,
-        requestLogger: this._requestLogger
-      }).resolve();
-    } catch (error) {
-      this.updateState("Error" /* Error */);
-      throw error;
+    await this.inOrder(async () => {
+      if (this._socket !== null && this._socket.open) {
+        await this.setPopOn(this._socket, pop);
+        this._currentPop = pop;
+        return;
+      }
+      const previous = this._currentPop;
+      this._currentPop = pop;
+      try {
+        await this.ensureSocket();
+      } catch (error) {
+        this._currentPop = previous;
+        throw error;
+      }
+    });
+  }
+  async setPopOn(socket, pop) {
+    await this.command(socket, { type: "setPop", pop });
+  }
+  // Jobs
+  async submit(work) {
+    if (this.ctx.client() === null) {
+      throw new Error("endpoint not connected, use connect()");
     }
-    this._sessionAccessToken = resolved.accessToken;
-    this._sessionAccessTokenValidUntil = resolved.accessTokenValidUntil;
-    this._baseUrl = resolved.session.session_endpoint;
-    this._accountId = resolved.session.account_uuid || void 0;
-    this._pipeline = null;
-    this._pipelineId = resolved.pipelineId;
-    if (this.options().pop) {
-      this.setTransientPipelinePop();
+    const sourceOptions = work.kind === "source" ? work.source : void 0;
+    this.notSent({ motionDetect: work.params.motionDetect, videoMode: sourceOptions?.videoMode, rtspForceNonCompliantUrl: work.params.rtspForceNonCompliantUrl });
+    const job = await this.jobOf(work);
+    const limit = this.ctx.limit();
+    await limit.acquire();
+    this.ctx.updateState();
+    this.run(job).then(
+      () => job.finish(),
+      (error) => job.finish(error instanceof Error ? error : new Error(String(error)))
+    ).finally(() => this.ctx.jobDone());
+    return job;
+  }
+  notSent(options) {
+    for (const [name, value] of Object.entries(options)) {
+      if (value === void 0 || this._warned.has(name)) {
+        continue;
+      }
+      this._warned.add(name);
+      const ticket = name === "rtspForceNonCompliantUrl" ? "" : " (AWSU-317)";
+      this.ctx.logger.warn(`${name} is not sent to the pipeline API and has no effect in pipeline mode${ticket}`);
+    }
+  }
+  async jobOf(work) {
+    switch (work.kind) {
+      case "source":
+        return await this.sourceJob(work.source, work.params);
+      case "uploadGroup": {
+        const media = await Promise.all(work.paths.map((path2) => this.pathMedia({ path: path2 })));
+        return new PipelineJob(uploadGroup(media), media, false, work.params);
+      }
+      case "uploadStreamGroup": {
+        const media = work.streams.map((stream, i) => bodyMedia(stream, work.mimeTypes?.[i] ?? "application/octet-stream", void 0));
+        return new PipelineJob(uploadGroup(media), media, false, work.params);
+      }
+      case "loadFromGroup":
+        return new PipelineJob({ group: work.urls.map((url) => ({ url })) }, [], false, work.params);
     }
   }
-  async startTransientPipeline() {
-    const client = this._client;
-    const baseUrl = this._baseUrl;
-    if (client == null || baseUrl == null) {
-      throw new Error("endpoint not initialized");
-    }
-    let pop;
-    if (this.options().pop) {
-      pop = this.options().pop;
-    } else if (this._pipeline && this._pipeline.pop) {
-      pop = this._pipeline.pop;
-    } else {
-      throw new Error("Cannot start a transient pipeline without a pop");
+  async sourceJob(source, params) {
+    if (source.file !== void 0) {
+      const file = source.file;
+      const media = bodyMedia(file, file.type || "application/octet-stream", file.size);
+      return new PipelineJob({ upload: { contentType: media.contentType } }, [media], false, params);
+    } else if (source.stream !== void 0) {
+      const stream = source;
+      const media = bodyMedia(stream.stream, stream.mimeType, stream.size ?? knownSize(stream.stream));
+      return new PipelineJob({ upload: { contentType: media.contentType } }, [media], false, params);
+    } else if (source.path !== void 0) {
+      const media = await this.pathMedia(source);
+      return new PipelineJob({ upload: { contentType: media.contentType } }, [media], false, params);
+    } else if (source.url !== void 0) {
+      const url = source.url;
+      if (url.startsWith("file://")) {
+        return await this.sourceJob({ path: url.substring("file://".length) }, params);
+      }
+      return new PipelineJob({ url }, [], /^(rtsp|rtmp):\/\//.test(url), params);
+    } else if (source.assetUuid !== void 0) {
+      return new PipelineJob({ assetUuid: source.assetUuid }, [], false, params);
+    } else if (source.mediaStream !== void 0) {
+      const ingressId = this.newId("whip");
+      return new PipelineJob({ whip: { ingressId } }, [], true, params, source.mediaStream);
     }
-    const body = {
-      pop,
-      source: {
-        sourceType: "NONE"
-      },
-      idleTimeoutSeconds: 30,
-      logging: ["out_meta"],
-      videoOutput: "no_output"
-    };
-    const post_url = `${baseUrl.replace(/\/+$/, "")}/pipelines`;
-    const response = await this.fetchWithRetry(async () => {
-      let headers = {
-        Accept: "application/json",
-        "Content-Type": "application/json",
-        Authorization: await this.authorizationHeader()
-      };
-      return client.fetch(post_url, {
-        method: "POST",
-        body: JSON.stringify(body),
-        headers
-      });
-    });
-    if (response.status != 200) {
-      const message = await response.text();
-      throw new Error(`Unexpected status ${response.status} starting transient pipeline: ${message.slice(0, 300)}`);
+    throw new Error("unknown source type");
+  }
+  async pathMedia(source) {
+    const options = this.ctx.options;
+    const resolve = async () => options.platformSupport?.resolvePath ? await options.platformSupport.resolvePath(source, this.ctx.logger) : await resolvePath(source, this.ctx.logger);
+    const first = await resolve();
+    let firstPending = true;
+    return {
+      contentType: first.mimeType,
+      size: first.size,
+      open: async () => {
+        if (firstPending) {
+          firstPending = false;
+          return first.stream;
+        }
+        return (await resolve()).stream;
+      }
+    };
+  }
+  /** Run the job's source to its end; a live source refused overloaded goes once more on a new socket. */
+  async run(job) {
+    let retried = false;
+    while (true) {
+      const sent = await this.inOrder(() => this.setSource(job));
+      if (sent === null) {
+        return;
+      }
+      const { socket, source } = sent;
+      const uploading = source.uploads.size > 0 ? this.upload(socket, source, job) : Promise.resolve();
+      let whip = null;
+      let overloaded;
+      try {
+        overloaded = await this.follow(job, source, () => {
+          if (job.mediaStream !== void 0) {
+            const fail = (error) => {
+              job.stopOnPipeline?.();
+              source.inbox.push(error instanceof Error ? error : new Error(String(error)));
+            };
+            whip = new SocketWhip(job.mediaStream, job.source["whip"]["ingressId"], (message) => this.command(socket, message), fail, this.ctx.requestLogger);
+            whip.start().catch(fail);
+          }
+        });
+      } finally {
+        job.openSource = null;
+        job.stopOnPipeline = null;
+        socket.sources.delete(source.id);
+        source.uploads.forEach((upload) => upload.end());
+        await uploading;
+        await whip?.close();
+      }
+      if (!overloaded) {
+        return;
+      }
+      if (retried || !job.live) {
+        throw new PipelineCommandError("overloaded", "the pipeline API has no capacity for another live source");
+      }
+      retried = true;
+      await socket.closed;
     }
-    const result = await response.json();
-    return result["id"];
   }
-  async ensureTransientPipelineStarted() {
-    if (this.options().popId != "transient" /* Transient */ || this._pipelineId) {
-      return;
+  /** Send the job's setSource; the caller runs it in submission order. */
+  async setSource(job) {
+    if (job.cancelled) {
+      return null;
     }
-    if (!this.options().pop) {
-      return;
+    const combined = await combinedMedia(job);
+    const socket = await this.ensureSocket();
+    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);
+    job.openSource = source;
+    job.stopOnPipeline = () => {
+      if (socket.open) {
+        socket.sendJson({ type: "stopSource", id: source.id });
+      }
+    };
+    const command = job.command(source.id);
+    if (combined === null) {
+      socket.sendJson(command);
+    } else {
+      socket.sendBytes(combinedMessage(command, combined));
     }
-    if (!this._baseUrl) {
-      await this.reconnect();
+    return { socket, source };
+  }
+  /** Hand the source's predictions to the job until it ends; true when the pipeline API was overloaded. */
+  async follow(job, source, onResult) {
+    while (true) {
+      if (job.cancelled) {
+        return false;
+      }
+      const message = await source.inbox.next();
+      if (message === CANCELLED) {
+        return false;
+      }
+      if (message instanceof Error) {
+        throw message;
+      }
+      switch (message["type"]) {
+        case "result":
+          onResult();
+          break;
+        case "prediction":
+          job.predicted(message["prediction"]);
+          break;
+        case "end":
+          if (message["reason"] === "eos") {
+            return false;
+          }
+          throw new PipelineSourceError(source.id, message["reason"] ?? "", message["message"] ?? "");
+        case "error":
+          if (message["error"] === "overloaded") {
+            return true;
+          }
+          throw new PipelineCommandError(message["error"] ?? "", message["message"] ?? "");
+        case "dropped":
+          this.ctx.requestLogger.debug("the pipeline API dropped %s predictions of a live source", message["count"]);
+          break;
+      }
     }
-    if (this._pipelineId) {
-      return;
+  }
+  /** Send each upload member's bytes in chunks within its credit, then its uploaded. */
+  async upload(socket, source, job) {
+    const keys = uploadKeys(job);
+    try {
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const credit = source.uploads.get(key);
+        for await (let piece of pieces(await job.media[i].open())) {
+          while (piece.length > 0) {
+            const n = await credit.take(Math.min(piece.length, CHUNK_BYTES));
+            const chunk = new Uint8Array(n + 1);
+            chunk[0] = CHUNK;
+            chunk.set(piece.subarray(0, n), 1);
+            socket.sendBytes(chunk);
+            piece = piece.subarray(n);
+          }
+        }
+        socket.sendJson(key === null ? { type: "uploaded", id: source.id } : { type: "uploaded", id: source.id, member: key });
+      }
+    } catch (error) {
+      if (!(error instanceof UploadEnded)) {
+        if (socket.open) {
+          source.inbox.push(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
     }
-    if (this.options().pop) {
-      await this.reconnect();
-      if (!this._pipelineId) {
-        throw new Error("Compute session did not provide a pipeline for the requested pop");
+  }
+  async session() {
+    const token = await this.token();
+    const validUntil = token === void 0 ? Number.MAX_VALUE : Math.min((await this.ctx.credentialSession()).validUntil, Number.MAX_VALUE);
+    return {
+      eyepopUrl: this.ctx.eyepopUrl(),
+      accessToken: token ?? "",
+      validUntil,
+      popId: "transient",
+      accountId: this.ctx.options.accountId,
+      baseUrl: this._pipelineApiUrl ?? void 0,
+      pipelineId: void 0,
+      isPipelineMode: true,
+      authenticationHeaders: () => token === void 0 ? {} : { Authorization: `Bearer ${token}` }
+    };
+  }
+};
+var SocketWhip = class {
+  constructor(_stream, _ingressId, _command, _fail, _logger) {
+    this._stream = _stream;
+    this._ingressId = _ingressId;
+    this._command = _command;
+    this._fail = _fail;
+    this._logger = _logger;
+    this._pc = null;
+    this._answered = false;
+    this._queued = [];
+    this._offerData = null;
+  }
+  async start() {
+    const servers = await this._command({ type: "whipIceServers", ingressId: this._ingressId });
+    const iceServers = servers["iceServers"] ?? [];
+    this._logger.debug("whip %s: ice servers %j", this._ingressId, iceServers.map((server) => server.split(";")[0]));
+    const pc = new RTCPeerConnection({ iceServers: WebrtcBase.linkToIceServers(iceServers.join(", ") || null) });
+    this._pc = pc;
+    pc.oniceconnectionstatechange = () => {
+      this._logger.debug("whip %s: ice connection %s", this._ingressId, pc.iceConnectionState);
+      if (pc.iceConnectionState === "failed" && this._pc === pc) {
+        this._fail(
+          new Error(
+            `the WebRTC connection of whip ingress ${this._ingressId} failed: no candidate pair connected, so the pipeline API is likely reachable through no STUN or TURN server (ice servers: ${iceServers.length})`
+          )
+        );
+      }
+    };
+    pc.onicecandidate = (evt) => {
+      if (evt.candidate !== null) {
+        this.candidate(evt.candidate).catch((error) => this._logger.debug("whipIce failed: %s", error));
       }
+    };
+    this._stream.getTracks().forEach((track) => pc.addTrack(track, this._stream));
+    const offer = await pc.createOffer();
+    if (!offer.sdp) {
+      throw new Error("the local offer has no sdp");
+    }
+    this._offerData = WebrtcBase.parseOffer(offer.sdp);
+    await pc.setLocalDescription(offer);
+    const answer = await this._command({ type: "whipOffer", ingressId: this._ingressId, sdp: offer.sdp });
+    await pc.setRemoteDescription({ type: "answer", sdp: answer["sdp"] });
+    this._answered = true;
+    const queued = this._queued;
+    this._queued = [];
+    if (queued.length > 0) {
+      await this.sendCandidates(queued);
+    }
+  }
+  async candidate(candidate) {
+    if (!this._answered) {
+      this._queued.push(candidate);
       return;
     }
-    if (!this._pipelineCreatePromise) {
-      this._pipelineCreatePromise = this.startTransientPipeline();
+    await this.sendCandidates([candidate]);
+  }
+  async sendCandidates(candidates) {
+    if (this._offerData === null) {
+      return;
     }
+    await this._command({ type: "whipIce", ingressId: this._ingressId, fragment: WebrtcBase.generateSdpFragment(this._offerData, candidates) });
+  }
+  async close() {
+    this._stream.getTracks().forEach((track) => track.stop());
+    const pc = this._pc;
+    this._pc = null;
+    pc?.close();
+  }
+};
+function checkedUrl(url) {
+  const parsed = new URL(url);
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new PipelineConfigurationError("insecure_url", `the pipeline API url ${url} must be an http or https url`);
+  }
+  if (parsed.protocol === "http:" && !isLoopback(parsed.hostname)) {
+    throw new PipelineConfigurationError("insecure_url", `the pipeline API url ${url} must use https unless its host is a loopback address`);
+  }
+  return url.replace(/\/+$/, "");
+}
+function isLoopback(host) {
+  return host === "localhost" || host === "[::1]" || host === "::1" || /^127\.\d+\.\d+\.\d+$/.test(host);
+}
+function knownSize(body) {
+  if (typeof Blob !== "undefined" && body instanceof Blob) {
+    return body.size;
+  }
+  if (ArrayBuffer.isView(body) || body instanceof ArrayBuffer) {
+    return body.byteLength;
+  }
+  return void 0;
+}
+function bodyMedia(body, contentType, size) {
+  return { open: async () => body, contentType, size: size ?? knownSize(body) };
+}
+function uploadGroup(media) {
+  return { group: media.map((m) => ({ upload: { contentType: m.contentType } })) };
+}
+function uploadKeys(job) {
+  if (job.source["upload"] !== void 0) {
+    return [null];
+  }
+  const group = job.source["group"] ?? [];
+  return group.flatMap((member, i) => member["upload"] !== void 0 ? [i] : []);
+}
+async function combinedMedia(job) {
+  if (job.media.length === 0 || job.live || job.media.some((m) => m.size === void 0)) {
+    return null;
+  }
+  if (job.media.reduce((total, m) => total + (m.size ?? 0), 0) > COMBINED_UPLOAD_MAX_BYTES) {
+    return null;
+  }
+  const bytes = [];
+  for (const media of job.media) {
+    bytes.push(await readAll(await media.open()));
+  }
+  return bytes;
+}
+async function readAll(body) {
+  const parts = [];
+  for await (const piece of pieces(body)) {
+    parts.push(piece);
+  }
+  return concat(parts);
+}
+function concat(parts) {
+  const all = new Uint8Array(parts.reduce((total, p) => total + p.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    all.set(part, offset);
+    offset += part.length;
+  }
+  return all;
+}
+function combinedMessage(command, media) {
+  if (command["group"] !== void 0) {
+    let i = 0;
+    command = {
+      ...command,
+      group: command["group"].map((member) => member["upload"] !== void 0 ? { upload: { ...member["upload"], bytes: media[i++].length } } : member)
+    };
+  }
+  const header = new TextEncoder().encode(JSON.stringify(command));
+  const prefix = new Uint8Array(5);
+  prefix[0] = COMBINED;
+  new DataView(prefix.buffer).setUint32(1, header.length, false);
+  return concat([prefix, header, ...media]);
+}
+async function* pieces(body) {
+  if (typeof Blob !== "undefined" && body instanceof Blob) {
+    yield* pieces(body.stream());
+  } else if (body instanceof ArrayBuffer) {
+    yield new Uint8Array(body);
+  } else if (ArrayBuffer.isView(body)) {
+    yield new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+  } else {
+    const reader = body.getReader();
     try {
-      this._pipelineId = await this._pipelineCreatePromise;
-      this.setTransientPipelinePop();
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) {
+          return;
+        }
+        if (value !== void 0 && value.length > 0) {
+          yield value;
+        }
+      }
     } finally {
-      this._pipelineCreatePromise = null;
+      reader.releaseLock();
     }
   }
-  async changeTransientPop(pop) {
-    if (!this._client) {
-      throw new Error("endpoint not initialized");
-    }
-    const previousPop = this.options().pop;
-    const previousBaseUrl = this._baseUrl;
-    const previousSessionAccessToken = this._sessionAccessToken;
-    const previousSessionAccessTokenValidUntil = this._sessionAccessTokenValidUntil;
-    if (this._pipelineId) {
-      await this.deleteTransientPipeline(this._pipelineId);
-      this._pipelineId = null;
-    }
-    this._pipeline = null;
-    try {
-      this.options().pop = pop;
-      await this.getComputeSession();
-    } catch (error) {
-      this.options().pop = previousPop;
-      this._pipeline = null;
-      this._pipelineId = null;
-      this._baseUrl = previousPop ? null : previousBaseUrl;
-      this._sessionAccessToken = previousSessionAccessToken;
-      this._sessionAccessTokenValidUntil = previousSessionAccessTokenValidUntil;
-      throw error;
-    }
-    if (!this._pipelineId) {
-      throw new Error("Compute session did not provide a pipeline for the requested pop");
+}
+
+// worker/worker_endpoint.ts
+var WorkerEndpoint = class extends Endpoint {
+  constructor(options) {
+    if (options.isPipelineMode) {
+      options = { ...options, jobQueueLength: options.jobQueueLength || MAX_OPEN_SOURCES };
+      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`);
+      }
     }
-    this.setTransientPipelinePop();
+    super(options);
+    const context = {
+      options,
+      logger: this._logger,
+      requestLogger: this._requestLogger,
+      client: () => this._client,
+      limit: () => this._limit,
+      jobDone: () => {
+        this._limit.release();
+        this.updateState();
+      },
+      updateState: (state, message) => this.updateState(state, message),
+      eyepopUrl: () => this.eyepopUrl(),
+      eyepopWebApiUrl: () => this.eyepopWebApiUrl(),
+      credentialHeader: () => super.authorizationHeader(),
+      forgetCredential: () => this.statusHandler401(401),
+      fetchWithRetry: (fetcher, retries) => this.fetchWithRetry(fetcher, retries),
+      credentialSession: () => super.session()
+    };
+    this._backend = options.isPipelineMode ? new PipelineBackend(context) : new SessionBackend(context);
+    this.setStatusRetryHandlers(/* @__PURE__ */ new Map([[404, (statusCode) => this._backend.onStatus(statusCode)]]));
   }
-  async deleteTransientPipeline(pipelineId) {
-    if (!this._client || !this._baseUrl) {
-      return;
+  options() {
+    return this._options;
+  }
+  /** What runs this endpoint's jobs. */
+  backend() {
+    return this._backend;
+  }
+  async disconnect(wait = true) {
+    await this._backend.disconnect(() => super.disconnect(wait));
+  }
+  async session() {
+    return await this._backend.session();
+  }
+  popName() {
+    return this._backend.popName();
+  }
+  pop() {
+    return this._backend.pop();
+  }
+  async changePop(pop) {
+    validatePop(pop);
+    await this._backend.changePop(pop);
+  }
+  /**
+   * @deprecated Pop ids are only retained for backwards compatibility.
+   * Configure transient sessions with `WorkerOptions.pop`.
+   */
+  popId() {
+    return this.options().popId || null;
+  }
+  async process(param1, param2) {
+    if (param1.source !== void 0) {
+      const request = param1;
+      this.validateProcessParams(request);
+      return await this.submit({ kind: "source", source: request.source, params: request });
+    } else {
+      return await this.submit({ kind: "source", source: param1, params: { componentParams: param2 } });
     }
-    const deleteUrl = `${this._baseUrl}/pipelines/${pipelineId}`;
-    const headers = {
-      Authorization: await this.authorizationHeader()
-    };
-    let response = await this._client.fetch(deleteUrl, {
-      method: "DELETE",
-      headers
-    });
-    if (response.status >= 300) {
-      const message = await response.text();
-      this._logger.info(`stopping pipeline failed, status ${response.status}: ${message}`);
+  }
+  /**
+   * Reject a source's calibration before any work is started for it.
+   *
+   * Called by every entry point that takes ProcessParams, before the
+   * concurrency limit is acquired, so a request that can never be sent
+   * does not hold a slot.
+   */
+  validateProcessParams(params) {
+    if (params.camera !== void 0) {
+      validateCamera(params.camera);
     }
   }
-  async authorizationHeader() {
-    if (this._sessionAccessToken) {
-      return `Bearer ${this._sessionAccessToken}`;
+  async uploadGroup(paths, params = {}) {
+    if (paths.length === 0) {
+      throw new Error("upload group requires at least one path");
     }
-    return super.authorizationHeader();
+    this.validateProcessParams(params);
+    return await this.submit({ kind: "uploadGroup", paths, params });
   }
-  async computeAuthorizationHeader() {
-    const auth = resolveAuth(this.options());
-    if (auth?.isLocal !== void 0) {
-      return "Implicit";
+  async uploadStreamGroup(streams, mimeTypes, params = {}) {
+    if (streams.length === 0) {
+      throw new Error("upload stream group requires at least one stream");
     }
-    const credential = apiKeyCredential(auth) ?? accessTokenCredential(auth);
-    if (credential !== void 0) {
-      return `Bearer ${credential}`;
+    if (mimeTypes !== void 0 && mimeTypes.length !== streams.length) {
+      throw new Error("mimeTypes must have the same length as streams");
     }
-    return super.authorizationHeader();
+    this.validateProcessParams(params);
+    return await this.submit({ kind: "uploadStreamGroup", streams, mimeTypes, params });
   }
-  setTransientPipelinePop() {
-    const pop = this.options().pop;
-    if (pop && this._pipelineId) {
-      this._pipeline = {
-        id: this._pipelineId,
-        state: "idle",
-        startTime: (/* @__PURE__ */ new Date()).toString(),
-        pop
-      };
+  async loadFromGroup(urls, params = {}) {
+    if (urls.length === 0) {
+      throw new Error("load from group requires at least one url");
     }
+    this.validateProcessParams(params);
+    return await this.submit({ kind: "loadFromGroup", urls, params });
+  }
+  async submit(work) {
+    return await this._backend.submit(work);
+  }
+  async reconnect() {
+    await this._backend.reconnect();
+    return this;
+  }
+  async authorizationHeader() {
+    return await this._backend.authorizationHeader();
   }
 };
-_WorkerEndpoint.WAIT_FOR_IS_READY = 60 * 1e3;
-var WorkerEndpoint = _WorkerEndpoint;
-
-// shims/websockets.ts
-var createWebSocket;
-if ("document" in globalThis && "implementation" in globalThis.document) {
-  createWebSocket = (url, protocols) => {
-    return new WebSocket(url, protocols);
-  };
-} else {
-  createWebSocket = (url, protocols) => {
-    const ws = __require("ws");
-    return new ws.WebSocket(url, protocols);
-  };
-}
 
 // data/data_endpoint.ts
 import urljoin from "url-join";
@@ -13250,6 +14152,13 @@ var EyePop;
     if (opts.isLocalMode === void 0) {
       opts.isLocalMode = stringToBooleanSafe(readEnv("EYEPOP_LOCAL_MODE"));
     }
+    if (opts.isPipelineMode === void 0) {
+      const shared = resolveAuth(opts)?.session;
+      opts.isPipelineMode = shared?.isPipelineMode ?? stringToBooleanSafe(readEnv("EYEPOP_PIPELINE_MODE"));
+    }
+    if (opts.isPipelineMode) {
+      return pipelineEndpoint(opts);
+    }
     if (opts.isLocalMode) {
       opts.eyepopUrl = "http://127.0.0.1:8080";
     }
@@ -13301,6 +14210,38 @@ var EyePop;
     return new WorkerEndpoint(opts);
   }
   EyePop2.workerEndpoint = workerEndpoint;
+  function pipelineEndpoint(opts) {
+    const popId = opts.popId ?? readEnv("EYEPOP_POP_ID");
+    const sessionOnly = {
+      popId: popId === "transient" /* Transient */ ? void 0 : popId,
+      sessionUuid: opts.sessionUuid ?? readEnv("EYEPOP_SESSION_UUID"),
+      sessionName: opts.sessionName,
+      pipelineImage: opts.pipelineImage,
+      pipelineVersion: opts.pipelineVersion
+    };
+    const named = Object.entries(sessionOnly).filter(([, value]) => value).map(([name]) => name);
+    if (named.length > 0) {
+      throw new PipelineConfigurationError("session_options", `pipeline mode runs no worker session; it takes no ${named.join(", ")}`, named);
+    }
+    if (opts.isLocalMode && !opts.eyepopUrl) {
+      opts.eyepopUrl = readEnv("EYEPOP_URL") || "http://127.0.0.1:9002";
+    }
+    if (!opts.jobQueueLength) {
+      opts.jobQueueLength = MAX_OPEN_SOURCES;
+    }
+    _fill_default_options(opts);
+    if (resolveAuth(opts) === void 0) {
+      if (opts.isLocalMode) {
+        opts.auth = { isLocal: true };
+      } else {
+        throw new Error("apiKey/accessToken/session/oAuth2 option or EYEPOP_API_KEY environment variable is required");
+      }
+    }
+    if (opts.accountId === void 0) {
+      opts.accountId = resolveAuth(opts)?.session?.accountId ?? readAccountUuidEnv();
+    }
+    return new WorkerEndpoint(opts);
+  }
   function dataEndpoint(opts = {}) {
     _fill_default_options(opts);
     const auth = resolveAuth(opts);
@@ -13377,6 +14318,7 @@ export {
   AssetUrlType,
   AutoAnnotateStatus,
   AutoAnnotateTask,
+  COMBINED_UPLOAD_MAX_BYTES,
   ChangeType,
   ComputeAccountMismatchError,
   ComputeApiError,
@@ -13398,6 +14340,7 @@ export {
   LoadFromGroupJob,
   LoadFromJob,
   LoadMediaStreamJob,
+  MAX_OPEN_SOURCES,
   ModelExportStatus,
   ModelFormat,
   ModelPrecisionType,
@@ -13406,11 +14349,21 @@ export {
   ModelTrainingStage,
   ModelType,
   MotionModel,
+  PIPELINE_PATH,
+  PipelineBackend,
+  PipelineCommandError,
+  PipelineConfigurationError,
+  PipelineJob,
+  PipelineSocketClosedError,
+  PipelineSourceError,
   PointCloud,
   PopComponentType,
   PredictionVersion,
   QUATERNION_TOLERANCE,
+  SUBPROTOCOL,
+  SelectMode,
   Semaphore,
+  SessionBackend,
   Stream,
   TaskMode,
   TaskType,
@@ -13436,6 +14389,8 @@ export {
   index_default as default,
   encodeMultipartFormData,
   getBaseUrl,
+  isSelectOperator,
+  popSelects,
   randomMultipartBoundary,
   readableStreamFromString,
   resolveAuth,