@eyepop.ai/eyepop 3.26.0-rc.2 → 3.27.0

package/dist/eyepop.index.mjs

@@ -8928,14 +8928,25 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
 }
 
 // endpoint.ts
+var ACCOUNT_CLAIM = "https://ident.eyepop.ai/account-uuid";
+var NOT_EXCHANGEABLE = ["API key or user login required", "API key authentication required for token refresh"];
+function carriesAccount(token) {
+  try {
+    const payload = (token.split(".")[1] ?? "").replace(/-/g, "+").replace(/_/g, "/");
+    return Boolean(JSON.parse(atob(payload))?.[ACCOUNT_CLAIM]);
+  } catch {
+    return false;
+  }
+}
 var Endpoint = class {
   constructor(options) {
+    this._exchanging = null;
     this._options = options;
     this._token = null;
     this._expire_token_time = null;
     this._client = null;
     this._statusRetryHandlers = /* @__PURE__ */ new Map();
-    this._statusRetryHandlers.set(401, (statusCode) => this.statusHandler401(statusCode));
+    this._statusRetryHandlers.set(401, (statusCode, failedToken) => this.statusHandler401(statusCode, failedToken));
     this._limit = new Semaphore(this._options.jobQueueLength ?? 1024);
     this._state = "Idle" /* Idle */;
     this._message = null;
@@ -8951,7 +8962,7 @@ var Endpoint = class {
   }
   setStatusRetryHandlers(statusRetryHandlers = void 0) {
     this._statusRetryHandlers = new Map(statusRetryHandlers);
-    this._statusRetryHandlers.set(401, (statusCode) => this.statusHandler401(statusCode));
+    this._statusRetryHandlers.set(401, (statusCode, failedToken) => this.statusHandler401(statusCode, failedToken));
   }
   eyepopUrl() {
     if (this._options.eyepopUrl) {
@@ -9048,12 +9059,15 @@ var Endpoint = class {
       validUntil: this._expire_token_time * 1e3
     };
   }
-  statusHandler401(_statusCode) {
-    this._token = null;
-    this._expire_token_time = null;
+  statusHandler401(_statusCode, failedToken = this._token) {
+    if (this._token === failedToken) {
+      this._token = null;
+      this._expire_token_time = null;
+    }
   }
   async fetchWithRetry(fetcher, retries = 1) {
     while (true) {
+      const sentToken = this._token ?? void 0;
       try {
         const response = await fetcher();
         if (response.ok) {
@@ -9061,7 +9075,7 @@ var Endpoint = class {
         } else {
           const handler = this._statusRetryHandlers.get(response.status);
           if (handler != null) {
-            handler(response.status);
+            handler(response.status, sentToken);
             if (retries--) {
               this._requestLogger.info("received %d response, retry", response.status);
             } else {
@@ -9095,54 +9109,75 @@ var Endpoint = class {
     }
     return `Bearer ${await this.currentAccessToken()}`;
   }
+  async exchange(client, credential, accountUuid) {
+    const query = accountUuid ? `?account_uuid=${encodeURIComponent(accountUuid)}` : "";
+    return await client.fetch(`${this.eyepopUrl()}/v1/auth/authenticate${query}`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${credential}` }
+    });
+  }
+  async storeExchangedToken(response, now) {
+    if (response.status != 200) {
+      const message = await response.text();
+      return Promise.reject(`Unexpected status ${response.status}: ${message}`);
+    }
+    const token = await response.json();
+    this._token = token.access_token;
+    this._expire_token_time = now + token.expires_in - 60;
+  }
+  /**
+   * A token that already carries an account, or that the compute API refuses to exchange
+   * (see NOT_EXCHANGEABLE), is used as is. Any other refusal is raised.
+   */
+  async exchangeLoginToken(client, loginToken, validUntil, now) {
+    if (!carriesAccount(loginToken)) {
+      const response = await this.exchange(client, loginToken, this._options.accountId);
+      const refusal = response.status == 401 ? await response.clone().text() : "";
+      if (!NOT_EXCHANGEABLE.some((message) => refusal.includes(message))) {
+        await this.storeExchangedToken(response, now);
+        return;
+      }
+    }
+    this._token = loginToken;
+    this._expire_token_time = validUntil;
+  }
   async currentAccessToken() {
+    if (!this._token || this._expire_token_time < Date.now() / 1e3) {
+      this._exchanging ?? (this._exchanging = this.authenticate().finally(() => this._exchanging = null));
+      await this._exchanging;
+    }
+    this._logger.debug("using access token, valid for at least %d seconds", this._expire_token_time - Date.now() / 1e3);
+    return this._token;
+  }
+  async authenticate() {
     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 {
+    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 login = await authenticateBrowserSession(auth.oAuth2, this._options);
+        await this.exchangeLoginToken(this._client, login.accessToken, login.validUntil / 1e3, now);
+      } else if (accessTokenCredential(auth) !== void 0) {
+        await this.exchangeLoginToken(this._client, accessTokenCredential(auth), Number.MAX_VALUE, now);
+      } else if (this._options.eyepopUrl) {
+        const credential = apiKeyCredential(auth);
+        if (credential === void 0) {
           return Promise.reject("no valid auth option");
         }
-      } finally {
-        this.updateState();
+        await this.storeExchangedToken(await this.exchange(this._client, credential), now);
+      } 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;
   }
 };
 
@@ -11692,10 +11727,22 @@ var PipelineJob = class {
     this.openSource = null;
     // Stops the job's source on the pipeline, once it was sent.
     this.stopOnPipeline = null;
+    this._milliComputeUnits = void 0;
   }
   get cancelled() {
     return this._cancelled;
   }
+  /** The source's milli compute units: the latest total of its `usage` messages and its `end`. */
+  get milliComputeUnits() {
+    return this._milliComputeUnits;
+  }
+  /** Keep a usage's or an end's milliComputeUnits: each carries the source's total so far. */
+  noteMilliComputeUnits(message) {
+    const value = message["milliComputeUnits"];
+    if (Number.isInteger(value) && value >= 0) {
+      this._milliComputeUnits = value;
+    }
+  }
   command(id) {
     const command = { type: "setSource", id, ...this.source };
     if (this.params.componentParams !== void 0) {
@@ -12273,7 +12320,11 @@ var PipelineBackend = class {
         case "prediction":
           job.predicted(message["prediction"]);
           break;
+        case "usage":
+          job.noteMilliComputeUnits(message);
+          break;
         case "end":
+          job.noteMilliComputeUnits(message);
           if (message["reason"] === "eos") {
             return null;
           }
@@ -12831,12 +12882,18 @@ var VlmAbilityStatus = /* @__PURE__ */ ((VlmAbilityStatus2) => {
   VlmAbilityStatus2["published"] = "published";
   return VlmAbilityStatus2;
 })(VlmAbilityStatus || {});
+var VLM_MODEL_WORKER_RELEASES = Object.freeze({
+  qwen3: "qwen3_instruct",
+  gpt_6_astra: "gpt-6-astra",
+  gemini_4_argon: "gemini-4-argon"
+});
 
 // data/jobs.ts
 var InferAssetJob = class {
   constructor(assetUrl, inferRequest, vlmFetch, requestLogger) {
     this._response = null;
     this._runInfo = null;
+    this._milliComputeUnits = void 0;
     this._controller = new AbortController();
     this._vlmFetch = vlmFetch;
     this._assetUrl = assetUrl;
@@ -12873,6 +12930,13 @@ var InferAssetJob = class {
     }
     return iterator();
   }
+  /**
+   * The milli compute units vlm-server billed for the inference, 0 on a cache hit; undefined before it answered
+   * or when it reported none.
+   */
+  get milliComputeUnits() {
+    return this._milliComputeUnits;
+  }
   start(done) {
     this._response = new Promise(async (resolve, reject) => {
       try {
@@ -12897,6 +12961,8 @@ var InferAssetJob = class {
           const runInfo = response["run_info"];
           if (predictions) {
             this._runInfo = runInfo;
+            const used = response["milli_compute_units"] ?? response["compute_units"];
+            this._milliComputeUnits = typeof used === "number" ? used : void 0;
             resolve(predictions);
             break;
           } else {
@@ -13013,6 +13079,151 @@ function omit_nulls(_, value) {
   }
   return value;
 }
+var TASK_EXCLUDED_FIELDS = ["text_prompt", "transform_into", "response_schema"];
+var VlmAbilityModeErrorReason = /* @__PURE__ */ ((VlmAbilityModeErrorReason2) => {
+  VlmAbilityModeErrorReason2["missing_mode"] = "missing_mode";
+  VlmAbilityModeErrorReason2["unknown_task"] = "unknown_task";
+  VlmAbilityModeErrorReason2["task_excludes_free_form"] = "task_excludes_free_form";
+  VlmAbilityModeErrorReason2["task_without_prompts"] = "task_without_prompts";
+  VlmAbilityModeErrorReason2["prompts_without_task"] = "prompts_without_task";
+  VlmAbilityModeErrorReason2["empty_prompts"] = "empty_prompts";
+  VlmAbilityModeErrorReason2["invalid_prompt"] = "invalid_prompt";
+  return VlmAbilityModeErrorReason2;
+})(VlmAbilityModeErrorReason || {});
+var VlmAbilityModeError = class extends Error {
+  constructor(reason, message, fields = []) {
+    super(message);
+    this.name = "VlmAbilityModeError";
+    this.reason = reason;
+    this.fields = fields;
+  }
+};
+function isSet(value) {
+  return value !== void 0 && value !== null;
+}
+function validateVlmAbilityMode(ability, partial) {
+  const kind = partial ? "VLM ability update" : "VLM ability";
+  const taskSet = isSet(ability.task);
+  const promptsSet = isSet(ability.prompts);
+  if (taskSet && !Object.values(AutoAnnotateTask).includes(ability.task)) {
+    throw new VlmAbilityModeError("unknown_task" /* unknown_task */, `${kind}: unknown task '${String(ability.task)}', expected one of ${Object.values(AutoAnnotateTask).join(", ")}`, [
+      "task"
+    ]);
+  }
+  if (taskSet || promptsSet) {
+    const conflicting = TASK_EXCLUDED_FIELDS.filter((field) => isSet(ability[field]));
+    if (conflicting.length > 0) {
+      throw new VlmAbilityModeError(
+        "task_excludes_free_form" /* task_excludes_free_form */,
+        `${kind}: a task derives the prompt and output schema, so ${conflicting.join(", ")} must be unset with task and prompts`,
+        [...conflicting]
+      );
+    }
+  }
+  if (promptsSet) {
+    if (!Array.isArray(ability.prompts) || ability.prompts.length === 0) {
+      throw new VlmAbilityModeError("empty_prompts" /* empty_prompts */, `${kind}: prompts must be a non-empty list of {label, prompt}`, ["prompts"]);
+    }
+    ability.prompts.forEach((entry, i) => {
+      if (!entry || typeof entry.label !== "string" || entry.label.length === 0 || typeof entry.prompt !== "string" || entry.prompt.length === 0) {
+        throw new VlmAbilityModeError("invalid_prompt" /* invalid_prompt */, `${kind}: prompts[${i}] needs a non-empty label and prompt`, [`prompts[${i}]`]);
+      }
+    });
+  }
+  if (partial) {
+    return;
+  }
+  if (taskSet && !promptsSet) {
+    throw new VlmAbilityModeError("task_without_prompts" /* task_without_prompts */, `${kind}: task '${ability.task}' requires a non-empty prompts list of {label, prompt}`, ["prompts"]);
+  }
+  if (!taskSet && promptsSet) {
+    throw new VlmAbilityModeError("prompts_without_task" /* prompts_without_task */, `${kind}: prompts are only used with a task; set task, or use text_prompt for a free-form ability`, ["prompts"]);
+  }
+  if (!taskSet && !(typeof ability.text_prompt === "string" && ability.text_prompt.length > 0)) {
+    throw new VlmAbilityModeError("missing_mode" /* missing_mode */, `${kind}: set either text_prompt (free-form) or task with non-empty prompts`, ["text_prompt", "task"]);
+  }
+}
+var VlmAbilityModelErrorReason = /* @__PURE__ */ ((VlmAbilityModelErrorReason2) => {
+  VlmAbilityModelErrorReason2["unknown_model"] = "unknown_model";
+  VlmAbilityModelErrorReason2["unknown_worker_release"] = "unknown_worker_release";
+  VlmAbilityModelErrorReason2["model_conflict"] = "model_conflict";
+  return VlmAbilityModelErrorReason2;
+})(VlmAbilityModelErrorReason || {});
+var VlmAbilityModelError = class extends Error {
+  constructor(reason, message, fields = []) {
+    super(message);
+    this.name = "VlmAbilityModelError";
+    this.reason = reason;
+    this.fields = fields;
+  }
+};
+var VLM_MODELS = Object.keys(VLM_MODEL_WORKER_RELEASES);
+var DEFAULT_VLM_MODEL = "qwen3";
+function isVlmModel(value) {
+  return typeof value === "string" && Object.prototype.hasOwnProperty.call(VLM_MODEL_WORKER_RELEASES, value);
+}
+function normalizeWorkerRelease(workerRelease) {
+  return workerRelease.toLowerCase().replace(/_/g, "-");
+}
+function modelForWorkerRelease(workerRelease) {
+  if (workerRelease === void 0 || workerRelease === null) {
+    return DEFAULT_VLM_MODEL;
+  }
+  const normalized = normalizeWorkerRelease(workerRelease);
+  return VLM_MODELS.find((model) => normalizeWorkerRelease(VLM_MODEL_WORKER_RELEASES[model]) === normalized) ?? null;
+}
+function checkModelAndWorkerRelease(model, workerRelease, prefix) {
+  const modelSet = isSet(model);
+  if (modelSet && !isVlmModel(model)) {
+    throw new VlmAbilityModelError("unknown_model" /* unknown_model */, `${prefix}unknown model '${String(model)}'; set \`model\` to one of ${VLM_MODELS.join(", ")}`, ["model"]);
+  }
+  if (!isSet(workerRelease)) {
+    return modelSet ? model : null;
+  }
+  const releaseModel = typeof workerRelease === "string" ? modelForWorkerRelease(workerRelease) : null;
+  if (releaseModel === null) {
+    throw new VlmAbilityModelError(
+      "unknown_worker_release" /* unknown_worker_release */,
+      `${prefix}unknown worker_release '${String(workerRelease)}'; worker_release is deprecated, set \`model\` to one of ${VLM_MODELS.join(", ")}`,
+      ["worker_release"]
+    );
+  }
+  if (modelSet && releaseModel !== model) {
+    throw new VlmAbilityModelError(
+      "model_conflict" /* model_conflict */,
+      `${prefix}worker_release '${String(workerRelease)}' runs model ${releaseModel}, not ${String(model)}; worker_release is deprecated, set only \`model\``,
+      ["model", "worker_release"]
+    );
+  }
+  return releaseModel;
+}
+function resolveWorkerRelease(model, workerRelease) {
+  return VLM_MODEL_WORKER_RELEASES[checkModelAndWorkerRelease(model, workerRelease, "") ?? DEFAULT_VLM_MODEL];
+}
+function withVlmModel(ability) {
+  if (!ability || typeof ability !== "object") {
+    return ability;
+  }
+  if (!("model" in ability)) {
+    return { ...ability, model: modelForWorkerRelease(ability.worker_release) };
+  }
+  if (isSet(ability.model) && !isVlmModel(ability.model)) {
+    return { ...ability, model: null };
+  }
+  return ability;
+}
+var warnedWorkerRelease = false;
+function prepareVlmAbilityModel(ability, partial) {
+  if (isSet(ability.worker_release) && !warnedWorkerRelease) {
+    warnedWorkerRelease = true;
+    console.warn("worker_release is deprecated, set model to a VlmModel instead");
+  }
+  checkModelAndWorkerRelease(ability.model, ability.worker_release, partial ? "VLM ability update: " : "VLM ability: ");
+  if (isSet(ability.model) && !isSet(ability.worker_release)) {
+    return { ...ability, worker_release: VLM_MODEL_WORKER_RELEASES[ability.model] };
+  }
+  return ability;
+}
 var DataEndpoint = class extends Endpoint {
   constructor(options) {
     super(options);
@@ -13801,20 +14012,22 @@ var DataEndpoint = class extends Endpoint {
   async listVlmAbilities() {
     return this.request(`/vlm_abilities?account_uuid=${this._accountId}`, {
       method: "GET"
-    });
+    }).then((abilities) => Array.isArray(abilities) ? abilities.map(withVlmModel) : abilities);
   }
   async createVlmAbility(create, vlm_ability_group_uuid) {
+    validateVlmAbilityMode(create, false);
+    const body = prepareVlmAbilityModel(create, false);
     const groupQuery = vlm_ability_group_uuid ? `&vlm_ability_group_uuid=${vlm_ability_group_uuid}` : "";
     return this.request(`/vlm_abilities?account_uuid=${this._accountId}${groupQuery}`, {
       method: "POST",
-      body: JSON.stringify(create, omit_nulls),
+      body: JSON.stringify(body, omit_nulls),
       headers: { "Content-Type": "application/json" }
-    });
+    }).then(withVlmModel);
   }
   async getVlmAbility(vlm_ability_uuid) {
     return this.request(`/vlm_abilities/${vlm_ability_uuid}`, {
       method: "GET"
-    });
+    }).then(withVlmModel);
   }
   async deleteVlmAbility(vlm_ability_uuid) {
     return this.request(`/vlm_abilities/${vlm_ability_uuid}`, {
@@ -13822,11 +14035,13 @@ var DataEndpoint = class extends Endpoint {
     });
   }
   async updateVlmAbility(vlm_ability_uuid, update) {
+    validateVlmAbilityMode(update, true);
+    const body = prepareVlmAbilityModel(update, true);
     return this.request(`/vlm_abilities/${vlm_ability_uuid}`, {
       method: "PATCH",
-      body: JSON.stringify(update),
+      body: JSON.stringify(body),
       headers: { "Content-Type": "application/json" }
-    });
+    }).then(withVlmModel);
   }
   async refineVlmAbility(vlm_ability_uuid, auto_prompt, auto_task) {
     if (auto_prompt !== void 0) {
@@ -13834,13 +14049,13 @@ var DataEndpoint = class extends Endpoint {
         method: "POST",
         body: JSON.stringify(auto_prompt, omit_nulls),
         headers: { "Content-Type": "application/json" }
-      });
+      }).then(withVlmModel);
     } else if (auto_task !== void 0) {
       return this.request(`/vlm_abilities/${vlm_ability_uuid}/refine_task`, {
         method: "POST",
         body: JSON.stringify(auto_task, omit_nulls),
         headers: { "Content-Type": "application/json" }
-      });
+      }).then(withVlmModel);
     } else {
       return Promise.reject("refine vlm ability requires auto_prompt or auto_config parameter");
     }
@@ -13860,24 +14075,24 @@ var DataEndpoint = class extends Endpoint {
     }
     return this.request(`/vlm_abilities/${vlm_ability_uuid}/clone?${params.toString()}`, {
       method: "POST"
-    });
+    }).then(withVlmModel);
   }
   async publishVlmAbility(vlm_ability_uuid, alias_name, tag_name) {
     const alias_name_query = alias_name ? `alias_name=${encodeURIComponent(alias_name)}&` : "";
     const tag_name_query = tag_name ? `tag_name=${encodeURIComponent(tag_name)}&` : "";
     return this.request(`/vlm_abilities/${vlm_ability_uuid}/publish?${alias_name_query}${tag_name_query}`, {
       method: "POST"
-    });
+    }).then(withVlmModel);
   }
   async addVlmAbilityAlias(vlm_ability_uuid, alias_name, tag_name) {
     return this.request(`/vlm_abilities/${vlm_ability_uuid}/alias/${encodeURIComponent(alias_name)}/tag/${tag_name ? encodeURIComponent(tag_name) : ""}`, {
       method: "POST"
-    });
+    }).then(withVlmModel);
   }
   async removeVlmAbilityAlias(vlm_ability_uuid, alias_name, tag_name) {
     return this.request(`/vlm_abilities/${vlm_ability_uuid}/alias/${encodeURIComponent(alias_name)}/tag/${encodeURIComponent(tag_name)}`, {
       method: "DELETE"
-    });
+    }).then(withVlmModel);
   }
   async listVlmAbilityEvaluations(vlm_ability_uuid) {
     return this.request(`/vlm_abilities/${vlm_ability_uuid}/evaluations`, {
@@ -14420,17 +14635,17 @@ var EyePop;
         if (typeof auth.oAuth2 === "boolean") {
           const oAuth2 = opts.eyepopUrl && opts.eyepopUrl.match(/https:(.*).staging.eyepop.xyz/i) ? {
             oAuth2: {
-              domain: "dev-eyepop.us.auth0.com",
+              domain: "auth0.eyepop.xyz",
               clientId: "jktx3YO2UnbkNPvr05PQWf26t1kNTJyg",
               audience: "https://dev-app.eyepop.ai",
-              scope: "admin:clouds access:inference-api access:datasets"
+              scope: "access:inference-api access:datasets"
             }
           } : {
             oAuth2: {
-              domain: "eyepop.us.auth0.com",
+              domain: "auth0.eyepop.ai",
               clientId: "Lb9ubA9Hf3jlaqWLUx8XgA0zvotgViCl",
               audience: "https://api.eyepop.ai",
-              scope: "admin:clouds access:inference-api access:datasets"
+              scope: "access:inference-api access:datasets"
             }
           };
           if (opts.oAuth2 !== void 0) {
@@ -14464,6 +14679,7 @@ export {
   ComputeApiError,
   ContourType,
   DEFAULT_PREDICTION_VERSION,
+  DEFAULT_VLM_MODEL,
   DataApiType,
   DataEndpoint,
   DepthMap,
@@ -14513,7 +14729,12 @@ export {
   UploadGroupJob,
   UploadJob,
   UserReview,
+  VLM_MODEL_WORKER_RELEASES,
   VideoMode,
+  VlmAbilityModeError,
+  VlmAbilityModeErrorReason,
+  VlmAbilityModelError,
+  VlmAbilityModelErrorReason,
   VlmAbilityStatus,
   WebrtcBase,
   WebrtcWhep,
@@ -14531,10 +14752,13 @@ export {
   encodeMultipartFormData,
   getBaseUrl,
   isSelectOperator,
+  modelForWorkerRelease,
+  normalizeWorkerRelease,
   popSelects,
   randomMultipartBoundary,
   readableStreamFromString,
   resolveAuth,
+  resolveWorkerRelease,
   validateCamera,
   validatePop
 };