@osdk/client 2.4.2 → 2.5.0-beta.10

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

@@ -1,32 +1,91 @@
 'use strict';
 
-var chunk26WFEZQO_cjs = require('../chunk-26WFEZQO.cjs');
-var chunk633AI7EA_cjs = require('../chunk-633AI7EA.cjs');
+var chunkYADG7KA6_cjs = require('../chunk-YADG7KA6.cjs');
+var chunkGVGP7T5P_cjs = require('../chunk-GVGP7T5P.cjs');
 require('../chunk-Q7SFCCGT.cjs');
 var shared_net_fetch = require('@osdk/shared.net.fetch');
 var rxjs = require('rxjs');
 var invariant2 = require('tiny-invariant');
 var trie = require('@wry/trie');
 var mnemonist = require('mnemonist');
-var deepEqual2 = require('fast-deep-equal');
+var deepEqual4 = 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 deepEqual2__default = /*#__PURE__*/_interopDefault(deepEqual2);
+var deepEqual4__default = /*#__PURE__*/_interopDefault(deepEqual4);
 var groupBy__default = /*#__PURE__*/_interopDefault(groupBy);
 
+// src/observable/internal/UnsubscribableWrapper.ts
+var UnsubscribableWrapper = class {
+  #subscription;
+  constructor(subscription) {
+    this.#subscription = subscription;
+  }
+  unsubscribe() {
+    this.#subscription?.unsubscribe();
+  }
+};
+
 // src/observable/internal/ObservableClientImpl.ts
 var ObservableClientImpl = class {
   constructor(store) {
     this.__experimentalStore = store;
-    this.observeObject = store.observeObject.bind(store);
-    this.observeList = store.observeList.bind(store);
     this.applyAction = store.applyAction.bind(store);
     this.validateAction = store.validateAction.bind(store);
-    this.canonicalizeWhereClause = store.canonicalizeWhereClause.bind(store);
+  }
+  observeObject = (apiName, pk, options, subFn) => {
+    return this.__experimentalStore.objects.observe(
+      {
+        ...options,
+        apiName,
+        pk
+      },
+      // cast to cross typed to untyped barrier
+      subFn
+    );
+  };
+  observeList = (options, subFn) => {
+    return this.__experimentalStore.lists.observe(
+      options,
+      // cast to cross typed to untyped barrier
+      subFn
+    );
+  };
+  observeLinks = (objects, linkName, options, subFn) => {
+    const objectsArray = Array.isArray(objects) ? objects : [objects];
+    const parentSub = new rxjs.Subscription();
+    for (const obj of objectsArray) {
+      const querySubscription = this.__experimentalStore.links.observe(
+        {
+          ...options,
+          srcType: {
+            type: "object",
+            apiName: obj.$apiName
+          },
+          linkName,
+          pk: obj.$primaryKey
+        },
+        // cast to cross typed to untyped barrier
+        subFn
+      );
+      parentSub.add(querySubscription);
+    }
+    return new UnsubscribableWrapper(parentSub);
+  };
+  invalidateAll() {
+    return this.__experimentalStore.invalidateAll();
+  }
+  invalidateObjects(objects) {
+    return this.__experimentalStore.invalidateObjects(objects);
+  }
+  invalidateObjectType(type) {
+    return this.__experimentalStore.invalidateObjectType(type, void 0);
+  }
+  canonicalizeWhereClause(where) {
+    return this.__experimentalStore.whereCanonicalizer.canonicalize(where);
   }
 };
 
@@ -47,7 +106,7 @@ function createOptimisticId() {
   return /* @__PURE__ */ Object.create(null);
 }
 
-// src/observable/internal/OptimisticJob.ts
+// src/observable/internal/actions/OptimisticJob.ts
 var OptimisticJob = class {
   #result;
   constructor(store, optimisticId) {
@@ -64,16 +123,25 @@ var OptimisticJob = class {
         }, (batch) => {
           for (const obj of addedObjects) {
             if (obj.status === "fulfilled") {
-              store.getObjectQuery(obj.value.$objectType, obj.value.$primaryKey).writeToStore(obj.value, "loading", batch);
+              store.objects.getQuery({
+                apiName: obj.value.$objectType,
+                pk: 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);
+            store.objects.getQuery({
+              apiName: obj.$objectType,
+              pk: obj.$primaryKey
+            }).writeToStore(obj, "loading", batch);
           }
           for (const obj of deletedObjects) {
-            store.getObjectQuery(obj.$objectType, obj.$primaryKey).deleteFromStore("loading", batch);
+            store.objects.getQuery({
+              apiName: obj.$objectType,
+              pk: obj.$primaryKey
+            }).deleteFromStore("loading", batch);
           }
         });
         return batchResult.changes;
@@ -85,7 +153,7 @@ var OptimisticJob = class {
         return this;
       },
       createObject(type, pk, properties) {
-        const create = store.client[chunk633AI7EA_cjs.additionalContext].objectFactory2(store.client[chunk633AI7EA_cjs.additionalContext], [{
+        const create = store.client[chunkGVGP7T5P_cjs.additionalContext].objectFactory2(store.client[chunkGVGP7T5P_cjs.additionalContext], [{
           $primaryKey: pk,
           $apiName: type.apiName,
           $objectType: type.apiName,
@@ -116,12 +184,12 @@ function runOptimisticJob(store, optimisticUpdate) {
       // we don't want to leak the result
       () => void 0
     ).finally(() => {
-      store.removeLayer(optimisticId);
+      store.layers.remove(optimisticId);
     });
   };
 }
 
-// src/observable/internal/ActionApplication.ts
+// src/observable/internal/actions/ActionApplication.ts
 var ACTION_DELAY = process.env.NODE_ENV === "production" ? 0 : 1e3;
 var ActionApplication = class {
   constructor(store) {
@@ -187,8 +255,8 @@ var ActionApplication = class {
           objectType,
           primaryKey
         } of deletedObjects ?? []) {
-          const cacheKey = this.store.getCacheKey("object", objectType, primaryKey);
-          this.store.peekQuery(cacheKey)?.deleteFromStore(
+          const cacheKey = this.store.cacheKeys.get("object", objectType, primaryKey);
+          this.store.queries.peek(cacheKey)?.deleteFromStore(
             "loaded",
             // this is probably not the best value to use
             batch
@@ -203,39 +271,110 @@ var ActionApplication = class {
     }
   };
 };
+
+// src/observable/internal/RefCounts.ts
+var RefCounts = class {
+  refCounts = /* @__PURE__ */ new Map();
+  // keeps our objects around for some extended duration after they are no longer
+  // needed which is good for quick clicks across tabs.
+  gcMap = /* @__PURE__ */ new Map();
+  constructor(keepAlive, cleanup) {
+    this.keepAlive = keepAlive;
+    this.cleanup = cleanup;
+  }
+  register(key) {
+    if (!this.refCounts.has(key)) {
+      this.gcMap.set(key, Date.now() + this.keepAlive);
+    }
+    return key;
+  }
+  retain(key) {
+    const count = this.refCounts.get(key) ?? 0;
+    this.refCounts.set(key, count + 1);
+    if (this.gcMap.has(key)) {
+      this.gcMap.delete(key);
+    }
+  }
+  release(key) {
+    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 {
+      this.refCounts.set(key, count - 1);
+    }
+  }
+  has(key) {
+    return this.refCounts.has(key);
+  }
+  gc() {
+    const now = Date.now();
+    for (const [key, deathTime] of this.gcMap) {
+      if (deathTime < now) {
+        this.gcMap.delete(key);
+        this.cleanup(key);
+      }
+    }
+  }
+};
+
+// src/observable/internal/CacheKeys.ts
 var CacheKeys = class {
   #cacheKeys = new trie.Trie(false, (keys) => {
-    const ret = {
+    const cacheKey = {
       type: keys[0],
       otherKeys: keys.slice(1)
     };
-    this.#onCreate(ret);
-    return ret;
+    this.#onCreate?.(cacheKey);
+    return cacheKey;
   });
-  #cacheKeyFactories = /* @__PURE__ */ new Map();
+  #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;
   #onCreate;
-  constructor(whereCanonicalizer, orderByCanonicalizer, onCreate) {
+  #onDestroy;
+  constructor({
+    onCreate,
+    onDestroy
+  }) {
     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", (type, apiName, where, orderBy) => {
-      if (process.env.NODE_ENV !== "production" && DEBUG_CACHE_KEYS) ;
-      return this.#cacheKeys.lookupArray(["list", type, apiName, whereCanonicalizer.canonicalize(where), orderByCanonicalizer.canonicalize(orderBy)]);
+    this.#onDestroy = onDestroy;
+    setInterval(() => {
+      this.#refCounts.gc();
+    }, 1e3);
+    this.#finalizationRegistry = new FinalizationRegistry((cleanupCallback) => {
+      try {
+        cleanupCallback();
+      } catch (e) {
+        console.error("Caught an error while running a finalization callback", e);
+      }
     });
   }
-  #registerCacheKeyFactory(type, factory) {
-    this.#cacheKeyFactories.set(type, factory);
-  }
   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) : void 0;
-    return factory(...args);
+    const cacheKeyArgs = [type, ...args];
+    if (process.env.NODE_ENV !== "production" && DEBUG_CACHE_KEYS) ;
+    const cacheKey = this.#cacheKeys.lookupArray(cacheKeyArgs);
+    this.#refCounts.register(cacheKey);
+    return cacheKey;
+  }
+  retain(cacheKey) {
+    this.#refCounts.retain(cacheKey);
+  }
+  release(cacheKey) {
+    this.#refCounts.release(cacheKey);
   }
-  remove(cacheKey) {
+  #remove(cacheKey) {
     this.#cacheKeys.remove(cacheKey.type, ...cacheKey.otherKeys);
   }
+  /**
+   * Called after a key is no longer retained and the timeout has elapsed
+   * @param key
+   */
+  #cleanupCacheKey = (key) => {
+    this.#onDestroy?.(key);
+    this.#remove(key);
+  };
 };
 
 // src/observable/internal/CacheKey.ts
@@ -271,6 +410,12 @@ var Changes = class {
   registerList = (key) => {
     this.modified.add(key);
   };
+  registerLink = (cacheKey) => {
+    this.modified.add(cacheKey);
+  };
+  deleteLink = (cacheKey) => {
+    this.deleted.add(cacheKey);
+  };
   isEmpty() {
     return this.modifiedObjects.size === 0 && this.addedObjects.size === 0 && this.added.size === 0 && this.modified.size === 0 && this.deleted.size === 0;
   }
@@ -299,6 +444,16 @@ function multimapHelper(multimap) {
   }));
 }
 
+// src/observable/internal/createInitEntry.ts
+function createInitEntry(cacheKey) {
+  return {
+    cacheKey,
+    status: "init",
+    value: void 0,
+    lastUpdated: 0
+  };
+}
+
 // src/observable/internal/WeakMapWithEntries.ts
 var WeakMapWithEntries = class {
   #map = /* @__PURE__ */ new WeakMap();
@@ -446,197 +601,240 @@ var Layer = class _Layer {
     this.#cache.set(cacheKey, value);
   }
 };
-var Entry = class {
-  constructor(cacheKey, value, lastUpdated, status = "init") {
-    this.cacheKey = cacheKey;
-    this.value = value;
-    this.lastUpdated = lastUpdated;
-    this.status = status;
-  }
-};
-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) : 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;
-    }
+var Subjects = class {
+  #layers;
+  // we can use a regular Map here because the refCounting will
+  // handle cleanup.
+  #cacheKeyToSubject = /* @__PURE__ */ new WeakMap();
+  constructor({
+    logger,
+    layers
+  }) {
+    this.logger = logger;
+    this.#layers = layers;
   }
-  return "$and" in 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) : 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;
+  peek = (cacheKey) => {
+    return this.#cacheKeyToSubject.get(cacheKey);
+  };
+  get = (cacheKey) => {
+    let subject = this.#cacheKeyToSubject.get(cacheKey);
+    if (!subject) {
+      const initialValue = this.#layers.top.get(cacheKey) ?? createInitEntry(cacheKey);
+      subject = new rxjs.BehaviorSubject({
+        ...initialValue,
+        isOptimistic: initialValue.value !== this.#layers.truth.get(cacheKey)?.value
+      });
+      this.#cacheKeyToSubject.set(cacheKey, subject);
     }
-  }
-  return "$or" in 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) : void 0;
+    return subject;
+  };
+  delete = (cacheKey) => {
+    const subject = this.peek(cacheKey);
+    if (subject) {
+      subject.complete();
+      this.#cacheKeyToSubject.delete(cacheKey);
     }
+  };
+};
+
+// src/observable/internal/tombstone.ts
+var tombstone = void 0;
+
+// src/observable/internal/Layers.ts
+var Layers = class {
+  #truthLayer = new Layer(void 0, void 0);
+  #topLayer;
+  #onRevalidate;
+  constructor({
+    logger,
+    onRevalidate
+  }) {
+    this.logger = logger;
+    this.#topLayer = this.#truthLayer;
+    this.subjects = new Subjects({
+      logger,
+      layers: this
+    });
+    this.#onRevalidate = onRevalidate;
   }
-  return "$not" in whereClause;
-}
-function objectSortaMatchesWhereClause(o, whereClause, strict) {
-  if (deepEqual2__default.default({}, whereClause)) {
-    return true;
-  }
-  if (is$and(whereClause)) {
-    return whereClause.$and.every((w) => objectSortaMatchesWhereClause(o, w, strict));
-  }
-  if (is$or(whereClause)) {
-    return whereClause.$or.some((w) => objectSortaMatchesWhereClause(o, w, strict));
+  get top() {
+    return this.#topLayer;
   }
-  if (is$not(whereClause)) {
-    return !objectSortaMatchesWhereClause(o, whereClause.$not, strict);
+  get truth() {
+    return this.#truthLayer;
   }
-  return Object.entries(whereClause).every(([key, filter]) => {
-    if (typeof filter === "object") {
-      const realValue = o[key];
-      const [f] = Object.keys(filter);
-      const expected = filter[f];
-      switch (f) {
-        case "$eq":
-          return realValue === expected;
-        case "$gt":
-          return realValue > expected;
-        case "$lt":
-          return realValue < expected;
-        case "$gte":
-          return realValue >= expected;
-        case "$lte":
-          return realValue <= expected;
-        case "$ne":
-          return realValue !== expected;
-        case "$in":
-          return expected.$in.includes(realValue);
-        case "$isNull":
-          return realValue == null;
-        case "$startsWith":
-          return realValue.startsWith(expected);
-        case "$contains":
-        case "$containsAllTerms":
-        case "$containsAllTermsInOrder":
-        case "$containsAnyTerm":
-        case "$intersects":
-        case "$within":
-          return !strict;
-        default:
-          if (process.env.NODE_ENV !== "production") {
-            process.env.NODE_ENV !== "production" ? invariant2__default.default(false, `Unknown where filter ${f}`) : invariant2__default.default(false) ;
-          }
-          return !strict;
+  remove(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) : void 0;
+    let currentLayer = this.#topLayer;
+    const cacheKeys = /* @__PURE__ */ new Map();
+    while (currentLayer != null && currentLayer.parentLayer != null) {
+      if (currentLayer.layerId === layerId) {
+        for (const [k, v] of currentLayer.entries()) {
+          if (cacheKeys.has(k)) continue;
+          cacheKeys.set(k, v);
+        }
       }
+      currentLayer = currentLayer.parentLayer;
     }
-    if (key in o) {
-      if (o[key] === filter) {
-        return true;
+    this.#topLayer = this.#topLayer.removeLayer(layerId);
+    for (const [k, oldEntry] of cacheKeys) {
+      const currentEntry = this.#topLayer.get(k);
+      if (oldEntry !== currentEntry) {
+        const newEntry = currentEntry ?? createInitEntry(k);
+        this.subjects.peek(k)?.next({
+          ...newEntry,
+          isOptimistic: currentEntry?.value !== this.#truthLayer.get(k)?.value
+        });
       }
     }
-    return false;
-  });
-}
-
-// ../../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[chunk633AI7EA_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
+  batch({
+    optimisticId,
+    changes
+  }, batchFn) {
+    !(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;
+    const batchContext = this.#createBatchContext({
+      optimisticId,
+      changes
     });
-    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);
+    const retVal = batchFn(batchContext);
+    this.#onRevalidate(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,
+      changes: batchContext.changes
+    };
   }
-  async #reallyLoadObjects(apiName, arr) {
-    const miniDef = {
-      type: "object",
-      apiName
+  #createBatchContext({
+    optimisticId,
+    changes
+  }) {
+    let needsLayer = optimisticId !== void 0;
+    const batchContext = {
+      changes,
+      createLayerIfNeeded: () => {
+        if (needsLayer) {
+          this.#topLayer = this.#topLayer.addLayer(optimisticId);
+          needsLayer = false;
+        }
+      },
+      optimisticWrite: !!optimisticId,
+      write: (cacheKey, value, status) => {
+        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
+        };
+        writeLayer.set(cacheKey, newValue);
+        const newTopValue = this.#topLayer.get(cacheKey);
+        if (oldTopValue !== newTopValue) {
+          this.subjects.get(cacheKey)?.next({
+            ...newValue,
+            isOptimistic: newTopValue?.value !== this.#truthLayer.get(cacheKey)?.value
+          });
+        }
+        return newValue;
+      },
+      delete: (cacheKey, status) => {
+        return batchContext.write(cacheKey, tombstone, status);
+      },
+      read: (cacheKey) => {
+        return optimisticId ? this.#topLayer.get(cacheKey) : this.#truthLayer.get(cacheKey);
+      }
     };
-    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
+    return batchContext;
+  }
+};
+
+// src/observable/internal/QuerySubscription.ts
+var subscriptionIdCounter = 0;
+var QuerySubscription = class extends UnsubscribableWrapper {
+  /** @internal */
+  /** @internal */
+  /** @internal */
+  constructor(query, subscription) {
+    super(subscription);
+    this.query = query;
+    this.subscription = subscription;
+    this.subscriptionId = `sub_${++subscriptionIdCounter}`;
+    Object.defineProperties(this, {
+      query: {
+        enumerable: false
+      },
+      subscription: {
+        enumerable: false
+      },
+      subscriptionId: {
+        enumerable: false
       }
-    }).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/AbstractHelper.ts
+var AbstractHelper = class {
+  constructor(store, cacheKeys) {
+    this.store = store;
+    this.cacheKeys = cacheKeys;
+  }
+  observe(options, subFn) {
+    const query = this.getQuery(options);
+    return this._subscribe(query, options, subFn);
+  }
+  _subscribe(query, options, subFn) {
+    this.store.cacheKeys.retain(query.cacheKey);
+    if (options.mode !== "offline") {
+      query.revalidate(options.mode === "force").catch((e) => {
+        subFn.error(e);
+        if (this.store.logger) {
+          this.store.logger.error("Unhandled error in observeObject", e);
+        } else {
+          throw e;
+        }
+      });
     }
+    const sub = query.subscribe(subFn);
+    const querySub = new QuerySubscription(query, sub);
+    query.registerSubscriptionDedupeInterval(querySub.subscriptionId, options.dedupeInterval);
+    sub.add(() => {
+      query.unregisterSubscriptionDedupeInterval(querySub.subscriptionId);
+      this.store.cacheKeys.release(query.cacheKey);
+    });
+    return querySub;
   }
 };
 
+// src/observable/internal/isObjectInstance.ts
+function isObjectInstance(item) {
+  return item != null && typeof item === "object" && "$primaryKey" in item;
+}
+
 // src/observable/internal/Query.ts
 var Query = class {
   retainCount = 0;
   #connectable;
   #subscription;
   #subject;
+  #subscriptionDedupeIntervals = /* @__PURE__ */ new Map();
   /** @internal */
   constructor(store, observable, opts, cacheKey, logger) {
     this.options = opts;
     this.cacheKey = cacheKey;
     this.store = store;
+    this.cacheKeys = store.cacheKeys;
     this.#subject = observable;
-    this.logger = logger ?? (process.env.NODE_ENV === "production" ? store.client[chunk633AI7EA_cjs.additionalContext].logger : store.client[chunk633AI7EA_cjs.additionalContext].logger?.child({}, {
+    this.logger = logger ?? (process.env.NODE_ENV === "production" ? store.client[chunkGVGP7T5P_cjs.additionalContext].logger : store.client[chunkGVGP7T5P_cjs.additionalContext].logger?.child({}, {
       msgPrefix: process.env.NODE_ENV !== "production" ? `Query<${cacheKey.type}, ${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>` : "Query"
     }));
   }
@@ -645,6 +843,29 @@ var Query = class {
     this.#subscription = this.#connectable.connect();
     return this.#connectable.subscribe(observer);
   }
+  /**
+   * Register a subscription's dedupeInterval value
+   */
+  registerSubscriptionDedupeInterval(subscriptionId, dedupeInterval) {
+    if (dedupeInterval != null && dedupeInterval > 0) {
+      this.#subscriptionDedupeIntervals.set(subscriptionId, dedupeInterval);
+    }
+  }
+  /**
+   * Unregister a subscription's dedupeInterval value
+   */
+  unregisterSubscriptionDedupeInterval(subscriptionId) {
+    this.#subscriptionDedupeIntervals.delete(subscriptionId);
+  }
+  /**
+   * Get the minimum dedupeInterval from all active subscriptions
+   */
+  getMinimumDedupeInterval() {
+    if (this.#subscriptionDedupeIntervals.size === 0) {
+      return this.options.dedupeInterval ?? 0;
+    }
+    return Math.min(...this.#subscriptionDedupeIntervals.values());
+  }
   /**
    * 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
@@ -667,7 +888,8 @@ var Query = class {
       await this.pendingFetch;
       return;
     }
-    if ((this.options.dedupeInterval ?? 0) > 0 && this.lastFetchStarted != null && Date.now() - this.lastFetchStarted < (this.options.dedupeInterval ?? 0)) {
+    const minDedupeInterval = this.getMinimumDedupeInterval();
+    if (minDedupeInterval > 0 && this.lastFetchStarted != null && Date.now() - this.lastFetchStarted < minDedupeInterval) {
       if (process.env.NODE_ENV !== "production") {
         logger?.debug("Within dupeInterval, aborting revalidate");
       }
@@ -685,7 +907,7 @@ var Query = class {
       logger?.debug("calling _fetchAndStore()");
     }
     this.pendingFetch = this._fetchAndStore().finally(() => {
-      logger?.debug("finally _fetchAndStore()");
+      logger?.debug("promise's finally for _fetchAndStore()");
       this.pendingFetch = void 0;
     });
     await this.pendingFetch;
@@ -704,10 +926,22 @@ var Query = class {
     if (process.env.NODE_ENV !== "production") {
       this.logger?.child({
         methodName: "setStatus"
-      }).debug(status);
+      }).debug(`Attempting to set status to '${status}'`);
     }
     const existing = batch.read(this.cacheKey);
-    if (existing?.status === status) return;
+    if (existing?.status === status) {
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.child({
+          methodName: "setStatus"
+        }).debug(`Status is already set to '${status}'; aborting`);
+      }
+      return;
+    }
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "setStatus"
+      }).debug(`Writing status '${status}' to cache`);
+    }
     batch.write(this.cacheKey, existing?.value, status);
   }
   dispose() {
@@ -738,167 +972,191 @@ var Query = class {
    */
 };
 
-// src/observable/internal/tombstone.ts
-var tombstone = void 0;
-
-// 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[chunk633AI7EA_cjs.additionalContext].logger?.child({}, {
-      msgPrefix: `ObjectQuery<${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>`
-    }) : void 0);
-    this.#apiName = type;
-    this.#pk = pk;
+// src/observable/internal/sorting/SortingStrategy.ts
+var NoOpSortingStrategy = class {
+  sortCacheKeys(objectCacheKeys, _batch) {
+    return objectCacheKeys;
   }
-  _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
-      })
+};
+var OrderBySortingStrategy = class {
+  constructor(apiName, orderBy) {
+    this.apiName = apiName;
+    this.orderBy = orderBy;
+    this.sortFns = createOrderBySortFns(orderBy);
+  }
+  sortCacheKeys(objectCacheKeys, batch) {
+    if (Object.keys(this.orderBy).length === 0) {
+      return objectCacheKeys;
+    }
+    return 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;
+        }
+      }
+      return 0;
     });
   }
-  async _fetchAndStore() {
+};
+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;
+    };
+  });
+}
+function createCollectionConnectable(subject, subjects, createPayload) {
+  return rxjs.connectable(subject.pipe(rxjs.switchMap((listEntry) => {
+    const resolvedData = listEntry?.value?.data == null || listEntry.value.data.length === 0 ? rxjs.of([]) : rxjs.combineLatest(listEntry.value.data.map((cacheKey) => subjects.get(cacheKey).pipe(rxjs.map((objectEntry) => objectEntry?.value), rxjs.distinctUntilChanged())));
+    return rxjs.scheduled(rxjs.combineLatest({
+      resolvedData,
+      isOptimistic: rxjs.of(listEntry.isOptimistic),
+      status: rxjs.of(listEntry.status),
+      lastUpdated: rxjs.of(listEntry.lastUpdated)
+    }).pipe(rxjs.map((params) => createPayload({
+      resolvedData: Array.isArray(params.resolvedData) ? params.resolvedData : [],
+      isOptimistic: params.isOptimistic,
+      status: params.status,
+      lastUpdated: params.lastUpdated
+    }))), rxjs.asapScheduler);
+  })), {
+    resetOnDisconnect: false,
+    connector: () => new rxjs.ReplaySubject(1)
+  });
+}
+
+// src/observable/internal/base-list/removeDuplicates.ts
+function removeDuplicates(objectCacheKeys, batch) {
+  const visited = /* @__PURE__ */ new Set();
+  return objectCacheKeys.filter((key) => {
+    batch.read(key);
+    if (visited.has(key)) {
+      return false;
+    }
+    visited.add(key);
+    return true;
+  });
+}
+
+// src/observable/internal/base-list/BaseListQuery.ts
+var BaseListQuery = class extends Query {
+  /**
+   * The sorting strategy to use for this collection
+   * @protected
+   */
+  sortingStrategy = new NoOpSortingStrategy();
+  // Collection-specific behavior is implemented by subclasses
+  /**
+   * Token for the next page of results
+   * @protected
+   */
+  /**
+   * Promise tracking an in-progress page fetch
+   * @protected
+   */
+  //
+  // Shared Implementations
+  //
+  /**
+   * Standard method to update a list of objects
+   * Handles common list update patterns for both ListQuery and SpecificLinkQuery
+   *
+   * @param items Objects or cache keys to add to the list
+   * @param status Status to set for the list
+   * @param batch Batch context to use
+   * @param append Whether to append to the existing list or replace it
+   * @returns The updated entry
+   */
+  _updateList(items, status, batch, append = false) {
     if (process.env.NODE_ENV !== "production") {
       this.logger?.child({
-        methodName: "_fetchAndStore"
-      }).debug("calling _fetchAndStore");
+        methodName: "updateList"
+      }).debug(`{status: ${status}, append: ${append}}`, JSON.stringify(items, null, 2));
     }
-    const obj = await getBulkObjectLoader(this.store.client).fetch(this.#apiName, this.#pk);
-    this.store.batch({}, (batch) => {
-      this.writeToStore(obj, "loaded", batch);
-    });
+    let objectCacheKeys;
+    if (items.length === 0) {
+      objectCacheKeys = [];
+    } else if (isObjectInstance(items[0])) {
+      objectCacheKeys = this.store.objects.storeOsdkInstances(items, batch);
+    } else {
+      objectCacheKeys = items;
+    }
+    objectCacheKeys = this.#retainReleaseAppend(batch, append, objectCacheKeys);
+    objectCacheKeys = this._sortCacheKeys(objectCacheKeys, batch);
+    objectCacheKeys = removeDuplicates(objectCacheKeys, batch);
+    return this.writeToStore({
+      data: objectCacheKeys
+    }, status, batch);
   }
+  /**
+   * Common implementation for writing to store for collection-based queries
+   * @param data The collection data to write to the store
+   * @param status The status to set
+   * @param batch The batch context
+   */
   writeToStore(data, status, batch) {
     const entry = batch.read(this.cacheKey);
-    if (entry && deepEqual2__default.default(data, entry.value)) {
+    if (entry && deepEqual4__default.default(data, entry.value)) {
+      if (entry.status === status) {
+        if (process.env.NODE_ENV !== "production") {
+          this.logger?.child({
+            methodName: "writeToStore"
+          }).debug(`Collection data was deep equal and status unchanged (${status}), skipping update`);
+        }
+        return entry;
+      }
       if (process.env.NODE_ENV !== "production") {
         this.logger?.child({
           methodName: "writeToStore"
-        }).debug(`Object was deep equal, just setting status`);
+        }).debug(`Collection data was deep equal, just updating status from ${entry.status} to ${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);
+      }).debug(`{status: ${status}},`, DEBUG_ONLY__cacheKeysToString(data.data));
     }
     const ret = batch.write(this.cacheKey, data, status);
-    batch.changes.registerObject(
-      this.cacheKey,
-      data,
-      /* isNew */
-      !entry
-    );
+    this.registerCacheChanges(batch);
     return ret;
   }
-  deleteFromStore(status, batch) {
-    const entry = batch.read(this.cacheKey);
-    if (entry && deepEqual2__default.default(tombstone, entry.value)) {
-      if (process.env.NODE_ENV !== "production") {
-        this.logger?.child({
-          methodName: "deleteFromStore"
-        }).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: "deleteFromStore"
-      }).debug(JSON.stringify({
-        status
-      }));
-    }
-    if (!entry || !entry.value) {
-      return;
-    }
-    const ret = batch.delete(this.cacheKey, status);
-    batch.changes.deleteObject(this.cacheKey);
-    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.
+   * Register changes to the cache based on the specific collection type
+   * Implemented by subclasses to handle specific change registration
+   */
+  /**
+   * Common method for managing object reference counting and appending results
+   * Used by collection queries when updating object references
    *
-   * @param objectCacheKeys
-   * @param append
-   * @param status
-   * @param batch
-   * @returns
+   * @param batch The batch context to use
+   * @param append Whether to append to existing objects or replace them
+   * @param objectCacheKeys Array of object cache keys to process
+   * @returns The final array of object cache keys after retain/release/append
    */
-  _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 && deepEqual2__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);
+          this.store.cacheKeys.release(objectCacheKey);
         }
       }
       for (const objectCacheKey of objectCacheKeys) {
-        this.store.retain(objectCacheKey);
+        this.store.cacheKeys.retain(objectCacheKey);
       }
     }
     if (append) {
@@ -907,68 +1165,87 @@ var BaseListQuery = class extends Query {
     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);
+          this.store.cacheKeys.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[chunk633AI7EA_cjs.additionalContext].logger?.child({}, {
-      msgPrefix: `ListQuery<${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>`
-    }) : void 0);
-    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;
+  /**
+   * Creates a payload from collection parameters
+   * Default implementation that covers common fields for all collection types
+   * Subclasses may override to add type-specific fields if needed
+   *
+   * @param params Common collection parameters
+   * @returns A typed payload for the specific collection type
+   */
+  createPayload(params) {
+    return {
+      resolvedList: params.resolvedData,
+      isOptimistic: params.isOptimistic,
+      fetchMore: this.fetchMore,
+      hasMore: this.nextPageToken != null,
+      status: params.status,
+      lastUpdated: params.lastUpdated
+    };
   }
+  /**
+   * Creates a connectable observable for this collection
+   * Common implementation shared by all collection types
+   *
+   * @param subject The subject to connect to
+   * @returns A connectable observable of the collection's payload type
+   */
   _createConnectable(subject) {
-    return rxjs.connectable(subject.pipe(
-      rxjs.switchMap((listEntry) => {
-        return rxjs.combineLatest({
-          resolvedList: listEntry?.value?.data == null || listEntry.value.data.length === 0 ? 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 createCollectionConnectable(subject, this.store.subjects, (params) => this.createPayload(params));
   }
+  /**
+   * @override Reset pagination state before a fetch
+   */
   _preFetch() {
-    this.#nextPageToken = void 0;
+    this.nextPageToken = void 0;
+    super._preFetch();
   }
+  /**
+   * Common fetchMore implementation for pagination
+   * Handles pending request management and loading states
+   */
+  fetchMore = () => {
+    if (this.pendingPageFetch) {
+      return this.pendingPageFetch;
+    }
+    if (this.pendingFetch) {
+      this.pendingPageFetch = new Promise(async (res) => {
+        await this.pendingFetch;
+        res(this.fetchMore());
+      });
+      return this.pendingPageFetch;
+    }
+    if (this.nextPageToken == null) {
+      return Promise.resolve(void 0);
+    }
+    this.store.batch({}, (batch) => {
+      this.setStatus("loading", batch);
+    });
+    this.pendingFetch = this.fetchPageAndUpdate("loaded", this.abortController?.signal).then(() => void 0).finally(() => {
+      this.pendingPageFetch = void 0;
+    });
+    return this.pendingFetch;
+  };
+  /**
+   * Minimum number of results to load initially
+   * May be overridden by subclasses for specific collection types
+   * @protected
+   */
+  minResultsToLoad = 0;
+  /**
+   * Common _fetchAndStore implementation for pagination
+   * Uses fetchPageAndUpdate to load the initial set of data
+   * Will load multiple pages if necessary to reach minResultsToLoad
+   */
   async _fetchAndStore() {
     if (process.env.NODE_ENV !== "production") {
       this.logger?.child({
@@ -976,13 +1253,12 @@ var ListQuery = class extends BaseListQuery {
       }).debug("fetching pages");
     }
     while (true) {
-      const entry = await this.#fetchPageAndUpdate(this.#objectSet, "loading", this.abortController?.signal);
+      const entry = await this.fetchPageAndUpdate("loading", this.abortController?.signal);
       if (!entry) {
         return;
       }
-      !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) {
+      const count = entry.value?.data.length || 0;
+      if (count >= this.minResultsToLoad || this.nextPageToken == null) {
         break;
       }
     }
@@ -991,91 +1267,406 @@ var ListQuery = class extends BaseListQuery {
     });
     return Promise.resolve();
   }
-  fetchMore = () => {
-    if (this.#pendingPageFetch) {
-      return this.#pendingPageFetch;
-    }
-    if (this.pendingFetch) {
-      this.#pendingPageFetch = new Promise(async (res) => {
-        await this.pendingFetch;
-        res(this.fetchMore());
-      });
-      return this.#pendingPageFetch;
+  /**
+   * Template method for fetching a page of data and updating the store
+   * Provides common error handling and abort signal checking
+   *
+   * @param status The status to set for the entry
+   * @param signal Optional AbortSignal for cancellation
+   * @returns A promise that resolves to the updated entry or undefined if aborted
+   */
+  async fetchPageAndUpdate(status, signal) {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "fetchPageAndUpdate"
+      }).debug(`Fetching data with status: ${status}`);
     }
-    if (this.#nextPageToken == null) {
-      return Promise.resolve();
+    if (signal?.aborted) {
+      return void 0;
     }
-    this.store.batch({}, (batch) => {
-      this.setStatus("loading", batch);
-    });
-    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;
     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
-        } : {}
-      });
+      const result = await this.fetchPageData(signal);
       if (signal?.aborted) {
-        return;
-      }
-      this.#nextPageToken = nextPageToken;
-      if (this.#type === "interface") {
-        data = await reloadDataAsFullObjects(this.store.client, data);
+        return void 0;
       }
       const {
         retVal
       } = this.store.batch({}, (batch) => {
-        return this._updateList(storeOsdkInstances(this.store, data, batch), append, nextPageToken ? status : "loaded", batch);
+        const append = this.nextPageToken != null;
+        const finalStatus = result.nextPageToken ? status : "loaded";
+        return this._updateList(this.store.objects.storeOsdkInstances(result.data, batch), finalStatus, batch, append);
       });
       return retVal;
-    } catch (e) {
-      this.logger?.error("error", e);
-      this.store.getSubject(this.cacheKey).error(e);
+    } catch (error) {
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.child({
+          methodName: "fetchPageAndUpdate"
+        }).error("Error fetching data", error);
+      }
+      if (!signal?.aborted) {
+        const {
+          retVal
+        } = this.store.batch({}, (batch) => {
+          return this.handleFetchError(error, status, batch);
+        });
+        return retVal;
+      }
+      return void 0;
     }
   }
   /**
-   * Will revalidate the list if its query is affected by invalidating the
-   * apiName of the object type passed in.
+   * Abstract method that subclasses implement for their specific data fetching logic
    *
-   * @param apiName to invalidate
-   * @returns
+   * @param signal Optional AbortSignal for cancellation
+   * @returns A promise that resolves to the fetched data
    */
-  revalidateObjectType = async (apiName) => {
-    if (this.#type === "object") {
-      if (this.#apiName === apiName) {
-        await this.revalidate(
-          /* force */
-          true
-        );
-        return;
-      } else {
-        return;
-      }
+  /**
+   * Handle fetch errors by setting appropriate error state
+   * Default implementation that subclasses can override
+   *
+   * @param error The error that occurred
+   * @param status The intended status if successful
+   * @param batch The batch context to use
+   * @returns The updated entry with error status
+   */
+  handleFetchError(_error, _status, batch) {
+    return this.writeToStore({
+      data: []
+    }, "error", batch);
+  }
+  /**
+   * Sort the collection items using the configured sorting strategy
+   * @param objectCacheKeys - The cache keys to sort
+   * @param batch - The batch context
+   * @returns Sorted array of cache keys
+   */
+  _sortCacheKeys(objectCacheKeys, batch) {
+    return this.sortingStrategy.sortCacheKeys(objectCacheKeys, batch);
+  }
+  /**
+   * Unified method for updating collection data in the store
+   * Handles storing, sorting, deduplication, and reference counting
+   *
+   * @param items - Either object cache keys or object instances to update
+   * @param options - Configuration options for the update
+   * @param batch - The batch context to use
+   * @returns The updated entry
+   */
+  updateCollection(items, options, batch) {
+    if (process.env.NODE_ENV !== "production") {
+      const logger = process.env.NODE_ENV !== "production" ? this.logger?.child({
+        methodName: "updateCollection"
+      }) : this.logger;
+      logger?.debug(`{status: ${options.status}, append: ${options.append}}`, JSON.stringify(items, null, 2));
     }
-    const objectMetadata = await this.store.client.fetchMetadata({
+    let objectCacheKeys;
+    if (items.length === 0) {
+      objectCacheKeys = [];
+    } else if (isObjectInstance(items[0])) {
+      objectCacheKeys = this.store.objects.storeOsdkInstances(items, batch);
+    } else {
+      objectCacheKeys = items;
+    }
+    objectCacheKeys = this.#retainReleaseAppend(batch, options.append ?? false, objectCacheKeys);
+    objectCacheKeys = this._sortCacheKeys(objectCacheKeys, batch);
+    objectCacheKeys = removeDuplicates(objectCacheKeys, batch);
+    return this.writeToStore({
+      data: objectCacheKeys
+    }, options.status, batch);
+  }
+};
+
+// src/observable/internal/links/SpecificLinkQuery.ts
+var SpecificLinkQuery = class extends BaseListQuery {
+  #sourceApiName;
+  #sourcePk;
+  #linkName;
+  #whereClause;
+  #orderBy;
+  /**
+   * Register changes to the cache specific to SpecificLinkQuery
+   */
+  registerCacheChanges(batch) {
+    batch.changes.modified.add(this.cacheKey);
+  }
+  constructor(store, subject, cacheKey, opts) {
+    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkGVGP7T5P_cjs.additionalContext].logger?.child({}, {
+      msgPrefix: `SpecificLinkQuery<${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>`
+    }) : void 0);
+    [this.#sourceApiName, this.#sourcePk, this.#linkName, this.#whereClause, this.#orderBy] = cacheKey.otherKeys;
+    this.sortingStrategy = new OrderBySortingStrategy(this.#linkName, this.#orderBy);
+  }
+  // _fetchAndStore is now implemented in BaseCollectionQuery
+  /**
+   * Implements fetchPageData from the BaseCollectionQuery template method pattern
+   * Fetches a page of linked objects
+   */
+  async fetchPageData(signal) {
+    const client = this.store.client;
+    const sourceObjectDef = {
       type: "object",
-      apiName
+      apiName: this.#sourceApiName
+    };
+    const sourceMetadata = await client[chunkGVGP7T5P_cjs.additionalContext].ontologyProvider.getObjectDefinition(this.#sourceApiName);
+    const sourceQuery = client(sourceObjectDef).where({
+      [sourceMetadata.primaryKeyApiName]: this.#sourcePk
     });
-    if (this.#apiName in objectMetadata.interfaceMap) {
-      await this.revalidate(
-        /* force */
-        true
-      );
+    const linkQuery = sourceQuery.pivotTo(this.#linkName);
+    if (signal?.aborted) {
+      throw new Error("Aborted");
+    }
+    const queryParams = {
+      $pageSize: this.options.pageSize || 100,
+      $nextPageToken: this.nextPageToken
+    };
+    if (this.#orderBy && Object.keys(this.#orderBy).length > 0) {
+      queryParams.$orderBy = this.#orderBy;
+    }
+    if (this.#whereClause && Object.keys(this.#whereClause).length > 0) {
+      queryParams.$where = this.#whereClause;
+    }
+    const response = await linkQuery.fetchPage(queryParams);
+    this.nextPageToken = response.nextPageToken;
+    return response;
+  }
+  /**
+   * Removes a link query from the store
+   */
+  deleteFromStore(status, batch) {
+    const entry = batch.read(this.cacheKey);
+    if (entry && deepEqual4__default.default(tombstone, entry.value)) {
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.child({
+          methodName: "deleteFromStore"
+        }).debug(`Links were already deleted, just setting status`);
+      }
+      return batch.write(this.cacheKey, entry.value, status);
+    }
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "deleteFromStore"
+      }).debug(JSON.stringify({
+        status
+      }));
+    }
+    if (!entry || !entry.value) {
       return;
     }
+    const ret = batch.delete(this.cacheKey, status);
+    batch.changes.deleted.add(this.cacheKey);
+    return ret;
+  }
+  /**
+   * Implements Query.maybeUpdateAndRevalidate to handle cache invalidation
+   */
+  maybeUpdateAndRevalidate = async (changes, _optimisticId) => {
+    if (changes.modified.has(this.cacheKey)) {
+      return this.revalidate(true);
+    }
+    return Promise.resolve();
+  };
+  invalidateObjectType = (objectType, changes) => {
+    if (this.#sourceApiName === objectType) {
+      changes?.modified.add(this.cacheKey);
+      return this.revalidate(true);
+    } else {
+      return (async () => {
+        const sourceMetadata = await this.store.client[chunkGVGP7T5P_cjs.additionalContext].ontologyProvider.getObjectDefinition(this.#sourceApiName);
+        const linkDef = sourceMetadata.links?.[this.#linkName];
+        if (!linkDef || linkDef.targetType !== objectType) return;
+        const promise = this.revalidate(true);
+        changes?.modified.add(this.cacheKey);
+        return promise;
+      })();
+    }
+  };
+};
+
+// src/observable/internal/links/LinksHelper.ts
+var LinksHelper = class extends AbstractHelper {
+  constructor(store, cacheKeys, whereCanonicalizer, orderByCanonicalizer) {
+    super(store, cacheKeys);
+    this.whereCanonicalizer = whereCanonicalizer;
+    this.orderByCanonicalizer = orderByCanonicalizer;
+  }
+  getQuery(options) {
+    const {
+      apiName
+    } = options.srcType;
+    const canonWhere = this.whereCanonicalizer.canonicalize(options.where ?? {});
+    const canonOrderBy = this.orderByCanonicalizer.canonicalize(options.orderBy ?? {});
+    const linkCacheKey = this.cacheKeys.get("specificLink", apiName, options.pk, options.linkName, canonWhere, canonOrderBy);
+    return this.store.queries.get(linkCacheKey, () => {
+      return new SpecificLinkQuery(this.store, this.store.subjects.get(linkCacheKey), linkCacheKey, options);
+    });
+  }
+};
+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) : 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;
+}
+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) : 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;
+}
+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) : void 0;
+    }
+  }
+  return "$not" in whereClause;
+}
+function objectSortaMatchesWhereClause(o, whereClause, strict) {
+  if (deepEqual4__default.default({}, whereClause)) {
+    return true;
+  }
+  if (is$and(whereClause)) {
+    return whereClause.$and.every((w) => objectSortaMatchesWhereClause(o, w, strict));
+  }
+  if (is$or(whereClause)) {
+    return whereClause.$or.some((w) => objectSortaMatchesWhereClause(o, w, strict));
+  }
+  if (is$not(whereClause)) {
+    return !objectSortaMatchesWhereClause(o, whereClause.$not, strict);
+  }
+  return Object.entries(whereClause).every(([key, filter]) => {
+    if (typeof filter === "object") {
+      const realValue = o[key];
+      const [f] = Object.keys(filter);
+      const expected = filter[f];
+      switch (f) {
+        case "$eq":
+          return realValue === expected;
+        case "$gt":
+          return realValue > expected;
+        case "$lt":
+          return realValue < expected;
+        case "$gte":
+          return realValue >= expected;
+        case "$lte":
+          return realValue <= expected;
+        case "$ne":
+          return realValue !== expected;
+        case "$in":
+          return expected.$in.includes(realValue);
+        case "$isNull":
+          return realValue == null;
+        case "$startsWith":
+          return realValue.startsWith(expected);
+        case "$contains":
+        case "$containsAllTerms":
+        case "$containsAllTermsInOrder":
+        case "$containsAnyTerm":
+        case "$intersects":
+        case "$within":
+          return !strict;
+        default:
+          if (process.env.NODE_ENV !== "production") {
+            process.env.NODE_ENV !== "production" ? invariant2__default.default(false, `Unknown where filter ${f}`) : invariant2__default.default(false) ;
+          }
+          return !strict;
+      }
+    }
+    if (key in o) {
+      if (o[key] === filter) {
+        return true;
+      }
+    }
+    return false;
+  });
+}
+
+// src/observable/internal/list/ListQuery.ts
+var API_NAME_IDX = 1;
+var ListQuery = class extends BaseListQuery {
+  // pageSize?: number; // this is the internal page size. we need to track this properly
+  #whereClause;
+  // Using base class minResultsToLoad instead of a private property
+  #orderBy;
+  #objectSet;
+  /**
+   * Register changes to the cache specific to ListQuery
+   */
+  registerCacheChanges(batch) {
+    batch.changes.registerList(this.cacheKey);
+  }
+  constructor(store, subject, apiName, whereClause, orderBy, cacheKey, opts) {
+    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkGVGP7T5P_cjs.additionalContext].logger?.child({}, {
+      msgPrefix: `ListQuery<${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>`
+    }) : void 0);
+    this.apiName = apiName;
+    this.#whereClause = whereClause;
+    this.#orderBy = orderBy;
+    this.#objectSet = this.createObjectSet(store);
+    this.sortingStrategy = new OrderBySortingStrategy(this.apiName, this.#orderBy);
+    this.minResultsToLoad = 0;
+  }
+  get canonicalWhere() {
+    return this.#whereClause;
+  }
+  /**
+   * Create the ObjectSet for this query.
+   */
+  /**
+   * Implements fetchPageData from BaseCollectionQuery template method
+   * Fetches a page of data
+   */
+  async fetchPageData(signal) {
+    const resp = await this.#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) {
+      throw new Error("Aborted");
+    }
+    this.nextPageToken = resp.nextPageToken;
+    const fetchedData = await this.postProcessFetchedData(resp.data);
+    return {
+      ...resp,
+      data: fetchedData
+    };
+  }
+  /**
+   * Handle fetch errors by setting appropriate error state and notifying subscribers
+   */
+  handleFetchError(error, _status, batch) {
+    this.logger?.error("error", error);
+    this.store.subjects.get(this.cacheKey).error(error);
+    return this.writeToStore({
+      data: []
+    }, "error", batch);
+  }
+  /**
+   * Will revalidate the list if its query is affected by invalidating the
+   * apiName of the object type passed in.
+   *
+   * @param apiName to invalidate
+   * @returns
+   */
+  /**
+   * Postprocess fetched data.
+   */
+  invalidateObjectType = async (objectType, changes) => {
+    if (this.cacheKey.otherKeys[1] === objectType) {
+      changes?.modified.add(this.cacheKey);
+      return this.revalidate(true);
+    }
   };
   /**
    * Note: This method is not async because I want it to return right after it
@@ -1091,11 +1682,14 @@ var ListQuery = class extends BaseListQuery {
       this.logger?.child({
         methodName: "maybeUpdateAndRevalidate"
       }).debug(DEBUG_ONLY__changesToString(changes));
+      this.logger?.child({
+        methodName: "maybeUpdateAndRevalidate"
+      }).debug(`Already in changes? ${changes.modified.has(this.cacheKey)}`);
     }
     if (changes.modified.has(this.cacheKey)) return;
     changes.modified.add(this.cacheKey);
     try {
-      const relevantObjects = this._extractRelevantObjects(changes);
+      const relevantObjects = this._extractAndCategorizeRelevantObjects(changes);
       const status = optimisticId || relevantObjects.added.sortaMatches.size > 0 || relevantObjects.modified.sortaMatches.size > 0 ? "loading" : "loaded";
       const newList = [];
       let needsRevalidation = false;
@@ -1111,7 +1705,7 @@ var ListQuery = class extends BaseListQuery {
         const toRemove = new Set(changes.deleted);
         for (const obj of relevantObjects.modified.all) {
           if (relevantObjects.modified.strictMatches.has(obj)) {
-            const objectCacheKey = this.store.getCacheKey("object", obj.$objectType, obj.$primaryKey);
+            const objectCacheKey = this.cacheKeys.get("object", obj.$objectType, obj.$primaryKey);
             if (!existingList.has(objectCacheKey)) {
               toAdd.add(obj);
             }
@@ -1119,7 +1713,7 @@ var ListQuery = class extends BaseListQuery {
           } else if (batch.optimisticWrite) {
             continue;
           } else {
-            const existingObjectCacheKey = this.store.getCacheKey("object", obj.$objectType, obj.$primaryKey);
+            const existingObjectCacheKey = this.cacheKeys.get("object", obj.$objectType, obj.$primaryKey);
             toRemove.add(existingObjectCacheKey);
             if (relevantObjects.modified.sortaMatches.has(obj)) {
               needsRevalidation = true;
@@ -1131,14 +1725,14 @@ var ListQuery = class extends BaseListQuery {
           newList.push(key);
         }
         for (const obj of toAdd) {
-          newList.push(this.store.getCacheKey("object", obj.$objectType, obj.$primaryKey));
+          newList.push(this.cacheKeys.get("object", obj.$objectType, obj.$primaryKey));
         }
         this._updateList(
           newList,
-          /* append */
-          false,
           status,
-          batch
+          batch,
+          /* append */
+          false
         );
       });
       if (needsRevalidation) {
@@ -1151,76 +1745,32 @@ var ListQuery = class extends BaseListQuery {
           methodName: "maybeUpdateAndRevalidate"
         }).debug("in finally");
       }
-    }
-  };
-  #matchType(obj) {
-    if (objectSortaMatchesWhereClause(obj, this.#whereClause, true)) {
-      return "strict";
-    }
-    if (objectSortaMatchesWhereClause(obj, this.#whereClause, false)) {
-      return "sorta";
-    }
-    return false;
-  }
-  _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 matchType = this.#matchType(obj);
-        if (matchType) {
-          group[`${matchType}Matches`].add(obj);
-        }
-      }
-    }
-    return relevantObjects;
-  }
-  #extractRelevantObjectsForTypeInterface(changes) {
-    const matchesApiName = ([, object]) => {
-      return this.#apiName in object[chunk26WFEZQO_cjs.ObjectDefRef].interfaceMap;
-    };
-    const added = Array.from(changes.addedObjects).filter(matchesApiName).map(([, object]) => object.$as(this.#apiName));
-    const modified = Array.from(changes.modifiedObjects).filter(matchesApiName).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()
-      }
-    };
-  }
-  #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()
-      }
-    };
+    }
+  };
+  #matchType(obj) {
+    if (objectSortaMatchesWhereClause(obj, this.#whereClause, true)) {
+      return "strict";
+    }
+    if (objectSortaMatchesWhereClause(obj, this.#whereClause, false)) {
+      return "sorta";
+    }
+    return false;
   }
-  _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;
-          }
+  _extractAndCategorizeRelevantObjects(changes) {
+    const relevantObjects = this.extractRelevantObjects(changes);
+    for (const group of Object.values(relevantObjects)) {
+      for (const obj of group.all ?? []) {
+        const matchType = this.#matchType(obj);
+        if (matchType) {
+          group[`${matchType}Matches`].add(obj);
         }
-        return 0;
-      });
+      }
     }
-    return objectCacheKeys;
+    return relevantObjects;
   }
+  /**
+   * Extract relevant objects for this query type.
+   */
   registerStreamUpdates(sub) {
     const logger = process.env.NODE_ENV !== "production" ? this.logger?.child({
       methodName: "registerStreamUpdates"
@@ -1231,10 +1781,10 @@ var ListQuery = class extends BaseListQuery {
       }).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)
+      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") {
@@ -1245,28 +1795,28 @@ var ListQuery = class extends BaseListQuery {
       websocketSubscription.unsubscribe();
     });
   }
-  #onOswSuccessfulSubscription() {
+  onOswSuccessfulSubscription() {
     if (process.env.NODE_ENV !== "production") {
       this.logger?.child({
         methodName: "onSuccessfulSubscription"
       }).debug("");
     }
   }
-  #onOswOutOfDate() {
+  onOswOutOfDate() {
     if (process.env.NODE_ENV !== "production") {
       this.logger?.child({
         methodName: "onOutOfDate"
       }).debug("");
     }
   }
-  #onOswError(errors) {
+  onOswError(errors) {
     if (this.logger) {
       this.logger?.child({
         methodName: "onError"
       }).error("subscription errors", errors);
     }
   }
-  #onOswChange({
+  onOswChange({
     object: objOrIface,
     state
   }) {
@@ -1281,18 +1831,18 @@ var ListQuery = class extends BaseListQuery {
     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);
+        this.store.objects.storeOsdkInstances([object], batch);
       });
     } else if (state === "REMOVED") {
-      this.#onOswRemoved(objOrIface, logger);
+      this.onOswRemoved(objOrIface, logger);
     }
   }
-  #onOswRemoved(objOrIface, logger) {
+  onOswRemoved(objOrIface, logger) {
     this.store.batch({}, (batch) => {
       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 objectCacheKey = this.cacheKeys.get("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);
@@ -1318,41 +1868,54 @@ var ListQuery = class extends BaseListQuery {
     });
   }
 };
-function removeDuplicates(objectCacheKeys, batch) {
-  const visited = /* @__PURE__ */ new Set();
-  objectCacheKeys = objectCacheKeys.filter((key) => {
-    batch.read(key);
-    if (visited.has(key)) {
-      return false;
+
+// src/observable/internal/list/InterfaceListQuery.ts
+var InterfaceListQuery = class extends ListQuery {
+  createObjectSet(store) {
+    return store.client({
+      type: "interface",
+      apiName: this.apiName
+    }).where(this.canonicalWhere);
+  }
+  async revalidateObjectType(apiName) {
+    const objectMetadata = await this.store.client.fetchMetadata({
+      type: "object",
+      apiName
+    });
+    if (this.apiName in objectMetadata.interfaceMap) {
+      await this.revalidate(
+        /* force */
+        true
+      );
     }
-    visited.add(key);
-    return true;
-  });
-  return objectCacheKeys;
-}
-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;
+  }
+  async postProcessFetchedData(data) {
+    return reloadDataAsFullObjects(this.store.client, data);
+  }
+  extractRelevantObjects(changes) {
+    const matchesApiName = ([, object]) => {
+      return this.apiName in object[chunkYADG7KA6_cjs.ObjectDefRef].interfaceMap;
+    };
+    const added = Array.from(changes.addedObjects).filter(matchesApiName).map(([, object]) => object.$as(this.apiName));
+    const modified = Array.from(changes.modifiedObjects).filter(matchesApiName).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 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][chunk26WFEZQO_cjs.UnderlyingOsdkObject][chunk26WFEZQO_cjs.ObjectDefRef];
+    const objectDef = objects[0][chunkYADG7KA6_cjs.UnderlyingOsdkObject][chunkYADG7KA6_cjs.ObjectDefRef];
     const where = {
       [objectDef.primaryKeyApiName]: {
         $in: objects.map((x) => x.$primaryKey)
@@ -1367,9 +1930,292 @@ async function reloadDataAsFullObjects(client, data) {
   });
   return data;
 }
-function isListCacheKey(cacheKey) {
-  return cacheKey.type === "list";
+
+// src/observable/internal/list/ObjectListQuery.ts
+var ObjectListQuery = class extends ListQuery {
+  createObjectSet(store) {
+    return store.client({
+      type: "object",
+      apiName: this.apiName
+    }).where(this.canonicalWhere);
+  }
+  async revalidateObjectType(apiName) {
+    if (this.apiName === apiName) {
+      await this.revalidate(
+        /* force */
+        true
+      );
+    }
+  }
+  postProcessFetchedData(data) {
+    return Promise.resolve(data);
+  }
+  extractRelevantObjects(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()
+      }
+    };
+  }
+};
+
+// src/observable/internal/list/ListsHelper.ts
+var ListsHelper = class extends AbstractHelper {
+  constructor(store, cacheKeys, whereCanonicalizer, orderByCanonicalizer) {
+    super(store, cacheKeys);
+    this.whereCanonicalizer = whereCanonicalizer;
+    this.orderByCanonicalizer = orderByCanonicalizer;
+  }
+  observe(options, subFn) {
+    const ret = super.observe(options, subFn);
+    if (options.streamUpdates) {
+      ret.query.registerStreamUpdates(ret.subscription);
+    }
+    return ret;
+  }
+  getQuery(options) {
+    const {
+      type: {
+        apiName,
+        type
+      },
+      where,
+      orderBy
+    } = options;
+    const canonWhere = this.whereCanonicalizer.canonicalize(where ?? {});
+    const canonOrderBy = this.orderByCanonicalizer.canonicalize(orderBy ?? {});
+    const listCacheKey = this.cacheKeys.get("list", type, apiName, canonWhere, canonOrderBy);
+    return this.store.queries.get(listCacheKey, () => {
+      const QueryClass = type === "object" ? ObjectListQuery : InterfaceListQuery;
+      return new QueryClass(this.store, this.store.subjects.get(listCacheKey), apiName, canonWhere, canonOrderBy, listCacheKey, options);
+    });
+  }
+};
+
+// ../../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[chunkGVGP7T5P_cjs.additionalContext].logger;
+    this.#maxWait = maxWait;
+    this.#maxEntries = maxEntries;
+  }
+  async 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 await 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: ${primaryKey}`));
+      }
+    }
+  }
+};
+
+// src/observable/internal/object/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[chunkGVGP7T5P_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"
+      }).debug("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 && deepEqual4__default.default(data, entry.value)) {
+      if (entry.status === status) {
+        if (process.env.NODE_ENV !== "production") {
+          this.logger?.child({
+            methodName: "writeToStore"
+          }).debug(`Object was deep equal and status unchanged (${status}), skipping update`);
+        }
+        return entry;
+      }
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.child({
+          methodName: "writeToStore"
+        }).debug(`Object was deep equal, just setting status (old status: ${entry.status}, new status: ${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;
+  }
+  deleteFromStore(status, batch) {
+    const entry = batch.read(this.cacheKey);
+    if (entry && deepEqual4__default.default(tombstone, entry.value)) {
+      if (process.env.NODE_ENV !== "production") {
+        this.logger?.child({
+          methodName: "deleteFromStore"
+        }).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: "deleteFromStore"
+      }).debug(JSON.stringify({
+        status
+      }));
+    }
+    if (!entry || !entry.value) {
+      return;
+    }
+    const ret = batch.delete(this.cacheKey, status);
+    batch.changes.deleteObject(this.cacheKey);
+    return ret;
+  }
+  invalidateObjectType = (objectType, changes) => {
+    if (this.#apiName === objectType) {
+      changes?.modified.add(this.cacheKey);
+      return this.revalidate(true);
+    }
+    return Promise.resolve();
+  };
+};
+
+// src/observable/internal/object/ObjectsHelper.ts
+var ObjectsHelper = class extends AbstractHelper {
+  observe(options, subFn) {
+    return super.observe(options, subFn);
+  }
+  getQuery(options) {
+    const apiName = typeof options.apiName === "string" ? options.apiName : options.apiName.apiName;
+    const {
+      pk
+    } = options;
+    const objectCacheKey = this.cacheKeys.get("object", apiName, pk);
+    return this.store.queries.get(objectCacheKey, () => new ObjectQuery(this.store, this.store.subjects.get(objectCacheKey), apiName, pk, objectCacheKey, {
+      dedupeInterval: 0
+    }));
+  }
+  /**
+   * Internal helper method for writing objects to the store and returning their
+   * object keys
+   * @internal
+   */
+  storeOsdkInstances(values, batch) {
+    return values.map((v) => this.getQuery({
+      apiName: v.$apiName,
+      pk: v.$primaryKey
+    }).writeToStore(v, "loaded", batch).cacheKey);
+  }
+};
 var defaultMakeData = () => /* @__PURE__ */ Object.create(null);
 var WeakRefTrie = class {
   #finalizer = new FinalizationRegistry((orderBy) => {
@@ -1404,6 +2250,8 @@ var WeakRefTrie = class {
     return this.#trie.removeArray(array)?.deref();
   }
 };
+
+// src/observable/internal/OrderByCanonicalizer.ts
 var OrderByCanonicalizer = class {
   #trie = new WeakRefTrie((array) => {
     const pairs = array.reduce(function(result, _, index, array2) {
@@ -1424,49 +2272,28 @@ var OrderByCanonicalizer = class {
   };
 };
 
-// src/observable/internal/RefCounts.ts
-var RefCounts = class {
-  refCounts = /* @__PURE__ */ new Map();
-  // keeps our objects around for some extended duration after they are no longer
-  // needed which is good for quick clicks across tabs.
-  gcMap = /* @__PURE__ */ new Map();
-  constructor(keepAlive, cleanup) {
-    this.keepAlive = keepAlive;
-    this.cleanup = cleanup;
-  }
-  register(key) {
-    if (!this.refCounts.has(key)) {
-      this.gcMap.set(key, Date.now() + this.keepAlive);
-    }
-    return key;
-  }
-  retain(key) {
-    const count = this.refCounts.get(key) ?? 0;
-    this.refCounts.set(key, count + 1);
-    if (this.gcMap.has(key)) {
-      this.gcMap.delete(key);
-    }
+// src/observable/internal/Queries.ts
+var Queries = class {
+  // we can use a regular Map here because the refCounting will
+  // handle cleanup.
+  map = /* @__PURE__ */ new Map();
+  peek(cacheKey) {
+    return this.map.get(cacheKey);
   }
-  release(key) {
-    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 {
-      this.refCounts.set(key, count - 1);
+  get(cacheKey, createQuery) {
+    let query = this.peek(cacheKey);
+    if (!query) {
+      query = createQuery();
+      this.map.set(cacheKey, query);
     }
+    return query;
   }
-  has(key) {
-    return this.refCounts.has(key);
+  keys() {
+    return this.map.keys();
   }
-  gc() {
-    const now = Date.now();
-    for (const [key, deathTime] of this.gcMap) {
-      if (deathTime < now) {
-        this.gcMap.delete(key);
-        this.cleanup(key);
-      }
-    }
+  delete(cacheKey) {
+    this.map.get(cacheKey)?.dispose();
+    this.map.delete(cacheKey);
   }
 };
 var WhereClauseCanonicalizer = class {
@@ -1501,7 +2328,7 @@ var WhereClauseCanonicalizer = class {
       options: []
     };
     this.#existingOptions.set(cacheKey, lookupEntry);
-    const canon = lookupEntry.options.find((ref) => deepEqual2__default.default(ref.deref(), calculatedCanon))?.deref() ?? calculatedCanon;
+    const canon = lookupEntry.options.find((ref) => deepEqual4__default.default(ref.deref(), calculatedCanon))?.deref() ?? calculatedCanon;
     if (canon === calculatedCanon) {
       lookupEntry.options.push(new WeakRef(canon));
     }
@@ -1535,65 +2362,40 @@ var WhereClauseCanonicalizer = class {
 };
 
 // src/observable/internal/Store.ts
-function createInitEntry(cacheKey) {
-  return {
-    cacheKey,
-    status: "init",
-    value: void 0,
-    lastUpdated: 0
-  };
-}
 var Store = class {
   whereCanonicalizer = new WhereClauseCanonicalizer();
   orderByCanonicalizer = new OrderByCanonicalizer();
-  #truthLayer = new Layer(void 0, void 0);
-  #topLayer;
   /** @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;
+  queries = new Queries();
+  layers = new Layers({
+    logger: this.logger,
+    onRevalidate: this.#maybeRevalidateQueries.bind(this)
+  });
+  subjects = this.layers.subjects;
+  // these are hopefully temporary
   constructor(client) {
-    this.client = client;
-    this.logger = client[chunk633AI7EA_cjs.additionalContext].logger?.child({}, {
+    this.logger = client[chunkGVGP7T5P_cjs.additionalContext].logger?.child({}, {
       msgPrefix: "Store"
     });
-    this.#topLayer = this.#truthLayer;
-    this.#cacheKeys = new CacheKeys(this.whereCanonicalizer, this.orderByCanonicalizer, (k) => {
-      this.#refCounts.register(k);
-    });
-    setInterval(() => {
-      this.#refCounts.gc();
-    }, 1e3);
-    this.#finalizationRegistry = new FinalizationRegistry((cleanupCallback) => {
-      try {
-        cleanupCallback();
-      } catch (e) {
-        console.error("Caught an error while running a finalization callback", e);
-      }
+    this.client = client;
+    this.cacheKeys = new CacheKeys({
+      onDestroy: this.#cleanupCacheKey
     });
+    this.lists = new ListsHelper(this, this.cacheKeys, this.whereCanonicalizer, this.orderByCanonicalizer);
+    this.objects = new ObjectsHelper(this, this.cacheKeys);
+    this.links = new LinksHelper(this, this.cacheKeys, this.whereCanonicalizer, this.orderByCanonicalizer);
   }
   /**
    * Called after a key is no longer retained and the timeout has elapsed
    * @param key
    */
   #cleanupCacheKey = (key) => {
-    const subject = this.peekSubject(key);
-    this.#cacheKeys.remove(key);
+    const subject = this.subjects.peek(key);
     if (process.env.NODE_ENV !== "production") {
       !subject ? process.env.NODE_ENV !== "production" ? invariant2__default.default(false) : invariant2__default.default(false) : void 0;
     }
-    if (subject) {
-      subject.complete();
-      this.#cacheKeyToSubject.delete(key);
-    }
-    this.#queries.get(key)?.dispose();
-    this.#queries.delete(key);
+    this.subjects.delete(key);
+    this.queries.delete(key);
   };
   applyAction = async (action, args, opts) => {
     return await new ActionApplication(this).applyAction(action, args, opts);
@@ -1605,228 +2407,68 @@ var Store = class {
     });
     return result;
   };
-  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) : void 0;
-    let currentLayer = this.#topLayer;
-    const cacheKeys = /* @__PURE__ */ new Map();
-    while (currentLayer != null && currentLayer.parentLayer != null) {
-      if (currentLayer.layerId === layerId) {
-        for (const [k, v] of currentLayer.entries()) {
-          if (cacheKeys.has(k)) continue;
-          cacheKeys.set(k, v);
-        }
-      }
-      currentLayer = currentLayer.parentLayer;
-    }
-    this.#topLayer = this.#topLayer.removeLayer(layerId);
-    for (const [k, oldEntry] of cacheKeys) {
-      const currentEntry = this.#topLayer.get(k);
-      if (oldEntry !== currentEntry) {
-        this.peekSubject(k)?.next({
-          // eslint-disable-next-line @typescript-eslint/no-misused-spread
-          ...currentEntry ?? createInitEntry(k),
-          isOptimistic: currentEntry?.value !== this.#truthLayer.get(k)?.value
-        });
-      }
-    }
-  }
-  getCacheKey(type, ...args) {
-    return this.#refCounts.register(this.#cacheKeys.get(type, ...args));
-  }
-  peekSubject = (cacheKey) => {
-    return this.#cacheKeyToSubject.get(cacheKey);
-  };
-  getSubject = (cacheKey) => {
-    let subject = this.#cacheKeyToSubject.get(cacheKey);
-    if (!subject) {
-      const initialValue = this.#topLayer.get(cacheKey) ?? createInitEntry(cacheKey);
-      subject = new rxjs.BehaviorSubject({
-        // eslint-disable-next-line @typescript-eslint/no-misused-spread
-        ...initialValue,
-        isOptimistic: initialValue.value !== this.#truthLayer.get(cacheKey)?.value
-      });
-      this.#cacheKeyToSubject.set(cacheKey, subject);
-    }
-    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.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 {
-          throw e;
-        }
-      });
-    }
-    const sub = query.subscribe(subFn);
-    return {
-      unsubscribe: () => {
-        sub.unsubscribe();
-        this.release(query.cacheKey);
-      }
-    };
-  }
-  observeList(options, subFn) {
-    const query = this.getListQuery(options.type, options.where ?? {}, options.orderBy ?? {}, options);
-    this.retain(query.cacheKey);
-    if (options.mode !== "offline") {
-      query.revalidate(options.mode === "force").catch((x) => {
-        subFn.error(x);
-      });
-    }
-    const sub = query.subscribe(subFn);
-    if (options.streamUpdates) {
-      query.registerStreamUpdates(sub);
-    }
-    return {
-      unsubscribe: () => {
-        sub.unsubscribe();
-        this.release(query.cacheKey);
-      }
-    };
-  }
-  peekQuery(cacheKey) {
-    return this.#queries.get(cacheKey);
-  }
-  #getQuery(cacheKey, createQuery) {
-    let query = this.peekQuery(cacheKey);
-    if (!query) {
-      query = createQuery();
-      this.#queries.set(cacheKey, query);
-    }
-    return query;
-  }
-  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", type, apiName, canonWhere, canonOrderBy);
-    return this.#getQuery(listCacheKey, () => {
-      return new ListQuery(this, this.getSubject(listCacheKey), type, apiName, canonWhere, canonOrderBy, listCacheKey, opts);
-    });
-  }
-  getObjectQuery(apiName, pk) {
-    if (typeof apiName !== "string") {
-      apiName = apiName.apiName;
-    }
-    const objectCacheKey = this.getCacheKey("object", apiName, pk);
-    return this.#getQuery(objectCacheKey, () => new ObjectQuery(this, this.getSubject(objectCacheKey), apiName, pk, objectCacheKey, {
-      dedupeInterval: 0
-    }));
-  }
   getValue(cacheKey) {
-    return this.#topLayer.get(cacheKey);
+    return this.layers.top.get(cacheKey);
   }
-  batch = ({
+  batch({
     optimisticId,
     changes = createChangedObjects()
-  }, batchFn) => {
-    !(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: () => {
-        if (needsLayer) {
-          this.#topLayer = this.#topLayer.addLayer(optimisticId);
-          needsLayer = false;
-        }
-      },
-      optimisticWrite: !!optimisticId,
-      write: (cacheKey, value, status) => {
-        const oldTopValue = this.#topLayer.get(cacheKey);
-        if (optimisticId) batchContext.createLayerIfNeeded();
-        const writeLayer = optimisticId ? this.#topLayer : this.#truthLayer;
-        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
-          });
-        }
-        return newValue;
-      },
-      delete: (cacheKey, status) => {
-        return batchContext.write(cacheKey, tombstone, status);
-      },
-      read: (cacheKey) => {
-        return optimisticId ? this.#topLayer.get(cacheKey) : this.#truthLayer.get(cacheKey);
-      }
-    };
-    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,
-      changes: batchContext.changes
-    };
-  };
+  }, batchFn) {
+    return this.layers.batch({
+      optimisticId,
+      changes
+    }, batchFn);
+  }
   invalidateObject(apiName, pk) {
     if (typeof apiName !== "string") {
       apiName = apiName.apiName;
     }
-    return this.getObjectQuery(apiName, pk).revalidate(
+    return this.objects.getQuery({
+      apiName,
+      pk
+    }).revalidate(
       /* force */
       true
     );
   }
-  async maybeRevalidateQueries(changes, optimisticId) {
+  async #maybeRevalidateQueries(changes, optimisticId) {
+    const logger = process.env.NODE_ENV !== "production" ? this.logger?.child({
+      methodName: "maybeRevalidateQueries"
+    }) : void 0;
     if (changes.isEmpty()) {
       if (process.env.NODE_ENV !== "production") {
-        this.logger?.child({
-          methodName: "maybeRevalidateQueries"
-        }).debug("No changes, aborting");
+        logger?.debug("No changes, aborting");
       }
       return;
     }
     if (process.env.NODE_ENV !== "production") {
-      this.logger?.child({
-        methodName: "maybeRevalidateQueries"
-      }).debug(DEBUG_ONLY__changesToString(changes), {
+      logger?.debug(DEBUG_ONLY__changesToString(changes), {
         optimisticId
       });
     }
     try {
       const promises = [];
-      for (const cacheKey of this.#queries.keys()) {
-        const promise = this.peekQuery(cacheKey)?.maybeUpdateAndRevalidate?.(changes, optimisticId);
+      for (const cacheKey of this.queries.keys()) {
+        const promise = this.queries.peek(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));
+        logger?.debug("in finally", DEBUG_ONLY__changesToString(changes));
       }
     }
   }
   /**
-   * @param apiName
-   * @param changes The changes we know about / to update
-   * @returns
+   * Invalidates all cache entries for a specific object type.
+   * This will revalidate:
+   * 1. All objects of the specified type
+   * 2. All lists of the specified type
+   * 3. All links where the source object is of the specified type
+   *
+   * @param apiName - The API name of the object type to invalidate
+   * @param changes - Optional changes object to track what has been modified
+   * @returns Promise that resolves when all invalidations are complete
    */
   invalidateObjectType(apiName, changes) {
     if (typeof apiName !== "string") {
@@ -1838,33 +2480,42 @@ var Store = class {
       }).info(changes ? DEBUG_ONLY__changesToString(changes) : void 0);
     }
     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);
-          }
-        }
+    for (const cacheKey of this.layers.truth.keys()) {
+      if (changes && changes.modified.has(cacheKey)) {
+        continue;
       }
+      const query = this.queries.peek(cacheKey);
+      if (!query) continue;
+      promises.push(query.invalidateObjectType(apiName, changes));
     }
-    return Promise.all(promises).then(() => void 0);
+    return Promise.allSettled(promises).then(() => void 0);
   }
-  retain(cacheKey) {
-    this.#refCounts.retain(cacheKey);
+  async invalidateAll() {
+    const promises = [];
+    for (const cacheKey of this.queries.keys()) {
+      const query = this.queries.peek(cacheKey);
+      if (query) {
+        promises.push(query.revalidate(true));
+      }
+    }
+    return Promise.allSettled(promises).then(() => void 0);
   }
-  release(cacheKey) {
-    this.#refCounts.release(cacheKey);
+  async invalidateObjects(objects) {
+    const objectsArray = Array.isArray(objects) ? objects : [objects];
+    const promises = [];
+    for (const obj of objectsArray) {
+      promises.push(this.invalidateObject(obj.$objectType, obj.$primaryKey));
+    }
+    return Promise.allSettled(promises).then(() => void 0);
   }
 };
 
 // src/observable/ObservableClient.ts
 function createObservableClient(client) {
-  const tweakedClient = chunk26WFEZQO_cjs.createClientFromContext({
-    ...client[chunk633AI7EA_cjs.additionalContext],
-    fetch: shared_net_fetch.createFetchHeaderMutator(client[chunk633AI7EA_cjs.additionalContext].fetch, (headers) => {
-      headers.set("Fetch-User-Agent", [headers.get("Fetch-User-Agent"), chunk26WFEZQO_cjs.OBSERVABLE_USER_AGENT].filter((x) => x && x?.length > 0).join(" "));
+  const tweakedClient = chunkYADG7KA6_cjs.createClientFromContext({
+    ...client[chunkGVGP7T5P_cjs.additionalContext],
+    fetch: shared_net_fetch.createFetchHeaderMutator(client[chunkGVGP7T5P_cjs.additionalContext].fetch, (headers) => {
+      headers.set("Fetch-User-Agent", [headers.get("Fetch-User-Agent"), chunkYADG7KA6_cjs.OBSERVABLE_USER_AGENT].filter((x) => x && x?.length > 0).join(" "));
       return headers;
     })
   });
@@ -1907,11 +2558,11 @@ function getOsdkConfig(ontologyRid) {
 
 Object.defineProperty(exports, "createClientWithTransaction", {
   enumerable: true,
-  get: function () { return chunk26WFEZQO_cjs.createClientWithTransaction; }
+  get: function () { return chunkYADG7KA6_cjs.createClientWithTransaction; }
 });
 Object.defineProperty(exports, "augment", {
   enumerable: true,
-  get: function () { return chunk633AI7EA_cjs.augment; }
+  get: function () { return chunkGVGP7T5P_cjs.augment; }
 });
 exports.createObservableClient = createObservableClient;
 exports.getMetaTagContent = getMetaTagContent;