@workglow/ai-provider 0.0.90 → 0.0.91

package/dist/tf-mediapipe/common/TFMP_JobRunFns.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TFMP_JobRunFns.d.ts","sourceRoot":"","sources":["../../../src/tf-mediapipe/common/TFMP_JobRunFns.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAmBH,OAAO,KAAK,EACV,eAAe,EACf,yBAAyB,EACzB,0BAA0B,EAC1B,qBAAqB,EACrB,sBAAsB,EACtB,uBAAuB,EACvB,wBAAwB,EACxB,0BAA0B,EAC1B,2BAA2B,EAC3B,uBAAuB,EACvB,wBAAwB,EACxB,4BAA4B,EAC5B,6BAA6B,EAC7B,uBAAuB,EACvB,wBAAwB,EACxB,0BAA0B,EAC1B,2BAA2B,EAC3B,wBAAwB,EACxB,yBAAyB,EACzB,uBAAuB,EACvB,wBAAwB,EACxB,2BAA2B,EAC3B,4BAA4B,EAC5B,sBAAsB,EACtB,uBAAuB,EACvB,8BAA8B,EAC9B,+BAA+B,EAC/B,uBAAuB,EACvB,wBAAwB,EACzB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AA4MrD;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,eAAe,CACzC,yBAAyB,EACzB,0BAA0B,EAC1B,eAAe,CAwDhB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,eAAe,CAC9C,sBAAsB,EACtB,uBAAuB,EACvB,eAAe,CAiChB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,uBAAuB,EAAE,eAAe,CACnD,2BAA2B,EAC3B,4BAA4B,EAC5B,eAAe,CA4BhB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,0BAA0B,EAAE,eAAe,CACtD,8BAA8B,EAC9B,+BAA+B,EAC/B,eAAe,CA8BhB,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,EAAE,eAAe,CACvC,uBAAuB,EACvB,wBAAwB,EACxB,eAAe,CAgChB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,eAAe,CAClD,0BAA0B,EAC1B,2BAA2B,EAC3B,eAAe,CAyBhB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,eAAe,CAC/C,uBAAuB,EACvB,wBAAwB,EACxB,eAAe,CAchB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB,EAAE,eAAe,CACpD,4BAA4B,EAC5B,6BAA6B,EAC7B,eAAe,CAyBhB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,eAAe,CAChD,wBAAwB,EACxB,yBAAyB,EACzB,eAAe,CA+BhB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,eAAe,CAClD,0BAA0B,EAC1B,2BAA2B,EAC3B,eAAe,CA4ChB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,eAAe,CAC/C,uBAAuB,EACvB,wBAAwB,EACxB,eAAe,CAwChB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAAe,CAC7C,qBAAqB,EACrB,sBAAsB,EACtB,eAAe,CAqChB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,eAAe,CAC/C,uBAAuB,EACvB,wBAAwB,EACxB,eAAe,CAgDhB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,eAAe,CAC/C,uBAAuB,EACvB,wBAAwB,EACxB,eAAe,CAsDhB,CAAC"}
+{"version":3,"file":"TFMP_JobRunFns.d.ts","sourceRoot":"","sources":["../../../src/tf-mediapipe/common/TFMP_JobRunFns.ts"],"names":[],"mappings":"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"}

package/dist/tf-mediapipe/index.d.ts

@@ -6,7 +6,6 @@
 export * from "./common/TFMP_Constants";
 export * from "./common/TFMP_JobRunFns";
 export * from "./common/TFMP_ModelSchema";
-export * from "./registry/TFMP_Client_RegisterJobFns";
-export * from "./registry/TFMP_Inline_RegisterJobFns";
-export * from "./registry/TFMP_Worker_RegisterJobFns";
+export * from "./TensorFlowMediaPipeProvider";
+export * from "./TFMP_Worker";
 //# sourceMappingURL=index.d.ts.map

package/dist/tf-mediapipe/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tf-mediapipe/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uCAAuC,CAAC;AACtD,cAAc,uCAAuC,CAAC;AACtD,cAAc,uCAAuC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tf-mediapipe/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,eAAe,CAAC"}

package/dist/tf-mediapipe/index.js

@@ -0,0 +1,674 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/tf-mediapipe/common/TFMP_Constants.ts
+var TENSORFLOW_MEDIAPIPE = "TENSORFLOW_MEDIAPIPE";
+var TextPipelineTask = {
+  "text-embedder": "text-embedder",
+  "text-classifier": "text-classifier",
+  "text-language-detector": "text-language-detector",
+  "genai-text": "genai-text",
+  "audio-classifier": "audio-classifier",
+  "audio-embedder": "audio-embedder",
+  "vision-face-detector": "vision-face-detector",
+  "vision-face-landmarker": "vision-face-landmarker",
+  "vision-face-stylizer": "vision-face-stylizer",
+  "vision-gesture-recognizer": "vision-gesture-recognizer",
+  "vision-hand-landmarker": "vision-hand-landmarker",
+  "vision-holistic-landmarker": "vision-holistic-landmarker",
+  "vision-image-classifier": "vision-image-classifier",
+  "vision-image-embedder": "vision-image-embedder",
+  "vision-image-segmenter": "vision-image-segmenter",
+  "vision-image-interactive-segmenter": "vision-image-interactive-segmenter",
+  "vision-object-detector": "vision-object-detector",
+  "vision-pose-landmarker": "vision-pose-landmarker"
+};
+// src/tf-mediapipe/common/TFMP_JobRunFns.ts
+import { PermanentJobError } from "@workglow/job-queue";
+var _textSdk;
+async function loadMediaPipeTextSDK() {
+  if (!_textSdk) {
+    try {
+      _textSdk = await import("@mediapipe/tasks-text");
+    } catch {
+      throw new Error("@mediapipe/tasks-text is required for MediaPipe text tasks. Install it with: bun add @mediapipe/tasks-text");
+    }
+  }
+  return _textSdk;
+}
+var _visionSdk;
+async function loadMediaPipeVisionSDK() {
+  if (!_visionSdk) {
+    try {
+      _visionSdk = await import("@mediapipe/tasks-vision");
+    } catch {
+      throw new Error("@mediapipe/tasks-vision is required for MediaPipe vision tasks. Install it with: bun add @mediapipe/tasks-vision");
+    }
+  }
+  return _visionSdk;
+}
+var wasm_tasks = new Map;
+var wasm_reference_counts = new Map;
+var getWasmTask = async (model, onProgress, 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");
+  }
+  onProgress(0.1, "Loading WASM task");
+  const { FilesetResolver } = await loadMediaPipeTextSDK();
+  let wasmFileset;
+  switch (task_engine) {
+    case "text":
+      wasmFileset = await FilesetResolver.forTextTasks("https://cdn.jsdelivr.net/npm/@mediapipe/tasks-text@latest/wasm");
+      break;
+    case "audio":
+      wasmFileset = await FilesetResolver.forAudioTasks("https://cdn.jsdelivr.net/npm/@mediapipe/tasks-audio@latest/wasm");
+      break;
+    case "vision":
+      wasmFileset = await FilesetResolver.forVisionTasks("https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@latest/wasm");
+      break;
+    case "genai":
+      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 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 getModelTask = async (model, options, onProgress, 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, onProgress, signal);
+  onProgress(0.2, "Creating model task");
+  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;
+};
+var TFMP_Download = async (input, model, onProgress, signal) => {
+  let task;
+  switch (model?.provider_config.pipeline) {
+    case "text-embedder": {
+      const { TextEmbedder } = await loadMediaPipeTextSDK();
+      task = await getModelTask(model, {}, onProgress, signal, TextEmbedder);
+      break;
+    }
+    case "text-classifier": {
+      const { TextClassifier } = await loadMediaPipeTextSDK();
+      task = await getModelTask(model, {}, onProgress, signal, TextClassifier);
+      break;
+    }
+    case "text-language-detector": {
+      const { LanguageDetector } = await loadMediaPipeTextSDK();
+      task = await getModelTask(model, {}, onProgress, signal, LanguageDetector);
+      break;
+    }
+    case "vision-image-classifier": {
+      const { ImageClassifier } = await loadMediaPipeVisionSDK();
+      task = await getModelTask(model, {}, onProgress, signal, ImageClassifier);
+      break;
+    }
+    case "vision-image-embedder": {
+      const { ImageEmbedder } = await loadMediaPipeVisionSDK();
+      task = await getModelTask(model, {}, onProgress, signal, ImageEmbedder);
+      break;
+    }
+    case "vision-image-segmenter": {
+      const { ImageSegmenter } = await loadMediaPipeVisionSDK();
+      task = await getModelTask(model, {}, onProgress, signal, ImageSegmenter);
+      break;
+    }
+    case "vision-object-detector": {
+      const { ObjectDetector } = await loadMediaPipeVisionSDK();
+      task = await getModelTask(model, {}, onProgress, signal, ObjectDetector);
+      break;
+    }
+    case "vision-face-detector": {
+      const { FaceDetector } = await loadMediaPipeVisionSDK();
+      task = await getModelTask(model, {}, onProgress, signal, FaceDetector);
+      break;
+    }
+    case "vision-face-landmarker": {
+      const { FaceLandmarker } = await loadMediaPipeVisionSDK();
+      task = await getModelTask(model, {}, onProgress, signal, FaceLandmarker);
+      break;
+    }
+    case "vision-gesture-recognizer": {
+      const { GestureRecognizer } = await loadMediaPipeVisionSDK();
+      task = await getModelTask(model, {}, onProgress, signal, GestureRecognizer);
+      break;
+    }
+    case "vision-hand-landmarker": {
+      const { HandLandmarker } = await loadMediaPipeVisionSDK();
+      task = await getModelTask(model, {}, onProgress, signal, HandLandmarker);
+      break;
+    }
+    case "vision-pose-landmarker": {
+      const { PoseLandmarker } = await loadMediaPipeVisionSDK();
+      task = await getModelTask(model, {}, onProgress, signal, PoseLandmarker);
+      break;
+    }
+    default:
+      throw new PermanentJobError(`Invalid pipeline: ${model?.provider_config.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`);
+  }
+  onProgress(0.9, "Pipeline loaded");
+  task.close();
+  const task_engine = model?.provider_config.task_engine;
+  wasm_reference_counts.set(task_engine, wasm_reference_counts.get(task_engine) - 1);
+  return {
+    model: input.model
+  };
+};
+var TFMP_TextEmbedding = async (input, model, onProgress, signal) => {
+  const { TextEmbedder } = await loadMediaPipeTextSDK();
+  const textEmbedder = await getModelTask(model, {}, onProgress, 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 PermanentJobError("Failed to generate embedding: Empty result");
+      }
+      return Float32Array.from(result2.embeddings[0].floatEmbedding);
+    });
+    return {
+      vector: embeddings
+    };
+  }
+  const result = textEmbedder.embed(input.text);
+  if (!result.embeddings?.[0]?.floatEmbedding) {
+    throw new PermanentJobError("Failed to generate embedding: Empty result");
+  }
+  const embedding = Float32Array.from(result.embeddings[0].floatEmbedding);
+  return {
+    vector: embedding
+  };
+};
+var TFMP_TextClassification = async (input, model, onProgress, signal) => {
+  const { TextClassifier } = await loadMediaPipeTextSDK();
+  const TextClassification = await getModelTask(model, {
+    maxCategories: input.maxCategories
+  }, onProgress, signal, TextClassifier);
+  const result = TextClassification.classify(input.text);
+  if (!result.classifications?.[0]?.categories) {
+    throw new PermanentJobError("Failed to classify text: Empty result");
+  }
+  const categories = result.classifications[0].categories.map((category) => ({
+    label: category.categoryName,
+    score: category.score
+  }));
+  return {
+    categories
+  };
+};
+var TFMP_TextLanguageDetection = async (input, model, onProgress, signal) => {
+  const maxLanguages = input.maxLanguages === 0 ? -1 : input.maxLanguages;
+  const { LanguageDetector } = await loadMediaPipeTextSDK();
+  const textLanguageDetector = await getModelTask(model, {
+    maxLanguages
+  }, onProgress, signal, LanguageDetector);
+  const result = textLanguageDetector.detect(input.text);
+  if (!result.languages?.[0]?.languageCode) {
+    throw new PermanentJobError("Failed to detect language: Empty result");
+  }
+  const languages = result.languages.map((language) => ({
+    language: language.languageCode,
+    score: language.probability
+  }));
+  return {
+    languages
+  };
+};
+var TFMP_Unload = async (input, model, onProgress, signal) => {
+  const model_path = model.provider_config.model_path;
+  onProgress(10, "Unloading model");
+  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);
+  }
+  return {
+    model: input.model
+  };
+};
+var TFMP_ImageSegmentation = async (input, model, onProgress, signal) => {
+  const { ImageSegmenter } = await loadMediaPipeVisionSDK();
+  const imageSegmenter = await getModelTask(model, {}, onProgress, signal, ImageSegmenter);
+  const result = imageSegmenter.segment(input.image);
+  if (!result.categoryMask) {
+    throw new PermanentJobError("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
+      }
+    }
+  ];
+  return {
+    masks
+  };
+};
+var TFMP_ImageEmbedding = async (input, model, onProgress, signal) => {
+  const { ImageEmbedder } = await loadMediaPipeVisionSDK();
+  const imageEmbedder = await getModelTask(model, {}, onProgress, signal, ImageEmbedder);
+  const result = imageEmbedder.embed(input.image);
+  if (!result.embeddings?.[0]?.floatEmbedding) {
+    throw new PermanentJobError("Failed to generate embedding: Empty result");
+  }
+  const embedding = Float32Array.from(result.embeddings[0].floatEmbedding);
+  return {
+    vector: embedding
+  };
+};
+var TFMP_ImageClassification = async (input, model, onProgress, signal) => {
+  const { ImageClassifier } = await loadMediaPipeVisionSDK();
+  const imageClassifier = await getModelTask(model, {
+    maxResults: input.maxCategories
+  }, onProgress, signal, ImageClassifier);
+  const result = imageClassifier.classify(input.image);
+  if (!result.classifications?.[0]?.categories) {
+    throw new PermanentJobError("Failed to classify image: Empty result");
+  }
+  const categories = result.classifications[0].categories.map((category) => ({
+    label: category.categoryName,
+    score: category.score
+  }));
+  return {
+    categories
+  };
+};
+var TFMP_ObjectDetection = async (input, model, onProgress, signal) => {
+  const { ObjectDetector } = await loadMediaPipeVisionSDK();
+  const objectDetector = await getModelTask(model, {
+    scoreThreshold: input.threshold
+  }, onProgress, signal, ObjectDetector);
+  const result = objectDetector.detect(input.image);
+  if (!result.detections) {
+    throw new PermanentJobError("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
+    }
+  }));
+  return {
+    detections
+  };
+};
+var TFMP_GestureRecognizer = async (input, model, onProgress, signal) => {
+  const { GestureRecognizer } = await loadMediaPipeVisionSDK();
+  const gestureRecognizer = await getModelTask(model, {
+    numHands: input.numHands,
+    minHandDetectionConfidence: input.minHandDetectionConfidence,
+    minHandPresenceConfidence: input.minHandPresenceConfidence,
+    minTrackingConfidence: input.minTrackingConfidence
+  }, onProgress, signal, GestureRecognizer);
+  const result = gestureRecognizer.recognize(input.image);
+  if (!result.gestures || !result.landmarks) {
+    throw new PermanentJobError("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
+    }))
+  }));
+  return {
+    hands
+  };
+};
+var TFMP_HandLandmarker = async (input, model, onProgress, signal) => {
+  const { HandLandmarker } = await loadMediaPipeVisionSDK();
+  const handLandmarker = await getModelTask(model, {
+    numHands: input.numHands,
+    minHandDetectionConfidence: input.minHandDetectionConfidence,
+    minHandPresenceConfidence: input.minHandPresenceConfidence,
+    minTrackingConfidence: input.minTrackingConfidence
+  }, onProgress, signal, HandLandmarker);
+  const result = handLandmarker.detect(input.image);
+  if (!result.landmarks) {
+    throw new PermanentJobError("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
+    }))
+  }));
+  return {
+    hands
+  };
+};
+var TFMP_FaceDetector = async (input, model, onProgress, signal) => {
+  const { FaceDetector } = await loadMediaPipeVisionSDK();
+  const faceDetector = await getModelTask(model, {
+    minDetectionConfidence: input.minDetectionConfidence,
+    minSuppressionThreshold: input.minSuppressionThreshold
+  }, onProgress, signal, FaceDetector);
+  const result = faceDetector.detect(input.image);
+  if (!result.detections) {
+    throw new PermanentJobError("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
+  }));
+  return {
+    faces
+  };
+};
+var TFMP_FaceLandmarker = async (input, model, onProgress, signal) => {
+  const { FaceLandmarker } = await loadMediaPipeVisionSDK();
+  const faceLandmarker = await getModelTask(model, {
+    numFaces: input.numFaces,
+    minFaceDetectionConfidence: input.minFaceDetectionConfidence,
+    minFacePresenceConfidence: input.minFacePresenceConfidence,
+    minTrackingConfidence: input.minTrackingConfidence,
+    outputFaceBlendshapes: input.outputFaceBlendshapes,
+    outputFacialTransformationMatrixes: input.outputFacialTransformationMatrixes
+  }, onProgress, signal, FaceLandmarker);
+  const result = faceLandmarker.detect(input.image);
+  if (!result.faceLandmarks) {
+    throw new PermanentJobError("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;
+  });
+  return {
+    faces
+  };
+};
+var TFMP_PoseLandmarker = async (input, model, onProgress, signal) => {
+  const { PoseLandmarker } = await loadMediaPipeVisionSDK();
+  const poseLandmarker = await getModelTask(model, {
+    numPoses: input.numPoses,
+    minPoseDetectionConfidence: input.minPoseDetectionConfidence,
+    minPosePresenceConfidence: input.minPosePresenceConfidence,
+    minTrackingConfidence: input.minTrackingConfidence,
+    outputSegmentationMasks: input.outputSegmentationMasks
+  }, onProgress, signal, PoseLandmarker);
+  const result = poseLandmarker.detect(input.image);
+  if (!result.landmarks) {
+    throw new PermanentJobError("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;
+  });
+  return {
+    poses
+  };
+};
+var TFMP_TASKS = {
+  DownloadModelTask: TFMP_Download,
+  UnloadModelTask: TFMP_Unload,
+  TextEmbeddingTask: TFMP_TextEmbedding,
+  TextLanguageDetectionTask: TFMP_TextLanguageDetection,
+  TextClassificationTask: TFMP_TextClassification,
+  ImageSegmentationTask: TFMP_ImageSegmentation,
+  ImageEmbeddingTask: TFMP_ImageEmbedding,
+  ImageClassificationTask: TFMP_ImageClassification,
+  ObjectDetectionTask: TFMP_ObjectDetection,
+  GestureRecognizerTask: TFMP_GestureRecognizer,
+  HandLandmarkerTask: TFMP_HandLandmarker,
+  FaceDetectorTask: TFMP_FaceDetector,
+  FaceLandmarkerTask: TFMP_FaceLandmarker,
+  PoseLandmarkerTask: TFMP_PoseLandmarker
+};
+// src/tf-mediapipe/common/TFMP_ModelSchema.ts
+import { ModelConfigSchema, ModelRecordSchema } from "@workglow/ai";
+var TFMPModelSchema = {
+  type: "object",
+  properties: {
+    provider: {
+      const: TENSORFLOW_MEDIAPIPE,
+      description: "Discriminator: TensorFlow MediaPipe backend."
+    },
+    provider_config: {
+      type: "object",
+      description: "TensorFlow MediaPipe-specific options.",
+      properties: {
+        model_path: {
+          type: "string",
+          description: "Filesystem path or URI for the ONNX model."
+        },
+        task_engine: {
+          type: "string",
+          enum: ["text", "audio", "vision", "genai"],
+          description: "Task engine for the MediaPipe model."
+        },
+        pipeline: {
+          type: "string",
+          enum: Object.values(TextPipelineTask),
+          description: "Pipeline task type for the MediaPipe model."
+        }
+      },
+      required: ["model_path", "task_engine", "pipeline"],
+      additionalProperties: false
+    }
+  },
+  required: ["provider", "provider_config"],
+  additionalProperties: true
+};
+var TFMPModelRecordSchema = {
+  type: "object",
+  properties: {
+    ...ModelRecordSchema.properties,
+    ...TFMPModelSchema.properties
+  },
+  required: [...ModelRecordSchema.required, ...TFMPModelSchema.required],
+  additionalProperties: false
+};
+var TFMPModelConfigSchema = {
+  type: "object",
+  properties: {
+    ...ModelConfigSchema.properties,
+    ...TFMPModelSchema.properties
+  },
+  required: [...ModelConfigSchema.required, ...TFMPModelSchema.required],
+  additionalProperties: false
+};
+// src/tf-mediapipe/TensorFlowMediaPipeProvider.ts
+import { AiProvider } from "@workglow/ai";
+class TensorFlowMediaPipeProvider extends AiProvider {
+  name = TENSORFLOW_MEDIAPIPE;
+  taskTypes = [
+    "DownloadModelTask",
+    "UnloadModelTask",
+    "TextEmbeddingTask",
+    "TextLanguageDetectionTask",
+    "TextClassificationTask",
+    "ImageSegmentationTask",
+    "ImageEmbeddingTask",
+    "ImageClassificationTask",
+    "ObjectDetectionTask",
+    "GestureRecognizerTask",
+    "HandLandmarkerTask",
+    "FaceDetectorTask",
+    "FaceLandmarkerTask",
+    "PoseLandmarkerTask"
+  ];
+  constructor(tasks) {
+    super(tasks);
+  }
+}
+// src/tf-mediapipe/TFMP_Worker.ts
+import { globalServiceRegistry, parentPort, WORKER_SERVER } from "@workglow/util";
+function TFMP_WORKER_JOBRUN_REGISTER() {
+  const workerServer = globalServiceRegistry.get(WORKER_SERVER);
+  new TensorFlowMediaPipeProvider(TFMP_TASKS).registerOnWorkerServer(workerServer);
+  parentPort.postMessage({ type: "ready" });
+  console.log("TFMP_WORKER_JOBRUN registered");
+}
+export {
+  TextPipelineTask,
+  TensorFlowMediaPipeProvider,
+  TFMP_WORKER_JOBRUN_REGISTER,
+  TFMP_Unload,
+  TFMP_TextLanguageDetection,
+  TFMP_TextEmbedding,
+  TFMP_TextClassification,
+  TFMP_TASKS,
+  TFMP_PoseLandmarker,
+  TFMP_ObjectDetection,
+  TFMP_ImageSegmentation,
+  TFMP_ImageEmbedding,
+  TFMP_ImageClassification,
+  TFMP_HandLandmarker,
+  TFMP_GestureRecognizer,
+  TFMP_FaceLandmarker,
+  TFMP_FaceDetector,
+  TFMP_Download,
+  TFMPModelSchema,
+  TFMPModelRecordSchema,
+  TFMPModelConfigSchema,
+  TENSORFLOW_MEDIAPIPE
+};
+
+//# debugId=0AF5B3FEF7B1A64464756E2164756E21