@osdk/client 2.2.0-beta.8 → 2.3.0-beta.1

package/build/cjs/public/unstable-do-not-use.cjs

@@ -1,35 +1,30 @@
 'use strict';
 
-var chunkJPENHIJB_cjs = require('../chunk-JPENHIJB.cjs');
-require('../chunk-Q7SFCCGT.cjs');
+var chunkT4NIFYZS_cjs = require('../chunk-T4NIFYZS.cjs');
+var chunkW5PFESFR_cjs = require('../chunk-W5PFESFR.cjs');
 var rxjs = require('rxjs');
 var invariant2 = require('tiny-invariant');
 var mnemonist = require('mnemonist');
 var trie = require('@wry/trie');
 var deepEqual = require('fast-deep-equal');
+var groupBy = require('object.groupby');
+var shared_net_errors = require('@osdk/shared.net.errors');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var invariant2__default = /*#__PURE__*/_interopDefault(invariant2);
 var deepEqual__default = /*#__PURE__*/_interopDefault(deepEqual);
+var groupBy__default = /*#__PURE__*/_interopDefault(groupBy);
 
 // src/observable/internal/ObservableClientImpl.ts
 var ObservableClientImpl = class {
   #store;
   constructor(store) {
     this.#store = store;
-  }
-  observeObject(apiName, pk, options, subFn) {
-    return this.#store.observeObject(apiName, pk, options, subFn);
-  }
-  observeList(options, subFn) {
-    return this.#store.observeList(options, subFn);
-  }
-  applyAction(action, args, opts) {
-    return this.#store.applyAction(action, args, opts);
-  }
-  canonicalizeWhereClause(where) {
-    return this.#store.whereCanonicalizer.canonicalize(where);
+    this.observeObject = store.observeObject.bind(store);
+    this.observeList = store.observeList.bind(store);
+    this.applyAction = store.applyAction.bind(store);
+    this.canonicalizeWhereClause = store.canonicalizeWhereClause.bind(store);
   }
 };
 
@@ -37,58 +32,60 @@ var ObservableClientImpl = class {
 process.env.NODE_ENV !== "production" && false;
 var DEBUG_CACHE_KEYS = process.env.NODE_ENV !== "production" && false;
 
-// ../../node_modules/.pnpm/is-node-process@1.2.0/node_modules/is-node-process/lib/index.mjs
-function isNodeProcess() {
-  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
-    return true;
-  }
-  if (typeof process !== "undefined") {
-    const type = process.type;
-    if (type === "renderer" || type === "worker") {
-      return false;
-    }
-    return !!(process.versions && process.versions.node);
-  }
-  return false;
-}
-
-// ../../node_modules/.pnpm/msw@2.7.0_@types+node@22.13.0_typescript@5.5.4/node_modules/msw/lib/core/delay.mjs
-var SET_TIMEOUT_MAX_ALLOWED_INT = 2147483647;
-var MIN_SERVER_RESPONSE_TIME = 100;
-var MAX_SERVER_RESPONSE_TIME = 400;
-var NODE_SERVER_RESPONSE_TIME = 5;
-function getRealisticResponseTime() {
-  if (isNodeProcess()) {
-    return NODE_SERVER_RESPONSE_TIME;
-  }
-  return Math.floor(Math.random() * (MAX_SERVER_RESPONSE_TIME - MIN_SERVER_RESPONSE_TIME) + MIN_SERVER_RESPONSE_TIME);
-}
-async function delay(durationOrMode) {
-  let delayTime;
-  if (typeof durationOrMode === "string") {
-    switch (durationOrMode) {
-      case "infinite": {
-        delayTime = SET_TIMEOUT_MAX_ALLOWED_INT;
-        break;
-      }
-      case "real": {
-        delayTime = getRealisticResponseTime();
-        break;
-      }
-      default: {
-        throw new Error(`Failed to delay a response: unknown delay mode "${durationOrMode}". Please make sure you provide one of the supported modes ("real", "infinite") or a number.`);
+// ../../node_modules/.pnpm/delay@6.0.0/node_modules/delay/index.js
+var createAbortError = () => {
+  const error = new Error("Delay aborted");
+  error.name = "AbortError";
+  return error;
+};
+var clearMethods = /* @__PURE__ */ new WeakMap();
+function createDelay({
+  clearTimeout: defaultClear,
+  setTimeout: defaultSet
+} = {}) {
+  return (milliseconds, {
+    value,
+    signal
+  } = {}) => {
+    if (signal?.aborted) {
+      return Promise.reject(createAbortError());
+    }
+    let timeoutId;
+    let settle;
+    let rejectFunction;
+    const clear = defaultClear ?? clearTimeout;
+    const signalListener = () => {
+      clear(timeoutId);
+      rejectFunction(createAbortError());
+    };
+    const cleanup = () => {
+      if (signal) {
+        signal.removeEventListener("abort", signalListener);
       }
+    };
+    const delayPromise = new Promise((resolve, reject) => {
+      settle = () => {
+        cleanup();
+        resolve(value);
+      };
+      rejectFunction = reject;
+      timeoutId = (defaultSet ?? setTimeout)(settle, milliseconds);
+    });
+    if (signal) {
+      signal.addEventListener("abort", signalListener, {
+        once: true
+      });
     }
-  } else if (typeof durationOrMode === "undefined") {
-    delayTime = getRealisticResponseTime();
-  } else {
-    if (durationOrMode > SET_TIMEOUT_MAX_ALLOWED_INT) {
-      throw new Error(`Failed to delay a response: provided delay duration (${durationOrMode}) exceeds the maximum allowed duration for "setTimeout" (${SET_TIMEOUT_MAX_ALLOWED_INT}). This will cause the response to be returned immediately. Please use a number within the allowed range to delay the response by exact duration, or consider the "infinite" delay mode to delay the response indefinitely.`);
-    }
-    delayTime = durationOrMode;
-  }
-  return new Promise((resolve) => setTimeout(resolve, delayTime));
+    clearMethods.set(delayPromise, () => {
+      clear(timeoutId);
+      timeoutId = null;
+      settle();
+    });
+    return delayPromise;
+  };
 }
+var delay = createDelay();
+var delay_default = delay;
 
 // src/observable/internal/CacheKey.ts
 function DEBUG_ONLY__cacheKeyToString(x) {
@@ -100,28 +97,39 @@ function DEBUG_ONLY__cacheKeyToString(x) {
 }
 function DEBUG_ONLY__cacheKeysToString(x) {
   if (process.env.NODE_ENV !== "production") {
-    return JSON.stringify(x.map(DEBUG_ONLY__cacheKeyToString), null, 2);
+    return "\n  - " + x.map(DEBUG_ONLY__cacheKeyToString).join("\n  - ");
   } else {
     throw new Error("not implemented");
   }
 }
 
-// src/observable/internal/ChangedObjects.ts
-function createChangedObjects() {
-  return {
-    modifiedObjects: new mnemonist.MultiMap(),
-    addedObjects: new mnemonist.MultiMap(),
-    addedLists: /* @__PURE__ */ new Set(),
-    modifiedLists: /* @__PURE__ */ new Set()
+// src/observable/internal/Changes.ts
+var Changes = class {
+  modifiedObjects = new mnemonist.MultiMap();
+  addedObjects = new mnemonist.MultiMap();
+  added = /* @__PURE__ */ new Set();
+  modified = /* @__PURE__ */ new Set();
+  registerObject = (cacheKey, data, isNew) => {
+    this[isNew ? "addedObjects" : "modifiedObjects"].set(data.$apiName, data);
+    this[isNew ? "added" : "modified"].add(cacheKey);
   };
+  registerList = (key) => {
+    this.modified.add(key);
+  };
+  isEmpty() {
+    return this.modifiedObjects.size === 0 && this.addedObjects.size === 0 && this.added.size === 0 && this.modified.size === 0;
+  }
+};
+function createChangedObjects() {
+  return new Changes();
 }
 function DEBUG_ONLY__changesToString(changes) {
   if (process.env.NODE_ENV !== "production") {
     return JSON.stringify({
       modifiedObjects: multimapHelper(changes.modifiedObjects),
       addedObjects: multimapHelper(changes.addedObjects),
-      addedLists: listHelper(changes.addedLists),
-      modifiedLists: listHelper(changes.modifiedLists)
+      added: listHelper(changes.added),
+      modified: listHelper(changes.modified)
     }, null, 2);
   } else {
     throw new Error("not implemented");
@@ -139,7 +147,7 @@ function multimapHelper(multimap) {
 // src/observable/internal/OptimisticId.ts
 function createOptimisticId() {
   if (process.env.NODE_ENV !== "production") {
-    if (createOptimisticId.counter === undefined) {
+    if (createOptimisticId.counter === void 0) {
       createOptimisticId.counter = 0;
     }
     return {
@@ -183,12 +191,12 @@ var OptimisticJob = class {
         return this;
       },
       createObject(type, pk, properties) {
-        const create = store.client[chunkJPENHIJB_cjs.additionalContext].objectFactory2(store.client[chunkJPENHIJB_cjs.additionalContext], [{
+        const create = store.client[chunkW5PFESFR_cjs.additionalContext].objectFactory2(store.client[chunkW5PFESFR_cjs.additionalContext], [{
           $primaryKey: pk,
           $apiName: type.apiName,
           $objectType: type.apiName,
           ...properties
-        }], undefined).then((objs) => {
+        }], void 0, {}).then((objs) => {
           return objs[0];
         });
         addedObjectPromises.push(create);
@@ -208,7 +216,7 @@ function runOptimisticJob(store, optimisticUpdate) {
   return () => {
     return optimisticApplicationDone.then(
       // we don't want to leak the result
-      () => undefined
+      () => void 0
     ).finally(() => {
       store.removeLayer(optimisticId);
     });
@@ -221,25 +229,30 @@ var ActionApplication = class {
   constructor(store) {
     this.store = store;
   }
-  applyAction = (action, args, {
+  applyAction = async (action, args, {
     optimisticUpdate
   } = {}) => {
+    const logger = process.env.NODE_ENV !== "production" ? this.store.logger?.child({
+      methodName: "applyAction"
+    }) : this.store.logger;
     const removeOptimisticResult = runOptimisticJob(this.store, optimisticUpdate);
-    return (async () => {
+    return await (async () => {
       try {
         const actionResults = await this.store.client(action).applyAction(args, {
           $returnEdits: true
         });
-        if (ACTION_DELAY > 0) {
-          console.log("action done, pausing");
-          await delay(ACTION_DELAY);
-          console.log("action done, pausing done");
+        if (process.env.NODE_ENV !== "production") {
+          if (ACTION_DELAY > 0) {
+            logger?.debug("action done, pausing", actionResults);
+            await delay_default(ACTION_DELAY);
+            logger?.debug("action done, pausing done");
+          }
         }
         await this.#invalidateActionEditResponse(actionResults);
         return actionResults;
       } finally {
         if (process.env.NODE_ENV !== "production") {
-          this.store.logger?.debug("optimistic action complete; remove the results");
+          logger?.debug("optimistic action complete; remove the results");
         }
         await removeOptimisticResult();
       }
@@ -258,8 +271,20 @@ var ActionApplication = class {
         typesToInvalidate.add(obj.objectType);
       }
       await Promise.all(promisesToWait);
-      changes = this.#changesFromActionEditResponse(value);
-      await this.store.maybeRevalidateLists(changes);
+      const changes2 = createChangedObjects();
+      for (const changeType of ["addedObjects", "modifiedObjects"]) {
+        for (const {
+          objectType,
+          primaryKey
+        } of value[changeType] ?? []) {
+          const cacheKey = this.store.getCacheKey("object", objectType, primaryKey);
+          const obj = this.store.getValue(cacheKey);
+          if (obj && obj.value) {
+            changes2[changeType].set(objectType, obj.value);
+            (changeType === "addedObjects" ? changes2.added : changes2.modified).add(cacheKey);
+          }
+        }
+      }
     } else {
       for (const apiName of value.editedObjectTypes) {
         typesToInvalidate.add(apiName.toString());
@@ -268,21 +293,6 @@ var ActionApplication = class {
     }
     return value;
   };
-  #changesFromActionEditResponse = (value) => {
-    const changes = createChangedObjects();
-    for (const changeType of ["addedObjects", "modifiedObjects"]) {
-      for (const {
-        objectType,
-        primaryKey
-      } of value[changeType] ?? []) {
-        const obj = this.store.getObject(objectType, primaryKey);
-        if (obj) {
-          changes[changeType].set(objectType, obj);
-        }
-      }
-    }
-    return changes;
-  };
 };
 var CacheKeys = class {
   #cacheKeys = new trie.Trie(false, (keys) => {
@@ -301,9 +311,9 @@ var CacheKeys = class {
       if (process.env.NODE_ENV !== "production" && DEBUG_CACHE_KEYS) ;
       return this.#cacheKeys.lookupArray(["object", apiName, pk]);
     });
-    this.#registerCacheKeyFactory("list", (apiName, where, orderBy) => {
+    this.#registerCacheKeyFactory("list", (type, apiName, where, orderBy) => {
       if (process.env.NODE_ENV !== "production" && DEBUG_CACHE_KEYS) ;
-      return this.#cacheKeys.lookupArray(["list", apiName, whereCanonicalizer.canonicalize(where), orderByCanonicalizer.canonicalize(orderBy)]);
+      return this.#cacheKeys.lookupArray(["list", type, apiName, whereCanonicalizer.canonicalize(where), orderByCanonicalizer.canonicalize(orderBy)]);
     });
   }
   #registerCacheKeyFactory(type, factory) {
@@ -311,7 +321,7 @@ var CacheKeys = class {
   }
   get(type, ...args) {
     const factory = this.#cacheKeyFactories.get(type);
-    !factory ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, `no cache key factory for type "${type}"`) : invariant2__default.default(false) : undefined;
+    !factory ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, `no cache key factory for type "${type}"`) : invariant2__default.default(false) : void 0;
     return factory(...args);
   }
   remove(cacheKey) {
@@ -343,7 +353,7 @@ var WeakMapWithEntries = class {
     }, 1e3);
   }
   #clean() {
-    this.#list = this.#list.filter((ref) => ref.deref() !== undefined);
+    this.#list = this.#list.filter((ref) => ref.deref() !== void 0);
   }
   // functions for WeakMap
   delete(key) {
@@ -383,7 +393,7 @@ var WeakMapWithEntries = class {
     function* iter() {
       for (const ref of self.#list) {
         const key = ref.deref();
-        if (key !== undefined) {
+        if (key !== void 0) {
           yield [key, self.#map.get(key)];
         }
       }
@@ -398,7 +408,7 @@ var WeakMapWithEntries = class {
     function* iter() {
       for (const ref of self.#list) {
         const key = ref.deref();
-        if (key !== undefined) {
+        if (key !== void 0) {
           yield key;
         }
       }
@@ -413,9 +423,9 @@ var WeakMapWithEntries = class {
     function* iter() {
       for (const ref of self.#list) {
         const key = ref.deref();
-        if (key !== undefined) {
+        if (key !== void 0) {
           const value = self.#map.get(key);
-          if (value !== undefined) {
+          if (value !== void 0) {
             yield value;
           }
         }
@@ -456,6 +466,9 @@ var Layer = class _Layer {
   entries() {
     return this.#cache.entries();
   }
+  keys() {
+    return this.#cache.keys();
+  }
   get(cacheKey) {
     return this.#cache.get(cacheKey) ?? this.#parent?.get(cacheKey);
   }
@@ -474,8 +487,8 @@ var Entry = class {
 function is$and(whereClause) {
   if (process.env.NODE_ENV !== "production") {
     if ("$and" in whereClause) {
-      !Array.isArray(whereClause.$and) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected $and to be an array") : invariant2__default.default(false) : undefined;
-      !(Object.keys(whereClause).length === 1) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected only $and to be present") : invariant2__default.default(false) : undefined;
+      !Array.isArray(whereClause.$and) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected $and to be an array") : invariant2__default.default(false) : void 0;
+      !(Object.keys(whereClause).length === 1) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected only $and to be present") : invariant2__default.default(false) : void 0;
     }
   }
   return "$and" in whereClause;
@@ -483,8 +496,8 @@ function is$and(whereClause) {
 function is$or(whereClause) {
   if (process.env.NODE_ENV !== "production") {
     if ("$or" in whereClause) {
-      !Array.isArray(whereClause.$or) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected $or to be an array") : invariant2__default.default(false) : undefined;
-      !(Object.keys(whereClause).length === 1) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected only $or to be present") : invariant2__default.default(false) : undefined;
+      !Array.isArray(whereClause.$or) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected $or to be an array") : invariant2__default.default(false) : void 0;
+      !(Object.keys(whereClause).length === 1) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected only $or to be present") : invariant2__default.default(false) : void 0;
     }
   }
   return "$or" in whereClause;
@@ -492,7 +505,7 @@ function is$or(whereClause) {
 function is$not(whereClause) {
   if (process.env.NODE_ENV !== "production") {
     if ("$not" in whereClause) {
-      !(Object.keys(whereClause).length === 1) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected only $not to be present") : invariant2__default.default(false) : undefined;
+      !(Object.keys(whereClause).length === 1) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected only $not to be present") : invariant2__default.default(false) : void 0;
     }
   }
   return "$not" in whereClause;
@@ -557,6 +570,90 @@ function objectSortaMatchesWhereClause(o, whereClause, strict) {
   });
 }
 
+// ../../node_modules/.pnpm/p-defer@4.0.1/node_modules/p-defer/index.js
+function pDefer() {
+  const deferred = {};
+  deferred.promise = new Promise((resolve, reject) => {
+    deferred.resolve = resolve;
+    deferred.reject = reject;
+  });
+  return deferred;
+}
+
+// src/observable/internal/BulkObjectLoader.ts
+var weakCache = new mnemonist.DefaultWeakMap((c) => new BulkObjectLoader(c));
+function getBulkObjectLoader(client) {
+  return weakCache.get(client);
+}
+var BulkObjectLoader = class {
+  #client;
+  #m = new mnemonist.DefaultMap(() => ({
+    data: [],
+    timer: void 0
+  }));
+  #logger;
+  #maxWait;
+  #maxEntries;
+  constructor(client, maxWait = 25, maxEntries = 100) {
+    this.#client = client;
+    this.#logger = client[chunkW5PFESFR_cjs.additionalContext].logger;
+    this.#maxWait = maxWait;
+    this.#maxEntries = maxEntries;
+  }
+  fetch(apiName, primaryKey) {
+    const deferred = pDefer();
+    const entry = this.#m.get(apiName);
+    entry.data.push({
+      primaryKey,
+      deferred
+    });
+    if (!entry.timer) {
+      entry.timer = setTimeout(() => {
+        this.#loadObjects(apiName, entry.data);
+      }, this.#maxWait);
+    }
+    if (entry.data.length >= this.#maxEntries) {
+      clearTimeout(entry.timer);
+      this.#loadObjects(apiName, entry.data);
+    }
+    return deferred.promise;
+  }
+  #loadObjects(apiName, arr) {
+    this.#m.delete(apiName);
+    this.#reallyLoadObjects(apiName, arr).catch((e) => {
+      this.#logger?.error("Unhandled exception", e);
+    });
+  }
+  async #reallyLoadObjects(apiName, arr) {
+    const miniDef = {
+      type: "object",
+      apiName
+    };
+    const objMetadata = await this.#client.fetchMetadata(miniDef);
+    const pks = arr.map((x) => x.primaryKey);
+    const {
+      data
+    } = await this.#client(miniDef).where({
+      [objMetadata.primaryKeyApiName]: {
+        $in: pks
+      }
+    }).fetchPage({
+      $pageSize: pks.length
+    });
+    for (const {
+      primaryKey,
+      deferred
+    } of arr) {
+      const object = data.find((x) => x.$primaryKey === primaryKey);
+      if (object) {
+        deferred.resolve(object);
+      } else {
+        deferred.reject(new shared_net_errors.PalantirApiError("Object not found"));
+      }
+    }
+  }
+};
+
 // src/observable/internal/Query.ts
 var Query = class {
   retainCount = 0;
@@ -569,7 +666,7 @@ var Query = class {
     this.cacheKey = cacheKey;
     this.store = store;
     this.#subject = observable;
-    this.logger = logger ?? (process.env.NODE_ENV === "production" ? store.client[chunkJPENHIJB_cjs.additionalContext].logger : store.client[chunkJPENHIJB_cjs.additionalContext].logger?.child({}, {
+    this.logger = logger ?? (process.env.NODE_ENV === "production" ? store.client[chunkW5PFESFR_cjs.additionalContext].logger : store.client[chunkW5PFESFR_cjs.additionalContext].logger?.child({}, {
       msgPrefix: process.env.NODE_ENV !== "production" ? `Query<${cacheKey.type}, ${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>` : "Query"
     }));
   }
@@ -578,61 +675,66 @@ var Query = class {
     this.#subscription = this.#connectable.connect();
     return this.#connectable.subscribe(observer);
   }
-  revalidate(force) {
-    if (process.env.NODE_ENV !== "production") {
-      this.logger?.info({
-        methodName: "revalidate"
-      });
-    }
+  /**
+   * Causes the query to revalidate. This will cause the query to fetch
+   * the latest data from the server and update the store if it is deemed
+   * "stale" or if `force` is true.
+   *
+   * @param force
+   * @returns
+   */
+  async revalidate(force) {
+    const logger = process.env.NODE_ENV !== "production" ? this.logger?.child({
+      methodName: "revalidate"
+    }) : this.logger;
     if (force) {
       this.abortController?.abort();
     }
     if (this.pendingFetch) {
-      return this.pendingFetch;
+      if (process.env.NODE_ENV !== "production") {
+        logger?.info("Fetch is already pending, using it");
+      }
+      await this.pendingFetch;
+      return;
     }
     if ((this.options.dedupeInterval ?? 0) > 0 && this.lastFetchStarted != null && Date.now() - this.lastFetchStarted < (this.options.dedupeInterval ?? 0)) {
       if (process.env.NODE_ENV !== "production") {
-        this.logger?.trace({
-          methodName: "revalidate"
-        }, "DEDUPE");
+        logger?.debug("Within dupeInterval, aborting revalidate");
       }
       return Promise.resolve();
     }
+    if (process.env.NODE_ENV !== "production") {
+      logger?.debug("Starting actual revalidate");
+    }
     this.store.batch({}, (batch) => {
       this.setStatus("loading", batch);
     });
     this._preFetch();
     this.lastFetchStarted = Date.now();
     if (process.env.NODE_ENV !== "production") {
-      this.logger?.trace({
-        methodName: "revalidate"
-      }, "calling _fetch()");
-    }
-    this.pendingFetch = this._fetch().catch((e) => {
-      this.logger?.error({
-        methodName: "revalidate"
-      }, "_fetch() FAILED", e);
-      throw e;
-    }).finally(() => {
-      this.logger?.info({
-        methodName: "revalidate"
-      }, "finally _fetch()");
-      this.pendingFetch = undefined;
-    });
-    if (process.env.NODE_ENV !== "production") {
-      this.logger?.info({
-        methodName: "revalidate"
-      }, "Returning");
+      logger?.debug("calling _fetchAndStore()");
     }
-    return this.pendingFetch;
+    this.pendingFetch = this._fetchAndStore().finally(() => {
+      logger?.info("finally _fetchAndStore()");
+      this.pendingFetch = void 0;
+    });
+    await this.pendingFetch;
+    return;
   }
   _preFetch() {
   }
+  /**
+   * Sets the status of the query in the store (but does not store that in `changes`).
+   *
+   * @param status
+   * @param batch
+   * @returns
+   */
   setStatus(status, batch) {
     if (process.env.NODE_ENV !== "production") {
-      this.logger?.trace({
+      this.logger?.child({
         methodName: "setStatus"
-      }, status);
+      }).debug(status);
     }
     const existing = batch.read(this.cacheKey);
     if (existing?.status === status) return;
@@ -645,31 +747,205 @@ var Query = class {
     this.#subscription?.unsubscribe();
     this._dispose();
   }
+  /**
+   * Per query type dispose functionality
+   */
   _dispose() {
   }
+  /**
+   * The purpose of this method is to provide a way for others to write
+   * directly into the store for this query.
+   *
+   * @param data
+   * @param status
+   * @param batch
+   */
+  /**
+   * @param changes
+   * @param optimisticId
+   * @returns If revalidation is needed, a promise that resolves after the
+   *          revalidation is complete. Otherwise, undefined.
+   */
 };
 
+// src/observable/internal/ObjectQuery.ts
+var ObjectQuery = class extends Query {
+  #apiName;
+  #pk;
+  constructor(store, subject, type, pk, cacheKey, opts) {
+    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkW5PFESFR_cjs.additionalContext].logger?.child({}, {
+      msgPrefix: `ObjectQuery<${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>`
+    }) : void 0);
+    this.#apiName = type;
+    this.#pk = pk;
+  }
+  _createConnectable(subject) {
+    return rxjs.connectable(subject.pipe(rxjs.map((x) => {
+      return {
+        status: x.status,
+        object: x.value,
+        lastUpdated: x.lastUpdated,
+        isOptimistic: x.isOptimistic
+      };
+    })), {
+      connector: () => new rxjs.BehaviorSubject({
+        status: "init",
+        object: void 0,
+        lastUpdated: 0,
+        isOptimistic: false
+      })
+    });
+  }
+  async _fetchAndStore() {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "_fetchAndStore"
+      }).info("calling _fetchAndStore");
+    }
+    const obj = await getBulkObjectLoader(this.store.client).fetch(this.#apiName, this.#pk);
+    this.store.batch({}, (batch) => {
+      this.writeToStore(obj, "loaded", batch);
+    });
+  }
+  writeToStore(data, status, batch) {
+    const entry = batch.read(this.cacheKey);
+    if (entry && deepEqual__default.default(data, entry.value)) {
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.child({
+          methodName: "writeToStore"
+        }).debug(`Object was deep equal, just setting status`);
+      }
+      return batch.write(this.cacheKey, entry.value, status);
+    }
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "writeToStore"
+      }).debug(JSON.stringify({
+        status
+      }), data);
+    }
+    const ret = batch.write(this.cacheKey, data, status);
+    batch.changes.registerObject(
+      this.cacheKey,
+      data,
+      /* isNew */
+      !entry
+    );
+    return ret;
+  }
+};
+function storeOsdkInstances(store, values, batch) {
+  return values.map((v) => {
+    return store.getObjectQuery(v.$apiName, v.$primaryKey).writeToStore(v, "loaded", batch).cacheKey;
+  });
+}
+
 // src/observable/internal/ListQuery.ts
-var ListQuery = class extends Query {
+var API_NAME_IDX = 1;
+var BaseListQuery = class extends Query {
+  //
+  // Per list type implementations
+  //
+  //
+  // Shared Implementations
+  //
+  /**
+   * Only intended to be "protected" and used by subclasses but exposed for
+   * testing.
+   *
+   * @param objectCacheKeys
+   * @param append
+   * @param status
+   * @param batch
+   * @returns
+   */
+  _updateList(objectCacheKeys, append, status, batch) {
+    if (process.env.NODE_ENV !== "production") {
+      const logger = process.env.NODE_ENV !== "production" ? this.logger?.child({
+        methodName: "updateList"
+      }) : this.logger;
+      logger?.debug(`{status: ${status}}`, JSON.stringify(objectCacheKeys, null, 2));
+    }
+    objectCacheKeys = this.#retainReleaseAppend(batch, append, objectCacheKeys);
+    objectCacheKeys = this._sortCacheKeys(objectCacheKeys, batch);
+    objectCacheKeys = removeDuplicates(objectCacheKeys, batch);
+    return this.writeToStore({
+      data: objectCacheKeys
+    }, status, batch);
+  }
+  writeToStore(data, status, batch) {
+    const entry = batch.read(this.cacheKey);
+    if (entry && deepEqual__default.default(data, entry.value)) {
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.child({
+          methodName: "writeToStore"
+        }).debug(`Object was deep equal, just setting status`);
+      }
+      return batch.write(this.cacheKey, entry.value, status);
+    }
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "writeToStore"
+      }).debug(`{status: ${status}},`, DEBUG_ONLY__cacheKeysToString(data.data));
+    }
+    const ret = batch.write(this.cacheKey, data, status);
+    batch.changes.registerList(this.cacheKey);
+    return ret;
+  }
+  #retainReleaseAppend(batch, append, objectCacheKeys) {
+    const existingList = batch.read(this.cacheKey);
+    if (!batch.optimisticWrite) {
+      if (!append) {
+        for (const objectCacheKey of existingList?.value?.data ?? []) {
+          this.store.release(objectCacheKey);
+        }
+      }
+      for (const objectCacheKey of objectCacheKeys) {
+        this.store.retain(objectCacheKey);
+      }
+    }
+    if (append) {
+      objectCacheKeys = [...existingList?.value?.data ?? [], ...objectCacheKeys];
+    }
+    return objectCacheKeys;
+  }
+  _dispose() {
+    console.log("DISPOSE LIST QUERY");
+    this.store.batch({}, (batch) => {
+      const entry = batch.read(this.cacheKey);
+      if (entry) {
+        for (const objectCacheKey of entry.value?.data ?? []) {
+          this.store.release(objectCacheKey);
+        }
+      }
+    });
+  }
+};
+var ListQuery = class extends BaseListQuery {
   // pageSize?: number; // this is the internal page size. we need to track this properly
-  #client;
   #type;
+  #apiName;
   #whereClause;
   // this represents the minimum number of results we need to load if we revalidate
   #minNumResults = 0;
   #nextPageToken;
   #pendingPageFetch;
-  #toRelease = /* @__PURE__ */ new Set();
   #orderBy;
-  constructor(store, subject, objectType, whereClause, orderBy, cacheKey, opts) {
-    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkJPENHIJB_cjs.additionalContext].logger?.child({}, {
+  #objectSet;
+  #sortFns;
+  constructor(store, subject, apiType, apiName, whereClause, orderBy, cacheKey, opts) {
+    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkW5PFESFR_cjs.additionalContext].logger?.child({}, {
       msgPrefix: `ListQuery<${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>`
-    }) : undefined);
-    this.#client = store.client;
-    this.#type = objectType;
+    }) : void 0);
+    this.#type = apiType;
+    this.#apiName = apiName;
     this.#whereClause = whereClause;
     this.#orderBy = orderBy;
-    rxjs.observeOn(rxjs.asyncScheduler);
+    this.#objectSet = store.client({
+      type: this.#type,
+      apiName: this.#apiName
+    }).where(this.#whereClause);
+    this.#sortFns = createOrderBySortFns(this.#orderBy);
   }
   get canonicalWhere() {
     return this.#whereClause;
@@ -694,19 +970,20 @@ var ListQuery = class extends Query {
     });
   }
   _preFetch() {
-    this.#nextPageToken = undefined;
+    this.#nextPageToken = void 0;
   }
-  async _fetch() {
-    const objectSet = this.#client({
-      type: "object",
-      apiName: this.#type
-    }).where(this.#whereClause);
+  async _fetchAndStore() {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "_fetchAndStore"
+      }).info("fetching pages");
+    }
     while (true) {
-      const entry = await this.#fetchPageAndUpdate(objectSet, "loading", this.abortController?.signal);
+      const entry = await this.#fetchPageAndUpdate(this.#objectSet, "loading", this.abortController?.signal);
       if (!entry) {
         return;
       }
-      !entry.value?.data ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false) : invariant2__default.default(false) : undefined;
+      !entry.value?.data ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false) : invariant2__default.default(false) : void 0;
       const count = entry.value.data.length;
       if (count > this.#minNumResults || this.#nextPageToken == null) {
         break;
@@ -734,40 +1011,75 @@ var ListQuery = class extends Query {
     this.store.batch({}, (batch) => {
       this.setStatus("loading", batch);
     });
-    const objectSet = this.#client({
-      type: "object",
-      apiName: this.#type
-    }).where(this.#whereClause);
-    this.pendingFetch = this.#fetchPageAndUpdate(objectSet, "loaded", this.abortController?.signal).finally(() => {
-      this.#pendingPageFetch = undefined;
+    this.pendingFetch = this.#fetchPageAndUpdate(this.#objectSet, "loaded", this.abortController?.signal).finally(() => {
+      this.#pendingPageFetch = void 0;
     });
     return this.pendingFetch;
   };
   async #fetchPageAndUpdate(objectSet, status, signal) {
     const append = this.#nextPageToken != null;
-    const {
-      data,
-      nextPageToken
-    } = await objectSet.fetchPage({
-      $nextPageToken: this.#nextPageToken,
-      $pageSize: this.options.pageSize,
-      // For now this keeps the shared test code from falling apart
-      // but shouldn't be needed ideally
-      ...Object.keys(this.#orderBy).length > 0 ? {
-        $orderBy: this.#orderBy
-      } : {}
+    try {
+      let {
+        data,
+        nextPageToken
+      } = await objectSet.fetchPage({
+        $nextPageToken: this.#nextPageToken,
+        $pageSize: this.options.pageSize,
+        // For now this keeps the shared test code from falling apart
+        // but shouldn't be needed ideally
+        ...Object.keys(this.#orderBy).length > 0 ? {
+          $orderBy: this.#orderBy
+        } : {}
+      });
+      if (signal?.aborted) {
+        return;
+      }
+      this.#nextPageToken = nextPageToken;
+      if (this.#type === "interface") {
+        data = await reloadDataAsFullObjects(this.store.client, data);
+      }
+      const {
+        retVal
+      } = this.store.batch({}, (batch) => {
+        return this._updateList(storeOsdkInstances(this.store, data, batch), append, nextPageToken ? status : "loaded", batch);
+      });
+      return retVal;
+    } catch (e) {
+      this.logger?.error("error", e);
+      this.store.getSubject(this.cacheKey).error(e);
+    }
+  }
+  /**
+   * Will revalidate the list if its query is affected by invalidating the
+   * apiName of the object type passed in.
+   *
+   * @param apiName to invalidate
+   * @returns
+   */
+  revalidateObjectType = async (apiName) => {
+    if (this.#type === "object") {
+      if (this.#apiName === apiName) {
+        await this.revalidate(
+          /* force */
+          true
+        );
+        return;
+      } else {
+        return;
+      }
+    }
+    const objectMetadata = await this.store.client.fetchMetadata({
+      type: "object",
+      apiName
     });
-    if (signal?.aborted) {
+    if (this.#apiName in objectMetadata.interfaceMap) {
+      await this.revalidate(
+        /* force */
+        true
+      );
       return;
     }
-    this.#nextPageToken = nextPageToken;
-    const {
-      retVal
-    } = this.store.batch({}, (batch) => {
-      return this.updateList(this.store.updateObjects(data, batch), append, nextPageToken ? status : "loaded", batch);
-    });
-    return retVal;
-  }
+  };
   /**
    * Note: This method is not async because I want it to return right after it
    *       finishes the synchronous updates. The promise that is returned
@@ -779,50 +1091,25 @@ var ListQuery = class extends Query {
    */
   maybeUpdateAndRevalidate = (changes, optimisticId) => {
     if (process.env.NODE_ENV !== "production") {
-      this.logger?.info({
-        methodName: "#maybeMaybe"
-      }, DEBUG_ONLY__changesToString(changes));
+      this.logger?.child({
+        methodName: "maybeUpdateAndRevalidate"
+      }).debug(DEBUG_ONLY__changesToString(changes));
     }
-    if (changes.modifiedLists.has(this.cacheKey)) return;
+    if (changes.modified.has(this.cacheKey)) return;
+    changes.modified.add(this.cacheKey);
     try {
-      const relevantObjects = {
-        added: {
-          all: changes.addedObjects.get(this.cacheKey.otherKeys[0]) ?? [],
-          strictMatches: /* @__PURE__ */ new Set(),
-          sortaMatches: /* @__PURE__ */ new Set()
-        },
-        modified: {
-          all: changes.modifiedObjects.get(this.cacheKey.otherKeys[0]) ?? [],
-          strictMatches: /* @__PURE__ */ new Set(),
-          sortaMatches: /* @__PURE__ */ new Set()
-        }
-      };
+      const relevantObjects = this._extractRelevantObjects(changes);
       if (relevantObjects.added.all.length === 0 && relevantObjects.modified.all.length === 0) {
         return;
       }
-      for (const group of Object.values(relevantObjects)) {
-        for (const obj of group.all ?? []) {
-          const strictMatch = objectSortaMatchesWhereClause(obj, this.#whereClause, true);
-          if (strictMatch) {
-            group.strictMatches.add(obj);
-          } else {
-            const sortaMatch = objectSortaMatchesWhereClause(obj, this.#whereClause, false);
-            if (sortaMatch) {
-              group.sortaMatches.add(obj);
-            }
-          }
-        }
-      }
       const status = optimisticId || relevantObjects.added.sortaMatches.size > 0 || relevantObjects.modified.sortaMatches.size > 0 ? "loading" : "loaded";
-      changes.modifiedLists.add(this.cacheKey);
       const newList = [];
       let needsRevalidation = false;
       this.store.batch({
         optimisticId,
         changes
       }, (batch) => {
-        const curValue = batch.read(this.cacheKey);
-        const existingList = new Set(curValue?.value?.data);
+        const existingList = new Set(batch.read(this.cacheKey)?.value?.data);
         const toAdd = new Set(
           // easy case. objects are new to the cache and they match this filter
           relevantObjects.added.strictMatches
@@ -830,15 +1117,15 @@ var ListQuery = class extends Query {
         const toRemove = /* @__PURE__ */ new Set();
         for (const obj of relevantObjects.modified.all) {
           if (relevantObjects.modified.strictMatches.has(obj)) {
-            const existingObjectCacheKey = this.store.getCacheKey("object", obj.$apiName, obj.$primaryKey);
-            if (!existingList.has(existingObjectCacheKey)) {
+            const objectCacheKey = this.store.getCacheKey("object", obj.$objectType, obj.$primaryKey);
+            if (!existingList.has(objectCacheKey)) {
               toAdd.add(obj);
             }
             continue;
           } else if (batch.optimisticWrite) {
             continue;
           } else {
-            const existingObjectCacheKey = this.store.getCacheKey("object", obj.$apiName, obj.$primaryKey);
+            const existingObjectCacheKey = this.store.getCacheKey("object", obj.$objectType, obj.$primaryKey);
             toRemove.add(existingObjectCacheKey);
             if (relevantObjects.modified.sortaMatches.has(obj)) {
               needsRevalidation = true;
@@ -850,9 +1137,9 @@ var ListQuery = class extends Query {
           newList.push(key);
         }
         for (const obj of toAdd) {
-          newList.push(this.store.getCacheKey("object", obj.$apiName, obj.$primaryKey));
+          newList.push(this.store.getCacheKey("object", obj.$objectType, obj.$primaryKey));
         }
-        this.updateList(
+        this._updateList(
           newList,
           /* append */
           false,
@@ -861,69 +1148,73 @@ var ListQuery = class extends Query {
         );
       });
       if (needsRevalidation) {
-        changes.modifiedLists.add(this.cacheKey);
-        return this.revalidate(true).then(() => void 0);
+        return this.revalidate(true);
       }
       return void 0;
     } finally {
       if (process.env.NODE_ENV !== "production") {
-        this.logger?.trace({
-          methodName: "#maybeMaybe"
-        }, "in finally");
+        this.logger?.child({
+          methodName: "maybeUpdateAndRevalidate"
+        }).debug("in finally");
       }
     }
   };
-  updateList(objectCacheKeys, append, status, batch) {
-    if (process.env.NODE_ENV !== "production") {
-      this.logger?.trace({
-        methodName: "updateList"
-      }, `{status: ${status}}`, JSON.stringify(objectCacheKeys, null, 2));
-    }
-    const existingList = batch.read(this.cacheKey);
-    if (!batch.optimisticWrite) {
-      if (!append) {
-        for (const objectCacheKey of existingList?.value?.data ?? []) {
-          this.store.release(objectCacheKey);
-          this.#toRelease.delete(objectCacheKey);
+  _extractRelevantObjects(changes) {
+    const relevantObjects = this.#type === "object" ? this.#extractRelevantObjectsForTypeObject(changes) : this.#extractRelevantObjectsForTypeInterface(changes);
+    for (const group of Object.values(relevantObjects)) {
+      for (const obj of group.all ?? []) {
+        const strictMatch = objectSortaMatchesWhereClause(obj, this.#whereClause, true);
+        if (strictMatch) {
+          group.strictMatches.add(obj);
+        } else {
+          const sortaMatch = objectSortaMatchesWhereClause(obj, this.#whereClause, false);
+          if (sortaMatch) {
+            group.sortaMatches.add(obj);
+          }
         }
       }
-      for (const objectCacheKey of objectCacheKeys) {
-        this.#toRelease.add(objectCacheKey);
-        this.store.retain(objectCacheKey);
-      }
     }
-    if (append) {
-      objectCacheKeys = [...existingList?.value?.data ?? [], ...objectCacheKeys];
-    }
-    if (Object.keys(this.#orderBy).length > 0) {
-      if (process.env.NODE_ENV !== "production") {
-        this.logger?.info({
-          methodName: "updateList"
-        }, "Sorting entries");
-        this.logger?.trace({
-          methodName: "updateList"
-        }, DEBUG_ONLY__cacheKeysToString(objectCacheKeys));
+    return relevantObjects;
+  }
+  #extractRelevantObjectsForTypeInterface(changes) {
+    const added = Array.from(changes.addedObjects).filter(([, object]) => {
+      return this.#apiName in object[chunkT4NIFYZS_cjs.ObjectDefRef].interfaceMap;
+    }).map(([, object]) => object.$as(this.#apiName));
+    const modified = Array.from(changes.modifiedObjects).filter(([, object]) => {
+      return this.#apiName in object[chunkT4NIFYZS_cjs.ObjectDefRef].interfaceMap;
+    }).map(([, object]) => object.$as(this.#apiName));
+    return {
+      added: {
+        all: added,
+        strictMatches: /* @__PURE__ */ new Set(),
+        sortaMatches: /* @__PURE__ */ new Set()
+      },
+      modified: {
+        all: modified,
+        strictMatches: /* @__PURE__ */ new Set(),
+        sortaMatches: /* @__PURE__ */ new Set()
       }
-      const sortFns = Object.entries(this.#orderBy).map(([key, order]) => {
-        return (a, b) => {
-          const aValue = a?.[key];
-          const bValue = b?.[key];
-          if (aValue == null && bValue == null) {
-            return 0;
-          }
-          if (aValue == null) {
-            return 1;
-          }
-          if (bValue == null) {
-            return -1;
-          }
-          const m = order === "asc" ? -1 : 1;
-          return aValue < bValue ? m : aValue > bValue ? -m : 0;
-        };
-      });
+    };
+  }
+  #extractRelevantObjectsForTypeObject(changes) {
+    return {
+      added: {
+        all: changes.addedObjects.get(this.cacheKey.otherKeys[API_NAME_IDX]) ?? [],
+        strictMatches: /* @__PURE__ */ new Set(),
+        sortaMatches: /* @__PURE__ */ new Set()
+      },
+      modified: {
+        all: changes.modifiedObjects.get(this.cacheKey.otherKeys[API_NAME_IDX]) ?? [],
+        strictMatches: /* @__PURE__ */ new Set(),
+        sortaMatches: /* @__PURE__ */ new Set()
+      }
+    };
+  }
+  _sortCacheKeys(objectCacheKeys, batch) {
+    if (Object.keys(this.#orderBy).length > 0) {
       objectCacheKeys = objectCacheKeys.sort((a, b) => {
-        for (const sortFn of sortFns) {
-          const ret = sortFn(batch.read(a)?.value, batch.read(b)?.value);
+        for (const sortFn of this.#sortFns) {
+          const ret = sortFn(batch.read(a)?.value?.$as(this.#apiName), batch.read(b)?.value?.$as(this.#apiName));
           if (ret !== 0) {
             return ret;
           }
@@ -931,108 +1222,209 @@ var ListQuery = class extends Query {
         return 0;
       });
     }
-    const visited = /* @__PURE__ */ new Set();
-    objectCacheKeys = objectCacheKeys.filter((key) => {
-      batch.read(key);
-      if (visited.has(key)) {
-        return false;
+    return objectCacheKeys;
+  }
+  registerStreamUpdates(sub) {
+    const logger = process.env.NODE_ENV !== "production" ? this.logger?.child({
+      methodName: "registerStreamUpdates"
+    }) : this.logger;
+    if (process.env.NODE_ENV !== "production") {
+      logger?.child({
+        methodName: "observeList"
+      }).info("Subscribing from websocket");
+    }
+    const websocketSubscription = this.#objectSet.subscribe({
+      onChange: this.#onOswChange.bind(this),
+      onError: this.#onOswError.bind(this),
+      onOutOfDate: this.#onOswOutOfDate.bind(this),
+      onSuccessfulSubscription: this.#onOswSuccessfulSubscription.bind(this)
+    });
+    sub.add(() => {
+      if (process.env.NODE_ENV !== "production") {
+        logger?.child({
+          methodName: "observeList"
+        }).info("Unsubscribing from websocket");
       }
-      visited.add(key);
-      return true;
+      websocketSubscription.unsubscribe();
     });
-    return this.writeToStore({
-      data: objectCacheKeys
-    }, status, batch);
   }
-  writeToStore(data, status, batch) {
+  #onOswSuccessfulSubscription() {
     if (process.env.NODE_ENV !== "production") {
-      this.logger?.trace({
-        methodName: "writeToStore"
-      }, `{status: ${status}},`, DEBUG_ONLY__cacheKeysToString(data.data));
+      this.logger?.child({
+        methodName: "onSuccessfulSubscription"
+      }).debug("");
     }
-    const entry = batch.read(this.cacheKey);
-    if (entry && deepEqual__default.default(data, entry.value)) {
-      return batch.write(this.cacheKey, entry.value, status);
+  }
+  #onOswOutOfDate() {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "onOutOfDate"
+      }).info("");
     }
-    const ret = batch.write(this.cacheKey, data, status);
-    batch.changes.modifiedLists.add(this.cacheKey);
-    return ret;
   }
-  _dispose() {
-    console.log("DISPOSE LIST QUERY");
+  #onOswError(errors) {
+    if (this.logger) {
+      this.logger?.child({
+        methodName: "onError"
+      }).error("subscription errors", errors);
+    }
+  }
+  #onOswChange({
+    object: objOrIface,
+    state
+  }) {
+    const logger = process.env.NODE_ENV !== "production" ? this.logger?.child({
+      methodName: "registerStreamUpdates"
+    }) : this.logger;
+    if (process.env.NODE_ENV !== "production") {
+      logger?.child({
+        methodName: "onChange"
+      }).debug(`Got an update of type: ${state}`, objOrIface);
+    }
+    if (state === "ADDED_OR_UPDATED") {
+      const object = objOrIface.$apiName !== objOrIface.$objectType ? objOrIface.$as(objOrIface.$objectType) : objOrIface;
+      this.store.batch({}, (batch) => {
+        storeOsdkInstances(this.store, [object], batch);
+      });
+    } else if (state === "REMOVED") {
+      this.#onOswRemoved(objOrIface, logger);
+    }
+  }
+  #onOswRemoved(objOrIface, logger) {
     this.store.batch({}, (batch) => {
-      const entry = batch.read(this.cacheKey);
-      if (entry) {
-        for (const objectCacheKey of entry.value?.data ?? []) {
-          this.store.release(objectCacheKey);
+      const existing = batch.read(this.cacheKey);
+      !existing ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "the truth value for our list should exist as we already subscribed") : invariant2__default.default(false) : void 0;
+      if (existing.status === "loaded") {
+        const objectCacheKey = this.store.getCacheKey("object", objOrIface.$objectType, objOrIface.$primaryKey);
+        const newObjects = existing.value?.data.filter((o) => o !== objectCacheKey);
+        if (newObjects?.length !== existing.value?.data.length) {
+          batch.changes.registerList(this.cacheKey);
+          batch.write(this.cacheKey, {
+            data: newObjects ?? []
+          }, "loaded");
         }
+        return;
       }
+      if (process.env.NODE_ENV !== "production") {
+        logger?.info("Removing an object from an object list that is in the middle of being loaded.", existing);
+      }
+      this.revalidate(
+        /* force */
+        true
+      ).catch((e) => {
+        if (logger) {
+          logger?.error("Uncaught error while revalidating list", e);
+        } else {
+          console.error("Uncaught error while revalidating list", e);
+        }
+      });
     });
   }
 };
-function isListCacheKey(cacheKey, apiName) {
-  return cacheKey.type === "list" && (apiName == null || cacheKey.otherKeys[0] === apiName);
+function removeDuplicates(objectCacheKeys, batch) {
+  const visited = /* @__PURE__ */ new Set();
+  objectCacheKeys = objectCacheKeys.filter((key) => {
+    batch.read(key);
+    if (visited.has(key)) {
+      return false;
+    }
+    visited.add(key);
+    return true;
+  });
+  return objectCacheKeys;
 }
-var ObjectQuery = class extends Query {
-  #apiName;
-  #pk;
-  constructor(store, subject, type, pk, cacheKey, opts) {
-    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkJPENHIJB_cjs.additionalContext].logger?.child({}, {
-      msgPrefix: `ObjectQuery<${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>`
-    }) : undefined);
-    this.#apiName = type;
-    this.#pk = pk;
-  }
-  _createConnectable(subject) {
-    return rxjs.connectable(subject.pipe(rxjs.map((x) => {
-      return {
-        status: x.status,
-        object: x.value,
-        lastUpdated: x.lastUpdated,
-        isOptimistic: x.isOptimistic
-      };
-    })), {
-      connector: () => new rxjs.BehaviorSubject({
-        status: "init",
-        object: undefined,
-        lastUpdated: 0,
-        isOptimistic: false
-      })
+function createOrderBySortFns(orderBy) {
+  return Object.entries(orderBy).map(([key, order]) => {
+    return (a, b) => {
+      const aValue = a?.[key];
+      const bValue = b?.[key];
+      if (aValue == null && bValue == null) {
+        return 0;
+      }
+      if (aValue == null) {
+        return 1;
+      }
+      if (bValue == null) {
+        return -1;
+      }
+      const m = order === "asc" ? -1 : 1;
+      return aValue < bValue ? m : aValue > bValue ? -m : 0;
+    };
+  });
+}
+async function reloadDataAsFullObjects(client, data) {
+  const groups = groupBy__default.default(data, (x) => x.$objectType);
+  const objectTypeToPrimaryKeyToObject = Object.fromEntries(await Promise.all(Object.entries(groups).map(async ([apiName, objects]) => {
+    const objectDef = objects[0][chunkT4NIFYZS_cjs.UnderlyingOsdkObject][chunkT4NIFYZS_cjs.ObjectDefRef];
+    const where = {
+      [objectDef.primaryKeyApiName]: {
+        $in: objects.map((x) => x.$primaryKey)
+      }
+    };
+    const result = await client(objectDef).where(where).fetchPage();
+    return [apiName, Object.fromEntries(result.data.map((x) => [x.$primaryKey, x]))];
+  })));
+  data = data.map((obj) => {
+    !objectTypeToPrimaryKeyToObject[obj.$objectType][obj.$primaryKey] ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, `Could not find object ${obj.$objectType} ${obj.$primaryKey}`) : invariant2__default.default(false) : void 0;
+    return objectTypeToPrimaryKeyToObject[obj.$objectType][obj.$primaryKey];
+  });
+  return data;
+}
+function isListCacheKey(cacheKey) {
+  return cacheKey.type === "list";
+}
+var defaultMakeData = () => /* @__PURE__ */ Object.create(null);
+var WeakRefTrie = class {
+  #finalizer = new FinalizationRegistry((orderBy) => {
+    this.#trie.removeArray(Object.entries(orderBy).flat());
+  });
+  #trie;
+  constructor(makeData = defaultMakeData) {
+    this.#trie = new trie.Trie(false, (array) => {
+      const data = makeData(array);
+      this.#finalizer.register(data, array);
+      return new WeakRef(data);
     });
   }
-  async _fetch() {
-    if (process.env.NODE_ENV !== "production") {
-      this.logger?.info({
-        methodName: "_fetch"
-      });
+  lookupArray(array) {
+    const maybe = this.#trie.lookupArray(array);
+    let ret = maybe.deref();
+    if (maybe && !ret) {
+      this.#trie.removeArray(array);
+      ret = this.#trie.lookupArray(array).deref();
     }
-    const objectSet = this.store.client({
-      type: "object",
-      apiName: this.#apiName
-    });
-    const obj = await objectSet.fetchOne(this.#pk);
-    this.store.batch({}, (batch) => {
-      this.writeToStore(obj, "loaded", batch);
-    });
+    return ret;
   }
-  writeToStore(data, status, batch) {
-    if (process.env.NODE_ENV !== "production") {
-      this.logger?.trace({
-        methodName: "writeToStore"
-      }, `{status: ${status}},`, data);
-    }
-    const entry = batch.read(this.cacheKey);
-    if (entry && deepEqual__default.default(data, entry.value)) {
-      return batch.write(this.cacheKey, entry.value, status);
-    }
-    const ret = batch.write(this.cacheKey, data, status);
-    if (entry) {
-      batch.changes.modifiedObjects.set(data.$apiName, data);
-    } else {
-      batch.changes.addedObjects.set(data.$apiName, data);
+  peekArray(array) {
+    const maybe = this.#trie.peekArray(array);
+    const ret = maybe?.deref();
+    if (maybe && !ret) {
+      this.#trie.removeArray(array);
     }
     return ret;
   }
+  removeArray(array) {
+    return this.#trie.removeArray(array)?.deref();
+  }
+};
+var OrderByCanonicalizer = class {
+  #trie = new WeakRefTrie((array) => {
+    const pairs = array.reduce(function(result, _, index, array2) {
+      if (index % 2 === 0 && array2[index] != null) {
+        result.push(array2.slice(index, index + 2));
+      }
+      return result;
+    }, []);
+    let data = Object.fromEntries(pairs);
+    if (process.env.NODE_ENV !== "production") {
+      data = Object.freeze(data);
+    }
+    return data;
+  });
+  canonicalize = (orderBy) => {
+    const strings = Object.entries(orderBy).flat();
+    return this.#trie.lookupArray(strings);
+  };
 };
 
 // src/observable/internal/RefCounts.ts
@@ -1059,8 +1451,8 @@ var RefCounts = class {
     }
   }
   release(key) {
-    const count = this.refCounts.get(key) ?? 0;
-    if (count === 1) {
+    const count = this.refCounts.get(key);
+    if (count === void 0) ; else if (count === 1) {
       this.refCounts.delete(key);
       this.gcMap.set(key, Date.now() + this.keepAlive);
     } else {
@@ -1081,6 +1473,14 @@ var RefCounts = class {
   }
 };
 var WhereClauseCanonicalizer = class {
+  /**
+   * This is a shortcut cache for any WhereClause's that we have
+   * seen and already canonicalized. The theory behind this
+   * is that well behaving React applications will either `useMemo`
+   * their where clause, or store it in state or pass it through as
+   * props such that we are likely to get the same WhereClause
+   * object multiple times and we can skip unnecessary work.
+   */
   #cache = /* @__PURE__ */ new WeakMap();
   /**
    * This is a trie that stores the sorted collapsed keys of a where clause to
@@ -1098,14 +1498,14 @@ var WhereClauseCanonicalizer = class {
       return this.#cache.get(where);
     }
     const keysSet = /* @__PURE__ */ new Set();
-    const tmpCanon = this.#toCanon(where, keysSet);
+    const calculatedCanon = this.#toCanon(where, keysSet);
     const cacheKey = this.#trie.lookupArray(Array.from(keysSet).sort());
     const lookupEntry = this.#existingOptions.get(cacheKey) ?? {
       options: []
     };
     this.#existingOptions.set(cacheKey, lookupEntry);
-    const canon = lookupEntry.options.find((ref) => deepEqual__default.default(ref.deref(), tmpCanon))?.deref() ?? tmpCanon;
-    if (canon === tmpCanon) {
+    const canon = lookupEntry.options.find((ref) => deepEqual__default.default(ref.deref(), calculatedCanon))?.deref() ?? calculatedCanon;
+    if (canon === calculatedCanon) {
       lookupEntry.options.push(new WeakRef(canon));
     }
     this.#cache.set(where, canon);
@@ -1114,8 +1514,8 @@ var WhereClauseCanonicalizer = class {
   #toCanon = (where, set = /* @__PURE__ */ new Set()) => {
     if ("$and" in where) {
       if (process.env.NODE_ENV !== "production") {
-        !Array.isArray(where.$and) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected $and to be an array") : invariant2__default.default(false) : undefined;
-        !(Object.keys(where).length === 1) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected only $and to be present") : invariant2__default.default(false) : undefined;
+        !Array.isArray(where.$and) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected $and to be an array") : invariant2__default.default(false) : void 0;
+        !(Object.keys(where).length === 1) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "expected only $and to be present") : invariant2__default.default(false) : void 0;
       }
       if (where.$and.length === 0) {
         return {};
@@ -1142,36 +1542,28 @@ function createInitEntry(cacheKey) {
   return {
     cacheKey,
     status: "init",
-    value: undefined,
+    value: void 0,
     lastUpdated: 0
   };
 }
-var OrderByCanonicalizer = class {
-  // crappy version
-  #map = /* @__PURE__ */ new Map();
-  canonicalize = (orderBy) => {
-    if (this.#map.has(JSON.stringify(orderBy))) {
-      return this.#map.get(JSON.stringify(orderBy));
-    } else {
-      this.#map.set(JSON.stringify(orderBy), orderBy);
-      return orderBy;
-    }
-  };
-};
 var Store = class {
   whereCanonicalizer = new WhereClauseCanonicalizer();
   orderByCanonicalizer = new OrderByCanonicalizer();
-  #truthLayer = new Layer(undefined, undefined);
+  #truthLayer = new Layer(void 0, void 0);
   #topLayer;
   /** @internal */
-  #queries = new WeakMapWithEntries();
+  // we can use a regular Map here because the refCounting will
+  // handle cleanup.
+  #queries = /* @__PURE__ */ new Map();
   #cacheKeyToSubject = /* @__PURE__ */ new WeakMap();
   #cacheKeys;
   #refCounts = new RefCounts(6e4, (k) => this.#cleanupCacheKey(k));
+  // we are currently only using this for debug logging and should just remove it in the future if that
+  // continues to be true
   #finalizationRegistry;
   constructor(client) {
     this.client = client;
-    this.logger = client[chunkJPENHIJB_cjs.additionalContext].logger?.child({}, {
+    this.logger = client[chunkW5PFESFR_cjs.additionalContext].logger?.child({}, {
       msgPrefix: "Store"
     });
     this.#topLayer = this.#truthLayer;
@@ -1197,7 +1589,7 @@ var Store = class {
     const subject = this.peekSubject(key);
     this.#cacheKeys.remove(key);
     if (process.env.NODE_ENV !== "production") {
-      !subject ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false) : invariant2__default.default(false) : undefined;
+      !subject ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false) : invariant2__default.default(false) : void 0;
     }
     if (subject) {
       subject.complete();
@@ -1206,11 +1598,11 @@ var Store = class {
     this.#queries.get(key)?.dispose();
     this.#queries.delete(key);
   };
-  applyAction = (action, args, opts) => {
-    return new ActionApplication(this).applyAction(action, args, opts);
+  applyAction = async (action, args, opts) => {
+    return await new ActionApplication(this).applyAction(action, args, opts);
   };
   removeLayer(layerId) {
-    !(layerId != null) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "undefined is the reserved layerId for the truth layer") : invariant2__default.default(false) : undefined;
+    !(layerId != null) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "undefined is the reserved layerId for the truth layer") : invariant2__default.default(false) : void 0;
     let currentLayer = this.#topLayer;
     const cacheKeys = /* @__PURE__ */ new Map();
     while (currentLayer != null && currentLayer.parentLayer != null) {
@@ -1253,14 +1645,18 @@ var Store = class {
     }
     return subject;
   };
+  canonicalizeWhereClause(where) {
+    return this.whereCanonicalizer.canonicalize(where);
+  }
   observeObject(apiName, pk, options, subFn) {
     if (typeof apiName !== "string") {
       apiName = apiName.apiName;
     }
     const query = this.getObjectQuery(apiName, pk);
-    this.#refCounts.retain(query.cacheKey);
+    this.retain(query.cacheKey);
     if (options.mode !== "offline") {
       query.revalidate(options.mode === "force").catch((e) => {
+        subFn.error(e);
         if (this.logger) {
           this.logger.error("Unhandled error in observeObject", e);
         } else {
@@ -1268,145 +1664,54 @@ var Store = class {
         }
       });
     }
-    const sub = query.subscribe({
-      next: subFn
-    });
+    const sub = query.subscribe(subFn);
     return {
       unsubscribe: () => {
         sub.unsubscribe();
-        this.#refCounts.release(query.cacheKey);
+        this.release(query.cacheKey);
       }
     };
   }
   observeList(options, subFn) {
-    const query = this.getListQuery(options.objectType, options.where ?? {}, options.orderBy ?? {}, options);
-    this.#refCounts.retain(query.cacheKey);
+    const query = this.getListQuery(options.type, options.where ?? {}, options.orderBy ?? {}, options);
+    this.retain(query.cacheKey);
     if (options.mode !== "offline") {
-      void query.revalidate(options.mode === "force");
+      query.revalidate(options.mode === "force").catch((x) => {
+        subFn.error(x);
+      });
     }
-    const sub = query.subscribe({
-      next: subFn
-    });
+    const sub = query.subscribe(subFn);
     if (options.streamUpdates) {
-      const miniDef = {
-        type: "object",
-        apiName: typeof options.objectType === "string" ? options.objectType : options.objectType.apiName
-      };
-      let objectSet = this.client(miniDef);
-      if (options.where) {
-        objectSet = objectSet.where(options.where ?? {});
-      }
-      const store = this;
-      const websocketSubscription = objectSet.subscribe({
-        onChange({
-          object,
-          state
-        }) {
-          if (process.env.NODE_ENV !== "production") {
-            store.logger?.debug({
-              methodName: "onError"
-            }, "updates", state, object);
-          }
-          const cacheKey = store.getCacheKey("object", object.$objectType, object.$primaryKey);
-          const type = store.#peekQuery(cacheKey) == null ? "addedObjects" : "modifiedObjects";
-          const changes = createChangedObjects();
-          changes[type].set(object.$objectType, object);
-          if (state === "ADDED_OR_UPDATED") {
-            store.updateObject(object.$objectType, object);
-            store.maybeRevalidateLists(changes).catch((err) => {
-              console.error("Unhandled error in maybeRevalidateLists", err);
-            });
-          } else if (state === "REMOVED") {
-            const changes2 = createChangedObjects();
-            store.batch({
-              changes: changes2
-            }, (batch) => {
-              const existing = batch.read(query.cacheKey);
-              const cacheKeyToRemove = store.getCacheKey("object", object.$objectType, object.$primaryKey);
-              if (existing?.status === "loaded") {
-                const newObjects = existing.value?.data.filter((o) => o !== cacheKeyToRemove);
-                if (newObjects?.length !== existing.value?.data.length) {
-                  batch.changes.modifiedLists.add(query.cacheKey);
-                  batch.write(query.cacheKey, {
-                    data: newObjects ?? []
-                  }, "loaded");
-                }
-              } else {
-                if (process.env.NODE_ENV !== "production") {
-                  store.logger?.info("Removing an object from an object list that is in the middle of being loaded.", existing);
-                }
-                query.revalidate(
-                  /* force */
-                  true
-                ).catch((e) => {
-                  if (store.logger) {
-                    store.logger?.error("Uncaught error while revalidating list", e);
-                  } else {
-                    console.error("Uncaught error while revalidating list", e);
-                  }
-                });
-              }
-            });
-          }
-        },
-        onError(errors) {
-          if (process.env.NODE_ENV !== "production") {
-            store.logger?.info({
-              methodName: "onError"
-            }, "subscription errors", errors);
-          }
-        },
-        onOutOfDate() {
-          if (process.env.NODE_ENV !== "production") {
-            store.logger?.info({
-              methodName: "onOutOfDate"
-            });
-          }
-        },
-        onSuccessfulSubscription() {
-          if (process.env.NODE_ENV !== "production") {
-            store.logger?.info({
-              methodName: "onSuccessfulSubscription"
-            });
-          }
-        }
-      });
-      sub.add(() => {
-        if (process.env.NODE_ENV !== "production") {
-          store.logger?.info({
-            methodName: "observeList"
-          }, "Unsubscribing from websocket");
-        }
-        websocketSubscription.unsubscribe();
-      });
+      query.registerStreamUpdates(sub);
     }
     return {
       unsubscribe: () => {
         sub.unsubscribe();
-        this.#refCounts.release(query.cacheKey);
+        this.release(query.cacheKey);
       }
     };
   }
-  #peekQuery(cacheKey) {
+  peekQuery(cacheKey) {
     return this.#queries.get(cacheKey);
   }
   #getQuery(cacheKey, createQuery) {
-    let query = this.#peekQuery(cacheKey);
+    let query = this.peekQuery(cacheKey);
     if (!query) {
       query = createQuery();
       this.#queries.set(cacheKey, query);
     }
     return query;
   }
-  getListQuery(apiName, where, orderBy, opts) {
-    if (typeof apiName !== "string") {
-      apiName = apiName.apiName;
-    }
+  getListQuery(def, where, orderBy, opts) {
+    const {
+      apiName,
+      type
+    } = def;
     const canonWhere = this.whereCanonicalizer.canonicalize(where);
     const canonOrderBy = this.orderByCanonicalizer.canonicalize(orderBy);
-    const listCacheKey = this.getCacheKey("list", apiName, canonWhere, canonOrderBy);
+    const listCacheKey = this.getCacheKey("list", type, apiName, canonWhere, canonOrderBy);
     return this.#getQuery(listCacheKey, () => {
-      return new ListQuery(this, this.getSubject(listCacheKey), apiName, canonWhere, canonOrderBy, listCacheKey, opts);
+      return new ListQuery(this, this.getSubject(listCacheKey), type, apiName, canonWhere, canonOrderBy, listCacheKey, opts);
     });
   }
   getObjectQuery(apiName, pk) {
@@ -1418,20 +1723,15 @@ var Store = class {
       dedupeInterval: 0
     }));
   }
-  getObject(apiName, pk) {
-    if (typeof apiName !== "string") {
-      apiName = apiName.apiName;
-    }
-    const objectCacheKey = this.getCacheKey("object", apiName, pk);
-    const objEntry = this.#topLayer.get(objectCacheKey);
-    return objEntry?.value;
+  getValue(cacheKey) {
+    return this.#topLayer.get(cacheKey);
   }
   batch = ({
     optimisticId,
     changes = createChangedObjects()
   }, batchFn) => {
-    !(optimisticId === undefined || !!optimisticId) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "optimistic must be undefined or not falsy") : invariant2__default.default(false) : undefined;
-    let needsLayer = optimisticId !== undefined;
+    !(optimisticId === void 0 || !!optimisticId) ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false, "optimistic must be undefined or not falsy") : invariant2__default.default(false) : void 0;
+    let needsLayer = optimisticId !== void 0;
     const batchContext = {
       changes,
       createLayerIfNeeded: () => {
@@ -1462,64 +1762,60 @@ var Store = class {
       }
     };
     const retVal = batchFn(batchContext);
-    void this.maybeUpdateLists(changes, optimisticId);
+    this.maybeRevalidateQueries(changes, optimisticId).catch((e) => {
+      if (this.logger) {
+        this.logger.error("Unhandled error in batch", e);
+      } else {
+        console.error("Unhandled error in batch", e);
+        throw e;
+      }
+    });
     return {
       batchResult: batchContext,
-      retVal
+      retVal,
+      changes: batchContext.changes
     };
   };
   invalidateObject(apiName, pk) {
     if (typeof apiName !== "string") {
       apiName = apiName.apiName;
     }
-    const query = this.getObjectQuery(apiName, pk);
-    return query.revalidate(true);
+    return this.getObjectQuery(apiName, pk).revalidate(
+      /* force */
+      true
+    );
   }
-  async maybeRevalidateLists(changes) {
+  async maybeRevalidateQueries(changes, optimisticId) {
+    if (changes.isEmpty()) {
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.child({
+          methodName: "maybeRevalidateQueries"
+        }).debug("No changes, aborting");
+      }
+      return;
+    }
     if (process.env.NODE_ENV !== "production") {
-      this.logger?.trace({
-        methodName: "maybeRevalidateList"
-      }, DEBUG_ONLY__changesToString(changes));
+      this.logger?.child({
+        methodName: "maybeRevalidateQueries"
+      }).debug(DEBUG_ONLY__changesToString(changes), {
+        optimisticId
+      });
     }
     try {
       const promises = [];
-      for (const [cacheKey, v] of this.#truthLayer.entries()) {
-        if (isListCacheKey(cacheKey)) {
-          const promise = this.#peekQuery(cacheKey)?.maybeUpdateAndRevalidate(changes, void 0);
-          if (promise) promises.push(promise);
-        }
+      for (const cacheKey of this.#queries.keys()) {
+        const promise = this.peekQuery(cacheKey)?.maybeUpdateAndRevalidate?.(changes, optimisticId);
+        if (promise) promises.push(promise);
       }
       await Promise.all(promises);
     } finally {
       if (process.env.NODE_ENV !== "production") {
-        this.logger?.trace({
-          methodName: "maybeRevalidateList"
-        }, "in finally", DEBUG_ONLY__changesToString(changes));
+        this.logger?.child({
+          methodName: "maybeRevalidateQueries"
+        }).debug("in finally", DEBUG_ONLY__changesToString(changes));
       }
     }
   }
-  maybeUpdateLists(changes, optimisticId) {
-    if (process.env.NODE_ENV !== "production") {
-      this.logger?.trace({
-        methodName: "maybeUpdateLists"
-      }, DEBUG_ONLY__changesToString(changes), {
-        optimisticId
-      });
-    }
-    if (changes.addedObjects.size === 0 && changes.modifiedObjects.size === 0) {
-      return Promise.resolve([]);
-    }
-    const promises = [];
-    for (const cacheKey of this.#queries.keys()) {
-      if (isListCacheKey(cacheKey)) {
-        if (!changes.modifiedLists.has(cacheKey)) {
-          const promise = this.#peekQuery(cacheKey)?.maybeUpdateAndRevalidate(changes, optimisticId);
-          if (promise) promises.push(promise);
-        }
-      }
-    }
-    return Promise.all(promises);
-  }
   /**
    * @param apiName
    * @param changes The changes we know about / to update
@@ -1530,90 +1826,23 @@ var Store = class {
       apiName = apiName.apiName;
     }
     if (process.env.NODE_ENV !== "production") {
-      this.logger?.info({
+      this.logger?.child({
         methodName: "invalidateObjectType"
-      }, changes ? DEBUG_ONLY__changesToString(changes) : undefined);
+      }).info(changes ? DEBUG_ONLY__changesToString(changes) : void 0);
     }
     const promises = [];
-    for (const [cacheKey, v] of this.#truthLayer.entries()) {
-      if (isListCacheKey(cacheKey, apiName)) {
-        if (!changes || !changes.modifiedLists.has(cacheKey)) {
-          const promise = this.#peekQuery(cacheKey)?.revalidate(true);
+    for (const cacheKey of this.#truthLayer.keys()) {
+      if (isListCacheKey(cacheKey)) {
+        if (!changes || !changes.modified.has(cacheKey)) {
+          const promise = this.peekQuery(cacheKey)?.revalidate(true);
           if (promise) {
             promises.push(promise);
-            changes?.modifiedLists.add(cacheKey);
+            changes?.modified.add(cacheKey);
           }
         }
       }
     }
-    return Promise.all(promises);
-  }
-  invalidateList({
-    objectType,
-    where,
-    orderBy
-  }) {
-    if (typeof objectType !== "string") {
-      objectType = objectType.apiName;
-    }
-    where = this.whereCanonicalizer.canonicalize(where ?? {});
-    orderBy = this.orderByCanonicalizer.canonicalize(orderBy ?? {});
-    const cacheKey = this.getCacheKey("list", objectType, where, orderBy);
-    void this.#peekQuery(cacheKey)?.revalidate(true);
-  }
-  updateObject(apiName, value, {
-    optimisticId
-  } = {}) {
-    if (typeof apiName !== "string") {
-      apiName = apiName.apiName;
-    }
-    const query = this.getObjectQuery(apiName, value.$primaryKey);
-    return this.batch({
-      optimisticId
-    }, (batch) => {
-      return query.writeToStore(value, "loaded", batch);
-    }).retVal.value;
-  }
-  updateObjects(values, batch) {
-    return values.map((v) => {
-      return this.getObjectQuery(v.$apiName, v.$primaryKey).writeToStore(v, "loaded", batch).cacheKey;
-    });
-  }
-  /**
-   * Updates the internal state of a list and will create a new internal query if needed.
-   *
-   * Helper method only for tests right now. May be removed later.
-   *
-   * @param apiName
-   * @param where
-   * @param orderBy
-   * @param objects
-   * @param param4
-   * @param opts
-   */
-  updateList({
-    objectType: apiName,
-    where,
-    orderBy
-  }, objects, {
-    optimisticId
-  } = {}, opts = {
-    dedupeInterval: 0
-  }) {
-    if (process.env.NODE_ENV !== "production") {
-      this.logger?.info({
-        methodName: "updateList"
-      }, "", {
-        optimisticId
-      });
-    }
-    const query = this.getListQuery(apiName, where ?? {}, orderBy ?? {}, opts);
-    this.batch({
-      optimisticId
-    }, (batch) => {
-      const objectCacheKeys = this.updateObjects(objects, batch);
-      query.updateList(objectCacheKeys, false, "loaded", batch);
-    });
+    return Promise.all(promises).then(() => void 0);
   }
   retain(cacheKey) {
     this.#refCounts.retain(cacheKey);
@@ -1628,10 +1857,46 @@ function createObservableClient(client) {
   return new ObservableClientImpl(new Store(client));
 }
 
+// src/public-utils/osdkConfig.ts
+function getMetaTagContent(name) {
+  const element = document.querySelector(`meta[name="${name}"]`);
+  const val = element ? element.getAttribute("content") : null;
+  if (val == null) {
+    throw new Error(`Missing meta tag: ${name}`);
+  }
+  return val;
+}
+function getViteEnvVar(name) {
+  const val = undefined[name];
+  if (val == null) {
+    throw new Error(`Missing environment variable: ${name}`);
+  }
+  return val;
+}
+function isProduction() {
+  return process.env.NODE_ENV === "production";
+}
+function getConfigValue(metaTagName, viteEnvVarName) {
+  return isProduction() ? getMetaTagContent(metaTagName) : getViteEnvVar(viteEnvVarName);
+}
+function getOntologyRid(ontologyRid) {
+  return isProduction() ? getMetaTagContent("osdk-ontologyRid") : ontologyRid;
+}
+function getOsdkConfig(ontologyRid) {
+  return {
+    clientId: getConfigValue("osdk-clientId", "VITE_FOUNDRY_CLIENT_ID"),
+    redirectUrl: getConfigValue("osdk-redirectUrl", "VITE_FOUNDRY_REDIRECT_URL"),
+    foundryUrl: getConfigValue("osdk-foundryUrl", "VITE_FOUNDRY_API_URL"),
+    ontologyRid: getOntologyRid(ontologyRid)
+  };
+}
+
 Object.defineProperty(exports, "augment", {
   enumerable: true,
-  get: function () { return chunkJPENHIJB_cjs.augment; }
+  get: function () { return chunkW5PFESFR_cjs.augment; }
 });
 exports.createObservableClient = createObservableClient;
+exports.getMetaTagContent = getMetaTagContent;
+exports.getOsdkConfig = getOsdkConfig;
 //# sourceMappingURL=unstable-do-not-use.cjs.map
 //# sourceMappingURL=unstable-do-not-use.cjs.map