orez 0.0.47 → 0.0.49

package/src/pglite-manager.ts

@@ -16,7 +16,7 @@ export interface PGliteInstances {
 }
 
 // create a single pglite instance with given dataDir suffix
-export async function createInstance(
+async function createInstance(
   config: ZeroLiteConfig,
   name: string,
   withExtensions: boolean

package/src/replication/change-tracker.ts

@@ -67,35 +67,6 @@ export async function installChangeTracking(db: PGlite): Promise<void> {
     $$ LANGUAGE plpgsql;
   `)
 
-  // auto-install change tracking on tables created after startup (e.g. via restore
-  // or wire protocol). uses a DDL event trigger that fires on CREATE TABLE.
-  await db.exec(`
-    CREATE OR REPLACE FUNCTION public._zero_auto_track() RETURNS event_trigger AS $$
-    DECLARE
-      obj record;
-    BEGIN
-      FOR obj IN SELECT * FROM pg_event_trigger_ddl_commands()
-                 WHERE command_tag = 'CREATE TABLE'
-      LOOP
-        IF obj.schema_name = 'public'
-           AND obj.object_identity NOT LIKE '%._zero_%'
-           AND obj.object_identity NOT LIKE '%.migrations'
-        THEN
-          EXECUTE format(
-            'CREATE TRIGGER _zero_change_trigger AFTER INSERT OR UPDATE OR DELETE ON %s FOR EACH ROW EXECUTE FUNCTION public._zero_track_change()',
-            obj.object_identity
-          );
-        END IF;
-      END LOOP;
-    END;
-    $$ LANGUAGE plpgsql;
-
-    DROP EVENT TRIGGER IF EXISTS _zero_auto_track_trigger;
-    CREATE EVENT TRIGGER _zero_auto_track_trigger ON ddl_command_end
-      WHEN TAG IN ('CREATE TABLE')
-      EXECUTE FUNCTION public._zero_auto_track();
-  `)
-
   // install triggers on all public tables
   await installTriggersOnAllTables(db)
 }
@@ -169,58 +140,6 @@ async function installTriggersOnAllTables(db: PGlite): Promise<void> {
   log.debug.pglite(`installed change tracking triggers on ${count} tables`)
 }
 
-/**
- * re-install change tracking triggers on any public tables that don't have them.
- * catches tables created between startup and replication start.
- */
-export async function ensureChangeTrackingOnAllTables(db: PGlite): Promise<void> {
-  const pubName = process.env.ZERO_APP_PUBLICATIONS
-  let tables: { tablename: string }[]
-
-  if (pubName) {
-    const result = await db.query<{ tablename: string }>(
-      `SELECT tablename FROM pg_publication_tables
-       WHERE pubname = $1
-         AND schemaname = 'public'
-         AND tablename NOT LIKE '_zero_%'`,
-      [pubName]
-    )
-    tables = result.rows
-  } else {
-    const result = await db.query<{ tablename: string }>(
-      `SELECT tablename FROM pg_tables
-       WHERE schemaname = 'public'
-         AND tablename NOT IN ('migrations', '_zero_changes')
-         AND tablename NOT LIKE '_zero_%'`
-    )
-    tables = result.rows
-  }
-
-  // find tables missing the change trigger
-  const triggered = await db.query<{ event_object_table: string }>(
-    `SELECT DISTINCT event_object_table FROM information_schema.triggers
-     WHERE trigger_name = '_zero_change_trigger'
-       AND event_object_schema = 'public'`
-  )
-  const hasTracker = new Set(triggered.rows.map((r) => r.event_object_table))
-
-  let count = 0
-  for (const { tablename } of tables) {
-    if (hasTracker.has(tablename)) continue
-    const quoted = quoteIdent(tablename)
-    await db.exec(`
-      CREATE TRIGGER _zero_change_trigger
-        AFTER INSERT OR UPDATE OR DELETE ON public.${quoted}
-        FOR EACH ROW EXECUTE FUNCTION public._zero_track_change();
-    `)
-    count++
-  }
-
-  if (count > 0) {
-    log.debug.pglite(`installed change tracking on ${count} new tables`)
-  }
-}
-
 /**
  * install change tracking triggers on tables in shard schemas.
  * zero-cache creates shard schemas (e.g. chat_0) with clients/mutations
@@ -276,17 +195,6 @@ export async function getChangesSince(
   return result.rows
 }
 
-export async function purgeConsumedChanges(
-  db: PGlite,
-  watermark: number
-): Promise<number> {
-  const result = await db.query<{ count: string }>(
-    'WITH deleted AS (DELETE FROM public._zero_changes WHERE watermark <= $1 RETURNING 1) SELECT count(*)::text AS count FROM deleted',
-    [watermark]
-  )
-  return Number(result.rows[0]?.count || 0)
-}
-
 export async function getCurrentWatermark(db: PGlite): Promise<number> {
   const result = await db.query<{ last_value: string; is_called: boolean }>(
     'SELECT last_value, is_called FROM public._zero_watermark'

package/src/replication/handler.ts

@@ -10,9 +10,7 @@ import { log } from '../log.js'
 import {
   getChangesSince,
   getCurrentWatermark,
-  purgeConsumedChanges,
   installTriggersOnShardTables,
-  ensureChangeTrackingOnAllTables,
   type ChangeRecord,
 } from './change-tracker.js'
 import {
@@ -33,9 +31,6 @@ import {
 import type { Mutex } from '../mutex.js'
 import type { PGlite } from '@electric-sql/pglite'
 
-// track concurrent replication handlers to detect reconnect-purge race
-let activeHandlerCount = 0
-
 export interface ReplicationWriter {
   write(data: Uint8Array): void
 }
@@ -266,9 +261,6 @@ export async function handleStartReplication(
   db: PGlite,
   mutex: Mutex
 ): Promise<void> {
-  activeHandlerCount++
-  const handlerId = activeHandlerCount
-  console.info(`[orez-repl#${handlerId}] START_REPLICATION (active handlers: ${activeHandlerCount})`)
   log.debug.proxy('replication: entering streaming mode')
 
   // send CopyBothResponse to enter streaming mode
@@ -292,9 +284,6 @@ export async function handleStartReplication(
   // "already in transaction" errors when they interleave.
   await mutex.acquire()
   try {
-    // install change tracking triggers on any tables created after startup
-    await ensureChangeTrackingOnAllTables(db)
-
     // install change tracking triggers on shard schema tables (e.g. chat_0.clients)
     // these track zero-cache's lastMutationID for .server promise resolution
     await installTriggersOnShardTables(db)
@@ -463,21 +452,13 @@ export async function handleStartReplication(
     mutex.release()
   }
 
-  console.info(`[orez-repl#${handlerId}] setup complete, starting poll (lastWatermark=${lastWatermark})`)
-
   // track which tables we've sent RELATION messages for
   const sentRelations = new Set<string>()
   let txCounter = 1
 
   // polling + notification loop
-  // adaptive: poll fast when catching up, slow when idle
-  const pollIntervalIdle = 500
-  const pollIntervalCatchUp = 20
-  const batchSize = 2000
-  const purgeEveryN = 10
+  const pollInterval = 500
   let running = true
-  let pollsSincePurge = 0
-  let lastIdleLog = 0
 
   const poll = async () => {
     while (running) {
@@ -486,14 +467,12 @@ export async function handleStartReplication(
         await mutex.acquire()
         let changes: Awaited<ReturnType<typeof getChangesSince>>
         try {
-          changes = await getChangesSince(db, lastWatermark, batchSize)
+          changes = await getChangesSince(db, lastWatermark, 100)
         } finally {
           mutex.release()
         }
 
         if (changes.length > 0) {
-          const tables = [...new Set(changes.map(c => c.table_name))].join(',')
-          console.info(`[orez-repl#${handlerId}] found ${changes.length} changes [${tables}] (wm ${lastWatermark}→${changes[changes.length - 1].watermark}, type=${typeof changes[0].watermark})`)
           await streamChanges(
             changes,
             writer,
@@ -504,37 +483,13 @@ export async function handleStartReplication(
             columnTypeOids
           )
           lastWatermark = changes[changes.length - 1].watermark
-
-          // purge consumed changes periodically to free wasm memory
-          pollsSincePurge++
-          if (pollsSincePurge >= purgeEveryN) {
-            pollsSincePurge = 0
-            await mutex.acquire()
-            try {
-              const purged = await purgeConsumedChanges(db, lastWatermark)
-              if (purged > 0) {
-                console.info(`[orez-repl#${handlerId}] purged ${purged} changes (wm<=${lastWatermark})`)
-              }
-            } finally {
-              mutex.release()
-            }
-          }
-        } else {
-          // throttled idle logging (every 10s)
-          const now = Date.now()
-          if (now - lastIdleLog > 10000) {
-            lastIdleLog = now
-            console.info(`[orez-repl#${handlerId}] idle (lastWatermark=${lastWatermark}, type=${typeof lastWatermark})`)
-          }
         }
 
         // send keepalive
         const ts = nowMicros()
         writer.write(encodeKeepalive(currentLsn, ts, false))
 
-        // if we got a full batch, there's likely more - poll fast
-        const delay = changes.length >= batchSize ? pollIntervalCatchUp : pollIntervalIdle
-        await new Promise((resolve) => setTimeout(resolve, delay))
+        await new Promise((resolve) => setTimeout(resolve, pollInterval))
       } catch (err: unknown) {
         const msg = err instanceof Error ? err.message : String(err)
         log.debug.proxy(`replication poll error: ${msg}`)
@@ -549,8 +504,7 @@ export async function handleStartReplication(
 
   log.debug.proxy('replication: starting poll loop')
   await poll()
-  activeHandlerCount--
-  console.info(`[orez-repl#${handlerId}] poll loop exited (remaining handlers: ${activeHandlerCount})`)
+  log.debug.proxy('replication: poll loop exited')
 }
 
 async function streamChanges(

package/src/shim/hooks.mjs

@@ -20,6 +20,13 @@ export function load(url, context, nextLoad) {
       format: 'module',
       shortCircuit: true,
       source: `
+// catch uncaught exceptions from bedrock-sqlite wasm clearly
+process.on('uncaughtException', (err) => {
+  console.error('[orez-shim] UNCAUGHT EXCEPTION:', err?.message || err);
+  console.error('[orez-shim] code:', err?.code, 'name:', err?.name);
+  console.error('[orez-shim] stack:', err?.stack?.split('\\n').slice(0, 5).join('\\n'));
+  process.exit(1);
+});
 import { createRequire } from 'node:module';
 const require = createRequire('${BEDROCK_PATH}');
 const mod = require('${BEDROCK_PATH}');
@@ -27,13 +34,39 @@ const OrigDatabase = mod.Database;
 const SqliteError = mod.SqliteError;
 function Database(...args) {
   const db = new OrigDatabase(...args);
-  try { db.pragma('busy_timeout = 30000'); db.pragma('synchronous = normal'); } catch(e) {}
+  try { db.pragma('journal_mode = delete'); db.pragma('busy_timeout = 30000'); db.pragma('synchronous = normal'); } catch(e) {}
   return db;
 }
 Database.prototype = OrigDatabase.prototype;
 Database.prototype.constructor = Database;
 Object.keys(OrigDatabase).forEach(k => { Database[k] = OrigDatabase[k]; });
 Database.prototype.unsafeMode = function() { return this; };
+// wrap pragma to skip optimize (corrupts wasm vfs) and swallow sqlite errors
+const origPragma = OrigDatabase.prototype.pragma;
+Database.prototype.pragma = function(str, opts) {
+  if (str && str.trim().toLowerCase().startsWith('optimize')) return [];
+  try { return origPragma.call(this, str, opts); }
+  catch(e) { if (e && (e.code === 'SQLITE_CORRUPT' || e.code === 'SQLITE_IOERR')) return []; throw e; }
+};
+// wrap close to swallow wasm errors during shutdown
+const origClose = OrigDatabase.prototype.close;
+Database.prototype.close = function() {
+  try { return origClose.call(this); }
+  catch(e) { console.error('[orez-shim] close error (swallowed):', e?.message || e); }
+};
+// trace writes to _zero.changeLog and _zero.replicationState to debug view-syncer
+const origRun = OrigDatabase.prototype.run;
+Database.prototype.run = function(sql, ...args) {
+  if (typeof sql === 'string') {
+    if (sql.includes('_zero.changeLog')) {
+      console.info('[orez-shim] changeLog write:', sql.slice(0, 120), args.length ? JSON.stringify(args[0]).slice(0, 80) : '');
+    }
+    if (sql.includes('_zero.replicationState') && (sql.includes('UPDATE') || sql.includes('INSERT'))) {
+      console.info('[orez-shim] replicationState update:', sql.slice(0, 120), args.length ? JSON.stringify(args[0]).slice(0, 80) : '');
+    }
+  }
+  return origRun.call(this, sql, ...args);
+};
 if (!Database.prototype.defaultSafeIntegers) Database.prototype.defaultSafeIntegers = function() { return this; };
 if (!Database.prototype.serialize) Database.prototype.serialize = function() { throw new Error('not supported in wasm'); };
 if (!Database.prototype.backup) Database.prototype.backup = function() { throw new Error('not supported in wasm'); };

package/src/vite-plugin.ts

@@ -7,21 +7,16 @@ import type { Plugin } from 'vite'
 export interface OrezPluginOptions extends Partial<ZeroLiteConfig> {
   s3?: boolean
   s3Port?: number
-  admin?: boolean
-  adminPort?: number
-  adminLogs?: boolean
 }
 
 export default function orez(options?: OrezPluginOptions): Plugin {
   let stop: (() => Promise<void>) | null = null
   let s3Server: Server | null = null
-  let adminServer: Server | null = null
 
   return {
     name: 'orez',
 
     async configureServer(server) {
-      const startTime = Date.now()
       const result = await startZeroLite(options)
       stop = result.stop
 
@@ -33,30 +28,7 @@ export default function orez(options?: OrezPluginOptions): Plugin {
         })
       }
 
-      if (options?.admin && result.logStore) {
-        const { findPort } = await import('./port.js')
-        const { log } = await import('./log.js')
-        const adminPort = options.adminPort || (result.config.zeroPort + 2)
-        const resolvedPort = await findPort(adminPort)
-        const { startAdminServer } = await import('./admin/server.js')
-        adminServer = await startAdminServer({
-          port: resolvedPort,
-          logStore: result.logStore,
-          config: result.config,
-          zeroEnv: result.zeroEnv,
-          actions: result.actions,
-          startTime,
-          httpLog: result.httpLogStore || undefined,
-        })
-        log.orez(`admin: http://127.0.0.1:${resolvedPort}`)
-        if (result.config.adminLogs) {
-          const { resolve } = await import('node:path')
-          log.orez(`logs: ${resolve(result.config.dataDir, 'logs', 'orez.log')}`)
-        }
-      }
-
       server.httpServer?.on('close', async () => {
-        adminServer?.close()
         s3Server?.close()
         if (stop) {
           await stop()

package/src/wasm-sqlite.test.ts

@@ -19,8 +19,7 @@ import { resolve } from 'node:path'
 
 // import bedrock-sqlite directly (our wasm build)
 // @ts-expect-error - CJS module
-import bedrockSqlite from 'bedrock-sqlite'
-const { Database } = bedrockSqlite
+import { Database } from 'bedrock-sqlite'
 import { describe, test, expect, beforeEach, afterEach } from 'vitest'
 
 // helper: temp db file