@nitra/cursor 1.8.143 → 1.8.145

package/bin/auto-rules.md

@@ -22,6 +22,8 @@ js-pino - якщо присутній хоч один js файл, не в мо
 
 js-mssql - якщо в хоч одному package.json в секції dependencies присутній пакет mssql
 
+js-bun-db - якщо в хоч одному package.json в секції dependencies присутній пакет pg або mysql2 або є імпорт sql/SQL з Bun (приклад: import { sql } from "bun")
+
 k8s - якщо присутня хоч одна директорія k8s
 
 nginx-default-tpl - якщо присутній хоч один файл з переліку - default.conf.template, default.conf, nginx.conf

package/mdc/js-bun-db.mdc

@@ -0,0 +1,118 @@
+---
+description: Використання pg / mysql2 / Bun SQL у Node.js та Bun
+alwaysApply: true
+version: '1.1'
+---
+
+## Підтримувані версії баз даних
+
+PostgreSQL 18+, MariaDB 10.6+ (сумісний з MySQL-протоколом, підключаємось як `mysql://`).
+
+## Заміна на Bun native SQL
+
+Якщо в проєкті використовуються бібліотеки `pg` або `mysql2`, їх потрібно замінити на Bun native SQL: <https://bun.com/docs/runtime/sql>.
+
+- Видалити з `dependencies`: `pg`, `pg-pool`, `pg-native`, `mysql`, `mysql2`.
+- Видалити з коду: усі `import` / `require` цих пакетів та власні обгортки над ними.
+- Замінити на `import { sql, SQL } from 'bun'` — Bun має вбудований клієнт із пулом, prepared statements та tagged templates.
+
+## Підключення (singleton + env)
+
+Дефолтний експорт `sql` з `'bun'` сам читає змінні середовища (`DATABASE_URL`, `POSTGRES_URL`, `MYSQL_URL`, `PGHOST`/`PGUSER`/... та `MYSQL_HOST`/`MYSQL_USER`/...) і керує пулом — окремий `Pool` як у `pg` створювати не треба.
+
+Для явного конфігу — `new SQL(...)` як **singleton** на рівні модуля, а не на кожен запит:
+
+```javascript
+// db.js
+import { SQL } from 'bun'
+
+export const sql = new SQL({
+  url: process.env.DATABASE_URL,
+  max: 20,
+  idleTimeout: 30,
+  connectionTimeout: 10
+})
+```
+
+Connection string обирає адаптер автоматично:
+
+- `postgres://...` / `postgresql://...` → PostgreSQL
+- `mysql://...` / `mysql2://...` → MySQL/MariaDB
+- `sqlite://...` / `file://...` / `:memory:` → SQLite
+
+## Як виконувати запити (безпечно)
+
+Тільки **tagged template** з `${...}` — Bun сам біндить позиційні параметри й захищає від SQL injection:
+
+```javascript
+import { sql } from 'bun'
+
+const userId = 42
+const status = 'active'
+
+const users = await sql`
+  SELECT * FROM users
+  WHERE id = ${userId} AND status = ${status}
+`
+```
+
+Об'єктний INSERT/UPDATE та `IN (...)` — через helper `sql(...)`:
+
+```javascript
+const user = { name: 'Alice', email: 'a@example.com' }
+
+const [created] = await sql`
+  INSERT INTO users ${sql(user)}
+  RETURNING *
+`
+
+await sql`UPDATE users SET ${sql(user, 'name', 'email')} WHERE id = ${created.id}`
+
+const ids = [1, 2, 3]
+await sql`SELECT * FROM users WHERE id IN ${sql(ids)}`
+```
+
+Транзакції — через `sql.begin` (auto-commit/rollback), вкладені — через `tx.savepoint`:
+
+```javascript
+await sql.begin(async tx => {
+  await tx`INSERT INTO users ${sql(user)}`
+  await tx`UPDATE accounts SET balance = balance - ${100} WHERE user_id = ${user.id}`
+})
+```
+
+## Що НЕ робити
+
+### Не використовувати `sql.unsafe(...)` з конкатенацією
+
+```javascript
+// ❌ конкатенація даних у SQL — SQL injection
+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(',')`.
+
+### Не створювати підключення на кожен запит
+
+```javascript
+// ❌ нове підключення/інстанс на кожен виклик
+function getUser(id) {
+  const sql = new SQL(process.env.DATABASE_URL)
+  return sql`SELECT * FROM users WHERE id = ${id}`
+}
+```
+
+`new SQL(...)` має створюватись **один раз** на рівні модуля. Bun сам тримає пул (`max`, `idleTimeout`, `maxLifetime`) — окремих `Pool`/`Client` як у `pg` не потрібно.
+
+### Не лишати `pg` / `mysql2` поряд із Bun SQL
+
+Якщо в коді з'явився `import { sql } from 'bun'`, то `pg` та `mysql2` мають бути прибрані і з `dependencies`, і з імпортів — щоб не лишалось двох паралельних шляхів до БД.
+
+## Перевірка
+
+`npx @nitra/cursor check js-bun-db`.

package/mdc/js-mssql.mdc

@@ -1,7 +1,7 @@
 ---
 description: Використання mssql в nodejs
 alwaysApply: true
-version: '1.1'
+version: '1.2'
 ---
 
 ## Підтримувана версія SQL Server
@@ -160,4 +160,30 @@ WHERE NOT EXISTS (
 - ліміт на кількість елементів (наприклад 5k/10k — залежить від вашого потоку).
 - `supplierId`/ID: число/BigInt, валідне та скінченне.
 
+## Парсинг значень для `IN (${...})`
+
+Якщо `IN (...)` все ж використовується (а не `JOIN` на TVP), значення в `${...}` **обовʼязково** мають бути попередньо приведені числовим парсером і відфільтровані від `NaN`. Це знімає будь-яку можливість SQL injection: SQL-метасимволи в `Number`/`parseInt(...)` перетворюються на `NaN` і відсіюються.
+
+```javascript
+// ❌ НЕ МОЖНА: значення з req.body / зовнішнього джерела без парсингу
+const outIds = pgQ.rows.flatMap(x => x.req_body.Orders.map(o => o.OutletId))
+await pool.query(/* sql */ String.raw`
+  SELECT ... WHERE so.OutletId IN (${outIds})
+`)
+```
+
+```javascript
+// ✅ МОЖНА: parseInt + filter(!isNaN) гарантує, що в SQL потраплять лише числа
+const outIds = pgQ.rows
+  .flatMap(x => x.req_body.Orders.map(o => parseInt(o.OutletId)))
+  .filter(n => !isNaN(n))
+await pool.request().query`
+  SELECT ... WHERE so.OutletId IN (${outIds})
+`
+```
+
+Допустимі парсери: `parseInt(...)`, `parseFloat(...)`, `Number(...)`, `BigInt(...)` або унарний `+x`. Літеральні масиви чисел (`[1, 2, 3]`) теж безпечні — без парсера, але без жодних рядків.
+
+Це правило діє і для безпечного `pool.request().query\`...\`` (де mssql сам параметризує масив), і поготів для `pool.query(String.raw\`...\`)` чи `pool.query(\`...\`)`, де такий парсинг — єдиний бар'єр.
+
 Перевірка: `npx @nitra/cursor check js-mssql`.

package/mdc/vue.mdc

@@ -1,7 +1,7 @@
 ---
 description: Vue
 alwaysApply: true
-version: '1.2'
+version: '1.3'
 ---
 
 # Vue 3 Composition API — правила для .cursorrules
@@ -111,6 +111,7 @@ const additionalInstructions = `
 - Якість коду: **ESLint** + **eslint-plugin-vue**; форматування — **oxfmt**, див. `text.mdc`.
 - Збірка та dev-сервер — **Vite**
 - **Vue Devtools** для дебагу; продакшен-збірка — **`vite build`**, оптимізація асетів і кешування на рівні деплою / CDN.
+- **esbuild заборонено:** у проєкті не має бути залежності `esbuild` і згадок `esbuild` у конфігах/коді. Якщо десь є налаштування або інструкції під `esbuild` — заміни на **rolldown**.
 
 ### CI/CD
 

package/package.json

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

package/scripts/auto-rules.mjs

@@ -1,7 +1,8 @@
 /**
  * Автовизначення правил і skills для `.n-cursor.json` за умовами з `npm/bin/auto-rules.md`.
  *
- * Модуль аналізує дерево проєкту (наявність файлів/директорій, `gql\`...\`` у source, кореневий
+ * Модуль аналізує дерево проєкту (наявність файлів/директорій, `gql\`...\`` у source,
+ * залежності `mssql` / `pg` / `mysql2` у `package.json`, імпорт `sql`/`SQL` з `bun`, кореневий
  * `package.json`) та повертає ідентифікатори правил і skills, які потрібно автододати.
  *
  * Також враховує винятки `disable-rules` і `disable-skills`: елементи з цих списків не
@@ -11,11 +12,13 @@ import { existsSync } from 'node:fs'
 import { readdir, readFile } from 'node:fs/promises'
 import { basename, join, relative } from 'node:path'
 
+import { textHasBunSqlImport } from './utils/bun-sql-scan.mjs'
 import {
   isGqlScanSourceFile,
   shouldSkipFileForGqlScan,
   sourceFileHasGqlTaggedTemplate
 } from './utils/graphql-gql-scan.mjs'
+import { contentForVueImportScan } from './utils/vue-forbidden-imports.mjs'
 
 /** Порядок автододавання правил відповідно до `auto-rules.md`. */
 export const AUTO_RULE_ORDER = Object.freeze([
@@ -27,6 +30,7 @@ export const AUTO_RULE_ORDER = Object.freeze([
   'graphql',
   'js-lint',
   'js-mssql',
+  'js-bun-db',
   'js-pino',
   'k8s',
   'nginx-default-tpl',
@@ -50,12 +54,25 @@ const IGNORED_DIR_NAMES = new Set(['node_modules', '.git', '.next', '.turbo'])
 const DEFAULT_DISABLED_LIST = Object.freeze([])
 
 /**
- * Чи є `mssql` у `dependencies` хоча б одного `package.json` у репозиторії.
+ * Чи містить текст джерела імпорт імені `sql` або `SQL` з `"bun"` (після витягування `<script>` у `.vue`).
+ * @param {string} content вміст файлу
+ * @param {string} relativePath шлях posix відносно кореня
+ * @returns {boolean}
+ */
+function sourceContentHasBunSqlImport(content, relativePath) {
+  return textHasBunSqlImport(contentForVueImportScan(content, relativePath))
+}
+
+/**
+ * Збирає, які з переданих ключів присутні в `dependencies` хоча б одного `package.json`.
  * @param {string} root абсолютний шлях до кореня репозиторію
- * @returns {Promise<boolean>} true, якщо знайдено `dependencies.mssql`
+ * @param {string[]} dependencyKeys імена залежностей (наприклад `mssql`, `pg`)
+ * @returns {Promise<Set<string>>} множина знайдених ключів
  */
-async function hasMssqlDependencyInAnyPackageJson(root) {
-  let found = false
+async function collectDependencyKeysPresentInPackageJsonTree(root, dependencyKeys) {
+  const wanted = new Set(dependencyKeys)
+  /** @type {Set<string>} */
+  const found = new Set()
 
   /**
    * Рекурсивний обхід каталогу з пропуском службових директорій.
@@ -63,7 +80,9 @@ async function hasMssqlDependencyInAnyPackageJson(root) {
    * @returns {Promise<void>}
    */
   async function walk(dir) {
-    if (found) return
+    if (found.size === wanted.size) {
+      return
+    }
     let entries
     try {
       entries = await readdir(dir, { withFileTypes: true })
@@ -71,7 +90,9 @@ async function hasMssqlDependencyInAnyPackageJson(root) {
       return
     }
     for (const entry of entries) {
-      if (found) return
+      if (found.size === wanted.size) {
+        return
+      }
       const absPath = join(dir, entry.name)
       if (entry.isDirectory()) {
         const isIgnoredDir = IGNORED_DIR_NAMES.has(entry.name)
@@ -82,9 +103,12 @@ async function hasMssqlDependencyInAnyPackageJson(root) {
         try {
           const parsed = JSON.parse(await readFile(absPath, 'utf8'))
           const deps = parsed?.dependencies
-          if (deps && typeof deps === 'object' && !Array.isArray(deps) && Object.hasOwn(deps, 'mssql')) {
-            found = true
-            return
+          if (deps && typeof deps === 'object' && !Array.isArray(deps)) {
+            for (const key of wanted) {
+              if (Object.hasOwn(deps, key)) {
+                found.add(key)
+              }
+            }
           }
         } catch {
           /* ігноруємо пошкоджені/недоступні package.json */
@@ -182,11 +206,40 @@ async function updateGqlFactFromFile(absPath, relPath, facts) {
   }
 }
 
+/**
+ * Чи сканувати файл на імпорт `sql`/`SQL` з `bun` (ті самі розширення й skip, що для gql).
+ * @param {string} relPath шлях posix відносно кореня
+ * @param {{ hasBunSqlImport: boolean }} facts агреговані факти
+ * @returns {boolean}
+ */
+function shouldScanFileForBunSql(relPath, facts) {
+  return !facts.hasBunSqlImport && isGqlScanSourceFile(relPath) && !shouldSkipFileForGqlScan(relPath)
+}
+
+/**
+ * Оновлює ознаку `hasBunSqlImport` за вмістом файлу.
+ * @param {string} absPath абсолютний шлях до файлу
+ * @param {string} relPath шлях posix відносно кореня
+ * @param {{ hasBunSqlImport: boolean }} facts агреговані факти
+ * @returns {Promise<void>}
+ */
+async function updateBunSqlFactFromFile(absPath, relPath, facts) {
+  try {
+    const content = await readFile(absPath, 'utf8')
+    if (sourceContentHasBunSqlImport(content, relPath)) {
+      facts.hasBunSqlImport = true
+    }
+  } catch {
+    /* ігноруємо пошкоджені/недоступні файли */
+  }
+}
+
 /**
  * Обробляє файл під час обходу дерева.
  * @param {string} absPath абсолютний шлях до файлу
  * @param {string} root абсолютний шлях кореня
  * @param {{
+ *   hasBunSqlImport: boolean,
  *   hasCapacitorConfig: boolean,
  *   hasDockerfile: boolean,
  *   hasGqlTaggedTemplates: boolean,
@@ -204,6 +257,9 @@ async function processFileEntry(absPath, root, facts) {
   if (shouldScanFileForGql(rel, facts)) {
     await updateGqlFactFromFile(absPath, rel, facts)
   }
+  if (shouldScanFileForBunSql(rel, facts)) {
+    await updateBunSqlFactFromFile(absPath, rel, facts)
+  }
 }
 
 /**
@@ -270,6 +326,7 @@ export function isMonorepoPackage(packageJson) {
  *   hasCapacitorConfig: boolean,
  *   hasDockerfile: boolean,
  *   hasGaWorkflowsDir: boolean,
+ *   hasBunSqlImport: boolean,
  *   hasGqlTaggedTemplates: boolean,
  *   hasJsLikeSource: boolean,
  *   hasK8sDir: boolean,
@@ -282,6 +339,7 @@ export function isMonorepoPackage(packageJson) {
  */
 export async function collectAutoRuleFacts(root) {
   const facts = {
+    hasBunSqlImport: false,
     hasCapacitorConfig: false,
     hasDockerfile: false,
     hasGaWorkflowsDir: existsSync(join(root, '.github', 'workflows')),
@@ -360,7 +418,9 @@ export async function detectAutoRulesAndSkills({
   )
   const isAbie = typeof repositoryUrl === 'string' && repositoryUrl.toLowerCase().includes(ABIE_REPOSITORY_URL_MARKER)
   const isMonorepo = isMonorepoPackage(packageJsonParsed)
-  const hasMssqlDependency = await hasMssqlDependencyInAnyPackageJson(root)
+  const depHits = await collectDependencyKeysPresentInPackageJsonTree(root, ['mssql', 'pg', 'mysql2'])
+  const hasMssqlDependency = depHits.has('mssql')
+  const hasJsBunDbSignal = depHits.has('pg') || depHits.has('mysql2') || facts.hasBunSqlImport
 
   /** @type {string[]} */
   const detectedRules = []
@@ -400,6 +460,7 @@ export async function detectAutoRulesAndSkills({
     { enabled: facts.hasGqlTaggedTemplates, id: 'graphql' },
     { enabled: facts.hasJsLikeSource, id: 'js-lint' },
     { enabled: hasMssqlDependency, id: 'js-mssql' },
+    { enabled: hasJsBunDbSignal, id: 'js-bun-db' },
     { enabled: facts.hasJsLikeSource && !(isMonorepo && facts.hasVueSource && facts.hasTempoDir), id: 'js-pino' },
     { enabled: facts.hasK8sDir, id: 'k8s' },
     { enabled: facts.hasNginxDefaultTplFile, id: 'nginx-default-tpl' },

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

@@ -0,0 +1,213 @@
+/**
+ * Перевіряє правило js-bun-db.mdc.
+ *
+ * 1) У жодному `package.json` (включно з workspace-пакетами) у `dependencies` не повинно
+ *    бути `pg` чи `mysql2` — ці бібліотеки треба замінити на Bun native SQL
+ *    (`import { sql, SQL } from 'bun'`, https://bun.com/docs/runtime/sql).
+ *
+ * 2) Якщо в коді використовується Bun SQL (імпорт `sql`/`SQL` з `'bun'`), додатково
+ *    перевіряє небезпечні патерни:
+ *    - `new SQL(...)` всередині функції (пул має бути singleton на рівні модуля).
+ *    - `sql.unsafe(\`...${expr}...\`)` (інтерполяція даних у `unsafe` ламає параметризацію).
+ *    - Динамічні SQL-списки через `.join(',')` у `IN (...)` / `VALUES (...)`
+ *      (треба `sql([...])`).
+ */
+import { existsSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { join, relative, sep } from 'node:path'
+
+import { createCheckReporter } from './utils/check-reporter.mjs'
+import {
+  findBunSqlPerRequestConnectionInText,
+  findUnsafeBunSqlDynamicSqlListInText,
+  findUnsafeBunSqlUnsafeCallInText,
+  isBunSqlScanSourceFile,
+  textHasBunSqlImport
+} from './utils/bun-sql-scan.mjs'
+import { walkDir } from './utils/walkDir.mjs'
+
+/** Імена забороненої залежності у будь-якому `package.json`. */
+const FORBIDDEN_DEPENDENCIES = Object.freeze(['pg', 'mysql2'])
+
+/**
+ * @param {unknown} v parsed JSON
+ * @returns {Record<string, unknown>} object або {}
+ */
+function asObject(v) {
+  if (!v || typeof v !== 'object' || Array.isArray(v)) return {}
+  return /** @type {Record<string, unknown>} */ (v)
+}
+
+/**
+ * Знаходить всі `package.json` у репозиторії (крім пропущених директорій у walkDir).
+ * @param {string} repoRoot абсолютний шлях до кореня репозиторію
+ * @returns {Promise<string[]>} абсолютні шляхи, відсортовані за відносним шляхом
+ */
+async function findAllPackageJsonPaths(repoRoot) {
+  /** @type {string[]} */
+  const paths = []
+  await walkDir(repoRoot, absPath => {
+    if (absPath.endsWith(`${sep}package.json`)) {
+      paths.push(absPath)
+    }
+  })
+  paths.sort((a, b) => relative(repoRoot, a).localeCompare(relative(repoRoot, b)))
+  return paths
+}
+
+/**
+ * Збирає абсолютні шляхи JS/TS джерел у репозиторії для скану Bun SQL патернів.
+ * @param {string} repoRoot абсолютний шлях до кореня репозиторію
+ * @returns {Promise<string[]>} абсолютні шляхи, відсортовані за відносним шляхом
+ */
+async function findAllSourcePathsForBunSqlScan(repoRoot) {
+  /** @type {string[]} */
+  const paths = []
+  await walkDir(repoRoot, absPath => {
+    const rel = relative(repoRoot, absPath).split('\\').join('/')
+    if (isBunSqlScanSourceFile(rel)) {
+      paths.push(absPath)
+    }
+  })
+  paths.sort((a, b) => relative(repoRoot, a).localeCompare(relative(repoRoot, b)))
+  return paths
+}
+
+/**
+ * Перевіряє, чи в кореневому `package.json` присутні заборонені пакети у `dependencies`.
+ * @param {string[]} pkgJsonPaths абсолютні шляхи всіх `package.json` у репо
+ * @param {string} repoRoot абсолютний шлях до кореня
+ * @param {{ pass: (m: string) => void, fail: (m: string) => void }} reporter
+ * @returns {Promise<number>} кількість знайдених порушень
+ */
+async function checkForbiddenDependencies(pkgJsonPaths, repoRoot, reporter) {
+  const { pass, fail } = reporter
+  let bad = 0
+  for (const absPath of pkgJsonPaths) {
+    const rel = relative(repoRoot, absPath).split('\\').join('/')
+    let parsed
+    try {
+      parsed = JSON.parse(await readFile(absPath, 'utf8'))
+    } catch {
+      fail(`js-bun-db: ${rel} — невалідний JSON`)
+      bad++
+      continue
+    }
+    const deps = asObject(parsed.dependencies)
+    for (const name of FORBIDDEN_DEPENDENCIES) {
+      if (Object.hasOwn(deps, name)) {
+        bad++
+        fail(
+          `js-bun-db: ${rel}: dependencies.${name} — замінити на Bun native SQL ` +
+            `(import { sql, SQL } from 'bun', https://bun.com/docs/runtime/sql) (js-bun-db.mdc)`
+        )
+      }
+    }
+  }
+  if (bad === 0) {
+    pass(`js-bun-db: жоден package.json не містить ${FORBIDDEN_DEPENDENCIES.join(' / ')} у dependencies`)
+  }
+  return bad
+}
+
+/**
+ * Сканує JS/TS-джерела на небезпечні патерни Bun SQL.
+ * @param {string[]} sourcePaths абсолютні шляхи джерел
+ * @param {string} repoRoot абсолютний шлях до кореня
+ * @param {{ pass: (m: string) => void, fail: (m: string) => void }} reporter
+ * @returns {Promise<{ hasBunSqlImport: boolean, perRequest: number, unsafeCall: number, dynamicList: number }>}
+ *   `hasBunSqlImport` — чи знайдено хоч один `import { sql|SQL } from 'bun'` у джерелах;
+ *   решта — кількість порушень кожного типу.
+ */
+async function scanSourcesForBunSqlPatterns(sourcePaths, repoRoot, reporter) {
+  const { fail } = reporter
+  let hasBunSqlImport = false
+  let perRequest = 0
+  let unsafeCall = 0
+  let dynamicList = 0
+
+  for (const absPath of sourcePaths) {
+    const rel = relative(repoRoot, absPath).split('\\').join('/')
+    const content = await readFile(absPath, 'utf8')
+    if (!hasBunSqlImport && textHasBunSqlImport(content)) {
+      hasBunSqlImport = true
+    }
+
+    for (const v of findBunSqlPerRequestConnectionInText(content, rel)) {
+      perRequest++
+      fail(
+        `js-bun-db: ${rel}:${v.line} — не створюй new SQL(...) всередині функцій; ` +
+          `тримай singleton на рівні модуля (js-bun-db.mdc): ${v.snippet}`
+      )
+    }
+    for (const v of findUnsafeBunSqlUnsafeCallInText(content, rel)) {
+      unsafeCall++
+      fail(
+        `js-bun-db: ${rel}:${v.line} — sql.unsafe(\`...\${...}...\`) недопустимо: ` +
+          `використовуй tagged template sql\`...\${value}...\` або sql.unsafe('static', [params]) (js-bun-db.mdc): ${v.snippet}`
+      )
+    }
+    for (const v of findUnsafeBunSqlDynamicSqlListInText(content, rel)) {
+      dynamicList++
+      fail(
+        `js-bun-db: ${rel}:${v.line} — заборонено підставляти у SQL динамічні списки через .join(',') ` +
+          `у IN (...) / VALUES (...); використовуй sql([...]) (js-bun-db.mdc): ${v.snippet}`
+      )
+    }
+  }
+
+  return { hasBunSqlImport, perRequest, unsafeCall, dynamicList }
+}
+
+/**
+ * Перевіряє відповідність проєкту правилу js-bun-db.mdc
+ * @returns {Promise<number>} 0 — все OK, 1 — є проблеми
+ */
+export async function check() {
+  const reporter = createCheckReporter()
+  const { pass } = reporter
+
+  const repoRoot = process.cwd()
+  const rootPkg = join(repoRoot, 'package.json')
+  if (!existsSync(rootPkg)) {
+    pass('js-bun-db: package.json у корені відсутній — перевірку пропущено')
+    return reporter.getExitCode()
+  }
+
+  const pkgJsonPaths = await findAllPackageJsonPaths(repoRoot)
+  if (pkgJsonPaths.length === 0) {
+    pass('js-bun-db: package.json не знайдено — перевірку пропущено')
+    return reporter.getExitCode()
+  }
+
+  await checkForbiddenDependencies(pkgJsonPaths, repoRoot, reporter)
+
+  const sourcePaths = await findAllSourcePathsForBunSqlScan(repoRoot)
+  if (sourcePaths.length === 0) {
+    pass('js-bun-db: немає JS/TS файлів для скану патернів Bun SQL')
+    return reporter.getExitCode()
+  }
+
+  const { hasBunSqlImport, perRequest, unsafeCall, dynamicList } = await scanSourcesForBunSqlPatterns(
+    sourcePaths,
+    repoRoot,
+    reporter
+  )
+
+  if (!hasBunSqlImport) {
+    pass("js-bun-db: Bun SQL не використовується в коді (немає import { sql|SQL } from 'bun')")
+    return reporter.getExitCode()
+  }
+
+  if (perRequest === 0) {
+    pass('js-bun-db: немає створення new SQL(...) всередині функцій (singleton на рівні модуля)')
+  }
+  if (unsafeCall === 0) {
+    pass('js-bun-db: немає небезпечних викликів sql.unsafe(`...${...}...`)')
+  }
+  if (dynamicList === 0) {
+    pass("js-bun-db: немає небезпечних динамічних SQL-списків через .join(',') у IN/VALUES")
+  }
+
+  return reporter.getExitCode()
+}

package/scripts/check-js-mssql.mjs

@@ -18,6 +18,7 @@ import {
   findSharedMssqlRequestInText,
   findUnsafeMssqlQueryTemplateCallInText,
   findUnsafeMssqlDynamicSqlListInText,
+  findUnsafeMssqlInListUnparsedInText,
   isMssqlScanSourceFile
 } from './utils/mssql-pool-scan.mjs'
 import { walkDir } from './utils/walkDir.mjs'
@@ -177,6 +178,7 @@ export async function check() {
     let sharedRequestViolations = 0
     let unsafeQueryCalls = 0
     let unsafeDynamicSqlLists = 0
+    let unparsedInLists = 0
     for (const absPath of sourcePaths) {
       const rel = relative(repoRoot, absPath).split('\\').join('/')
       const content = await readFile(absPath, 'utf8')
@@ -204,6 +206,12 @@ export async function check() {
           `js-mssql: ${rel}:${v.line} — заборонено підставляти у SQL динамічні списки через .join(',') (типово IN (...) / VALUES (...)); використовуй TVP (sql.Table) + JOIN/INSERT (js-mssql.mdc): ${v.snippet}`
         )
       }
+      for (const v of findUnsafeMssqlInListUnparsedInText(content, rel)) {
+        unparsedInLists++
+        fail(
+          `js-mssql: ${rel}:${v.line} — у SQL IN (\${...}) значення мають бути попередньо приведені числовим парсером (parseInt/Number/BigInt/parseFloat) і відфільтровані від NaN, інакше можливий SQL injection (js-mssql.mdc): ${v.snippet}`
+        )
+      }
     }
 
     if (violations === 0) {
@@ -218,6 +226,9 @@ export async function check() {
     if (unsafeDynamicSqlLists === 0) {
       pass("js-mssql: немає небезпечних динамічних SQL-списків через .join(',') у IN/VALUES")
     }
+    if (unparsedInLists === 0) {
+      pass('js-mssql: немає підстановок IN (${...}) без числового парсера значень')
+    }
   }
 
   return reporter.getExitCode()

package/scripts/check-vue.mjs

@@ -24,6 +24,98 @@ import { walkDir } from './utils/walkDir.mjs'
 import { getMonorepoPackageRootDirs } from './utils/workspaces.mjs'
 
 const MAJOR_VERSION_RE = /(\d+)/
+const ESBUILD_RE = /\besbuild\b/
+
+/**
+ * Визначає, чи можна сканувати файл як текст на згадки `esbuild`.
+ * @param {string} relPosix відносний шлях у posix-форматі
+ * @returns {boolean} true якщо файл варто перевірити
+ */
+function isEsbuildScanFile(relPosix) {
+  if (
+    relPosix.startsWith('node_modules/') ||
+    relPosix.startsWith('dist/') ||
+    relPosix.startsWith('build/') ||
+    relPosix.startsWith('coverage/') ||
+    relPosix.startsWith('.git/')
+  ) {
+    return false
+  }
+
+  const lower = relPosix.toLowerCase()
+  if (
+    lower === 'bun.lock' ||
+    lower === 'bun.lockb' ||
+    lower === 'package-lock.json' ||
+    lower === 'yarn.lock' ||
+    lower === 'pnpm-lock.yaml'
+  ) {
+    return false
+  }
+
+  return (
+    lower.endsWith('.js') ||
+    lower.endsWith('.mjs') ||
+    lower.endsWith('.cjs') ||
+    lower.endsWith('.ts') ||
+    lower.endsWith('.tsx') ||
+    lower.endsWith('.vue') ||
+    lower.endsWith('.json') ||
+    lower.endsWith('.jsonc') ||
+    lower.endsWith('.yaml') ||
+    lower.endsWith('.yml') ||
+    lower.endsWith('.md') ||
+    lower.endsWith('.mdc')
+  )
+}
+
+/**
+ * Сканує дерево пакета на згадки `esbuild` і підказує заміну на `rolldown`.
+ * @param {string} rootDir відносний шлях до пакета
+ * @param {string} absPackageRoot абсолютний шлях до кореня пакета
+ * @param {string} prefix параметр prefix
+ * @param {(msg: string) => void} passFn callback при успішній перевірці
+ * @param {(msg: string) => void} fail callback при помилці
+ */
+async function checkEsbuildMentions(rootDir, absPackageRoot, prefix, passFn, fail) {
+  /** @type {{ rel: string; line: number; snippet: string }[]} */
+  const hits = []
+
+  await walkDir(absPackageRoot, absPath => {
+    const rel = relative(absPackageRoot, absPath).split('\\').join('/')
+    if (!isEsbuildScanFile(rel)) return
+    hits.push({ rel, line: 0, snippet: '' })
+  })
+
+  // ми використали hits як буфер шляхів; зараз перетворимо на реальні співпадіння
+  /** @type {{ rel: string; line: number; snippet: string }[]} */
+  const matches = []
+  for (const { rel } of hits) {
+    const content = await readFile(join(absPackageRoot, rel), 'utf8')
+    if (!ESBUILD_RE.test(content)) continue
+
+    const lines = content.split('\n')
+    for (let i = 0; i < lines.length; i++) {
+      if (ESBUILD_RE.test(lines[i])) {
+        matches.push({ rel, line: i + 1, snippet: lines[i].trim() })
+        if (matches.length >= 30) break
+      }
+    }
+    if (matches.length >= 30) break
+  }
+
+  if (matches.length === 0) {
+    passFn(`${prefix}немає згадок 'esbuild' у джерелах пакета (очікується rolldown)`)
+    return
+  }
+
+  for (const m of matches) {
+    fail(`${prefix}${m.rel}:${m.line} — знайдено 'esbuild'. Замінити на 'rolldown'. Фрагмент: ${m.snippet}`)
+  }
+  if (matches.length >= 30) {
+    fail(`${prefix}показано перші 30 збігів 'esbuild' (замінити на 'rolldown')`)
+  }
+}
 
 /**
  * Формує зрозумілий для людини підпис пакета для повідомлень перевірки.
@@ -107,6 +199,9 @@ async function checkViteConfig(rootDir, prefix, passFn, fail) {
     return
   }
   const content = await readFile(join(rootDir, viteConfig), 'utf8')
+  if (ESBUILD_RE.test(content)) {
+    fail(`${prefix}${viteConfig} містить 'esbuild' — заміни на 'rolldown'`)
+  }
   const checks = [
     { token: 'VueMacros', ok: `${viteConfig} використовує VueMacros`, err: `${viteConfig} не містить VueMacros` },
     { token: 'AutoImport', ok: `${viteConfig} використовує AutoImport`, err: `${viteConfig} не містить AutoImport` }
@@ -175,6 +270,10 @@ async function checkVuePackage(rootDir, fail, passFn) {
   const devDeps = pkg.devDependencies || {}
   const allDeps = { ...deps, ...devDeps }
 
+  if (allDeps.esbuild) {
+    fail(`${prefix}esbuild заборонено (знайдено: ${allDeps.esbuild}). Замінити на rolldown та прибрати esbuild.`)
+  }
+
   checkRequiredDep(deps, 'vue', prefix, passFn, fail, 'vue відсутній в dependencies')
   checkViteVersion(devDeps, prefix, passFn, fail)
   checkRequiredDep(
@@ -205,6 +304,7 @@ async function checkVuePackage(rootDir, fail, passFn) {
 
   await checkViteConfig(rootDir, prefix, passFn, fail)
   await checkVueImportViolations(rootDir, join(process.cwd(), rootDir), prefix, passFn, fail)
+  await checkEsbuildMentions(rootDir, join(process.cwd(), rootDir), prefix, passFn, fail)
 }
 
 /**
@@ -215,17 +315,6 @@ export async function check() {
   const reporter = createCheckReporter()
   const { pass, fail } = reporter
 
-  if (existsSync('.vscode/extensions.json')) {
-    const ext = JSON.parse(await readFile('.vscode/extensions.json', 'utf8'))
-    if (ext.recommendations?.includes('Vue.volar')) {
-      pass('extensions.json містить Vue.volar')
-    } else {
-      fail('extensions.json не містить Vue.volar — додай до recommendations')
-    }
-  } else {
-    fail('.vscode/extensions.json не існує')
-  }
-
   const roots = await getMonorepoPackageRootDirs()
   /** @type {string[]} */
   const vueRoots = []
@@ -237,8 +326,23 @@ export async function check() {
     }
   }
 
+  if (vueRoots.length > 0) {
+    if (existsSync('.vscode/extensions.json')) {
+      const ext = JSON.parse(await readFile('.vscode/extensions.json', 'utf8'))
+      if (ext.recommendations?.includes('Vue.volar')) {
+        pass('extensions.json містить Vue.volar')
+      } else {
+        fail('extensions.json не містить Vue.volar — додай до recommendations')
+      }
+    } else {
+      fail('.vscode/extensions.json не існує (для Vue-проєкту потрібна рекомендація Vue.volar)')
+    }
+  } else {
+    pass('Vue.volar: пропущено (у repo немає пакетів з vue у dependencies)')
+  }
+
   if (vueRoots.length === 0) {
-    fail('vue не знайдено в dependencies жодного пакета (корінь репо та каталоги з кореневого workspaces)')
+    pass('vue не знайдено в dependencies жодного пакета (перевірка vue пропущена)')
     return reporter.getExitCode()
   }
 

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

@@ -0,0 +1,294 @@
+/**
+ * AST-сканер небезпечних патернів Bun SQL (`import { sql, SQL } from 'bun'`).
+ *
+ * Знаходить:
+ * - `new SQL(...)` всередині функції — пул має бути singleton на рівні модуля,
+ *   а не на кожен виклик handler-а.
+ * - Виклик `sql.unsafe(\`...${expr}...\`)` з даними у TemplateLiteral —
+ *   `sql.unsafe` приймає лише статичний SQL (плюс масив параметрів); інтерполяція
+ *   у текст руйнує параметризацію і відкриває SQL injection.
+ * - Динамічні SQL-списки у tagged template `sql\`... IN (${arr.join(',')}) ...\``:
+ *   навіть «через tagged template» у запит потрапляє готовий шматок SQL замість
+ *   параметризованих значень — треба `sql([...])`.
+ *
+ * Семантика — через **oxc-parser**, без regex по тексту коду.
+ * Якщо файл не парситься / містить синтаксичні помилки — повертаємо порожній
+ * результат: спочатку треба полагодити синтаксис, потім перезапустити перевірку.
+ */
+import { parseSync } from 'oxc-parser'
+
+const SOURCE_FILE_RE = /\.([cm]?[jt]sx?)$/u
+const SQL_LIST_CONTEXT_RE = /\b(in|values)\b\s*\(/iu
+const BUN_SQL_IMPORT_RE = /\bimport\s*\{[\s\S]*?\b(sql|SQL)\b[\s\S]*?\}\s*from\s*["']bun["']/u
+
+/**
+ * Мова для Oxc за шляхом файлу (розширення).
+ * @param {string} filePath віртуальний або реальний шлях до файлу
+ * @returns {'js' | 'jsx' | 'ts' | 'tsx'} значення опції `lang` для `parseSync`
+ */
+function langFromPath(filePath) {
+  const lower = filePath.toLowerCase()
+  if (lower.endsWith('.tsx')) return 'tsx'
+  if (lower.endsWith('.ts') || lower.endsWith('.mts') || lower.endsWith('.cts')) return 'ts'
+  if (lower.endsWith('.jsx')) return 'jsx'
+  return 'js'
+}
+
+/**
+ * Номер рядка (1-based) за зміщенням у буфері.
+ * @param {string} content повний текст файлу
+ * @param {number} offset байтове зміщення початку фрагмента
+ * @returns {number} номер рядка від 1
+ */
+function offsetToLine(content, offset) {
+  let line = 1
+  const n = Math.min(offset, content.length)
+  for (let i = 0; i < n; i++) {
+    if (content.codePointAt(i) === 10) line++
+  }
+  return line
+}
+
+/**
+ * Стискає пробіли для повідомлення про порушення.
+ * @param {string} s фрагмент коду
+ * @returns {string} скорочений однорядковий рядок
+ */
+function normalizeSnippet(s) {
+  return s.replaceAll(/\s+/gu, ' ').trim().slice(0, 180)
+}
+
+/**
+ * Чи є вузол функцією.
+ * @param {unknown} node AST node
+ * @returns {boolean} true, якщо це будь-який вузол-функція
+ */
+function isFunctionNode(node) {
+  return (
+    !!node &&
+    typeof node === 'object' &&
+    typeof node.type === 'string' &&
+    (node.type === 'FunctionDeclaration' ||
+      node.type === 'FunctionExpression' ||
+      node.type === 'ArrowFunctionExpression')
+  )
+}
+
+/**
+ * Рекурсивний обхід AST з предками, щоб визначати контекст (всередині функції чи ні).
+ * @param {unknown} node поточний вузол
+ * @param {unknown[]} ancestors масив предків від кореня до parent
+ * @param {(n: Record<string, unknown>, ancestors: unknown[]) => void} visit відвідувач для вузлів з `type`
+ * @returns {void}
+ */
+function walkAstWithAncestors(node, ancestors, visit) {
+  if (!node || typeof node !== 'object') return
+  if (Array.isArray(node)) {
+    for (const item of node) walkAstWithAncestors(item, ancestors, visit)
+    return
+  }
+
+  const rec = /** @type {Record<string, unknown>} */ (node)
+  if (typeof rec.type === 'string') {
+    visit(rec, ancestors)
+    ancestors = [...ancestors, rec]
+  }
+
+  for (const key of Object.keys(node)) {
+    if (key === 'parent') continue
+    const v = rec[key]
+    if (v && typeof v === 'object') {
+      walkAstWithAncestors(v, ancestors, visit)
+    }
+  }
+}
+
+/**
+ * Парсить файл та повертає program або null, якщо є синтаксичні помилки.
+ * @param {string} content вихідний код
+ * @param {string} virtualPath шлях для вибору `lang`
+ * @returns {unknown | null} `result.program` або null
+ */
+function parseProgramOrNull(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 result.program
+}
+
+/**
+ * Чи це `new SQL(...)` (Identifier callee з імʼям `SQL`).
+ * @param {unknown} node AST node
+ * @returns {boolean} true, якщо це `new SQL(...)`
+ */
+function isNewSqlConstructor(node) {
+  if (!node || node.type !== 'NewExpression') return false
+  const callee = node.callee
+  return !!callee && callee.type === 'Identifier' && callee.name === 'SQL'
+}
+
+/**
+ * Чи це виклик `<obj>.unsafe(...)` з TemplateLiteral як першим аргументом і expressions усередині нього.
+ * Допустимий лише `sql.unsafe('static text', [params])`; з `${...}` у TemplateLiteral — небезпечно.
+ * @param {unknown} node AST node
+ * @returns {boolean} true для небезпечного `sql.unsafe(\`... ${x} ...\`)`
+ */
+function isUnsafeCallWithInterpolatedTemplate(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
+}
+
+/**
+ * Чи це `.join(...)` виклик (типово для динамічних списків у SQL).
+ * @param {unknown} node AST node
+ * @returns {boolean} true, якщо це CallExpression `*.join(...)`
+ */
+function isJoinCall(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
+  return !!prop && prop.type === 'Identifier' && prop.name === 'join'
+}
+
+/**
+ * Текст quasis у TemplateLiteral (без expressions).
+ * @param {unknown} template TemplateLiteral
+ * @returns {string} обʼєднаний raw-текст
+ */
+function templateQuasisText(template) {
+  if (!template || template.type !== 'TemplateLiteral') return ''
+  const quasis = template.quasis
+  if (!Array.isArray(quasis) || quasis.length === 0) return ''
+  let out = ''
+  for (const q of quasis) {
+    if (!q || typeof q !== 'object') continue
+    const value = q.value
+    if (!value || typeof value !== 'object') continue
+    if (typeof value.raw === 'string') out += value.raw
+  }
+  return out
+}
+
+/**
+ * Чи виглядає TemplateLiteral як SQL-контекст зі списком (IN/VALUES (...)).
+ * @param {unknown} template TemplateLiteral
+ * @returns {boolean} true, якщо текст містить `IN (` або `VALUES (`
+ */
+function isSqlListContextTemplate(template) {
+  return SQL_LIST_CONTEXT_RE.test(templateQuasisText(template))
+}
+
+/**
+ * Знаходить `new SQL(...)` всередині функцій (handler на кожен запит замість singleton).
+ * @param {string} content вихідний код
+ * @param {string} [virtualPath] шлях для вибору `lang`
+ * @returns {{ line: number, snippet: string }[]} список порушень
+ */
+export function findBunSqlPerRequestConnectionInText(content, virtualPath = 'scan.ts') {
+  const program = parseProgramOrNull(content, virtualPath)
+  if (!program) return []
+
+  /** @type {{ line: number, snippet: string }[]} */
+  const out = []
+  walkAstWithAncestors(program, [], (node, ancestors) => {
+    if (!isNewSqlConstructor(node)) return
+    const insideFunction = ancestors.some(n => isFunctionNode(n))
+    if (!insideFunction) return
+    out.push({
+      line: offsetToLine(content, node.start),
+      snippet: normalizeSnippet(content.slice(node.start, node.end))
+    })
+  })
+  return out
+}
+
+/**
+ * Знаходить виклики `sql.unsafe(\`...${...}...\`)` (TemplateLiteral з expressions).
+ * @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 []
+
+  /** @type {{ line: number, snippet: string }[]} */
+  const out = []
+  walkAstWithAncestors(program, [], node => {
+    if (!isUnsafeCallWithInterpolatedTemplate(node)) return
+    out.push({
+      line: offsetToLine(content, node.start),
+      snippet: normalizeSnippet(content.slice(node.start, node.end))
+    })
+  })
+  return out
+}
+
+/**
+ * Знаходить динамічні SQL-списки у TaggedTemplateExpression / TemplateLiteral в контексті
+ * `IN (...)` або `VALUES (...)`, де серед expressions є виклик `.join(...)`.
+ * @param {string} content вихідний код
+ * @param {string} [virtualPath] шлях для вибору `lang`
+ * @returns {{ line: number, snippet: string }[]} список порушень
+ */
+export function findUnsafeBunSqlDynamicSqlListInText(content, virtualPath = 'scan.ts') {
+  const program = parseProgramOrNull(content, virtualPath)
+  if (!program) return []
+
+  /** @type {{ line: number, snippet: string }[]} */
+  const out = []
+  walkAstWithAncestors(program, [], node => {
+    /** @type {unknown} */
+    let template = null
+    if (node.type === 'TemplateLiteral') {
+      template = node
+    } else if (node.type === 'TaggedTemplateExpression') {
+      template = node.quasi
+    }
+    if (!template || typeof template !== 'object' || template.type !== 'TemplateLiteral') return
+    if (!isSqlListContextTemplate(template)) return
+    const expressions = template.expressions
+    if (!Array.isArray(expressions) || expressions.length === 0) return
+    if (!expressions.some(expr => isJoinCall(expr))) return
+    out.push({
+      line: offsetToLine(content, template.start),
+      snippet: normalizeSnippet(content.slice(template.start, template.end))
+    })
+  })
+  return out
+}
+
+/**
+ * Чи містить текст джерела імпорт імені `sql` або `SQL` з `"bun"`.
+ * Скан по сирому тексту — без AST, щоб бути дешевим: викликається на кожному
+ * JS/TS-файлі при зборі ознак для авто-детекту правил.
+ * @param {string} content вміст файлу
+ * @returns {boolean}
+ */
+export function textHasBunSqlImport(content) {
+  return BUN_SQL_IMPORT_RE.test(content)
+}
+
+/**
+ * Чи сканувати цей файл за розширенням (JS/TS-сімʼя, без `.d.ts`).
+ * @param {string} relativePathPosix відносний шлях (posix)
+ * @returns {boolean} true, якщо розширення підходить для AST-скану
+ */
+export function isBunSqlScanSourceFile(relativePathPosix) {
+  return SOURCE_FILE_RE.test(relativePathPosix) && !relativePathPosix.endsWith('.d.ts')
+}

package/scripts/utils/mssql-pool-scan.mjs

@@ -12,6 +12,9 @@
  *   повторно використовувати між запитами.
  * - небезпечні “динамічні списки” в SQL, коли в TemplateLiteral/TaggedTemplateExpression
  *   підставляють рядки, зібрані через `.join(',')` (типово для `IN (...)` або `VALUES (...)`).
+ * - підстановки `IN (${expr})`, де `expr` не пройшов числовий парсер (parseInt/Number/BigInt
+ *   /parseFloat або унарний `+`) і не є літеральним масивом чисел — навіть у tagged template
+ *   це додатковий шар захисту від SQL injection (див. js-mssql.mdc).
  *
  * Семантика береться з **oxc-parser** по AST, щоб не покладатися на regex.
  * Якщо файл не парситься або містить синтаксичні помилки — повертаємо порожній
@@ -21,6 +24,8 @@ import { parseSync } from 'oxc-parser'
 
 const SOURCE_FILE_RE = /\.([cm]?[jt]sx?)$/
 const SQL_LIST_CONTEXT_RE = /\b(in|values)\b\s*\(/iu
+const IN_PLACEHOLDER_END_RE = /\bin\s*\(\s*$/iu
+const NUMERIC_PARSE_FN_NAMES = new Set(['parseInt', 'parseFloat', 'Number', 'BigInt'])
 
 /**
  * Мова для Oxc за шляхом файлу (розширення).
@@ -346,6 +351,175 @@ export function findUnsafeMssqlDynamicSqlListInText(content, virtualPath = 'scan
   return out
 }
 
+/**
+ * Чи елементи літерального масиву — лише числові (numeric/bigint) літерали.
+ * Такі масиви безпечні в `IN (...)` навіть без явного парсера.
+ * @param {unknown} node AST node
+ * @returns {boolean} true, якщо це непорожній масив суто числових літералів
+ */
+function isLiteralNumericArrayExpression(node) {
+  if (!node || typeof node !== 'object' || node.type !== 'ArrayExpression') return false
+  const elements = node.elements
+  if (!Array.isArray(elements) || elements.length === 0) return false
+  return elements.every(el => {
+    if (!el || typeof el !== 'object') return false
+    if (el.type === 'NumericLiteral' || el.type === 'BigIntLiteral') return true
+    if (el.type === 'Literal' && (typeof el.value === 'number' || typeof el.value === 'bigint')) {
+      return true
+    }
+    return false
+  })
+}
+
+/**
+ * Чи містить піддерево виклик числового парсера (parseInt/parseFloat/Number/BigInt)
+ * або унарний `+` (приведення до Number). Це сигнал, що значення гарантовано числове
+ * і не може містити SQL-метасимволи.
+ * @param {unknown} node AST node
+ * @returns {boolean} true, якщо знайдено числовий парсер у піддереві
+ */
+function subtreeHasNumericParseCall(node) {
+  if (!node || typeof node !== 'object') return false
+  if (Array.isArray(node)) return node.some(subtreeHasNumericParseCall)
+
+  if (node.type === 'CallExpression') {
+    const callee = node.callee
+    if (callee && callee.type === 'Identifier' && NUMERIC_PARSE_FN_NAMES.has(callee.name)) {
+      return true
+    }
+    if (callee && callee.type === 'MemberExpression' && !callee.computed) {
+      const prop = callee.property
+      if (prop && prop.type === 'Identifier' && NUMERIC_PARSE_FN_NAMES.has(prop.name)) {
+        return true
+      }
+    }
+  }
+  if (node.type === 'UnaryExpression' && node.operator === '+') return true
+
+  for (const key of Object.keys(node)) {
+    if (key === 'parent') continue
+    const v = node[key]
+    if (v && typeof v === 'object' && subtreeHasNumericParseCall(v)) return true
+  }
+  return false
+}
+
+/**
+ * Збирає всі VariableDeclarator-вузли в AST (для трасування Identifier-ів до їх init).
+ * @param {unknown} programNode AST root (Program)
+ * @returns {Array<Record<string, unknown>>} список VariableDeclarator-ів
+ */
+function collectVariableDeclarators(programNode) {
+  /** @type {Array<Record<string, unknown>>} */
+  const out = []
+  walkAstWithAncestors(programNode, [], node => {
+    if (node.type === 'VariableDeclarator') out.push(node)
+  })
+  return out
+}
+
+/**
+ * Чи виглядає вираз, який підставляється в `IN (${...})`, як «безпечно розпарсений»:
+ * - літеральний масив чисел;
+ * - саме піддерево містить виклик числового парсера (parseInt/Number/BigInt/parseFloat/+x);
+ * - Identifier, чий init у файлі рекурсивно задовольняє ці умови.
+ *
+ * Якщо для Identifier немає видимого init (наприклад параметр функції чи import),
+ * вираз вважається не парсованим — потрібен явний парсер на місці підстановки.
+ *
+ * @param {unknown} expr вираз з template.expressions
+ * @param {Array<Record<string, unknown>>} declarators VariableDeclarator-и файлу
+ * @param {Set<string>} [seen] іменa Identifier-ів, що вже трасуються (анти-цикл)
+ * @returns {boolean} true, якщо вираз можна вважати безпечно числовим
+ */
+function isInListExpressionParsed(expr, declarators, seen = new Set()) {
+  if (!expr || typeof expr !== 'object') return false
+  if (isLiteralNumericArrayExpression(expr)) return true
+  if (subtreeHasNumericParseCall(expr)) return true
+
+  if (expr.type === 'Identifier' && typeof expr.name === 'string') {
+    if (seen.has(expr.name)) return false
+    const nextSeen = new Set(seen)
+    nextSeen.add(expr.name)
+    const inits = declarators
+      .filter(d => {
+        const id = d.id
+        return (
+          !!id &&
+          typeof id === 'object' &&
+          id.type === 'Identifier' &&
+          id.name === expr.name &&
+          !!d.init
+        )
+      })
+      .map(d => d.init)
+    if (inits.length === 0) return false
+    return inits.every(init => isInListExpressionParsed(init, declarators, nextSeen))
+  }
+
+  return false
+}
+
+/**
+ * Знаходить підстановки `IN (${expr})` у TemplateLiteral, де `expr` не пройшов числовий парсер.
+ *
+ * Навіть у безпечному `pool.request().query\`...\`` краще явно парсити значення (parseInt/
+ * Number/BigInt/parseFloat) та фільтрувати NaN — це гарантує, що жодний елемент не може
+ * містити SQL-метасимволи, навіть якщо колись query-функція або обгортка зміняться. У
+ * небезпечних контекстах (наприклад `pool.query(String.raw\`...\`)`) це єдиний бар'єр від SQL
+ * injection.
+ *
+ * Випадки `${arr.join(',')}` свідомо ігноруються — їх ловить
+ * {@link findUnsafeMssqlDynamicSqlListInText}.
+ *
+ * @param {string} content вихідний код
+ * @param {string} [virtualPath] шлях для вибору `lang`
+ * @returns {{ line: number, snippet: string }[]} список порушень
+ */
+export function findUnsafeMssqlInListUnparsedInText(content, virtualPath = 'scan.ts') {
+  const lang = langFromPath(virtualPath || 'scan.ts')
+  let result
+  try {
+    result = parseSync(virtualPath, content, { lang, sourceType: 'module' })
+  } catch {
+    return []
+  }
+  if (result.errors?.length) return []
+
+  const declarators = collectVariableDeclarators(result.program)
+
+  /** @type {{ line: number, snippet: string }[]} */
+  const out = []
+  walkAstWithAncestors(result.program, [], node => {
+    if (node.type !== 'TemplateLiteral') return
+    const quasis = node.quasis
+    const expressions = node.expressions
+    if (!Array.isArray(quasis) || !Array.isArray(expressions) || expressions.length === 0) return
+
+    for (let i = 0; i < expressions.length; i++) {
+      const q = quasis[i]
+      const rawText =
+        q && typeof q === 'object' && q.value && typeof q.value === 'object' && typeof q.value.raw === 'string'
+          ? q.value.raw
+          : ''
+      if (!IN_PLACEHOLDER_END_RE.test(rawText)) continue
+
+      const expr = expressions[i]
+      if (!expr || typeof expr !== 'object') continue
+      if (isJoinCall(expr)) continue
+      if (isInListExpressionParsed(expr, declarators)) continue
+
+      const startOffset = typeof expr.start === 'number' ? expr.start : node.start
+      out.push({
+        line: offsetToLine(content, startOffset),
+        snippet: normalizeSnippet(content.slice(node.start, node.end))
+      })
+    }
+  })
+
+  return out
+}
+
 /**
  * Чи сканувати цей файл за розширенням (JS/TS-сім'я).
  * @param {string} relativePathPosix відносний шлях (posix)