@srsergio/taptapp-ar 1.0.9 → 1.0.10

package/dist/compiler/input-loader.js

@@ -1,88 +1,70 @@
-import * as tf from "@tensorflow/tfjs";
-// More efficient implementation for tf.browser.fromPixels
-//   original implementation: /node_modules/@tensorflow/tfjs-backend-webgl/src/kernels/FromPixels.ts
-//
-// This implementation return grey scale instead of RGBA in the orignal implementation
+/**
+ * InputLoader - Maneja la carga de imágenes y video sin TensorFlow
+ */
 class InputLoader {
     constructor(width, height) {
         this.width = width;
         this.height = height;
-        this.texShape = [height, width];
-        const context = document.createElement("canvas").getContext("2d");
-        context.canvas.width = width;
-        context.canvas.height = height;
-        this.context = context;
-        this.program = this.buildProgram(width, height);
-        const backend = tf.backend();
-        //this.tempPixelHandle = backend.makeTensorInfo(this.texShape, 'int32');
-        this.tempPixelHandle = backend.makeTensorInfo(this.texShape, "float32");
-        // warning!!!
-        // usage type should be TextureUsage.PIXELS, but tfjs didn't export this enum type, so we hard-coded 2 here
-        //   i.e. backend.texData.get(tempPixelHandle.dataId).usage = TextureUsage.PIXELS;
-        backend.texData.get(this.tempPixelHandle.dataId).usage = 2;
-    }
-    // old method
-    _loadInput(input) {
-        return tf.tidy(() => {
-            let inputImage = tf.browser.fromPixels(input);
-            inputImage = inputImage.mean(2);
-            return inputImage;
-        });
+        this.grayscaleBuffer = new Uint8Array(width * height);
+        if (typeof document !== "undefined") {
+            const canvas = document.createElement("canvas");
+            canvas.width = width;
+            canvas.height = height;
+            this.context = canvas.getContext("2d", { willReadFrequently: true, alpha: false });
+        }
     }
-    // input is instance of HTMLVideoElement or HTMLImageElement
+    /**
+     * Carga una imagen o video y devuelve los datos en escala de grises
+     * @param {HTMLVideoElement|HTMLImageElement|ImageData|Uint8Array} input - La fuente de entrada
+     * @returns {Uint8Array} Datos de imagen en escala de grises (width * height)
+     */
     loadInput(input) {
-        const context = this.context;
-        context.clearRect(0, 0, this.context.canvas.width, this.context.canvas.height);
-        const isInputRotated = input.width === this.height && input.height === this.width;
-        if (isInputRotated) {
-            // rotate 90 degree and draw
-            let x = this.context.canvas.width / 2;
-            let y = this.context.canvas.height / 2;
-            let angleInDegrees = 90;
-            context.save(); // save the current context state
-            context.translate(x, y); // move the context origin to the center of the image
-            context.rotate((angleInDegrees * Math.PI) / 180); // rotate the context
-            // draw the image with its center at the origin
-            context.drawImage(input, -input.width / 2, -input.height / 2);
-            context.restore(); // restore the context to its original state
+        // Si ya es un Uint8Array de escala de grises, lo devolvemos
+        if (input instanceof Uint8Array && input.length === this.width * this.height) {
+            return input;
         }
-        else {
-            this.context.drawImage(input, 0, 0, input.width, input.height);
+        // Si es ImageData, convertimos a escala de grises directamente
+        if (typeof ImageData !== "undefined" && input instanceof ImageData) {
+            this._convertToGrayscale(input.data, input.width, input.height);
+            return this.grayscaleBuffer;
         }
-        const backend = tf.backend();
-        backend.gpgpu.uploadPixelDataToTexture(backend.getTexture(this.tempPixelHandle.dataId), this.context.canvas);
-        //const res = backend.compileAndRun(this.program, [this.tempPixelHandle]);
-        const res = this._compileAndRun(this.program, [this.tempPixelHandle]);
-        //const res = this._runWebGLProgram(this.program, [this.tempPixelHandle], 'float32');
-        //backend.disposeData(tempPixelHandle.dataId);
-        return res;
-    }
-    buildProgram(width, height) {
-        const textureMethod = tf.env().getNumber("WEBGL_VERSION") === 2 ? "texture" : "texture2D";
-        const program = {
-            variableNames: ["A"],
-            outputShape: this.texShape,
-            userCode: `
-	void main() {
-	  ivec2 coords = getOutputCoords();
-	  int texR = coords[0];
-	  int texC = coords[1];
-	  vec2 uv = (vec2(texC, texR) + halfCR) / vec2(${width}.0, ${height}.0);
-
-	  vec4 values = ${textureMethod}(A, uv);
-	  setOutput((0.299 * values.r + 0.587 * values.g + 0.114 * values.b) * 255.0);
-	}
-      `,
-        };
-        return program;
-    }
-    _compileAndRun(program, inputs) {
-        const outInfo = tf.backend().compileAndRun(program, inputs);
-        return tf.engine().makeTensor(outInfo.dataId, outInfo.shape, outInfo.dtype);
+        // En el navegador, usamos canvas para procesar video/imágenes
+        if (this.context) {
+            this.context.clearRect(0, 0, this.width, this.height);
+            const isInputRotated = input.width === this.height && input.height === this.width;
+            if (isInputRotated) {
+                this.context.save();
+                this.context.translate(this.width / 2, this.height / 2);
+                this.context.rotate(Math.PI / 2);
+                this.context.drawImage(input, -input.width / 2, -input.height / 2);
+                this.context.restore();
+            }
+            else {
+                this.context.drawImage(input, 0, 0, this.width, this.height);
+            }
+            const imageData = this.context.getImageData(0, 0, this.width, this.height);
+            this._convertToGrayscale(imageData.data, this.width, this.height);
+            return this.grayscaleBuffer;
+        }
+        // Fallback para Node.js o entornos sin DOM
+        if (input.data && input.data instanceof Uint8Array) {
+            this._convertToGrayscale(input.data, input.width || this.width, input.height || this.height);
+            return this.grayscaleBuffer;
+        }
+        throw new Error("Input no soportado o entorno sin Canvas");
     }
-    _runWebGLProgram(program, inputs, outputType) {
-        const outInfo = tf.backend().runWebGLProgram(program, inputs, outputType);
-        return tf.engine().makeTensor(outInfo.dataId, outInfo.shape, outInfo.dtype);
+    /**
+     * Convierte datos RGBA a escala de grises optimizada (reutilizando buffer)
+     */
+    _convertToGrayscale(rgbaData, width, height) {
+        const grayscale = this.grayscaleBuffer;
+        const len = (width * height);
+        // Optimized loop with bitwise ops
+        for (let i = 0; i < len; i++) {
+            const offset = i << 2;
+            // Formula de luminosidad estándar: 0.299R + 0.587G + 0.114B (scaled by 256)
+            grayscale[i] = (rgbaData[offset] * 77 + rgbaData[offset + 1] * 150 + rgbaData[offset + 2] * 29) >> 8;
+        }
     }
 }
 export { InputLoader };

package/dist/compiler/matching/hamming-distance.js

@@ -9,11 +9,11 @@ for (let i = 0; i < 256; i++) {
     BIT_COUNT_8[i] = c;
 }
 const compute = (options) => {
-    const { v1, v2 } = options;
+    const { v1, v2, v1Offset = 0, v2Offset = 0 } = options;
     let d = 0;
-    const len = v1.length;
-    for (let i = 0; i < len; i++) {
-        d += BIT_COUNT_8[v1[i] ^ v2[i]];
+    // FREAK descriptors are 84 bytes
+    for (let i = 0; i < 84; i++) {
+        d += BIT_COUNT_8[v1[v1Offset + i] ^ v2[v2Offset + i]];
     }
     return d;
 };

package/dist/compiler/matching/matcher.js

@@ -37,8 +37,8 @@ class Matcher {
                 y: querypoint.y,
             });
             worldCoords.push({
-                x: (keypoint.x + 0.5) / keyframe.scale,
-                y: (keypoint.y + 0.5) / keyframe.scale,
+                x: (keypoint.x + 0.5) / (keyframe.s || keyframe.scale || 1.0),
+                y: (keypoint.y + 0.5) / (keyframe.s || keyframe.scale || 1.0),
                 z: 0,
             });
         }

package/dist/compiler/matching/matching.d.ts

@@ -6,14 +6,6 @@ export function match({ keyframe, querypoints, querywidth, queryheight, debugMod
     debugMode: any;
 }): {
     debugExtra: {
-        matches: {
-            querypoint: any;
-            keypoint: {
-                x: any;
-                y: any;
-                angle: any;
-            };
-        }[];
         houghMatches: any[];
         inlierMatches: any[];
         matches2: {
@@ -22,6 +14,7 @@ export function match({ keyframe, querypoints, querywidth, queryheight, debugMod
                 x: any;
                 y: any;
                 angle: any;
+                scale: any;
             };
         }[];
         houghMatches2: any[];
@@ -33,14 +26,6 @@ export function match({ keyframe, querypoints, querywidth, queryheight, debugMod
     H: number[];
     matches: any[];
     debugExtra: {
-        matches: {
-            querypoint: any;
-            keypoint: {
-                x: any;
-                y: any;
-                angle: any;
-            };
-        }[];
         houghMatches: any[];
         inlierMatches: any[];
         matches2: {
@@ -49,6 +34,7 @@ export function match({ keyframe, querypoints, querywidth, queryheight, debugMod
                 x: any;
                 y: any;
                 angle: any;
+                scale: any;
             };
         }[];
         houghMatches2: any[];

package/dist/compiler/matching/matching.js

@@ -12,16 +12,17 @@ const HAMMING_THRESHOLD = 0.7;
 const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) => {
     let debugExtra = {};
     const matches = [];
-    for (let j = 0; j < querypoints.length; j++) {
+    const qlen = querypoints.length;
+    const kmax = keyframe.max;
+    const kmin = keyframe.min;
+    for (let j = 0; j < qlen; j++) {
         const querypoint = querypoints[j];
-        const col = querypoint.maxima ? keyframe.max : keyframe.min;
+        const col = querypoint.maxima ? kmax : kmin;
         if (!col || col.x.length === 0)
             continue;
         const rootNode = col.t;
         const keypointIndexes = [];
-        const queue = new TinyQueue([], (a1, a2) => {
-            return a1.d - a2.d;
-        });
+        const queue = new TinyQueue([], (a1, a2) => a1.d - a2.d);
         // query potential candidates from the columnar tree
         _query({
             node: rootNode,
@@ -34,11 +35,12 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
         let bestIndex = -1;
         let bestD1 = Number.MAX_SAFE_INTEGER;
         let bestD2 = Number.MAX_SAFE_INTEGER;
+        const qDesc = querypoint.descriptors;
+        const cDesc = col.d;
         for (let k = 0; k < keypointIndexes.length; k++) {
             const idx = keypointIndexes[k];
-            // Access descriptor directly from binary buffer (Zero-copy)
-            const keypointDescriptor = col.d.subarray(idx * 84, (idx + 1) * 84);
-            const d = hammingCompute({ v1: keypointDescriptor, v2: querypoint.descriptors });
+            // Use offsets to avoid subarray allocation
+            const d = hammingCompute({ v1: cDesc, v1Offset: idx * 84, v2: qDesc });
             if (d < bestD1) {
                 bestD2 = bestD1;
                 bestD1 = d;
@@ -49,32 +51,29 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
             }
         }
         if (bestIndex !== -1 &&
-            (bestD2 === Number.MAX_SAFE_INTEGER || (1.0 * bestD1) / bestD2 < HAMMING_THRESHOLD)) {
+            (bestD2 === Number.MAX_SAFE_INTEGER || (bestD1 / bestD2) < HAMMING_THRESHOLD)) {
             matches.push({
                 querypoint,
                 keypoint: {
                     x: col.x[bestIndex],
                     y: col.y[bestIndex],
-                    angle: col.a[bestIndex]
+                    angle: col.a[bestIndex],
+                    scale: col.s ? col.s[bestIndex] : keyframe.s
                 }
             });
         }
     }
-    if (debugMode) {
-        debugExtra.matches = matches;
-    }
     if (matches.length < MIN_NUM_INLIERS)
         return { debugExtra };
     const houghMatches = computeHoughMatches({
-        keywidth: keyframe.w, // Protocol V3 uses .w, .h
+        keywidth: keyframe.w,
         keyheight: keyframe.h,
         querywidth,
         queryheight,
         matches,
     });
-    if (debugMode) {
+    if (debugMode)
         debugExtra.houghMatches = houghMatches;
-    }
     const H = computeHomography({
         srcPoints: houghMatches.map((m) => [m.keypoint.x, m.keypoint.y]),
         dstPoints: houghMatches.map((m) => [m.querypoint.x, m.querypoint.y]),
@@ -87,32 +86,40 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
         matches: houghMatches,
         threshold: INLIER_THRESHOLD,
     });
-    if (debugMode) {
+    if (debugMode)
         debugExtra.inlierMatches = inlierMatches;
-    }
     if (inlierMatches.length < MIN_NUM_INLIERS)
         return { debugExtra };
     // Second pass with homography guided matching
     const HInv = matrixInverse33(H, 0.00001);
-    const dThreshold2 = 10 * 10;
+    const dThreshold2 = 100; // 10 * 10
     const matches2 = [];
-    for (let j = 0; j < querypoints.length; j++) {
+    const hi00 = HInv[0], hi01 = HInv[1], hi02 = HInv[2];
+    const hi10 = HInv[3], hi11 = HInv[4], hi12 = HInv[5];
+    const hi20 = HInv[6], hi21 = HInv[7], hi22 = HInv[8];
+    for (let j = 0; j < qlen; j++) {
         const querypoint = querypoints[j];
-        const mapquerypoint = multiplyPointHomographyInhomogenous([querypoint.x, querypoint.y], HInv);
+        const qx = querypoint.x, qy = querypoint.y;
+        // Inline multiplyPointHomographyInhomogenous
+        const uz = (qx * hi20) + (qy * hi21) + hi22;
+        const invZ = 1.0 / uz;
+        const mapX = ((qx * hi00) + (qy * hi01) + hi02) * invZ;
+        const mapY = ((qx * hi10) + (qy * hi11) + hi12) * invZ;
         let bestIndex = -1;
         let bestD1 = Number.MAX_SAFE_INTEGER;
         let bestD2 = Number.MAX_SAFE_INTEGER;
-        const col = querypoint.maxima ? keyframe.max : keyframe.min;
+        const col = querypoint.maxima ? kmax : kmin;
         if (!col)
             continue;
-        for (let k = 0; k < col.x.length; k++) {
-            const dx = col.x[k] - mapquerypoint[0];
-            const dy = col.y[k] - mapquerypoint[1];
+        const cx = col.x, cy = col.y, cd = col.d;
+        const qDesc = querypoint.descriptors;
+        for (let k = 0, clen = cx.length; k < clen; k++) {
+            const dx = cx[k] - mapX;
+            const dy = cy[k] - mapY;
             const d2 = dx * dx + dy * dy;
             if (d2 > dThreshold2)
                 continue;
-            const keypointDescriptor = col.d.subarray(k * 84, (k + 1) * 84);
-            const d = hammingCompute({ v1: keypointDescriptor, v2: querypoint.descriptors });
+            const d = hammingCompute({ v1: cd, v1Offset: k * 84, v2: qDesc });
             if (d < bestD1) {
                 bestD2 = bestD1;
                 bestD1 = d;
@@ -123,20 +130,20 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
             }
         }
         if (bestIndex !== -1 &&
-            (bestD2 === Number.MAX_SAFE_INTEGER || (1.0 * bestD1) / bestD2 < HAMMING_THRESHOLD)) {
+            (bestD2 === Number.MAX_SAFE_INTEGER || (bestD1 / bestD2) < HAMMING_THRESHOLD)) {
             matches2.push({
                 querypoint,
                 keypoint: {
                     x: col.x[bestIndex],
                     y: col.y[bestIndex],
-                    angle: col.a[bestIndex]
+                    angle: col.a[bestIndex],
+                    scale: col.s ? col.s[bestIndex] : keyframe.s
                 }
             });
         }
     }
-    if (debugMode) {
+    if (debugMode)
         debugExtra.matches2 = matches2;
-    }
     const houghMatches2 = computeHoughMatches({
         keywidth: keyframe.w,
         keyheight: keyframe.h,
@@ -144,9 +151,8 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
         queryheight,
         matches: matches2,
     });
-    if (debugMode) {
+    if (debugMode)
         debugExtra.houghMatches2 = houghMatches2;
-    }
     const H2 = computeHomography({
         srcPoints: houghMatches2.map((m) => [m.keypoint.x, m.keypoint.y]),
         dstPoints: houghMatches2.map((m) => [m.querypoint.x, m.querypoint.y]),
@@ -159,14 +165,12 @@ const match = ({ keyframe, querypoints, querywidth, queryheight, debugMode }) =>
         matches: houghMatches2,
         threshold: INLIER_THRESHOLD,
     });
-    if (debugMode) {
+    if (debugMode)
         debugExtra.inlierMatches2 = inlierMatches2;
-    }
     return { H: H2, matches: inlierMatches2, debugExtra };
 };
 const _query = ({ node, descriptors, querypoint, queue, keypointIndexes, numPop }) => {
     const isLeaf = node[0] === 1;
-    const centerIdx = node[1];
     const childrenOrIndices = node[2];
     if (isLeaf) {
         for (let i = 0; i < childrenOrIndices.length; i++) {
@@ -174,48 +178,56 @@ const _query = ({ node, descriptors, querypoint, queue, keypointIndexes, numPop
         }
         return;
     }
-    const distances = [];
-    for (let i = 0; i < childrenOrIndices.length; i++) {
+    const qDesc = querypoint.descriptors;
+    let minD = Number.MAX_SAFE_INTEGER;
+    const clen = childrenOrIndices.length;
+    const distances = new Int32Array(clen);
+    for (let i = 0; i < clen; i++) {
         const childNode = childrenOrIndices[i];
         const cIdx = childNode[1];
         const d = hammingCompute({
-            v1: descriptors.subarray(cIdx * 84, (cIdx + 1) * 84),
-            v2: querypoint.descriptors,
+            v1: descriptors,
+            v1Offset: cIdx * 84,
+            v2: qDesc,
         });
-        distances.push(d);
+        distances[i] = d;
+        if (d < minD)
+            minD = d;
     }
-    let minD = Number.MAX_SAFE_INTEGER;
-    for (let i = 0; i < childrenOrIndices.length; i++) {
-        minD = Math.min(minD, distances[i]);
-    }
-    for (let i = 0; i < childrenOrIndices.length; i++) {
-        if (distances[i] !== minD) {
-            queue.push({ node: childrenOrIndices[i], d: distances[i] });
+    for (let i = 0; i < clen; i++) {
+        const dist = distances[i];
+        if (dist !== minD) {
+            queue.push({ node: childrenOrIndices[i], d: dist });
         }
-    }
-    for (let i = 0; i < childrenOrIndices.length; i++) {
-        if (distances[i] === minD) {
+        else {
             _query({ node: childrenOrIndices[i], descriptors, querypoint, queue, keypointIndexes, numPop });
         }
     }
     if (numPop < CLUSTER_MAX_POP && queue.length > 0) {
         const { node } = queue.pop();
-        numPop += 1;
-        _query({ node, descriptors, querypoint, queue, keypointIndexes, numPop });
+        _query({ node, descriptors, querypoint, queue, keypointIndexes, numPop: numPop + 1 });
     }
 };
 const _findInlierMatches = (options) => {
     const { H, matches, threshold } = options;
     const threshold2 = threshold * threshold;
+    const h00 = H[0], h01 = H[1], h02 = H[2];
+    const h10 = H[3], h11 = H[4], h12 = H[5];
+    const h20 = H[6], h21 = H[7], h22 = H[8];
     const goodMatches = [];
     for (let i = 0; i < matches.length; i++) {
-        const querypoint = matches[i].querypoint;
-        const keypoint = matches[i].keypoint;
-        const mp = multiplyPointHomographyInhomogenous([keypoint.x, keypoint.y], H);
-        const d2 = (mp[0] - querypoint.x) * (mp[0] - querypoint.x) +
-            (mp[1] - querypoint.y) * (mp[1] - querypoint.y);
-        if (d2 <= threshold2) {
-            goodMatches.push(matches[i]);
+        const m = matches[i];
+        const qp = m.querypoint;
+        const kp = m.keypoint;
+        // Inline multiplyPointHomographyInhomogenous
+        const uz = (kp.x * h20) + (kp.y * h21) + h22;
+        const invZ = 1.0 / uz;
+        const mx = ((kp.x * h00) + (kp.y * h01) + h02) * invZ;
+        const my = ((kp.x * h10) + (kp.y * h11) + h12) * invZ;
+        const dx = mx - qp.x;
+        const dy = my - qp.y;
+        if (dx * dx + dy * dy <= threshold2) {
+            goodMatches.push(m);
         }
     }
     return goodMatches;

package/dist/compiler/offline-compiler.d.ts

@@ -12,38 +12,18 @@ export class OfflineCompiler {
      * @returns {Promise<Array>} Datos compilados
      */
     compileImageTargets(images: any[], progressCallback: Function): Promise<any[]>;
-    /**
-     * Compila datos de matching usando DetectorLite (JS puro)
-     */
     _compileMatch(targetImages: any, progressCallback: any): Promise<any[]>;
-    /**
-     * Compila datos de tracking usando extractTrackingFeatures (JS puro)
-     */
     _compileTrack(targetImages: any, progressCallback: any): Promise<any[]>;
-    /**
-     * Método público para compilar tracking (compatibilidad con API anterior)
-     * @param {Object} options - Opciones de compilación
-     * @param {Function} options.progressCallback - Callback de progreso
-     * @param {Array} options.targetImages - Lista de imágenes objetivo
-     * @param {number} options.basePercent - Porcentaje base
-     * @returns {Promise<Array>} Datos de tracking
-     */
     compileTrack({ progressCallback, targetImages, basePercent }: {
-        progressCallback: Function;
-        targetImages: any[];
-        basePercent: number;
+        progressCallback: any;
+        targetImages: any;
+        basePercent?: number | undefined;
     }): Promise<any[]>;
-    /**
-     * Método público para compilar matching (compatibilidad con API anterior)
-     */
     compileMatch({ progressCallback, targetImages, basePercent }: {
         progressCallback: any;
         targetImages: any;
         basePercent?: number | undefined;
     }): Promise<any[]>;
-    /**
-     * Exporta datos compilados en formato binario columnar optimizado
-     */
     exportData(): any;
     _packKeyframe(kf: any): {
         w: any;
@@ -53,6 +33,7 @@ export class OfflineCompiler {
             x: Float32Array<any>;
             y: Float32Array<any>;
             a: Float32Array<any>;
+            s: Float32Array<any>;
             d: Uint8Array<ArrayBuffer>;
             t: any[];
         };
@@ -60,6 +41,7 @@ export class OfflineCompiler {
             x: Float32Array<any>;
             y: Float32Array<any>;
             a: Float32Array<any>;
+            s: Float32Array<any>;
             d: Uint8Array<ArrayBuffer>;
             t: any[];
         };
@@ -68,13 +50,11 @@ export class OfflineCompiler {
         x: Float32Array<any>;
         y: Float32Array<any>;
         a: Float32Array<any>;
+        s: Float32Array<any>;
         d: Uint8Array<ArrayBuffer>;
         t: any[];
     };
     _compactTree(node: any): any[];
-    /**
-     * Importa datos - Mantiene el formato columnar para máximo rendimiento (Zero-copy)
-     */
     importData(buffer: any): any;
     _unpackKeyframe(kf: any): {
         width: any;
@@ -84,12 +64,14 @@ export class OfflineCompiler {
             x: any;
             y: any;
             angle: any;
+            scale: any;
             descriptors: any;
         }[];
         minimaPoints: {
             x: any;
             y: any;
             angle: any;
+            scale: any;
             descriptors: any;
         }[];
         maximaPointsCluster: {
@@ -123,6 +105,7 @@ export class OfflineCompiler {
         x: any;
         y: any;
         angle: any;
+        scale: any;
         descriptors: any;
     }[];
     _expandTree(node: any): {
@@ -136,9 +119,6 @@ export class OfflineCompiler {
         children: any;
         pointIndexes?: undefined;
     };
-    /**
-     * Destruye el pool de workers
-     */
     destroy(): Promise<void>;
 }
 import { WorkerPool } from "./utils/worker-pool.js";