@osdk/react-devtools 0.5.0

package/build/esm/utils/ObservableClientMonitor.js

@@ -0,0 +1,768 @@
+/*
+ * Copyright 2025 Palantir Technologies, Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { MetricsStore } from "../store/MetricsStore.js";
+import { ActionLifecycleTracker } from "./ActionLifecycleTracker.js";
+import { componentContextCapture } from "./ComponentContextCapture.js";
+import { SubscriptionTracker } from "./SubscriptionTracker.js";
+function getDebugMetadata(value) {
+  if (typeof value === "object" && value != null && "__debugMetadata" in value) {
+    return value.__debugMetadata;
+  }
+  return undefined;
+}
+function isMockActionEdits(value) {
+  return typeof value === "object" && value != null && "type" in value && value.type === "edits";
+}
+function hasExperimentalStore(client) {
+  return "__experimentalStore" in client && typeof client.__experimentalStore === "object" && client.__experimentalStore != null;
+}
+export class ObservableClientMonitor {
+  signatureLastRecorded = new Map();
+  subscriptionHasLoaded = new Map();
+  DEDUP_WINDOW_MS = 100;
+  cleanupIntervalId = null;
+  wrappedClient = null;
+  constructor(config) {
+    this.metricsStore = config.metricsStore ?? new MetricsStore();
+    this.subscriptionTracker = new SubscriptionTracker(config.cacheThresholdMs ?? 10);
+    this.actionTracker = new ActionLifecycleTracker(this.metricsStore, config.eventTimeline);
+    this.cleanupIntervalMs = config.cleanupIntervalMs ?? 60000;
+    this.cleanupIntervalId = setInterval(() => {
+      this.subscriptionTracker.cleanup();
+      this.pruneSignatureLastRecorded();
+    }, this.cleanupIntervalMs);
+    this.componentRegistry = config.componentRegistry;
+    this.linkTraversalTracker = config.linkTraversalTracker;
+    this.propertyAccessTracker = config.propertyAccessTracker;
+    this.eventTimeline = config.eventTimeline ?? null;
+    this.captureComponentContext = config.captureComponentContext ?? true;
+    this.captureQueryParams = config.captureQueryParams ?? true;
+    this.mockManager = config.mockManager ?? null;
+  }
+  wrapClient(client) {
+    this.wrappedClient = client;
+
+    // Suppress the client's internal BrowserLogger. It writes to console.*
+    // which our ConsoleLogStore intercepts, flooding the devtools console tab
+    // with hundreds of internal debug logs. The devtools monitoring proxy
+    // already captures all the same operations through its own instrumentation.
+    if (hasExperimentalStore(client)) {
+      client.__experimentalStore.logger = undefined;
+    }
+    const methodCache = new Map();
+    return new Proxy(client, {
+      get: (target, prop) => {
+        const cached = methodCache.get(prop);
+        if (cached !== undefined) {
+          return cached;
+        }
+        const ext = target;
+        let wrapped;
+        if (prop === "observeObject") {
+          wrapped = this.wrapObserveObject(target.observeObject.bind(target));
+        } else if (prop === "observeList") {
+          wrapped = this.wrapObserveList(target.observeList.bind(target));
+        } else if (prop === "observeAggregation") {
+          wrapped = this.wrapObserveAggregation(
+          // eslint-disable-next-line @typescript-eslint/no-deprecated
+          target.observeAggregation.bind(target));
+        } else if (prop === "observeLinks" && ext.observeLinks) {
+          wrapped = this.wrapObserveLinks(ext.observeLinks.bind(ext));
+        } else if (prop === "applyAction") {
+          wrapped = this.wrapApplyAction(target.applyAction.bind(target));
+        } else if (prop === "validateAction") {
+          wrapped = this.wrapValidateAction(target.validateAction.bind(target));
+        } else if (prop === "getCacheSnapshot") {
+          wrapped = ext.getCacheSnapshot?.bind(ext);
+        } else if (prop === "invalidateAll") {
+          wrapped = ext.invalidateAll?.bind(ext);
+        } else if (prop === "invalidateObjects") {
+          wrapped = ext.invalidateObjects?.bind(ext);
+        } else if (prop === "invalidateObjectType") {
+          wrapped = ext.invalidateObjectType?.bind(ext);
+        }
+        if (wrapped !== undefined) {
+          methodCache.set(prop, wrapped);
+          return wrapped;
+        }
+        const value = Reflect.get(target, prop);
+        if (typeof value === "function") {
+          const bound = value.bind(target);
+          methodCache.set(prop, bound);
+          return bound;
+        }
+        return value;
+      }
+    });
+  }
+  recordMockHitIfNeeded(value, signature) {
+    const metadata = getDebugMetadata(value);
+    if (metadata?.servedFromMock && this.eventTimeline) {
+      this.eventTimeline.record({
+        type: "MOCK_HIT",
+        subscriptionId: signature,
+        timestamp: Date.now(),
+        mockId: metadata.mockId
+      });
+    }
+  }
+  recordEmissionEvent(signature, objectKey) {
+    if (this.eventTimeline) {
+      this.eventTimeline.record({
+        type: "EMISSION",
+        subscriptionId: signature,
+        objectKey,
+        timestamp: Date.now(),
+        isOptimistic: false
+      });
+    }
+  }
+  classifyCacheEvent(signature, subscriptionId, servedFromCache) {
+    const lastRecorded = this.signatureLastRecorded.get(signature) ?? 0;
+    const now = Date.now();
+    if (now - lastRecorded <= this.DEDUP_WINDOW_MS) {
+      return "skip";
+    }
+    this.signatureLastRecorded.set(signature, now);
+    if (servedFromCache) {
+      return "hit";
+    }
+    if (this.subscriptionHasLoaded.has(subscriptionId)) {
+      return "revalidation";
+    }
+    return "miss";
+  }
+  processEmission(subscriptionId, signature, metadata, status, hasData, isOptimistic, objectCount, value, objectKey) {
+    const timestamp = Date.now();
+    const debugMetadata = getDebugMetadata(value);
+    this.subscriptionTracker.recordEmission(subscriptionId, status, hasData, isOptimistic, debugMetadata?.optimisticId, timestamp);
+    this.actionTracker.noteEmission({
+      subscriptionId,
+      optimisticId: debugMetadata?.optimisticId,
+      isOptimistic,
+      timestamp,
+      objectCount
+    });
+    if (isOptimistic) {
+      this.metricsStore.recordOptimisticUpdate(signature, metadata);
+    }
+    if (status === "loaded") {
+      const classification = this.classifyCacheEvent(signature, subscriptionId, debugMetadata?.servedFromCache ?? false);
+      if (classification !== "skip") {
+        const analysis = this.subscriptionTracker.analyzeEmissions(subscriptionId);
+        const responseTime = analysis?.loadTime ?? 0;
+        const effectiveClassification = analysis?.wasCached ? "hit" : classification;
+        if (effectiveClassification === "hit") {
+          this.metricsStore.recordCacheHit(signature, responseTime, metadata, objectCount);
+        } else if (effectiveClassification === "revalidation") {
+          this.metricsStore.recordRevalidation(signature, responseTime, metadata, objectCount);
+        } else {
+          this.metricsStore.recordCacheMiss(signature, responseTime, metadata, objectCount);
+        }
+        this.subscriptionHasLoaded.set(subscriptionId, true);
+      }
+    }
+    this.recordMockHitIfNeeded(value, signature);
+    this.recordEmissionEvent(signature, objectKey);
+  }
+  cleanupSubscription(subscriptionId) {
+    this.subscriptionTracker.endSubscription(subscriptionId);
+    this.actionTracker.clearSubscription(subscriptionId);
+    this.subscriptionHasLoaded.delete(subscriptionId);
+  }
+  createCleanupUnsubscribable(original, subscriptionId) {
+    return {
+      unsubscribe: () => {
+        try {
+          original.unsubscribe();
+        } finally {
+          this.cleanupSubscription(subscriptionId);
+        }
+      }
+    };
+  }
+  setupObservation(params) {
+    const componentContext = this.captureComponentContext ? componentContextCapture.captureNow() : null;
+    if (componentContext && this.captureQueryParams) {
+      this.componentRegistry.registerBinding({
+        componentId: componentContext.id,
+        componentName: componentContext.name,
+        componentDisplayName: componentContext.displayName,
+        hookType: params.hookType,
+        hookIndex: 0,
+        querySignature: params.signature,
+        queryParams: params.queryParams
+      });
+    }
+    const isDeduplicated = this.subscriptionTracker.isDeduplicatedSubscription(params.signature);
+    if (isDeduplicated) {
+      this.metricsStore.recordDeduplication(params.signature, params.metadata);
+    }
+    const subscriptionId = this.subscriptionTracker.startSubscription(params.signature);
+    return {
+      componentContext,
+      subscriptionId
+    };
+  }
+  createCleanupObserverCallbacks(subscriptionId, componentContext, observer) {
+    return {
+      error: err => {
+        try {
+          this.cleanupSubscription(subscriptionId);
+        } catch (_cleanupError) {}
+        if (componentContext) {
+          this.componentRegistry.unregisterComponent(componentContext.id);
+        }
+        observer.error(err);
+      },
+      complete: () => {
+        this.cleanupSubscription(subscriptionId);
+        if (componentContext) {
+          this.componentRegistry.unregisterComponent(componentContext.id);
+        }
+        observer.complete();
+      }
+    };
+  }
+  wrapObserveObject(original) {
+    return (apiName, primaryKey, options, observer) => {
+      const apiNameStr = typeof apiName === "string" ? apiName : apiName.apiName;
+      const signature = `object:${apiNameStr}:${String(primaryKey)}`;
+      const metadata = {
+        apiName: apiNameStr,
+        primaryKey: String(primaryKey)
+      };
+      const {
+        componentContext,
+        subscriptionId
+      } = this.setupObservation({
+        signature,
+        metadata,
+        hookType: "useOsdkObject",
+        queryParams: {
+          type: "object",
+          objectType: apiNameStr,
+          primaryKey: String(primaryKey)
+        }
+      });
+      const objectKey = `${apiNameStr}:${primaryKey}`;
+      const mockManager = this.mockManager;
+      const cleanupCallbacks = this.createCleanupObserverCallbacks(subscriptionId, componentContext, observer);
+      const wrappedObserver = {
+        next: value => {
+          if (mockManager) {
+            const mock = mockManager.findMock({
+              type: "object",
+              objectType: apiNameStr,
+              primaryKey: String(primaryKey)
+            });
+            if (mock) {
+              if (mock.response.type === "error") {
+                observer.next({
+                  ...value,
+                  status: "error",
+                  object: undefined,
+                  isOptimistic: false,
+                  error: new Error(mock.response.error)
+                });
+                return;
+              }
+              if (mock.response.type === "object") {
+                observer.next({
+                  ...value,
+                  status: "loaded",
+                  object: mock.response.object,
+                  isOptimistic: false
+                });
+                return;
+              }
+            }
+          }
+          this.processEmission(subscriptionId, signature, metadata, value.status, value.object !== undefined, value.isOptimistic, value.object !== undefined ? 1 : 0, value, objectKey);
+          if (value.object && componentContext) {
+            const wrapped = this.propertyAccessTracker.wrapObject(value.object, objectKey, componentContext.id);
+            value.object = wrapped;
+          }
+          observer.next(value);
+        },
+        ...cleanupCallbacks
+      };
+      const unsubscribable = original(apiName, primaryKey, options, wrappedObserver);
+      return this.createCleanupUnsubscribable(unsubscribable, subscriptionId);
+    };
+  }
+  wrapObserveList(original) {
+    return (options, observer) => {
+      const apiNameStr = typeof options.type === "string" ? options.type : options.type.apiName;
+      const canonicalWhere = this.wrappedClient ? this.wrappedClient.canonicalizeWhereClause(options.where ?? {}) : options.where ?? {};
+      const whereClause = JSON.stringify(canonicalWhere);
+      const signature = options.__devtoolsSignature ?? `useOsdkObjects:${apiNameStr}:${whereClause}:${JSON.stringify(options.orderBy)}`;
+      const metadata = {
+        objectType: apiNameStr,
+        whereClause,
+        pageSize: options.pageSize
+      };
+      const {
+        componentContext,
+        subscriptionId
+      } = this.setupObservation({
+        signature,
+        metadata,
+        hookType: "useOsdkObjects",
+        queryParams: {
+          type: "list",
+          objectType: apiNameStr,
+          where: options.where,
+          orderBy: options.orderBy,
+          pageSize: options.pageSize
+        }
+      });
+      const mockManager = this.mockManager;
+      const cleanupCallbacks = this.createCleanupObserverCallbacks(subscriptionId, componentContext, observer);
+      const wrappedObserver = {
+        next: value => {
+          if (mockManager) {
+            const mock = mockManager.findMock({
+              type: "list",
+              objectType: apiNameStr,
+              whereClause: options.where
+            });
+            if (mock) {
+              if (mock.response.type === "error") {
+                observer.next({
+                  ...value,
+                  status: "error",
+                  resolvedList: [],
+                  isOptimistic: false,
+                  error: new Error(mock.response.error)
+                });
+                return;
+              }
+              if (mock.response.type === "list") {
+                observer.next({
+                  ...value,
+                  status: "loaded",
+                  resolvedList: mock.response.list,
+                  isOptimistic: false
+                });
+                return;
+              }
+            }
+          }
+          this.processEmission(subscriptionId, signature, metadata, value.status, value.resolvedList !== undefined, value.isOptimistic, value.resolvedList ? value.resolvedList.length : 0, value);
+          if (value.resolvedList && componentContext) {
+            const wrappedList = value.resolvedList.map((obj, index) => {
+              const objectKey = `${apiNameStr}:${obj.$primaryKey || index}`;
+              return this.propertyAccessTracker.wrapObject(obj, objectKey, componentContext.id);
+            });
+            value.resolvedList = wrappedList;
+          }
+          observer.next(value);
+        },
+        ...cleanupCallbacks
+      };
+      const unsubscribable = original(options, wrappedObserver);
+      return this.createCleanupUnsubscribable(unsubscribable, subscriptionId);
+    };
+  }
+  wrapObserveAggregation(original) {
+    return (options, observer) => {
+      const apiNameStr = typeof options.type === "string" ? options.type : options.type.apiName;
+      const signature = `useOsdkAggregation:${apiNameStr}:${JSON.stringify(options.where)}:${JSON.stringify(options.aggregate)}`;
+      const metadata = {
+        objectType: apiNameStr,
+        whereClause: JSON.stringify(options.where ?? {})
+      };
+      const {
+        componentContext,
+        subscriptionId
+      } = this.setupObservation({
+        signature,
+        metadata,
+        hookType: "useOsdkAggregation",
+        queryParams: {
+          type: "aggregation",
+          objectType: apiNameStr,
+          where: options.where,
+          aggregate: options.aggregate
+        }
+      });
+      const mockManager = this.mockManager;
+      const cleanupCallbacks = this.createCleanupObserverCallbacks(subscriptionId, componentContext, observer);
+      const wrappedObserver = {
+        next: value => {
+          if (mockManager) {
+            const mock = mockManager.findMock({
+              type: "list",
+              objectType: apiNameStr,
+              whereClause: options.where
+            });
+            if (mock) {
+              if (mock.response.type === "error") {
+                observer.next({
+                  result: undefined,
+                  status: "error",
+                  lastUpdated: Date.now(),
+                  error: new Error(mock.response.error)
+                });
+                return;
+              }
+              if (mock.response.type === "list" || mock.response.type === "object") {
+                const mockData = mock.response.type === "list" ? mock.response.list : mock.response.object;
+                observer.next({
+                  result: mockData,
+                  status: "loaded",
+                  lastUpdated: Date.now()
+                });
+                return;
+              }
+            }
+          }
+          this.processEmission(subscriptionId, signature, metadata, value.status, value.result !== undefined, false, value.result !== undefined ? 1 : 0, value);
+          observer.next(value);
+        },
+        ...cleanupCallbacks
+      };
+      const result = original(options, wrappedObserver);
+      if (result instanceof Promise) {
+        return result.then(unsub => this.createCleanupUnsubscribable(unsub, subscriptionId));
+      }
+      return this.createCleanupUnsubscribable(result, subscriptionId);
+    };
+  }
+  wrapObserveLinks(original) {
+    return (sourceObject, linkName, options, observer) => {
+      const componentContext = this.captureComponentContext ? componentContextCapture.captureNow() : null;
+      const sourceObjectKey = `${sourceObject.$apiName}:${sourceObject.$primaryKey}`;
+      const signature = `links:${sourceObjectKey}:${linkName}`;
+      if (componentContext && this.captureQueryParams) {
+        this.componentRegistry.registerBinding({
+          componentId: componentContext.id,
+          componentName: componentContext.name,
+          componentDisplayName: componentContext.displayName,
+          hookType: "useLinks",
+          hookIndex: 0,
+          querySignature: signature,
+          queryParams: {
+            type: "links",
+            sourceObject: sourceObjectKey,
+            linkName
+          }
+        });
+      }
+      this.linkTraversalTracker.recordTraversal({
+        sourceObjectType: sourceObject.$apiName,
+        sourceObjectKey: String(sourceObject.$primaryKey),
+        linkName,
+        timestamp: Date.now(),
+        componentId: componentContext?.id,
+        subscriptionId: signature
+      });
+      return original(sourceObject, linkName, options, {
+        next: value => {
+          this.recordMockHitIfNeeded(value, signature);
+          this.recordEmissionEvent(signature);
+          if (value.resolvedList && componentContext) {
+            const linkedObjects = [];
+            const wrappedList = value.resolvedList.map(obj => {
+              const osdkObj = obj;
+              linkedObjects.push({
+                objectType: osdkObj.$apiName,
+                primaryKey: String(osdkObj.$primaryKey)
+              });
+              return this.propertyAccessTracker.wrapObject(obj, `${osdkObj.$apiName}:${osdkObj.$primaryKey}`, componentContext.id);
+            });
+            this.linkTraversalTracker.recordLinkedObjects({
+              subscriptionId: signature,
+              linkName,
+              objects: linkedObjects
+            });
+            value.resolvedList = wrappedList;
+          }
+          observer.next(value);
+        },
+        error: err => observer.error(err),
+        complete: () => observer.complete()
+      });
+    };
+  }
+  wrapApplyAction(original) {
+    return async (actionDef, args, options) => {
+      const actionName = typeof actionDef === "string" ? actionDef : actionDef.apiName;
+      const signature = `action:${actionName}`;
+      const metadata = {
+        actionName
+      };
+      if (this.mockManager) {
+        const mock = this.mockManager.findMock({
+          type: "action",
+          actionName
+        });
+        if (mock) {
+          if (mock.delay) {
+            await new Promise(resolve => setTimeout(resolve, mock.delay));
+          }
+          if (mock.response.type === "passthrough") {
+            let actualArgs = args;
+            if (mock.usePayload && mock.payload) {
+              try {
+                const payloadData = JSON.parse(mock.payload);
+                actualArgs = payloadData.parameters || args;
+              } catch {}
+            }
+            try {
+              const result = await original(actionDef, actualArgs, options);
+              return result;
+            } catch (error) {
+              this.captureActionError(actionName, error, actualArgs);
+              throw error;
+            }
+          } else if (mock.response.type === "error") {
+            throw new Error(mock.response.error);
+          } else if (mock.response.type === "action") {
+            const mockResult = mock.response.result;
+            this.injectMockedObjectsFromActionResult(mock.id, mockResult);
+            const store = this.wrappedClient && hasExperimentalStore(this.wrappedClient) ? this.wrappedClient.__experimentalStore : undefined;
+            if (store && isMockActionEdits(mockResult)) {
+              const promises = [];
+              const allObjects = [...(mockResult.addedObjects || []), ...(mockResult.modifiedObjects || []), ...(mockResult.deletedObjects || [])];
+              for (const obj of allObjects) {
+                if (store.invalidateObject) {
+                  promises.push(store.invalidateObject(obj.objectType, obj.primaryKey));
+                }
+              }
+              for (const objectType of mockResult.editedObjectTypes || []) {
+                if (store.invalidateObjectType) {
+                  promises.push(store.invalidateObjectType(objectType));
+                }
+              }
+              await Promise.allSettled(promises);
+            }
+            return mockResult;
+          }
+        }
+      }
+      const componentContext = componentContextCapture.captureNow();
+      const hasOptimisticUpdate = Boolean(options?.optimisticUpdate);
+      const actionId = this.actionTracker.startAction({
+        signature,
+        actionName,
+        metadata,
+        optimisticConfigured: hasOptimisticUpdate,
+        componentId: componentContext?.id
+      });
+      const existingListeners = options?.__debugListeners;
+      if (hasOptimisticUpdate) {
+        this.metricsStore.recordOptimisticUpdate(signature, metadata);
+      }
+      const instrumentedOptions = {
+        ...(options ?? {}),
+        __debugListeners: {
+          onLayerCreated: id => {
+            this.actionTracker.registerOptimisticLayer(actionId, id);
+            existingListeners?.onLayerCreated?.(id);
+          },
+          onLayerCleared: id => {
+            this.actionTracker.handleLayerCleared(id, Date.now());
+            existingListeners?.onLayerCleared?.(id);
+          },
+          onObjectModified: (objectType, primaryKey, operation) => {
+            if (this.eventTimeline) {
+              this.eventTimeline.record({
+                type: "OBJECT_MODIFIED",
+                actionId,
+                objectType,
+                primaryKey,
+                modifiedBy: "optimistic",
+                timestamp: Date.now()
+              });
+            }
+            existingListeners?.onObjectModified?.(objectType, primaryKey, operation);
+          },
+          onServerObjectsModified: objects => {
+            if (this.eventTimeline) {
+              const timestamp = Date.now();
+              for (const obj of objects) {
+                this.eventTimeline.record({
+                  type: "OBJECT_MODIFIED",
+                  actionId,
+                  objectType: obj.objectType,
+                  primaryKey: obj.primaryKey,
+                  modifiedBy: "server",
+                  timestamp
+                });
+              }
+            }
+            existingListeners?.onServerObjectsModified?.(objects);
+          }
+        }
+      };
+      try {
+        const result = await original(actionDef, args, instrumentedOptions);
+        this.actionTracker.markActionSettled({
+          actionId,
+          succeeded: true,
+          completedAt: Date.now()
+        });
+        return result;
+      } catch (error) {
+        this.actionTracker.markActionSettled({
+          actionId,
+          succeeded: false,
+          completedAt: Date.now()
+        });
+        this.captureActionError(actionName, error, args);
+        throw error;
+      }
+    };
+  }
+  wrapValidateAction(original) {
+    return async (actionDef, args) => {
+      const actionName = typeof actionDef === "string" ? actionDef : actionDef.apiName;
+      const start = Date.now();
+      try {
+        return await original(actionDef, args);
+      } finally {
+        const duration = Date.now() - start;
+        this.metricsStore.recordActionValidation(`validate:${actionName}`, duration, {
+          actionName
+        });
+      }
+    };
+  }
+  captureActionError(actionName, error, args) {
+    this.metricsStore.recordActionError({
+      id: `${Date.now()}-${Math.random().toString(36).slice(2)}`,
+      actionType: actionName,
+      timestamp: Date.now(),
+      message: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+      parameters: args,
+      validationErrors: error?.validationErrors
+    });
+  }
+  injectMockedObjectsFromActionResult(mockId, mockResult) {
+    if (!this.mockManager || !mockResult) {
+      return;
+    }
+    const objects = this.extractObjectsFromMockResult(mockResult);
+    for (const obj of objects) {
+      const objectType = obj.$objectType ?? obj.$apiName;
+      const primaryKey = obj.$primaryKey ?? obj.id;
+      if (typeof objectType === "string" && (typeof primaryKey === "string" || typeof primaryKey === "number")) {
+        this.mockManager.injectMockedObjectToCache(mockId, objectType, primaryKey, obj);
+      }
+    }
+  }
+  extractObjectsFromMockResult(mockResult) {
+    const objects = [];
+    if (!mockResult || typeof mockResult !== "object") {
+      return objects;
+    }
+    const result = mockResult;
+    if (result.$objectType || result.$apiName) {
+      objects.push(result);
+      return objects;
+    }
+    if (Array.isArray(mockResult)) {
+      for (const item of mockResult) {
+        if (item && typeof item === "object" && (item.$objectType || item.$apiName)) {
+          objects.push(item);
+        }
+      }
+      return objects;
+    }
+    if (Array.isArray(result.addedObjects)) {
+      for (const item of result.addedObjects) {
+        if (item && typeof item === "object") {
+          objects.push(item);
+        }
+      }
+    }
+    if (Array.isArray(result.modifiedObjects)) {
+      for (const item of result.modifiedObjects) {
+        if (item && typeof item === "object") {
+          objects.push(item);
+        }
+      }
+    }
+    return objects;
+  }
+  getCacheSnapshot() {
+    if (!this.wrappedClient) {
+      return Promise.reject(new Error("No wrapped client available"));
+    }
+    const ext = this.wrappedClient;
+    if (!ext.getCacheSnapshot) {
+      return Promise.reject(new Error("getCacheSnapshot not available on client"));
+    }
+    return ext.getCacheSnapshot();
+  }
+  invalidateObjects(objects) {
+    if (!this.wrappedClient) {
+      return Promise.reject(new Error("No wrapped client available"));
+    }
+    const ext = this.wrappedClient;
+    if (!ext.invalidateObjects) {
+      return Promise.reject(new Error("invalidateObjects not available on client"));
+    }
+    return ext.invalidateObjects(objects);
+  }
+  invalidateObjectType(objectType) {
+    if (!this.wrappedClient) {
+      return Promise.reject(new Error("No wrapped client available"));
+    }
+    const ext = this.wrappedClient;
+    if (!ext.invalidateObjectType) {
+      return Promise.reject(new Error("invalidateObjectType not available on client"));
+    }
+    return ext.invalidateObjectType(objectType);
+  }
+  invalidateAll() {
+    if (!this.wrappedClient) {
+      return Promise.reject(new Error("No wrapped client available"));
+    }
+    const ext = this.wrappedClient;
+    if (!ext.invalidateAll) {
+      return Promise.reject(new Error("invalidateAll not available on client"));
+    }
+    return ext.invalidateAll();
+  }
+  pruneSignatureLastRecorded() {
+    const now = Date.now();
+    for (const [key, timestamp] of this.signatureLastRecorded) {
+      if (now - timestamp > this.cleanupIntervalMs) {
+        this.signatureLastRecorded.delete(key);
+      }
+    }
+  }
+  dispose() {
+    try {
+      this.signatureLastRecorded.clear();
+      if ("dispose" in this.metricsStore && typeof this.metricsStore.dispose === "function") {
+        this.metricsStore.dispose();
+      }
+      this.actionTracker.dispose();
+    } finally {
+      if (this.cleanupIntervalId) {
+        clearInterval(this.cleanupIntervalId);
+        this.cleanupIntervalId = null;
+      }
+    }
+  }
+}
+//# sourceMappingURL=ObservableClientMonitor.js.map