grepmax 0.26.5 → 0.26.6

package/dist/lib/index/syncer.js

@@ -666,7 +666,7 @@ function initialSync(options) {
                     total,
                     filePath: "Creating FTS index...",
                 });
-                yield vectorDb.runMaintenance();
+                yield vectorDb.runMaintenance({ force: true });
                 throwIfSyncAborted();
                 ftsTimer();
             }

package/dist/lib/index/watcher.js

@@ -57,9 +57,14 @@ const batch_processor_1 = require("./batch-processor");
 const cache_coherence_1 = require("./cache-coherence");
 const file_policy_1 = require("./file-policy");
 const walker_1 = require("./walker");
-// Ignore patterns for @parcel/watcher (micromatch globs + directory names).
-// Directory names are matched at any depth automatically.
-exports.WATCHER_IGNORE_GLOBS = [
+// Directory names ignored at ANY depth. @parcel/watcher treats a non-glob
+// ignore entry as a literal path resolved against the watch root, so a bare
+// "dist" only covered <root>/dist — nested build dirs (packages/*/dist,
+// nested node_modules, .turbo) still flooded the daemon with events on every
+// build. Glob entries are matched against the path relative to the watch
+// root, and a leading "**/" matches zero or more segments, so the expansion
+// below covers both the top-level and nested cases.
+const IGNORED_DIR_NAMES = [
     "node_modules",
     ".git",
     ".gmax",
@@ -77,10 +82,16 @@ exports.WATCHER_IGNORE_GLOBS = [
     ".pytest_cache",
     ".next",
     ".nuxt",
+    ".turbo",
     ".gradle",
     ".m2",
     "vendor",
     "lancedb",
+];
+// Ignore patterns for @parcel/watcher (picomatch globs).
+exports.WATCHER_IGNORE_GLOBS = [
+    // "**/<name>" ignores the directory entry itself, "**/<name>/**" its contents.
+    ...IGNORED_DIR_NAMES.flatMap((name) => [`**/${name}`, `**/${name}/**`]),
     "**/*.tmp.*", // editor atomic save artifacts
     "**/*.sb-*", // Xcode swap files
 ];

package/dist/lib/search/searcher.js

@@ -13,6 +13,7 @@ exports.Searcher = void 0;
 exports.asSymbolQuery = asSymbolQuery;
 exports.buildWhereClause = buildWhereClause;
 const config_1 = require("../../config");
+const ann_config_1 = require("../store/ann-config");
 const filter_builder_1 = require("../utils/filter-builder");
 const pool_1 = require("../workers/pool");
 const intent_1 = require("./intent");
@@ -475,8 +476,7 @@ class Searcher {
             // in the respective query to suppress LanceDB deprecation warnings
             const VECTOR_COLUMNS = [...LIGHTWEIGHT_COLUMNS, "_distance"];
             const FTS_COLUMNS = [...LIGHTWEIGHT_COLUMNS, "_score"];
-            let vectorQuery = table
-                .vectorSearch(queryVector)
+            let vectorQuery = (0, ann_config_1.configureAnnVectorQuery)(table.vectorSearch(queryVector))
                 .select(VECTOR_COLUMNS)
                 .limit(PRE_RERANK_K);
             if (whereClause) {

package/dist/lib/skeleton/skeletonizer.js

@@ -164,10 +164,14 @@ class Skeletonizer {
             if (!language || !this.parser) {
                 return this.createFallbackResult(filePath, content, "Failed to load grammar");
             }
+            let tree = null;
             try {
                 // Parse the file
                 this.parser.setLanguage(language);
-                const tree = this.parser.parse(content);
+                tree = this.parser.parse(content);
+                if (!tree) {
+                    return this.createFallbackResult(filePath, content, "Parse returned no tree");
+                }
                 const root = tree.rootNode;
                 // Find all regions to elide (function/method bodies)
                 const elisions = [];
@@ -192,6 +196,10 @@ class Skeletonizer {
             catch (err) {
                 return this.createFallbackResult(filePath, content, `Parse error: ${err instanceof Error ? err.message : String(err)}`);
             }
+            finally {
+                // Nothing in the guarded block may retain a Node.
+                tree === null || tree === void 0 ? void 0 : tree.delete();
+            }
         });
     }
     /**

package/dist/lib/store/ann-config.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAnnEnabled = isAnnEnabled;
+exports.annMinRows = annMinRows;
+exports.configureAnnVectorQuery = configureAnnVectorQuery;
+function positiveInt(value, fallback) {
+    const parsed = Number.parseInt(value !== null && value !== void 0 ? value : "", 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function isAnnEnabled() {
+    return process.env.GMAX_ANN === "1";
+}
+function annMinRows() {
+    return positiveInt(process.env.GMAX_ANN_MIN_ROWS, 50000);
+}
+function configureAnnVectorQuery(query) {
+    let configured = query;
+    if (typeof configured.column === "function") {
+        configured = configured.column("vector");
+    }
+    if (!isAnnEnabled()) {
+        return typeof configured.bypassVectorIndex === "function"
+            ? configured.bypassVectorIndex()
+            : configured;
+    }
+    const minimum = positiveInt(process.env.GMAX_ANN_NPROBES, 20);
+    const maximum = Math.max(minimum, positiveInt(process.env.GMAX_ANN_MAX_NPROBES, 200));
+    if (typeof configured.minimumNprobes === "function") {
+        configured = configured.minimumNprobes(minimum);
+    }
+    return typeof configured.maximumNprobes === "function"
+        ? configured.maximumNprobes(maximum)
+        : configured;
+}

package/dist/lib/store/vector-db.js

@@ -53,6 +53,7 @@ const index_config_1 = require("../index/index-config");
 const cleanup_1 = require("../utils/cleanup");
 const filter_builder_1 = require("../utils/filter-builder");
 const logger_1 = require("../utils/logger");
+const ann_config_1 = require("./ann-config");
 const store_lease_1 = require("./store-lease");
 class DiskPressureError extends Error {
     constructor(message = "Disk critically low — writes suspended") {
@@ -86,6 +87,7 @@ function isMissingTableError(err) {
 }
 const TABLE_NAME = "chunks";
 const MAINTENANCE_INTERVAL_MS = 5 * 60 * 1000;
+const CLEAN_MAINTENANCE_INTERVAL_MS = 60 * 60 * 1000;
 class VectorDB {
     constructor(lancedbDir, vectorDim, suppliedLease) {
         this.lancedbDir = lancedbDir;
@@ -95,11 +97,18 @@ class VectorDB {
         this.maintenanceRunning = false;
         this.maintenancePromise = null;
         this.maintenanceTimer = null;
+        this.writeEpoch = 0;
+        this.maintainedEpoch = -1;
+        this.maintainedTableVersion = null;
+        this.lastMaintenanceMs = 0;
+        this.ftsIndexEnsured = false;
+        this.lastOptimizeDidWork = false;
         this.maintenanceRunner = (fn) => fn();
         /** Latched when a from-scratch FTS rebuild failed to stop an optimize
          *  panic. Stops the (expensive) rebuild from re-running every maintenance
          *  tick for a panic it cannot fix; cleared when an optimize succeeds. */
         this.ftsPanicRecoveryExhausted = false;
+        this.annPanicRecoveryExhausted = false;
         this.lastCorruptionLogMs = 0;
         this.diskPressure = "ok";
         this.lastDiskCheckMs = 0;
@@ -141,6 +150,8 @@ class VectorDB {
             // promise to await instead of a chain.
             if (this.maintenancePromise)
                 return;
+            if (!this.maintenanceDue())
+                return;
             const run = this.maintenanceRunner(() => __awaiter(this, void 0, void 0, function* () {
                 try {
                     yield this.runMaintenance();
@@ -179,6 +190,14 @@ class VectorDB {
     isMaintenanceActive() {
         return this.maintenancePromise !== null;
     }
+    maintenanceDue() {
+        return (this.writeEpoch !== this.maintainedEpoch ||
+            !this.ftsIndexEnsured ||
+            Date.now() - this.lastMaintenanceMs >= CLEAN_MAINTENANCE_INTERVAL_MS);
+    }
+    markWriteCommitted() {
+        this.writeEpoch++;
+    }
     /** Pause the maintenance timer (e.g. during a full index that calls runMaintenance itself). */
     pauseMaintenanceLoop() {
         if (this.maintenanceTimer) {
@@ -402,7 +421,9 @@ class VectorDB {
                         }
                         yield Promise.all([this.drainWrites(), this.drainCompactions()]);
                         const db = yield this.getDb();
-                        return yield mutation(db);
+                        const result = yield mutation(db);
+                        this.markWriteCommitted();
+                        return result;
                     }
                     finally {
                         yield (temporaryExclusiveLease === null || temporaryExclusiveLease === void 0 ? void 0 : temporaryExclusiveLease.release());
@@ -555,6 +576,7 @@ class VectorDB {
                     continue;
                 try {
                     yield table.addColumns(new apache_arrow_1.Field(col, new apache_arrow_1.List(new apache_arrow_1.Field("item", new apache_arrow_1.Utf8(), true)), true));
+                    this.markWriteCommitted();
                     (0, logger_1.log)("db", `Added ${col} column to existing table`);
                 }
                 catch (err) {
@@ -586,6 +608,7 @@ class VectorDB {
                     schema,
                 });
                 yield table.delete('id = "seed"');
+                this.markWriteCommitted();
                 return table;
             }
             yield this.validateSchema(table);
@@ -606,6 +629,18 @@ class VectorDB {
             }
         });
     }
+    readTableVersion(table) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!table || typeof table.version !== "function")
+                return null;
+            try {
+                return yield table.version();
+            }
+            catch (_a) {
+                return null;
+            }
+        });
+    }
     insertBatch(records) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
@@ -620,13 +655,6 @@ class VectorDB {
                     const view = val;
                     return Buffer.from(view.buffer, (_a = view.byteOffset) !== null && _a !== void 0 ? _a : 0, (_b = view.byteLength) !== null && _b !== void 0 ? _b : undefined);
                 }
-                if (val &&
-                    typeof val === "object" &&
-                    "type" in val &&
-                    val.type === "Buffer" &&
-                    Array.isArray(val.data)) {
-                    return Buffer.from(val.data);
-                }
                 if (Array.isArray(val))
                     return Buffer.from(val);
                 return Buffer.alloc(0);
@@ -637,16 +665,6 @@ class VectorDB {
                 if (ArrayBuffer.isView(val) && val.buffer) {
                     return Array.from(val);
                 }
-                if (val &&
-                    typeof val === "object" &&
-                    !("length" in val) &&
-                    Object.keys(val).length > 0) {
-                    // Plain object with numeric keys (e.g., from IPC serialization)
-                    return Object.entries(val)
-                        .filter(([k]) => !Number.isNaN(Number(k)))
-                        .sort((a, b) => Number(a[0]) - Number(b[0]))
-                        .map(([, v]) => Number(v) || 0);
-                }
                 return [];
             };
             // Mutate records in-place to avoid doubling memory with a parallel rows array.
@@ -697,6 +715,7 @@ class VectorDB {
                 yield this.withWriteGate(() => __awaiter(this, void 0, void 0, function* () {
                     const table = yield this.ensureTableUnsafe();
                     yield table.add(records);
+                    this.markWriteCommitted();
                 }));
             }
             catch (err) {
@@ -716,10 +735,105 @@ class VectorDB {
             return this.withWriteGate(() => this.createFTSIndexUnsafe(rebuild, retries));
         });
     }
+    createVectorIndex() {
+        return __awaiter(this, arguments, void 0, function* (rebuild = false, retries = 5, checkOnly = false) {
+            if (this.checkDiskPressure() !== "ok") {
+                (0, logger_1.debug)("vectordb", "ANN index skipped under disk pressure");
+                return false;
+            }
+            return this.withWriteGate(() => this.createVectorIndexUnsafe(rebuild, retries, checkOnly));
+        });
+    }
+    createVectorIndexUnsafe(rebuild, retries, checkOnly) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const table = yield this.ensureTableUnsafe();
+            const rowCount = yield table.countRows();
+            if (rowCount < (0, ann_config_1.annMinRows)())
+                return false;
+            const indices = yield table.listIndices();
+            const vectorIndex = indices.find((index) => index.name === "vector_idx" || index.columns.includes("vector"));
+            const pathIndex = indices.find((index) => index.name === "path_idx" || index.columns.includes("path"));
+            const vectorStats = vectorIndex
+                ? yield table.indexStats(vectorIndex.name)
+                : undefined;
+            const staleRatio = vectorStats
+                ? vectorStats.numUnindexedRows / Math.max(1, vectorStats.numIndexedRows)
+                : 0;
+            let needsVector = (0, ann_config_1.isAnnEnabled)() &&
+                (rebuild ||
+                    !vectorIndex ||
+                    ((_a = vectorStats === null || vectorStats === void 0 ? void 0 : vectorStats.distanceType) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== "l2" ||
+                    staleRatio > 0.2);
+            let needsPath = rebuild || !pathIndex;
+            if (!needsVector && !needsPath)
+                return false;
+            if (checkOnly) {
+                (0, logger_1.debug)("vectordb", `ANN maintenance due (vector=${needsVector}, path=${needsPath}, unindexed=${(_b = vectorStats === null || vectorStats === void 0 ? void 0 : vectorStats.numUnindexedRows) !== null && _b !== void 0 ? _b : 0})`);
+                return true;
+            }
+            let rebuiltAfterPanic = false;
+            for (let attempt = 1; attempt <= retries; attempt++) {
+                try {
+                    if (needsVector) {
+                        const numPartitions = Math.max(64, Math.min(2048, Math.round(Math.sqrt(rowCount))));
+                        yield table.createIndex("vector", {
+                            config: lancedb.Index.ivfFlat({
+                                distanceType: "l2",
+                                numPartitions,
+                            }),
+                            name: "vector_idx",
+                            replace: true,
+                        });
+                    }
+                    if (needsPath) {
+                        yield table.createIndex("path", {
+                            config: lancedb.Index.btree(),
+                            name: "path_idx",
+                            replace: true,
+                        });
+                    }
+                    this.annPanicRecoveryExhausted = false;
+                    return true;
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    if (attempt < retries &&
+                        (message.includes("conflict") || message.includes("Retryable"))) {
+                        const delay = 1000 * Math.pow(2, (attempt - 1));
+                        (0, logger_1.log)("vectordb", `createVectorIndex conflict (attempt ${attempt}/${retries}), retrying in ${delay}ms`);
+                        yield new Promise((resolve) => setTimeout(resolve, delay));
+                        continue;
+                    }
+                    if (message.includes("Panic") &&
+                        attempt < retries &&
+                        !rebuiltAfterPanic &&
+                        !this.annPanicRecoveryExhausted) {
+                        rebuiltAfterPanic = true;
+                        for (const name of ["vector_idx", "path_idx"]) {
+                            try {
+                                yield table.dropIndex(name);
+                            }
+                            catch (_c) { }
+                        }
+                        needsVector = (0, ann_config_1.isAnnEnabled)();
+                        needsPath = true;
+                        continue;
+                    }
+                    if (rebuiltAfterPanic)
+                        this.annPanicRecoveryExhausted = true;
+                    console.warn("Failed to create ANN indexes:", err);
+                    return false;
+                }
+            }
+            return false;
+        });
+    }
     createFTSIndexUnsafe() {
         return __awaiter(this, arguments, void 0, function* (rebuild = false, retries = 5) {
             const table = yield this.ensureTableUnsafe();
             if (rebuild) {
+                this.ftsIndexEnsured = false;
                 try {
                     yield table.dropIndex("content_idx");
                 }
@@ -730,11 +844,13 @@ class VectorDB {
                     yield table.createIndex("content", {
                         config: lancedb.Index.fts({ withPosition: true }),
                     });
+                    this.ftsIndexEnsured = true;
                     return;
                 }
                 catch (e) {
                     const msg = e instanceof Error ? e.message : String(e);
                     if (msg.includes("already exists")) {
+                        this.ftsIndexEnsured = true;
                         return;
                     }
                     // Retry on the same Lance commit-conflict pattern that optimize() handles —
@@ -748,18 +864,23 @@ class VectorDB {
                     }
                     // If position error, try dropping and recreating once
                     if (msg.includes("position")) {
+                        this.ftsIndexEnsured = false;
                         try {
                             yield table.dropIndex("content_idx");
                             yield table.createIndex("content", {
                                 config: lancedb.Index.fts({ withPosition: true }),
                             });
+                            this.ftsIndexEnsured = true;
                             (0, logger_1.log)("vectordb", "Rebuilt FTS index with position support");
                             return;
                         }
-                        catch (_b) { }
+                        catch (rebuildError) {
+                            console.warn("Failed to rebuild positional FTS index:", rebuildError);
+                            throw rebuildError;
+                        }
                     }
                     console.warn("Failed to create FTS index:", e);
-                    return;
+                    throw e;
                 }
             }
         });
@@ -777,6 +898,7 @@ class VectorDB {
                 yield this.compactingPromise;
                 return;
             }
+            this.lastOptimizeDidWork = false;
             let resolveCompacting;
             this.compactingPromise = new Promise((resolve) => {
                 resolveCompacting = resolve;
@@ -800,6 +922,7 @@ class VectorDB {
                         if (compaction.fragmentsRemoved > 0 ||
                             prune.oldVersionsRemoved > 0 ||
                             prune.bytesRemoved > 0) {
+                            this.lastOptimizeDidWork = true;
                             (0, logger_1.log)("vectordb", `Compacted: ${compaction.fragmentsRemoved} frags → ${compaction.fragmentsAdded}, ` +
                                 `pruned ${prune.oldVersionsRemoved} versions, ` +
                                 `freed ${(prune.bytesRemoved / 1024 / 1024).toFixed(1)}MB`);
@@ -842,6 +965,7 @@ class VectorDB {
                                 rebuiltFts = true;
                                 (0, logger_1.log)("vectordb", "Optimize panicked (likely corrupt FTS merge) — rebuilding FTS index from scratch and retrying");
                                 try {
+                                    this.ftsIndexEnsured = false;
                                     yield this.createFTSIndexUnsafe(true);
                                     continue;
                                 }
@@ -879,12 +1003,13 @@ class VectorDB {
      * Checks disk bloat ratio and retries optimize when bloat persists.
      */
     runMaintenance() {
-        return __awaiter(this, void 0, void 0, function* () {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
             if (this.maintenanceRunning) {
                 (0, logger_1.debug)("vectordb", "Maintenance already running, skipping");
                 return;
             }
             this.maintenanceRunning = true;
+            const epochSnapshot = this.writeEpoch;
             try {
                 const pressure = this.checkDiskPressure();
                 if (pressure === "critical") {
@@ -892,25 +1017,47 @@ class VectorDB {
                     (0, logger_1.log)("vectordb", `Maintenance skipped: disk critically low (${freeGb}GB free)`);
                     return;
                 }
+                if (!options.force &&
+                    epochSnapshot === this.maintainedEpoch &&
+                    this.ftsIndexEnsured) {
+                    const table = yield this.openExistingTableUnsafe();
+                    const version = yield this.readTableVersion(table);
+                    if (version === this.maintainedTableVersion) {
+                        this.lastMaintenanceMs = Date.now();
+                        return;
+                    }
+                    (0, logger_1.log)("vectordb", `External store writes detected (v${this.maintainedTableVersion} → v${version})`);
+                }
                 yield this.createFTSIndex();
+                yield this.createVectorIndex();
                 if (pressure === "low") {
                     (0, logger_1.log)("vectordb", `Low disk — single-pass optimize (no bloat retry)`);
                     yield this.optimize(1, 0, true);
-                    return;
                 }
-                // Normal maintenance: full optimize + bloat check
-                yield this.optimize(5, 0, true);
-                const table = yield this.ensureTable();
-                const stats = yield table.stats();
-                const diskSize = this.getDirectorySize(this.lancedbDir);
-                const logicalSize = stats.totalBytes;
-                const bloatRatio = logicalSize > 0 ? diskSize / logicalSize : 0;
-                // Only retry if disk is still ok after optimize (don't spiral)
-                if (bloatRatio > 2.0 && this.checkDiskPressure() === "ok") {
-                    (0, logger_1.log)("vectordb", `Bloat detected after optimize: ${(diskSize / 1024 / 1024).toFixed(0)}MB disk vs ${(logicalSize / 1024 / 1024).toFixed(0)}MB logical (${bloatRatio.toFixed(1)}x) — retrying`);
-                    yield new Promise((r) => setTimeout(r, 2000));
+                else {
+                    // Normal maintenance: full optimize + bloat check
                     yield this.optimize(5, 0, true);
+                    if (this.lastOptimizeDidWork) {
+                        const table = yield this.openExistingTableUnsafe();
+                        if (table) {
+                            const stats = yield table.stats();
+                            const diskSize = this.getDirectorySize(this.lancedbDir);
+                            const logicalSize = stats.totalBytes;
+                            const bloatRatio = logicalSize > 0 ? diskSize / logicalSize : 0;
+                            // Only retry if disk is still ok after optimize (don't spiral)
+                            if (bloatRatio > 2.0 && this.checkDiskPressure() === "ok") {
+                                (0, logger_1.log)("vectordb", `Bloat detected after optimize: ${(diskSize / 1024 / 1024).toFixed(0)}MB disk vs ${(logicalSize / 1024 / 1024).toFixed(0)}MB logical (${bloatRatio.toFixed(1)}x) — retrying`);
+                                yield new Promise((r) => setTimeout(r, 2000));
+                                yield this.optimize(5, 0, true);
+                            }
+                        }
+                    }
                 }
+                const maintainedTable = yield this.openExistingTableUnsafe();
+                this.maintainedTableVersion =
+                    yield this.readTableVersion(maintainedTable);
+                this.maintainedEpoch = epochSnapshot;
+                this.lastMaintenanceMs = Date.now();
             }
             finally {
                 this.maintenanceRunning = false;
@@ -1048,6 +1195,7 @@ class VectorDB {
                         .toArray();
                     if (existing.length > 0) {
                         yield table.delete(where);
+                        this.markWriteCommitted();
                     }
                 }
             }));
@@ -1067,6 +1215,7 @@ class VectorDB {
                         values: { [field]: (_a = values[i]) !== null && _a !== void 0 ? _a : "" },
                     });
                 }
+                this.markWriteCommitted();
             }));
         });
     }
@@ -1095,6 +1244,7 @@ class VectorDB {
                         .toArray();
                     if (existing.length > 0) {
                         yield table.delete(where);
+                        this.markWriteCommitted();
                     }
                 }
             }));
@@ -1112,6 +1262,7 @@ class VectorDB {
                 if (!table)
                     return;
                 yield table.delete((0, filter_builder_1.pathStartsWith)(dirPrefix));
+                this.markWriteCommitted();
             }));
         });
     }

package/dist/lib/workers/orchestrator.js

@@ -62,40 +62,18 @@ const granite_1 = require("./embeddings/granite");
 const mlx_client_1 = require("./embeddings/mlx-client");
 let mlxFallbackWarned = false;
 /**
- * Normalize a colbert payload received over IPC into an Int8Array.
- *
- * Node `child_process.send` serializes payloads as JSON, which doesn't
- * preserve TypedArrays. An Int8Array sent over IPC arrives as a plain
- * object with numeric keys (`{0: byte, 1: byte, ...}`). Without explicitly
- * handling that shape, the rerank pipeline silently no-ops (empty matrix
- * → maxSim returns 0 → final ranking falls back to fusion-only). Caught
- * 2026-05-25 when the eval harness showed rerank-on producing identical
- * scores to rerank-off across 97 cases.
+ * Reinterpret a ColBERT byte payload as signed bytes without copying views.
+ * Arrow returns Uint8Array subarray views, so byteOffset and byteLength must
+ * be preserved or reranking can read unrelated bytes from the backing buffer.
  */
 function coerceColbertBytes(col) {
     if (col instanceof Int8Array)
         return col;
-    if (Buffer.isBuffer(col)) {
+    if (ArrayBuffer.isView(col)) {
         return new Int8Array(col.buffer, col.byteOffset, col.byteLength);
     }
     if (Array.isArray(col))
         return new Int8Array(col);
-    if (col && typeof col === "object") {
-        // {type:"Buffer", data:[...]} — Node Buffer.toJSON output
-        const asUnknown = col;
-        if (asUnknown.type === "Buffer" && Array.isArray(asUnknown.data)) {
-            return new Int8Array(asUnknown.data);
-        }
-        // {0: byte, 1: byte, ...} — Int8Array after IPC JSON serialization
-        const keys = Object.keys(col);
-        if (keys.length > 0 && keys.every((k) => /^\d+$/.test(k))) {
-            const arr = new Int8Array(keys.length);
-            for (const k of keys) {
-                arr[Number(k)] = col[k];
-            }
-            return arr;
-        }
-    }
     return new Int8Array(0);
 }
 const CACHE_DIR = config_1.PATHS.models;
@@ -313,15 +291,7 @@ class WorkerOrchestrator {
                     colbert: new Int8Array(),
                     scale: 1,
                 };
-                return Object.assign(Object.assign({}, chunk), { vector: hybrid.dense, colbert: Buffer.from(hybrid.colbert), colbert_scale: hybrid.scale, 
-                    // Convert the pooled Float32Array to a plain number[] so it survives
-                    // the JSON IPC hop to the parent (process-child.ts → pool.ts). A typed
-                    // array JSON-serializes to a length-less {"0":..} object, which then
-                    // Array.from()s to [] on insert and pads to 48 zeros — silently making
-                    // the stage-1 cosine prefilter a no-op (searcher.ts:732).
-                    pooled_colbert_48d: hybrid.pooled_colbert_48d
-                        ? Array.from(hybrid.pooled_colbert_48d)
-                        : undefined, doc_token_ids: hybrid.token_ids });
+                return Object.assign(Object.assign({}, chunk), { vector: hybrid.dense, colbert: Buffer.from(hybrid.colbert), colbert_scale: hybrid.scale, pooled_colbert_48d: hybrid.pooled_colbert_48d, doc_token_ids: hybrid.token_ids });
             });
             onProgress === null || onProgress === void 0 ? void 0 : onProgress();
             (0, logger_1.debug)("orch", `processFile done: ${input.path} ${vectors.length} vectors ${(performance.now() - fileStart).toFixed(0)}ms`);