orez 0.1.3 → 0.1.5

package/dist/sqlite-mode/shim-template.js

@@ -0,0 +1,144 @@
+/**
+ * shim template generator - single source of truth for both cjs and esm shims.
+ * generates the shim code that wraps bedrock-sqlite to be compatible with
+ * @rocicorp/zero-sqlite3 (better-sqlite3 api).
+ */
+import { COMMON_PRAGMAS, JOURNAL_MODE } from './types.js';
+/**
+ * generate the core shim code (shared between cjs and esm)
+ * this is the constructor wrapper and api polyfills
+ */
+function generateShimCore(opts) {
+    const journalMode = JOURNAL_MODE[opts.mode];
+    const { busy_timeout, synchronous } = COMMON_PRAGMAS;
+    return `
+var OrigDatabase = mod.Database;
+var SqliteError = mod.SqliteError;
+
+function Database() {
+  var db = new OrigDatabase(...arguments);
+  try {
+    db.pragma('journal_mode = ${journalMode}');
+    db.pragma('busy_timeout = ${busy_timeout}');
+    db.pragma('synchronous = ${synchronous}');
+  } catch(e) {}
+  return db;
+}
+
+Database.prototype = OrigDatabase.prototype;
+Database.prototype.constructor = Database;
+Object.keys(OrigDatabase).forEach(function(k) { Database[k] = OrigDatabase[k]; });
+
+// api polyfills for better-sqlite3 compatibility
+Database.prototype.unsafeMode = function() { return this; };
+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'); };
+}
+
+// wrap pragma to skip optimize (can corrupt wasm vfs) and swallow sqlite errors
+var 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
+var 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); }
+};
+
+// statement prototype polyfills
+var tmpDb = new OrigDatabase(':memory:');
+var tmpStmt = tmpDb.prepare('SELECT 1');
+var SP = Object.getPrototypeOf(tmpStmt);
+if (!SP.safeIntegers) SP.safeIntegers = function() { return this; };
+SP.scanStatus = function() { return undefined; };
+SP.scanStatusV2 = function() { return []; };
+SP.scanStatusReset = function() {};
+tmpDb.close();
+
+// scanstat constants for query planner compatibility
+Database.SQLITE_SCANSTAT_NLOOP = 0;
+Database.SQLITE_SCANSTAT_NVISIT = 1;
+Database.SQLITE_SCANSTAT_EST = 2;
+Database.SQLITE_SCANSTAT_NAME = 3;
+Database.SQLITE_SCANSTAT_EXPLAIN = 4;
+Database.SQLITE_SCANSTAT_SELECTID = 5;
+Database.SQLITE_SCANSTAT_PARENTID = 6;
+Database.SQLITE_SCANSTAT_NCYCLE = 7;
+Database.SQLITE_SCANSTAT_COMPLEX = 8;
+`.trim();
+}
+/**
+ * generate debug tracing code for run() method
+ */
+function generateTracing() {
+    return `
+// trace writes to _zero.changeLog and _zero.replicationState for debugging
+var origRun = OrigDatabase.prototype.run;
+Database.prototype.run = function(sql) {
+  var args = Array.prototype.slice.call(arguments, 1);
+  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.apply(this, arguments);
+};
+`.trim();
+}
+/**
+ * generate commonjs shim for in-place patching of @rocicorp/zero-sqlite3
+ */
+export function generateCjsShim(opts) {
+    const core = generateShimCore(opts);
+    const tracing = opts.includeTracing ? '\n' + generateTracing() : '';
+    return `'use strict';
+// orez sqlite shim - wraps bedrock-sqlite for zero-cache compatibility
+// mode: ${opts.mode}, journal_mode: ${JOURNAL_MODE[opts.mode]}
+var mod = require('${opts.bedrockPath}');
+${core}
+${tracing}
+module.exports = Database;
+module.exports.SqliteError = SqliteError;
+`;
+}
+/**
+ * generate esm shim for loader hooks
+ */
+export function generateEsmShim(opts) {
+    const core = generateShimCore(opts);
+    const tracing = opts.includeTracing ? '\n' + generateTracing() : '';
+    return `// orez sqlite shim - wraps bedrock-sqlite for zero-cache compatibility
+// mode: ${opts.mode}, journal_mode: ${JOURNAL_MODE[opts.mode]}
+
+// 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('${opts.bedrockPath}');
+var mod = require('${opts.bedrockPath}');
+${core}
+${tracing}
+export default Database;
+export { SqliteError };
+`;
+}
+//# sourceMappingURL=shim-template.js.map

package/dist/sqlite-mode/shim-template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shim-template.js","sourceRoot":"","sources":["../../src/sqlite-mode/shim-template.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAE,YAAY,EAAmB,MAAM,YAAY,CAAA;AAS1E;;;GAGG;AACH,SAAS,gBAAgB,CAAC,IAAiB;IACzC,MAAM,WAAW,GAAG,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAC3C,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,GAAG,cAAc,CAAA;IAEpD,OAAO;;;;;;;gCAOuB,WAAW;gCACX,YAAY;+BACb,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwDzC,CAAC,IAAI,EAAE,CAAA;AACR,CAAC;AAED;;GAEG;AACH,SAAS,eAAe;IACtB,OAAO;;;;;;;;;;;;;;;CAeR,CAAC,IAAI,EAAE,CAAA;AACR,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAAC,IAAiB;IAC/C,MAAM,IAAI,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAA;IACnC,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,GAAG,eAAe,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;IAEnE,OAAO;;WAEE,IAAI,CAAC,IAAI,mBAAmB,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC;qBACzC,IAAI,CAAC,WAAW;EACnC,IAAI;EACJ,OAAO;;;CAGR,CAAA;AACD,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAAC,IAAiB;IAC/C,MAAM,IAAI,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAA;IACnC,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,GAAG,eAAe,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;IAEnE,OAAO;WACE,IAAI,CAAC,IAAI,mBAAmB,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC;;;;;;;;;;;iCAW7B,IAAI,CAAC,WAAW;qBAC5B,IAAI,CAAC,WAAW;EACnC,IAAI;EACJ,OAAO;;;CAGR,CAAA;AACD,CAAC"}

package/dist/sqlite-mode/types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * sqlite mode types and constants
+ */
+export type SqliteMode = 'native' | 'wasm';
+export interface SqliteModeConfig {
+    mode: SqliteMode;
+    bedrockPath?: string;
+    zeroSqlitePath?: string;
+}
+export declare const JOURNAL_MODE: Record<SqliteMode, string>;
+export declare const COMMON_PRAGMAS: {
+    busy_timeout: string;
+    synchronous: string;
+};
+export declare const BACKUP_MARKER = ".orez-backup";
+//# sourceMappingURL=types.d.ts.map

package/dist/sqlite-mode/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/sqlite-mode/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,MAAM,CAAA;AAE1C,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,UAAU,CAAA;IAEhB,WAAW,CAAC,EAAE,MAAM,CAAA;IAEpB,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAKD,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAGnD,CAAA;AAGD,eAAO,MAAM,cAAc;;;CAG1B,CAAA;AAGD,eAAO,MAAM,aAAa,iBAAiB,CAAA"}

package/dist/sqlite-mode/types.js

@@ -0,0 +1,18 @@
+/**
+ * sqlite mode types and constants
+ */
+// journal mode differs between native and wasm
+// - native: wal2 for better concurrency
+// - wasm: delete for compatibility (wal2 corrupts wasm vfs on certain operations)
+export const JOURNAL_MODE = {
+    native: 'wal2',
+    wasm: 'delete',
+};
+// common pragmas shared by both modes
+export const COMMON_PRAGMAS = {
+    busy_timeout: '30000',
+    synchronous: 'normal',
+};
+// backup file marker for identifying orez-shimmed packages
+export const BACKUP_MARKER = '.orez-backup';
+//# sourceMappingURL=types.js.map

package/dist/sqlite-mode/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/sqlite-mode/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAYH,+CAA+C;AAC/C,wCAAwC;AACxC,kFAAkF;AAClF,MAAM,CAAC,MAAM,YAAY,GAA+B;IACtD,MAAM,EAAE,MAAM;IACd,IAAI,EAAE,QAAQ;CACf,CAAA;AAED,sCAAsC;AACtC,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,YAAY,EAAE,OAAO;IACrB,WAAW,EAAE,QAAQ;CACtB,CAAA;AAED,2DAA2D;AAC3D,MAAM,CAAC,MAAM,aAAa,GAAG,cAAc,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orez",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "PGlite-powered zero-sync development backend. No Docker required.",
   "type": "module",
   "license": "MIT",
@@ -49,7 +49,7 @@
     "@electric-sql/pglite": "^0.3.15",
     "@electric-sql/pglite-tools": "^0.2.20",
     "@rocicorp/zero": ">=0.1.0",
-    "bedrock-sqlite": "0.1.3",
+    "bedrock-sqlite": "0.1.5",
     "citty": "^0.2.0",
     "pg-gateway": "0.3.0-beta.4",
     "pgsql-parser": "^17.9.11",
@@ -64,6 +64,7 @@
     }
   },
   "devDependencies": {
+    "@rocicorp/zero-sqlite3": "^1.0.15",
     "@types/node": "^22.0.0",
     "@types/ws": "^8.18.1",
     "oxfmt": "latest",

package/src/admin/server.ts

@@ -93,6 +93,7 @@ export function startAdminServer(opts: AdminServerOpts): Promise<Server> {
           uptime: Math.floor((Date.now() - startTime) / 1000),
           logLevel: config.logLevel,
           skipZeroCache: config.skipZeroCache,
+          sqliteMode: config.disableWasmSqlite ? 'native' : 'wasm',
         })
         return
       }

package/src/admin/ui.ts

@@ -341,6 +341,7 @@ export function getAdminHtml(): string {
     '    <div class="spacer"></div>\n' +
     '    <span class="badge"><span class="dot"></span> pg <span id="pg-port">-</span></span>\n' +
     '    <span class="badge"><span class="dot"></span> zero <span id="zero-port">-</span></span>\n' +
+    '    <span class="badge" id="sqlite-badge">sqlite: --</span>\n' +
     '    <span class="badge" id="uptime-badge">&#9201; --</span>\n' +
     '  </div>\n' +
     '\n' +
@@ -458,6 +459,16 @@ export function getAdminHtml(): string {
     '    logView.style.display = "block";\n' +
     '    toolbar.style.display = "flex";\n' +
     '    activeSource = source;\n' +
+    '    // default zero tab to info level (too verbose otherwise)\n' +
+    '    var levelSelect = document.getElementById("level-filter");\n' +
+    '    if (source === "zero") {\n' +
+    '      activeLevel = "info";\n' +
+    '      levelSelect.value = "info";\n' +
+    '    } else if (activeLevel === "info" && levelSelect.value === "info") {\n' +
+    '      // reset to all levels when leaving zero tab if still on info\n' +
+    '      activeLevel = "";\n' +
+    '      levelSelect.value = "";\n' +
+    '    }\n' +
     '    lastCursor = 0;\n' +
     '    logView.innerHTML = "";\n' +
     '    fetchLogs();\n' +
@@ -624,6 +635,7 @@ export function getAdminHtml(): string {
     '  fetch("/api/status").then(function(res) { return res.json(); }).then(function(data) {\n' +
     '    document.getElementById("pg-port").textContent = ":" + data.pgPort;\n' +
     '    document.getElementById("zero-port").textContent = ":" + data.zeroPort;\n' +
+    '    document.getElementById("sqlite-badge").textContent = "sqlite: " + (data.sqliteMode || "wasm");\n' +
     '    var m = Math.floor(data.uptime / 60);\n' +
     '    var s = data.uptime % 60;\n' +
     '    document.getElementById("uptime-badge").textContent = "\\u23F1 " + (m > 0 ? m + "m " : "") + s + "s";\n' +

package/src/cli.ts

@@ -895,9 +895,9 @@ const main = defineCommand({
       description: 'command to run once all services are healthy',
       default: '',
     },
-    admin: {
+    'disable-admin': {
       type: 'boolean',
-      description: 'start admin dashboard',
+      description: 'disable admin dashboard',
       default: false,
     },
     'admin-port': {
@@ -912,7 +912,7 @@ const main = defineCommand({
     pg_restore: pgRestoreCommand,
   },
   async run({ args }) {
-    const adminPort = args.admin ? Number(args['admin-port']) : 0
+    const adminPort = args['disable-admin'] ? 0 : Number(args['admin-port'])
     const {
       config,
       stop,
@@ -948,7 +948,7 @@ const main = defineCommand({
     }
 
     let adminServer: import('node:http').Server | null = null
-    if (args.admin && logStore && zeroEnv) {
+    if (!args['disable-admin'] && logStore && zeroEnv) {
       const { startAdminServer } = await import('./admin/server.js')
       adminServer = await startAdminServer({
         port: config.adminPort,
@@ -963,7 +963,7 @@ const main = defineCommand({
     }
 
     log.pg(
-      `postgresql://${config.pgUser}:${config.pgPassword}@127.0.0.1:${config.pgPort}/postgres`
+      `ready ${url(`postgresql://${config.pgUser}:${config.pgPassword}@127.0.0.1:${config.pgPort}/postgres`)}`
     )
 
     let stopping = false

package/src/index.ts

@@ -8,7 +8,6 @@
 
 import { spawn, type ChildProcess } from 'node:child_process'
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs'
-import { createRequire } from 'node:module'
 import { resolve } from 'node:path'
 
 import {
@@ -23,6 +22,14 @@ import { startPgProxy } from './pg-proxy.js'
 import { createPGliteInstances, runMigrations } from './pglite-manager.js'
 import { findPort } from './port.js'
 import { installChangeTracking } from './replication/change-tracker.js'
+import {
+  applySqliteMode,
+  cleanupShim,
+  resolveSqliteMode,
+  resolveSqliteModeConfig,
+  type SqliteMode,
+  type SqliteModeConfig,
+} from './sqlite-mode/index.js'
 
 import type { ZeroLiteConfig } from './config.js'
 import type { PGlite } from '@electric-sql/pglite'
@@ -65,18 +72,8 @@ async function runHook(
   })
 }
 
-// resolve a package entry — import.meta.resolve doesn't work in vitest
-function resolvePackage(pkg: string): string {
-  try {
-    const resolved = import.meta.resolve(pkg)
-    if (resolved) return resolved.replace('file://', '')
-  } catch {}
-  try {
-    const require = createRequire(import.meta.url)
-    return require.resolve(pkg)
-  } catch {}
-  return ''
-}
+// resolvePackage moved to sqlite-mode/resolve-mode.ts
+import { resolvePackage } from './sqlite-mode/resolve-mode.js'
 
 export async function startZeroLite(overrides: Partial<ZeroLiteConfig> = {}) {
   const config = getConfig(overrides)
@@ -111,6 +108,20 @@ export async function startZeroLite(overrides: Partial<ZeroLiteConfig> = {}) {
 
   log.debug.orez(`data dir: ${resolve(config.dataDir)}`)
 
+  // resolve sqlite mode config early (used for shim application and cleanup)
+  // requested wasm can fall back to native if required packages are missing.
+  let sqliteMode = resolveSqliteMode(config.disableWasmSqlite)
+  let sqliteModeConfig = resolveSqliteModeConfig(config.disableWasmSqlite)
+  if (sqliteMode === 'wasm' && !sqliteModeConfig) {
+    log.orez(
+      'warning: wasm sqlite requested but dependencies are missing, falling back to native sqlite'
+    )
+    sqliteMode = 'native'
+    config.disableWasmSqlite = true
+    sqliteModeConfig = resolveSqliteModeConfig(true)
+  }
+  log.orez(`sqlite: ${sqliteMode}`)
+
   mkdirSync(config.dataDir, { recursive: true })
 
   // write pid file for IPC (pg_restore uses this to signal restart)
@@ -174,7 +185,12 @@ export async function startZeroLite(overrides: Partial<ZeroLiteConfig> = {}) {
   if (!config.skipZeroCache) {
     // use internal port when http proxy is enabled
     const zeroConfig = httpLog ? { ...config, zeroPort: zeroInternalPort } : config
-    const result = await startZeroCache(zeroConfig, logStore)
+    const result = await startZeroCache(
+      zeroConfig,
+      logStore,
+      sqliteMode,
+      sqliteModeConfig
+    )
     zeroCacheProcess = result.process
     zeroEnv = result.env
     await waitForZeroCache(zeroConfig)
@@ -189,7 +205,7 @@ export async function startZeroLite(overrides: Partial<ZeroLiteConfig> = {}) {
       log.debug.orez(`http proxy listening on ${config.zeroPort}`)
     }
 
-    log.zero(`ready ${port(config.zeroPort, 'magenta')}`)
+    log.zero(`ready ${port(config.zeroPort, 'magenta')} (sqlite: ${sqliteMode})`)
   } else {
     log.orez('skip zero-cache')
   }
@@ -225,7 +241,12 @@ export async function startZeroLite(overrides: Partial<ZeroLiteConfig> = {}) {
     await killZeroCache()
     // use internal port when http proxy is enabled
     const zeroConfig = httpLog ? { ...config, zeroPort: zeroInternalPort } : config
-    const result = await startZeroCache(zeroConfig, logStore)
+    const result = await startZeroCache(
+      zeroConfig,
+      logStore,
+      sqliteMode,
+      sqliteModeConfig
+    )
     zeroCacheProcess = result.process
     zeroEnv = result.env
     await waitForZeroCache(zeroConfig)
@@ -322,7 +343,12 @@ export async function startZeroLite(overrides: Partial<ZeroLiteConfig> = {}) {
       log.orez('starting zero-cache...')
       // use internal port when http proxy is enabled
       const zeroConfig = httpLog ? { ...config, zeroPort: zeroInternalPort } : config
-      const result = await startZeroCache(zeroConfig, logStore)
+      const result = await startZeroCache(
+        zeroConfig,
+        logStore,
+        sqliteMode,
+        sqliteModeConfig
+      )
       zeroCacheProcess = result.process
       zeroEnv = result.env
 
@@ -364,6 +390,9 @@ export async function startZeroLite(overrides: Partial<ZeroLiteConfig> = {}) {
     try {
       unlinkSync(pidFile)
     } catch {}
+    // restore original @rocicorp/zero-sqlite3 if we shimmed it
+    // (next start will re-apply shim if needed for wasm mode)
+    cleanupShim(sqliteModeConfig?.zeroSqlitePath)
     log.debug.orez('stopped')
   }
 
@@ -435,73 +464,13 @@ async function seedIfNeeded(db: PGlite, config: ZeroLiteConfig): Promise<void> {
   log.orez('seeded')
 }
 
-// create a fake @rocicorp/zero-sqlite3 package in tmpdir that redirects to
-// bedrock-sqlite (wasm). uses NODE_PATH to make node resolve our shim first —
-// no require hooks, no Module._resolveFilename monkey-patching, no .cjs files
-// in the package (which all break vite).
-function writeSqliteShim(): string {
-  const tmp = process.env.TMPDIR || process.env.TEMP || '/tmp'
-  const dir = resolve(tmp, 'orez-sqlite', 'node_modules', '@rocicorp', 'zero-sqlite3')
-  mkdirSync(dir, { recursive: true })
-
-  const bedrockEntry = resolvePackage('bedrock-sqlite')
-
-  writeFileSync(
-    resolve(dir, 'package.json'),
-    '{"name":"@rocicorp/zero-sqlite3","main":"./index.js"}\n'
-  )
-
-  writeFileSync(
-    resolve(dir, 'index.js'),
-    `'use strict';
-var mod = require('${bedrockEntry}');
-var OrigDatabase = mod.Database;
-var SqliteError = mod.SqliteError;
-function Database() {
-  var db = new OrigDatabase(...arguments);
-  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(function(k) { Database[k] = OrigDatabase[k]; });
-Database.prototype.unsafeMode = function() { return this; };
-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'); };
-var tmpDb = new OrigDatabase(':memory:');
-var tmpStmt = tmpDb.prepare('SELECT 1');
-var SP = Object.getPrototypeOf(tmpStmt);
-if (!SP.safeIntegers) SP.safeIntegers = function() { return this; };
-SP.scanStatus = function() { return undefined; };
-SP.scanStatusV2 = function() { return []; };
-SP.scanStatusReset = function() {};
-tmpDb.close();
-Database.SQLITE_SCANSTAT_NLOOP = 0;
-Database.SQLITE_SCANSTAT_NVISIT = 1;
-Database.SQLITE_SCANSTAT_EST = 2;
-Database.SQLITE_SCANSTAT_NAME = 3;
-Database.SQLITE_SCANSTAT_EXPLAIN = 4;
-Database.SQLITE_SCANSTAT_SELECTID = 5;
-Database.SQLITE_SCANSTAT_PARENTID = 6;
-Database.SQLITE_SCANSTAT_NCYCLE = 7;
-Database.SQLITE_SCANSTAT_COMPLEX = 8;
-module.exports = Database;
-module.exports.SqliteError = SqliteError;
-`
-  )
-
-  // return the node_modules root so it can be prepended to NODE_PATH
-  return resolve(tmp, 'orez-sqlite', 'node_modules')
-}
+// writeSqliteShim replaced by sqlite-mode/apply-mode.ts applySqliteMode()
 
 async function startZeroCache(
   config: ZeroLiteConfig,
-  logStore?: LogStore
+  logStore?: LogStore,
+  sqliteMode: SqliteMode = resolveSqliteMode(config.disableWasmSqlite),
+  sqliteModeConfig?: SqliteModeConfig | null
 ): Promise<{ process: ChildProcess; env: Record<string, string> }> {
   // resolve @rocicorp/zero entry for finding zero-cache modules
   const zeroEntry = resolvePackage('@rocicorp/zero')
@@ -510,7 +479,7 @@ async function startZeroCache(
     throw new Error('zero-cache not found. install @rocicorp/zero')
   }
 
-  if (config.disableWasmSqlite) {
+  if (sqliteMode === 'native') {
     log.debug.orez('wasm sqlite disabled, using native @rocicorp/zero-sqlite3')
   }
 
@@ -551,20 +520,25 @@ async function startZeroCache(
     throw new Error('zero-cache cli.js not found. install @rocicorp/zero')
   }
 
-  // wasm sqlite: create a fake @rocicorp/zero-sqlite3 in tmpdir and prepend
-  // to NODE_PATH so node resolves our shim first. no require hooks, no
-  // Module._resolveFilename monkey-patching (which conflicts with vite).
-  if (!config.disableWasmSqlite) {
-    const shimNodeModules = writeSqliteShim()
-    const existingNodePath = process.env.NODE_PATH || ''
-    env.NODE_PATH = existingNodePath
-      ? `${shimNodeModules}:${existingNodePath}`
-      : shimNodeModules
+  // apply sqlite mode - either wasm shim or restore to native
+  if (sqliteModeConfig) {
+    const result = applySqliteMode(sqliteModeConfig)
+    if (!result.success) {
+      // native mode failure is fatal - user explicitly requested native but we can't provide it
+      if (sqliteMode === 'native') {
+        throw new Error(`cannot use native sqlite: ${result.error}`)
+      }
+      // wasm mode failure is also fatal now - can't safely proceed without backup
+      throw new Error(`cannot apply sqlite mode: ${result.error}`)
+    } else if (result.shimPath) {
+      log.debug.orez(`shimmed @rocicorp/zero-sqlite3 at ${result.shimPath}`)
+    }
   }
 
-  const nodeOptions = !config.disableWasmSqlite
-    ? `--max-old-space-size=16384 ${process.env.NODE_OPTIONS || ''}`
-    : process.env.NODE_OPTIONS || ''
+  const nodeOptions =
+    sqliteMode === 'wasm'
+      ? `--max-old-space-size=16384 ${process.env.NODE_OPTIONS || ''}`
+      : process.env.NODE_OPTIONS || ''
   if (nodeOptions.trim()) env.NODE_OPTIONS = nodeOptions.trim()
 
   const child = spawn(zeroCacheBin, [], {

package/src/log.ts

@@ -41,9 +41,9 @@ export function port(n: number, color: keyof typeof COLORS): string {
   return `${DIM}${COLORS[color]}:${n}${RESET}`
 }
 
-/** format a url with yellow color */
+/** format a url with green color */
 export function url(u: string): string {
-  return `${COLORS.yellow}${u}${RESET}`
+  return `${COLORS.green}${u}${RESET}`
 }
 
 // map logger labels to logStore source names