@syncular/server 0.16.1 → 0.17.0

package/dist/postgres-storage.js

@@ -110,6 +110,11 @@ CREATE INDEX IF NOT EXISTS sync_blob_refs_by_blob
   ON sync_blob_refs(partition, blob_id);
 `;
 async function lockPartitionOn(client, partition) {
+    const locked = await client.query('SELECT max_commit_seq FROM sync_partitions WHERE partition=$1 FOR UPDATE', [partition]);
+    if (locked.rows.length > 0)
+        return;
+    // The first writer initializes the partition. Concurrent initializers may
+    // wait on this insert, so acquire the row lock again before applying writes.
     await client.query(`INSERT INTO sync_partitions(partition, max_commit_seq) VALUES ($1, 0)
     ON CONFLICT (partition) DO NOTHING`, [partition]);
     await client.query('SELECT max_commit_seq FROM sync_partitions WHERE partition=$1 FOR UPDATE', [partition]);
@@ -438,26 +443,37 @@ class PostgresTransaction {
         // Allocate the next dense commitSeq under a per-partition row lock: the
         // UPDATE … RETURNING serializes concurrent pushes to this partition and
         // never leaves a gap on rollback (see the file header).
-        const { rows } = await q.query(`INSERT INTO sync_partitions(partition, max_commit_seq) VALUES ($1, 1)
-       ON CONFLICT (partition) DO UPDATE
-         SET max_commit_seq = sync_partitions.max_commit_seq + 1
-       RETURNING max_commit_seq`, [p]);
-        const commitSeq = asNumber(rows[0]?.max_commit_seq);
-        await q.query(`INSERT INTO sync_commits(partition, commit_seq, client_id, client_commit_id, actor_id, created_at_ms)
-       VALUES ($1,$2,$3,$4,$5,$6)`, [
+        const { rows } = await q.query(`WITH allocated AS (
+         INSERT INTO sync_partitions(partition, max_commit_seq) VALUES ($1, 1)
+         ON CONFLICT (partition) DO UPDATE
+           SET max_commit_seq = sync_partitions.max_commit_seq + 1
+         RETURNING max_commit_seq
+       )
+       INSERT INTO sync_commits(partition, commit_seq, client_id, client_commit_id, actor_id, created_at_ms)
+       SELECT $1, max_commit_seq, $2, $3, $4, $5 FROM allocated
+       RETURNING commit_seq`, [
             p,
-            commitSeq,
             commit.clientId,
             commit.clientCommitId,
             commit.actorId,
             commit.createdAtMs,
         ]);
+        const commitSeq = asNumber(rows[0]?.commit_seq);
         for (let idx = 0; idx < commit.changes.length; idx++) {
             const change = commit.changes[idx];
             if (change === undefined)
                 continue;
-            await q.query(`INSERT INTO sync_changes(partition, commit_seq, idx, tbl, row_id, op, row_version, scopes, payload)
-         VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9)`, [
+            // Bind serialized scopes as text before parsing JSONB. Drivers that
+            // encode JSONB parameters would otherwise store this string as a scalar.
+            await q.query(`WITH inserted AS (
+           INSERT INTO sync_changes(partition, commit_seq, idx, tbl, row_id, op, row_version, scopes, payload)
+           VALUES ($1,$2,$3,$4,$5,$6,$7,$8::text::jsonb,$9)
+           RETURNING partition, tbl, commit_seq, scopes
+         )
+         INSERT INTO sync_change_scopes(partition, tbl, var, value, commit_seq)
+         SELECT inserted.partition, inserted.tbl, scope.key, scope.value, inserted.commit_seq
+         FROM inserted CROSS JOIN LATERAL jsonb_each_text(inserted.scopes) AS scope
+         ON CONFLICT DO NOTHING`, [
                 p,
                 commitSeq,
                 idx,
@@ -468,10 +484,6 @@ class PostgresTransaction {
                 JSON.stringify(change.scopes),
                 change.payload ?? null,
             ]);
-            for (const [variable, value] of Object.entries(change.scopes)) {
-                await q.query(`INSERT INTO sync_change_scopes(partition, tbl, var, value, commit_seq)
-           VALUES ($1,$2,$3,$4,$5) ON CONFLICT DO NOTHING`, [p, change.table, variable, value, commitSeq]);
-            }
         }
         return commitSeq;
     }
@@ -622,6 +634,9 @@ export class PostgresServerStorage {
                     await client.query('DELETE FROM sync_row_scopes WHERE tbl=$1', [
                         tableName,
                     ]);
+                    await client.query('DELETE FROM sync_blob_refs WHERE tbl=$1', [
+                        tableName,
+                    ]);
                     await client.query(dropTableDdl(tableName));
                 }
                 for (const statement of schemaDdl(schema, existing, 'postgres', existingIndexes)) {
@@ -1094,6 +1109,18 @@ export class PostgresServerStorage {
             record.updatedAtMs,
         ]);
     }
+    async advanceClientCursor(partition, clientId, actorId, logEpoch, cursor, updatedAtMs) {
+        await this.#exec.query(`UPDATE sync_clients
+         SET cursor=GREATEST(cursor, $1), updated_at_ms=GREATEST(updated_at_ms, $2)
+         WHERE partition=$3 AND client_id=$4 AND actor_id=$5
+           AND EXISTS (SELECT 1 FROM sync_partition_registry
+                       WHERE partition=sync_clients.partition AND log_epoch=$6)`, [cursor, updatedAtMs, partition, clientId, actorId, logEpoch]);
+    }
+    async updateClientCursor(partition, clientId, cursor, updatedAtMs) {
+        await this.#exec.query(`UPDATE sync_clients
+       SET cursor=GREATEST(cursor, $3), updated_at_ms=GREATEST(updated_at_ms, $4)
+       WHERE partition=$1 AND client_id=$2`, [partition, clientId, cursor, updatedAtMs]);
+    }
     async getActiveClientCursorFloor(partition, cutoffMs) {
         const { rows } = await this.#exec.query('SELECT MIN(cursor) AS cursor FROM sync_clients WHERE partition=$1 AND updated_at_ms>=$2', [partition, cutoffMs]);
         return rows[0].cursor === null ? null : asNumber(rows[0].cursor);

package/dist/pull.js

@@ -361,6 +361,22 @@ export async function* subscriptionSection(ctx, schema, limits, plan, maxSeq, ho
         return { nextCursor: sub.cursor, active: false };
     }
     const token = parseBootstrapToken(sub.bootstrapState, sub.table);
+    let commits = [];
+    if (token === undefined &&
+        sub.cursor >= 0 &&
+        sub.cursor >= horizonSeq &&
+        sub.cursor <= maxSeq) {
+        commits = await ctx.storage.readCommitWindow(ctx.partition, {
+            table: sub.table,
+            scopeFilter: plan.effective,
+            afterSeq: sub.cursor,
+            throughSeq: maxSeq,
+            limitChanges: limits.limitCommits + 1,
+        });
+        // Validate continuity before committing to an active section. A prune
+        // during a paged read can otherwise make an incomplete window look empty.
+        horizonSeq = Math.max(horizonSeq, await ctx.storage.getHorizonSeq(ctx.partition));
+    }
     // §4.6: a cursor behind the horizon (and not resuming a bootstrap)
     // cannot compute deltas — answer `reset` and echo the cursor.
     if (token === undefined && sub.cursor >= 0 && sub.cursor < horizonSeq) {
@@ -421,13 +437,6 @@ export async function* subscriptionSection(ctx, schema, limits, plan, maxSeq, ho
         effectiveScopes: plan.effective,
         bootstrap: false,
     };
-    const commits = await ctx.storage.readCommitWindow(ctx.partition, {
-        table: sub.table,
-        scopeFilter: plan.effective,
-        afterSeq: sub.cursor,
-        throughSeq: maxSeq,
-        limitChanges: limits.limitCommits + 1,
-    });
     let delivered = 0;
     let deliveredCommits = 0;
     let lastDeliveredSeq = sub.cursor;

package/dist/realtime.d.ts

@@ -137,7 +137,7 @@ export declare class RealtimeSession {
     handleBinary(bytes: Uint8Array): Promise<void> | undefined;
     sendHeartbeat(): void;
     sendWake(reason: WakeReason): void;
-    /** Called by the hub for every applied commit, in commitSeq order. */
+    /** Called by the hub for every applied commit notification. */
     deliverCommit(commit: StoredCommit): void;
     close(): void;
 }

package/dist/realtime.js

@@ -191,6 +191,10 @@ export class RealtimeSession {
         if (typeof cursor !== 'number' || !Number.isSafeInteger(cursor))
             return;
         this.cursor = Math.max(this.cursor, cursor);
+        // The client may have caught up through another binding (§8.4). Its ack
+        // proves those commits no longer need socket notifications, so the next
+        // notification must be adjacent to the acknowledged cursor.
+        this.lastKnownSeq = Math.max(this.lastKnownSeq, this.cursor);
         if (this.cursor >= this.lastKnownSeq)
             this.wakePending = false;
         // §8.2: acks update the client cursor record without an HTTP pull.
@@ -468,14 +472,7 @@ export class RealtimeSession {
     }
     async #persistCursor() {
         try {
-            const record = await this.#storage.getClientRecord(this.partition, this.clientId);
-            if (record === undefined)
-                return;
-            await this.#storage.putClientRecord(this.partition, {
-                ...record,
-                cursor: Math.max(record.cursor, this.cursor),
-                updatedAtMs: this.#clock(),
-            });
+            await this.#storage.advanceClientCursor(this.partition, this.clientId, this.actorId, this.logEpoch, this.cursor, this.#clock());
         }
         catch {
             // Cursor persistence is best-effort; the next pull repairs it.
@@ -523,8 +520,9 @@ export class RealtimeSession {
             });
         }
     }
-    /** Called by the hub for every applied commit, in commitSeq order. */
+    /** Called by the hub for every applied commit notification. */
     deliverCommit(commit) {
+        const contiguous = commit.commitSeq === this.lastKnownSeq + 1;
         this.lastKnownSeq = Math.max(this.lastKnownSeq, commit.commitSeq);
         const sections = [];
         for (const registration of this.registrations) {
@@ -544,6 +542,14 @@ export class RealtimeSession {
             if (changes.length > 0)
                 sections.push({ registration, changes });
         }
+        if (!contiguous) {
+            // Pushes allocate commitSeq under the partition lock but notify after
+            // commit, so racing notifications may arrive out of order. A gap,
+            // duplicate, or regression cannot be a delta: the client would apply
+            // and acknowledge a cursor that does not prove the intervening log.
+            this.sendWake('catchup-required');
+            return;
+        }
         if (sections.length === 0)
             return;
         if (this.#activeRound !== undefined) {
@@ -600,7 +606,7 @@ export class RealtimeSession {
         tagged[0] = REALTIME_TAG_DELTA;
         tagged.set(bytes, 1);
         this.#sendSafe(tagged);
-        this.cursor = commit.commitSeq;
+        this.cursor = Math.max(this.cursor, commit.commitSeq);
         const events = this.#events;
         if (events !== undefined) {
             emitEvent(events, {

package/dist/relational-rows.d.ts

@@ -87,7 +87,7 @@ export declare const SYNC_INDEX_PREFIX = "sync_ix_";
 export declare function physicalIndexName(declaredName: string): string;
 /**
  * CREATE INDEX IF NOT EXISTS for the table's user-declared indexes. These use
- * the same declared names and columns the client materializes. Cross-table
+ * the declared columns with a leading server partition column. Cross-table
  * index-name uniqueness is the user's schema concern, as it is client-side.
  * Server-side the physical name carries the {@link SYNC_INDEX_PREFIX}
  * ownership marker.
@@ -181,6 +181,12 @@ export declare function commitWindowPageSql(valueCount: number, dialect: Relatio
 export declare function selectRowScopesSql(table: CompiledTable, dialect: RelationalDialect): string;
 /** DELETE one stored row. Params: [partition, rowId]. */
 export declare function deleteRowSql(table: CompiledTable, dialect: RelationalDialect): string;
+/**
+ * SQLite: remove the old row's exact scope keys before replacing or deleting the row.
+ * Params: [partition, table, rowId, partition, rowId]. The caller keeps this
+ * statement and the row write in the same transaction (or D1 atomic batch).
+ */
+export declare function deleteSqliteRowScopesSql(table: CompiledTable): string;
 /**
  * The schema-version marker table gates DDL work. `ensureSchema` compares the
  * stored version and skips

package/dist/relational-rows.js

@@ -177,7 +177,7 @@ export function physicalIndexName(declaredName) {
 }
 /**
  * CREATE INDEX IF NOT EXISTS for the table's user-declared indexes. These use
- * the same declared names and columns the client materializes. Cross-table
+ * the declared columns with a leading server partition column. Cross-table
  * index-name uniqueness is the user's schema concern, as it is client-side.
  * Server-side the physical name carries the {@link SYNC_INDEX_PREFIX}
  * ownership marker.
@@ -188,7 +188,7 @@ export function createIndexDdl(table) {
         return [];
     return table.indexes.map((index) => {
         const unique = index.unique ? 'UNIQUE ' : '';
-        const columns = index.columns
+        const columns = [SYNC_PARTITION_COLUMN, ...index.columns]
             .map((column) => quoteIdent(column))
             .join(', ');
         return `CREATE ${unique}INDEX IF NOT EXISTS ${quoteIdent(physicalIndexName(index.name))} ON ${quoteIdent(table.name)} (${columns})`;
@@ -401,6 +401,21 @@ export function deleteRowSql(table, dialect) {
     const p = dialect === 'sqlite' ? ['?', '?'] : ['$1', '$2'];
     return `DELETE FROM ${quoteIdent(table.name)} WHERE ${quoteIdent(SYNC_PARTITION_COLUMN)}=${p[0]} AND ${quoteIdent(SYNC_ROW_ID_COLUMN)}=${p[1]}`;
 }
+/**
+ * SQLite: remove the old row's exact scope keys before replacing or deleting the row.
+ * Params: [partition, table, rowId, partition, rowId]. The caller keeps this
+ * statement and the row write in the same transaction (or D1 atomic batch).
+ */
+export function deleteSqliteRowScopesSql(table) {
+    return `DELETE FROM sync_row_scopes
+    WHERE partition=? AND tbl=? AND row_id=?
+      AND (var, value) IN (
+        SELECT key, value FROM json_each((
+          SELECT ${quoteIdent(SYNC_SCOPES_COLUMN)} FROM ${quoteIdent(table.name)}
+          WHERE ${quoteIdent(SYNC_PARTITION_COLUMN)}=? AND ${quoteIdent(SYNC_ROW_ID_COLUMN)}=?
+        ))
+      )`;
+}
 /**
  * The schema-version marker table gates DDL work. `ensureSchema` compares the
  * stored version and skips

package/dist/sqlite-storage.d.ts

@@ -37,6 +37,8 @@ export declare class SqliteServerStorage implements ServerStorage {
     scanRowsByIndex(partition: string, query: IndexRowScanQuery): Promise<StoredRow[]>;
     getClientRecord(partition: string, clientId: string): Promise<ClientRecord | undefined>;
     putClientRecord(partition: string, record: ClientRecord): Promise<void>;
+    advanceClientCursor(partition: string, clientId: string, actorId: string, logEpoch: string, cursor: number, updatedAtMs: number): Promise<void>;
+    updateClientCursor(partition: string, clientId: string, cursor: number, updatedAtMs: number): Promise<void>;
     getActiveClientCursorFloor(partition: string, cutoffMs: number): Promise<number | null>;
     listClientCursors(partition: string): Promise<ClientCursorInfo[]>;
     listRowsReferencingBlob(partition: string, blobId: string): Promise<{

package/dist/sqlite-storage.js

@@ -10,7 +10,7 @@ import { StorageQueryError } from './storage-errors.js';
  */
 import { bindAuthoritativePartition, prepareAuthoritativeQuery, } from './authoritative-query.js';
 import { syncError } from './errors.js';
-import { commitWindowPageSql, deleteRowSql, dropTableDdl, indexRowPageStatement, layoutsOf, migratePayload, parseLayouts, retiredTableNames, rewritePlan, rewriteRowSql, rewriteValues, SCHEMA_META_DDL_SQLITE, scanRowPageSql, schemaDdl, selectRowScopesSql, selectRowSql, selectRowsForRewriteSql, upsertSql, upsertValues, } from './relational-rows.js';
+import { commitWindowPageSql, deleteRowSql, deleteSqliteRowScopesSql, dropTableDdl, indexRowPageStatement, layoutsOf, migratePayload, parseLayouts, retiredTableNames, rewritePlan, rewriteRowSql, rewriteValues, SCHEMA_META_DDL_SQLITE, scanRowPageSql, schemaDdl, selectRowScopesSql, selectRowSql, selectRowsForRewriteSql, upsertSql, upsertValues, } from './relational-rows.js';
 import { matchesEffective } from './scopes.js';
 import { collectCommitWindowPage, deserializePushResult, SQLITE_DDL, serializePushResult, toStoredRow, } from './sqlite-dialect.js';
 import { SqliteAdapterRequiredError, } from './sqlite-driver.js';
@@ -108,8 +108,9 @@ class SqliteTransaction {
     async deleteRow(table, rowId) {
         this.#assertOpen();
         const db = this.#storage.db;
-        db.query(deleteRowSql(this.#storage.table(table), 'sqlite')).run(this.#partition, rowId);
-        db.query('DELETE FROM sync_row_scopes WHERE partition=? AND tbl=? AND row_id=?').run(this.#partition, table, rowId);
+        const compiled = this.#storage.table(table);
+        db.query(deleteSqliteRowScopesSql(compiled)).run(this.#partition, table, rowId, this.#partition, rowId);
+        db.query(deleteRowSql(compiled, 'sqlite')).run(this.#partition, rowId);
         // §5.9.4: a deleted row references no blobs.
         db.query('DELETE FROM sync_blob_refs WHERE partition=? AND tbl=? AND row_id=?').run(this.#partition, table, rowId);
     }
@@ -277,6 +278,9 @@ export class SqliteServerStorage {
                     this.db
                         .query('DELETE FROM sync_row_scopes WHERE tbl=?')
                         .run(tableName);
+                    this.db
+                        .query('DELETE FROM sync_blob_refs WHERE tbl=?')
+                        .run(tableName);
                     this.db.exec(dropTableDdl(tableName));
                 }
                 for (const statement of schemaDdl(schema, existing, 'sqlite', existingIndexes)) {
@@ -423,12 +427,12 @@ export class SqliteServerStorage {
     /** Internal: write a row + refresh its scope-index entries. */
     writeRow(partition, table, row) {
         const compiled = this.table(table);
+        this.db
+            .query(deleteSqliteRowScopesSql(compiled))
+            .run(partition, table, row.rowId, partition, row.rowId);
         this.db
             .query(upsertSql(compiled, 'sqlite'))
             .run(...upsertValues(compiled, partition, row, 'sqlite'));
-        this.db
-            .query('DELETE FROM sync_row_scopes WHERE partition=? AND tbl=? AND row_id=?')
-            .run(partition, table, row.rowId);
         for (const [variable, value] of Object.entries(row.scopes)) {
             this.db
                 .query('INSERT OR IGNORE INTO sync_row_scopes(partition, tbl, var, value, row_id) VALUES (?,?,?,?,?)')
@@ -786,6 +790,22 @@ export class SqliteServerStorage {
             .query('INSERT OR REPLACE INTO sync_clients(partition, client_id, actor_id, wire_version, cursor, subscriptions, updated_at_ms) VALUES (?,?,?,?,?,?,?)')
             .run(partition, record.clientId, record.actorId, record.wireVersion, record.cursor, JSON.stringify(record.subscriptions), record.updatedAtMs);
     }
+    async advanceClientCursor(partition, clientId, actorId, logEpoch, cursor, updatedAtMs) {
+        this.db
+            .query(`UPDATE sync_clients
+         SET cursor=MAX(cursor, ?), updated_at_ms=MAX(updated_at_ms, ?)
+         WHERE partition=? AND client_id=? AND actor_id=?
+           AND EXISTS (SELECT 1 FROM sync_partition_registry
+                       WHERE partition=sync_clients.partition AND log_epoch=?)`)
+            .run(cursor, updatedAtMs, partition, clientId, actorId, logEpoch);
+    }
+    async updateClientCursor(partition, clientId, cursor, updatedAtMs) {
+        this.db
+            .query(`UPDATE sync_clients
+         SET cursor=MAX(cursor, ?), updated_at_ms=MAX(updated_at_ms, ?)
+         WHERE partition=? AND client_id=?`)
+            .run(cursor, updatedAtMs, partition, clientId);
+    }
     async getActiveClientCursorFloor(partition, cutoffMs) {
         const row = this.db
             .query('SELECT MIN(cursor) AS cursor FROM sync_clients WHERE partition=? AND updated_at_ms>=?')

package/dist/storage-errors.d.ts

@@ -9,7 +9,7 @@ export declare class StorageConstraintError extends Error {
     constructor(cause: unknown, opIndex?: number);
 }
 /** Stable, privacy-safe failures for trusted server storage queries. */
-export type StorageQueryErrorCode = 'sync.storage.scan_requires_scope' | 'sync.storage.index_not_found' | 'sync.storage.index_not_materialized' | 'sync.storage.index_value_count_mismatch' | 'sync.storage.invalid_limit' | 'sync.storage.prune_epoch_mismatch' | 'sync.storage.partition_unregistered' | 'sync.storage.invalid_prune_cursor';
+export type StorageQueryErrorCode = 'sync.storage.schema_migration_pending' | 'sync.storage.schema_migration_conflict' | 'sync.storage.schema_changed' | 'sync.storage.invalid_migration_budget' | 'sync.storage.scan_requires_scope' | 'sync.storage.index_not_found' | 'sync.storage.index_not_materialized' | 'sync.storage.index_value_count_mismatch' | 'sync.storage.invalid_limit' | 'sync.storage.prune_epoch_mismatch' | 'sync.storage.partition_unregistered' | 'sync.storage.invalid_prune_cursor';
 /**
  * Host-only query error. Messages never include identifiers, values, SQL,
  * paths, or row data; callers branch on `code`, never message text.

package/dist/storage-errors.js

@@ -12,6 +12,10 @@ export class StorageConstraintError extends Error {
     }
 }
 const STORAGE_QUERY_MESSAGES = {
+    'sync.storage.schema_migration_pending': 'schema migration requires another invocation',
+    'sync.storage.schema_migration_conflict': 'another schema migration target is already pending',
+    'sync.storage.schema_changed': 'storage schema is not ready for this operation',
+    'sync.storage.invalid_migration_budget': 'migration statement budget must be an integer from 10 through 1000',
     'sync.storage.prune_epoch_mismatch': 'partition log epoch changed; recompute retention inputs',
     'sync.storage.partition_unregistered': 'pruning requires a registered partition',
     'sync.storage.invalid_prune_cursor': 'pruning requires a non-negative safe integer cursor and a non-empty log epoch',

package/dist/storage.d.ts

@@ -425,6 +425,15 @@ export interface ServerStorage {
     scanRowsByIndex?(partition: string, query: IndexRowScanQuery): Promise<StoredRow[]>;
     getClientRecord(partition: string, clientId: string): Promise<ClientRecord | undefined>;
     putClientRecord(partition: string, record: ClientRecord): Promise<void>;
+    /**
+     * Atomically advance an existing record's cursor and activity timestamp.
+     * Preserve registration fields; require matching actor and current log epoch.
+     * Missing records and mismatched identities are unchanged (§8.2).
+     */
+    advanceClientCursor(partition: string, clientId: string, actorId: string, logEpoch: string, cursor: number, updatedAtMs: number): Promise<void>;
+    /** Advance an existing client's ACK cursor and timestamp atomically,
+     * preserving actor, wire version, and subscriptions. Missing records stay absent. */
+    updateClientCursor(partition: string, clientId: string, cursor: number, updatedAtMs: number): Promise<void>;
     /** Minimum cursor with updatedAtMs >= cutoff; null when none are active. */
     getActiveClientCursorFloor(partition: string, cutoffMs: number): Promise<number | null>;
     /** Cursor records for client listings and administrative counts. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncular/server",
-  "version": "0.16.1",
+  "version": "0.17.0",
   "description": "Syncular server: handleSyncRequest + storage/auth interfaces for the sync protocol",
   "license": "Apache-2.0",
   "author": "Benjamin Kniffler",
@@ -68,7 +68,7 @@
     "verify:node": "cd ../.. && bun build ./packages/server/test/sqlite-runtime/verify-node.mjs --target=node --conditions=bun --outfile=./packages/server/.verify-node.built.mjs && node ./packages/server/.verify-node.built.mjs"
   },
   "dependencies": {
-    "@syncular/core": "0.16.1"
+    "@syncular/core": "0.17.0"
   },
   "devDependencies": {
     "@electric-sql/pglite": "^0.5.4"