@osdk/client 2.6.0-beta.7 → 2.6.0-beta.9

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

@@ -1,8 +1,8 @@
 'use strict';
 
-var chunk4ZOXOCQX_cjs = require('../chunk-4ZOXOCQX.cjs');
-var chunk3LMKH6RS_cjs = require('../chunk-3LMKH6RS.cjs');
-require('../chunk-Q7SFCCGT.cjs');
+var chunkS4JPAF56_cjs = require('../chunk-S4JPAF56.cjs');
+var chunkDZE6IAUU_cjs = require('../chunk-DZE6IAUU.cjs');
+var chunk6SCDLAU2_cjs = require('../chunk-6SCDLAU2.cjs');
 var trie = require('@wry/trie');
 var deepEqual = require('fast-deep-equal');
 var invariant4 = require('tiny-invariant');
@@ -18,6 +18,17 @@ var deepEqual__default = /*#__PURE__*/_interopDefault(deepEqual);
 var invariant4__default = /*#__PURE__*/_interopDefault(invariant4);
 var groupBy__default = /*#__PURE__*/_interopDefault(groupBy);
 
+// src/public/unstable-do-not-use.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/computeObjectSetCacheKey.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/OrderByCanonicalizer.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/WeakRefTrie.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
 var defaultMakeData = () => /* @__PURE__ */ Object.create(null);
 var WeakRefTrie = class {
   #finalizer = new FinalizationRegistry((orderBy) => {
@@ -70,6 +81,9 @@ var OrderByCanonicalizer = class {
     return this.#trie.lookupArray(strings);
   };
 };
+
+// src/observable/internal/WhereClauseCanonicalizer.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
 var WhereClauseCanonicalizer = class {
   /**
    * This is a shortcut cache for any WhereClause's that we have
@@ -139,7 +153,7 @@ var WhereClauseCanonicalizer = class {
 var whereCanonicalizer = new WhereClauseCanonicalizer();
 var orderByCanonicalizer = new OrderByCanonicalizer();
 function computeObjectSetCacheKey(objectSet, options) {
-  const keyParts = ["objectSet", chunk3LMKH6RS_cjs.getWireObjectSet(objectSet)];
+  const keyParts = ["objectSet", chunkDZE6IAUU_cjs.getWireObjectSet(objectSet)];
   if (!options) {
     return JSON.stringify(keyParts);
   }
@@ -151,13 +165,13 @@ function computeObjectSetCacheKey(objectSet, options) {
     keyParts.push("props", propKeys);
   }
   if (options.union && options.union.length > 0) {
-    keyParts.push("union", options.union.map((os) => chunk3LMKH6RS_cjs.getWireObjectSet(os)));
+    keyParts.push("union", options.union.map((os) => chunkDZE6IAUU_cjs.getWireObjectSet(os)));
   }
   if (options.intersect && options.intersect.length > 0) {
-    keyParts.push("intersect", options.intersect.map((os) => chunk3LMKH6RS_cjs.getWireObjectSet(os)));
+    keyParts.push("intersect", options.intersect.map((os) => chunkDZE6IAUU_cjs.getWireObjectSet(os)));
   }
   if (options.subtract && options.subtract.length > 0) {
-    keyParts.push("subtract", options.subtract.map((os) => chunk3LMKH6RS_cjs.getWireObjectSet(os)));
+    keyParts.push("subtract", options.subtract.map((os) => chunkDZE6IAUU_cjs.getWireObjectSet(os)));
   }
   if (options.pivotTo) {
     keyParts.push("pivotTo", options.pivotTo);
@@ -171,7 +185,14 @@ function computeObjectSetCacheKey(objectSet, options) {
   return JSON.stringify(keyParts);
 }
 
+// src/observable/ObservableClient.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/ObservableClientImpl.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
 // src/observable/internal/UnsubscribableWrapper.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
 var UnsubscribableWrapper = class {
   #subscription;
   constructor(subscription) {
@@ -207,6 +228,9 @@ var ObservableClientImpl = class {
       subFn
     );
   };
+  observeAggregation = (options, subFn) => {
+    return this.__experimentalStore.aggregations.observe(options, subFn);
+  };
   observeLinks = (objects, linkName, options, subFn) => {
     const objectsArray = Array.isArray(objects) ? objects : [objects];
     const parentSub = new rxjs.Subscription();
@@ -252,11 +276,22 @@ var ObservableClientImpl = class {
   }
 };
 
+// src/observable/internal/Store.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
 // src/observable/DebugFlags.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
 process.env.NODE_ENV !== "production" && false;
 var DEBUG_CACHE_KEYS = process.env.NODE_ENV !== "production" && false;
 
+// src/observable/internal/actions/ActionApplication.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/actions/OptimisticJob.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
 // src/observable/internal/OptimisticId.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
 function createOptimisticId() {
   if (process.env.NODE_ENV !== "production") {
     if (createOptimisticId.counter === void 0) {
@@ -316,7 +351,7 @@ var OptimisticJob = class {
         return this;
       },
       createObject(type, pk, properties) {
-        const create = store.client[chunk3LMKH6RS_cjs.additionalContext].objectFactory2(store.client[chunk3LMKH6RS_cjs.additionalContext], [{
+        const create = store.client[chunkDZE6IAUU_cjs.additionalContext].objectFactory2(store.client[chunkDZE6IAUU_cjs.additionalContext], [{
           $primaryKey: pk,
           $apiName: type.apiName,
           $objectType: type.apiName,
@@ -383,7 +418,7 @@ var ActionApplication = class {
         if (process.env.NODE_ENV !== "production") {
           if (ACTION_DELAY > 0) {
             logger?.debug("action done, pausing", actionResults);
-            const delay = (await import('../delay-QK4T7RVX.cjs')).default;
+            const delay = (await import('../delay-KIUUJ5NJ.cjs')).default;
             await delay(ACTION_DELAY);
             logger?.debug("action done, pausing done");
           }
@@ -441,735 +476,950 @@ var ActionApplication = class {
   };
 };
 
-// src/observable/internal/CacheKey.ts
-function DEBUG_ONLY__cacheKeyToString(x) {
-  if (process.env.NODE_ENV !== "production") {
-    return `${x.type}CacheKey<${x.otherKeys.map((xx) => JSON.stringify(xx)).join(", ")}>`.replaceAll('"', "'");
-  } else {
-    throw new Error("not implemented");
-  }
-}
-function DEBUG_ONLY__cacheKeysToString(x) {
-  if (process.env.NODE_ENV !== "production") {
-    return "\n  - " + x.map(DEBUG_ONLY__cacheKeyToString).join("\n  - ");
-  } else {
-    throw new Error("not implemented");
-  }
-}
+// src/observable/internal/aggregation/AggregationCacheKey.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+var API_NAME_IDX = 1;
+var WHERE_IDX = 2;
+var RDP_IDX = 3;
+var AGGREGATE_IDX = 4;
 
-// 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/aggregation/AggregationsHelper.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/AbstractHelper.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/QuerySubscription.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+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
+      }
+    });
   }
-  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);
-    }
+};
+
+// src/observable/internal/AbstractHelper.ts
+var AbstractHelper = class {
+  constructor(store, cacheKeys) {
+    this.store = store;
+    this.cacheKeys = cacheKeys;
   }
-  has(key) {
-    return this.refCounts.has(key);
+  observe(options, subFn) {
+    const query = this.getQuery(options);
+    return this._subscribe(query, options, subFn);
   }
-  gc() {
-    const now = Date.now();
-    for (const [key, deathTime] of this.gcMap) {
-      if (deathTime < now) {
-        this.gcMap.delete(key);
-        this.cleanup(key);
-      }
+  _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/CacheKeys.ts
-var CacheKeys = class {
-  #cacheKeys = new trie.Trie(false, (keys) => {
-    const cacheKey = {
-      type: keys[0],
-      otherKeys: keys.slice(1)
-    };
-    this.#onCreate?.(cacheKey);
-    return cacheKey;
-  });
-  #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;
-  #onDestroy;
-  constructor({
-    onCreate,
-    onDestroy
-  }) {
-    this.#onCreate = onCreate;
-    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);
+// src/observable/internal/aggregation/ObjectAggregationQuery.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/aggregation/AggregationQuery.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/Query.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+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[chunkDZE6IAUU_cjs.additionalContext].logger : store.client[chunkDZE6IAUU_cjs.additionalContext].logger?.child({}, {
+      msgPrefix: process.env.NODE_ENV !== "production" ? `Query<${cacheKey.type}, ${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>` : "Query"
+    }));
+  }
+  subscribe(observer) {
+    this.#connectable ??= this._createConnectable(this.#subject);
+    this.#subscription = this.#connectable.connect();
+    const sub = this.#connectable.subscribe({
+      next: (value) => {
+        if (observer.next) {
+          observer.next(value);
+        }
+      },
+      error: (err) => {
+        if (observer.error) {
+          observer.error(err);
+        }
+      },
+      complete: () => {
+        if (observer.complete) {
+          observer.complete();
+        }
       }
     });
+    return sub;
   }
-  get(type, ...args) {
-    const normalizedArgs = [...args];
-    while (normalizedArgs.length > 0 && normalizedArgs[normalizedArgs.length - 1] === void 0) {
-      normalizedArgs.pop();
+  /**
+   * Register a subscription's dedupeInterval value
+   */
+  registerSubscriptionDedupeInterval(subscriptionId, dedupeInterval) {
+    if (dedupeInterval != null && dedupeInterval > 0) {
+      this.#subscriptionDedupeIntervals.set(subscriptionId, dedupeInterval);
     }
-    const cacheKeyArgs = [type, ...normalizedArgs];
-    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);
+  /**
+   * Unregister a subscription's dedupeInterval value
+   */
+  unregisterSubscriptionDedupeInterval(subscriptionId) {
+    this.#subscriptionDedupeIntervals.delete(subscriptionId);
   }
-  #remove(cacheKey) {
-    this.#cacheKeys.remove(cacheKey.type, ...cacheKey.otherKeys);
+  /**
+   * 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());
   }
   /**
-   * Called after a key is no longer retained and the timeout has elapsed
-   * @param key
+   * Causes the query to revalidate. This will cause the query to fetch
+   * the latest data from the server and update the store if it is deemed
+   * "stale" or if `force` is true.
+   *
+   * @param force
+   * @returns
    */
-  #cleanupCacheKey = (key) => {
-    this.#onDestroy?.(key);
-    this.#remove(key);
-  };
-};
-var Changes = class {
-  modifiedObjects = new mnemonist.MultiMap();
-  addedObjects = new mnemonist.MultiMap();
-  added = /* @__PURE__ */ new Set();
-  modified = /* @__PURE__ */ new Set();
-  deleted = /* @__PURE__ */ new Set();
-  registerObject = (cacheKey, data, isNew) => {
-    this[isNew ? "addedObjects" : "modifiedObjects"].set(data.$apiName, data);
-    this[isNew ? "added" : "modified"].add(cacheKey);
-  };
-  deleteObject = (cacheKey) => {
-    this.deleted.add(cacheKey);
-  };
-  registerList = (key) => {
-    this.modified.add(key);
-  };
-  registerLink = (cacheKey) => {
-    this.modified.add(cacheKey);
-  };
-  deleteLink = (cacheKey) => {
-    this.deleted.add(cacheKey);
-  };
-  registerObjectSet = (key) => {
-    this.modified.add(key);
-  };
-  isEmpty() {
-    return this.modifiedObjects.size === 0 && this.addedObjects.size === 0 && this.added.size === 0 && this.modified.size === 0 && this.deleted.size === 0;
-  }
-};
-function createChangedObjects() {
-  return new Changes();
-}
-function DEBUG_ONLY__changesToString(changes) {
-  if (process.env.NODE_ENV !== "production") {
-    return JSON.stringify({
-      modifiedObjects: multimapHelper(changes.modifiedObjects),
-      addedObjects: multimapHelper(changes.addedObjects),
-      added: listHelper(changes.added),
-      modified: listHelper(changes.modified)
-    }, null, 2);
-  } else {
-    throw new Error("not implemented");
-  }
-}
-function listHelper(set) {
-  return Array.from(set).map(DEBUG_ONLY__cacheKeyToString);
-}
-function multimapHelper(multimap) {
-  return Object.fromEntries(Array.from(multimap.associations()).map(([type, objects]) => {
-    return [type, objects.map((o) => o.$primaryKey)];
-  }));
-}
-
-// src/observable/internal/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();
-  #list = [];
-  #toClean = [];
-  #needsCleaning = false;
-  #registry = new FinalizationRegistry(() => {
-    this.#toClean.push(new WeakRef({}));
-    this.#needsCleaning = true;
-  });
-  constructor() {
-    const weakThis = new WeakRef(this);
-    const intervalId = setInterval(() => {
-      const self = weakThis.deref();
-      if (self) {
-        if (this.#needsCleaning) {
-          this.#clean();
-        }
-      } else {
-        clearInterval(intervalId);
+  async revalidate(force) {
+    const logger = process.env.NODE_ENV !== "production" ? this.logger?.child({
+      methodName: "revalidate"
+    }) : this.logger;
+    if (force) {
+      this.abortController?.abort();
+    }
+    if (this.pendingFetch) {
+      if (process.env.NODE_ENV !== "production") {
+        logger?.debug("Fetch is already pending, using it");
       }
-    }, 1e3);
-  }
-  #clean() {
-    this.#list = this.#list.filter((ref) => ref.deref() !== void 0);
-  }
-  // functions for WeakMap
-  delete(key) {
-    const ret = this.#map.delete(key);
-    this.#toClean.push(new WeakRef(key));
-    this.#needsCleaning = true;
-    return ret;
-  }
-  get(key) {
-    return this.#map.get(key);
+      await this.pendingFetch;
+      return;
+    }
+    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");
+      }
+      return Promise.resolve();
+    }
+    if (process.env.NODE_ENV !== "production") {
+      logger?.debug("Starting actual revalidate");
+    }
+    this.store.batch({}, (batch) => {
+      this.setStatus("loading", batch);
+    });
+    this._preFetch();
+    this.lastFetchStarted = Date.now();
+    if (process.env.NODE_ENV !== "production") {
+      logger?.debug("calling _fetchAndStore()");
+    }
+    this.pendingFetch = this._fetchAndStore().finally(() => {
+      logger?.debug("promise's finally for _fetchAndStore()");
+      this.pendingFetch = void 0;
+    });
+    await this.pendingFetch;
+    return;
   }
-  has(key) {
-    return this.#map.has(key);
+  _preFetch() {
   }
   /**
-   * Adds a new element with a specified key and value.
-   * @param key Must be an object or symbol.
+   * Sets the status of the query in the store (but does not store that in `changes`).
+   *
+   * @param status
+   * @param batch
+   * @returns
    */
-  set(key, value) {
-    if (!this.#map.has(key)) {
-      this.#list.push(new WeakRef(key));
+  setStatus(status, batch) {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "setStatus"
+      }).debug(`Attempting to set status to '${status}'`);
     }
-    this.#map.set(key, value);
-    return this;
+    const existing = batch.read(this.cacheKey);
+    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);
   }
-  [Symbol.toStringTag] = "WeakMap";
-  // functions for iterables
-  /** Returns an iterable of entries in the map. */
-  [Symbol.iterator]() {
-    return this.entries();
+  dispose() {
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+    this.#subscription?.unsubscribe();
+    this._dispose();
   }
   /**
-   * Returns an iterable of key, value pairs for every entry in the map.
+   * Per query type dispose functionality
    */
-  entries() {
-    const self = this;
-    function* iter() {
-      for (const ref of self.#list) {
-        const key = ref.deref();
-        if (key !== void 0) {
-          yield [key, self.#map.get(key)];
-        }
-      }
-    }
-    return iter();
+  _dispose() {
   }
   /**
-   * Returns an iterable of keys in the map
+   * The purpose of this method is to provide a way for others to write
+   * directly into the store for this query.
+   *
+   * @param data
+   * @param status
+   * @param batch
    */
-  keys() {
-    const self = this;
-    function* iter() {
-      for (const ref of self.#list) {
-        const key = ref.deref();
-        if (key !== void 0) {
-          yield key;
-        }
-      }
-    }
-    return iter();
-  }
   /**
-   * Returns an iterable of values in the map
+   * @param changes
+   * @param optimisticId
+   * @returns If revalidation is needed, a promise that resolves after the
+   *          revalidation is complete. Otherwise, undefined.
    */
-  values() {
-    const self = this;
-    function* iter() {
-      for (const ref of self.#list) {
-        const key = ref.deref();
-        if (key !== void 0) {
-          const value = self.#map.get(key);
-          if (value !== void 0) {
-            yield value;
-          }
-        }
-      }
-    }
-    return iter();
-  }
 };
 
-// src/observable/internal/Layer.ts
-var Layer = class _Layer {
-  #parent;
-  #cache = new WeakMapWithEntries();
-  #layerId;
-  constructor(parent, layerId) {
-    this.#parent = parent;
-    this.#layerId = layerId;
-  }
-  get parentLayer() {
-    return this.#parent;
-  }
-  get layerId() {
-    return this.#layerId;
+// src/observable/internal/aggregation/AggregationQuery.ts
+var AggregationQuery = class extends Query {
+  constructor(store, subject, cacheKey, opts) {
+    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkDZE6IAUU_cjs.additionalContext].logger?.child({}, {
+      msgPrefix: `AggregationQuery<${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>`
+    }) : void 0);
+    this.apiName = cacheKey.otherKeys[API_NAME_IDX];
+    this.canonicalWhere = cacheKey.otherKeys[WHERE_IDX];
+    this.rdpConfig = cacheKey.otherKeys[RDP_IDX];
+    this.canonicalAggregate = cacheKey.otherKeys[AGGREGATE_IDX];
   }
-  addLayer(layerId) {
-    return new _Layer(this, layerId);
+  _createConnectable(subject) {
+    return rxjs.connectable(subject.pipe(rxjs.map((x) => {
+      return {
+        status: x.status,
+        result: x.value,
+        lastUpdated: x.lastUpdated,
+        error: x.status === "error" ? new Error("Aggregation failed") : void 0
+      };
+    })), {
+      connector: () => new rxjs.BehaviorSubject({
+        status: "init",
+        result: void 0,
+        lastUpdated: 0
+      })
+    });
   }
-  removeLayer(layerId) {
-    if (layerId == null || this.#parent == null) {
-      return this;
-    }
-    if (this.#layerId !== layerId) {
-      this.#parent = this.#parent.removeLayer(layerId);
-      return this;
+  async _fetchAndStore() {
+    if (process.env.NODE_ENV !== "production") {
+      this.logger?.child({
+        methodName: "_fetchAndStore"
+      }).debug("calling _fetchAndStore");
+    }
+    try {
+      const result = await this._fetchAggregation();
+      this.store.batch({}, (batch) => {
+        this.writeToStore(result, "loaded", batch);
+      });
+    } catch (err) {
+      this.store.batch({}, (batch) => {
+        this.writeToStore(void 0, "error", batch);
+      });
     }
-    return this.#parent.removeLayer(layerId);
   }
-  entries() {
-    return this.#cache.entries();
+  writeToStore(data, status, batch) {
+    batch.write(this.cacheKey, data, status);
+    batch.changes.modified.add(this.cacheKey);
+    return batch.read(this.cacheKey);
   }
-  keys() {
-    return this.#cache.keys();
+  invalidateObjectType = (objectType, changes) => {
+    if (this.apiName === objectType) {
+      changes?.modified.add(this.cacheKey);
+      return this.revalidate(true);
+    }
+    return Promise.resolve();
+  };
+};
+
+// src/observable/internal/aggregation/ObjectAggregationQuery.ts
+var ObjectAggregationQuery = class extends AggregationQuery {
+  async _fetchAggregation() {
+    const type = this.cacheKey.otherKeys[API_NAME_IDX];
+    let objectSet = this.store.client({
+      type: "object",
+      apiName: type
+    });
+    if (this.rdpConfig) {
+      objectSet = objectSet.withProperties(this.rdpConfig);
+    }
+    objectSet = objectSet.where(this.canonicalWhere);
+    return await objectSet.aggregate(this.canonicalAggregate);
   }
-  get(cacheKey) {
-    return this.#cache.get(cacheKey) ?? this.#parent?.get(cacheKey);
+};
+
+// src/observable/internal/aggregation/AggregationsHelper.ts
+var AggregationsHelper = class extends AbstractHelper {
+  constructor(store, cacheKeys, whereCanonicalizer2, rdpCanonicalizer) {
+    super(store, cacheKeys);
+    this.whereCanonicalizer = whereCanonicalizer2;
+    this.rdpCanonicalizer = rdpCanonicalizer;
   }
-  set(cacheKey, value) {
-    this.#cache.set(cacheKey, value);
+  observe(options, subFn) {
+    return super.observe(options, subFn);
   }
-};
-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;
+  getQuery(options) {
+    const {
+      type,
+      where,
+      withProperties,
+      aggregate
+    } = options;
+    const {
+      apiName
+    } = type;
+    const typeKind = "type" in type ? type.type : "interface";
+    const canonWhere = this.whereCanonicalizer.canonicalize(where ?? {});
+    const canonRdp = withProperties ? this.rdpCanonicalizer.canonicalize(withProperties) : void 0;
+    const canonAggregate = this.canonicalizeAggregate(aggregate);
+    const aggregationCacheKey = this.cacheKeys.get("aggregation", typeKind, apiName, canonWhere, canonRdp, canonAggregate);
+    return this.store.queries.get(aggregationCacheKey, () => {
+      if (typeKind !== "object") {
+        throw new Error("Only ObjectTypeDefinition is currently supported for aggregations");
+      }
+      return new ObjectAggregationQuery(this.store, this.store.subjects.get(aggregationCacheKey), aggregationCacheKey, options);
+    });
+  }
+  canonicalizeAggregate(aggregate) {
+    return JSON.parse(JSON.stringify(aggregate));
   }
-  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 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/CacheKey.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+function DEBUG_ONLY__cacheKeyToString(x) {
+  if (process.env.NODE_ENV !== "production") {
+    return `${x.type}CacheKey<${x.otherKeys.map((xx) => JSON.stringify(xx)).join(", ")}>`.replaceAll('"', "'");
+  } else {
+    throw new Error("not implemented");
+  }
+}
+function DEBUG_ONLY__cacheKeysToString(x) {
+  if (process.env.NODE_ENV !== "production") {
+    return "\n  - " + x.map(DEBUG_ONLY__cacheKeyToString).join("\n  - ");
+  } else {
+    throw new Error("not implemented");
+  }
+}
 
-// src/observable/internal/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;
+// src/observable/internal/CacheKeys.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/RefCounts.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+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;
   }
-  get top() {
-    return this.#topLayer;
+  register(key) {
+    if (!this.refCounts.has(key)) {
+      this.gcMap.set(key, Date.now() + this.keepAlive);
+    }
+    return key;
   }
-  get truth() {
-    return this.#truthLayer;
+  retain(key) {
+    const count = this.refCounts.get(key) ?? 0;
+    this.refCounts.set(key, count + 1);
+    if (this.gcMap.has(key)) {
+      this.gcMap.delete(key);
+    }
   }
-  remove(layerId) {
-    !(layerId != null) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "undefined is the reserved layerId for the truth layer") : invariant4__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;
+  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);
     }
-    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
-        });
+  }
+  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);
       }
     }
   }
-  batch({
-    optimisticId,
-    changes
-  }, batchFn) {
-    !(optimisticId === void 0 || !!optimisticId) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "optimistic must be undefined or not falsy") : invariant4__default.default(false) : void 0;
-    const batchContext = this.#createBatchContext({
-      optimisticId,
-      changes
-    });
-    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
+};
+
+// src/observable/internal/CacheKeys.ts
+var CacheKeys = class {
+  #cacheKeys = new trie.Trie(false, (keys) => {
+    const cacheKey = {
+      type: keys[0],
+      otherKeys: keys.slice(1)
     };
-  }
-  #createBatchContext({
-    optimisticId,
-    changes
+    this.#onCreate?.(cacheKey);
+    return cacheKey;
+  });
+  #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;
+  #onDestroy;
+  constructor({
+    onCreate,
+    onDestroy
   }) {
-    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);
+    this.#onCreate = onCreate;
+    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);
       }
-    };
-    return batchContext;
+    });
   }
+  get(type, ...args) {
+    const normalizedArgs = [...args];
+    while (normalizedArgs.length > 0 && normalizedArgs[normalizedArgs.length - 1] === void 0) {
+      normalizedArgs.pop();
+    }
+    const cacheKeyArgs = [type, ...normalizedArgs];
+    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) {
+    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/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
-      }
-    });
+// src/observable/internal/Changes.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+var Changes = class {
+  modifiedObjects = new mnemonist.MultiMap();
+  addedObjects = new mnemonist.MultiMap();
+  added = /* @__PURE__ */ new Set();
+  modified = /* @__PURE__ */ new Set();
+  deleted = /* @__PURE__ */ new Set();
+  registerObject = (cacheKey, data, isNew) => {
+    this[isNew ? "addedObjects" : "modifiedObjects"].set(data.$apiName, data);
+    this[isNew ? "added" : "modified"].add(cacheKey);
+  };
+  deleteObject = (cacheKey) => {
+    this.deleted.add(cacheKey);
+  };
+  registerList = (key) => {
+    this.modified.add(key);
+  };
+  registerLink = (cacheKey) => {
+    this.modified.add(cacheKey);
+  };
+  deleteLink = (cacheKey) => {
+    this.deleted.add(cacheKey);
+  };
+  registerObjectSet = (key) => {
+    this.modified.add(key);
+  };
+  isEmpty() {
+    return this.modifiedObjects.size === 0 && this.addedObjects.size === 0 && this.added.size === 0 && this.modified.size === 0 && this.deleted.size === 0;
   }
 };
+function createChangedObjects() {
+  return new Changes();
+}
+function DEBUG_ONLY__changesToString(changes) {
+  if (process.env.NODE_ENV !== "production") {
+    return JSON.stringify({
+      modifiedObjects: multimapHelper(changes.modifiedObjects),
+      addedObjects: multimapHelper(changes.addedObjects),
+      added: listHelper(changes.added),
+      modified: listHelper(changes.modified)
+    }, null, 2);
+  } else {
+    throw new Error("not implemented");
+  }
+}
+function listHelper(set) {
+  return Array.from(set).map(DEBUG_ONLY__cacheKeyToString);
+}
+function multimapHelper(multimap) {
+  return Object.fromEntries(Array.from(multimap.associations()).map(([type, objects]) => {
+    return [type, objects.map((o) => o.$primaryKey)];
+  }));
+}
 
-// src/observable/internal/AbstractHelper.ts
-var AbstractHelper = class {
-  constructor(store, cacheKeys) {
-    this.store = store;
-    this.cacheKeys = cacheKeys;
+// src/observable/internal/IntersectCanonicalizer.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/Canonicalizer.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+var CachingCanonicalizer = class {
+  /**
+   * Cache for input object identity.
+   */
+  inputCache = /* @__PURE__ */ new WeakMap();
+  /**
+   * Look up or create a canonical form for the given input.
+   * This method handles the structural deduplication logic.
+   *
+   * @param input The input to canonicalize
+   * @returns The canonical form
+   */
+  canonicalize(input) {
+    if (!input) {
+      return void 0;
+    }
+    if (this.inputCache.has(input)) {
+      return this.inputCache.get(input);
+    }
+    const canonical = this.lookupOrCreate(input);
+    this.inputCache.set(input, canonical);
+    return canonical;
   }
-  observe(options, subFn) {
-    const query = this.getQuery(options);
-    return this._subscribe(query, options, subFn);
+};
+
+// src/observable/internal/IntersectCanonicalizer.ts
+var IntersectCanonicalizer = class extends CachingCanonicalizer {
+  structuralCache = /* @__PURE__ */ new Map();
+  constructor(whereCanonicalizer2) {
+    super();
+    this.whereCanonicalizer = whereCanonicalizer2;
   }
-  _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;
-        }
-      });
+  lookupOrCreate(intersectWith) {
+    const canonicalClauses = intersectWith.map((item) => this.whereCanonicalizer.canonicalize(item.where ?? {}));
+    const structuralKey = canonicalClauses.map((clause) => JSON.stringify(clause)).join("||");
+    let canonical = this.structuralCache.get(structuralKey);
+    if (!canonical) {
+      canonical = canonicalClauses;
+      this.structuralCache.set(structuralKey, canonical);
     }
-    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;
+    return canonical;
   }
 };
 
-// src/observable/internal/isObjectInstance.ts
-function isObjectInstance(item) {
-  return item != null && typeof item === "object" && "$primaryKey" in item;
+// src/observable/internal/Layers.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/createInitEntry.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+function createInitEntry(cacheKey) {
+  return {
+    cacheKey,
+    status: "init",
+    value: void 0,
+    lastUpdated: 0
+  };
 }
 
-// src/observable/internal/list/ListCacheKey.ts
-var API_NAME_IDX = 1;
-var WHERE_IDX = 2;
-var ORDER_BY_IDX = 3;
-var RDP_IDX = 4;
+// src/observable/internal/Layer.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
 
-// 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[chunk3LMKH6RS_cjs.additionalContext].logger : store.client[chunk3LMKH6RS_cjs.additionalContext].logger?.child({}, {
-      msgPrefix: process.env.NODE_ENV !== "production" ? `Query<${cacheKey.type}, ${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>` : "Query"
-    }));
-  }
-  subscribe(observer) {
-    this.#connectable ??= this._createConnectable(this.#subject);
-    this.#subscription = this.#connectable.connect();
-    const sub = this.#connectable.subscribe({
-      next: (value) => {
-        if (observer.next) {
-          observer.next(value);
-        }
-      },
-      error: (err) => {
-        if (observer.error) {
-          observer.error(err);
-        }
-      },
-      complete: () => {
-        if (observer.complete) {
-          observer.complete();
+// src/observable/internal/WeakMapWithEntries.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+var WeakMapWithEntries = class {
+  #map = /* @__PURE__ */ new WeakMap();
+  #list = [];
+  #toClean = [];
+  #needsCleaning = false;
+  #registry = new FinalizationRegistry(() => {
+    this.#toClean.push(new WeakRef({}));
+    this.#needsCleaning = true;
+  });
+  constructor() {
+    const weakThis = new WeakRef(this);
+    const intervalId = setInterval(() => {
+      const self = weakThis.deref();
+      if (self) {
+        if (this.#needsCleaning) {
+          this.#clean();
         }
+      } else {
+        clearInterval(intervalId);
       }
-    });
-    return sub;
+    }, 1e3);
+  }
+  #clean() {
+    this.#list = this.#list.filter((ref) => ref.deref() !== void 0);
+  }
+  // functions for WeakMap
+  delete(key) {
+    const ret = this.#map.delete(key);
+    this.#toClean.push(new WeakRef(key));
+    this.#needsCleaning = true;
+    return ret;
+  }
+  get(key) {
+    return this.#map.get(key);
+  }
+  has(key) {
+    return this.#map.has(key);
   }
   /**
-   * Register a subscription's dedupeInterval value
+   * Adds a new element with a specified key and value.
+   * @param key Must be an object or symbol.
    */
-  registerSubscriptionDedupeInterval(subscriptionId, dedupeInterval) {
-    if (dedupeInterval != null && dedupeInterval > 0) {
-      this.#subscriptionDedupeIntervals.set(subscriptionId, dedupeInterval);
+  set(key, value) {
+    if (!this.#map.has(key)) {
+      this.#list.push(new WeakRef(key));
     }
+    this.#map.set(key, value);
+    return this;
+  }
+  [Symbol.toStringTag] = "WeakMap";
+  // functions for iterables
+  /** Returns an iterable of entries in the map. */
+  [Symbol.iterator]() {
+    return this.entries();
   }
   /**
-   * Unregister a subscription's dedupeInterval value
+   * Returns an iterable of key, value pairs for every entry in the map.
    */
-  unregisterSubscriptionDedupeInterval(subscriptionId) {
-    this.#subscriptionDedupeIntervals.delete(subscriptionId);
+  entries() {
+    const self = this;
+    function* iter() {
+      for (const ref of self.#list) {
+        const key = ref.deref();
+        if (key !== void 0) {
+          yield [key, self.#map.get(key)];
+        }
+      }
+    }
+    return iter();
   }
   /**
-   * Get the minimum dedupeInterval from all active subscriptions
+   * Returns an iterable of keys in the map
    */
-  getMinimumDedupeInterval() {
-    if (this.#subscriptionDedupeIntervals.size === 0) {
-      return this.options.dedupeInterval ?? 0;
+  keys() {
+    const self = this;
+    function* iter() {
+      for (const ref of self.#list) {
+        const key = ref.deref();
+        if (key !== void 0) {
+          yield key;
+        }
+      }
     }
-    return Math.min(...this.#subscriptionDedupeIntervals.values());
+    return iter();
   }
   /**
-   * Causes the query to revalidate. This will cause the query to fetch
-   * the latest data from the server and update the store if it is deemed
-   * "stale" or if `force` is true.
-   *
-   * @param force
-   * @returns
+   * Returns an iterable of values in the map
    */
-  async revalidate(force) {
-    const logger = process.env.NODE_ENV !== "production" ? this.logger?.child({
-      methodName: "revalidate"
-    }) : this.logger;
-    if (force) {
-      this.abortController?.abort();
-    }
-    if (this.pendingFetch) {
-      if (process.env.NODE_ENV !== "production") {
-        logger?.debug("Fetch is already pending, using it");
+  values() {
+    const self = this;
+    function* iter() {
+      for (const ref of self.#list) {
+        const key = ref.deref();
+        if (key !== void 0) {
+          const value = self.#map.get(key);
+          if (value !== void 0) {
+            yield value;
+          }
+        }
       }
-      await this.pendingFetch;
-      return;
     }
-    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");
-      }
-      return Promise.resolve();
+    return iter();
+  }
+};
+
+// src/observable/internal/Layer.ts
+var Layer = class _Layer {
+  #parent;
+  #cache = new WeakMapWithEntries();
+  #layerId;
+  constructor(parent, layerId) {
+    this.#parent = parent;
+    this.#layerId = layerId;
+  }
+  get parentLayer() {
+    return this.#parent;
+  }
+  get layerId() {
+    return this.#layerId;
+  }
+  addLayer(layerId) {
+    return new _Layer(this, layerId);
+  }
+  removeLayer(layerId) {
+    if (layerId == null || this.#parent == null) {
+      return this;
     }
-    if (process.env.NODE_ENV !== "production") {
-      logger?.debug("Starting actual revalidate");
+    if (this.#layerId !== layerId) {
+      this.#parent = this.#parent.removeLayer(layerId);
+      return this;
     }
-    this.store.batch({}, (batch) => {
-      this.setStatus("loading", batch);
-    });
-    this._preFetch();
-    this.lastFetchStarted = Date.now();
-    if (process.env.NODE_ENV !== "production") {
-      logger?.debug("calling _fetchAndStore()");
+    return this.#parent.removeLayer(layerId);
+  }
+  entries() {
+    return this.#cache.entries();
+  }
+  keys() {
+    return this.#cache.keys();
+  }
+  get(cacheKey) {
+    return this.#cache.get(cacheKey) ?? this.#parent?.get(cacheKey);
+  }
+  set(cacheKey, value) {
+    this.#cache.set(cacheKey, value);
+  }
+};
+
+// src/observable/internal/Subjects.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+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;
+  }
+  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 subject;
+  };
+  delete = (cacheKey) => {
+    const subject = this.peek(cacheKey);
+    if (subject) {
+      subject.complete();
+      this.#cacheKeyToSubject.delete(cacheKey);
     }
-    this.pendingFetch = this._fetchAndStore().finally(() => {
-      logger?.debug("promise's finally for _fetchAndStore()");
-      this.pendingFetch = void 0;
+  };
+};
+
+// src/observable/internal/tombstone.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+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
     });
-    await this.pendingFetch;
-    return;
+    this.#onRevalidate = onRevalidate;
   }
-  _preFetch() {
+  get top() {
+    return this.#topLayer;
   }
-  /**
-   * Sets the status of the query in the store (but does not store that in `changes`).
-   *
-   * @param status
-   * @param batch
-   * @returns
-   */
-  setStatus(status, batch) {
-    if (process.env.NODE_ENV !== "production") {
-      this.logger?.child({
-        methodName: "setStatus"
-      }).debug(`Attempting to set status to '${status}'`);
-    }
-    const existing = batch.read(this.cacheKey);
-    if (existing?.status === status) {
-      if (process.env.NODE_ENV !== "production") {
-        this.logger?.child({
-          methodName: "setStatus"
-        }).debug(`Status is already set to '${status}'; aborting`);
+  get truth() {
+    return this.#truthLayer;
+  }
+  remove(layerId) {
+    !(layerId != null) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "undefined is the reserved layerId for the truth layer") : invariant4__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);
+        }
       }
-      return;
+      currentLayer = currentLayer.parentLayer;
     }
-    if (process.env.NODE_ENV !== "production") {
-      this.logger?.child({
-        methodName: "setStatus"
-      }).debug(`Writing status '${status}' to cache`);
+    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
+        });
+      }
     }
-    batch.write(this.cacheKey, existing?.value, status);
   }
-  dispose() {
-    if (this.abortController) {
-      this.abortController.abort();
-    }
-    this.#subscription?.unsubscribe();
-    this._dispose();
+  batch({
+    optimisticId,
+    changes
+  }, batchFn) {
+    !(optimisticId === void 0 || !!optimisticId) ? process.env.NODE_ENV !== "production" ? invariant4__default.default(false, "optimistic must be undefined or not falsy") : invariant4__default.default(false) : void 0;
+    const batchContext = this.#createBatchContext({
+      optimisticId,
+      changes
+    });
+    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
+    };
   }
-  /**
-   * Per query type dispose functionality
-   */
-  _dispose() {
+  #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);
+      }
+    };
+    return batchContext;
   }
-  /**
-   * The purpose of this method is to provide a way for others to write
-   * directly into the store for this query.
-   *
-   * @param data
-   * @param status
-   * @param batch
-   */
-  /**
-   * @param changes
-   * @param optimisticId
-   * @returns If revalidation is needed, a promise that resolves after the
-   *          revalidation is complete. Otherwise, undefined.
-   */
 };
 
+// src/observable/internal/links/LinksHelper.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/links/SpecificLinkQuery.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/base-list/BaseListQuery.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/isObjectInstance.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+function isObjectInstance(item) {
+  return item != null && typeof item === "object" && "$primaryKey" in item;
+}
+
+// src/observable/internal/list/ListCacheKey.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+var API_NAME_IDX2 = 1;
+var WHERE_IDX2 = 2;
+var ORDER_BY_IDX = 3;
+var RDP_IDX2 = 4;
+var INTERSECT_IDX = 5;
+var PIVOT_IDX = 6;
+
 // src/observable/internal/sorting/SortingStrategy.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
 var NoOpSortingStrategy = class {
   sortCacheKeys(objectCacheKeys, _batch) {
     return objectCacheKeys;
@@ -1215,6 +1465,9 @@ function createOrderBySortFns(orderBy) {
     };
   });
 }
+
+// src/observable/internal/base-list/createCollectionConnectable.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
 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())));
@@ -1236,6 +1489,7 @@ function createCollectionConnectable(subject, subjects, createPayload) {
 }
 
 // src/observable/internal/base-list/removeDuplicates.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
 function removeDuplicates(objectCacheKeys, batch) {
   const visited = /* @__PURE__ */ new Set();
   return objectCacheKeys.filter((key) => {
@@ -1259,7 +1513,7 @@ var BaseListQuery = class extends Query {
    * Get RDP configuration from the cache key
    */
   get rdpConfig() {
-    return this.cacheKey.otherKeys[RDP_IDX];
+    return this.cacheKey.otherKeys[RDP_IDX2];
   }
   // Collection-specific behavior is implemented by subclasses
   /**
@@ -1722,7 +1976,7 @@ var SpecificLinkQuery = class extends BaseListQuery {
     batch.changes.modified.add(this.cacheKey);
   }
   constructor(store, subject, cacheKey, opts) {
-    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunk3LMKH6RS_cjs.additionalContext].logger?.child({}, {
+    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkDZE6IAUU_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;
@@ -1739,7 +1993,7 @@ var SpecificLinkQuery = class extends BaseListQuery {
       type: "object",
       apiName: this.#sourceApiName
     };
-    const sourceMetadata = await client[chunk3LMKH6RS_cjs.additionalContext].ontologyProvider.getObjectDefinition(this.#sourceApiName);
+    const sourceMetadata = await client[chunkDZE6IAUU_cjs.additionalContext].ontologyProvider.getObjectDefinition(this.#sourceApiName);
     const sourceQuery = client(sourceObjectDef).where({
       [sourceMetadata.primaryKeyApiName]: this.#sourcePk
     });
@@ -1803,7 +2057,7 @@ var SpecificLinkQuery = class extends BaseListQuery {
       return this.revalidate(true);
     } else {
       return (async () => {
-        const sourceMetadata = await this.store.client[chunk3LMKH6RS_cjs.additionalContext].ontologyProvider.getObjectDefinition(this.#sourceApiName);
+        const sourceMetadata = await this.store.client[chunkDZE6IAUU_cjs.additionalContext].ontologyProvider.getObjectDefinition(this.#sourceApiName);
         const linkDef = sourceMetadata.links?.[this.#linkName];
         if (!linkDef || linkDef.targetType !== objectType) return;
         const promise = this.revalidate(true);
@@ -1821,9 +2075,6 @@ var LinksHelper = class extends AbstractHelper {
     this.whereCanonicalizer = whereCanonicalizer2;
     this.orderByCanonicalizer = orderByCanonicalizer2;
   }
-  observe(options, subFn) {
-    return super.observe(options, subFn);
-  }
   getQuery(options) {
     const {
       apiName
@@ -1836,6 +2087,21 @@ var LinksHelper = class extends AbstractHelper {
     });
   }
 };
+
+// src/observable/internal/list/ListsHelper.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/list/InterfaceListQuery.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/list/ListQuery.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/objectMatchesWhereClause.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/evaluateFilter.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
 function evaluateFilter(f, realValue, expected, strict) {
   switch (f) {
     case "$eq":
@@ -1933,6 +2199,8 @@ var ListQuery = class extends BaseListQuery {
   #whereClause;
   // Using base class minResultsToLoad instead of a private property
   #orderBy;
+  #intersectWith;
+  #pivotInfo;
   #objectSet;
   /**
    * Register changes to the cache specific to ListQuery
@@ -1941,12 +2209,14 @@ var ListQuery = class extends BaseListQuery {
     batch.changes.registerList(this.cacheKey);
   }
   constructor(store, subject, apiName, cacheKey, opts) {
-    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunk3LMKH6RS_cjs.additionalContext].logger?.child({}, {
+    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkDZE6IAUU_cjs.additionalContext].logger?.child({}, {
       msgPrefix: `ListQuery<${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>`
     }) : void 0);
     this.apiName = apiName;
-    this.#whereClause = cacheKey.otherKeys[WHERE_IDX];
+    this.#whereClause = cacheKey.otherKeys[WHERE_IDX2];
     this.#orderBy = cacheKey.otherKeys[ORDER_BY_IDX];
+    this.#intersectWith = cacheKey.otherKeys[INTERSECT_IDX];
+    this.#pivotInfo = cacheKey.otherKeys[PIVOT_IDX];
     this.#objectSet = this.createObjectSet(store);
     this.sortingStrategy = new OrderBySortingStrategy(this.apiName, this.#orderBy);
     this.minResultsToLoad = 0;
@@ -1954,6 +2224,12 @@ var ListQuery = class extends BaseListQuery {
   get canonicalWhere() {
     return this.#whereClause;
   }
+  get canonicalIntersectWith() {
+    return this.#intersectWith;
+  }
+  get canonicalPivotInfo() {
+    return this.#pivotInfo;
+  }
   /**
    * Create the ObjectSet for this query.
    */
@@ -2179,7 +2455,7 @@ var ListQuery = class extends BaseListQuery {
 // src/observable/internal/list/InterfaceListQuery.ts
 var InterfaceListQuery = class extends ListQuery {
   createObjectSet(store) {
-    const rdpConfig = this.cacheKey.otherKeys[RDP_IDX];
+    const rdpConfig = this.cacheKey.otherKeys[RDP_IDX2];
     const type = "interface";
     const objectTypeDef = {
       type,
@@ -2207,7 +2483,7 @@ var InterfaceListQuery = class extends ListQuery {
   }
   extractRelevantObjects(changes) {
     const matchesApiName = ([, object]) => {
-      return this.apiName in object[chunk4ZOXOCQX_cjs.ObjectDefRef].interfaceMap;
+      return this.apiName in object[chunkS4JPAF56_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));
@@ -2228,7 +2504,7 @@ var InterfaceListQuery = class extends ListQuery {
 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][chunk4ZOXOCQX_cjs.UnderlyingOsdkObject][chunk4ZOXOCQX_cjs.ObjectDefRef];
+    const objectDef = objects[0][chunkS4JPAF56_cjs.UnderlyingOsdkObject][chunkS4JPAF56_cjs.ObjectDefRef];
     const where = {
       [objectDef.primaryKeyApiName]: {
         $in: objects.map((x) => x.$primaryKey)
@@ -2245,19 +2521,59 @@ async function reloadDataAsFullObjects(client, data) {
 }
 
 // src/observable/internal/list/ObjectListQuery.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
 var ObjectListQuery = class extends ListQuery {
   createObjectSet(store) {
-    const rdpConfig = this.cacheKey.otherKeys[RDP_IDX];
-    if (rdpConfig != null) {
-      return store.client({
+    const rdpConfig = this.cacheKey.otherKeys[RDP_IDX2];
+    const intersectWith = this.cacheKey.otherKeys[INTERSECT_IDX];
+    const pivotInfo = this.cacheKey.otherKeys[PIVOT_IDX];
+    if (pivotInfo != null) {
+      const sourceSet = store.client({
         type: "object",
-        apiName: this.apiName
-      }).withProperties(rdpConfig).where(this.canonicalWhere);
+        apiName: pivotInfo.sourceType
+      });
+      let objectSet2 = sourceSet.pivotTo(pivotInfo.linkName);
+      if (rdpConfig != null) {
+        objectSet2 = objectSet2.withProperties(rdpConfig);
+      }
+      objectSet2 = objectSet2.where(this.canonicalWhere);
+      if (intersectWith != null && intersectWith.length > 0) {
+        const intersectSets = intersectWith.map((whereClause) => {
+          let intersectSet = store.client({
+            type: "object",
+            apiName: pivotInfo.targetType
+          });
+          if (rdpConfig != null) {
+            intersectSet = intersectSet.withProperties(rdpConfig);
+          }
+          return intersectSet.where(whereClause);
+        });
+        objectSet2 = objectSet2.intersect(...intersectSets);
+      }
+      return objectSet2;
     }
-    return store.client({
+    let objectSet = store.client({
       type: "object",
       apiName: this.apiName
-    }).where(this.canonicalWhere);
+    });
+    if (rdpConfig != null) {
+      objectSet = objectSet.withProperties(rdpConfig);
+    }
+    objectSet = objectSet.where(this.canonicalWhere);
+    if (intersectWith != null && intersectWith.length > 0) {
+      const intersectSets = intersectWith.map((whereClause) => {
+        let intersectSet = store.client({
+          type: "object",
+          apiName: this.apiName
+        });
+        if (rdpConfig != null) {
+          intersectSet = intersectSet.withProperties(rdpConfig);
+        }
+        return intersectSet.where(whereClause);
+      });
+      objectSet = objectSet.intersect(...intersectSets);
+    }
+    return objectSet;
   }
   async revalidateObjectType(apiName) {
     if (this.apiName === apiName) {
@@ -2273,12 +2589,12 @@ var ObjectListQuery = class extends ListQuery {
   extractRelevantObjects(changes) {
     return {
       added: {
-        all: changes.addedObjects.get(this.cacheKey.otherKeys[API_NAME_IDX]) ?? [],
+        all: changes.addedObjects.get(this.cacheKey.otherKeys[API_NAME_IDX2]) ?? [],
         strictMatches: /* @__PURE__ */ new Set(),
         sortaMatches: /* @__PURE__ */ new Set()
       },
       modified: {
-        all: changes.modifiedObjects.get(this.cacheKey.otherKeys[API_NAME_IDX]) ?? [],
+        all: changes.modifiedObjects.get(this.cacheKey.otherKeys[API_NAME_IDX2]) ?? [],
         strictMatches: /* @__PURE__ */ new Set(),
         sortaMatches: /* @__PURE__ */ new Set()
       }
@@ -2288,11 +2604,13 @@ var ObjectListQuery = class extends ListQuery {
 
 // src/observable/internal/list/ListsHelper.ts
 var ListsHelper = class extends AbstractHelper {
-  constructor(store, cacheKeys, whereCanonicalizer2, orderByCanonicalizer2, rdpCanonicalizer) {
+  constructor(store, cacheKeys, whereCanonicalizer2, orderByCanonicalizer2, rdpCanonicalizer, intersectCanonicalizer, pivotCanonicalizer) {
     super(store, cacheKeys);
     this.whereCanonicalizer = whereCanonicalizer2;
     this.orderByCanonicalizer = orderByCanonicalizer2;
     this.rdpCanonicalizer = rdpCanonicalizer;
+    this.intersectCanonicalizer = intersectCanonicalizer;
+    this.pivotCanonicalizer = pivotCanonicalizer;
   }
   observe(options, subFn) {
     const ret = super.observe(options, subFn);
@@ -2306,7 +2624,9 @@ var ListsHelper = class extends AbstractHelper {
       type: typeDefinition,
       where,
       orderBy,
-      withProperties
+      withProperties,
+      intersectWith,
+      pivotTo
     } = options;
     const {
       apiName,
@@ -2315,7 +2635,9 @@ var ListsHelper = class extends AbstractHelper {
     const canonWhere = this.whereCanonicalizer.canonicalize(where ?? {});
     const canonOrderBy = this.orderByCanonicalizer.canonicalize(orderBy ?? {});
     const canonRdp = withProperties ? this.rdpCanonicalizer.canonicalize(withProperties) : void 0;
-    const listCacheKey = this.cacheKeys.get("list", type, apiName, canonWhere, canonOrderBy, canonRdp);
+    const canonIntersect = intersectWith && intersectWith.length > 0 ? this.intersectCanonicalizer.canonicalize(intersectWith) : void 0;
+    const canonPivot = pivotTo ? this.pivotCanonicalizer.canonicalize(apiName, pivotTo) : void 0;
+    const listCacheKey = this.cacheKeys.get("list", type, apiName, canonWhere, canonOrderBy, canonRdp, canonIntersect, canonPivot);
     return this.store.queries.get(listCacheKey, () => {
       const QueryClass = type === "object" ? ObjectListQuery : InterfaceListQuery;
       return new QueryClass(this.store, this.store.subjects.get(listCacheKey), apiName, listCacheKey, options);
@@ -2324,10 +2646,15 @@ var ListsHelper = class extends AbstractHelper {
 };
 
 // src/observable/internal/object/ObjectCacheKey.ts
-var API_NAME_IDX2 = 0;
+chunk6SCDLAU2_cjs.init_cjs_shims();
+var API_NAME_IDX3 = 0;
 var RDP_CONFIG_IDX = 2;
 
+// src/observable/internal/object/ObjectCacheKeyRegistry.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
 // src/observable/internal/utils/rdpFieldOperations.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
 function extractRdpFieldNames(rdpConfig) {
   if (!rdpConfig) {
     return /* @__PURE__ */ new Set();
@@ -2494,7 +2821,17 @@ var ObjectCacheKeyRegistry = class {
   }
 };
 
+// src/observable/internal/object/ObjectsHelper.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/object/ObjectQuery.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
+// src/observable/internal/BulkObjectLoader.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
 // ../../node_modules/.pnpm/p-defer@4.0.1/node_modules/p-defer/index.js
+chunk6SCDLAU2_cjs.init_cjs_shims();
 function pDefer() {
   const deferred = {};
   deferred.promise = new Promise((resolve, reject) => {
@@ -2520,7 +2857,7 @@ var BulkObjectLoader = class {
   #maxEntries;
   constructor(client, maxWait = 25, maxEntries = 100) {
     this.#client = client;
-    this.#logger = client[chunk3LMKH6RS_cjs.additionalContext].logger;
+    this.#logger = client[chunkDZE6IAUU_cjs.additionalContext].logger;
     this.#maxWait = maxWait;
     this.#maxEntries = maxEntries;
   }
@@ -2588,7 +2925,7 @@ 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[chunk3LMKH6RS_cjs.additionalContext].logger?.child({}, {
+    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkDZE6IAUU_cjs.additionalContext].logger?.child({}, {
       msgPrefix: `ObjectQuery<${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>`
     }) : void 0);
     this.#apiName = type;
@@ -2725,14 +3062,18 @@ var ObjectsHelper = class extends AbstractHelper {
   }
 };
 
+// src/observable/internal/objectset/ObjectSetHelper.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+
 // src/observable/internal/objectset/ObjectSetQuery.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
 var ObjectSetQuery = class extends BaseListQuery {
   #baseObjectSetWire;
   #operations;
   #composedObjectSet;
   #objectTypes;
   constructor(store, subject, baseObjectSetWire, operations, cacheKey, opts) {
-    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunk3LMKH6RS_cjs.additionalContext].logger?.child({}, {
+    super(store, subject, opts, cacheKey, process.env.NODE_ENV !== "production" ? store.client[chunkDZE6IAUU_cjs.additionalContext].logger?.child({}, {
       msgPrefix: `ObjectSetQuery<${cacheKey.otherKeys.map((x) => JSON.stringify(x)).join(", ")}>`
     }) : void 0);
     this.#baseObjectSetWire = baseObjectSetWire;
@@ -2775,7 +3116,7 @@ var ObjectSetQuery = class extends BaseListQuery {
     }
     if (opts.union) {
       for (const os of opts.union) {
-        const wire = chunk3LMKH6RS_cjs.getWireObjectSet(os);
+        const wire = chunkDZE6IAUU_cjs.getWireObjectSet(os);
         if (wire.type) {
           types.add(wire.type);
         }
@@ -2783,7 +3124,7 @@ var ObjectSetQuery = class extends BaseListQuery {
     }
     if (opts.intersect) {
       for (const os of opts.intersect) {
-        const wire = chunk3LMKH6RS_cjs.getWireObjectSet(os);
+        const wire = chunkDZE6IAUU_cjs.getWireObjectSet(os);
         if (wire.type) {
           types.add(wire.type);
         }
@@ -2791,7 +3132,7 @@ var ObjectSetQuery = class extends BaseListQuery {
     }
     if (opts.subtract) {
       for (const os of opts.subtract) {
-        const wire = chunk3LMKH6RS_cjs.getWireObjectSet(os);
+        const wire = chunkDZE6IAUU_cjs.getWireObjectSet(os);
         if (wire.type) {
           types.add(wire.type);
         }
@@ -2872,7 +3213,7 @@ var ObjectSetHelper = class extends AbstractHelper {
     const {
       baseObjectSet
     } = options;
-    const baseObjectSetWire = JSON.stringify(chunk3LMKH6RS_cjs.getWireObjectSet(baseObjectSet));
+    const baseObjectSetWire = JSON.stringify(chunkDZE6IAUU_cjs.getWireObjectSet(baseObjectSet));
     const operations = this.buildCanonicalizedOperations(options);
     const objectSetCacheKey = this.cacheKeys.get("objectSet", baseObjectSetWire, operations);
     return this.store.queries.get(objectSetCacheKey, () => {
@@ -2888,13 +3229,13 @@ var ObjectSetHelper = class extends AbstractHelper {
       operations.withProperties = Object.keys(options.withProperties).sort();
     }
     if (options.union && options.union.length > 0) {
-      operations.union = options.union.map((os) => JSON.stringify(chunk3LMKH6RS_cjs.getWireObjectSet(os)));
+      operations.union = options.union.map((os) => JSON.stringify(chunkDZE6IAUU_cjs.getWireObjectSet(os)));
     }
     if (options.intersect && options.intersect.length > 0) {
-      operations.intersect = options.intersect.map((os) => JSON.stringify(chunk3LMKH6RS_cjs.getWireObjectSet(os)));
+      operations.intersect = options.intersect.map((os) => JSON.stringify(chunkDZE6IAUU_cjs.getWireObjectSet(os)));
     }
     if (options.subtract && options.subtract.length > 0) {
-      operations.subtract = options.subtract.map((os) => JSON.stringify(chunk3LMKH6RS_cjs.getWireObjectSet(os)));
+      operations.subtract = options.subtract.map((os) => JSON.stringify(chunkDZE6IAUU_cjs.getWireObjectSet(os)));
     }
     if (options.pivotTo) {
       operations.pivotTo = options.pivotTo;
@@ -2909,7 +3250,27 @@ var ObjectSetHelper = class extends AbstractHelper {
   }
 };
 
+// src/observable/internal/PivotCanonicalizer.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
+var PivotCanonicalizer = class {
+  #cache = /* @__PURE__ */ new Map();
+  canonicalize(sourceType, linkName) {
+    const key = `${sourceType}::${linkName}`;
+    let canonical = this.#cache.get(key);
+    if (!canonical) {
+      canonical = {
+        sourceType,
+        linkName,
+        targetType: "<targetType>"
+      };
+      this.#cache.set(key, canonical);
+    }
+    return canonical;
+  }
+};
+
 // src/observable/internal/Queries.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
 var Queries = class {
   // we can use a regular Map here because the refCounting will
   // handle cleanup.
@@ -2934,33 +3295,8 @@ var Queries = class {
   }
 };
 
-// src/observable/internal/Canonicalizer.ts
-var CachingCanonicalizer = class {
-  /**
-   * Cache for input object identity.
-   */
-  inputCache = /* @__PURE__ */ new WeakMap();
-  /**
-   * Look up or create a canonical form for the given input.
-   * This method handles the structural deduplication logic.
-   *
-   * @param input The input to canonicalize
-   * @returns The canonical form
-   */
-  canonicalize(input) {
-    if (!input) {
-      return void 0;
-    }
-    if (this.inputCache.has(input)) {
-      return this.inputCache.get(input);
-    }
-    const canonical = this.lookupOrCreate(input);
-    this.inputCache.set(input, canonical);
-    return canonical;
-  }
-};
-
 // src/observable/internal/RdpCanonicalizer.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
 var RdpCanonicalizer = class extends CachingCanonicalizer {
   structuralCache = /* @__PURE__ */ new Map();
   lookupOrCreate(rdp) {
@@ -2971,7 +3307,7 @@ var RdpCanonicalizer = class extends CachingCanonicalizer {
       apiName: "__rdp_canonicalizer_holder__"
     };
     for (const [key, rdpFunction] of Object.entries(rdp)) {
-      const builder = chunk3LMKH6RS_cjs.createWithPropertiesObjectSet(
+      const builder = chunkDZE6IAUU_cjs.createWithPropertiesObjectSet(
         objectTypeHolder,
         {
           type: "methodInput"
@@ -3010,6 +3346,8 @@ var Store = class {
   whereCanonicalizer = new WhereClauseCanonicalizer();
   orderByCanonicalizer = new OrderByCanonicalizer();
   rdpCanonicalizer = new RdpCanonicalizer();
+  intersectCanonicalizer = new IntersectCanonicalizer(this.whereCanonicalizer);
+  pivotCanonicalizer = new PivotCanonicalizer();
   /** @internal */
   queries = new Queries();
   objectCacheKeyRegistry = new ObjectCacheKeyRegistry();
@@ -3020,14 +3358,15 @@ var Store = class {
   subjects = this.layers.subjects;
   // these are hopefully temporary
   constructor(client) {
-    this.logger = client[chunk3LMKH6RS_cjs.additionalContext].logger?.child({}, {
+    this.logger = client[chunkDZE6IAUU_cjs.additionalContext].logger?.child({}, {
       msgPrefix: "Store"
     });
     this.client = client;
     this.cacheKeys = new CacheKeys({
       onDestroy: this.#cleanupCacheKey
     });
-    this.lists = new ListsHelper(this, this.cacheKeys, this.whereCanonicalizer, this.orderByCanonicalizer, this.rdpCanonicalizer);
+    this.aggregations = new AggregationsHelper(this, this.cacheKeys, this.whereCanonicalizer, this.rdpCanonicalizer);
+    this.lists = new ListsHelper(this, this.cacheKeys, this.whereCanonicalizer, this.orderByCanonicalizer, this.rdpCanonicalizer, this.intersectCanonicalizer, this.pivotCanonicalizer);
     this.objects = new ObjectsHelper(this, this.cacheKeys);
     this.links = new LinksHelper(this, this.cacheKeys, this.whereCanonicalizer, this.orderByCanonicalizer);
     this.objectSets = new ObjectSetHelper(this, this.cacheKeys, this.whereCanonicalizer, this.orderByCanonicalizer);
@@ -3182,13 +3521,15 @@ var Store = class {
    * Extracts RDP configuration from a cache key if present.
    *
    * @param cacheKey - The cache key to check
-   * @returns The RDP configuration, or undefined if not present
+   * @returns The RDP configuration, null, or undefined
    */
   #getQueryRdpConfig(cacheKey) {
     if ("otherKeys" in cacheKey && Array.isArray(cacheKey.otherKeys)) {
       if (cacheKey.type === "object") {
         return cacheKey.otherKeys[RDP_CONFIG_IDX];
       } else if (cacheKey.type === "list") {
+        return cacheKey.otherKeys[RDP_IDX2];
+      } else if (cacheKey.type === "aggregation") {
         return cacheKey.otherKeys[RDP_IDX];
       }
     }
@@ -3203,8 +3544,10 @@ var Store = class {
   #getQueryObjectType(cacheKey) {
     if ("otherKeys" in cacheKey && Array.isArray(cacheKey.otherKeys)) {
       if (cacheKey.type === "object") {
-        return cacheKey.otherKeys[API_NAME_IDX2];
+        return cacheKey.otherKeys[API_NAME_IDX3];
       } else if (cacheKey.type === "list") {
+        return cacheKey.otherKeys[API_NAME_IDX2];
+      } else if (cacheKey.type === "aggregation") {
         return cacheKey.otherKeys[API_NAME_IDX];
       }
     }
@@ -3281,10 +3624,10 @@ var Store = class {
 
 // src/observable/ObservableClient.ts
 function createObservableClient(client) {
-  const tweakedClient = chunk4ZOXOCQX_cjs.createClientFromContext({
-    ...client[chunk3LMKH6RS_cjs.additionalContext],
-    fetch: shared_net_fetch.createFetchHeaderMutator(client[chunk3LMKH6RS_cjs.additionalContext].fetch, (headers) => {
-      headers.set("Fetch-User-Agent", [headers.get("Fetch-User-Agent"), chunk4ZOXOCQX_cjs.OBSERVABLE_USER_AGENT].filter((x) => x && x?.length > 0).join(" "));
+  const tweakedClient = chunkS4JPAF56_cjs.createClientFromContext({
+    ...client[chunkDZE6IAUU_cjs.additionalContext],
+    fetch: shared_net_fetch.createFetchHeaderMutator(client[chunkDZE6IAUU_cjs.additionalContext].fetch, (headers) => {
+      headers.set("Fetch-User-Agent", [headers.get("Fetch-User-Agent"), chunkS4JPAF56_cjs.OBSERVABLE_USER_AGENT].filter((x) => x && x?.length > 0).join(" "));
       return headers;
     })
   });
@@ -3292,6 +3635,7 @@ function createObservableClient(client) {
 }
 
 // src/public-utils/osdkConfig.ts
+chunk6SCDLAU2_cjs.init_cjs_shims();
 function getMetaTagContent(name) {
   const element = document.querySelector(`meta[name="${name}"]`);
   const val = element ? element.getAttribute("content") : null;
@@ -3327,11 +3671,11 @@ function getOsdkConfig(ontologyRid) {
 
 Object.defineProperty(exports, "createClientWithTransaction", {
   enumerable: true,
-  get: function () { return chunk4ZOXOCQX_cjs.createClientWithTransaction; }
+  get: function () { return chunkS4JPAF56_cjs.createClientWithTransaction; }
 });
 Object.defineProperty(exports, "augment", {
   enumerable: true,
-  get: function () { return chunk3LMKH6RS_cjs.augment; }
+  get: function () { return chunkDZE6IAUU_cjs.augment; }
 });
 exports.computeObjectSetCacheKey = computeObjectSetCacheKey;
 exports.createObservableClient = createObservableClient;