@workglow/tf-mediapipe 0.2.34 → 0.2.36

package/dist/ai.js

@@ -9,8 +9,8 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 // src/ai/common/TFMP_Constants.ts
 var TENSORFLOW_MEDIAPIPE = "TENSORFLOW_MEDIAPIPE";
 var TFMP_DEFAULT_TASK_TYPES = [
-  "DownloadModelTask",
-  "UnloadModelTask",
+  "ModelDownloadTask",
+  "ModelDownloadRemoveTask",
   "ModelInfoTask",
   "TextEmbeddingTask",
   "TextLanguageDetectionTask",
@@ -46,7 +46,6 @@ var TextPipelineTask = {
   "vision-object-detector": "vision-object-detector",
   "vision-pose-landmarker": "vision-pose-landmarker"
 };
-
 // src/ai/common/TFMP_ModelSchema.ts
 import { ModelConfigSchema, ModelRecordSchema } from "@workglow/ai/worker";
 var TFMPModelSchema = {
@@ -100,7 +99,6 @@ var TFMPModelConfigSchema = {
   required: [...ModelConfigSchema.required, ...TFMPModelSchema.required],
   additionalProperties: false
 };
-
 // src/ai/common/TFMP_ModelSearch.ts
 import { filterModelSearchResultsByQuery } from "@workglow/ai/provider-utils";
 var TFMP_MODEL_RESULTS = [
@@ -112,7 +110,7 @@ var TFMP_MODEL_RESULTS = [
       provider: TENSORFLOW_MEDIAPIPE,
       title: "Universal Sentence Encoder",
       description: "Universal Sentence Encoder",
-      tasks: ["TextEmbeddingTask"],
+      capabilities: ["text.embedding"],
       provider_config: {
         model_path: "https://storage.googleapis.com/mediapipe-tasks/text_embedder/universal_sentence_encoder.tflite",
         task_engine: "text",
@@ -130,7 +128,7 @@ var TFMP_MODEL_RESULTS = [
       provider: TENSORFLOW_MEDIAPIPE,
       title: "MediaPipe Language Detector",
       description: "MediaPipe Language Detector",
-      tasks: ["TextLanguageDetectionTask"],
+      capabilities: ["text.language-detection"],
       provider_config: {
         model_path: "https://storage.googleapis.com/mediapipe-models/language_detector/language_detector/float32/latest/language_detector.tflite",
         task_engine: "text",
@@ -148,7 +146,7 @@ var TFMP_MODEL_RESULTS = [
       provider: TENSORFLOW_MEDIAPIPE,
       title: "MediaPipe BERT Text Classifier",
       description: "MediaPipe BERT Text Classifier",
-      tasks: ["TextClassificationTask"],
+      capabilities: ["text.classification"],
       provider_config: {
         model_path: "https://storage.googleapis.com/mediapipe-tasks/text_classifier/bert_text_classifier.tflite",
         task_engine: "text",
@@ -166,7 +164,7 @@ var TFMP_MODEL_RESULTS = [
       provider: TENSORFLOW_MEDIAPIPE,
       title: "MediaPipe Image Embedder",
       description: "MediaPipe Image Embedder",
-      tasks: ["ImageEmbeddingTask"],
+      capabilities: ["image.embedding"],
       provider_config: {
         model_path: "https://storage.googleapis.com/mediapipe-models/image_embedder/mobilenet_v3_small/float32/1/mobilenet_v3_small.tflite",
         task_engine: "vision",
@@ -184,7 +182,7 @@ var TFMP_MODEL_RESULTS = [
       provider: TENSORFLOW_MEDIAPIPE,
       title: "EfficientNet Lite0",
       description: "Image classification model",
-      tasks: ["ImageClassificationTask"],
+      capabilities: ["image.classification"],
       provider_config: {
         model_path: "https://storage.googleapis.com/mediapipe-models/image_classifier/efficientnet_lite0/float32/1/efficientnet_lite0.tflite",
         task_engine: "vision",
@@ -202,7 +200,7 @@ var TFMP_MODEL_RESULTS = [
       provider: TENSORFLOW_MEDIAPIPE,
       title: "Efficient Object Detector Lite0",
       description: "Object detection model",
-      tasks: ["ObjectDetectionTask"],
+      capabilities: ["image.object-detection"],
       provider_config: {
         model_path: "https://storage.googleapis.com/mediapipe-models/object_detector/efficientdet_lite0/float32/1/efficientdet_lite0.tflite",
         task_engine: "vision",
@@ -220,7 +218,7 @@ var TFMP_MODEL_RESULTS = [
       provider: TENSORFLOW_MEDIAPIPE,
       title: "Efficient Image Segmenter Lite0",
       description: "Image segmentation model",
-      tasks: ["ImageSegmentationTask"],
+      capabilities: ["image.segmentation"],
       provider_config: {
         model_path: "https://storage.googleapis.com/mediapipe-assets/deeplabv3.tflite?generation=1661875711618421",
         task_engine: "vision",
@@ -238,7 +236,7 @@ var TFMP_MODEL_RESULTS = [
       provider: TENSORFLOW_MEDIAPIPE,
       title: "Face Landmarker",
       description: "Detects 478 facial landmarks with blendshapes",
-      tasks: ["FaceLandmarkerTask"],
+      capabilities: ["vision.face-landmarks"],
       provider_config: {
         model_path: "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/1/face_landmarker.task",
         task_engine: "vision",
@@ -256,7 +254,7 @@ var TFMP_MODEL_RESULTS = [
       provider: TENSORFLOW_MEDIAPIPE,
       title: "Gesture Recognizer",
       description: "Recognizes hand gestures such as thumbs up and victory",
-      tasks: ["GestureRecognizerTask"],
+      capabilities: ["vision.gesture"],
       provider_config: {
         model_path: "https://storage.googleapis.com/mediapipe-models/gesture_recognizer/gesture_recognizer/float16/1/gesture_recognizer.task",
         task_engine: "vision",
@@ -274,7 +272,7 @@ var TFMP_MODEL_RESULTS = [
       provider: TENSORFLOW_MEDIAPIPE,
       title: "Hand Landmarker",
       description: "Detects 21 hand landmarks",
-      tasks: ["HandLandmarkerTask"],
+      capabilities: ["vision.hand-landmarks"],
       provider_config: {
         model_path: "https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/1/hand_landmarker.task",
         task_engine: "vision",
@@ -292,7 +290,7 @@ var TFMP_MODEL_RESULTS = [
       provider: TENSORFLOW_MEDIAPIPE,
       title: "Pose Landmarker",
       description: "Detects 33 body pose landmarks",
-      tasks: ["PoseLandmarkerTask"],
+      capabilities: ["vision.pose-landmarks"],
       provider_config: {
         model_path: "https://storage.googleapis.com/mediapipe-models/pose_landmarker/pose_landmarker_lite/float16/1/pose_landmarker_lite.task",
         task_engine: "vision",
@@ -304,29 +302,131 @@ var TFMP_MODEL_RESULTS = [
   }
 ];
 function createTFMPModelSearch(providerId) {
-  return async (input) => {
+  return async (input, _model, _signal, emit) => {
     const results = filterModelSearchResultsByQuery(TFMP_MODEL_RESULTS.map((result) => ({
       ...result,
       record: { ...result.record, provider: providerId }
     })), input.query);
-    return { results };
+    emit({ type: "finish", data: { results } });
   };
 }
 var TFMP_ModelSearch = createTFMPModelSearch(TENSORFLOW_MEDIAPIPE);
-
 // src/ai/registerTensorFlowMediaPipe.ts
 import { registerProviderWithWorker } from "@workglow/ai/provider-utils";
 
 // src/ai/TensorFlowMediaPipeQueuedProvider.ts
 import { AiProvider } from "@workglow/ai";
+
+// src/ai/common/TFMP_CapabilitySets.ts
+var TFMP_TEXT_EMBEDDING = ["text.embedding"];
+var TFMP_TEXT_CLASSIFICATION = ["text.classification"];
+var TFMP_TEXT_LANGUAGE_DETECTION = [
+  "text.language-detection"
+];
+var TFMP_IMAGE_CLASSIFICATION = ["image.classification"];
+var TFMP_IMAGE_EMBEDDING = ["image.embedding"];
+var TFMP_IMAGE_SEGMENTATION = ["image.segmentation"];
+var TFMP_IMAGE_OBJECT_DETECTION = [
+  "image.object-detection"
+];
+var TFMP_VISION_FACE_DETECTION = ["vision.face-detection"];
+var TFMP_VISION_FACE_LANDMARKS = ["vision.face-landmarks"];
+var TFMP_VISION_HAND_LANDMARKS = ["vision.hand-landmarks"];
+var TFMP_VISION_POSE_LANDMARKS = ["vision.pose-landmarks"];
+var TFMP_VISION_GESTURE = ["vision.gesture"];
+var TFMP_MODEL_DOWNLOAD = ["model.download"];
+var TFMP_MODEL_UNLOAD = ["model.download-remove"];
+var TFMP_MODEL_SEARCH = ["model.search"];
+var TFMP_MODEL_INFO = ["model.info"];
+var TFMP_CAPABILITY_SETS = [
+  TFMP_TEXT_EMBEDDING,
+  TFMP_TEXT_CLASSIFICATION,
+  TFMP_TEXT_LANGUAGE_DETECTION,
+  TFMP_IMAGE_CLASSIFICATION,
+  TFMP_IMAGE_EMBEDDING,
+  TFMP_IMAGE_SEGMENTATION,
+  TFMP_IMAGE_OBJECT_DETECTION,
+  TFMP_VISION_FACE_DETECTION,
+  TFMP_VISION_FACE_LANDMARKS,
+  TFMP_VISION_HAND_LANDMARKS,
+  TFMP_VISION_POSE_LANDMARKS,
+  TFMP_VISION_GESTURE,
+  TFMP_MODEL_DOWNLOAD,
+  TFMP_MODEL_UNLOAD,
+  TFMP_MODEL_SEARCH,
+  TFMP_MODEL_INFO
+];
+
+// src/ai/common/TFMP_Capabilities.ts
+var TFMP_RUN_FN_SPECS = TFMP_CAPABILITY_SETS.map((serves) => ({ serves }));
+function tfmpWorkerRunFnSpecs() {
+  return TFMP_RUN_FN_SPECS;
+}
+function inferTfmpCapabilities(model) {
+  const declared = model.capabilities ?? [];
+  if (declared.length > 0)
+    return declared;
+  const id = String(model.model_id ?? model.provider_config?.model_path ?? model.provider_config?.model_name ?? "");
+  const baseName = (id.split("/").pop() ?? id).toLowerCase();
+  if (/gesture_recognizer/.test(baseName)) {
+    return [
+      "vision.gesture",
+      "vision.hand-landmarks",
+      "model.download-remove",
+      "model.info",
+      "model.search"
+    ];
+  }
+  if (/hand_landmarker/.test(baseName)) {
+    return ["vision.hand-landmarks", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/face_landmarker/.test(baseName)) {
+    return ["vision.face-landmarks", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/face_detector|blaze_face/.test(baseName)) {
+    return ["vision.face-detection", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/pose_landmarker/.test(baseName)) {
+    return ["vision.pose-landmarks", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/object_detector|efficientdet|ssd_mobilenet|yolo/.test(baseName)) {
+    return ["image.object-detection", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/segmenter|deeplab|selfie/.test(baseName)) {
+    return ["image.segmentation", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/image_classifier|efficientnet|mobilenet/.test(baseName)) {
+    return ["image.classification", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/image_embed/.test(baseName)) {
+    return ["image.embedding", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/text_embed|universal_sentence_encoder|use_/.test(baseName)) {
+    return ["text.embedding", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/text_classifier|bert_classifier/.test(baseName)) {
+    return ["text.classification", "model.download-remove", "model.info", "model.search"];
+  }
+  if (/language_detector/.test(baseName)) {
+    return ["text.language-detection", "model.download-remove", "model.info", "model.search"];
+  }
+  return ["model.search", "model.info"];
+}
+
+// src/ai/TensorFlowMediaPipeQueuedProvider.ts
 class TensorFlowMediaPipeQueuedProvider extends AiProvider {
   name = TENSORFLOW_MEDIAPIPE;
   displayName = "TensorFlow MediaPipe";
   isLocal = true;
   supportsBrowser = true;
-  taskTypes = TFMP_DEFAULT_TASK_TYPES;
-  constructor(tasks, previewTasks) {
-    super(tasks, undefined, previewTasks);
+  constructor(promiseRunFns, previewTasks) {
+    super(promiseRunFns, previewTasks);
+  }
+  inferCapabilities(model) {
+    return inferTfmpCapabilities(model);
+  }
+  workerRunFnSpecs() {
+    return tfmpWorkerRunFnSpecs();
   }
 }
 
@@ -334,9 +434,622 @@ class TensorFlowMediaPipeQueuedProvider extends AiProvider {
 async function registerTensorFlowMediaPipe(options) {
   await registerProviderWithWorker(new TensorFlowMediaPipeQueuedProvider, "TensorFlow MediaPipe", options);
 }
+// src/ai/common/TFMP_Download.ts
+import { PermanentJobError as PermanentJobError2 } from "@workglow/job-queue";
+
+// src/ai/common/TFMP_Client.ts
+var _loadPromiseText;
+var _loadPromiseVision;
+async function loadTfmpTasksTextSDK() {
+  _loadPromiseText ??= import("@mediapipe/tasks-text").catch(() => {
+    _loadPromiseText = undefined;
+    throw new Error("@mediapipe/tasks-text is required for TensorFlow MediaPipe text (and related) tasks. Install with: bun add @mediapipe/tasks-text");
+  });
+  return _loadPromiseText;
+}
+async function loadTfmpTasksVisionSDK() {
+  _loadPromiseVision ??= import("@mediapipe/tasks-vision").catch(() => {
+    _loadPromiseVision = undefined;
+    throw new Error("@mediapipe/tasks-vision is required for TensorFlow MediaPipe vision tasks. Install with: bun add @mediapipe/tasks-vision");
+  });
+  return _loadPromiseVision;
+}
+
+// src/ai/common/TFMP_Runtime.ts
+import { PermanentJobError } from "@workglow/job-queue";
+var wasm_tasks = new Map;
+var wasm_reference_counts = new Map;
+var modelTaskCache = new Map;
+var optionsMatch = (opts1, opts2) => {
+  const keys1 = Object.keys(opts1).sort();
+  const keys2 = Object.keys(opts2).sort();
+  if (keys1.length !== keys2.length)
+    return false;
+  return keys1.every((key) => {
+    const val1 = opts1[key];
+    const val2 = opts2[key];
+    if (Array.isArray(val1) && Array.isArray(val2)) {
+      return JSON.stringify(val1) === JSON.stringify(val2);
+    }
+    return val1 === val2;
+  });
+};
+var getWasmTask = async (model, emit, signal) => {
+  const task_engine = model.provider_config.task_engine;
+  if (wasm_tasks.has(task_engine)) {
+    return wasm_tasks.get(task_engine);
+  }
+  if (signal.aborted) {
+    throw new PermanentJobError("Aborted job");
+  }
+  emit({ type: "phase", message: "Loading WASM task", progress: 0.1 });
+  let wasmFileset;
+  switch (task_engine) {
+    case "vision": {
+      const { FilesetResolver } = await loadTfmpTasksVisionSDK();
+      wasmFileset = await FilesetResolver.forVisionTasks("https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@latest/wasm");
+      break;
+    }
+    case "text": {
+      const { FilesetResolver } = await loadTfmpTasksTextSDK();
+      wasmFileset = await FilesetResolver.forTextTasks("https://cdn.jsdelivr.net/npm/@mediapipe/tasks-text@latest/wasm");
+      break;
+    }
+    case "audio": {
+      const { FilesetResolver } = await loadTfmpTasksTextSDK();
+      wasmFileset = await FilesetResolver.forAudioTasks("https://cdn.jsdelivr.net/npm/@mediapipe/tasks-audio@latest/wasm");
+      break;
+    }
+    case "genai": {
+      const { FilesetResolver } = await loadTfmpTasksTextSDK();
+      wasmFileset = await FilesetResolver.forGenAiTasks("https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm");
+      break;
+    }
+    default:
+      throw new PermanentJobError("Invalid task engine");
+  }
+  wasm_tasks.set(task_engine, wasmFileset);
+  return wasmFileset;
+};
+var getModelTask = async (model, options, emit, signal, TaskType) => {
+  const model_path = model.provider_config.model_path;
+  const task_engine = model.provider_config.task_engine;
+  const cachedTasks = modelTaskCache.get(model_path);
+  if (cachedTasks) {
+    const matchedTask = cachedTasks.find((cached) => optionsMatch(cached.options, options));
+    if (matchedTask) {
+      return matchedTask.task;
+    }
+  }
+  const wasmFileset = await getWasmTask(model, emit, signal);
+  emit({ type: "phase", message: "Creating model task", progress: 0.2 });
+  const task = await TaskType.createFromOptions(wasmFileset, {
+    baseOptions: {
+      modelAssetPath: model_path
+    },
+    ...options
+  });
+  const cachedTask = { task, options, task_engine };
+  if (!modelTaskCache.has(model_path)) {
+    modelTaskCache.set(model_path, []);
+  }
+  modelTaskCache.get(model_path).push(cachedTask);
+  wasm_reference_counts.set(task_engine, (wasm_reference_counts.get(task_engine) || 0) + 1);
+  return task;
+};
+
+// src/ai/common/TFMP_Download.ts
+var TFMP_Download = async (input, model, signal, emit) => {
+  const pipeline = model?.provider_config.pipeline;
+  let task;
+  switch (pipeline) {
+    case "text-embedder": {
+      const { TextEmbedder } = await loadTfmpTasksTextSDK();
+      task = await getModelTask(model, {}, emit, signal, TextEmbedder);
+      break;
+    }
+    case "text-classifier": {
+      const { TextClassifier } = await loadTfmpTasksTextSDK();
+      task = await getModelTask(model, {}, emit, signal, TextClassifier);
+      break;
+    }
+    case "text-language-detector": {
+      const { LanguageDetector } = await loadTfmpTasksTextSDK();
+      task = await getModelTask(model, {}, emit, signal, LanguageDetector);
+      break;
+    }
+    case "vision-image-classifier": {
+      const { ImageClassifier } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, emit, signal, ImageClassifier);
+      break;
+    }
+    case "vision-image-embedder": {
+      const { ImageEmbedder } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, emit, signal, ImageEmbedder);
+      break;
+    }
+    case "vision-image-segmenter": {
+      const { ImageSegmenter } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, emit, signal, ImageSegmenter);
+      break;
+    }
+    case "vision-object-detector": {
+      const { ObjectDetector } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, emit, signal, ObjectDetector);
+      break;
+    }
+    case "vision-face-detector": {
+      const { FaceDetector } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, emit, signal, FaceDetector);
+      break;
+    }
+    case "vision-face-landmarker": {
+      const { FaceLandmarker } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, emit, signal, FaceLandmarker);
+      break;
+    }
+    case "vision-gesture-recognizer": {
+      const { GestureRecognizer } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, emit, signal, GestureRecognizer);
+      break;
+    }
+    case "vision-hand-landmarker": {
+      const { HandLandmarker } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, emit, signal, HandLandmarker);
+      break;
+    }
+    case "vision-pose-landmarker": {
+      const { PoseLandmarker } = await loadTfmpTasksVisionSDK();
+      task = await getModelTask(model, {}, emit, signal, PoseLandmarker);
+      break;
+    }
+    default:
+      throw new PermanentJobError2(`Invalid pipeline: ${pipeline}. Supported pipelines: text-embedder, text-classifier, text-language-detector, vision-image-classifier, vision-image-embedder, vision-image-segmenter, vision-object-detector, vision-face-detector, vision-face-landmarker, vision-gesture-recognizer, vision-hand-landmarker, vision-pose-landmarker`);
+  }
+  emit({ type: "phase", message: "Pipeline loaded", progress: 0.9 });
+  task.close();
+  const task_engine = model.provider_config.task_engine;
+  wasm_reference_counts.set(task_engine, wasm_reference_counts.get(task_engine) - 1);
+  emit({ type: "finish", data: { model: input.model } });
+};
+
+// src/ai/common/TFMP_FaceDetector.ts
+import { PermanentJobError as PermanentJobError3 } from "@workglow/job-queue";
+var TFMP_FaceDetector = async (input, model, signal, emit) => {
+  const { FaceDetector } = await loadTfmpTasksVisionSDK();
+  const faceDetector = await getModelTask(model, {
+    minDetectionConfidence: input.minDetectionConfidence,
+    minSuppressionThreshold: input.minSuppressionThreshold
+  }, emit, signal, FaceDetector);
+  const result = faceDetector.detect(input.image);
+  if (!result.detections) {
+    throw new PermanentJobError3("Failed to detect faces: Empty result");
+  }
+  const faces = result.detections.map((detection) => ({
+    box: {
+      x: detection.boundingBox?.originX || 0,
+      y: detection.boundingBox?.originY || 0,
+      width: detection.boundingBox?.width || 0,
+      height: detection.boundingBox?.height || 0
+    },
+    keypoints: detection.keypoints?.map((kp) => ({
+      x: kp.x,
+      y: kp.y,
+      label: kp.label
+    })) || [],
+    score: detection.categories?.[0]?.score || 0
+  }));
+  emit({ type: "finish", data: { faces } });
+};
+
+// src/ai/common/TFMP_FaceLandmarker.ts
+import { PermanentJobError as PermanentJobError4 } from "@workglow/job-queue";
+var TFMP_FaceLandmarker = async (input, model, signal, emit) => {
+  const { FaceLandmarker } = await loadTfmpTasksVisionSDK();
+  const faceLandmarker = await getModelTask(model, {
+    numFaces: input.numFaces,
+    minFaceDetectionConfidence: input.minFaceDetectionConfidence,
+    minFacePresenceConfidence: input.minFacePresenceConfidence,
+    minTrackingConfidence: input.minTrackingConfidence,
+    outputFaceBlendshapes: input.outputFaceBlendshapes,
+    outputFacialTransformationMatrixes: input.outputFacialTransformationMatrixes
+  }, emit, signal, FaceLandmarker);
+  const result = faceLandmarker.detect(input.image);
+  if (!result.faceLandmarks) {
+    throw new PermanentJobError4("Failed to detect face landmarks: Empty result");
+  }
+  const faces = result.faceLandmarks.map((landmarks, index) => {
+    const face = {
+      landmarks: landmarks.map((l) => ({
+        x: l.x,
+        y: l.y,
+        z: l.z
+      }))
+    };
+    if (result.faceBlendshapes && result.faceBlendshapes[index]) {
+      face.blendshapes = result.faceBlendshapes[index].categories.map((b) => ({
+        label: b.categoryName,
+        score: b.score
+      }));
+    }
+    if (result.facialTransformationMatrixes && result.facialTransformationMatrixes[index]) {
+      face.transformationMatrix = Array.from(result.facialTransformationMatrixes[index].data);
+    }
+    return face;
+  });
+  emit({ type: "finish", data: { faces } });
+};
+
+// src/ai/common/TFMP_GestureRecognizer.ts
+import { PermanentJobError as PermanentJobError5 } from "@workglow/job-queue";
+var TFMP_GestureRecognizer = async (input, model, signal, emit) => {
+  const { GestureRecognizer } = await loadTfmpTasksVisionSDK();
+  const gestureRecognizer = await getModelTask(model, {
+    numHands: input.numHands,
+    minHandDetectionConfidence: input.minHandDetectionConfidence,
+    minHandPresenceConfidence: input.minHandPresenceConfidence,
+    minTrackingConfidence: input.minTrackingConfidence
+  }, emit, signal, GestureRecognizer);
+  const result = gestureRecognizer.recognize(input.image);
+  if (!result.gestures || !result.landmarks) {
+    throw new PermanentJobError5("Failed to recognize gestures: Empty result");
+  }
+  const hands = result.gestures.map((gestures, index) => ({
+    gestures: gestures.map((g) => ({
+      label: g.categoryName,
+      score: g.score
+    })),
+    handedness: result.handedness[index].map((h) => ({
+      label: h.categoryName,
+      score: h.score
+    })),
+    landmarks: result.landmarks[index].map((l) => ({
+      x: l.x,
+      y: l.y,
+      z: l.z
+    })),
+    worldLandmarks: result.worldLandmarks[index].map((l) => ({
+      x: l.x,
+      y: l.y,
+      z: l.z
+    }))
+  }));
+  emit({ type: "finish", data: { hands } });
+};
+
+// src/ai/common/TFMP_HandLandmarker.ts
+import { PermanentJobError as PermanentJobError6 } from "@workglow/job-queue";
+var TFMP_HandLandmarker = async (input, model, signal, emit) => {
+  const { HandLandmarker } = await loadTfmpTasksVisionSDK();
+  const handLandmarker = await getModelTask(model, {
+    numHands: input.numHands,
+    minHandDetectionConfidence: input.minHandDetectionConfidence,
+    minHandPresenceConfidence: input.minHandPresenceConfidence,
+    minTrackingConfidence: input.minTrackingConfidence
+  }, emit, signal, HandLandmarker);
+  const result = handLandmarker.detect(input.image);
+  if (!result.landmarks) {
+    throw new PermanentJobError6("Failed to detect hand landmarks: Empty result");
+  }
+  const hands = result.landmarks.map((landmarks, index) => ({
+    handedness: result.handedness[index].map((h) => ({
+      label: h.categoryName,
+      score: h.score
+    })),
+    landmarks: landmarks.map((l) => ({
+      x: l.x,
+      y: l.y,
+      z: l.z
+    })),
+    worldLandmarks: result.worldLandmarks[index].map((l) => ({
+      x: l.x,
+      y: l.y,
+      z: l.z
+    }))
+  }));
+  emit({ type: "finish", data: { hands } });
+};
+
+// src/ai/common/TFMP_ImageClassification.ts
+import { PermanentJobError as PermanentJobError7 } from "@workglow/job-queue";
+var TFMP_ImageClassification = async (input, model, signal, emit) => {
+  const { ImageClassifier } = await loadTfmpTasksVisionSDK();
+  const imageClassifier = await getModelTask(model, {
+    maxResults: input.maxCategories
+  }, emit, signal, ImageClassifier);
+  const result = imageClassifier.classify(input.image);
+  if (!result.classifications?.[0]?.categories) {
+    throw new PermanentJobError7("Failed to classify image: Empty result");
+  }
+  const categories = result.classifications[0].categories.map((category) => ({
+    label: category.categoryName,
+    score: category.score
+  }));
+  emit({ type: "finish", data: { categories } });
+};
+
+// src/ai/common/TFMP_ImageEmbedding.ts
+import { PermanentJobError as PermanentJobError8 } from "@workglow/job-queue";
+var TFMP_ImageEmbedding = async (input, model, signal, emit) => {
+  const { ImageEmbedder } = await loadTfmpTasksVisionSDK();
+  const imageEmbedder = await getModelTask(model, {}, emit, signal, ImageEmbedder);
+  if (Array.isArray(input.image)) {
+    const vectors = [];
+    for (const image of input.image) {
+      const result2 = imageEmbedder.embed(image);
+      if (!result2.embeddings?.[0]?.floatEmbedding) {
+        throw new PermanentJobError8("Failed to generate embedding: Empty result");
+      }
+      vectors.push(Float32Array.from(result2.embeddings[0].floatEmbedding));
+    }
+    emit({ type: "finish", data: { vector: vectors } });
+    return;
+  }
+  const result = imageEmbedder.embed(input.image);
+  if (!result.embeddings?.[0]?.floatEmbedding) {
+    throw new PermanentJobError8("Failed to generate embedding: Empty result");
+  }
+  const embedding = Float32Array.from(result.embeddings[0].floatEmbedding);
+  emit({ type: "finish", data: { vector: embedding } });
+};
+
+// src/ai/common/TFMP_ImageSegmentation.ts
+import { PermanentJobError as PermanentJobError9 } from "@workglow/job-queue";
+var TFMP_ImageSegmentation = async (input, model, signal, emit) => {
+  const { ImageSegmenter } = await loadTfmpTasksVisionSDK();
+  const imageSegmenter = await getModelTask(model, {}, emit, signal, ImageSegmenter);
+  const result = imageSegmenter.segment(input.image);
+  if (!result.categoryMask) {
+    throw new PermanentJobError9("Failed to segment image: Empty result");
+  }
+  const masks = [
+    {
+      label: "segment",
+      score: 1,
+      mask: {
+        data: result.categoryMask.canvas,
+        width: result.categoryMask.width,
+        height: result.categoryMask.height
+      }
+    }
+  ];
+  emit({ type: "finish", data: { masks } });
+};
+
+// src/ai/common/TFMP_ModelInfo.ts
+var TFMP_EMBEDDING_DIMENSIONS = {
+  "universal-sentence-encoder": { native_dimensions: 512, mrl: false }
+};
+var TFMP_ModelInfo = async (input, model, _signal, emit) => {
+  if (input.detail === "dimensions") {
+    const pc = model?.provider_config;
+    let native_dimensions = typeof pc?.native_dimensions === "number" ? pc.native_dimensions : undefined;
+    const mrl = typeof pc?.mrl === "boolean" ? pc.mrl : false;
+    if (native_dimensions === undefined) {
+      const modelPath = pc?.model_path ?? "";
+      const known = TFMP_EMBEDDING_DIMENSIONS[modelPath];
+      if (known) {
+        native_dimensions = known.native_dimensions;
+      }
+    }
+    emit({
+      type: "finish",
+      data: {
+        model: input.model,
+        is_local: true,
+        is_remote: false,
+        supports_browser: true,
+        supports_node: false,
+        is_cached: false,
+        is_loaded: false,
+        file_sizes: null,
+        ...native_dimensions !== undefined ? { native_dimensions } : {},
+        ...mrl ? { mrl } : {}
+      }
+    });
+    return;
+  }
+  const model_path = model.provider_config.model_path;
+  const is_loaded = modelTaskCache.has(model_path);
+  emit({
+    type: "finish",
+    data: {
+      model: input.model,
+      is_local: true,
+      is_remote: false,
+      supports_browser: true,
+      supports_node: false,
+      is_cached: is_loaded,
+      is_loaded,
+      file_sizes: null
+    }
+  });
+};
+
+// src/ai/common/TFMP_ObjectDetection.ts
+import { PermanentJobError as PermanentJobError10 } from "@workglow/job-queue";
+var TFMP_ObjectDetection = async (input, model, signal, emit) => {
+  const { ObjectDetector } = await loadTfmpTasksVisionSDK();
+  const objectDetector = await getModelTask(model, {
+    scoreThreshold: input.threshold
+  }, emit, signal, ObjectDetector);
+  const result = objectDetector.detect(input.image);
+  if (!result.detections) {
+    throw new PermanentJobError10("Failed to detect objects: Empty result");
+  }
+  const detections = result.detections.map((detection) => ({
+    label: detection.categories?.[0]?.categoryName || "unknown",
+    score: detection.categories?.[0]?.score || 0,
+    box: {
+      x: detection.boundingBox?.originX || 0,
+      y: detection.boundingBox?.originY || 0,
+      width: detection.boundingBox?.width || 0,
+      height: detection.boundingBox?.height || 0
+    }
+  }));
+  emit({ type: "finish", data: { detections } });
+};
+
+// src/ai/common/TFMP_PoseLandmarker.ts
+import { PermanentJobError as PermanentJobError11 } from "@workglow/job-queue";
+var TFMP_PoseLandmarker = async (input, model, signal, emit) => {
+  const { PoseLandmarker } = await loadTfmpTasksVisionSDK();
+  const poseLandmarker = await getModelTask(model, {
+    numPoses: input.numPoses,
+    minPoseDetectionConfidence: input.minPoseDetectionConfidence,
+    minPosePresenceConfidence: input.minPosePresenceConfidence,
+    minTrackingConfidence: input.minTrackingConfidence,
+    outputSegmentationMasks: input.outputSegmentationMasks
+  }, emit, signal, PoseLandmarker);
+  const result = poseLandmarker.detect(input.image);
+  if (!result.landmarks) {
+    throw new PermanentJobError11("Failed to detect pose landmarks: Empty result");
+  }
+  const poses = result.landmarks.map((landmarks, index) => {
+    const pose = {
+      landmarks: landmarks.map((l) => ({
+        x: l.x,
+        y: l.y,
+        z: l.z,
+        visibility: l.visibility,
+        presence: l.presence
+      })),
+      worldLandmarks: result.worldLandmarks[index].map((l) => ({
+        x: l.x,
+        y: l.y,
+        z: l.z,
+        visibility: l.visibility,
+        presence: l.presence
+      }))
+    };
+    if (result.segmentationMasks && result.segmentationMasks[index]) {
+      const mask = result.segmentationMasks[index];
+      pose.segmentationMask = {
+        data: mask.canvas || mask,
+        width: mask.width,
+        height: mask.height
+      };
+    }
+    return pose;
+  });
+  emit({ type: "finish", data: { poses } });
+};
+
+// src/ai/common/TFMP_TextClassification.ts
+import { PermanentJobError as PermanentJobError12 } from "@workglow/job-queue";
+var TFMP_TextClassification = async (input, model, signal, emit) => {
+  const { TextClassifier } = await loadTfmpTasksTextSDK();
+  const TextClassification = await getModelTask(model, {
+    maxCategories: input.maxCategories
+  }, emit, signal, TextClassifier);
+  const result = TextClassification.classify(input.text);
+  if (!result.classifications?.[0]?.categories) {
+    throw new PermanentJobError12("Failed to classify text: Empty result");
+  }
+  const categories = result.classifications[0].categories.map((category) => ({
+    label: category.categoryName,
+    score: category.score
+  }));
+  emit({ type: "finish", data: { categories } });
+};
+
+// src/ai/common/TFMP_TextEmbedding.ts
+import { PermanentJobError as PermanentJobError13 } from "@workglow/job-queue";
+var TFMP_TextEmbedding = async (input, model, signal, emit) => {
+  const { TextEmbedder } = await loadTfmpTasksTextSDK();
+  const textEmbedder = await getModelTask(model, {}, emit, signal, TextEmbedder);
+  if (Array.isArray(input.text)) {
+    const embeddings = input.text.map((text) => {
+      const result2 = textEmbedder.embed(text);
+      if (!result2.embeddings?.[0]?.floatEmbedding) {
+        throw new PermanentJobError13("Failed to generate embedding: Empty result");
+      }
+      return Float32Array.from(result2.embeddings[0].floatEmbedding);
+    });
+    emit({ type: "finish", data: { vector: embeddings } });
+    return;
+  }
+  const result = textEmbedder.embed(input.text);
+  if (!result.embeddings?.[0]?.floatEmbedding) {
+    throw new PermanentJobError13("Failed to generate embedding: Empty result");
+  }
+  const embedding = Float32Array.from(result.embeddings[0].floatEmbedding);
+  emit({ type: "finish", data: { vector: embedding } });
+};
+
+// src/ai/common/TFMP_TextLanguageDetection.ts
+import { PermanentJobError as PermanentJobError14 } from "@workglow/job-queue";
+var TFMP_TextLanguageDetection = async (input, model, signal, emit) => {
+  const maxLanguages = input.maxLanguages === 0 ? -1 : input.maxLanguages;
+  const { LanguageDetector } = await loadTfmpTasksTextSDK();
+  const textLanguageDetector = await getModelTask(model, {
+    maxLanguages
+  }, emit, signal, LanguageDetector);
+  const result = textLanguageDetector.detect(input.text);
+  if (!result.languages?.[0]?.languageCode) {
+    throw new PermanentJobError14("Failed to detect language: Empty result");
+  }
+  const languages = result.languages.map((language) => ({
+    language: language.languageCode,
+    score: language.probability
+  }));
+  emit({ type: "finish", data: { languages } });
+};
+
+// src/ai/common/TFMP_Unload.ts
+var TFMP_Unload = async (input, model, _signal, emit) => {
+  const model_path = model.provider_config.model_path;
+  if (modelTaskCache.has(model_path)) {
+    const cachedTasks = modelTaskCache.get(model_path);
+    for (const cachedTask of cachedTasks) {
+      const task = cachedTask.task;
+      if ("close" in task && typeof task.close === "function")
+        task.close();
+      const task_engine = cachedTask.task_engine;
+      const currentCount = wasm_reference_counts.get(task_engine) || 0;
+      const newCount = currentCount - 1;
+      if (newCount <= 0) {
+        wasm_tasks.delete(task_engine);
+        wasm_reference_counts.delete(task_engine);
+      } else {
+        wasm_reference_counts.set(task_engine, newCount);
+      }
+    }
+    modelTaskCache.delete(model_path);
+  }
+  emit({ type: "finish", data: { model: input.model } });
+};
+
+// src/ai/common/TFMP_JobRunFns.ts
+var TFMP_RUN_FNS = [
+  { serves: TFMP_TEXT_EMBEDDING, runFn: TFMP_TextEmbedding },
+  { serves: TFMP_TEXT_CLASSIFICATION, runFn: TFMP_TextClassification },
+  { serves: TFMP_TEXT_LANGUAGE_DETECTION, runFn: TFMP_TextLanguageDetection },
+  { serves: TFMP_IMAGE_CLASSIFICATION, runFn: TFMP_ImageClassification },
+  { serves: TFMP_IMAGE_EMBEDDING, runFn: TFMP_ImageEmbedding },
+  { serves: TFMP_IMAGE_SEGMENTATION, runFn: TFMP_ImageSegmentation },
+  { serves: TFMP_IMAGE_OBJECT_DETECTION, runFn: TFMP_ObjectDetection },
+  { serves: TFMP_VISION_FACE_DETECTION, runFn: TFMP_FaceDetector },
+  { serves: TFMP_VISION_FACE_LANDMARKS, runFn: TFMP_FaceLandmarker },
+  { serves: TFMP_VISION_HAND_LANDMARKS, runFn: TFMP_HandLandmarker },
+  { serves: TFMP_VISION_POSE_LANDMARKS, runFn: TFMP_PoseLandmarker },
+  { serves: TFMP_VISION_GESTURE, runFn: TFMP_GestureRecognizer },
+  { serves: TFMP_MODEL_DOWNLOAD, runFn: TFMP_Download },
+  { serves: TFMP_MODEL_UNLOAD, runFn: TFMP_Unload },
+  { serves: TFMP_MODEL_SEARCH, runFn: TFMP_ModelSearch },
+  { serves: TFMP_MODEL_INFO, runFn: TFMP_ModelInfo }
+];
+
+// src/ai/index.ts
+var _testOnly = {
+  TensorFlowMediaPipeQueuedProvider,
+  TFMP_RUN_FN_SPECS,
+  TFMP_RUN_FNS
+};
 export {
   registerTensorFlowMediaPipe,
   createTFMPModelSearch,
+  _testOnly,
   TextPipelineTask,
   TFMP_ModelSearch,
   TFMP_DEFAULT_TASK_TYPES,
@@ -346,4 +1059,4 @@ export {
   TENSORFLOW_MEDIAPIPE
 };
 
-//# debugId=50E8E246C2C5CE2A64756E2164756E21
+//# debugId=23504D8C865655B764756E2164756E21