@lzehrung/codegraph 2.1.0 → 2.1.2

package/dist/bin/queryIndexWorker.js

@@ -3,7 +3,7 @@ const require = __codegraphCreateRequire(import.meta.url);
 
 
 // dist/agent/query-index/content.js
-import fs4 from "node:fs/promises";
+import fs5 from "node:fs/promises";
 import { brotliCompressSync, constants as zlibConstants } from "node:zlib";
 
 // dist/languages/queryGenerator.js
@@ -528,6 +528,27 @@ var JAVASCRIPT_DEF = {
 };
 registerLanguage(JAVASCRIPT_DEF);
 
+// dist/util/identifiers.js
+function hasNonAsciiCodePoint(value, includeC0Controls = false) {
+  for (const character of value) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint > 127 || includeC0Controls && codePoint <= 31)
+      return true;
+  }
+  return false;
+}
+var ECMASCRIPT_IDENTIFIER_SOURCE = String.raw`[$_\p{ID_Start}](?:[$_\p{ID_Continue}]|\u200c|\u200d)*`;
+var DUPLICATE_TOKENIZER_IDENTIFIER_SOURCE = String.raw`[$_\p{XID_Start}\u1885\u1886\u2118\u212E\u309B\u309C](?:[$_\p{XID_Continue}\u00B7\u0387\u1369-\u1371\u19DA\u200C\u200D\u1885\u1886\u2118\u212E\u309B\u309C])*`;
+var BLOOM_FILTER_IDENTIFIER_SOURCE = String.raw`[A-Za-z0-9_$\u0000-\u0008\u000E-\u001B\u007F-\u009F\u200C\u200D\u0080-\u{10FFFF}]+`;
+var XID_IDENTIFIER_SOURCE = String.raw`[_\p{XID_Start}][_\p{XID_Continue}]*`;
+var PHP_IDENTIFIER_SOURCE = String.raw`[A-Za-z_\u{80}-\u{10FFFF}][A-Za-z0-9_\u{80}-\u{10FFFF}]*`;
+var JAVA_IDENTIFIER_IGNORABLE_SOURCE = String.raw`\p{Cf}\u0000-\u0008\u000E-\u001B\u007F-\u009F`;
+var CSHARP_IDENTIFIER_FORMAT_SOURCE = String.raw`\p{Cf}`;
+var JAVA_IDENTIFIER_SOURCE = String.raw`[\p{L}\p{Nl}\p{Sc}\p{Pc}][\p{L}\p{Nl}\p{Sc}\p{Pc}\p{Nd}\p{Mn}\p{Mc}${JAVA_IDENTIFIER_IGNORABLE_SOURCE}]*`;
+var CSHARP_IDENTIFIER_SOURCE = String.raw`@?[\p{L}\p{Nl}_][\p{L}\p{Nl}_\p{Nd}\p{Pc}\p{Mn}\p{Mc}${CSHARP_IDENTIFIER_FORMAT_SOURCE}]*`;
+var GO_IDENTIFIER_SOURCE = String.raw`[\p{L}_][\p{L}\p{Nd}_]*`;
+var KOTLIN_IDENTIFIER_SOURCE = String.raw`[\p{L}_][\p{L}\p{Nd}_]*`;
+
 // dist/languages/definitions/python.js
 var PYTHON_DEF = {
   id: "python",
@@ -654,7 +675,8 @@ var PYTHON_DEF = {
   createsBlockScope: (n) => n.type === "module" || n.type === "block",
   createsFunctionScope: (n) => n.type === "function_definition" || n.type === "lambda",
   membersAreImplicitlyInScope: false,
-  supportsCrossModuleSymbols: true
+  supportsCrossModuleSymbols: true,
+  normalizeIdentifier: (name) => hasNonAsciiCodePoint(name) ? name.normalize("NFKC") : name
 };
 registerLanguage(PYTHON_DEF);
 
@@ -1272,6 +1294,7 @@ var GO_DEF = {
 registerLanguage(GO_DEF);
 
 // dist/languages/definitions/java.js
+var JAVA_IDENTIFIER_IGNORABLE_PATTERN = new RegExp(`[${JAVA_IDENTIFIER_IGNORABLE_SOURCE}]`, "gu");
 var JAVA_DEF = {
   id: "java",
   extensions: [".java"],
@@ -1390,11 +1413,13 @@ var JAVA_DEF = {
     if (p.type === "formal_parameter" && p.childForFieldName("name")?.id === node.id)
       return true;
     return false;
-  }
+  },
+  normalizeIdentifier: (name) => hasNonAsciiCodePoint(name, true) ? name.replace(JAVA_IDENTIFIER_IGNORABLE_PATTERN, "") : name
 };
 registerLanguage(JAVA_DEF);
 
 // dist/languages/definitions/csharp.js
+var CSHARP_IDENTIFIER_FORMAT_PATTERN = new RegExp(`[${CSHARP_IDENTIFIER_FORMAT_SOURCE}]`, "gu");
 var CSHARP_DEF = {
   id: "csharp",
   extensions: [".cs"],
@@ -1515,6 +1540,10 @@ var CSHARP_DEF = {
     if (p.type === "declaration_pattern" && p.childForFieldName("name")?.id === node.id)
       return true;
     return false;
+  },
+  normalizeIdentifier: (name) => {
+    const withoutVerbatimPrefix = name.startsWith("@") ? name.slice(1) : name;
+    return hasNonAsciiCodePoint(withoutVerbatimPrefix) ? withoutVerbatimPrefix.replace(CSHARP_IDENTIFIER_FORMAT_PATTERN, "") : withoutVerbatimPrefix;
   }
 };
 registerLanguage(CSHARP_DEF);
@@ -1660,7 +1689,8 @@ var RUST_DEF = {
     if (p.type === "parameter" && p.childForFieldName("pattern")?.id === node.id)
       return true;
     return false;
-  }
+  },
+  normalizeIdentifier: (name) => hasNonAsciiCodePoint(name) ? name.normalize("NFC") : name
 };
 registerLanguage(RUST_DEF);
 
@@ -2648,10 +2678,11 @@ function stringifyUnknown(value) {
 }
 
 // dist/native/bindingLoader.js
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 import path4 from "node:path";
 
 // dist/util/paths.js
+import fs2, {} from "node:fs";
 import fsp from "node:fs/promises";
 import path2 from "node:path";
 
@@ -2659,6 +2690,19 @@ import path2 from "node:path";
 function errorMessage(error) {
   if (error instanceof Error)
     return error.message;
+  if (typeof error === "string")
+    return error;
+  if (error === null || error === void 0)
+    return String(error);
+  if (typeof error === "object") {
+    try {
+      const serialized = JSON.stringify(error);
+      if (serialized)
+        return serialized;
+    } catch {
+      return String(error);
+    }
+  }
   return String(error);
 }
 
@@ -2735,7 +2779,9 @@ function isRelativeToRoot(normalizedRoot, normalizedFile) {
 function isFilePathWithinRoot(projectRoot, filePath) {
   const normalizedRoot = normalizePath(resolveComparableProjectRoot(projectRoot));
   const normalizedFile = normalizePath(resolveFilePathFromRoot(normalizedRoot, filePath));
-  return isRelativeToRoot(normalizedRoot, normalizedFile);
+  if (isRelativeToRoot(normalizedRoot, normalizedFile))
+    return true;
+  return windowsAliasRelativePath(normalizedRoot, normalizedFile) !== null;
 }
 function assertFilePathWithinRoot(projectRoot, filePath, label = "File") {
   const normalizedRoot = normalizePath(resolveComparableProjectRoot(projectRoot));
@@ -2745,10 +2791,42 @@ function assertFilePathWithinRoot(projectRoot, filePath, label = "File") {
   }
   return normalizedFile;
 }
+function windowsAliasRelativePath(normalizedRoot, normalizedFile) {
+  if (process.platform !== "win32")
+    return null;
+  if (!isWindowsQualifiedAbsolutePath(normalizedRoot) || !isWindowsQualifiedAbsolutePath(normalizedFile)) {
+    return null;
+  }
+  try {
+    const realRoot = fs2.realpathSync.native(normalizedRoot);
+    const realFile = fs2.realpathSync.native(normalizedFile);
+    const directRelativePath = path2.win32.relative(realRoot, realFile);
+    if (!directRelativePath.startsWith("..") && !path2.win32.isAbsolute(directRelativePath)) {
+      return normalizePath(directRelativePath);
+    }
+    const rootStat = fs2.statSync(realRoot, { bigint: true });
+    let ancestorPath = realFile;
+    while (true) {
+      const ancestorStat = fs2.statSync(ancestorPath, { bigint: true });
+      if (sameWindowsDirectoryIdentity(rootStat, ancestorStat)) {
+        return normalizePath(path2.win32.relative(ancestorPath, realFile));
+      }
+      const parentPath = path2.dirname(ancestorPath);
+      if (parentPath === ancestorPath)
+        return null;
+      ancestorPath = parentPath;
+    }
+  } catch {
+    return null;
+  }
+}
+function sameWindowsDirectoryIdentity(left, right) {
+  return left.ino !== 0n && left.dev === right.dev && left.ino === right.ino && left.birthtimeNs === right.birthtimeNs;
+}
 
 // dist/native/runtimeCache.js
 import { createHash, randomBytes } from "node:crypto";
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import path3 from "node:path";
 var CACHE_SCHEMA_VERSION = 1;
 var HASH_BUFFER_SIZE = 1024 * 1024;
@@ -2768,7 +2846,7 @@ function assertSafeCacheSegment(value, label) {
   }
 }
 function assertSafePathComponent(componentPath) {
-  const stats = fs2.lstatSync(componentPath);
+  const stats = fs3.lstatSync(componentPath);
   if (!stats.isDirectory() || stats.isSymbolicLink()) {
     throw new Error(`unsafe native cache path component: ${componentPath}`);
   }
@@ -2788,7 +2866,7 @@ function prepareSafeDirectory(directoryPath) {
         throw error;
       }
       try {
-        fs2.mkdirSync(current);
+        fs3.mkdirSync(current);
       } catch (mkdirError) {
         if (mkdirError.code !== "EEXIST")
           throw mkdirError;
@@ -2796,7 +2874,7 @@ function prepareSafeDirectory(directoryPath) {
       assertSafePathComponent(current);
     }
   }
-  return fs2.realpathSync.native(absolute);
+  return fs3.realpathSync.native(absolute);
 }
 function resolveProductionCacheRoot() {
   const localAppData = process.env.LOCALAPPDATA;
@@ -2806,17 +2884,17 @@ function resolveProductionCacheRoot() {
   return path3.join(localAppData, "codegraph", "native-cache", `v${CACHE_SCHEMA_VERSION}`);
 }
 function hashFileStreaming(filePath, onChunk) {
-  const before = fs2.statSync(filePath);
+  const before = fs3.statSync(filePath);
   if (!before.isFile() || before.size <= 0) {
     throw new Error(`native binary is not a non-empty regular file: ${filePath}`);
   }
   const hash = createHash("sha256");
   const buffer = Buffer.allocUnsafe(HASH_BUFFER_SIZE);
-  const descriptor = fs2.openSync(filePath, "r");
+  const descriptor = fs3.openSync(filePath, "r");
   let size = 0;
   try {
     while (true) {
-      const bytesRead = fs2.readSync(descriptor, buffer, 0, buffer.length, null);
+      const bytesRead = fs3.readSync(descriptor, buffer, 0, buffer.length, null);
       if (!bytesRead)
         break;
       hash.update(buffer.subarray(0, bytesRead));
@@ -2824,7 +2902,7 @@ function hashFileStreaming(filePath, onChunk) {
       onChunk?.(bytesRead);
     }
   } finally {
-    fs2.closeSync(descriptor);
+    fs3.closeSync(descriptor);
   }
   if (size !== before.size) {
     throw new Error(`native binary changed while hashing: ${filePath}`);
@@ -2835,32 +2913,32 @@ function randomSuffix() {
   return `${process.pid}.${randomBytes(8).toString("hex")}`;
 }
 function copyFileExclusive(sourcePath, destinationPath) {
-  const source = fs2.openSync(sourcePath, "r");
+  const source = fs3.openSync(sourcePath, "r");
   let destination;
   const buffer = Buffer.allocUnsafe(HASH_BUFFER_SIZE);
   try {
-    destination = fs2.openSync(destinationPath, "wx");
+    destination = fs3.openSync(destinationPath, "wx");
     while (true) {
-      const bytesRead = fs2.readSync(source, buffer, 0, buffer.length, null);
+      const bytesRead = fs3.readSync(source, buffer, 0, buffer.length, null);
       if (!bytesRead)
         break;
       let written = 0;
       while (written < bytesRead) {
-        written += fs2.writeSync(destination, buffer, written, bytesRead - written);
+        written += fs3.writeSync(destination, buffer, written, bytesRead - written);
       }
     }
-    fs2.fsyncSync(destination);
+    fs3.fsyncSync(destination);
   } finally {
     if (destination !== void 0)
-      fs2.closeSync(destination);
-    fs2.closeSync(source);
+      fs3.closeSync(destination);
+    fs3.closeSync(source);
   }
 }
 function removeRegularTemporaryFile(filePath) {
   try {
-    const stats = fs2.lstatSync(filePath);
+    const stats = fs3.lstatSync(filePath);
     if (stats.isFile() && !stats.isSymbolicLink())
-      fs2.unlinkSync(filePath);
+      fs3.unlinkSync(filePath);
   } catch {
   }
 }
@@ -2874,7 +2952,7 @@ function verifyFile(filePath, expected) {
 }
 function publishExclusive(temporaryPath, finalPath) {
   try {
-    fs2.linkSync(temporaryPath, finalPath);
+    fs3.linkSync(temporaryPath, finalPath);
     return true;
   } catch (error) {
     if (error.code === "EEXIST")
@@ -2899,21 +2977,21 @@ function populateBinary(sourcePath, finalPath, expected) {
 }
 function recoverCorruptFinal(finalPath) {
   const recoveryPath = `${finalPath}.corrupt.${randomSuffix()}`;
-  fs2.renameSync(finalPath, recoveryPath);
+  fs3.renameSync(finalPath, recoveryPath);
 }
 function writeManifest(entryPath, manifest) {
   const finalPath = path3.join(entryPath, "manifest.json");
-  if (fs2.existsSync(finalPath))
+  if (fs3.existsSync(finalPath))
     return;
   const temporaryPath = `${finalPath}.${randomSuffix()}.tmp`;
   try {
-    const descriptor = fs2.openSync(temporaryPath, "wx");
+    const descriptor = fs3.openSync(temporaryPath, "wx");
     try {
-      fs2.writeFileSync(descriptor, `${JSON.stringify(manifest, null, 2)}
+      fs3.writeFileSync(descriptor, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
-      fs2.fsyncSync(descriptor);
+      fs3.fsyncSync(descriptor);
     } finally {
-      fs2.closeSync(descriptor);
+      fs3.closeSync(descriptor);
     }
     publishExclusive(temporaryPath, finalPath);
   } catch (error) {
@@ -2926,7 +3004,7 @@ function prepareNativeRuntimeCache(request) {
   try {
     assertSafeCacheSegment(request.target, "target");
     assertSafeCacheSegment(request.packageVersion, "package version");
-    const sourceRealPath = fs2.realpathSync.native(sourcePath);
+    const sourceRealPath = fs3.realpathSync.native(sourcePath);
     const source = hashFileStreaming(sourceRealPath);
     const cacheRoot = prepareSafeDirectory(request.cacheRoot ?? resolveProductionCacheRoot());
     const targetPath = prepareSafeDirectory(path3.join(cacheRoot, request.target));
@@ -2941,7 +3019,7 @@ function prepareNativeRuntimeCache(request) {
     const sourceFileName = path3.basename(sourceRealPath);
     const finalPath = path3.join(entryPath, sourceFileName);
     let status = "reused";
-    const finalExists = fs2.existsSync(finalPath);
+    const finalExists = fs3.existsSync(finalPath);
     if (!finalExists || !verifyFile(finalPath, source)) {
       if (finalExists)
         recoverCorruptFinal(finalPath);
@@ -3024,7 +3102,7 @@ function findLocalNativeBinary(packageRoot) {
   }
   const expectedName = `index.${suffix}.node`;
   try {
-    const entries = fs3.readdirSync(packageRoot, { withFileTypes: true });
+    const entries = fs4.readdirSync(packageRoot, { withFileTypes: true });
     const binary = entries.find((entry) => entry.isFile() && entry.name === expectedName);
     return binary ? path4.join(packageRoot, binary.name) : null;
   } catch {
@@ -3038,13 +3116,13 @@ function readPlatformPackage(packageName, target, resolveFn) {
   if (path4.basename(resolvedEntry) !== expectedFileName) {
     throw new Error(`unexpected native platform entry for ${platformPackageName}: ${resolvedEntry}`);
   }
-  const sourcePath = fs3.realpathSync.native(resolvedEntry);
-  const stats = fs3.statSync(sourcePath);
+  const sourcePath = fs4.realpathSync.native(resolvedEntry);
+  const stats = fs4.statSync(sourcePath);
   if (!stats.isFile() || stats.size <= 0) {
     throw new Error(`native platform entry is not a non-empty regular file: ${sourcePath}`);
   }
   const packageJsonPath = path4.join(path4.dirname(sourcePath), "package.json");
-  const parsed = JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
+  const parsed = JSON.parse(fs4.readFileSync(packageJsonPath, "utf8"));
   if (parsed.name !== platformPackageName || !parsed.version) {
     throw new Error(`invalid native platform package metadata: ${packageJsonPath}`);
   }
@@ -3653,7 +3731,7 @@ function countWhitespaceTokens(text) {
 }
 
 // dist/chunking/chunkFile.js
-function chunkFile(opts) {
+function chunkFileWithSymbols(opts) {
   const { language, source, filePath, minTokens = 150, maxTokens = 400, tokenizer = countWhitespaceTokens } = opts;
   const matches = getChunkMatches(language, source, filePath);
   const newlineOffsets = collectNewlineOffsets(source);
@@ -3668,9 +3746,20 @@ function chunkFile(opts) {
     appendBlockChunks(comment, [], source, tokenizer, maxTokens, preliminaryChunks, language.id, newlineOffsets, filePath);
   }
   preliminaryChunks.sort((left, right) => left.sourceStart - right.sourceStart || right.sourceEnd - left.sourceEnd);
-  const mergedChunks = mergeSmallChunks(preliminaryChunks, minTokens, maxTokens, tokenizer);
+  if (minTokens <= 1) {
+    const completeChunks2 = fillGapsWithMiscChunks(preliminaryChunks, source, language.id, filePath, tokenizer, 1, maxTokens, newlineOffsets);
+    const chunks2 = withStableChunkIds(completeChunks2.map(({ sourceStart: _sourceStart, sourceEnd: _sourceEnd, ...chunk }) => chunk), language.id, filePath);
+    return { chunks: chunks2, symbolChunks: chunks2 };
+  }
+  const completeSymbolChunks = fillGapsWithMiscChunks(preliminaryChunks, source, language.id, filePath, tokenizer, 1, maxTokens, newlineOffsets);
+  const symbolChunks = withStableChunkIds(completeSymbolChunks.map(({ sourceStart: _sourceStart, sourceEnd: _sourceEnd, ...chunk }) => chunk), language.id, filePath);
+  const mergedChunks = mergeSmallChunks([...preliminaryChunks], minTokens, maxTokens, tokenizer);
   const completeChunks = fillGapsWithMiscChunks(mergedChunks, source, language.id, filePath, tokenizer, minTokens, maxTokens, newlineOffsets);
-  return withStableChunkIds(completeChunks.map(({ sourceStart: _sourceStart, sourceEnd: _sourceEnd, ...chunk }) => chunk), language.id, filePath);
+  const chunks = withStableChunkIds(completeChunks.map(({ sourceStart: _sourceStart, sourceEnd: _sourceEnd, ...chunk }) => chunk), language.id, filePath);
+  return { chunks, symbolChunks };
+}
+function chunkFile(opts) {
+  return chunkFileWithSymbols(opts).chunks;
 }
 function appendBlockChunks(block, innerBlocks, source, tokenizer, maxTokens, out, languageId, newlineOffsets, filePath) {
   const text = source.slice(block.startByte, block.endByte);
@@ -3800,7 +3889,7 @@ function compressQueryText(text) {
   });
 }
 function normalizeQuerySearchText(input) {
-  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+  return input.replace(/([\p{Ll}\p{Nd}])(\p{Lu})/gu, "$1 $2").replace(/(\p{Lu}+)(\p{Lu}\p{Ll})/gu, "$1 $2").toLowerCase().replace(/[^\p{L}\p{N}\p{M}_]+/gu, " ").trim();
 }
 function detectQueryIndexSurface(relativePath) {
   const lower = relativePath.toLowerCase();
@@ -3850,7 +3939,7 @@ function buildQueryTextChunks(file, text) {
 }
 async function prepareQueryIndexFile(input) {
   try {
-    const stat = await fs4.stat(input.absolutePath);
+    const stat = await fs5.stat(input.absolutePath);
     const support = supportForFile(input.absolutePath);
     if (stat.size > MAX_QUERY_INDEX_TEXT_BYTES) {
       return {
@@ -3865,7 +3954,7 @@ async function prepareQueryIndexFile(input) {
         sourceRead: false
       };
     }
-    const text = await fs4.readFile(input.absolutePath, "utf8");
+    const text = await fs5.readFile(input.absolutePath, "utf8");
     return {
       path: input.path,
       sourceIdentity: input.sourceIdentity,

package/dist/bin/rawQueryWorker.js

@@ -0,0 +1,270 @@
+import { createRequire as __codegraphCreateRequire } from 'node:module';
+const require = __codegraphCreateRequire(import.meta.url);
+
+
+// dist/sqlite-driver.js
+import { createRequire } from "node:module";
+var requireNodeModule = createRequire(import.meta.url);
+var sqliteModule;
+var reportedReadonlyAuthorizerDegradation = false;
+function reportReadonlyAuthorizerDegraded() {
+  if (reportedReadonlyAuthorizerDegradation)
+    return;
+  reportedReadonlyAuthorizerDegradation = true;
+  console.error("[codegraph] node:sqlite read-only authorizer is unavailable or incomplete; relying on connection readOnly enforcement.");
+}
+var sqliteLoadError;
+function loadNodeSqlite() {
+  if (sqliteModule)
+    return sqliteModule;
+  if (sqliteLoadError)
+    throw sqliteLoadError;
+  try {
+    const loaded = requireNodeModule("node:sqlite");
+    sqliteModule = loaded;
+    return loaded;
+  } catch (error) {
+    sqliteLoadError = error instanceof Error ? error : new Error(String(error));
+    throw sqliteLoadError;
+  }
+}
+var READONLY_AUTHORIZER_CONSTANTS = [
+  "SQLITE_DENY",
+  "SQLITE_FUNCTION",
+  "SQLITE_OK",
+  "SQLITE_PRAGMA",
+  "SQLITE_READ",
+  "SQLITE_RECURSIVE",
+  "SQLITE_SELECT",
+  "SQLITE_TRANSACTION"
+];
+function canInstallReadonlyAuthorizer(constants) {
+  return READONLY_AUTHORIZER_CONSTANTS.every((name) => typeof constants[name] === "number");
+}
+function isReadOnlyAllowedAction(actionCode, constants) {
+  return actionCode === constants.SQLITE_FUNCTION || actionCode === constants.SQLITE_PRAGMA || actionCode === constants.SQLITE_READ || actionCode === constants.SQLITE_SELECT || actionCode === constants.SQLITE_TRANSACTION || actionCode === constants.SQLITE_RECURSIVE;
+}
+var isSqliteValueArray = (value) => Array.isArray(value);
+var normalizeParams = (params) => {
+  if (params.length === 1) {
+    const [only] = params;
+    if (only !== void 0 && isSqliteValueArray(only))
+      return [...only];
+  }
+  const normalized = [];
+  for (const param of params) {
+    if (isSqliteValueArray(param)) {
+      throw new Error("SQLite parameters must be passed as a single array or as positional values.");
+    }
+    normalized.push(param);
+  }
+  return normalized;
+};
+var SqliteStatement = class _SqliteStatement {
+  statement;
+  returnArrays;
+  constructor(statement, returnArrays = false) {
+    this.statement = statement;
+    this.returnArrays = returnArrays;
+    this.statement.setReturnArrays(returnArrays);
+  }
+  raw() {
+    return new _SqliteStatement(this.statement, true);
+  }
+  all(...params) {
+    return this.statement.all(...normalizeParams(params));
+  }
+  get(...params) {
+    return this.statement.get(...normalizeParams(params));
+  }
+  iterate(...params) {
+    return this.statement.iterate(...normalizeParams(params));
+  }
+  run(...params) {
+    return this.statement.run(...normalizeParams(params));
+  }
+  columns() {
+    return this.statement.columns();
+  }
+};
+var SqliteDatabase = class {
+  db;
+  statements = /* @__PURE__ */ new Map();
+  constructor(filePath, options) {
+    const sqlite = loadNodeSqlite();
+    this.db = new sqlite.DatabaseSync(filePath, {
+      readOnly: options?.readonly,
+      timeout: options?.timeout ?? 5e3
+    });
+    if (options?.readonly) {
+      const { constants } = sqlite;
+      if (this.db.setAuthorizer && canInstallReadonlyAuthorizer(constants)) {
+        this.db.setAuthorizer((actionCode) => isReadOnlyAllowedAction(actionCode, constants) ? constants.SQLITE_OK : constants.SQLITE_DENY);
+      } else {
+        reportReadonlyAuthorizerDegraded();
+      }
+    }
+  }
+  exec(sql) {
+    this.statements.clear();
+    this.db.exec(sql);
+  }
+  pragma(sql) {
+    this.exec(`PRAGMA ${sql};`);
+  }
+  prepare(sql) {
+    const cached = this.statements.get(sql);
+    if (cached)
+      return cached;
+    const statement = new SqliteStatement(this.db.prepare(sql));
+    this.statements.set(sql, statement);
+    return statement;
+  }
+  transaction(fn) {
+    return () => {
+      this.exec("BEGIN;");
+      try {
+        const result = fn();
+        this.exec("COMMIT;");
+        return result;
+      } catch (error) {
+        this.exec("ROLLBACK;");
+        throw error;
+      }
+    };
+  }
+  close() {
+    this.statements.clear();
+    this.db.close();
+  }
+};
+function isReadOnlySqliteError(error) {
+  if (!(error instanceof Error))
+    return false;
+  const message = error.message.toLowerCase();
+  return message.includes("not authorized") || message.includes("read-only") || message.includes("readonly") || message.includes("attempt to write");
+}
+
+// dist/sqlite/database.js
+import fs from "node:fs/promises";
+import path from "node:path";
+var readOrCreateDb = async (outputPath, options) => {
+  const readonly = options?.readonly ?? false;
+  const dir = path.dirname(outputPath);
+  if (dir && !readonly) {
+    await fs.mkdir(dir, { recursive: true });
+  }
+  const db = new SqliteDatabase(outputPath, {
+    readonly
+  });
+  return { db };
+};
+async function withReadOnlySqliteDatabase(outputPath, callback) {
+  const { db } = await readOrCreateDb(outputPath, { readonly: true });
+  try {
+    return await callback(db);
+  } finally {
+    db.close();
+  }
+}
+function assertReadOnlyQueryStatement(stmt) {
+  if (stmt.columns().length)
+    return;
+  throw new Error("Raw SQLite queries must be read-only result-producing statements such as SELECT or PRAGMA.");
+}
+
+// dist/sqlite/rowBounds.js
+var MAX_SQLITE_CELL_BYTES = 8e3;
+var SQLITE_TRUNCATED_MARKER = "...[truncated]";
+function collectBoundedRawSqlRows(columns, rowIterator, options) {
+  const maxCellBytes = options.maxCellBytes ?? MAX_SQLITE_CELL_BYTES;
+  const maxRows = Math.max(0, Math.floor(options.maxRows));
+  const maxBytes = options.maxBytes;
+  const rows = [];
+  let bytes = Buffer.byteLength(JSON.stringify({ columns, rows: [] }), "utf8");
+  let truncated = false;
+  let sawExtraRow = false;
+  for (const rawRow of rowIterator) {
+    if (rows.length >= maxRows) {
+      sawExtraRow = true;
+      truncated = true;
+      break;
+    }
+    let cellTruncated = false;
+    const row = rawRow.map((value) => {
+      const normalized = normalizeSqliteValue(value, maxCellBytes);
+      if (normalized.truncated)
+        cellTruncated = true;
+      return normalized.value;
+    });
+    if (cellTruncated)
+      truncated = true;
+    const rowBytes = Buffer.byteLength(JSON.stringify(row), "utf8");
+    if (maxBytes !== void 0 && bytes + rowBytes > maxBytes) {
+      truncated = true;
+      break;
+    }
+    rows.push(row);
+    bytes += rowBytes;
+  }
+  return {
+    columns,
+    rows,
+    rowLimit: maxRows,
+    ...maxBytes !== void 0 ? { byteLimit: maxBytes, bytes } : { bytes },
+    ...truncated || sawExtraRow ? { truncated: true } : {}
+  };
+}
+function normalizeSqliteValue(value, maxCellBytes = MAX_SQLITE_CELL_BYTES) {
+  if (typeof value === "string") {
+    const truncated = Buffer.byteLength(value, "utf8") > maxCellBytes;
+    return { value: truncateUtf8(value, maxCellBytes), truncated };
+  }
+  if (typeof value === "bigint")
+    return { value: value.toString(), truncated: false };
+  if (value instanceof Uint8Array) {
+    return { value: `<${value.byteLength} bytes>`, truncated: true };
+  }
+  return { value, truncated: false };
+}
+function truncateUtf8(value, maxBytes) {
+  if (Buffer.byteLength(value, "utf8") <= maxBytes)
+    return value;
+  const marker = SQLITE_TRUNCATED_MARKER;
+  const markerBytes = Buffer.byteLength(marker, "utf8");
+  const budget = Math.max(0, maxBytes - markerBytes);
+  let output = "";
+  let bytes = 0;
+  for (const char of value) {
+    const charBytes = Buffer.byteLength(char, "utf8");
+    if (bytes + charBytes > budget)
+      break;
+    output += char;
+    bytes += charBytes;
+  }
+  return `${output}${marker}`;
+}
+
+// dist/sqlite/rawQueryWorker.js
+async function runRawQueryWorkerTask(task) {
+  return await withReadOnlySqliteDatabase(task.outputPath, (db) => {
+    try {
+      const stmt = db.prepare(task.sql);
+      assertReadOnlyQueryStatement(stmt);
+      const columns = stmt.columns().map((col) => col.name);
+      return collectBoundedRawSqlRows(columns, stmt.raw().iterate(task.params), {
+        maxRows: task.maxRows,
+        maxBytes: task.maxBytes,
+        maxCellBytes: task.maxCellBytes
+      });
+    } catch (error) {
+      if (isReadOnlySqliteError(error)) {
+        throw new Error("Raw SQLite queries must be read-only result-producing statements such as SELECT or PRAGMA.");
+      }
+      throw error;
+    }
+  });
+}
+export {
+  runRawQueryWorkerTask as default
+};

package/dist/chunking/chunkFile.d.ts

@@ -30,5 +30,10 @@ export interface ChunkFileOptions {
  * @param opts Chunking options
  * @returns Array of semantic chunks
  */
+export type ChunkFileWithSymbolsResult = {
+    chunks: Chunk[];
+    symbolChunks: Chunk[];
+};
+export declare function chunkFileWithSymbols(opts: ChunkFileOptions): ChunkFileWithSymbolsResult;
 export declare function chunkFile(opts: ChunkFileOptions): Chunk[];
 //# sourceMappingURL=chunkFile.d.ts.map