@syntopica/db-quality 0.2.1 → 0.3.0

package/dist/cli.js

@@ -546,6 +546,52 @@ var postgrestSectionFrom = (raw) => {
   return { roots };
 };
 
+// src/config/SQLITE_QUERY_MIN_ROWS.ts
+var SQLITE_QUERY_MIN_ROWS = 1e4;
+
+// src/config/sqliteQueriesSectionFrom.ts
+var sqliteQueriesSectionFrom = (raw) => {
+  const paths = raw["paths"];
+  const database = raw["database"];
+  const minRows = raw["minRows"] ?? SQLITE_QUERY_MIN_ROWS;
+  expectConfig(
+    isStringList(paths),
+    "sqlite.queries.paths must be a list of strings"
+  );
+  expectConfig(
+    paths.length > 0,
+    "sqlite.queries.paths must name at least one directory"
+  );
+  expectConfig(
+    database === void 0 || typeof database === "string",
+    "sqlite.queries.database must be a string"
+  );
+  expectConfig(
+    isPositiveInteger(minRows),
+    "sqlite.queries.minRows must be a positive integer"
+  );
+  return {
+    paths,
+    ...database === void 0 ? {} : { database },
+    minRows
+  };
+};
+
+// src/config/sqliteSectionFrom.ts
+var sqliteSectionFrom = (raw) => {
+  const files = raw["files"];
+  if (!isStringList(files))
+    throw new ConfigError("sqlite.files must be a list of strings");
+  const queries = raw["queries"];
+  if (queries === void 0) return { files };
+  if (typeof queries !== "object" || queries === null || Array.isArray(queries))
+    throw new ConfigError("sqlite.queries must be an object");
+  return {
+    files,
+    queries: sqliteQueriesSectionFrom(queries)
+  };
+};
+
 // src/config/stackSectionsFrom.ts
 var stackSectionsFrom = (raw) => {
   const stacks = {};
@@ -566,12 +612,7 @@ var stackSectionsFrom = (raw) => {
   const drizzle = configSection(raw, "drizzle");
   if (drizzle) stacks.drizzle = drizzleSectionFrom(drizzle);
   const sqlite = configSection(raw, "sqlite");
-  if (sqlite) {
-    const files = sqlite["files"];
-    if (!isStringList(files))
-      throw new ConfigError("sqlite.files must be a list of strings");
-    stacks.sqlite = { files };
-  }
+  if (sqlite) stacks.sqlite = sqliteSectionFrom(sqlite);
   const postgrest = configSection(raw, "postgrest");
   if (postgrest) stacks.postgrest = postgrestSectionFrom(postgrest);
   return stacks;
@@ -653,8 +694,8 @@ var auditCommand = (argv2, io) => {
 };
 
 // src/commands/baselineCommand.ts
-import { existsSync as existsSync6 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { join as join12 } from "path";
 
 // src/baseline/BASELINE_FILENAME.ts
 var BASELINE_FILENAME = ".codeality-db-baseline.json";
@@ -855,7 +896,7 @@ var sqliteFinding = (input, disabled) => {
     code: input.code,
     severity: input.severity,
     path: input.file,
-    line: 0,
+    line: input.line ?? 0,
     message: input.message,
     subject: input.subject
   };
@@ -962,9 +1003,434 @@ var runSqliteChecks = (runner, root, files, disabled) => files.flatMap((file) =>
   ...primaryKeyFindings(runner, root, file, disabled)
 ]);
 
+// src/adapters/sqlite/probeQueryDatabase.ts
+import { existsSync as existsSync5 } from "fs";
+
+// src/adapters/sqlite/attemptSqlite.ts
+var attemptSqlite = (call) => {
+  try {
+    return call();
+  } catch (error) {
+    if (error instanceof ToolMissingError) throw error;
+    return void 0;
+  }
+};
+
+// src/adapters/sqlite/resolveQueryDatabase.ts
+import { homedir } from "os";
+import { join as join6, resolve } from "path";
+var resolveQueryDatabase = (root, database) => database.startsWith("~/") ? join6(homedir(), database.slice(2)) : resolve(root, database);
+
+// src/adapters/sqlite/userTables.ts
+var userTables = (runner, root, database) => new Map(
+  sqliteRows(
+    runner,
+    root,
+    database,
+    "select name from sqlite_master where type = 'table'"
+  ).map((row) => [row.name.toLowerCase(), row.name])
+);
+
+// src/adapters/sqlite/probeQueryDatabase.ts
+var probeQueryDatabase = (runner, root, database) => {
+  const path = resolveQueryDatabase(root, database);
+  if (!existsSync5(path)) return { path, unavailable: "does not exist" };
+  const tables = attemptSqlite(() => userTables(runner, root, path));
+  return tables ? { path, tables } : { path, unavailable: "is not a readable SQLite database" };
+};
+
+// src/adapters/sqlite/fullScanMessage.ts
+var fullScanMessage = (scan, rows, sorts) => {
+  const what = scan.kind === "table" ? "full table scan" : "full index scan";
+  const sorted = sorts ? ", then USE TEMP B-TREE FOR ORDER BY" : "";
+  const hint = scan.kind === "table" ? "give the filter an index it can use" : "the whole index is read; filter on its leading column or change the join order";
+  return `${what} of ${scan.table} (${String(rows)} rows) in the plan the application prepares: ${scan.detail}${sorted}; ${hint}`;
+};
+
+// src/adapters/sqlite/planDetails.ts
+var planDetails = (output) => {
+  const text = output.trim();
+  if (text.startsWith("["))
+    return JSON.parse(text).map((row) => row.detail);
+  return text.split("\n").map((line) => line.replace(/^[\s|`-]*/, "").trim()).filter((line) => line !== "" && line !== "QUERY PLAN");
+};
+
+// src/adapters/sqlite/queryPlan.ts
+var queryPlan = (runner, root, database, statement) => planDetails(
+  sqliteQuery(runner, root, database, `EXPLAIN QUERY PLAN ${statement}`)
+);
+
+// src/adapters/sqlite/cteNames.ts
+var cteNames = (text) => new Set(
+  [
+    ...text.matchAll(
+      /(?:\bwith\s+(?:recursive\s+)?|,\s*)"?(?<name>\w+)"?(?:\s*\([^()]*\))?\s+as\s*(?:not\s+)?(?:materialized\s*)?\(/gi
+    )
+  ].map((match) => (match.groups?.["name"] ?? "").toLowerCase())
+);
+
+// src/adapters/sqlite/scanOfPlanRow.ts
+var scanOfPlanRow = (detail) => {
+  const match = /^SCAN (?:TABLE )?(?<name>[^\s(]\S*)(?: AS \S+)?(?<rest>(?: .*)?)$/.exec(
+    detail
+  );
+  const name = match?.groups?.["name"];
+  const rest = match?.groups?.["rest"] ?? "";
+  if (name === void 0 || detail === "SCAN CONSTANT ROW") return void 0;
+  if (rest.includes("VIRTUAL TABLE")) return void 0;
+  return {
+    name,
+    kind: /\bUSING (?:COVERING )?INDEX\b/.test(rest) ? "index" : "table",
+    detail
+  };
+};
+
+// src/adapters/sqlite/ALIAS_KEYWORDS.ts
+var ALIAS_KEYWORDS = /* @__PURE__ */ new Set([
+  "and",
+  "as",
+  "cross",
+  "default",
+  "except",
+  "from",
+  "full",
+  "group",
+  "having",
+  "indexed",
+  "inner",
+  "intersect",
+  "join",
+  "left",
+  "limit",
+  "natural",
+  "not",
+  "offset",
+  "on",
+  "or",
+  "order",
+  "outer",
+  "returning",
+  "right",
+  "select",
+  "set",
+  "union",
+  "using",
+  "values",
+  "where",
+  "window"
+]);
+
+// src/adapters/sqlite/statementTableAliases.ts
+var statementTableAliases = (text, tables) => {
+  const aliases = /* @__PURE__ */ new Map();
+  const pattern = /(?<=\b(?:from|join|update|into)\s+|,\s*)"?(?<table>\w+)"?(?:\s+as)?\s+"?(?<alias>\w+)"?/gi;
+  for (const match of text.matchAll(pattern)) {
+    const table = tables.get(match.groups?.["table"]?.toLowerCase() ?? "");
+    const alias = match.groups?.["alias"]?.toLowerCase() ?? "";
+    if (table !== void 0 && !ALIAS_KEYWORDS.has(alias))
+      aliases.set(alias, table);
+  }
+  return aliases;
+};
+
+// src/adapters/sqlite/scannedTables.ts
+var scannedTables = (statement, details, tables) => {
+  const ctes = cteNames(statement);
+  const aliases = statementTableAliases(statement, tables);
+  return details.flatMap((detail) => {
+    const scan = scanOfPlanRow(detail);
+    if (!scan) return [];
+    const name = scan.name.toLowerCase();
+    if (ctes.has(name)) return [];
+    const table = aliases.get(name) ?? tables.get(name);
+    return table === void 0 ? [] : [{ table, kind: scan.kind, detail: scan.detail }];
+  });
+};
+
+// src/adapters/sqlite/tableRowCount.ts
+var tableRowCount = (runner, root, database, table) => sqliteRows(
+  runner,
+  root,
+  database,
+  `select count(*) as n from "${table.replaceAll('"', '""')}"`
+)[0]?.n ?? 0;
+
+// src/adapters/sqlite/queryPlanFindings.ts
+var queryPlanFindings = (context, files) => {
+  if (isDisabled("BDB406", context.disabled)) return [];
+  const { runner, root, database } = context;
+  const counts = /* @__PURE__ */ new Map();
+  const rowsOf = (table) => {
+    const known = counts.get(table);
+    if (known !== void 0) return known;
+    const rows = attemptSqlite(() => tableRowCount(runner, root, database, table)) ?? 0;
+    counts.set(table, rows);
+    return rows;
+  };
+  return files.flatMap((file) => {
+    const reported = /* @__PURE__ */ new Set();
+    return file.statements.flatMap((statement) => {
+      const details = attemptSqlite(
+        () => queryPlan(runner, root, database, statement.text)
+      );
+      if (!details) return [];
+      const sorts = details.includes("USE TEMP B-TREE FOR ORDER BY");
+      return scannedTables(statement.text, details, context.tables).flatMap(
+        (scan) => {
+          const key = `${scan.table}:${scan.kind}`;
+          const rows = rowsOf(scan.table);
+          if (reported.has(key) || rows < context.minRows) return [];
+          reported.add(key);
+          return sqliteFinding(
+            {
+              code: "BDB406",
+              severity: "warn",
+              file: file.path,
+              line: statement.line,
+              subject: scan.table,
+              message: fullScanMessage(scan, rows, sorts),
+              context: key
+            },
+            context.disabled
+          );
+        }
+      );
+    });
+  });
+};
+
+// src/adapters/sqlite/readQueryFiles.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { join as join8 } from "path";
+
+// src/adapters/sqlite/isQueryStatement.ts
+var isQueryStatement = (statement) => /^(?:select|with|update|delete|insert|replace)\b/i.test(statement.text);
+
+// src/adapters/sqlite/queryFilesUnder.ts
+import { readdirSync } from "fs";
+import { join as join7, relative as relative2 } from "path";
+
+// src/config/isDirectory.ts
+import { existsSync as existsSync6, statSync } from "fs";
+var isDirectory = (path) => existsSync6(path) && statSync(path).isDirectory();
+
+// src/postgrest/SKIPPED_SOURCE_DIRS.ts
+var SKIPPED_SOURCE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  ".next",
+  "coverage",
+  "__tests__",
+  "__mocks__"
+]);
+
+// src/adapters/sqlite/queryFilesUnder.ts
+var queryFilesUnder = (root, paths) => {
+  for (const base of paths) {
+    if (!isDirectory(join7(root, base)))
+      throw new ConfigError(
+        `sqlite.queries.paths: "${base}" is not a directory`
+      );
+  }
+  const found = /* @__PURE__ */ new Set();
+  const walk = (dir) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith(".")) continue;
+      const path = join7(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!SKIPPED_SOURCE_DIRS.has(entry.name)) walk(path);
+      } else if (entry.isFile() && entry.name.endsWith(".sql")) {
+        found.add(relative2(root, path).replaceAll("\\", "/"));
+      }
+    }
+  };
+  for (const base of paths) walk(join7(root, base));
+  return [...found].sort();
+};
+
+// src/sql/quotedSpanEnd.ts
+var quotedSpanEnd = (sql, index) => {
+  const dollar = /^\$[a-z_]*\$/i.exec(sql.slice(index, index + 64));
+  if (dollar) {
+    const end2 = sql.indexOf(dollar[0], index + dollar[0].length);
+    return end2 === -1 ? sql.length : end2 + dollar[0].length;
+  }
+  const quote = sql[index];
+  if (quote !== "'" && quote !== '"') return void 0;
+  const end = sql.indexOf(quote, index + 1);
+  return end === -1 ? sql.length : end + 1;
+};
+
+// src/sql/stripSqlComments.ts
+var stripSqlComments = (sql) => {
+  let out = "";
+  let index = 0;
+  while (index < sql.length) {
+    const quoted = quotedSpanEnd(sql, index);
+    if (quoted !== void 0) {
+      out += sql.slice(index, quoted);
+      index = quoted;
+    } else if (sql.startsWith("--", index)) {
+      const end = sql.indexOf("\n", index);
+      index = end === -1 ? sql.length : end;
+    } else if (sql.startsWith("/*", index)) {
+      const end = sql.indexOf("*/", index + 2);
+      const stop = end === -1 ? sql.length : end + 2;
+      out += sql.slice(index, stop).replaceAll(/[^\n]/g, "");
+      index = stop;
+    } else {
+      out += sql.charAt(index);
+      index += 1;
+    }
+  }
+  return out;
+};
+
+// src/sql/splitSqlStatements.ts
+var splitSqlStatements = (sql) => {
+  const text = stripSqlComments(sql);
+  const statements = [];
+  let start = 0;
+  const flush = (end) => {
+    const raw = text.slice(start, end);
+    const leading = raw.length - raw.trimStart().length;
+    const body = raw.trim();
+    if (body) {
+      const line = 1 + (text.slice(0, start + leading).match(/\n/g)?.length ?? 0);
+      statements.push({ text: body, line });
+    }
+    start = end + 1;
+  };
+  let index = 0;
+  while (index < text.length) {
+    const quoted = quotedSpanEnd(text, index);
+    if (quoted !== void 0) index = quoted;
+    else {
+      if (text[index] === ";") flush(index);
+      index += 1;
+    }
+  }
+  flush(text.length);
+  return statements;
+};
+
+// src/adapters/sqlite/readQueryFiles.ts
+var readQueryFiles = (root, paths) => queryFilesUnder(root, paths).map((path) => ({
+  path,
+  statements: splitSqlStatements(
+    readFileSync4(join8(root, path), "utf8")
+  ).filter(isQueryStatement)
+}));
+
+// src/adapters/sqlite/statementAtMatch.ts
+var statementAtMatch = (statement, index) => ({
+  text: statement.text,
+  line: statement.line + (statement.text.slice(0, index).match(/\n/g)?.length ?? 0)
+});
+
 // src/model/normalizeSqlText.ts
 var normalizeSqlText = (text) => text.toLowerCase().replaceAll(/\s+/g, " ").trim();
 
+// src/rules/makeSqlFinding.ts
+var makeSqlFinding = (rule, { file, statement }, subject, message) => {
+  const partial = {
+    code: rule.code,
+    severity: rule.severity,
+    path: file.path,
+    line: statement.line,
+    message,
+    subject
+  };
+  return {
+    ...partial,
+    fingerprint: fingerprintFinding(partial, normalizeSqlText(statement.text))
+  };
+};
+
+// src/adapters/sqlite/commaListMembership.ts
+var commaListMembership = {
+  code: "BDB405",
+  name: "comma-list-membership",
+  severity: "warn",
+  // instr(',' || ?1 || ',', ',' || col || ','): membership in a comma-joined
+  // list, which no index can answer.
+  run: (set) => set.flatMap(
+    (file) => file.statements.flatMap((statement) => {
+      const match = /\binstr\s*\(\s*','\s*\|\|\s*(?<param>\?\d*|[:@$][a-z_]\w*)\s*\|\|\s*','/i.exec(
+        statement.text
+      );
+      if (!match) return [];
+      const param = match.groups?.["param"] ?? "";
+      return [
+        makeSqlFinding(
+          commaListMembership,
+          { file, statement: statementAtMatch(statement, match.index) },
+          param,
+          `instr() over a comma-joined ${param} cannot use an index; bind a JSON array and filter with col IN (SELECT value FROM json_each(${param}))`
+        )
+      ];
+    })
+  )
+};
+
+// src/adapters/sqlite/optionalParameterGuard.ts
+var optionalParameterGuard = {
+  code: "BDB404",
+  name: "optional-parameter-guard",
+  severity: "warn",
+  // `?1 IS NULL OR col = ?1` and `col = ?1 OR ?1 IS NULL`, for every parameter
+  // spelling SQLite binds: ?, ?NNN, :name, @name and $name.
+  run: (set) => set.flatMap(
+    (file) => file.statements.flatMap((statement) => {
+      const match = /(?<param>\?\d*|[:@$][a-z_]\w*)\s+is\s+null\s+or\b|\bor\s+(?<trailing>\?\d*|[:@$][a-z_]\w*)\s+is\s+null\b/i.exec(
+        statement.text
+      );
+      if (!match) return [];
+      const param = match.groups?.["param"] ?? match.groups?.["trailing"] ?? "";
+      return [
+        makeSqlFinding(
+          optionalParameterGuard,
+          { file, statement: statementAtMatch(statement, match.index) },
+          param,
+          `"${param} IS NULL OR" hides the index from the planner: SQLite picks the plan at prepare time, before the value is bound; split the query per case, or bind a non-null sentinel or a json_each list`
+        )
+      ];
+    })
+  )
+};
+
+// src/adapters/sqlite/SQLITE_QUERY_RULES.ts
+var SQLITE_QUERY_RULES = [
+  optionalParameterGuard,
+  commaListMembership
+];
+
+// src/adapters/sqlite/runSqliteQueryChecks.ts
+var runSqliteQueryChecks = (runner, root, queries, disabled) => {
+  const files = readQueryFiles(root, queries.paths);
+  const findings = SQLITE_QUERY_RULES.filter(
+    (rule) => !isDisabled(rule.code, disabled)
+  ).flatMap((rule) => rule.run(files));
+  if (queries.database === void 0) return findings;
+  const probe = probeQueryDatabase(runner, root, queries.database);
+  if ("unavailable" in probe) return findings;
+  return [
+    ...findings,
+    ...queryPlanFindings(
+      {
+        runner,
+        root,
+        database: probe.path,
+        tables: probe.tables,
+        minRows: queries.minRows,
+        disabled
+      },
+      files
+    )
+  ];
+};
+
 // src/sql/statementAtLine.ts
 var statementAtLine = (file, line) => [...file.statements].reverse().find((statement) => statement.line <= line);
 
@@ -1027,8 +1493,8 @@ var runSquawk = (runner, root, set, disabled) => {
 };
 
 // src/postgrest/runPostgrestRules.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { join as join7 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join10 } from "path";
 
 // src/postgrest/ITERATION_METHODS.ts
 var ITERATION_METHODS = /* @__PURE__ */ new Set([
@@ -1307,45 +1773,28 @@ var POSTGREST_RULES = [
 ];
 
 // src/postgrest/sourceFilesUnder.ts
-import { readdirSync } from "fs";
-import { join as join6, relative as relative2 } from "path";
-
-// src/config/isDirectory.ts
-import { existsSync as existsSync5, statSync } from "fs";
-var isDirectory = (path) => existsSync5(path) && statSync(path).isDirectory();
-
-// src/postgrest/SKIPPED_SOURCE_DIRS.ts
-var SKIPPED_SOURCE_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  "dist",
-  "build",
-  ".next",
-  "coverage",
-  "__tests__",
-  "__mocks__"
-]);
-
-// src/postgrest/sourceFilesUnder.ts
+import { readdirSync as readdirSync2 } from "fs";
+import { join as join9, relative as relative3 } from "path";
 var sourceFilesUnder = (root, roots) => {
   for (const base of roots) {
-    if (!isDirectory(join6(root, base)))
+    if (!isDirectory(join9(root, base)))
       throw new ConfigError(`postgrest.roots: "${base}" is not a directory`);
   }
   const files = [];
   const walk = (dir) => {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
       if (entry.isDirectory()) {
         if (!SKIPPED_SOURCE_DIRS.has(entry.name) && !entry.name.startsWith("."))
-          walk(join6(dir, entry.name));
+          walk(join9(dir, entry.name));
         continue;
       }
       const name = entry.name;
       if (!/\.tsx?$/.test(name) || name.endsWith(".d.ts") || /\.(?:test|spec)\.tsx?$/.test(name))
         continue;
-      files.push(relative2(root, join6(dir, name)));
+      files.push(relative3(root, join9(dir, name)));
     }
   };
-  for (const base of roots) walk(join6(root, base));
+  for (const base of roots) walk(join9(root, base));
   return files.sort();
 };
 
@@ -1355,12 +1804,12 @@ var runPostgrestRules = (root, roots, knowledge, disabled) => {
     (rule) => !isDisabled(rule.code, disabled)
   );
   const context = { knowledge };
-  const compiler = loadTypeScript([join7(root, "package.json"), import.meta.url]);
+  const compiler = loadTypeScript([join10(root, "package.json"), import.meta.url]);
   return sourceFilesUnder(root, roots).flatMap(
     (path) => collectPostgrestChains(
       compiler,
       path,
-      readFileSync4(join7(root, path), "utf8")
+      readFileSync5(join10(root, path), "utf8")
     )
   ).flatMap((chain) => rules.map((rule) => rule.run(chain, context))).filter((finding) => finding !== void 0).sort(compareFindings);
 };
@@ -1491,22 +1940,6 @@ var indexedColumns = (set) => {
   return knowledge;
 };
 
-// src/rules/makeSqlFinding.ts
-var makeSqlFinding = (rule, { file, statement }, subject, message) => {
-  const partial = {
-    code: rule.code,
-    severity: rule.severity,
-    path: file.path,
-    line: statement.line,
-    message,
-    subject
-  };
-  return {
-    ...partial,
-    fingerprint: fingerprintFinding(partial, normalizeSqlText(statement.text))
-  };
-};
-
 // src/rules/policyTable.ts
 var policyTable = (statement) => {
   const match = /^create policy .+? on ((?:"[^"]+"|[\w$]+)(?:\.(?:"[^"]+"|[\w$]+))?)/.exec(
@@ -1647,80 +2080,12 @@ var SQL_RULES = [
 var runSqlRules = (set, disabled) => SQL_RULES.filter((rule) => !isDisabled(rule.code, disabled)).flatMap((rule) => rule.run(set)).sort(compareFindings);
 
 // src/sql/readMigrationSet.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
-import { join as join8 } from "path";
-
-// src/sql/quotedSpanEnd.ts
-var quotedSpanEnd = (sql, index) => {
-  const dollar = /^\$[a-z_]*\$/i.exec(sql.slice(index, index + 64));
-  if (dollar) {
-    const end2 = sql.indexOf(dollar[0], index + dollar[0].length);
-    return end2 === -1 ? sql.length : end2 + dollar[0].length;
-  }
-  const quote = sql[index];
-  if (quote !== "'" && quote !== '"') return void 0;
-  const end = sql.indexOf(quote, index + 1);
-  return end === -1 ? sql.length : end + 1;
-};
-
-// src/sql/stripSqlComments.ts
-var stripSqlComments = (sql) => {
-  let out = "";
-  let index = 0;
-  while (index < sql.length) {
-    const quoted = quotedSpanEnd(sql, index);
-    if (quoted !== void 0) {
-      out += sql.slice(index, quoted);
-      index = quoted;
-    } else if (sql.startsWith("--", index)) {
-      const end = sql.indexOf("\n", index);
-      index = end === -1 ? sql.length : end;
-    } else if (sql.startsWith("/*", index)) {
-      const end = sql.indexOf("*/", index + 2);
-      const stop = end === -1 ? sql.length : end + 2;
-      out += sql.slice(index, stop).replaceAll(/[^\n]/g, "");
-      index = stop;
-    } else {
-      out += sql.charAt(index);
-      index += 1;
-    }
-  }
-  return out;
-};
-
-// src/sql/splitSqlStatements.ts
-var splitSqlStatements = (sql) => {
-  const text = stripSqlComments(sql);
-  const statements = [];
-  let start = 0;
-  const flush = (end) => {
-    const raw = text.slice(start, end);
-    const leading = raw.length - raw.trimStart().length;
-    const body = raw.trim();
-    if (body) {
-      const line = 1 + (text.slice(0, start + leading).match(/\n/g)?.length ?? 0);
-      statements.push({ text: body, line });
-    }
-    start = end + 1;
-  };
-  let index = 0;
-  while (index < text.length) {
-    const quoted = quotedSpanEnd(text, index);
-    if (quoted !== void 0) index = quoted;
-    else {
-      if (text[index] === ";") flush(index);
-      index += 1;
-    }
-  }
-  flush(text.length);
-  return statements;
-};
-
-// src/sql/readMigrationSet.ts
-var readMigrationSet = (root, migrationsDir) => readdirSync2(join8(root, migrationsDir)).filter((name) => name.endsWith(".sql")).sort().map((name) => ({
+import { readdirSync as readdirSync3, readFileSync as readFileSync6 } from "fs";
+import { join as join11 } from "path";
+var readMigrationSet = (root, migrationsDir) => readdirSync3(join11(root, migrationsDir)).filter((name) => name.endsWith(".sql")).sort().map((name) => ({
   path: `${migrationsDir.replaceAll("\\", "/")}/${name}`,
   statements: splitSqlStatements(
-    readFileSync5(join8(root, migrationsDir, name), "utf8")
+    readFileSync6(join11(root, migrationsDir, name), "utf8")
   )
 }));
 
@@ -1747,6 +2112,15 @@ var runCheck = ({ root, config, runner }) => {
     findings.push(
       ...runSqliteChecks(runner, root, config.sqlite.files, config.disable)
     );
+    if (config.sqlite.queries)
+      findings.push(
+        ...runSqliteQueryChecks(
+          runner,
+          root,
+          config.sqlite.queries,
+          config.disable
+        )
+      );
   }
   if (config.postgrest) {
     findings.push(
@@ -1761,6 +2135,20 @@ var runCheck = ({ root, config, runner }) => {
   return findings.sort(compareFindings);
 };
 
+// src/check/sqliteQueriesNotice.ts
+var sqliteQueriesNotice = (runner, root, config) => {
+  const database = config.sqlite?.queries?.database;
+  if (database === void 0 || isDisabled("BDB406", config.disable))
+    return void 0;
+  try {
+    const probe = probeQueryDatabase(runner, root, database);
+    return "unavailable" in probe ? `sqlite.queries.database ${probe.path} ${probe.unavailable}; the query-plan check BDB406 was skipped` : void 0;
+  } catch (error) {
+    if (error instanceof ToolMissingError) return void 0;
+    throw error;
+  }
+};
+
 // src/packageVersion.ts
 import { createRequire as createRequire2 } from "module";
 var PACKAGE_VERSION = createRequire2(import.meta.url)("../package.json").version;
@@ -1772,7 +2160,7 @@ var baselineCommand = (argv2, io) => {
       "check-stale": { type: "boolean" }
     });
     const action = baselineActionFrom(positionals);
-    if (action === "create" && existsSync6(join9(io.root, BASELINE_FILENAME))) {
+    if (action === "create" && existsSync7(join12(io.root, BASELINE_FILENAME))) {
       throw new ConfigError(
         `${BASELINE_FILENAME} exists; use "baseline update" to rewrite it`
       );
@@ -1780,6 +2168,9 @@ var baselineCommand = (argv2, io) => {
     const config = readConfig(io.root);
     const notice = legacyConfigNotice(config);
     if (notice) io.stderr(`${notice}
+`);
+    const skipped = sqliteQueriesNotice(io.runner, io.root, config);
+    if (skipped) io.stderr(`${skipped}
 `);
     const findings = runCheck({
       root: io.root,
@@ -1816,6 +2207,9 @@ var checkCommand = (argv2, io) => {
     const config = readConfig(io.root);
     const notice = legacyConfigNotice(config);
     if (notice) io.stderr(`${notice}
+`);
+    const skipped = sqliteQueriesNotice(io.runner, io.root, config);
+    if (skipped) io.stderr(`${skipped}
 `);
     const findings = runCheck({
       root: io.root,
@@ -1842,24 +2236,24 @@ var gateExitCode = (results) => {
 };
 
 // src/gate/gateStages.ts
-import { existsSync as existsSync11 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { join as join18 } from "path";
 
 // src/gate/perfStage.ts
-import { existsSync as existsSync10 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { join as join17 } from "path";
 
 // src/bench/BENCH_RECORD_FILENAME.ts
 var BENCH_RECORD_FILENAME = ".codeality-db-bench.json";
 
 // src/bench/readBenchRecord.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { join as join13 } from "path";
 var readBenchRecord = (root) => {
-  const path = join10(root, BENCH_RECORD_FILENAME);
-  if (!existsSync7(path)) return void 0;
+  const path = join13(root, BENCH_RECORD_FILENAME);
+  if (!existsSync8(path)) return void 0;
   const document = JSON.parse(
-    readFileSync6(path, "utf8")
+    readFileSync7(path, "utf8")
   );
   if (document.schemaVersion !== 1)
     throw new ConfigError(
@@ -1926,18 +2320,18 @@ var benchFindings = (input, recorded, current, judgement) => {
 };
 
 // src/bench/readBenchQueries.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync7 } from "fs";
-import { join as join11 } from "path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync8 } from "fs";
+import { join as join14 } from "path";
 
 // src/bench/RUNS_HEADER.ts
 var RUNS_HEADER = /^--\s*runs:\s*(\S+)/;
 
 // src/bench/readBenchQueries.ts
 var readBenchQueries = (root, benchDir, defaultRuns) => {
-  const dir = join11(root, benchDir);
+  const dir = join14(root, benchDir);
   if (!isDirectory(dir)) throw new ConfigError(`${benchDir} is not a directory`);
-  return readdirSync3(dir).filter((name) => name.endsWith(".sql")).sort().map((name) => {
-    const raw = readFileSync7(join11(dir, name), "utf8");
+  return readdirSync4(dir).filter((name) => name.endsWith(".sql")).sort().map((name) => {
+    const raw = readFileSync8(join14(dir, name), "utf8");
     const match = RUNS_HEADER.exec(raw);
     const runs = match?.[1] ? Number(match[1]) : defaultRuns;
     if (!isPositiveInteger(runs))
@@ -2336,22 +2730,22 @@ var diffSnapshots = (previous, current, perf, disabled) => {
 var QUERY_TIMEOUT_MS = 3e4;
 
 // src/perf/readPerfSnapshot.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
+import { join as join15 } from "path";
 
 // src/perf/PERF_SNAPSHOT_FILENAME.ts
 var PERF_SNAPSHOT_FILENAME = ".codeality-db-perf.json";
 
 // src/perf/readPerfSnapshot.ts
 var readPerfSnapshot = (root) => {
-  const path = join12(root, PERF_SNAPSHOT_FILENAME);
-  if (!existsSync8(path)) {
+  const path = join15(root, PERF_SNAPSHOT_FILENAME);
+  if (!existsSync9(path)) {
     throw new ConfigError(
       `${PERF_SNAPSHOT_FILENAME} not found; run "codeality-db perf snapshot"`
     );
   }
   const document = JSON.parse(
-    readFileSync8(path, "utf8")
+    readFileSync9(path, "utf8")
   );
   if (document.schemaVersion !== 1) {
     throw new ConfigError(
@@ -2472,8 +2866,8 @@ var perfDiffFindings = ({ root, config, runner }, target) => {
 };
 
 // src/postgres/resolvePostgresTarget.ts
-import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
+import { join as join16 } from "path";
 import { env } from "process";
 
 // src/postgres/DB_PASSWORD_ENV.ts
@@ -2530,12 +2924,12 @@ var targetFromUrl = (raw, source, fallbackPassword) => {
 var resolvePostgresTarget = (root, flags) => {
   const explicit = flags["db-url"];
   if (explicit !== void 0) return targetFromUrl(explicit, "--db-url");
-  const poolerPath = join13(root, POOLER_URL_FILE);
+  const poolerPath = join16(root, POOLER_URL_FILE);
   const password = env[DB_PASSWORD_ENV];
-  if (!existsSync9(poolerPath) || password === void 0 || password === "")
+  if (!existsSync10(poolerPath) || password === void 0 || password === "")
     return void 0;
   return targetFromUrl(
-    readFileSync9(poolerPath, "utf8").trim(),
+    readFileSync10(poolerPath, "utf8").trim(),
     POOLER_URL_FILE,
     password
   );
@@ -2551,8 +2945,8 @@ var perfStage = (context) => ({
       return {
         skipped: "no linked project with SUPABASE_DB_PASSWORD"
       };
-    const hasSnapshot = existsSync10(join14(context.root, PERF_SNAPSHOT_FILENAME));
-    const hasRecord = existsSync10(join14(context.root, BENCH_RECORD_FILENAME));
+    const hasSnapshot = existsSync11(join17(context.root, PERF_SNAPSHOT_FILENAME));
+    const hasRecord = existsSync11(join17(context.root, BENCH_RECORD_FILENAME));
     if (!hasSnapshot && !hasRecord)
       return {
         skipped: 'no perf snapshot and no bench record; run "perf snapshot" or "perf bench --record"'
@@ -2566,8 +2960,8 @@ var perfStage = (context) => ({
 
 // src/gate/gateStages.ts
 var gateStages = (context) => {
-  const hasBaseline = existsSync11(join15(context.root, BASELINE_FILENAME));
-  const linked = existsSync11(join15(context.root, "supabase/.temp/project-ref"));
+  const hasBaseline = existsSync12(join18(context.root, BASELINE_FILENAME));
+  const linked = existsSync12(join18(context.root, "supabase/.temp/project-ref"));
   return [
     hasBaseline ? {
       name: "baseline-check",
@@ -2621,6 +3015,9 @@ var gateCommand = (argv2, io) => {
     const config = readConfig(io.root);
     const notice = legacyConfigNotice(config);
     if (notice) io.stderr(`${notice}
+`);
+    const skipped = sqliteQueriesNotice(io.runner, io.root, config);
+    if (skipped) io.stderr(`${skipped}
 `);
     const results = runGate(
       gateStages({
@@ -2639,12 +3036,12 @@ var gateCommand = (argv2, io) => {
 };
 
 // src/init/adoptionPhase.ts
-import { existsSync as existsSync12 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join19 } from "path";
 var adoptionPhase = (root, config) => {
   if (config.schemaVersion !== 2) return 0;
-  const hasSnapshot = existsSync12(join16(root, PERF_SNAPSHOT_FILENAME));
-  const hasBench = existsSync12(join16(root, BENCH_RECORD_FILENAME));
+  const hasSnapshot = existsSync13(join19(root, PERF_SNAPSHOT_FILENAME));
+  const hasBench = existsSync13(join19(root, BENCH_RECORD_FILENAME));
   if (config.perf.inGate && (hasSnapshot || hasBench)) return 4;
   if (hasBench) return 3;
   if (hasSnapshot) return 2;
@@ -2652,12 +3049,12 @@ var adoptionPhase = (root, config) => {
 };
 
 // src/init/baselineStep.ts
-import { existsSync as existsSync13 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { join as join20 } from "path";
 var baselineStep = (context) => {
   const findings = runCheck(context);
   if (findings.length === 0) return "covered";
-  if (!existsSync13(join17(context.root, BASELINE_FILENAME))) return "create";
+  if (!existsSync14(join20(context.root, BASELINE_FILENAME))) return "create";
   const classified = classifyFindings(findings, readBaseline(context.root));
   return classified.new.length > 0 ? "update" : "covered";
 };
@@ -2677,19 +3074,19 @@ var adoptionStanding = (context) => {
 
 // src/init/applyInit.ts
 import { mkdirSync, writeFileSync as writeFileSync3 } from "fs";
-import { dirname, join as join18 } from "path";
+import { dirname, join as join21 } from "path";
 var applyInit = (root, plan) => {
   for (const file of plan) {
     const writes = file.disposition === "create" || file.disposition === "merge";
     if (!writes || file.content === void 0) continue;
-    mkdirSync(dirname(join18(root, file.path)), { recursive: true });
-    writeFileSync3(join18(root, file.path), file.content);
+    mkdirSync(dirname(join21(root, file.path)), { recursive: true });
+    writeFileSync3(join21(root, file.path), file.content);
   }
 };
 
 // src/init/planBenchReadme.ts
-import { existsSync as existsSync14 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { join as join22 } from "path";
 
 // src/init/BENCH_README.ts
 var BENCH_README = `# Bench queries
@@ -2721,12 +3118,12 @@ var planBenchReadme = (root) => {
       return PERF_DEFAULTS.benchDir;
     }
   })();
-  const relative4 = `${benchDir}/README.md`;
-  if (existsSync14(join19(root, relative4))) {
-    return { path: relative4, disposition: "unchanged", detail: "present" };
+  const relative5 = `${benchDir}/README.md`;
+  if (existsSync15(join22(root, relative5))) {
+    return { path: relative5, disposition: "unchanged", detail: "present" };
   }
   return {
-    path: relative4,
+    path: relative5,
     disposition: "create",
     detail: "explains the bench convention",
     content: BENCH_README
@@ -2734,26 +3131,26 @@ var planBenchReadme = (root) => {
 };
 
 // src/init/planConfigFile.ts
-import { existsSync as existsSync17, readFileSync as readFileSync11 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
+import { join as join26 } from "path";
 
 // src/config/detectStacks.ts
-import { existsSync as existsSync16 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync17 } from "fs";
+import { join as join25 } from "path";
 
 // src/config/findSqliteFiles.ts
-import { readdirSync as readdirSync4 } from "fs";
-import { join as join20, relative as relative3 } from "path";
+import { readdirSync as readdirSync5 } from "fs";
+import { join as join23, relative as relative4 } from "path";
 var findSqliteFiles = (root) => {
   const skipped = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage"]);
   const found = [];
   const walk = (directory, depth) => {
-    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
       if (skipped.has(entry.name) || entry.name.startsWith(".")) continue;
-      const path = join20(directory, entry.name);
+      const path = join23(directory, entry.name);
       if (entry.isDirectory() && depth < 2) walk(path, depth + 1);
       else if (entry.isFile() && /\.(?:db|sqlite|sqlite3)$/.test(entry.name)) {
-        found.push(relative3(root, path).replaceAll("\\", "/"));
+        found.push(relative4(root, path).replaceAll("\\", "/"));
       }
     }
   };
@@ -2765,13 +3162,13 @@ var findSqliteFiles = (root) => {
 var hasPostgrestSources = (root, name) => sourceFilesUnder(root, [name]).length > 0;
 
 // src/config/hasSupabaseJsDependency.ts
-import { existsSync as existsSync15, readFileSync as readFileSync10 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync11 } from "fs";
+import { join as join24 } from "path";
 var hasSupabaseJsDependency = (root) => {
-  const manifestPath = join21(root, "package.json");
-  if (!existsSync15(manifestPath)) return false;
+  const manifestPath = join24(root, "package.json");
+  if (!existsSync16(manifestPath)) return false;
   const manifest = JSON.parse(
-    readFileSync10(manifestPath, "utf8")
+    readFileSync11(manifestPath, "utf8")
   );
   const dependencies = { ...manifest.dependencies, ...manifest.devDependencies };
   return "@supabase/supabase-js" in dependencies;
@@ -2781,17 +3178,17 @@ var hasSupabaseJsDependency = (root) => {
 var detectStacks = (root) => {
   const sqliteFiles = findSqliteFiles(root);
   const hasDrizzle = ["ts", "js", "mjs"].some(
-    (ext) => existsSync16(join22(root, `drizzle.config.${ext}`))
+    (ext) => existsSync17(join25(root, `drizzle.config.${ext}`))
   );
   const drizzleRoots = ["src", "server", "app", "lib", "db"].filter(
-    (name) => isDirectory(join22(root, name))
+    (name) => isDirectory(join25(root, name))
   );
   const postgrestRoots = ["src", "app", "supabase/functions"].filter(
-    (name) => isDirectory(join22(root, name)) && hasPostgrestSources(root, name)
+    (name) => isDirectory(join25(root, name)) && hasPostgrestSources(root, name)
   );
   return {
-    ...isDirectory(join22(root, "supabase/migrations")) ? { supabase: { migrations: "supabase/migrations" } } : {},
-    ...existsSync16(join22(root, "prisma/schema.prisma")) ? { prisma: { schema: "prisma/schema.prisma" } } : {},
+    ...isDirectory(join25(root, "supabase/migrations")) ? { supabase: { migrations: "supabase/migrations" } } : {},
+    ...existsSync17(join25(root, "prisma/schema.prisma")) ? { prisma: { schema: "prisma/schema.prisma" } } : {},
     ...hasDrizzle ? { drizzle: { roots: drizzleRoots, objectNames: ["db", "tx"] } } : {},
     ...sqliteFiles.length > 0 ? { sqlite: { files: sqliteFiles } } : {},
     ...hasSupabaseJsDependency(root) && postgrestRoots.length > 0 ? { postgrest: { roots: postgrestRoots } } : {}
@@ -2819,14 +3216,14 @@ var upgradedConfigDocument = (raw, detected) => {
 
 // src/init/planConfigFile.ts
 var planConfigFile = (root, force) => {
-  const path = join23(root, CONFIG_FILENAME);
+  const path = join26(root, CONFIG_FILENAME);
   const freshContent = `${JSON.stringify(
     { schemaVersion: 2, ...detectStacks(root), perf: PERF_INIT_SECTION },
     null,
     2
   )}
 `;
-  if (!existsSync17(path)) {
+  if (!existsSync18(path)) {
     return {
       path: CONFIG_FILENAME,
       disposition: "create",
@@ -2835,7 +3232,7 @@ var planConfigFile = (root, force) => {
     };
   }
   try {
-    const raw = JSON.parse(readFileSync11(path, "utf8"));
+    const raw = JSON.parse(readFileSync12(path, "utf8"));
     const config = configFromDocument(raw);
     if (config.schemaVersion === 1) {
       return {
@@ -2866,23 +3263,23 @@ var planConfigFile = (root, force) => {
 };
 
 // src/init/planPackageScript.ts
-import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync13 } from "fs";
+import { join as join27 } from "path";
 
 // src/init/PACKAGE_MANIFEST.ts
 var PACKAGE_MANIFEST = "package.json";
 
 // src/init/planPackageScript.ts
 var planPackageScript = (root, force) => {
-  const path = join24(root, PACKAGE_MANIFEST);
-  if (!existsSync18(path)) {
+  const path = join27(root, PACKAGE_MANIFEST);
+  if (!existsSync19(path)) {
     return {
       path: PACKAGE_MANIFEST,
       disposition: "unchanged",
       detail: "no package.json"
     };
   }
-  const manifest = JSON.parse(readFileSync12(path, "utf8"));
+  const manifest = JSON.parse(readFileSync13(path, "utf8"));
   const current = manifest.scripts?.["db:gate"];
   if (current === "codeality-db gate") {
     return {
@@ -2910,8 +3307,8 @@ var planPackageScript = (root, force) => {
 };
 
 // src/init/planWorkflow.ts
-import { existsSync as existsSync19, readFileSync as readFileSync13 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync14 } from "fs";
+import { join as join28 } from "path";
 
 // src/init/sha256Of.ts
 import { createHash as createHash2 } from "crypto";
@@ -2924,33 +3321,33 @@ var SHIPPED_WORKFLOW_HASHES = {
 
 // src/init/planWorkflow.ts
 var planWorkflow = (root, force) => {
-  const relative4 = ".github/workflows/db-quality.yml";
-  const content = readFileSync13(assetPath("db-quality.yml"), "utf8");
-  const path = join25(root, relative4);
-  if (!existsSync19(path)) {
+  const relative5 = ".github/workflows/db-quality.yml";
+  const content = readFileSync14(assetPath("db-quality.yml"), "utf8");
+  const path = join28(root, relative5);
+  if (!existsSync20(path)) {
     const detail = "runs codeality-db gate on push and pull request";
-    return { path: relative4, disposition: "create", detail, content };
+    return { path: relative5, disposition: "create", detail, content };
   }
-  const existing = readFileSync13(path, "utf8");
+  const existing = readFileSync14(path, "utf8");
   if (existing === content) {
-    return { path: relative4, disposition: "unchanged", detail: "identical" };
+    return { path: relative5, disposition: "unchanged", detail: "identical" };
   }
   const shippedVersion = SHIPPED_WORKFLOW_HASHES[sha256Of(existing)];
   if (shippedVersion !== void 0) {
     return {
-      path: relative4,
+      path: relative5,
       disposition: "merge",
       detail: `upgraded from the ${shippedVersion} workflow`,
       content
     };
   }
   return force ? {
-    path: relative4,
+    path: relative5,
     disposition: "merge",
     detail: "replaced (--force)",
     content
   } : {
-    path: relative4,
+    path: relative5,
     disposition: "conflict",
     detail: "differs from the shipped workflow"
   };
@@ -3091,9 +3488,9 @@ var renderBenchJson = (result, recorded) => JSON.stringify(
 
 // src/bench/writeBenchRecord.ts
 import { renameSync as renameSync2, writeFileSync as writeFileSync4 } from "fs";
-import { join as join26 } from "path";
+import { join as join29 } from "path";
 var writeBenchRecord = (root, record) => {
-  const path = join26(root, BENCH_RECORD_FILENAME);
+  const path = join29(root, BENCH_RECORD_FILENAME);
   writeFileSync4(`${path}.tmp`, `${JSON.stringify(record, null, 2)}
 `);
   renameSync2(`${path}.tmp`, path);
@@ -3196,9 +3593,9 @@ var perfDiffAction = ({
 
 // src/perf/writePerfSnapshot.ts
 import { renameSync as renameSync3, writeFileSync as writeFileSync5 } from "fs";
-import { join as join27 } from "path";
+import { join as join30 } from "path";
 var writePerfSnapshot = (root, snapshot) => {
-  const path = join27(root, PERF_SNAPSHOT_FILENAME);
+  const path = join30(root, PERF_SNAPSHOT_FILENAME);
   writeFileSync5(`${path}.tmp`, `${JSON.stringify(snapshot, null, 2)}
 `);
   renameSync3(`${path}.tmp`, path);
@@ -3330,7 +3727,7 @@ var runCli = (argv2, io) => {
 
 // src/tools/spawnRunner.ts
 import { spawnSync } from "child_process";
-import { delimiter, join as join28 } from "path";
+import { delimiter, join as join31 } from "path";
 import { env as processEnv } from "process";
 
 // src/tools/packageBinPath.ts
@@ -3340,7 +3737,7 @@ var packageBinPath = () => fileURLToPath2(new URL("../node_modules/.bin", import
 // src/tools/spawnRunner.ts
 var spawnRunner = (command, args, options) => {
   const path = options.systemPathOnly ? processEnv["PATH"] ?? "" : [
-    join28(options.cwd, "node_modules/.bin"),
+    join31(options.cwd, "node_modules/.bin"),
     packageBinPath(),
     processEnv["PATH"] ?? ""
   ].join(delimiter);