feat: add @ember/inspector-support public API for Ember Inspector

Implements the public inspector API as outlined in emberjs/ember-inspector#2723.
This provides a stable, high-level interface for the Ember Inspector to access
Ember internals without depending on private APIs.

The API includes:
- debug: captureRenderTree, inspect, registerDeprecationHandler
- environment: getEnv, VERSION
- instrumentation: subscribe, unsubscribe
- objectInternals: cacheFor, guidFor, meta, get, set
- owner: getOwner, lookup, factoryFor, hasRegistration, getContainerInstances
- libraries: getRegistry
- typeChecking: isEmberObject, isComponent, isGlimmerComponent, isService, etc.
- naming: getClassName (resolves Ember class/mixin names)
- tracking: createPropertyTracker, hasPropertyChanged, getPropertyDependencies, etc.
- computed: isComputed, getComputedMetadata, isMandatorySetter, isCached
- renderTree: getDebugRenderTree
- runloop: getBackburner, join, debounce, cancel

Author: patricklx

packages/@ember/inspector-support/index.ts

@@ -0,0 +1,97 @@
+/**
+ * @ember/inspector-support
+ *
+ * Public API for the Ember Inspector to access Ember internals in a stable,
+ * version-independent way. This package is intended to be accessed by the
+ * Ember Inspector via `appLoader.loadCompatInspector()`.
+ *
+ * ## Usage
+ *
+ * ```javascript
+ * // In ember-inspector:
+ * const api = globalThis.emberInspectorApps[0].loadCompatInspector();
+ *
+ * // Use the API:
+ * const renderTree = api.debug.captureRenderTree();
+ * const guid = api.objectInternals.guidFor(someObject);
+ * const tracker = api.tracking.createPropertyTracker(obj, 'myProp');
+ * ```
+ *
+ * ## Design Goals
+ *
+ * - **Stability**: Public API contract prevents breaking changes
+ * - **Simplicity**: High-level APIs are easier to use and understand
+ * - **Encapsulation**: Implementation details hidden behind function boundaries
+ * - **Reduced Coupling**: Inspector doesn't need to import or reference Ember classes
+ *
+ * @module @ember/inspector-support
+ * @public
+ */
+
+export { debug } from './lib/debug';
+export { environment } from './lib/environment';
+export { instrumentation } from './lib/instrumentation';
+export { objectInternals } from './lib/object-internals';
+export { owner } from './lib/owner';
+export { libraries } from './lib/libraries';
+export { typeChecking } from './lib/type-checking';
+export { naming } from './lib/naming';
+export { tracking } from './lib/tracking';
+export { computed } from './lib/computed';
+export { renderTree } from './lib/render-tree';
+export { runloop } from './lib/runloop';
+
+export type {
+  EmberInspectorAPI,
+  RenderNode,
+  Bounds,
+  Library,
+  Owner,
+  PropertyTracker,
+  PropertyDependency,
+  ComputedMetadata,
+  DeprecationOptions,
+  DeprecationHandler,
+  InstrumentationCallbacks,
+  EmberEnvironment,
+  ContainerInstance,
+  GetContainerInstancesOptions,
+} from './types';
+
+import { debug } from './lib/debug';
+import { environment } from './lib/environment';
+import { instrumentation } from './lib/instrumentation';
+import { objectInternals } from './lib/object-internals';
+import { owner } from './lib/owner';
+import { libraries } from './lib/libraries';
+import { typeChecking } from './lib/type-checking';
+import { naming } from './lib/naming';
+import { tracking } from './lib/tracking';
+import { computed } from './lib/computed';
+import { renderTree } from './lib/render-tree';
+import { runloop } from './lib/runloop';
+import type { EmberInspectorAPI } from './types';
+
+/**
+ * The complete Ember Inspector API object.
+ *
+ * This is the object returned by `appLoader.loadCompatInspector()`.
+ * It provides a stable, high-level interface for the Ember Inspector
+ * to access Ember internals without depending on private APIs.
+ */
+export const emberInspectorAPI: EmberInspectorAPI = {
+  debug,
+  environment,
+  instrumentation,
+  objectInternals,
+  owner,
+  libraries,
+  typeChecking,
+  naming,
+  tracking,
+  computed,
+  renderTree,
+  runloop,
+};
+
+export default emberInspectorAPI;

packages/@ember/inspector-support/lib/computed.ts

@@ -0,0 +1,126 @@
+import { descriptorForProperty, isComputed } from '@ember/-internals/metal';
+import type { ComputedMetadata } from '../types';
+
+export const computed = {
+  /**
+   * Check if a property is a computed property.
+   */
+  isComputed(obj: object, key: string): boolean {
+    try {
+      return isComputed(obj, key);
+    } catch {
+      return false;
+    }
+  },
+
+  /**
+   * Get the computed property descriptor for a property.
+   * Returns null if the property is not computed.
+   */
+  getComputedPropertyDescriptor(obj: object, key: string): unknown | null {
+    try {
+      return descriptorForProperty(obj, key) ?? null;
+    } catch {
+      return null;
+    }
+  },
+
+  /**
+   * Get the dependent keys for a computed property.
+   * Returns an empty array if the property is not computed or has no dependent keys.
+   */
+  getDependentKeys(obj: object, key: string): string[] {
+    try {
+      const desc = descriptorForProperty(obj, key) as any;
+      return desc?._dependentKeys ?? [];
+    } catch {
+      return [];
+    }
+  },
+
+  /**
+   * Get computed property metadata without accessing private properties directly.
+   * Replaces direct access to desc._getter, desc._readOnly, desc._auto, etc.
+   *
+   * @param descriptor - The computed property descriptor
+   * @returns Public metadata object, or null if descriptor is invalid
+   */
+  getComputedMetadata(descriptor: unknown): ComputedMetadata | null {
+    if (!descriptor) {
+      return null;
+    }
+
+    const desc = descriptor as any;
+
+    const getter: Function | undefined = desc._getter ?? desc.get;
+    const setter: Function | undefined = desc.set;
+
+    return {
+      getter,
+      setter,
+      readOnly: desc._readOnly ?? false,
+      auto: desc._auto ?? false,
+      dependentKeys: desc._dependentKeys ?? [],
+      code: getter ? Function.prototype.toString.call(getter) : undefined,
+    };
+  },
+
+  /**
+   * Check if a descriptor is Ember's mandatory setter.
+   * Replaces checking for "You attempted to update" string in setter code.
+   *
+   * @param descriptor - The property descriptor
+   * @returns true if this is a mandatory setter
+   */
+  isMandatorySetter(descriptor: unknown): boolean {
+    if (!descriptor) return false;
+
+    const desc = descriptor as any;
+    if (typeof desc.set !== 'function') return false;
+
+    try {
+      return Function.prototype.toString.call(desc.set).includes('You attempted to update');
+    } catch {
+      return false;
+    }
+  },
+
+  /**
+   * Check if a property uses the @cached decorator from @glimmer/tracking.
+   * The @cached decorator memoizes getter results and invalidates when dependencies change.
+   *
+   * @param obj - The object
+   * @param key - The property name
+   * @returns true if the property uses @cached decorator
+   */
+  isCached(obj: object, key: string): boolean {
+    try {
+      // @cached replaces the getter with one that uses createCache/getValue from @glimmer/validator
+      // It is NOT a ComputedProperty descriptor - it's a native getter
+      if (this.isComputed(obj, key)) {
+        return false;
+      }
+
+      // Check the prototype chain for a native getter
+      let proto: object | null = Object.getPrototypeOf(obj);
+      while (proto !== null && proto !== Object.prototype) {
+        const nativeDesc = Object.getOwnPropertyDescriptor(proto, key);
+        if (nativeDesc?.get) {
+          // @cached wraps the getter with a WeakMap-based cache using @glimmer/validator's createCache
+          // We detect it by checking if the getter's source references the cache WeakMap pattern
+          // This is a best-effort heuristic
+          const src = Function.prototype.toString.call(nativeDesc.get);
+          if (src.includes('caches') && src.includes('getValue')) {
+            return true;
+          }
+          break;
+        }
+        proto = Object.getPrototypeOf(proto);
+      }
+
+      return false;
+    } catch {
+      return false;
+    }
+  },
+};

packages/@ember/inspector-support/lib/debug.ts

@@ -0,0 +1,29 @@
+import {
+  captureRenderTree as _captureRenderTree,
+  inspect,
+  registerDeprecationHandler,
+} from '@ember/debug';
+import type { Owner, DeprecationHandler } from '../types';
+
+export const debug = {
+  /**
+   * Captures the current component render tree for the component inspector.
+   */
+  captureRenderTree(app: Owner) {
+    return _captureRenderTree(app as any);
+  },
+
+  /**
+   * Convert any value to a human-readable string representation.
+   */
+  inspect(value: unknown): string {
+    return inspect(value);
+  },
+
+  /**
+   * Register a custom handler for deprecation warnings.
+   */
+  registerDeprecationHandler(handler: DeprecationHandler): void {
+    registerDeprecationHandler(handler as any);
+  },
+};

packages/@ember/inspector-support/lib/environment.ts

@@ -0,0 +1,17 @@
+import { ENV } from '@ember/-internals/environment';
+import VERSION from 'ember/version';
+import type { EmberEnvironment } from '../types';
+
+export const environment = {
+  /**
+   * Get Ember's environment configuration.
+   */
+  getEnv(): EmberEnvironment {
+    return ENV as EmberEnvironment;
+  },
+
+  /**
+   * The current Ember version string.
+   */
+  VERSION,
+};

packages/@ember/inspector-support/lib/instrumentation.ts

@@ -0,0 +1,34 @@
+import { subscribe, unsubscribe } from '@ember/instrumentation';
+import type { InstrumentationCallbacks } from '../types';
+
+export const instrumentation = {
+  /**
+   * Subscribe to an Ember instrumentation event.
+   *
+   * @param eventName - Namespaced event name (e.g. "render", "render.component")
+   * @param callbacks - Before and after hooks
+   * @returns A subscriber token that can be passed to unsubscribe
+   */
+  subscribe<T>(
+    eventName: string,
+    callbacks: InstrumentationCallbacks<T>
+  ): { pattern: string; regex: RegExp; object: InstrumentationCallbacks<T> } {
+    return subscribe(eventName, {
+      before: callbacks.before ?? (() => undefined as unknown as T),
+      after: callbacks.after ?? (() => {}),
+    }) as { pattern: string; regex: RegExp; object: InstrumentationCallbacks<T> };
+  },
+
+  /**
+   * Unsubscribe from an instrumentation event.
+   *
+   * @param subscriber - The subscriber token returned by subscribe
+   */
+  unsubscribe(subscriber: {
+    pattern: string;
+    regex: RegExp;
+    object: InstrumentationCallbacks;
+  }): void {
+    unsubscribe(subscriber as any);
+  },
+};

packages/@ember/inspector-support/lib/libraries.ts

@@ -0,0 +1,15 @@
+import { libraries as LIBRARIES } from '@ember/-internals/metal';
+import type { Library } from '../types';
+
+export const libraries = {
+  /**
+   * Get the registry of all loaded Ember libraries and addons.
+   * Used to display loaded libraries in the Info tab of the inspector.
+   */
+  getRegistry(): Library[] {
+    return LIBRARIES._registry.map((lib) => ({
+      name: lib.name,
+      version: lib.version,
+    }));
+  },
+};