add hints to implementation instructions

.cursor/rules/absurd-sql.mdc

@@ -1,153 +0,0 @@
----
-description: 
-globs: 
-alwaysApply: true
----
-# Absurd SQL - Cursor Development Guide
-
-## Project Overview
-Absurd SQL is a backend implementation for sql.js that enables persistent SQLite databases in the browser by using IndexedDB as a block storage system. This guide provides rules and best practices for developing with this project in Cursor.
-
-## Project Structure
-```
-absurd-sql/
-├── src/               # Source code
-├── dist/             # Built files
-├── package.json      # Dependencies and scripts
-├── rollup.config.js  # Build configuration
-└── jest.config.js    # Test configuration
-```
-
-## Development Rules
-
-### 1. Worker Thread Requirements
-- All SQL operations MUST be performed in a worker thread
-- Main thread should only handle worker initialization and communication
-- Never block the main thread with database operations
-
-### 2. Code Organization
-- Keep worker code in separate files (e.g., `*.worker.js`)
-- Use ES modules for imports/exports
-- Follow the project's existing module structure
-
-### 3. Required Headers
-When developing locally or deploying, ensure these headers are set:
-```
-Cross-Origin-Opener-Policy: same-origin
-Cross-Origin-Embedder-Policy: require-corp
-```
-
-### 4. Browser Compatibility
-- Primary target: Modern browsers with SharedArrayBuffer support
-- Fallback mode: Safari (with limitations)
-- Always test in both modes
-
-### 5. Database Configuration
-Recommended database settings:
-```sql
-PRAGMA journal_mode=MEMORY;
-PRAGMA page_size=8192;  -- Optional, but recommended
-```
-
-### 6. Development Workflow
-1. Install dependencies:
-   ```bash
-   yarn add @jlongster/sql.js absurd-sql
-   ```
-
-2. Development commands:
-   - `yarn build` - Build the project
-   - `yarn jest` - Run tests
-   - `yarn serve` - Start development server
-
-### 7. Testing Guidelines
-- Write tests for both SharedArrayBuffer and fallback modes
-- Use Jest for testing
-- Include performance benchmarks for critical operations
-
-### 8. Performance Considerations
-- Use bulk operations when possible
-- Monitor read/write performance
-- Consider using transactions for multiple operations
-- Avoid unnecessary database connections
-
-### 9. Error Handling
-- Implement proper error handling for:
-  - Worker initialization failures
-  - Database connection issues
-  - Concurrent access conflicts (in fallback mode)
-  - Storage quota exceeded scenarios
-
-### 10. Security Best Practices
-- Never expose database operations directly to the client
-- Validate all SQL queries
-- Implement proper access controls
-- Handle sensitive data appropriately
-
-### 11. Code Style
-- Follow ESLint configuration
-- Use async/await for asynchronous operations
-- Document complex database operations
-- Include comments for non-obvious optimizations
-
-### 12. Debugging
-- Use `jest-debug` for debugging tests
-- Monitor IndexedDB usage in browser dev tools
-- Check worker communication in console
-- Use performance monitoring tools
-
-## Common Patterns
-
-### Worker Initialization
-```javascript
-// Main thread
-import { initBackend } from 'absurd-sql/dist/indexeddb-main-thread';
-
-function init() {
-  let worker = new Worker(new URL('./index.worker.js', import.meta.url));
-  initBackend(worker);
-}
-```
-
-### Database Setup
-```javascript
-// Worker thread
-import initSqlJs from '@jlongster/sql.js';
-import { SQLiteFS } from 'absurd-sql';
-import IndexedDBBackend from 'absurd-sql/dist/indexeddb-backend';
-
-async function setupDatabase() {
-  let SQL = await initSqlJs({ locateFile: file => file });
-  let sqlFS = new SQLiteFS(SQL.FS, new IndexedDBBackend());
-  SQL.register_for_idb(sqlFS);
-  
-  SQL.FS.mkdir('/sql');
-  SQL.FS.mount(sqlFS, {}, '/sql');
-  
-  return new SQL.Database('/sql/db.sqlite', { filename: true });
-}
-```
-
-## Troubleshooting
-
-### Common Issues
-1. SharedArrayBuffer not available
-   - Check COOP/COEP headers
-   - Verify browser support
-   - Test fallback mode
-
-2. Worker initialization failures
-   - Check file paths
-   - Verify module imports
-   - Check browser console for errors
-
-3. Performance issues
-   - Monitor IndexedDB usage
-   - Check for unnecessary operations
-   - Verify transaction usage
-
-## Resources
-- [Project Demo](https://priceless-keller-d097e5.netlify.app/)
-- [Example Project](https://github.com/jlongster/absurd-example-project)
-- [Blog Post](https://jlongster.com/future-sql-web)
-- [SQL.js Documentation](https://github.com/sql-js/sql.js/) 

.cursor/rules/crowd-funder-for-time-pwa/docs/camera-implementation.mdc

@@ -1,7 +1,7 @@
 ---
 description: 
 globs: 
-alwaysApply: false
+alwaysApply: true
 ---
 # Camera Implementation Documentation
 

.env.development

@@ -9,5 +9,4 @@ VITE_DEFAULT_ENDORSER_API_SERVER=http://localhost:3000
 # Using shared server by default to ease setup, which works for shared test users.
 VITE_DEFAULT_IMAGE_API_SERVER=https://test-image-api.timesafari.app
 VITE_DEFAULT_PARTNER_API_SERVER=http://localhost:3000
-#VITE_DEFAULT_PUSH_SERVER... can't be set up with localhost domain
 VITE_PASSKEYS_ENABLED=true

.env.example

@@ -0,0 +1,6 @@
+# Admin DID credentials
+ADMIN_DID=did:ethr:0x0000694B58C2cC69658993A90D3840C560f2F51F
+ADMIN_PRIVATE_KEY=2b6472c026ec2aa2c4235c994a63868fc9212d18b58f6cbfe861b52e71330f5b
+
+# API Configuration
+ENDORSER_API_URL=https://test-api.endorser.ch/api/v2/claim 

.env.production

@@ -9,4 +9,3 @@ VITE_DEFAULT_ENDORSER_API_SERVER=https://api.endorser.ch
 
 VITE_DEFAULT_IMAGE_API_SERVER=https://image-api.timesafari.app
 VITE_DEFAULT_PARTNER_API_SERVER=https://partner-api.endorser.ch
-VITE_DEFAULT_PUSH_SERVER=https://timesafari.app

.env.staging

@@ -9,5 +9,4 @@ VITE_DEFAULT_ENDORSER_API_SERVER=https://test-api.endorser.ch
 
 VITE_DEFAULT_IMAGE_API_SERVER=https://test-image-api.timesafari.app
 VITE_DEFAULT_PARTNER_API_SERVER=https://test-partner-api.endorser.ch
-VITE_DEFAULT_PUSH_SERVER=https://test.timesafari.app
 VITE_PASSKEYS_ENABLED=true

.eslintrc.js

@@ -4,12 +4,6 @@ module.exports = {
     node: true,
     es2022: true,
   },
-  ignorePatterns: [
-    'node_modules/',
-    'dist/',
-    'dist-electron/',
-    '*.d.ts'
-  ],
   extends: [
     "plugin:vue/vue3-recommended",
     "eslint:recommended",

BUILDING.md

@@ -84,7 +84,7 @@ Install dependencies:
 * For test, build the app (because test server is not yet set up to build):
 
 ```bash
-TIME_SAFARI_APP_TITLE="TimeSafari_Test" VITE_APP_SERVER=https://test.timesafari.app VITE_BVC_MEETUPS_PROJECT_CLAIM_ID=https://endorser.ch/entity/01HWE8FWHQ1YGP7GFZYYPS272F VITE_DEFAULT_ENDORSER_API_SERVER=https://test-api.endorser.ch VITE_DEFAULT_IMAGE_API_SERVER=https://test-image-api.timesafari.app VITE_DEFAULT_PARTNER_API_SERVER=https://test-partner-api.endorser.ch VITE_DEFAULT_PUSH_SERVER=https://test.timesafari.app VITE_PASSKEYS_ENABLED=true npm run build
+TIME_SAFARI_APP_TITLE="TimeSafari_Test" VITE_APP_SERVER=https://test.timesafari.app VITE_BVC_MEETUPS_PROJECT_CLAIM_ID=https://endorser.ch/entity/01HWE8FWHQ1YGP7GFZYYPS272F VITE_DEFAULT_ENDORSER_API_SERVER=https://test-api.endorser.ch VITE_DEFAULT_IMAGE_API_SERVER=https://test-image-api.timesafari.app VITE_DEFAULT_PARTNER_API_SERVER=https://test-partner-api.endorser.ch VITE_PASSKEYS_ENABLED=true npm run build
 ```
 
    ... and transfer to the test server:
@@ -241,9 +241,7 @@ docker run -d \
 1. Build the electron app in production mode:
 
    ```bash
-   npm run build:web
-   npm run build:electron
-   npm run electron:build-mac
+   npm run build:electron-prod
    ```
 
 2. Package the Electron app for macOS:

android/app/build.gradle

@@ -91,8 +91,6 @@ dependencies {
     implementation "androidx.coordinatorlayout:coordinatorlayout:$androidxCoordinatorLayoutVersion"
     implementation "androidx.core:core-splashscreen:$coreSplashScreenVersion"
     implementation project(':capacitor-android')
-    implementation project(':capacitor-community-sqlite')
-    implementation "androidx.biometric:biometric:1.2.0-alpha05"
     testImplementation "junit:junit:$junitVersion"
     androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
     androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"

android/app/capacitor.build.gradle

@@ -9,7 +9,6 @@ android {
 
 apply from: "../capacitor-cordova-android-plugins/cordova.variables.gradle"
 dependencies {
-    implementation project(':capacitor-community-sqlite')
     implementation project(':capacitor-mlkit-barcode-scanning')
     implementation project(':capacitor-app')
     implementation project(':capacitor-camera')

android/app/src/main/assets/capacitor.config.json

@@ -16,41 +16,6 @@
 					}
 				]
 			}
-		},
-		"SQLite": {
-			"iosDatabaseLocation": "Library/CapacitorDatabase",
-			"iosIsEncryption": true,
-			"iosBiometric": {
-				"biometricAuth": true,
-				"biometricTitle": "Biometric login for TimeSafari"
-			},
-			"androidIsEncryption": true,
-			"androidBiometric": {
-				"biometricAuth": true,
-				"biometricTitle": "Biometric login for TimeSafari"
-			}
 		}
-	},
-	"ios": {
-		"contentInset": "always",
-		"allowsLinkPreview": true,
-		"scrollEnabled": true,
-		"limitsNavigationsToAppBoundDomains": true,
-		"backgroundColor": "#ffffff",
-		"allowNavigation": [
-			"*.timesafari.app",
-			"*.jsdelivr.net",
-			"api.endorser.ch"
-		]
-	},
-	"android": {
-		"allowMixedContent": false,
-		"captureInput": true,
-		"webContentsDebuggingEnabled": false,
-		"allowNavigation": [
-			"*.timesafari.app",
-			"*.jsdelivr.net",
-			"api.endorser.ch"
-		]
 	}
 }

android/app/src/main/assets/capacitor.plugins.json

@@ -1,8 +1,4 @@
 [
-	{
-		"pkg": "@capacitor-community/sqlite",
-		"classpath": "com.getcapacitor.community.database.sqlite.CapacitorSQLitePlugin"
-	},
 	{
 		"pkg": "@capacitor-mlkit/barcode-scanning",
 		"classpath": "io.capawesome.capacitorjs.plugins.mlkit.barcodescanning.BarcodeScannerPlugin"

android/app/src/main/java/app/timesafari/MainActivity.java

@@ -1,15 +1,7 @@
 package app.timesafari;
 
-import android.os.Bundle;
 import com.getcapacitor.BridgeActivity;
-import com.getcapacitor.community.sqlite.SQLite;
 
 public class MainActivity extends BridgeActivity {
-    @Override
-    public void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        
-        // Initialize SQLite
-        registerPlugin(SQLite.class);
-    }
+    // ... existing code ...
 } 

android/capacitor.settings.gradle

@@ -2,9 +2,6 @@
 include ':capacitor-android'
 project(':capacitor-android').projectDir = new File('../node_modules/@capacitor/android/capacitor')
 
-include ':capacitor-community-sqlite'
-project(':capacitor-community-sqlite').projectDir = new File('../node_modules/@capacitor-community/sqlite/android')
-
 include ':capacitor-mlkit-barcode-scanning'
 project(':capacitor-mlkit-barcode-scanning').projectDir = new File('../node_modules/@capacitor-mlkit/barcode-scanning/android')
 

capacitor.config.json

@@ -1,11 +1,10 @@
 {
-	"appId": "com.timesafari.app",
+	"appId": "app.timesafari",
 	"appName": "TimeSafari",
 	"webDir": "dist",
 	"bundledWebRuntime": false,
 	"server": {
-		"cleartext": true,
-		"androidScheme": "https"
+		"cleartext": true
 	},
 	"plugins": {
 		"App": {
@@ -17,47 +16,6 @@
 					}
 				]
 			}
-		},
-		"SQLite": {
-			"iosDatabaseLocation": "Library/CapacitorDatabase",
-			"iosIsEncryption": true,
-			"iosBiometric": {
-				"biometricAuth": true,
-				"biometricTitle": "Biometric login for TimeSafari"
-			},
-			"androidIsEncryption": true,
-			"androidBiometric": {
-				"biometricAuth": true,
-				"biometricTitle": "Biometric login for TimeSafari"
-			}
-		},
-		"CapacitorSQLite": {
-			"electronIsEncryption": false,
-			"electronMacLocation": "~/Library/Application Support/TimeSafari",
-			"electronWindowsLocation": "C:\\ProgramData\\TimeSafari",
-			"electronLinuxLocation": "~/.local/share/TimeSafari"
 		}
-	},
-	"ios": {
-		"contentInset": "always",
-		"allowsLinkPreview": true,
-		"scrollEnabled": true,
-		"limitsNavigationsToAppBoundDomains": true,
-		"backgroundColor": "#ffffff",
-		"allowNavigation": [
-			"*.timesafari.app",
-			"*.jsdelivr.net",
-			"api.endorser.ch"
-		]
-	},
-	"android": {
-		"allowMixedContent": false,
-		"captureInput": true,
-		"webContentsDebuggingEnabled": false,
-		"allowNavigation": [
-			"*.timesafari.app",
-			"*.jsdelivr.net",
-			"api.endorser.ch"
-		]
 	}
 }

doc/electron-migration.md

@@ -1,270 +0,0 @@
-# Electron App Migration Strategy
-
-## Overview
-
-This document outlines the migration strategy for the TimeSafari Electron app, focusing on the transition from web-based storage to native SQLite implementation while maintaining cross-platform compatibility.
-
-## Current Architecture
-
-### 1. Platform Services
-- `ElectronPlatformService`: Implements platform-specific features for desktop
-- Uses `@capacitor-community/sqlite` for database operations
-- Maintains compatibility with web/mobile platforms through shared interfaces
-
-### 2. Database Implementation
-- SQLite with native Node.js backend
-- WAL journal mode for better concurrency
-- Connection pooling for performance
-- Migration system for schema updates
-- Secure file permissions (0o755)
-
-### 3. Build Process
-```bash
-# Development
-npm run dev:electron
-
-# Production Build
-npm run build:web
-npm run build:electron
-npm run electron:build-linux  # or electron:build-mac
-```
-
-## Migration Goals
-
-1. **Data Integrity**
-   - Preserve existing data during migration
-   - Maintain data relationships
-   - Ensure ACID compliance
-   - Implement proper backup/restore
-
-2. **Performance**
-   - Optimize SQLite configuration
-   - Implement connection pooling
-   - Use WAL journal mode
-   - Configure optimal PRAGMA settings
-
-3. **Security**
-   - Secure file permissions
-   - Proper IPC communication
-   - Context isolation
-   - Safe preload scripts
-
-4. **User Experience**
-   - Zero data loss
-   - Automatic migration
-   - Progress indicators
-   - Error recovery
-
-## Implementation Details
-
-### 1. Database Initialization
-```typescript
-// electron/src/rt/sqlite-init.ts
-export async function initializeSQLite() {
-  // Set up database path with proper permissions
-  const dbPath = path.join(app.getPath('userData'), 'timesafari.db');
-  
-  // Initialize SQLite plugin
-  const sqlite = new CapacitorSQLite();
-  
-  // Configure database
-  await sqlite.createConnection({
-    database: 'timesafari',
-    path: dbPath,
-    encrypted: false,
-    mode: 'no-encryption'
-  });
-  
-  // Set optimal PRAGMA settings
-  await sqlite.execute({
-    database: 'timesafari',
-    statements: [
-      'PRAGMA journal_mode = WAL;',
-      'PRAGMA synchronous = NORMAL;',
-      'PRAGMA foreign_keys = ON;'
-    ]
-  });
-}
-```
-
-### 2. Migration System
-```typescript
-// electron/src/rt/sqlite-migrations.ts
-interface Migration {
-  version: number;
-  name: string;
-  description: string;
-  sql: string;
-  rollback?: string;
-}
-
-async function runMigrations(plugin: any, database: string) {
-  // Track migration state
-  const state = await getMigrationState(plugin, database);
-  
-  // Execute migrations in transaction
-  for (const migration of pendingMigrations) {
-    await executeMigration(plugin, database, migration);
-  }
-}
-```
-
-### 3. Platform Service Implementation
-```typescript
-// src/services/platforms/ElectronPlatformService.ts
-export class ElectronPlatformService implements PlatformService {
-  private sqlite: any;
-  
-  async dbQuery(sql: string, params: any[]): Promise<QueryExecResult> {
-    return await this.sqlite.execute({
-      database: 'timesafari',
-      statements: [{ statement: sql, values: params }]
-    });
-  }
-}
-```
-
-### 4. Preload Script
-```typescript
-// electron/preload.ts
-contextBridge.exposeInMainWorld('electron', {
-  sqlite: {
-    isAvailable: () => ipcRenderer.invoke('sqlite:isAvailable'),
-    execute: (method: string, ...args: unknown[]) => 
-      ipcRenderer.invoke('sqlite:execute', method, ...args)
-  },
-  getPath: (pathType: string) => ipcRenderer.invoke('get-path', pathType),
-  env: {
-    platform: 'electron'
-  }
-});
-```
-
-## Build Configuration
-
-### 1. Vite Configuration
-```typescript
-// vite.config.app.electron.mts
-export default defineConfig({
-  build: {
-    outDir: 'dist',
-    emptyOutDir: true
-  },
-  define: {
-    'process.env.VITE_PLATFORM': JSON.stringify('electron'),
-    'process.env.VITE_PWA_ENABLED': JSON.stringify(false)
-  }
-});
-```
-
-### 2. Package Scripts
-```json
-{
-  "scripts": {
-    "dev:electron": "vite build --watch --config vite.config.app.electron.mts",
-    "build:electron": "vite build --config vite.config.app.electron.mts",
-    "electron:build-linux": "electron-builder --linux",
-    "electron:build-mac": "electron-builder --mac"
-  }
-}
-```
-
-## Testing Strategy
-
-1. **Unit Tests**
-   - Database operations
-   - Migration system
-   - Platform service methods
-   - IPC communication
-
-2. **Integration Tests**
-   - Full migration process
-   - Data integrity verification
-   - Cross-platform compatibility
-   - Error recovery
-
-3. **End-to-End Tests**
-   - User workflows
-   - Data persistence
-   - UI interactions
-   - Platform-specific features
-
-## Error Handling
-
-1. **Database Errors**
-   - Connection failures
-   - Migration errors
-   - Query execution errors
-   - Transaction failures
-
-2. **Platform Errors**
-   - File system errors
-   - IPC communication errors
-   - Permission issues
-   - Resource constraints
-
-3. **Recovery Mechanisms**
-   - Automatic retry logic
-   - Transaction rollback
-   - State verification
-   - User notifications
-
-## Security Considerations
-
-1. **File System**
-   - Secure file permissions
-   - Path validation
-   - Access control
-   - Data encryption
-
-2. **IPC Communication**
-   - Context isolation
-   - Channel validation
-   - Data sanitization
-   - Error handling
-
-3. **Preload Scripts**
-   - Minimal API exposure
-   - Type safety
-   - Input validation
-   - Error boundaries
-
-## Future Improvements
-
-1. **Performance**
-   - Query optimization
-   - Index tuning
-   - Connection management
-   - Cache implementation
-
-2. **Features**
-   - Offline support
-   - Sync capabilities
-   - Backup/restore
-   - Data export/import
-
-3. **Security**
-   - Database encryption
-   - Secure storage
-   - Access control
-   - Audit logging
-
-## Maintenance
-
-1. **Regular Tasks**
-   - Database optimization
-   - Log rotation
-   - Error monitoring
-   - Performance tracking
-
-2. **Updates**
-   - Dependency updates
-   - Security patches
-   - Feature additions
-   - Bug fixes
-
-3. **Documentation**
-   - API documentation
-   - Migration guides
-   - Troubleshooting
-   - Best practices 

doc/secure-storage-implementation.md

@@ -1,339 +0,0 @@
-# Secure Storage Implementation Guide for TimeSafari App
-
-## Overview
-
-This document outlines the implementation of secure storage for the TimeSafari app. The implementation focuses on:
-
-1. **Platform-Specific Storage Solutions**:
-   - Web: SQLite with IndexedDB backend (absurd-sql)
-   - Electron: SQLite with Node.js backend
-   - Native: (Planned) SQLCipher with platform-specific secure storage
-
-2. **Key Features**:
-   - SQLite-based storage using absurd-sql for web
-   - Platform-specific service factory pattern
-   - Consistent API across platforms
-   - Migration support from Dexie.js
-
-## Quick Start
-
-### 1. Installation
-
-```bash
-# Core dependencies
-npm install @jlongster/sql.js
-npm install absurd-sql
-
-# Platform-specific dependencies (for future native support)
-npm install @capacitor/preferences
-npm install @capacitor-community/biometric-auth
-```
-
-### 2. Basic Usage
-
-```typescript
-// Using the platform service
-import { PlatformServiceFactory } from '../services/PlatformServiceFactory';
-
-// Get platform-specific service instance
-const platformService = PlatformServiceFactory.getInstance();
-
-// Example database operations
-async function example() {
-  try {
-    // Query example
-    const result = await platformService.dbQuery(
-      "SELECT * FROM accounts WHERE did = ?",
-      [did]
-    );
-
-    // Execute example
-    await platformService.dbExec(
-      "INSERT INTO accounts (did, public_key_hex) VALUES (?, ?)",
-      [did, publicKeyHex]
-    );
-
-    } catch (error) {
-    console.error('Database operation failed:', error);
-  }
-}
-```
-
-### 3. Platform Detection
-
-```typescript
-// src/services/PlatformServiceFactory.ts
-export class PlatformServiceFactory {
-  static getInstance(): PlatformService {
-    if (process.env.ELECTRON) {
-      // Electron platform
-      return new ElectronPlatformService();
-    } else {
-      // Web platform (default)
-      return new AbsurdSqlDatabaseService();
-    }
-  }
-}
-```
-
-### 4. Current Implementation Details
-
-#### Web Platform (AbsurdSqlDatabaseService)
-
-The web platform uses absurd-sql with IndexedDB backend:
-
-```typescript
-// src/services/AbsurdSqlDatabaseService.ts
-export class AbsurdSqlDatabaseService implements PlatformService {
-  private static instance: AbsurdSqlDatabaseService | null = null;
-  private db: AbsurdSqlDatabase | null = null;
-  private initialized: boolean = false;
-      
-  // Singleton pattern
-  static getInstance(): AbsurdSqlDatabaseService {
-    if (!AbsurdSqlDatabaseService.instance) {
-      AbsurdSqlDatabaseService.instance = new AbsurdSqlDatabaseService();
-    }
-    return AbsurdSqlDatabaseService.instance;
-  }
-
-  // Database operations
-  async dbQuery(sql: string, params: unknown[] = []): Promise<QueryExecResult[]> {
-    await this.waitForInitialization();
-    return this.queueOperation<QueryExecResult[]>("query", sql, params);
-    }
-
-  async dbExec(sql: string, params: unknown[] = []): Promise<void> {
-    await this.waitForInitialization();
-    await this.queueOperation<void>("run", sql, params);
-  }
-}
-```
-
-Key features:
-- Uses absurd-sql for SQLite in the browser
-- Implements operation queuing for thread safety
-- Handles initialization and connection management
-- Provides consistent API across platforms
-
-### 5. Migration from Dexie.js
-
-The current implementation supports gradual migration from Dexie.js:
-
-```typescript
-// Example of dual-storage pattern
-async function getAccount(did: string): Promise<Account | undefined> {
-  // Try SQLite first
-  const platform = PlatformServiceFactory.getInstance();
-  let account = await platform.dbQuery(
-    "SELECT * FROM accounts WHERE did = ?",
-    [did]
-  );
-
-  // Fallback to Dexie if needed
-  if (USE_DEXIE_DB) {
-    account = await db.accounts.get(did);
-  }
-
-  return account;
-   }
-```
-
-#### A. Modifying Code
-
-When converting from Dexie.js to SQL-based implementation, follow these patterns:
-
-1. **Database Access Pattern**
-   ```typescript
-   // Before (Dexie)
-   const result = await db.table.where("field").equals(value).first();
-
-   // After (SQL)
-   const platform = PlatformServiceFactory.getInstance();
-   let result = await platform.dbQuery(
-     "SELECT * FROM table WHERE field = ?",
-     [value]
-   );
-   result = databaseUtil.mapQueryResultToValues(result);
-   
-   // Fallback to Dexie if needed
-   if (USE_DEXIE_DB) {
-     result = await db.table.where("field").equals(value).first();
-   }
-   ```
-
-2. **Update Operations**
-   ```typescript
-   // Before (Dexie)
-   await db.table.where("id").equals(id).modify(changes);
-
-   // After (SQL)
-   // For settings updates, use the utility methods:
-   await databaseUtil.updateDefaultSettings(changes);
-   // OR
-   await databaseUtil.updateAccountSettings(did, changes);
-
-   // For other tables, use direct SQL:
-   const platform = PlatformServiceFactory.getInstance();
-   await platform.dbExec(
-     "UPDATE table SET field1 = ?, field2 = ? WHERE id = ?",
-     [changes.field1, changes.field2, id]
-   );
-
-   // Fallback to Dexie if needed
-   if (USE_DEXIE_DB) {
-     await db.table.where("id").equals(id).modify(changes);
-   }
-   ```
-
-3. **Insert Operations**
-   ```typescript
-   // Before (Dexie)
-   await db.table.add(item);
-
-   // After (SQL)
-   const platform = PlatformServiceFactory.getInstance();
-   const columns = Object.keys(item);
-   const values = Object.values(item);
-   const placeholders = values.map(() => '?').join(', ');
-   const sql = `INSERT INTO table (${columns.join(', ')}) VALUES (${placeholders})`;
-   await platform.dbExec(sql, values);
-
-   // Fallback to Dexie if needed
-   if (USE_DEXIE_DB) {
-     await db.table.add(item);
-   }
-   ```
-
-4. **Delete Operations**
-   ```typescript
-   // Before (Dexie)
-   await db.table.where("id").equals(id).delete();
-
-   // After (SQL)
-   const platform = PlatformServiceFactory.getInstance();
-   await platform.dbExec("DELETE FROM table WHERE id = ?", [id]);
-
-   // Fallback to Dexie if needed
-   if (USE_DEXIE_DB) {
-     await db.table.where("id").equals(id).delete();
-   }
-   ```
-
-5. **Result Processing**
-   ```typescript
-   // Before (Dexie)
-   const items = await db.table.toArray();
-
-   // After (SQL)
-   const platform = PlatformServiceFactory.getInstance();
-   let items = await platform.dbQuery("SELECT * FROM table");
-   items = databaseUtil.mapQueryResultToValues(items);
-
-   // Fallback to Dexie if needed
-   if (USE_DEXIE_DB) {
-     items = await db.table.toArray();
-   }
-   ```
-
-6. **Using Utility Methods**
-
-When working with settings or other common operations, use the utility methods in `db/index.ts`:
-
-```typescript
-// Settings operations
-await databaseUtil.updateDefaultSettings(settings);
-await databaseUtil.updateAccountSettings(did, settings);
-const settings = await databaseUtil.retrieveSettingsForDefaultAccount();
-const settings = await databaseUtil.retrieveSettingsForActiveAccount();
-
-// Logging operations
-await databaseUtil.logToDb(message);
-await databaseUtil.logConsoleAndDb(message, showInConsole);
-```
-
-Key Considerations:
-- Always use `databaseUtil.mapQueryResultToValues()` to process SQL query results
-- Use utility methods from `db/index.ts` when available instead of direct SQL
-- Keep Dexie fallbacks wrapped in `if (USE_DEXIE_DB)` checks
-- For queries that return results, use `let` variables to allow Dexie fallback to override
-- For updates/inserts/deletes, execute both SQL and Dexie operations when `USE_DEXIE_DB` is true
-
-Example Migration:
-```typescript
-// Before (Dexie)
-export async function updateSettings(settings: Settings): Promise<void> {
-  await db.settings.put(settings);
-}
-
-// After (SQL)
-export async function updateSettings(settings: Settings): Promise<void> {
-  const platform = PlatformServiceFactory.getInstance();
-  const { sql, params } = generateUpdateStatement(
-    settings,
-    "settings",
-    "id = ?",
-    [settings.id]
-  );
-  await platform.dbExec(sql, params);
-}
-```
-
-Remember to:
-- Create database access code to use the platform service, putting it in front of the Dexie version
-- Instead of removing Dexie-specific code, keep it.
-
-  - For creates & updates & deletes, the duplicate code is fine.
-
-  - For queries where we use the results, make the setting from SQL into a 'let' variable, then wrap the Dexie code in a check for USE_DEXIE_DB from app.ts and if
-it's true then use that result instead of the SQL code's result.
-
-- Consider data migration needs, and warn if there are any potential migration problems
-
-## Success Criteria
-
-1. **Functionality**
-   - [x] Basic CRUD operations work correctly
-   - [x] Platform service factory pattern implemented
-   - [x] Error handling in place
-   - [ ] Native platform support (planned)
-
-2. **Performance**
-   - [x] Database operations complete within acceptable time
-   - [x] Operation queuing for thread safety
-   - [x] Proper initialization handling
-   - [ ] Performance monitoring (planned)
-
-3. **Security**
-   - [x] Basic data integrity
-   - [ ] Encryption (planned for native platforms)
-   - [ ] Secure key storage (planned)
-   - [ ] Platform-specific security features (planned)
-
-4. **Testing**
-   - [x] Basic unit tests
-   - [ ] Comprehensive integration tests (planned)
-   - [ ] Platform-specific tests (planned)
-   - [ ] Migration tests (planned)
-
-## Next Steps
-
-1. **Native Platform Support**
-   - Implement SQLCipher for iOS/Android
-   - Add platform-specific secure storage
-   - Implement biometric authentication
-
-2. **Enhanced Security**
-   - Add encryption for sensitive data
-   - Implement secure key storage
-   - Add platform-specific security features
-
-3. **Testing and Monitoring**
-   - Add comprehensive test coverage
-   - Implement performance monitoring
-   - Add error tracking and analytics
-
-4. **Documentation**
-   - Add API documentation
-   - Create migration guides
-   - Document security measures

docs/dexie-to-sqlite-mapping.md

@@ -1,4 +1,4 @@
-# Dexie to absurd-sql Mapping Guide
+# Dexie to SQLite Mapping Guide
 
 ## Schema Mapping
 
@@ -54,11 +54,10 @@ CREATE INDEX idx_settings_updated_at ON settings(updated_at);
 // Dexie
 const account = await db.accounts.get(did);
 
-// absurd-sql
-const result = await db.exec(`
+// SQLite
+const account = await db.selectOne(`
   SELECT * FROM accounts WHERE did = ?
 `, [did]);
-const account = result[0]?.values[0];
 ```
 
 #### Get All Accounts
@@ -66,11 +65,10 @@ const account = result[0]?.values[0];
 // Dexie
 const accounts = await db.accounts.toArray();
 
-// absurd-sql
-const result = await db.exec(`
+// SQLite
+const accounts = await db.selectAll(`
   SELECT * FROM accounts ORDER BY created_at DESC
 `);
-const accounts = result[0]?.values || [];
 ```
 
 #### Add Account
@@ -83,8 +81,8 @@ await db.accounts.add({
   updatedAt: Date.now()
 });
 
-// absurd-sql
-await db.run(`
+// SQLite
+await db.execute(`
   INSERT INTO accounts (did, public_key_hex, created_at, updated_at)
   VALUES (?, ?, ?, ?)
 `, [did, publicKeyHex, Date.now(), Date.now()]);
@@ -98,8 +96,8 @@ await db.accounts.update(did, {
   updatedAt: Date.now()
 });
 
-// absurd-sql
-await db.run(`
+// SQLite
+await db.execute(`
   UPDATE accounts 
   SET public_key_hex = ?, updated_at = ?
   WHERE did = ?
@@ -113,11 +111,10 @@ await db.run(`
 // Dexie
 const setting = await db.settings.get(key);
 
-// absurd-sql
-const result = await db.exec(`
+// SQLite
+const setting = await db.selectOne(`
   SELECT * FROM settings WHERE key = ?
 `, [key]);
-const setting = result[0]?.values[0];
 ```
 
 #### Set Setting
@@ -129,8 +126,8 @@ await db.settings.put({
   updatedAt: Date.now()
 });
 
-// absurd-sql
-await db.run(`
+// SQLite
+await db.execute(`
   INSERT INTO settings (key, value, updated_at)
   VALUES (?, ?, ?)
   ON CONFLICT(key) DO UPDATE SET
@@ -149,13 +146,12 @@ const contacts = await db.contacts
   .equals(accountDid)
   .toArray();
 
-// absurd-sql
-const result = await db.exec(`
+// SQLite
+const contacts = await db.selectAll(`
   SELECT * FROM contacts 
   WHERE did = ?
   ORDER BY created_at DESC
 `, [accountDid]);
-const contacts = result[0]?.values || [];
 ```
 
 #### Add Contact
@@ -169,8 +165,8 @@ await db.contacts.add({
   updatedAt: Date.now()
 });
 
-// absurd-sql
-await db.run(`
+// SQLite
+await db.execute(`
   INSERT INTO contacts (id, did, name, created_at, updated_at)
   VALUES (?, ?, ?, ?, ?)
 `, [generateId(), accountDid, name, Date.now(), Date.now()]);
@@ -186,25 +182,20 @@ await db.transaction('rw', [db.accounts, db.contacts], async () => {
   await db.contacts.bulkAdd(contacts);
 });
 
-// absurd-sql
-await db.exec('BEGIN TRANSACTION;');
-try {
-  await db.run(`
+// SQLite
+await db.transaction(async (tx) => {
+  await tx.execute(`
     INSERT INTO accounts (did, public_key_hex, created_at, updated_at)
     VALUES (?, ?, ?, ?)
   `, [account.did, account.publicKeyHex, account.createdAt, account.updatedAt]);
 
   for (const contact of contacts) {
-    await db.run(`
+    await tx.execute(`
       INSERT INTO contacts (id, did, name, created_at, updated_at)
       VALUES (?, ?, ?, ?, ?)
     `, [contact.id, contact.did, contact.name, contact.createdAt, contact.updatedAt]);
   }
-  await db.exec('COMMIT;');
-} catch (error) {
-  await db.exec('ROLLBACK;');
-  throw error;
-}
+});
 ```
 
 ## Migration Helper Functions
@@ -227,14 +218,15 @@ async function exportDexieData(): Promise<MigrationData> {
 }
 ```
 
-### 2. Data Import (JSON to absurd-sql)
+### 2. Data Import (JSON to SQLite)
 ```typescript
-async function importToAbsurdSql(data: MigrationData): Promise<void> {
-  await db.exec('BEGIN TRANSACTION;');
-  try {
+async function importToSQLite(data: MigrationData): Promise<void> {
+  const db = await getSQLiteConnection();
+  
+  await db.transaction(async (tx) => {
     // Import accounts
     for (const account of data.accounts) {
-      await db.run(`
+      await tx.execute(`
         INSERT INTO accounts (did, public_key_hex, created_at, updated_at)
         VALUES (?, ?, ?, ?)
       `, [account.did, account.publicKeyHex, account.createdAt, account.updatedAt]);
@@ -242,7 +234,7 @@ async function importToAbsurdSql(data: MigrationData): Promise<void> {
     
     // Import settings
     for (const setting of data.settings) {
-      await db.run(`
+      await tx.execute(`
         INSERT INTO settings (key, value, updated_at)
         VALUES (?, ?, ?)
       `, [setting.key, setting.value, setting.updatedAt]);
@@ -250,52 +242,52 @@ async function importToAbsurdSql(data: MigrationData): Promise<void> {
     
     // Import contacts
     for (const contact of data.contacts) {
-      await db.run(`
+      await tx.execute(`
         INSERT INTO contacts (id, did, name, created_at, updated_at)
         VALUES (?, ?, ?, ?, ?)
       `, [contact.id, contact.did, contact.name, contact.createdAt, contact.updatedAt]);
     }
-    await db.exec('COMMIT;');
-  } catch (error) {
-    await db.exec('ROLLBACK;');
-    throw error;
-  }
+  });
 }
 ```
 
 ### 3. Verification
 ```typescript
 async function verifyMigration(dexieData: MigrationData): Promise<boolean> {
+  const db = await getSQLiteConnection();
+  
   // Verify account count
-  const accountResult = await db.exec('SELECT COUNT(*) as count FROM accounts');
-  const accountCount = accountResult[0].values[0][0];
+  const accountCount = await db.selectValue(
+    'SELECT COUNT(*) FROM accounts'
+  );
   if (accountCount !== dexieData.accounts.length) {
     return false;
   }
   
   // Verify settings count
-  const settingsResult = await db.exec('SELECT COUNT(*) as count FROM settings');
-  const settingsCount = settingsResult[0].values[0][0];
+  const settingsCount = await db.selectValue(
+    'SELECT COUNT(*) FROM settings'
+  );
   if (settingsCount !== dexieData.settings.length) {
     return false;
   }
   
   // Verify contacts count
-  const contactsResult = await db.exec('SELECT COUNT(*) as count FROM contacts');
-  const contactsCount = contactsResult[0].values[0][0];
+  const contactsCount = await db.selectValue(
+    'SELECT COUNT(*) FROM contacts'
+  );
   if (contactsCount !== dexieData.contacts.length) {
     return false;
   }
   
   // Verify data integrity
   for (const account of dexieData.accounts) {
-    const result = await db.exec(
+    const migratedAccount = await db.selectOne(
       'SELECT * FROM accounts WHERE did = ?',
       [account.did]
     );
-    const migratedAccount = result[0]?.values[0];
     if (!migratedAccount || 
-        migratedAccount[1] !== account.publicKeyHex) { // public_key_hex is second column
+        migratedAccount.public_key_hex !== account.publicKeyHex) {
       return false;
     }
   }
@@ -308,21 +300,18 @@ async function verifyMigration(dexieData: MigrationData): Promise<boolean> {
 
 ### 1. Indexing
 - Dexie automatically creates indexes based on the schema
-- absurd-sql requires explicit index creation
+- SQLite requires explicit index creation
 - Added indexes for frequently queried fields
-- Use `PRAGMA journal_mode=MEMORY;` for better performance
 
 ### 2. Batch Operations
 - Dexie has built-in bulk operations
-- absurd-sql uses transactions for batch operations
+- SQLite uses transactions for batch operations
 - Consider chunking large datasets
-- Use prepared statements for repeated queries
 
 ### 3. Query Optimization
 - Dexie uses IndexedDB's native indexing
-- absurd-sql requires explicit query optimization
+- SQLite requires explicit query optimization
 - Use prepared statements for repeated queries
-- Consider using `PRAGMA synchronous=NORMAL;` for better performance
 
 ## Error Handling
 
@@ -337,14 +326,14 @@ try {
   }
 }
 
-// absurd-sql errors
+// SQLite errors
 try {
-  await db.run(`
+  await db.execute(`
     INSERT INTO accounts (did, public_key_hex, created_at, updated_at)
     VALUES (?, ?, ?, ?)
   `, [account.did, account.publicKeyHex, account.createdAt, account.updatedAt]);
 } catch (error) {
-  if (error.message.includes('UNIQUE constraint failed')) {
+  if (error.code === 'SQLITE_CONSTRAINT') {
     // Handle duplicate key
   }
 }
@@ -361,14 +350,15 @@ try {
   // Dexie automatically rolls back
 }
 
-// absurd-sql transaction
+// SQLite transaction
+const db = await getSQLiteConnection();
 try {
-  await db.exec('BEGIN TRANSACTION;');
-  // Operations
-  await db.exec('COMMIT;');
+  await db.transaction(async (tx) => {
+    // Operations
+  });
 } catch (error) {
-  await db.exec('ROLLBACK;');
-  throw error;
+  // SQLite automatically rolls back
+  await db.execute('ROLLBACK');
 }
 ```
 

docs/migration-to-wa-sqlite.md

@@ -1,8 +1,8 @@
-# Migration Guide: Dexie to absurd-sql
+# Migration Guide: Dexie to wa-sqlite
 
 ## Overview
 
-This document outlines the migration process from Dexie.js to absurd-sql for the TimeSafari app's storage implementation. The migration aims to provide a consistent SQLite-based storage solution across all platforms while maintaining data integrity and ensuring a smooth transition for users.
+This document outlines the migration process from Dexie.js to wa-sqlite for the TimeSafari app's storage implementation. The migration aims to provide a consistent SQLite-based storage solution across all platforms while maintaining data integrity and ensuring a smooth transition for users.
 
 ## Migration Goals
 
@@ -43,20 +43,12 @@ This document outlines the migration process from Dexie.js to absurd-sql for the
    }
    ```
 
-2. **Dependencies**
-   ```json
-   {
-     "@jlongster/sql.js": "^1.8.0",
-     "absurd-sql": "^1.8.0"
-   }
-   ```
-
-3. **Storage Requirements**
+2. **Storage Requirements**
    - Sufficient IndexedDB quota
    - Available disk space for SQLite
    - Backup storage space
 
-4. **Platform Support**
+3. **Platform Support**
    - Web: Modern browser with IndexedDB support
    - iOS: iOS 13+ with SQLite support
    - Android: Android 5+ with SQLite support
@@ -68,15 +60,9 @@ This document outlines the migration process from Dexie.js to absurd-sql for the
 
 ```typescript
 // src/services/storage/migration/MigrationService.ts
-import initSqlJs from '@jlongster/sql.js';
-import { SQLiteFS } from 'absurd-sql';
-import IndexedDBBackend from 'absurd-sql/dist/indexeddb-backend';
-
 export class MigrationService {
   private static instance: MigrationService;
   private backup: MigrationBackup | null = null;
-  private sql: any = null;
-  private db: any = null;
 
   async prepare(): Promise<void> {
     try {
@@ -89,8 +75,8 @@ export class MigrationService {
       // 3. Verify backup integrity
       await this.verifyBackup();
       
-      // 4. Initialize absurd-sql
-      await this.initializeAbsurdSql();
+      // 4. Initialize wa-sqlite
+      await this.initializeWaSqlite();
     } catch (error) {
       throw new StorageError(
         'Migration preparation failed',
@@ -100,42 +86,6 @@ export class MigrationService {
     }
   }
 
-  private async initializeAbsurdSql(): Promise<void> {
-    // Initialize SQL.js
-    this.sql = await initSqlJs({
-      locateFile: (file: string) => {
-        return new URL(`/node_modules/@jlongster/sql.js/dist/${file}`, import.meta.url).href;
-      }
-    });
-
-    // Setup SQLiteFS with IndexedDB backend
-    const sqlFS = new SQLiteFS(this.sql.FS, new IndexedDBBackend());
-    this.sql.register_for_idb(sqlFS);
-
-    // Create and mount filesystem
-    this.sql.FS.mkdir('/sql');
-    this.sql.FS.mount(sqlFS, {}, '/sql');
-
-    // Open database
-    const path = '/sql/db.sqlite';
-    if (typeof SharedArrayBuffer === 'undefined') {
-      let stream = this.sql.FS.open(path, 'a+');
-      await stream.node.contents.readIfFallback();
-      this.sql.FS.close(stream);
-    }
-
-    this.db = new this.sql.Database(path, { filename: true });
-    if (!this.db) {
-      throw new StorageError(
-        'Database initialization failed',
-        StorageErrorCodes.INITIALIZATION_FAILED
-      );
-    }
-
-    // Configure database
-    await this.db.exec(`PRAGMA journal_mode=MEMORY;`);
-  }
-
   private async checkPrerequisites(): Promise<void> {
     // Check IndexedDB availability
     if (!window.indexedDB) {
@@ -210,11 +160,12 @@ export class DataMigration {
   }
 
   private async migrateAccounts(accounts: Account[]): Promise<void> {
+    const db = await this.getWaSqliteConnection();
+    
     // Use transaction for atomicity
-    await this.db.exec('BEGIN TRANSACTION;');
-    try {
+    await db.transaction(async (tx) => {
       for (const account of accounts) {
-        await this.db.run(`
+        await tx.execute(`
           INSERT INTO accounts (did, public_key_hex, created_at, updated_at)
           VALUES (?, ?, ?, ?)
         `, [
@@ -224,18 +175,16 @@ export class DataMigration {
           account.updatedAt
         ]);
       }
-      await this.db.exec('COMMIT;');
-    } catch (error) {
-      await this.db.exec('ROLLBACK;');
-      throw error;
-    }
+    });
   }
 
   private async verifyMigration(backup: MigrationBackup): Promise<void> {
-    // Verify account count
-    const result = await this.db.exec('SELECT COUNT(*) as count FROM accounts');
-    const accountCount = result[0].values[0][0];
+    const db = await this.getWaSqliteConnection();
     
+    // Verify account count
+    const accountCount = await db.selectValue(
+      'SELECT COUNT(*) FROM accounts'
+    );
     if (accountCount !== backup.accounts.length) {
       throw new StorageError(
         'Account count mismatch',
@@ -265,8 +214,8 @@ export class RollbackService {
       // 3. Verify restoration
       await this.verifyRestoration(backup);
       
-      // 4. Clean up absurd-sql
-      await this.cleanupAbsurdSql();
+      // 4. Clean up wa-sqlite
+      await this.cleanupWaSqlite();
     } catch (error) {
       throw new StorageError(
         'Rollback failed',
@@ -422,14 +371,6 @@ button:hover {
    ```typescript
    // src/services/storage/migration/__tests__/MigrationService.spec.ts
    describe('MigrationService', () => {
-     it('should initialize absurd-sql correctly', async () => {
-       const service = MigrationService.getInstance();
-       await service.initializeAbsurdSql();
-       
-       expect(service.isInitialized()).toBe(true);
-       expect(service.getDatabase()).toBeDefined();
-     });
-
      it('should create valid backup', async () => {
        const service = MigrationService.getInstance();
        const backup = await service.createBackup();

docs/storage-implementation-checklist.md

@@ -3,46 +3,45 @@
 ## Core Services
 
 ### 1. Storage Service Layer
-- [x] Create base `PlatformService` interface
-  - [x] Define common methods for all platforms
-  - [x] Add platform-specific method signatures
-  - [x] Include error handling types
-  - [x] Add migration support methods
+- [ ] Create base `StorageService` interface
+  - [ ] Define common methods for all platforms
+  - [ ] Add platform-specific method signatures
+  - [ ] Include error handling types
+  - [ ] Add migration support methods
 
-- [x] Implement platform-specific services
-  - [x] `AbsurdSqlDatabaseService` (web)
-    - [x] Database initialization
-    - [x] VFS setup with IndexedDB backend
-    - [x] Connection management
-    - [x] Operation queuing
-  - [ ] `NativeSQLiteService` (iOS/Android) (planned)
+- [ ] Implement platform-specific services
+  - [ ] `WebSQLiteService` (wa-sqlite)
+    - [ ] Database initialization
+    - [ ] VFS setup
+    - [ ] Connection management
+    - [ ] Query builder
+  - [ ] `NativeSQLiteService` (iOS/Android)
     - [ ] SQLCipher integration
     - [ ] Native bridge setup
     - [ ] File system access
-  - [ ] `ElectronSQLiteService` (planned)
+  - [ ] `ElectronSQLiteService`
     - [ ] Node SQLite integration
     - [ ] IPC communication
     - [ ] File system access
 
 ### 2. Migration Services
-- [x] Implement basic migration support
-  - [x] Dual-storage pattern (SQLite + Dexie)
-  - [x] Basic data verification
-  - [ ] Rollback procedures (planned)
-  - [ ] Progress tracking (planned)
-- [ ] Create `MigrationUI` components (planned)
+- [ ] Implement `MigrationService`
+  - [ ] Backup creation
+  - [ ] Data verification
+  - [ ] Rollback procedures
+  - [ ] Progress tracking
+- [ ] Create `MigrationUI` components
   - [ ] Progress indicators
   - [ ] Error handling
   - [ ] User notifications
   - [ ] Manual triggers
 
 ### 3. Security Layer
-- [x] Basic data integrity
-- [ ] Implement `EncryptionService` (planned)
+- [ ] Implement `EncryptionService`
   - [ ] Key management
   - [ ] Encryption/decryption
   - [ ] Secure storage
-- [ ] Add `BiometricService` (planned)
+- [ ] Add `BiometricService`
   - [ ] Platform detection
   - [ ] Authentication flow
   - [ ] Fallback mechanisms
@@ -50,39 +49,31 @@
 ## Platform-Specific Implementation
 
 ### Web Platform
-- [x] Setup absurd-sql
-  - [x] Install dependencies
+- [ ] Setup wa-sqlite
+  - [ ] Install dependencies
     ```json
     {
-      "@jlongster/sql.js": "^1.8.0",
-      "absurd-sql": "^1.8.0"
+      "@wa-sqlite/sql.js": "^0.8.12",
+      "@wa-sqlite/sql.js-httpvfs": "^0.8.12"
     }
     ```
-  - [x] Configure VFS with IndexedDB backend
-  - [x] Setup worker threads
-  - [x] Implement operation queuing
-  - [x] Configure database pragmas
-  
-    ```sql
-    PRAGMA journal_mode=MEMORY;
-    PRAGMA synchronous=NORMAL;
-    PRAGMA foreign_keys=ON;
-    PRAGMA busy_timeout=5000;
-    ```
+    (May not need httpvfs. Here's one recommended install method: `npm add github:rhashimoto/wa-sqlite`)
+  - [ ] Configure VFS for IndexedDB (eg. IDBBatchAtomicVFS)
+  - [ ] Setup worker threads
+  - [ ] Implement connection pooling
 
-- [x] Update build configuration
-  - [x] Modify `vite.config.ts`
-  - [x] Add worker configuration
-  - [x] Update chunk splitting
-  - [x] Configure asset handling
+- [ ] Update build configuration
+  - [ ] Modify `vite.config.ts`
+  - [ ] Add worker configuration
+  - [ ] Update chunk splitting
+  - [ ] Configure asset handling
 
-- [x] Implement IndexedDB backend
-  - [x] Create database service
-  - [x] Add operation queuing
-  - [x] Handle initialization
-  - [x] Implement atomic operations
+- [ ] Implement IndexedDB fallback
+  - [ ] Create fallback service
+  - [ ] Add data synchronization
+  - [ ] Handle quota exceeded
 
-### iOS Platform (Planned)
+### iOS Platform
 - [ ] Setup SQLCipher
   - [ ] Install pod dependencies
   - [ ] Configure encryption
@@ -95,7 +86,7 @@
   - [ ] Configure backup
   - [ ] Setup app groups
 
-### Android Platform (Planned)
+### Android Platform
 - [ ] Setup SQLCipher
   - [ ] Add Gradle dependencies
   - [ ] Configure encryption
@@ -108,7 +99,7 @@
   - [ ] Configure backup
   - [ ] Setup file provider
 
-### Electron Platform (Planned)
+### Electron Platform
 - [ ] Setup Node SQLite
   - [ ] Install dependencies
   - [ ] Configure IPC
@@ -124,8 +115,7 @@
 ## Data Models and Types
 
 ### 1. Database Schema
-- [x] Define tables
-
+- [ ] Define tables
   ```sql
   -- Accounts table
   CREATE TABLE accounts (
@@ -151,21 +141,15 @@
     updated_at INTEGER NOT NULL,
     FOREIGN KEY (did) REFERENCES accounts(did)
   );
-
-  -- Indexes for performance
-  CREATE INDEX idx_accounts_created_at ON accounts(created_at);
-  CREATE INDEX idx_contacts_did ON contacts(did);
-  CREATE INDEX idx_settings_updated_at ON settings(updated_at);
   ```
 
-- [x] Create indexes
-- [x] Define constraints
-- [ ] Add triggers (planned)
-- [ ] Setup migrations (planned)
+- [ ] Create indexes
+- [ ] Define constraints
+- [ ] Add triggers
+- [ ] Setup migrations
 
 ### 2. Type Definitions
-
-- [x] Create interfaces
+- [ ] Create interfaces
   ```typescript
   interface Account {
     did: string;
@@ -189,28 +173,28 @@
   }
   ```
 
-- [x] Add validation
-- [x] Create DTOs
-- [x] Define enums
-- [x] Add type guards
+- [ ] Add validation
+- [ ] Create DTOs
+- [ ] Define enums
+- [ ] Add type guards
 
 ## UI Components
 
-### 1. Migration UI (Planned)
+### 1. Migration UI
 - [ ] Create components
   - [ ] `MigrationProgress.vue`
   - [ ] `MigrationError.vue`
   - [ ] `MigrationSettings.vue`
   - [ ] `MigrationStatus.vue`
 
-### 2. Settings UI (Planned)
+### 2. Settings UI
 - [ ] Update components
   - [ ] Add storage settings
   - [ ] Add migration controls
   - [ ] Add backup options
   - [ ] Add security settings
 
-### 3. Error Handling UI (Planned)
+### 3. Error Handling UI
 - [ ] Create components
   - [ ] `StorageError.vue`
   - [ ] `QuotaExceeded.vue`
@@ -220,20 +204,20 @@
 ## Testing
 
 ### 1. Unit Tests
-- [x] Basic service tests
-  - [x] Platform service tests
-  - [x] Database operation tests
-  - [ ] Security service tests (planned)
-  - [ ] Platform detection tests (planned)
+- [ ] Test services
+  - [ ] Storage service tests
+  - [ ] Migration service tests
+  - [ ] Security service tests
+  - [ ] Platform detection tests
 
-### 2. Integration Tests (Planned)
+### 2. Integration Tests
 - [ ] Test migrations
   - [ ] Web platform tests
   - [ ] iOS platform tests
   - [ ] Android platform tests
   - [ ] Electron platform tests
 
-### 3. E2E Tests (Planned)
+### 3. E2E Tests
 - [ ] Test workflows
   - [ ] Account management
   - [ ] Settings management
@@ -243,12 +227,12 @@
 ## Documentation
 
 ### 1. Technical Documentation
-- [x] Update architecture docs
-- [x] Add API documentation
-- [ ] Create migration guides (planned)
-- [ ] Document security measures (planned)
+- [ ] Update architecture docs
+- [ ] Add API documentation
+- [ ] Create migration guides
+- [ ] Document security measures
 
-### 2. User Documentation (Planned)
+### 2. User Documentation
 - [ ] Update user guides
 - [ ] Add troubleshooting guides
 - [ ] Create FAQ
@@ -257,18 +241,18 @@
 ## Deployment
 
 ### 1. Build Process
-- [x] Update build scripts
-- [x] Add platform-specific builds
-- [ ] Configure CI/CD (planned)
-- [ ] Setup automated testing (planned)
+- [ ] Update build scripts
+- [ ] Add platform-specific builds
+- [ ] Configure CI/CD
+- [ ] Setup automated testing
 
-### 2. Release Process (Planned)
+### 2. Release Process
 - [ ] Create release checklist
 - [ ] Add version management
 - [ ] Setup rollback procedures
 - [ ] Configure monitoring
 
-## Monitoring and Analytics (Planned)
+## Monitoring and Analytics
 
 ### 1. Error Tracking
 - [ ] Setup error logging
@@ -282,7 +266,7 @@
 - [ ] Monitor performance
 - [ ] Collect user feedback
 
-## Security Audit (Planned)
+## Security Audit
 
 ### 1. Code Review
 - [ ] Review encryption
@@ -299,31 +283,25 @@
 ## Success Criteria
 
 ### 1. Performance
-- [x] Query response time < 100ms
-- [x] Operation queuing for thread safety
-- [x] Proper initialization handling
-- [ ] Migration time < 5s per 1000 records (planned)
-- [ ] Storage overhead < 10% (planned)
-- [ ] Memory usage < 50MB (planned)
+- [ ] Query response time < 100ms
+- [ ] Migration time < 5s per 1000 records
+- [ ] Storage overhead < 10%
+- [ ] Memory usage < 50MB
 
 ### 2. Reliability
-- [x] Basic data integrity
-- [x] Operation queuing
-- [ ] Automatic recovery (planned)
-- [ ] Backup verification (planned)
-- [ ] Transaction atomicity (planned)
-- [ ] Data consistency (planned)
+- [ ] 99.9% uptime
+- [ ] Zero data loss
+- [ ] Automatic recovery
+- [ ] Backup verification
 
 ### 3. Security
-- [x] Basic data integrity
-- [ ] AES-256 encryption (planned)
-- [ ] Secure key storage (planned)
-- [ ] Access control (planned)
-- [ ] Audit logging (planned)
+- [ ] AES-256 encryption
+- [ ] Secure key storage
+- [ ] Access control
+- [ ] Audit logging
 
 ### 4. User Experience
-- [x] Basic database operations
-- [ ] Smooth migration (planned)
-- [ ] Clear error messages (planned)
-- [ ] Progress indicators (planned)
-- [ ] Recovery options (planned) 
+- [ ] Smooth migration
+- [ ] Clear error messages
+- [ ] Progress indicators
+- [ ] Recovery options 

electron/.gitignore

@@ -1,55 +0,0 @@
-# NPM renames .gitignore to .npmignore
-# In order to prevent that, we remove the initial "."
-# And the CLI then renames it
-app
-node_modules
-build
-dist
-logs
-# Node.js dependencies
-node_modules/
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-.pnpm-debug.log*
-
-# Capacitor build outputs
-web/
-ios/
-android/
-electron/app/
-
-# Capacitor SQLite plugin data (important!)
-capacitor-sqlite/
-
-# TypeScript / build output
-dist/
-build/
-*.log
-
-# Development / IDE files
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
-
-# VS Code
-.vscode/
-!.vscode/extensions.json
-
-# JetBrains IDEs (IntelliJ, WebStorm, etc.)
-.idea/
-*.iml
-*.iws
-
-# macOS specific
-.DS_Store
-*.swp
-*~
-*.tmp
-
-# Windows specific
-Thumbs.db
-ehthumbs.db
-Desktop.ini
-$RECYCLE.BIN/

electron/capacitor.config.json

@@ -1,62 +0,0 @@
-{
-	"appId": "com.timesafari.app",
-	"appName": "TimeSafari",
-	"webDir": "dist",
-	"bundledWebRuntime": false,
-	"server": {
-		"cleartext": true,
-		"androidScheme": "https"
-	},
-	"plugins": {
-		"App": {
-			"appUrlOpen": {
-				"handlers": [
-					{
-						"url": "timesafari://*",
-						"autoVerify": true
-					}
-				]
-			}
-		},
-		"SQLite": {
-			"iosDatabaseLocation": "Library/CapacitorDatabase",
-			"iosIsEncryption": true,
-			"iosBiometric": {
-				"biometricAuth": true,
-				"biometricTitle": "Biometric login for TimeSafari"
-			},
-			"androidIsEncryption": true,
-			"androidBiometric": {
-				"biometricAuth": true,
-				"biometricTitle": "Biometric login for TimeSafari"
-			}
-		},
-		"CapacitorSQLite": {
-			"electronIsEncryption": false,
-			"electronMacLocation": "~/Library/Application Support/TimeSafari",
-			"electronWindowsLocation": "C:\\ProgramData\\TimeSafari"
-		}
-	},
-	"ios": {
-		"contentInset": "always",
-		"allowsLinkPreview": true,
-		"scrollEnabled": true,
-		"limitsNavigationsToAppBoundDomains": true,
-		"backgroundColor": "#ffffff",
-		"allowNavigation": [
-			"*.timesafari.app",
-			"*.jsdelivr.net",
-			"api.endorser.ch"
-		]
-	},
-	"android": {
-		"allowMixedContent": false,
-		"captureInput": true,
-		"webContentsDebuggingEnabled": false,
-		"allowNavigation": [
-			"*.timesafari.app",
-			"*.jsdelivr.net",
-			"api.endorser.ch"
-		]
-	}
-}

electron/electron-builder.config.json

@@ -1,28 +0,0 @@
-{
-  "appId": "com.yourdoamnin.yourapp",
-  "directories": {
-    "buildResources": "resources"
-  },
-  "files": [
-    "assets/**/*",
-    "build/**/*",
-    "capacitor.config.*",
-    "app/**/*"
-  ],
-  "publish": {
-    "provider": "github"
-  },
-  "nsis": {
-    "allowElevation": true,
-    "oneClick": false,
-    "allowToChangeInstallationDirectory": true
-  },
-  "win": {
-    "target": "nsis",
-    "icon": "assets/appIcon.ico"
-  },
-  "mac": {
-    "category": "your.app.category.type",
-    "target": "dmg"
-  }
-}

electron/live-runner.js

@@ -1,75 +0,0 @@
-/* eslint-disable no-undef */
-/* eslint-disable @typescript-eslint/no-var-requires */
-const cp = require('child_process');
-const chokidar = require('chokidar');
-const electron = require('electron');
-
-let child = null;
-const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-const reloadWatcher = {
-  debouncer: null,
-  ready: false,
-  watcher: null,
-  restarting: false,
-};
-
-///*
-function runBuild() {
-  return new Promise((resolve, _reject) => {
-    let tempChild = cp.spawn(npmCmd, ['run', 'build']);
-    tempChild.once('exit', () => {
-      resolve();
-    });
-    tempChild.stdout.pipe(process.stdout);
-  });
-}
-//*/
-
-async function spawnElectron() {
-  if (child !== null) {
-    child.stdin.pause();
-    child.kill();
-    child = null;
-    await runBuild();
-  }
-  child = cp.spawn(electron, ['--inspect=5858', './']);
-  child.on('exit', () => {
-    if (!reloadWatcher.restarting) {
-      process.exit(0);
-    }
-  });
-  child.stdout.pipe(process.stdout);
-}
-
-function setupReloadWatcher() {
-  reloadWatcher.watcher = chokidar
-    .watch('./src/**/*', {
-      ignored: /[/\\]\./,
-      persistent: true,
-    })
-    .on('ready', () => {
-      reloadWatcher.ready = true;
-    })
-    .on('all', (_event, _path) => {
-      if (reloadWatcher.ready) {
-        clearTimeout(reloadWatcher.debouncer);
-        reloadWatcher.debouncer = setTimeout(async () => {
-          console.log('Restarting');
-          reloadWatcher.restarting = true;
-          await spawnElectron();
-          reloadWatcher.restarting = false;
-          reloadWatcher.ready = false;
-          clearTimeout(reloadWatcher.debouncer);
-          reloadWatcher.debouncer = null;
-          reloadWatcher.watcher = null;
-          setupReloadWatcher();
-        }, 500);
-      }
-    });
-}
-
-(async () => {
-  await runBuild();
-  await spawnElectron();
-  setupReloadWatcher();
-})();

electron/package.json

@@ -1,52 +0,0 @@
-{
-  "name": "TimeSafari",
-  "version": "1.0.0",
-  "description": "TimeSafari Electron App",
-  "author": {
-    "name": "",
-    "email": ""
-  },
-  "repository": {
-    "type": "git",
-    "url": ""
-  },
-  "license": "MIT",
-  "main": "build/src/index.js",
-  "scripts": {
-    "build": "tsc && electron-rebuild",
-    "electron:start-live": "node ./live-runner.js",
-    "electron:start": "npm run build && electron --inspect=5858 ./",
-    "electron:pack": "npm run build && electron-builder build --dir -c ./electron-builder.config.json",
-    "electron:make": "npm run build && electron-builder build -c ./electron-builder.config.json -p always"
-  },
-  "dependencies": {
-    "@capacitor-community/electron": "^5.0.0",
-    "@capacitor-community/sqlite": "^6.0.2",
-    "better-sqlite3-multiple-ciphers": "^11.10.0",
-    "chokidar": "~3.5.3",
-    "crypto": "^1.0.1",
-    "crypto-js": "^4.2.0",
-    "electron-is-dev": "~2.0.0",
-    "electron-json-storage": "^4.6.0",
-    "electron-serve": "~1.1.0",
-    "electron-unhandled": "~4.0.1",
-    "electron-updater": "^5.3.0",
-    "electron-window-state": "^5.0.3",
-    "jszip": "^3.10.1",
-    "node-fetch": "^2.6.7",
-    "winston": "^3.17.0"
-  },
-  "devDependencies": {
-    "@types/better-sqlite3": "^7.6.13",
-    "@types/crypto-js": "^4.2.2",
-    "@types/electron-json-storage": "^4.5.4",
-    "electron": "^26.2.2",
-    "electron-builder": "~23.6.0",
-    "source-map-support": "^0.5.21",
-    "typescript": "^5.0.4"
-  },
-  "keywords": [
-    "capacitor",
-    "electron"
-  ]
-}

electron/resources/electron-publisher-custom.js

@@ -1,10 +0,0 @@
-/* eslint-disable no-undef */
-/* eslint-disable @typescript-eslint/no-var-requires */
-const electronPublish = require('electron-publish');
-
-class Publisher extends electronPublish.Publisher {
-  async upload(task) {
-    console.log('electron-publisher-custom', task.file);
-  }
-}
-module.exports = Publisher;

electron/src/index.ts

@@ -1,140 +0,0 @@
-import type { CapacitorElectronConfig } from '@capacitor-community/electron';
-import { getCapacitorElectronConfig, setupElectronDeepLinking } from '@capacitor-community/electron';
-import type { MenuItemConstructorOptions } from 'electron';
-import { app, MenuItem } from 'electron';
-import electronIsDev from 'electron-is-dev';
-import unhandled from 'electron-unhandled';
-import { autoUpdater } from 'electron-updater';
-
-import { ElectronCapacitorApp, setupContentSecurityPolicy, setupReloadWatcher } from './setup';
-import { initializeSQLite, setupSQLiteHandlers } from './rt/sqlite-init';
-
-// Graceful handling of unhandled errors.
-unhandled();
-
-// Define our menu templates (these are optional)
-const trayMenuTemplate: (MenuItemConstructorOptions | MenuItem)[] = [new MenuItem({ label: 'Quit App', role: 'quit' })];
-const appMenuBarMenuTemplate: (MenuItemConstructorOptions | MenuItem)[] = [
-  { role: process.platform === 'darwin' ? 'appMenu' : 'fileMenu' },
-  { role: 'viewMenu' },
-];
-
-// Get Config options from capacitor.config
-const capacitorFileConfig: CapacitorElectronConfig = getCapacitorElectronConfig();
-
-// Initialize our app. You can pass menu templates into the app here.
-const myCapacitorApp = new ElectronCapacitorApp(capacitorFileConfig, trayMenuTemplate, appMenuBarMenuTemplate);
-
-// If deeplinking is enabled then we will set it up here.
-if (capacitorFileConfig.electron?.deepLinkingEnabled) {
-  setupElectronDeepLinking(myCapacitorApp, {
-    customProtocol: capacitorFileConfig.electron.deepLinkingCustomProtocol ?? 'mycapacitorapp',
-  });
-}
-
-// If we are in Dev mode, use the file watcher components.
-if (electronIsDev) {
-  setupReloadWatcher(myCapacitorApp);
-}
-
-// Run Application
-(async () => {
-  try {
-    // Wait for electron app to be ready first
-    await app.whenReady();
-    console.log('[Electron Main Process] App is ready');
-
-    // Initialize SQLite plugin and handlers BEFORE creating any windows
-    console.log('[Electron Main Process] Initializing SQLite...');
-    setupSQLiteHandlers();
-    await initializeSQLite();
-    console.log('[Electron Main Process] SQLite initialization complete');
-
-    // Security - Set Content-Security-Policy
-    setupContentSecurityPolicy(myCapacitorApp.getCustomURLScheme());
-    
-    // Initialize our app and create window
-    console.log('[Electron Main Process] Starting app initialization...');
-    await myCapacitorApp.init();
-    console.log('[Electron Main Process] App initialization complete');
-
-    // Get the main window
-    const mainWindow = myCapacitorApp.getMainWindow();
-    if (!mainWindow) {
-      throw new Error('Main window not available after app initialization');
-    }
-
-    // Wait for window to be ready and loaded
-    await new Promise<void>((resolve) => {
-      const handleReady = () => {
-        console.log('[Electron Main Process] Window ready to show');
-        mainWindow.show();
-        
-        // Wait for window to finish loading
-        mainWindow.webContents.once('did-finish-load', () => {
-          console.log('[Electron Main Process] Window finished loading');
-          
-          // Send SQLite ready signal after window is fully loaded
-          if (!mainWindow.isDestroyed()) {
-            mainWindow.webContents.send('sqlite-ready');
-            console.log('[Electron Main Process] Sent SQLite ready signal to renderer');
-          } else {
-            console.warn('[Electron Main Process] Window was destroyed before sending SQLite ready signal');
-          }
-          
-          resolve();
-        });
-      };
-
-      // Always use the event since isReadyToShow is not reliable
-      mainWindow.once('ready-to-show', handleReady);
-    });
-
-    // Check for updates if we are in a packaged app
-    if (!electronIsDev) {
-      console.log('[Electron Main Process] Checking for updates...');
-      autoUpdater.checkForUpdatesAndNotify();
-    }
-
-    // Handle window close
-    mainWindow.on('closed', () => {
-      console.log('[Electron Main Process] Main window closed');
-    });
-
-    // Handle window close request
-    mainWindow.on('close', (event) => {
-      console.log('[Electron Main Process] Window close requested');
-      if (mainWindow.webContents.isLoading()) {
-        event.preventDefault();
-        console.log('[Electron Main Process] Deferring window close due to loading state');
-        mainWindow.webContents.once('did-finish-load', () => {
-          mainWindow.close();
-        });
-      }
-    });
-
-  } catch (error) {
-    console.error('[Electron Main Process] Fatal error during initialization:', error);
-    app.quit();
-  }
-})();
-
-// Handle when all of our windows are close (platforms have their own expectations).
-app.on('window-all-closed', function () {
-  // On OS X it is common for applications and their menu bar
-  // to stay active until the user quits explicitly with Cmd + Q
-  if (process.platform !== 'darwin') {
-    app.quit();
-  }
-});
-
-// When the dock icon is clicked.
-app.on('activate', async function () {
-  // On OS X it's common to re-create a window in the app when the
-  // dock icon is clicked and there are no other windows open.
-  if (myCapacitorApp.getMainWindow().isDestroyed()) {
-    await myCapacitorApp.init();
-  }
-});
-
-// Place all ipc or other electron api calls and custom functionality under this line

electron/src/preload.ts

@@ -1,303 +0,0 @@
-/**
- * Preload script for Electron
- * Sets up secure IPC communication between renderer and main process
- * 
- * @author Matthew Raymer
- */
-
-import { contextBridge, ipcRenderer } from 'electron';
-
-// Enhanced logger for preload script that forwards to main process
-const logger = {
-  log: (...args: unknown[]) => {
-    console.log('[Preload]', ...args);
-    ipcRenderer.send('renderer-log', { level: 'log', args });
-  },
-  error: (...args: unknown[]) => {
-    console.error('[Preload]', ...args);
-    ipcRenderer.send('renderer-log', { level: 'error', args });
-  },
-  info: (...args: unknown[]) => {
-    console.info('[Preload]', ...args);
-    ipcRenderer.send('renderer-log', { level: 'info', args });
-  },
-  warn: (...args: unknown[]) => {
-    console.warn('[Preload]', ...args);
-    ipcRenderer.send('renderer-log', { level: 'warn', args });
-  },
-  debug: (...args: unknown[]) => {
-    console.debug('[Preload]', ...args);
-    ipcRenderer.send('renderer-log', { level: 'debug', args });
-  },
-  sqlite: {
-    log: (operation: string, ...args: unknown[]) => {
-      const message = ['[Preload][SQLite]', operation, ...args];
-      console.log(...message);
-      ipcRenderer.send('renderer-log', { 
-        level: 'log', 
-        args: message,
-        source: 'sqlite',
-        operation
-      });
-    },
-    error: (operation: string, error: unknown) => {
-      const message = ['[Preload][SQLite]', operation, 'failed:', error];
-      console.error(...message);
-      ipcRenderer.send('renderer-log', { 
-        level: 'error', 
-        args: message,
-        source: 'sqlite',
-        operation,
-        error: error instanceof Error ? {
-          name: error.name,
-          message: error.message,
-          stack: error.stack
-        } : error
-      });
-    },
-    debug: (operation: string, ...args: unknown[]) => {
-      const message = ['[Preload][SQLite]', operation, ...args];
-      console.debug(...message);
-      ipcRenderer.send('renderer-log', { 
-        level: 'debug', 
-        args: message,
-        source: 'sqlite',
-        operation
-      });
-    }
-  }
-};
-
-// Types for SQLite connection options
-interface SQLiteConnectionOptions {
-  database: string;
-  version?: number;
-  readOnly?: boolean;
-  readonly?: boolean; // Handle both cases
-  encryption?: string;
-  mode?: string;
-  useNative?: boolean;
-  [key: string]: unknown; // Allow other properties
-}
-
-// Define valid channels for security
-const VALID_CHANNELS = {
-  send: ['toMain'] as const,
-  receive: ['fromMain', 'sqlite-ready', 'database-status'] as const,
-  invoke: [
-    'sqlite-is-available',
-    'sqlite-echo',
-    'sqlite-create-connection',
-    'sqlite-execute',
-    'sqlite-query',
-    'sqlite-run',
-    'sqlite-close-connection',
-    'sqlite-open',
-    'sqlite-close',
-    'sqlite-is-db-open',
-    'sqlite-status',
-    'get-path',
-    'get-base-path'
-  ] as const
-};
-
-type ValidSendChannel = typeof VALID_CHANNELS.send[number];
-type ValidReceiveChannel = typeof VALID_CHANNELS.receive[number];
-type ValidInvokeChannel = typeof VALID_CHANNELS.invoke[number];
-
-// Create a secure IPC bridge
-const createSecureIPCBridge = () => {
-  return {
-    send: (channel: string, data: unknown) => {
-      if (VALID_CHANNELS.send.includes(channel as ValidSendChannel)) {
-        logger.debug('IPC Send:', channel, data);
-        ipcRenderer.send(channel, data);
-      } else {
-        logger.warn(`[Preload] Attempted to send on invalid channel: ${channel}`);
-      }
-    },
-
-    receive: (channel: string, func: (...args: unknown[]) => void) => {
-      if (VALID_CHANNELS.receive.includes(channel as ValidReceiveChannel)) {
-        logger.debug('IPC Receive:', channel);
-        ipcRenderer.on(channel, (_event, ...args) => {
-          logger.debug('IPC Received:', channel, args);
-          func(...args);
-        });
-      } else {
-        logger.warn(`[Preload] Attempted to receive on invalid channel: ${channel}`);
-      }
-    },
-
-    once: (channel: string, func: (...args: unknown[]) => void) => {
-      if (VALID_CHANNELS.receive.includes(channel as ValidReceiveChannel)) {
-        logger.debug('IPC Once:', channel);
-        ipcRenderer.once(channel, (_event, ...args) => {
-          logger.debug('IPC Received Once:', channel, args);
-          func(...args);
-        });
-      } else {
-        logger.warn(`[Preload] Attempted to receive once on invalid channel: ${channel}`);
-      }
-    },
-
-    invoke: async (channel: string, ...args: unknown[]) => {
-      if (VALID_CHANNELS.invoke.includes(channel as ValidInvokeChannel)) {
-        logger.debug('IPC Invoke:', channel, args);
-        try {
-          const result = await ipcRenderer.invoke(channel, ...args);
-          logger.debug('IPC Invoke Result:', channel, result);
-          return result;
-        } catch (error) {
-          logger.error('IPC Invoke Error:', channel, error);
-          throw error;
-        }
-      } else {
-        logger.warn(`[Preload] Attempted to invoke on invalid channel: ${channel}`);
-        throw new Error(`Invalid channel: ${channel}`);
-      }
-    }
-  };
-};
-
-// Create SQLite proxy with retry logic
-const createSQLiteProxy = () => {
-  const MAX_RETRIES = 3;
-  const RETRY_DELAY = 1000;
-
-  const withRetry = async <T>(operation: string, ...args: unknown[]): Promise<T> => {
-    let lastError: Error | undefined;
-    const operationId = `${operation}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-    const startTime = Date.now();
-    
-    logger.sqlite.debug(operation, 'starting with args:', {
-      operationId,
-      args,
-      timestamp: new Date().toISOString()
-    });
-    
-    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-      try {
-        logger.sqlite.debug(operation, `attempt ${attempt}/${MAX_RETRIES}`, {
-          operationId,
-          attempt,
-          args,
-          timestamp: new Date().toISOString()
-        });
-        
-        // Log the exact IPC call
-        logger.sqlite.debug(operation, 'invoking IPC', {
-          operationId,
-          channel: `sqlite-${operation}`,
-          args,
-          timestamp: new Date().toISOString()
-        });
-        
-        const result = await ipcRenderer.invoke(`sqlite-${operation}`, ...args);
-        
-        const duration = Date.now() - startTime;
-        logger.sqlite.log(operation, 'success', {
-          operationId,
-          attempt,
-          result,
-          duration: `${duration}ms`,
-          timestamp: new Date().toISOString()
-        });
-        
-        return result as T;
-      } catch (error) {
-        const duration = Date.now() - startTime;
-        lastError = error instanceof Error ? error : new Error(String(error));
-        
-        logger.sqlite.error(operation, {
-          operationId,
-          attempt,
-          error: {
-            name: lastError.name,
-            message: lastError.message,
-            stack: lastError.stack
-          },
-          args,
-          duration: `${duration}ms`,
-          timestamp: new Date().toISOString()
-        });
-        
-        if (attempt < MAX_RETRIES) {
-          const backoffDelay = RETRY_DELAY * Math.pow(2, attempt - 1);
-          logger.warn(`[Preload] SQLite ${operation} failed (attempt ${attempt}/${MAX_RETRIES}), retrying in ${backoffDelay}ms...`, {
-            operationId,
-            error: lastError,
-            args,
-            nextAttemptIn: `${backoffDelay}ms`,
-            timestamp: new Date().toISOString()
-          });
-          await new Promise(resolve => setTimeout(resolve, backoffDelay));
-        }
-      }
-    }
-    
-    const finalError = new Error(
-      `SQLite ${operation} failed after ${MAX_RETRIES} attempts: ${lastError?.message || "Unknown error"}`
-    );
-    
-    logger.error('[Preload] SQLite operation failed permanently:', {
-      operation,
-      operationId,
-      error: {
-        name: finalError.name,
-        message: finalError.message,
-        stack: finalError.stack,
-        originalError: lastError
-      },
-      args,
-      attempts: MAX_RETRIES,
-      timestamp: new Date().toISOString()
-    });
-    
-    throw finalError;
-  };
-
-  return {
-    isAvailable: () => withRetry('is-available'),
-    echo: (value: string) => withRetry('echo', { value }),
-    createConnection: (options: SQLiteConnectionOptions) => withRetry('create-connection', options),
-    closeConnection: (options: { database: string }) => withRetry('close-connection', options),
-    query: (options: { statement: string; values?: unknown[] }) => withRetry('query', options),
-    run: (options: { statement: string; values?: unknown[] }) => withRetry('run', options),
-    execute: (options: { statements: { statement: string; values?: unknown[] }[] }) => withRetry('execute', options),
-    getPlatform: () => Promise.resolve('electron')
-  };
-};
-
-try {
-  // Expose the secure IPC bridge and SQLite proxy
-  const electronAPI = {
-    ipcRenderer: createSecureIPCBridge(),
-    sqlite: createSQLiteProxy(),
-    env: {
-      platform: 'electron',
-      isDev: process.env.NODE_ENV === 'development'
-    }
-  };
-
-  // Log the exposed API for debugging
-  logger.debug('Exposing Electron API:', {
-    hasIpcRenderer: !!electronAPI.ipcRenderer,
-    hasSqlite: !!electronAPI.sqlite,
-    sqliteMethods: Object.keys(electronAPI.sqlite),
-    env: electronAPI.env
-  });
-
-  contextBridge.exposeInMainWorld('electron', electronAPI);
-  logger.info('[Preload] IPC bridge and SQLite proxy initialized successfully');
-} catch (error) {
-  logger.error('[Preload] Failed to initialize IPC bridge:', error);
-}
-
-// Log startup
-logger.log('[CapacitorSQLite] Preload script starting...');
-
-// Handle window load
-window.addEventListener('load', () => {
-  logger.log('[CapacitorSQLite] Preload script complete');
-});

electron/src/rt/electron-plugins.js

@@ -1,6 +0,0 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-const CapacitorCommunitySqlite = require('../../../node_modules/@capacitor-community/sqlite/electron/dist/plugin.js');
-
-module.exports = {
-  CapacitorCommunitySqlite,
-}

electron/src/rt/electron-rt.ts

@@ -1,88 +0,0 @@
-import { randomBytes } from 'crypto';
-import { ipcRenderer, contextBridge } from 'electron';
-import { EventEmitter } from 'events';
-
-////////////////////////////////////////////////////////
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const plugins = require('./electron-plugins');
-
-const randomId = (length = 5) => randomBytes(length).toString('hex');
-
-const contextApi: {
-  [plugin: string]: { [functionName: string]: () => Promise<any> };
-} = {};
-
-Object.keys(plugins).forEach((pluginKey) => {
-  Object.keys(plugins[pluginKey])
-    .filter((className) => className !== 'default')
-    .forEach((classKey) => {
-      const functionList = Object.getOwnPropertyNames(plugins[pluginKey][classKey].prototype).filter(
-        (v) => v !== 'constructor'
-      );
-
-      if (!contextApi[classKey]) {
-        contextApi[classKey] = {};
-      }
-
-      functionList.forEach((functionName) => {
-        if (!contextApi[classKey][functionName]) {
-          contextApi[classKey][functionName] = (...args) => ipcRenderer.invoke(`${classKey}-${functionName}`, ...args);
-        }
-      });
-
-      // Events
-      if (plugins[pluginKey][classKey].prototype instanceof EventEmitter) {
-        const listeners: { [key: string]: { type: string; listener: (...args: any[]) => void } } = {};
-        const listenersOfTypeExist = (type) =>
-          !!Object.values(listeners).find((listenerObj) => listenerObj.type === type);
-
-        Object.assign(contextApi[classKey], {
-          addListener(type: string, callback: (...args) => void) {
-            const id = randomId();
-
-            // Deduplicate events
-            if (!listenersOfTypeExist(type)) {
-              ipcRenderer.send(`event-add-${classKey}`, type);
-            }
-
-            const eventHandler = (_, ...args) => callback(...args);
-
-            ipcRenderer.addListener(`event-${classKey}-${type}`, eventHandler);
-            listeners[id] = { type, listener: eventHandler };
-
-            return id;
-          },
-          removeListener(id: string) {
-            if (!listeners[id]) {
-              throw new Error('Invalid id');
-            }
-
-            const { type, listener } = listeners[id];
-
-            ipcRenderer.removeListener(`event-${classKey}-${type}`, listener);
-
-            delete listeners[id];
-
-            if (!listenersOfTypeExist(type)) {
-              ipcRenderer.send(`event-remove-${classKey}-${type}`);
-            }
-          },
-          removeAllListeners(type: string) {
-            Object.entries(listeners).forEach(([id, listenerObj]) => {
-              if (!type || listenerObj.type === type) {
-                ipcRenderer.removeListener(`event-${classKey}-${listenerObj.type}`, listenerObj.listener);
-                ipcRenderer.send(`event-remove-${classKey}-${listenerObj.type}`);
-                delete listeners[id];
-              }
-            });
-          },
-        });
-      }
-    });
-});
-
-contextBridge.exposeInMainWorld('CapacitorCustomPlatform', {
-  name: 'electron',
-  plugins: contextApi,
-});
-////////////////////////////////////////////////////////

electron/src/rt/logger.ts

@@ -1,188 +0,0 @@
-/**
- * Enhanced logging system for TimeSafari Electron
- * Provides structured logging with proper levels and formatting
- * Supports both console and file output with different verbosity levels
- * 
- * @author Matthew Raymer
- */
-
-import { app, ipcMain } from 'electron';
-import winston from 'winston';
-import path from 'path';
-import os from 'os';
-import fs from 'fs';
-
-// Extend Winston Logger type with our custom loggers
-declare module 'winston' {
-  interface Logger {
-    sqlite: {
-      debug: (message: string, ...args: unknown[]) => void;
-      info: (message: string, ...args: unknown[]) => void;
-      warn: (message: string, ...args: unknown[]) => void;
-      error: (message: string, ...args: unknown[]) => void;
-    };
-    migration: {
-      debug: (message: string, ...args: unknown[]) => void;
-      info: (message: string, ...args: unknown[]) => void;
-      warn: (message: string, ...args: unknown[]) => void;
-      error: (message: string, ...args: unknown[]) => void;
-    };
-  }
-}
-
-// Create logs directory if it doesn't exist
-const logsDir = path.join(app.getPath('userData'), 'logs');
-if (!fs.existsSync(logsDir)) {
-  fs.mkdirSync(logsDir, { recursive: true });
-}
-
-// Custom format for console output with migration filtering
-const consoleFormat = winston.format.combine(
-  winston.format.timestamp(),
-  winston.format.colorize(),
-  winston.format.printf(({ level, message, timestamp, ...metadata }) => {
-    // Skip migration logs unless DEBUG_MIGRATIONS is set
-    if (level === 'info' && 
-        typeof message === 'string' && 
-        message.includes('[Migration]') && 
-        !process.env.DEBUG_MIGRATIONS) {
-      return '';
-    }
-    
-    let msg = `${timestamp} [${level}] ${message}`;
-    if (Object.keys(metadata).length > 0) {
-      msg += ` ${JSON.stringify(metadata, null, 2)}`;
-    }
-    return msg;
-  })
-);
-
-// Custom format for file output
-const fileFormat = winston.format.combine(
-  winston.format.timestamp(),
-  winston.format.json()
-);
-
-// Create logger instance
-const logger = winston.createLogger({
-  level: process.env.NODE_ENV === 'development' ? 'debug' : 'info',
-  format: fileFormat,
-  defaultMeta: { service: 'timesafari-electron' },
-  transports: [
-    // Console transport with custom format and migration filtering
-    new winston.transports.Console({
-      format: consoleFormat,
-      level: process.env.NODE_ENV === 'development' ? 'debug' : 'info',
-      silent: false // Ensure we can still see non-migration logs
-    }),
-    // File transport for all logs
-    new winston.transports.File({
-      filename: path.join(logsDir, 'error.log'),
-      level: 'error',
-      maxsize: 5242880, // 5MB
-      maxFiles: 5
-    }),
-    // File transport for all logs including debug
-    new winston.transports.File({
-      filename: path.join(logsDir, 'combined.log'),
-      maxsize: 5242880, // 5MB
-      maxFiles: 5
-    })
-  ]
-}) as winston.Logger & {
-  sqlite: {
-    debug: (message: string, ...args: unknown[]) => void;
-    info: (message: string, ...args: unknown[]) => void;
-    warn: (message: string, ...args: unknown[]) => void;
-    error: (message: string, ...args: unknown[]) => void;
-  };
-  migration: {
-    debug: (message: string, ...args: unknown[]) => void;
-    info: (message: string, ...args: unknown[]) => void;
-    warn: (message: string, ...args: unknown[]) => void;
-    error: (message: string, ...args: unknown[]) => void;
-  };
-};
-
-// Add SQLite specific logger
-logger.sqlite = {
-  debug: (message: string, ...args: unknown[]) => {
-    logger.debug(`[SQLite] ${message}`, ...args);
-  },
-  info: (message: string, ...args: unknown[]) => {
-    logger.info(`[SQLite] ${message}`, ...args);
-  },
-  warn: (message: string, ...args: unknown[]) => {
-    logger.warn(`[SQLite] ${message}`, ...args);
-  },
-  error: (message: string, ...args: unknown[]) => {
-    logger.error(`[SQLite] ${message}`, ...args);
-  }
-};
-
-// Add migration specific logger with debug filtering
-logger.migration = {
-  debug: (message: string, ...args: unknown[]) => {
-    if (process.env.DEBUG_MIGRATIONS) {
-      //logger.debug(`[Migration] ${message}`, ...args);
-    }
-  },
-  info: (message: string, ...args: unknown[]) => {
-    // Always log to file, but only log to console if DEBUG_MIGRATIONS is set
-    if (process.env.DEBUG_MIGRATIONS) {
-      //logger.info(`[Migration] ${message}`, ...args);
-    } else {
-      // Use a separate transport for migration logs to file only
-      const metadata = args[0] as Record<string, unknown>;
-      logger.write({
-        level: 'info',
-        message: `[Migration] ${message}`,
-        ...(metadata || {})
-      });
-    }
-  },
-  warn: (message: string, ...args: unknown[]) => {
-    // Always log warnings to both console and file
-    //logger.warn(`[Migration] ${message}`, ...args);
-  },
-  error: (message: string, ...args: unknown[]) => {
-    // Always log errors to both console and file
-    //logger.error(`[Migration] ${message}`, ...args);
-  }
-};
-
-// Add renderer log handler
-ipcMain.on('renderer-log', (_event, { level, args, source, operation, error }) => {
-  const message = args.map((arg: unknown) => 
-    typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)
-  ).join(' ');
-
-  const meta = {
-    source: source || 'renderer',
-    ...(operation && { operation }),
-    ...(error && { error })
-  };
-
-  switch (level) {
-    case 'error':
-      logger.error(message, meta);
-      break;
-    case 'warn':
-      logger.warn(message, meta);
-      break;
-    case 'info':
-      logger.info(message, meta);
-      break;
-    case 'debug':
-      logger.debug(message, meta);
-      break;
-    default:
-      logger.log(level, message, meta);
-  }
-});
-
-// Export logger instance
-export { logger };
-
-// Export a function to get the logs directory
-export const getLogsDirectory = () => logsDir; 

electron/src/rt/sqlite-error.ts

@@ -1,14 +0,0 @@
-/**
- * Custom error class for SQLite operations
- * Provides additional context and error tracking for SQLite operations
- */
-export class SQLiteError extends Error {
-  constructor(
-    message: string,
-    public operation: string,
-    public cause?: unknown
-  ) {
-    super(message);
-    this.name = 'SQLiteError';
-  }
-}

electron/src/setup.ts

@@ -1,442 +0,0 @@
-import type { CapacitorElectronConfig } from '@capacitor-community/electron';
-import {
-  CapElectronEventEmitter,
-  CapacitorSplashScreen,
-  setupCapacitorElectronPlugins,
-} from '@capacitor-community/electron';
-import chokidar from 'chokidar';
-import type { MenuItemConstructorOptions } from 'electron';
-import { app, BrowserWindow, Menu, MenuItem, nativeImage, Tray, session } from 'electron';
-import electronIsDev from 'electron-is-dev';
-import electronServe from 'electron-serve';
-import windowStateKeeper from 'electron-window-state';
-import { join } from 'path';
-
-/**
- * Reload watcher configuration and state management
- * Prevents infinite reload loops and implements rate limiting
- * Also prevents reloads during critical database operations
- * 
- * @author Matthew Raymer
- */
-const RELOAD_CONFIG = {
-  DEBOUNCE_MS: 1500,
-  COOLDOWN_MS: 5000,
-  MAX_RELOADS_PER_MINUTE: 10,
-  MAX_RELOADS_PER_SESSION: 100,
-  DATABASE_OPERATION_TIMEOUT_MS: 10000  // 10 second timeout for database operations
-};
-
-// Track database operation state
-let isDatabaseOperationInProgress = false;
-let lastDatabaseOperationTime = 0;
-
-/**
- * Checks if a database operation is in progress or recently completed
- * @returns {boolean} Whether a database operation is active
- */
-const isDatabaseOperationActive = (): boolean => {
-  const now = Date.now();
-  return isDatabaseOperationInProgress || 
-         (now - lastDatabaseOperationTime < RELOAD_CONFIG.DATABASE_OPERATION_TIMEOUT_MS);
-};
-
-/**
- * Marks the start of a database operation
- */
-export const startDatabaseOperation = (): void => {
-  isDatabaseOperationInProgress = true;
-  lastDatabaseOperationTime = Date.now();
-};
-
-/**
- * Marks the end of a database operation
- */
-export const endDatabaseOperation = (): void => {
-  isDatabaseOperationInProgress = false;
-  lastDatabaseOperationTime = Date.now();
-};
-
-const reloadWatcher = {
-  debouncer: null as NodeJS.Timeout | null,
-  ready: false,
-  watcher: null as chokidar.FSWatcher | null,
-  lastReloadTime: 0,
-  reloadCount: 0,
-  sessionReloadCount: 0,
-  resetTimeout: null as NodeJS.Timeout | null,
-  isReloading: false
-};
-
-/**
- * Resets the reload counter after one minute
- */
-const resetReloadCounter = () => {
-  reloadWatcher.reloadCount = 0;
-  reloadWatcher.resetTimeout = null;
-};
-
-/**
- * Checks if a reload is allowed based on rate limits, cooldown, and database state
- * @returns {boolean} Whether a reload is allowed
- */
-const canReload = (): boolean => {
-  const now = Date.now();
-  
-  // Check if database operation is active
-  if (isDatabaseOperationActive()) {
-    console.warn('[Reload Watcher] Skipping reload - database operation in progress');
-    return false;
-  }
-  
-  // Check cooldown period
-  if (now - reloadWatcher.lastReloadTime < RELOAD_CONFIG.COOLDOWN_MS) {
-    console.warn('[Reload Watcher] Skipping reload - cooldown period active');
-    return false;
-  }
-  
-  // Check per-minute limit
-  if (reloadWatcher.reloadCount >= RELOAD_CONFIG.MAX_RELOADS_PER_MINUTE) {
-    console.warn('[Reload Watcher] Skipping reload - maximum reloads per minute reached');
-    return false;
-  }
-  
-  // Check session limit
-  if (reloadWatcher.sessionReloadCount >= RELOAD_CONFIG.MAX_RELOADS_PER_SESSION) {
-    console.error('[Reload Watcher] Maximum reloads per session reached. Please restart the application.');
-    return false;
-  }
-  
-  return true;
-};
-
-/**
- * Cleans up the current watcher instance
- */
-const cleanupWatcher = () => {
-  if (reloadWatcher.watcher) {
-    reloadWatcher.watcher.close();
-    reloadWatcher.watcher = null;
-  }
-  if (reloadWatcher.debouncer) {
-    clearTimeout(reloadWatcher.debouncer);
-    reloadWatcher.debouncer = null;
-  }
-  if (reloadWatcher.resetTimeout) {
-    clearTimeout(reloadWatcher.resetTimeout);
-    reloadWatcher.resetTimeout = null;
-  }
-};
-
-/**
- * Sets up the file watcher for development mode reloading
- * Implements rate limiting and prevents infinite reload loops
- * 
- * @param electronCapacitorApp - The Electron Capacitor app instance
- */
-export function setupReloadWatcher(electronCapacitorApp: ElectronCapacitorApp): void {
-  // Cleanup any existing watcher
-  cleanupWatcher();
-  
-  // Reset state
-  reloadWatcher.ready = false;
-  reloadWatcher.isReloading = false;
-  
-  reloadWatcher.watcher = chokidar
-    .watch(join(app.getAppPath(), 'app'), {
-      ignored: /[/\\]\./,
-      persistent: true,
-      awaitWriteFinish: {
-        stabilityThreshold: 1000,
-        pollInterval: 100
-      }
-    })
-    .on('ready', () => {
-      reloadWatcher.ready = true;
-      console.log('[Reload Watcher] Ready to watch for changes');
-    })
-    .on('all', (_event, _path) => {
-      if (!reloadWatcher.ready || reloadWatcher.isReloading) {
-        return;
-      }
-      
-      // Clear existing debouncer
-      if (reloadWatcher.debouncer) {
-        clearTimeout(reloadWatcher.debouncer);
-      }
-      
-      // Set up new debouncer
-        reloadWatcher.debouncer = setTimeout(async () => {
-        if (!canReload()) {
-          return;
-        }
-        
-        try {
-          reloadWatcher.isReloading = true;
-          
-          // Update reload counters
-          reloadWatcher.lastReloadTime = Date.now();
-          reloadWatcher.reloadCount++;
-          reloadWatcher.sessionReloadCount++;
-          
-          // Set up reset timeout for per-minute counter
-          if (!reloadWatcher.resetTimeout) {
-            reloadWatcher.resetTimeout = setTimeout(resetReloadCounter, 60000);
-          }
-          
-          // Perform reload
-          console.log('[Reload Watcher] Reloading window...');
-          await electronCapacitorApp.getMainWindow().webContents.reload();
-          
-          // Reset state after reload
-          reloadWatcher.ready = false;
-          reloadWatcher.isReloading = false;
-          
-          // Re-setup watcher after successful reload
-          setupReloadWatcher(electronCapacitorApp);
-          
-        } catch (error) {
-          console.error('[Reload Watcher] Error during reload:', error);
-          reloadWatcher.isReloading = false;
-          reloadWatcher.ready = true;
-        }
-      }, RELOAD_CONFIG.DEBOUNCE_MS);
-    })
-    .on('error', (error) => {
-      console.error('[Reload Watcher] Error:', error);
-      cleanupWatcher();
-    });
-}
-
-// Define our class to manage our app.
-export class ElectronCapacitorApp {
-  private MainWindow: BrowserWindow | null = null;
-  private SplashScreen: CapacitorSplashScreen | null = null;
-  private TrayIcon: Tray | null = null;
-  private CapacitorFileConfig: CapacitorElectronConfig;
-  private TrayMenuTemplate: (MenuItem | MenuItemConstructorOptions)[] = [
-    new MenuItem({ label: 'Quit App', role: 'quit' }),
-  ];
-  private AppMenuBarMenuTemplate: (MenuItem | MenuItemConstructorOptions)[] = [
-    { role: process.platform === 'darwin' ? 'appMenu' : 'fileMenu' },
-    { role: 'viewMenu' },
-  ];
-  private mainWindowState;
-  private loadWebApp;
-  private customScheme: string;
-
-  constructor(
-    capacitorFileConfig: CapacitorElectronConfig,
-    trayMenuTemplate?: (MenuItemConstructorOptions | MenuItem)[],
-    appMenuBarMenuTemplate?: (MenuItemConstructorOptions | MenuItem)[]
-  ) {
-    this.CapacitorFileConfig = capacitorFileConfig;
-
-    this.customScheme = this.CapacitorFileConfig.electron?.customUrlScheme ?? 'capacitor-electron';
-
-    if (trayMenuTemplate) {
-      this.TrayMenuTemplate = trayMenuTemplate;
-    }
-
-    if (appMenuBarMenuTemplate) {
-      this.AppMenuBarMenuTemplate = appMenuBarMenuTemplate;
-    }
-
-    // Setup our web app loader, this lets us load apps like react, vue, and angular without changing their build chains.
-    this.loadWebApp = electronServe({
-      directory: join(app.getAppPath(), 'app'),
-      scheme: this.customScheme,
-    });
-  }
-
-  // Helper function to load in the app.
-  private async loadMainWindow(thisRef: any) {
-    await thisRef.loadWebApp(thisRef.MainWindow);
-  }
-
-  // Expose the mainWindow ref for use outside of the class.
-  getMainWindow(): BrowserWindow {
-    return this.MainWindow;
-  }
-
-  getCustomURLScheme(): string {
-    return this.customScheme;
-  }
-
-  async init(): Promise<void> {
-    const icon = nativeImage.createFromPath(
-      join(app.getAppPath(), 'assets', process.platform === 'win32' ? 'appIcon.ico' : 'appIcon.png')
-    );
-    this.mainWindowState = windowStateKeeper({
-      defaultWidth: 1000,
-      defaultHeight: 800,
-    });
-
-    // Setup preload script path based on environment
-    const preloadPath = app.isPackaged
-      ? join(process.resourcesPath, 'preload.js')
-      : join(__dirname, 'preload.js');
-
-    console.log('[Electron Main Process] Preload path:', preloadPath);
-    console.log('[Electron Main Process] Preload exists:', require('fs').existsSync(preloadPath));
-
-    this.MainWindow = new BrowserWindow({
-      icon,
-      show: false,
-      x: this.mainWindowState.x,
-      y: this.mainWindowState.y,
-      width: this.mainWindowState.width,
-      height: this.mainWindowState.height,
-      webPreferences: {
-        nodeIntegration: false,
-        contextIsolation: true,
-        sandbox: false,
-        preload: preloadPath,
-        webSecurity: true,
-        allowRunningInsecureContent: false,
-      },
-    });
-    this.mainWindowState.manage(this.MainWindow);
-
-    if (this.CapacitorFileConfig.backgroundColor) {
-      this.MainWindow.setBackgroundColor(this.CapacitorFileConfig.electron.backgroundColor);
-    }
-
-    // If we close the main window with the splashscreen enabled we need to destory the ref.
-    this.MainWindow.on('closed', () => {
-      if (this.SplashScreen?.getSplashWindow() && !this.SplashScreen.getSplashWindow().isDestroyed()) {
-        this.SplashScreen.getSplashWindow().close();
-      }
-    });
-
-    // When the tray icon is enabled, setup the options.
-    if (this.CapacitorFileConfig.electron?.trayIconAndMenuEnabled) {
-      this.TrayIcon = new Tray(icon);
-      this.TrayIcon.on('double-click', () => {
-        if (this.MainWindow) {
-          if (this.MainWindow.isVisible()) {
-            this.MainWindow.hide();
-          } else {
-            this.MainWindow.show();
-            this.MainWindow.focus();
-          }
-        }
-      });
-      this.TrayIcon.on('click', () => {
-        if (this.MainWindow) {
-          if (this.MainWindow.isVisible()) {
-            this.MainWindow.hide();
-          } else {
-            this.MainWindow.show();
-            this.MainWindow.focus();
-          }
-        }
-      });
-      this.TrayIcon.setToolTip(app.getName());
-      this.TrayIcon.setContextMenu(Menu.buildFromTemplate(this.TrayMenuTemplate));
-    }
-
-    // Setup the main manu bar at the top of our window.
-    Menu.setApplicationMenu(Menu.buildFromTemplate(this.AppMenuBarMenuTemplate));
-
-    // If the splashscreen is enabled, show it first while the main window loads then switch it out for the main window, or just load the main window from the start.
-    if (this.CapacitorFileConfig.electron?.splashScreenEnabled) {
-      this.SplashScreen = new CapacitorSplashScreen({
-        imageFilePath: join(
-          app.getAppPath(),
-          'assets',
-          this.CapacitorFileConfig.electron?.splashScreenImageName ?? 'splash.png'
-        ),
-        windowWidth: 400,
-        windowHeight: 400,
-      });
-      this.SplashScreen.init(this.loadMainWindow, this);
-    } else {
-      this.loadMainWindow(this);
-    }
-
-    // Security
-    this.MainWindow.webContents.setWindowOpenHandler((details) => {
-      if (!details.url.includes(this.customScheme)) {
-        return { action: 'deny' };
-      } else {
-        return { action: 'allow' };
-      }
-    });
-    this.MainWindow.webContents.on('will-navigate', (event, _newURL) => {
-      if (!this.MainWindow.webContents.getURL().includes(this.customScheme)) {
-        event.preventDefault();
-      }
-    });
-
-    // Link electron plugins into the system.
-    setupCapacitorElectronPlugins();
-
-    // When the web app is loaded we hide the splashscreen if needed and show the mainwindow.
-    this.MainWindow.webContents.on('dom-ready', () => {
-      if (this.CapacitorFileConfig.electron?.splashScreenEnabled) {
-        this.SplashScreen.getSplashWindow().hide();
-      }
-      if (!this.CapacitorFileConfig.electron?.hideMainWindowOnLaunch) {
-        this.MainWindow.show();
-      }
-      
-      // Re-register SQLite handlers after reload
-      if (electronIsDev) {
-        console.log('[Electron Main Process] Re-registering SQLite handlers after reload');
-        const { setupSQLiteHandlers } = require('./rt/sqlite-init');
-        setupSQLiteHandlers();
-      }
-      
-      setTimeout(() => {
-        if (electronIsDev) {
-          this.MainWindow.webContents.openDevTools();
-        }
-        CapElectronEventEmitter.emit('CAPELECTRON_DeeplinkListenerInitialized', '');
-      }, 400);
-    });
-  }
-}
-
-// Set a CSP up for our application based on the custom scheme
-export function setupContentSecurityPolicy(customScheme: string): void {
-  session.defaultSession.webRequest.onHeadersReceived((details, callback) => {
-    callback({
-      responseHeaders: {
-        ...details.responseHeaders,
-        'Content-Security-Policy': [
-          // Base CSP for both dev and prod
-          `default-src ${customScheme}://*;`,
-          // Script sources
-          `script-src ${customScheme}://* 'self' 'unsafe-inline'${electronIsDev ? " 'unsafe-eval'" : ''};`,
-          // Style sources
-          `style-src ${customScheme}://* 'self' 'unsafe-inline' https://fonts.googleapis.com;`,
-          // Font sources
-          `font-src ${customScheme}://* 'self' https://fonts.gstatic.com;`,
-          // Image sources
-          `img-src ${customScheme}://* 'self' data: https:;`,
-          // Connect sources (for API calls)
-          `connect-src ${customScheme}://* 'self' https:;`,
-          // Worker sources
-          `worker-src ${customScheme}://* 'self' blob:;`,
-          // Frame sources
-          `frame-src ${customScheme}://* 'self';`,
-          // Media sources
-          `media-src ${customScheme}://* 'self' data:;`,
-          // Object sources
-          `object-src 'none';`,
-          // Base URI
-          `base-uri 'self';`,
-          // Form action
-          `form-action ${customScheme}://* 'self';`,
-          // Frame ancestors
-          `frame-ancestors 'none';`,
-          // Upgrade insecure requests
-          'upgrade-insecure-requests;',
-          // Block mixed content
-          'block-all-mixed-content;'
-        ].join(' ')
-      },
-    });
-  });
-}

electron/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compileOnSave": true,
-  "include": ["./src/**/*", "./capacitor.config.ts", "./capacitor.config.js"],
-  "compilerOptions": {
-    "outDir": "./build",
-    "importHelpers": true,
-    "target": "ES2020",
-    "module": "CommonJS",
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "typeRoots": ["./node_modules/@types"],
-    "allowJs": true,
-    "rootDir": ".",
-    "skipLibCheck": true,
-    "resolveJsonModule": true
-  }
-}
- 

experiment.sh

@@ -1,155 +0,0 @@
-#!/bin/bash
-# experiment.sh
-# Author: Matthew Raymer
-# Description: Build script for TimeSafari Electron application
-# This script handles the complete build process for the TimeSafari Electron app,
-# including web asset compilation and Capacitor sync.
-#
-# Build Process:
-# 1. Environment setup and dependency checks
-# 2. Web asset compilation (Vite)
-# 3. Capacitor sync
-# 4. Electron start
-#
-# Dependencies:
-# - Node.js and npm
-# - TypeScript
-# - Vite
-# - @capacitor-community/electron
-#
-# Usage: ./experiment.sh
-#
-# Exit Codes:
-# 1 - Required command not found
-# 2 - TypeScript installation failed
-# 3 - Build process failed
-# 4 - Capacitor sync failed
-# 5 - Electron start failed
-
-# Exit on any error
-set -e
-
-# ANSI color codes for better output formatting
-readonly RED='\033[0;31m'
-readonly GREEN='\033[0;32m'
-readonly YELLOW='\033[1;33m'
-readonly BLUE='\033[0;34m'
-readonly NC='\033[0m' # No Color
-
-# Logging functions
-log_info() {
-    echo -e "${BLUE}[$(date '+%Y-%m-%d %H:%M:%S')] [INFO]${NC} $1"
-}
-
-log_success() {
-    echo -e "${GREEN}[$(date '+%Y-%m-%d %H:%M:%S')] [SUCCESS]${NC} $1"
-}
-
-log_warn() {
-    echo -e "${YELLOW}[$(date '+%Y-%m-%d %H:%M:%S')] [WARN]${NC} $1"
-}
-
-log_error() {
-    echo -e "${RED}[$(date '+%Y-%m-%d %H:%M:%S')] [ERROR]${NC} $1"
-}
-
-# Function to check if a command exists
-check_command() {
-    if ! command -v "$1" &> /dev/null; then
-        log_error "$1 is required but not installed."
-        exit 1
-    fi
-    log_info "Found $1: $(command -v "$1")"
-}
-
-# Function to measure and log execution time
-measure_time() {
-    local start_time=$(date +%s)
-    "$@"
-    local end_time=$(date +%s)
-    local duration=$((end_time - start_time))
-    log_success "Completed in ${duration} seconds"
-}
-
-# Print build header
-echo -e "\n${BLUE}=== TimeSafari Electron Build Process ===${NC}\n"
-log_info "Starting build process at $(date)"
-
-# Check required commands
-log_info "Checking required dependencies..."
-check_command node
-check_command npm
-check_command git
-
-# Create application data directory
-log_info "Setting up application directories..."
-mkdir -p ~/.local/share/TimeSafari/timesafari
-
-# Clean up previous builds
-log_info "Cleaning previous builds..."
-rm -rf dist* || log_warn "No previous builds to clean"
-
-# Set environment variables for the build
-log_info "Configuring build environment..."
-export VITE_PLATFORM=electron
-export VITE_PWA_ENABLED=false
-export VITE_DISABLE_PWA=true
-export DEBUG_MIGRATIONS=0
-
-# Ensure TypeScript is installed
-log_info "Verifying TypeScript installation..."
-if [ ! -f "./node_modules/.bin/tsc" ]; then
-    log_info "Installing TypeScript..."
-    if ! npm install --save-dev typescript@~5.2.2; then
-        log_error "TypeScript installation failed!"
-        exit 2
-    fi
-    # Verify installation
-    if [ ! -f "./node_modules/.bin/tsc" ]; then
-        log_error "TypeScript installation verification failed!"
-        exit 2
-    fi
-    log_success "TypeScript installed successfully"
-else
-    log_info "TypeScript already installed"
-fi
-
-# Get git hash for versioning
-GIT_HASH=$(git log -1 --pretty=format:%h)
-log_info "Using git hash: ${GIT_HASH}"
-
-# Build web assets
-log_info "Building web assets with Vite..."
-if ! measure_time env VITE_GIT_HASH="$GIT_HASH" npx vite build --config vite.config.app.electron.mts --mode electron; then
-    log_error "Web asset build failed!"
-    exit 3
-fi
-
-# Sync with Capacitor
-log_info "Syncing with Capacitor..."
-if ! measure_time npx cap sync electron; then
-    log_error "Capacitor sync failed!"
-    exit 4
-fi
-
-# Restore capacitor config
-log_info "Restoring capacitor config..."
-if ! git checkout electron/capacitor.config.json; then
-    log_error "Failed to restore capacitor config!"
-    exit 4
-fi
-
-# Start Electron
-log_info "Starting Electron..."
-cd electron/
-if ! measure_time npm run electron:start; then
-    log_error "Electron start failed!"
-    exit 5
-fi
-
-# Print build summary
-log_success "Build and start completed successfully!"
-echo -e "\n${GREEN}=== End of Build Process ===${NC}\n"
-
-# Exit with success
-exit 0

ios/App/App/AppDelegate.swift

@@ -1,6 +1,5 @@
 import UIKit
 import Capacitor
-import CapacitorCommunitySqlite
 
 @UIApplicationMain
 class AppDelegate: UIResponder, UIApplicationDelegate {
@@ -8,10 +7,6 @@ class AppDelegate: UIResponder, UIApplicationDelegate {
     var window: UIWindow?
 
     func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
-        // Initialize SQLite
-        let sqlite = SQLite()
-        sqlite.initialize()
-        
         // Override point for customization after application launch.
         return true
     }

ios/App/Podfile

@@ -11,7 +11,6 @@ install! 'cocoapods', :disable_input_output_paths => true
 def capacitor_pods
   pod 'Capacitor', :path => '../../node_modules/@capacitor/ios'
   pod 'CapacitorCordova', :path => '../../node_modules/@capacitor/ios'
-  pod 'CapacitorCommunitySqlite', :path => '../../node_modules/@capacitor-community/sqlite'
   pod 'CapacitorMlkitBarcodeScanning', :path => '../../node_modules/@capacitor-mlkit/barcode-scanning'
   pod 'CapacitorApp', :path => '../../node_modules/@capacitor/app'
   pod 'CapacitorCamera', :path => '../../node_modules/@capacitor/camera'

package.json

@@ -11,7 +11,7 @@
     "build": "VITE_GIT_HASH=`git log -1 --pretty=format:%h` vite build --config vite.config.mts",
     "lint": "eslint --ext .js,.ts,.vue --ignore-path .gitignore src",
     "lint-fix": "eslint --ext .js,.ts,.vue --ignore-path .gitignore --fix src",
-    "prebuild": "eslint --ext .js,.ts,.vue --ignore-path .gitignore src && node sw_combine.cjs && node scripts/copy-wasm.cjs",
+    "prebuild": "eslint --ext .js,.ts,.vue --ignore-path .gitignore src && node sw_combine.js",
     "test:all": "npm run test:prerequisites && npm run build && npm run test:web && npm run test:mobile",
     "test:prerequisites": "node scripts/check-prerequisites.js",
     "test:web": "npx playwright test -c playwright.config-local.ts --trace on",
@@ -22,15 +22,14 @@
     "check:ios-device": "xcrun xctrace list devices 2>&1 | grep -w 'Booted' || (echo 'No iOS simulator running' && exit 1)",
     "clean:electron": "rimraf dist-electron",
     "build:pywebview": "vite build --config vite.config.pywebview.mts",
-    "build:web": "VITE_GIT_HASH=`git log -1 --pretty=format:%h` vite build --config vite.config.web.mts",
-    "build:web:electron": "VITE_GIT_HASH=`git log -1 --pretty=format:%h` vite build --config vite.config.web.mts && VITE_GIT_HASH=`git log -1 --pretty=format:%h` vite build --config vite.config.electron.mts --mode electron",
-    "build:electron": "npm run clean:electron && npm run build:web:electron && tsc -p tsconfig.electron.json && vite build --config vite.config.electron.mts && node scripts/build-electron.cjs",
+    "build:electron": "npm run clean:electron && tsc -p tsconfig.electron.json && vite build --config vite.config.electron.mts && node scripts/build-electron.js",
     "build:capacitor": "vite build --mode capacitor --config vite.config.capacitor.mts",
+    "build:web": "VITE_GIT_HASH=`git log -1 --pretty=format:%h` vite build --config vite.config.web.mts",
     "electron:dev": "npm run build && electron .",
     "electron:start": "electron .",
     "clean:android": "adb uninstall app.timesafari.app || true",
     "build:android": "npm run clean:android && rm -rf dist && npm run build:web && npm run build:capacitor && cd android && ./gradlew clean && ./gradlew assembleDebug && cd .. && npx cap sync android && npx capacitor-assets generate --android && npx cap open android",
-    "electron:build-linux": "electron-builder --linux AppImage",
+    "electron:build-linux": "npm run build:electron && electron-builder --linux AppImage",
     "electron:build-linux-deb": "npm run build:electron && electron-builder --linux deb",
     "electron:build-linux-prod": "NODE_ENV=production npm run build:electron && electron-builder --linux AppImage",
     "build:electron-prod": "NODE_ENV=production npm run build:electron",
@@ -47,7 +46,6 @@
     "electron:build-mac-universal": "npm run build:electron-prod && electron-builder --mac --universal"
   },
   "dependencies": {
-    "@capacitor-community/sqlite": "^6.0.2",
     "@capacitor-mlkit/barcode-scanning": "^6.0.0",
     "@capacitor/android": "^6.2.0",
     "@capacitor/app": "^6.0.0",
@@ -58,19 +56,18 @@
     "@capacitor/ios": "^6.2.0",
     "@capacitor/share": "^6.0.3",
     "@capawesome/capacitor-file-picker": "^6.2.0",
-    "@dicebear/collection": "^5.4.3",
-    "@dicebear/core": "^5.4.3",
+    "@dicebear/collection": "^5.4.1",
+    "@dicebear/core": "^5.4.1",
     "@ethersproject/hdnode": "^5.7.0",
     "@ethersproject/wallet": "^5.8.0",
     "@fortawesome/fontawesome-svg-core": "^6.5.1",
     "@fortawesome/free-solid-svg-icons": "^6.5.1",
     "@fortawesome/vue-fontawesome": "^3.0.6",
-    "@jlongster/sql.js": "^1.6.7",
     "@peculiar/asn1-ecc": "^2.3.8",
     "@peculiar/asn1-schema": "^2.3.8",
     "@pvermeer/dexie-encrypted-addon": "^3.0.0",
     "@simplewebauthn/browser": "^10.0.0",
-    "@simplewebauthn/server": "^10.0.1",
+    "@simplewebauthn/server": "^10.0.0",
     "@tweenjs/tween.js": "^21.1.1",
     "@types/qrcode": "^1.5.5",
     "@veramo/core": "^5.6.0",
@@ -84,10 +81,8 @@
     "@vue-leaflet/vue-leaflet": "^0.10.1",
     "@vueuse/core": "^12.3.0",
     "@zxing/text-encoding": "^0.9.0",
-    "absurd-sql": "^0.0.54",
     "asn1-ber": "^1.2.2",
     "axios": "^1.6.8",
-    "better-sqlite3-multiple-ciphers": "^11.10.0",
     "cbor-x": "^1.5.9",
     "class-transformer": "^0.5.1",
     "dexie": "^3.2.7",
@@ -95,23 +90,22 @@
     "did-jwt": "^7.4.7",
     "did-resolver": "^4.1.0",
     "dotenv": "^16.0.3",
-    "electron-json-storage": "^4.6.0",
-    "ethereum-cryptography": "^2.2.1",
+    "ethereum-cryptography": "^2.1.3",
     "ethereumjs-util": "^7.1.5",
-    "jdenticon": "^3.3.0",
+    "jdenticon": "^3.2.0",
     "js-generate-password": "^0.1.9",
     "js-yaml": "^4.1.0",
     "jsqr": "^1.4.0",
     "leaflet": "^1.9.4",
     "localstorage-slim": "^2.7.0",
-    "lru-cache": "^10.4.3",
+    "lru-cache": "^10.2.0",
     "luxon": "^3.4.4",
     "merkletreejs": "^0.3.11",
-    "nostr-tools": "^2.13.1",
+    "nostr-tools": "^2.10.4",
     "notiwind": "^2.0.2",
     "papaparse": "^5.4.1",
     "pina": "^0.20.2204228",
-    "pinia-plugin-persistedstate": "^3.2.3",
+    "pinia-plugin-persistedstate": "^3.2.1",
     "qr-code-generator-vue3": "^1.4.21",
     "qrcode": "^1.5.4",
     "ramda": "^0.29.1",
@@ -127,13 +121,12 @@
     "vue-axios": "^3.5.2",
     "vue-facing-decorator": "^3.0.4",
     "vue-picture-cropper": "^0.7.0",
-    "vue-qrcode-reader": "^5.7.2",
+    "vue-qrcode-reader": "^5.5.3",
     "vue-router": "^4.5.0",
-    "web-did-resolver": "^2.0.30",
+    "web-did-resolver": "^2.0.27",
     "zod": "^3.24.2"
   },
   "devDependencies": {
-    "@capacitor-community/electron": "^5.0.1",
     "@capacitor/assets": "^3.0.5",
     "@playwright/test": "^1.45.2",
     "@types/dom-webcodecs": "^0.1.7",
@@ -148,12 +141,10 @@
     "@types/ua-parser-js": "^0.7.39",
     "@typescript-eslint/eslint-plugin": "^6.21.0",
     "@typescript-eslint/parser": "^6.21.0",
-    "@vitejs/plugin-vue": "^5.2.4",
+    "@vitejs/plugin-vue": "^5.2.1",
     "@vue/eslint-config-typescript": "^11.0.3",
     "autoprefixer": "^10.4.19",
-    "browserify-fs": "^1.0.0",
     "concurrently": "^8.2.2",
-    "crypto-browserify": "^3.12.1",
     "electron": "^33.2.1",
     "electron-builder": "^25.1.8",
     "eslint": "^8.57.0",
@@ -164,17 +155,15 @@
     "markdownlint": "^0.37.4",
     "markdownlint-cli": "^0.44.0",
     "npm-check-updates": "^17.1.13",
-    "path-browserify": "^1.0.1",
     "postcss": "^8.4.38",
     "prettier": "^3.2.5",
     "rimraf": "^6.0.1",
-    "source-map-support": "^0.5.21",
     "tailwindcss": "^3.4.1",
     "typescript": "~5.2.2",
     "vite": "^5.2.0",
-    "vite-plugin-pwa": "^1.0.0"
+    "vite-plugin-pwa": "^0.19.8"
   },
-  "main": "./dist-electron/main.mjs",
+  "main": "./dist-electron/main.js",
   "build": {
     "appId": "app.timesafari",
     "productName": "TimeSafari",
@@ -183,17 +172,12 @@
     },
     "files": [
       "dist-electron/**/*",
-      "dist/**/*",
-      "capacitor.config.json"
+      "dist/**/*"
     ],
     "extraResources": [
       {
-        "from": "dist-electron/www",
+        "from": "dist",
         "to": "www"
-      },
-      {
-        "from": "dist-electron/resources/preload.js",
-        "to": "preload.js"
       }
     ],
     "linux": {
@@ -231,6 +215,5 @@
         }
       ]
     }
-  },
-  "type": "module"
+  }
 }

requirements.txt

@@ -1,6 +1,5 @@
 eth_keys
 pywebview
 pyinstaller>=6.12.0
-setuptools>=69.0.0  # Required for distutils for electron-builder on macOS
 # For development
 watchdog>=3.0.0  # For file watching support 

scripts/build-electron.cjs

@@ -1,96 +0,0 @@
-const fs = require("fs");
-const fse = require("fs-extra");
-const path = require("path");
-const { execSync } = require('child_process');
-
-console.log("Starting Electron build finalization...");
-
-// Define paths
-const distPath = path.join(__dirname, "..", "dist");
-const electronDistPath = path.join(__dirname, "..", "dist-electron");
-const wwwPath = path.join(electronDistPath, "www");
-const builtIndexPath = path.join(distPath, "index.html");
-const finalIndexPath = path.join(wwwPath, "index.html");
-
-// Ensure target directory exists
-if (!fs.existsSync(wwwPath)) {
-  fs.mkdirSync(wwwPath, { recursive: true });
-}
-
-// Copy assets directory
-const assetsSrc = path.join(distPath, "assets");
-const assetsDest = path.join(wwwPath, "assets");
-if (fs.existsSync(assetsSrc)) {
-  fse.copySync(assetsSrc, assetsDest, { overwrite: true });
-}
-
-// Copy favicon.ico
-const faviconSrc = path.join(distPath, "favicon.ico");
-if (fs.existsSync(faviconSrc)) {
-  fs.copyFileSync(faviconSrc, path.join(wwwPath, "favicon.ico"));
-}
-
-// Copy manifest.webmanifest
-const manifestSrc = path.join(distPath, "manifest.webmanifest");
-if (fs.existsSync(manifestSrc)) {
-  fs.copyFileSync(manifestSrc, path.join(wwwPath, "manifest.webmanifest"));
-}
-
-// Load and modify index.html from Vite output
-let indexContent = fs.readFileSync(builtIndexPath, "utf-8");
-
-// Inject the window.process shim after the first <script> block
-indexContent = indexContent.replace(
-  /<script[^>]*type="module"[^>]*>/,
-  match => `${match}\n  window.process = { env: { VITE_PLATFORM: 'electron' } };`
-);
-
-// Write the modified index.html to dist-electron/www
-fs.writeFileSync(finalIndexPath, indexContent);
-
-// Copy preload script to resources
-const preloadSrc = path.join(electronDistPath, "preload.mjs");
-const preloadDest = path.join(electronDistPath, "resources", "preload.js");
-
-// Ensure resources directory exists
-const resourcesDir = path.join(electronDistPath, "resources");
-if (!fs.existsSync(resourcesDir)) {
-  fs.mkdirSync(resourcesDir, { recursive: true });
-}
-
-if (fs.existsSync(preloadSrc)) {
-  // Read the preload script
-  let preloadContent = fs.readFileSync(preloadSrc, 'utf-8');
-  
-  // Convert ESM to CommonJS if needed
-  preloadContent = preloadContent
-    .replace(/import\s*{\s*([^}]+)\s*}\s*from\s*['"]electron['"];?/g, 'const { $1 } = require("electron");')
-    .replace(/export\s*{([^}]+)};?/g, '')
-    .replace(/export\s+default\s+([^;]+);?/g, 'module.exports = $1;');
-  
-  // Write the modified preload script
-  fs.writeFileSync(preloadDest, preloadContent);
-  console.log("Preload script copied and converted to resources directory");
-} else {
-  console.error("Preload script not found at:", preloadSrc);
-  process.exit(1);
-}
-
-// Copy capacitor.config.json to dist-electron
-try {
-  console.log("Copying capacitor.config.json to dist-electron...");
-  const configPath = path.join(process.cwd(), 'capacitor.config.json');
-  const targetPath = path.join(process.cwd(), 'dist-electron', 'capacitor.config.json');
-  
-  if (!fs.existsSync(configPath)) {
-    throw new Error('capacitor.config.json not found in project root');
-  }
-  
-  fs.copyFileSync(configPath, targetPath);
-  console.log("Successfully copied capacitor.config.json");
-} catch (error) {
-  console.error("Failed to copy capacitor.config.json:", error);
-  throw error;
-}
-
-console.log("Electron index.html copied and patched for Electron context.");

scripts/build-electron.js

@@ -0,0 +1,243 @@
+const fs = require('fs');
+const path = require('path');
+
+    console.log('Starting electron build process...');
+
+    // Copy web files
+const webDistPath = path.join(__dirname, '..', 'dist');
+const electronDistPath = path.join(__dirname, '..', 'dist-electron');
+const wwwPath = path.join(electronDistPath, 'www');
+
+// Create www directory if it doesn't exist
+if (!fs.existsSync(wwwPath)) {
+  fs.mkdirSync(wwwPath, { recursive: true });
+}
+
+// Copy web files to www directory
+fs.cpSync(webDistPath, wwwPath, { recursive: true });
+
+// Fix asset paths in index.html
+const indexPath = path.join(wwwPath, 'index.html');
+let indexContent = fs.readFileSync(indexPath, 'utf8');
+
+// Fix asset paths
+    indexContent = indexContent
+  .replace(/\/assets\//g, './assets/')
+  .replace(/href="\//g, 'href="./')
+  .replace(/src="\//g, 'src="./');
+
+fs.writeFileSync(indexPath, indexContent);
+
+// Check for remaining /assets/ paths
+    console.log('After path fixing, checking for remaining /assets/ paths:', indexContent.includes('/assets/'));
+console.log('Sample of fixed content:', indexContent.substring(0, 500));
+    
+console.log('Copied and fixed web files in:', wwwPath);
+
+    // Copy main process files
+    console.log('Copying main process files...');
+
+// Create the main process file with inlined logger
+const mainContent = `const { app, BrowserWindow } = require("electron");
+const path = require("path");
+const fs = require("fs");
+
+// Inline logger implementation
+const logger = {
+  log: (...args) => console.log(...args),
+  error: (...args) => console.error(...args),
+  info: (...args) => console.info(...args),
+  warn: (...args) => console.warn(...args),
+  debug: (...args) => console.debug(...args),
+};
+
+// Check if running in dev mode
+const isDev = process.argv.includes("--inspect");
+
+function createWindow() {
+  // Add before createWindow function
+  const preloadPath = path.join(__dirname, "preload.js");
+  logger.log("Checking preload path:", preloadPath);
+  logger.log("Preload exists:", fs.existsSync(preloadPath));
+
+  // Create the browser window.
+  const mainWindow = new BrowserWindow({
+    width: 1200,
+    height: 800,
+    webPreferences: {
+      nodeIntegration: false,
+      contextIsolation: true,
+      webSecurity: true,
+      allowRunningInsecureContent: false,
+      preload: path.join(__dirname, "preload.js"),
+    },
+  });
+
+  // Always open DevTools for now
+  mainWindow.webContents.openDevTools();
+
+  // Intercept requests to fix asset paths
+  mainWindow.webContents.session.webRequest.onBeforeRequest(
+    {
+      urls: [
+        "file://*/*/assets/*",
+        "file://*/assets/*",
+        "file:///assets/*", // Catch absolute paths
+        "<all_urls>", // Catch all URLs as a fallback
+      ],
+    },
+    (details, callback) => {
+      let url = details.url;
+
+      // Handle paths that don't start with file://
+      if (!url.startsWith("file://") && url.includes("/assets/")) {
+        url = \`file://\${path.join(__dirname, "www", url)}\`;
+      }
+
+      // Handle absolute paths starting with /assets/
+      if (url.includes("/assets/") && !url.includes("/www/assets/")) {
+        const baseDir = url.includes("dist-electron")
+          ? url.substring(
+              0,
+              url.indexOf("/dist-electron") + "/dist-electron".length,
+            )
+          : \`file://\${__dirname}\`;
+        const assetPath = url.split("/assets/")[1];
+        const newUrl = \`\${baseDir}/www/assets/\${assetPath}\`;
+        callback({ redirectURL: newUrl });
+        return;
+      }
+
+      callback({}); // No redirect for other URLs
+    },
+  );
+
+  if (isDev) {
+    // Debug info
+    logger.log("Debug Info:");
+    logger.log("Running in dev mode:", isDev);
+    logger.log("App is packaged:", app.isPackaged);
+    logger.log("Process resource path:", process.resourcesPath);
+    logger.log("App path:", app.getAppPath());
+    logger.log("__dirname:", __dirname);
+    logger.log("process.cwd():", process.cwd());
+  }
+
+  const indexPath = path.join(__dirname, "www", "index.html");
+
+  if (isDev) {
+    logger.log("Loading index from:", indexPath);
+    logger.log("www path:", path.join(__dirname, "www"));
+    logger.log("www assets path:", path.join(__dirname, "www", "assets"));
+  }
+
+  if (!fs.existsSync(indexPath)) {
+    logger.error(\`Index file not found at: \${indexPath}\`);
+    throw new Error("Index file not found");
+  }
+
+  // Add CSP headers to allow API connections, Google Fonts, and zxing-wasm
+  mainWindow.webContents.session.webRequest.onHeadersReceived(
+    (details, callback) => {
+      callback({
+        responseHeaders: {
+          ...details.responseHeaders,
+          "Content-Security-Policy": [
+            "default-src 'self';" +
+            "connect-src 'self' https://api.endorser.ch https://*.timesafari.app https://*.jsdelivr.net;" +
+            "img-src 'self' data: https: blob:;" +
+            "script-src 'self' 'unsafe-inline' 'unsafe-eval' https://*.jsdelivr.net;" +
+            "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com;" +
+            "font-src 'self' data: https://fonts.gstatic.com;" +
+            "style-src-elem 'self' 'unsafe-inline' https://fonts.googleapis.com;" +
+            "worker-src 'self' blob:;",
+          ],
+        },
+      });
+    },
+  );
+
+  // Load the index.html
+  mainWindow
+    .loadFile(indexPath)
+    .then(() => {
+      logger.log("Successfully loaded index.html");
+      if (isDev) {
+        mainWindow.webContents.openDevTools();
+        logger.log("DevTools opened - running in dev mode");
+      }
+    })
+    .catch((err) => {
+      logger.error("Failed to load index.html:", err);
+      logger.error("Attempted path:", indexPath);
+    });
+
+  // Listen for console messages from the renderer
+  mainWindow.webContents.on("console-message", (_event, _level, message) => {
+    logger.log("Renderer Console:", message);
+  });
+
+  // Add right after creating the BrowserWindow
+  mainWindow.webContents.on(
+    "did-fail-load",
+    (_event, errorCode, errorDescription) => {
+      logger.error("Page failed to load:", errorCode, errorDescription);
+    },
+  );
+
+  mainWindow.webContents.on("preload-error", (_event, preloadPath, error) => {
+    logger.error("Preload script error:", preloadPath, error);
+  });
+
+  mainWindow.webContents.on(
+    "console-message",
+    (_event, _level, message, line, sourceId) => {
+      logger.log("Renderer Console:", line, sourceId, message);
+    },
+  );
+
+  // Enable remote debugging when in dev mode
+  if (isDev) {
+    mainWindow.webContents.openDevTools();
+    }
+}
+
+// Handle app ready
+app.whenReady().then(createWindow);
+
+// Handle all windows closed
+app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
+    app.quit();
+  }
+});
+
+app.on("activate", () => {
+  if (BrowserWindow.getAllWindows().length === 0) {
+    createWindow();
+  }
+});
+
+// Handle any errors
+process.on("uncaughtException", (error) => {
+  logger.error("Uncaught Exception:", error);
+});
+`;
+
+// Write the main process file
+const mainDest = path.join(electronDistPath, 'main.js');
+fs.writeFileSync(mainDest, mainContent);
+
+// Copy preload script if it exists
+const preloadSrc = path.join(__dirname, '..', 'src', 'electron', 'preload.js');
+const preloadDest = path.join(electronDistPath, 'preload.js');
+if (fs.existsSync(preloadSrc)) {
+  console.log(`Copying ${preloadSrc} to ${preloadDest}`);
+  fs.copyFileSync(preloadSrc, preloadDest);
+}
+
+// Verify build structure
+console.log('\nVerifying build structure:');
+console.log('Files in dist-electron:', fs.readdirSync(electronDistPath));
+
+console.log('Build completed successfully!'); 

scripts/copy-wasm.cjs

@@ -1,15 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-// Create public/wasm directory if it doesn't exist
-const wasmDir = path.join(__dirname, '../public/wasm');
-if (!fs.existsSync(wasmDir)) {
-  fs.mkdirSync(wasmDir, { recursive: true });
-}
-
-// Copy the WASM file from node_modules to public/wasm
-const sourceFile = path.join(__dirname, '../node_modules/@jlongster/sql.js/dist/sql-wasm.wasm');
-const targetFile = path.join(wasmDir, 'sql-wasm.wasm');
-
-fs.copyFileSync(sourceFile, targetFile);
-console.log('WASM file copied successfully!'); 

src/App.vue

@@ -330,11 +330,8 @@
 
 <script lang="ts">
 import { Vue, Component } from "vue-facing-decorator";
-
-import { NotificationIface, USE_DEXIE_DB } from "./constants/app";
-import * as databaseUtil from "./db/databaseUtil";
-import { retrieveSettingsForActiveAccount } from "./db/index";
-import { logConsoleAndDb } from "./db/databaseUtil";
+import { logConsoleAndDb, retrieveSettingsForActiveAccount } from "./db/index";
+import { NotificationIface } from "./constants/app";
 import { logger } from "./utils/logger";
 
 interface Settings {
@@ -399,11 +396,7 @@ export default class App extends Vue {
 
     try {
       logger.log("Retrieving settings for the active account...");
-      let settings: Settings =
-        await databaseUtil.retrieveSettingsForActiveAccount();
-      if (USE_DEXIE_DB) {
-        settings = await retrieveSettingsForActiveAccount();
-      }
+      const settings: Settings = await retrieveSettingsForActiveAccount();
       logger.log("Retrieved settings:", settings);
 
       const notifyingNewActivity = !!settings?.notifyingNewActivityTime;
@@ -459,10 +452,9 @@ export default class App extends Vue {
         return true;
       }
 
-      const serverSubscription =
-        typeof subscription === "object" && subscription !== null
-          ? { ...subscription }
-          : {};
+      const serverSubscription = {
+        ...subscription,
+      };
       if (!allGoingOff) {
         serverSubscription["notifyType"] = notification.title;
         logger.log(

src/components/DataExportSection.vue

@@ -62,7 +62,7 @@ backup and database export, with platform-specific download instructions. * *
 
 <script lang="ts">
 import { Component, Prop, Vue } from "vue-facing-decorator";
-import { AppString, NotificationIface, USE_DEXIE_DB } from "../constants/app";
+import { NotificationIface } from "../constants/app";
 import { db } from "../db/index";
 import { logger } from "../utils/logger";
 import { PlatformServiceFactory } from "../services/PlatformServiceFactory";
@@ -131,15 +131,12 @@ export default class DataExportSection extends Vue {
    */
   public async exportDatabase() {
     try {
-      if (!USE_DEXIE_DB) {
-        throw new Error("Not implemented");
-      }
       const blob = await db.export({
         prettyJson: true,
         transform: (table, value, key) => {
           if (table === "contacts") {
             // Dexie inserts a number 0 when some are undefined, so we need to totally remove them.
-            Object.keys(value).forEach((prop) => {
+            Object.keys(value).forEach(prop => {
               if (value[prop] === undefined) {
                 delete value[prop];
               }
@@ -148,7 +145,7 @@ export default class DataExportSection extends Vue {
           return { value, key };
         },
       });
-      const fileName = `${AppString.APP_NAME_NO_SPACES}-backup.json`;
+      const fileName = `${db.name}-backup.json`;
 
       if (this.platformCapabilities.hasFileDownload) {
         // Web platform: Use download link
@@ -162,8 +159,6 @@ export default class DataExportSection extends Vue {
         // Native platform: Write to app directory
         const content = await blob.text();
         await this.platformService.writeAndShareFile(fileName, content);
-      } else {
-        throw new Error("This platform does not support file downloads.");
       }
 
       this.$notify(

src/components/FeedFilters.vue

@@ -99,12 +99,8 @@ import {
   LTileLayer,
 } from "@vue-leaflet/vue-leaflet";
 import { Router } from "vue-router";
-
-import { USE_DEXIE_DB } from "@/constants/app";
-import * as databaseUtil from "../db/databaseUtil";
 import { MASTER_SETTINGS_KEY } from "../db/tables/settings";
 import { db, retrieveSettingsForActiveAccount } from "../db/index";
-import { PlatformServiceFactory } from "@/services/PlatformServiceFactory";
 
 @Component({
   components: {
@@ -126,10 +122,7 @@ export default class FeedFilters extends Vue {
   async open(onCloseIfChanged: () => void) {
     this.onCloseIfChanged = onCloseIfChanged;
 
-    let settings = await databaseUtil.retrieveSettingsForActiveAccount();
-    if (USE_DEXIE_DB) {
-      settings = await retrieveSettingsForActiveAccount();
-    }
+    const settings = await retrieveSettingsForActiveAccount();
     this.hasVisibleDid = !!settings.filterFeedByVisible;
     this.isNearby = !!settings.filterFeedByNearby;
     if (settings.searchBoxes && settings.searchBoxes.length > 0) {
@@ -151,17 +144,9 @@ export default class FeedFilters extends Vue {
   async toggleNearby() {
     this.settingChanged = true;
     this.isNearby = !this.isNearby;
-    const platformService = PlatformServiceFactory.getInstance();
-    await platformService.dbExec(
-      `UPDATE settings SET filterFeedByNearby = ? WHERE id = ?`,
-      [this.isNearby, MASTER_SETTINGS_KEY],
-    );
-
-    if (USE_DEXIE_DB) {
-      await db.settings.update(MASTER_SETTINGS_KEY, {
-        filterFeedByNearby: this.isNearby,
-      });
-    }
+    await db.settings.update(MASTER_SETTINGS_KEY, {
+      filterFeedByNearby: this.isNearby,
+    });
   }
 
   async clearAll() {
@@ -169,18 +154,10 @@ export default class FeedFilters extends Vue {
       this.settingChanged = true;
     }
 
-    const platformService = PlatformServiceFactory.getInstance();
-    await platformService.dbExec(
-      `UPDATE settings SET filterFeedByNearby = ? AND filterFeedByVisible = ? WHERE id = ?`,
-      [false, false, MASTER_SETTINGS_KEY],
-    );
-
-    if (USE_DEXIE_DB) {
-      await db.settings.update(MASTER_SETTINGS_KEY, {
-        filterFeedByNearby: false,
-        filterFeedByVisible: false,
-      });
-    }
+    await db.settings.update(MASTER_SETTINGS_KEY, {
+      filterFeedByNearby: false,
+      filterFeedByVisible: false,
+    });
 
     this.hasVisibleDid = false;
     this.isNearby = false;
@@ -191,18 +168,10 @@ export default class FeedFilters extends Vue {
       this.settingChanged = true;
     }
 
-    const platformService = PlatformServiceFactory.getInstance();
-    await platformService.dbExec(
-      `UPDATE settings SET filterFeedByNearby = ? AND filterFeedByVisible = ? WHERE id = ?`,
-      [true, true, MASTER_SETTINGS_KEY],
-    );
-
-    if (USE_DEXIE_DB) {
-      await db.settings.update(MASTER_SETTINGS_KEY, {
-        filterFeedByNearby: true,
-        filterFeedByVisible: true,
-      });
-    }
+    await db.settings.update(MASTER_SETTINGS_KEY, {
+      filterFeedByNearby: true,
+      filterFeedByVisible: true,
+    });
 
     this.hasVisibleDid = true;
     this.isNearby = true;

src/components/GiftedDialog.vue

@@ -89,7 +89,7 @@
 <script lang="ts">
 import { Vue, Component, Prop } from "vue-facing-decorator";
 
-import { NotificationIface, USE_DEXIE_DB } from "../constants/app";
+import { NotificationIface } from "../constants/app";
 import {
   createAndSubmitGive,
   didInfo,
@@ -98,10 +98,8 @@ import {
 import * as libsUtil from "../libs/util";
 import { db, retrieveSettingsForActiveAccount } from "../db/index";
 import { Contact } from "../db/tables/contacts";
-import * as databaseUtil from "../db/databaseUtil";
 import { retrieveAccountDids } from "../libs/util";
 import { logger } from "../utils/logger";
-import { PlatformServiceFactory } from "@/services/PlatformServiceFactory";
 
 @Component
 export default class GiftedDialog extends Vue {
@@ -146,23 +144,11 @@ export default class GiftedDialog extends Vue {
     this.offerId = offerId || "";
 
     try {
-      let settings = await databaseUtil.retrieveSettingsForActiveAccount();
-      if (USE_DEXIE_DB) {
-        settings = await retrieveSettingsForActiveAccount();
-      }
+      const settings = await retrieveSettingsForActiveAccount();
       this.apiServer = settings.apiServer || "";
       this.activeDid = settings.activeDid || "";
 
-      const platformService = PlatformServiceFactory.getInstance();
-      const result = await platformService.dbQuery(`SELECT * FROM contacts`);
-      if (result) {
-        this.allContacts = databaseUtil.mapQueryResultToValues(
-          result,
-        ) as unknown as Contact[];
-      }
-      if (USE_DEXIE_DB) {
-        this.allContacts = await db.contacts.toArray();
-      }
+      this.allContacts = await db.contacts.toArray();
 
       this.allMyDids = await retrieveAccountDids();
 
@@ -320,7 +306,10 @@ export default class GiftedDialog extends Vue {
         this.fromProjectId,
       );
 
-      if (!result.success) {
+      if (
+        result.type === "error" ||
+        this.isGiveCreationError(result.response)
+      ) {
         const errorMessage = this.getGiveCreationErrorMessage(result);
         logger.error("Error with give creation result:", result);
         this.$notify(
@@ -367,6 +356,15 @@ export default class GiftedDialog extends Vue {
 
   // Helper functions for readability
 
+  /**
+   * @param result response "data" from the server
+   * @returns true if the result indicates an error
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  isGiveCreationError(result: any) {
+    return result.status !== 201 || result.data?.error;
+  }
+
   /**
    * @param result direct response eg. ErrorResult or SuccessResult (potentially with embedded "data")
    * @returns best guess at an error message

src/components/GiftedPrompts.vue

@@ -74,12 +74,10 @@
 import { Vue, Component } from "vue-facing-decorator";
 import { Router } from "vue-router";
 
-import { AppString, NotificationIface, USE_DEXIE_DB } from "../constants/app";
+import { AppString, NotificationIface } from "../constants/app";
 import { db } from "../db/index";
 import { Contact } from "../db/tables/contacts";
-import * as databaseUtil from "../db/databaseUtil";
 import { GiverReceiverInputInfo } from "../libs/util";
-import { PlatformServiceFactory } from "@/services/PlatformServiceFactory";
 
 @Component
 export default class GivenPrompts extends Vue {
@@ -129,16 +127,8 @@ export default class GivenPrompts extends Vue {
     this.visible = true;
     this.callbackOnFullGiftInfo = callbackOnFullGiftInfo;
 
-    const platformService = PlatformServiceFactory.getInstance();
-    const result = await platformService.dbQuery(
-      "SELECT COUNT(*) FROM contacts",
-    );
-    if (result) {
-      this.numContacts = result.values[0][0] as number;
-    }
-    if (USE_DEXIE_DB) {
-      this.numContacts = await db.contacts.count();
-    }
+    await db.open();
+    this.numContacts = await db.contacts.count();
     this.shownContactDbIndices = new Array<boolean>(this.numContacts); // all undefined to start
   }
 
@@ -239,22 +229,10 @@ export default class GivenPrompts extends Vue {
       this.nextIdeaPastContacts();
     } else {
       // get the contact at that offset
-      const platformService = PlatformServiceFactory.getInstance();
-      const result = await platformService.dbQuery(
-        "SELECT * FROM contacts LIMIT 1 OFFSET ?",
-        [someContactDbIndex],
-      );
-      if (result) {
-        this.currentContact = databaseUtil.mapQueryResultToValues(result)[
-          someContactDbIndex
-        ] as unknown as Contact;
-      }
-      if (USE_DEXIE_DB) {
-        await db.open();
-        this.currentContact = await db.contacts
-          .offset(someContactDbIndex)
-          .first();
-      }
+      await db.open();
+      this.currentContact = await db.contacts
+        .offset(someContactDbIndex)
+        .first();
       this.shownContactDbIndices[someContactDbIndex] = true;
     }
   }

src/components/ImageMethodDialog.vue

@@ -247,16 +247,11 @@ import axios from "axios";
 import { ref } from "vue";
 import { Component, Vue } from "vue-facing-decorator";
 import VuePictureCropper, { cropper } from "vue-picture-cropper";
-import {
-  DEFAULT_IMAGE_API_SERVER,
-  NotificationIface,
-  USE_DEXIE_DB,
-} from "../constants/app";
+import { DEFAULT_IMAGE_API_SERVER, NotificationIface } from "../constants/app";
 import { retrieveSettingsForActiveAccount } from "../db/index";
 import { accessToken } from "../libs/crypto";
 import { logger } from "../utils/logger";
 import { PlatformServiceFactory } from "../services/PlatformServiceFactory";
-import * as databaseUtil from "../db/databaseUtil";
 
 const inputImageFileNameRef = ref<Blob>();
 
@@ -338,11 +333,9 @@ export default class ImageMethodDialog extends Vue {
    * @throws {Error} When settings retrieval fails
    */
   async mounted() {
+    logger.log("ImageMethodDialog mounted");
     try {
-      let settings = await databaseUtil.retrieveSettingsForActiveAccount();
-      if (USE_DEXIE_DB) {
-        settings = await retrieveSettingsForActiveAccount();
-      }
+      const settings = await retrieveSettingsForActiveAccount();
       this.activeDid = settings.activeDid || "";
     } catch (error: unknown) {
       logger.error("Error retrieving settings from database:", error);

src/components/MembersList.vue

@@ -172,10 +172,8 @@ import {
 } from "../libs/endorserServer";
 import { decryptMessage } from "../libs/crypto";
 import { Contact } from "../db/tables/contacts";
-import * as databaseUtil from "../db/databaseUtil";
 import * as libsUtil from "../libs/util";
-import { NotificationIface, USE_DEXIE_DB } from "../constants/app";
-import { PlatformServiceFactory } from "@/services/PlatformServiceFactory";
+import { NotificationIface } from "../constants/app";
 
 interface Member {
   admitted: boolean;
@@ -211,10 +209,7 @@ export default class MembersList extends Vue {
   contacts: Array<Contact> = [];
 
   async created() {
-    let settings = await databaseUtil.retrieveSettingsForActiveAccount();
-    if (USE_DEXIE_DB) {
-      settings = await retrieveSettingsForActiveAccount();
-    }
+    const settings = await retrieveSettingsForActiveAccount();
     this.activeDid = settings.activeDid || "";
     this.apiServer = settings.apiServer || "";
     this.firstName = settings.firstName || "";
@@ -360,16 +355,7 @@ export default class MembersList extends Vue {
   }
 
   async loadContacts() {
-    const platformService = PlatformServiceFactory.getInstance();
-    const result = await platformService.dbQuery("SELECT * FROM contacts");
-    if (result) {
-      this.contacts = databaseUtil.mapQueryResultToValues(
-        result,
-      ) as unknown as Contact[];
-    }
-    if (USE_DEXIE_DB) {
-      this.contacts = await db.contacts.toArray();
-    }
+    this.contacts = await db.contacts.toArray();
   }
 
   getContactFor(did: string): Contact | undefined {
@@ -453,14 +439,7 @@ export default class MembersList extends Vue {
           if (result.success) {
             decrMember.isRegistered = true;
             if (oldContact) {
-              const platformService = PlatformServiceFactory.getInstance();
-              await platformService.dbExec(
-                "UPDATE contacts SET registered = ? WHERE did = ?",
-                [true, decrMember.did],
-              );
-              if (USE_DEXIE_DB) {
-                await db.contacts.update(decrMember.did, { registered: true });
-              }
+              await db.contacts.update(decrMember.did, { registered: true });
               oldContact.registered = true;
             }
             this.$notify(
@@ -513,14 +492,7 @@ export default class MembersList extends Vue {
         name: member.name,
       };
 
-      const platformService = PlatformServiceFactory.getInstance();
-      await platformService.dbExec(
-        "INSERT INTO contacts (did, name) VALUES (?, ?)",
-        [member.did, member.name],
-      );
-      if (USE_DEXIE_DB) {
-        await db.contacts.add(newContact);
-      }
+      await db.contacts.add(newContact);
       this.contacts.push(newContact);
 
       this.$notify(

src/components/OfferDialog.vue

@@ -82,13 +82,12 @@
 <script lang="ts">
 import { Vue, Component, Prop } from "vue-facing-decorator";
 
-import { NotificationIface, USE_DEXIE_DB } from "../constants/app";
+import { NotificationIface } from "../constants/app";
 import {
   createAndSubmitOffer,
   serverMessageForUser,
 } from "../libs/endorserServer";
 import * as libsUtil from "../libs/util";
-import * as databaseUtil from "../db/databaseUtil";
 import { retrieveSettingsForActiveAccount } from "../db/index";
 import { logger } from "../utils/logger";
 
@@ -117,10 +116,7 @@ export default class OfferDialog extends Vue {
       this.recipientDid = recipientDid;
       this.recipientName = recipientName;
 
-      let settings = await databaseUtil.retrieveSettingsForActiveAccount();
-      if (USE_DEXIE_DB) {
-        settings = await retrieveSettingsForActiveAccount();
-      }
+      const settings = await retrieveSettingsForActiveAccount();
       this.apiServer = settings.apiServer || "";
       this.activeDid = settings.activeDid || "";
 
@@ -249,7 +245,10 @@ export default class OfferDialog extends Vue {
         this.projectId,
       );
 
-      if (!result.success) {
+      if (
+        result.type === "error" ||
+        this.isOfferCreationError(result.response)
+      ) {
         const errorMessage = this.getOfferCreationErrorMessage(result);
         logger.error("Error with offer creation result:", result);
         this.$notify(
@@ -293,6 +292,15 @@ export default class OfferDialog extends Vue {
 
   // Helper functions for readability
 
+  /**
+   * @param result response "data" from the server
+   * @returns true if the result indicates an error
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  isOfferCreationError(result: any) {
+    return result.status !== 201 || result.data?.error;
+  }
+
   /**
    * @param result direct response eg. ErrorResult or SuccessResult (potentially with embedded "data")
    * @returns best guess at an error message

src/components/OnboardingDialog.vue

@@ -201,16 +201,13 @@
 import { Component, Vue } from "vue-facing-decorator";
 import { Router } from "vue-router";
 
-import { NotificationIface, USE_DEXIE_DB } from "../constants/app";
+import { NotificationIface } from "../constants/app";
 import {
   db,
   retrieveSettingsForActiveAccount,
   updateAccountSettings,
 } from "../db/index";
-import * as databaseUtil from "../db/databaseUtil";
 import { OnboardPage } from "../libs/util";
-import { PlatformServiceFactory } from "@/services/PlatformServiceFactory";
-import { Contact } from "@/db/tables/contacts";
 
 @Component({
   computed: {
@@ -225,7 +222,7 @@ export default class OnboardingDialog extends Vue {
   $router!: Router;
 
   activeDid = "";
-  firstContactName = "";
+  firstContactName = null;
   givenName = "";
   isRegistered = false;
   numContacts = 0;
@@ -234,54 +231,29 @@ export default class OnboardingDialog extends Vue {
 
   async open(page: OnboardPage) {
     this.page = page;
-    let settings = await databaseUtil.retrieveSettingsForActiveAccount();
-    if (USE_DEXIE_DB) {
-      settings = await retrieveSettingsForActiveAccount();
-    }
+    const settings = await retrieveSettingsForActiveAccount();
     this.activeDid = settings.activeDid || "";
     this.isRegistered = !!settings.isRegistered;
-    const platformService = PlatformServiceFactory.getInstance();
-    const dbContacts = await platformService.dbQuery("SELECT * FROM contacts");
-    if (dbContacts) {
-      this.numContacts = dbContacts.values.length;
-      const firstContact = dbContacts.values[0];
-      const fullContact = databaseUtil.mapColumnsToValues(dbContacts.columns, [
-        firstContact,
-      ]) as unknown as Contact;
-      this.firstContactName = fullContact.name || "";
-    }
-    if (USE_DEXIE_DB) {
-      const contacts = await db.contacts.toArray();
-      this.numContacts = contacts.length;
-      if (this.numContacts > 0) {
-        this.firstContactName = contacts[0].name || "";
-      }
+    const contacts = await db.contacts.toArray();
+    this.numContacts = contacts.length;
+    if (this.numContacts > 0) {
+      this.firstContactName = contacts[0].name;
     }
     this.visible = true;
     if (this.page === OnboardPage.Create) {
       // we'll assume that they've been through all the other pages
-      await databaseUtil.updateAccountSettings(this.activeDid, {
+      await updateAccountSettings(this.activeDid, {
         finishedOnboarding: true,
       });
-      if (USE_DEXIE_DB) {
-        await updateAccountSettings(this.activeDid, {
-          finishedOnboarding: true,
-        });
-      }
     }
   }
 
   async onClickClose(done?: boolean, goHome?: boolean) {
     this.visible = false;
     if (done) {
-      await databaseUtil.updateAccountSettings(this.activeDid, {
+      await updateAccountSettings(this.activeDid, {
         finishedOnboarding: true,
       });
-      if (USE_DEXIE_DB) {
-        await updateAccountSettings(this.activeDid, {
-          finishedOnboarding: true,
-        });
-      }
       if (goHome) {
         this.$router.push({ name: "home" });
       }

src/components/PhotoDialog.vue

@@ -119,12 +119,7 @@ PhotoDialog.vue */
 import axios from "axios";
 import { Component, Vue } from "vue-facing-decorator";
 import VuePictureCropper, { cropper } from "vue-picture-cropper";
-import {
-  DEFAULT_IMAGE_API_SERVER,
-  NotificationIface,
-  USE_DEXIE_DB,
-} from "../constants/app";
-import * as databaseUtil from "../db/databaseUtil";
+import { DEFAULT_IMAGE_API_SERVER, NotificationIface } from "../constants/app";
 import { retrieveSettingsForActiveAccount } from "../db/index";
 import { accessToken } from "../libs/crypto";
 import { logger } from "../utils/logger";
@@ -178,12 +173,9 @@ export default class PhotoDialog extends Vue {
    * @throws {Error} When settings retrieval fails
    */
   async mounted() {
-    // logger.log("PhotoDialog mounted");
+    logger.log("PhotoDialog mounted");
     try {
-      let settings = await databaseUtil.retrieveSettingsForActiveAccount();
-      if (USE_DEXIE_DB) {
-        settings = await retrieveSettingsForActiveAccount();
-      }
+      const settings = await retrieveSettingsForActiveAccount();
       this.activeDid = settings.activeDid || "";
       this.isRegistered = !!settings.isRegistered;
       logger.log("isRegistered:", this.isRegistered);

src/components/PushNotificationPermission.vue

@@ -102,12 +102,7 @@
 <script lang="ts">
 import { Component, Vue } from "vue-facing-decorator";
 
-import {
-  DEFAULT_PUSH_SERVER,
-  NotificationIface,
-  USE_DEXIE_DB,
-} from "../constants/app";
-import * as databaseUtil from "../db/databaseUtil";
+import { DEFAULT_PUSH_SERVER, NotificationIface } from "../constants/app";
 import {
   logConsoleAndDb,
   retrieveSettingsForActiveAccount,
@@ -174,10 +169,7 @@ export default class PushNotificationPermission extends Vue {
     this.isVisible = true;
     this.pushType = pushType;
     try {
-      let settings = await databaseUtil.retrieveSettingsForActiveAccount();
-      if (USE_DEXIE_DB) {
-        settings = await retrieveSettingsForActiveAccount();
-      }
+      const settings = await retrieveSettingsForActiveAccount();
       let pushUrl = DEFAULT_PUSH_SERVER;
       if (settings?.webPushServer) {
         pushUrl = settings.webPushServer;

src/components/TopMessage.vue

@@ -15,8 +15,7 @@
 <script lang="ts">
 import { Component, Vue, Prop } from "vue-facing-decorator";
 
-import { AppString, NotificationIface, USE_DEXIE_DB } from "../constants/app";
-import * as databaseUtil from "../db/databaseUtil";
+import { AppString, NotificationIface } from "../constants/app";
 import { retrieveSettingsForActiveAccount } from "../db/index";
 
 @Component
@@ -29,10 +28,7 @@ export default class TopMessage extends Vue {
 
   async mounted() {
     try {
-      let settings = await databaseUtil.retrieveSettingsForActiveAccount();
-      if (USE_DEXIE_DB) {
-        settings = await retrieveSettingsForActiveAccount();
-      }
+      const settings = await retrieveSettingsForActiveAccount();
       if (
         settings.warnIfTestServer &&
         settings.apiServer !== AppString.PROD_ENDORSER_API_SERVER

src/components/UserNameDialog.vue

@@ -37,9 +37,8 @@
 <script lang="ts">
 import { Vue, Component, Prop } from "vue-facing-decorator";
 
-import { NotificationIface, USE_DEXIE_DB } from "../constants/app";
+import { NotificationIface } from "../constants/app";
 import { db, retrieveSettingsForActiveAccount } from "../db/index";
-import * as databaseUtil from "../db/databaseUtil";
 import { MASTER_SETTINGS_KEY } from "../db/tables/settings";
 
 @Component
@@ -62,23 +61,15 @@ export default class UserNameDialog extends Vue {
    */
   async open(aCallback?: (name?: string) => void) {
     this.callback = aCallback || this.callback;
-    let settings = await databaseUtil.retrieveSettingsForActiveAccount();
-    if (USE_DEXIE_DB) {
-      settings = await retrieveSettingsForActiveAccount();
-    }
+    const settings = await retrieveSettingsForActiveAccount();
     this.givenName = settings.firstName || "";
     this.visible = true;
   }
 
   async onClickSaveChanges() {
-    await databaseUtil.updateDefaultSettings({
+    await db.settings.update(MASTER_SETTINGS_KEY, {
       firstName: this.givenName,
     });
-    if (USE_DEXIE_DB) {
-      await db.settings.update(MASTER_SETTINGS_KEY, {
-        firstName: this.givenName,
-      });
-    }
     this.visible = false;
     this.callback(this.givenName);
   }

src/components/World/components/objects/landmarks.js

@@ -3,8 +3,6 @@ import * as THREE from "three";
 import { GLTFLoader } from "three/addons/loaders/GLTFLoader";
 import * as SkeletonUtils from "three/addons/utils/SkeletonUtils";
 import * as TWEEN from "@tweenjs/tween.js";
-import { USE_DEXIE_DB } from "../../../../constants/app";
-import * as databaseUtil from "../../../../db/databaseUtil";
 import { retrieveSettingsForActiveAccount } from "../../../../db";
 import { getHeaders } from "../../../../libs/endorserServer";
 import { logger } from "../../../../utils/logger";
@@ -16,10 +14,7 @@ export async function loadLandmarks(vue, world, scene, loop) {
   vue.setWorldProperty("animationDurationSeconds", ANIMATION_DURATION_SECS);
 
   try {
-    let settings = await databaseUtil.retrieveSettingsForActiveAccount();
-    if (USE_DEXIE_DB) {
-      settings = await retrieveSettingsForActiveAccount();
-    }
+    const settings = await retrieveSettingsForActiveAccount();
     const activeDid = settings.activeDid || "";
     const apiServer = settings.apiServer;
     const headers = await getHeaders(activeDid);

src/constants/app.ts

@@ -7,7 +7,6 @@ export enum AppString {
   // This is used in titles and verbiage inside the app.
   // There is also an app name without spaces, for packaging in the package.json file used in the manifest.
   APP_NAME = "Time Safari",
-  APP_NAME_NO_SPACES = "TimeSafari",
 
   PROD_ENDORSER_API_SERVER = "https://api.endorser.ch",
   TEST_ENDORSER_API_SERVER = "https://test-api.endorser.ch",
@@ -44,15 +43,13 @@ export const DEFAULT_PARTNER_API_SERVER =
   AppString.TEST_PARTNER_API_SERVER;
 
 export const DEFAULT_PUSH_SERVER =
-  import.meta.env.VITE_DEFAULT_PUSH_SERVER || "https://timesafari.app";
+  window.location.protocol + "//" + window.location.host;
 
 export const IMAGE_TYPE_PROFILE = "profile";
 
 export const PASSKEYS_ENABLED =
   !!import.meta.env.VITE_PASSKEYS_ENABLED || false;
 
-export const USE_DEXIE_DB = false;
-
 /**
  * The possible values for "group" and "type" are in App.vue.
  * Some of this comes from the notiwind package, some is custom.

src/db-sql/migration.ts

@@ -1,134 +0,0 @@
-import migrationService from "../services/migrationService";
-import type { QueryExecResult } from "../interfaces/database";
-import { DEFAULT_ENDORSER_API_SERVER } from "@/constants/app";
-import { arrayBufferToBase64 } from "@/libs/crypto";
-
-// Generate a random secret for the secret table
-
-// It's not really secure to maintain the secret next to the user's data.
-// However, until we have better hooks into a real wallet or reliable secure
-// storage, we'll do this for user convenience. As they sign more records
-// and integrate with more people, they'll value it more and want to be more
-// secure, so we'll prompt them to take steps to back it up, properly encrypt,
-// etc. At the beginning, we'll prompt for a password, then we'll prompt for a
-// PWA so it's not in a browser... and then we hope to be integrated with a
-// real wallet or something else more secure.
-
-// One might ask: why encrypt at all? We figure a basic encryption is better
-// than none. Plus, we expect to support their own password or keystore or
-// external wallet as better signing options in the future, so it's gonna be
-// important to have the structure where each account access might require
-// user action.
-
-// (Once upon a time we stored the secret in localStorage, but it frequently
-// got erased, even though the IndexedDB still had the identity data. This
-// ended up throwing lots of errors to the user... and they'd end up in a state
-// where they couldn't take action because they couldn't unlock that identity.)
-
-const randomBytes = crypto.getRandomValues(new Uint8Array(32));
-const secretBase64 = arrayBufferToBase64(randomBytes);
-
-// Each migration can include multiple SQL statements (with semicolons)
-const MIGRATIONS = [
-  {
-    name: "001_initial",
-    // see ../db/tables files for explanations of the fields
-    sql: `
-      CREATE TABLE IF NOT EXISTS accounts (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        dateCreated TEXT NOT NULL,
-        derivationPath TEXT,
-        did TEXT NOT NULL,
-        identityEncrBase64 TEXT, -- encrypted & base64-encoded
-        mnemonicEncrBase64 TEXT, -- encrypted & base64-encoded
-        passkeyCredIdHex TEXT,
-        publicKeyHex TEXT NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_accounts_did ON accounts(did);
-
-      CREATE TABLE IF NOT EXISTS secret (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        secretBase64 TEXT NOT NULL
-      );
-
-      INSERT INTO secret (id, secretBase64) VALUES (1, '${secretBase64}');
-
-      CREATE TABLE IF NOT EXISTS settings (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        accountDid TEXT,
-        activeDid TEXT,
-        apiServer TEXT,
-        filterFeedByNearby BOOLEAN,
-        filterFeedByVisible BOOLEAN,
-        finishedOnboarding BOOLEAN,
-        firstName TEXT,
-        hideRegisterPromptOnNewContact BOOLEAN,
-        isRegistered BOOLEAN,
-        lastName TEXT,
-        lastAckedOfferToUserJwtId TEXT,
-        lastAckedOfferToUserProjectsJwtId TEXT,
-        lastNotifiedClaimId TEXT,
-        lastViewedClaimId TEXT,
-        notifyingNewActivityTime TEXT,
-        notifyingReminderMessage TEXT,
-        notifyingReminderTime TEXT,
-        partnerApiServer TEXT,
-        passkeyExpirationMinutes INTEGER,
-        profileImageUrl TEXT,
-        searchBoxes TEXT, -- Stored as JSON string
-        showContactGivesInline BOOLEAN,
-        showGeneralAdvanced BOOLEAN,
-        showShortcutBvc BOOLEAN,
-        vapid TEXT,
-        warnIfProdServer BOOLEAN,
-        warnIfTestServer BOOLEAN,
-        webPushServer TEXT
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_settings_accountDid ON settings(accountDid);
-
-      INSERT INTO settings (id, apiServer) VALUES (1, '${DEFAULT_ENDORSER_API_SERVER}');
-
-      CREATE TABLE IF NOT EXISTS contacts (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        did TEXT NOT NULL,
-        name TEXT,
-        contactMethods TEXT, -- Stored as JSON string
-        nextPubKeyHashB64 TEXT,
-        notes TEXT,
-        profileImageUrl TEXT,
-        publicKeyBase64 TEXT,
-        seesMe BOOLEAN,
-        registered BOOLEAN
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_contacts_did ON contacts(did);
-      CREATE INDEX IF NOT EXISTS idx_contacts_name ON contacts(name);
-
-      CREATE TABLE IF NOT EXISTS logs (
-        date TEXT NOT NULL,
-        message TEXT NOT NULL
-      );
-
-      CREATE TABLE IF NOT EXISTS temp (
-        id TEXT PRIMARY KEY,
-        blobB64 TEXT
-      );
-      `,
-  },
-];
-
-export async function registerMigrations(): Promise<void> {
-  // Register all migrations
-  for (const migration of MIGRATIONS) {
-    await migrationService.registerMigration(migration);
-  }
-}
-
-export async function runMigrations(
-  sqlExec: (sql: string, params?: unknown[]) => Promise<Array<QueryExecResult>>,
-): Promise<void> {
-  await registerMigrations();
-  await migrationService.runMigrations(sqlExec);
-}

src/db/databaseUtil.ts

@@ -1,308 +0,0 @@
-/**
- * This file is the SQL replacement of the index.ts file in the db directory.
- * That file will eventually be deleted.
- */
-
-import { PlatformServiceFactory } from "../services/PlatformServiceFactory";
-import { MASTER_SETTINGS_KEY, Settings } from "./tables/settings";
-import { logger } from "../utils/logger";
-import { DEFAULT_ENDORSER_API_SERVER } from "../constants/app";
-import { QueryExecResult } from "../interfaces/database";
-
-const formatLogObject = (obj: unknown): string => {
-  try {
-    return JSON.stringify(obj, null, 2);
-  } catch (error) {
-    return `[Object could not be stringified: ${error instanceof Error ? error.message : String(error)}]`;
-  }
-};
-
-export async function updateDefaultSettings(
-  settingsChanges: Settings,
-): Promise<boolean> {
-  delete settingsChanges.accountDid; // just in case
-  // ensure there is no "id" that would override the key
-  delete settingsChanges.id;
-  try {
-    const platformService = PlatformServiceFactory.getInstance();
-    const { sql, params } = generateUpdateStatement(
-      settingsChanges,
-      "settings",
-      "id = ?",
-      [MASTER_SETTINGS_KEY],
-    );
-    console.log("[databaseUtil] updateDefaultSettings", { sql, params });
-    const result = await platformService.dbExec(sql, params);
-    console.log("[databaseUtil] updateDefaultSettings result", { result });
-    return result.changes === 1;
-  } catch (error) {
-    logger.error("Error updating default settings:", error);
-    console.log("[databaseUtil] updateDefaultSettings error", { error });
-    if (error instanceof Error) {
-      throw error; // Re-throw if it's already an Error with a message
-    } else {
-      throw new Error(
-        `Failed to update settings. We recommend you try again or restart the app.`,
-      );
-    }
-  }
-}
-
-export async function updateAccountSettings(
-  accountDid: string,
-  settingsChanges: Settings,
-): Promise<boolean> {
-  settingsChanges.accountDid = accountDid;
-  delete settingsChanges.id; // key off account, not ID
-
-  const platform = PlatformServiceFactory.getInstance();
-
-  // First try to update existing record
-  const { sql: updateSql, params: updateParams } = generateUpdateStatement(
-    settingsChanges,
-    "settings",
-    "accountDid = ?",
-    [accountDid],
-  );
-
-  const updateResult = await platform.dbExec(updateSql, updateParams);
-
-  // If no record was updated, insert a new one
-  if (updateResult.changes === 1) {
-    return true;
-  } else {
-    const columns = Object.keys(settingsChanges);
-    const values = Object.values(settingsChanges);
-    const placeholders = values.map(() => "?").join(", ");
-
-    const insertSql = `INSERT INTO settings (${columns.join(", ")}) VALUES (${placeholders})`;
-    const result = await platform.dbExec(insertSql, values);
-
-    return result.changes === 1;
-  }
-}
-
-const DEFAULT_SETTINGS: Settings = {
-  id: MASTER_SETTINGS_KEY,
-  activeDid: undefined,
-  apiServer: DEFAULT_ENDORSER_API_SERVER,
-};
-
-// retrieves default settings
-export async function retrieveSettingsForDefaultAccount(): Promise<Settings> {
-  console.log('[DatabaseUtil] Retrieving default account settings');
-  const platform = PlatformServiceFactory.getInstance();
-  
-  console.log('[DatabaseUtil] Platform service state:', {
-    platformType: platform.constructor.name,
-    capabilities: platform.getCapabilities(),
-    timestamp: new Date().toISOString()
-  });
-
-  const result = await platform.dbQuery("SELECT * FROM settings WHERE id = ?", [
-    MASTER_SETTINGS_KEY,
-  ]);
-
-  if (!result) {
-    console.log('[DatabaseUtil] No settings found, returning defaults');
-    return DEFAULT_SETTINGS;
-  }
-
-  const settings = mapColumnsToValues(result.columns, result.values)[0] as Settings;
-  if (settings.searchBoxes) {
-    // @ts-expect-error - the searchBoxes field is a string in the DB
-    settings.searchBoxes = JSON.parse(settings.searchBoxes);
-  }
-
-  console.log('[DatabaseUtil] Retrieved settings:', {
-    settings: formatLogObject(settings),
-    timestamp: new Date().toISOString()
-  });
-
-  return settings;
-}
-
-export async function retrieveSettingsForActiveAccount(): Promise<Settings> {
-  console.log('[DatabaseUtil] Retrieving active account settings');
-  const defaultSettings = await retrieveSettingsForDefaultAccount();
-  
-  console.log('[DatabaseUtil] Default settings retrieved:', {
-    defaultSettings: formatLogObject(defaultSettings),
-    timestamp: new Date().toISOString()
-  });
-
-  if (!defaultSettings.activeDid) {
-    console.log('[DatabaseUtil] No active DID, returning default settings');
-    return defaultSettings;
-  }
-
-  const platform = PlatformServiceFactory.getInstance();
-  const result = await platform.dbQuery(
-    "SELECT * FROM settings WHERE accountDid = ?",
-    [defaultSettings.activeDid],
-  );
-
-  const overrideSettings = result
-    ? (mapColumnsToValues(result.columns, result.values)[0] as Settings)
-    : {};
-
-  const overrideSettingsFiltered = Object.fromEntries(
-    Object.entries(overrideSettings).filter(([_, v]) => v !== null),
-  );
-
-  const settings = { ...defaultSettings, ...overrideSettingsFiltered };
-  if (settings.searchBoxes) {
-    // @ts-expect-error - the searchBoxes field is a string in the DB
-    settings.searchBoxes = JSON.parse(settings.searchBoxes);
-  }
-
-  console.log('[DatabaseUtil] Final active account settings:', {
-    settings: formatLogObject(settings),
-    timestamp: new Date().toISOString()
-  });
-
-  return settings;
-}
-
-let lastCleanupDate: string | null = null;
-
-/**
- * Logs a message to the database with proper handling of concurrent writes
- * @param message - The message to log
- * @author Matthew Raymer
- */
-export async function logToDb(message: string): Promise<void> {
-  //const platform = PlatformServiceFactory.getInstance();
-  const todayKey = new Date().toDateString();
-  //const nowKey = new Date().toISOString();
-
-  try {
-    // Try to insert first, if it fails due to UNIQUE constraint, update instead
-    // await platform.dbExec("INSERT INTO logs (date, message) VALUES (?, ?)", [
-    //   nowKey,
-    //   message,
-    // ]);
-
-    // Clean up old logs (keep only last 7 days) - do this less frequently
-    // Only clean up if the date is different from the last cleanup
-    if (!lastCleanupDate || lastCleanupDate !== todayKey) {
-      // const sevenDaysAgo = new Date(
-      //   new Date().getTime() - 7 * 24 * 60 * 60 * 1000,
-      // );
-      // await platform.dbExec("DELETE FROM logs WHERE date < ?", [
-      //   sevenDaysAgo.toDateString(),
-      // ]);
-      lastCleanupDate = todayKey;
-    }
-  } catch (error) {
-    // Log to console as fallback
-    // eslint-disable-next-line no-console
-    console.error(
-      "Error logging to database:",
-      error,
-      " ... for original message:",
-      message,
-    );
-  }
-}
-
-// similar method is in the sw_scripts/additional-scripts.js file
-export async function logConsoleAndDb(
-  message: string,
-  isError = false,
-): Promise<void> {
-  if (isError) {
-    logger.error(`${new Date().toISOString()} ${message}`);
-  } else {
-    logger.log(`${new Date().toISOString()} ${message}`);
-  }
-  await logToDb(message);
-}
-
-/**
- * Generates an SQL INSERT statement and parameters from a model object.
- * @param model The model object containing fields to update
- * @param tableName The name of the table to update
- * @returns Object containing the SQL statement and parameters array
- */
-export function generateInsertStatement(
-  model: Record<string, unknown>,
-  tableName: string,
-): { sql: string; params: unknown[] } {
-  const columns = Object.keys(model).filter((key) => model[key] !== undefined);
-  const values = Object.values(model).filter((value) => value !== undefined);
-  const placeholders = values.map(() => "?").join(", ");
-  const insertSql = `INSERT INTO ${tableName} (${columns.join(", ")}) VALUES (${placeholders})`;
-  return {
-    sql: insertSql,
-    params: values,
-  };
-}
-
-/**
- * Generates an SQL UPDATE statement and parameters from a model object.
- * @param model The model object containing fields to update
- * @param tableName The name of the table to update
- * @param whereClause The WHERE clause for the update (e.g. "id = ?")
- * @param whereParams Parameters for the WHERE clause
- * @returns Object containing the SQL statement and parameters array
- */
-export function generateUpdateStatement(
-  model: Record<string, unknown>,
-  tableName: string,
-  whereClause: string,
-  whereParams: unknown[] = [],
-): { sql: string; params: unknown[] } {
-  // Filter out undefined/null values and create SET clause
-  const setClauses: string[] = [];
-  const params: unknown[] = [];
-
-  Object.entries(model).forEach(([key, value]) => {
-    if (value !== undefined) {
-      setClauses.push(`${key} = ?`);
-      params.push(value);
-    }
-  });
-
-  if (setClauses.length === 0) {
-    throw new Error("No valid fields to update");
-  }
-
-  const sql = `UPDATE ${tableName} SET ${setClauses.join(", ")} WHERE ${whereClause}`;
-
-  return {
-    sql,
-    params: [...params, ...whereParams],
-  };
-}
-
-export function mapQueryResultToValues(
-  record: QueryExecResult | undefined,
-): Array<Record<string, unknown>> {
-  if (!record) {
-    return [];
-  }
-  return mapColumnsToValues(record.columns, record.values) as Array<
-    Record<string, unknown>
-  >;
-}
-
-/**
- * Maps an array of column names to an array of value arrays, creating objects where each column name
- * is mapped to its corresponding value.
- * @param columns Array of column names to use as object keys
- * @param values Array of value arrays, where each inner array corresponds to one row of data
- * @returns Array of objects where each object maps column names to their corresponding values
- */
-export function mapColumnsToValues(
-  columns: string[],
-  values: unknown[][],
-): Array<Record<string, unknown>> {
-  return values.map((row) => {
-    const obj: Record<string, unknown> = {};
-    columns.forEach((column, index) => {
-      obj[column] = row[index];
-    });
-    return obj;
-  });
-}

src/db/index.ts

@@ -1,9 +1,3 @@
-/**
- * This is the original IndexedDB version of the database.
- * It will eventually be replaced fully by the SQL version in databaseUtil.ts.
- * Turn this on or off with the USE_DEXIE_DB constant in constants/app.ts.
- */
-
 import BaseDexie, { Table } from "dexie";
 import { encrypted, Encryption } from "@pvermeer/dexie-encrypted-addon";
 import * as R from "ramda";
@@ -32,8 +26,8 @@ type NonsensitiveTables = {
 };
 
 // Using 'unknown' instead of 'any' for stricter typing and to avoid TypeScript warnings
-type SecretDexie<T extends unknown = SecretTable> = BaseDexie & T;
-type SensitiveDexie<T extends unknown = SensitiveTables> = BaseDexie & T;
+export type SecretDexie<T extends unknown = SecretTable> = BaseDexie & T;
+export type SensitiveDexie<T extends unknown = SensitiveTables> = BaseDexie & T;
 export type NonsensitiveDexie<T extends unknown = NonsensitiveTables> =
   BaseDexie & T;
 
@@ -96,40 +90,40 @@ db.on("populate", async () => {
   try {
     await db.settings.add(DEFAULT_SETTINGS);
   } catch (error) {
-    logger.error("Error populating the database with default settings:", error);
+    console.error("Error populating the database with default settings:", error);
   }
 });
 
 // Helper function to safely open the database with retries
 async function safeOpenDatabase(retries = 1, delay = 500): Promise<void> {
-  // logger.log("Starting safeOpenDatabase with retries:", retries);
+  // console.log("Starting safeOpenDatabase with retries:", retries);
   for (let i = 0; i < retries; i++) {
     try {
-      // logger.log(`Attempt ${i + 1}: Checking if database is open...`);
+      // console.log(`Attempt ${i + 1}: Checking if database is open...`);
       if (!db.isOpen()) {
-        // logger.log(`Attempt ${i + 1}: Database is closed, attempting to open...`);
+        // console.log(`Attempt ${i + 1}: Database is closed, attempting to open...`);
 
         // Create a promise that rejects after 5 seconds
         const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => reject(new Error("Database open timed out")), 500);
+          setTimeout(() => reject(new Error('Database open timed out')), 500);
         });
 
         // Race between the open operation and the timeout
         const openPromise = db.open();
-        // logger.log(`Attempt ${i + 1}: Waiting for db.open() promise...`);
+        // console.log(`Attempt ${i + 1}: Waiting for db.open() promise...`);
         await Promise.race([openPromise, timeoutPromise]);
 
         // If we get here, the open succeeded
-        // logger.log(`Attempt ${i + 1}: Database opened successfully`);
+        // console.log(`Attempt ${i + 1}: Database opened successfully`);
         return;
       }
-      // logger.log(`Attempt ${i + 1}: Database was already open`);
+      // console.log(`Attempt ${i + 1}: Database was already open`);
       return;
     } catch (error) {
-      logger.error(`Attempt ${i + 1}: Database open failed:`, error);
+      console.error(`Attempt ${i + 1}: Database open failed:`, error);
       if (i < retries - 1) {
-        logger.log(`Attempt ${i + 1}: Waiting ${delay}ms before retry...`);
-        await new Promise((resolve) => setTimeout(resolve, delay));
+        console.log(`Attempt ${i + 1}: Waiting ${delay}ms before retry...`);
+        await new Promise(resolve => setTimeout(resolve, delay));
       } else {
         throw error;
       }
@@ -145,29 +139,23 @@ export async function updateDefaultSettings(
   delete settingsChanges.id;
   try {
     try {
-      // logger.log("Database state before open:", db.isOpen() ? "open" : "closed");
-      // logger.log("Database name:", db.name);
-      // logger.log("Database version:", db.verno);
+      // console.log("Database state before open:", db.isOpen() ? "open" : "closed");
+      // console.log("Database name:", db.name);
+      // console.log("Database version:", db.verno);
       await safeOpenDatabase();
     } catch (openError: unknown) {
-      logger.error("Failed to open database:", openError, String(openError));
-      throw new Error(
-        `The database connection failed. We recommend you try again or restart the app.`,
-      );
+      console.error("Failed to open database:", openError);
+      const errorMessage = openError instanceof Error ? openError.message : String(openError);
+      throw new Error(`Database connection failed: ${errorMessage}. Please try again or restart the app.`);
     }
-    const result = await db.settings.update(
-      MASTER_SETTINGS_KEY,
-      settingsChanges,
-    );
+    const result = await db.settings.update(MASTER_SETTINGS_KEY, settingsChanges);
     return result;
   } catch (error) {
-    logger.error("Error updating default settings:", error);
+    console.error("Error updating default settings:", error);
     if (error instanceof Error) {
       throw error; // Re-throw if it's already an Error with a message
     } else {
-      throw new Error(
-        `Failed to update settings. We recommend you try again or restart the app.`,
-      );
+      throw new Error(`Failed to update settings: ${error}`);
     }
   }
 }

src/db/sqlite/init.ts

@@ -0,0 +1,293 @@
+/**
+ * SQLite Database Initialization
+ * 
+ * This module handles database initialization, including:
+ * - Database connection management
+ * - Schema creation and migration
+ * - Connection pooling and lifecycle
+ * - Error handling and recovery
+ */
+
+import { Database, SQLite3 } from '@wa-sqlite/sql.js';
+import { DATABASE_SCHEMA, SQLiteTable } from './types';
+import { logger } from '../../utils/logger';
+
+// ============================================================================
+// Database Connection Management
+// ============================================================================
+
+export interface DatabaseConnection {
+  db: Database;
+  sqlite3: SQLite3;
+  isOpen: boolean;
+  lastUsed: number;
+}
+
+let connection: DatabaseConnection | null = null;
+const CONNECTION_TIMEOUT = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Initialize the SQLite database connection
+ */
+export async function initDatabase(): Promise<DatabaseConnection> {
+  if (connection?.isOpen) {
+    connection.lastUsed = Date.now();
+    return connection;
+  }
+
+  try {
+    const sqlite3 = await import('@wa-sqlite/sql.js');
+    const db = await sqlite3.open(':memory:'); // TODO: Configure storage location
+
+    // Enable foreign keys
+    await db.exec('PRAGMA foreign_keys = ON;');
+    
+    // Configure for better performance
+    await db.exec(`
+      PRAGMA journal_mode = WAL;
+      PRAGMA synchronous = NORMAL;
+      PRAGMA cache_size = -2000; -- Use 2MB of cache
+    `);
+
+    connection = {
+      db,
+      sqlite3,
+      isOpen: true,
+      lastUsed: Date.now()
+    };
+
+    // Start connection cleanup interval
+    startConnectionCleanup();
+
+    return connection;
+  } catch (error) {
+    logger.error('[SQLite] Database initialization failed:', error);
+    throw new Error('Failed to initialize database');
+  }
+}
+
+/**
+ * Close the database connection
+ */
+export async function closeDatabase(): Promise<void> {
+  if (!connection?.isOpen) return;
+
+  try {
+    await connection.db.close();
+    connection.isOpen = false;
+    connection = null;
+  } catch (error) {
+    logger.error('[SQLite] Database close failed:', error);
+    throw new Error('Failed to close database');
+  }
+}
+
+/**
+ * Cleanup inactive connections
+ */
+function startConnectionCleanup(): void {
+  setInterval(() => {
+    if (connection && Date.now() - connection.lastUsed > CONNECTION_TIMEOUT) {
+      closeDatabase().catch(error => {
+        logger.error('[SQLite] Connection cleanup failed:', error);
+      });
+    }
+  }, 60000); // Check every minute
+}
+
+// ============================================================================
+// Schema Management
+// ============================================================================
+
+/**
+ * Create the database schema
+ */
+export async function createSchema(): Promise<void> {
+  const { db } = await initDatabase();
+
+  try {
+    await db.transaction(async () => {
+      for (const table of DATABASE_SCHEMA) {
+        await createTable(db, table);
+      }
+    });
+  } catch (error) {
+    logger.error('[SQLite] Schema creation failed:', error);
+    throw new Error('Failed to create database schema');
+  }
+}
+
+/**
+ * Create a single table
+ */
+async function createTable(db: Database, table: SQLiteTable): Promise<void> {
+  const columnDefs = table.columns.map(col => {
+    const constraints = [
+      col.primaryKey ? 'PRIMARY KEY' : '',
+      col.unique ? 'UNIQUE' : '',
+      !col.nullable ? 'NOT NULL' : '',
+      col.references ? `REFERENCES ${col.references.table}(${col.references.column})` : '',
+      col.default !== undefined ? `DEFAULT ${formatDefaultValue(col.default)}` : ''
+    ].filter(Boolean).join(' ');
+
+    return `${col.name} ${col.type} ${constraints}`.trim();
+  });
+
+  const createTableSQL = `
+    CREATE TABLE IF NOT EXISTS ${table.name} (
+      ${columnDefs.join(',\n      ')}
+    );
+  `;
+
+  await db.exec(createTableSQL);
+
+  // Create indexes
+  if (table.indexes) {
+    for (const index of table.indexes) {
+      const createIndexSQL = `
+        CREATE INDEX IF NOT EXISTS ${index.name} 
+        ON ${table.name} (${index.columns.join(', ')})
+        ${index.unique ? 'UNIQUE' : ''};
+      `;
+      await db.exec(createIndexSQL);
+    }
+  }
+}
+
+/**
+ * Format default value for SQL
+ */
+function formatDefaultValue(value: unknown): string {
+  if (value === null) return 'NULL';
+  if (typeof value === 'string') return `'${value.replace(/'/g, "''")}'`;
+  if (typeof value === 'number') return value.toString();
+  if (typeof value === 'boolean') return value ? '1' : '0';
+  throw new Error(`Unsupported default value type: ${typeof value}`);
+}
+
+// ============================================================================
+// Database Health Checks
+// ============================================================================
+
+/**
+ * Check database health
+ */
+export async function checkDatabaseHealth(): Promise<{
+  isHealthy: boolean;
+  tables: string[];
+  error?: string;
+}> {
+  try {
+    const { db } = await initDatabase();
+    
+    // Check if we can query the database
+    const tables = await db.selectAll<{ name: string }>(`
+      SELECT name FROM sqlite_master 
+      WHERE type='table' AND name NOT LIKE 'sqlite_%'
+    `);
+
+    return {
+      isHealthy: true,
+      tables: tables.map(t => t.name)
+    };
+  } catch (error) {
+    logger.error('[SQLite] Health check failed:', error);
+    return {
+      isHealthy: false,
+      tables: [],
+      error: error instanceof Error ? error.message : 'Unknown error'
+    };
+  }
+}
+
+/**
+ * Verify database integrity
+ */
+export async function verifyDatabaseIntegrity(): Promise<{
+  isIntegrityOk: boolean;
+  errors: string[];
+}> {
+  const { db } = await initDatabase();
+  const errors: string[] = [];
+
+  try {
+    // Run integrity check
+    const result = await db.selectAll<{ integrity_check: string }>('PRAGMA integrity_check;');
+    
+    if (result[0]?.integrity_check !== 'ok') {
+      errors.push('Database integrity check failed');
+    }
+
+    // Check foreign key constraints
+    const fkResult = await db.selectAll<{ table: string; rowid: number; parent: string; fkid: number }>(`
+      PRAGMA foreign_key_check;
+    `);
+
+    if (fkResult.length > 0) {
+      errors.push('Foreign key constraint violations found');
+    }
+
+    return {
+      isIntegrityOk: errors.length === 0,
+      errors
+    };
+  } catch (error) {
+    logger.error('[SQLite] Integrity check failed:', error);
+    return {
+      isIntegrityOk: false,
+      errors: [error instanceof Error ? error.message : 'Unknown error']
+    };
+  }
+}
+
+// ============================================================================
+// Database Backup and Recovery
+// ============================================================================
+
+/**
+ * Create a database backup
+ */
+export async function createBackup(): Promise<Uint8Array> {
+  const { db } = await initDatabase();
+  
+  try {
+    // Export the database to a binary array
+    return await db.export();
+  } catch (error) {
+    logger.error('[SQLite] Backup creation failed:', error);
+    throw new Error('Failed to create database backup');
+  }
+}
+
+/**
+ * Restore database from backup
+ */
+export async function restoreFromBackup(backup: Uint8Array): Promise<void> {
+  const { db } = await initDatabase();
+  
+  try {
+    // Close current connection
+    await closeDatabase();
+    
+    // Create new connection and import backup
+    const sqlite3 = await import('@wa-sqlite/sql.js');
+    const newDb = await sqlite3.open(backup);
+    
+    // Verify integrity
+    const { isIntegrityOk, errors } = await verifyDatabaseIntegrity();
+    if (!isIntegrityOk) {
+      throw new Error(`Backup integrity check failed: ${errors.join(', ')}`);
+    }
+    
+    // Replace current connection
+    connection = {
+      db: newDb,
+      sqlite3,
+      isOpen: true,
+      lastUsed: Date.now()
+    };
+  } catch (error) {
+    logger.error('[SQLite] Backup restoration failed:', error);
+    throw new Error('Failed to restore database from backup');
+  }
+} 

src/db/sqlite/migration.ts

@@ -0,0 +1,374 @@
+/**
+ * SQLite Migration Utilities
+ * 
+ * This module handles the migration of data from Dexie to SQLite,
+ * including data transformation, validation, and rollback capabilities.
+ */
+
+import { Database } from '@wa-sqlite/sql.js';
+import { initDatabase, createSchema, createBackup } from './init';
+import { 
+  MigrationData, 
+  MigrationResult,
+  SQLiteAccount,
+  SQLiteContact,
+  SQLiteContactMethod,
+  SQLiteSettings,
+  SQLiteLog,
+  SQLiteSecret,
+  isSQLiteAccount,
+  isSQLiteContact,
+  isSQLiteSettings
+} from './types';
+import { logger } from '../../utils/logger';
+
+// ============================================================================
+// Migration Types
+// ============================================================================
+
+interface MigrationContext {
+  db: Database;
+  startTime: number;
+  stats: MigrationResult['stats'];
+  errors: Error[];
+}
+
+// ============================================================================
+// Migration Functions
+// ============================================================================
+
+/**
+ * Migrate data from Dexie to SQLite
+ */
+export async function migrateFromDexie(data: MigrationData): Promise<MigrationResult> {
+  const startTime = Date.now();
+  const context: MigrationContext = {
+    db: (await initDatabase()).db,
+    startTime,
+    stats: {
+      accounts: 0,
+      contacts: 0,
+      contactMethods: 0,
+      settings: 0,
+      logs: 0,
+      secrets: 0
+    },
+    errors: []
+  };
+
+  try {
+    // Create backup before migration
+    const backup = await createBackup();
+
+    // Create schema if needed
+    await createSchema();
+
+    // Perform migration in a transaction
+    await context.db.transaction(async () => {
+      // Migrate in order of dependencies
+      await migrateAccounts(context, data.accounts);
+      await migrateContacts(context, data.contacts);
+      await migrateContactMethods(context, data.contactMethods);
+      await migrateSettings(context, data.settings);
+      await migrateLogs(context, data.logs);
+      await migrateSecrets(context, data.secrets);
+    });
+
+    // Verify migration
+    const verificationResult = await verifyMigration(context, data);
+    if (!verificationResult.success) {
+      throw new Error(`Migration verification failed: ${verificationResult.error}`);
+    }
+
+    return {
+      success: true,
+      stats: context.stats,
+      duration: Date.now() - startTime
+    };
+
+  } catch (error) {
+    logger.error('[SQLite] Migration failed:', error);
+    
+    // Attempt rollback
+    try {
+      await rollbackMigration(backup);
+    } catch (rollbackError) {
+      logger.error('[SQLite] Rollback failed:', rollbackError);
+      context.errors.push(new Error('Migration and rollback failed'));
+    }
+
+    return {
+      success: false,
+      error: error instanceof Error ? error : new Error('Unknown migration error'),
+      stats: context.stats,
+      duration: Date.now() - startTime
+    };
+  }
+}
+
+// ============================================================================
+// Migration Helpers
+// ============================================================================
+
+/**
+ * Migrate accounts
+ */
+async function migrateAccounts(context: MigrationContext, accounts: SQLiteAccount[]): Promise<void> {
+  for (const account of accounts) {
+    try {
+      if (!isSQLiteAccount(account)) {
+        throw new Error(`Invalid account data: ${JSON.stringify(account)}`);
+      }
+
+      await context.db.exec(`
+        INSERT INTO accounts (
+          did, public_key_hex, created_at, updated_at,
+          identity_json, mnemonic_encrypted, passkey_cred_id_hex, derivation_path
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `, [
+        account.did,
+        account.public_key_hex,
+        account.created_at,
+        account.updated_at,
+        account.identity_json || null,
+        account.mnemonic_encrypted || null,
+        account.passkey_cred_id_hex || null,
+        account.derivation_path || null
+      ]);
+
+      context.stats.accounts++;
+    } catch (error) {
+      context.errors.push(new Error(`Failed to migrate account ${account.did}: ${error}`));
+      throw error; // Re-throw to trigger transaction rollback
+    }
+  }
+}
+
+/**
+ * Migrate contacts
+ */
+async function migrateContacts(context: MigrationContext, contacts: SQLiteContact[]): Promise<void> {
+  for (const contact of contacts) {
+    try {
+      if (!isSQLiteContact(contact)) {
+        throw new Error(`Invalid contact data: ${JSON.stringify(contact)}`);
+      }
+
+      await context.db.exec(`
+        INSERT INTO contacts (
+          id, did, name, notes, profile_image_url,
+          public_key_base64, next_pub_key_hash_b64,
+          sees_me, registered, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `, [
+        contact.id,
+        contact.did,
+        contact.name || null,
+        contact.notes || null,
+        contact.profile_image_url || null,
+        contact.public_key_base64 || null,
+        contact.next_pub_key_hash_b64 || null,
+        contact.sees_me ? 1 : 0,
+        contact.registered ? 1 : 0,
+        contact.created_at,
+        contact.updated_at
+      ]);
+
+      context.stats.contacts++;
+    } catch (error) {
+      context.errors.push(new Error(`Failed to migrate contact ${contact.id}: ${error}`));
+      throw error;
+    }
+  }
+}
+
+/**
+ * Migrate contact methods
+ */
+async function migrateContactMethods(
+  context: MigrationContext, 
+  methods: SQLiteContactMethod[]
+): Promise<void> {
+  for (const method of methods) {
+    try {
+      await context.db.exec(`
+        INSERT INTO contact_methods (
+          id, contact_id, label, type, value,
+          created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      `, [
+        method.id,
+        method.contact_id,
+        method.label,
+        method.type,
+        method.value,
+        method.created_at,
+        method.updated_at
+      ]);
+
+      context.stats.contactMethods++;
+    } catch (error) {
+      context.errors.push(new Error(`Failed to migrate contact method ${method.id}: ${error}`));
+      throw error;
+    }
+  }
+}
+
+/**
+ * Migrate settings
+ */
+async function migrateSettings(context: MigrationContext, settings: SQLiteSettings[]): Promise<void> {
+  for (const setting of settings) {
+    try {
+      if (!isSQLiteSettings(setting)) {
+        throw new Error(`Invalid settings data: ${JSON.stringify(setting)}`);
+      }
+
+      await context.db.exec(`
+        INSERT INTO settings (
+          key, account_did, value_json, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?)
+      `, [
+        setting.key,
+        setting.account_did || null,
+        setting.value_json,
+        setting.created_at,
+        setting.updated_at
+      ]);
+
+      context.stats.settings++;
+    } catch (error) {
+      context.errors.push(new Error(`Failed to migrate setting ${setting.key}: ${error}`));
+      throw error;
+    }
+  }
+}
+
+/**
+ * Migrate logs
+ */
+async function migrateLogs(context: MigrationContext, logs: SQLiteLog[]): Promise<void> {
+  for (const log of logs) {
+    try {
+      await context.db.exec(`
+        INSERT INTO logs (
+          id, level, message, metadata_json, created_at
+        ) VALUES (?, ?, ?, ?, ?)
+      `, [
+        log.id,
+        log.level,
+        log.message,
+        log.metadata_json || null,
+        log.created_at
+      ]);
+
+      context.stats.logs++;
+    } catch (error) {
+      context.errors.push(new Error(`Failed to migrate log ${log.id}: ${error}`));
+      throw error;
+    }
+  }
+}
+
+/**
+ * Migrate secrets
+ */
+async function migrateSecrets(context: MigrationContext, secrets: SQLiteSecret[]): Promise<void> {
+  for (const secret of secrets) {
+    try {
+      await context.db.exec(`
+        INSERT INTO secrets (
+          key, value_encrypted, created_at, updated_at
+        ) VALUES (?, ?, ?, ?)
+      `, [
+        secret.key,
+        secret.value_encrypted,
+        secret.created_at,
+        secret.updated_at
+      ]);
+
+      context.stats.secrets++;
+    } catch (error) {
+      context.errors.push(new Error(`Failed to migrate secret ${secret.key}: ${error}`));
+      throw error;
+    }
+  }
+}
+
+// ============================================================================
+// Verification and Rollback
+// ============================================================================
+
+/**
+ * Verify migration success
+ */
+async function verifyMigration(
+  context: MigrationContext,
+  data: MigrationData
+): Promise<{ success: boolean; error?: string }> {
+  try {
+    // Verify counts
+    const counts = await context.db.selectAll<{ table: string; count: number }>(`
+      SELECT 'accounts' as table, COUNT(*) as count FROM accounts
+      UNION ALL
+      SELECT 'contacts', COUNT(*) FROM contacts
+      UNION ALL
+      SELECT 'contact_methods', COUNT(*) FROM contact_methods
+      UNION ALL
+      SELECT 'settings', COUNT(*) FROM settings
+      UNION ALL
+      SELECT 'logs', COUNT(*) FROM logs
+      UNION ALL
+      SELECT 'secrets', COUNT(*) FROM secrets
+    `);
+
+    const countMap = new Map(counts.map(c => [c.table, c.count]));
+
+    if (countMap.get('accounts') !== data.accounts.length) {
+      return { success: false, error: 'Account count mismatch' };
+    }
+    if (countMap.get('contacts') !== data.contacts.length) {
+      return { success: false, error: 'Contact count mismatch' };
+    }
+    if (countMap.get('contact_methods') !== data.contactMethods.length) {
+      return { success: false, error: 'Contact method count mismatch' };
+    }
+    if (countMap.get('settings') !== data.settings.length) {
+      return { success: false, error: 'Settings count mismatch' };
+    }
+    if (countMap.get('logs') !== data.logs.length) {
+      return { success: false, error: 'Log count mismatch' };
+    }
+    if (countMap.get('secrets') !== data.secrets.length) {
+      return { success: false, error: 'Secret count mismatch' };
+    }
+
+    return { success: true };
+  } catch (error) {
+    return { 
+      success: false, 
+      error: error instanceof Error ? error.message : 'Unknown verification error'
+    };
+  }
+}
+
+/**
+ * Rollback migration
+ */
+async function rollbackMigration(backup: Uint8Array): Promise<void> {
+  const { db } = await initDatabase();
+  
+  try {
+    // Close current connection
+    await db.close();
+    
+    // Restore from backup
+    const sqlite3 = await import('@wa-sqlite/sql.js');
+    await sqlite3.open(backup);
+    
+    logger.info('[SQLite] Migration rollback successful');
+  } catch (error) {
+    logger.error('[SQLite] Migration rollback failed:', error);
+    throw new Error('Failed to rollback migration');
+  }
+} 

src/db/sqlite/operations.ts

@@ -0,0 +1,449 @@
+/**
+ * SQLite Database Operations
+ * 
+ * This module provides utility functions for common database operations,
+ * including CRUD operations, queries, and transactions.
+ */
+
+import { Database } from '@wa-sqlite/sql.js';
+import { initDatabase } from './init';
+import {
+  SQLiteAccount,
+  SQLiteContact,
+  SQLiteContactMethod,
+  SQLiteSettings,
+  SQLiteLog,
+  SQLiteSecret,
+  isSQLiteAccount,
+  isSQLiteContact,
+  isSQLiteSettings
+} from './types';
+import { logger } from '../../utils/logger';
+
+// ============================================================================
+// Transaction Helpers
+// ============================================================================
+
+/**
+ * Execute a function within a transaction
+ */
+export async function withTransaction<T>(
+  operation: (db: Database) => Promise<T>
+): Promise<T> {
+  const { db } = await initDatabase();
+  
+  try {
+    return await db.transaction(operation);
+  } catch (error) {
+    logger.error('[SQLite] Transaction failed:', error);
+    throw error;
+  }
+}
+
+/**
+ * Execute a function with retries
+ */
+export async function withRetry<T>(
+  operation: () => Promise<T>,
+  maxRetries = 3,
+  delay = 1000
+): Promise<T> {
+  let lastError: Error | undefined;
+  
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return await operation();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      
+      if (i < maxRetries - 1) {
+        await new Promise(resolve => setTimeout(resolve, delay * (i + 1)));
+      }
+    }
+  }
+  
+  throw lastError;
+}
+
+// ============================================================================
+// Account Operations
+// ============================================================================
+
+/**
+ * Get account by DID
+ */
+export async function getAccountByDid(did: string): Promise<SQLiteAccount | null> {
+  const { db } = await initDatabase();
+  
+  const accounts = await db.selectAll<SQLiteAccount>(
+    'SELECT * FROM accounts WHERE did = ?',
+    [did]
+  );
+  
+  return accounts[0] || null;
+}
+
+/**
+ * Get all accounts
+ */
+export async function getAllAccounts(): Promise<SQLiteAccount[]> {
+  const { db } = await initDatabase();
+  
+  return db.selectAll<SQLiteAccount>(
+    'SELECT * FROM accounts ORDER BY created_at DESC'
+  );
+}
+
+/**
+ * Create or update account
+ */
+export async function upsertAccount(account: SQLiteAccount): Promise<void> {
+  if (!isSQLiteAccount(account)) {
+    throw new Error('Invalid account data');
+  }
+
+  await withTransaction(async (db) => {
+    const existing = await db.selectOne<{ did: string }>(
+      'SELECT did FROM accounts WHERE did = ?',
+      [account.did]
+    );
+
+    if (existing) {
+      await db.exec(`
+        UPDATE accounts SET
+          public_key_hex = ?,
+          updated_at = ?,
+          identity_json = ?,
+          mnemonic_encrypted = ?,
+          passkey_cred_id_hex = ?,
+          derivation_path = ?
+        WHERE did = ?
+      `, [
+        account.public_key_hex,
+        Date.now(),
+        account.identity_json || null,
+        account.mnemonic_encrypted || null,
+        account.passkey_cred_id_hex || null,
+        account.derivation_path || null,
+        account.did
+      ]);
+    } else {
+      await db.exec(`
+        INSERT INTO accounts (
+          did, public_key_hex, created_at, updated_at,
+          identity_json, mnemonic_encrypted, passkey_cred_id_hex, derivation_path
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `, [
+        account.did,
+        account.public_key_hex,
+        account.created_at,
+        account.updated_at,
+        account.identity_json || null,
+        account.mnemonic_encrypted || null,
+        account.passkey_cred_id_hex || null,
+        account.derivation_path || null
+      ]);
+    }
+  });
+}
+
+// ============================================================================
+// Contact Operations
+// ============================================================================
+
+/**
+ * Get contact by ID
+ */
+export async function getContactById(id: string): Promise<SQLiteContact | null> {
+  const { db } = await initDatabase();
+  
+  const contacts = await db.selectAll<SQLiteContact>(
+    'SELECT * FROM contacts WHERE id = ?',
+    [id]
+  );
+  
+  return contacts[0] || null;
+}
+
+/**
+ * Get contacts by account DID
+ */
+export async function getContactsByAccountDid(did: string): Promise<SQLiteContact[]> {
+  const { db } = await initDatabase();
+  
+  return db.selectAll<SQLiteContact>(
+    'SELECT * FROM contacts WHERE did = ? ORDER BY created_at DESC',
+    [did]
+  );
+}
+
+/**
+ * Get contact methods for a contact
+ */
+export async function getContactMethods(contactId: string): Promise<SQLiteContactMethod[]> {
+  const { db } = await initDatabase();
+  
+  return db.selectAll<SQLiteContactMethod>(
+    'SELECT * FROM contact_methods WHERE contact_id = ? ORDER BY created_at DESC',
+    [contactId]
+  );
+}
+
+/**
+ * Create or update contact with methods
+ */
+export async function upsertContact(
+  contact: SQLiteContact,
+  methods: SQLiteContactMethod[] = []
+): Promise<void> {
+  if (!isSQLiteContact(contact)) {
+    throw new Error('Invalid contact data');
+  }
+
+  await withTransaction(async (db) => {
+    const existing = await db.selectOne<{ id: string }>(
+      'SELECT id FROM contacts WHERE id = ?',
+      [contact.id]
+    );
+
+    if (existing) {
+      await db.exec(`
+        UPDATE contacts SET
+          did = ?,
+          name = ?,
+          notes = ?,
+          profile_image_url = ?,
+          public_key_base64 = ?,
+          next_pub_key_hash_b64 = ?,
+          sees_me = ?,
+          registered = ?,
+          updated_at = ?
+        WHERE id = ?
+      `, [
+        contact.did,
+        contact.name || null,
+        contact.notes || null,
+        contact.profile_image_url || null,
+        contact.public_key_base64 || null,
+        contact.next_pub_key_hash_b64 || null,
+        contact.sees_me ? 1 : 0,
+        contact.registered ? 1 : 0,
+        Date.now(),
+        contact.id
+      ]);
+    } else {
+      await db.exec(`
+        INSERT INTO contacts (
+          id, did, name, notes, profile_image_url,
+          public_key_base64, next_pub_key_hash_b64,
+          sees_me, registered, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `, [
+        contact.id,
+        contact.did,
+        contact.name || null,
+        contact.notes || null,
+        contact.profile_image_url || null,
+        contact.public_key_base64 || null,
+        contact.next_pub_key_hash_b64 || null,
+        contact.sees_me ? 1 : 0,
+        contact.registered ? 1 : 0,
+        contact.created_at,
+        contact.updated_at
+      ]);
+    }
+
+    // Update contact methods
+    if (methods.length > 0) {
+      // Delete existing methods
+      await db.exec(
+        'DELETE FROM contact_methods WHERE contact_id = ?',
+        [contact.id]
+      );
+
+      // Insert new methods
+      for (const method of methods) {
+        await db.exec(`
+          INSERT INTO contact_methods (
+            id, contact_id, label, type, value,
+            created_at, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?)
+        `, [
+          method.id,
+          contact.id,
+          method.label,
+          method.type,
+          method.value,
+          method.created_at,
+          method.updated_at
+        ]);
+      }
+    }
+  });
+}
+
+// ============================================================================
+// Settings Operations
+// ============================================================================
+
+/**
+ * Get setting by key
+ */
+export async function getSetting(key: string): Promise<SQLiteSettings | null> {
+  const { db } = await initDatabase();
+  
+  const settings = await db.selectAll<SQLiteSettings>(
+    'SELECT * FROM settings WHERE key = ?',
+    [key]
+  );
+  
+  return settings[0] || null;
+}
+
+/**
+ * Get settings by account DID
+ */
+export async function getSettingsByAccountDid(did: string): Promise<SQLiteSettings[]> {
+  const { db } = await initDatabase();
+  
+  return db.selectAll<SQLiteSettings>(
+    'SELECT * FROM settings WHERE account_did = ? ORDER BY updated_at DESC',
+    [did]
+  );
+}
+
+/**
+ * Set setting value
+ */
+export async function setSetting(setting: SQLiteSettings): Promise<void> {
+  if (!isSQLiteSettings(setting)) {
+    throw new Error('Invalid settings data');
+  }
+
+  await withTransaction(async (db) => {
+    const existing = await db.selectOne<{ key: string }>(
+      'SELECT key FROM settings WHERE key = ?',
+      [setting.key]
+    );
+
+    if (existing) {
+      await db.exec(`
+        UPDATE settings SET
+          account_did = ?,
+          value_json = ?,
+          updated_at = ?
+        WHERE key = ?
+      `, [
+        setting.account_did || null,
+        setting.value_json,
+        Date.now(),
+        setting.key
+      ]);
+    } else {
+      await db.exec(`
+        INSERT INTO settings (
+          key, account_did, value_json, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?)
+      `, [
+        setting.key,
+        setting.account_did || null,
+        setting.value_json,
+        setting.created_at,
+        setting.updated_at
+      ]);
+    }
+  });
+}
+
+// ============================================================================
+// Log Operations
+// ============================================================================
+
+/**
+ * Add log entry
+ */
+export async function addLog(log: SQLiteLog): Promise<void> {
+  await withTransaction(async (db) => {
+    await db.exec(`
+      INSERT INTO logs (
+        id, level, message, metadata_json, created_at
+      ) VALUES (?, ?, ?, ?, ?)
+    `, [
+      log.id,
+      log.level,
+      log.message,
+      log.metadata_json || null,
+      log.created_at
+    ]);
+  });
+}
+
+/**
+ * Get logs by level
+ */
+export async function getLogsByLevel(
+  level: string,
+  limit = 100,
+  offset = 0
+): Promise<SQLiteLog[]> {
+  const { db } = await initDatabase();
+  
+  return db.selectAll<SQLiteLog>(
+    'SELECT * FROM logs WHERE level = ? ORDER BY created_at DESC LIMIT ? OFFSET ?',
+    [level, limit, offset]
+  );
+}
+
+// ============================================================================
+// Secret Operations
+// ============================================================================
+
+/**
+ * Get secret by key
+ */
+export async function getSecret(key: string): Promise<SQLiteSecret | null> {
+  const { db } = await initDatabase();
+  
+  const secrets = await db.selectAll<SQLiteSecret>(
+    'SELECT * FROM secrets WHERE key = ?',
+    [key]
+  );
+  
+  return secrets[0] || null;
+}
+
+/**
+ * Set secret value
+ */
+export async function setSecret(secret: SQLiteSecret): Promise<void> {
+  await withTransaction(async (db) => {
+    const existing = await db.selectOne<{ key: string }>(
+      'SELECT key FROM secrets WHERE key = ?',
+      [secret.key]
+    );
+
+    if (existing) {
+      await db.exec(`
+        UPDATE secrets SET
+          value_encrypted = ?,
+          updated_at = ?
+        WHERE key = ?
+      `, [
+        secret.value_encrypted,
+        Date.now(),
+        secret.key
+      ]);
+    } else {
+      await db.exec(`
+        INSERT INTO secrets (
+          key, value_encrypted, created_at, updated_at
+        ) VALUES (?, ?, ?, ?)
+      `, [
+        secret.key,
+        secret.value_encrypted,
+        secret.created_at,
+        secret.updated_at
+      ]);
+    }
+  });
+} 

src/db/sqlite/types.ts

@@ -0,0 +1,349 @@
+/**
+ * SQLite Type Definitions
+ * 
+ * This file defines the type system for the SQLite implementation,
+ * mapping from the existing Dexie types to SQLite-compatible types.
+ * It includes both the database schema types and the runtime types.
+ */
+
+import { SQLiteCompatibleType } from '@jlongster/sql.js';
+
+// ============================================================================
+// Base Types and Utilities
+// ============================================================================
+
+/**
+ * SQLite column type mapping
+ */
+export type SQLiteColumnType = 
+  | 'INTEGER'  // For numbers, booleans, dates
+  | 'TEXT'     // For strings, JSON
+  | 'BLOB'     // For binary data
+  | 'REAL'     // For floating point numbers
+  | 'NULL';    // For null values
+
+/**
+ * SQLite column definition
+ */
+export interface SQLiteColumn {
+  name: string;
+  type: SQLiteColumnType;
+  nullable?: boolean;
+  primaryKey?: boolean;
+  unique?: boolean;
+  references?: {
+    table: string;
+    column: string;
+  };
+  default?: SQLiteCompatibleType;
+}
+
+/**
+ * SQLite table definition
+ */
+export interface SQLiteTable {
+  name: string;
+  columns: SQLiteColumn[];
+  indexes?: Array<{
+    name: string;
+    columns: string[];
+    unique?: boolean;
+  }>;
+}
+
+// ============================================================================
+// Account Types
+// ============================================================================
+
+/**
+ * SQLite-compatible Account type
+ * Maps from the Dexie Account type
+ */
+export interface SQLiteAccount {
+  did: string;                    // TEXT PRIMARY KEY
+  public_key_hex: string;         // TEXT NOT NULL
+  created_at: number;             // INTEGER NOT NULL
+  updated_at: number;             // INTEGER NOT NULL
+  identity_json?: string;         // TEXT (encrypted JSON)
+  mnemonic_encrypted?: string;    // TEXT (encrypted)
+  passkey_cred_id_hex?: string;   // TEXT
+  derivation_path?: string;       // TEXT
+}
+
+export const ACCOUNTS_TABLE: SQLiteTable = {
+  name: 'accounts',
+  columns: [
+    { name: 'did', type: 'TEXT', primaryKey: true },
+    { name: 'public_key_hex', type: 'TEXT', nullable: false },
+    { name: 'created_at', type: 'INTEGER', nullable: false },
+    { name: 'updated_at', type: 'INTEGER', nullable: false },
+    { name: 'identity_json', type: 'TEXT' },
+    { name: 'mnemonic_encrypted', type: 'TEXT' },
+    { name: 'passkey_cred_id_hex', type: 'TEXT' },
+    { name: 'derivation_path', type: 'TEXT' }
+  ],
+  indexes: [
+    { name: 'idx_accounts_created_at', columns: ['created_at'] },
+    { name: 'idx_accounts_updated_at', columns: ['updated_at'] }
+  ]
+};
+
+// ============================================================================
+// Contact Types
+// ============================================================================
+
+/**
+ * SQLite-compatible ContactMethod type
+ */
+export interface SQLiteContactMethod {
+  id: string;                     // TEXT PRIMARY KEY
+  contact_id: string;             // TEXT NOT NULL
+  label: string;                  // TEXT NOT NULL
+  type: string;                   // TEXT NOT NULL
+  value: string;                  // TEXT NOT NULL
+  created_at: number;             // INTEGER NOT NULL
+  updated_at: number;             // INTEGER NOT NULL
+}
+
+/**
+ * SQLite-compatible Contact type
+ */
+export interface SQLiteContact {
+  id: string;                     // TEXT PRIMARY KEY
+  did: string;                    // TEXT NOT NULL
+  name?: string;                  // TEXT
+  notes?: string;                 // TEXT
+  profile_image_url?: string;     // TEXT
+  public_key_base64?: string;     // TEXT
+  next_pub_key_hash_b64?: string; // TEXT
+  sees_me?: boolean;              // INTEGER (0 or 1)
+  registered?: boolean;           // INTEGER (0 or 1)
+  created_at: number;             // INTEGER NOT NULL
+  updated_at: number;             // INTEGER NOT NULL
+}
+
+export const CONTACTS_TABLE: SQLiteTable = {
+  name: 'contacts',
+  columns: [
+    { name: 'id', type: 'TEXT', primaryKey: true },
+    { name: 'did', type: 'TEXT', nullable: false },
+    { name: 'name', type: 'TEXT' },
+    { name: 'notes', type: 'TEXT' },
+    { name: 'profile_image_url', type: 'TEXT' },
+    { name: 'public_key_base64', type: 'TEXT' },
+    { name: 'next_pub_key_hash_b64', type: 'TEXT' },
+    { name: 'sees_me', type: 'INTEGER' },
+    { name: 'registered', type: 'INTEGER' },
+    { name: 'created_at', type: 'INTEGER', nullable: false },
+    { name: 'updated_at', type: 'INTEGER', nullable: false }
+  ],
+  indexes: [
+    { name: 'idx_contacts_did', columns: ['did'] },
+    { name: 'idx_contacts_created_at', columns: ['created_at'] }
+  ]
+};
+
+export const CONTACT_METHODS_TABLE: SQLiteTable = {
+  name: 'contact_methods',
+  columns: [
+    { name: 'id', type: 'TEXT', primaryKey: true },
+    { name: 'contact_id', type: 'TEXT', nullable: false, 
+      references: { table: 'contacts', column: 'id' } },
+    { name: 'label', type: 'TEXT', nullable: false },
+    { name: 'type', type: 'TEXT', nullable: false },
+    { name: 'value', type: 'TEXT', nullable: false },
+    { name: 'created_at', type: 'INTEGER', nullable: false },
+    { name: 'updated_at', type: 'INTEGER', nullable: false }
+  ],
+  indexes: [
+    { name: 'idx_contact_methods_contact_id', columns: ['contact_id'] }
+  ]
+};
+
+// ============================================================================
+// Settings Types
+// ============================================================================
+
+/**
+ * SQLite-compatible Settings type
+ */
+export interface SQLiteSettings {
+  key: string;                    // TEXT PRIMARY KEY
+  account_did?: string;           // TEXT
+  value_json: string;             // TEXT NOT NULL (JSON stringified)
+  created_at: number;             // INTEGER NOT NULL
+  updated_at: number;             // INTEGER NOT NULL
+}
+
+export const SETTINGS_TABLE: SQLiteTable = {
+  name: 'settings',
+  columns: [
+    { name: 'key', type: 'TEXT', primaryKey: true },
+    { name: 'account_did', type: 'TEXT' },
+    { name: 'value_json', type: 'TEXT', nullable: false },
+    { name: 'created_at', type: 'INTEGER', nullable: false },
+    { name: 'updated_at', type: 'INTEGER', nullable: false }
+  ],
+  indexes: [
+    { name: 'idx_settings_account_did', columns: ['account_did'] },
+    { name: 'idx_settings_updated_at', columns: ['updated_at'] }
+  ]
+};
+
+// ============================================================================
+// Log Types
+// ============================================================================
+
+/**
+ * SQLite-compatible Log type
+ */
+export interface SQLiteLog {
+  id: string;                     // TEXT PRIMARY KEY
+  level: string;                  // TEXT NOT NULL
+  message: string;                // TEXT NOT NULL
+  metadata_json?: string;         // TEXT (JSON stringified)
+  created_at: number;             // INTEGER NOT NULL
+}
+
+export const LOGS_TABLE: SQLiteTable = {
+  name: 'logs',
+  columns: [
+    { name: 'id', type: 'TEXT', primaryKey: true },
+    { name: 'level', type: 'TEXT', nullable: false },
+    { name: 'message', type: 'TEXT', nullable: false },
+    { name: 'metadata_json', type: 'TEXT' },
+    { name: 'created_at', type: 'INTEGER', nullable: false }
+  ],
+  indexes: [
+    { name: 'idx_logs_level', columns: ['level'] },
+    { name: 'idx_logs_created_at', columns: ['created_at'] }
+  ]
+};
+
+// ============================================================================
+// Secret Types
+// ============================================================================
+
+/**
+ * SQLite-compatible Secret type
+ * Note: This table should be encrypted at the database level
+ */
+export interface SQLiteSecret {
+  key: string;                    // TEXT PRIMARY KEY
+  value_encrypted: string;        // TEXT NOT NULL (encrypted)
+  created_at: number;             // INTEGER NOT NULL
+  updated_at: number;             // INTEGER NOT NULL
+}
+
+export const SECRETS_TABLE: SQLiteTable = {
+  name: 'secrets',
+  columns: [
+    { name: 'key', type: 'TEXT', primaryKey: true },
+    { name: 'value_encrypted', type: 'TEXT', nullable: false },
+    { name: 'created_at', type: 'INTEGER', nullable: false },
+    { name: 'updated_at', type: 'INTEGER', nullable: false }
+  ],
+  indexes: [
+    { name: 'idx_secrets_updated_at', columns: ['updated_at'] }
+  ]
+};
+
+// ============================================================================
+// Database Schema
+// ============================================================================
+
+/**
+ * Complete database schema definition
+ */
+export const DATABASE_SCHEMA: SQLiteTable[] = [
+  ACCOUNTS_TABLE,
+  CONTACTS_TABLE,
+  CONTACT_METHODS_TABLE,
+  SETTINGS_TABLE,
+  LOGS_TABLE,
+  SECRETS_TABLE
+];
+
+// ============================================================================
+// Type Guards and Validators
+// ============================================================================
+
+/**
+ * Type guard for SQLiteAccount
+ */
+export function isSQLiteAccount(value: unknown): value is SQLiteAccount {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as SQLiteAccount).did === 'string' &&
+    typeof (value as SQLiteAccount).public_key_hex === 'string' &&
+    typeof (value as SQLiteAccount).created_at === 'number' &&
+    typeof (value as SQLiteAccount).updated_at === 'number'
+  );
+}
+
+/**
+ * Type guard for SQLiteContact
+ */
+export function isSQLiteContact(value: unknown): value is SQLiteContact {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as SQLiteContact).id === 'string' &&
+    typeof (value as SQLiteContact).did === 'string' &&
+    typeof (value as SQLiteContact).created_at === 'number' &&
+    typeof (value as SQLiteContact).updated_at === 'number'
+  );
+}
+
+/**
+ * Type guard for SQLiteSettings
+ */
+export function isSQLiteSettings(value: unknown): value is SQLiteSettings {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof (value as SQLiteSettings).key === 'string' &&
+    typeof (value as SQLiteSettings).value_json === 'string' &&
+    typeof (value as SQLiteSettings).created_at === 'number' &&
+    typeof (value as SQLiteSettings).updated_at === 'number'
+  );
+}
+
+// ============================================================================
+// Migration Types
+// ============================================================================
+
+/**
+ * Type for migration data from Dexie to SQLite
+ */
+export interface MigrationData {
+  accounts: SQLiteAccount[];
+  contacts: SQLiteContact[];
+  contactMethods: SQLiteContactMethod[];
+  settings: SQLiteSettings[];
+  logs: SQLiteLog[];
+  secrets: SQLiteSecret[];
+  metadata: {
+    version: string;
+    timestamp: number;
+    source: 'dexie';
+  };
+}
+
+/**
+ * Migration result type
+ */
+export interface MigrationResult {
+  success: boolean;
+  error?: Error;
+  stats: {
+    accounts: number;
+    contacts: number;
+    contactMethods: number;
+    settings: number;
+    logs: number;
+    secrets: number;
+  };
+  duration: number;
+} 

src/db/tables/accounts.ts

@@ -45,12 +45,6 @@ export type Account = {
   publicKeyHex: string;
 };
 
-// When finished with USE_DEXIE_DB, move these fields to Account and move identity and mnemonic here.
-export type AccountEncrypted = Account & {
-  identityEncrBase64: string;
-  mnemonicEncrBase64: string;
-};
-
 /**
  * Schema for the accounts table in the database.
  * Fields starting with a $ character are encrypted.

src/electron/main.js

@@ -0,0 +1,174 @@
+const { app, BrowserWindow } = require("electron");
+const path = require("path");
+const fs = require("fs");
+const logger = require("../utils/logger");
+
+// Check if running in dev mode
+const isDev = process.argv.includes("--inspect");
+
+function createWindow() {
+  // Add before createWindow function
+  const preloadPath = path.join(__dirname, "preload.js");
+  logger.log("Checking preload path:", preloadPath);
+  logger.log("Preload exists:", fs.existsSync(preloadPath));
+
+  // Create the browser window.
+  const mainWindow = new BrowserWindow({
+    width: 1200,
+    height: 800,
+    webPreferences: {
+      nodeIntegration: false,
+      contextIsolation: true,
+      webSecurity: true,
+      allowRunningInsecureContent: false,
+      preload: path.join(__dirname, "preload.js"),
+    },
+  });
+
+  // Always open DevTools for now
+  mainWindow.webContents.openDevTools();
+
+  // Intercept requests to fix asset paths
+  mainWindow.webContents.session.webRequest.onBeforeRequest(
+    {
+      urls: [
+        "file://*/*/assets/*",
+        "file://*/assets/*",
+        "file:///assets/*", // Catch absolute paths
+        "<all_urls>", // Catch all URLs as a fallback
+      ],
+    },
+    (details, callback) => {
+      let url = details.url;
+
+      // Handle paths that don't start with file://
+      if (!url.startsWith("file://") && url.includes("/assets/")) {
+        url = `file://${path.join(__dirname, "www", url)}`;
+      }
+
+      // Handle absolute paths starting with /assets/
+      if (url.includes("/assets/") && !url.includes("/www/assets/")) {
+        const baseDir = url.includes("dist-electron")
+          ? url.substring(
+              0,
+              url.indexOf("/dist-electron") + "/dist-electron".length,
+            )
+          : `file://${__dirname}`;
+        const assetPath = url.split("/assets/")[1];
+        const newUrl = `${baseDir}/www/assets/${assetPath}`;
+        callback({ redirectURL: newUrl });
+        return;
+      }
+
+      callback({}); // No redirect for other URLs
+    },
+  );
+
+  if (isDev) {
+    // Debug info
+    logger.log("Debug Info:");
+    logger.log("Running in dev mode:", isDev);
+    logger.log("App is packaged:", app.isPackaged);
+    logger.log("Process resource path:", process.resourcesPath);
+    logger.log("App path:", app.getAppPath());
+    logger.log("__dirname:", __dirname);
+    logger.log("process.cwd():", process.cwd());
+  }
+
+  const indexPath = path.join(__dirname, "www", "index.html");
+
+  if (isDev) {
+    logger.log("Loading index from:", indexPath);
+    logger.log("www path:", path.join(__dirname, "www"));
+    logger.log("www assets path:", path.join(__dirname, "www", "assets"));
+  }
+
+  if (!fs.existsSync(indexPath)) {
+    logger.error(`Index file not found at: ${indexPath}`);
+    throw new Error("Index file not found");
+  }
+
+  // Add CSP headers to allow API connections
+  mainWindow.webContents.session.webRequest.onHeadersReceived(
+    (details, callback) => {
+      callback({
+        responseHeaders: {
+          ...details.responseHeaders,
+          "Content-Security-Policy": [
+            "default-src 'self';" +
+              "connect-src 'self' https://api.endorser.ch https://*.timesafari.app;" +
+              "img-src 'self' data: https: blob:;" +
+              "script-src 'self' 'unsafe-inline' 'unsafe-eval';" +
+              "style-src 'self' 'unsafe-inline';" +
+              "font-src 'self' data:;",
+          ],
+        },
+      });
+    },
+  );
+
+  // Load the index.html
+  mainWindow
+    .loadFile(indexPath)
+    .then(() => {
+      logger.log("Successfully loaded index.html");
+      if (isDev) {
+        mainWindow.webContents.openDevTools();
+        logger.log("DevTools opened - running in dev mode");
+      }
+    })
+    .catch((err) => {
+      logger.error("Failed to load index.html:", err);
+      logger.error("Attempted path:", indexPath);
+    });
+
+  // Listen for console messages from the renderer
+  mainWindow.webContents.on("console-message", (_event, level, message) => {
+    logger.log("Renderer Console:", message);
+  });
+
+  // Add right after creating the BrowserWindow
+  mainWindow.webContents.on(
+    "did-fail-load",
+    (event, errorCode, errorDescription) => {
+      logger.error("Page failed to load:", errorCode, errorDescription);
+    },
+  );
+
+  mainWindow.webContents.on("preload-error", (event, preloadPath, error) => {
+    logger.error("Preload script error:", preloadPath, error);
+  });
+
+  mainWindow.webContents.on(
+    "console-message",
+    (event, level, message, line, sourceId) => {
+      logger.log("Renderer Console:", line, sourceId, message);
+    },
+  );
+
+  // Enable remote debugging when in dev mode
+  if (isDev) {
+    mainWindow.webContents.openDevTools();
+  }
+}
+
+// Handle app ready
+app.whenReady().then(createWindow);
+
+// Handle all windows closed
+app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
+    app.quit();
+  }
+});
+
+app.on("activate", () => {
+  if (BrowserWindow.getAllWindows().length === 0) {
+    createWindow();
+  }
+});
+
+// Handle any errors
+process.on("uncaughtException", (error) => {
+  logger.error("Uncaught Exception:", error);
+});

src/electron/main.ts

@@ -0,0 +1,187 @@
+import { app, BrowserWindow } from "electron";
+import path from "path";
+import fs from "fs";
+
+// Simple logger implementation
+const logger = {
+  // eslint-disable-next-line no-console
+  log: (...args: unknown[]) => console.log(...args),
+  // eslint-disable-next-line no-console
+  error: (...args: unknown[]) => console.error(...args),
+  // eslint-disable-next-line no-console
+  info: (...args: unknown[]) => console.info(...args),
+  // eslint-disable-next-line no-console
+  warn: (...args: unknown[]) => console.warn(...args),
+  // eslint-disable-next-line no-console
+  debug: (...args: unknown[]) => console.debug(...args),
+};
+
+// Check if running in dev mode
+const isDev = process.argv.includes("--inspect");
+
+function createWindow(): void {
+  // Add before createWindow function
+  const preloadPath = path.join(__dirname, "preload.js");
+  logger.log("Checking preload path:", preloadPath);
+  logger.log("Preload exists:", fs.existsSync(preloadPath));
+
+  // Create the browser window.
+  const mainWindow = new BrowserWindow({
+    width: 1200,
+    height: 800,
+    webPreferences: {
+      nodeIntegration: false,
+      contextIsolation: true,
+      webSecurity: true,
+      allowRunningInsecureContent: false,
+      preload: path.join(__dirname, "preload.js"),
+    },
+  });
+
+  // Always open DevTools for now
+  mainWindow.webContents.openDevTools();
+
+  // Intercept requests to fix asset paths
+  mainWindow.webContents.session.webRequest.onBeforeRequest(
+    {
+      urls: [
+        "file://*/*/assets/*",
+        "file://*/assets/*",
+        "file:///assets/*", // Catch absolute paths
+        "<all_urls>", // Catch all URLs as a fallback
+      ],
+    },
+    (details, callback) => {
+      let url = details.url;
+
+      // Handle paths that don't start with file://
+      if (!url.startsWith("file://") && url.includes("/assets/")) {
+        url = `file://${path.join(__dirname, "www", url)}`;
+      }
+
+      // Handle absolute paths starting with /assets/
+      if (url.includes("/assets/") && !url.includes("/www/assets/")) {
+        const baseDir = url.includes("dist-electron")
+          ? url.substring(
+              0,
+              url.indexOf("/dist-electron") + "/dist-electron".length,
+            )
+          : `file://${__dirname}`;
+        const assetPath = url.split("/assets/")[1];
+        const newUrl = `${baseDir}/www/assets/${assetPath}`;
+        callback({ redirectURL: newUrl });
+        return;
+      }
+
+      callback({}); // No redirect for other URLs
+    },
+  );
+
+  if (isDev) {
+    // Debug info
+    logger.log("Debug Info:");
+    logger.log("Running in dev mode:", isDev);
+    logger.log("App is packaged:", app.isPackaged);
+    logger.log("Process resource path:", process.resourcesPath);
+    logger.log("App path:", app.getAppPath());
+    logger.log("__dirname:", __dirname);
+    logger.log("process.cwd():", process.cwd());
+  }
+
+  const indexPath = path.join(__dirname, "www", "index.html");
+
+  if (isDev) {
+    logger.log("Loading index from:", indexPath);
+    logger.log("www path:", path.join(__dirname, "www"));
+    logger.log("www assets path:", path.join(__dirname, "www", "assets"));
+  }
+
+  if (!fs.existsSync(indexPath)) {
+    logger.error(`Index file not found at: ${indexPath}`);
+    throw new Error("Index file not found");
+  }
+
+  // Add CSP headers to allow API connections
+  mainWindow.webContents.session.webRequest.onHeadersReceived(
+    (details, callback) => {
+      callback({
+        responseHeaders: {
+          ...details.responseHeaders,
+          "Content-Security-Policy": [
+            "default-src 'self';" +
+              "connect-src 'self' https://api.endorser.ch https://*.timesafari.app;" +
+              "img-src 'self' data: https: blob:;" +
+              "script-src 'self' 'unsafe-inline' 'unsafe-eval';" +
+              "style-src 'self' 'unsafe-inline';" +
+              "font-src 'self' data:;",
+          ],
+        },
+      });
+    },
+  );
+
+  // Load the index.html
+  mainWindow
+    .loadFile(indexPath)
+    .then(() => {
+      logger.log("Successfully loaded index.html");
+      if (isDev) {
+        mainWindow.webContents.openDevTools();
+        logger.log("DevTools opened - running in dev mode");
+      }
+    })
+    .catch((err) => {
+      logger.error("Failed to load index.html:", err);
+      logger.error("Attempted path:", indexPath);
+    });
+
+  // Listen for console messages from the renderer
+  mainWindow.webContents.on("console-message", (_event, _level, message) => {
+    logger.log("Renderer Console:", message);
+  });
+
+  // Add right after creating the BrowserWindow
+  mainWindow.webContents.on(
+    "did-fail-load",
+    (_event, errorCode, errorDescription) => {
+      logger.error("Page failed to load:", errorCode, errorDescription);
+    },
+  );
+
+  mainWindow.webContents.on("preload-error", (_event, preloadPath, error) => {
+    logger.error("Preload script error:", preloadPath, error);
+  });
+
+  mainWindow.webContents.on(
+    "console-message",
+    (_event, _level, message, line, sourceId) => {
+      logger.log("Renderer Console:", line, sourceId, message);
+    },
+  );
+
+  // Enable remote debugging when in dev mode
+  if (isDev) {
+    mainWindow.webContents.openDevTools();
+  }
+}
+
+// Handle app ready
+app.whenReady().then(createWindow);
+
+// Handle all windows closed
+app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
+    app.quit();
+  }
+});
+
+app.on("activate", () => {
+  if (BrowserWindow.getAllWindows().length === 0) {
+    createWindow();
+  }
+});
+
+// Handle any errors
+process.on("uncaughtException", (error) => {
+  logger.error("Uncaught Exception:", error);
+});

src/electron/preload.js

@@ -0,0 +1,78 @@
+const { contextBridge, ipcRenderer } = require("electron");
+
+const logger = {
+  log: (message, ...args) => {
+    if (process.env.NODE_ENV !== "production") {
+      /* eslint-disable no-console */
+      console.log(message, ...args);
+      /* eslint-enable no-console */
+    }
+  },
+  warn: (message, ...args) => {
+    if (process.env.NODE_ENV !== "production") {
+      /* eslint-disable no-console */
+      console.warn(message, ...args);
+      /* eslint-enable no-console */
+    }
+  },
+  error: (message, ...args) => {
+    /* eslint-disable no-console */
+    console.error(message, ...args); // Errors should always be logged
+    /* eslint-enable no-console */
+  },
+};
+
+// Use a more direct path resolution approach
+const getPath = (pathType) => {
+  switch (pathType) {
+    case "userData":
+      return (
+        process.env.APPDATA ||
+        (process.platform === "darwin"
+          ? `${process.env.HOME}/Library/Application Support`
+          : `${process.env.HOME}/.local/share`)
+      );
+    case "home":
+      return process.env.HOME;
+    case "appPath":
+      return process.resourcesPath;
+    default:
+      return "";
+  }
+};
+
+logger.log("Preload script starting...");
+
+try {
+  contextBridge.exposeInMainWorld("electronAPI", {
+    // Path utilities
+    getPath,
+
+    // IPC functions
+    send: (channel, data) => {
+      const validChannels = ["toMain"];
+      if (validChannels.includes(channel)) {
+        ipcRenderer.send(channel, data);
+      }
+    },
+    receive: (channel, func) => {
+      const validChannels = ["fromMain"];
+      if (validChannels.includes(channel)) {
+        ipcRenderer.on(channel, (event, ...args) => func(...args));
+      }
+    },
+    // Environment info
+    env: {
+      isElectron: true,
+      isDev: process.env.NODE_ENV === "development",
+    },
+    // Path utilities
+    getBasePath: () => {
+      return process.env.NODE_ENV === "development" ? "/" : "./";
+    },
+  });
+
+  logger.log("Preload script completed successfully");
+} catch (error) {
+  logger.error("Error in preload script:", error);
+}

src/interfaces/absurd-sql.d.ts

@@ -1,59 +0,0 @@
-import type { QueryExecResult, SqlValue } from "./database";
-
-declare module "@jlongster/sql.js" {
-  interface SQL {
-    Database: new (path: string, options?: { filename: boolean }) => AbsurdSqlDatabase;
-    FS: {
-      mkdir: (path: string) => void;
-      mount: (fs: any, options: any, path: string) => void;
-      open: (path: string, flags: string) => any;
-      close: (stream: any) => void;
-    };
-    register_for_idb: (fs: any) => void;
-  }
-
-  interface AbsurdSqlDatabase {
-    exec: (sql: string, params?: unknown[]) => Promise<QueryExecResult[]>;
-    run: (
-      sql: string,
-      params?: unknown[],
-    ) => Promise<{ changes: number; lastId?: number }>;
-  }
-
-  const initSqlJs: (options?: {
-    locateFile?: (file: string) => string;
-  }) => Promise<SQL>;
-
-  export default initSqlJs;
-}
-
-declare module "absurd-sql" {
-  import type { SQL } from "@jlongster/sql.js";
-
-  export class SQLiteFS {
-    constructor(fs: any, backend: any);
-  }
-}
-
-declare module "absurd-sql/dist/indexeddb-backend" {
-  export default class IndexedDBBackend {
-    constructor();
-  }
-}
-
-declare module "absurd-sql/dist/indexeddb-main-thread" {
-  export interface SQLiteOptions {
-    filename?: string;
-    autoLoad?: boolean;
-    debug?: boolean;
-  }
-
-  export interface SQLiteDatabase {
-    exec: (sql: string, params?: unknown[]) => Promise<QueryExecResult[]>;
-    close: () => Promise<void>;
-  }
-
-  export function initSqlJs(options?: any): Promise<any>;
-  export function createDatabase(options?: SQLiteOptions): Promise<SQLiteDatabase>;
-  export function openDatabase(options?: SQLiteOptions): Promise<SQLiteDatabase>;
-} 

src/interfaces/claims.ts

@@ -1,24 +1,15 @@
-/**
- * Types of Claims
- *
- * Note that these are for the claims that get signed.
- * Records that are the latest edited entities are in the records.ts file.
- *
- */
+import { GenericVerifiableCredential } from "./common";
 
-import { ClaimObject } from "./common";
-
-export interface AgreeActionClaim extends ClaimObject {
-  "@context": "https://schema.org";
+export interface AgreeVerifiableCredential {
+  "@context": string;
   "@type": string;
   object: Record<string, unknown>;
 }
 
 // Note that previous VCs may have additional fields.
 // https://endorser.ch/doc/html/transactions.html#id4
-export interface GiveActionClaim extends ClaimObject {
-  // context is optional because it might be embedded in another claim, eg. an AgreeAction
-  "@context"?: "https://schema.org";
+export interface GiveVerifiableCredential extends GenericVerifiableCredential {
+  "@context"?: string;
   "@type": "GiveAction";
   agent?: { identifier: string };
   description?: string;
@@ -26,25 +17,16 @@ export interface GiveActionClaim extends ClaimObject {
   identifier?: string;
   image?: string;
   object?: { amountOfThisGood: number; unitCode: string };
-  provider?: ClaimObject;
+  provider?: GenericVerifiableCredential;
   recipient?: { identifier: string };
 }
 
-export interface JoinActionClaim extends ClaimObject {
-  agent?: { identifier: string };
-  event?: { organizer?: { name: string }; name?: string; startTime?: string };
-}
-
 // Note that previous VCs may have additional fields.
 // https://endorser.ch/doc/html/transactions.html#id8
-export interface OfferClaim extends ClaimObject {
-  "@context": "https://schema.org";
+export interface OfferVerifiableCredential extends GenericVerifiableCredential {
+  "@context"?: string;
   "@type": "Offer";
-  agent?: { identifier: string };
   description?: string;
-  fulfills?: { "@type": string; identifier?: string; lastClaimId?: string }[];
-  identifier?: string;
-  image?: string;
   includesObject?: { amountOfThisGood: number; unitCode: string };
   itemOffered?: {
     description?: string;
@@ -55,18 +37,14 @@ export interface OfferClaim extends ClaimObject {
       name?: string;
     };
   };
-  offeredBy?: {
-    type?: "Person";
-    identifier: string;
-  };
-  provider?: ClaimObject;
+  offeredBy?: { identifier: string };
   recipient?: { identifier: string };
   validThrough?: string;
 }
 
 // Note that previous VCs may have additional fields.
 // https://endorser.ch/doc/html/transactions.html#id7
-export interface PlanActionClaim extends ClaimObject {
+export interface PlanVerifiableCredential extends GenericVerifiableCredential {
   "@context": "https://schema.org";
   "@type": "PlanAction";
   name: string;
@@ -80,18 +58,11 @@ export interface PlanActionClaim extends ClaimObject {
 }
 
 // AKA Registration & RegisterAction
-export interface RegisterActionClaim extends ClaimObject {
-  "@context": "https://schema.org";
+export interface RegisterVerifiableCredential {
+  "@context": string;
   "@type": "RegisterAction";
   agent: { identifier: string };
   identifier?: string;
-  object?: string;
+  object: string;
   participant?: { identifier: string };
 }
-
-export interface TenureClaim extends ClaimObject {
-  "@context": "https://endorser.ch";
-  "@type": "Tenure";
-  party?: { identifier: string };
-  spatialUnit?: { geo?: { polygon?: string } };
-}

src/interfaces/common.ts

@@ -34,77 +34,3 @@ export interface ErrorResult extends ResultWithType {
   type: "error";
   error: InternalError;
 }
-
-export interface KeyMeta {
-  did: string;
-  publicKeyHex: string;
-  derivationPath?: string;
-  passkeyCredIdHex?: string; // The Webauthn credential ID in hex, if this is from a passkey
-}
-
-export interface KeyMetaMaybeWithPrivate extends KeyMeta {
-  mnemonic?: string; // 12 or 24 words encoding the seed
-  identity?: string; // Stringified IIdentifier object from Veramo
-}
-
-export interface KeyMetaWithPrivate extends KeyMeta {
-  mnemonic: string; // 12 or 24 words encoding the seed
-  identity: string; // Stringified IIdentifier object from Veramo
-}
-
-export interface QuantitativeValue extends GenericVerifiableCredential {
-  "@type": "QuantitativeValue";
-  "@context"?: string;
-  amountOfThisGood: number;
-  unitCode: string;
-}
-
-export interface AxiosErrorResponse {
-  message?: string;
-  response?: {
-    data?: {
-      error?: {
-        message?: string;
-      };
-      [key: string]: unknown;
-    };
-    status?: number;
-    config?: unknown;
-  };
-  config?: unknown;
-  [key: string]: unknown;
-}
-
-export interface UserInfo {
-  did: string;
-  name: string;
-  publicEncKey: string;
-  registered: boolean;
-  profileImageUrl?: string;
-  nextPublicEncKeyHash?: string;
-}
-
-export interface CreateAndSubmitClaimResult {
-  success: boolean;
-  error?: string;
-  handleId?: string;
-}
-
-export interface Agent {
-  identifier?: string;
-  did?: string;
-}
-
-export interface ClaimObject {
-  "@type": string;
-  "@context"?: string;
-  [key: string]: unknown;
-}
-
-export interface VerifiableCredentialClaim {
-  "@context"?: string;
-  "@type": string;
-  type: string[];
-  credentialSubject: ClaimObject;
-  [key: string]: unknown;
-}

src/interfaces/database.ts

@@ -1,17 +0,0 @@
-export type SqlValue = string | number | null | Uint8Array;
-
-export interface QueryExecResult {
-  columns: Array<string>;
-  values: Array<Array<SqlValue>>;
-}
-
-export interface DatabaseService {
-  initialize(): Promise<void>;
-  query(sql: string, params?: unknown[]): Promise<QueryExecResult[]>;
-  run(
-    sql: string,
-    params?: unknown[],
-  ): Promise<{ changes: number; lastId?: number }>;
-  getOneRow(sql: string, params?: unknown[]): Promise<unknown[] | undefined>;
-  getAll(sql: string, params?: unknown[]): Promise<unknown[][]>;
-}

src/interfaces/index.ts

@@ -1,38 +1,7 @@
-export type {
-  // From common.ts
-  GenericCredWrapper,
-  GenericVerifiableCredential,
-  KeyMeta,
-  // Exclude types that are also exported from other files
-  // GiveVerifiableCredential,
-  // OfferVerifiableCredential,
-  // RegisterVerifiableCredential,
-  // PlanSummaryRecord,
-  // UserInfo,
-} from "./common";
-
-export type {
-  // From claims.ts
-  GiveActionClaim,
-  OfferClaim,
-  RegisterActionClaim,
-} from "./claims";
-
-export type {
-  // From claims-result.ts
-  CreateAndSubmitClaimResult,
-} from "./claims-result";
-
-export type {
-  // From records.ts
-  PlanSummaryRecord,
-  GiveSummaryRecord,
-} from "./records";
-
-export type {
-  // From user.ts
-  UserInfo,
-} from "./user";
-
+export * from "./claims";
+export * from "./claims-result";
+export * from "./common";
 export * from "./limits";
+export * from "./records";
+export * from "./user";
 export * from "./deepLinks";

src/interfaces/records.ts

@@ -1,14 +1,14 @@
-import { GiveActionClaim, OfferClaim } from "./claims";
+import { GiveVerifiableCredential, OfferVerifiableCredential } from "./claims";
 
 // a summary record; the VC is found the fullClaim field
 export interface GiveSummaryRecord {
-  [x: string]: PropertyKey | undefined | GiveActionClaim;
+  [x: string]: PropertyKey | undefined | GiveVerifiableCredential;
   type?: string;
   agentDid: string;
   amount: number;
   amountConfirmed: number;
   description: string;
-  fullClaim: GiveActionClaim;
+  fullClaim: GiveVerifiableCredential;
   fulfillsHandleId: string;
   fulfillsPlanHandleId?: string;
   fulfillsType?: string;
@@ -26,7 +26,7 @@ export interface OfferSummaryRecord {
   amount: number;
   amountGiven: number;
   amountGivenConfirmed: number;
-  fullClaim: OfferClaim;
+  fullClaim: OfferVerifiableCredential;
   fulfillsPlanHandleId: string;
   handleId: string;
   issuerDid: string;

src/libs/crypto/index.ts

@@ -159,7 +159,7 @@ export const nextDerivationPath = (origDerivPath: string) => {
 };
 
 // Base64 encoding/decoding utilities for browser
-export function base64ToArrayBuffer(base64: string): Uint8Array {
+function base64ToArrayBuffer(base64: string): Uint8Array {
   const binaryString = atob(base64);
   const bytes = new Uint8Array(binaryString.length);
   for (let i = 0; i < binaryString.length; i++) {
@@ -168,7 +168,7 @@ export function base64ToArrayBuffer(base64: string): Uint8Array {
   return bytes;
 }
 
-export function arrayBufferToBase64(buffer: ArrayBuffer): string {
+function arrayBufferToBase64(buffer: ArrayBuffer): string {
   const binary = String.fromCharCode(...new Uint8Array(buffer));
   return btoa(binary);
 }
@@ -178,7 +178,7 @@ const IV_LENGTH = 12;
 const KEY_LENGTH = 256;
 const ITERATIONS = 100000;
 
-// Message encryption helper function, used for onboarding meeting messages
+// Encryption helper function
 export async function encryptMessage(message: string, password: string) {
   const encoder = new TextEncoder();
   const salt = crypto.getRandomValues(new Uint8Array(SALT_LENGTH));
@@ -226,7 +226,7 @@ export async function encryptMessage(message: string, password: string) {
   return btoa(JSON.stringify(result));
 }
 
-// Message decryption helper function, used for onboarding meeting messages
+// Decryption helper function
 export async function decryptMessage(encryptedJson: string, password: string) {
   const decoder = new TextDecoder();
   const { salt, iv, encrypted } = JSON.parse(atob(encryptedJson));
@@ -273,7 +273,7 @@ export async function decryptMessage(encryptedJson: string, password: string) {
 }
 
 // Test function to verify encryption/decryption
-export async function testMessageEncryptionDecryption() {
+export async function testEncryptionDecryption() {
   try {
     const testMessage = "Hello, this is a test message! 🚀";
     const testPassword = "myTestPassword123";
@@ -299,111 +299,9 @@ export async function testMessageEncryptionDecryption() {
     logger.log("\nTesting with wrong password...");
     try {
       await decryptMessage(encrypted, "wrongPassword");
-      logger.log("Incorrectly decrypted with wrong password ❌");
+      logger.log("Should not reach here");
     } catch (error) {
-      logger.log("Correctly failed to decrypt with wrong password ✅");
-    }
-
-    return success;
-  } catch (error) {
-    logger.error("Test failed with error:", error);
-    return false;
-  }
-}
-
-// Simple encryption using Node's crypto, used for the initial encryption of the identity and mnemonic
-export async function simpleEncrypt(
-  text: string,
-  secret: ArrayBuffer,
-): Promise<ArrayBuffer> {
-  const iv = crypto.getRandomValues(new Uint8Array(16));
-
-  // Derive a 256-bit key from the secret using SHA-256
-  const keyData = await crypto.subtle.digest("SHA-256", secret);
-  const key = await crypto.subtle.importKey(
-    "raw",
-    keyData,
-    { name: "AES-GCM" },
-    false,
-    ["encrypt"],
-  );
-
-  const encrypted = await crypto.subtle.encrypt(
-    { name: "AES-GCM", iv },
-    key,
-    new TextEncoder().encode(text),
-  );
-
-  // Combine IV and encrypted data
-  const result = new Uint8Array(iv.length + encrypted.byteLength);
-  result.set(iv);
-  result.set(new Uint8Array(encrypted), iv.length);
-
-  return result.buffer;
-}
-
-// Simple decryption using Node's crypto, used for the default decryption of identity and mnemonic
-export async function simpleDecrypt(
-  encryptedText: ArrayBuffer,
-  secret: ArrayBuffer,
-): Promise<string> {
-  const data = new Uint8Array(encryptedText);
-
-  // Extract IV and encrypted data
-  const iv = data.slice(0, 16);
-  const encrypted = data.slice(16);
-
-  // Derive the same 256-bit key from the secret using SHA-256
-  const keyData = await crypto.subtle.digest("SHA-256", secret);
-  const key = await crypto.subtle.importKey(
-    "raw",
-    keyData,
-    { name: "AES-GCM" },
-    false,
-    ["decrypt"],
-  );
-
-  const decrypted = await crypto.subtle.decrypt(
-    { name: "AES-GCM", iv },
-    key,
-    encrypted,
-  );
-
-  return new TextDecoder().decode(decrypted);
-}
-
-// Test function for simple encryption/decryption
-export async function testSimpleEncryptionDecryption() {
-  try {
-    const testMessage = "Hello, this is a test message! 🚀";
-    const testSecret = crypto.getRandomValues(new Uint8Array(32));
-
-    logger.log("Original message:", testMessage);
-
-    // Test encryption
-    logger.log("Encrypting...");
-    const encrypted = await simpleEncrypt(testMessage, testSecret);
-    const encryptedBase64 = arrayBufferToBase64(encrypted);
-    logger.log("Encrypted result:", encryptedBase64);
-
-    // Test decryption
-    logger.log("Decrypting...");
-    const encryptedArrayBuffer = base64ToArrayBuffer(encryptedBase64);
-    const decrypted = await simpleDecrypt(encryptedArrayBuffer, testSecret);
-    logger.log("Decrypted result:", decrypted);
-
-    // Verify
-    const success = testMessage === decrypted;
-    logger.log("Test " + (success ? "PASSED ✅" : "FAILED ❌"));
-    logger.log("Messages match:", success);
-
-    // Test with wrong secret
-    logger.log("\nTesting with wrong secret...");
-    try {
-      await simpleDecrypt(encryptedArrayBuffer, new Uint8Array(32));
-      logger.log("Incorrectly decrypted with wrong secret ❌");
-    } catch (error) {
-      logger.log("Correctly failed to decrypt with wrong secret ✅");
+      logger.log("Correctly failed with wrong password ✅");
     }
 
     return success;

src/libs/crypto/vc/index.ts

@@ -17,12 +17,29 @@ import { didEthLocalResolver } from "./did-eth-local-resolver";
 import { PEER_DID_PREFIX, verifyPeerSignature } from "./didPeer";
 import { base64urlDecodeString, createDidPeerJwt } from "./passkeyDidPeer";
 import { urlBase64ToUint8Array } from "./util";
-import { KeyMeta, KeyMetaWithPrivate } from "../../../interfaces/common";
 
 export const ETHR_DID_PREFIX = "did:ethr:";
 export const JWT_VERIFY_FAILED_CODE = "JWT_VERIFY_FAILED";
 export const UNSUPPORTED_DID_METHOD_CODE = "UNSUPPORTED_DID_METHOD";
 
+/**
+ * Meta info about a key
+ */
+export interface KeyMeta {
+  /**
+   * Decentralized ID for the key
+   */
+  did: string;
+  /**
+   * Stringified IIDentifier object from Veramo
+   */
+  identity?: string;
+  /**
+   * The Webauthn credential ID in hex, if this is from a passkey
+   */
+  passkeyCredIdHex?: string;
+}
+
 const ethLocalResolver = new Resolver({ ethr: didEthLocalResolver });
 
 /**
@@ -34,7 +51,7 @@ export function isFromPasskey(keyMeta?: KeyMeta): boolean {
 }
 
 export async function createEndorserJwtForKey(
-  account: KeyMetaWithPrivate,
+  account: KeyMeta,
   payload: object,
   expiresIn?: number,
 ) {

src/libs/crypto/vc/passkeyDidPeer.ts

@@ -1,6 +1,7 @@
 import { Buffer } from "buffer/";
 import { JWTPayload } from "did-jwt";
-import { p256 } from "@noble/curves/p256";
+import { DIDResolutionResult } from "did-resolver";
+import { sha256 } from "ethereum-cryptography/sha256.js";
 import {
   startAuthentication,
   startRegistration,
@@ -10,13 +11,12 @@ import {
   generateRegistrationOptions,
   verifyAuthenticationResponse,
   verifyRegistrationResponse,
-  VerifyAuthenticationResponseOpts,
 } from "@simplewebauthn/server";
+import { VerifyAuthenticationResponseOpts } from "@simplewebauthn/server/esm/authentication/verifyAuthenticationResponse";
 import {
   Base64URLString,
   PublicKeyCredentialCreationOptionsJSON,
   PublicKeyCredentialRequestOptionsJSON,
-  AuthenticatorAssertionResponse,
 } from "@simplewebauthn/types";
 
 import { AppString } from "../../../constants/app";
@@ -194,19 +194,16 @@ export class PeerSetup {
       },
     };
 
-    const credential = (await navigator.credentials.get(
-      options,
-    )) as PublicKeyCredential;
+    const credential = await navigator.credentials.get(options);
     // console.log("nav credential get", credential);
 
-    const response = credential?.response as AuthenticatorAssertionResponse;
-    this.authenticatorData = response?.authenticatorData;
+    this.authenticatorData = credential?.response.authenticatorData;
     const authenticatorDataBase64Url = arrayBufferToBase64URLString(
       this.authenticatorData as ArrayBuffer,
     );
 
     this.clientDataJsonBase64Url = arrayBufferToBase64URLString(
-      response?.clientDataJSON,
+      credential?.response.clientDataJSON,
     );
 
     // Our custom type of JWANT means the signature is based on a concatenation of the two Webauthn properties
@@ -231,7 +228,9 @@ export class PeerSetup {
       .replace(/\//g, "_")
       .replace(/=+$/, "");
 
-    const origSignature = Buffer.from(response?.signature).toString("base64");
+    const origSignature = Buffer.from(credential?.response.signature).toString(
+      "base64",
+    );
     this.signature = origSignature
       .replace(/\+/g, "-")
       .replace(/\//g, "_")
@@ -316,18 +315,24 @@ export async function createDidPeerJwt(
 // ... and this import:
 // import { p256 } from "@noble/curves/p256";
 export async function verifyJwtP256(
+  credIdHex: string,
   issuerDid: string,
   authenticatorData: ArrayBuffer,
   challenge: Uint8Array,
+  clientDataJsonBase64Url: Base64URLString,
   signature: Base64URLString,
 ) {
   const authDataFromBase = Buffer.from(authenticatorData);
+  const clientDataFromBase = Buffer.from(clientDataJsonBase64Url, "base64");
   const sigBuffer = Buffer.from(signature, "base64");
   const finalSigBuffer = unwrapEC2Signature(sigBuffer);
   const publicKeyBytes = peerDidToPublicKeyBytes(issuerDid);
 
-  // Use challenge in preimage construction
-  const preimage = Buffer.concat([authDataFromBase, Buffer.from(challenge)]);
+  // Hash the client data
+  const hash = sha256(clientDataFromBase);
+
+  // Construct the preimage
+  const preimage = Buffer.concat([authDataFromBase, hash]);
 
   const isValid = p256.verify(
     finalSigBuffer,
@@ -378,37 +383,122 @@ export async function verifyJwtSimplewebauthn(
 
 // similar code is in endorser-ch util-crypto.ts verifyPeerSignature
 export async function verifyJwtWebCrypto(
+  credId: Base64URLString,
   issuerDid: string,
   authenticatorData: ArrayBuffer,
   challenge: Uint8Array,
+  clientDataJsonBase64Url: Base64URLString,
   signature: Base64URLString,
 ) {
   const authDataFromBase = Buffer.from(authenticatorData);
+  const clientDataFromBase = Buffer.from(clientDataJsonBase64Url, "base64");
   const sigBuffer = Buffer.from(signature, "base64");
   const finalSigBuffer = unwrapEC2Signature(sigBuffer);
 
-  // Use challenge in preimage construction
-  const preimage = Buffer.concat([authDataFromBase, Buffer.from(challenge)]);
+  // Hash the client data
+  const hash = sha256(clientDataFromBase);
 
+  // Construct the preimage
+  const preimage = Buffer.concat([authDataFromBase, hash]);
   return verifyPeerSignature(preimage, issuerDid, finalSigBuffer);
 }
 
-// Remove unused functions:
-// - peerDidToDidDocument
-// - COSEtoPEM
-// - base64urlDecodeArrayBuffer
-// - base64urlEncodeArrayBuffer
-// - pemToCryptoKey
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+async function peerDidToDidDocument(did: string): Promise<DIDResolutionResult> {
+  if (!did.startsWith("did:peer:0z")) {
+    throw new Error(
+      "This only verifies a peer DID, method 0, encoded base58btc.",
+    );
+  }
+  // this is basically hard-coded from https://www.w3.org/TR/did-core/#example-various-verification-method-types
+  // (another reference is the @aviarytech/did-peer resolver)
 
-// Keep only the used functions:
+  /**
+   * Looks like JsonWebKey2020 isn't too difficult:
+   * - change context security/suites link to jws-2020/v1
+   * - change publicKeyMultibase to publicKeyJwk generated with cborToKeys
+   * - change type to JsonWebKey2020
+   */
+
+  const id = did.split(":")[2];
+  const multibase = id.slice(1);
+  const encnumbasis = multibase.slice(1);
+  const didDocument = {
+    "@context": [
+      "https://www.w3.org/ns/did/v1",
+      "https://w3id.org/security/suites/secp256k1-2019/v1",
+    ],
+    assertionMethod: [did + "#" + encnumbasis],
+    authentication: [did + "#" + encnumbasis],
+    capabilityDelegation: [did + "#" + encnumbasis],
+    capabilityInvocation: [did + "#" + encnumbasis],
+    id: did,
+    keyAgreement: undefined,
+    service: undefined,
+    verificationMethod: [
+      {
+        controller: did,
+        id: did + "#" + encnumbasis,
+        publicKeyMultibase: multibase,
+        type: "EcdsaSecp256k1VerificationKey2019",
+      },
+    ],
+  };
+  return {
+    didDocument,
+    didDocumentMetadata: {},
+    didResolutionMetadata: { contentType: "application/did+ld+json" },
+  };
+}
+
+// convert COSE public key to PEM format
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function COSEtoPEM(cose: Buffer) {
+  // const alg = cose.get(3); // Algorithm
+  const x = cose[-2]; // x-coordinate
+  const y = cose[-3]; // y-coordinate
+
+  // Ensure the coordinates are in the correct format
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error because it complains about the type of x and y
+  const pubKeyBuffer = Buffer.concat([Buffer.from([0x04]), x, y]);
+
+  // Convert to PEM format
+  const pem = `-----BEGIN PUBLIC KEY-----
+${pubKeyBuffer.toString("base64")}
+-----END PUBLIC KEY-----`;
+
+  return pem;
+}
+
+// tried the base64url library but got an error using their Buffer
 export function base64urlDecodeString(input: string) {
   return atob(input.replace(/-/g, "+").replace(/_/g, "/"));
 }
 
+// tried the base64url library but got an error using their Buffer
 export function base64urlEncodeString(input: string) {
   return btoa(input).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function base64urlDecodeArrayBuffer(input: string) {
+  input = input.replace(/-/g, "+").replace(/_/g, "/");
+  const pad = input.length % 4 === 0 ? "" : "====".slice(input.length % 4);
+  const str = atob(input + pad);
+  const bytes = new Uint8Array(str.length);
+  for (let i = 0; i < str.length; i++) {
+    bytes[i] = str.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function base64urlEncodeArrayBuffer(buffer: ArrayBuffer) {
+  const str = String.fromCharCode(...new Uint8Array(buffer));
+  return base64urlEncodeString(str);
+}
+
 // from @simplewebauthn/browser
 function arrayBufferToBase64URLString(buffer: ArrayBuffer) {
   const bytes = new Uint8Array(buffer);
@@ -433,3 +523,28 @@ function base64URLStringToArrayBuffer(base64URLString: string) {
   }
   return buffer;
 }
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+async function pemToCryptoKey(pem: string) {
+  const binaryDerString = atob(
+    pem
+      .split("\n")
+      .filter((x) => !x.includes("-----"))
+      .join(""),
+  );
+  const binaryDer = new Uint8Array(binaryDerString.length);
+  for (let i = 0; i < binaryDerString.length; i++) {
+    binaryDer[i] = binaryDerString.charCodeAt(i);
+  }
+  // console.log("binaryDer", binaryDer.buffer);
+  return await window.crypto.subtle.importKey(
+    "spki",
+    binaryDer.buffer,
+    {
+      name: "RSASSA-PKCS1-v1_5",
+      hash: "SHA-256",
+    },
+    true,
+    ["verify"],
+  );
+}

src/libs/endorserServer.ts

@@ -26,42 +26,29 @@ import {
   DEFAULT_IMAGE_API_SERVER,
   NotificationIface,
   APP_SERVER,
-  USE_DEXIE_DB,
 } from "../constants/app";
 import { Contact } from "../db/tables/contacts";
 import { accessToken, deriveAddress, nextDerivationPath } from "../libs/crypto";
-import { NonsensitiveDexie } from "../db/index";
-import { logConsoleAndDb } from "../db/databaseUtil";
+import { logConsoleAndDb, NonsensitiveDexie } from "../db/index";
+
 import {
   retrieveAccountMetadata,
   retrieveFullyDecryptedAccount,
   getPasskeyExpirationSeconds,
 } from "../libs/util";
-import { createEndorserJwtForKey } from "../libs/crypto/vc";
-import {
-  GiveActionClaim,
-  JoinActionClaim,
-  OfferClaim,
-  PlanActionClaim,
-  RegisterActionClaim,
-  TenureClaim,
-} from "../interfaces/claims";
+import { createEndorserJwtForKey, KeyMeta } from "../libs/crypto/vc";
 
 import {
-  GenericCredWrapper,
+  GiveVerifiableCredential,
+  OfferVerifiableCredential,
+  RegisterVerifiableCredential,
   GenericVerifiableCredential,
-  AxiosErrorResponse,
+  GenericCredWrapper,
+  PlanSummaryRecord,
   UserInfo,
   CreateAndSubmitClaimResult,
-  ClaimObject,
-  VerifiableCredentialClaim,
-  QuantitativeValue,
-  KeyMetaWithPrivate,
-  KeyMetaMaybeWithPrivate,
-} from "../interfaces/common";
-import { PlanSummaryRecord } from "../interfaces/records";
+} from "../interfaces";
 import { logger } from "../utils/logger";
-import { PlatformServiceFactory } from "@/services/PlatformServiceFactory";
 
 /**
  * Standard context for schema.org data
@@ -113,10 +100,7 @@ export const ENDORSER_CH_HANDLE_PREFIX = "https://endorser.ch/entity/";
 
 export const BLANK_GENERIC_SERVER_RECORD: GenericCredWrapper<GenericVerifiableCredential> =
   {
-    claim: {
-      "@context": SCHEMA_ORG_CONTEXT,
-      "@type": "",
-    },
+    claim: { "@type": "" },
     handleId: "",
     id: "",
     issuedAt: "",
@@ -196,21 +180,37 @@ export function isEmptyOrHiddenDid(did?: string): boolean {
  * };
  * testRecursivelyOnStrings(isHiddenDid, obj); // Returns: true
  */
-const testRecursivelyOnStrings = (
+function testRecursivelyOnStrings(
+  func: (arg0: unknown) => boolean,
   input: unknown,
-  test: (s: string) => boolean,
-): boolean => {
-  if (typeof input === "string") {
-    return test(input);
-  } else if (Array.isArray(input)) {
-    return input.some((item) => testRecursivelyOnStrings(item, test));
-  } else if (input && typeof input === "object") {
-    return Object.values(input as Record<string, unknown>).some((value) =>
-      testRecursivelyOnStrings(value, test),
-    );
+): boolean {
+  // Test direct string values
+  if (Object.prototype.toString.call(input) === "[object String]") {
+    return func(input);
   }
-  return false;
-};
+  // Recursively test objects and arrays
+  else if (input instanceof Object) {
+    if (!Array.isArray(input)) {
+      // Handle plain objects
+      for (const key in input) {
+        if (testRecursivelyOnStrings(func, input[key])) {
+          return true;
+        }
+      }
+    } else {
+      // Handle arrays
+      for (const value of input) {
+        if (testRecursivelyOnStrings(func, value)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  } else {
+    // Non-string, non-object values can't contain strings
+    return false;
+  }
+}
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function containsHiddenDid(obj: any) {
@@ -551,11 +551,7 @@ export async function setPlanInCache(
  * @returns {string|undefined} User-friendly message or undefined if none found
  */
 export function serverMessageForUser(error: unknown): string | undefined {
-  if (error && typeof error === "object" && "response" in error) {
-    const err = error as AxiosErrorResponse;
-    return err.response?.data?.error?.message;
-  }
-  return undefined;
+  return error?.response?.data?.error?.message;
 }
 
 /**
@@ -577,27 +573,18 @@ export function errorStringForLog(error: unknown) {
     // --- property '_value' closes the circle
   }
   let fullError = "" + error + " - JSON: " + stringifiedError;
-
-  if (error && typeof error === "object" && "response" in error) {
-    const err = error as AxiosErrorResponse;
-    const errorResponseText = JSON.stringify(err.response);
-    // for some reason, error.response is not included in stringify result (eg. for 400 errors on invite redemptions)
-    if (!R.empty(errorResponseText) && !fullError.includes(errorResponseText)) {
-      // add error.response stuff
-      if (
-        err.response?.config &&
-        err.config &&
-        R.equals(err.config, err.response.config)
-      ) {
-        // but exclude "config" because it's already in there
-        const newErrorResponseText = JSON.stringify(
-          R.omit(["config"] as never[], err.response),
-        );
-        fullError +=
-          " - .response w/o same config JSON: " + newErrorResponseText;
-      } else {
-        fullError += " - .response JSON: " + errorResponseText;
-      }
+  const errorResponseText = JSON.stringify(error.response);
+  // for some reason, error.response is not included in stringify result (eg. for 400 errors on invite redemptions)
+  if (!R.empty(errorResponseText) && !fullError.includes(errorResponseText)) {
+    // add error.response stuff
+    if (R.equals(error?.config, error?.response?.config)) {
+      // but exclude "config" because it's already in there
+      const newErrorResponseText = JSON.stringify(
+        R.omit(["config"] as never[], error.response),
+      );
+      fullError += " - .response w/o same config JSON: " + newErrorResponseText;
+    } else {
+      fullError += " - .response JSON: " + errorResponseText;
     }
   }
   return fullError;
@@ -655,7 +642,7 @@ export async function getNewOffersToUserProjects(
  * @param lastClaimId supplied when editing a previous claim
  */
 export function hydrateGive(
-  vcClaimOrig?: GiveActionClaim,
+  vcClaimOrig?: GiveVerifiableCredential,
   fromDid?: string,
   toDid?: string,
   description?: string,
@@ -663,12 +650,14 @@ export function hydrateGive(
   unitCode?: string,
   fulfillsProjectHandleId?: string,
   fulfillsOfferHandleId?: string,
-  isTrade: boolean = false,
+  isTrade: boolean = false, // remove, because this app is all for gifting
   imageUrl?: string,
   providerPlanHandleId?: string,
   lastClaimId?: string,
-): GiveActionClaim {
-  const vcClaim: GiveActionClaim = vcClaimOrig
+): GiveVerifiableCredential {
+  // Remember: replace values or erase if it's null
+
+  const vcClaim: GiveVerifiableCredential = vcClaimOrig
     ? R.clone(vcClaimOrig)
     : {
         "@context": SCHEMA_ORG_CONTEXT,
@@ -676,72 +665,55 @@ export function hydrateGive(
       };
 
   if (lastClaimId) {
+    // this is an edit
     vcClaim.lastClaimId = lastClaimId;
     delete vcClaim.identifier;
   }
 
-  if (fromDid) {
-    vcClaim.agent = { identifier: fromDid };
-  }
-  if (toDid) {
-    vcClaim.recipient = { identifier: toDid };
-  }
+  vcClaim.agent = fromDid ? { identifier: fromDid } : undefined;
+  vcClaim.recipient = toDid ? { identifier: toDid } : undefined;
   vcClaim.description = description || undefined;
+  vcClaim.object =
+    amount && !isNaN(amount)
+      ? { amountOfThisGood: amount, unitCode: unitCode || "HUR" }
+      : undefined;
 
-  if (amount && !isNaN(amount)) {
-    const quantitativeValue: QuantitativeValue = {
-      "@type": "QuantitativeValue",
-      amountOfThisGood: amount,
-      unitCode: unitCode || "HUR",
-    };
-    vcClaim.object = quantitativeValue;
-  }
-
-  // Initialize fulfills array if not present
+  // ensure fulfills is an array
   if (!Array.isArray(vcClaim.fulfills)) {
     vcClaim.fulfills = vcClaim.fulfills ? [vcClaim.fulfills] : [];
   }
-
-  // Filter and add fulfills elements
+  // ... and replace or add each element, ending with Trade or Donate
+  // I realize the following doesn't change any elements that are not PlanAction or Offer or Trade/Action.
   vcClaim.fulfills = vcClaim.fulfills.filter(
-    (elem: { "@type": string }) => elem["@type"] !== "PlanAction",
+    (elem) => elem["@type"] !== "PlanAction",
   );
-
   if (fulfillsProjectHandleId) {
     vcClaim.fulfills.push({
       "@type": "PlanAction",
       identifier: fulfillsProjectHandleId,
     });
   }
-
   vcClaim.fulfills = vcClaim.fulfills.filter(
-    (elem: { "@type": string }) => elem["@type"] !== "Offer",
+    (elem) => elem["@type"] !== "Offer",
   );
-
   if (fulfillsOfferHandleId) {
     vcClaim.fulfills.push({
       "@type": "Offer",
       identifier: fulfillsOfferHandleId,
     });
   }
-
+  // do Trade/Donate last because current endorser.ch only looks at the first for plans & offers
   vcClaim.fulfills = vcClaim.fulfills.filter(
-    (elem: { "@type": string }) =>
+    (elem) =>
       elem["@type"] !== "DonateAction" && elem["@type"] !== "TradeAction",
   );
-
-  vcClaim.fulfills.push({
-    "@type": isTrade ? "TradeAction" : "DonateAction",
-  });
+  vcClaim.fulfills.push({ "@type": isTrade ? "TradeAction" : "DonateAction" });
 
   vcClaim.image = imageUrl || undefined;
 
-  if (providerPlanHandleId) {
-    vcClaim.provider = {
-      "@type": "PlanAction",
-      identifier: providerPlanHandleId,
-    };
-  }
+  vcClaim.provider = providerPlanHandleId
+    ? { "@type": "PlanAction", identifier: providerPlanHandleId }
+    : undefined;
 
   return vcClaim;
 }
@@ -802,7 +774,7 @@ export async function createAndSubmitGive(
 export async function editAndSubmitGive(
   axios: Axios,
   apiServer: string,
-  fullClaim: GenericCredWrapper<GiveActionClaim>,
+  fullClaim: GenericCredWrapper<GiveVerifiableCredential>,
   issuerDid: string,
   fromDid?: string,
   toDid?: string,
@@ -843,7 +815,7 @@ export async function editAndSubmitGive(
  * @param lastClaimId supplied when editing a previous claim
  */
 export function hydrateOffer(
-  vcClaimOrig?: OfferClaim,
+  vcClaimOrig?: OfferVerifiableCredential,
   fromDid?: string,
   toDid?: string,
   itemDescription?: string,
@@ -853,8 +825,10 @@ export function hydrateOffer(
   fulfillsProjectHandleId?: string,
   validThrough?: string,
   lastClaimId?: string,
-): OfferClaim {
-  const vcClaim: OfferClaim = vcClaimOrig
+): OfferVerifiableCredential {
+  // Remember: replace values or erase if it's null
+
+  const vcClaim: OfferVerifiableCredential = vcClaimOrig
     ? R.clone(vcClaimOrig)
     : {
         "@context": SCHEMA_ORG_CONTEXT,
@@ -867,20 +841,14 @@ export function hydrateOffer(
     delete vcClaim.identifier;
   }
 
-  if (fromDid) {
-    vcClaim.offeredBy = { identifier: fromDid };
-  }
-  if (toDid) {
-    vcClaim.recipient = { identifier: toDid };
-  }
+  vcClaim.offeredBy = fromDid ? { identifier: fromDid } : undefined;
+  vcClaim.recipient = toDid ? { identifier: toDid } : undefined;
   vcClaim.description = conditionDescription || undefined;
 
-  if (amount && !isNaN(amount)) {
-    vcClaim.includesObject = {
-      amountOfThisGood: amount,
-      unitCode: unitCode || "HUR",
-    };
-  }
+  vcClaim.includesObject =
+    amount && !isNaN(amount)
+      ? { amountOfThisGood: amount, unitCode: unitCode || "HUR" }
+      : undefined;
 
   if (itemDescription || fulfillsProjectHandleId) {
     vcClaim.itemOffered = vcClaim.itemOffered || {};
@@ -892,7 +860,6 @@ export function hydrateOffer(
       };
     }
   }
-
   vcClaim.validThrough = validThrough || undefined;
 
   return vcClaim;
@@ -932,7 +899,7 @@ export async function createAndSubmitOffer(
     undefined,
   );
   return createAndSubmitClaim(
-    vcClaim as OfferClaim,
+    vcClaim as OfferVerifiableCredential,
     issuerDid,
     apiServer,
     axios,
@@ -942,7 +909,7 @@ export async function createAndSubmitOffer(
 export async function editAndSubmitOffer(
   axios: Axios,
   apiServer: string,
-  fullClaim: GenericCredWrapper<OfferClaim>,
+  fullClaim: GenericCredWrapper<OfferVerifiableCredential>,
   issuerDid: string,
   itemDescription: string,
   amount?: number,
@@ -965,7 +932,7 @@ export async function editAndSubmitOffer(
     fullClaim.id,
   );
   return createAndSubmitClaim(
-    vcClaim as OfferClaim,
+    vcClaim as OfferVerifiableCredential,
     issuerDid,
     apiServer,
     axios,
@@ -1001,12 +968,11 @@ export async function createAndSubmitClaim(
   axios: Axios,
 ): Promise<CreateAndSubmitClaimResult> {
   try {
-    const vcPayload: { vc: VerifiableCredentialClaim } = {
+    const vcPayload = {
       vc: {
-        "@context": "https://www.w3.org/2018/credentials/v1",
-        "@type": "VerifiableCredential",
+        "@context": ["https://www.w3.org/2018/credentials/v1"],
         type: ["VerifiableCredential"],
-        credentialSubject: vcClaim as unknown as ClaimObject,
+        credentialSubject: vcClaim,
       },
     };
 
@@ -1022,25 +988,26 @@ export async function createAndSubmitClaim(
       },
     });
 
-    return { success: true, handleId: response.data?.handleId };
-  } catch (error: unknown) {
+    return { type: "success", response };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } catch (error: any) {
     logger.error("Error submitting claim:", error);
     const errorMessage: string =
       serverMessageForUser(error) ||
-      (error && typeof error === "object" && "message" in error
-        ? String(error.message)
-        : undefined) ||
+      error.message ||
       "Got some error submitting the claim. Check your permissions, network, and error logs.";
 
     return {
-      success: false,
-      error: errorMessage,
+      type: "error",
+      error: {
+        error: errorMessage,
+      },
     };
   }
 }
 
 export async function generateEndorserJwtUrlForAccount(
-  account: KeyMetaMaybeWithPrivate,
+  account: KeyMeta,
   isRegistered: boolean,
   givenName: string,
   profileImageUrl: string,
@@ -1064,9 +1031,12 @@ export async function generateEndorserJwtUrlForAccount(
   }
 
   // Add the next key -- not recommended for the QR code for such a high resolution
-  if (isContact && account.derivationPath && account.mnemonic) {
-    const newDerivPath = nextDerivationPath(account.derivationPath);
-    const nextPublicHex = deriveAddress(account.mnemonic, newDerivPath)[2];
+  if (isContact && account?.mnemonic && account?.derivationPath) {
+    const newDerivPath = nextDerivationPath(account.derivationPath as string);
+    const nextPublicHex = deriveAddress(
+      account.mnemonic as string,
+      newDerivPath,
+    )[2];
     const nextPublicEncKey = Buffer.from(nextPublicHex, "hex");
     const nextPublicEncKeyHash = sha256(nextPublicEncKey);
     const nextPublicEncKeyHashBase64 =
@@ -1086,11 +1056,7 @@ export async function createEndorserJwtForDid(
   expiresIn?: number,
 ) {
   const account = await retrieveFullyDecryptedAccount(issuerDid);
-  return createEndorserJwtForKey(
-    account as KeyMetaWithPrivate,
-    payload,
-    expiresIn,
-  );
+  return createEndorserJwtForKey(account as KeyMeta, payload, expiresIn);
 }
 
 /**
@@ -1138,21 +1104,21 @@ export const capitalizeAndInsertSpacesBeforeCaps = (text: string) => {
 
  similar code is also contained in endorser-mobile
  **/
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const claimSummary = (
-  claim:
-    | GenericVerifiableCredential
-    | GenericCredWrapper<GenericVerifiableCredential>,
+  claim: GenericCredWrapper<GenericVerifiableCredential>,
 ) => {
   if (!claim) {
+    // to differentiate from "something" above
     return "something";
   }
-  let specificClaim: GenericVerifiableCredential;
-  if ("claim" in claim) {
-    // It's a GenericCredWrapper
-    specificClaim = claim.claim as GenericVerifiableCredential;
-  } else {
-    // It's already a GenericVerifiableCredential
-    specificClaim = claim;
+  let specificClaim:
+    | GenericVerifiableCredential
+    | GenericCredWrapper<GenericVerifiableCredential> = claim;
+  if (claim.claim) {
+    // probably a Verified Credential
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    specificClaim = claim.claim;
   }
   if (Array.isArray(specificClaim)) {
     if (specificClaim.length === 1) {
@@ -1187,112 +1153,88 @@ export const claimSpecialDescription = (
   identifiers: Array<string>,
   contacts: Array<Contact>,
 ) => {
-  let claim:
-    | GenericVerifiableCredential
-    | GenericCredWrapper<GenericVerifiableCredential> = record.claim;
-  if ("claim" in claim) {
-    // it's a nested GenericCredWrapper
-    claim = claim.claim as GenericVerifiableCredential;
+  let claim = record.claim;
+  if (claim.claim) {
+    // it's probably a Verified Credential
+    claim = claim.claim;
   }
 
   const issuer = didInfo(record.issuer, activeDid, identifiers, contacts);
   const type = claim["@type"] || "UnknownType";
 
   if (type === "AgreeAction") {
-    return (
-      issuer +
-      " agreed with " +
-      claimSummary(claim.object as GenericVerifiableCredential)
-    );
+    return issuer + " agreed with " + claimSummary(claim.object);
   } else if (isAccept(claim)) {
-    return (
-      issuer +
-      " accepted " +
-      claimSummary(claim.object as GenericVerifiableCredential)
-    );
+    return issuer + " accepted " + claimSummary(claim.object);
   } else if (type === "GiveAction") {
-    const giveClaim = claim as GiveActionClaim;
-    // @ts-expect-error because .did may be found in legacy data, before March 2023
-    const legacyGiverDid = giveClaim.agent?.did;
-    const giver = giveClaim.agent?.identifier || legacyGiverDid;
+    // agent.did is for legacy data, before March 2023
+    const giver = claim.agent?.identifier || claim.agent?.did;
     const giverInfo = didInfo(giver, activeDid, identifiers, contacts);
-    let gaveAmount = giveClaim.object?.amountOfThisGood
-      ? displayAmount(
-          giveClaim.object.unitCode as string,
-          giveClaim.object.amountOfThisGood as number,
-        )
+    let gaveAmount = claim.object?.amountOfThisGood
+      ? displayAmount(claim.object.unitCode, claim.object.amountOfThisGood)
       : "";
-    if (giveClaim.description) {
+    if (claim.description) {
       if (gaveAmount) {
         gaveAmount = gaveAmount + ", and also: ";
       }
-      gaveAmount = gaveAmount + giveClaim.description;
+      gaveAmount = gaveAmount + claim.description;
     }
     if (!gaveAmount) {
       gaveAmount = "something not described";
     }
-    // @ts-expect-error because .did may be found in legacy data, before March 2023
-    const legacyRecipDid = giveClaim.recipient?.did;
-    const gaveRecipientId = giveClaim.recipient?.identifier || legacyRecipDid;
+    // recipient.did is for legacy data, before March 2023
+    const gaveRecipientId = claim.recipient?.identifier || claim.recipient?.did;
     const gaveRecipientInfo = gaveRecipientId
       ? " to " + didInfo(gaveRecipientId, activeDid, identifiers, contacts)
       : "";
     return giverInfo + " gave" + gaveRecipientInfo + ": " + gaveAmount;
   } else if (type === "JoinAction") {
-    const joinClaim = claim as JoinActionClaim;
-    // @ts-expect-error because .did may be found in legacy data, before March 2023
-    const legacyDid = joinClaim.agent?.did;
-    const agent = joinClaim.agent?.identifier || legacyDid;
+    // agent.did is for legacy data, before March 2023
+    const agent = claim.agent?.identifier || claim.agent?.did;
     const contactInfo = didInfo(agent, activeDid, identifiers, contacts);
 
     let eventOrganizer =
-      joinClaim.event &&
-      joinClaim.event.organizer &&
-      joinClaim.event.organizer.name;
+      claim.event && claim.event.organizer && claim.event.organizer.name;
     eventOrganizer = eventOrganizer || "";
-    let eventName = joinClaim.event && joinClaim.event.name;
+    let eventName = claim.event && claim.event.name;
     eventName = eventName ? " " + eventName : "";
     let fullEvent = eventOrganizer + eventName;
     fullEvent = fullEvent ? " attended the " + fullEvent : "";
 
-    let eventDate = joinClaim.event && joinClaim.event.startTime;
+    let eventDate = claim.event && claim.event.startTime;
     eventDate = eventDate ? " at " + eventDate : "";
     return contactInfo + fullEvent + eventDate;
   } else if (isOffer(claim)) {
-    const offerClaim = claim as OfferClaim;
-    const offerer = offerClaim.offeredBy?.identifier;
+    const offerer = claim.offeredBy?.identifier;
     const contactInfo = didInfo(offerer, activeDid, identifiers, contacts);
     let offering = "";
-    if (offerClaim.includesObject) {
+    if (claim.includesObject) {
       offering +=
         " " +
         displayAmount(
-          offerClaim.includesObject.unitCode,
-          offerClaim.includesObject.amountOfThisGood,
+          claim.includesObject.unitCode,
+          claim.includesObject.amountOfThisGood,
         );
     }
-    if (offerClaim.itemOffered?.description) {
-      offering += ", saying: " + offerClaim.itemOffered?.description;
+    if (claim.itemOffered?.description) {
+      offering += ", saying: " + claim.itemOffered?.description;
     }
-    // @ts-expect-error because .did may be found in legacy data, before March 2023
-    const legacyDid = offerClaim.recipient?.did;
-    const offerRecipientId = offerClaim.recipient?.identifier || legacyDid;
+    // recipient.did is for legacy data, before March 2023
+    const offerRecipientId =
+      claim.recipient?.identifier || claim.recipient?.did;
     const offerRecipientInfo = offerRecipientId
       ? " to " + didInfo(offerRecipientId, activeDid, identifiers, contacts)
       : "";
     return contactInfo + " offered" + offering + offerRecipientInfo;
   } else if (type === "PlanAction") {
-    const planClaim = claim as PlanActionClaim;
-    const claimer = planClaim.agent?.identifier || record.issuer;
+    const claimer = claim.agent?.identifier || record.issuer;
     const claimerInfo = didInfo(claimer, activeDid, identifiers, contacts);
-    return claimerInfo + " announced a project: " + planClaim.name;
+    return claimerInfo + " announced a project: " + claim.name;
   } else if (type === "Tenure") {
-    const tenureClaim = claim as TenureClaim;
-    // @ts-expect-error because .did may be found in legacy data, before March 2023
-    const legacyDid = tenureClaim.party?.did;
-    const claimer = tenureClaim.party?.identifier || legacyDid;
+    // party.did is for legacy data, before March 2023
+    const claimer = claim.party?.identifier || claim.party?.did;
     const contactInfo = didInfo(claimer, activeDid, identifiers, contacts);
-    const polygon = tenureClaim.spatialUnit?.geo?.polygon || "";
+    const polygon = claim.spatialUnit?.geo?.polygon || "";
     return (
       contactInfo +
       " possesses [" +
@@ -1300,7 +1242,11 @@ export const claimSpecialDescription = (
       "...]"
     );
   } else {
-    return issuer + " declared " + claimSummary(claim);
+    return (
+      issuer +
+      " declared " +
+      claimSummary(claim as GenericCredWrapper<GenericVerifiableCredential>)
+    );
   }
 };
 
@@ -1332,7 +1278,7 @@ export async function createEndorserJwtVcFromClaim(
   // Make a payload for the claim
   const vcPayload = {
     vc: {
-      "@context": "https://www.w3.org/2018/credentials/v1",
+      "@context": ["https://www.w3.org/2018/credentials/v1"],
       type: ["VerifiableCredential"],
       credentialSubject: claim,
     },
@@ -1340,42 +1286,32 @@ export async function createEndorserJwtVcFromClaim(
   return createEndorserJwtForDid(issuerDid, vcPayload);
 }
 
-/**
- * Create a JWT for a RegisterAction claim.
- *
- * @param activeDid - The DID of the user creating the invite
- * @param contact - The contact to register, with a 'did' field (all optional for invites)
- * @param identifier - The identifier for the invite, usually random
- * @param expiresIn - The number of seconds until the invite expires
- * @returns The JWT for the RegisterAction claim
- */
 export async function createInviteJwt(
   activeDid: string,
   contact?: Contact,
-  identifier?: string,
-  expiresIn?: number, // in seconds
+  inviteId?: string,
+  expiresIn?: number,
 ): Promise<string> {
-  const vcClaim: RegisterActionClaim = {
+  const vcClaim: RegisterVerifiableCredential = {
     "@context": SCHEMA_ORG_CONTEXT,
     "@type": "RegisterAction",
     agent: { identifier: activeDid },
     object: SERVICE_ID,
-    identifier: identifier,
   };
-  if (contact?.did) {
+  if (contact) {
     vcClaim.participant = { identifier: contact.did };
   }
-
+  if (inviteId) {
+    vcClaim.identifier = inviteId;
+  }
   // Make a payload for the claim
-  const vcPayload: { vc: VerifiableCredentialClaim } = {
+  const vcPayload = {
     vc: {
-      "@context": "https://www.w3.org/2018/credentials/v1",
-      "@type": "VerifiableCredential",
+      "@context": ["https://www.w3.org/2018/credentials/v1"],
       type: ["VerifiableCredential"],
-      credentialSubject: vcClaim as unknown as ClaimObject,
+      credentialSubject: vcClaim,
     },
   };
-
   // Create a signature using private key of identity
   const vcJwt = await createEndorserJwtForDid(activeDid, vcPayload, expiresIn);
   return vcJwt;
@@ -1387,44 +1323,21 @@ export async function register(
   axios: Axios,
   contact: Contact,
 ): Promise<{ success?: boolean; error?: string }> {
-  try {
-    const vcJwt = await createInviteJwt(activeDid, contact);
-    const url = apiServer + "/api/v2/claim";
-    const resp = await axios.post<{
-      success?: {
-        handleId?: string;
-        embeddedRecordError?: string;
-      };
-      error?: string;
-      message?: string;
-    }>(url, { jwtEncoded: vcJwt });
+  const vcJwt = await createInviteJwt(activeDid, contact);
 
-    if (resp.data?.success?.handleId) {
-      return { success: true };
-    } else if (resp.data?.success?.embeddedRecordError) {
-      let message =
-        "There was some problem with the registration and so it may not be complete.";
-      if (typeof resp.data.success.embeddedRecordError === "string") {
-        message += " " + resp.data.success.embeddedRecordError;
-      }
-      return { error: message };
-    } else {
-      logger.error("Registration error:", JSON.stringify(resp.data));
-      return { error: "Got a server error when registering." };
-    }
-  } catch (error: unknown) {
-    if (error && typeof error === "object") {
-      const err = error as AxiosErrorResponse;
-      const errorMessage =
-        err.message ||
-        (err.response?.data &&
-        typeof err.response.data === "object" &&
-        "message" in err.response.data
-          ? (err.response.data as { message: string }).message
-          : undefined);
-      logger.error("Registration error:", errorMessage || JSON.stringify(err));
-      return { error: errorMessage || "Got a server error when registering." };
+  const url = apiServer + "/api/v2/claim";
+  const resp = await axios.post(url, { jwtEncoded: vcJwt });
+  if (resp.data?.success?.handleId) {
+    return { success: true };
+  } else if (resp.data?.success?.embeddedRecordError) {
+    let message =
+      "There was some problem with the registration and so it may not be complete.";
+    if (typeof resp.data.success.embeddedRecordError == "string") {
+      message += " " + resp.data.success.embeddedRecordError;
     }
+    return { error: message };
+  } else {
+    logger.error(resp);
     return { error: "Got a server error when registering." };
   }
 }
@@ -1450,14 +1363,7 @@ export async function setVisibilityUtil(
     if (resp.status === 200) {
       const success = resp.data.success;
       if (success) {
-        const platformService = PlatformServiceFactory.getInstance();
-        await platformService.dbExec(
-          "UPDATE contacts SET seesMe = ? WHERE did = ?",
-          [visibility, contact.did],
-        );
-        if (USE_DEXIE_DB) {
-          db.contacts.update(contact.did, { seesMe: visibility });
-        }
+        db.contacts.update(contact.did, { seesMe: visibility });
       }
       return { success };
     } else {

src/libs/util.ts

@@ -5,43 +5,29 @@ import { Buffer } from "buffer";
 import * as R from "ramda";
 import { useClipboard } from "@vueuse/core";
 
-import {
-  DEFAULT_PUSH_SERVER,
-  NotificationIface,
-  USE_DEXIE_DB,
-} from "../constants/app";
+import { DEFAULT_PUSH_SERVER, NotificationIface } from "../constants/app";
 import {
   accountsDBPromise,
   retrieveSettingsForActiveAccount,
   updateAccountSettings,
   updateDefaultSettings,
 } from "../db/index";
-import { Account, AccountEncrypted } from "../db/tables/accounts";
+import { Account } from "../db/tables/accounts";
 import { Contact } from "../db/tables/contacts";
-import * as databaseUtil from "../db/databaseUtil";
 import { DEFAULT_PASSKEY_EXPIRATION_MINUTES } from "../db/tables/settings";
-import {
-  arrayBufferToBase64,
-  base64ToArrayBuffer,
-  deriveAddress,
-  generateSeed,
-  newIdentifier,
-  simpleDecrypt,
-  simpleEncrypt,
-} from "../libs/crypto";
+import { deriveAddress, generateSeed, newIdentifier } from "../libs/crypto";
 import * as serverUtil from "../libs/endorserServer";
-import { containsHiddenDid } from "../libs/endorserServer";
 import {
+  containsHiddenDid,
   GenericCredWrapper,
   GenericVerifiableCredential,
-  KeyMetaWithPrivate,
-} from "../interfaces/common";
-import { GiveSummaryRecord } from "../interfaces/records";
-import { OfferClaim } from "../interfaces/claims";
+  GiveSummaryRecord,
+  OfferVerifiableCredential,
+} from "../libs/endorserServer";
+import { KeyMeta } from "../libs/crypto/vc";
 import { createPeerDid } from "../libs/crypto/vc/didPeer";
 import { registerCredential } from "../libs/crypto/vc/passkeyDidPeer";
 import { logger } from "../utils/logger";
-import { PlatformServiceFactory } from "@/services/PlatformServiceFactory";
 
 export interface GiverReceiverInputInfo {
   did?: string;
@@ -378,19 +364,16 @@ export function base64ToBlob(base64DataUrl: string, sliceSize = 512) {
  * @param veriClaim is expected to have fields: claim and issuer
  */
 export function offerGiverDid(
-  veriClaim: GenericCredWrapper<OfferClaim>,
+  veriClaim: GenericCredWrapper<OfferVerifiableCredential>,
 ): string | undefined {
-  const innerClaim = veriClaim.claim as OfferClaim;
-  let giver: string | undefined = undefined;
-
-  giver = innerClaim.offeredBy?.identifier;
-  if (giver && !serverUtil.isHiddenDid(giver)) {
-    return giver;
-  }
-
-  giver = veriClaim.issuer;
-  if (giver && !serverUtil.isHiddenDid(giver)) {
-    return giver;
+  let giver;
+  if (
+    veriClaim.claim.offeredBy?.identifier &&
+    !serverUtil.isHiddenDid(veriClaim.claim.offeredBy.identifier as string)
+  ) {
+    giver = veriClaim.claim.offeredBy.identifier;
+  } else if (veriClaim.issuer && !serverUtil.isHiddenDid(veriClaim.issuer)) {
+    giver = veriClaim.issuer;
   }
   return giver;
 }
@@ -404,7 +387,7 @@ export const canFulfillOffer = (
 ) => {
   return (
     veriClaim.claimType === "Offer" &&
-    !!offerGiverDid(veriClaim as GenericCredWrapper<OfferClaim>)
+    !!offerGiverDid(veriClaim as GenericCredWrapper<OfferVerifiableCredential>)
   );
 };
 
@@ -474,235 +457,73 @@ export function findAllVisibleToDids(
  *
  **/
 
-export type AccountKeyInfo = Account & KeyMetaWithPrivate;
+export interface AccountKeyInfo extends Account, KeyMeta {}
 
 export const retrieveAccountCount = async (): Promise<number> => {
-  let result = 0;
-  const platformService = PlatformServiceFactory.getInstance();
-  const dbResult = await platformService.dbQuery(
-    `SELECT COUNT(*) FROM accounts`,
-  );
-  if (dbResult?.values?.[0]?.[0]) {
-    result = dbResult.values[0][0] as number;
-  }
-
-  if (USE_DEXIE_DB) {
-    // one of the few times we use accountsDBPromise directly; try to avoid more usage
-    const accountsDB = await accountsDBPromise;
-    result = await accountsDB.accounts.count();
-  }
-  return result;
+  // one of the few times we use accountsDBPromise directly; try to avoid more usage
+  const accountsDB = await accountsDBPromise;
+  return await accountsDB.accounts.count();
 };
 
 export const retrieveAccountDids = async (): Promise<string[]> => {
-  const platformService = PlatformServiceFactory.getInstance();
-  const dbAccounts = await platformService.dbQuery(`SELECT did FROM accounts`);
-  let allDids =
-    databaseUtil
-      .mapQueryResultToValues(dbAccounts)
-      ?.map((row) => row[0] as string) || [];
-  if (USE_DEXIE_DB) {
-    // this is the old way
-    // one of the few times we use accountsDBPromise directly; try to avoid more usage
-    const accountsDB = await accountsDBPromise;
-    const allAccounts = await accountsDB.accounts.toArray();
-    allDids = allAccounts.map((acc) => acc.did);
-  }
+  // one of the few times we use accountsDBPromise directly; try to avoid more usage
+  const accountsDB = await accountsDBPromise;
+  const allAccounts = await accountsDB.accounts.toArray();
+  const allDids = allAccounts.map((acc) => acc.did);
   return allDids;
 };
 
-/**
- * This is provided and recommended when the full key is not necessary so that
- * future work could separate this info from the sensitive key material.
- *
- * If you need the private key data, use retrieveFullyDecryptedAccount instead.
- */
+// This is provided and recommended when the full key is not necessary so that
+// future work could separate this info from the sensitive key material.
 export const retrieveAccountMetadata = async (
   activeDid: string,
-): Promise<Account | undefined> => {
-  let result: Account | undefined = undefined;
-  const platformService = PlatformServiceFactory.getInstance();
-  const dbAccount = await platformService.dbQuery(
-    `SELECT * FROM accounts WHERE did = ?`,
-    [activeDid],
-  );
-  const account = databaseUtil.mapQueryResultToValues(dbAccount)[0] as Account;
+): Promise<AccountKeyInfo | undefined> => {
+  // one of the few times we use accountsDBPromise directly; try to avoid more usage
+  const accountsDB = await accountsDBPromise;
+  const account = (await accountsDB.accounts
+    .where("did")
+    .equals(activeDid)
+    .first()) as Account;
   if (account) {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { identity, mnemonic, ...metadata } = account;
-    result = metadata;
+    return metadata;
   } else {
-    result = undefined;
+    return undefined;
   }
-  if (USE_DEXIE_DB) {
-    // one of the few times we use accountsDBPromise directly; try to avoid more usage
-    const accountsDB = await accountsDBPromise;
-    const account = (await accountsDB.accounts
-      .where("did")
-      .equals(activeDid)
-      .first()) as Account;
-    if (account) {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      const { identity, mnemonic, ...metadata } = account;
-      result = metadata;
-    } else {
-      result = undefined;
-    }
-  }
-  return result;
-};
-
-/**
- * This contains sensitive data. If possible, use retrieveAccountMetadata instead.
- *
- * @param activeDid
- * @returns account info with private key data decrypted
- */
-export const retrieveFullyDecryptedAccount = async (
-  activeDid: string,
-): Promise<Account | undefined> => {
-  let result: Account | undefined = undefined;
-  const platformService = PlatformServiceFactory.getInstance();
-  const dbSecrets = await platformService.dbQuery(
-    `SELECT secretBase64 from secret`,
-  );
-  if (
-    !dbSecrets ||
-    dbSecrets.values.length === 0 ||
-    dbSecrets.values[0].length === 0
-  ) {
-    throw new Error(
-      "No secret found. We recommend you clear your data and start over.",
-    );
-  }
-  const secretBase64 = dbSecrets.values[0][0] as string;
-  const secret = base64ToArrayBuffer(secretBase64);
-  const dbAccount = await platformService.dbQuery(
-    `SELECT * FROM accounts WHERE did = ?`,
-    [activeDid],
-  );
-  if (
-    !dbAccount ||
-    dbAccount.values.length === 0 ||
-    dbAccount.values[0].length === 0
-  ) {
-    throw new Error("Account not found.");
-  }
-  const fullAccountData = databaseUtil.mapQueryResultToValues(
-    dbAccount,
-  )[0] as AccountEncrypted;
-  const identityEncr = base64ToArrayBuffer(fullAccountData.identityEncrBase64);
-  const mnemonicEncr = base64ToArrayBuffer(fullAccountData.mnemonicEncrBase64);
-  fullAccountData.identity = await simpleDecrypt(identityEncr, secret);
-  fullAccountData.mnemonic = await simpleDecrypt(mnemonicEncr, secret);
-  result = fullAccountData;
-
-  if (USE_DEXIE_DB) {
-    // one of the few times we use accountsDBPromise directly; try to avoid more usage
-    const accountsDB = await accountsDBPromise;
-    const account = (await accountsDB.accounts
-      .where("did")
-      .equals(activeDid)
-      .first()) as Account;
-    result = account;
-  }
-  return result;
 };
 
 export const retrieveAllAccountsMetadata = async (): Promise<Account[]> => {
-  const platformService = PlatformServiceFactory.getInstance();
-  const dbAccounts = await platformService.dbQuery(`SELECT * FROM accounts`);
-  const accounts = databaseUtil.mapQueryResultToValues(dbAccounts) as Account[];
-  let result = accounts.map((account) => {
+  // one of the few times we use accountsDBPromise directly; try to avoid more usage
+  const accountsDB = await accountsDBPromise;
+  const array = await accountsDB.accounts.toArray();
+  return array.map((account) => {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { identity, mnemonic, ...metadata } = account;
-    return metadata as Account;
+    return metadata;
   });
-  if (USE_DEXIE_DB) {
-    // one of the few times we use accountsDBPromise directly; try to avoid more usage
-    const accountsDB = await accountsDBPromise;
-    const array = await accountsDB.accounts.toArray();
-    result = array.map((account) => {
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      const { identity, mnemonic, ...metadata } = account;
-      return metadata as Account;
-    });
-  }
-  return result;
 };
 
-/**
- * Saves a new identity to both SQL and Dexie databases
- */
-export async function saveNewIdentity(
-  identity: string,
-  mnemonic: string,
-  newId: { did: string; keys: Array<{ publicKeyHex: string }> },
-  derivationPath: string,
-): Promise<void> {
-  try {
-    // add to the new sql db
-    const platformService = PlatformServiceFactory.getInstance();
-    const secrets = await platformService.dbQuery(
-      `SELECT secretBase64 FROM secret`,
-    );
+export const retrieveFullyDecryptedAccount = async (
+  activeDid: string,
+): Promise<AccountKeyInfo | undefined> => {
+  // one of the few times we use accountsDBPromise directly; try to avoid more usage
+  const accountsDB = await accountsDBPromise;
+  const account = (await accountsDB.accounts
+    .where("did")
+    .equals(activeDid)
+    .first()) as Account;
+  return account;
+};
 
-    // If no secret exists, create one
-    let secretBase64: string;
-    if (!secrets?.values?.length || !secrets.values[0]?.length) {
-      // Generate a new secret
-      const randomBytes = crypto.getRandomValues(new Uint8Array(32));
-      secretBase64 = arrayBufferToBase64(randomBytes);
-
-      // Store the new secret
-      await platformService.dbExec(
-        `INSERT INTO secret (id, secretBase64) VALUES (1, ?)`,
-        [secretBase64],
-      );
-    } else {
-      secretBase64 = secrets.values[0][0] as string;
-    }
-
-    const secret = base64ToArrayBuffer(secretBase64);
-    const encryptedIdentity = await simpleEncrypt(identity, secret);
-    const encryptedMnemonic = await simpleEncrypt(mnemonic, secret);
-    const encryptedIdentityBase64 = arrayBufferToBase64(encryptedIdentity);
-    const encryptedMnemonicBase64 = arrayBufferToBase64(encryptedMnemonic);
-
-    await platformService.dbExec(
-      `INSERT INTO accounts (dateCreated, derivationPath, did, identityEncrBase64, mnemonicEncrBase64, publicKeyHex)
-       VALUES (?, ?, ?, ?, ?, ?)`,
-      [
-        new Date().toISOString(),
-        derivationPath,
-        newId.did,
-        encryptedIdentityBase64,
-        encryptedMnemonicBase64,
-        newId.keys[0].publicKeyHex,
-      ],
-    );
-    await databaseUtil.updateDefaultSettings({ activeDid: newId.did });
-
-    if (USE_DEXIE_DB) {
-      // one of the few times we use accountsDBPromise directly; try to avoid more usage
-      const accountsDB = await accountsDBPromise;
-      await accountsDB.accounts.add({
-        dateCreated: new Date().toISOString(),
-        derivationPath: derivationPath,
-        did: newId.did,
-        identity: identity,
-        mnemonic: mnemonic,
-        publicKeyHex: newId.keys[0].publicKeyHex,
-      });
-      await updateDefaultSettings({ activeDid: newId.did });
-    }
-  } catch (error) {
-    logger.error("Failed to update default settings:", error);
-    throw new Error(
-      "Failed to set default settings. Please try again or restart the app.",
-    );
-  }
-}
+// let's try and eliminate this
+export const retrieveAllFullyDecryptedAccounts = async (): Promise<
+  Array<AccountKeyInfo>
+> => {
+  const accountsDB = await accountsDBPromise;
+  const allAccounts = await accountsDB.accounts.toArray();
+  return allAccounts;
+};
 
 /**
  * Generates a new identity, saves it to the database, and sets it as the active identity.
@@ -717,11 +538,24 @@ export const generateSaveAndActivateIdentity = async (): Promise<string> => {
   const newId = newIdentifier(address, publicHex, privateHex, derivationPath);
   const identity = JSON.stringify(newId);
 
-  await saveNewIdentity(identity, mnemonic, newId, derivationPath);
-  await databaseUtil.updateAccountSettings(newId.did, { isRegistered: false });
-  if (USE_DEXIE_DB) {
-    await updateAccountSettings(newId.did, { isRegistered: false });
+  // one of the few times we use accountsDBPromise directly; try to avoid more usage
+  try {
+    const accountsDB = await accountsDBPromise;
+    await accountsDB.accounts.add({
+      dateCreated: new Date().toISOString(),
+      derivationPath: derivationPath,
+      did: newId.did,
+      identity: identity,
+      mnemonic: mnemonic,
+      publicKeyHex: newId.keys[0].publicKeyHex,
+    });
+  
+    await updateDefaultSettings({ activeDid: newId.did });
+  } catch (error) {
+    console.error("Failed to update default settings:", error);
+    throw new Error("Failed to set default settings. Please try again or restart the app.");
   }
+  await updateAccountSettings(newId.did, { isRegistered: false });
   return newId.did;
 };
 
@@ -739,19 +573,9 @@ export const registerAndSavePasskey = async (
     passkeyCredIdHex,
     publicKeyHex: Buffer.from(publicKeyBytes).toString("hex"),
   };
-  const insertStatement = databaseUtil.generateInsertStatement(
-    account,
-    "accounts",
-  );
-  await PlatformServiceFactory.getInstance().dbExec(
-    insertStatement.sql,
-    insertStatement.params,
-  );
-  if (USE_DEXIE_DB) {
-    // one of the few times we use accountsDBPromise directly; try to avoid more usage
-    const accountsDB = await accountsDBPromise;
-    await accountsDB.accounts.add(account);
-  }
+  // one of the few times we use accountsDBPromise directly; try to avoid more usage
+  const accountsDB = await accountsDBPromise;
+  await accountsDB.accounts.add(account);
   return account;
 };
 
@@ -759,22 +583,13 @@ export const registerSaveAndActivatePasskey = async (
   keyName: string,
 ): Promise<Account> => {
   const account = await registerAndSavePasskey(keyName);
-  await databaseUtil.updateDefaultSettings({ activeDid: account.did });
-  await databaseUtil.updateAccountSettings(account.did, {
-    isRegistered: false,
-  });
-  if (USE_DEXIE_DB) {
-    await updateDefaultSettings({ activeDid: account.did });
-    await updateAccountSettings(account.did, { isRegistered: false });
-  }
+  await updateDefaultSettings({ activeDid: account.did });
+  await updateAccountSettings(account.did, { isRegistered: false });
   return account;
 };
 
 export const getPasskeyExpirationSeconds = async (): Promise<number> => {
-  let settings = await databaseUtil.retrieveSettingsForActiveAccount();
-  if (USE_DEXIE_DB) {
-    settings = await retrieveSettingsForActiveAccount();
-  }
+  const settings = await retrieveSettingsForActiveAccount();
   return (
     (settings?.passkeyExpirationMinutes ?? DEFAULT_PASSKEY_EXPIRATION_MINUTES) *
     60
@@ -790,10 +605,7 @@ export const sendTestThroughPushServer = async (
   subscriptionJSON: PushSubscriptionJSON,
   skipFilter: boolean,
 ): Promise<AxiosResponse> => {
-  let settings = await databaseUtil.retrieveSettingsForActiveAccount();
-  if (USE_DEXIE_DB) {
-    settings = await retrieveSettingsForActiveAccount();
-  }
+  const settings = await retrieveSettingsForActiveAccount();
   let pushUrl: string = DEFAULT_PUSH_SERVER as string;
   if (settings?.webPushServer) {
     pushUrl = settings.webPushServer;

src/main.capacitor.ts

@@ -34,7 +34,7 @@ import router from "./router";
 import { handleApiError } from "./services/api";
 import { AxiosError } from "axios";
 import { DeepLinkHandler } from "./services/deepLinks";
-import { logConsoleAndDb } from "./db/databaseUtil";
+import { logConsoleAndDb } from "./db";
 import { logger } from "./utils/logger";
 
 logger.log("[Capacitor] Starting initialization");

src/main.common.ts

@@ -2,7 +2,6 @@ import { createPinia } from "pinia";
 import { App as VueApp, ComponentPublicInstance, createApp } from "vue";
 import App from "./App.vue";
 import router from "./router";
-// Use the browser version of axios for web builds
 import axios from "axios";
 import VueAxios from "vue-axios";
 import Notifications from "notiwind";
@@ -11,12 +10,6 @@ import { FontAwesomeIcon } from "./libs/fontawesome";
 import Camera from "simple-vue-camera";
 import { logger } from "./utils/logger";
 
-const platform = process.env.VITE_PLATFORM;
-const pwa_enabled = process.env.VITE_PWA_ENABLED === "true";
-
-logger.log("Platform", { platform });
-logger.log("PWA enabled", { pwa_enabled });
-
 // Global Error Handler
 function setupGlobalErrorHandler(app: VueApp) {
   logger.log("[App Init] Setting up global error handler");

src/main.electron.ts

@@ -1,301 +1,4 @@
 import { initializeApp } from "./main.common";
-import { logger } from "./utils/logger";
-import { SQLiteQueryResult } from "./services/platforms/ElectronPlatformService";
 
-const platform = process.env.VITE_PLATFORM;
-const pwa_enabled = process.env.VITE_PWA_ENABLED === "true";
-
-logger.info("[Main Electron] Initializing app");
-logger.info("[Main Electron] Platform:", { platform });
-logger.info("[Main Electron] PWA enabled:", { pwa_enabled });
-
-if (pwa_enabled) {
-  logger.warn("[Main Electron] PWA is enabled, but not supported in electron");
-}
-
-// Initialize app and SQLite
 const app = initializeApp();
-
-// Create a promise that resolves when SQLite is ready
-const sqliteReady = new Promise<void>((resolve, reject) => {
-  let retryCount = 0;
-  let initializationTimeout: NodeJS.Timeout;
-
-  const attemptInitialization = () => {
-    // Clear any existing timeout
-    if (initializationTimeout) {
-      clearTimeout(initializationTimeout);
-    }
-
-    // Set timeout for this attempt
-    initializationTimeout = setTimeout(() => {
-      if (retryCount < 3) {
-        // Use same retry count as ElectronPlatformService
-        retryCount++;
-        logger.warn(
-          `[Main Electron] SQLite initialization attempt ${retryCount} timed out, retrying...`,
-        );
-        setTimeout(attemptInitialization, 1000); // Use same delay as ElectronPlatformService
-      } else {
-        logger.error(
-          "[Main Electron] SQLite initialization failed after all retries",
-        );
-        reject(new Error("SQLite initialization timeout after all retries"));
-      }
-    }, 10000); // Use same timeout as ElectronPlatformService
-
-    // Wait for electron bridge to be available
-    const checkElectronBridge = () => {
-      if (!window.electron?.ipcRenderer) {
-        // Check again in 100ms if bridge isn't ready
-        setTimeout(checkElectronBridge, 100);
-        return;
-      }
-
-      // At this point we know ipcRenderer exists
-      const ipcRenderer = window.electron.ipcRenderer;
-
-      logger.info("[Main Electron] [IPC:bridge] IPC renderer bridge available");
-
-      // Listen for SQLite ready signal
-      logger.debug(
-        "[Main Electron] [IPC:sqlite-ready] Registering listener for SQLite ready signal",
-      );
-      ipcRenderer.once("sqlite-ready", () => {
-        clearTimeout(initializationTimeout);
-        logger.info(
-          "[Main Electron] [IPC:sqlite-ready] Received SQLite ready signal",
-        );
-        resolve();
-      });
-
-      // Also listen for database errors
-      logger.debug(
-        "[Main Electron] [IPC:database-status] Registering listener for database status",
-      );
-      ipcRenderer.once("database-status", (...args: unknown[]) => {
-        clearTimeout(initializationTimeout);
-        const status = args[0] as { status: string; error?: string };
-        if (status.status === "error") {
-          logger.error(
-            "[Main Electron] [IPC:database-status] Database error:",
-            {
-              error: status.error,
-              channel: "database-status",
-            },
-          );
-          reject(new Error(status.error || "Database initialization failed"));
-        }
-      });
-
-      // Check if SQLite is already available
-      logger.debug(
-        "[Main Electron] [IPC:sqlite-is-available] Checking SQLite availability",
-      );
-      ipcRenderer
-        .invoke("sqlite-is-available")
-        .then(async (result: unknown) => {
-          const isAvailable = Boolean(result);
-          if (isAvailable) {
-            logger.info(
-              "[Main Electron] [IPC:sqlite-is-available] SQLite is available",
-            );
-
-            try {
-              // First create a database connection
-              logger.debug(
-                "[Main Electron] [IPC:get-path] Requesting database path",
-              );
-              const dbPath = await ipcRenderer.invoke("get-path");
-              logger.info(
-                "[Main Electron] [IPC:get-path] Database path received:",
-                { dbPath },
-              );
-
-              // Create the database connection
-              logger.debug(
-                "[Main Electron] [IPC:sqlite-create-connection] Creating database connection",
-              );
-              await ipcRenderer.invoke("sqlite-create-connection", {
-                database: "timesafari",
-                version: 1,
-              });
-              logger.info(
-                "[Main Electron] [IPC:sqlite-create-connection] Database connection created",
-              );
-
-              // Explicitly open the database
-              logger.debug(
-                "[Main Electron] [IPC:sqlite-open] Opening database",
-              );
-              await ipcRenderer.invoke("sqlite-open", {
-                database: "timesafari",
-              });
-              logger.info(
-                "[Main Electron] [IPC:sqlite-open] Database opened successfully",
-              );
-
-              // Verify the database is open
-              logger.debug(
-                "[Main Electron] [IPC:sqlite-is-db-open] Verifying database is open",
-              );
-              const isOpen = await ipcRenderer.invoke("sqlite-is-db-open", {
-                database: "timesafari",
-              });
-              logger.info(
-                "[Main Electron] [IPC:sqlite-is-db-open] Database open status:",
-                { isOpen },
-              );
-
-              if (!isOpen) {
-                throw new Error("Database failed to open");
-              }
-
-              // Now execute the test query
-              logger.debug(
-                "[Main Electron] [IPC:sqlite-query] Executing test query",
-              );
-              const testQuery = (await ipcRenderer.invoke("sqlite-query", {
-                database: "timesafari",
-                statement: "SELECT 1 as test;", // Safe test query
-              })) as SQLiteQueryResult;
-              logger.info(
-                "[Main Electron] [IPC:sqlite-query] Test query successful:",
-                {
-                  hasResults: Boolean(testQuery?.values),
-                  resultCount: testQuery?.values?.length,
-                },
-              );
-
-              // Signal that SQLite is ready - database stays open
-              logger.debug(
-                "[Main Electron] [IPC:sqlite-status] Sending SQLite ready status",
-              );
-              await ipcRenderer.invoke("sqlite-status", {
-                status: "ready",
-                database: "timesafari",
-                timestamp: Date.now(),
-              });
-              logger.info(
-                "[Main Electron] SQLite ready status sent, database connection maintained",
-              );
-
-              // Remove the close operations - database stays open for component use
-              // Database will be closed during app shutdown
-            } catch (error) {
-              logger.error(
-                "[Main Electron] [IPC:*] SQLite test operation failed:",
-                {
-                  error,
-                  lastOperation: "sqlite-test-query",
-                  database: "timesafari",
-                },
-              );
-
-              // Try to close everything if anything was opened
-              try {
-                logger.debug(
-                  "[Main Electron] [IPC:cleanup] Attempting database cleanup after error",
-                );
-                await ipcRenderer
-                  .invoke("sqlite-close", {
-                    database: "timesafari",
-                  })
-                  .catch((closeError) => {
-                    logger.warn(
-                      "[Main Electron] [IPC:sqlite-close] Failed to close database during cleanup:",
-                      closeError,
-                    );
-                  });
-
-                await ipcRenderer
-                  .invoke("sqlite-close-connection", {
-                    database: "timesafari",
-                  })
-                  .catch((closeError) => {
-                    logger.warn(
-                      "[Main Electron] [IPC:sqlite-close-connection] Failed to close connection during cleanup:",
-                      closeError,
-                    );
-                  });
-
-                logger.info(
-                  "[Main Electron] [IPC:cleanup] Database cleanup completed after error",
-                );
-              } catch (closeError) {
-                logger.error(
-                  "[Main Electron] [IPC:cleanup] Failed to cleanup database:",
-                  {
-                    error: closeError,
-                    database: "timesafari",
-                  },
-                );
-              }
-              // Don't reject here - we still want to wait for the ready signal
-            }
-          }
-        })
-        .catch((error: Error) => {
-          logger.error(
-            "[Main Electron] [IPC:sqlite-is-available] Failed to check SQLite availability:",
-            {
-              error,
-              channel: "sqlite-is-available",
-            },
-          );
-          // Don't reject here - wait for either ready signal or timeout
-        });
-    };
-
-    // Start checking for bridge
-    checkElectronBridge();
-  };
-
-  // Start first initialization attempt
-  attemptInitialization();
-});
-
-// Wait for SQLite to be ready before initializing router and mounting app
-sqliteReady
-  .then(async () => {
-    logger.info("[Main Electron] SQLite ready, initializing router...");
-
-    // Initialize router after SQLite is ready
-    const router = await import("./router").then((m) => m.default);
-    app.use(router);
-    logger.info("[Main Electron] Router initialized");
-
-    // Now mount the app
-    logger.info("[Main Electron] Mounting app...");
-    app.mount("#app");
-    logger.info("[Main Electron] App mounted successfully");
-  })
-  .catch((error) => {
-    logger.error(
-      "[Main Electron] Failed to initialize SQLite:",
-      error instanceof Error ? error.message : "Unknown error",
-    );
-    // Show error to user with retry option
-    const errorDiv = document.createElement("div");
-    errorDiv.style.cssText =
-      "position: fixed; top: 50%; left: 50%; transform: translate(-50%, -50%); background: #ffebee; color: #c62828; padding: 20px; border-radius: 4px; text-align: center; max-width: 80%; z-index: 9999;";
-    errorDiv.innerHTML = `
-      <h2>Failed to Initialize Application</h2>
-      <p>There was an error initializing the database. This could be due to:</p>
-      <ul style="text-align: left; margin: 10px 0;">
-        <li>Database file is locked by another process</li>
-        <li>Insufficient permissions to access the database</li>
-        <li>Database file is corrupted</li>
-      </ul>
-      <p>Error details: ${error instanceof Error ? error.message : "Unknown error"}</p>
-      <div style="margin-top: 15px;">
-        <button onclick="window.location.reload()" style="margin: 0 5px; padding: 8px 16px; background: #c62828; color: white; border: none; border-radius: 4px; cursor: pointer;">
-          Retry
-        </button>
-        <button onclick="window.electron.ipcRenderer.send('sqlite-status', { action: 'reset' })" style="margin: 0 5px; padding: 8px 16px; background: #f57c00; color: white; border: none; border-radius: 4px; cursor: pointer;">
-          Reset Database
-        </button>
-      </div>
-    `;
-    document.body.appendChild(errorDiv);
-  });
+app.mount("#app");

src/main.web.ts

@@ -1,37 +1,5 @@
-import { initBackend } from "absurd-sql/dist/indexeddb-main-thread";
 import { initializeApp } from "./main.common";
-import { logger } from "./utils/logger";
-
-const platform = process.env.VITE_PLATFORM;
-const pwa_enabled = process.env.VITE_PWA_ENABLED === "true";
-
-logger.error("[Web] PWA enabled", { pwa_enabled });
-logger.error("[Web] Platform", { platform });
-
-// Only import service worker for web builds
-if (platform !== "electron" && pwa_enabled) {
-  import("./registerServiceWorker"); // Web PWA support
-}
+import "./registerServiceWorker"; // Web PWA support
 
 const app = initializeApp();
-
-function sqlInit() {
-  // see https://github.com/jlongster/absurd-sql
-  const worker = new Worker(
-    new URL("./registerSQLWorker.js", import.meta.url),
-    {
-      type: "module",
-    },
-  );
-  // This is only required because Safari doesn't support nested
-  // workers. This installs a handler that will proxy creating web
-  // workers through the main thread
-  initBackend(worker);
-}
-if (platform === "web" || platform === "development") {
-  sqlInit();
-} else {
-  logger.info("[Web] SQL not initialized for platform", { platform });
-}
-
 app.mount("#app");

src/registerSQLWorker.js

@@ -1,6 +0,0 @@
-import databaseService from "./services/AbsurdSqlDatabaseService";
-
-async function run() {
-  await databaseService.initialize();
-}
-run();

src/registerServiceWorker.ts

@@ -2,18 +2,8 @@
 
 import { register } from "register-service-worker";
 
-// Check if we're in an Electron environment
-const isElectron =
-  process.env.VITE_PLATFORM === "electron" ||
-  process.env.VITE_DISABLE_PWA === "true" ||
-  window.navigator.userAgent.toLowerCase().includes("electron");
-
-// Only register service worker if:
-// 1. Not in Electron
-// 2. PWA is explicitly enabled
-// 3. In production mode
+// Only register service worker if explicitly enabled and in production
 if (
-  !isElectron &&
   process.env.VITE_PWA_ENABLED === "true" &&
   process.env.NODE_ENV === "production"
 ) {
@@ -44,12 +34,6 @@ if (
   });
 } else {
   console.log(
-    `Service worker registration skipped - ${
-      isElectron
-        ? "running in Electron"
-        : process.env.VITE_PWA_ENABLED !== "true"
-          ? "PWA not enabled"
-          : "not in production mode"
-    }`,
+    "Service worker registration skipped - not enabled or not in production",
   );
 }

src/router/index.ts

@@ -2,11 +2,35 @@ import {
   createRouter,
   createWebHistory,
   createMemoryHistory,
+  NavigationGuardNext,
   RouteLocationNormalized,
   RouteRecordRaw,
 } from "vue-router";
+import { accountsDBPromise } from "../db/index";
 import { logger } from "../utils/logger";
 
+/**
+ *
+ * @param to :RouteLocationNormalized
+ * @param from :RouteLocationNormalized
+ * @param next :NavigationGuardNext
+ */
+const enterOrStart = async (
+  to: RouteLocationNormalized,
+  from: RouteLocationNormalized,
+  next: NavigationGuardNext,
+) => {
+  // one of the few times we use accountsDBPromise directly; try to avoid more usage
+  const accountsDB = await accountsDBPromise;
+  const num_accounts = await accountsDB.accounts.count();
+
+  if (num_accounts > 0) {
+    next();
+  } else {
+    next({ name: "start" });
+  }
+};
+
 const routes: Array<RouteRecordRaw> = [
   {
     path: "/account",
@@ -192,6 +216,7 @@ const routes: Array<RouteRecordRaw> = [
     path: "/projects",
     name: "projects",
     component: () => import("../views/ProjectsView.vue"),
+    beforeEnter: enterOrStart,
   },
   {
     path: "/quick-action-bvc",
@@ -277,31 +302,18 @@ const initialPath = isElectron
   ? window.location.pathname.split("/dist-electron/www/")[1] || "/"
   : window.location.pathname;
 
-logger.info("[Router] Initializing router", { isElectron, initialPath });
-
 const history = isElectron
   ? createMemoryHistory() // Memory history for Electron
   : createWebHistory("/"); // Add base path for web apps
 
+/** @type {*} */
 const router = createRouter({
   history,
   routes,
 });
 
-// Set initial route
-router.beforeEach((to, from, next) => {
-  logger.info("[Router] Navigation", { to: to.path, from: from.path });
-  next();
-});
-
 // Replace initial URL to start at `/` if necessary
-if (initialPath === "/" || !initialPath) {
-  logger.info("[Router] Setting initial route to /");
-  router.replace("/");
-} else {
-  logger.info("[Router] Setting initial route to", initialPath);
-  router.replace(initialPath);
-}
+router.replace(initialPath || "/");
 
 const errorHandler = (
   // eslint-disable-next-line @typescript-eslint/no-explicit-any

src/services/AbsurdSqlDatabaseService.d.ts

@@ -1,29 +0,0 @@
-import { DatabaseService } from "../interfaces/database";
-
-declare module "@jlongster/sql.js" {
-  interface SQL {
-    Database: unknown;
-    FS: unknown;
-    register_for_idb: (fs: unknown) => void;
-  }
-
-  function initSqlJs(config: {
-    locateFile: (file: string) => string;
-  }): Promise<SQL>;
-  export default initSqlJs;
-}
-
-declare module "absurd-sql" {
-  export class SQLiteFS {
-    constructor(fs: unknown, backend: unknown);
-  }
-}
-
-declare module "absurd-sql/dist/indexeddb-backend" {
-  export default class IndexedDBBackend {
-    constructor();
-  }
-}
-
-declare const databaseService: DatabaseService;
-export default databaseService;

src/services/AbsurdSqlDatabaseService.ts

@@ -1,243 +0,0 @@
-import initSqlJs from "@jlongster/sql.js";
-import { SQLiteFS } from "absurd-sql";
-import IndexedDBBackend from "absurd-sql/dist/indexeddb-backend";
-
-import { runMigrations } from "../db-sql/migration";
-import type { DatabaseService, QueryExecResult } from "../interfaces/database";
-import { logger } from "@/utils/logger";
-
-interface QueuedOperation {
-  type: "run" | "query" | "getOneRow" | "getAll";
-  sql: string;
-  params: unknown[];
-  resolve: (value: unknown) => void;
-  reject: (reason: unknown) => void;
-}
-
-interface AbsurdSqlDatabase {
-  exec: (sql: string, params?: unknown[]) => Promise<QueryExecResult[]>;
-  run: (
-    sql: string,
-    params?: unknown[],
-  ) => Promise<{ changes: number; lastId?: number }>;
-}
-
-class AbsurdSqlDatabaseService implements DatabaseService {
-  private static instance: AbsurdSqlDatabaseService | null = null;
-  private db: AbsurdSqlDatabase | null;
-  private initialized: boolean;
-  private initializationPromise: Promise<void> | null = null;
-  private operationQueue: Array<QueuedOperation> = [];
-  private isProcessingQueue: boolean = false;
-
-  private constructor() {
-    this.db = null;
-    this.initialized = false;
-  }
-
-  static getInstance(): AbsurdSqlDatabaseService {
-    if (!AbsurdSqlDatabaseService.instance) {
-      AbsurdSqlDatabaseService.instance = new AbsurdSqlDatabaseService();
-    }
-    return AbsurdSqlDatabaseService.instance;
-  }
-
-  async initialize(): Promise<void> {
-    // If already initialized, return immediately
-    if (this.initialized) {
-      return;
-    }
-
-    // If initialization is in progress, wait for it
-    if (this.initializationPromise) {
-      return this.initializationPromise;
-    }
-
-    // Start initialization
-    this.initializationPromise = this._initialize();
-    try {
-      await this.initializationPromise;
-    } catch (error) {
-      logger.error(`AbsurdSqlDatabaseService initialize method failed:`, error);
-      this.initializationPromise = null; // Reset on failure
-      throw error;
-    }
-  }
-
-  private async _initialize(): Promise<void> {
-    if (this.initialized) {
-      return;
-    }
-
-    const SQL = await initSqlJs({
-      locateFile: (file: string) => {
-        return new URL(
-          `/node_modules/@jlongster/sql.js/dist/${file}`,
-          import.meta.url,
-        ).href;
-      },
-    });
-
-    const sqlFS = new SQLiteFS(SQL.FS, new IndexedDBBackend());
-    SQL.register_for_idb(sqlFS);
-
-    SQL.FS.mkdir("/sql");
-    SQL.FS.mount(sqlFS, {}, "/sql");
-
-    const path = "/sql/timesafari.absurd-sql";
-    if (typeof SharedArrayBuffer === "undefined") {
-      const stream = SQL.FS.open(path, "a+");
-      await stream.node.contents.readIfFallback();
-      SQL.FS.close(stream);
-    }
-
-    this.db = new SQL.Database(path, { filename: true });
-    if (!this.db) {
-      throw new Error(
-        "The database initialization failed. We recommend you restart or reinstall.",
-      );
-    }
-
-    // An error is thrown without this pragma: "File has invalid page size. (the first block of a new file must be written first)"
-    await this.db.exec(`PRAGMA journal_mode=MEMORY;`);
-    const sqlExec = this.db.exec.bind(this.db);
-
-    // Run migrations
-    await runMigrations(sqlExec);
-
-    this.initialized = true;
-
-    // Start processing the queue after initialization
-    this.processQueue();
-  }
-
-  private async processQueue(): Promise<void> {
-    if (this.isProcessingQueue || !this.initialized || !this.db) {
-      return;
-    }
-
-    this.isProcessingQueue = true;
-
-    while (this.operationQueue.length > 0) {
-      const operation = this.operationQueue.shift();
-      if (!operation) continue;
-
-      try {
-        let queryResult: QueryExecResult[] = [];
-        let result: unknown;
-        switch (operation.type) {
-          case "run":
-            result = await this.db.run(operation.sql, operation.params);
-            break;
-          case "query":
-            result = await this.db.exec(operation.sql, operation.params);
-            break;
-          case "getOneRow":
-            queryResult = await this.db.exec(operation.sql, operation.params);
-            result = queryResult[0]?.values[0];
-            break;
-          case "getAll":
-            queryResult = await this.db.exec(operation.sql, operation.params);
-            result = queryResult[0]?.values || [];
-            break;
-        }
-        operation.resolve(result);
-      } catch (error) {
-        logger.error(
-          "Error while processing SQL queue:",
-          error,
-          " ... for sql:",
-          operation.sql,
-          " ... with params:",
-          operation.params,
-        );
-        operation.reject(error);
-      }
-    }
-
-    this.isProcessingQueue = false;
-  }
-
-  private async queueOperation<R>(
-    type: QueuedOperation["type"],
-    sql: string,
-    params: unknown[] = [],
-  ): Promise<R> {
-    return new Promise<R>((resolve, reject) => {
-      const operation: QueuedOperation = {
-        type,
-        sql,
-        params,
-        resolve: (value: unknown) => resolve(value as R),
-        reject,
-      };
-      this.operationQueue.push(operation);
-
-      // If we're already initialized, start processing the queue
-      if (this.initialized && this.db) {
-        this.processQueue();
-      }
-    });
-  }
-
-  private async waitForInitialization(): Promise<void> {
-    // If we have an initialization promise, wait for it
-    if (this.initializationPromise) {
-      await this.initializationPromise;
-      return;
-    }
-
-    // If not initialized and no promise, start initialization
-    if (!this.initialized) {
-      await this.initialize();
-      return;
-    }
-
-    // If initialized but no db, something went wrong
-    if (!this.db) {
-      logger.error(
-        `Database not properly initialized after await waitForInitialization() - initialized flag is true but db is null`,
-      );
-      throw new Error(
-        `The database could not be initialized. We recommend you restart or reinstall.`,
-      );
-    }
-  }
-
-  // Used for inserts, updates, and deletes
-  async run(
-    sql: string,
-    params: unknown[] = [],
-  ): Promise<{ changes: number; lastId?: number }> {
-    await this.waitForInitialization();
-    return this.queueOperation<{ changes: number; lastId?: number }>(
-      "run",
-      sql,
-      params,
-    );
-  }
-
-  // Note that the resulting array may be empty if there are no results from the query
-  async query(sql: string, params: unknown[] = []): Promise<QueryExecResult[]> {
-    await this.waitForInitialization();
-    return this.queueOperation<QueryExecResult[]>("query", sql, params);
-  }
-
-  async getOneRow(
-    sql: string,
-    params: unknown[] = [],
-  ): Promise<unknown[] | undefined> {
-    await this.waitForInitialization();
-    return this.queueOperation<unknown[] | undefined>("getOneRow", sql, params);
-  }
-
-  async getAll(sql: string, params: unknown[] = []): Promise<unknown[][]> {
-    await this.waitForInitialization();
-    return this.queueOperation<unknown[][]>("getAll", sql, params);
-  }
-}
-
-// Create a singleton instance
-const databaseService = AbsurdSqlDatabaseService.getInstance();
-
-export default databaseService;

src/services/PlatformService.ts

@@ -1,13 +1,3 @@
-import { QueryExecResult } from "@/interfaces/database";
-
-/**
- * Query execution result interface
- */
-export interface QueryExecResult<T = unknown> {
-  columns: string[];
-  values: T[];
-}
-
 /**
  * Represents the result of an image capture or selection operation.
  * Contains both the image data as a Blob and the associated filename.
@@ -108,26 +98,4 @@ export interface PlatformService {
    * @returns Promise that resolves when the deep link has been handled
    */
   handleDeepLink(url: string): Promise<void>;
-
-  /**
-   * Execute a database query and return the results
-   * @param sql SQL query to execute
-   * @param params Query parameters
-   * @returns Query results with columns and values
-   */
-  dbQuery<T = unknown>(
-    sql: string,
-    params?: unknown[],
-  ): Promise<QueryExecResult<T>>;
-
-  /**
-   * Executes a create/update/delete on the database.
-   * @param sql - The SQL statement to execute
-   * @param params - The parameters to pass to the statement
-   * @returns Promise resolving to the result of the statement
-   */
-  dbExec(
-    sql: string,
-    params?: unknown[],
-  ): Promise<{ changes: number; lastId?: number }>;
 }

src/services/QRScanner/CapacitorQRScanner.ts

@@ -4,13 +4,7 @@ import {
   StartScanOptions,
   LensFacing,
 } from "@capacitor-mlkit/barcode-scanning";
-import {
-  QRScannerService,
-  ScanListener,
-  QRScannerOptions,
-  CameraStateListener,
-  CameraState,
-} from "./types";
+import { QRScannerService, ScanListener, QRScannerOptions } from "./types";
 import { logger } from "@/utils/logger";
 
 export class CapacitorQRScanner implements QRScannerService {
@@ -18,9 +12,6 @@ export class CapacitorQRScanner implements QRScannerService {
   private isScanning = false;
   private listenerHandles: Array<() => Promise<void>> = [];
   private cleanupPromise: Promise<void> | null = null;
-  private cameraStateListeners: Set<CameraStateListener> = new Set();
-  private currentState: CameraState = "off";
-  private currentStateMessage?: string;
 
   async checkPermissions(): Promise<boolean> {
     try {
@@ -88,11 +79,8 @@ export class CapacitorQRScanner implements QRScannerService {
     }
 
     try {
-      this.updateCameraState("initializing", "Starting camera...");
-
       // Ensure we have permissions before starting
       if (!(await this.checkPermissions())) {
-        this.updateCameraState("permission_denied", "Camera permission denied");
         logger.debug("Requesting camera permissions");
         const granted = await this.requestPermissions();
         if (!granted) {
@@ -102,16 +90,11 @@ export class CapacitorQRScanner implements QRScannerService {
 
       // Check if scanning is supported
       if (!(await this.isSupported())) {
-        this.updateCameraState(
-          "error",
-          "QR scanning not supported on this device",
-        );
         throw new Error("QR scanning not supported on this device");
       }
 
       logger.info("Starting MLKit scanner");
       this.isScanning = true;
-      this.updateCameraState("active", "Camera is active");
 
       const scanOptions: StartScanOptions = {
         formats: [BarcodeFormat.QrCode],
@@ -143,7 +126,6 @@ export class CapacitorQRScanner implements QRScannerService {
         stack: wrappedError.stack,
       });
       this.isScanning = false;
-      this.updateCameraState("error", wrappedError.message);
       await this.cleanup();
       this.scanListener?.onError?.(wrappedError);
       throw wrappedError;
@@ -158,7 +140,6 @@ export class CapacitorQRScanner implements QRScannerService {
 
     try {
       logger.debug("Stopping QR scanner");
-      this.updateCameraState("off", "Camera stopped");
       await BarcodeScanner.stopScan();
       logger.info("QR scanner stopped successfully");
     } catch (error) {
@@ -168,7 +149,6 @@ export class CapacitorQRScanner implements QRScannerService {
         error: wrappedError.message,
         stack: wrappedError.stack,
       });
-      this.updateCameraState("error", wrappedError.message);
       this.scanListener?.onError?.(wrappedError);
       throw wrappedError;
     } finally {
@@ -227,23 +207,4 @@ export class CapacitorQRScanner implements QRScannerService {
     // No-op for native scanner
     callback(null);
   }
-
-  addCameraStateListener(listener: CameraStateListener): void {
-    this.cameraStateListeners.add(listener);
-    // Immediately notify the new listener of current state
-    listener.onStateChange(this.currentState, this.currentStateMessage);
-  }
-
-  removeCameraStateListener(listener: CameraStateListener): void {
-    this.cameraStateListeners.delete(listener);
-  }
-
-  private updateCameraState(state: CameraState, message?: string): void {
-    this.currentState = state;
-    this.currentStateMessage = message;
-    // Notify all listeners of state change
-    for (const listener of this.cameraStateListeners) {
-      listener.onStateChange(state, message);
-    }
-  }
 }