@tanstack/powersync-db-collection 0.1.67 → 0.2.1

package/dist/esm/helpers.d.ts

@@ -1,4 +1,4 @@
-import { DiffTriggerOperation, BaseColumnType, ExtractColumnValueType, Table } from '@powersync/common';
+import { DiffTriggerOperation, ExtractColumnValueType, Table } from '@powersync/common';
 /**
  * All PowerSync table records include a UUID `id` column.
  */
@@ -20,9 +20,9 @@ type OptionalIfUndefined<T> = {
 /**
  * Provides the base column types for a table. This excludes the `id` column.
  */
-export type ExtractedTableColumns<TTable extends Table> = {
-    [K in keyof TTable[`columnMap`]]: ExtractColumnValueType<TTable[`columnMap`][K]>;
-};
+export type ExtractedTableColumns<TTable extends Table> = TTable extends Table<infer Columns> ? {
+    [K in keyof Columns]: ExtractColumnValueType<Columns[K]>;
+} : never;
 /**
  * Utility type that extracts the typed structure of a table based on its column definitions.
  * Maps each column to its corresponding TypeScript type using ExtractColumnValueType.
@@ -42,7 +42,7 @@ export type ExtractedTable<TTable extends Table> = ExtractedTableColumns<TTable>
     id: string;
 };
 export type OptionalExtractedTable<TTable extends Table> = OptionalIfUndefined<{
-    [K in keyof TTable[`columnMap`]]: WithUndefinedIfNull<ExtractColumnValueType<TTable[`columnMap`][K]>>;
+    [K in keyof ExtractedTableColumns<TTable>]: WithUndefinedIfNull<ExtractedTableColumns<TTable>[K]>;
 }> & {
     id: string;
 };
@@ -51,14 +51,11 @@ export type OptionalExtractedTable<TTable extends Table> = OptionalIfUndefined<{
  * requires the keys be equal, but the values can have any value type.
  */
 export type AnyTableColumnType<TTable extends Table> = {
-    [K in keyof TTable[`columnMap`]]: any;
+    [K in keyof ExtractedTableColumns<TTable>]: unknown;
 } & {
     id: string;
 };
 export declare function asPowerSyncRecord(record: any): PowerSyncRecord;
-export type MapBaseColumnType<TOutput> = {
-    [Key in keyof TOutput]: BaseColumnType<any>;
-};
 /**
  * Maps {@link DiffTriggerOperation} to TanstackDB operations
  */

package/dist/esm/helpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.js","sources":["../../src/helpers.ts"],"sourcesContent":["import { DiffTriggerOperation } from '@powersync/common'\nimport type {\n  BaseColumnType,\n  ExtractColumnValueType,\n  Table,\n} from '@powersync/common'\n\n/**\n * All PowerSync table records include a UUID `id` column.\n */\nexport type PowerSyncRecord = {\n  id: string\n  [key: string]: unknown\n}\n\n/**\n * Utility type: If T includes null, also allow undefined (to support optional fields in insert/update operations).\n * PowerSync records are typically typed as `string | null`, where insert\n * and update operations may also allow not specifying a value at all (optional).\n */\ntype WithUndefinedIfNull<T> = null extends T ? T | undefined : T\ntype OptionalIfUndefined<T> = {\n  [K in keyof T as undefined extends T[K] ? K : never]?: T[K]\n} & {\n  [K in keyof T as undefined extends T[K] ? never : K]: T[K]\n}\n\n/**\n * Provides the base column types for a table. This excludes the `id` column.\n */\nexport type ExtractedTableColumns<TTable extends Table> = {\n  [K in keyof TTable[`columnMap`]]: ExtractColumnValueType<\n    TTable[`columnMap`][K]\n  >\n}\n/**\n * Utility type that extracts the typed structure of a table based on its column definitions.\n * Maps each column to its corresponding TypeScript type using ExtractColumnValueType.\n *\n * @template TTable - The PowerSync table definition\n * @example\n * ```typescript\n * const table = new Table({\n *   name: column.text,\n *   age: column.integer\n * })\n * type TableType = ExtractedTable<typeof table>\n * // Results in: { id: string, name: string | null, age: number | null }\n * ```\n */\nexport type ExtractedTable<TTable extends Table> =\n  ExtractedTableColumns<TTable> & {\n    id: string\n  }\n\nexport type OptionalExtractedTable<TTable extends Table> = OptionalIfUndefined<{\n  [K in keyof TTable[`columnMap`]]: WithUndefinedIfNull<\n    ExtractColumnValueType<TTable[`columnMap`][K]>\n  >\n}> & {\n  id: string\n}\n\n/**\n * Maps the schema of TTable to a type which\n * requires the keys be equal, but the values can have any value type.\n */\nexport type AnyTableColumnType<TTable extends Table> = {\n  [K in keyof TTable[`columnMap`]]: any\n} & { id: string }\n\nexport function asPowerSyncRecord(record: any): PowerSyncRecord {\n  if (typeof record.id !== `string`) {\n    throw new Error(`Record must have a string id field`)\n  }\n  return record as PowerSyncRecord\n}\n\n//  Helper type to ensure the keys of TOutput match the Table columns\nexport type MapBaseColumnType<TOutput> = {\n  [Key in keyof TOutput]: BaseColumnType<any>\n}\n\n/**\n * Maps {@link DiffTriggerOperation} to TanstackDB operations\n */\nexport function mapOperation(operation: DiffTriggerOperation) {\n  switch (operation) {\n    case DiffTriggerOperation.INSERT:\n      return `insert`\n    case DiffTriggerOperation.UPDATE:\n      return `update`\n    case DiffTriggerOperation.DELETE:\n      return `delete`\n  }\n}\n\n/**\n * Maps TanstackDB operations to  {@link DiffTriggerOperation}\n */\nexport function mapOperationToPowerSync(operation: string) {\n  switch (operation) {\n    case `insert`:\n      return DiffTriggerOperation.INSERT\n    case `update`:\n      return DiffTriggerOperation.UPDATE\n    case `delete`:\n      return DiffTriggerOperation.DELETE\n    default:\n      throw new Error(`Unknown operation ${operation} received`)\n  }\n}\n"],"names":[],"mappings":";AAuEO,SAAS,kBAAkB,QAA8B;AAC9D,MAAI,OAAO,OAAO,OAAO,UAAU;AACjC,UAAM,IAAI,MAAM,oCAAoC;AAAA,EACtD;AACA,SAAO;AACT;AAUO,SAAS,aAAa,WAAiC;AAC5D,UAAQ,WAAA;AAAA,IACN,KAAK,qBAAqB;AACxB,aAAO;AAAA,IACT,KAAK,qBAAqB;AACxB,aAAO;AAAA,IACT,KAAK,qBAAqB;AACxB,aAAO;AAAA,EAAA;AAEb;AAKO,SAAS,wBAAwB,WAAmB;AACzD,UAAQ,WAAA;AAAA,IACN,KAAK;AACH,aAAO,qBAAqB;AAAA,IAC9B,KAAK;AACH,aAAO,qBAAqB;AAAA,IAC9B,KAAK;AACH,aAAO,qBAAqB;AAAA,IAC9B;AACE,YAAM,IAAI,MAAM,qBAAqB,SAAS,WAAW;AAAA,EAAA;AAE/D;"}
+{"version":3,"file":"helpers.js","sources":["../../src/helpers.ts"],"sourcesContent":["import { DiffTriggerOperation } from '@powersync/common'\nimport type { ExtractColumnValueType, Table } from '@powersync/common'\n\n/**\n * All PowerSync table records include a UUID `id` column.\n */\nexport type PowerSyncRecord = {\n  id: string\n  [key: string]: unknown\n}\n\n/**\n * Utility type: If T includes null, also allow undefined (to support optional fields in insert/update operations).\n * PowerSync records are typically typed as `string | null`, where insert\n * and update operations may also allow not specifying a value at all (optional).\n */\ntype WithUndefinedIfNull<T> = null extends T ? T | undefined : T\ntype OptionalIfUndefined<T> = {\n  [K in keyof T as undefined extends T[K] ? K : never]?: T[K]\n} & {\n  [K in keyof T as undefined extends T[K] ? never : K]: T[K]\n}\n\n/**\n * Provides the base column types for a table. This excludes the `id` column.\n */\nexport type ExtractedTableColumns<TTable extends Table> =\n  TTable extends Table<infer Columns>\n    ? {\n        [K in keyof Columns]: ExtractColumnValueType<Columns[K]>\n      }\n    : never\n/**\n * Utility type that extracts the typed structure of a table based on its column definitions.\n * Maps each column to its corresponding TypeScript type using ExtractColumnValueType.\n *\n * @template TTable - The PowerSync table definition\n * @example\n * ```typescript\n * const table = new Table({\n *   name: column.text,\n *   age: column.integer\n * })\n * type TableType = ExtractedTable<typeof table>\n * // Results in: { id: string, name: string | null, age: number | null }\n * ```\n */\nexport type ExtractedTable<TTable extends Table> =\n  ExtractedTableColumns<TTable> & {\n    id: string\n  }\n\nexport type OptionalExtractedTable<TTable extends Table> = OptionalIfUndefined<{\n  [K in keyof ExtractedTableColumns<TTable>]: WithUndefinedIfNull<\n    ExtractedTableColumns<TTable>[K]\n  >\n}> & {\n  id: string\n}\n\n/**\n * Maps the schema of TTable to a type which\n * requires the keys be equal, but the values can have any value type.\n */\nexport type AnyTableColumnType<TTable extends Table> = {\n  [K in keyof ExtractedTableColumns<TTable>]: unknown\n} & { id: string }\n\nexport function asPowerSyncRecord(record: any): PowerSyncRecord {\n  if (typeof record.id !== `string`) {\n    throw new Error(`Record must have a string id field`)\n  }\n  return record as PowerSyncRecord\n}\n\n/**\n * Maps {@link DiffTriggerOperation} to TanstackDB operations\n */\nexport function mapOperation(operation: DiffTriggerOperation) {\n  switch (operation) {\n    case DiffTriggerOperation.INSERT:\n      return `insert`\n    case DiffTriggerOperation.UPDATE:\n      return `update`\n    case DiffTriggerOperation.DELETE:\n      return `delete`\n  }\n}\n\n/**\n * Maps TanstackDB operations to  {@link DiffTriggerOperation}\n */\nexport function mapOperationToPowerSync(operation: string) {\n  switch (operation) {\n    case `insert`:\n      return DiffTriggerOperation.INSERT\n    case `update`:\n      return DiffTriggerOperation.UPDATE\n    case `delete`:\n      return DiffTriggerOperation.DELETE\n    default:\n      throw new Error(`Unknown operation ${operation} received`)\n  }\n}\n"],"names":[],"mappings":";AAoEO,SAAS,kBAAkB,QAA8B;AAC9D,MAAI,OAAO,OAAO,OAAO,UAAU;AACjC,UAAM,IAAI,MAAM,oCAAoC;AAAA,EACtD;AACA,SAAO;AACT;AAKO,SAAS,aAAa,WAAiC;AAC5D,UAAQ,WAAA;AAAA,IACN,KAAK,qBAAqB;AACxB,aAAO;AAAA,IACT,KAAK,qBAAqB;AACxB,aAAO;AAAA,IACT,KAAK,qBAAqB;AACxB,aAAO;AAAA,EAAA;AAEb;AAKO,SAAS,wBAAwB,WAAmB;AACzD,UAAQ,WAAA;AAAA,IACN,KAAK;AACH,aAAO,qBAAqB;AAAA,IAC9B,KAAK;AACH,aAAO,qBAAqB;AAAA,IAC9B,KAAK;AACH,aAAO,qBAAqB;AAAA,IAC9B;AACE,YAAM,IAAI,MAAM,qBAAqB,SAAS,WAAW;AAAA,EAAA;AAE/D;"}

package/dist/esm/index.d.ts

@@ -2,3 +2,4 @@ export * from './definitions.js';
 export * from './powersync.js';
 export * from './PowerSyncTransactor.js';
 export * from './sqlite-compiler.js';
+export type { OptionalExtractedTable } from './helpers.js';

package/dist/esm/powersync.js

@@ -1,4 +1,4 @@
-import { DiffTriggerOperation, sanitizeSQL } from "@powersync/common";
+import { LogLevels, DiffTriggerOperation, sanitizeSQL } from "@powersync/common";
 import { withCollectionConfigFactory, or } from "@tanstack/db";
 import { compileSQLite } from "./sqlite-compiler.js";
 import { PendingOperationStore } from "./PendingOperationStore.js";
@@ -7,6 +7,9 @@ import { DEFAULT_BATCH_SIZE } from "./definitions.js";
 import { asPowerSyncRecord, mapOperation } from "./helpers.js";
 import { convertTableToSchema } from "./schema.js";
 import { serializeForSQLite } from "./serialization.js";
+function isPromiseLike(value) {
+  return !!value && (typeof value === `object` || typeof value === `function`) && typeof value.then === `function`;
+}
 function powerSyncCollectionOptions(config) {
   const outputConfig = createPowerSyncCollectionConfig(config);
   return withCollectionConfigFactory(
@@ -34,12 +37,15 @@ function createPowerSyncCollectionConfig(config) {
       return validation.value;
     } else if (`issues` in validation) {
       const issueMessage = `Failed to validate incoming data for ${viewName}. Issues: ${validation.issues.map((issue) => `${issue.path} - ${issue.message}`)}`;
-      database.logger.error(issueMessage);
+      database.logger.log({ level: LogLevels.error, message: issueMessage });
       onDeserializationError(validation);
       throw new Error(issueMessage);
     } else {
       const unknownErrorMessage = `Unknown deserialization error for ${viewName}`;
-      database.logger.error(unknownErrorMessage);
+      database.logger.log({
+        level: LogLevels.error,
+        message: unknownErrorMessage
+      });
       onDeserializationError({ issues: [{ message: unknownErrorMessage }] });
       throw new Error(unknownErrorMessage);
     }
@@ -58,6 +64,8 @@ function createPowerSyncCollectionConfig(config) {
       const abortController = new AbortController();
       let disposeTracking = null;
       let trackingSetup = null;
+      let activeTrackingDisposal = null;
+      let abortTrackingDisposal = null;
       if (syncMode === `eager`) {
         return runEagerSync();
       } else {
@@ -70,10 +78,29 @@ function createPowerSyncCollectionConfig(config) {
         }
         const dispose = disposeTracking;
         if (!dispose) {
+          await activeTrackingDisposal;
           return;
         }
         disposeTracking = null;
-        await dispose(context ? { context } : void 0);
+        let disposal;
+        try {
+          disposal = Promise.resolve(dispose(context ? { context } : void 0));
+        } catch (error) {
+          disposal = Promise.reject(error);
+        }
+        activeTrackingDisposal = disposal;
+        try {
+          await disposal;
+        } finally {
+          if (activeTrackingDisposal === disposal) {
+            activeTrackingDisposal = null;
+          }
+        }
+      }
+      function disposeTrackingAfterAbort() {
+        const disposal = abortTrackingDisposal ??= safelyDisposeTracking();
+        void disposal.catch(() => void 0);
+        return disposal;
       }
       async function establishTracking(options, appliedReceipts) {
         const setup = (async () => {
@@ -94,6 +121,7 @@ function createPowerSyncCollectionConfig(config) {
         return await database.triggers.createDiffTrigger({
           source: viewName,
           destination: trackedTableName,
+          columns: table.columns.map((column) => column.name),
           setupContext,
           when,
           hooks: {
@@ -117,9 +145,10 @@ function createPowerSyncCollectionConfig(config) {
                 }
                 appliedReceipts.push(commit());
               }
-              database.logger.info(
-                `Sync is ready for ${viewName} into ${trackedTableName}`
-              );
+              database.logger.log({
+                level: LogLevels.info,
+                message: `Sync is ready for ${viewName} into ${trackedTableName}`
+              });
             }
           }
         });
@@ -136,10 +165,11 @@ function createPowerSyncCollectionConfig(config) {
         await database.writeTransaction(async (context) => {
           await flushDiffRecordsWithContext(context, ignoredReceipts);
         }).catch((error) => {
-          database.logger.error(
-            `An error has been detected in the sync handler`,
+          database.logger.log({
+            level: LogLevels.error,
+            message: `An error has been detected in the sync handler`,
             error
-          );
+          });
         });
       }
       async function flushDiffRecordsWithContext(context, appliedReceipts) {
@@ -179,16 +209,18 @@ function createPowerSyncCollectionConfig(config) {
           appliedReceipts.push(applied);
           pendingOperationStore.resolvePendingFor(pendingOperations);
         } catch (error) {
-          database.logger.error(
-            `An error has been detected in the sync handler`,
+          database.logger.log({
+            level: LogLevels.error,
+            message: `An error has been detected in the sync handler`,
             error
-          );
+          });
         }
       }
       async function start(afterOnChangeRegistered) {
-        database.logger.info(
-          `Sync is starting for ${viewName} into ${trackedTableName}`
-        );
+        database.logger.log({
+          level: LogLevels.info,
+          message: `Sync is starting for ${viewName} into ${trackedTableName}`
+        });
         database.onChangeWithCallback(
           {
             onChange: async () => {
@@ -203,12 +235,12 @@ function createPowerSyncCollectionConfig(config) {
         );
         await afterOnChangeRegistered?.();
         if (abortController.signal.aborted) {
-          await safelyDisposeTracking();
+          await disposeTrackingAfterAbort();
         } else {
           abortController.signal.addEventListener(
             `abort`,
-            async () => {
-              await safelyDisposeTracking();
+            () => {
+              void disposeTrackingAfterAbort();
             },
             { once: true }
           );
@@ -216,13 +248,13 @@ function createPowerSyncCollectionConfig(config) {
       }
       function runEagerSync() {
         let onUnload = null;
-        start(async () => {
+        let onUnloadStarted = false;
+        const startup = start(async () => {
           const cleanup = await restConfig.onLoad?.();
+          onUnload = cleanup;
           if (abortController.signal.aborted) {
-            cleanup?.();
             return;
           }
-          onUnload = cleanup;
           const appliedReceipts = [];
           await establishTracking(
             {
@@ -245,38 +277,77 @@ function createPowerSyncCollectionConfig(config) {
           await Promise.all(appliedReceipts);
           markReady();
         }).catch((error) => {
-          database.logger.error(
-            `Could not start syncing process for ${viewName} into ${trackedTableName}`,
+          database.logger.log({
+            level: LogLevels.error,
+            message: `Could not start syncing process for ${viewName} into ${trackedTableName}`,
             error
-          );
+          });
           if (collection.status === `loading`) {
             markError(error);
           }
         });
-        return () => {
-          database.logger.info(
-            `Sync has been stopped for ${viewName} into ${trackedTableName}`
-          );
+        const invokeOnUnload = () => {
+          if (onUnloadStarted || !onUnload) return;
+          onUnloadStarted = true;
+          const cleanup = onUnload;
+          onUnload = null;
+          return cleanup();
+        };
+        return async () => {
+          database.logger.log({
+            level: LogLevels.info,
+            message: `Sync has been stopped for ${viewName} into ${trackedTableName}`
+          });
           abortController.abort();
-          onUnload?.();
+          const trackingDisposal = disposeTrackingAfterAbort();
+          let onUnloadFailure;
+          const settleOnUnload = async () => {
+            try {
+              await invokeOnUnload();
+            } catch (error) {
+              onUnloadFailure ??= { error };
+            }
+          };
+          const settlements = await Promise.allSettled([
+            startup,
+            trackingDisposal,
+            settleOnUnload()
+          ]);
+          const disposalSettlement = settlements[1];
+          await settleOnUnload();
+          if (disposalSettlement.status === `rejected` && onUnloadFailure) {
+            throw new AggregateError(
+              [disposalSettlement.reason, onUnloadFailure.error],
+              `PowerSync tracking disposal and load-hook cleanup both failed`,
+              { cause: disposalSettlement.reason }
+            );
+          }
+          if (disposalSettlement.status === `rejected`) {
+            throw disposalSettlement.reason;
+          }
+          if (onUnloadFailure) throw onUnloadFailure.error;
         };
       }
       function runOnDemandSync() {
         const demands = /* @__PURE__ */ new Map();
         const releasedSubsets = /* @__PURE__ */ new WeakSet();
         const pendingReleases = [];
+        const pendingDemandLoads = /* @__PURE__ */ new Set();
+        const pendingDemandCleanups = /* @__PURE__ */ new Set();
         let stopped = false;
         let trackingRevision = 0;
         let reconciledTrackingRevision = 0;
         let rebuildPromise = null;
         let drainingReleases = false;
         let releaseRetryTimer;
+        let demandCleanupCollector = null;
         const startup = start();
         void startup.catch(
-          (error) => database.logger.error(
-            `Could not start syncing process for ${viewName} into ${trackedTableName}`,
+          (error) => database.logger.log({
+            level: LogLevels.error,
+            message: `Could not start syncing process for ${viewName} into ${trackedTableName}`,
             error
-          )
+          })
         );
         const activeWhereExpressions = () => Array.from(demands.values()).filter((demand) => demand.active).map((demand) => demand.options.where);
         const reconcileTracking = async () => {
@@ -291,41 +362,52 @@ function createPowerSyncCollectionConfig(config) {
               await safelyDisposeTracking(ctx);
               if (!isCurrent()) return;
               const active = activeWhereExpressions();
-              if (active.length === 0) return;
-              const combinedWhere = active.length === 1 ? active[0] : or(active[0], active[1], ...active.slice(2));
-              const compiledNewData = compileSQLite(
-                { where: combinedWhere },
-                { jsonColumn: "NEW.data" }
-              );
-              const compiledOldData = compileSQLite(
-                { where: combinedWhere },
-                { jsonColumn: "OLD.data" }
-              );
-              const compiledView = compileSQLite({ where: combinedWhere });
-              const newDataWhenClause = toInlinedWhereClause(compiledNewData);
-              const oldDataWhenClause = toInlinedWhereClause(compiledOldData);
-              const viewWhereClause = toInlinedWhereClause(compiledView);
-              await establishTracking(
-                {
-                  setupContext: ctx,
-                  when: {
-                    [DiffTriggerOperation.INSERT]: newDataWhenClause,
-                    [DiffTriggerOperation.UPDATE]: `(${newDataWhenClause}) OR (${oldDataWhenClause})`,
-                    [DiffTriggerOperation.DELETE]: oldDataWhenClause
+              const missing = collection.status === `error` ? new Set(collection.keys()) : void 0;
+              if (active.length > 0) {
+                const combinedWhere = active.length === 1 ? active[0] : or(active[0], active[1], ...active.slice(2));
+                const compiledNewData = compileSQLite(
+                  { where: combinedWhere },
+                  { jsonColumn: "NEW.data" }
+                );
+                const compiledOldData = compileSQLite(
+                  { where: combinedWhere },
+                  { jsonColumn: "OLD.data" }
+                );
+                const compiledView = compileSQLite({ where: combinedWhere });
+                const newDataWhenClause = toInlinedWhereClause(compiledNewData);
+                const oldDataWhenClause = toInlinedWhereClause(compiledOldData);
+                const viewWhereClause = toInlinedWhereClause(compiledView);
+                await establishTracking(
+                  {
+                    setupContext: ctx,
+                    when: {
+                      [DiffTriggerOperation.INSERT]: newDataWhenClause,
+                      [DiffTriggerOperation.UPDATE]: `(${newDataWhenClause}) OR (${oldDataWhenClause})`,
+                      [DiffTriggerOperation.DELETE]: oldDataWhenClause
+                    },
+                    writeType: (rowId) => collection.has(rowId) ? `update` : `insert`,
+                    batchQuery: (lockContext, batchSize, cursor) => lockContext.getAll(
+                      `SELECT * FROM ${viewName} WHERE ${viewWhereClause} LIMIT ? OFFSET ?`,
+                      [batchSize, cursor]
+                    ).then((rows) => {
+                      for (const row of rows) missing?.delete(row.id);
+                      return rows;
+                    })
                   },
-                  writeType: (rowId) => collection.has(rowId) ? `update` : `insert`,
-                  batchQuery: (lockContext, batchSize, cursor) => lockContext.getAll(
-                    `SELECT * FROM ${viewName} WHERE ${viewWhereClause} LIMIT ? OFFSET ?`,
-                    [batchSize, cursor]
-                  )
-                },
-                appliedReceipts
-              );
+                  appliedReceipts
+                );
+              }
               if (!isCurrent()) await safelyDisposeTracking(ctx);
+              else if (missing?.size) {
+                begin();
+                for (const key of missing) write({ type: `delete`, key });
+                appliedReceipts.push(commit());
+              }
             });
             await Promise.all(appliedReceipts);
             if (isCurrent()) {
               reconciledTrackingRevision = revision;
+              if (collection.status === `error`) markReady();
             }
           }
         };
@@ -356,6 +438,13 @@ function createPowerSyncCollectionConfig(config) {
             if (cleanup) demand.cleanup = cleanup;
           } catch (error) {
             demands.delete(options);
+            const collector = demandCleanupCollector;
+            if (collector) {
+              collector.failures.push({
+                order: collector.nextOrder++,
+                error
+              });
+            }
             throw error;
           }
           if (
@@ -363,14 +452,20 @@ function createPowerSyncCollectionConfig(config) {
             // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             stopped || releasedSubsets.has(options) || options.signal?.aborted || demands.get(options) !== demand
           ) {
-            demands.delete(options);
-            demand.cleanup?.();
+            cleanupDemand(demand);
             return;
           }
           demand.active = true;
           trackingRevision++;
           await rebuildTracking();
         };
+        const trackLoadSubset = (options) => {
+          const task = loadSubset(options);
+          pendingDemandLoads.add(task);
+          const finish = () => pendingDemandLoads.delete(task);
+          void task.then(finish, finish);
+          return task;
+        };
         const toInlinedWhereClause = (compiled) => {
           if (!compiled.where) return "TRUE";
           const sqlParts = compiled.where.split("?");
@@ -379,15 +474,55 @@ function createPowerSyncCollectionConfig(config) {
             ...compiled.params
           );
         };
+        const reportDemandCleanupFailure = (error) => {
+          database.logger.log({
+            level: LogLevels.error,
+            message: `Could not clean up subset hook for ${viewName}`,
+            error
+          });
+        };
         const cleanupDemand = (demand) => {
           demands.delete(demand.options);
+          const collector = demandCleanupCollector;
+          const order = collector ? collector.nextOrder++ : void 0;
           try {
-            demand.cleanup?.();
+            const cleanup = demand.cleanup;
+            demand.cleanup = void 0;
+            const result = cleanup?.();
+            if (!isPromiseLike(result)) return;
+            const task = Promise.resolve(result);
+            pendingDemandCleanups.add(task);
+            const finish = () => pendingDemandCleanups.delete(task);
+            void task.then(finish, finish);
+            if (collector) {
+              collector.tasks.push({ order, promise: task });
+              collector.ownedTasks.add(task);
+              void task.catch(() => void 0);
+            } else {
+              void task.catch((error) => {
+                if (!demandCleanupCollector?.ownedTasks.has(task)) {
+                  reportDemandCleanupFailure(error);
+                }
+              });
+            }
           } catch (error) {
-            database.logger.error(
-              `Could not clean up subset hook for ${viewName}`,
-              error
-            );
+            if (collector) {
+              collector.failures.push({ order, error });
+            } else {
+              reportDemandCleanupFailure(error);
+            }
+          }
+        };
+        const throwDemandCleanupFailures = (collector, primaryFailures = []) => {
+          const errors = [
+            ...primaryFailures,
+            ...collector.failures.slice().sort((left, right) => left.order - right.order).map(({ error }) => error)
+          ];
+          if (errors.length === 1) throw errors[0];
+          if (errors.length > 1) {
+            throw new AggregateError(errors, `PowerSync cleanup failed`, {
+              cause: errors[0]
+            });
           }
         };
         const performPhysicalRelease = async (options) => {
@@ -451,10 +586,11 @@ function createPowerSyncCollectionConfig(config) {
                   3e4
                 );
                 retryDelay = retryDelay === 0 ? delay : Math.min(retryDelay, delay);
-                database.logger.error(
-                  `Could not release subset tracking for ${viewName}; retrying`,
+                database.logger.log({
+                  level: LogLevels.error,
+                  message: `Could not release subset tracking for ${viewName}; retrying`,
                   error
-                );
+                });
               }
             }
           } finally {
@@ -482,16 +618,58 @@ function createPowerSyncCollectionConfig(config) {
             stopped = true;
             clearTimeout(releaseRetryTimer);
             releaseRetryTimer = void 0;
-            database.logger.info(
-              `Sync has been stopped for ${viewName} into ${trackedTableName}`
-            );
+            database.logger.log({
+              level: LogLevels.info,
+              message: `Sync has been stopped for ${viewName} into ${trackedTableName}`
+            });
             abortController.abort();
+            const trackingDisposal = disposeTrackingAfterAbort();
+            const pendingLoads = [...pendingDemandLoads];
+            const pendingTasks = [...pendingDemandCleanups];
+            const collector = {
+              tasks: pendingTasks.map((promise, order) => ({ order, promise })),
+              ownedTasks: new Set(pendingTasks),
+              failures: [],
+              nextOrder: pendingTasks.length
+            };
+            demandCleanupCollector = collector;
             for (const demand of demands.values()) {
               cleanupDemand(demand);
             }
             pendingReleases.length = 0;
+            return (async () => {
+              const ownershipSettlements = await Promise.allSettled([
+                trackingDisposal,
+                ...pendingLoads
+              ]);
+              const disposalSettlement = ownershipSettlements[0];
+              let settledTasks = 0;
+              while (settledTasks < collector.tasks.length) {
+                const tasks = collector.tasks.slice(settledTasks);
+                settledTasks = collector.tasks.length;
+                const outcomes = await Promise.allSettled(
+                  tasks.map(({ promise }) => promise)
+                );
+                for (const [index, outcome] of outcomes.entries()) {
+                  if (outcome.status === `rejected`) {
+                    collector.failures.push({
+                      order: tasks[index].order,
+                      error: outcome.reason
+                    });
+                  }
+                }
+              }
+              throwDemandCleanupFailures(
+                collector,
+                disposalSettlement.status === `rejected` ? [disposalSettlement.reason] : []
+              );
+            })().finally(() => {
+              if (demandCleanupCollector === collector) {
+                demandCleanupCollector = null;
+              }
+            });
           },
-          loadSubset: (options) => loadSubset(options),
+          loadSubset: trackLoadSubset,
           unloadSubset
         };
       }
@@ -522,13 +700,7 @@ function createPowerSyncCollectionConfig(config) {
         tableName: viewName,
         trackedTableName,
         metadataIsTracked,
-        serializeValue: (value) => serializeForSQLite(
-          value,
-          // This is required by the input generic
-          table,
-          // Coerce serializer to the shape that corresponds to the Table constructed from OutputType
-          serializer
-        )
+        serializeValue: (value) => serializeForSQLite(value, table, serializer)
       })
     }
   };