specmem-hardwicksoftware 3.5.99

package/dist/db/bigBrainMigrations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigBrainMigrations.js","sourceRoot":"","sources":["../../src/db/bigBrainMigrations.ts"],"names":[],"mappings":"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"}

package/dist/db/connectionPoolGoBrrr.d.ts

@@ -0,0 +1,94 @@
+import pg from 'pg';
+import { DatabaseConfig } from '../types/index.js';
+interface PoolDrip {
+    total: number;
+    idle: number;
+    waiting: number;
+    maxedOut: boolean;
+}
+interface PoolConfig {
+    maxConnections: number;
+    minConnections: number;
+    idleTimeoutMs: number;
+    connectionTimeoutMs: number;
+    statementTimeoutMs: number;
+    queryTimeoutMs: number;
+    healthCheckIntervalMs: number;
+    retryAttempts: number;
+    retryDelayMs: number;
+}
+/**
+ * ConnectionPoolGoBrrr - the most GOATED postgres connection manager
+ * handles 100+ concurrent connections like its nothing fr
+ * auto reconnects, health checks, all that good stuff
+ *
+ * features that go crazy:
+ * - connection pooling (duh)
+ * - automatic retry with exponential backoff
+ * - health monitoring that NEVER sleeps
+ * - query performance tracking
+ * - transaction management thats actually fire
+ */
+export declare class ConnectionPoolGoBrrr {
+    private pool;
+    private readonly config;
+    private readonly poolSettings;
+    private isAlive;
+    private healthCheckInterval;
+    private queryCount;
+    private slowQueryCount;
+    private errorCount;
+    private lastHealthCheck;
+    private cleanupHandlerId;
+    private errorHandlerCleanupId;
+    private currentErrorHandler;
+    private currentConnectHandler;
+    private currentAcquireHandler;
+    private currentRemoveHandler;
+    constructor(config: DatabaseConfig, poolSettings?: Partial<PoolConfig>);
+    private spawnThePool;
+    private cleanupPoolListeners;
+    private setupPoolListeners;
+    wakeUp(): Promise<void>;
+    private startHealthMonitor;
+    private recreatePool;
+    queryWithSwag<T extends pg.QueryResultRow = pg.QueryResultRow>(text: string, params?: unknown[], retries?: number): Promise<pg.QueryResult<T>>;
+    private isTransientError;
+    transactionGang<T>(callback: (client: pg.PoolClient) => Promise<T>): Promise<T>;
+    seriousTransaction<T>(callback: (client: pg.PoolClient) => Promise<T>): Promise<T>;
+    getPoolDrip(): PoolDrip;
+    getFullStats(): {
+        pool: PoolDrip;
+        queries: {
+            total: number;
+            slow: number;
+            errors: number;
+        };
+        health: {
+            isAlive: boolean;
+            lastCheck: Date;
+            uptimeMs: number;
+        };
+        config: {
+            maxConnections: number;
+            host: string;
+            database: string;
+        };
+    };
+    private sleep;
+    shutdown(): Promise<void>;
+    getRawClient(): Promise<pg.PoolClient>;
+    /**
+     * Gets a client with GUARANTEED search_path set.
+     * Use this instead of getRawClient() when schema isolation is critical.
+     * The pool.on('connect') handler sets search_path async, which can race.
+     * This method explicitly waits for search_path to be set before returning.
+     */
+    getClientWithSchema(): Promise<pg.PoolClient>;
+    getPool(): pg.Pool;
+}
+export declare function getThePool(config?: DatabaseConfig): ConnectionPoolGoBrrr;
+export declare function yeetThePool(): void;
+export declare function yeetAllPools(): void;
+export type { PoolDrip, PoolConfig };
+//# sourceMappingURL=connectionPoolGoBrrr.d.ts.map

package/dist/db/connectionPoolGoBrrr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectionPoolGoBrrr.d.ts","sourceRoot":"","sources":["../../src/db/connectionPoolGoBrrr.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,IAAI,CAAC;AAEpB,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAcnD,UAAU,QAAQ;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAGD,UAAU,UAAU;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;CACtB;AAcD;;;;;;;;;;;GAWG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IACxC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAa;IAC1C,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,mBAAmB,CAA+B;IAC1D,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,eAAe,CAAqB;IAC5C,OAAO,CAAC,gBAAgB,CAAuB;IAC/C,OAAO,CAAC,qBAAqB,CAAuB;IAEpD,OAAO,CAAC,mBAAmB,CAAuC;IAClE,OAAO,CAAC,qBAAqB,CAAwC;IACrE,OAAO,CAAC,qBAAqB,CAA6B;IAC1D,OAAO,CAAC,oBAAoB,CAA6B;gBAE7C,MAAM,EAAE,cAAc,EAAE,YAAY,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC;IAoBtE,OAAO,CAAC,YAAY;IAqBpB,OAAO,CAAC,oBAAoB;IA0B5B,OAAO,CAAC,kBAAkB;IA0EpB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB7B,OAAO,CAAC,kBAAkB;YAgCZ,YAAY;IAuBpB,aAAa,CAAC,CAAC,SAAS,EAAE,CAAC,cAAc,GAAG,EAAE,CAAC,cAAc,EACjE,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,OAAO,EAAE,EAClB,OAAO,SAAkC,GACxC,OAAO,CAAC,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;IAiD7B,OAAO,CAAC,gBAAgB;IAqBlB,eAAe,CAAC,CAAC,EACrB,QAAQ,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC,GAC9C,OAAO,CAAC,CAAC,CAAC;IA2BP,kBAAkB,CAAC,CAAC,EACxB,QAAQ,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC,GAC9C,OAAO,CAAC,CAAC,CAAC;IAyBb,WAAW,IAAI,QAAQ;IAUvB,YAAY;;;;;;;;;;;;;;;;;;IAsBZ,OAAO,CAAC,KAAK;IAKP,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IA6BzB,YAAY,IAAI,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC;IAI5C;;;;;OAKG;IACG,mBAAmB,IAAI,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC;IAoBnD,OAAO,IAAI,EAAE,CAAC,IAAI;CAGnB;AA8CD,wBAAgB,UAAU,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,oBAAoB,CAqCxE;AAGD,wBAAgB,WAAW,IAAI,IAAI,CAWlC;AAGD,wBAAgB,YAAY,IAAI,IAAI,CAenC;AAGD,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC"}

package/dist/db/connectionPoolGoBrrr.js

@@ -0,0 +1,548 @@
+// yoooo this connection pool straight up BUSSIN no cap
+// handles all the postgres connection drip
+// skids cant even comprehend this scalability fr fr
+// @ts-ignore - pg types not installed
+import pg from 'pg';
+import { logger } from '../utils/logger.js';
+import { registerCleanupHandler, unregisterCleanupHandler } from '../utils/cleanupHandler.js';
+import { loadConfig } from '../config.js';
+// Schema isolation - get project schema for search_path
+import { getProjectSchema } from './projectNamespacing.js';
+const { Pool, types } = pg;
+// nah bruh we gotta fix these postgres type parsers
+// otherwise numbers come back as strings and thats NOT IT
+types.setTypeParser(1700, parseFloat); // numeric/decimal
+types.setTypeParser(20, parseInt); // bigint
+const DEFAULT_POOL_SETTINGS = {
+    maxConnections: 100, // bruh we scaling to the MOON
+    minConnections: 5, // keep some warm connections fr
+    idleTimeoutMs: 30000, // 30 sec timeout on idle connections
+    connectionTimeoutMs: 30000, // 30 sec to establish connection
+    statementTimeoutMs: 30000, // 30 sec statement timeout
+    queryTimeoutMs: 60000, // 1 min query timeout for thicc queries
+    healthCheckIntervalMs: 30000, // health check every 30 sec
+    retryAttempts: 3, // retry this many times on failure
+    retryDelayMs: 1000 // wait 1 sec between retries
+};
+/**
+ * ConnectionPoolGoBrrr - the most GOATED postgres connection manager
+ * handles 100+ concurrent connections like its nothing fr
+ * auto reconnects, health checks, all that good stuff
+ *
+ * features that go crazy:
+ * - connection pooling (duh)
+ * - automatic retry with exponential backoff
+ * - health monitoring that NEVER sleeps
+ * - query performance tracking
+ * - transaction management thats actually fire
+ */
+export class ConnectionPoolGoBrrr {
+    pool;
+    config;
+    poolSettings;
+    isAlive = false;
+    healthCheckInterval = null;
+    queryCount = 0;
+    slowQueryCount = 0;
+    errorCount = 0;
+    lastHealthCheck = null;
+    cleanupHandlerId = null;
+    errorHandlerCleanupId = null;
+    // HIGH-08 FIX: Store listener references for proper cleanup before recreate
+    currentErrorHandler = null;
+    currentConnectHandler = null;
+    currentAcquireHandler = null;
+    currentRemoveHandler = null;
+    constructor(config, poolSettings) {
+        this.config = config;
+        this.poolSettings = { ...DEFAULT_POOL_SETTINGS, ...poolSettings };
+        this.pool = this.spawnThePool();
+        this.setupPoolListeners();
+        // Log with project isolation info for debugging
+        const projectHash = process.env['SPECMEM_PROJECT_HASH'] || 'default';
+        const projectPath = process.env['SPECMEM_PROJECT_PATH'] || process.cwd();
+        logger.info({
+            host: config.host,
+            port: config.port,
+            database: config.database,
+            projectHash,
+            projectPath: projectPath.slice(-50), // Last 50 chars for readability
+            maxConnections: this.poolSettings.maxConnections
+        }, 'ConnectionPoolGoBrrr initialized with project-scoped database');
+    }
+    // creates the actual pg pool with all the drip settings
+    spawnThePool() {
+        return new Pool({
+            host: this.config.host,
+            port: this.config.port,
+            database: this.config.database,
+            user: this.config.user,
+            password: this.config.password,
+            max: this.poolSettings.maxConnections,
+            min: this.poolSettings.minConnections,
+            idleTimeoutMillis: this.poolSettings.idleTimeoutMs,
+            connectionTimeoutMillis: this.poolSettings.connectionTimeoutMs,
+            statement_timeout: this.poolSettings.statementTimeoutMs,
+            query_timeout: this.poolSettings.queryTimeoutMs,
+            ssl: this.config.ssl,
+            // these pragmas go CRAZY for performance
+            application_name: 'specmem-goBrrr'
+        });
+    }
+    // HIGH-08 FIX: Clean up existing listeners before setting up new ones
+    // This prevents duplicate listeners when pool is recreated
+    cleanupPoolListeners() {
+        if (this.currentErrorHandler) {
+            this.pool.removeListener('error', this.currentErrorHandler);
+        }
+        if (this.currentConnectHandler) {
+            this.pool.removeListener('connect', this.currentConnectHandler);
+        }
+        if (this.currentAcquireHandler) {
+            this.pool.removeListener('acquire', this.currentAcquireHandler);
+        }
+        if (this.currentRemoveHandler) {
+            this.pool.removeListener('remove', this.currentRemoveHandler);
+        }
+        // Unregister cleanup handlers to prevent leaks
+        if (this.errorHandlerCleanupId) {
+            unregisterCleanupHandler(this.errorHandlerCleanupId);
+            this.errorHandlerCleanupId = null;
+        }
+        if (this.cleanupHandlerId) {
+            unregisterCleanupHandler(this.cleanupHandlerId);
+            this.cleanupHandlerId = null;
+        }
+        logger.debug('cleaned up all pool listeners - fresh slate fr');
+    }
+    // sets up all the event listeners so we know whats happening
+    setupPoolListeners() {
+        // HIGH-08 FIX: Clean up existing listeners first to prevent duplicates on recreate
+        this.cleanupPoolListeners();
+        // Store error handler reference for cleanup
+        this.currentErrorHandler = (err) => {
+            this.errorCount++;
+            logger.error({ err, errorCount: this.errorCount }, 'pool error - NOT GOOD bruh');
+        };
+        this.pool.on('error', this.currentErrorHandler);
+        // Register cleanup handler for error listener
+        this.errorHandlerCleanupId = registerCleanupHandler('ConnectionPoolGoBrrr:errorHandler', () => {
+            if (this.currentErrorHandler) {
+                this.pool.removeListener('error', this.currentErrorHandler);
+            }
+        }, 10 // High priority - remove listeners early
+        );
+        // SCHEMA ISOLATION FIX: Track pending search_path operations per client
+        // The connect event doesn't wait for async ops, so we track them separately
+        const pendingSearchPaths = new WeakMap();
+        this.currentConnectHandler = (client) => {
+            // Set search_path - store promise for potential waiting
+            // NOTE: pg doesn't await connect handler, so this is fire-and-forget
+            // Critical paths use getClientWithSchema() which explicitly awaits
+            try {
+                const schemaName = getProjectSchema();
+                // Use quoted identifier format with escaped quotes for safety
+                const safeSchema = '"' + schemaName.replace(/"/g, '""') + '"';
+                const searchPathPromise = client.query('SET search_path TO ' + safeSchema + ', public')
+                    .then(() => {
+                    logger.debug({ schemaName }, 'search_path configured for project isolation');
+                })
+                    .catch((err) => {
+                    logger.warn({ err, schemaName }, 'failed to set search_path on connection');
+                });
+                pendingSearchPaths.set(client, searchPathPromise);
+            }
+            catch (err) {
+                // getProjectSchema() failed - this is CRITICAL for schema isolation
+                // Log error and set search_path to public only as fallback
+                logger.error({ err }, 'CRITICAL: could not determine project schema - queries may hit wrong schema!');
+                client.query('SET search_path TO public')
+                    .catch((qErr) => logger.warn({ qErr }, 'failed to set fallback search_path'));
+            }
+        };
+        this.pool.on('connect', this.currentConnectHandler);
+        this.currentAcquireHandler = () => {
+            logger.trace('client acquired from pool');
+        };
+        this.pool.on('acquire', this.currentAcquireHandler);
+        this.currentRemoveHandler = () => {
+            logger.debug('connection removed from pool - cleaning up');
+        };
+        this.pool.on('remove', this.currentRemoveHandler);
+        // Register main cleanup handler
+        this.cleanupHandlerId = registerCleanupHandler('ConnectionPoolGoBrrr:shutdown', async () => {
+            await this.shutdown();
+        }, 20 // Run after listener removal
+        );
+    }
+    // wakes up the pool and makes sure everything is gucci
+    async wakeUp() {
+        if (this.isAlive) {
+            logger.debug('pool already awake bro');
+            return;
+        }
+        // test the connection real quick
+        const client = await this.pool.connect();
+        try {
+            await client.query('SELECT 1 as alive');
+            this.isAlive = true;
+            this.startHealthMonitor();
+            logger.info('ConnectionPoolGoBrrr is AWAKE and ready to serve');
+        }
+        finally {
+            client.release();
+        }
+    }
+    // health check loop that runs forever checking if we good
+    startHealthMonitor() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+        }
+        this.healthCheckInterval = setInterval(async () => {
+            try {
+                const start = Date.now();
+                await this.pool.query('SELECT 1');
+                const latency = Date.now() - start;
+                this.lastHealthCheck = new Date();
+                if (latency > 100) {
+                    // nah bruh thats kinda slow
+                    logger.warn({ latency }, 'health check latency kinda mid');
+                }
+                else {
+                    logger.trace({ latency }, 'health check passed - we chillin');
+                }
+            }
+            catch (err) {
+                this.errorCount++;
+                logger.error({ err }, 'health check FAILED - this is bad fr');
+                // try to recreate the pool if health check fails
+                if (this.errorCount > 5) {
+                    logger.warn('too many errors - recreating pool');
+                    await this.recreatePool();
+                }
+            }
+        }, this.poolSettings.healthCheckIntervalMs);
+    }
+    // recreates the entire pool if things get sus
+    async recreatePool() {
+        logger.info('recreating pool - hold up...');
+        // HIGH-08 FIX: Clean up listeners BEFORE ending pool to prevent leaks
+        // Must happen before pool.end() since we need the pool reference
+        this.cleanupPoolListeners();
+        try {
+            await this.pool.end();
+        }
+        catch (err) {
+            logger.warn({ err }, 'error ending old pool but we move');
+        }
+        this.pool = this.spawnThePool();
+        this.setupPoolListeners();
+        this.errorCount = 0;
+        await this.wakeUp();
+        logger.info('pool recreated successfully - WE BACK');
+    }
+    // executes a query with automatic retry on transient failures
+    // SCHEMA ISOLATION FIX: Use getClientWithSchema to guarantee search_path before any query
+    async queryWithSwag(text, params, retries = this.poolSettings.retryAttempts) {
+        const start = Date.now();
+        this.queryCount++;
+        for (let attempt = 0; attempt <= retries; attempt++) {
+            const client = await this.getClientWithSchema();
+            try {
+                const result = await client.query(text, params);
+                const duration = Date.now() - start;
+                // track slow queries so we can optimize later
+                if (duration > 100) {
+                    this.slowQueryCount++;
+                    logger.warn({
+                        duration,
+                        query: text.slice(0, 100),
+                        slowQueries: this.slowQueryCount
+                    }, 'slow query detected - might wanna optimize this fr');
+                }
+                return result;
+            }
+            catch (err) {
+                const isTransient = this.isTransientError(err);
+                if (isTransient && attempt < retries) {
+                    const delay = this.poolSettings.retryDelayMs * Math.pow(2, attempt);
+                    logger.warn({
+                        attempt: attempt + 1,
+                        maxRetries: retries,
+                        delayMs: delay,
+                        error: err.message
+                    }, 'transient error - retrying with backoff');
+                    await this.sleep(delay);
+                    continue;
+                }
+                this.errorCount++;
+                throw err;
+            }
+            finally {
+                client.release();
+            }
+        }
+        // this should never happen but typescript wants it
+        throw new Error('query failed after all retries - L');
+    }
+    // checks if an error is transient (can be retried)
+    isTransientError(err) {
+        const transientCodes = [
+            '40001', // serialization failure
+            '40P01', // deadlock
+            '57P01', // admin shutdown
+            '57P02', // crash shutdown
+            '57P03', // cannot connect now
+            '08006', // connection failure
+            '08001', // unable to establish connection
+            '08004', // server rejected connection
+        ];
+        if (err instanceof Error) {
+            const pgErr = err;
+            return transientCodes.includes(pgErr.code ?? '');
+        }
+        return false;
+    }
+    // executes multiple queries in a transaction - all or nothing baby
+    // SCHEMA ISOLATION FIX: Uses getClientWithSchema() to guarantee search_path
+    async transactionGang(callback) {
+        const client = await this.getClientWithSchema();
+        const start = Date.now();
+        try {
+            await client.query('BEGIN');
+            logger.trace('transaction started - lets get this bread');
+            const result = await callback(client);
+            await client.query('COMMIT');
+            const duration = Date.now() - start;
+            logger.debug({ duration }, 'transaction committed successfully');
+            return result;
+        }
+        catch (err) {
+            await client.query('ROLLBACK');
+            const duration = Date.now() - start;
+            logger.error({ err, duration }, 'transaction ROLLED BACK - big sad');
+            throw err;
+        }
+        finally {
+            client.release();
+        }
+    }
+    // executes a serializable transaction for when consistency is CRITICAL
+    // SCHEMA ISOLATION FIX: Uses getClientWithSchema() to guarantee search_path
+    async seriousTransaction(callback) {
+        const client = await this.getClientWithSchema();
+        const start = Date.now();
+        try {
+            // serializable is the strongest isolation level no cap
+            await client.query('BEGIN ISOLATION LEVEL SERIALIZABLE');
+            logger.trace('SERIOUS transaction started - no games');
+            const result = await callback(client);
+            await client.query('COMMIT');
+            const duration = Date.now() - start;
+            logger.debug({ duration }, 'serious transaction committed - WE DID IT');
+            return result;
+        }
+        catch (err) {
+            await client.query('ROLLBACK');
+            throw err;
+        }
+        finally {
+            client.release();
+        }
+    }
+    // gets stats about the pool - useful for monitoring
+    getPoolDrip() {
+        return {
+            total: this.pool.totalCount,
+            idle: this.pool.idleCount,
+            waiting: this.pool.waitingCount,
+            maxedOut: this.pool.totalCount >= this.poolSettings.maxConnections
+        };
+    }
+    // gets comprehensive stats for observability
+    getFullStats() {
+        return {
+            pool: this.getPoolDrip(),
+            queries: {
+                total: this.queryCount,
+                slow: this.slowQueryCount,
+                errors: this.errorCount
+            },
+            health: {
+                isAlive: this.isAlive,
+                lastCheck: this.lastHealthCheck,
+                uptimeMs: this.lastHealthCheck ? Date.now() - this.lastHealthCheck.getTime() : 0
+            },
+            config: {
+                maxConnections: this.poolSettings.maxConnections,
+                host: this.config.host,
+                database: this.config.database
+            }
+        };
+    }
+    // helper function to sleep - used for retry backoff
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    // gracefully shuts down the pool
+    async shutdown() {
+        logger.info('shutting down ConnectionPoolGoBrrr...');
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = null;
+        }
+        // Unregister cleanup handlers to prevent double-shutdown
+        if (this.errorHandlerCleanupId) {
+            unregisterCleanupHandler(this.errorHandlerCleanupId);
+            this.errorHandlerCleanupId = null;
+        }
+        if (this.cleanupHandlerId) {
+            unregisterCleanupHandler(this.cleanupHandlerId);
+            this.cleanupHandlerId = null;
+        }
+        try {
+            await this.pool.end();
+            this.isAlive = false;
+            logger.info('ConnectionPoolGoBrrr shut down cleanly - peace out');
+        }
+        catch (err) {
+            logger.error({ err }, 'error during shutdown but we tried');
+            throw err;
+        }
+    }
+    // gets a raw client for advanced operations
+    async getRawClient() {
+        return this.pool.connect();
+    }
+    /**
+     * Gets a client with GUARANTEED search_path set.
+     * Use this instead of getRawClient() when schema isolation is critical.
+     * The pool.on('connect') handler sets search_path async, which can race.
+     * This method explicitly waits for search_path to be set before returning.
+     */
+    async getClientWithSchema() {
+        const client = await this.pool.connect();
+        try {
+            const schemaName = getProjectSchema();
+            // Use quoted identifier format with escaped quotes for safety
+            const safeSchema = '"' + schemaName.replace(/"/g, '""') + '"';
+            await client.query('SET search_path TO ' + safeSchema + ', public');
+            logger.trace({ schemaName }, 'search_path explicitly set on client');
+            return client;
+        }
+        catch (err) {
+            // If we can't set search_path, release client and throw
+            // Don't let broken connections leak
+            client.release();
+            logger.error({ err }, 'failed to set search_path on client - releasing');
+            throw err;
+        }
+    }
+    // gets the underlying pg.Pool for direct access
+    // fr fr needed for memorization system
+    getPool() {
+        return this.pool;
+    }
+}
+// ============================================================================
+// PROJECT-SCOPED POOL INSTANCES
+// Each project gets its own connection pool to prevent cross-project pollution
+// Pools are keyed by project path for complete isolation
+// ============================================================================
+const poolInstancesByProject = new Map();
+const poolAccessTimes = new Map();
+const POOL_STALE_THRESHOLD_MS = 60 * 60 * 1000; // 1 hour - pools stay longer
+// LOW-33 FIX: Store interval handle so it can be cleared on shutdown
+let stalePoolCleanupInterval = null;
+// Cleanup stale project pools periodically
+stalePoolCleanupInterval = setInterval(() => {
+    const cutoff = Date.now() - POOL_STALE_THRESHOLD_MS;
+    for (const [project, lastAccess] of poolAccessTimes) {
+        if (lastAccess < cutoff) {
+            const pool = poolInstancesByProject.get(project);
+            if (pool) {
+                pool.shutdown().catch(err => {
+                    logger.warn({ err, project }, 'error cleaning up stale pool');
+                });
+            }
+            poolInstancesByProject.delete(project);
+            poolAccessTimes.delete(project);
+            logger.debug({ project }, 'Cleaned up stale project pool');
+        }
+    }
+}, 30 * 60 * 1000); // Check every 30 minutes
+// LOW-33 FIX: Allow process to exit even if interval is running
+if (stalePoolCleanupInterval.unref) {
+    stalePoolCleanupInterval.unref();
+}
+/**
+ * Get current project path for pool scoping
+ */
+function getPoolProjectPath() {
+    return process.env['SPECMEM_PROJECT_PATH'] || process.cwd();
+}
+// gets or creates the project-scoped pool instance
+export function getThePool(config) {
+    const projectPath = getPoolProjectPath();
+    poolAccessTimes.set(projectPath, Date.now());
+    let poolInstance = poolInstancesByProject.get(projectPath);
+    // TASK #23 FIX: Auto-load config when not provided - graceful degradation
+    if (!poolInstance && !config) {
+        logger.info({ projectPath }, 'No config provided for pool, auto-loading from loadConfig().database');
+        try {
+            config = loadConfig().database;
+        }
+        catch (e) {
+            // loadConfig failed - use sensible defaults
+            logger.warn({ projectPath, error: String(e) }, 'loadConfig() failed for pool, using fallback defaults');
+            // Use unified credential pattern - matches config.ts
+            const unifiedCred = process.env['SPECMEM_PASSWORD'] || 'specmem_westayunprofessional';
+            config = {
+                host: process.env['SPECMEM_DB_HOST'] || 'localhost',
+                port: parseInt(process.env['SPECMEM_DB_PORT'] || '5432', 10),
+                database: process.env['SPECMEM_DB_NAME'] || unifiedCred,
+                user: process.env['SPECMEM_DB_USER'] || unifiedCred,
+                password: process.env['SPECMEM_DB_PASSWORD'] || unifiedCred,
+                maxConnections: 20,
+                idleTimeout: 30000,
+                connectionTimeout: 5000,
+                ssl: undefined
+            };
+        }
+    }
+    if (!poolInstance && config) {
+        poolInstance = new ConnectionPoolGoBrrr(config);
+        poolInstancesByProject.set(projectPath, poolInstance);
+        logger.debug({ projectPath }, 'Created project-scoped pool instance');
+    }
+    return poolInstance;
+}
+// resets the project-scoped pool for testing
+export function yeetThePool() {
+    const projectPath = getPoolProjectPath();
+    const poolInstance = poolInstancesByProject.get(projectPath);
+    if (poolInstance) {
+        poolInstance.shutdown().catch(err => {
+            logger.warn({ err, projectPath }, 'error yeeting pool but whatever');
+        });
+        poolInstancesByProject.delete(projectPath);
+        poolAccessTimes.delete(projectPath);
+    }
+}
+// Yeets ALL pools - for cleanup on process exit
+export function yeetAllPools() {
+    // LOW-33 FIX: Clear the stale pool cleanup interval on shutdown
+    if (stalePoolCleanupInterval) {
+        clearInterval(stalePoolCleanupInterval);
+        stalePoolCleanupInterval = null;
+        logger.debug('Cleared stale pool cleanup interval');
+    }
+    for (const [project, pool] of poolInstancesByProject) {
+        pool.shutdown().catch(err => {
+            logger.warn({ err, project }, 'error yeeting pool during cleanup');
+        });
+    }
+    poolInstancesByProject.clear();
+    poolAccessTimes.clear();
+}
+//# sourceMappingURL=connectionPoolGoBrrr.js.map