flatsql 0.4.2 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flatsql",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "SQL queries over raw FlatBuffer storage - zero conversion, real-time indexing, pure streaming",
   "type": "module",
   "main": "dist/index.js",
@@ -84,7 +84,7 @@
   "author": "Digital Arsenal <tj@digitalarsenal.io>",
   "license": "Apache-2.0",
   "dependencies": {
-    "flatc-wasm": "^26.1.31",
+    "flatc-wasm": "^26.1.32",
     "sql.js": "^1.10.0"
   },
   "devDependencies": {

package/wasm/index.d.ts

@@ -312,6 +312,16 @@ export interface InitOptions {
    */
   requireIntegrity?: boolean;
 
+  /**
+   * SHA-384 digest provider used for browser integrity verification.
+   * Browser WebCrypto is intentionally not used; browser callers that require
+   * integrity verification must pass a WASM/native-backed provider.
+   * The result may be a base64 digest string or raw digest bytes.
+   */
+  computeSHA384?: (
+    data: ArrayBuffer
+  ) => Promise<string | Uint8Array | ArrayBuffer> | string | Uint8Array | ArrayBuffer;
+
   /**
    * Custom Emscripten module factory function
    * Default: built-in FlatSQLModule

package/wasm/index.js

@@ -9,30 +9,60 @@ let api = null;
 // Security: Track if integrity was verified
 let integrityVerified = false;
 
+function toBase64(bytes) {
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(bytes).toString('base64');
+    }
+    let binary = '';
+    for (let offset = 0; offset < bytes.length; offset += 0x8000) {
+        binary += String.fromCharCode(...bytes.subarray(offset, offset + 0x8000));
+    }
+    return btoa(binary);
+}
+
+function normalizeHashResult(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value instanceof Uint8Array) {
+        return toBase64(value);
+    }
+    if (ArrayBuffer.isView(value)) {
+        return toBase64(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+    }
+    if (value instanceof ArrayBuffer) {
+        return toBase64(new Uint8Array(value));
+    }
+    throw new Error('SHA-384 provider must return a base64 string or binary digest');
+}
+
+function hasNodeProcess() {
+    return typeof process !== 'undefined' &&
+        process.versions !== undefined &&
+        typeof process.versions.node === 'string';
+}
+
 /**
- * Compute SHA-384 hash of data and return as base64
- * Works in both Node.js and browser environments
+ * Compute SHA-384 hash of data and return as base64.
+ * Browser WebCrypto is intentionally not used; browser callers that require
+ * integrity verification must pass computeSHA384 backed by WASM/native crypto.
  * @param {ArrayBuffer} data
+ * @param {(data: ArrayBuffer) => Promise<string|Uint8Array|ArrayBuffer>|string|Uint8Array|ArrayBuffer} [provider]
  * @returns {Promise<string>}
  */
-async function computeSHA384(data) {
-    if (typeof crypto !== 'undefined' && crypto.subtle) {
-        // Browser or Node.js 18+
-        const hashBuffer = await crypto.subtle.digest('SHA-384', data);
-        const hashArray = new Uint8Array(hashBuffer);
-        // Convert to base64
-        if (typeof btoa !== 'undefined') {
-            return btoa(String.fromCharCode(...hashArray));
-        } else {
-            return Buffer.from(hashArray).toString('base64');
-        }
-    } else {
-        // Node.js fallback using dynamic import
-        const cryptoModule = await import('crypto');
+async function computeSHA384(data, provider) {
+    if (typeof provider === 'function') {
+        return normalizeHashResult(await provider(data));
+    }
+    if (hasNodeProcess()) {
+        const cryptoModule = await import('node:crypto');
         const hash = cryptoModule.createHash('sha384');
         hash.update(Buffer.from(data));
         return hash.digest('base64');
     }
+    throw new Error(
+        'WASM integrity verification requires a computeSHA384 option backed by WASM/native crypto; browser WebCrypto is intentionally not used.'
+    );
 }
 
 /**
@@ -41,8 +71,8 @@ async function computeSHA384(data) {
  * @param {string} expectedHash - Expected SHA-384 hash (base64)
  * @returns {Promise<boolean>}
  */
-async function verifyWASMIntegrity(wasmBinary, expectedHash) {
-    const computedHash = await computeSHA384(wasmBinary);
+async function verifyWASMIntegrity(wasmBinary, expectedHash, options = {}) {
+    const computedHash = await computeSHA384(wasmBinary, options.computeSHA384);
     return computedHash === expectedHash;
 }
 
@@ -177,7 +207,7 @@ export async function initFlatSQL(moduleFactoryOrOptions) {
                 }
 
                 // Verify integrity
-                const isValid = await verifyWASMIntegrity(wasmBinary, expectedIntegrity);
+                const isValid = await verifyWASMIntegrity(wasmBinary, expectedIntegrity, options);
                 if (!isValid) {
                     throw new Error(
                         'WASM integrity check failed: hash mismatch. ' +