grepmax 0.26.42 → 0.26.44

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

@@ -41,6 +41,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VectorDB = exports.DiskPressureError = void 0;
 exports.findStaleLanceTempFiles = findStaleLanceTempFiles;
@@ -48,7 +55,6 @@ exports.sweepStaleLanceTempFiles = sweepStaleLanceTempFiles;
 exports.isLanceCorruptionError = isLanceCorruptionError;
 exports.isMissingTableError = isMissingTableError;
 const fs = __importStar(require("node:fs"));
-const lancedb = __importStar(require("@lancedb/lancedb"));
 const apache_arrow_1 = require("apache-arrow");
 const config_1 = require("../../config");
 const embedding_reuse_1 = require("../index/embedding-reuse");
@@ -56,7 +62,10 @@ 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 query_timeout_1 = require("../utils/query-timeout");
 const ann_config_1 = require("./ann-config");
+const compaction_result_1 = require("./compaction-result");
+const lancedb = __importStar(require("./lance-sdk"));
 const store_lease_1 = require("./store-lease");
 /**
  * Find abandoned Lance scratch files under `<lancedbDir>/ *.lance/data`.
@@ -230,6 +239,7 @@ class VectorDB {
         /** Only an index owner may create/rebuild shared indexes — see markIndexOwner. */
         this.indexOwner = false;
         this.lastOptimizeDidWork = false;
+        this.lastCompactionResult = null;
         /** Compaction rate limiter — see COMPACTION_MIN_INTERVAL_MS. */
         this.lastCompactionMs = 0;
         this.compactionIntervalMs = COMPACTION_MIN_INTERVAL_MS;
@@ -367,7 +377,11 @@ class VectorDB {
             if (!this.db) {
                 fs.mkdirSync(this.lancedbDir, { recursive: true });
                 this.session = createLanceSession();
-                this.db = yield lancedb.connect(this.lancedbDir, {}, this.session);
+                // 0.38 accepts the legacy third argument in its types but drops it in
+                // the JS wrapper. Put the session in native ConnectionOptions instead.
+                this.db = yield lancedb.connect(this.lancedbDir, {
+                    session: this.session,
+                });
             }
             return this.db;
         });
@@ -1085,8 +1099,18 @@ class VectorDB {
             }
         });
     }
+    compactionStatus() {
+        return this.lastCompactionResult ? Object.assign({}, this.lastCompactionResult) : null;
+    }
+    recordSkippedCompaction(reason) {
+        const result = (0, compaction_result_1.skippedCompaction)(reason);
+        this.lastCompactionResult = result;
+        (0, logger_1.log)("vectordb", `Compaction result: ${JSON.stringify(result)}`);
+        return Object.assign({}, result);
+    }
     optimize() {
         return __awaiter(this, arguments, void 0, function* (retries = COMPACTION_MAX_ATTEMPTS, retentionMs = 0, bypassExclusiveMutation = false) {
+            var _a;
             if (!bypassExclusiveMutation) {
                 while (this.exclusiveMutationPromise)
                     yield this.exclusiveMutationPromise;
@@ -1096,7 +1120,7 @@ class VectorDB {
             if (this.compactingPromise) {
                 (0, logger_1.debug)("vectordb", "Optimize already in progress, skipping");
                 yield this.compactingPromise;
-                return;
+                return ((_a = this.compactionStatus()) !== null && _a !== void 0 ? _a : (0, compaction_result_1.skippedCompaction)("compaction unavailable"));
             }
             this.lastOptimizeDidWork = false;
             let resolveCompacting;
@@ -1104,6 +1128,29 @@ class VectorDB {
                 resolveCompacting = resolve;
             });
             this.activeCompactions++;
+            const startedAt = Date.now();
+            let attempts = 0;
+            let logicalBytes;
+            let diskBytesBefore;
+            let freeBytesBefore;
+            const finish = (status, reason, bytesReclaimed) => {
+                const result = {
+                    status,
+                    at: Date.now(),
+                    attempts,
+                    elapsedMs: Date.now() - startedAt,
+                    reason: reason === null || reason === void 0 ? void 0 : reason.replace(/[\r\n\t]/g, " ").slice(0, 512),
+                    logicalBytes,
+                    diskBytesBefore,
+                    freeBytesBefore,
+                    diskBytesAfter: this.getDirectorySize(this.lancedbDir),
+                    freeBytesAfter: this.getAvailableBytes(),
+                    bytesReclaimed,
+                };
+                this.lastCompactionResult = result;
+                (0, logger_1.log)("vectordb", `Compaction result: ${JSON.stringify(result)}`);
+                return Object.assign({}, result);
+            };
             try {
                 const maxAttempts = Math.min(retries, COMPACTION_MAX_ATTEMPTS);
                 let rebuiltFts = false;
@@ -1123,10 +1170,17 @@ class VectorDB {
                         // for rewrite/index overhead, leaving the critical reserve untouched.
                         const availableBytes = this.getAvailableBytes();
                         const requiredBytes = totalBytes * 2 + config_1.DISK_CRITICAL_BYTES;
+                        logicalBytes = totalBytes;
+                        const diskBytes = this.getDirectorySize(this.lancedbDir);
+                        diskBytesBefore !== null && diskBytesBefore !== void 0 ? diskBytesBefore : (diskBytesBefore = diskBytes);
+                        freeBytesBefore !== null && freeBytesBefore !== void 0 ? freeBytesBefore : (freeBytesBefore = availableBytes);
                         if (availableBytes < requiredBytes) {
-                            (0, logger_1.log)("vectordb", `Optimize skipped: insufficient rewrite headroom (${(availableBytes / Math.pow(1024, 3)).toFixed(1)}GB free, ${(requiredBytes / Math.pow(1024, 3)).toFixed(1)}GB required)`);
-                            return;
+                            const reason = `insufficient rewrite headroom (${(availableBytes / Math.pow(1024, 3)).toFixed(1)}GB free, ${(requiredBytes / Math.pow(1024, 3)).toFixed(1)}GB required)`;
+                            (0, logger_1.log)("vectordb", `Optimize skipped: ${reason}`);
+                            return finish("skipped", reason);
                         }
+                        attempts++;
+                        (0, logger_1.log)("vectordb", `Compaction attempt: ${JSON.stringify({ attempt, maxAttempts, logicalBytes, diskBytes, freeBytes: availableBytes, requiredBytes })}`);
                         const done = (0, logger_1.timer)("vectordb", "optimize");
                         // deleteUnverified deletes files Lance cannot prove are unreferenced.
                         // LanceDB's own docs: only safe "if you can guarantee that no other
@@ -1156,19 +1210,20 @@ class VectorDB {
                         else {
                             (0, logger_1.debug)("vectordb", "Optimize: nothing to compact or prune");
                         }
-                        return;
+                        return finish("completed", undefined, prune.bytesRemoved);
                     }
                     catch (e) {
                         const msg = e instanceof Error ? e.message : String(e);
                         if (msg.includes("Nothing to do")) {
                             (0, logger_1.debug)("vectordb", "Optimize: nothing to do");
-                            return;
+                            return finish("completed", "nothing to compact or prune", 0);
                         }
+                        (0, logger_1.log)("vectordb", `Compaction attempt failed: ${JSON.stringify({ attempt, elapsedMs: Date.now() - startedAt, diskBytes: this.getDirectorySize(this.lancedbDir), freeBytes: this.getAvailableBytes(), reason: msg.slice(0, 512) })}`);
                         // ENOSPC: return immediately — retrying will only make things worse
                         if (msg.includes("No space left on device") ||
                             msg.includes("os error 28")) {
                             (0, logger_1.log)("vectordb", `Optimize failed (ENOSPC): disk full — skipping retries`);
-                            return;
+                            return finish("failed", "disk full — skipping retries");
                         }
                         if (attempt < maxAttempts &&
                             (msg.includes("conflict") || msg.includes("Retryable"))) {
@@ -1198,7 +1253,7 @@ class VectorDB {
                                 catch (rebuildErr) {
                                     this.ftsPanicRecoveryExhausted = true;
                                     (0, logger_1.log)("vectordb", `FTS rebuild failed: ${rebuildErr}`);
-                                    return;
+                                    return finish("failed", `FTS rebuild failed: ${rebuildErr}`);
                                 }
                             }
                             if (rebuiltFts) {
@@ -1207,9 +1262,10 @@ class VectorDB {
                             }
                         }
                         (0, logger_1.log)("vectordb", `Optimize failed: ${msg}`);
-                        return;
+                        return finish("failed", msg);
                     }
                 }
+                return finish("skipped", "no compaction attempts requested");
             }
             finally {
                 this.compactingPromise = null;
@@ -1232,16 +1288,17 @@ class VectorDB {
         return __awaiter(this, arguments, void 0, function* (options = {}) {
             if (this.maintenanceRunning) {
                 (0, logger_1.debug)("vectordb", "Maintenance already running, skipping");
-                return;
+                return (0, compaction_result_1.skippedCompaction)("maintenance already running");
             }
             this.maintenanceRunning = true;
             const epochSnapshot = this.writeEpoch;
+            let result;
             try {
                 const pressure = this.checkDiskPressure();
                 if (pressure === "critical") {
                     const freeGb = (this.getAvailableBytes() / 1024 / 1024 / 1024).toFixed(1);
                     (0, logger_1.log)("vectordb", `Maintenance skipped: disk critically low (${freeGb}GB free)`);
-                    return;
+                    return this.recordSkippedCompaction(`disk critically low (${freeGb}GB free)`);
                 }
                 if (!options.force &&
                     epochSnapshot === this.maintainedEpoch &&
@@ -1270,12 +1327,12 @@ class VectorDB {
                 }
                 else if (pressure === "low") {
                     (0, logger_1.log)("vectordb", `Low disk — single-pass optimize (no bloat retry)`);
-                    yield this.optimize(1, 0, true);
+                    result = yield this.optimize(1, 0, true);
                     this.noteCompaction(this.lastOptimizeDidWork);
                 }
                 else {
                     // Normal maintenance: full optimize + bloat check
-                    yield this.optimize(5, 0, true);
+                    result = yield this.optimize(5, 0, true);
                     // Track across both passes: `lastOptimizeDidWork` is reset per optimize()
                     // call, so a productive first pass followed by a barren bloat retry would
                     // otherwise read as unproductive and trigger a spurious backoff.
@@ -1300,7 +1357,7 @@ class VectorDB {
                             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);
+                                result = yield this.optimize(5, 0, true);
                                 didWork = didWork || this.lastOptimizeDidWork;
                             }
                         }
@@ -1312,6 +1369,7 @@ class VectorDB {
                     yield this.readTableVersion(maintainedTable);
                 this.maintainedEpoch = epochSnapshot;
                 this.lastMaintenanceMs = Date.now();
+                return result;
             }
             finally {
                 this.maintenanceRunning = false;
@@ -1376,9 +1434,9 @@ class VectorDB {
                         return false;
                     }
                     (0, logger_1.log)("vectordb", `Fragment threshold exceeded (${stats.fragmentStats.numSmallFragments} > ${threshold}) — compacting`);
-                    yield this.optimize(2, 0, true);
+                    const result = yield this.optimize(2, 0, true);
                     this.noteCompaction(this.lastOptimizeDidWork);
-                    return true;
+                    return result.status === "completed";
                 }
             }
             catch (err) {
@@ -1411,7 +1469,11 @@ class VectorDB {
     hasAnyRows() {
         return __awaiter(this, void 0, void 0, function* () {
             const table = yield this.ensureTable();
-            const rows = yield table.query().select(["id"]).limit(1).toArray();
+            const rows = yield table
+                .query()
+                .select(["id"])
+                .limit(1)
+                .toArray(query_timeout_1.QUERY_EXECUTION_OPTIONS);
             return rows.length > 0;
         });
     }
@@ -1424,7 +1486,7 @@ class VectorDB {
                 .select(["id"])
                 .where((0, filter_builder_1.pathStartsWith)(prefix))
                 .limit(1)
-                .toArray();
+                .toArray(query_timeout_1.QUERY_EXECUTION_OPTIONS);
             return rows.length > 0;
         });
     }
@@ -1442,16 +1504,25 @@ class VectorDB {
     }
     getDistinctPathsForPrefix(pathPrefix) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
             const table = yield this.ensureTable();
             const prefix = pathPrefix.endsWith("/") ? pathPrefix : `${pathPrefix}/`;
-            const rows = yield table
-                .query()
-                .select(["path"])
-                .where((0, filter_builder_1.pathStartsWith)(prefix))
-                .toArray();
+            const rows = (0, query_timeout_1.streamQueryRows)(table.query().select(["path"]).where((0, filter_builder_1.pathStartsWith)(prefix)), "distinct project paths");
             const unique = new Set();
-            for (const r of rows) {
-                unique.add(String(r.path));
+            try {
+                for (var _d = true, rows_1 = __asyncValues(rows), rows_1_1; rows_1_1 = yield rows_1.next(), _a = rows_1_1.done, !_a; _d = true) {
+                    _c = rows_1_1.value;
+                    _d = false;
+                    const r = _c;
+                    unique.add(String(r.path));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = rows_1.return)) yield _b.call(rows_1);
+                }
+                finally { if (e_1) throw e_1.error; }
             }
             return unique;
         });
@@ -1476,7 +1547,7 @@ class VectorDB {
                 "doc_token_ids",
             ])
                 .where(`path = '${(0, filter_builder_1.escapeSqlString)(filePath)}'`)
-                .toArray();
+                .toArray(query_timeout_1.QUERY_EXECUTION_OPTIONS);
             const reusable = new Map();
             for (const row of rows) {
                 const vector = (0, embedding_reuse_1.toFloat32)(row.vector);
@@ -1510,9 +1581,25 @@ class VectorDB {
     }
     getDistinctFileCount() {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_2, _b, _c;
             const table = yield this.ensureTable();
-            const rows = yield table.query().select(["path"]).toArray();
-            return new Set(rows.map((r) => r.path)).size;
+            const paths = new Set();
+            try {
+                for (var _d = true, _e = __asyncValues((0, query_timeout_1.streamQueryRows)(table.query().select(["path"]), "distinct file count")), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const row = _c;
+                    paths.add(String(row.path));
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return paths.size;
         });
     }
     deletePaths(paths) {
@@ -1535,7 +1622,7 @@ class VectorDB {
                         .select(["id"])
                         .where(where)
                         .limit(1)
-                        .toArray();
+                        .toArray(query_timeout_1.QUERY_EXECUTION_OPTIONS);
                     if (existing.length > 0) {
                         yield table.delete(where);
                         this.markWriteCommitted();
@@ -1584,7 +1671,7 @@ class VectorDB {
                         .select(["id"])
                         .where(where)
                         .limit(1)
-                        .toArray();
+                        .toArray(query_timeout_1.QUERY_EXECUTION_OPTIONS);
                     if (existing.length > 0) {
                         yield table.delete(where);
                         this.markWriteCommitted();

package/dist/lib/utils/cross-project.js

@@ -15,13 +15,13 @@ exports.resolveCrossProjectScope = resolveCrossProjectScope;
 exports.projectForPath = projectForPath;
 exports.groupResultsByProject = groupResultsByProject;
 const project_registry_1 = require("./project-registry");
-function resolveCrossProjectScope(opts) {
+function resolveCrossProjectScope(opts, registeredProjects = (0, project_registry_1.listProjects)()) {
     const active = !!(opts.allProjects || opts.projects);
     if (!active) {
         return { active: false, roots: [], projectRoots: [], warnings: [] };
     }
     // Ignore "error"-status projects: the daemon won't search them anyway.
-    const all = (0, project_registry_1.listProjects)().filter((p) => p.status !== "error");
+    const all = registeredProjects.filter((p) => p.status !== "error");
     const byName = new Map(all.map((p) => [p.name, p]));
     const warnings = [];
     const resolveNames = (csv) => {

package/dist/lib/utils/doctor-optimize.js

@@ -0,0 +1,81 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctorOptimize = runDoctorOptimize;
+exports.formatDoctorOptimize = formatDoctorOptimize;
+const compaction_result_1 = require("../store/compaction-result");
+/** A live daemon's failed repair must never become a competing local rewrite. */
+function runDoctorOptimize(send, optimizeInProcess) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const response = yield send();
+        const result = (0, compaction_result_1.parseCompactionResult)(response.compaction);
+        if (result) {
+            return {
+                status: !response.ok && result.status === "completed"
+                    ? "failed"
+                    : result.status,
+                via: "daemon",
+                reason: (_a = result.reason) !== null && _a !== void 0 ? _a : (response.ok ? undefined : String(response.error)),
+                result,
+            };
+        }
+        if (response.ok) {
+            return {
+                status: "unverified",
+                via: "daemon",
+                reason: "daemon did not report a compaction outcome; restart it with the current gmax version",
+            };
+        }
+        const reason = String((_b = response.error) !== null && _b !== void 0 ? _b : "unknown failure");
+        // Socket errors are returned as exact errno codes by sendDaemonCommand.
+        // An ENOENT inside a daemon's failure message is not proof it is absent.
+        if (reason === "ECONNREFUSED" || reason === "ENOENT") {
+            try {
+                const local = yield optimizeInProcess();
+                return {
+                    status: local.status,
+                    via: "in-process",
+                    reason: local.reason,
+                    result: local,
+                };
+            }
+            catch (error) {
+                return { status: "failed", via: "in-process", reason: String(error) };
+            }
+        }
+        return {
+            status: reason.includes("unknown command") ? "skipped" : "failed",
+            via: "daemon",
+            reason,
+        };
+    });
+}
+function formatDoctorOptimize(report, agent) {
+    var _a;
+    const reason = (_a = report.reason) === null || _a === void 0 ? void 0 : _a.replace(/[\r\n\t]/g, " ").slice(0, 512);
+    if (agent) {
+        const r = report.result;
+        return [
+            `optimize`,
+            `status=${report.status}`,
+            `via=${report.via}`,
+            ...(r ? [`attempts=${r.attempts}`, `elapsed_ms=${r.elapsedMs}`] : []),
+            ...(typeof (r === null || r === void 0 ? void 0 : r.bytesReclaimed) === "number"
+                ? [`bytes_reclaimed=${r.bytesReclaimed}`]
+                : []),
+            ...(reason ? [`reason=${reason}`] : []),
+        ].join("\t");
+    }
+    if (report.status === "completed")
+        return `ok  Optimize complete (${report.via})`;
+    return `${report.status === "failed" ? "FAIL" : "WARN"}  Optimize ${report.status} (${report.via}): ${reason !== null && reason !== void 0 ? reason : "no outcome reported"}`;
+}

package/dist/lib/utils/project-registry.js

@@ -74,16 +74,16 @@ class ProjectRegistryConflictError extends Error {
     }
 }
 exports.ProjectRegistryConflictError = ProjectRegistryConflictError;
-function loadRegistry() {
+function loadRegistry(registryPath = REGISTRY_PATH) {
     let raw;
     try {
-        raw = fs.readFileSync(REGISTRY_PATH, "utf-8");
+        raw = fs.readFileSync(registryPath, "utf-8");
     }
     catch (err) {
         if (err.code === "ENOENT")
             return [];
         const message = err instanceof Error ? err.message : String(err);
-        throw new Error(`Failed to read project registry ${REGISTRY_PATH}: ${message}`);
+        throw new Error(`Failed to read project registry ${registryPath}: ${message}`);
     }
     let parsed;
     try {
@@ -91,14 +91,14 @@ function loadRegistry() {
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        throw new Error(`Invalid project registry JSON ${REGISTRY_PATH}: ${message}`);
+        throw new Error(`Invalid project registry JSON ${registryPath}: ${message}`);
     }
     if (!Array.isArray(parsed)) {
-        throw new Error(`Invalid project registry ${REGISTRY_PATH}: expected an array`);
+        throw new Error(`Invalid project registry ${registryPath}: expected an array`);
     }
     for (const [index, entry] of parsed.entries()) {
         if (!isProjectEntry(entry)) {
-            throw new Error(`Invalid project registry entry at index ${index} in ${REGISTRY_PATH}`);
+            throw new Error(`Invalid project registry entry at index ${index} in ${registryPath}`);
         }
     }
     return parsed;
@@ -455,8 +455,8 @@ function stampProjectFullSync(stamp) {
         return entry;
     });
 }
-function listProjects() {
-    return loadRegistry();
+function listProjects(home) {
+    return loadRegistry(home ? path.join(home, "projects.json") : undefined);
 }
 function getProject(root) {
     return loadRegistry().find((e) => e.root === root);

package/dist/lib/utils/query-timeout.js

@@ -8,10 +8,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryTimeoutError = void 0;
+exports.QueryTimeoutError = exports.QUERY_EXECUTION_OPTIONS = exports.QUERY_TIMEOUT_MS = void 0;
 exports.withQueryTimeout = withQueryTimeout;
-const DEFAULT_TIMEOUT_MS = Number(process.env.GMAX_QUERY_TIMEOUT_MS || "") || 15000;
+exports.streamQueryRows = streamQueryRows;
+const configuredTimeout = Number(process.env.GMAX_QUERY_TIMEOUT_MS);
+exports.QUERY_TIMEOUT_MS = Number.isFinite(configuredTimeout) && configuredTimeout > 0
+    ? Math.max(1, Math.min(Math.floor(configuredTimeout), 2147483647))
+    : 15000;
+exports.QUERY_EXECUTION_OPTIONS = { timeoutMs: exports.QUERY_TIMEOUT_MS };
 class QueryTimeoutError extends Error {
     constructor(label, ms) {
         super(`LanceDB query timed out after ${ms}ms (${label}). ` +
@@ -24,19 +42,13 @@ exports.QueryTimeoutError = QueryTimeoutError;
  * Race a LanceDB query against a wall-clock timeout so a native-layer deadlock
  * surfaces as a loud error instead of hanging the process forever.
  *
- * Known trigger (@lancedb/lancedb 0.27.x): a `content LIKE` scan with
- * `.limit(N)` where more than N rows match never resolves — the limit-pushdown
- * cancellation loses the completion (see lancedb/lancedb#2189 for the same
- * family of hangs). Callers should also avoid that query shape (scan without
- * a limit and cap in JS); this wrapper is the backstop for shapes we missed.
- *
- * The timed-out native promise is NOT cancelled — its tokio task may stay
- * parked. CLI commands exit via gracefulExit() (process.exit), so the leak is
- * bounded to the command's lifetime. Long-lived callers (daemon) should treat
- * a QueryTimeoutError as a signal that the connection may be wedged.
+ * This JavaScript backstop does not cancel its input. Native query callers
+ * must also pass QUERY_EXECUTION_OPTIONS to toArray/execute so Lance enforces
+ * an execution deadline. The historical 0.27 LIKE+limit hang has a native
+ * temporary-store regression on the pinned SDK.
  */
 function withQueryTimeout(promise_1, label_1) {
-    return __awaiter(this, arguments, void 0, function* (promise, label, ms = DEFAULT_TIMEOUT_MS) {
+    return __awaiter(this, arguments, void 0, function* (promise, label, ms = exports.QUERY_TIMEOUT_MS) {
         let timer;
         const timeout = new Promise((_, reject) => {
             timer = setTimeout(() => reject(new QueryTimeoutError(label, ms)), ms);
@@ -50,3 +62,31 @@ function withQueryTimeout(promise_1, label_1) {
         }
     });
 }
+/** Stream bounded Arrow batches with a native and overall wall-clock deadline.
+ * SDK 0.38 exposes execute(options) at runtime but marks it protected in its
+ * declarations. Keep this version-specific adapter here and cover it natively.
+ */
+function streamQueryRows(query_1, label_1) {
+    return __asyncGenerator(this, arguments, function* streamQueryRows_1(query, label, ms = exports.QUERY_TIMEOUT_MS) {
+        var _a;
+        const streaming = query;
+        const iterator = streaming.execute({ timeoutMs: ms, maxBatchLength: 512 });
+        const deadline = Date.now() + ms;
+        try {
+            for (;;) {
+                const remaining = deadline - Date.now();
+                if (remaining <= 0)
+                    throw new QueryTimeoutError(label, ms);
+                const batch = yield __await(withQueryTimeout(iterator.next(), label, remaining));
+                if (batch.done)
+                    return yield __await(void 0);
+                for (const row of batch.value.toArray())
+                    yield yield __await(row);
+            }
+        }
+        finally {
+            // Do not let a broken native iterator's pending next() hang cleanup.
+            void ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator).catch(() => { }));
+        }
+    });
+}

package/dist/lib/utils/store-access.js

@@ -189,15 +189,14 @@ function classifyDaemonError(error) {
  *
  * Kept as a named predicate because it is the exact rule `search-run.ts` has
  * always applied (and re-exports); `unknown command` is deliberately NOT in the
- * set — see `isUnknownCommandError` for the version-skew allowance.
+ * set; an unsupported verb is a live daemon refusing the request.
  */
 function shouldFallbackFromDaemonError(error) {
     return classifyDaemonError(error) === "no-daemon";
 }
 /**
- * A daemon older than this CLI does not know a newly added verb. Treat that as
- * "no daemon" for one release so an unrestarted daemon does not break the
- * command, then remove the allowance. Mirrors the `search-v2` transition rule.
+ * An unsupported verb means a live daemon is outdated or incompatible. It must
+ * be restarted, never bypassed by opening a second reader.
  */
 function isUnknownCommandError(error) {
     return typeof error === "string" && error.startsWith("unknown command");
@@ -304,8 +303,10 @@ function withStoreRead(name, opts) {
         const cls = classifyDaemonError(resp.error);
         if (cls === "sandboxed")
             throw refuseStoreAccess("socket");
+        if (isUnknownCommandError(resp.error)) {
+            throw new Error(`${defaultDaemonErrorMessage(name, resp)}. The daemon is outdated or incompatible; run: gmax watch restart`);
+        }
         if (cls === "no-daemon" ||
-            (opts.fallbackOnUnknownVerb && isUnknownCommandError(resp.error)) ||
             (opts.fallbackOnOversize && isOversizeError(resp.error)) ||
             ((_a = opts.extraFallback) === null || _a === void 0 ? void 0 : _a.call(opts, resp.error)) === true) {
             if (process.env.GMAX_DEBUG === "1") {