trickle-observe 0.2.93 → 0.2.95

package/dist/db-observer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Database query observer — patches popular database drivers to capture
+ * SQL queries, execution time, and result shapes.
+ *
+ * Currently supports:
+ * - pg (node-postgres) — used by Prisma, Knex, Sequelize, TypeORM
+ *
+ * Captured data is written to .trickle/queries.jsonl as:
+ *   { query: "SELECT ...", params: [...], durationMs: 2.5, rowCount: 42, columns: [...] }
+ */
+/**
+ * Patch pg (node-postgres) to capture queries.
+ * Called from observe-register when pg is required.
+ */
+export declare function patchPg(pgModule: any, debug: boolean): void;
+/**
+ * Patch mysql2 to capture queries.
+ */
+export declare function patchMysql2(mysqlModule: any, debug: boolean): void;
+/**
+ * Patch better-sqlite3 to capture queries.
+ */
+export declare function patchBetterSqlite3(dbConstructor: any, debug: boolean): void;

package/dist/db-observer.js

@@ -0,0 +1,292 @@
+"use strict";
+/**
+ * Database query observer — patches popular database drivers to capture
+ * SQL queries, execution time, and result shapes.
+ *
+ * Currently supports:
+ * - pg (node-postgres) — used by Prisma, Knex, Sequelize, TypeORM
+ *
+ * Captured data is written to .trickle/queries.jsonl as:
+ *   { query: "SELECT ...", params: [...], durationMs: 2.5, rowCount: 42, columns: [...] }
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchPg = patchPg;
+exports.patchMysql2 = patchMysql2;
+exports.patchBetterSqlite3 = patchBetterSqlite3;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+let queriesFile = null;
+let debugMode = false;
+const MAX_QUERY_LENGTH = 500;
+const MAX_QUERIES = 100;
+let queryCount = 0;
+function getQueriesFile() {
+    if (queriesFile)
+        return queriesFile;
+    const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    catch { }
+    queriesFile = path.join(dir, 'queries.jsonl');
+    // Clear previous
+    try {
+        fs.writeFileSync(queriesFile, '');
+    }
+    catch { }
+    return queriesFile;
+}
+function writeQuery(record) {
+    if (queryCount >= MAX_QUERIES)
+        return;
+    queryCount++;
+    try {
+        fs.appendFileSync(getQueriesFile(), JSON.stringify(record) + '\n');
+    }
+    catch { }
+}
+/**
+ * Patch pg (node-postgres) to capture queries.
+ * Called from observe-register when pg is required.
+ */
+function patchPg(pgModule, debug) {
+    debugMode = debug;
+    // Patch Client.prototype.query
+    const Client = pgModule.Client;
+    if (!Client || !Client.prototype)
+        return;
+    const originalQuery = Client.prototype.query;
+    if (originalQuery.__trickle_patched)
+        return;
+    Client.prototype.query = function patchedQuery(...args) {
+        const startTime = performance.now();
+        // Extract query text and params
+        let queryText = '';
+        let params;
+        if (typeof args[0] === 'string') {
+            queryText = args[0];
+            params = Array.isArray(args[1]) ? args[1] : undefined;
+        }
+        else if (args[0] && typeof args[0] === 'object' && args[0].text) {
+            queryText = args[0].text;
+            params = args[0].values;
+        }
+        const truncatedQuery = queryText.length > MAX_QUERY_LENGTH
+            ? queryText.substring(0, MAX_QUERY_LENGTH) + '...'
+            : queryText;
+        // Call original
+        const result = originalQuery.apply(this, args);
+        // Handle promise-based queries
+        if (result && typeof result.then === 'function') {
+            return result.then((res) => {
+                const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+                const columns = res.fields?.map((f) => f.name) || [];
+                writeQuery({
+                    kind: 'query',
+                    query: truncatedQuery,
+                    params: params?.slice(0, 5),
+                    durationMs,
+                    rowCount: res.rowCount || 0,
+                    columns: columns.length > 0 ? columns : undefined,
+                    timestamp: Date.now(),
+                });
+                if (debugMode) {
+                    console.log(`[trickle/db] ${truncatedQuery.substring(0, 60)}... (${durationMs}ms, ${res.rowCount} rows)`);
+                }
+                return res;
+            }, (err) => {
+                const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+                writeQuery({
+                    kind: 'query',
+                    query: truncatedQuery,
+                    params: params?.slice(0, 5),
+                    durationMs,
+                    rowCount: 0,
+                    error: err.message?.substring(0, 200),
+                    timestamp: Date.now(),
+                });
+                throw err;
+            });
+        }
+        return result;
+    };
+    Client.prototype.query.__trickle_patched = true;
+    // Also patch Pool if available
+    if (pgModule.Pool) {
+        const Pool = pgModule.Pool;
+        const origPoolQuery = Pool.prototype.query;
+        if (origPoolQuery && !origPoolQuery.__trickle_patched) {
+            Pool.prototype.query = function patchedPoolQuery(...args) {
+                const startTime = performance.now();
+                let queryText = '';
+                let params;
+                if (typeof args[0] === 'string') {
+                    queryText = args[0];
+                    params = Array.isArray(args[1]) ? args[1] : undefined;
+                }
+                else if (args[0] && typeof args[0] === 'object' && args[0].text) {
+                    queryText = args[0].text;
+                    params = args[0].values;
+                }
+                const truncatedQuery = queryText.length > MAX_QUERY_LENGTH
+                    ? queryText.substring(0, MAX_QUERY_LENGTH) + '...'
+                    : queryText;
+                const result = origPoolQuery.apply(this, args);
+                if (result && typeof result.then === 'function') {
+                    return result.then((res) => {
+                        const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+                        writeQuery({
+                            kind: 'query',
+                            query: truncatedQuery,
+                            params: params?.slice(0, 5),
+                            durationMs,
+                            rowCount: res.rowCount || 0,
+                            columns: res.fields?.map((f) => f.name),
+                            timestamp: Date.now(),
+                        });
+                        return res;
+                    }, (err) => {
+                        writeQuery({
+                            kind: 'query',
+                            query: truncatedQuery,
+                            durationMs: Math.round((performance.now() - startTime) * 100) / 100,
+                            rowCount: 0,
+                            error: err.message?.substring(0, 200),
+                            timestamp: Date.now(),
+                        });
+                        throw err;
+                    });
+                }
+                return result;
+            };
+            Pool.prototype.query.__trickle_patched = true;
+        }
+    }
+    if (debugMode) {
+        console.log('[trickle/db] PostgreSQL query tracing enabled');
+    }
+}
+/**
+ * Patch mysql2 to capture queries.
+ */
+function patchMysql2(mysqlModule, debug) {
+    debugMode = debug;
+    // Patch Connection.prototype.query and .execute
+    const Connection = mysqlModule.Connection;
+    if (!Connection || !Connection.prototype)
+        return;
+    for (const method of ['query', 'execute']) {
+        const original = Connection.prototype[method];
+        if (!original || original.__trickle_patched)
+            continue;
+        Connection.prototype[method] = function patchedMethod(...args) {
+            const startTime = performance.now();
+            let queryText = typeof args[0] === 'string' ? args[0] : args[0]?.sql || '';
+            const truncated = queryText.length > MAX_QUERY_LENGTH ? queryText.substring(0, MAX_QUERY_LENGTH) + '...' : queryText;
+            const result = original.apply(this, args);
+            if (result && typeof result.then === 'function') {
+                return result.then((res) => {
+                    const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+                    const rows = Array.isArray(res) ? res[0] : res;
+                    writeQuery({
+                        kind: 'query', query: truncated, durationMs,
+                        rowCount: Array.isArray(rows) ? rows.length : 0,
+                        columns: Array.isArray(rows) && rows[0] ? Object.keys(rows[0]) : undefined,
+                        timestamp: Date.now(),
+                    });
+                    return res;
+                }, (err) => {
+                    writeQuery({
+                        kind: 'query', query: truncated,
+                        durationMs: Math.round((performance.now() - startTime) * 100) / 100,
+                        rowCount: 0, error: err.message?.substring(0, 200), timestamp: Date.now(),
+                    });
+                    throw err;
+                });
+            }
+            return result;
+        };
+        Connection.prototype[method].__trickle_patched = true;
+    }
+    if (debug)
+        console.log('[trickle/db] MySQL query tracing enabled');
+}
+/**
+ * Patch better-sqlite3 to capture queries.
+ */
+function patchBetterSqlite3(dbConstructor, debug) {
+    debugMode = debug;
+    // better-sqlite3 returns a Database constructor — patch its prototype
+    const origPrepare = dbConstructor.prototype?.prepare;
+    if (!origPrepare || origPrepare.__trickle_patched)
+        return;
+    dbConstructor.prototype.prepare = function patchedPrepare(sql) {
+        const stmt = origPrepare.call(this, sql);
+        const truncated = sql.length > MAX_QUERY_LENGTH ? sql.substring(0, MAX_QUERY_LENGTH) + '...' : sql;
+        // Patch run, get, all methods on the statement
+        for (const method of ['run', 'get', 'all']) {
+            const origMethod = stmt[method];
+            if (!origMethod)
+                continue;
+            stmt[method] = function (...args) {
+                const startTime = performance.now();
+                try {
+                    const result = origMethod.apply(this, args);
+                    const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+                    const rowCount = method === 'all' ? (Array.isArray(result) ? result.length : 0)
+                        : method === 'get' ? (result ? 1 : 0)
+                            : (result?.changes || 0);
+                    writeQuery({
+                        kind: 'query', query: truncated, durationMs, rowCount, timestamp: Date.now(),
+                    });
+                    return result;
+                }
+                catch (err) {
+                    writeQuery({
+                        kind: 'query', query: truncated,
+                        durationMs: Math.round((performance.now() - startTime) * 100) / 100,
+                        rowCount: 0, error: err.message?.substring(0, 200), timestamp: Date.now(),
+                    });
+                    throw err;
+                }
+            };
+        }
+        return stmt;
+    };
+    dbConstructor.prototype.prepare.__trickle_patched = true;
+    if (debug)
+        console.log('[trickle/db] SQLite query tracing enabled');
+}

package/dist/observe-register.js

@@ -1123,6 +1123,31 @@ if (enabled) {
             }
             catch { /* fall through to normal processing */ }
         }
+        // ── Database auto-detection: patch database drivers to capture SQL queries ──
+        if (request === 'pg' && !expressPatched.has('pg')) {
+            expressPatched.add('pg');
+            try {
+                const { patchPg } = require(path_1.default.join(__dirname, 'db-observer.js'));
+                patchPg(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
+        if ((request === 'mysql2' || request === 'mysql2/promise') && !expressPatched.has('mysql2')) {
+            expressPatched.add('mysql2');
+            try {
+                const { patchMysql2 } = require(path_1.default.join(__dirname, 'db-observer.js'));
+                patchMysql2(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
+        if (request === 'better-sqlite3' && !expressPatched.has('better-sqlite3')) {
+            expressPatched.add('better-sqlite3');
+            try {
+                const { patchBetterSqlite3 } = require(path_1.default.join(__dirname, 'db-observer.js'));
+                patchBetterSqlite3(exports, debug);
+            }
+            catch { /* not critical */ }
+        }
         // Resolve to absolute path for dedup — do this FIRST since bundlers like
         // tsx/esbuild may use path aliases (e.g., @config/env) that don't start
         // with './' or '/'. We need the resolved path to decide if it's user code.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trickle-observe",
-  "version": "0.2.93",
+  "version": "0.2.95",
   "description": "Runtime type observability for JavaScript applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/db-observer.ts

@@ -0,0 +1,283 @@
+/**
+ * Database query observer — patches popular database drivers to capture
+ * SQL queries, execution time, and result shapes.
+ *
+ * Currently supports:
+ * - pg (node-postgres) — used by Prisma, Knex, Sequelize, TypeORM
+ *
+ * Captured data is written to .trickle/queries.jsonl as:
+ *   { query: "SELECT ...", params: [...], durationMs: 2.5, rowCount: 42, columns: [...] }
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface QueryRecord {
+  kind: 'query';
+  query: string;
+  params?: unknown[];
+  durationMs: number;
+  rowCount: number;
+  columns?: string[];
+  error?: string;
+  timestamp: number;
+}
+
+let queriesFile: string | null = null;
+let debugMode = false;
+const MAX_QUERY_LENGTH = 500;
+const MAX_QUERIES = 100;
+let queryCount = 0;
+
+function getQueriesFile(): string {
+  if (queriesFile) return queriesFile;
+  const dir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
+  try { fs.mkdirSync(dir, { recursive: true }); } catch {}
+  queriesFile = path.join(dir, 'queries.jsonl');
+  // Clear previous
+  try { fs.writeFileSync(queriesFile, ''); } catch {}
+  return queriesFile;
+}
+
+function writeQuery(record: QueryRecord): void {
+  if (queryCount >= MAX_QUERIES) return;
+  queryCount++;
+  try {
+    fs.appendFileSync(getQueriesFile(), JSON.stringify(record) + '\n');
+  } catch {}
+}
+
+/**
+ * Patch pg (node-postgres) to capture queries.
+ * Called from observe-register when pg is required.
+ */
+export function patchPg(pgModule: any, debug: boolean): void {
+  debugMode = debug;
+
+  // Patch Client.prototype.query
+  const Client = pgModule.Client;
+  if (!Client || !Client.prototype) return;
+
+  const originalQuery = Client.prototype.query;
+  if ((originalQuery as any).__trickle_patched) return;
+
+  Client.prototype.query = function patchedQuery(...args: any[]): any {
+    const startTime = performance.now();
+
+    // Extract query text and params
+    let queryText = '';
+    let params: unknown[] | undefined;
+    if (typeof args[0] === 'string') {
+      queryText = args[0];
+      params = Array.isArray(args[1]) ? args[1] : undefined;
+    } else if (args[0] && typeof args[0] === 'object' && args[0].text) {
+      queryText = args[0].text;
+      params = args[0].values;
+    }
+
+    const truncatedQuery = queryText.length > MAX_QUERY_LENGTH
+      ? queryText.substring(0, MAX_QUERY_LENGTH) + '...'
+      : queryText;
+
+    // Call original
+    const result = originalQuery.apply(this, args);
+
+    // Handle promise-based queries
+    if (result && typeof result.then === 'function') {
+      return result.then(
+        (res: any) => {
+          const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+          const columns = res.fields?.map((f: any) => f.name) || [];
+          writeQuery({
+            kind: 'query',
+            query: truncatedQuery,
+            params: params?.slice(0, 5),
+            durationMs,
+            rowCount: res.rowCount || 0,
+            columns: columns.length > 0 ? columns : undefined,
+            timestamp: Date.now(),
+          });
+          if (debugMode) {
+            console.log(`[trickle/db] ${truncatedQuery.substring(0, 60)}... (${durationMs}ms, ${res.rowCount} rows)`);
+          }
+          return res;
+        },
+        (err: any) => {
+          const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+          writeQuery({
+            kind: 'query',
+            query: truncatedQuery,
+            params: params?.slice(0, 5),
+            durationMs,
+            rowCount: 0,
+            error: err.message?.substring(0, 200),
+            timestamp: Date.now(),
+          });
+          throw err;
+        },
+      );
+    }
+
+    return result;
+  };
+
+  (Client.prototype.query as any).__trickle_patched = true;
+
+  // Also patch Pool if available
+  if (pgModule.Pool) {
+    const Pool = pgModule.Pool;
+    const origPoolQuery = Pool.prototype.query;
+    if (origPoolQuery && !(origPoolQuery as any).__trickle_patched) {
+      Pool.prototype.query = function patchedPoolQuery(...args: any[]): any {
+        const startTime = performance.now();
+        let queryText = '';
+        let params: unknown[] | undefined;
+        if (typeof args[0] === 'string') {
+          queryText = args[0];
+          params = Array.isArray(args[1]) ? args[1] : undefined;
+        } else if (args[0] && typeof args[0] === 'object' && args[0].text) {
+          queryText = args[0].text;
+          params = args[0].values;
+        }
+
+        const truncatedQuery = queryText.length > MAX_QUERY_LENGTH
+          ? queryText.substring(0, MAX_QUERY_LENGTH) + '...'
+          : queryText;
+
+        const result = origPoolQuery.apply(this, args);
+        if (result && typeof result.then === 'function') {
+          return result.then(
+            (res: any) => {
+              const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+              writeQuery({
+                kind: 'query',
+                query: truncatedQuery,
+                params: params?.slice(0, 5),
+                durationMs,
+                rowCount: res.rowCount || 0,
+                columns: res.fields?.map((f: any) => f.name),
+                timestamp: Date.now(),
+              });
+              return res;
+            },
+            (err: any) => {
+              writeQuery({
+                kind: 'query',
+                query: truncatedQuery,
+                durationMs: Math.round((performance.now() - startTime) * 100) / 100,
+                rowCount: 0,
+                error: err.message?.substring(0, 200),
+                timestamp: Date.now(),
+              });
+              throw err;
+            },
+          );
+        }
+        return result;
+      };
+      (Pool.prototype.query as any).__trickle_patched = true;
+    }
+  }
+
+  if (debugMode) {
+    console.log('[trickle/db] PostgreSQL query tracing enabled');
+  }
+}
+
+/**
+ * Patch mysql2 to capture queries.
+ */
+export function patchMysql2(mysqlModule: any, debug: boolean): void {
+  debugMode = debug;
+
+  // Patch Connection.prototype.query and .execute
+  const Connection = mysqlModule.Connection;
+  if (!Connection || !Connection.prototype) return;
+
+  for (const method of ['query', 'execute'] as const) {
+    const original = Connection.prototype[method];
+    if (!original || (original as any).__trickle_patched) continue;
+
+    Connection.prototype[method] = function patchedMethod(...args: any[]): any {
+      const startTime = performance.now();
+      let queryText = typeof args[0] === 'string' ? args[0] : args[0]?.sql || '';
+      const truncated = queryText.length > MAX_QUERY_LENGTH ? queryText.substring(0, MAX_QUERY_LENGTH) + '...' : queryText;
+
+      const result = original.apply(this, args);
+      if (result && typeof result.then === 'function') {
+        return result.then(
+          (res: any) => {
+            const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+            const rows = Array.isArray(res) ? res[0] : res;
+            writeQuery({
+              kind: 'query', query: truncated, durationMs,
+              rowCount: Array.isArray(rows) ? rows.length : 0,
+              columns: Array.isArray(rows) && rows[0] ? Object.keys(rows[0]) : undefined,
+              timestamp: Date.now(),
+            });
+            return res;
+          },
+          (err: any) => {
+            writeQuery({
+              kind: 'query', query: truncated,
+              durationMs: Math.round((performance.now() - startTime) * 100) / 100,
+              rowCount: 0, error: err.message?.substring(0, 200), timestamp: Date.now(),
+            });
+            throw err;
+          },
+        );
+      }
+      return result;
+    };
+    (Connection.prototype[method] as any).__trickle_patched = true;
+  }
+
+  if (debug) console.log('[trickle/db] MySQL query tracing enabled');
+}
+
+/**
+ * Patch better-sqlite3 to capture queries.
+ */
+export function patchBetterSqlite3(dbConstructor: any, debug: boolean): void {
+  debugMode = debug;
+
+  // better-sqlite3 returns a Database constructor — patch its prototype
+  const origPrepare = dbConstructor.prototype?.prepare;
+  if (!origPrepare || (origPrepare as any).__trickle_patched) return;
+
+  dbConstructor.prototype.prepare = function patchedPrepare(sql: string): any {
+    const stmt = origPrepare.call(this, sql);
+    const truncated = sql.length > MAX_QUERY_LENGTH ? sql.substring(0, MAX_QUERY_LENGTH) + '...' : sql;
+
+    // Patch run, get, all methods on the statement
+    for (const method of ['run', 'get', 'all'] as const) {
+      const origMethod = stmt[method];
+      if (!origMethod) continue;
+      stmt[method] = function (...args: any[]): any {
+        const startTime = performance.now();
+        try {
+          const result = origMethod.apply(this, args);
+          const durationMs = Math.round((performance.now() - startTime) * 100) / 100;
+          const rowCount = method === 'all' ? (Array.isArray(result) ? result.length : 0)
+            : method === 'get' ? (result ? 1 : 0)
+            : (result?.changes || 0);
+          writeQuery({
+            kind: 'query', query: truncated, durationMs, rowCount, timestamp: Date.now(),
+          });
+          return result;
+        } catch (err: any) {
+          writeQuery({
+            kind: 'query', query: truncated,
+            durationMs: Math.round((performance.now() - startTime) * 100) / 100,
+            rowCount: 0, error: err.message?.substring(0, 200), timestamp: Date.now(),
+          });
+          throw err;
+        }
+      };
+    }
+    return stmt;
+  };
+  (dbConstructor.prototype.prepare as any).__trickle_patched = true;
+
+  if (debug) console.log('[trickle/db] SQLite query tracing enabled');
+}

package/src/observe-register.ts

@@ -1113,6 +1113,29 @@ if (enabled) {
       } catch { /* fall through to normal processing */ }
     }
 
+    // ── Database auto-detection: patch database drivers to capture SQL queries ──
+    if (request === 'pg' && !expressPatched.has('pg')) {
+      expressPatched.add('pg');
+      try {
+        const { patchPg } = require(path.join(__dirname, 'db-observer.js'));
+        patchPg(exports, debug);
+      } catch { /* not critical */ }
+    }
+    if ((request === 'mysql2' || request === 'mysql2/promise') && !expressPatched.has('mysql2')) {
+      expressPatched.add('mysql2');
+      try {
+        const { patchMysql2 } = require(path.join(__dirname, 'db-observer.js'));
+        patchMysql2(exports, debug);
+      } catch { /* not critical */ }
+    }
+    if (request === 'better-sqlite3' && !expressPatched.has('better-sqlite3')) {
+      expressPatched.add('better-sqlite3');
+      try {
+        const { patchBetterSqlite3 } = require(path.join(__dirname, 'db-observer.js'));
+        patchBetterSqlite3(exports, debug);
+      } catch { /* not critical */ }
+    }
+
     // Resolve to absolute path for dedup — do this FIRST since bundlers like
     // tsx/esbuild may use path aliases (e.g., @config/env) that don't start
     // with './' or '/'. We need the resolved path to decide if it's user code.