[Update] powersync sqlite core

.changeset/gorgeous-starfishes-sparkle.md

@@ -0,0 +1,5 @@
+---
+"@journeyapps/wa-sqlite": patch
+---
+
+Updated from upstream changes

.changeset/rare-panthers-study.md

@@ -0,0 +1,5 @@
+---
+"@journeyapps/wa-sqlite": patch
+---
+
+Updated powersync-sqlite-core to v0.1.6

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,10 @@
+---
+name: Bug report
+about: Report potential problems in project code
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+In this project, Issues are only for possible bugs in project code. Please don't ask for help debugging _your_ code; I have plenty of challenges debugging _my_ code. 🥲

.github/workflows/dev-packages.yml

@@ -2,7 +2,7 @@
 # Packages are versioned as `0.0.0-{tag}-DATETIMESTAMP`
 name: Packages Deploy
 
-on: push
+on: workflow_dispatch
 
 jobs:
   publish:
@@ -14,7 +14,7 @@ jobs:
       - name: Setup NodeJS
         uses: actions/setup-node@v2
         with:
-          node-version: 18
+          node-version: 16
 
       - name: Setup Yarn
         run: |

.github/workflows/release.yml

@@ -15,10 +15,10 @@ jobs:
       - name: Checkout Repo
         uses: actions/checkout@v3
 
-      - name: Setup Node.js 18
+      - name: Setup Node.js 16
         uses: actions/setup-node@v3
         with:
-          node-version: 18
+          node-version: 16
 
       - name: Install Dependencies
         run: yarn

Makefile

@@ -56,7 +56,7 @@ EMFLAGS_COMMON = \
 
 EMFLAGS_DEBUG = \
 	-s ASSERTIONS=1 \
-	-g \
+	-g -Oz \
 	$(EMFLAGS_COMMON)
 
 EMFLAGS_DIST = \

src/examples/IDBBatchAtomicVFS.js

@@ -58,6 +58,12 @@ export class IDBBatchAtomicVFS extends VFS.Base {
   #taskTimestamp = performance.now();
   #pendingAsync = new Set();
 
+  // Asyncify can grow WebAssembly memory during an asynchronous call.
+  // If this happens, then any array buffer arguments will be detached.
+  // The workaround is when finding a detached buffer, set this handler
+  // function to process the new buffer outside handlerAsync().
+  #growthHandler = null;
+
   constructor(idbDatabaseName = 'wa-sqlite', options = DEFAULT_OPTIONS) {
     super();
     this.name = idbDatabaseName;
@@ -84,7 +90,7 @@ export class IDBBatchAtomicVFS extends VFS.Base {
    * @returns {number}
    */
   xOpen(name, fileId, flags, pOutFlags) {
-    return this.handleAsync(async () => {
+    const result = this.handleAsync(async () => {
       if (name === null) name = `null_${fileId}`;
       log(`xOpen ${name} 0x${fileId.toString(16)} 0x${flags.toString(16)}`);
 
@@ -118,13 +124,25 @@ export class IDBBatchAtomicVFS extends VFS.Base {
             }
           }
         });
+
+        // @ts-ignore
+        if (pOutFlags.buffer.detached || !pOutFlags.buffer.byteLength) {
+          pOutFlags = new DataView(new ArrayBuffer(4));
+          this.#growthHandler = (pOutFlagsNew) => {
+            pOutFlagsNew.setInt32(0, pOutFlags.getInt32(0, true), true);
+          };
+        }
         pOutFlags.setInt32(0, flags & VFS.SQLITE_OPEN_READONLY, true);
         return VFS.SQLITE_OK;
       } catch (e) {
         console.error(e);
         return VFS.SQLITE_CANTOPEN;
       }
     });
+
+    this.#growthHandler?.(pOutFlags);
+    this.#growthHandler = null;
+    return result;
   }
 
   /**
@@ -160,7 +178,8 @@ export class IDBBatchAtomicVFS extends VFS.Base {
    * @returns {number}
    */
   xRead(fileId, pData, iOffset) {
-    return this.handleAsync(async () => {
+    const byteLength = pData.byteLength;
+    const result = this.handleAsync(async () => {
       const file = this.#mapIdToFile.get(fileId);
       log(`xRead ${file.path} ${pData.byteLength} ${iOffset}`);
 
@@ -170,6 +189,15 @@ export class IDBBatchAtomicVFS extends VFS.Base {
         // one case - rollback after journal spill - where reads cross
         // write boundaries so we have to allow for that.
         const result = await this.#idb.run('readonly', async ({blocks}) => {
+          // @ts-ignore
+          if (pData.buffer.detached || !pData.buffer.byteLength) {
+            // WebAssembly memory has grown, invalidating our buffer. Use
+            // a temporary buffer and copy after this asynchronous call
+            // completes.
+            pData = new Uint8Array(byteLength);
+            this.#growthHandler = (pDataNew) => pDataNew.set(pData);
+          }
+
           let pDataOffset = 0;
           while (pDataOffset < pData.byteLength) {
             // Fetch the IndexedDB block for this file location.
@@ -200,6 +228,10 @@ export class IDBBatchAtomicVFS extends VFS.Base {
         return VFS.SQLITE_IOERR;
       }
     });
+
+    this.#growthHandler?.(pData);
+    this.#growthHandler = null;
+    return result;
   }
 
   /**
@@ -221,7 +253,7 @@ export class IDBBatchAtomicVFS extends VFS.Base {
         }
         await new Promise(resolve => setTimeout(resolve));
 
-        const result = this.#xWriteHelper(fileId, pData, iOffset);
+        const result = this.#xWriteHelper(fileId, pData.slice(), iOffset);
         this.#taskTimestamp = performance.now();
         return result;
       });
@@ -436,14 +468,28 @@ export class IDBBatchAtomicVFS extends VFS.Base {
    * @returns {number}
    */
   xCheckReservedLock(fileId, pResOut) {
-    return this.handleAsync(async () => {
+    const result = this.handleAsync(async () => {
       const file = this.#mapIdToFile.get(fileId);
       log(`xCheckReservedLock ${file.path}`);
 
       const isReserved = await file.locks.isSomewhereReserved();
+      function setOutput(pResOut) {
+      };
+
+      // @ts-ignore
+      if (pResOut.buffer.detached || !pResOut.buffer.byteLength) {
+        pResOut = new DataView(new ArrayBuffer(4));
+        this.#growthHandler = (pResOutNew) => {
+          pResOutNew.setInt32(0, pResOut.getInt32(0, true), true);
+        };
+      }
       pResOut.setInt32(0, isReserved ? 1 : 0, true);
       return VFS.SQLITE_OK;
     });
+
+    this.#growthHandler?.(pResOut);
+    this.#growthHandler = null;
+    return result;
   }
 
   /**
@@ -611,7 +657,7 @@ export class IDBBatchAtomicVFS extends VFS.Base {
    * @returns {number}
    */
   xAccess(name, flags, pResOut) {
-    return this.handleAsync(async () => {
+    const result = this.handleAsync(async () => {
       try {
         const path = new URL(name, 'file://localhost/').pathname;
         log(`xAccess ${path} ${flags}`);
@@ -620,13 +666,25 @@ export class IDBBatchAtomicVFS extends VFS.Base {
         const key = await this.#idb.run('readonly', ({blocks}) => {
           return blocks.getKey(this.#bound({path}, 0));
         });
+
+        // @ts-ignore
+        if (pResOut.buffer.detached || !pResOut.buffer.byteLength) {
+          pResOut = new DataView(new ArrayBuffer(4));
+          this.#growthHandler = (pResOutNew) => {
+            pResOutNew.setInt32(0, pResOut.getInt32(0, true), true);
+          }
+        }
         pResOut.setInt32(0, key ? 1 : 0, true);
         return VFS.SQLITE_OK;
       } catch (e) {
         console.error(e);
         return VFS.SQLITE_IOERR;
       }
     });
+
+    this.#growthHandler?.(pResOut);
+    this.#growthHandler = null;
+    return result;
   }
 
   /**