update messaging for unknown icons on home feed

- Known entities get routed to their corresponding detail views
- Unknown entities pop up a notification

.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",

.gitignore

@@ -51,6 +51,7 @@ vendor/
 # Build logs
 build_logs/
 
-android/app/src/main/assets/public
-android/app/src/main/res
+# PWA icon files generated by capacitor-assets
+icons
+
 

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:
@@ -345,7 +343,11 @@ Prerequisites: macOS with Xcode installed
 3. Copy the assets:
 
    ```bash
+   # It makes no sense why capacitor-assets will not run without these but it actually changes the contents.
    mkdir -p ios/App/App/Assets.xcassets/AppIcon.appiconset
+   echo '{"images":[]}' > ios/App/App/Assets.xcassets/AppIcon.appiconset/Contents.json
+   mkdir -p ios/App/App/Assets.xcassets/Splash.imageset
+   echo '{"images":[]}' > ios/App/App/Assets.xcassets/Splash.imageset/Contents.json
    npx capacitor-assets generate --ios
    ```
 

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

@@ -1,5 +1,5 @@
 {
-	"appId": "app.timesafari",
+	"appId": "app.timesafari.app",
 	"appName": "TimeSafari",
 	"webDir": "dist",
 	"bundledWebRuntime": false,
@@ -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/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -1,5 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/ic_launcher_background"/>
-    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+    <background>
+        <inset android:drawable="@mipmap/ic_launcher_background" android:inset="16.7%" />
+    </background>
+    <foreground>
+        <inset android:drawable="@mipmap/ic_launcher_foreground" android:inset="16.7%" />
+    </foreground>
 </adaptive-icon>

android/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml

@@ -1,5 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/ic_launcher_background"/>
-    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+    <background>
+        <inset android:drawable="@mipmap/ic_launcher_background" android:inset="16.7%" />
+    </background>
+    <foreground>
+        <inset android:drawable="@mipmap/ic_launcher_foreground" android:inset="16.7%" />
+    </foreground>
 </adaptive-icon>

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/dexie-to-sqlite-mapping.md

@@ -1,399 +0,0 @@
-# Dexie to absurd-sql Mapping Guide
-
-## Schema Mapping
-
-### Current Dexie Schema
-```typescript
-// Current Dexie schema
-const db = new Dexie('TimeSafariDB');
-
-db.version(1).stores({
-  accounts: 'did, publicKeyHex, createdAt, updatedAt',
-  settings: 'key, value, updatedAt',
-  contacts: 'id, did, name, createdAt, updatedAt'
-});
-```
-
-### New SQLite Schema
-```sql
--- New SQLite schema
-CREATE TABLE accounts (
-  did TEXT PRIMARY KEY,
-  public_key_hex TEXT NOT NULL,
-  created_at INTEGER NOT NULL,
-  updated_at INTEGER NOT NULL
-);
-
-CREATE TABLE settings (
-  key TEXT PRIMARY KEY,
-  value TEXT NOT NULL,
-  updated_at INTEGER NOT NULL
-);
-
-CREATE TABLE contacts (
-  id TEXT PRIMARY KEY,
-  did TEXT NOT NULL,
-  name TEXT,
-  created_at INTEGER NOT NULL,
-  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);
-```
-
-## Query Mapping
-
-### 1. Account Operations
-
-#### Get Account by DID
-```typescript
-// Dexie
-const account = await db.accounts.get(did);
-
-// absurd-sql
-const result = await db.exec(`
-  SELECT * FROM accounts WHERE did = ?
-`, [did]);
-const account = result[0]?.values[0];
-```
-
-#### Get All Accounts
-```typescript
-// Dexie
-const accounts = await db.accounts.toArray();
-
-// absurd-sql
-const result = await db.exec(`
-  SELECT * FROM accounts ORDER BY created_at DESC
-`);
-const accounts = result[0]?.values || [];
-```
-
-#### Add Account
-```typescript
-// Dexie
-await db.accounts.add({
-  did,
-  publicKeyHex,
-  createdAt: Date.now(),
-  updatedAt: Date.now()
-});
-
-// absurd-sql
-await db.run(`
-  INSERT INTO accounts (did, public_key_hex, created_at, updated_at)
-  VALUES (?, ?, ?, ?)
-`, [did, publicKeyHex, Date.now(), Date.now()]);
-```
-
-#### Update Account
-```typescript
-// Dexie
-await db.accounts.update(did, {
-  publicKeyHex,
-  updatedAt: Date.now()
-});
-
-// absurd-sql
-await db.run(`
-  UPDATE accounts 
-  SET public_key_hex = ?, updated_at = ?
-  WHERE did = ?
-`, [publicKeyHex, Date.now(), did]);
-```
-
-### 2. Settings Operations
-
-#### Get Setting
-```typescript
-// Dexie
-const setting = await db.settings.get(key);
-
-// absurd-sql
-const result = await db.exec(`
-  SELECT * FROM settings WHERE key = ?
-`, [key]);
-const setting = result[0]?.values[0];
-```
-
-#### Set Setting
-```typescript
-// Dexie
-await db.settings.put({
-  key,
-  value,
-  updatedAt: Date.now()
-});
-
-// absurd-sql
-await db.run(`
-  INSERT INTO settings (key, value, updated_at)
-  VALUES (?, ?, ?)
-  ON CONFLICT(key) DO UPDATE SET
-    value = excluded.value,
-    updated_at = excluded.updated_at
-`, [key, value, Date.now()]);
-```
-
-### 3. Contact Operations
-
-#### Get Contacts by Account
-```typescript
-// Dexie
-const contacts = await db.contacts
-  .where('did')
-  .equals(accountDid)
-  .toArray();
-
-// absurd-sql
-const result = await db.exec(`
-  SELECT * FROM contacts 
-  WHERE did = ?
-  ORDER BY created_at DESC
-`, [accountDid]);
-const contacts = result[0]?.values || [];
-```
-
-#### Add Contact
-```typescript
-// Dexie
-await db.contacts.add({
-  id: generateId(),
-  did: accountDid,
-  name,
-  createdAt: Date.now(),
-  updatedAt: Date.now()
-});
-
-// absurd-sql
-await db.run(`
-  INSERT INTO contacts (id, did, name, created_at, updated_at)
-  VALUES (?, ?, ?, ?, ?)
-`, [generateId(), accountDid, name, Date.now(), Date.now()]);
-```
-
-## Transaction Mapping
-
-### Batch Operations
-```typescript
-// Dexie
-await db.transaction('rw', [db.accounts, db.contacts], async () => {
-  await db.accounts.add(account);
-  await db.contacts.bulkAdd(contacts);
-});
-
-// absurd-sql
-await db.exec('BEGIN TRANSACTION;');
-try {
-  await db.run(`
-    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(`
-      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
-
-### 1. Data Export (Dexie to JSON)
-```typescript
-async function exportDexieData(): Promise<MigrationData> {
-  const db = new Dexie('TimeSafariDB');
-  
-  return {
-    accounts: await db.accounts.toArray(),
-    settings: await db.settings.toArray(),
-    contacts: await db.contacts.toArray(),
-    metadata: {
-      version: '1.0.0',
-      timestamp: Date.now(),
-      dexieVersion: Dexie.version
-    }
-  };
-}
-```
-
-### 2. Data Import (JSON to absurd-sql)
-```typescript
-async function importToAbsurdSql(data: MigrationData): Promise<void> {
-  await db.exec('BEGIN TRANSACTION;');
-  try {
-    // Import accounts
-    for (const account of data.accounts) {
-      await db.run(`
-        INSERT INTO accounts (did, public_key_hex, created_at, updated_at)
-        VALUES (?, ?, ?, ?)
-      `, [account.did, account.publicKeyHex, account.createdAt, account.updatedAt]);
-    }
-    
-    // Import settings
-    for (const setting of data.settings) {
-      await db.run(`
-        INSERT INTO settings (key, value, updated_at)
-        VALUES (?, ?, ?)
-      `, [setting.key, setting.value, setting.updatedAt]);
-    }
-    
-    // Import contacts
-    for (const contact of data.contacts) {
-      await db.run(`
-        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> {
-  // Verify account count
-  const accountResult = await db.exec('SELECT COUNT(*) as count FROM accounts');
-  const accountCount = accountResult[0].values[0][0];
-  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];
-  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];
-  if (contactsCount !== dexieData.contacts.length) {
-    return false;
-  }
-  
-  // Verify data integrity
-  for (const account of dexieData.accounts) {
-    const result = await db.exec(
-      '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
-      return false;
-    }
-  }
-  
-  return true;
-}
-```
-
-## Performance Considerations
-
-### 1. Indexing
-- Dexie automatically creates indexes based on the schema
-- absurd-sql 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
-- 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
-- Use prepared statements for repeated queries
-- Consider using `PRAGMA synchronous=NORMAL;` for better performance
-
-## Error Handling
-
-### 1. Common Errors
-```typescript
-// Dexie errors
-try {
-  await db.accounts.add(account);
-} catch (error) {
-  if (error instanceof Dexie.ConstraintError) {
-    // Handle duplicate key
-  }
-}
-
-// absurd-sql errors
-try {
-  await db.run(`
-    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')) {
-    // Handle duplicate key
-  }
-}
-```
-
-### 2. Transaction Recovery
-```typescript
-// Dexie transaction
-try {
-  await db.transaction('rw', db.accounts, async () => {
-    // Operations
-  });
-} catch (error) {
-  // Dexie automatically rolls back
-}
-
-// absurd-sql transaction
-try {
-  await db.exec('BEGIN TRANSACTION;');
-  // Operations
-  await db.exec('COMMIT;');
-} catch (error) {
-  await db.exec('ROLLBACK;');
-  throw error;
-}
-```
-
-## Migration Strategy
-
-1. **Preparation**
-   - Export all Dexie data
-   - Verify data integrity
-   - Create SQLite schema
-   - Setup indexes
-
-2. **Migration**
-   - Import data in transactions
-   - Verify each batch
-   - Handle errors gracefully
-   - Maintain backup
-
-3. **Verification**
-   - Compare record counts
-   - Verify data integrity
-   - Test common queries
-   - Validate relationships
-
-4. **Cleanup**
-   - Remove Dexie database
-   - Clear IndexedDB storage
-   - Update application code
-   - Remove old dependencies 

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

doc/storage-implementation-checklist.md

@@ -1,329 +0,0 @@
-# Storage Implementation Checklist
-
-## 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
-
-- [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)
-    - [ ] SQLCipher integration
-    - [ ] Native bridge setup
-    - [ ] File system access
-  - [ ] `ElectronSQLiteService` (planned)
-    - [ ] 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)
-  - [ ] Progress indicators
-  - [ ] Error handling
-  - [ ] User notifications
-  - [ ] Manual triggers
-
-### 3. Security Layer
-- [x] Basic data integrity
-- [ ] Implement `EncryptionService` (planned)
-  - [ ] Key management
-  - [ ] Encryption/decryption
-  - [ ] Secure storage
-- [ ] Add `BiometricService` (planned)
-  - [ ] Platform detection
-  - [ ] Authentication flow
-  - [ ] Fallback mechanisms
-
-## Platform-Specific Implementation
-
-### Web Platform
-- [x] Setup absurd-sql
-  - [x] Install dependencies
-    ```json
-    {
-      "@jlongster/sql.js": "^1.8.0",
-      "absurd-sql": "^1.8.0"
-    }
-    ```
-  - [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;
-    ```
-
-- [x] Update build configuration
-  - [x] Modify `vite.config.ts`
-  - [x] Add worker configuration
-  - [x] Update chunk splitting
-  - [x] Configure asset handling
-
-- [x] Implement IndexedDB backend
-  - [x] Create database service
-  - [x] Add operation queuing
-  - [x] Handle initialization
-  - [x] Implement atomic operations
-
-### iOS Platform (Planned)
-- [ ] Setup SQLCipher
-  - [ ] Install pod dependencies
-  - [ ] Configure encryption
-  - [ ] Setup keychain access
-  - [ ] Implement secure storage
-
-- [ ] Update Capacitor config
-  - [ ] Modify `capacitor.config.ts`
-  - [ ] Add iOS permissions
-  - [ ] Configure backup
-  - [ ] Setup app groups
-
-### Android Platform (Planned)
-- [ ] Setup SQLCipher
-  - [ ] Add Gradle dependencies
-  - [ ] Configure encryption
-  - [ ] Setup keystore
-  - [ ] Implement secure storage
-
-- [ ] Update Capacitor config
-  - [ ] Modify `capacitor.config.ts`
-  - [ ] Add Android permissions
-  - [ ] Configure backup
-  - [ ] Setup file provider
-
-### Electron Platform (Planned)
-- [ ] Setup Node SQLite
-  - [ ] Install dependencies
-  - [ ] Configure IPC
-  - [ ] Setup file system access
-  - [ ] Implement secure storage
-
-- [ ] Update Electron config
-  - [ ] Modify `electron.config.ts`
-  - [ ] Add security policies
-  - [ ] Configure file access
-  - [ ] Setup auto-updates
-
-## Data Models and Types
-
-### 1. Database Schema
-- [x] Define tables
-
-  ```sql
-  -- Accounts table
-  CREATE TABLE accounts (
-    did TEXT PRIMARY KEY,
-    public_key_hex TEXT NOT NULL,
-    created_at INTEGER NOT NULL,
-    updated_at INTEGER NOT NULL
-  );
-
-  -- Settings table
-  CREATE TABLE settings (
-    key TEXT PRIMARY KEY,
-    value TEXT NOT NULL,
-    updated_at INTEGER NOT NULL
-  );
-
-  -- Contacts table
-  CREATE TABLE contacts (
-    id TEXT PRIMARY KEY,
-    did TEXT NOT NULL,
-    name TEXT,
-    created_at INTEGER NOT NULL,
-    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)
-
-### 2. Type Definitions
-
-- [x] Create interfaces
-  ```typescript
-  interface Account {
-    did: string;
-    publicKeyHex: string;
-    createdAt: number;
-    updatedAt: number;
-  }
-
-  interface Setting {
-    key: string;
-    value: string;
-    updatedAt: number;
-  }
-
-  interface Contact {
-    id: string;
-    did: string;
-    name?: string;
-    createdAt: number;
-    updatedAt: number;
-  }
-  ```
-
-- [x] Add validation
-- [x] Create DTOs
-- [x] Define enums
-- [x] Add type guards
-
-## UI Components
-
-### 1. Migration UI (Planned)
-- [ ] Create components
-  - [ ] `MigrationProgress.vue`
-  - [ ] `MigrationError.vue`
-  - [ ] `MigrationSettings.vue`
-  - [ ] `MigrationStatus.vue`
-
-### 2. Settings UI (Planned)
-- [ ] Update components
-  - [ ] Add storage settings
-  - [ ] Add migration controls
-  - [ ] Add backup options
-  - [ ] Add security settings
-
-### 3. Error Handling UI (Planned)
-- [ ] Create components
-  - [ ] `StorageError.vue`
-  - [ ] `QuotaExceeded.vue`
-  - [ ] `MigrationFailed.vue`
-  - [ ] `RecoveryOptions.vue`
-
-## Testing
-
-### 1. Unit Tests
-- [x] Basic service tests
-  - [x] Platform service tests
-  - [x] Database operation tests
-  - [ ] Security service tests (planned)
-  - [ ] Platform detection tests (planned)
-
-### 2. Integration Tests (Planned)
-- [ ] Test migrations
-  - [ ] Web platform tests
-  - [ ] iOS platform tests
-  - [ ] Android platform tests
-  - [ ] Electron platform tests
-
-### 3. E2E Tests (Planned)
-- [ ] Test workflows
-  - [ ] Account management
-  - [ ] Settings management
-  - [ ] Contact management
-  - [ ] Migration process
-
-## Documentation
-
-### 1. Technical Documentation
-- [x] Update architecture docs
-- [x] Add API documentation
-- [ ] Create migration guides (planned)
-- [ ] Document security measures (planned)
-
-### 2. User Documentation (Planned)
-- [ ] Update user guides
-- [ ] Add troubleshooting guides
-- [ ] Create FAQ
-- [ ] Document new features
-
-## Deployment
-
-### 1. Build Process
-- [x] Update build scripts
-- [x] Add platform-specific builds
-- [ ] Configure CI/CD (planned)
-- [ ] Setup automated testing (planned)
-
-### 2. Release Process (Planned)
-- [ ] Create release checklist
-- [ ] Add version management
-- [ ] Setup rollback procedures
-- [ ] Configure monitoring
-
-## Monitoring and Analytics (Planned)
-
-### 1. Error Tracking
-- [ ] Setup error logging
-- [ ] Add performance monitoring
-- [ ] Configure alerts
-- [ ] Create dashboards
-
-### 2. Usage Analytics
-- [ ] Add storage metrics
-- [ ] Track migration success
-- [ ] Monitor performance
-- [ ] Collect user feedback
-
-## Security Audit (Planned)
-
-### 1. Code Review
-- [ ] Review encryption
-- [ ] Check access controls
-- [ ] Verify data handling
-- [ ] Audit dependencies
-
-### 2. Penetration Testing
-- [ ] Test data access
-- [ ] Verify encryption
-- [ ] Check authentication
-- [ ] Review permissions
-
-## 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)
-
-### 2. Reliability
-- [x] Basic data integrity
-- [x] Operation queuing
-- [ ] Automatic recovery (planned)
-- [ ] Backup verification (planned)
-- [ ] Transaction atomicity (planned)
-- [ ] Data consistency (planned)
-
-### 3. Security
-- [x] Basic data integrity
-- [ ] AES-256 encryption (planned)
-- [ ] Secure key storage (planned)
-- [ ] Access control (planned)
-- [ ] Audit logging (planned)
-
-### 4. User Experience
-- [x] Basic database operations
-- [ ] Smooth migration (planned)
-- [ ] Clear error messages (planned)
-- [ ] Progress indicators (planned)
-- [ ] Recovery options (planned) 

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();

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/.gitignore

@@ -11,3 +11,16 @@ capacitor-cordova-ios-plugins
 # Generated Config files
 App/App/capacitor.config.json
 App/App/config.xml
+
+# User-specific Xcode files
+App/App.xcodeproj/xcuserdata/*.xcuserdatad/
+App/App.xcodeproj/*.xcuserstate
+
+fastlane/report.xml
+fastlane/Preview.html
+fastlane/screenshots
+fastlane/test_output
+
+# Generated Icons from capacitor-assets (also Contents.json which is confusing; see BUILDING.md)
+App/App/Assets.xcassets/AppIcon.appiconset
+App/App/Assets.xcassets/Splash.imageset

ios/App/App.xcodeproj/project.pbxproj

@@ -380,6 +380,7 @@
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				CODE_SIGN_STYLE = Automatic;
 				CURRENT_PROJECT_VERSION = 18;
+				DEVELOPMENT_TEAM = GM3FS5JQPH;
 				ENABLE_APP_SANDBOX = NO;
 				ENABLE_USER_SCRIPT_SANDBOXING = NO;
 				INFOPLIST_FILE = App/Info.plist;
@@ -406,6 +407,7 @@
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				CODE_SIGN_STYLE = Automatic;
 				CURRENT_PROJECT_VERSION = 18;
+				DEVELOPMENT_TEAM = GM3FS5JQPH;
 				ENABLE_APP_SANDBOX = NO;
 				ENABLE_USER_SCRIPT_SANDBOXING = NO;
 				INFOPLIST_FILE = App/Info.plist;

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/App/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -1,14 +0,0 @@
-{
-  "images": [
-    {
-      "idiom": "universal",
-      "size": "1024x1024",
-      "filename": "AppIcon-512@2x.png",
-      "platform": "ios"
-    }
-  ],
-  "info": {
-    "author": "xcode",
-    "version": 1
-  }
-}

ios/App/App/Assets.xcassets/Splash.imageset/Contents.json

@@ -1,23 +0,0 @@
-{
-  "images" : [
-    {
-      "idiom" : "universal",
-      "filename" : "splash-2732x2732-2.png",
-      "scale" : "1x"
-    },
-    {
-      "idiom" : "universal",
-      "filename" : "splash-2732x2732-1.png",
-      "scale" : "2x"
-    },
-    {
-      "idiom" : "universal",
-      "filename" : "splash-2732x2732.png",
-      "scale" : "3x"
-    }
-  ],
-  "info" : {
-    "version" : 1,
-    "author" : "xcode"
-  }
-}

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'

main.js

@@ -0,0 +1,29 @@
+const { app, BrowserWindow } = require('electron');
+const path = require('path');
+
+function createWindow() {
+  const win = new BrowserWindow({
+    width: 1200,
+    height: 800,
+    webPreferences: {
+      nodeIntegration: true,
+      contextIsolation: false
+    }
+  });
+
+  win.loadFile(path.join(__dirname, 'dist-electron/www/index.html'));
+}
+
+app.whenReady().then(createWindow);
+
+app.on('window-all-closed', () => {
+  if (process.platform !== 'darwin') {
+    app.quit();
+  }
+});
+
+app.on('activate', () => {
+  if (BrowserWindow.getAllWindows().length === 0) {
+    createWindow();
+  }
+}); 

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,36 +155,29 @@
     "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",
+    "appId": "app.timesafari.app",
     "productName": "TimeSafari",
     "directories": {
       "output": "dist-electron-packages"
     },
     "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/check-prerequisites.js

@@ -51,7 +51,7 @@ const { existsSync } = require('fs');
  */
 function checkCommand(command, errorMessage) {
     try {
-        execSync(command + ' --version', { stdio: 'ignore' });
+        execSync(command, { stdio: 'ignore' });
         return true;
     } catch (e) {
         console.error(`❌ ${errorMessage}`);
@@ -164,10 +164,10 @@ function main() {
 
     // Check required command line tools
     // These are essential for building and testing the application
-    success &= checkCommand('node', 'Node.js is required');
-    success &= checkCommand('npm', 'npm is required');
-    success &= checkCommand('gradle', 'Gradle is required for Android builds');
-    success &= checkCommand('xcodebuild', 'Xcode is required for iOS builds');
+    success &= checkCommand('node --version', 'Node.js is required');
+    success &= checkCommand('npm --version', 'npm is required');
+    success &= checkCommand('gradle --version', 'Gradle is required for Android builds');
+    success &= checkCommand('xcodebuild --help', 'Xcode is required for iOS builds');
 
     // Check platform-specific development environments
     success &= checkAndroidSetup();

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!'); 

scripts/test-android.js

@@ -170,7 +170,7 @@ const executeDeeplink = async (url, description, log) => {
     
     try {
         // Stop the app before executing the deep link
-        execSync('adb shell am force-stop app.timesafari');
+        execSync('adb shell am force-stop app.timesafari.app');
         await new Promise(resolve => setTimeout(resolve, 1000)); // Wait 1s
         
         execSync(`adb shell am start -W -a android.intent.action.VIEW -d "${url}" -c android.intent.category.BROWSABLE`);

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/ActivityListItem.vue

@@ -14,22 +14,37 @@
       class="flex items-center justify-between gap-2 text-lg bg-slate-200 border border-slate-300 border-b-0 rounded-t-md px-3 sm:px-4 py-1 sm:py-2"
     >
       <div class="flex items-center gap-2">
-        <div v-if="record.issuerDid">
+        <router-link
+          v-if="record.issuerDid && !isHiddenDid(record.issuerDid)"
+          :to="{
+            path: '/did/' + encodeURIComponent(record.issuerDid),
+          }"
+          title="More details about this person"
+        >
           <EntityIcon
             :entity-id="record.issuerDid"
             class="rounded-full bg-white overflow-hidden !size-[2rem] object-cover"
           />
-        </div>
-        <div v-else>
-          <font-awesome
-            icon="person-circle-question"
-            class="text-slate-300 text-[2rem]"
-          />
-        </div>
+        </router-link>
+        <font-awesome
+          v-else-if="isHiddenDid(record.issuerDid)"
+          icon="eye-slash"
+          class="text-slate-400 !size-[2rem] cursor-pointer"
+          @click="notifyHiddenPerson"
+        />
+        <font-awesome
+          v-else
+          icon="person-circle-question"
+          class="text-slate-400 !size-[2rem] cursor-pointer"
+          @click="notifyUnknownPerson"
+        />
 
         <div>
-          <h3 class="font-semibold">
-            {{ record.issuer.known ? record.issuer.displayName : "" }}
+          <h3
+            v-if="record.issuer.known"
+            class="font-semibold leading-tight"
+          >
+            {{ record.issuer.displayName }}
           </h3>
           <p class="ms-auto text-xs text-slate-500 italic">
             {{ friendlyDate }}
@@ -46,7 +61,7 @@
       <!-- Record Image -->
       <div
         v-if="record.image"
-        class="bg-cover mb-6 -mt-3 sm:-mt-4 -mx-3 sm:-mx-4"
+        class="bg-cover mb-4 -mt-3 sm:-mt-4 -mx-3 sm:-mx-4"
         :style="`background-image: url(${record.image});`"
       >
         <a
@@ -63,33 +78,55 @@
       </div>
 
       <div
-        class="relative flex justify-between gap-4 max-w-[40rem] mx-auto mb-5"
+        class="relative flex justify-between gap-4 max-w-[40rem] mx-auto mb-3"
       >
         <!-- Source -->
         <div
-          class="w-[8rem] sm:w-[12rem] text-center bg-white border border-slate-200 rounded p-2 sm:p-3"
+          class="w-[7rem] sm:w-[12rem] text-center bg-white border border-slate-200 rounded p-2 sm:p-3"
         >
           <div class="relative w-fit mx-auto">
             <div>
               <!-- Project Icon -->
               <div v-if="record.providerPlanName">
-                <ProjectIcon
-                  :entity-id="record.providerPlanName"
-                  :icon-size="48"
-                  class="rounded size-[3rem] sm:size-[4rem] *:w-full *:h-full"
-                />
+                <router-link
+                  :to="{
+                    path: '/project/' + encodeURIComponent(record.providerPlanHandleId || ''),
+                  }"
+                  title="View project details"
+                >
+                  <ProjectIcon
+                    :entity-id="record.providerPlanHandleId || ''"
+                    :icon-size="48"
+                    class="rounded size-[3rem] sm:size-[4rem] *:w-full *:h-full"
+                  />
+                </router-link>
               </div>
               <!-- Identicon for DIDs -->
               <div v-else-if="record.agentDid">
-                <EntityIcon
-                  :entity-id="record.agentDid"
-                  :profile-image-url="record.issuer.profileImageUrl"
-                  class="rounded-full bg-slate-100 overflow-hidden !size-[3rem] sm:!size-[4rem]"
+                <router-link
+                  v-if="!isHiddenDid(record.agentDid)"
+                  :to="{
+                    path: '/did/' + encodeURIComponent(record.agentDid),
+                  }"
+                  title="More details about this person"
+                >
+                  <EntityIcon
+                    :entity-id="record.agentDid"
+                    :profile-image-url="record.issuer.profileImageUrl"
+                    class="rounded-full bg-slate-100 overflow-hidden !size-[3rem] sm:!size-[4rem]"
+                  />
+                </router-link>
+                <font-awesome
+                  v-else
+                  @click="notifyHiddenPerson"
+                  icon="eye-slash"
+                  class="text-slate-300 !size-[3rem] sm:!size-[4rem]"
                 />
               </div>
               <!-- Unknown Person -->
               <div v-else>
                 <font-awesome
+                  @click="notifyUnknownPerson"
                   icon="person-circle-question"
                   class="text-slate-300 text-[3rem] sm:text-[4rem]"
                 />
@@ -110,9 +147,9 @@
 
         <!-- Arrow -->
         <div
-          class="absolute inset-x-[8rem] sm:inset-x-[12rem] mx-2 top-1/2 -translate-y-1/2"
+          class="absolute inset-x-[7rem] sm:inset-x-[12rem] mx-2 top-1/2 -translate-y-1/2"
         >
-          <div class="text-sm text-center leading-none font-semibold pe-[15px]">
+          <div class="text-sm text-center leading-none font-semibold pe-2 sm:pe-4">
             {{ fetchAmount }}
           </div>
 
@@ -129,29 +166,51 @@
 
         <!-- Destination -->
         <div
-          class="w-[8rem] sm:w-[12rem] text-center bg-white border border-slate-200 rounded p-2 sm:p-3"
+          class="w-[7rem] sm:w-[12rem] text-center bg-white border border-slate-200 rounded p-2 sm:p-3"
         >
           <div class="relative w-fit mx-auto">
             <div>
               <!-- Project Icon -->
               <div v-if="record.recipientProjectName">
-                <ProjectIcon
-                  :entity-id="record.recipientProjectName"
-                  :icon-size="48"
-                  class="rounded size-[3rem] sm:size-[4rem] *:w-full *:h-full"
-                />
+                <router-link
+                  :to="{
+                    path: '/project/' + encodeURIComponent(record.fulfillsPlanHandleId || ''),
+                  }"
+                  title="View project details"
+                >
+                  <ProjectIcon
+                    :entity-id="record.fulfillsPlanHandleId || ''"
+                    :icon-size="48"
+                    class="rounded size-[3rem] sm:size-[4rem] *:w-full *:h-full"
+                  />
+                </router-link>
               </div>
               <!-- Identicon for DIDs -->
               <div v-else-if="record.recipientDid">
-                <EntityIcon
-                  :entity-id="record.recipientDid"
-                  :profile-image-url="record.receiver.profileImageUrl"
-                  class="rounded-full bg-slate-100 overflow-hidden !size-[3rem] sm:!size-[4rem]"
+                <router-link
+                  v-if="!isHiddenDid(record.recipientDid)"
+                  :to="{
+                    path: '/did/' + encodeURIComponent(record.recipientDid),
+                  }"
+                  title="More details about this person"
+                >
+                  <EntityIcon
+                    :entity-id="record.recipientDid"
+                    :profile-image-url="record.receiver.profileImageUrl"
+                    class="rounded-full bg-slate-100 overflow-hidden !size-[3rem] sm:!size-[4rem]"
+                  />
+                </router-link>
+                <font-awesome
+                  v-else
+                  @click="notifyHiddenPerson"
+                  icon="eye-slash"
+                  class="text-slate-300 !size-[3rem] sm:!size-[4rem]"
                 />
               </div>
               <!-- Unknown Person -->
               <div v-else>
                 <font-awesome
+                  @click="notifyUnknownPerson"
                   icon="person-circle-question"
                   class="text-slate-300 text-[3rem] sm:text-[4rem]"
                 />
@@ -186,8 +245,9 @@ import { Component, Prop, Vue, Emit } from "vue-facing-decorator";
 import { GiveRecordWithContactInfo } from "../types";
 import EntityIcon from "./EntityIcon.vue";
 import { isGiveClaimType, notifyWhyCannotConfirm } from "../libs/util";
-import { containsHiddenDid } from "../libs/endorserServer";
+import { containsHiddenDid, isHiddenDid } from "../libs/endorserServer";
 import ProjectIcon from "./ProjectIcon.vue";
+import { NotificationIface } from "../constants/app";
 
 @Component({
   components: {
@@ -202,6 +262,33 @@ export default class ActivityListItem extends Vue {
   @Prop() activeDid!: string;
   @Prop() confirmerIdList?: string[];
 
+  isHiddenDid = isHiddenDid;
+  $notify!: (notification: NotificationIface, timeout?: number) => void;
+
+  notifyHiddenPerson() {
+    this.$notify(
+      {
+        group: "alert",
+        type: "warning",
+        title: "Person Outside Your Network",
+        text: "This person is not visible to you.",
+      },
+      3000
+    );
+  }
+
+  notifyUnknownPerson() {
+    this.$notify(
+      {
+        group: "alert",
+        type: "warning",
+        title: "Unidentified Person",
+        text: "Nobody specific was recognized.",
+      },
+      3000
+    );
+  }
+
   @Emit()
   cacheImage(image: string) {
     return image;

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,9 +131,6 @@ 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) => {
@@ -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;
     }
   }