orez 0.1.4 → 0.1.6

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;AAID,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,17 @@
+/**
+ * sqlite mode types and constants
+ */
+// journal mode - zero-cache requires wal2 for replica sync (BEGIN CONCURRENT)
+// both modes use wal2 now - bedrock-sqlite wasm should support it
+export const JOURNAL_MODE = {
+    native: 'wal2',
+    wasm: 'wal2',
+};
+// 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,8EAA8E;AAC9E,kEAAkE;AAClE,MAAM,CAAC,MAAM,YAAY,GAA+B;IACtD,MAAM,EAAE,MAAM;IACd,IAAI,EAAE,MAAM;CACb,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.4",
+  "version": "0.1.6",
   "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.4",
+    "bedrock-sqlite": "0.1.NaN",
     "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,12 @@ 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 {
+  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 +70,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 +106,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 +183,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 +203,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 +239,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 +341,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
 
@@ -435,38 +459,30 @@ async function seedIfNeeded(db: PGlite, config: ZeroLiteConfig): Promise<void> {
   log.orez('seeded')
 }
 
-// overwrite @rocicorp/zero-sqlite3 with a shim that uses bedrock-sqlite (wasm).
-// NODE_PATH doesn't work because local node_modules is searched first, so we
-// have to overwrite the actual package in place.
-function writeSqliteShim(): void {
-  const zeroSqlitePath = resolvePackage('@rocicorp/zero-sqlite3')
-  if (!zeroSqlitePath) {
-    log.debug.orez('warning: @rocicorp/zero-sqlite3 not found, skipping shim')
-    return
-  }
-
-  // find the package root (contains package.json)
-  let dir = zeroSqlitePath
-  while (dir && !existsSync(resolve(dir, 'package.json'))) {
-    const parent = resolve(dir, '..')
-    if (parent === dir) break
-    dir = parent
-  }
-
-  const bedrockEntry = resolvePackage('bedrock-sqlite')
-  if (!bedrockEntry) {
-    log.debug.orez('warning: bedrock-sqlite not found, skipping shim')
-    return
-  }
-
-  const shimCode = `'use strict';
-var mod = require('${bedrockEntry}');
+// write shim to tmpdir and return node_modules path for NODE_PATH
+// this approach doesn't modify node_modules - just shadows it via NODE_PATH
+function writeTmpShim(bedrockPath: string): 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 })
+
+  writeFileSync(
+    resolve(dir, 'package.json'),
+    '{"name":"@rocicorp/zero-sqlite3","main":"./index.js"}\n'
+  )
+
+  // use wal2 journal mode - required by zero-cache for replica sync
+  writeFileSync(
+    resolve(dir, 'index.js'),
+    `'use strict';
+// orez wasm shim - shadows @rocicorp/zero-sqlite3 via NODE_PATH
+var mod = require('${bedrockPath}');
 var OrigDatabase = mod.Database;
 var SqliteError = mod.SqliteError;
 function Database() {
   var db = new OrigDatabase(...arguments);
   try {
-    db.pragma('journal_mode = delete');
+    db.pragma('journal_mode = wal2');
     db.pragma('busy_timeout = 30000');
     db.pragma('synchronous = normal');
   } catch(e) {}
@@ -499,23 +515,16 @@ Database.SQLITE_SCANSTAT_COMPLEX = 8;
 module.exports = Database;
 module.exports.SqliteError = SqliteError;
 `
+  )
 
-  // overwrite the package's index.js and lib/index.js
-  const indexPath = resolve(dir, 'lib', 'index.js')
-  if (existsSync(indexPath)) {
-    writeFileSync(indexPath, shimCode)
-    log.debug.orez(`shimmed @rocicorp/zero-sqlite3 at ${indexPath}`)
-  } else {
-    // fallback: try root index.js
-    const rootIndex = resolve(dir, 'index.js')
-    writeFileSync(rootIndex, shimCode)
-    log.debug.orez(`shimmed @rocicorp/zero-sqlite3 at ${rootIndex}`)
-  }
+  return resolve(tmp, 'orez-sqlite', 'node_modules')
 }
 
 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')
@@ -524,7 +533,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')
   }
 
@@ -565,14 +574,21 @@ async function startZeroCache(
     throw new Error('zero-cache cli.js not found. install @rocicorp/zero')
   }
 
-  // wasm sqlite: overwrite @rocicorp/zero-sqlite3 with our bedrock-sqlite shim
-  if (!config.disableWasmSqlite) {
-    writeSqliteShim()
+  // wasm mode: write shim to tmpdir and use NODE_PATH to shadow the real package
+  // this is non-destructive - doesn't modify node_modules
+  if (sqliteMode === 'wasm' && sqliteModeConfig?.bedrockPath) {
+    const shimNodeModules = writeTmpShim(sqliteModeConfig.bedrockPath)
+    const existingNodePath = process.env.NODE_PATH || ''
+    env.NODE_PATH = existingNodePath
+      ? `${shimNodeModules}:${existingNodePath}`
+      : shimNodeModules
+    log.debug.orez(`using wasm sqlite shim via NODE_PATH: ${shimNodeModules}`)
   }
 
-  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