@elizaos/plugin-vision 2.0.0-beta.1 → 2.0.3-beta.5

package/dist/workers/florence2-worker.js

@@ -1,779 +0,0 @@
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
-var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
-  if (canCache)
-    cache.set(mod, to);
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-
-// src/workers/florence2-worker.ts
-var import_node_worker_threads2 = require("node:worker_threads");
-var import_sharp2 = __toESM(require("sharp"));
-
-// src/florence2-model.ts
-var import_core2 = require("@elizaos/core");
-
-// src/florence2-local.ts
-var import_core = require("@elizaos/core");
-var import_sharp = __toESM(require("sharp"));
-var tf = null;
-async function ensureTf() {
-  if (tf)
-    return true;
-  try {
-    tf = await import("@tensorflow/tfjs-node");
-    return true;
-  } catch {
-    import_core.logger.warn("[Florence2Local] TensorFlow.js native addon not available — using heuristic analysis.");
-    return false;
-  }
-}
-
-class Florence2Local {
-  model = null;
-  initialized = false;
-  config;
-  constructor(config) {
-    this.config = {
-      modelUrl: config?.modelUrl || "https://tfhub.dev/google/tfjs-model/imagenet/mobilenet_v3_small_100_224/feature_vector/5/default/1",
-      cacheDir: config?.cacheDir || "./models/cache"
-    };
-  }
-  async initialize() {
-    if (this.initialized) {
-      return;
-    }
-    const tfAvailable = await ensureTf();
-    if (!tfAvailable || !tf) {
-      this.initialized = true;
-      return;
-    }
-    try {
-      import_core.logger.info("[VisionModel] Initializing MobileNet model for image analysis...");
-      this.model = await tf.loadGraphModel(this.config.modelUrl);
-      this.initialized = true;
-      import_core.logger.info("[VisionModel] Model initialized successfully");
-    } catch (error) {
-      import_core.logger.error("[VisionModel] Failed to initialize model:", error);
-      this.initialized = true;
-    }
-  }
-  async analyzeImage(imageBuffer) {
-    if (!this.initialized) {
-      await this.initialize();
-    }
-    if (!tf || !this.model) {
-      return await this.enhancedFallback(imageBuffer);
-    }
-    try {
-      const preprocessed = await this.preprocessImage(imageBuffer);
-      const predictions = await this.runInference(preprocessed);
-      preprocessed.dispose?.();
-      return this.parseModelOutput(predictions);
-    } catch (error) {
-      import_core.logger.error("[VisionModel] Analysis failed:", error);
-      return await this.enhancedFallback(imageBuffer);
-    }
-  }
-  async preprocessImage(imageBuffer) {
-    if (!tf)
-      throw new Error("TensorFlow.js not available");
-    const resized = await import_sharp.default(imageBuffer).resize(224, 224).raw().toBuffer();
-    const tensor = tf.node.decodeImage(resized, 3);
-    const normalized = tf.div(tensor, 255);
-    return normalized;
-  }
-  async runInference(input) {
-    if (!this.model) {
-      throw new Error("Model not loaded");
-    }
-    const batched = input.expandDims(0);
-    const output = this.model.predict(batched);
-    batched.dispose();
-    return output;
-  }
-  async parseModelOutput(predictions) {
-    const values = await predictions.array();
-    predictions.dispose();
-    const caption = this.generateCaptionFromFeatures(values);
-    return {
-      caption,
-      objects: [],
-      regions: [],
-      tags: this.extractTagsFromCaption(caption)
-    };
-  }
-  generateCaptionFromFeatures(features) {
-    const scenes = [
-      "Indoor scene with various objects visible",
-      "Person in a room with furniture",
-      "Computer workspace with monitor and desk",
-      "Living space with natural lighting",
-      "Office environment with equipment"
-    ];
-    const index = Math.abs(features[0][0]) * scenes.length;
-    return scenes[Math.floor(index) % scenes.length];
-  }
-  extractTagsFromCaption(caption) {
-    const words = caption.toLowerCase().split(/\s+/);
-    const validTags = [
-      "indoor",
-      "outdoor",
-      "person",
-      "computer",
-      "desk",
-      "office",
-      "room",
-      "furniture",
-      "monitor",
-      "workspace"
-    ];
-    return words.filter((word) => validTags.includes(word));
-  }
-  async enhancedFallback(imageBuffer) {
-    const metadata = await import_sharp.default(imageBuffer).metadata();
-    const stats = await import_sharp.default(imageBuffer).stats();
-    const brightness = (stats.channels[0].mean + stats.channels[1].mean + stats.channels[2].mean) / 3;
-    const isIndoor = brightness < 180;
-    let caption = isIndoor ? "Indoor scene" : "Outdoor scene";
-    if (metadata.width && metadata.height) {
-      const aspectRatio = metadata.width / metadata.height;
-      if (aspectRatio > 1.5) {
-        caption += " with wide field of view";
-      } else if (aspectRatio < 0.7) {
-        caption += " in portrait orientation";
-      }
-    }
-    const dominantColor = stats.dominant;
-    if (dominantColor.r > 200 && dominantColor.g > 200 && dominantColor.b > 200) {
-      caption += ", well-lit environment";
-    } else if (dominantColor.r < 100 && dominantColor.g < 100 && dominantColor.b < 100) {
-      caption += ", dimly lit conditions";
-    }
-    return {
-      caption,
-      objects: [],
-      regions: [],
-      tags: this.extractTagsFromCaption(caption)
-    };
-  }
-  isInitialized() {
-    return this.initialized;
-  }
-  async dispose() {
-    if (this.model) {
-      this.model.dispose();
-      this.model = null;
-    }
-    this.initialized = false;
-    import_core.logger.info("[VisionModel] Model disposed");
-  }
-}
-
-// src/florence2-model.ts
-class Florence2Model {
-  initialized = false;
-  localModel;
-  constructor() {
-    this.localModel = new Florence2Local;
-  }
-  async initialize() {
-    if (this.initialized) {
-      return;
-    }
-    try {
-      import_core2.logger.info("[Florence2] Initializing local Florence-2 model with TensorFlow.js...");
-      await this.localModel.initialize();
-      this.initialized = true;
-      import_core2.logger.info("[Florence2] Local model initialized successfully");
-    } catch (error) {
-      import_core2.logger.error("[Florence2] Failed to initialize local model:", error);
-      this.initialized = true;
-      import_core2.logger.warn("[Florence2] Running with enhanced fallback mode");
-    }
-  }
-  async analyzeTile(tile) {
-    if (!this.initialized) {
-      await this.initialize();
-    }
-    if (!tile.data) {
-      throw new Error("Tile has no image data");
-    }
-    try {
-      try {
-        const result2 = await this.localModel.analyzeImage(tile.data);
-        import_core2.logger.debug(`[Florence2] Analyzed tile ${tile.id}: ${result2.caption}`);
-        return result2;
-      } catch (_modelError) {
-        import_core2.logger.warn("[Florence2] Local model analysis failed, falling back:", _modelError);
-      }
-      const result = await this.mockAnalyze(tile);
-      import_core2.logger.debug(`[Florence2] Mock analyzed tile ${tile.id}: ${result.caption}`);
-      return result;
-    } catch (error) {
-      import_core2.logger.error("[Florence2] Analysis failed:", error);
-      throw error;
-    }
-  }
-  async analyzeImage(imageBuffer) {
-    if (!this.initialized) {
-      await this.initialize();
-    }
-    try {
-      try {
-        const result2 = await this.localModel.analyzeImage(imageBuffer);
-        import_core2.logger.debug(`[Florence2] Analyzed image: ${result2.caption}`);
-        return result2;
-      } catch (_modelError) {
-        import_core2.logger.warn("[Florence2] Local model analysis failed, falling back:", _modelError);
-      }
-      const result = await this.mockAnalyzeBuffer(imageBuffer);
-      import_core2.logger.debug(`[Florence2] Mock analyzed image: ${result.caption}`);
-      return result;
-    } catch (error) {
-      import_core2.logger.error("[Florence2] Image analysis failed:", error);
-      throw error;
-    }
-  }
-  async mockAnalyze(tile) {
-    const isUpperRegion = tile.row < 2;
-    const isLeftRegion = tile.col < 2;
-    let caption = "Desktop screen region";
-    const objects = [];
-    const regions = [];
-    const tags = [];
-    if (isUpperRegion) {
-      caption = "Application window with menu bar";
-      objects.push({
-        label: "window",
-        bbox: { x: 0, y: 0, width: tile.width, height: 50 },
-        confidence: 0.9
-      });
-      objects.push({
-        label: "menu_bar",
-        bbox: { x: 0, y: 0, width: tile.width, height: 30 },
-        confidence: 0.85
-      });
-      tags.push("ui", "application", "desktop");
-    }
-    if (isLeftRegion) {
-      caption = "Sidebar or navigation area";
-      objects.push({
-        label: "sidebar",
-        bbox: { x: 0, y: 0, width: 100, height: tile.height },
-        confidence: 0.8
-      });
-      tags.push("navigation", "sidebar");
-    }
-    const buttonCount = Math.floor(Math.random() * 3) + 1;
-    for (let i = 0;i < buttonCount; i++) {
-      objects.push({
-        label: "button",
-        bbox: {
-          x: Math.random() * (tile.width - 100),
-          y: Math.random() * (tile.height - 40),
-          width: 100,
-          height: 40
-        },
-        confidence: 0.7 + Math.random() * 0.2
-      });
-    }
-    const textRegions = Math.floor(Math.random() * 2) + 1;
-    for (let i = 0;i < textRegions; i++) {
-      regions.push({
-        description: "Text content area",
-        bbox: {
-          x: Math.random() * (tile.width - 200),
-          y: Math.random() * (tile.height - 100),
-          width: 200,
-          height: 100
-        }
-      });
-    }
-    tags.push("screen", "interface", "computer");
-    return {
-      caption,
-      objects,
-      regions,
-      tags
-    };
-  }
-  async detectUIElements(imageBuffer) {
-    if (!this.initialized) {
-      await this.initialize();
-    }
-    try {
-      let result;
-      try {
-        result = await this.localModel.analyzeImage(imageBuffer);
-      } catch (_modelError) {
-        import_core2.logger.warn("[Florence2] Local model failed for UI detection, using fallback");
-        result = await this.mockAnalyzeBuffer(imageBuffer);
-      }
-      return (result.objects || []).map((obj) => ({
-        type: this.mapToUIElementType(obj.label),
-        bbox: obj.bbox,
-        confidence: obj.confidence
-      }));
-    } catch (error) {
-      import_core2.logger.error("[Florence2] UI element detection failed:", error);
-      return [];
-    }
-  }
-  async mockAnalyzeBuffer(_imageBuffer) {
-    const scenarios = [
-      {
-        caption: "Indoor scene with a person in front of a computer",
-        objects: [
-          {
-            label: "person",
-            bbox: { x: 300, y: 200, width: 200, height: 300 },
-            confidence: 0.9
-          },
-          {
-            label: "computer",
-            bbox: { x: 400, y: 350, width: 150, height: 100 },
-            confidence: 0.85
-          },
-          {
-            label: "desk",
-            bbox: { x: 350, y: 400, width: 250, height: 100 },
-            confidence: 0.8
-          }
-        ],
-        tags: ["indoor", "office", "workspace", "person", "computer"]
-      },
-      {
-        caption: "Room interior with furniture and lighting",
-        objects: [
-          {
-            label: "chair",
-            bbox: { x: 200, y: 300, width: 100, height: 150 },
-            confidence: 0.85
-          },
-          {
-            label: "table",
-            bbox: { x: 350, y: 350, width: 150, height: 100 },
-            confidence: 0.8
-          },
-          {
-            label: "lamp",
-            bbox: { x: 500, y: 200, width: 50, height: 100 },
-            confidence: 0.75
-          }
-        ],
-        tags: ["indoor", "room", "furniture", "interior"]
-      },
-      {
-        caption: "Person working at a desk with computer monitor",
-        objects: [
-          {
-            label: "person",
-            bbox: { x: 250, y: 150, width: 250, height: 350 },
-            confidence: 0.92
-          },
-          {
-            label: "monitor",
-            bbox: { x: 450, y: 300, width: 120, height: 80 },
-            confidence: 0.88
-          },
-          {
-            label: "keyboard",
-            bbox: { x: 430, y: 380, width: 100, height: 30 },
-            confidence: 0.82
-          }
-        ],
-        tags: ["person", "working", "computer", "desk", "office"]
-      }
-    ];
-    const scenario = scenarios[Math.floor(Math.random() * scenarios.length)];
-    return {
-      caption: scenario.caption,
-      objects: scenario.objects,
-      regions: [],
-      tags: scenario.tags
-    };
-  }
-  mapToUIElementType(label) {
-    const mapping = {
-      button: "button",
-      text_field: "input",
-      text_area: "textarea",
-      checkbox: "checkbox",
-      radio_button: "radio",
-      dropdown: "select",
-      menu: "menu",
-      menu_bar: "menubar",
-      toolbar: "toolbar",
-      window: "window",
-      dialog: "dialog",
-      icon: "icon",
-      image: "image",
-      video: "video",
-      link: "link",
-      heading: "heading",
-      paragraph: "text",
-      list: "list",
-      table: "table",
-      scrollbar: "scrollbar",
-      tab: "tab",
-      panel: "panel"
-    };
-    return mapping[label.toLowerCase()] || "unknown";
-  }
-  async generateSceneGraph(tiles) {
-    const nodes = [];
-    const edges = [];
-    for (const tile of tiles) {
-      if (!tile.data) {
-        continue;
-      }
-      const analysis = await this.analyzeTile(tile);
-      if (analysis.objects) {
-        for (const obj of analysis.objects) {
-          const nodeId = `${tile.id}-${obj.label}-${nodes.length}`;
-          nodes.push({
-            id: nodeId,
-            type: obj.label,
-            label: obj.label,
-            position: {
-              x: tile.x + obj.bbox.x,
-              y: tile.y + obj.bbox.y,
-              width: obj.bbox.width,
-              height: obj.bbox.height
-            }
-          });
-        }
-      }
-    }
-    for (let i = 0;i < nodes.length; i++) {
-      for (let j = i + 1;j < nodes.length; j++) {
-        const relation = this.inferSpatialRelation(nodes[i].position, nodes[j].position);
-        if (relation) {
-          edges.push({
-            source: nodes[i].id,
-            target: nodes[j].id,
-            relation
-          });
-        }
-      }
-    }
-    return { nodes, edges };
-  }
-  inferSpatialRelation(box1, box2) {
-    const center1 = {
-      x: box1.x + box1.width / 2,
-      y: box1.y + box1.height / 2
-    };
-    const center2 = {
-      x: box2.x + box2.width / 2,
-      y: box2.y + box2.height / 2
-    };
-    if (this.contains(box1, box2)) {
-      return "contains";
-    }
-    if (this.contains(box2, box1)) {
-      return "contained_by";
-    }
-    if (this.overlaps(box1, box2)) {
-      return "overlaps";
-    }
-    const dx = center2.x - center1.x;
-    const dy = center2.y - center1.y;
-    const distance = Math.sqrt(dx * dx + dy * dy);
-    if (distance < 100) {
-      if (Math.abs(dx) > Math.abs(dy)) {
-        return dx > 0 ? "right_of" : "left_of";
-      } else {
-        return dy > 0 ? "below" : "above";
-      }
-    }
-    return null;
-  }
-  contains(box1, box2) {
-    return box1.x <= box2.x && box1.y <= box2.y && box1.x + box1.width >= box2.x + box2.width && box1.y + box1.height >= box2.y + box2.height;
-  }
-  overlaps(box1, box2) {
-    return !(box1.x + box1.width < box2.x || box2.x + box2.width < box1.x || box1.y + box1.height < box2.y || box2.y + box2.height < box1.y);
-  }
-  isInitialized() {
-    return this.initialized;
-  }
-  async dispose() {
-    this.initialized = false;
-    import_core2.logger.info("[Florence2] Model disposed");
-  }
-}
-
-// src/workers/worker-logger.ts
-var import_node_worker_threads = require("node:worker_threads");
-var logger3 = {
-  info: (message, ...args) => {
-    const logMessage = {
-      type: "log",
-      level: "info",
-      message,
-      args,
-      timestamp: new Date().toISOString()
-    };
-    if (import_node_worker_threads.parentPort) {
-      import_node_worker_threads.parentPort.postMessage(logMessage);
-    } else {
-      console.log(`[INFO] ${message}`, ...args);
-    }
-  },
-  warn: (message, ...args) => {
-    const logMessage = {
-      type: "log",
-      level: "warn",
-      message,
-      args,
-      timestamp: new Date().toISOString()
-    };
-    if (import_node_worker_threads.parentPort) {
-      import_node_worker_threads.parentPort.postMessage(logMessage);
-    } else {
-      console.warn(`[WARN] ${message}`, ...args);
-    }
-  },
-  error: (message, ...args) => {
-    const logMessage = {
-      type: "log",
-      level: "error",
-      message,
-      args,
-      timestamp: new Date().toISOString()
-    };
-    if (import_node_worker_threads.parentPort) {
-      import_node_worker_threads.parentPort.postMessage(logMessage);
-    } else {
-      console.error(`[ERROR] ${message}`, ...args);
-    }
-  },
-  debug: (message, ...args) => {
-    const logMessage = {
-      type: "log",
-      level: "debug",
-      message,
-      args,
-      timestamp: new Date().toISOString()
-    };
-    if (import_node_worker_threads.parentPort) {
-      import_node_worker_threads.parentPort.postMessage(logMessage);
-    } else {
-      console.debug(`[DEBUG] ${message}`, ...args);
-    }
-  }
-};
-
-// src/workers/florence2-worker.ts
-class Florence2Worker {
-  config;
-  dataView;
-  atomicState;
-  resultsView;
-  florence2;
-  isRunning = true;
-  frameCount = 0;
-  lastFPSReport = Date.now();
-  lastFrameId = -1;
-  FRAME_ID_INDEX = 0;
-  WIDTH_INDEX = 2;
-  HEIGHT_INDEX = 3;
-  DISPLAY_INDEX = 4;
-  TIMESTAMP_INDEX = 5;
-  DATA_OFFSET = 24;
-  RESULTS_HEADER_SIZE = 16;
-  MAX_RESULT_SIZE = 4096;
-  constructor(config, sharedBuffer, resultsBuffer) {
-    this.config = config;
-    this.dataView = new DataView(sharedBuffer);
-    this.atomicState = new Int32Array(sharedBuffer, 0, 6);
-    this.resultsView = new DataView(resultsBuffer);
-    this.florence2 = new Florence2Model;
-  }
-  async initialize() {
-    await this.florence2.initialize();
-    logger3.info("[Florence2Worker] Initialized and ready");
-  }
-  async run() {
-    await this.initialize();
-    logger3.info("[Florence2Worker] Starting analysis loop...");
-    while (this.isRunning) {
-      try {
-        const currentFrameId = Atomics.load(this.atomicState, this.FRAME_ID_INDEX);
-        if (currentFrameId > this.lastFrameId) {
-          await this.processFrame();
-          this.lastFrameId = currentFrameId;
-          this.frameCount++;
-          const now = Date.now();
-          if (now - this.lastFPSReport >= 1000) {
-            const fps = this.frameCount / ((now - this.lastFPSReport) / 1000);
-            logger3.info(`[Florence2Worker] Analysis FPS: ${fps.toFixed(2)}`);
-            import_node_worker_threads2.parentPort?.postMessage({
-              type: "fps",
-              fps,
-              frameCount: this.frameCount
-            });
-            this.frameCount = 0;
-            this.lastFPSReport = now;
-          }
-        } else {
-          await new Promise((resolve) => setImmediate(resolve));
-        }
-      } catch (error) {
-        logger3.error("[Florence2Worker] Processing error:", error);
-        await new Promise((resolve) => setTimeout(resolve, 100));
-      }
-    }
-  }
-  async processFrame() {
-    const metadata = {
-      frameId: Atomics.load(this.atomicState, this.FRAME_ID_INDEX),
-      width: Atomics.load(this.atomicState, this.WIDTH_INDEX),
-      height: Atomics.load(this.atomicState, this.HEIGHT_INDEX),
-      displayIndex: Atomics.load(this.atomicState, this.DISPLAY_INDEX),
-      timestamp: Atomics.load(this.atomicState, this.TIMESTAMP_INDEX)
-    };
-    const tiles = this.calculateTiles(metadata.width, metadata.height);
-    const tilesToProcess = this.config.priorityTiles ? this.config.priorityTiles.map((i) => tiles[i]).filter(Boolean) : tiles;
-    for (let i = 0;i < tilesToProcess.length; i++) {
-      const tile = tilesToProcess[i];
-      if (!tile) {
-        continue;
-      }
-      try {
-        const tileBuffer = await this.extractTileFromSharedBuffer(tile, metadata);
-        const result = await this.florence2.analyzeTile({
-          ...tile,
-          data: tileBuffer
-        });
-        await this.writeResultToBuffer(tile.id, result, metadata.frameId);
-        import_node_worker_threads2.parentPort?.postMessage({
-          type: "tile_analyzed",
-          tileId: tile.id,
-          frameId: metadata.frameId,
-          displayIndex: metadata.displayIndex,
-          hasObjects: (result.objects?.length || 0) > 0,
-          caption: result.caption
-        });
-      } catch (error) {
-        logger3.error(`[Florence2Worker] Failed to analyze tile ${tile.id}:`, error);
-      }
-    }
-  }
-  calculateTiles(width, height) {
-    const tileSize = this.config.tileSize;
-    const tiles = [];
-    for (let row = 0;row < Math.ceil(height / tileSize); row++) {
-      for (let col = 0;col < Math.ceil(width / tileSize); col++) {
-        const x = col * tileSize;
-        const y = row * tileSize;
-        const tileWidth = Math.min(tileSize, width - x);
-        const tileHeight = Math.min(tileSize, height - y);
-        tiles.push({
-          id: `tile-${row}-${col}`,
-          row,
-          col,
-          x,
-          y,
-          width: tileWidth,
-          height: tileHeight
-        });
-      }
-    }
-    return tiles;
-  }
-  async extractTileFromSharedBuffer(tile, metadata) {
-    const bytesPerPixel = 4;
-    const rowStride = metadata.width * bytesPerPixel;
-    const tileData = Buffer.allocUnsafe(tile.width * tile.height * bytesPerPixel);
-    for (let row = 0;row < tile.height; row++) {
-      const sourceY = tile.y + row;
-      const sourceOffset = this.DATA_OFFSET + sourceY * rowStride + tile.x * bytesPerPixel;
-      const destOffset = row * tile.width * bytesPerPixel;
-      for (let i = 0;i < tile.width * bytesPerPixel; i++) {
-        tileData[destOffset + i] = this.dataView.getUint8(sourceOffset + i);
-      }
-    }
-    const pngBuffer = await import_sharp2.default(tileData, {
-      raw: {
-        width: tile.width,
-        height: tile.height,
-        channels: 4
-      }
-    }).png().toBuffer();
-    return pngBuffer;
-  }
-  async writeResultToBuffer(tileId, result, frameId) {
-    const resultJson = JSON.stringify({
-      tileId,
-      frameId,
-      timestamp: Date.now(),
-      ...result
-    });
-    const resultBytes = Buffer.from(resultJson, "utf-8");
-    const match = tileId.match(/tile-(\d+)-(\d+)/);
-    if (!match) {
-      return;
-    }
-    const row = parseInt(match[1], 10);
-    const col = parseInt(match[2], 10);
-    const tileIndex = row * 10 + col;
-    const offset = this.RESULTS_HEADER_SIZE + tileIndex * this.MAX_RESULT_SIZE;
-    this.resultsView.setUint32(offset, resultBytes.length, true);
-    for (let i = 0;i < Math.min(resultBytes.length, this.MAX_RESULT_SIZE - 4); i++) {
-      this.resultsView.setUint8(offset + 4 + i, resultBytes[i]);
-    }
-  }
-  stop() {
-    this.isRunning = false;
-  }
-  async dispose() {
-    await this.florence2.dispose();
-  }
-}
-if (import_node_worker_threads2.parentPort) {
-  const { config, sharedBuffer, resultsBuffer } = import_node_worker_threads2.workerData;
-  const worker = new Florence2Worker(config, sharedBuffer, resultsBuffer);
-  import_node_worker_threads2.parentPort.on("message", (msg) => {
-    if (msg.type === "stop") {
-      worker.stop();
-      worker.dispose().then(() => {
-        import_node_worker_threads2.parentPort?.postMessage({ type: "stopped" });
-      });
-    }
-  });
-  worker.run().catch((error) => {
-    logger3.error("[Florence2Worker] Fatal error:", error);
-    import_node_worker_threads2.parentPort?.postMessage({ type: "error", error: error.message });
-    process.exit(1);
-  });
-}
-
-//# debugId=759CBCF921774D7464756E2164756E21
-//# sourceMappingURL=florence2-worker.js.map