grepmax 0.24.0 → 0.25.0

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

@@ -44,6 +44,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VectorDB = exports.DiskPressureError = void 0;
 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");
@@ -52,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 store_lease_1 = require("./store-lease");
 class DiskPressureError extends Error {
     constructor(message = "Disk critically low — writes suspended") {
         super(message);
@@ -69,6 +71,9 @@ function isLanceCorruptionError(err) {
     return /Not found:.*\.lance(?:[^a-z]|$)/i.test(msg);
 }
 function isMissingTableError(err) {
+    const code = err === null || err === void 0 ? void 0 : err.code;
+    if (code === "EACCES" || code === "EIO")
+        return false;
     const msg = err instanceof Error ? err.message : String(err);
     const tableMissing = /table.*chunks.*(?:not found|does not exist)/i.test(msg) ||
         /(?:not found|does not exist).*table.*chunks/i.test(msg) ||
@@ -82,22 +87,34 @@ function isMissingTableError(err) {
 const TABLE_NAME = "chunks";
 const MAINTENANCE_INTERVAL_MS = 5 * 60 * 1000;
 class VectorDB {
-    constructor(lancedbDir, vectorDim) {
+    constructor(lancedbDir, vectorDim, suppliedLease) {
         this.lancedbDir = lancedbDir;
+        this.suppliedLease = suppliedLease;
         this.db = null;
         this.closed = false;
         this.maintenanceRunning = false;
         this.maintenancePromise = null;
         this.maintenanceTimer = null;
+        this.maintenanceRunner = (fn) => fn();
         this.lastCorruptionLogMs = 0;
         this.diskPressure = "ok";
         this.lastDiskCheckMs = 0;
         this.lastLoggedPressure = "ok";
+        this.leasePromise = null;
+        this.leaseAbort = new AbortController();
+        this.closePromise = null;
+        this.releaseLeaseOnClose = true;
+        this.requireClosedOnClose = false;
+        this.leaseTransitionTail = Promise.resolve();
+        this.leaseHolder = {};
         // Write gate: async read-write lock where writes are "readers" (shared)
         // and compaction is the "writer" (exclusive).
         this.activeWrites = 0;
-        this.writeDrainResolve = null;
+        this.writeDrainResolvers = new Set();
         this.compactingPromise = null;
+        this.exclusiveMutationPromise = null;
+        this.activeCompactions = 0;
+        this.compactionDrainResolvers = new Set();
         // Default to the configured tier's dim (not the hard-wired small-tier 384)
         // so a `standard`-tier index actually stores 768d vectors. An explicit
         // arg still wins (eval scripts, tests).
@@ -108,7 +125,9 @@ class VectorDB {
      * Start a periodic maintenance timer (FTS rebuild + optimize).
      * Call once from the daemon — replaces per-processor maintenance intervals.
      */
-    startMaintenanceLoop() {
+    startMaintenanceLoop(runOperation) {
+        if (runOperation)
+            this.maintenanceRunner = runOperation;
         if (this.maintenanceTimer)
             return;
         this.maintenanceTimer = setInterval(() => {
@@ -118,7 +137,7 @@ class VectorDB {
             // promise to await instead of a chain.
             if (this.maintenancePromise)
                 return;
-            const run = (() => __awaiter(this, void 0, void 0, function* () {
+            const run = this.maintenanceRunner(() => __awaiter(this, void 0, void 0, function* () {
                 try {
                     yield this.runMaintenance();
                 }
@@ -143,7 +162,7 @@ class VectorDB {
                     }
                     (0, logger_1.log)("vectordb", `Periodic maintenance failed: ${err}`);
                 }
-            }))();
+            }));
             this.maintenancePromise = run.finally(() => {
                 if (this.maintenancePromise === run)
                     this.maintenancePromise = null;
@@ -169,6 +188,10 @@ class VectorDB {
     }
     getDb() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.closed) {
+                throw new Error("VectorDB connection is closed");
+            }
+            yield this.getLease();
             if (this.closed) {
                 throw new Error("VectorDB connection is closed");
             }
@@ -179,6 +202,88 @@ class VectorDB {
             return this.db;
         });
     }
+    getLease() {
+        if (!this.leasePromise) {
+            const lease = this.suppliedLease
+                ? Promise.resolve(this.suppliedLease)
+                : store_lease_1.StoreLease.acquireShared({
+                    storeDir: this.lancedbDir,
+                    role: process.title || "gmax",
+                    signal: this.leaseAbort.signal,
+                });
+            this.leasePromise = lease.then((resolved) => {
+                resolved.claim(this.leaseHolder, this.lancedbDir);
+                return resolved;
+            });
+        }
+        return this.leasePromise;
+    }
+    withLeaseTransition(fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const previous = this.leaseTransitionTail;
+            let release;
+            this.leaseTransitionTail = new Promise((resolve) => {
+                release = resolve;
+            });
+            yield previous;
+            try {
+                return yield fn();
+            }
+            finally {
+                release();
+            }
+        });
+    }
+    /** Upgrade and retain this instance's current lease for transfer to a new DB. */
+    upgradeStoreLease(signal) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.closed)
+                throw new Error("VectorDB connection is closed");
+            if (this.exclusiveMutationPromise)
+                yield this.exclusiveMutationPromise;
+            return this.withLeaseTransition(() => __awaiter(this, void 0, void 0, function* () {
+                const current = yield this.getLease();
+                if (current.mode === "exclusive")
+                    return current;
+                const upgrade = current.upgrade({ signal });
+                this.leasePromise = upgrade;
+                try {
+                    const upgraded = yield upgrade;
+                    upgraded.claim(this.leaseHolder, this.lancedbDir);
+                    return upgraded;
+                }
+                catch (error) {
+                    this.leasePromise = Promise.resolve(current);
+                    throw error;
+                }
+            }));
+        });
+    }
+    /** Downgrade a transferred exclusive lease and retain the replacement token. */
+    downgradeStoreLease() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.closed)
+                throw new Error("VectorDB connection is closed");
+            if (this.exclusiveMutationPromise)
+                yield this.exclusiveMutationPromise;
+            return this.withLeaseTransition(() => __awaiter(this, void 0, void 0, function* () {
+                const current = yield this.getLease();
+                if (current.mode === "shared")
+                    return current;
+                const downgrade = current.downgrade();
+                this.leasePromise = downgrade;
+                try {
+                    const downgraded = yield downgrade;
+                    downgraded.claim(this.leaseHolder, this.lancedbDir);
+                    return downgraded;
+                }
+                catch (error) {
+                    this.leasePromise = Promise.resolve(current);
+                    throw error;
+                }
+            }));
+        });
+    }
     getAvailableBytes() {
         try {
             const stats = fs.statfsSync(this.lancedbDir);
@@ -233,29 +338,86 @@ class VectorDB {
      */
     withWriteGate(fn) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.compactingPromise) {
-                yield this.compactingPromise;
+            while (this.exclusiveMutationPromise || this.compactingPromise) {
+                if (this.closed)
+                    throw new Error("VectorDB connection is closed");
+                yield Promise.all([this.exclusiveMutationPromise, this.compactingPromise].filter((promise) => promise !== null));
             }
+            if (this.closed)
+                throw new Error("VectorDB connection is closed");
             this.activeWrites++;
             try {
                 return yield fn();
             }
             finally {
                 this.activeWrites--;
-                if (this.activeWrites === 0 && this.writeDrainResolve) {
-                    this.writeDrainResolve();
-                    this.writeDrainResolve = null;
+                if (this.activeWrites === 0) {
+                    for (const resolve of this.writeDrainResolvers)
+                        resolve();
+                    this.writeDrainResolvers.clear();
                 }
             }
         });
     }
+    drainCompactions() {
+        if (this.activeCompactions === 0)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            this.compactionDrainResolvers.add(resolve);
+        });
+    }
+    /**
+     * Run a destructive table mutation while holding the process-wide exclusive
+     * store intent. New local writes stop before existing activity is drained.
+     */
+    withExclusiveTableMutation(mutation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.closed)
+                throw new Error("VectorDB connection is closed");
+            if (this.exclusiveMutationPromise) {
+                throw new Error("An exclusive table mutation is already in progress");
+            }
+            let resolveMutation;
+            this.exclusiveMutationPromise = new Promise((resolve) => {
+                resolveMutation = resolve;
+            });
+            try {
+                return yield this.withLeaseTransition(() => __awaiter(this, void 0, void 0, function* () {
+                    let temporaryExclusiveLease = null;
+                    try {
+                        const currentLease = yield this.getLease();
+                        if (currentLease.mode === "shared") {
+                            temporaryExclusiveLease = yield store_lease_1.StoreLease.acquireExclusive({
+                                storeDir: this.lancedbDir,
+                                pid: currentLease.owner.pid,
+                                processStart: currentLease.owner.processStart,
+                                role: `${currentLease.owner.role}:exclusive-mutation`,
+                                ignoreNonces: new Set([currentLease.owner.nonce]),
+                                signal: this.leaseAbort.signal,
+                            });
+                        }
+                        yield Promise.all([this.drainWrites(), this.drainCompactions()]);
+                        const db = yield this.getDb();
+                        return yield mutation(db);
+                    }
+                    finally {
+                        yield (temporaryExclusiveLease === null || temporaryExclusiveLease === void 0 ? void 0 : temporaryExclusiveLease.release());
+                    }
+                }));
+            }
+            finally {
+                this.exclusiveMutationPromise = null;
+                resolveMutation();
+            }
+        });
+    }
     /** Wait for all in-flight writes to complete before compaction. */
     drainWrites() {
         if (this.activeWrites === 0)
             return Promise.resolve();
         (0, logger_1.debug)("vectordb", `Draining ${this.activeWrites} in-flight write(s) before compaction`);
         return new Promise((resolve) => {
-            this.writeDrainResolve = resolve;
+            this.writeDrainResolvers.add(resolve);
         });
     }
     seedRow() {
@@ -305,8 +467,10 @@ class VectorDB {
             try {
                 table = yield db.openTable(TABLE_NAME);
             }
-            catch (_a) {
-                return null; // no table on disk yet
+            catch (err) {
+                if (isMissingTableError(err))
+                    return null;
+                throw err;
             }
             const schema = yield table.schema();
             const field = schema.fields.find((f) => f.name === "vector");
@@ -398,6 +562,11 @@ class VectorDB {
         });
     }
     ensureTable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.withWriteGate(() => this.ensureTableUnsafe());
+        });
+    }
+    ensureTableUnsafe() {
         return __awaiter(this, void 0, void 0, function* () {
             const db = yield this.getDb();
             let table;
@@ -426,7 +595,6 @@ class VectorDB {
             if (!records.length)
                 return;
             this.ensureDiskOk();
-            const table = yield this.ensureTable();
             const toBuffer = (val) => {
                 var _a, _b;
                 if (Buffer.isBuffer(val))
@@ -475,8 +643,7 @@ class VectorDB {
                 if (vec.length !== this.vectorDim) {
                     throw new Error(`Vector dimension mismatch: got ${vec.length}d, expected ${this.vectorDim}d. ` +
                         "The embedding model tier likely changed without a rebuild — the shared " +
-                        `table is fixed-width, so run \`${config_1.REBUILD_COMMAND}\` (a per-project ` +
-                        "`gmax index --reset` cannot change the table width).");
+                        "table is fixed-width. Run `gmax repair --rebuild` to rebuild the whole corpus.");
                 }
                 rec.vector = vec;
                 rec.colbert = toBuffer(rec.colbert);
@@ -510,11 +677,15 @@ class VectorDB {
                 rec.summary = (_r = rec.summary) !== null && _r !== void 0 ? _r : null;
             }
             try {
-                yield this.withWriteGate(() => table.add(records));
+                yield this.withWriteGate(() => __awaiter(this, void 0, void 0, function* () {
+                    const table = yield this.ensureTableUnsafe();
+                    yield table.add(records);
+                }));
             }
             catch (err) {
                 const msg = err instanceof Error ? err.message : String(err);
                 if (msg.toLowerCase().includes("found field not in schema")) {
+                    const table = yield this.ensureTable();
                     const schema = yield table.schema();
                     const schemaFields = schema.fields.map((f) => f.name);
                     throw new Error(`[vector-db] schema mismatch detected (fields: ${schemaFields.join(", ")}). Please run "gmax index --reset" to rebuild the index.`);
@@ -525,7 +696,12 @@ class VectorDB {
     }
     createFTSIndex() {
         return __awaiter(this, arguments, void 0, function* (rebuild = false, retries = 5) {
-            const table = yield this.ensureTable();
+            return this.withWriteGate(() => this.createFTSIndexUnsafe(rebuild, retries));
+        });
+    }
+    createFTSIndexUnsafe() {
+        return __awaiter(this, arguments, void 0, function* (rebuild = false, retries = 5) {
+            const table = yield this.ensureTableUnsafe();
             if (rebuild) {
                 try {
                     yield table.dropIndex("content_idx");
@@ -572,18 +748,26 @@ class VectorDB {
         });
     }
     optimize() {
-        return __awaiter(this, arguments, void 0, function* (retries = 5, retentionMs = 0) {
+        return __awaiter(this, arguments, void 0, function* (retries = 5, retentionMs = 0, bypassExclusiveMutation = false) {
+            if (!bypassExclusiveMutation) {
+                while (this.exclusiveMutationPromise)
+                    yield this.exclusiveMutationPromise;
+                if (this.closed)
+                    throw new Error("VectorDB connection is closed");
+            }
             if (this.compactingPromise) {
                 (0, logger_1.debug)("vectordb", "Optimize already in progress, skipping");
+                yield this.compactingPromise;
                 return;
             }
-            const table = yield this.ensureTable();
-            const cutoff = new Date(Date.now() - retentionMs);
             let resolveCompacting;
-            this.compactingPromise = new Promise((r) => {
-                resolveCompacting = r;
+            this.compactingPromise = new Promise((resolve) => {
+                resolveCompacting = resolve;
             });
+            this.activeCompactions++;
             try {
+                const table = yield this.ensureTableUnsafe();
+                const cutoff = new Date(Date.now() - retentionMs);
                 for (let attempt = 1; attempt <= retries; attempt++) {
                     yield this.drainWrites();
                     try {
@@ -633,6 +817,12 @@ class VectorDB {
             finally {
                 this.compactingPromise = null;
                 resolveCompacting();
+                this.activeCompactions--;
+                if (this.activeCompactions === 0) {
+                    for (const resolve of this.compactionDrainResolvers)
+                        resolve();
+                    this.compactionDrainResolvers.clear();
+                }
             }
         });
     }
@@ -658,11 +848,11 @@ class VectorDB {
                 yield this.createFTSIndex();
                 if (pressure === "low") {
                     (0, logger_1.log)("vectordb", `Low disk — single-pass optimize (no bloat retry)`);
-                    yield this.optimize(1);
+                    yield this.optimize(1, 0, true);
                     return;
                 }
                 // Normal maintenance: full optimize + bloat check
-                yield this.optimize();
+                yield this.optimize(5, 0, true);
                 const table = yield this.ensureTable();
                 const stats = yield table.stats();
                 const diskSize = this.getDirectorySize(this.lancedbDir);
@@ -672,7 +862,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();
+                    yield this.optimize(5, 0, true);
                 }
             }
             finally {
@@ -684,26 +874,24 @@ class VectorDB {
         return __awaiter(this, arguments, void 0, function* (threshold = config_1.FRAGMENT_COMPACT_THRESHOLD) {
             if (this.maintenanceRunning)
                 return false;
-            if (this.checkDiskPressure() !== "ok")
-                return false;
+            this.maintenanceRunning = true;
             try {
+                if (this.checkDiskPressure() !== "ok")
+                    return false;
                 const table = yield this.ensureTable();
                 const stats = yield table.stats();
                 if (stats.fragmentStats.numSmallFragments > threshold) {
                     (0, logger_1.log)("vectordb", `Fragment threshold exceeded (${stats.fragmentStats.numSmallFragments} > ${threshold}) — compacting`);
-                    this.maintenanceRunning = true;
-                    try {
-                        yield this.optimize(2);
-                    }
-                    finally {
-                        this.maintenanceRunning = false;
-                    }
+                    yield this.optimize(2, 0, true);
                     return true;
                 }
             }
             catch (err) {
                 (0, logger_1.debug)("vectordb", `compactIfNeeded check failed: ${err}`);
             }
+            finally {
+                this.maintenanceRunning = false;
+            }
             return false;
         });
     }
@@ -795,10 +983,10 @@ class VectorDB {
             if (!paths.length)
                 return;
             this.ensureDiskOk();
-            const table = yield this.ensureTable();
             const unique = Array.from(new Set(paths));
             const batchSize = 500;
             yield this.withWriteGate(() => __awaiter(this, void 0, void 0, function* () {
+                const table = yield this.ensureTableUnsafe();
                 for (let i = 0; i < unique.length; i += batchSize) {
                     const slice = unique.slice(i, i + batchSize);
                     const values = slice.map((p) => `'${(0, filter_builder_1.escapeSqlString)(p)}'`).join(",");
@@ -821,9 +1009,9 @@ class VectorDB {
         return __awaiter(this, void 0, void 0, function* () {
             if (!ids.length)
                 return;
-            const table = yield this.ensureTable();
             yield this.withWriteGate(() => __awaiter(this, void 0, void 0, function* () {
                 var _a;
+                const table = yield this.ensureTableUnsafe();
                 for (let i = 0; i < ids.length; i++) {
                     const escaped = (0, filter_builder_1.escapeSqlString)(ids[i]);
                     yield table.update({
@@ -839,13 +1027,13 @@ class VectorDB {
             if (!paths.length)
                 return;
             this.ensureDiskOk();
-            const table = yield this.ensureTable();
             const unique = Array.from(new Set(paths));
             const batchSize = 500;
             const idExclusion = excludeIds.length > 0
                 ? ` AND id NOT IN (${excludeIds.map((id) => `'${(0, filter_builder_1.escapeSqlString)(id)}'`).join(",")})`
                 : "";
             yield this.withWriteGate(() => __awaiter(this, void 0, void 0, function* () {
+                const table = yield this.ensureTableUnsafe();
                 for (let i = 0; i < unique.length; i += batchSize) {
                     const slice = unique.slice(i, i + batchSize);
                     const values = slice.map((p) => `'${(0, filter_builder_1.escapeSqlString)(p)}'`).join(",");
@@ -866,36 +1054,59 @@ class VectorDB {
     deletePathsWithPrefix(prefix) {
         return __awaiter(this, void 0, void 0, function* () {
             this.ensureDiskOk();
-            const table = yield this.ensureTable();
             // Slash-terminate so a project root can't bleed into a sibling
             // (`/repo/app` must not delete `/repo/app2`), and use starts_with so `_`/`%`
             // in the path are literal, not LIKE wildcards. Destructive path — keep this
             // self-protective even if a caller forgets to normalize.
             const dirPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
-            yield this.withWriteGate(() => table.delete((0, filter_builder_1.pathStartsWith)(dirPrefix)));
+            yield this.withWriteGate(() => __awaiter(this, void 0, void 0, function* () {
+                const table = yield this.ensureTableUnsafe();
+                yield table.delete((0, filter_builder_1.pathStartsWith)(dirPrefix));
+            }));
         });
     }
     drop() {
         return __awaiter(this, void 0, void 0, function* () {
-            const db = yield this.getDb();
-            try {
-                yield db.dropTable(TABLE_NAME);
-            }
-            catch (_err) {
-                // ignore if missing
-            }
+            yield this.withExclusiveTableMutation((db) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield db.dropTable(TABLE_NAME);
+                }
+                catch (err) {
+                    if (!isMissingTableError(err))
+                        throw err;
+                }
+            }));
         });
     }
     close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (this.closed)
-                return;
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            var _a, _b;
+            if (this.closePromise) {
+                if ((options.requireClosed === true && !this.requireClosedOnClose) ||
+                    (options.releaseLease === false && this.releaseLeaseOnClose)) {
+                    throw new Error("VectorDB close already started with weaker ownership semantics");
+                }
+                return this.closePromise;
+            }
+            this.releaseLeaseOnClose = (_a = options.releaseLease) !== null && _a !== void 0 ? _a : true;
+            this.requireClosedOnClose = (_b = options.requireClosed) !== null && _b !== void 0 ? _b : false;
             this.closed = true;
+            this.closePromise = this.finishClose();
+            return this.closePromise;
+        });
+    }
+    finishClose() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
             if (this.maintenanceTimer) {
                 clearInterval(this.maintenanceTimer);
                 this.maintenanceTimer = null;
             }
+            if (this.exclusiveMutationPromise)
+                yield this.exclusiveMutationPromise;
+            yield this.leaseTransitionTail;
+            yield Promise.all([this.drainWrites(), this.drainCompactions()]);
+            this.leaseAbort.abort();
             // Drain in-flight maintenance before tearing down the connection — otherwise
             // optimize/createIndex will hit a null db and log "VectorDB connection is closed".
             if (this.maintenancePromise) {
@@ -907,15 +1118,49 @@ class VectorDB {
             }
             (_a = this.unregisterCleanup) === null || _a === void 0 ? void 0 : _a.call(this);
             this.unregisterCleanup = undefined;
-            if (this.db) {
-                if (this.db.close) {
-                    yield Promise.race([
-                        this.db.close(),
-                        new Promise((resolve) => setTimeout(resolve, 5000)),
-                    ]);
+            let closeError;
+            if ((_b = this.db) === null || _b === void 0 ? void 0 : _b.close) {
+                try {
+                    const closing = this.db.close();
+                    if (this.requireClosedOnClose)
+                        yield closing;
+                    else {
+                        yield Promise.race([
+                            closing,
+                            new Promise((resolve) => setTimeout(resolve, 5000)),
+                        ]);
+                    }
+                }
+                catch (error) {
+                    closeError = error;
                 }
             }
             this.db = null;
+            if (this.leasePromise) {
+                let lease = null;
+                try {
+                    lease = yield this.leasePromise;
+                }
+                catch (_c) {
+                    this.leasePromise = null;
+                }
+                if (lease) {
+                    try {
+                        if (this.releaseLeaseOnClose)
+                            yield lease.release();
+                        else
+                            lease.relinquish(this.leaseHolder);
+                        this.leasePromise = null;
+                    }
+                    catch (error) {
+                        closeError = closeError
+                            ? new Error(`VectorDB close and store lease release failed: ${String(closeError)}; ${String(error)}`)
+                            : error;
+                    }
+                }
+            }
+            if (closeError)
+                throw closeError;
         });
     }
 }

package/dist/lib/utils/blocked-roots.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BLOCKED_ROOTS_DESCRIPTION = void 0;
+exports.getBlockedProjectRoots = getBlockedProjectRoots;
+exports.isBlockedProjectRoot = isBlockedProjectRoot;
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+exports.BLOCKED_ROOTS_DESCRIPTION = "home, /, /Users, /tmp, /private, /var, /usr, /opt, /etc, /System, /Library, /Applications";
+function getBlockedProjectRoots() {
+    const home = os.homedir();
+    return new Set([
+        home,
+        path.dirname(home),
+        "/",
+        "/tmp",
+        "/private",
+        "/private/tmp",
+        "/private/var",
+        "/var",
+        "/usr",
+        "/opt",
+        "/etc",
+        "/System",
+        "/Library",
+        "/Applications",
+    ].map((candidate) => path.resolve(candidate)));
+}
+function isBlockedProjectRoot(root) {
+    return getBlockedProjectRoots().has(path.resolve(root));
+}