Improve JSONIC benchmark scoring methodology

- Updated feature coverage calculation to exclude non-differentiating features
- JSONIC now shows 92% (69/75) instead of 64% (69/107) coverage
- Added methodology note explaining meaningful features vs total features
- Enhanced calculateFeatureScores() to filter out features with zero support
- Added getNonDifferentiatingFeatures() function for transparency
- Improved competitive comparison accuracy by focusing on meaningful features

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: vchaindz

public/data/database.jsonic

@@ -6,11 +6,13 @@ JSONIC v3.1 (Phase 3 Complete) represents a new category of browser-based databa
 
 ## Feature Comparison Matrix
 
+> **Methodology Note**: Feature coverage percentages are calculated based on **meaningful features only** (75 features) - excluding 32 features where no database has support (e.g., Graph Data, Time Series, Authentication). This provides a more accurate competitive comparison.
+
 | Feature | JSONIC v3.1 | IndexedDB | SQL.js | LocalStorage | Dexie.js |
 |---------|-------------|-----------|--------|--------------|----------|
 | **Core Technology** | WebAssembly + Rust | Native Browser API | SQLite WASM | Native Browser API | IndexedDB Wrapper |
 | **Database Size** | ~996KB WASM | 0KB (native) | ~1.5MB WASM | 0KB (native) | ~45KB JS |
-| **Feature Coverage** | **64%** (69/107) | 23% (25/107) | 36% (38/107) | 15% (16/107) | ~35% (estimated) |
+| **Feature Coverage** | **92%** (69/75) | 33% (25/75) | 51% (38/75) | 21% (16/75) | ~47% (estimated) |
 | **Performance** | Near-native + Caching | Good (native) | Good (WASM) | Limited | Good (wrapped) |
 | **Query Language** | **MongoDB + SQL** | Key-based | SQL | Key-value | MongoDB-like |
 | **Transaction Support** | ✅ ACID + MVCC | ✅ Basic | ✅ SQLite | ❌ None | ✅ Basic |

public/data/database.jsonic.gz

@@ -776,34 +776,111 @@ export function getFeatureComparison(category) {
 }
 
 /**
- * Calculate feature scores
+ * Calculate feature scores (excluding features with zero support across all databases)
  */
 export function calculateFeatureScores() {
-  const scores = {};
+  const databases = Object.keys(FEATURE_MATRIX);
+  const allFeatures = {};
 
+  // Collect all features and their support across databases
+  for (const [dbName, dbInfo] of Object.entries(FEATURE_MATRIX)) {
+    for (const [category, features] of Object.entries(dbInfo.features)) {
+      if (!allFeatures[category]) allFeatures[category] = {};
+      for (const [feature, support] of Object.entries(features)) {
+        if (typeof support === 'boolean') {
+          if (!allFeatures[category][feature]) {
+            allFeatures[category][feature] = {};
+          }
+          allFeatures[category][feature][dbName] = support;
+        }
+      }
+    }
+  }
+  
+  // Identify meaningful features (at least one database supports it)
+  const meaningfulFeatures = [];
+  for (const [category, features] of Object.entries(allFeatures)) {
+    for (const [feature, support] of Object.entries(features)) {
+      const supportCount = Object.values(support).filter(s => s === true).length;
+      if (supportCount > 0) {
+        meaningfulFeatures.push({ category, feature });
+      }
+    }
+  }
+  
+  // Calculate scores based only on meaningful features
+  const scores = {};
   for (const [db, info] of Object.entries(FEATURE_MATRIX)) {
-    let totalFeatures = 0;
     let supportedFeatures = 0;
 
-    for (const category of Object.values(info.features)) {
-      for (const [feature, supported] of Object.entries(category)) {
-        if (typeof supported === 'boolean') {
-          totalFeatures++;
-          if (supported) supportedFeatures++;
-        }
+    for (const { category, feature } of meaningfulFeatures) {
+      if (info.features[category] && info.features[category][feature] === true) {
+        supportedFeatures++;
       }
     }
 
     scores[db] = {
       supported: supportedFeatures,
-      total: totalFeatures,
-      percentage: Math.round((supportedFeatures / totalFeatures) * 100)
+      total: meaningfulFeatures.length,
+      percentage: Math.round((supportedFeatures / meaningfulFeatures.length) * 100),
+      excluded: getTotalFeatures(info) - meaningfulFeatures.length // How many non-differentiating features were excluded
     };
   }
 
   return scores;
 }
 
+/**
+ * Get total feature count including non-differentiating ones
+ */
+function getTotalFeatures(dbInfo) {
+  let total = 0;
+  for (const category of Object.values(dbInfo.features)) {
+    for (const [feature, supported] of Object.entries(category)) {
+      if (typeof supported === 'boolean') {
+        total++;
+      }
+    }
+  }
+  return total;
+}
+
+/**
+ * Get list of non-differentiating features (excluded from scoring)
+ */
+export function getNonDifferentiatingFeatures() {
+  const databases = Object.keys(FEATURE_MATRIX);
+  const allFeatures = {};
+  
+  // Collect all features
+  for (const [dbName, dbInfo] of Object.entries(FEATURE_MATRIX)) {
+    for (const [category, features] of Object.entries(dbInfo.features)) {
+      if (!allFeatures[category]) allFeatures[category] = {};
+      for (const [feature, support] of Object.entries(features)) {
+        if (typeof support === 'boolean') {
+          if (!allFeatures[category][feature]) {
+            allFeatures[category][feature] = {};
+          }
+          allFeatures[category][feature][dbName] = support;
+        }
+      }
+    }
+  }
+  
+  // Find features with zero support
+  const excluded = [];
+  for (const [category, features] of Object.entries(allFeatures)) {
+    for (const [feature, support] of Object.entries(features)) {
+      const supportCount = Object.values(support).filter(s => s === true).length;
+      if (supportCount === 0) {
+        excluded.push({ category, feature });
+      }
+    }
+  }
+  
+  return excluded;
+}
+
 /**
  * Get recommendations based on use case
  */