@jcbuisson/express-x 3.0.5 → 3.1.0

package/CLAUDE.md

@@ -4,13 +4,16 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-**express-x** is a full-stack framework that unifies backend and frontend communication through WebSocket-based services. It's published as `@jcbuisson/express-x` on npm.
+**express-x** is a full-stack framework that unifies backend and frontend communication through WebSocket-based services.
+It's published as `@jcbuisson/express-x` on npm.
 
-Core concept: ExpressX is a thin wrapper around Express.js and Socket.io that provides a service-oriented, real-time RPC pattern. Clients call server-side service methods via WebSocket and receive results as promises. Services can publish events to channels, enabling pub/sub-style real-time updates.
+Core concept: ExpressX is a thin wrapper around Express.js and Socket.io that provides a service-oriented, real-time RPC pattern.
+Clients call server-side service methods via WebSocket and receive results as promises.
+Services can publish events to channels, enabling pub/sub-style real-time updates.
 
 **Repository**: https://github.com/jcbuisson/express-x  
 **Documentation**: https://expressx.jcbuisson.dev  
-**Version**: 3.0.3 (ES modules)
+**Version**: 3.1.0 (ES modules)
 
 ## Development Commands
 
@@ -25,22 +28,23 @@ npm test
 node --import tsx/esm --test test/sync.test.mjs
 
 # Run both test files
-node --import tsx/esm --test --test-force-exit test/round-trip.test.mjs test/sync.test.mjs
+node --import tsx/esm --test --test-force-exit test/offline.test.mjs test/sync.test.mjs
 
 # Run a single named test (partial match on test name)
-node --import tsx/esm --test --test-force-exit --test-name-pattern="service call" test/round-trip.test.mjs
+node --import tsx/esm --test --test-force-exit --test-name-pattern="service call" test/offline.test.mjs
 ```
 
 No build step — the source is run directly as ES modules.
 
 ## Architecture
 
-### Single Source File
-- `src/server.mjs` is the complete server-side framework. All exports live here.
+### Source Files
+- `src/server.mjs` — complete server-side framework; all exports live here.
+- `src/client.mjs` — local mirror of the client-side library (`@jcbuisson/express-x-client`). Used for development and to track changes before publishing.
 
 ### Related Packages (also authored here, published separately)
-- **`@jcbuisson/express-x-client`** (`node_modules/@jcbuisson/express-x-client/src/client.mts`) — client-side library: `createClient`, `offlinePlugin`, `Mutex`, `wherePredicate`. TypeScript source consumed directly via `tsx`.
-- **`@jcbuisson/express-x-drizzle`** (`node_modules/@jcbuisson/express-x-drizzle/src/drizzle-plugins.mjs`) — Drizzle ORM variant of the offline plugin. The installed version may lag behind local development; the authoritative Drizzle plugin logic for tests is wired via `serverApp.configure(drizzleOfflinePlugin, ...)`.
+- **`@jcbuisson/express-x-client`** (`node_modules/@jcbuisson/express-x-client/src/client.mts`) — published client library: `createClient`, `offlinePlugin`, `Mutex`, `wherePredicate`. TypeScript source consumed directly via `tsx`. `src/client.mjs` is the local development counterpart.
+- **`@jcbuisson/express-x-drizzle`** (`node_modules/@jcbuisson/express-x-drizzle/src/drizzle-plugins.mjs`) — Drizzle ORM offline plugin. The installed version may lag behind local development; tests wire it via `serverApp.configure(drizzleOfflinePlugin, ...)`.
 
 ### Core Concepts
 
@@ -52,7 +56,7 @@ No build step — the source is run directly as ES modules.
 
 4. **Channels & Pub/Sub**: Socket.io rooms. After a service method completes, `service.publishFunction(context)` returns channel names; the result is broadcast as `service-event` to all sockets in those rooms. Clients subscribe with `app.service(name).on(action, handler)`.
 
-5. **WebSocket Protocol**: Client emits `client-request {uid, name, action, args}` → server emits `client-response {uid, result|error}`. Requests are correlated by `uid`.
+5. **WebSocket Protocol**: Client calls `socket.timeout(ms).emitWithAck('client-request', { name, action, args })` → server handler receives `({ name, action, args }, ack)` and responds via `ack({ result })` or `ack({ error })`. Correlation is handled by Socket.io's built-in acknowledgment mechanism — no custom uid tracking.
 
 ### Offline Sync Architecture
 
@@ -83,9 +87,11 @@ The sync system reconciles a client Dexie cache with a server database. The prot
 
 ## Test Structure
 
-- `test/round-trip.test.mjs` — Integration tests. Spins up a real Express/Socket.io server on a random port, connects via `socket.io-client`, uses PGlite (in-memory Postgres) + Drizzle + Dexie (via `fake-indexeddb`). Tests cover the full client↔server sync protocol, pub/sub, rollbacks, and edge cases. Each test gets an isolated PGlite instance and unique model name.
+- `test/offline.test.mjs` — Integration tests. Spins up a real Express/Socket.io server on a random port, connects via `socket.io-client`, uses PGlite (in-memory Postgres) + Drizzle + Dexie (via `fake-indexeddb`). Tests cover the full client↔server sync protocol, pub/sub, rollbacks, and edge cases. Each test gets an isolated PGlite instance and unique model name.
 - `test/sync.test.mjs` — Unit tests for `computeSyncResult` only. Imports from `#root/src/drizzle-plugins.mjs` (the `#root/*` alias maps to the repo root via `package.json` imports).
 
+Each integration test uses `createTestContext(registerServices, opts)` which starts a server on a random port, connects a client, and returns a `cleanup()` function. Tests import from the published npm packages (`@jcbuisson/express-x`, `@jcbuisson/express-x-client`, `@jcbuisson/express-x-drizzle`), not from local `src/`.
+
 ## Configuration
 
 `expressX(config)` accepts:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcbuisson/express-x",
-  "version": "3.0.5",
+  "version": "3.1.0",
   "description": "",
   "type": "module",
   "main": "src/server.mjs",
@@ -18,7 +18,7 @@
     "#root/*": "./*"
   },
   "scripts": {
-    "test": "node --import tsx/esm --test --test-force-exit test/round-trip.test.mjs"
+    "test": "node --import tsx/esm --test --test-force-exit test/offline.test.mjs test/sync.test.mjs"
   },
   "keywords": [],
   "dependencies": {

package/src/server.mjs

@@ -6,10 +6,6 @@ import bcrypt from 'bcryptjs'
 
 
 
-// UTILISER L'ACKNOWLEDGEMENT : https://socket.io/docs/v4/#acknowledgements
-
-
-
 
 //////////////////////////       UTILITIES       //////////////////////////
 
@@ -185,11 +181,11 @@ export function expressX(config) {
 
       /*
       * Handle websocket client request
-      * Emit in return a 'client-response' message
+      * Respond via socket.io acknowledgment callback
       */
-      socket.on('client-request', async ({ uid, name, action, args }) => {
+      socket.on('client-request', async ({ name, action, args }, ack) => {
          const trimmedArgs = args ? JSON.stringify(args).slice(0, 300) : ''
-         app.log('verbose', `client-request ${uid} ${name} ${action} ${trimmedArgs}`)
+         app.log('verbose', `client-request ${name} ${action} ${trimmedArgs}`)
          if (name in services) {
             const service = services[name]
             try {
@@ -200,30 +196,21 @@ export function expressX(config) {
                      caller: 'client',
                      transport: 'ws',
                      socket,
-                     // connectionId,
                      serviceName: name,
                      methodName: action,
                      args,
                   }
 
                   try {
-                     // call method with context
-                     if (name === 'highlighted_part') {
-                        console.log('')
-                     }
                      const result = await serviceMethod(context, ...args)
 
                      const trimmedResult = result ? JSON.stringify(result).slice(0, 300) : ''
-                     app.log('verbose', `client-response ${uid} ${trimmedResult}`)
-                     socket.emit('client-response', {
-                        uid,
-                        result,
-                     })
+                     app.log('verbose', `client-response ${trimmedResult}`)
+                     ack({ result })
                   } catch(err) {
                      console.log('!!!!!!error', 'name', name, 'action', action, 'args', args, 'err.code', err.code, 'err.message', err.message)
                      app.log('verbose', err.stack)
-                     socket.emit('client-response', {
-                        uid,
+                     ack({
                         error: {
                            code: err.code || 'unknown-error',
                            message: err.message,
@@ -232,8 +219,7 @@ export function expressX(config) {
                      })
                   }
                } else {
-                  socket.emit('client-response', {
-                     uid,
+                  ack({
                      error: {
                         code: 'missing-method',
                         message: `there is no method named '${action}' for service '${name}'`,
@@ -243,18 +229,16 @@ export function expressX(config) {
             } catch(err) {
                console.log('err', err)
                app.log('verbose', err.stack)
-               socket.emit('client-response', {
-                  uid,
+               ack({
                   error: {
                      code: err.code || 'unknown-error',
                      message: err.message,
                      stack: err.stack,
-            }
+                  }
                })
             }
          } else {
-            socket.emit('client-response', {
-               uid,
+            ack({
                error: {
                   code: 'missing-service',
                   message: `there is no service named '${name}'`,

package/test/offline.test.mjs

@@ -5,7 +5,7 @@ process.on('unhandledRejection', (reason, promise) => {
    console.error('UNHANDLED REJECTION:', reason)
 })
 
-import { test, describe } from 'node:test'
+import { test, describe, after } from 'node:test'
 import assert from 'node:assert/strict'
 import { io as ioc } from 'socket.io-client'
 import { PGlite } from '@electric-sql/pglite'
@@ -53,7 +53,7 @@ async function createTestDb(modelName) {
       uid: text('uid').primaryKey(),
       label: text('label').notNull(),
    })
-   return { db, metaTable, modelTable }
+   return { pglite, db, metaTable, modelTable }
 }
 
 // ─── Test context helper ──────────────────────────────────────────────────────
@@ -128,7 +128,7 @@ describe('Full offline-first client ↔ server protocol', () => {
 
    test('sync.go through socket: server records pulled into real Dexie', async () => {
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       await db.insert(modelTable).values({ uid: 'r1', label: 'Vacances' })
       await db.insert(metaTable).values({ uid: 'r1', created_at: T0 })
@@ -148,12 +148,13 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.equal(r1.label, 'Vacances')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
    test('sync.go through socket: local Dexie record pushed to server', async () => {
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       const { clientApp, cleanup } = await createTestContext(
          serverApp => serverApp.configure(drizzleOfflinePlugin, db, metaTable, [modelTable]),
@@ -172,12 +173,13 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.equal(rows[0].label, 'Formation')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
    test('record only on client, deleted → ignored on both sides', async () => {
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       const { clientApp, cleanup } = await createTestContext(
          serverApp => serverApp.configure(drizzleOfflinePlugin, db, metaTable, [modelTable]),
@@ -197,6 +199,7 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.ok(!d1, 'Dexie should no longer hold the deleted record')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
@@ -242,7 +245,7 @@ describe('Full offline-first client ↔ server protocol', () => {
 
    test('deleted record is fully removed from Dexie metadata after sync', async () => {
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       const { clientApp, cleanup } = await createTestContext(
          serverApp => serverApp.configure(drizzleOfflinePlugin, db, metaTable, [modelTable]),
@@ -266,12 +269,13 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.ok(!d1Meta, 'Dexie metadata should also be removed for deleted record')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
    test('record in both, DB newer → client cache is updated with server value', async () => {
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       // Server has s1 at T2 (newer than client)
       await db.insert(modelTable).values({ uid: 's1', label: 'server-v2' })
@@ -300,6 +304,7 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.equal(s1Again.label, 'server-v2', 'second sync should not overwrite client value')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
@@ -346,7 +351,7 @@ describe('Full offline-first client ↔ server protocol', () => {
 
    test('record in both, client newer → server is updated via socket', async () => {
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       await db.insert(modelTable).values({ uid: 'u1', label: 'old' })
       await db.insert(metaTable).values({ uid: 'u1', created_at: T0, updated_at: T1 })
@@ -369,12 +374,13 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.equal(clientValue.label, 'new', 'client Dexie should be unchanged')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
    test('record deleted on server while client was offline is re-created on reconnect', async () => {
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       // r1 exists on server initially
       await db.insert(modelTable).values({ uid: 'r1', label: 'original' })
@@ -407,12 +413,13 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.ok(r1, 'client Dexie should still have r1 after sync')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
    test('offline changes are synced after server restart', async () => {
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       // ─ Phase 1: start server, connect, register synchro scope ─
       const serverApp1 = expressX({})
@@ -479,6 +486,7 @@ describe('Full offline-first client ↔ server protocol', () => {
 
       socket.disconnect()
       await new Promise(resolve => serverApp2.io.close(resolve))
+      pglite.close()
    })
 
    test('updateWithMeta pub/sub handler tolerates undefined value (concurrent delete race)', async () => {
@@ -690,7 +698,7 @@ describe('Full offline-first client ↔ server protocol', () => {
       // other addClient records in the same batch.
       // Fix: use idbValues.put() (upsert) so a pre-existing uid is handled gracefully.
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       await db.insert(modelTable).values({ uid: 'r1', label: 'server-r1' })
       await db.insert(metaTable).values({ uid: 'r1', created_at: T0 })
@@ -729,6 +737,7 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.equal(r2.label, 'server-r2')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
@@ -740,7 +749,7 @@ describe('Full offline-first client ↔ server protocol', () => {
       // Fix: use null instead of new Date() so the client's version "wins" once
       // (updateDatabase), the server gets metadata, and subsequent syncs see diff=0.
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       // Server has s1 in model table but intentionally NO metadata row
       await db.insert(modelTable).values({ uid: 's1', label: 'server-label' })
@@ -774,6 +783,7 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.ok(s1Meta, 'server metadata must be created after the first sync (updateDatabase + upsert)')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
@@ -848,7 +858,7 @@ describe('Full offline-first client ↔ server protocol', () => {
       // TypeError that escapes to the outer try/catch, aborting the entire sync and
       // silently skipping every remaining addDatabase / updateDatabase entry.
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       const { clientApp, cleanup } = await createTestContext(
          serverApp => serverApp.configure(drizzleOfflinePlugin, db, metaTable, [modelTable]),
@@ -876,6 +886,7 @@ describe('Full offline-first client ↔ server protocol', () => {
             'a2 must be pushed to the server even though a1 has missing metadata')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
@@ -887,7 +898,7 @@ describe('Full offline-first client ↔ server protocol', () => {
       // That record enters clientMetadataDict, appears as addDatabase to the server,
       // and if score is NOT NULL the insert fails, rolling back the Dexie record.
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       const { clientApp, cleanup } = await createTestContext(
          serverApp => serverApp.configure(drizzleOfflinePlugin, db, metaTable, [modelTable]),
@@ -909,6 +920,7 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.ok( uids.includes('five-score'), 'score=5 must match { lte: 10 }')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
@@ -921,7 +933,7 @@ describe('Full offline-first client ↔ server protocol', () => {
       // the client includes the record in clientMetadataDict → addDatabase → if the
       // column is NOT NULL the insert fails → rollback deletes the record from Dexie.
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       const { clientApp, cleanup } = await createTestContext(
          serverApp => serverApp.configure(drizzleOfflinePlugin, db, metaTable, [modelTable]),
@@ -942,6 +954,7 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.ok( uids.includes('r2'), 'record with score=5 must match { gte: 1 }')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
@@ -988,6 +1001,7 @@ describe('Full offline-first client ↔ server protocol', () => {
          }
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
@@ -1045,6 +1059,7 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.ok(!uids.includes('hi'),  'score=15 is above range and must NOT be in Dexie')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
@@ -1096,6 +1111,7 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.ok( uids.includes('hi'), 'score=7 should be pulled (≥ 5)')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
@@ -1154,7 +1170,7 @@ describe('Full offline-first client ↔ server protocol', () => {
       // model table → throws → addDatabase catch deletes the record from Dexie.
       // Fix: model INSERT should use ON CONFLICT DO UPDATE just like the metadata INSERT.
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       // Server already has r1 (createWithMeta_A already landed)
       await db.insert(modelTable).values({ uid: 'r1', label: 'original' })
@@ -1186,6 +1202,7 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.ok(r1, 'client Dexie should retain r1 after idempotent createWithMeta')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
@@ -1196,7 +1213,7 @@ describe('Full offline-first client ↔ server protocol', () => {
       // throws a ConstraintError (PK already taken by the orphan), aborting the
       // entire addClient transaction — the record never arrives in the client cache.
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       await db.insert(modelTable).values({ uid: 'r1', label: 'from-server' })
       await db.insert(metaTable).values({ uid: 'r1', created_at: T0 })
@@ -1221,6 +1238,7 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.equal(r1.label, 'from-server')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
@@ -1229,7 +1247,7 @@ describe('Full offline-first client ↔ server protocol', () => {
       // nor the null branch nor the object branch — so boolean where-values are silently
       // ignored and every record passes, sending wrong records into clientMetadataDict.
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       const { clientApp, cleanup } = await createTestContext(
          serverApp => serverApp.configure(drizzleOfflinePlugin, db, metaTable, [modelTable]),
@@ -1249,6 +1267,7 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.ok(!uids.includes('r2'), 'active=false should NOT match { active: true }')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
@@ -1259,7 +1278,7 @@ describe('Full offline-first client ↔ server protocol', () => {
       // with user_uid === null.  In synchronize() this causes records with a non-null
       // user_uid to appear as addDatabase, hit a PK conflict, and get deleted.
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       const { clientApp, cleanup } = await createTestContext(
          serverApp => serverApp.configure(drizzleOfflinePlugin, db, metaTable, [modelTable]),
@@ -1279,6 +1298,7 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.ok( uids.includes('r2'), 'record with user_uid=null should match { user_uid: null }')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
@@ -1289,7 +1309,7 @@ describe('Full offline-first client ↔ server protocol', () => {
       // and the sync pushes them to the server where they fail with PK conflicts,
       // then the rollback deletes them from Dexie (data loss).
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       const { clientApp, cleanup } = await createTestContext(
          serverApp => serverApp.configure(drizzleOfflinePlugin, db, metaTable, [modelTable]),
@@ -1312,12 +1332,13 @@ describe('Full offline-first client ↔ server protocol', () => {
          assert.ok( uids.includes('zero'), 'score=0  should match { lte: 0 }')
       } finally {
          await cleanup()
+         pglite.close()
       }
    })
 
    test('pub/sub createWithMeta event correctly updates a second client\'s Dexie', async () => {
       const modelName = `model${++dbCounter}`
-      const { db, metaTable, modelTable } = await createTestDb(modelName)
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
 
       // Server with pub/sub: every client joins 'all' and createWithMeta broadcasts there
       const serverApp = expressX({})
@@ -1362,6 +1383,7 @@ describe('Full offline-first client ↔ server protocol', () => {
          socketA.disconnect()
          socketB.disconnect()
          await new Promise(resolve => serverApp.io.close(resolve))
+         pglite.close()
       }
    })
 

package/test/sync.test.mjs

@@ -1,7 +1,7 @@
 import { test, describe, mock } from 'node:test'
 import assert from 'node:assert/strict'
 
-import { computeSyncResult } from '#root/src/drizzle-plugins.mjs'
+import { computeSyncResult } from '#root/src/server.mjs'
 
 const T0 = new Date('2026-01-01T00:00:00Z')
 const T1 = new Date('2026-01-02T00:00:00Z')