@osdk/client 2.1.1 → 2.2.0-beta.10

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

@@ -1,38 +1,38 @@
 'use strict';
 
-var chunkFWVJ2AKD_cjs = require('../chunk-FWVJ2AKD.cjs');
+var chunkT4NIFYZS_cjs = require('../chunk-T4NIFYZS.cjs');
+var chunkEY52J5Z4_cjs = require('../chunk-EY52J5Z4.cjs');
 require('../chunk-Q7SFCCGT.cjs');
 var rxjs = require('rxjs');
 var invariant2 = require('tiny-invariant');
-var trie = require('@wry/trie');
 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(apiName, where, options, subFn) {
-    return this.#store.observeList(apiName, where, 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);
   }
 };
 
+// src/observable/DebugFlags.ts
+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") {
@@ -48,7 +48,7 @@ function isNodeProcess() {
   return false;
 }
 
-// ../../node_modules/.pnpm/msw@2.7.0_@types+node@22.13.1_typescript@5.5.4/node_modules/msw/lib/core/delay.mjs
+// ../../node_modules/.pnpm/msw@2.7.3_@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;
@@ -86,9 +86,213 @@ async function delay(durationOrMode) {
   return new Promise((resolve) => setTimeout(resolve, delayTime));
 }
 
-// src/observable/DebugFlags.ts
-process.env.NODE_ENV !== "production" && false;
-var DEBUG_CACHE_KEYS = process.env.NODE_ENV !== "production" && false;
+// src/observable/internal/CacheKey.ts
+function DEBUG_ONLY__cacheKeyToString(x) {
+  if (process.env.NODE_ENV !== "production") {
+    return `${x.type}CacheKey<${x.otherKeys.map((xx) => JSON.stringify(xx)).join(", ")}>`.replaceAll('"', "'");
+  } else {
+    throw new Error("not implemented");
+  }
+}
+function DEBUG_ONLY__cacheKeysToString(x) {
+  if (process.env.NODE_ENV !== "production") {
+    return "\n  - " + x.map(DEBUG_ONLY__cacheKeyToString).join("\n  - ");
+  } else {
+    throw new Error("not implemented");
+  }
+}
+
+// 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),
+      added: listHelper(changes.added),
+      modified: listHelper(changes.modified)
+    }, null, 2);
+  } else {
+    throw new Error("not implemented");
+  }
+}
+function listHelper(set) {
+  return Array.from(set).map(DEBUG_ONLY__cacheKeyToString);
+}
+function multimapHelper(multimap) {
+  return Object.fromEntries(Array.from(multimap.associations()).map(([type, objects]) => {
+    return [type, objects.map((o) => o.$primaryKey)];
+  }));
+}
+
+// src/observable/internal/OptimisticId.ts
+function createOptimisticId() {
+  if (process.env.NODE_ENV !== "production") {
+    if (createOptimisticId.counter === undefined) {
+      createOptimisticId.counter = 0;
+    }
+    return {
+      __optimisticId: createOptimisticId.counter++
+    };
+  }
+  return /* @__PURE__ */ Object.create(null);
+}
+
+// src/observable/internal/OptimisticJob.ts
+var OptimisticJob = class {
+  #result;
+  constructor(store, optimisticId) {
+    const updatedObjects = [];
+    const addedObjectPromises = [];
+    this.getResult = () => {
+      return this.#result ??= (async () => {
+        const addedObjects = await Promise.allSettled(addedObjectPromises);
+        const {
+          batchResult
+        } = store.batch({
+          optimisticId
+        }, (batch) => {
+          for (const obj of addedObjects) {
+            if (obj.status === "fulfilled") {
+              store.getObjectQuery(obj.value.$objectType, obj.value.$primaryKey).writeToStore(obj.value, "loading", batch);
+            } else {
+              throw obj;
+            }
+          }
+          for (const obj of updatedObjects) {
+            store.getObjectQuery(obj.$objectType, obj.$primaryKey).writeToStore(obj, "loading", batch);
+          }
+        });
+        return batchResult.changes;
+      })();
+    };
+    this.context = {
+      updateObject(value) {
+        updatedObjects.push(value);
+        return this;
+      },
+      createObject(type, pk, properties) {
+        const create = store.client[chunkEY52J5Z4_cjs.additionalContext].objectFactory2(store.client[chunkEY52J5Z4_cjs.additionalContext], [{
+          $primaryKey: pk,
+          $apiName: type.apiName,
+          $objectType: type.apiName,
+          ...properties
+        }], undefined).then((objs) => {
+          return objs[0];
+        });
+        addedObjectPromises.push(create);
+        return this;
+      }
+    };
+  }
+};
+function runOptimisticJob(store, optimisticUpdate) {
+  if (!optimisticUpdate) {
+    return () => Promise.resolve();
+  }
+  const optimisticId = createOptimisticId();
+  const job = new OptimisticJob(store, optimisticId);
+  optimisticUpdate(job.context);
+  const optimisticApplicationDone = job.getResult();
+  return () => {
+    return optimisticApplicationDone.then(
+      // we don't want to leak the result
+      () => undefined
+    ).finally(() => {
+      store.removeLayer(optimisticId);
+    });
+  };
+}
+
+// src/observable/internal/ActionApplication.ts
+var ACTION_DELAY = process.env.NODE_ENV === "production" ? 0 : 1e3;
+var ActionApplication = class {
+  constructor(store) {
+    this.store = store;
+  }
+  applyAction = (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 () => {
+      try {
+        const actionResults = await this.store.client(action).applyAction(args, {
+          $returnEdits: true
+        });
+        if (process.env.NODE_ENV !== "production") {
+          if (ACTION_DELAY > 0) {
+            logger?.debug("action done, pausing");
+            await delay(ACTION_DELAY);
+            logger?.debug("action done, pausing done");
+          }
+        }
+        await this.#invalidateActionEditResponse(actionResults);
+        return actionResults;
+      } finally {
+        if (process.env.NODE_ENV !== "production") {
+          logger?.debug("optimistic action complete; remove the results");
+        }
+        await removeOptimisticResult();
+      }
+    })();
+  };
+  #invalidateActionEditResponse = async (value) => {
+    const typesToInvalidate = /* @__PURE__ */ new Set();
+    let changes;
+    if (value.type === "edits") {
+      const promisesToWait = [];
+      for (const obj of value.modifiedObjects) {
+        promisesToWait.push(this.store.invalidateObject(obj.objectType, obj.primaryKey));
+      }
+      for (const obj of value.addedObjects) {
+        promisesToWait.push(this.store.invalidateObject(obj.objectType, obj.primaryKey));
+        typesToInvalidate.add(obj.objectType);
+      }
+      await Promise.all(promisesToWait);
+      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());
+        await this.store.invalidateObjectType(apiName, changes);
+      }
+    }
+    return value;
+  };
+};
 var CacheKeys = class {
   #cacheKeys = new trie.Trie(false, (keys) => {
     const ret = {
@@ -100,15 +304,15 @@ var CacheKeys = class {
   });
   #cacheKeyFactories = /* @__PURE__ */ new Map();
   #onCreate;
-  constructor(whereCanonicalizer, onCreate) {
+  constructor(whereCanonicalizer, orderByCanonicalizer, onCreate) {
     this.#onCreate = onCreate;
     this.#registerCacheKeyFactory("object", (apiName, pk) => {
       if (process.env.NODE_ENV !== "production" && DEBUG_CACHE_KEYS) ;
       return this.#cacheKeys.lookupArray(["object", apiName, pk]);
     });
-    this.#registerCacheKeyFactory("list", (apiName, where) => {
+    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)]);
+      return this.#cacheKeys.lookupArray(["list", type, apiName, whereCanonicalizer.canonicalize(where), orderByCanonicalizer.canonicalize(orderBy)]);
     });
   }
   #registerCacheKeyFactory(type, factory) {
@@ -123,12 +327,6 @@ var CacheKeys = class {
     this.#cacheKeys.remove(cacheKey.type, ...cacheKey.otherKeys);
   }
 };
-function createChangedObjects() {
-  return {
-    modifiedObjects: new mnemonist.MultiMap(),
-    addedObjects: new mnemonist.MultiMap()
-  };
-}
 
 // src/observable/internal/WeakMapWithEntries.ts
 var WeakMapWithEntries = class {
@@ -262,11 +460,14 @@ var Layer = class _Layer {
       this.#parent = this.#parent.removeLayer(layerId);
       return this;
     }
-    return this.#parent ?? this;
+    return this.#parent.removeLayer(layerId);
   }
   entries() {
     return this.#cache.entries();
   }
+  keys() {
+    return this.#cache.keys();
+  }
   get(cacheKey) {
     return this.#cache.get(cacheKey) ?? this.#parent?.get(cacheKey);
   }
@@ -275,11 +476,11 @@ var Layer = class _Layer {
   }
 };
 var Entry = class {
-  constructor(cacheKey, value, lastUpdated) {
+  constructor(cacheKey, value, lastUpdated, status = "init") {
     this.cacheKey = cacheKey;
     this.value = value;
     this.lastUpdated = lastUpdated;
-    this.status = "init";
+    this.status = status;
   }
 };
 function is$and(whereClause) {
@@ -368,46 +569,172 @@ 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: undefined
+  }));
+  #logger;
+  #maxWait;
+  #maxEntries;
+  constructor(client, maxWait = 25, maxEntries = 100) {
+    this.#client = client;
+    this.#logger = client[chunkEY52J5Z4_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;
   #connectable;
   #subscription;
   #subject;
-  constructor(store, observable, opts, cacheKey) {
+  /** @internal */
+  constructor(store, observable, opts, cacheKey, logger) {
     this.options = opts;
     this.cacheKey = cacheKey;
     this.store = store;
     this.#subject = observable;
+    this.logger = logger ?? (process.env.NODE_ENV === "production" ? store.client[chunkEY52J5Z4_cjs.additionalContext].logger : store.client[chunkEY52J5Z4_cjs.additionalContext].logger?.child({}, {
+      msgPrefix: process.env.NODE_ENV !== "production" ? `Query<${cacheKey.type}, ${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>` : "Query"
+    }));
   }
   subscribe(observer) {
     this.#connectable ??= this._createConnectable(this.#subject);
     this.#subscription = this.#connectable.connect();
     return this.#connectable.subscribe(observer);
   }
-  revalidate(force) {
+  /**
+   * 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") {
+        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();
-    this.pendingFetch = this._fetch().finally(() => {
+    if (process.env.NODE_ENV !== "production") {
+      logger?.debug("calling _fetchAndStore()");
+    }
+    this.pendingFetch = this._fetchAndStore().finally(() => {
+      logger?.info("finally _fetchAndStore()");
       this.pendingFetch = undefined;
     });
-    return this.pendingFetch;
+    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?.child({
+        methodName: "setStatus"
+      }).debug(status);
+    }
     const existing = batch.read(this.cacheKey);
     if (existing?.status === status) return;
     batch.write(this.cacheKey, existing?.value, status);
@@ -419,69 +746,250 @@ 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/ListQuery.ts
-rxjs.auditTime(0);
-var ListQuery = class extends Query {
-  // pageSize?: number; // this is the internal page size. we need to track this properly
-  #client;
-  #type;
-  #whereClause;
-  // this represents the minimum number of results we need to load if we revalidate
-  #minNumResults = 0;
-  #nextPageToken;
-  #pendingPageFetch;
-  #toRelease = /* @__PURE__ */ new Set();
-  constructor(store, subject, type, whereClause, cacheKey, opts) {
-    super(store, subject, opts, cacheKey);
-    this.#client = store.client;
-    this.#type = type;
-    this.#whereClause = whereClause;
-    rxjs.observeOn(rxjs.asyncScheduler);
+// 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[chunkEY52J5Z4_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.mergeMap((listEntry) => {
-        return rxjs.combineLatest({
-          resolvedList: listEntry?.value?.data == null ? rxjs.of([]) : rxjs.combineLatest(listEntry.value.data.map((cacheKey) => this.store.getSubject(cacheKey).pipe(rxjs.map((objectEntry) => objectEntry?.value)))),
-          isOptimistic: rxjs.of(listEntry.isOptimistic),
-          fetchMore: rxjs.of(this.fetchMore),
-          hasMore: rxjs.of(this.#nextPageToken != null),
-          status: rxjs.of(listEntry.status),
-          lastUpdated: rxjs.of(listEntry.lastUpdated)
-        });
-      }),
-      // like throttle but returns the tail
-      rxjs.auditTime(0)
-    ), {
-      resetOnDisconnect: false,
-      connector: () => new rxjs.ReplaySubject(1)
+    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
+      })
     });
   }
-  _preFetch() {
-    this.#nextPageToken = undefined;
-  }
-  async _fetch() {
-    const objectSet = this.#client({
-      type: "object",
-      apiName: this.#type
-    }).where(this.#whereClause);
-    while (true) {
-      const entry = await this.#fetchPageAndUpdate(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;
-      const count = entry.value.data.length;
-      if (count > this.#minNumResults || this.#nextPageToken == null) {
-        break;
-      }
+  async _fetchAndStore() {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "_fetchAndStore"
+      }).info("calling fetchOne");
     }
+    const obj = await getBulkObjectLoader(this.store.client).fetch(this.#apiName, this.#pk);
     this.store.batch({}, (batch) => {
-      this.setStatus("loaded", 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 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
+  #type;
+  #apiName;
+  #whereClause;
+  // this represents the minimum number of results we need to load if we revalidate
+  #minNumResults = 0;
+  #nextPageToken;
+  #pendingPageFetch;
+  #orderBy;
+  #objectSet;
+  #sortFns;
+  constructor(store, subject, apiType, apiName, whereClause, orderBy, cacheKey, opts) {
+    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkEY52J5Z4_cjs.additionalContext].logger?.child({}, {
+      msgPrefix: `ListQuery<${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>`
+    }) : undefined);
+    this.#type = apiType;
+    this.#apiName = apiName;
+    this.#whereClause = whereClause;
+    this.#orderBy = orderBy;
+    this.#objectSet = store.client({
+      type: this.#type,
+      apiName: this.#apiName
+    }).where(this.#whereClause);
+    this.#sortFns = createOrderBySortFns(this.#orderBy);
+  }
+  get canonicalWhere() {
+    return this.#whereClause;
+  }
+  _createConnectable(subject) {
+    return rxjs.connectable(subject.pipe(
+      rxjs.switchMap((listEntry) => {
+        return rxjs.combineLatest({
+          resolvedList: listEntry?.value?.data == null ? rxjs.of([]) : rxjs.combineLatest(listEntry.value.data.map((cacheKey) => this.store.getSubject(cacheKey).pipe(rxjs.map((objectEntry) => objectEntry?.value)))),
+          isOptimistic: rxjs.of(listEntry.isOptimistic),
+          fetchMore: rxjs.of(this.fetchMore),
+          hasMore: rxjs.of(this.#nextPageToken != null),
+          status: rxjs.of(listEntry.status),
+          lastUpdated: rxjs.of(listEntry.lastUpdated)
+        });
+      }),
+      // like throttle but returns the tail
+      rxjs.auditTime(0)
+    ), {
+      resetOnDisconnect: false,
+      connector: () => new rxjs.ReplaySubject(1)
+    });
+  }
+  _preFetch() {
+    this.#nextPageToken = undefined;
+  }
+  async _fetchAndStore() {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "_fetchAndStore"
+      }).info("fetching pages");
+    }
+    while (true) {
+      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;
+      const count = entry.value.data.length;
+      if (count > this.#minNumResults || this.#nextPageToken == null) {
+        break;
+      }
+    }
+    this.store.batch({}, (batch) => {
+      this.setStatus("loaded", batch);
     });
     return Promise.resolve();
   }
@@ -502,271 +1010,421 @@ 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.pendingFetch = this.#fetchPageAndUpdate(this.#objectSet, "loaded", this.abortController?.signal).finally(() => {
       this.#pendingPageFetch = undefined;
     });
     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
-    });
-    if (signal?.aborted) {
-      return;
+    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);
     }
-    this.#nextPageToken = nextPageToken;
-    const {
-      retVal
-    } = this.store.batch({}, (batch) => {
-      return this.updateList(data, append, nextPageToken ? status : "loaded", batch);
-    });
-    return retVal;
   }
   /**
-   * Caller is responsible for removing the layer
+   * Will revalidate the list if its query is affected by invalidating the
+   * apiName of the object type passed in.
    *
-   * @param changedObjects
-   * @param optimisticId
+   * @param apiName to invalidate
    * @returns
    */
-  maybeUpdate(changedObjects, optimisticId) {
-    let needsRevalidation = false;
-    const objectsToInsert = [];
-    for (const [type, objects] of changedObjects.addedObjects.associations()) {
-      if (this.cacheKey.otherKeys[0] !== type) {
-        continue;
+  revalidateObjectType = async (apiName) => {
+    if (this.#type === "object") {
+      if (this.#apiName === apiName) {
+        await this.revalidate(
+          /* force */
+          true
+        );
+        return;
+      } else {
+        return;
       }
-      for (const obj of objects) {
+    }
+    const objectMetadata = await this.store.client.fetchMetadata({
+      type: "object",
+      apiName
+    });
+    if (this.#apiName in objectMetadata.interfaceMap) {
+      await this.revalidate(
+        /* force */
+        true
+      );
+      return;
+    }
+  };
+  /**
+   * Note: This method is not async because I want it to return right after it
+   *       finishes the synchronous updates. The promise that is returned
+   *       will resolve after the revalidation is complete.
+   * @param changes
+   * @param optimisticId
+   * @returns If revalidation is needed, a promise that resolves after the
+   *          revalidation is complete. Otherwise, undefined.
+   */
+  maybeUpdateAndRevalidate = (changes, optimisticId) => {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "maybeUpdateAndRevalidate"
+      }).debug(DEBUG_ONLY__changesToString(changes));
+    }
+    if (changes.modified.has(this.cacheKey)) return;
+    changes.modified.add(this.cacheKey);
+    try {
+      const relevantObjects = this._extractRelevantObjects(changes);
+      if (relevantObjects.added.all.length === 0 && relevantObjects.modified.all.length === 0) {
+        return;
+      }
+      const status = optimisticId || relevantObjects.added.sortaMatches.size > 0 || relevantObjects.modified.sortaMatches.size > 0 ? "loading" : "loaded";
+      const newList = [];
+      let needsRevalidation = false;
+      this.store.batch({
+        optimisticId,
+        changes
+      }, (batch) => {
+        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
+        );
+        const toRemove = /* @__PURE__ */ new Set();
+        for (const obj of relevantObjects.modified.all) {
+          if (relevantObjects.modified.strictMatches.has(obj)) {
+            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.$objectType, obj.$primaryKey);
+            toRemove.add(existingObjectCacheKey);
+            if (relevantObjects.modified.sortaMatches.has(obj)) {
+              needsRevalidation = true;
+            }
+          }
+        }
+        for (const key of existingList) {
+          if (toRemove.has(key)) continue;
+          newList.push(key);
+        }
+        for (const obj of toAdd) {
+          newList.push(this.store.getCacheKey("object", obj.$objectType, obj.$primaryKey));
+        }
+        this._updateList(
+          newList,
+          /* append */
+          false,
+          status,
+          batch
+        );
+      });
+      if (needsRevalidation) {
+        return this.revalidate(true);
+      }
+      return void 0;
+    } finally {
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.child({
+          methodName: "maybeUpdateAndRevalidate"
+        }).debug("in finally");
+      }
+    }
+  };
+  _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) {
-          objectsToInsert.push(obj);
+          group.strictMatches.add(obj);
         } else {
           const sortaMatch = objectSortaMatchesWhereClause(obj, this.#whereClause, false);
           if (sortaMatch) {
-            needsRevalidation = true;
+            group.sortaMatches.add(obj);
           }
         }
       }
     }
-    needsRevalidation ||= objectsToInsert.length > 0;
-    if (objectsToInsert.length > 0) {
-      this.store.batch({
-        optimisticId
-      }, (batch) => {
-        this.updateList(objectsToInsert, true, "loading", batch);
-      });
-    }
-    return needsRevalidation;
+    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()
+      }
+    };
   }
-  maybeRevalidate(changedObjects) {
-    let needsRevalidation = false;
-    for (const [type, objects] of changedObjects.addedObjects.associations()) {
-      if (this.cacheKey.otherKeys[0] !== type) {
-        continue;
+  #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()
       }
-      for (const obj of objects) {
-        const sortaMatch = objectSortaMatchesWhereClause(obj, this.#whereClause, false);
-        if (sortaMatch) {
-          needsRevalidation = true;
+    };
+  }
+  _sortCacheKeys(objectCacheKeys, batch) {
+    if (Object.keys(this.#orderBy).length > 0) {
+      objectCacheKeys = objectCacheKeys.sort((a, b) => {
+        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;
+          }
         }
-      }
-    }
-    if (needsRevalidation) {
-      return this.revalidate(true);
+        return 0;
+      });
     }
-    return Promise.resolve();
+    return objectCacheKeys;
   }
-  updateList(values, append, status, batch) {
-    let objectCacheKeys = values.map((v) => {
-      if (v instanceof Entry) return v.cacheKey;
-      this.store.getObjectQuery(this.#type, v.$primaryKey).writeToStore(v, "loaded", batch);
-      return this.store.getCacheKey("object", v.$apiName, v.$primaryKey);
+  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)
     });
-    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);
-        }
-      }
-      for (const objectCacheKey of objectCacheKeys) {
-        this.#toRelease.add(objectCacheKey);
-        this.store.retain(objectCacheKey);
+    sub.add(() => {
+      if (process.env.NODE_ENV !== "production") {
+        logger?.child({
+          methodName: "observeList"
+        }).info("Unsubscribing from websocket");
       }
+      websocketSubscription.unsubscribe();
+    });
+  }
+  #onOswSuccessfulSubscription() {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "onSuccessfulSubscription"
+      }).debug("");
     }
-    if (append) {
-      objectCacheKeys = [...existingList?.value?.data ?? [], ...objectCacheKeys];
+  }
+  #onOswOutOfDate() {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "onOutOfDate"
+      }).info("");
     }
-    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)) {
-      return batch.write(this.cacheKey, entry.value, status);
+  #onOswError(errors) {
+    if (this.logger) {
+      this.logger?.child({
+        methodName: "onError"
+      }).error("subscription errors", errors);
     }
-    const ret = batch.write(this.cacheKey, data, status);
-    batch.modifiedLists.add(this.cacheKey);
-    return ret;
   }
-  _dispose() {
-    console.log("DISPOSE LIST QUERY");
+  #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) : undefined;
+      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);
-    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
-      })
-    });
-  }
-  async _fetch() {
-    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);
+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) : undefined;
+    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);
     });
   }
-  writeToStore(data, status, batch) {
-    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.modifiedObjects.add(this.cacheKey);
-    } else {
-      batch.addedObjects.add(this.cacheKey);
+  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();
     }
     return ret;
   }
-};
-
-// src/observable/internal/OptimisticId.ts
-function createOptimisticId() {
-  if (process.env.NODE_ENV !== "production") {
-    if (createOptimisticId.counter === undefined) {
-      createOptimisticId.counter = 0;
+  peekArray(array) {
+    const maybe = this.#trie.peekArray(array);
+    const ret = maybe?.deref();
+    if (maybe && !ret) {
+      this.#trie.removeArray(array);
     }
-    return {
-      __optimisticId: createOptimisticId.counter++
-    };
+    return ret;
   }
-  return /* @__PURE__ */ Object.create(null);
-}
-
-// src/observable/internal/OptimisticJob.ts
-var OptimisticJob = class {
-  #result;
-  constructor(store, optimisticId) {
-    const updatedObjects = [];
-    const addedObjects = [];
-    this.getResult = () => {
-      return this.#result ??= (async () => {
-        const changes = {
-          addedObjects: new mnemonist.MultiMap(),
-          modifiedObjects: new mnemonist.MultiMap()
-        };
-        const settled = await Promise.allSettled(addedObjects);
-        for (const added of settled) {
-          if (added.status === "fulfilled") {
-            changes.addedObjects.set(added.value.$objectType, added.value);
-          } else {
-            throw added;
-          }
-        }
-        for (const modified of updatedObjects) {
-          changes.modifiedObjects.set(modified.$apiName, modified);
-        }
-        store.batch({
-          optimisticId
-        }, (batch) => {
-          for (const a of ["addedObjects", "modifiedObjects"]) {
-            for (const b of changes[a].values()) {
-              store.getObjectQuery(b.$objectType, b.$primaryKey).writeToStore(b, "loading", batch);
-            }
-          }
-        });
-        return changes;
-      })();
-    };
-    this.context = {
-      updateObject(value) {
-        updatedObjects.push(value);
-        return this;
-      },
-      createObject(type, pk, properties) {
-        const create = store.client[chunkFWVJ2AKD_cjs.additionalContext].objectFactory2(store.client[chunkFWVJ2AKD_cjs.additionalContext], [{
-          $primaryKey: pk,
-          $apiName: type.apiName,
-          $objectType: type.apiName,
-          ...properties
-        }], undefined).then((x) => x[0]);
-        addedObjects.push(create);
-        return this;
-      }
-    };
+  removeArray(array) {
+    return this.#trie.removeArray(array)?.deref();
   }
 };
-function runOptimisticJob(store, optimisticUpdate) {
-  if (!optimisticUpdate) {
-    return () => Promise.resolve();
-  }
-  const optimisticId = createOptimisticId();
-  const job = new OptimisticJob(store, optimisticId);
-  optimisticUpdate(job.context);
-  const optimisticApplicationDone = job.getResult().then((result) => {
-    store.maybeUpdateLists(result, optimisticId);
+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;
   });
-  return () => {
-    return optimisticApplicationDone.finally(() => {
-      store.removeLayer(optimisticId);
-    });
+  canonicalize = (orderBy) => {
+    const strings = Object.entries(orderBy).flat();
+    return this.#trie.lookupArray(strings);
   };
-}
+};
 
 // src/observable/internal/RefCounts.ts
 var RefCounts = class {
@@ -792,8 +1450,8 @@ var RefCounts = class {
     }
   }
   release(key) {
-    const count = this.refCounts.get(key) ?? 0;
-    if (count === 1) {
+    const count = this.refCounts.get(key);
+    if (count === undefined) ; else if (count === 1) {
       this.refCounts.delete(key);
       this.gcMap.set(key, Date.now() + this.keepAlive);
     } else {
@@ -814,6 +1472,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
@@ -831,14 +1497,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);
@@ -871,7 +1537,6 @@ var WhereClauseCanonicalizer = class {
 };
 
 // src/observable/internal/Store.ts
-var ACTION_DELAY = process.env.NODE_ENV === "production" ? 0 : 1e3;
 function createInitEntry(cacheKey) {
   return {
     cacheKey,
@@ -882,17 +1547,26 @@ function createInitEntry(cacheKey) {
 }
 var Store = class {
   whereCanonicalizer = new WhereClauseCanonicalizer();
+  orderByCanonicalizer = new OrderByCanonicalizer();
   #truthLayer = new Layer(undefined, undefined);
   #topLayer;
-  #queries = /* @__PURE__ */ new WeakMap();
+  /** @internal */
+  // 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[chunkEY52J5Z4_cjs.additionalContext].logger?.child({}, {
+      msgPrefix: "Store"
+    });
     this.#topLayer = this.#truthLayer;
-    this.#cacheKeys = new CacheKeys(this.whereCanonicalizer, (k) => {
+    this.#cacheKeys = new CacheKeys(this.whereCanonicalizer, this.orderByCanonicalizer, (k) => {
       this.#refCounts.register(k);
     });
     setInterval(() => {
@@ -970,63 +1644,73 @@ 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") {
-      void query.revalidate(options.mode === "force");
+      query.revalidate(options.mode === "force").catch((e) => {
+        subFn.error(e);
+        if (this.logger) {
+          this.logger.error("Unhandled error in observeObject", e);
+        } else {
+          throw e;
+        }
+      });
     }
-    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(apiName, where, options, subFn) {
-    if (typeof apiName !== "string") {
-      apiName = apiName.apiName;
-    }
-    const query = this.getListQuery(apiName, where, options);
-    this.#refCounts.retain(query.cacheKey);
+  observeList(options, subFn) {
+    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(subFn);
+    if (options.streamUpdates) {
+      query.registerStreamUpdates(sub);
     }
-    const sub = query.subscribe({
-      next: subFn
-    });
     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, opts, peek = false) {
-    if (typeof apiName !== "string") {
-      apiName = apiName.apiName;
-    }
+  getListQuery(def, where, orderBy, opts) {
+    const {
+      apiName,
+      type
+    } = def;
     const canonWhere = this.whereCanonicalizer.canonicalize(where);
-    const listCacheKey = this.getCacheKey("list", apiName, canonWhere);
+    const canonOrderBy = this.orderByCanonicalizer.canonicalize(orderBy);
+    const listCacheKey = this.getCacheKey("list", type, apiName, canonWhere, canonOrderBy);
     return this.#getQuery(listCacheKey, () => {
-      return new ListQuery(this, this.getSubject(listCacheKey), apiName, canonWhere, listCacheKey, opts);
+      return new ListQuery(this, this.getSubject(listCacheKey), type, apiName, canonWhere, canonOrderBy, listCacheKey, opts);
     });
   }
   getObjectQuery(apiName, pk) {
@@ -1038,23 +1722,17 @@ 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
+    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;
     const batchContext = {
-      addedObjects: /* @__PURE__ */ new Set(),
-      modifiedObjects: /* @__PURE__ */ new Set(),
-      modifiedLists: /* @__PURE__ */ new Set(),
+      changes,
       createLayerIfNeeded: () => {
         if (needsLayer) {
           this.#topLayer = this.#topLayer.addLayer(optimisticId);
@@ -1066,16 +1744,12 @@ var Store = class {
         const oldTopValue = this.#topLayer.get(cacheKey);
         if (optimisticId) batchContext.createLayerIfNeeded();
         const writeLayer = optimisticId ? this.#topLayer : this.#truthLayer;
-        const newValue = {
-          cacheKey,
-          value,
-          lastUpdated: Date.now(),
-          status
-        };
+        const newValue = new Entry(cacheKey, value, Date.now(), status);
         writeLayer.set(cacheKey, newValue);
         const newTopValue = this.#topLayer.get(cacheKey);
         if (oldTopValue !== newTopValue) {
           this.#cacheKeyToSubject.get(cacheKey)?.next({
+            // eslint-disable-next-line @typescript-eslint/no-misused-spread
             ...newValue,
             isOptimistic: newTopValue?.value !== this.#truthLayer.get(cacheKey)?.value
           });
@@ -1087,76 +1761,87 @@ var Store = class {
       }
     };
     const retVal = batchFn(batchContext);
+    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
+    );
   }
-  maybeRevalidateLists(changes) {
-    for (const [cacheKey, v] of this.#truthLayer.entries()) {
-      if (isListCacheKey(cacheKey)) {
-        void this.#peekQuery(cacheKey)?.maybeRevalidate(changes);
-      }
-    }
-  }
-  maybeUpdateLists(changes, optimisticId) {
-    for (const [cacheKey, v] of this.#truthLayer.entries()) {
-      if (isListCacheKey(cacheKey)) {
-        void this.#peekQuery(cacheKey)?.maybeUpdate(changes, optimisticId);
+  async maybeRevalidateQueries(changes, optimisticId) {
+    if (changes.isEmpty()) {
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.child({
+          methodName: "maybeRevalidateQueries"
+        }).debug("No changes, aborting");
       }
+      return;
     }
-  }
-  invalidateObjectType(apiName) {
-    if (typeof apiName !== "string") {
-      apiName = apiName.apiName;
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "maybeRevalidateQueries"
+      }).debug(DEBUG_ONLY__changesToString(changes), {
+        optimisticId
+      });
     }
-    for (const [cacheKey, v] of this.#truthLayer.entries()) {
-      if (isListCacheKey(cacheKey, apiName)) {
-        void this.#peekQuery(cacheKey)?.revalidate(true);
+    try {
+      const promises = [];
+      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?.child({
+          methodName: "maybeRevalidateQueries"
+        }).debug("in finally", DEBUG_ONLY__changesToString(changes));
       }
     }
   }
-  invalidateList(apiName, where) {
+  /**
+   * @param apiName
+   * @param changes The changes we know about / to update
+   * @returns
+   */
+  invalidateObjectType(apiName, changes) {
     if (typeof apiName !== "string") {
       apiName = apiName.apiName;
     }
-    const cacheKey = this.getCacheKey("list", apiName, where);
-    void this.#peekQuery(cacheKey)?.revalidate(true);
-  }
-  updateObject(apiName, value, {
-    optimisticId
-  } = {}) {
-    if (typeof apiName !== "string") {
-      apiName = apiName.apiName;
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "invalidateObjectType"
+      }).info(changes ? DEBUG_ONLY__changesToString(changes) : undefined);
     }
-    const query = this.getObjectQuery(apiName, value.$primaryKey);
-    return this.batch({
-      optimisticId
-    }, (batch) => {
-      return query.writeToStore(value, "loaded", batch);
-    }).retVal.value;
-  }
-  updateList(apiName, where, values, {
-    optimisticId
-  } = {}, opts = {
-    dedupeInterval: 0
-  }) {
-    if (typeof apiName !== "string") {
-      apiName = apiName.apiName;
+    const promises = [];
+    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?.modified.add(cacheKey);
+          }
+        }
+      }
     }
-    const query = this.getListQuery(apiName, where, opts);
-    this.batch({
-      optimisticId
-    }, (b) => {
-      query.updateList(values, false, "loaded", b);
-    });
+    return Promise.all(promises).then(() => undefined);
   }
   retain(cacheKey) {
     this.#refCounts.retain(cacheKey);
@@ -1165,74 +1850,6 @@ var Store = class {
     this.#refCounts.release(cacheKey);
   }
 };
-var ActionApplication = class {
-  constructor(store) {
-    this.store = store;
-  }
-  applyAction = (action, args, {
-    optimisticUpdate
-  } = {}) => {
-    const removeOptimisticResult = runOptimisticJob(this.store, optimisticUpdate);
-    return (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");
-        }
-        await this.#invalidateActionEditResponse(actionResults);
-        return actionResults;
-      } finally {
-        await removeOptimisticResult();
-      }
-    })();
-  };
-  #invalidateActionEditResponse = (value) => {
-    const typesToInvalidate = /* @__PURE__ */ new Set();
-    let promisesToWait = [];
-    if (value.type === "edits") {
-      for (const obj of value.modifiedObjects) {
-        promisesToWait.push(this.store.invalidateObject(obj.objectType, obj.primaryKey));
-      }
-      for (const obj of value.addedObjects) {
-        promisesToWait.push(this.store.invalidateObject(obj.objectType, obj.primaryKey));
-        typesToInvalidate.add(obj.objectType);
-      }
-      promisesToWait = [Promise.allSettled(promisesToWait).then(() => {
-        const changes2 = this.#changesFromActionEditResponse(value);
-        this.store.maybeRevalidateLists(changes2);
-      })];
-    } else {
-      for (const apiName of value.editedObjectTypes) {
-        typesToInvalidate.add(apiName.toString());
-      }
-    }
-    return Promise.allSettled(promisesToWait).then(() => {
-      for (const objectType of typesToInvalidate) {
-        this.store.invalidateObjectType(objectType);
-      }
-      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;
-  };
-};
 
 // src/observable/ObservableClient.ts
 function createObservableClient(client) {
@@ -1241,7 +1858,7 @@ function createObservableClient(client) {
 
 Object.defineProperty(exports, "augment", {
   enumerable: true,
-  get: function () { return chunkFWVJ2AKD_cjs.augment; }
+  get: function () { return chunkEY52J5Z4_cjs.augment; }
 });
 exports.createObservableClient = createObservableClient;
 //# sourceMappingURL=unstable-do-not-use.cjs.map