@nitra/cursor 1.8.159 → 1.8.161

package/CHANGELOG.md

@@ -4,6 +4,21 @@
 
 Формат — [Keep a Changelog](https://keepachangelog.com/uk/1.1.0/), нумерація — [SemVer](https://semver.org/lang/uk/).
 
+## [1.8.161] - 2026-05-01
+
+### Added
+
+- `js-bun-db.mdc` (v1.5): нова секція «Прибирати pg-leftover виклики (`.connect()`, `.end()`)». У файлах з Bun SQL прапоруються `<obj>.connect(...)` і `<obj>.end(...)` як ручний lifecycle, який Bun SQL робить за тебе. Opt-out — маркер `// allow-pg-leftover: <причина>` (line- або block-коментар на тому ж рядку чи безпосередньо перед викликом).
+- `bun-sql-scan.mjs`: новий сканер `findBunSqlPgLeftoverCallInText` (скоп — лише файли з `import { sql|SQL } from 'bun'`, щоб не давати false-positive на WebSocket/Stream `.end()`). Виділено спільний `hasMarkerCommentNear` для обох opt-in маркерів (`allow-unsafe`, `allow-pg-leftover`).
+
+## [1.8.160] - 2026-05-01
+
+### Changed
+
+- `js-bun-db.mdc` (v1.4): `sql.unsafe(...)` тепер заборонено за замовчуванням — допустимо лише для підстановки назви таблиці/колонки чи dynamic SQL/DDL з code-controlled значенням; інакше переробляємо на tagged template `sql\`...${value}...\``. Кожен легітимний виклик має супроводжуватись маркером `// allow-unsafe: <причина>` на тому ж рядку або рядком вище.
+- `check-js-bun-db.mjs`: замість вузької перевірки `sql.unsafe(\`...${expr}...\`)` тепер сканер `findBunSqlUnsafeUseWithoutAllowMarkerInText` падає на будь-якому `<obj>.unsafe(...)` без маркера-коментаря з непорожньою причиною (line- або block-коментар на тому ж рядку чи безпосередньо перед викликом).
+- `ast-scan-utils.mjs`: додано `parseProgramAndCommentsOrNull` — окремий вхід для перевірок, яким потрібні коментарі поряд з AST.
+
 ## [1.8.159] - 2026-05-01
 
 ### Added

package/mdc/js-bun-db.mdc

@@ -1,7 +1,7 @@
 ---
 description: Використання pg / mysql2 / Bun SQL у Node.js та Bun
 alwaysApply: true
-version: '1.3'
+version: '1.5'
 ---
 
 ## Підтримувані версії баз даних
@@ -116,22 +116,71 @@ await sql.begin(async tx => {
 await sql`SELECT * FROM users WHERE id IN ${sql(ids)}`
 ```
 
-## Що НЕ робити
+## `sql.unsafe(...)` за замовчуванням заборонено
+
+Будь-який виклик `sql.unsafe(...)` (так само `tx.unsafe(...)` всередині `sql.begin`) **заборонено**, окрім випадків, коли **обидві** умови виконані:
+
+1. значення підставляється з **коду** — константа, конфіг, whitelist; **не з user input**;
+2. треба підставити те, що **не можна параметризувати** через tagged template:
+   - назву **таблиці**,
+   - назву **колонки**,
+   - **dynamic SQL / DDL** (`CREATE`, `ALTER`, `DROP`, multi-statement migration, серверні `SET`/`SHOW` і подібне).
+
+В усіх інших випадках — переробити на звичайний tagged template `sql\`...\${value}...\``: значення біндяться як параметри й injection не лишається.
 
-### Не використовувати `sql.unsafe(...)` з конкатенацією
+Кожен легітимний `sql.unsafe(...)` має супроводжуватись **маркером-коментарем** з причиною — на тому ж рядку (trailing) або на рядку безпосередньо перед викликом. Маркер — opt-in для перевірки `js-bun-db` і слід для ревʼюера:
 
 ```javascript
-// ❌ конкатенація даних у SQL — SQL injection
+// allow-unsafe: DDL — назву таблиці параметризувати не можна
+await sql.unsafe(`CREATE TABLE ${tableName} (id int)`)
+
+await sql.unsafe('SELECT pg_advisory_lock($1)', [lockId]) // allow-unsafe: pg_advisory_lock — окремий шлях, без tagged template
+```
+
+Формат маркера: `allow-unsafe: <непорожня причина>` у line- або block-коментарі. Без причини (`// allow-unsafe:`) і без маркера взагалі — **fail** перевірки.
+
+❌ Заборонені кейси (треба переробити на tagged template):
+
+```javascript
+// ❌ дані від користувача — параметризуй через tagged template
 await sql.unsafe(`SELECT * FROM users WHERE id = ${userId}`)
 
 // ❌ навіть у tagged template — динамічний список через .join(',')
 await sql`SELECT * FROM users WHERE id IN (${ids.join(',')})`
 ```
 
-`sql.unsafe(text, params)` допустимий лише для **статичного** SQL без даних від користувача (наприклад, разовий DDL-скрипт), і обов'язково з масивом параметрів — ніяких `${...}` у самому рядку.
-
 Для динамічних списків — `sql([...])` або `sql(rows, 'colA', 'colB')`, **не** `.join(',')`.
 
+## Прибирати pg-leftover виклики (`.connect()`, `.end()`)
+
+У файлах з Bun SQL (`import { sql, SQL } from 'bun'`) залишки від `pg` — `pool.connect()`, `client.end()`, `pool.end()` — мають бути видалені. Bun SQL пулом керує сам: на першому запиті підключається, idle/lifetime закриває за конфігом — окремий життєвий цикл вручну не потрібен.
+
+```javascript
+// ❌ pg-leftover: ручний lifecycle, який Bun SQL робить за тебе
+const client = await pool.connect()
+try {
+  await client.query('...')
+} finally {
+  await client.end()
+}
+
+// ✅ Bun SQL — без явних .connect()/.end()
+await sql`...`
+```
+
+Якщо виклик дійсно потрібен (наприклад, `sql.end()` у graceful shutdown або `.connect()` на сторонньому об'єкті, що випадково ділить імʼя методу), додай маркер `// allow-pg-leftover: <причина>` на тому ж рядку (trailing) або на рядку безпосередньо перед викликом:
+
+```javascript
+// allow-pg-leftover: graceful shutdown — закриваємо пул перед exit
+await sql.end()
+
+ws.connect(url) // allow-pg-leftover: WebSocket, не pg
+```
+
+Формат маркера: `allow-pg-leftover: <непорожня причина>` у line- або block-коментарі. Без маркера й без причини — **fail** перевірки.
+
+## Що НЕ робити
+
 ### Не створювати підключення на кожен запит
 
 ```javascript

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nitra/cursor",
-  "version": "1.8.159",
+  "version": "1.8.161",
   "description": "CLI для завантаження cursor-правил (префікс n-) у локальний репозиторій",
   "keywords": [
     "cli",

package/scripts/check-js-bun-db.mjs

@@ -10,7 +10,14 @@
  * 2) Якщо в коді використовується Bun SQL (імпорт `sql`/`SQL` з `'bun'`), додатково
  *    перевіряє небезпечні патерни:
  *    - `new SQL(...)` всередині функції (пул має бути singleton на рівні модуля).
- *    - `sql.unsafe(\`...${expr}...\`)` (інтерполяція даних у `unsafe` ламає параметризацію).
+ *    - Будь-який `<obj>.unsafe(...)` без маркера-коментаря `// allow-unsafe: <reason>`
+ *      на тому ж рядку або рядком вище. `sql.unsafe` за замовчуванням заборонено;
+ *      допустимий лише для підстановки назви таблиці/колонки чи dynamic SQL/DDL,
+ *      коли значення контролюється кодом (не user input) — в інших випадках
+ *      переробляємо на tagged template `sql\`...\${value}...\``.
+ *    - pg-leftover виклики `<obj>.connect(...)` / `<obj>.end(...)` у файлах, що
+ *      імпортують Bun SQL: пулом керує Bun, життєвий цикл вручну не потрібен.
+ *      Opt-out — маркер `// allow-pg-leftover: <reason>`.
  *    - Динамічні SQL-списки через `.join(',')` у `IN (...)` / `VALUES (...)`
  *      (треба `sql([...])`).
  */
@@ -21,9 +28,10 @@ import { join, relative, sep } from 'node:path'
 import { createCheckReporter } from './utils/check-reporter.mjs'
 import {
   findBunSqlPerRequestConnectionInText,
+  findBunSqlPgLeftoverCallInText,
+  findBunSqlUnsafeUseWithoutAllowMarkerInText,
   findUnsafeBunSqlDynamicSqlListInText,
   findUnsafeBunSqlInListMissingEmptyGuardInText,
-  findUnsafeBunSqlUnsafeCallInText,
   isBunSqlScanSourceFile,
   textHasBunSqlImport
 } from './utils/bun-sql-scan.mjs'
@@ -124,7 +132,7 @@ async function checkForbiddenDependencies(pkgJsonPaths, repoRoot, reporter) {
  */
 async function scanSourcesForBunSqlPatterns(sourcePaths, repoRoot, reporter) {
   const { fail } = reporter
-  const counts = { perRequest: 0, unsafeCall: 0, dynamicList: 0, inListGuard: 0 }
+  const counts = { perRequest: 0, unsafeCall: 0, dynamicList: 0, inListGuard: 0, pgLeftover: 0 }
   let hasBunSqlImport = false
 
   for (const absPath of sourcePaths) {
@@ -144,7 +152,7 @@ async function scanSourcesForBunSqlPatterns(sourcePaths, repoRoot, reporter) {
  * @param {string} content вміст файлу
  * @param {string} rel posix-шлях відносно `repoRoot`
  * @param {(msg: string) => void} fail callback при помилці
- * @param {{ perRequest: number, unsafeCall: number, dynamicList: number, inListGuard: number }} counts акумулятори
+ * @param {{ perRequest: number, unsafeCall: number, dynamicList: number, inListGuard: number, pgLeftover: number }} counts акумулятори
  * @returns {void}
  */
 function scanFileForBunSqlPatterns(content, rel, fail, counts) {
@@ -155,11 +163,23 @@ function scanFileForBunSqlPatterns(content, rel, fail, counts) {
         `тримай singleton на рівні модуля (js-bun-db.mdc): ${v.snippet}`
     )
   }
-  for (const v of findUnsafeBunSqlUnsafeCallInText(content, rel)) {
+  for (const v of findBunSqlUnsafeUseWithoutAllowMarkerInText(content, rel)) {
     counts.unsafeCall++
     fail(
-      `js-bun-db: ${rel}:${v.line} — sql.unsafe(\`...\${...}...\`) недопустимо: ` +
-        `використовуй tagged template sql\`...\${value}...\` або sql.unsafe('static', [params]) (js-bun-db.mdc): ${v.snippet}`
+      `js-bun-db: ${rel}:${v.line} — sql.unsafe(...) заборонено за замовчуванням; ` +
+        `допустимо лише для підстановки назви таблиці/колонки чи dynamic SQL/DDL з code-controlled значенням, ` +
+        `інакше переробити на tagged template sql\`...\${value}...\`. ` +
+        `Якщо випадок легітимний — додай маркер "// allow-unsafe: <причина>" на тому ж рядку або рядком вище ` +
+        `(js-bun-db.mdc): ${v.snippet}`
+    )
+  }
+  for (const v of findBunSqlPgLeftoverCallInText(content, rel)) {
+    counts.pgLeftover++
+    fail(
+      `js-bun-db: ${rel}:${v.line} — pg-leftover виклик .${v.methodName}(...): Bun SQL пулом керує сам, ` +
+        `видали зайвий .connect()/.end() або, якщо випадок легітимний (graceful shutdown тощо), ` +
+        `додай маркер "// allow-pg-leftover: <причина>" на тому ж рядку або рядком вище ` +
+        `(js-bun-db.mdc): ${v.snippet}`
     )
   }
   for (const v of findUnsafeBunSqlDynamicSqlListInText(content, rel)) {
@@ -230,11 +250,8 @@ export async function check() {
     return reporter.getExitCode()
   }
 
-  const { hasBunSqlImport, perRequest, unsafeCall, dynamicList, inListGuard } = await scanSourcesForBunSqlPatterns(
-    sourcePaths,
-    repoRoot,
-    reporter
-  )
+  const { hasBunSqlImport, perRequest, unsafeCall, dynamicList, inListGuard, pgLeftover } =
+    await scanSourcesForBunSqlPatterns(sourcePaths, repoRoot, reporter)
 
   if (!hasBunSqlImport) {
     pass("js-bun-db: Bun SQL не використовується в коді (немає import { sql|SQL } from 'bun')")
@@ -245,7 +262,13 @@ export async function check() {
     pass('js-bun-db: немає створення new SQL(...) всередині функцій (singleton на рівні модуля)')
   }
   if (unsafeCall === 0) {
-    pass('js-bun-db: немає небезпечних викликів sql.unsafe з інтерполяцією в шаблонному рядку')
+    pass('js-bun-db: усі sql.unsafe(...) або відсутні, або супроводжуються маркером "// allow-unsafe: <причина>"')
+  }
+  if (pgLeftover === 0) {
+    pass(
+      'js-bun-db: немає pg-leftover викликів .connect()/.end() у файлах з Bun SQL ' +
+        '(або всі вони мають маркер "// allow-pg-leftover: <причина>")'
+    )
   }
   if (dynamicList === 0) {
     pass("js-bun-db: немає небезпечних динамічних SQL-списків через .join(',') у IN/VALUES")

package/scripts/utils/ast-scan-utils.mjs

@@ -112,6 +112,29 @@ export function parseProgramOrNull(content, virtualPath) {
   return result.program
 }
 
+/**
+ * Парсить файл і повертає `{ program, comments }` або null. Окремий вхід для перевірок,
+ * яким потрібні коментарі (наприклад, маркер `// allow-unsafe: ...` біля виклику) —
+ * базовий `parseProgramOrNull` свідомо лишається без коментарів, щоб не змінювати API.
+ * @param {string} content вихідний код
+ * @param {string} virtualPath шлях для вибору `lang` (також для діагностики)
+ * @returns {{ program: unknown, comments: { type: 'Line' | 'Block', value: string, start: number, end: number }[] } | null}
+ */
+export function parseProgramAndCommentsOrNull(content, virtualPath) {
+  const lang = langFromPath(virtualPath || 'scan.ts')
+  let result
+  try {
+    result = parseSync(virtualPath || 'scan.ts', content, { lang, sourceType: 'module' })
+  } catch {
+    return null
+  }
+  if (result.errors?.length) return null
+  return {
+    program: result.program,
+    comments: Array.isArray(result.comments) ? result.comments : []
+  }
+}
+
 /**
  * Чи це `.join(...)` виклик (типово для динамічних списків у SQL).
  * @param {unknown} node AST node

package/scripts/utils/bun-sql-scan.mjs

@@ -4,9 +4,11 @@
  * Знаходить:
  * - `new SQL(...)` всередині функції — пул має бути singleton на рівні модуля,
  *   а не на кожен виклик handler-а.
- * - Виклик `sql.unsafe(\`...${expr}...\`)` з даними у TemplateLiteral —
- *   `sql.unsafe` приймає лише статичний SQL (плюс масив параметрів); інтерполяція
- *   у текст руйнує параметризацію і відкриває SQL injection.
+ * - Будь-який виклик `<obj>.unsafe(...)` без маркера-коментаря `// allow-unsafe: <reason>`
+ *   на тому ж рядку або рядком вище. `sql.unsafe` за замовчуванням заборонено: дозволено
+ *   тільки якщо значення контролюється кодом (не user input) і потрібно підставити
+ *   назву таблиці/колонки або dynamic SQL/DDL. Інакше — переробити на tagged template
+ *   `sql\`...\${value}...\``. Маркер фіксує цю причину для ревʼюера.
  * - Динамічні SQL-списки у tagged template `sql\`... IN (${arr.join(',')}) ...\``:
  *   навіть «через tagged template» у запит потрапляє готовий шматок SQL замість
  *   параметризованих значень — треба `sql([...])`.
@@ -21,6 +23,7 @@ import {
   isSqlListContextTemplate,
   normalizeSnippet,
   offsetToLine,
+  parseProgramAndCommentsOrNull,
   parseProgramOrNull,
   walkAstWithAncestors
 } from './ast-scan-utils.mjs'
@@ -28,6 +31,17 @@ import {
 const SOURCE_FILE_RE = /\.([cm]?[jt]sx?)$/u
 const BUN_SQL_IMPORT_RE = /\bimport\s*\{[\s\S]*?\b(sql|SQL)\b[\s\S]*?\}\s*from\s*["']bun["']/u
 const IN_PLACEHOLDER_END_RE = /\bin\s*(\(\s*)?$/iu
+// `// allow-unsafe: <reason>` — `allow-unsafe`, двокрапка, **непорожня** причина.
+// Без причини маркер не приймається: ціль — лишити слід для ревʼюера, а не «німий» прапорець.
+const ALLOW_UNSAFE_MARKER_RE = /\ballow-unsafe\s*:\s*\S+/u
+// `// allow-pg-leftover: <reason>` — opt-in для виправданих `.connect()` / `.end()`
+// у файлах з Bun SQL (наприклад, `sql.end()` у graceful shutdown або `.connect()`
+// на сторонньому об'єкті, що випадково ділить імʼя методу з `pg`).
+const ALLOW_PG_LEFTOVER_MARKER_RE = /\ballow-pg-leftover\s*:\s*\S+/u
+// pg-API, які не потрібні з Bun SQL: pool/client життєвий цикл вручну.
+// `release` не входить — Bun SQL такого методу не має, а `.connect()` / `.end()`
+// формально існують і там, тому опт-аут маркером лишається доречним.
+const PG_LEFTOVER_METHOD_NAMES = new Set(['connect', 'end'])
 
 /**
  * @param {unknown} node AST node
@@ -192,23 +206,65 @@ function isNewSqlConstructor(node) {
 }
 
 /**
- * Чи це виклик `<obj>.unsafe(...)` з TemplateLiteral як першим аргументом і expressions усередині нього.
- * Допустимий лише `sql.unsafe('static text', [params])`; з `${...}` у TemplateLiteral — небезпечно.
+ * Чи це виклик `<obj>.unsafe(...)` (будь-який обʼєкт, не тільки `sql`).
+ * Файл сканується лише якщо є `import { sql|SQL } from 'bun'`, тож у практиці це
+ * або `sql.unsafe`, або `tx.unsafe` всередині `sql.begin(async tx => ...)` —
+ * обидва однаково небезпечні, тому розрізняти імʼя обʼєкта не треба.
  * @param {unknown} node AST node
- * @returns {boolean} true для небезпечного `sql.unsafe(\`... ${x} ...\`)`
+ * @returns {boolean} true для будь-якого `<obj>.unsafe(...)`
  */
-function isUnsafeCallWithInterpolatedTemplate(node) {
+function isUnsafeCall(node) {
   if (!node || node.type !== 'CallExpression') return false
   const callee = node.callee
   if (!callee || callee.type !== 'MemberExpression' || callee.computed) return false
   const prop = callee.property
-  if (!prop || prop.type !== 'Identifier' || prop.name !== 'unsafe') return false
-  const args = node.arguments
-  if (!Array.isArray(args) || args.length === 0) return false
-  const first = args[0]
-  if (!first || first.type !== 'TemplateLiteral') return false
-  const expressions = first.expressions
-  return Array.isArray(expressions) && expressions.length > 0
+  return !!prop && prop.type === 'Identifier' && prop.name === 'unsafe'
+}
+
+/**
+ * Чи є біля виклику маркер-коментар, що матчиться на `markerRe`, на тому ж рядку,
+ * що й початок виклику, або на рядку, що передує початку виклику. Це навмисно строга
+ * суміжність: відірваний коментар через порожній рядок не зараховується — щоб маркер
+ * стояв саме біля виклику, а не «загубився десь вище».
+ *
+ * Використовується для opt-in маркерів типу `// allow-unsafe: ...` і `// allow-pg-leftover: ...`.
+ * @param {{ start: number }} callNode виклик
+ * @param {{ type: 'Line' | 'Block', value: string, start: number, end: number }[]} comments коментарі з парсера
+ * @param {string} content вихідний код
+ * @param {RegExp} markerRe регекс, що валідує текст маркера в `comment.value`
+ * @returns {boolean} true, якщо маркер знайдено
+ */
+function hasMarkerCommentNear(callNode, comments, content, markerRe) {
+  const callStartLine = offsetToLine(content, callNode.start)
+  for (const c of comments) {
+    if (!c || (c.type !== 'Line' && c.type !== 'Block')) continue
+    if (typeof c.value !== 'string' || !markerRe.test(c.value)) continue
+    const startLine = offsetToLine(content, c.start)
+    const endLine = offsetToLine(content, c.end)
+    // trailing-коментар на тому ж рядку (`<call> // marker: ...`)
+    if (startLine === callStartLine) return true
+    // коментар на рядку, що безпосередньо передує виклику — для блокових
+    // коментарів важливим є саме `endLine`, бо block може займати кілька рядків.
+    if (endLine === callStartLine - 1) return true
+  }
+  return false
+}
+
+/**
+ * Чи це pg-leftover виклик: `<obj>.connect(...)` або `<obj>.end(...)`. Bun SQL пулом
+ * керує сам — і `.connect()`, і `.end()` у файлах з Bun SQL зазвичай зайві, тож такі
+ * виклики прапоруються (з opt-in маркером для рідкісних легітимних випадків).
+ * @param {unknown} node AST node
+ * @returns {{ name: 'connect' | 'end' } | null} ім'я pg-leftover методу або null
+ */
+function asPgLeftoverCall(node) {
+  if (!node || node.type !== 'CallExpression') return null
+  const callee = node.callee
+  if (!callee || callee.type !== 'MemberExpression' || callee.computed) return null
+  const prop = callee.property
+  if (!prop || prop.type !== 'Identifier' || typeof prop.name !== 'string') return null
+  if (!PG_LEFTOVER_METHOD_NAMES.has(prop.name)) return null
+  return { name: /** @type {'connect' | 'end'} */ (prop.name) }
 }
 
 /**
@@ -236,19 +292,28 @@ export function findBunSqlPerRequestConnectionInText(content, virtualPath = 'sca
 }
 
 /**
- * Знаходить виклики `sql.unsafe(\`...${...}...\`)` (TemplateLiteral з expressions).
+ * Знаходить виклики `<obj>.unsafe(...)` без маркера-коментаря `// allow-unsafe: <reason>`
+ * на тому ж рядку або рядком вище. `sql.unsafe` за замовчуванням заборонено: дозволено
+ * лише коли значення контролюється кодом (не user input) і потрібно підставити те, що
+ * не можна параметризувати — назву таблиці/колонки або dynamic SQL/DDL. У всіх інших
+ * випадках — переробити на tagged template `sql\`...\${value}...\``.
+ *
+ * Маркер-коментар фіксує причину для ревʼюера й одночасно слугує opt-in: без нього
+ * перевірка падає, навіть якщо у `unsafe` лежить статичний рядок без інтерполяції.
  * @param {string} content вихідний код
  * @param {string} [virtualPath] шлях для вибору `lang`
  * @returns {{ line: number, snippet: string }[]} список порушень
  */
-export function findUnsafeBunSqlUnsafeCallInText(content, virtualPath = 'scan.ts') {
-  const program = parseProgramOrNull(content, virtualPath)
-  if (!program) return []
+export function findBunSqlUnsafeUseWithoutAllowMarkerInText(content, virtualPath = 'scan.ts') {
+  const parsed = parseProgramAndCommentsOrNull(content, virtualPath)
+  if (!parsed) return []
+  const { program, comments } = parsed
 
   /** @type {{ line: number, snippet: string }[]} */
   const out = []
   walkAstWithAncestors(program, [], node => {
-    if (!isUnsafeCallWithInterpolatedTemplate(node)) return
+    if (!isUnsafeCall(node)) return
+    if (hasMarkerCommentNear(node, comments, content, ALLOW_UNSAFE_MARKER_RE)) return
     out.push({
       line: offsetToLine(content, node.start),
       snippet: normalizeSnippet(content.slice(node.start, node.end))
@@ -257,6 +322,39 @@ export function findUnsafeBunSqlUnsafeCallInText(content, virtualPath = 'scan.ts
   return out
 }
 
+/**
+ * Знаходить pg-leftover виклики `<obj>.connect(...)` / `<obj>.end(...)` без маркера
+ * `// allow-pg-leftover: <reason>` у файлах, де **в цьому ж файлі** є `import { sql|SQL } from 'bun'`.
+ *
+ * Скоп навмисно вузький: ці метод-імена занадто загальні (WebSocket, Stream, інші бібліотеки),
+ * тож сканер обмежений файлами, що вже використовують Bun SQL — там pg-залишок є явним
+ * багом міграції. У не-Bun-SQL файлах прапоратися не буде, навіть якщо проєкт у цілому
+ * мігрував.
+ * @param {string} content вихідний код
+ * @param {string} [virtualPath] шлях для вибору `lang`
+ * @returns {{ line: number, snippet: string, methodName: 'connect' | 'end' }[]} список порушень
+ */
+export function findBunSqlPgLeftoverCallInText(content, virtualPath = 'scan.ts') {
+  if (!textHasBunSqlImport(content)) return []
+  const parsed = parseProgramAndCommentsOrNull(content, virtualPath)
+  if (!parsed) return []
+  const { program, comments } = parsed
+
+  /** @type {{ line: number, snippet: string, methodName: 'connect' | 'end' }[]} */
+  const out = []
+  walkAstWithAncestors(program, [], node => {
+    const m = asPgLeftoverCall(node)
+    if (!m) return
+    if (hasMarkerCommentNear(node, comments, content, ALLOW_PG_LEFTOVER_MARKER_RE)) return
+    out.push({
+      line: offsetToLine(content, node.start),
+      snippet: normalizeSnippet(content.slice(node.start, node.end)),
+      methodName: m.name
+    })
+  })
+  return out
+}
+
 /**
  * Знаходить динамічні SQL-списки у TaggedTemplateExpression / TemplateLiteral в контексті
  * `IN (...)` або `VALUES (...)`, де серед expressions є виклик `.join(...)`.