@steve31415/baselib 2.2.0 → 2.2.2

package/dist/app-update-browser/build-update.d.ts

@@ -1,5 +1,4 @@
 import type { Logger } from '../log-browser.js';
-import type { ReloadSafety } from './reload-safety.js';
 export type BuildUpdateState = {
     kind: 'current';
 } | {
@@ -9,9 +8,13 @@ export type BuildUpdateState = {
     kind: 'reloading';
     buildId: string;
 };
+export interface ReloadSafetyState {
+    readonly isSafe: () => boolean;
+    readonly subscribe: (listener: () => void) => () => void;
+}
 export interface BuildUpdateDeps {
     currentBuildId: string;
-    safety: ReloadSafety;
+    safety: ReloadSafetyState;
     logger: Pick<Logger, 'info' | 'warn'>;
     fetchFn?: (input: string, init?: RequestInit) => Promise<Response>;
     reload?: () => void;

package/dist/db.d.ts

@@ -6,6 +6,14 @@ export interface PoolOptions {
     max?: number;
 }
 export declare function createPool(opts?: PoolOptions): Promise<pg.Pool>;
+/** End a pool and resolve only once every client's connection has actually
+ * closed. pg-pool's own `end()` resolves as soon as it has *asked* its idle
+ * clients to close — their sockets are still open — so a caller that then
+ * drops the database `with (force)` can kill a backend mid-goodbye, and the
+ * FATAL it sends back surfaces as an unhandled pool 'error' (it took down a
+ * todo2 deploy with every test green, 2026-08-20). pg-pool emits 'remove' for
+ * each client once its socket has closed; wait for all of them. */
+export declare function endPool(pool: pg.Pool): Promise<void>;
 export declare function migrate(pool: pg.Pool, migrationsDir: string, logger?: Logger): Promise<{
     applied: string[];
 }>;

package/dist/db.js

@@ -35,6 +35,26 @@ export async function createPool(opts = {}) {
         url.pathname = `/${opts.database}`;
     return new pg.Pool({ connectionString: url.toString(), max: opts.max ?? 5 });
 }
+/** End a pool and resolve only once every client's connection has actually
+ * closed. pg-pool's own `end()` resolves as soon as it has *asked* its idle
+ * clients to close — their sockets are still open — so a caller that then
+ * drops the database `with (force)` can kill a backend mid-goodbye, and the
+ * FATAL it sends back surfaces as an unhandled pool 'error' (it took down a
+ * todo2 deploy with every test green, 2026-08-20). pg-pool emits 'remove' for
+ * each client once its socket has closed; wait for all of them. */
+export async function endPool(pool) {
+    let open = pool.totalCount;
+    const allClosed = new Promise((resolve) => {
+        if (open === 0)
+            return resolve();
+        pool.on('remove', () => {
+            if (--open === 0)
+                resolve();
+        });
+    });
+    await pool.end();
+    await allClosed;
+}
 // Plain-SQL migrations: numbered files (001-*.sql, 002-*.sql, …) applied in
 // order, recorded in schema_migrations, each inside a transaction, guarded by
 // an advisory lock so concurrent boots can't race. Applied at service boot.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steve31415/baselib",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Plasticine new-world shared platform library: logging, auth, service-to-service auth, db, HTTP, sync, app updates",
   "type": "module",
   "license": "MIT",