@chiway/contextweaver 1.1.0 → 1.5.0

package/dist/chunk-3BNHQV5W.js

@@ -0,0 +1,373 @@
+// src/vectorStore/index.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import * as lancedb from "@lancedb/lancedb";
+var BASE_DIR = path.join(os.homedir(), ".contextweaver");
+function sampleCheckDisplayCode(oldRows, getContent, options = {}) {
+  const sampleSize = options.sampleSize ?? 100;
+  const maxMismatchRatio = options.maxMismatchRatio ?? 0.01;
+  if (oldRows.length === 0) {
+    return { abort: false, sampled: 0, mismatched: 0, ratio: 0 };
+  }
+  const indices = [];
+  const step = Math.max(1, Math.floor(oldRows.length / sampleSize));
+  for (let i = 0; i < oldRows.length && indices.length < sampleSize; i += step) {
+    indices.push(i);
+  }
+  let sampled = 0;
+  let mismatched = 0;
+  for (const idx of indices) {
+    const r = oldRows[idx];
+    const content = getContent(r.file_path);
+    if (content === null) continue;
+    sampled++;
+    const safeStart = Math.max(0, Math.min(r.start_index, content.length));
+    const safeEnd = Math.max(safeStart, Math.min(r.end_index, content.length));
+    const expected = content.slice(safeStart, safeEnd);
+    if (expected !== r.display_code) {
+      mismatched++;
+    }
+  }
+  const ratio = sampled > 0 ? mismatched / sampled : 0;
+  return { abort: ratio > maxMismatchRatio, sampled, mismatched, ratio };
+}
+var VectorStore = class {
+  db = null;
+  table = null;
+  dbPath;
+  vectorDim;
+  constructor(projectId, vectorDim = 1024, dbPathOverride) {
+    this.dbPath = dbPathOverride ?? path.join(BASE_DIR, projectId, "vectors.lance");
+    this.vectorDim = vectorDim;
+  }
+  /**
+   * 初始化连接
+   */
+  async init() {
+    if (this.db) return;
+    const parent = path.dirname(this.dbPath);
+    if (!fs.existsSync(parent)) {
+      fs.mkdirSync(parent, { recursive: true });
+    }
+    this.db = await lancedb.connect(this.dbPath);
+    const tableNames = await this.db.tableNames();
+    if (tableNames.includes("chunks")) {
+      this.table = await this.db.openTable("chunks");
+    }
+  }
+  /**
+   * 确保表存在（首次插入时调用）
+   */
+  async ensureTable(records) {
+    if (this.table) return;
+    if (!this.db) throw new Error("VectorStore not initialized");
+    if (records.length === 0) return;
+    this.table = await this.db.createTable(
+      "chunks",
+      records
+    );
+  }
+  /**
+   * C2 迁移：移除 chunks 表中的 display_code / vector_text 列
+   *
+   * LanceDB 不支持 ALTER DROP COLUMN，方案为 dropTable + recreate：
+   * 1. 读取所有现有 chunks，仅保留新 schema 字段（含 raw_start/raw_end 用于回查正文）
+   * 2. 抽样校验：display_code vs files.content.slice(raw_start, raw_end)
+   *    差异比例 > sampleMaxMismatchRatio 则中止迁移
+   * 3. drop chunks 表 + 用新 schema 重建
+   *
+   * 幂等：若表中已无 display_code 列，直接返回。
+   *
+   * @returns 迁移摘要；migrated=false 表示无需迁移或被中止
+   */
+  /**
+   * 检测 chunks 表是否含 display_code 列（H3：纯 vector 操作）
+   *
+   * 返回值：
+   * - true: 表存在且含 display_code（需要迁移）
+   * - false: 表存在但不含 display_code（已迁移）
+   * - null: 表不存在（全新库 / 已 drop）
+   */
+  async hasDisplayCodeColumn() {
+    if (!this.table) return null;
+    const schema = await this.table.schema();
+    return schema.fields.some((f) => f.name === "display_code");
+  }
+  /**
+   * 读取全表（H3：纯 vector 操作，供 bootstrap 模块抽样校验使用）
+   */
+  async readAllRowsRaw() {
+    if (!this.table) return [];
+    return await this.table.query().toArray();
+  }
+  /**
+   * Drop chunks 表并用新 schema 重建（H3：纯 vector 操作）
+   *
+   * 调用方需保证：传入的 newRows 已剥离 display_code/vector_text 字段。
+   * 崩溃恢复语义由 bootstrap 模块的 state machine 负责。
+   */
+  async dropAndRecreateChunks(newRows) {
+    if (!this.db) throw new Error("VectorStore not initialized");
+    await this.db.dropTable("chunks");
+    this.table = null;
+    if (newRows.length > 0) {
+      this.table = await this.db.createTable("chunks", newRows);
+    }
+  }
+  /**
+   * 单调版本更新：先插入新版本，再删除旧版本
+   *
+   * 这保证了：
+   * - 最坏情况（崩溃）是新旧版本共存（不缺失）
+   * - 正常情况下旧版本被清理
+   */
+  async upsertFile(filePath, newHash, records) {
+    if (!this.db) throw new Error("VectorStore not initialized");
+    if (records.length === 0) {
+      await this.deleteFile(filePath);
+      return;
+    }
+    if (!this.table) {
+      await this.ensureTable(records);
+    } else {
+      await this.table.add(records);
+    }
+    if (this.table) {
+      await this.table.delete(
+        `file_path = '${this.escapeString(filePath)}' AND file_hash != '${this.escapeString(newHash)}'`
+      );
+    }
+  }
+  /**
+   * 批量 upsert 多个文件（性能优化版，带分批机制）
+   *
+   * 流程：
+   * 1. 将文件分成小批次（每批最多 BATCH_FILES 个文件或 BATCH_RECORDS 条记录）
+   * 2. 每批执行：插入新 records → 删除旧版本
+   *
+   * 分批是必要的，因为 LanceDB native 模块在处理超大数据时可能崩溃
+   *
+   * @param files 文件列表，每个包含 path、hash 和 records
+   */
+  async batchUpsertFiles(files) {
+    if (!this.db) throw new Error("VectorStore not initialized");
+    if (files.length === 0) return;
+    const BATCH_FILES = 50;
+    const BATCH_RECORDS = 5e3;
+    const batches = [];
+    let currentBatch = [];
+    let currentRecordCount = 0;
+    for (const file of files) {
+      if (currentBatch.length >= BATCH_FILES || currentRecordCount + file.records.length > BATCH_RECORDS) {
+        if (currentBatch.length > 0) {
+          batches.push(currentBatch);
+        }
+        currentBatch = [];
+        currentRecordCount = 0;
+      }
+      currentBatch.push(file);
+      currentRecordCount += file.records.length;
+    }
+    if (currentBatch.length > 0) {
+      batches.push(currentBatch);
+    }
+    for (const batch of batches) {
+      const batchRecords = [];
+      for (const file of batch) {
+        batchRecords.push(...file.records);
+      }
+      if (batchRecords.length === 0) {
+        const pathsToDelete = batch.map((f) => f.path);
+        await this.deleteFiles(pathsToDelete);
+        continue;
+      }
+      if (this.table && batch.length > 0) {
+        await this.deleteFilesByHash(batch.map((f) => ({ path: f.path, hash: f.hash })));
+      }
+      if (!this.table) {
+        await this.ensureTable(batchRecords);
+      } else {
+        await this.table.add(batchRecords);
+      }
+      if (this.table && batch.length > 0) {
+        const deleteConditions = batch.map(
+          (f) => `(file_path = '${this.escapeString(f.path)}' AND file_hash != '${this.escapeString(f.hash)}')`
+        ).join(" OR ");
+        await this.table.delete(deleteConditions);
+      }
+    }
+  }
+  /**
+   * 列出所有 chunks 的 (file_path, file_hash) 唯一组合
+   *
+   * 用于 GC 阶段对比 SQLite 权威数据，识别孤儿 chunks。
+   * 性能优化：仅 select 两列，按 (path, hash) 去重后返回。
+   */
+  async listFileHashes() {
+    if (!this.table) return [];
+    const rows = await this.table.query().select(["file_path", "file_hash"]).toArray();
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const r of rows) {
+      const key = `${r.file_path}\0${r.file_hash}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        result.push({ path: r.file_path, hash: r.file_hash });
+      }
+    }
+    return result;
+  }
+  /**
+   * 删除文件的所有 chunks
+   */
+  async deleteFile(filePath) {
+    if (!this.table) return;
+    await this.table.delete(`file_path = '${this.escapeString(filePath)}'`);
+  }
+  /**
+   * 按 (file_path, file_hash) 精确删除 chunks
+   *
+   * 用于事务补偿：当下游写入（如 FTS）失败时，反向删除已 upsert 的新版本，
+   * 保留旧版本不动，确保 vector_index_hash 仍指向旧 hash 时 LanceDB 状态一致。
+   */
+  async deleteFilesByHash(items) {
+    if (!this.table || items.length === 0) return;
+    const BATCH_SIZE = 500;
+    for (let i = 0; i < items.length; i += BATCH_SIZE) {
+      const batch = items.slice(i, i + BATCH_SIZE);
+      const conditions = batch.map(
+        (it) => `(file_path = '${this.escapeString(it.path)}' AND file_hash = '${this.escapeString(it.hash)}')`
+      ).join(" OR ");
+      await this.table.delete(conditions);
+    }
+  }
+  /**
+   * 批量删除文件（性能优化：单次 DELETE 替代 N 次循环）
+   * 当文件数超过 500 时分批处理，防止 LanceDB filter 字符串过长
+   */
+  async deleteFiles(filePaths) {
+    if (!this.table || filePaths.length === 0) return;
+    const BATCH_SIZE = 500;
+    if (filePaths.length <= BATCH_SIZE) {
+      const conditions = filePaths.map((p) => `file_path = '${this.escapeString(p)}'`).join(" OR ");
+      await this.table.delete(conditions);
+    } else {
+      for (let i = 0; i < filePaths.length; i += BATCH_SIZE) {
+        const batch = filePaths.slice(i, i + BATCH_SIZE);
+        const conditions = batch.map((p) => `file_path = '${this.escapeString(p)}'`).join(" OR ");
+        await this.table.delete(conditions);
+      }
+    }
+  }
+  /**
+   * 向量搜索
+   */
+  async search(queryVector, limit = 10, filter) {
+    if (!this.table) return [];
+    let query = this.table.vectorSearch(queryVector).limit(limit);
+    if (filter) {
+      query = query.where(filter);
+    }
+    const results = await query.toArray();
+    return results;
+  }
+  /**
+   * 获取文件的所有 chunks（按 chunk_index 排序）
+   */
+  async getFileChunks(filePath) {
+    if (!this.table) return [];
+    const results = await this.table.query().where(`file_path = '${this.escapeString(filePath)}'`).toArray();
+    const chunks = results;
+    return chunks.sort((a, b) => a.chunk_index - b.chunk_index);
+  }
+  /**
+   * 批量获取多个文件的 chunks（性能优化：单次查询替代 N 次循环）
+   * 当文件数超过 500 时分批处理，防止 LanceDB filter 字符串过长
+   *
+   * 适用于 GraphExpander 扩展、词法召回等需要批量获取的场景
+   * @returns Map<filePath, ChunkRecord[]>，每个文件的 chunks 已按 chunk_index 排序
+   */
+  async getFilesChunks(filePaths) {
+    const result = /* @__PURE__ */ new Map();
+    if (!this.table || filePaths.length === 0) return result;
+    const BATCH_SIZE = 500;
+    for (let i = 0; i < filePaths.length; i += BATCH_SIZE) {
+      const batch = filePaths.slice(i, i + BATCH_SIZE);
+      const conditions = batch.map((p) => `file_path = '${this.escapeString(p)}'`).join(" OR ");
+      const rows = await this.table.query().where(conditions).toArray();
+      for (const row of rows) {
+        let arr = result.get(row.file_path);
+        if (!arr) {
+          arr = [];
+          result.set(row.file_path, arr);
+        }
+        arr.push(row);
+      }
+    }
+    for (const arr of result.values()) {
+      arr.sort((a, b) => a.chunk_index - b.chunk_index);
+    }
+    return result;
+  }
+  /**
+   * 获取表的总记录数
+   */
+  async count() {
+    if (!this.table) return 0;
+    return await this.table.countRows();
+  }
+  /**
+   * 清空所有数据
+   */
+  async clear() {
+    if (!this.db) return;
+    try {
+      await this.db.dropTable("chunks");
+      this.table = null;
+    } catch {
+    }
+  }
+  /**
+   * 获取向量维度
+   */
+  getVectorDim() {
+    return this.vectorDim;
+  }
+  /**
+   * 转义字符串（防止 SQL 注入）
+   */
+  escapeString(str) {
+    return str.replace(/'/g, "''");
+  }
+  /**
+   * 关闭连接
+   */
+  async close() {
+    this.db = null;
+    this.table = null;
+  }
+};
+var vectorStores = /* @__PURE__ */ new Map();
+async function getVectorStore(projectId, vectorDim = 1024) {
+  let store = vectorStores.get(projectId);
+  if (!store) {
+    store = new VectorStore(projectId, vectorDim);
+    await store.init();
+    vectorStores.set(projectId, store);
+  }
+  return store;
+}
+async function closeAllVectorStores() {
+  for (const store of vectorStores.values()) {
+    await store.close();
+  }
+  vectorStores.clear();
+}
+
+export {
+  sampleCheckDisplayCode,
+  VectorStore,
+  getVectorStore,
+  closeAllVectorStores
+};

package/dist/chunk-BFCIZ52F.js

@@ -0,0 +1,102 @@
+// src/search/config.ts
+var SEARCH_CONFIG_BOUNDS = {
+  vectorTopK: { min: 40, max: 200, integer: true },
+  vectorTopM: { min: 30, max: 100, integer: true },
+  ftsTopKFiles: { min: 10, max: 50, integer: true },
+  lexChunksPerFile: { min: 1, max: 5, integer: true },
+  lexTotalChunks: { min: 20, max: 80, integer: true },
+  rrfK0: { min: 10, max: 60, integer: true },
+  wVec: { min: 0, max: 1, integer: false },
+  wLex: { min: 0, max: 1, integer: false },
+  fusedTopM: { min: 30, max: 100, integer: true },
+  rerankTopN: { min: 5, max: 20, integer: true },
+  maxRerankChars: { min: 500, max: 2e3, integer: true },
+  maxBreadcrumbChars: { min: 100, max: 500, integer: true },
+  headRatio: { min: 0.5, max: 0.8, integer: false },
+  neighborHops: { min: 1, max: 3, integer: true },
+  breadcrumbExpandLimit: { min: 1, max: 5, integer: true },
+  importFilesPerSeed: { min: 0, max: 5, integer: true },
+  chunksPerImportFile: { min: 1, max: 5, integer: true },
+  decayNeighbor: { min: 0.5, max: 0.9, integer: false },
+  decayBreadcrumb: { min: 0.4, max: 0.8, integer: false },
+  decayImport: { min: 0.3, max: 0.7, integer: false },
+  decayDepth: { min: 0.5, max: 0.9, integer: false },
+  maxSegmentsPerFile: { min: 1, max: 5, integer: true },
+  maxTotalChars: { min: 2e4, max: 8e4, integer: true },
+  smartTopScoreRatio: { min: 0.3, max: 0.7, integer: false },
+  smartTopScoreDeltaAbs: { min: 0.1, max: 0.4, integer: false },
+  smartMinScore: { min: 0.1, max: 0.4, integer: false },
+  smartMinK: { min: 1, max: 3, integer: true },
+  smartMaxK: { min: 5, max: 15, integer: true }
+};
+var DEFAULT_CONFIG = {
+  // ── Recall (向量 + 词法召回) ──
+  vectorTopK: 80,
+  // Vector ANN candidates before dedup. Range: 40–200. Higher = better recall, more compute.
+  vectorTopM: 60,
+  // Vectors kept after dedup. Range: 30–100.
+  ftsTopKFiles: 20,
+  // Max files returned by FTS5 full-text search. Range: 10–50.
+  lexChunksPerFile: 2,
+  // Chunks to pull per FTS-matched file. Range: 1–5. Low keeps diversity across files.
+  lexTotalChunks: 40,
+  // Hard cap on total lexical chunks. Range: 20–80.
+  // ── RRF Fusion (向量 + 词法分数融合) ──
+  rrfK0: 20,
+  // RRF smoothing constant. Range: 10–60. Lower amplifies top ranks.
+  wVec: 0.6,
+  // Vector weight in fused score. Range: 0.3–0.8. Semantic relevance emphasis.
+  wLex: 0.4,
+  // Lexical weight in fused score. wVec + wLex should equal 1.0.
+  fusedTopM: 60,
+  // Candidates after fusion, fed into reranker. Range: 30–100.
+  // ── Rerank (精排) ──
+  rerankTopN: 10,
+  // Final top-N results after reranking. Range: 5–20.
+  maxRerankChars: 1e3,
+  // Max chars per chunk sent to reranker. Truncated beyond this. Range: 500–2000.
+  maxBreadcrumbChars: 250,
+  // Max chars for breadcrumb context in rerank input. Range: 100–500.
+  headRatio: 0.67,
+  // Ratio of head vs tail when truncating chunks. Range: 0.5–0.8.
+  // ── Expansion (上下文扩展: E1 邻居 / E2 面包屑 / E3 跨文件导入) ──
+  neighborHops: 2,
+  // E1: How many sibling chunks to expand in each direction. Range: 1–3.
+  breadcrumbExpandLimit: 3,
+  // E2: Max ancestor breadcrumbs (class/function scope). Range: 1–5.
+  importFilesPerSeed: 3,
+  // E3: Cross-file import files to resolve per seed chunk. Range: 0–5. Set to 3 to enable import-graph expansion for better cross-file context.
+  chunksPerImportFile: 3,
+  // E3: Chunks to pull from each resolved import file. Range: 1–5. Set to 3 for balanced coverage of imported symbols.
+  decayNeighbor: 0.8,
+  // Score decay per E1 hop. Range: 0.5–0.9. Higher = neighbors stay relevant longer.
+  decayBreadcrumb: 0.7,
+  // Score decay per E2 level. Range: 0.4–0.8.
+  decayImport: 0.6,
+  // Score decay for E3 import chunks. Range: 0.3–0.7. Lower than E1/E2 since cross-file is less certain.
+  decayDepth: 0.7,
+  // General depth decay multiplier. Range: 0.5–0.9.
+  // ── ContextPacker (上下文打包) ──
+  maxSegmentsPerFile: 3,
+  // Max non-contiguous segments per file in output. Range: 1–5. Prevents excessive fragmentation.
+  maxTotalChars: 48e3,
+  // Token budget expressed as chars (~12k tokens). Range: 20000–80000.
+  // ── Smart TopK (动态结果数量) ──
+  enableSmartTopK: true,
+  // Dynamically adjust result count based on score distribution.
+  smartTopScoreRatio: 0.5,
+  // Min score as ratio of top-1 score to remain included. Range: 0.3–0.7.
+  smartTopScoreDeltaAbs: 0.25,
+  // Max absolute score drop from top-1 before cutting off. Range: 0.1–0.4.
+  smartMinScore: 0.25,
+  // Hard floor: chunks below this score are always excluded. Range: 0.1–0.4.
+  smartMinK: 2,
+  // Minimum results to return regardless of scores. Range: 1–3.
+  smartMaxK: 8
+  // Maximum results when smart topK is active. Range: 5–15.
+};
+
+export {
+  SEARCH_CONFIG_BOUNDS,
+  DEFAULT_CONFIG
+};

package/dist/{chunk-NQR4CGQ6.js → chunk-GDVB6PJ4.js}

@@ -1,9 +1,11 @@
 import {
   closeAllIndexers,
-  closeAllVectorStores,
   getIndexer,
   invalidateAllExpanderCaches
-} from "./chunk-6QMYML5V.js";
+} from "./chunk-XMZZZKG7.js";
+import {
+  closeAllVectorStores
+} from "./chunk-3BNHQV5W.js";
 import {
   batchDelete,
   batchUpdateMtime,
@@ -15,16 +17,19 @@ import {
   getAllPaths,
   getFilesNeedingVectorIndex,
   getStoredEmbeddingDimensions,
+  incrementIndexVersion,
+  incrementStat,
   initDb,
+  setStatJson,
   setStoredEmbeddingDimensions
-} from "./chunk-6Z4JEEVJ.js";
+} from "./chunk-PPLFJGO3.js";
 import {
   logger
-} from "./chunk-AMQQK4P7.js";
+} from "./chunk-JVKVSTQ3.js";
 import {
   getEmbeddingConfig,
   getExcludePatterns
-} from "./chunk-RJURH22T.js";
+} from "./chunk-SKBAE26T.js";
 
 // src/scanner/index.ts
 import path3 from "path";
@@ -523,6 +528,19 @@ var SourceAdapter = class {
   /**
    * 将字节偏移转换为字符偏移
    */
+  /**
+   * 将 tree-sitter 返回的偏移（可能是 UTF-8 字节或 UTF-16 字符域）
+   * 标准化为 UTF-16 字符域偏移。下游 String.prototype.slice 直接可用。
+   *
+   * 导出供 SemanticSplitter 在生成 ChunkMetadata 时统一域。
+   */
+  toCharOffset(offset) {
+    if (this.domain === "utf16" || this.domain === "unknown") return offset;
+    return this.byteToChar(offset);
+  }
+  /**
+   * 将字节偏移转换为字符偏移（仅 utf8 域有效；utf16/unknown 直接返回原值）
+   */
   byteToChar(byteOffset) {
     if (!this.byteToCharMap) return byteOffset;
     const safeOffset = Math.max(0, Math.min(this.byteToCharMap.length - 1, byteOffset));
@@ -915,11 +933,12 @@ ${displayCode}`,
       const vectorEnd = end;
       const displayCode = this.adapter.slice(start, end);
       const vectorCode = this.adapter.slice(vectorStart, vectorEnd);
+      const toChar = (n) => this.adapter.toCharOffset(n);
       const metadata = {
-        startIndex: start,
-        endIndex: end,
-        rawSpan: { start: prevEnd, end: rawSpanEnd },
-        vectorSpan: { start: vectorStart, end: vectorEnd },
+        startIndex: toChar(start),
+        endIndex: toChar(end),
+        rawSpan: { start: toChar(prevEnd), end: toChar(rawSpanEnd) },
+        vectorSpan: { start: toChar(vectorStart), end: toChar(vectorEnd) },
         filePath,
         language,
         contextPath: w.contextPath
@@ -1351,6 +1370,34 @@ async function scan(rootPath, options = {}) {
       }
     }
     options.onProgress?.(100, 100, "\u7D22\u5F15\u5B8C\u6210");
+    if (options.vectorIndex !== false) {
+      try {
+        const embeddingConfig = getEmbeddingConfig();
+        const indexer = await getIndexer(projectId, embeddingConfig.dimensions);
+        const gcResult = await indexer.gc(db);
+        if (gcResult.orphans > 0) {
+          logger.info({ orphans: gcResult.orphans }, "GC \u5B8C\u6210");
+        } else if (gcResult.truncated) {
+          logger.debug("GC \u8D85\u65F6\u8DF3\u8FC7\uFF0C\u4E0B\u6B21\u626B\u63CF\u91CD\u8BD5");
+        }
+      } catch (err) {
+        const error = err;
+        logger.warn({ error: error.message }, "GC \u8DF3\u8FC7");
+      }
+    }
+    const didWork = stats.added + stats.modified + stats.deleted > 0;
+    if (didWork) {
+      incrementIndexVersion(db);
+    }
+    try {
+      if (didWork) {
+        incrementStat(db, "stats.index.total_runs");
+      }
+      setStatJson(db, "stats.index.last_run_json", stats);
+      setStatJson(db, "stats.index.last_run_at", Date.now());
+    } catch (err) {
+      logger.warn({ error: err.message }, "\u7D22\u5F15\u7EDF\u8BA1\u57CB\u70B9\u5931\u8D25");
+    }
     invalidateAllExpanderCaches();
     return stats;
   } finally {
@@ -1361,6 +1408,7 @@ async function scan(rootPath, options = {}) {
 }
 
 export {
+  initFilter,
+  isFiltered,
   scan
 };
-//# sourceMappingURL=chunk-NQR4CGQ6.js.map

package/dist/{lock-DVY3KJSK.js → chunk-HHYPQA3X.js}

@@ -1,7 +1,6 @@
 import {
   logger
-} from "./chunk-AMQQK4P7.js";
-import "./chunk-RJURH22T.js";
+} from "./chunk-JVKVSTQ3.js";
 
 // src/utils/lock.ts
 import fs from "fs";
@@ -122,7 +121,7 @@ async function withLock(projectId, operation, fn, timeoutMs = 3e4) {
     releaseLock(projectId);
   }
 }
+
 export {
   withLock
 };
-//# sourceMappingURL=lock-DVY3KJSK.js.map