@rocicorp/zero 0.26.0-canary.2 → 0.26.0-canary.3

package/out/zero-cache/src/services/view-syncer/view-syncer.js

@@ -59,6 +59,7 @@ class ViewSyncerService {
   #slowHydrateThreshold;
   #queryConfig;
   userQueryURL;
+  userQueryHeaders;
   // The ViewSyncerService is only started in response to a connection,
   // so #lastConnectTime is always initialized to now(). This is necessary
   // to handle race conditions in which, e.g. the replica is ready and the
@@ -103,6 +104,7 @@ class ViewSyncerService {
   // auth and cookie headers directly
   #authData;
   #httpCookie;
+  #origin;
   #expiredQueriesTimer = 0;
   #setTimeout;
   #customQueryTransformer;
@@ -156,7 +158,7 @@ class ViewSyncerService {
   #inspectorDelegate;
   #config;
   #runPriorityOp;
-  constructor(config, lc, shard, taskID, clientGroupID, cvrDb, upstreamDb, pipelineDriver, versionChanges, drainCoordinator, slowHydrateThreshold, inspectorDelegate, customQueryTransformer, runPriorityOp, keepaliveMs = DEFAULT_KEEPALIVE_MS, setTimeoutFn = setTimeout.bind(globalThis)) {
+  constructor(config, lc, shard, taskID, clientGroupID, cvrDb, pipelineDriver, versionChanges, drainCoordinator, slowHydrateThreshold, inspectorDelegate, customQueryTransformer, runPriorityOp, keepaliveMs = DEFAULT_KEEPALIVE_MS, setTimeoutFn = setTimeout.bind(globalThis)) {
     const queryConfig = config.query?.url ? config.query : config.getQueries;
     this.#config = config;
     this.id = clientGroupID;
@@ -173,7 +175,6 @@ class ViewSyncerService {
     this.#cvrStore = new CVRStore(
       lc,
       cvrDb,
-      upstreamDb,
       shard,
       taskID,
       clientGroupID,
@@ -188,8 +189,11 @@ class ViewSyncerService {
   #getHeaderOptions(forwardCookie) {
     return {
       apiKey: this.#queryConfig.apiKey,
+      customHeaders: this.userQueryHeaders,
+      allowedClientHeaders: this.#queryConfig.allowedClientHeaders,
       token: this.#authData?.raw,
-      cookie: forwardCookie ? this.#httpCookie : void 0
+      cookie: forwardCookie ? this.#httpCookie : void 0,
+      origin: this.#origin
     };
   }
   #runInLockWithCVR(fn) {
@@ -213,8 +217,10 @@ class ViewSyncerService {
         return;
       }
       if (!this.#cvr) {
-        this.#lc.debug?.("loading CVR");
+        this.#lc.debug?.("loading cvr");
         this.#cvr = await this.#runPriorityOp(
+          lc,
+          "loading cvr",
           () => this.#cvrStore.load(lc, this.#lastConnectTime)
         );
         this.#ttlClock = this.#cvr.ttlClock;
@@ -272,6 +278,7 @@ class ViewSyncerService {
             }
             lc.info?.(`resetting pipelines: ${result.message}`);
             this.#pipelines.reset(clientSchema);
+            this.#pipelinesSynced = false;
           }
           const version2 = this.#pipelines.advanceWithoutDiff();
           const cvrVer = versionString(cvr.version);
@@ -281,7 +288,7 @@ class ViewSyncerService {
           }
           lc.info?.(`init pipelines@${version2} (cvr@${cvrVer})`);
           await this.#hydrateUnchangedQueries(lc, cvr);
-          await this.#syncQueryPipelineSet(lc, cvr);
+          await this.#syncQueryPipelineSet(lc, cvr, "missing");
           this.#pipelinesSynced = true;
         });
       }
@@ -306,8 +313,9 @@ class ViewSyncerService {
     if (hasExpiredQueries(cvr)) {
       lc = lc.withContext("method", "#removeExpiredQueries");
       lc.debug?.("Queries have expired");
-      await this.#syncQueryPipelineSet(lc, cvr);
-      this.#pipelinesSynced = true;
+      if (this.#pipelinesSynced) {
+        await this.#syncQueryPipelineSet(lc, cvr, "missing");
+      }
     }
     this.#scheduleExpireEviction(lc, cvr);
   };
@@ -385,16 +393,17 @@ class ViewSyncerService {
         baseCookie,
         tokenData,
         httpCookie,
+        origin,
         protocolVersion
       } = ctx;
       this.#authData = pickToken(this.#lc, this.#authData, tokenData);
-      this.#lc.debug?.(
-        `Picked auth token: ${JSON.stringify(this.#authData?.decoded)}`
-      );
+      this.#lc.debug?.(`Picked auth token for clientGroupID`);
       this.#httpCookie = httpCookie;
-      const [, { userQueryURL }] = initConnectionMessage;
+      this.#origin = origin;
+      const [, { userQueryURL, userQueryHeaders }] = initConnectionMessage;
       if (this.userQueryURL === void 0) {
         this.userQueryURL = userQueryURL;
+        this.userQueryHeaders = userQueryHeaders;
       } else {
         if (this.userQueryURL !== userQueryURL) {
           this.#lc.warn?.(
@@ -451,6 +460,8 @@ class ViewSyncerService {
             clientID2,
             msg,
             cvr,
+            "all",
+            // re transform all on new connections
             // Until the profileID is required in the URL, default it to
             // `cg${clientGroupID}`, as is done in the schema migration.
             // As clients update to the zero version with the profileID logic,
@@ -465,13 +476,17 @@ class ViewSyncerService {
     });
   }
   async changeDesiredQueries(ctx, msg) {
-    await this.#runInLockForClient(ctx, msg, this.#handleConfigUpdate);
+    await this.#runInLockForClient(
+      ctx,
+      msg,
+      (lc, clientID, msg2, cvr) => this.#handleConfigUpdate(lc, clientID, msg2, cvr, "missing")
+    );
   }
   async deleteClients(ctx, msg) {
-    await this.#runInLockForClient(
+    return await this.#runInLockForClient(
       ctx,
       [msg[0], { deleted: msg[1] }],
-      this.#handleConfigUpdate
+      (lc, clientID, msg2, cvr) => this.#handleConfigUpdate(lc, clientID, msg2, cvr, "missing")
     );
   }
   #getTTLClock(now) {
@@ -489,7 +504,7 @@ class ViewSyncerService {
     return ttlClock;
   }
   #flushUpdater(lc, updater) {
-    return this.#runPriorityOp(async () => {
+    return this.#runPriorityOp(lc, "flushing cvr", async () => {
       const now = Date.now();
       const ttlClock = this.#getTTLClock(now);
       const { cvr, flushed } = await updater.flush(
@@ -516,14 +531,22 @@ class ViewSyncerService {
     this.#ttlClockInterval = 0;
   }
   #updateTTLClockInCVRWithoutLock(lc) {
-    lc.debug?.("Syncing ttlClock");
-    const now = Date.now();
-    const ttlClock = this.#getTTLClock(now);
-    this.#cvrStore.updateTTLClock(ttlClock, now).catch((e) => {
-      lc.error?.("failed to update TTL clock", e);
+    const rid = randomID();
+    lc.debug?.("Syncing ttlClock", rid);
+    const start = Date.now();
+    const ttlClock = this.#getTTLClock(start);
+    this.#cvrStore.updateTTLClock(ttlClock, start).then(() => {
+      lc.debug?.("Synced ttlClock", rid, `in ${Date.now() - start} ms`);
+    }).catch((e) => {
+      lc.error?.(
+        "failed to update TTL clock",
+        rid,
+        `after ${Date.now() - start} ms`,
+        e
+      );
     });
   }
-  async #updateCVRConfig(lc, cvr, clientID, fn) {
+  async #updateCVRConfig(lc, cvr, clientID, customQueryTransformMode, fn) {
     const updater = new CVRConfigDrivenUpdater(
       this.#cvrStore,
       cvr,
@@ -541,7 +564,7 @@ class ViewSyncerService {
       await pokers.end(newCVR.version);
     }
     if (this.#pipelinesSynced) {
-      await this.#syncQueryPipelineSet(lc, this.#cvr);
+      await this.#syncQueryPipelineSet(lc, this.#cvr, customQueryTransformMode);
     }
     return this.#cvr;
   }
@@ -561,8 +584,9 @@ class ViewSyncerService {
       `vs.#runInLockForClient(${cmd})`,
       async () => {
         let client;
+        let result;
         try {
-          await this.#runInLockWithCVR((lc, cvr) => {
+          await this.#runInLockWithCVR(async (lc, cvr) => {
             lc = lc.withContext("clientID", clientID).withContext("wsID", wsID).withContext("cmd", cmd);
             lc.debug?.("acquired lock for cvr");
             client = this.#clients.get(clientID);
@@ -580,7 +604,7 @@ class ViewSyncerService {
               lc.warn?.(`Processing ${cmd} before initConnection was received`);
             }
             lc.debug?.(cmd, body);
-            return fn(lc, clientID, body, cvr);
+            result = await fn(lc, clientID, body, cvr);
           });
         } catch (e) {
           const lc = this.#lc.withContext("clientID", clientID).withContext("wsID", wsID).withContext("cmd", cmd);
@@ -591,6 +615,7 @@ class ViewSyncerService {
             throw e;
           }
         }
+        return result;
       }
     );
   }
@@ -606,68 +631,74 @@ class ViewSyncerService {
     deleted,
     desiredQueriesPatch,
     activeClients
-  }, cvr, profileID) => startAsyncSpan(tracer, "vs.#patchQueries", async () => {
+  }, cvr, customQueryTransformMode, profileID) => startAsyncSpan(tracer, "vs.#patchQueries", async () => {
     const deletedClientIDs = [];
     const deletedClientGroupIDs = [];
-    cvr = await this.#updateCVRConfig(lc, cvr, clientID, (updater) => {
-      const { ttlClock } = cvr;
-      const patches = [];
-      if (clientSchema) {
-        updater.setClientSchema(lc, clientSchema);
-      }
-      if (profileID) {
-        updater.setProfileID(lc, profileID);
-      }
-      lc.debug?.(`applying ${desiredQueriesPatch?.length} query patches`);
-      if (desiredQueriesPatch?.length) {
-        for (const patch of desiredQueriesPatch) {
-          switch (patch.op) {
-            case "put":
-              patches.push(...updater.putDesiredQueries(clientID, [patch]));
-              break;
-            case "del":
-              patches.push(
-                ...updater.markDesiredQueriesAsInactive(
-                  clientID,
-                  [patch.hash],
-                  ttlClock
-                )
-              );
-              break;
-            case "clear":
-              patches.push(...updater.clearDesiredQueries(clientID));
-              break;
+    cvr = await this.#updateCVRConfig(
+      lc,
+      cvr,
+      clientID,
+      customQueryTransformMode,
+      (updater) => {
+        const { ttlClock } = cvr;
+        const patches = [];
+        if (clientSchema) {
+          updater.setClientSchema(lc, clientSchema);
+        }
+        if (profileID) {
+          updater.setProfileID(lc, profileID);
+        }
+        lc.debug?.(`applying ${desiredQueriesPatch?.length} query patches`);
+        if (desiredQueriesPatch?.length) {
+          for (const patch of desiredQueriesPatch) {
+            switch (patch.op) {
+              case "put":
+                patches.push(...updater.putDesiredQueries(clientID, [patch]));
+                break;
+              case "del":
+                patches.push(
+                  ...updater.markDesiredQueriesAsInactive(
+                    clientID,
+                    [patch.hash],
+                    ttlClock
+                  )
+                );
+                break;
+              case "clear":
+                patches.push(...updater.clearDesiredQueries(clientID));
+                break;
+            }
           }
         }
-      }
-      const clientIDsToDelete = /* @__PURE__ */ new Set();
-      if (activeClients) {
-        const allClientIDs = Object.keys(cvr.clients);
-        const activeClientsSet = new Set(activeClients);
-        for (const id of allClientIDs) {
-          if (!activeClientsSet.has(id)) {
-            clientIDsToDelete.add(id);
+        const clientIDsToDelete = /* @__PURE__ */ new Set();
+        if (activeClients) {
+          const allClientIDs = Object.keys(cvr.clients);
+          const activeClientsSet = new Set(activeClients);
+          for (const id of allClientIDs) {
+            if (!activeClientsSet.has(id)) {
+              clientIDsToDelete.add(id);
+            }
           }
         }
-      }
-      if (deleted?.clientIDs?.length) {
-        for (const cid of deleted.clientIDs) {
-          assert(cid !== clientID, "cannot delete self");
-          clientIDsToDelete.add(cid);
+        if (deleted?.clientIDs?.length) {
+          for (const cid of deleted.clientIDs) {
+            assert(cid !== clientID, "cannot delete self");
+            clientIDsToDelete.add(cid);
+          }
         }
+        for (const cid of clientIDsToDelete) {
+          const patchesDueToClient = updater.deleteClient(cid, ttlClock);
+          patches.push(...patchesDueToClient);
+          deletedClientIDs.push(cid);
+        }
+        if (deleted?.clientGroupIDs?.length) {
+          lc.debug?.(
+            `ignoring ${deleted.clientGroupIDs.length} deprecated client group deletes`
+          );
+        }
+        return patches;
       }
-      for (const cid of clientIDsToDelete) {
-        const patchesDueToClient = updater.deleteClient(cid, ttlClock);
-        patches.push(...patchesDueToClient);
-        deletedClientIDs.push(cid);
-      }
-      if (deleted?.clientGroupIDs?.length) {
-        lc.debug?.(
-          `ignoring ${deleted.clientGroupIDs.length} deprecated client group deletes`
-        );
-      }
-      return patches;
-    });
+    );
     if (deletedClientIDs.length && deleted?.clientIDs?.length || deletedClientGroupIDs.length) {
       const clients = this.#getClients();
       await Promise.allSettled(
@@ -681,6 +712,7 @@ class ViewSyncerService {
       );
     }
     this.#scheduleExpireEviction(lc, cvr);
+    return deletedClientIDs;
   });
   #scheduleExpireEviction(lc, cvr) {
     const { ttlClock } = cvr;
@@ -759,21 +791,25 @@ class ViewSyncerService {
         "Custom/named queries were requested but no `ZERO_QUERY_URL` is configured for Zero Cache."
       );
     }
-    await this.#runPriorityOp(async () => {
-      if (this.#customQueryTransformer && customQueries.size > 0) {
-        const transformedCustomQueries = await this.#customQueryTransformer.transform(
+    const customQueryTransformer = this.#customQueryTransformer;
+    if (customQueryTransformer && customQueries.size > 0) {
+      const transformedCustomQueries = await this.#runPriorityOp(
+        lc,
+        "#hydrateUnchangedQueries transforming custom queries",
+        () => customQueryTransformer.transform(
           this.#getHeaderOptions(this.#queryConfig.forwardCookies),
           customQueries.values(),
           this.userQueryURL
-        );
-        this.#processTransformedCustomQueries(
-          lc,
-          transformedCustomQueries,
-          (q) => transformedQueries.push(q),
-          customQueries
-        );
+        )
+      );
+      if (Array.isArray(transformedCustomQueries)) {
+        for (const q of transformedCustomQueries) {
+          if (!("error" in q) && q.transformationHash === customQueries.get(q.id)?.transformationHash) {
+            transformedQueries.push(q);
+          }
+        }
       }
-    });
+    }
     for (const q of otherQueries) {
       const transformed = transformAndHashQuery(
         lc,
@@ -794,7 +830,7 @@ class ViewSyncerService {
       transformationHash,
       transformedAst
     } of transformedQueries) {
-      const timer = new TimeSliceTimer();
+      const timer = new TimeSliceTimer(lc);
       let count = 0;
       await startAsyncSpan(
         tracer,
@@ -876,11 +912,11 @@ class ViewSyncerService {
       this.#clients.get(clientId)?.sendQueryTransformApplicationErrors(errors);
     }
   }
-  #addQueryMaterializationServerMetric(transformationHash, elapsed) {
+  #addQueryMaterializationServerMetric(queryID, elapsed) {
     this.#inspectorDelegate.addMetric(
       "query-materialization-server",
       elapsed,
-      transformationHash
+      queryID
     );
   }
   /**
@@ -891,14 +927,12 @@ class ViewSyncerService {
    *
    * This must be called from within the #lock.
    */
-  #syncQueryPipelineSet(lc, cvr) {
+  #syncQueryPipelineSet(lc, cvr, customQueryTransformMode) {
     return startAsyncSpan(tracer, "vs.#syncQueryPipelineSet", async () => {
       assert(
         this.#pipelines.initialized(),
         "pipelines must be initialized (syncQueryPipelineSet)"
       );
-      const [hydratedQueries, byOriginalHash] = this.#pipelines.addedQueries();
-      const hashToIDs = /* @__PURE__ */ new Map();
       if (this.#ttlClock === void 0) {
         this.#ttlClock = cvr.ttlClock;
       }
@@ -940,14 +974,22 @@ class ViewSyncerService {
         );
       }
       let erroredQueryIDs;
-      if (this.#customQueryTransformer && customQueries.size > 0) {
+      const customQueriesToTransform = customQueryTransformMode === "all" ? [...customQueries.values()] : customQueryTransformMode && [...customQueries.values()].filter(
+        (q) => !this.#pipelines.queries().has(q.id)
+      );
+      const customQueryTransformer = this.#customQueryTransformer;
+      if (customQueryTransformer && customQueriesToTransform.length > 0) {
         const transformStart = performance.now();
         let transformedCustomQueries;
         try {
-          transformedCustomQueries = await this.#customQueryTransformer.transform(
-            this.#getHeaderOptions(true),
-            customQueries.values(),
-            this.userQueryURL
+          transformedCustomQueries = await this.#runPriorityOp(
+            lc,
+            "#syncQueryPipelineSet transforming custom queries",
+            () => customQueryTransformer.transform(
+              this.#getHeaderOptions(true),
+              customQueriesToTransform,
+              this.userQueryURL
+            )
           );
           this.#queryTransformations.add(1, { result: "success" });
         } catch (e) {
@@ -963,24 +1005,30 @@ class ViewSyncerService {
             getLogLevel(transformedCustomQueries.kind)
           );
         }
-        const successfullyTransformed = /* @__PURE__ */ new Map();
+        const successfullyTransformedCustomQueries = /* @__PURE__ */ new Map();
         erroredQueryIDs = this.#processTransformedCustomQueries(
           lc,
           transformedCustomQueries,
           (q) => {
-            successfullyTransformed.set(q.id, q);
-            transformedQueries.push({
-              id: q.id,
-              origQuery: must(customQueries.get(q.id)),
-              transformed: q
-            });
+            const origQuery = customQueries.get(q.id);
+            if (origQuery) {
+              successfullyTransformedCustomQueries.set(q.id, q);
+              transformedQueries.push({
+                id: q.id,
+                origQuery,
+                transformed: q
+              });
+            }
           },
           customQueries
         );
-        for (const [queryID, newTransform] of successfullyTransformed) {
-          const existingTransforms = byOriginalHash.get(queryID);
-          if (existingTransforms && existingTransforms.length > 0) {
-            const oldHash = existingTransforms[0].transformationHash;
+        for (const [
+          queryID,
+          newTransform
+        ] of successfullyTransformedCustomQueries) {
+          const existingTransformHash = cvr.queries[queryID]?.transformationHash;
+          if (existingTransformHash) {
+            const oldHash = existingTransformHash;
             const newHash = newTransform.transformationHash;
             if (oldHash !== newHash) {
               lc.info?.(
@@ -994,31 +1042,15 @@ class ViewSyncerService {
           }
         }
       }
-      const serverQueries = transformedQueries.map(
-        ({ id, origQuery, transformed }) => {
-          const ids = hashToIDs.get(transformed.transformationHash);
-          if (ids) {
-            ids.push(id);
-          } else {
-            hashToIDs.set(transformed.transformationHash, [id]);
-          }
-          return {
-            id,
-            ast: transformed.transformedAst,
-            transformationHash: transformed.transformationHash,
-            remove: expired(ttlClock, origQuery)
-          };
-        }
+      const removeQueriesQueryIds = new Set(
+        Object.values(cvr.queries).filter((q) => expired(ttlClock, q)).map((q) => q.id).concat(erroredQueryIDs || [])
       );
-      const addQueries = serverQueries.filter(
-        (q) => !q.remove && !hydratedQueries.has(q.transformationHash)
-      );
-      const removeQueries = serverQueries.filter((q) => q.remove);
-      const desiredQueries = new Set(
-        serverQueries.filter((q) => !q.remove).map((q) => q.transformationHash)
-      );
-      const unhydrateQueries = [...hydratedQueries].filter(
-        (transformationHash) => !desiredQueries.has(transformationHash)
+      const addQueries = transformedQueries.map(({ id, transformed }) => ({
+        id,
+        ast: transformed.transformedAst,
+        transformationHash: transformed.transformationHash
+      })).filter(
+        (q) => !removeQueriesQueryIds.has(q.id) && this.#pipelines.queries().get(q.id)?.transformationHash !== q.transformationHash
       );
       for (const q of addQueries) {
         const orig = cvr.queries[q.id];
@@ -1029,33 +1061,12 @@ class ViewSyncerService {
           orig.type === "custom" ? orig.name : orig.ast
         );
       }
-      if (erroredQueryIDs) {
-        const successfulHashes = new Set(
-          transformedQueries.map(
-            ({ transformed }) => transformed.transformationHash
-          )
-        );
-        for (const queryID of erroredQueryIDs) {
-          let lastKnownHash;
-          const cvrQuery = cvr.queries[queryID];
-          if (cvrQuery?.transformationHash) {
-            lastKnownHash = cvrQuery.transformationHash;
-          }
-          const transformationHash = lastKnownHash && successfulHashes.has(lastKnownHash) ? void 0 : lastKnownHash;
-          removeQueries.push({
-            id: queryID,
-            transformationHash
-          });
-        }
-      }
-      if (addQueries.length > 0 || removeQueries.length > 0 || unhydrateQueries.length > 0) {
+      if (addQueries.length > 0 || removeQueriesQueryIds.size > 0) {
         await this.#addAndRemoveQueries(
           lc,
           cvr,
           addQueries,
-          removeQueries,
-          unhydrateQueries,
-          hashToIDs
+          [...removeQueriesQueryIds].map((id) => ({ id }))
         );
       } else {
         await this.#catchupClients(lc, cvr);
@@ -1089,10 +1100,10 @@ class ViewSyncerService {
     }
   }
   // This must be called from within the #lock.
-  #addAndRemoveQueries(lc, cvr, addQueries, removeQueries, unhydrateQueries, hashToIDs) {
+  #addAndRemoveQueries(lc, cvr, addQueries, removeQueries) {
     return startAsyncSpan(tracer, "vs.#addAndRemoveQueries", async () => {
       assert(
-        addQueries.length > 0 || removeQueries.length > 0 || unhydrateQueries.length > 0,
+        addQueries.length > 0 || removeQueries.length > 0,
         "Must have queries to add or remove"
       );
       const start = performance.now();
@@ -1116,29 +1127,17 @@ class ViewSyncerService {
         await pokers.addPatch(patch);
       }
       for (const q of removeQueries) {
-        if (q.transformationHash) {
-          this.#pipelines.removeQuery(q.transformationHash);
-        }
+        this.#pipelines.removeQuery(q.id);
         this.#inspectorDelegate.removeQuery(q.id);
         this.#queryReplacements.delete(q.id);
       }
-      for (const hash of unhydrateQueries) {
-        this.#pipelines.removeQuery(hash);
-        const ids = hashToIDs.get(hash);
-        if (ids) {
-          for (const id of ids) {
-            this.#inspectorDelegate.removeQuery(id);
-            this.#queryReplacements.delete(id);
-          }
-        }
-      }
       let totalProcessTime = 0;
-      const timer = new TimeSliceTimer();
+      const timer = new TimeSliceTimer(lc);
       const pipelines = this.#pipelines;
       const hydrations = this.#hydrations;
       const hydrationTime = this.#hydrationTime;
       const self = this;
-      await yieldProcess();
+      await yieldProcess(lc);
       function* generateRowChanges(slowHydrateThreshold) {
         for (const q of addQueries) {
           lc = lc.withContext("hash", q.id).withContext("transformationHash", q.transformationHash);
@@ -1151,10 +1150,7 @@ class ViewSyncerService {
           );
           const elapsed = timer.stop();
           totalProcessTime += elapsed;
-          self.#addQueryMaterializationServerMetric(
-            q.transformationHash,
-            elapsed
-          );
+          self.#addQueryMaterializationServerMetric(q.id, elapsed);
           if (elapsed > slowHydrateThreshold) {
             lc.warn?.("Slow query materialization", elapsed, q.ast);
           }
@@ -1171,8 +1167,7 @@ class ViewSyncerService {
         timer,
         generateRowChanges(this.#slowHydrateThreshold),
         updater,
-        pokers,
-        hashToIDs
+        pokers
       );
       for (const patch of await updater.deleteUnreferencedRows(lc)) {
         await pokers.addPatch(patch);
@@ -1232,6 +1227,8 @@ class ViewSyncerService {
         cvr,
         current
       );
+      configPatches.catch(() => {
+      });
       let rowPatchCount = 0;
       for await (const rows of rowPatches) {
         for (const row of rows) {
@@ -1267,7 +1264,7 @@ class ViewSyncerService {
       }
     });
   }
-  #processChanges(lc, timer, changes, updater, pokers, hashToIDs) {
+  #processChanges(lc, timer, changes, updater, pokers) {
     return startAsyncSpan(tracer, "vs.#processChanges", async () => {
       const start = performance.now();
       const rows = new CustomKeyMap(rowIDString);
@@ -1290,24 +1287,14 @@ class ViewSyncerService {
             await timer.yieldProcess("yield in processChanges");
             continue;
           }
-          const {
-            type,
-            queryHash: transformationHash,
-            table,
-            rowKey,
-            row
-          } = change;
-          const queryIDs = must(
-            hashToIDs.get(transformationHash),
-            "could not find the original hash for the transformation hash"
-          );
+          const { type, queryID, table, rowKey, row } = change;
           const rowID = { schema: "", table, rowKey };
           let parsedRow = rows.get(rowID);
           if (!parsedRow) {
             parsedRow = { refCounts: {} };
             rows.set(rowID, parsedRow);
           }
-          queryIDs.forEach((hash) => parsedRow.refCounts[hash] ??= 0);
+          parsedRow.refCounts[queryID] ??= 0;
           const updateVersion = (row2) => {
             const { version: version2, contents } = contentsAndVersion(row2);
             parsedRow.version = version2;
@@ -1316,13 +1303,13 @@ class ViewSyncerService {
           switch (type) {
             case "add":
               updateVersion(row);
-              queryIDs.forEach((hash) => parsedRow.refCounts[hash]++);
+              parsedRow.refCounts[queryID]++;
               break;
             case "edit":
               updateVersion(row);
               break;
             case "remove":
-              queryIDs.forEach((hash) => parsedRow.refCounts[hash]--);
+              parsedRow.refCounts[queryID]--;
               break;
             default:
               unreachable(type);
@@ -1353,7 +1340,7 @@ class ViewSyncerService {
         "pipelines must be initialized (advancePipelines"
       );
       const start = performance.now();
-      const timer = new TimeSliceTimer();
+      const timer = new TimeSliceTimer(lc);
       const { version: version2, numChanges, changes } = this.#pipelines.advance(timer);
       lc = lc.withContext("newVersion", version2);
       const updater = new CVRQueryDrivenUpdater(
@@ -1367,15 +1354,13 @@ class ViewSyncerService {
         updater.updatedVersion()
       );
       lc.debug?.(`applying ${numChanges} to advance to ${version2}`);
-      const hashToIDs = createHashToIDs(cvr);
       try {
         await this.#processChanges(
           lc,
           await timer.start(),
           changes,
           updater,
-          pokers,
-          hashToIDs
+          pokers
         );
       } catch (e) {
         if (e instanceof ResetPipelinesSignal) {
@@ -1442,22 +1427,8 @@ class ViewSyncerService {
   }
 }
 const CURSOR_PAGE_SIZE = 1e4;
-function createHashToIDs(cvr) {
-  const hashToIDs = /* @__PURE__ */ new Map();
-  for (const { id, transformationHash } of Object.values(cvr.queries)) {
-    if (!transformationHash) {
-      continue;
-    }
-    if (hashToIDs.has(transformationHash)) {
-      must(hashToIDs.get(transformationHash)).push(id);
-    } else {
-      hashToIDs.set(transformationHash, [id]);
-    }
-  }
-  return hashToIDs;
-}
 const timeSliceQueue = new Lock();
-function yieldProcess() {
+function yieldProcess(_lc) {
   return timeSliceQueue.withLock(() => new Promise(setImmediate));
 }
 function contentsAndVersion(row) {
@@ -1545,8 +1516,12 @@ function hasExpiredQueries(cvr) {
 class TimeSliceTimer {
   #total = 0;
   #start = 0;
+  #lc;
+  constructor(lc) {
+    this.#lc = lc;
+  }
   async start() {
-    await yieldProcess();
+    await yieldProcess(this.#lc);
     return this.startWithoutYielding();
   }
   startWithoutYielding() {
@@ -1556,7 +1531,7 @@ class TimeSliceTimer {
   }
   async yieldProcess(_msgForTesting) {
     this.#stopLap();
-    await yieldProcess();
+    await yieldProcess(this.#lc);
     this.#startLap();
   }
   #startLap() {