fix: single write connection prevents flaky notification tests

The write pool defaulted to unlimited connections, but
powersync_update_hooks state is per-connection. install and get could
hit different connections, so get always returned [].

SetMaxOpenConns(1) on the write pool fixes this — SQLite only allows
one writer anyway. Also kick the watcher immediately from Exec and
sqlc write queries so subscribers don't wait for the 50ms poll tick.

Author: binarylogic

internal/sqlite/database.go

@@ -150,6 +150,10 @@ func Open(ctx context.Context, path string) (DB, error) {
 		db.Close()
 		return nil, fmt.Errorf("ping write pool: %w", err)
 	}
+	// SQLite only allows one writer at a time. A single connection avoids
+	// SQLITE_BUSY between writers and ensures powersync_update_hooks state
+	// (which is per-connection) is shared across all write operations.
+	db.SetMaxOpenConns(1)
 
 	// Database-level pragmas (not per-connection — one exec is correct).
 	// WAL allows concurrent readers during writes — the core fix for query blocking during sync.
@@ -236,8 +240,9 @@ func (d *database) ReadQueries() *gen.Queries {
 }
 
 // WriteQueries returns a Queries instance backed by the write pool.
+// Writes kick the watcher so subscribers are notified immediately.
 func (d *database) WriteQueries() *gen.Queries {
-	return gen.New(d.db)
+	return gen.New(&kickingDB{db: d.db, kick: d.kickWatcher})
 }
 
 // ---------------------------------------------------------------------------
@@ -295,9 +300,14 @@ func (d *database) QueryRow(ctx context.Context, query string, args ...any) *sql
 	return d.readDB.QueryRowContext(ctx, query, args...)
 }
 
-// Exec executes a statement via the write pool.
+// Exec executes a statement via the write pool and kicks the watcher so
+// subscribers are notified without waiting for the next poll tick.
 func (d *database) Exec(ctx context.Context, query string, args ...any) (sql.Result, error) {
-	return d.db.ExecContext(ctx, query, args...)
+	result, err := d.db.ExecContext(ctx, query, args...)
+	if err == nil {
+		d.kickWatcher()
+	}
+	return result, err
 }
 
 // BeginTx starts a transaction on the write pool.

internal/sqlite/watch.go

@@ -2,10 +2,13 @@ package sqlite
 
 import (
 	"context"
+	"database/sql"
 	"encoding/json"
 	"strings"
 	"sync"
 	"time"
+
+	"github.com/usetero/cli/internal/sqlite/gen"
 )
 
 const (
@@ -32,12 +35,39 @@ func (s *Subscription) Stop() {
 	s.db.unsubscribe(s)
 }
 
+// kickingDB wraps a DBTX and kicks the watcher after successful writes.
+type kickingDB struct {
+	db   gen.DBTX
+	kick func()
+}
+
+func (k *kickingDB) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) {
+	result, err := k.db.ExecContext(ctx, query, args...)
+	if err == nil {
+		k.kick()
+	}
+	return result, err
+}
+
+func (k *kickingDB) PrepareContext(ctx context.Context, query string) (*sql.Stmt, error) {
+	return k.db.PrepareContext(ctx, query)
+}
+
+func (k *kickingDB) QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error) {
+	return k.db.QueryContext(ctx, query, args...)
+}
+
+func (k *kickingDB) QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row {
+	return k.db.QueryRowContext(ctx, query, args...)
+}
+
 // watchState manages change detection and subscriber notification.
 type watchState struct {
 	mu          sync.RWMutex
 	subscribers map[*Subscription]struct{}
 	installed   bool
 	cancel      context.CancelFunc
+	kick        chan struct{} // signals an immediate check
 }
 
 // installUpdateHooks enables change tracking via PowerSync's update hooks.
@@ -60,13 +90,15 @@ func (d *database) installUpdateHooks(ctx context.Context) error {
 	// Start background polling goroutine
 	pollCtx, cancel := context.WithCancel(ctx)
 	d.watch.cancel = cancel
+	d.watch.kick = make(chan struct{}, 1)
 	go d.pollForChanges(pollCtx)
 
 	d.watch.installed = true
 	return nil
 }
 
-// pollForChanges runs in the background, checking for table changes periodically.
+// pollForChanges runs in the background, checking for table changes periodically
+// or immediately when kicked by Exec.
 func (d *database) pollForChanges(ctx context.Context) {
 	ticker := time.NewTicker(pollInterval)
 	defer ticker.Stop()
@@ -77,10 +109,25 @@ func (d *database) pollForChanges(ctx context.Context) {
 			return
 		case <-ticker.C:
 			d.checkForChanges()
+		case <-d.watch.kick:
+			d.checkForChanges()
 		}
 	}
 }
 
+// kickWatcher signals the poll loop to check immediately.
+// Safe to call before hooks are installed (no-op).
+func (d *database) kickWatcher() {
+	if d.watch.kick == nil {
+		return
+	}
+	select {
+	case d.watch.kick <- struct{}{}:
+	default:
+		// Already pending — poller will pick it up.
+	}
+}
+
 // Subscribe returns a Subscription that receives table names when they change.
 // The channel has a buffer of 1 to avoid blocking the poller.
 // Call Stop() on the subscription when done to prevent leaks.